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-2015 Free Software Foundation, Inc.
8 This file is part of GNU Bash, the Bourne Again SHell.
10 Bash is free software: you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation, either version 3 of the License, or
13 (at your option) any later version.
15 Bash is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with Bash. If not, see <http://www.gnu.org/licenses/>.
26 #include "bashtypes.h"
32 #if defined (HAVE_UNISTD_H)
36 #include "posixtime.h"
38 #if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE)
39 # include <sys/resource.h>
40 #endif /* !_POSIX_VERSION && HAVE_SYS_RESOURCE_H && HAVE_WAIT3 && !RLIMTYPE */
42 #if defined (HAVE_SYS_FILE_H)
43 # include <sys/file.h>
47 #include <sys/ioctl.h>
48 #if defined (HAVE_SYS_PARAM_H)
49 #include <sys/param.h>
52 #if defined (BUFFERED_INPUT)
56 /* Need to include this up here for *_TTY_DRIVER definitions. */
59 /* Define this if your output is getting swallowed. It's a no-op on
60 machines with the termio or termios tty drivers. */
61 /* #define DRAIN_OUTPUT */
63 /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
64 #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
66 #endif /* hpux && !TERMIOS_TTY_DRIVER */
72 #include "execute_cmd.h"
75 #include "builtins/builtext.h"
76 #include "builtins/common.h"
78 #if defined (READLINE)
79 # include <readline/readline.h>
86 #if !defined (HAVE_KILLPG)
87 extern int killpg
__P((pid_t
, int));
90 #if !DEFAULT_CHILD_MAX
91 # define DEFAULT_CHILD_MAX 32
95 # define MAX_CHILD_MAX 8192
99 #define MAX_JOBS_IN_ARRAY 4096 /* production */
101 #define MAX_JOBS_IN_ARRAY 128 /* testing */
105 #define PIDSTAT_TABLE_SZ 4096
106 #define BGPIDS_TABLE_SZ 512
108 /* Flag values for second argument to delete_job */
109 #define DEL_WARNSTOPPED 1 /* warn about deleting stopped jobs */
110 #define DEL_NOBGPID 2 /* don't add pgrp leader to bgpids */
112 /* Take care of system dependencies that must be handled when waiting for
113 children. The arguments to the WAITPID macro match those to the Posix.1
114 waitpid() function. */
116 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
117 # define WAITPID(pid, statusp, options) \
118 wait3 ((union wait *)statusp, options, (struct rusage *)0)
120 # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
121 # define WAITPID(pid, statusp, options) \
122 waitpid ((pid_t)pid, statusp, options)
124 # if defined (HAVE_WAIT3)
125 # define WAITPID(pid, statusp, options) \
126 wait3 (statusp, options, (struct rusage *)0)
128 # define WAITPID(pid, statusp, options) \
129 wait3 (statusp, options, (int *)0)
130 # endif /* HAVE_WAIT3 */
131 # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
132 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
134 /* getpgrp () varies between systems. Even systems that claim to be
135 Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
136 #if defined (GETPGRP_VOID)
137 # define getpgid(p) getpgrp ()
139 # define getpgid(p) getpgrp (p)
140 #endif /* !GETPGRP_VOID */
142 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
143 handler for SIGCHLD. */
144 #if defined (MUST_REINSTALL_SIGHANDLERS)
145 # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
147 # define REINSTALL_SIGCHLD_HANDLER
148 #endif /* !MUST_REINSTALL_SIGHANDLERS */
150 /* Some systems let waitpid(2) tell callers about stopped children. */
151 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
153 # define WCONTINUED 0
155 #if !defined (WIFCONTINUED)
156 # define WIFCONTINUED(s) (0)
159 /* The number of additional slots to allocate when we run out. */
162 typedef int sh_job_map_func_t
__P((JOB
*, int, int, int));
164 /* Variables used here but defined in other files. */
165 extern int subshell_environment
, line_number
;
166 extern int posixly_correct
, shell_level
;
167 extern int last_command_exit_value
, last_command_exit_signal
;
168 extern int loop_level
, breaking
;
169 extern int executing_list
;
170 extern int sourcelevel
;
171 extern int running_trap
;
172 extern sh_builtin_func_t
*this_shell_builtin
;
173 extern char *shell_name
, *this_command_name
;
174 extern sigset_t top_level_mask
;
175 extern procenv_t wait_intr_buf
;
176 extern int wait_intr_flag
;
177 extern int wait_signal_received
;
178 extern WORD_LIST
*subst_assign_varlist
;
180 extern SigHandler
**original_signals
;
182 extern void set_original_signal
__P((int, SigHandler
*));
184 static struct jobstats zerojs
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
185 struct jobstats js
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
187 ps_index_t pidstat_table
[PIDSTAT_TABLE_SZ
];
188 struct bgpids bgpids
= { 0, 0, 0 };
190 /* The array of known jobs. */
191 JOB
**jobs
= (JOB
**)NULL
;
194 /* The number of slots currently allocated to JOBS. */
198 /* The controlling tty for this shell. */
201 /* The shell's process group. */
202 pid_t shell_pgrp
= NO_PID
;
204 /* The terminal's process group. */
205 pid_t terminal_pgrp
= NO_PID
;
207 /* The process group of the shell's parent. */
208 pid_t original_pgrp
= NO_PID
;
210 /* The process group of the pipeline currently being made. */
211 pid_t pipeline_pgrp
= (pid_t
)0;
213 #if defined (PGRP_PIPE)
214 /* Pipes which each shell uses to communicate with the process group leader
215 until all of the processes in a pipeline have been started. Then the
216 process leader is allowed to continue. */
217 int pgrp_pipe
[2] = { -1, -1 };
221 /* The job which is current; i.e. the one that `%+' stands for. */
222 int current_job
= NO_JOB
;
224 /* The previous job; i.e. the one that `%-' stands for. */
225 int previous_job
= NO_JOB
;
228 /* Last child made by the shell. */
229 volatile pid_t last_made_pid
= NO_PID
;
231 /* Pid of the last asynchronous child. */
232 volatile pid_t last_asynchronous_pid
= NO_PID
;
234 /* The pipeline currently being built. */
235 PROCESS
*the_pipeline
= (PROCESS
*)NULL
;
237 /* If this is non-zero, do job control. */
240 /* Are we running in background? (terminal_pgrp != shell_pgrp) */
241 int running_in_background
= 0;
243 /* Call this when you start making children. */
244 int already_making_children
= 0;
246 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
247 exits from get_tty_state(). */
248 int check_window_size
= CHECKWINSIZE_DEFAULT
;
250 PROCESS
*last_procsub_child
= (PROCESS
*)NULL
;
252 /* Functions local to this file. */
254 static sighandler wait_sigint_handler
__P((int));
255 static sighandler sigchld_handler
__P((int));
256 static sighandler sigcont_sighandler
__P((int));
257 static sighandler sigstop_sighandler
__P((int));
259 static int waitchld
__P((pid_t
, int));
261 static PROCESS
*find_pipeline
__P((pid_t
, int, int *));
262 static PROCESS
*find_process
__P((pid_t
, int, int *));
264 static char *current_working_directory
__P((void));
265 static char *job_working_directory
__P((void));
266 static char *j_strsignal
__P((int));
267 static char *printable_job_status
__P((int, PROCESS
*, int));
269 static PROCESS
*find_last_proc
__P((int, int));
270 static pid_t find_last_pid
__P((int, int));
272 static int set_new_line_discipline
__P((int));
273 static int map_over_jobs
__P((sh_job_map_func_t
*, int, int));
274 static int job_last_stopped
__P((int));
275 static int job_last_running
__P((int));
276 static int most_recent_job_in_state
__P((int, JOB_STATE
));
277 static int find_job
__P((pid_t
, int, PROCESS
**));
278 static int print_job
__P((JOB
*, int, int, int));
279 static int process_exit_status
__P((WAIT
));
280 static int process_exit_signal
__P((WAIT
));
281 static int set_job_status_and_cleanup
__P((int));
283 static WAIT job_signal_status
__P((int));
284 static WAIT raw_job_exit_status
__P((int));
286 static void notify_of_job_status
__P((void));
287 static void reset_job_indices
__P((void));
288 static void cleanup_dead_jobs
__P((void));
289 static int processes_in_job
__P((int));
290 static void realloc_jobs_list
__P((void));
291 static int compact_jobs_list
__P((int));
292 static void add_process
__P((char *, pid_t
));
293 static void print_pipeline
__P((PROCESS
*, int, int, FILE *));
294 static void pretty_print_job
__P((int, int, FILE *));
295 static void set_current_job
__P((int));
296 static void reset_current
__P((void));
297 static void set_job_running
__P((int));
298 static void setjstatus
__P((int));
299 static int maybe_give_terminal_to
__P((pid_t
, pid_t
, int));
300 static void mark_all_jobs_as_dead
__P((void));
301 static void mark_dead_jobs_as_notified
__P((int));
302 static void restore_sigint_handler
__P((void));
303 #if defined (PGRP_PIPE)
304 static void pipe_read
__P((int *));
307 /* Hash table manipulation */
309 static ps_index_t
*pshash_getbucket
__P((pid_t
));
310 static void pshash_delindex
__P((ps_index_t
));
312 /* Saved background process status management */
313 static struct pidstat
*bgp_add
__P((pid_t
, int));
314 static int bgp_delete
__P((pid_t
));
315 static void bgp_clear
__P((void));
316 static int bgp_search
__P((pid_t
));
318 static ps_index_t bgp_getindex
__P((void));
319 static void bgp_resize
__P((void)); /* XXX */
321 #if defined (ARRAY_VARS)
322 static int *pstatuses
; /* list of pipeline statuses */
326 /* Used to synchronize between wait_for and other functions and the SIGCHLD
329 static int queue_sigchld
;
331 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
333 #define UNQUEUE_SIGCHLD(os) \
336 if (queue_sigchld == 0 && os != sigchld) \
340 static SigHandler
*old_tstp
, *old_ttou
, *old_ttin
;
341 static SigHandler
*old_cont
= (SigHandler
*)SIG_DFL
;
343 /* A place to temporarily save the current pipeline. */
344 static struct pipeline_saver
*saved_pipeline
;
345 static int saved_already_making_children
;
347 /* Set this to non-zero whenever you don't want the jobs list to change at
348 all: no jobs deleted and no status change notifications. This is used,
349 for example, when executing SIGCHLD traps, which may run arbitrary
351 static int jobs_list_frozen
;
353 static char retcode_name_buffer
[64];
355 #if !defined (_POSIX_VERSION)
357 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
358 library functions and system calls. */
359 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
360 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
368 /* ioctl will handle setting errno correctly. */
369 if (ioctl (fd
, TIOCGPGRP
, &pgrp
) < 0)
374 #endif /* !_POSIX_VERSION */
376 /* Initialize the global job stats structure and other bookkeeping variables */
383 /* Return the working directory for the current process. Unlike
384 job_working_directory, this does not call malloc (), nor do any
385 of the functions it calls. This is so that it can safely be called
386 from a signal handler. */
388 current_working_directory ()
391 static char d
[PATH_MAX
];
393 dir
= get_string_value ("PWD");
395 if (dir
== 0 && the_current_working_directory
&& no_symbolic_links
)
396 dir
= the_current_working_directory
;
400 dir
= getcwd (d
, sizeof(d
));
405 return (dir
== 0) ? "<unknown>" : dir
;
408 /* Return the working directory for the current process. */
410 job_working_directory ()
414 dir
= get_string_value ("PWD");
416 return (savestring (dir
));
418 dir
= get_working_directory ("job-working-directory");
422 return (savestring ("<unknown>"));
428 if (already_making_children
)
431 already_making_children
= 1;
436 stop_making_children ()
438 already_making_children
= 0;
442 cleanup_the_pipeline ()
447 BLOCK_CHILD (set
, oset
);
448 disposer
= the_pipeline
;
449 the_pipeline
= (PROCESS
*)NULL
;
450 UNBLOCK_CHILD (oset
);
453 discard_pipeline (disposer
);
457 discard_last_procsub_child ()
462 BLOCK_CHILD (set
, oset
);
463 disposer
= last_procsub_child
;
464 last_procsub_child
= (PROCESS
*)NULL
;
465 UNBLOCK_CHILD (oset
);
468 discard_pipeline (disposer
);
471 struct pipeline_saver
*
472 alloc_pipeline_saver ()
474 struct pipeline_saver
*ret
;
476 ret
= (struct pipeline_saver
*)xmalloc (sizeof (struct pipeline_saver
));
483 save_pipeline (clear
)
487 struct pipeline_saver
*saver
;
489 BLOCK_CHILD (set
, oset
);
490 saver
= alloc_pipeline_saver ();
491 saver
->pipeline
= the_pipeline
;
492 saver
->next
= saved_pipeline
;
493 saved_pipeline
= saver
;
495 the_pipeline
= (PROCESS
*)NULL
;
496 saved_already_making_children
= already_making_children
;
497 UNBLOCK_CHILD (oset
);
501 restore_pipeline (discard
)
504 PROCESS
*old_pipeline
;
506 struct pipeline_saver
*saver
;
508 BLOCK_CHILD (set
, oset
);
509 old_pipeline
= the_pipeline
;
510 the_pipeline
= saved_pipeline
->pipeline
;
511 saver
= saved_pipeline
;
512 saved_pipeline
= saved_pipeline
->next
;
514 already_making_children
= saved_already_making_children
;
515 UNBLOCK_CHILD (oset
);
517 if (discard
&& old_pipeline
)
519 discard_pipeline (old_pipeline
);
520 return ((PROCESS
*)NULL
);
525 /* Start building a pipeline. */
531 cleanup_the_pipeline ();
533 #if defined (PGRP_PIPE)
534 sh_closepipe (pgrp_pipe
);
538 #if defined (PGRP_PIPE)
541 if (pipe (pgrp_pipe
) == -1)
542 sys_error (_("start_pipeline: pgrp pipe"));
547 /* Stop building a pipeline. Install the process list in the job array.
548 This returns the index of the newly installed job.
549 DEFERRED is a command structure to be executed upon satisfactory
550 execution exit of this pipeline. */
552 stop_pipeline (async
, deferred
)
560 BLOCK_CHILD (set
, oset
);
562 #if defined (PGRP_PIPE)
563 /* The parent closes the process group synchronization pipe. */
564 sh_closepipe (pgrp_pipe
);
567 cleanup_dead_jobs ();
569 if (js
.j_jobslots
== 0)
571 js
.j_jobslots
= JOB_SLOTS
;
572 jobs
= (JOB
**)xmalloc (js
.j_jobslots
* sizeof (JOB
*));
574 /* Now blank out these new entries. */
575 for (i
= 0; i
< js
.j_jobslots
; i
++)
576 jobs
[i
] = (JOB
*)NULL
;
578 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
581 /* Scan from the last slot backward, looking for the next free one. */
582 /* XXX - revisit this interactive assumption */
583 /* XXX - this way for now */
586 for (i
= js
.j_jobslots
; i
; i
--)
593 /* This wraps around, but makes it inconvenient to extend the array */
594 for (i
= js
.j_lastj
+1; i
!= js
.j_lastj
; i
++)
596 if (i
>= js
.j_jobslots
)
604 /* This doesn't wrap around yet. */
605 for (i
= js
.j_lastj
? js
.j_lastj
+ 1 : js
.j_lastj
; i
< js
.j_jobslots
; i
++)
611 /* Do we need more room? */
613 /* First try compaction */
614 if ((interactive_shell
== 0 || subshell_environment
) && i
== js
.j_jobslots
&& js
.j_jobslots
>= MAX_JOBS_IN_ARRAY
)
615 i
= compact_jobs_list (0);
617 /* If we can't compact, reallocate */
618 if (i
== js
.j_jobslots
)
620 js
.j_jobslots
+= JOB_SLOTS
;
621 jobs
= (JOB
**)xrealloc (jobs
, (js
.j_jobslots
* sizeof (JOB
*)));
623 for (j
= i
; j
< js
.j_jobslots
; j
++)
624 jobs
[j
] = (JOB
*)NULL
;
627 /* Add the current pipeline to the job list. */
631 int any_running
, any_stopped
, n
;
633 newjob
= (JOB
*)xmalloc (sizeof (JOB
));
635 for (n
= 1, p
= the_pipeline
; p
->next
!= the_pipeline
; n
++, p
= p
->next
)
637 p
->next
= (PROCESS
*)NULL
;
638 newjob
->pipe
= REVERSE_LIST (the_pipeline
, PROCESS
*);
639 for (p
= newjob
->pipe
; p
->next
; p
= p
->next
)
641 p
->next
= newjob
->pipe
;
643 the_pipeline
= (PROCESS
*)NULL
;
644 newjob
->pgrp
= pipeline_pgrp
;
649 /* Flag to see if in another pgrp. */
651 newjob
->flags
|= J_JOBCONTROL
;
653 /* Set the state of this pipeline. */
655 any_running
= any_stopped
= 0;
658 any_running
|= PRUNNING (p
);
659 any_stopped
|= PSTOPPED (p
);
662 while (p
!= newjob
->pipe
);
664 newjob
->state
= any_running
? JRUNNING
: (any_stopped
? JSTOPPED
: JDEAD
);
665 newjob
->wd
= job_working_directory ();
666 newjob
->deferred
= deferred
;
668 newjob
->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
669 newjob
->cleanarg
= (PTR_T
) NULL
;
672 if (newjob
->state
== JDEAD
&& (newjob
->flags
& J_FOREGROUND
))
674 if (newjob
->state
== JDEAD
)
676 js
.c_reaped
+= n
; /* wouldn't have been done since this was not part of a job */
685 newjob
= (JOB
*)NULL
;
688 js
.j_lastmade
= newjob
;
694 newjob
->flags
&= ~J_FOREGROUND
;
695 newjob
->flags
|= J_ASYNC
;
696 js
.j_lastasync
= newjob
;
704 newjob
->flags
|= J_FOREGROUND
;
706 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
708 * The currently-accepted job control wisdom says to set the
709 * terminal's process group n+1 times in an n-step pipeline:
710 * once in the parent and once in each child. This is where
711 * the parent gives it away.
713 * Don't give the terminal away if this shell is an asynchronous
714 * subshell or if we're a (presumably non-interactive) shell running
718 if (job_control
&& newjob
->pgrp
&& (subshell_environment
&SUBSHELL_ASYNC
) == 0 && running_in_background
== 0)
719 maybe_give_terminal_to (shell_pgrp
, newjob
->pgrp
, 0);
723 stop_making_children ();
724 UNBLOCK_CHILD (oset
);
725 return (newjob
? i
: js
.j_current
);
728 /* Functions to manage the list of exited background pids whose status has
733 The current implementation is a hash table using a single (separate) arena
734 for storage that can be allocated and freed as a unit. The size of the hash
735 table is a multiple of PIDSTAT_TABLE_SZ (4096) and multiple PIDs that hash
736 to the same value are chained through the bucket_next and bucket_prev
737 pointers (basically coalesced hashing for collision resolution).
741 All pid/status storage is done using the circular buffer bgpids.storage.
742 This must contain at least js.c_childmax entries. The circular buffer is
743 used to supply the ordered list Posix requires ("the last CHILD_MAX
744 processes"). To avoid searching the entire storage table for a given PID,
745 the hash table (pidstat_table) holds pointers into the storage arena and
746 uses a doubly-linked list of cells (bucket_next/bucket_prev, also pointers
747 into the arena) to implement collision resolution. */
749 /* The number of elements in bgpids.storage always has to be > js.c_childmax for
750 the circular buffer to work right. */
757 if (bgpids
.nalloc
== 0)
759 /* invalidate hash table when bgpids table is reallocated */
760 for (psi
= 0; psi
< PIDSTAT_TABLE_SZ
; psi
++)
761 pidstat_table
[psi
] = NO_PIDSTAT
;
762 nsize
= BGPIDS_TABLE_SZ
; /* should be power of 2 */
766 nsize
= bgpids
.nalloc
;
768 while (nsize
< js
.c_childmax
)
771 if (bgpids
.nalloc
< js
.c_childmax
)
773 bgpids
.storage
= (struct pidstat
*)xrealloc (bgpids
.storage
, nsize
* sizeof (struct pidstat
));
775 for (psi
= bgpids
.nalloc
; psi
< nsize
; psi
++)
776 bgpids
.storage
[psi
].pid
= NO_PID
;
778 bgpids
.nalloc
= nsize
;
781 else if (bgpids
.head
>= bgpids
.nalloc
) /* wrap around */
790 if (bgpids
.nalloc
< js
.c_childmax
|| bgpids
.head
>= bgpids
.nalloc
)
793 pshash_delindex (bgpids
.head
); /* XXX - clear before reusing */
794 return bgpids
.head
++;
798 pshash_getbucket (pid
)
801 unsigned long hash
; /* XXX - u_bits32_t */
803 hash
= pid
* 0x9e370001UL
;
804 return (&pidstat_table
[hash
% PIDSTAT_TABLE_SZ
]);
807 static struct pidstat
*
808 bgp_add (pid
, status
)
812 ps_index_t
*bucket
, psi
;
815 bucket
= pshash_getbucket (pid
);
816 psi
= bgp_getindex ();
817 ps
= &bgpids
.storage
[psi
];
821 ps
->bucket_next
= *bucket
;
822 ps
->bucket_prev
= NO_PIDSTAT
;
827 if (bgpids
.npid
> js
.c_childmax
)
831 if (ps
->bucket_next
!= NO_PIDSTAT
)
832 bgpids
.storage
[ps
->bucket_next
].bucket_prev
= psi
;
834 *bucket
= psi
; /* set chain head in hash table */
840 pshash_delindex (psi
)
845 ps
= &bgpids
.storage
[psi
];
846 if (ps
->pid
== NO_PID
)
849 if (ps
->bucket_next
!= NO_PID
)
850 bgpids
.storage
[ps
->bucket_next
].bucket_prev
= ps
->bucket_prev
;
851 if (ps
->bucket_prev
!= NO_PID
)
852 bgpids
.storage
[ps
->bucket_prev
].bucket_next
= ps
->bucket_next
;
854 *(pshash_getbucket (ps
->pid
)) = ps
->bucket_next
;
863 if (bgpids
.storage
== 0 || bgpids
.nalloc
== 0 || bgpids
.npid
== 0)
866 /* Search chain using hash to find bucket in pidstat_table */
867 for (psi
= *(pshash_getbucket (pid
)); psi
!= NO_PIDSTAT
; psi
= bgpids
.storage
[psi
].bucket_next
)
868 if (bgpids
.storage
[psi
].pid
== pid
)
871 if (psi
== NO_PIDSTAT
)
872 return 0; /* not found */
875 itrace("bgp_delete: deleting %d", pid
);
878 pshash_delindex (psi
); /* hash table management */
884 /* Clear out the list of saved statuses */
888 if (bgpids
.storage
== 0 || bgpids
.nalloc
== 0)
891 free (bgpids
.storage
);
900 /* Search for PID in the list of saved background pids; return its status if
901 found. If not found, return -1. We hash to the right spot in pidstat_table
902 and follow the bucket chain to the end. */
909 if (bgpids
.storage
== 0 || bgpids
.nalloc
== 0 || bgpids
.npid
== 0)
912 /* Search chain using hash to find bucket in pidstat_table */
913 for (psi
= *(pshash_getbucket (pid
)); psi
!= NO_PIDSTAT
; psi
= bgpids
.storage
[psi
].bucket_next
)
914 if (bgpids
.storage
[psi
].pid
== pid
)
915 return (bgpids
.storage
[psi
].status
);
928 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
929 been deleted. The caller should check whether js.j_njobs is 0 before
930 calling this. This wraps around, but the rest of the code does not. At
931 this point, it should not matter. */
937 if (jobs
[js
.j_firstj
] == 0)
940 if (old
>= js
.j_jobslots
)
941 old
= js
.j_jobslots
- 1;
942 while (js
.j_firstj
!= old
)
944 if (js
.j_firstj
>= js
.j_jobslots
)
946 if (jobs
[js
.j_firstj
] || js
.j_firstj
== old
) /* needed if old == 0 */
950 if (js
.j_firstj
== old
)
951 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
953 if (jobs
[js
.j_lastj
] == 0)
958 while (js
.j_lastj
!= old
)
961 js
.j_lastj
= js
.j_jobslots
- 1;
962 if (jobs
[js
.j_lastj
] || js
.j_lastj
== old
) /* needed if old == js.j_jobslots */
966 if (js
.j_lastj
== old
)
967 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
971 /* Delete all DEAD jobs that the user had received notification about. */
978 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
983 /* XXX could use js.j_firstj and js.j_lastj here */
984 for (i
= 0; i
< js
.j_jobslots
; i
++)
987 if (i
< js
.j_firstj
&& jobs
[i
])
988 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
989 if (i
> js
.j_lastj
&& jobs
[i
])
990 itrace("cleanup_dead_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
993 if (jobs
[i
] && DEADJOB (i
) && IS_NOTIFIED (i
))
997 #if defined (PROCESS_SUBSTITUTION)
998 if (last_procsub_child
&& last_procsub_child
->running
== PS_DONE
)
1000 bgp_add (last_procsub_child
->pid
, process_exit_status (last_procsub_child
->status
)); /* XXX */
1001 discard_pipeline (last_procsub_child
);
1002 last_procsub_child
= (PROCESS
*)NULL
;
1006 #if defined (COPROCESS_SUPPORT)
1010 UNQUEUE_SIGCHLD(os
);
1014 processes_in_job (job
)
1018 register PROCESS
*p
;
1021 p
= jobs
[job
]->pipe
;
1027 while (p
!= jobs
[job
]->pipe
);
1033 delete_old_job (pid
)
1039 job
= find_job (pid
, 0, &p
);
1043 itrace ("delete_old_job: found pid %d in job %d with state %d", pid
, job
, jobs
[job
]->state
);
1045 if (JOBSTATE (job
) == JDEAD
)
1046 delete_job (job
, DEL_NOBGPID
);
1050 internal_warning (_("forked pid %d appears in running job %d"), pid
, job
+1);
1058 /* Reallocate and compress the jobs list. This returns with a jobs array
1059 whose size is a multiple of JOB_SLOTS and can hold the current number of
1060 jobs. Heuristics are used to minimize the number of new reallocs. */
1062 realloc_jobs_list ()
1065 int nsize
, i
, j
, ncur
, nprev
;
1068 ncur
= nprev
= NO_JOB
;
1069 nsize
= ((js
.j_njobs
+ JOB_SLOTS
- 1) / JOB_SLOTS
);
1071 i
= js
.j_njobs
% JOB_SLOTS
;
1072 if (i
== 0 || i
> (JOB_SLOTS
>> 1))
1075 BLOCK_CHILD (set
, oset
);
1076 nlist
= (js
.j_jobslots
== nsize
) ? jobs
: (JOB
**) xmalloc (nsize
* sizeof (JOB
*));
1078 js
.c_reaped
= js
.j_ndead
= 0;
1079 for (i
= j
= 0; i
< js
.j_jobslots
; i
++)
1082 if (i
== js
.j_current
)
1084 if (i
== js
.j_previous
)
1086 nlist
[j
++] = jobs
[i
];
1087 if (jobs
[i
]->state
== JDEAD
)
1090 js
.c_reaped
+= processes_in_job (i
);
1095 itrace ("realloc_jobs_list: resize jobs list from %d to %d", js
.j_jobslots
, nsize
);
1096 itrace ("realloc_jobs_list: j_lastj changed from %d to %d", js
.j_lastj
, (j
> 0) ? j
- 1 : 0);
1097 itrace ("realloc_jobs_list: j_njobs changed from %d to %d", js
.j_njobs
, j
);
1098 itrace ("realloc_jobs_list: js.j_ndead %d js.c_reaped %d", js
.j_ndead
, js
.c_reaped
);
1102 js
.j_lastj
= (j
> 0) ? j
- 1 : 0;
1104 js
.j_jobslots
= nsize
;
1106 /* Zero out remaining slots in new jobs list */
1107 for ( ; j
< nsize
; j
++)
1108 nlist
[j
] = (JOB
*)NULL
;
1117 js
.j_current
= ncur
;
1118 if (nprev
!= NO_JOB
)
1119 js
.j_previous
= nprev
;
1121 /* Need to reset these */
1122 if (js
.j_current
== NO_JOB
|| js
.j_previous
== NO_JOB
|| js
.j_current
> js
.j_lastj
|| js
.j_previous
> js
.j_lastj
)
1126 itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js
.j_current
, js
.j_previous
);
1129 UNBLOCK_CHILD (oset
);
1132 /* Compact the jobs list by removing dead jobs. Assume that we have filled
1133 the jobs array to some predefined maximum. Called when the shell is not
1134 the foreground process (subshell_environment != 0). Returns the first
1135 available slot in the compacted list. If that value is js.j_jobslots, then
1136 the list needs to be reallocated. The jobs array may be in new memory if
1137 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
1139 compact_jobs_list (flags
)
1142 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
1143 return js
.j_jobslots
;
1146 realloc_jobs_list ();
1149 itrace("compact_jobs_list: returning %d", (js
.j_lastj
|| jobs
[js
.j_lastj
]) ? js
.j_lastj
+ 1 : 0);
1152 return ((js
.j_lastj
|| jobs
[js
.j_lastj
]) ? js
.j_lastj
+ 1 : 0);
1155 /* Delete the job at INDEX from the job list. Must be called
1156 with SIGCHLD blocked. */
1158 delete_job (job_index
, dflags
)
1159 int job_index
, dflags
;
1165 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
1168 if ((dflags
& DEL_WARNSTOPPED
) && subshell_environment
== 0 && STOPPED (job_index
))
1169 internal_warning (_("deleting stopped job %d with process group %ld"), job_index
+1, (long)jobs
[job_index
]->pgrp
);
1170 temp
= jobs
[job_index
];
1174 if ((dflags
& DEL_NOBGPID
) == 0 && (temp
->flags
& (J_ASYNC
|J_FOREGROUND
)) == J_ASYNC
)
1176 proc
= find_last_proc (job_index
, 0);
1178 bgp_add (proc
->pid
, process_exit_status (proc
->status
));
1181 jobs
[job_index
] = (JOB
*)NULL
;
1182 if (temp
== js
.j_lastmade
)
1184 else if (temp
== js
.j_lastasync
)
1188 ndel
= discard_pipeline (temp
->pipe
);
1190 js
.c_injobs
-= ndel
;
1191 if (temp
->state
== JDEAD
)
1193 js
.c_reaped
-= ndel
;
1195 if (js
.c_reaped
< 0)
1198 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
);
1205 dispose_command (temp
->deferred
);
1210 if (js
.j_njobs
== 0)
1211 js
.j_firstj
= js
.j_lastj
= 0;
1212 else if (jobs
[js
.j_firstj
] == 0 || jobs
[js
.j_lastj
] == 0)
1213 reset_job_indices ();
1215 if (job_index
== js
.j_current
|| job_index
== js
.j_previous
)
1219 /* Must be called with SIGCHLD blocked. */
1221 nohup_job (job_index
)
1226 if (js
.j_jobslots
== 0)
1229 if (temp
= jobs
[job_index
])
1230 temp
->flags
|= J_NOHUP
;
1233 /* Get rid of the data structure associated with a process chain. */
1235 discard_pipeline (chain
)
1236 register PROCESS
*chain
;
1238 register PROCESS
*this, *next
;
1246 FREE (this->command
);
1251 while (this != chain
);
1256 /* Add this process to the chain being built in the_pipeline.
1257 NAME is the command string that will be exec'ed later.
1258 PID is the process id of the child. */
1260 add_process (name
, pid
)
1266 #if defined (RECYCLES_PIDS)
1268 p
= find_process (pid
, 0, &j
);
1273 internal_warning (_("add_process: process %5ld (%s) in the_pipeline"), (long)p
->pid
, p
->command
);
1276 internal_warning (_("add_process: pid %5ld (%s) marked as still alive"), (long)p
->pid
, p
->command
);
1277 p
->running
= PS_RECYCLED
; /* mark as recycled */
1281 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1282 t
->next
= the_pipeline
;
1284 WSTATUS (t
->status
) = 0;
1285 t
->running
= PS_RUNNING
;
1294 while (p
->next
!= t
->next
)
1300 /* Create a (dummy) PROCESS with NAME, PID, and STATUS, and make it the last
1301 process in jobs[JID]->pipe. Used by the lastpipe code. */
1303 append_process (name
, pid
, status
, jid
)
1311 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1312 t
->next
= (PROCESS
*)NULL
;
1314 /* set process exit status using offset discovered by configure */
1315 t
->status
= (status
& 0xff) << WEXITSTATUS_OFFSET
;
1316 t
->running
= PS_DONE
;
1319 js
.c_reaped
++; /* XXX */
1321 for (p
= jobs
[jid
]->pipe
; p
->next
!= jobs
[jid
]->pipe
; p
= p
->next
)
1324 t
->next
= jobs
[jid
]->pipe
;
1328 /* Take the last job and make it the first job. Must be called with
1331 rotate_the_pipeline ()
1335 if (the_pipeline
->next
== the_pipeline
)
1337 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1342 /* Reverse the order of the processes in the_pipeline. Must be called with
1345 reverse_the_pipeline ()
1349 if (the_pipeline
->next
== the_pipeline
)
1352 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1354 p
->next
= (PROCESS
*)NULL
;
1356 n
= REVERSE_LIST (the_pipeline
, PROCESS
*);
1359 for (p
= the_pipeline
; p
->next
; p
= p
->next
)
1361 p
->next
= the_pipeline
;
1365 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
1366 then it is time to stop mapping, and that is the return value
1367 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
1370 map_over_jobs (func
, arg1
, arg2
)
1371 sh_job_map_func_t
*func
;
1378 if (js
.j_jobslots
== 0)
1381 BLOCK_CHILD (set
, oset
);
1383 /* XXX could use js.j_firstj here */
1384 for (i
= result
= 0; i
< js
.j_jobslots
; i
++)
1387 if (i
< js
.j_firstj
&& jobs
[i
])
1388 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1389 if (i
> js
.j_lastj
&& jobs
[i
])
1390 itrace("map_over_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1394 result
= (*func
)(jobs
[i
], arg1
, arg2
, i
);
1400 UNBLOCK_CHILD (oset
);
1405 /* Cause all the jobs in the current pipeline to exit. */
1407 terminate_current_pipeline ()
1409 if (pipeline_pgrp
&& pipeline_pgrp
!= shell_pgrp
)
1411 killpg (pipeline_pgrp
, SIGTERM
);
1412 killpg (pipeline_pgrp
, SIGCONT
);
1416 /* Cause all stopped jobs to exit. */
1418 terminate_stopped_jobs ()
1422 /* XXX could use js.j_firstj here */
1423 for (i
= 0; i
< js
.j_jobslots
; i
++)
1425 if (jobs
[i
] && STOPPED (i
))
1427 killpg (jobs
[i
]->pgrp
, SIGTERM
);
1428 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1433 /* Cause all jobs, running or stopped, to receive a hangup signal. If
1434 a job is marked J_NOHUP, don't send the SIGHUP. */
1440 /* XXX could use js.j_firstj here */
1441 for (i
= 0; i
< js
.j_jobslots
; i
++)
1445 if (jobs
[i
]->flags
& J_NOHUP
)
1447 killpg (jobs
[i
]->pgrp
, SIGHUP
);
1449 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1455 kill_current_pipeline ()
1457 stop_making_children ();
1461 /* Return the pipeline that PID belongs to. Note that the pipeline
1462 doesn't have to belong to a job. Must be called with SIGCHLD blocked.
1463 If JOBP is non-null, return the index of the job containing PID. */
1465 find_pipeline (pid
, alive_only
, jobp
)
1468 int *jobp
; /* index into jobs list or NO_JOB */
1473 /* See if this process is in the pipeline that we are building. */
1481 /* Return it if we found it. Don't ever return a recycled pid. */
1482 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1487 while (p
!= the_pipeline
);
1489 /* Now look in the last process substitution pipeline, since that sets $! */
1490 if (last_procsub_child
)
1492 p
= last_procsub_child
;
1495 /* Return it if we found it. Don't ever return a recycled pid. */
1496 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1501 while (p
!= last_procsub_child
);
1504 job
= find_job (pid
, alive_only
, &p
);
1507 return (job
== NO_JOB
) ? (PROCESS
*)NULL
: jobs
[job
]->pipe
;
1510 /* Return the PROCESS * describing PID. If JOBP is non-null return the index
1511 into the jobs array of the job containing PID. Must be called with
1514 find_process (pid
, alive_only
, jobp
)
1517 int *jobp
; /* index into jobs list or NO_JOB */
1521 p
= find_pipeline (pid
, alive_only
, jobp
);
1522 while (p
&& p
->pid
!= pid
)
1527 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1528 belong to any job. Must be called with SIGCHLD blocked. */
1530 find_job (pid
, alive_only
, procp
)
1538 /* XXX could use js.j_firstj here, and should check js.j_lastj */
1539 for (i
= 0; i
< js
.j_jobslots
; i
++)
1542 if (i
< js
.j_firstj
&& jobs
[i
])
1543 itrace("find_job: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1544 if (i
> js
.j_lastj
&& jobs
[i
])
1545 itrace("find_job: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1553 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1562 while (p
!= jobs
[i
]->pipe
);
1569 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1570 required by find_job. */
1572 get_job_by_pid (pid
, block
)
1580 BLOCK_CHILD (set
, oset
);
1582 job
= find_job (pid
, 0, NULL
);
1585 UNBLOCK_CHILD (oset
);
1590 /* Print descriptive information about the job with leader pid PID. */
1598 BLOCK_CHILD (set
, oset
);
1600 job
= find_job (pid
, 0, NULL
);
1603 fprintf (stderr
, "[%d] %ld\n", job
+ 1, (long)pid
);
1605 programming_error (_("describe_pid: %ld: no such pid"), (long)pid
);
1607 UNBLOCK_CHILD (oset
);
1619 x
= retcode_name_buffer
;
1620 snprintf (x
, sizeof(retcode_name_buffer
), _("Signal %d"), s
);
1626 printable_job_status (j
, p
, format
)
1636 if (STOPPED (j
) && format
== 0)
1638 if (posixly_correct
== 0 || p
== 0 || (WIFSTOPPED (p
->status
) == 0))
1639 temp
= _("Stopped");
1642 temp
= retcode_name_buffer
;
1643 snprintf (temp
, sizeof(retcode_name_buffer
), _("Stopped(%s)"), signal_name (WSTOPSIG (p
->status
)));
1646 else if (RUNNING (j
))
1647 temp
= _("Running");
1650 if (WIFSTOPPED (p
->status
))
1651 temp
= j_strsignal (WSTOPSIG (p
->status
));
1652 else if (WIFSIGNALED (p
->status
))
1653 temp
= j_strsignal (WTERMSIG (p
->status
));
1654 else if (WIFEXITED (p
->status
))
1656 temp
= retcode_name_buffer
;
1657 es
= WEXITSTATUS (p
->status
);
1660 strncpy (temp
, _("Done"), sizeof (retcode_name_buffer
) - 1);
1661 temp
[sizeof (retcode_name_buffer
) - 1] = '\0';
1663 else if (posixly_correct
)
1664 snprintf (temp
, sizeof(retcode_name_buffer
), _("Done(%d)"), es
);
1666 snprintf (temp
, sizeof(retcode_name_buffer
), _("Exit %d"), es
);
1669 temp
= _("Unknown status");
1675 /* This is the way to print out information on a job if you
1676 know the index. FORMAT is:
1678 JLIST_NORMAL) [1]+ Running emacs
1679 JLIST_LONG ) [1]+ 2378 Running emacs
1680 -1 ) [1]+ 2378 emacs
1682 JLIST_NORMAL) [1]+ Stopped ls | more
1683 JLIST_LONG ) [1]+ 2369 Stopped ls
1686 Just list the pid of the process group leader (really
1689 Use format JLIST_NORMAL, but list only jobs about which
1690 the user has not been notified. */
1692 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1693 the JOBS array corresponding to this pipeline. FORMAT is as described
1694 above. Must be called with SIGCHLD blocked.
1696 If you're printing a pipeline that's not in the jobs array, like the
1697 current pipeline as it's being created, pass -1 for JOB_INDEX */
1699 print_pipeline (p
, job_index
, format
, stream
)
1701 int job_index
, format
;
1704 PROCESS
*first
, *last
, *show
;
1705 int es
, name_padding
;
1712 while (last
->next
!= first
)
1718 fprintf (stream
, format
? " " : " |");
1720 if (format
!= JLIST_STANDARD
)
1721 fprintf (stream
, "%5ld", (long)p
->pid
);
1723 fprintf (stream
, " ");
1725 if (format
> -1 && job_index
>= 0)
1727 show
= format
? p
: last
;
1728 temp
= printable_job_status (job_index
, show
, format
);
1734 if (show
->running
== first
->running
&&
1735 WSTATUS (show
->status
) == WSTATUS (first
->status
))
1739 temp
= (char *)NULL
;
1744 fprintf (stream
, "%s", temp
);
1748 es
= 2; /* strlen ("| ") */
1749 name_padding
= LONGEST_SIGNAL_DESC
- es
;
1751 fprintf (stream
, "%*s", name_padding
, "");
1753 if ((WIFSTOPPED (show
->status
) == 0) &&
1754 (WIFCONTINUED (show
->status
) == 0) &&
1755 WIFCORED (show
->status
))
1756 fprintf (stream
, _("(core dumped) "));
1760 if (p
!= first
&& format
)
1761 fprintf (stream
, "| ");
1764 fprintf (stream
, "%s", p
->command
);
1766 if (p
== last
&& job_index
>= 0)
1768 temp
= current_working_directory ();
1770 if (RUNNING (job_index
) && (IS_FOREGROUND (job_index
) == 0))
1771 fprintf (stream
, " &");
1773 if (strcmp (temp
, jobs
[job_index
]->wd
) != 0)
1775 _(" (wd: %s)"), polite_directory_format (jobs
[job_index
]->wd
));
1778 if (format
|| (p
== last
))
1780 /* We need to add a CR only if this is an interactive shell, and
1781 we're reporting the status of a completed job asynchronously.
1782 We can't really check whether this particular job is being
1783 reported asynchronously, so just add the CR if the shell is
1784 currently interactive and asynchronous notification is enabled. */
1785 if (asynchronous_notification
&& interactive
)
1786 fprintf (stream
, "\r\n");
1788 fprintf (stream
, "\n");
1798 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1799 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1801 pretty_print_job (job_index
, format
, stream
)
1802 int job_index
, format
;
1805 register PROCESS
*p
;
1807 /* Format only pid information about the process group leader? */
1808 if (format
== JLIST_PID_ONLY
)
1810 fprintf (stream
, "%ld\n", (long)jobs
[job_index
]->pipe
->pid
);
1814 if (format
== JLIST_CHANGED_ONLY
)
1816 if (IS_NOTIFIED (job_index
))
1818 format
= JLIST_STANDARD
;
1821 if (format
!= JLIST_NONINTERACTIVE
)
1822 fprintf (stream
, "[%d]%c ", job_index
+ 1,
1823 (job_index
== js
.j_current
) ? '+':
1824 (job_index
== js
.j_previous
) ? '-' : ' ');
1826 if (format
== JLIST_NONINTERACTIVE
)
1827 format
= JLIST_LONG
;
1829 p
= jobs
[job_index
]->pipe
;
1831 print_pipeline (p
, job_index
, format
, stream
);
1833 /* We have printed information about this job. When the job's
1834 status changes, waitchld () sets the notification flag to 0. */
1835 jobs
[job_index
]->flags
|= J_NOTIFIED
;
1839 print_job (job
, format
, state
, job_index
)
1841 int format
, state
, job_index
;
1843 if (state
== -1 || (JOB_STATE
)state
== job
->state
)
1844 pretty_print_job (job_index
, format
, stdout
);
1849 list_one_job (job
, format
, ignore
, job_index
)
1851 int format
, ignore
, job_index
;
1853 pretty_print_job (job_index
, format
, stdout
);
1857 list_stopped_jobs (format
)
1860 cleanup_dead_jobs ();
1861 map_over_jobs (print_job
, format
, (int)JSTOPPED
);
1865 list_running_jobs (format
)
1868 cleanup_dead_jobs ();
1869 map_over_jobs (print_job
, format
, (int)JRUNNING
);
1872 /* List jobs. If FORMAT is non-zero, then the long form of the information
1873 is printed, else just a short version. */
1875 list_all_jobs (format
)
1878 cleanup_dead_jobs ();
1879 map_over_jobs (print_job
, format
, -1);
1882 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1883 COMMAND is just for remembering the name of the command; we don't do
1884 anything else with it. ASYNC_P says what to do with the tty. If
1885 non-zero, then don't give it away. */
1887 make_child (command
, async_p
)
1895 /* XXX - block SIGTERM here and unblock in child after fork resets the
1896 set of pending signals? */
1898 sigaddset (&set
, SIGCHLD
);
1899 sigaddset (&set
, SIGINT
);
1900 sigemptyset (&oset
);
1901 sigprocmask (SIG_BLOCK
, &set
, &oset
);
1907 #if defined (BUFFERED_INPUT)
1908 /* If default_buffered_input is active, we are reading a script. If
1909 the command is asynchronous, we have already duplicated /dev/null
1910 as fd 0, but have not changed the buffered stream corresponding to
1911 the old fd 0. We don't want to sync the stream in this case. */
1912 if (default_buffered_input
!= -1 &&
1913 (!async_p
|| default_buffered_input
> 0))
1914 sync_buffered_stream (default_buffered_input
);
1915 #endif /* BUFFERED_INPUT */
1919 /* Create the child, handle severe errors. Retry on EAGAIN. */
1920 while ((pid
= fork ()) < 0 && errno
== EAGAIN
&& forksleep
< FORKSLEEP_MAX
)
1923 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
1924 /* If we can't create any children, try to reap some dead ones. */
1927 errno
= EAGAIN
; /* restore errno */
1928 sys_error ("fork: retry");
1931 if (sleep (forksleep
) != 0)
1935 if (interrupt_state
)
1937 sigprocmask (SIG_SETMASK
, &set
, (sigset_t
*)NULL
);
1947 /* Kill all of the processes in the current pipeline. */
1948 terminate_current_pipeline ();
1950 /* Discard the current pipeline, if any. */
1952 kill_current_pipeline ();
1954 last_command_exit_value
= EX_NOEXEC
;
1955 throw_to_top_level (); /* Reset signals, etc. */
1960 /* In the child. Give this child the right process group, set the
1961 signals to the default state for a new process. */
1965 #if defined (BUFFERED_INPUT)
1966 /* Close default_buffered_input if it's > 0. We don't close it if it's
1967 0 because that's the file descriptor used when redirecting input,
1968 and it's wrong to close the file in that case. */
1969 unset_bash_input (0);
1970 #endif /* BUFFERED_INPUT */
1972 CLRINTERRUPT
; /* XXX - children have their own interrupt state */
1974 /* Restore top-level signal mask. */
1975 sigprocmask (SIG_SETMASK
, &top_level_mask
, (sigset_t
*)NULL
);
1979 /* All processes in this pipeline belong in the same
1982 if (pipeline_pgrp
== 0) /* This is the first child. */
1983 pipeline_pgrp
= mypid
;
1985 /* Check for running command in backquotes. */
1986 if (pipeline_pgrp
== shell_pgrp
)
1987 ignore_tty_job_signals ();
1989 default_tty_job_signals ();
1991 /* Set the process group before trying to mess with the terminal's
1992 process group. This is mandated by POSIX. */
1993 /* This is in accordance with the Posix 1003.1 standard,
1994 section B.7.2.4, which says that trying to set the terminal
1995 process group with tcsetpgrp() to an unused pgrp value (like
1996 this would have for the first child) is an error. Section
1997 B.4.3.3, p. 237 also covers this, in the context of job control
1999 if (setpgid (mypid
, pipeline_pgrp
) < 0)
2000 sys_error (_("child setpgid (%ld to %ld)"), (long)mypid
, (long)pipeline_pgrp
);
2002 /* By convention (and assumption above), if
2003 pipeline_pgrp == shell_pgrp, we are making a child for
2004 command substitution.
2005 In this case, we don't want to give the terminal to the
2006 shell's process group (we could be in the middle of a
2007 pipeline, for example). */
2008 if (async_p
== 0 && pipeline_pgrp
!= shell_pgrp
&& ((subshell_environment
&(SUBSHELL_ASYNC
|SUBSHELL_PIPE
)) == 0) && running_in_background
== 0)
2009 give_terminal_to (pipeline_pgrp
, 0);
2011 #if defined (PGRP_PIPE)
2012 if (pipeline_pgrp
== mypid
)
2013 pipe_read (pgrp_pipe
);
2016 else /* Without job control... */
2018 if (pipeline_pgrp
== 0)
2019 pipeline_pgrp
= shell_pgrp
;
2021 /* If these signals are set to SIG_DFL, we encounter the curious
2022 situation of an interactive ^Z to a running process *working*
2023 and stopping the process, but being unable to do anything with
2024 that process to change its state. On the other hand, if they
2025 are set to SIG_IGN, jobs started from scripts do not stop when
2026 the shell running the script gets a SIGTSTP and stops. */
2028 default_tty_job_signals ();
2031 #if defined (PGRP_PIPE)
2032 /* Release the process group pipe, since our call to setpgid ()
2033 is done. The last call to sh_closepipe is done in stop_pipeline. */
2034 sh_closepipe (pgrp_pipe
);
2035 #endif /* PGRP_PIPE */
2038 /* Don't set last_asynchronous_pid in the child */
2040 last_asynchronous_pid
= mypid
; /* XXX */
2043 #if defined (RECYCLES_PIDS)
2044 if (last_asynchronous_pid
== mypid
)
2045 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
2046 last_asynchronous_pid
= 1;
2051 /* In the parent. Remember the pid of the child just created
2052 as the proper pgrp if this is the first child. */
2056 if (pipeline_pgrp
== 0)
2058 pipeline_pgrp
= pid
;
2059 /* Don't twiddle terminal pgrps in the parent! This is the bug,
2060 not the good thing of twiddling them in the child! */
2061 /* give_terminal_to (pipeline_pgrp, 0); */
2063 /* This is done on the recommendation of the Rationale section of
2064 the POSIX 1003.1 standard, where it discusses job control and
2065 shells. It is done to avoid possible race conditions. (Ref.
2066 1003.1 Rationale, section B.4.3.3, page 236). */
2067 setpgid (pid
, pipeline_pgrp
);
2071 if (pipeline_pgrp
== 0)
2072 pipeline_pgrp
= shell_pgrp
;
2075 /* Place all processes into the jobs array regardless of the
2076 state of job_control. */
2077 add_process (command
, pid
);
2080 last_asynchronous_pid
= pid
;
2081 #if defined (RECYCLES_PIDS)
2082 else if (last_asynchronous_pid
== pid
)
2083 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
2084 last_asynchronous_pid
= 1;
2087 /* Delete the saved status for any job containing this PID in case it's
2089 delete_old_job (pid
);
2091 /* Perform the check for pid reuse unconditionally. Some systems reuse
2092 PIDs before giving a process CHILD_MAX/_SC_CHILD_MAX unique ones. */
2093 bgp_delete (pid
); /* new process, discard any saved status */
2095 last_made_pid
= pid
;
2101 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
2102 SIGCHLD remains blocked until all commands in the pipeline have been
2104 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
2110 /* These two functions are called only in child processes. */
2112 ignore_tty_job_signals ()
2114 set_signal_handler (SIGTSTP
, SIG_IGN
);
2115 set_signal_handler (SIGTTIN
, SIG_IGN
);
2116 set_signal_handler (SIGTTOU
, SIG_IGN
);
2119 /* Reset the tty-generated job control signals to SIG_DFL unless that signal
2120 was ignored at entry to the shell, in which case we need to set it to
2121 SIG_IGN in the child. We can't rely on resetting traps, since the hard
2122 ignored signals can't be trapped. */
2124 default_tty_job_signals ()
2126 if (signal_is_trapped (SIGTSTP
) == 0 && signal_is_hard_ignored (SIGTSTP
))
2127 set_signal_handler (SIGTSTP
, SIG_IGN
);
2129 set_signal_handler (SIGTSTP
, SIG_DFL
);
2131 if (signal_is_trapped (SIGTTIN
) == 0 && signal_is_hard_ignored (SIGTTIN
))
2132 set_signal_handler (SIGTTIN
, SIG_IGN
);
2134 set_signal_handler (SIGTTIN
, SIG_DFL
);
2136 if (signal_is_trapped (SIGTTOU
) == 0 && signal_is_hard_ignored (SIGTTOU
))
2137 set_signal_handler (SIGTTOU
, SIG_IGN
);
2139 set_signal_handler (SIGTTOU
, SIG_DFL
);
2142 /* Called once in a parent process. */
2144 get_original_tty_job_signals ()
2146 static int fetched
= 0;
2150 if (interactive_shell
)
2152 set_original_signal (SIGTSTP
, SIG_DFL
);
2153 set_original_signal (SIGTTIN
, SIG_DFL
);
2154 set_original_signal (SIGTTOU
, SIG_DFL
);
2158 get_original_signal (SIGTSTP
);
2159 get_original_signal (SIGTTIN
);
2160 get_original_signal (SIGTTOU
);
2166 /* When we end a job abnormally, or if we stop a job, we set the tty to the
2167 state kept in here. When a job ends normally, we set the state in here
2168 to the state of the tty. */
2170 static TTYSTRUCT shell_tty_info
;
2172 #if defined (NEW_TTY_DRIVER)
2173 static struct tchars shell_tchars
;
2174 static struct ltchars shell_ltchars
;
2175 #endif /* NEW_TTY_DRIVER */
2177 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
2178 /* Since the BSD tty driver does not allow us to change the tty modes
2179 while simultaneously waiting for output to drain and preserving
2180 typeahead, we have to drain the output ourselves before calling
2181 ioctl. We cheat by finding the length of the output queue, and
2182 using select to wait for an appropriate length of time. This is
2183 a hack, and should be labeled as such (it's a hastily-adapted
2184 mutation of a `usleep' implementation). It's only reason for
2185 existing is the flaw in the BSD tty driver. */
2187 static int ttspeeds
[] =
2189 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
2190 1800, 2400, 4800, 9600, 19200, 38400
2197 register int delay
= ttspeeds
[ospeed
];
2203 while ((ioctl (fd
, TIOCOUTQ
, &n
) == 0) && n
)
2205 if (n
> (delay
/ 100))
2209 n
*= 10; /* 2 bits more for conservativeness. */
2210 tv
.tv_sec
= n
/ delay
;
2211 tv
.tv_usec
= ((n
% delay
) * 1000000) / delay
;
2212 select (fd
, (fd_set
*)0, (fd_set
*)0, (fd_set
*)0, &tv
);
2218 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
2220 /* Return the fd from which we are actually getting input. */
2221 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
2223 /* Fill the contents of shell_tty_info with the current tty info. */
2232 #if defined (NEW_TTY_DRIVER)
2233 ioctl (tty
, TIOCGETP
, &shell_tty_info
);
2234 ioctl (tty
, TIOCGETC
, &shell_tchars
);
2235 ioctl (tty
, TIOCGLTC
, &shell_ltchars
);
2236 #endif /* NEW_TTY_DRIVER */
2238 #if defined (TERMIO_TTY_DRIVER)
2239 ioctl (tty
, TCGETA
, &shell_tty_info
);
2240 #endif /* TERMIO_TTY_DRIVER */
2242 #if defined (TERMIOS_TTY_DRIVER)
2243 if (tcgetattr (tty
, &shell_tty_info
) < 0)
2246 /* Only print an error message if we're really interactive at
2249 sys_error ("[%ld: %d (%d)] tcgetattr", (long)getpid (), shell_level
, tty
);
2253 #endif /* TERMIOS_TTY_DRIVER */
2254 if (check_window_size
)
2255 get_new_window_size (0, (int *)0, (int *)0);
2260 /* Make the current tty use the state in shell_tty_info. */
2269 #if defined (NEW_TTY_DRIVER)
2270 # if defined (DRAIN_OUTPUT)
2271 draino (tty
, shell_tty_info
.sg_ospeed
);
2272 # endif /* DRAIN_OUTPUT */
2273 ioctl (tty
, TIOCSETN
, &shell_tty_info
);
2274 ioctl (tty
, TIOCSETC
, &shell_tchars
);
2275 ioctl (tty
, TIOCSLTC
, &shell_ltchars
);
2276 #endif /* NEW_TTY_DRIVER */
2278 #if defined (TERMIO_TTY_DRIVER)
2279 ioctl (tty
, TCSETAW
, &shell_tty_info
);
2280 #endif /* TERMIO_TTY_DRIVER */
2282 #if defined (TERMIOS_TTY_DRIVER)
2283 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
2285 /* Only print an error message if we're really interactive at
2288 sys_error ("[%ld: %d (%d)] tcsetattr", (long)getpid (), shell_level
, tty
);
2291 #endif /* TERMIOS_TTY_DRIVER */
2296 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
2297 process in that job's pipeline. This is the one whose exit status
2298 counts. Must be called with SIGCHLD blocked or queued. */
2300 find_last_proc (job
, block
)
2304 register PROCESS
*p
;
2308 BLOCK_CHILD (set
, oset
);
2310 p
= jobs
[job
]->pipe
;
2311 while (p
&& p
->next
!= jobs
[job
]->pipe
)
2315 UNBLOCK_CHILD (oset
);
2321 find_last_pid (job
, block
)
2327 p
= find_last_proc (job
, block
);
2328 /* Possible race condition here. */
2332 /* Wait for a particular child of the shell to finish executing.
2333 This low-level function prints an error message if PID is not
2334 a child of this shell. It returns -1 if it fails, or whatever
2335 wait_for returns otherwise. If the child is not found in the
2336 jobs table, it returns 127. If FLAGS doesn't include 1, we
2337 suppress the error message if PID isn't found. */
2340 wait_for_single_pid (pid
, flags
)
2344 register PROCESS
*child
;
2348 BLOCK_CHILD (set
, oset
);
2349 child
= find_pipeline (pid
, 0, (int *)NULL
);
2350 UNBLOCK_CHILD (oset
);
2354 r
= bgp_search (pid
);
2362 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid
);
2368 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
2370 BLOCK_CHILD (set
, oset
);
2371 job
= find_job (pid
, 0, NULL
);
2372 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2373 jobs
[job
]->flags
|= J_NOTIFIED
;
2374 UNBLOCK_CHILD (oset
);
2376 /* If running in posix mode, remove the job from the jobs table immediately */
2377 if (posixly_correct
)
2379 cleanup_dead_jobs ();
2386 /* Wait for all of the background processes started by this shell to finish. */
2388 wait_for_background_pids ()
2390 register int i
, r
, waited_for
;
2394 for (waited_for
= 0;;)
2396 BLOCK_CHILD (set
, oset
);
2398 /* find first running job; if none running in foreground, break */
2399 /* XXX could use js.j_firstj and js.j_lastj here */
2400 for (i
= 0; i
< js
.j_jobslots
; i
++)
2403 if (i
< js
.j_firstj
&& jobs
[i
])
2404 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
2405 if (i
> js
.j_lastj
&& jobs
[i
])
2406 itrace("wait_for_background_pids: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
2408 if (jobs
[i
] && RUNNING (i
) && IS_FOREGROUND (i
) == 0)
2411 if (i
== js
.j_jobslots
)
2413 UNBLOCK_CHILD (oset
);
2417 /* now wait for the last pid in that job. */
2418 pid
= find_last_pid (i
, 0);
2419 UNBLOCK_CHILD (oset
);
2421 errno
= 0; /* XXX */
2422 r
= wait_for_single_pid (pid
, 1);
2425 /* If we're mistaken about job state, compensate. */
2426 if (errno
== ECHILD
)
2427 mark_all_jobs_as_dead ();
2433 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2434 `wait' is called with no arguments. */
2435 mark_dead_jobs_as_notified (1);
2436 cleanup_dead_jobs ();
2440 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2441 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2442 static SigHandler
*old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2444 static int wait_sigint_received
;
2445 static int child_caught_sigint
;
2446 static int waiting_for_child
;
2448 /* Clean up state after longjmp to wait_intr_buf */
2450 wait_sigint_cleanup ()
2453 waiting_for_child
= 0;
2457 restore_sigint_handler ()
2459 if (old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
2461 set_signal_handler (SIGINT
, old_sigint_handler
);
2462 old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2463 waiting_for_child
= 0;
2467 /* Handle SIGINT while we are waiting for children in a script to exit.
2468 The `wait' builtin should be interruptible, but all others should be
2469 effectively ignored (i.e. not cause the shell to exit). */
2471 wait_sigint_handler (sig
)
2474 SigHandler
*sigint_handler
;
2476 if (interrupt_immediately
||
2477 (this_shell_builtin
&& this_shell_builtin
== wait_builtin
))
2479 last_command_exit_value
= 128+SIGINT
;
2480 restore_sigint_handler ();
2481 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2482 what POSIX.2 says (see builtins/wait.def for more info). */
2483 if (this_shell_builtin
&& this_shell_builtin
== wait_builtin
&&
2484 signal_is_trapped (SIGINT
) &&
2485 ((sigint_handler
= trap_to_sighandler (SIGINT
)) == trap_handler
))
2487 trap_handler (SIGINT
); /* set pending_traps[SIGINT] */
2488 wait_signal_received
= SIGINT
;
2489 if (interrupt_immediately
&& wait_intr_flag
)
2491 interrupt_immediately
= 0;
2492 sh_longjmp (wait_intr_buf
, 1);
2495 /* Let CHECK_WAIT_INTR handle it in wait_for/waitchld */
2498 else if (interrupt_immediately
)
2503 else /* wait_builtin but signal not trapped, treat as interrupt */
2504 kill (getpid (), SIGINT
);
2507 /* XXX - should this be interrupt_state? If it is, the shell will act
2508 as if it got the SIGINT interrupt. */
2509 if (waiting_for_child
)
2510 wait_sigint_received
= 1;
2513 last_command_exit_value
= 128+SIGINT
;
2514 restore_sigint_handler ();
2515 kill (getpid (), SIGINT
);
2518 /* Otherwise effectively ignore the SIGINT and allow the running job to
2524 process_exit_signal (status
)
2527 return (WIFSIGNALED (status
) ? WTERMSIG (status
) : 0);
2531 process_exit_status (status
)
2534 if (WIFSIGNALED (status
))
2535 return (128 + WTERMSIG (status
));
2536 else if (WIFSTOPPED (status
) == 0)
2537 return (WEXITSTATUS (status
));
2539 return (EXECUTION_SUCCESS
);
2543 job_signal_status (job
)
2546 register PROCESS
*p
;
2549 p
= jobs
[job
]->pipe
;
2553 if (WIFSIGNALED(s
) || WIFSTOPPED(s
))
2557 while (p
!= jobs
[job
]->pipe
);
2562 /* Return the exit status of the last process in the pipeline for job JOB.
2563 This is the exit status of the entire job. */
2565 raw_job_exit_status (job
)
2568 register PROCESS
*p
;
2575 p
= jobs
[job
]->pipe
;
2578 if (WSTATUS (p
->status
) != EXECUTION_SUCCESS
)
2579 fail
= WSTATUS(p
->status
);
2582 while (p
!= jobs
[job
]->pipe
);
2583 WSTATUS (ret
) = fail
;
2587 for (p
= jobs
[job
]->pipe
; p
->next
!= jobs
[job
]->pipe
; p
= p
->next
)
2592 /* Return the exit status of job JOB. This is the exit status of the last
2593 (rightmost) process in the job's pipeline, modified if the job was killed
2594 by a signal or stopped. */
2596 job_exit_status (job
)
2599 return (process_exit_status (raw_job_exit_status (job
)));
2603 job_exit_signal (job
)
2606 return (process_exit_signal (raw_job_exit_status (job
)));
2609 #define FIND_CHILD(pid, child) \
2612 child = find_pipeline (pid, 0, (int *)NULL); \
2615 give_terminal_to (shell_pgrp, 0); \
2616 UNBLOCK_CHILD (oset); \
2617 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2618 restore_sigint_handler (); \
2619 return (termination_state = 127); \
2624 /* Wait for pid (one of our children) to terminate, then
2625 return the termination state. Returns 127 if PID is not found in
2626 the jobs table. Returns -1 if waitchld() returns -1, indicating
2627 that there are no unwaited-for child processes. */
2632 int job
, termination_state
, r
;
2634 register PROCESS
*child
;
2637 /* In the case that this code is interrupted, and we longjmp () out of it,
2638 we are relying on the code in throw_to_top_level () to restore the
2639 top-level signal mask. */
2641 BLOCK_CHILD (set
, oset
);
2643 /* Ignore interrupts while waiting for a job run without job control
2644 to finish. We don't want the shell to exit if an interrupt is
2645 received, only if one of the jobs run is killed via SIGINT. If
2646 job control is not set, the job will be run in the same pgrp as
2647 the shell, and the shell will see any signals the job gets. In
2648 fact, we want this set every time the waiting shell and the waited-
2649 for process are in the same process group, including command
2652 /* This is possibly a race condition -- should it go in stop_pipeline? */
2653 wait_sigint_received
= child_caught_sigint
= 0;
2654 if (job_control
== 0 || (subshell_environment
&SUBSHELL_COMSUB
))
2656 old_sigint_handler
= set_signal_handler (SIGINT
, wait_sigint_handler
);
2657 waiting_for_child
= 0;
2658 if (old_sigint_handler
== SIG_IGN
)
2659 set_signal_handler (SIGINT
, old_sigint_handler
);
2662 termination_state
= last_command_exit_value
;
2664 if (interactive
&& job_control
== 0)
2666 /* Check for terminating signals and exit the shell if we receive one */
2669 /* Check for a trapped signal interrupting the wait builtin and jump out */
2672 /* If we say wait_for (), then we have a record of this child somewhere.
2673 If it and none of its peers are running, don't call waitchld(). */
2679 FIND_CHILD (pid
, child
);
2681 /* If this child is part of a job, then we are really waiting for the
2682 job to finish. Otherwise, we are waiting for the child to finish.
2683 We check for JDEAD in case the job state has been set by waitchld
2684 after receipt of a SIGCHLD. */
2685 if (job
== NO_JOB
) /* XXX -- && pid != ANY_PID ? */
2686 job
= find_job (pid
, 0, NULL
);
2688 /* waitchld() takes care of setting the state of the job. If the job
2689 has already exited before this is called, sigchld_handler will have
2690 called waitchld and the state will be set to JDEAD. */
2692 if (pid
== ANY_PID
|| PRUNNING(child
) || (job
!= NO_JOB
&& RUNNING (job
)))
2694 #if defined (WAITPID_BROKEN) /* SCOv4 */
2695 sigset_t suspend_set
;
2696 sigemptyset (&suspend_set
);
2697 sigsuspend (&suspend_set
);
2698 #else /* !WAITPID_BROKEN */
2699 # if defined (MUST_UNBLOCK_CHLD)
2700 struct sigaction act
, oact
;
2701 sigset_t nullset
, chldset
;
2704 sigemptyset (&nullset
);
2705 sigemptyset (&chldset
);
2706 sigprocmask (SIG_SETMASK
, &nullset
, &chldset
);
2707 act
.sa_handler
= SIG_DFL
;
2708 sigemptyset (&act
.sa_mask
);
2709 sigemptyset (&oact
.sa_mask
);
2711 # if defined (SA_RESTART)
2712 act
.sa_flags
|= SA_RESTART
;
2714 sigaction (SIGCHLD
, &act
, &oact
);
2715 # endif /* MUST_UNBLOCK_CHLD */
2717 waiting_for_child
++;
2718 r
= waitchld (pid
, 1); /* XXX */
2719 waiting_for_child
--;
2721 itrace("wait_for: blocking wait for %d returns %d child = %p", (int)pid
, r
, child
);
2723 # if defined (MUST_UNBLOCK_CHLD)
2724 sigaction (SIGCHLD
, &oact
, (struct sigaction
*)NULL
);
2725 sigprocmask (SIG_SETMASK
, &chldset
, (sigset_t
*)NULL
);
2728 if (r
== -1 && errno
== ECHILD
&& this_shell_builtin
== wait_builtin
)
2730 termination_state
= -1;
2731 /* XXX - restore sigint handler here? */
2732 goto wait_for_return
;
2735 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2736 there is something wrong. Somewhere, wait should have returned
2737 that child's pid. Mark the child as not running and the job,
2738 if it exists, as JDEAD. */
2739 if (r
== -1 && errno
== ECHILD
)
2743 child
->running
= PS_DONE
;
2744 WSTATUS (child
->status
) = 0; /* XXX -- can't find true status */
2746 js
.c_living
= 0; /* no living child processes */
2749 jobs
[job
]->state
= JDEAD
;
2755 termination_state
= -1;
2759 #endif /* WAITPID_BROKEN */
2762 /* If the shell is interactive, and job control is disabled, see
2763 if the foreground process has died due to SIGINT and jump out
2764 of the wait loop if it has. waitchld has already restored the
2765 old SIGINT signal handler. */
2766 if (interactive
&& job_control
== 0)
2768 /* Check for terminating signals and exit the shell if we receive one */
2771 /* Check for a trapped signal interrupting the wait builtin and jump out */
2775 /* XXX - could set child but we don't have a handle on what waitchld
2776 reaps. Leave termination_state alone. */
2777 goto wait_for_return
;
2779 while (PRUNNING (child
) || (job
!= NO_JOB
&& RUNNING (job
)));
2781 /* Restore the original SIGINT signal handler before we return. */
2782 restore_sigint_handler ();
2784 /* The exit state of the command is either the termination state of the
2785 child, or the termination state of the job. If a job, the status
2786 of the last child in the pipeline is the significant one. If the command
2787 or job was terminated by a signal, note that value also. */
2788 termination_state
= (job
!= NO_JOB
) ? job_exit_status (job
)
2789 : (child
? process_exit_status (child
->status
) : EXECUTION_SUCCESS
);
2790 last_command_exit_signal
= (job
!= NO_JOB
) ? job_exit_signal (job
)
2791 : (child
? process_exit_signal (child
->status
) : 0);
2794 if ((job
!= NO_JOB
&& JOBSTATE (job
) == JSTOPPED
) || (child
&& WIFSTOPPED (child
->status
)))
2795 termination_state
= 128 + WSTOPSIG (child
->status
);
2797 if (job
== NO_JOB
|| IS_JOBCONTROL (job
))
2799 /* XXX - under what circumstances is a job not present in the jobs
2800 table (job == NO_JOB)?
2801 1. command substitution
2803 In the case of command substitution, at least, it's probably not
2804 the right thing to give the terminal to the shell's process group,
2805 even though there is code in subst.c:command_substitute to work
2809 $PROMPT_COMMAND execution
2810 process substitution
2814 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp
);
2816 /* Don't modify terminal pgrp if we are running in background or a
2817 subshell. Make sure subst.c:command_substitute uses the same
2818 conditions to determine whether or not it should undo this and
2819 give the terminal to pipeline_pgrp. */
2821 if (running_in_background
== 0 && (subshell_environment
&(SUBSHELL_ASYNC
|SUBSHELL_PIPE
)) == 0)
2822 give_terminal_to (shell_pgrp
, 0);
2825 /* If the command did not exit cleanly, or the job is just
2826 being stopped, then reset the tty state back to what it
2827 was before this command. Reset the tty state and notify
2828 the user of the job termination only if the shell is
2829 interactive. Clean up any dead jobs in either case. */
2832 if (interactive_shell
&& subshell_environment
== 0)
2834 /* This used to use `child->status'. That's wrong, however, for
2835 pipelines. `child' is the first process in the pipeline. It's
2836 likely that the process we want to check for abnormal termination
2837 or stopping is the last process in the pipeline, especially if
2838 it's long-lived and the first process is short-lived. Since we
2839 know we have a job here, we can check all the processes in this
2840 job's pipeline and see if one of them stopped or terminated due
2841 to a signal. We might want to change this later to just check
2842 the last process in the pipeline. If no process exits due to a
2843 signal, S is left as the status of the last job in the pipeline. */
2844 s
= job_signal_status (job
);
2846 if (WIFSIGNALED (s
) || WIFSTOPPED (s
))
2850 /* If the current job was stopped or killed by a signal, and
2851 the user has requested it, get a possibly new window size */
2852 if (check_window_size
&& (job
== js
.j_current
|| IS_FOREGROUND (job
)))
2853 get_new_window_size (0, (int *)0, (int *)0);
2856 #if defined (READLINE)
2857 /* We don't want to do this if we are running a process during
2858 programmable completion. */
2859 if (RL_ISSTATE (RL_STATE_COMPLETING
) == 0)
2863 /* If job control is enabled, the job was started with job
2864 control, the job was the foreground job, and it was killed
2865 by SIGINT, then print a newline to compensate for the kernel
2866 printing the ^C without a trailing newline. */
2867 if (job_control
&& IS_JOBCONTROL (job
) && IS_FOREGROUND (job
) &&
2868 WIFSIGNALED (s
) && WTERMSIG (s
) == SIGINT
)
2870 /* If SIGINT is not trapped and the shell is in a for, while,
2871 or until loop, act as if the shell received SIGINT as
2872 well, so the loop can be broken. This doesn't call the
2873 SIGINT signal handler; maybe it should. */
2874 if (signal_is_trapped (SIGINT
) == 0 && (loop_level
|| (shell_compatibility_level
> 32 && executing_list
)))
2876 /* Call any SIGINT trap handler if the shell is running a loop, so
2877 the loop can be broken. This seems more useful and matches the
2878 behavior when the shell is running a builtin command in a loop
2879 when it is interrupted. Change ADDINTERRUPT to
2880 trap_handler (SIGINT) to run the trap without interrupting the
2882 else if (signal_is_trapped (SIGINT
) && loop_level
)
2891 else if ((subshell_environment
& (SUBSHELL_COMSUB
|SUBSHELL_PIPE
)) && wait_sigint_received
)
2893 /* If waiting for a job in a subshell started to do command
2894 substitution or to run a pipeline element that consists of
2895 something like a while loop or a for loop, simulate getting
2896 and being killed by the SIGINT to pass the status back to our
2898 if (child_caught_sigint
== 0 && signal_is_trapped (SIGINT
) == 0)
2900 UNBLOCK_CHILD (oset
);
2901 old_sigint_handler
= set_signal_handler (SIGINT
, SIG_DFL
);
2902 if (old_sigint_handler
== SIG_IGN
)
2903 restore_sigint_handler ();
2905 kill (getpid (), SIGINT
);
2908 else if (interactive_shell
== 0 && IS_FOREGROUND (job
) && check_window_size
)
2909 get_new_window_size (0, (int *)0, (int *)0);
2911 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2912 signal handler path */
2913 if (DEADJOB (job
) && IS_FOREGROUND (job
) /*&& subshell_environment == 0*/)
2916 /* If this job is dead, notify the user of the status. If the shell
2917 is interactive, this will display a message on the terminal. If
2918 the shell is not interactive, make sure we turn on the notify bit
2919 so we don't get an unwanted message about the job's termination,
2920 and so delete_job really clears the slot in the jobs table. */
2921 notify_and_cleanup ();
2926 UNBLOCK_CHILD (oset
);
2928 return (termination_state
);
2931 /* Wait for the last process in the pipeline for JOB. Returns whatever
2932 wait_for returns: the last process's termination state or -1 if there
2933 are no unwaited-for child processes or an error occurs. */
2942 BLOCK_CHILD(set
, oset
);
2943 if (JOBSTATE (job
) == JSTOPPED
)
2944 internal_warning (_("wait_for_job: job %d is stopped"), job
+1);
2946 pid
= find_last_pid (job
, 0);
2947 UNBLOCK_CHILD(oset
);
2950 /* POSIX.2: we can remove the job from the jobs table if we just waited
2952 BLOCK_CHILD (set
, oset
);
2953 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2954 jobs
[job
]->flags
|= J_NOTIFIED
;
2955 UNBLOCK_CHILD (oset
);
2960 /* Wait for any background job started by this shell to finish. Very
2961 similar to wait_for_background_pids(). Returns the exit status of
2962 the next exiting job, -1 if there are no background jobs. The caller
2963 is responsible for translating -1 into the right return value. */
2968 int i
, r
, waited_for
;
2971 if (jobs_list_frozen
)
2974 /* First see if there are any unnotified dead jobs that we can report on */
2975 BLOCK_CHILD (set
, oset
);
2976 for (i
= 0; i
< js
.j_jobslots
; i
++)
2978 if (jobs
[i
] && DEADJOB (i
) && IS_NOTIFIED (i
) == 0)
2981 r
= job_exit_status (i
);
2982 notify_of_job_status (); /* XXX */
2984 #if defined (COPROCESS_SUPPORT)
2987 UNBLOCK_CHILD (oset
);
2991 UNBLOCK_CHILD (oset
);
2993 /* At this point, we have no dead jobs in the jobs table. Wait until we
2994 get one, even if it takes multiple pids exiting. */
2995 for (waited_for
= 0;;)
2997 /* Make sure there is a background job to wait for */
2998 BLOCK_CHILD (set
, oset
);
2999 for (i
= 0; i
< js
.j_jobslots
; i
++)
3000 if (jobs
[i
] && RUNNING (i
) && IS_FOREGROUND (i
) == 0)
3002 if (i
== js
.j_jobslots
)
3004 UNBLOCK_CHILD (oset
);
3008 UNBLOCK_CHILD (oset
);
3015 r
= wait_for (ANY_PID
); /* special sentinel value for wait_for */
3016 if (r
== -1 && errno
== ECHILD
)
3017 mark_all_jobs_as_dead ();
3019 /* Now we see if we have any dead jobs and return the first one */
3020 BLOCK_CHILD (set
, oset
);
3021 for (i
= 0; i
< js
.j_jobslots
; i
++)
3022 if (jobs
[i
] && DEADJOB (i
))
3024 UNBLOCK_CHILD (oset
);
3030 /* Print info about dead jobs, and then delete them from the list
3031 of known jobs. This does not actually delete jobs when the
3032 shell is not interactive, because the dead jobs are not marked
3035 notify_and_cleanup ()
3037 if (jobs_list_frozen
)
3040 if (interactive
|| interactive_shell
== 0 || sourcelevel
)
3041 notify_of_job_status ();
3043 cleanup_dead_jobs ();
3046 /* Make dead jobs disappear from the jobs array without notification.
3047 This is used when the shell is not interactive. */
3051 mark_dead_jobs_as_notified (0);
3052 cleanup_dead_jobs ();
3055 /* Return the next closest (chronologically) job to JOB which is in
3056 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
3057 there is no next recent job. */
3059 most_recent_job_in_state (job
, state
)
3063 register int i
, result
;
3066 BLOCK_CHILD (set
, oset
);
3068 for (result
= NO_JOB
, i
= job
- 1; i
>= 0; i
--)
3070 if (jobs
[i
] && (JOBSTATE (i
) == state
))
3077 UNBLOCK_CHILD (oset
);
3082 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
3085 job_last_stopped (job
)
3088 return (most_recent_job_in_state (job
, JSTOPPED
));
3091 /* Return the newest *running* job older than JOB, or NO_JOB if not
3094 job_last_running (job
)
3097 return (most_recent_job_in_state (job
, JRUNNING
));
3100 /* Make JOB be the current job, and make previous be useful. Must be
3101 called with SIGCHLD blocked. */
3103 set_current_job (job
)
3108 if (js
.j_current
!= job
)
3110 js
.j_previous
= js
.j_current
;
3114 /* First choice for previous job is the old current job. */
3115 if (js
.j_previous
!= js
.j_current
&&
3116 js
.j_previous
!= NO_JOB
&&
3117 jobs
[js
.j_previous
] &&
3118 STOPPED (js
.j_previous
))
3121 /* Second choice: Newest stopped job that is older than
3124 if (STOPPED (js
.j_current
))
3126 candidate
= job_last_stopped (js
.j_current
);
3128 if (candidate
!= NO_JOB
)
3130 js
.j_previous
= candidate
;
3135 /* If we get here, there is either only one stopped job, in which case it is
3136 the current job and the previous job should be set to the newest running
3137 job, or there are only running jobs and the previous job should be set to
3138 the newest running job older than the current job. We decide on which
3139 alternative to use based on whether or not JOBSTATE(js.j_current) is
3142 candidate
= RUNNING (js
.j_current
) ? job_last_running (js
.j_current
)
3143 : job_last_running (js
.j_jobslots
);
3145 if (candidate
!= NO_JOB
)
3147 js
.j_previous
= candidate
;
3151 /* There is only a single job, and it is both `+' and `-'. */
3152 js
.j_previous
= js
.j_current
;
3155 /* Make current_job be something useful, if it isn't already. */
3157 /* Here's the deal: The newest non-running job should be `+', and the
3158 next-newest non-running job should be `-'. If there is only a single
3159 stopped job, the js.j_previous is the newest non-running job. If there
3160 are only running jobs, the newest running job is `+' and the
3161 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
3168 if (js
.j_jobslots
&& js
.j_current
!= NO_JOB
&& jobs
[js
.j_current
] && STOPPED (js
.j_current
))
3169 candidate
= js
.j_current
;
3174 /* First choice: the previous job. */
3175 if (js
.j_previous
!= NO_JOB
&& jobs
[js
.j_previous
] && STOPPED (js
.j_previous
))
3176 candidate
= js
.j_previous
;
3178 /* Second choice: the most recently stopped job. */
3179 if (candidate
== NO_JOB
)
3180 candidate
= job_last_stopped (js
.j_jobslots
);
3182 /* Third choice: the newest running job. */
3183 if (candidate
== NO_JOB
)
3184 candidate
= job_last_running (js
.j_jobslots
);
3187 /* If we found a job to use, then use it. Otherwise, there
3188 are no jobs period. */
3189 if (candidate
!= NO_JOB
)
3190 set_current_job (candidate
);
3192 js
.j_current
= js
.j_previous
= NO_JOB
;
3195 /* Set up the job structures so we know the job and its processes are
3198 set_job_running (job
)
3201 register PROCESS
*p
;
3203 /* Each member of the pipeline is now running. */
3204 p
= jobs
[job
]->pipe
;
3208 if (WIFSTOPPED (p
->status
))
3209 p
->running
= PS_RUNNING
; /* XXX - could be PS_STOPPED */
3212 while (p
!= jobs
[job
]->pipe
);
3214 /* This means that the job is running. */
3215 JOBSTATE (job
) = JRUNNING
;
3218 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
3219 start the job in the background. JOB is a zero-based index into
3220 JOBS. Returns -1 if it is unable to start a job, and the return
3221 status of the job otherwise. */
3223 start_job (job
, foreground
)
3224 int job
, foreground
;
3226 register PROCESS
*p
;
3227 int already_running
;
3230 static TTYSTRUCT save_stty
;
3232 BLOCK_CHILD (set
, oset
);
3236 internal_error (_("%s: job has terminated"), this_command_name
);
3237 UNBLOCK_CHILD (oset
);
3241 already_running
= RUNNING (job
);
3243 if (foreground
== 0 && already_running
)
3245 internal_error (_("%s: job %d already in background"), this_command_name
, job
+ 1);
3246 UNBLOCK_CHILD (oset
);
3247 return (0); /* XPG6/SUSv3 says this is not an error */
3250 wd
= current_working_directory ();
3252 /* You don't know about the state of this job. Do you? */
3253 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3257 set_current_job (job
);
3258 jobs
[job
]->flags
|= J_FOREGROUND
;
3261 /* Tell the outside world what we're doing. */
3262 p
= jobs
[job
]->pipe
;
3264 if (foreground
== 0)
3266 /* POSIX.2 says `bg' doesn't give any indication about current or
3268 if (posixly_correct
== 0)
3269 s
= (job
== js
.j_current
) ? "+ ": ((job
== js
.j_previous
) ? "- " : " ");
3272 printf ("[%d]%s", job
+ 1, s
);
3278 p
->command
? p
->command
: "",
3279 p
->next
!= jobs
[job
]->pipe
? " | " : "");
3282 while (p
!= jobs
[job
]->pipe
);
3284 if (foreground
== 0)
3287 if (strcmp (wd
, jobs
[job
]->wd
) != 0)
3288 printf (" (wd: %s)", polite_directory_format (jobs
[job
]->wd
));
3293 if (already_running
== 0)
3294 set_job_running (job
);
3296 /* Save the tty settings before we start the job in the foreground. */
3300 save_stty
= shell_tty_info
;
3301 /* Give the terminal to this job. */
3302 if (IS_JOBCONTROL (job
))
3303 give_terminal_to (jobs
[job
]->pgrp
, 0);
3306 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3308 /* If the job is already running, then don't bother jump-starting it. */
3309 if (already_running
== 0)
3311 jobs
[job
]->flags
|= J_NOTIFIED
;
3312 killpg (jobs
[job
]->pgrp
, SIGCONT
);
3320 pid
= find_last_pid (job
, 0);
3321 UNBLOCK_CHILD (oset
);
3322 st
= wait_for (pid
);
3323 shell_tty_info
= save_stty
;
3330 UNBLOCK_CHILD (oset
);
3335 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
3336 If PID does belong to a job, and the job is stopped, then CONTinue the
3337 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
3338 then kill the process group associated with PID. */
3340 kill_pid (pid
, sig
, group
)
3344 register PROCESS
*p
;
3345 int job
, result
, negative
;
3351 group
= negative
= 1;
3356 result
= EXECUTION_SUCCESS
;
3359 BLOCK_CHILD (set
, oset
);
3360 p
= find_pipeline (pid
, 0, &job
);
3364 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3366 /* Kill process in backquotes or one started without job control? */
3368 /* If we're passed a pid < -1, just call killpg and see what happens */
3369 if (negative
&& jobs
[job
]->pgrp
== shell_pgrp
)
3370 result
= killpg (pid
, sig
);
3371 /* If we're killing using job control notification, for example,
3372 without job control active, we have to do things ourselves. */
3373 else if (jobs
[job
]->pgrp
== shell_pgrp
)
3375 p
= jobs
[job
]->pipe
;
3378 if (PALIVE (p
) == 0)
3379 continue; /* avoid pid recycling problem */
3381 if (PEXITED (p
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
3382 kill (p
->pid
, SIGCONT
);
3385 while (p
!= jobs
[job
]->pipe
);
3389 result
= killpg (jobs
[job
]->pgrp
, sig
);
3390 if (p
&& STOPPED (job
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
3391 killpg (jobs
[job
]->pgrp
, SIGCONT
);
3392 /* If we're continuing a stopped job via kill rather than bg or
3393 fg, emulate the `bg' behavior. */
3394 if (p
&& STOPPED (job
) && (sig
== SIGCONT
))
3396 set_job_running (job
);
3397 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3398 jobs
[job
]->flags
|= J_NOTIFIED
;
3403 result
= killpg (pid
, sig
);
3405 UNBLOCK_CHILD (oset
);
3408 result
= kill (pid
, sig
);
3413 /* sigchld_handler () flushes at least one of the children that we are
3414 waiting for. It gets run when we have gotten a SIGCHLD signal. */
3416 sigchld_handler (sig
)
3422 REINSTALL_SIGCHLD_HANDLER
;
3425 if (queue_sigchld
== 0)
3426 n
= waitchld (-1, 0);
3431 /* waitchld() reaps dead or stopped children. It's called by wait_for and
3432 sigchld_handler, and runs until there aren't any children terminating any
3434 If BLOCK is 1, this is to be a blocking wait for a single child, although
3435 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
3436 the number of children reaped, or -1 if there are no unwaited-for child
3439 waitchld (wpid
, block
)
3447 int call_set_current
, last_stopped_job
, job
, children_exited
, waitpid_flags
;
3448 static int wcontinued
= WCONTINUED
; /* run-time fix for glibc problem */
3450 call_set_current
= children_exited
= 0;
3451 last_stopped_job
= NO_JOB
;
3455 /* We don't want to be notified about jobs stopping if job control
3456 is not active. XXX - was interactive_shell instead of job_control */
3457 waitpid_flags
= (job_control
&& subshell_environment
== 0)
3458 ? (WUNTRACED
|wcontinued
)
3460 if (sigchld
|| block
== 0)
3461 waitpid_flags
|= WNOHANG
;
3463 /* Check for terminating signals and exit the shell if we receive one */
3465 /* Check for a trapped signal interrupting the wait builtin and jump out */
3468 if (block
== 1 && queue_sigchld
== 0 && (waitpid_flags
& WNOHANG
) == 0)
3470 internal_warning (_("waitchld: turning on WNOHANG to avoid indefinite block"));
3471 waitpid_flags
|= WNOHANG
;
3474 pid
= WAITPID (-1, &status
, waitpid_flags
);
3477 if (wpid
!= -1 && block
)
3478 itrace("waitchld: blocking waitpid returns %d", pid
);
3482 itrace("waitchld: %s waitpid returns %d", block
?"blocking":"non-blocking", pid
);
3484 /* WCONTINUED may be rejected by waitpid as invalid even when defined */
3485 if (wcontinued
&& pid
< 0 && errno
== EINVAL
)
3488 continue; /* jump back to the test and retry without WCONTINUED */
3491 /* The check for WNOHANG is to make sure we decrement sigchld only
3492 if it was non-zero before we called waitpid. */
3493 if (sigchld
> 0 && (waitpid_flags
& WNOHANG
))
3496 /* If waitpid returns -1 with errno == ECHILD, there are no more
3497 unwaited-for child processes of this shell. */
3498 if (pid
< 0 && errno
== ECHILD
)
3500 if (children_exited
== 0)
3507 itrace("waitchld: waitpid returns %d block = %d children_exited = %d", pid
, block
, children_exited
);
3509 /* If waitpid returns 0, there are running children. If it returns -1,
3510 the only other error POSIX says it can return is EINTR. */
3514 /* If waitpid returns -1/EINTR and the shell saw a SIGINT, then we
3515 assume the child has blocked or handled SIGINT. In that case, we
3516 require the child to actually die due to SIGINT to act on the
3517 SIGINT we received; otherwise we assume the child handled it and
3519 if (pid
< 0 && errno
== EINTR
&& wait_sigint_received
)
3520 child_caught_sigint
= 1;
3523 continue; /* jumps right to the test */
3525 /* Linux kernels appear to signal the parent but not interrupt the
3526 waitpid() (or restart it even without SA_RESTART) on SIGINT, so if
3527 we saw a SIGINT and the process exited or died due to some other
3528 signal, assume the child caught the SIGINT. */
3529 if (wait_sigint_received
&& (WIFSIGNALED (status
) == 0 || WTERMSIG (status
) != SIGINT
))
3530 child_caught_sigint
= 1;
3532 /* If the child process did die due to SIGINT, forget our assumption
3533 that it caught or otherwise handled it. */
3534 if (WIFSIGNALED (status
) && WTERMSIG (status
) == SIGINT
)
3535 child_caught_sigint
= 0;
3537 /* children_exited is used to run traps on SIGCHLD. We don't want to
3538 run the trap if a process is just being continued. */
3539 if (WIFCONTINUED(status
) == 0)
3545 /* Locate our PROCESS for this pid. */
3546 child
= find_process (pid
, 1, &job
); /* want living procs only */
3548 #if defined (COPROCESS_SUPPORT)
3549 coproc_pidchk (pid
, WSTATUS(status
));
3552 /* It is not an error to have a child terminate that we did
3553 not have a record of. This child could have been part of
3554 a pipeline in backquote substitution. Even so, I'm not
3555 sure child is ever non-zero. */
3558 if (WIFEXITED (status
) || WIFSIGNALED (status
))
3563 /* Remember status, and whether or not the process is running. */
3564 child
->status
= status
;
3565 child
->running
= WIFCONTINUED(status
) ? PS_RUNNING
: PS_DONE
;
3567 if (PEXITED (child
))
3577 call_set_current
+= set_job_status_and_cleanup (job
);
3580 last_stopped_job
= job
;
3581 else if (DEADJOB (job
) && last_stopped_job
== job
)
3582 last_stopped_job
= NO_JOB
;
3584 while ((sigchld
|| block
== 0) && pid
> (pid_t
)0);
3586 /* If a job was running and became stopped, then set the current
3587 job. Otherwise, don't change a thing. */
3588 if (call_set_current
)
3590 if (last_stopped_job
!= NO_JOB
)
3591 set_current_job (last_stopped_job
);
3596 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
3597 if (job_control
&& children_exited
&&
3598 (signal_is_trapped (SIGCHLD
) || trap_list
[SIGCHLD
] == (char *)IMPOSSIBLE_TRAP_HANDLER
) &&
3599 trap_list
[SIGCHLD
] != (char *)IGNORE_SIG
)
3601 if (posixly_correct
&& this_shell_builtin
&& this_shell_builtin
== wait_builtin
)
3603 interrupt_immediately
= 0;
3604 /* This was trap_handler (SIGCHLD) but that can lose traps if
3605 children_exited > 1 */
3606 queue_sigchld_trap (children_exited
);
3607 wait_signal_received
= SIGCHLD
;
3608 /* If we're in a signal handler, let CHECK_WAIT_INTR pick it up;
3609 run_pending_traps will call run_sigchld_trap later */
3610 if (sigchld
== 0 && wait_intr_flag
)
3611 sh_longjmp (wait_intr_buf
, 1);
3613 /* If not in posix mode and not executing the wait builtin, queue the
3614 signal for later handling. Run the trap immediately if we are
3615 executing the wait builtin, but don't break out of `wait'. */
3616 else if (sigchld
) /* called from signal handler */
3617 queue_sigchld_trap (children_exited
);
3618 else if (signal_in_progress (SIGCHLD
))
3619 queue_sigchld_trap (children_exited
);
3620 else if (trap_list
[SIGCHLD
] == (char *)IMPOSSIBLE_TRAP_HANDLER
)
3621 queue_sigchld_trap (children_exited
);
3622 else if (running_trap
)
3623 queue_sigchld_trap (children_exited
);
3624 else if (this_shell_builtin
== wait_builtin
)
3625 run_sigchld_trap (children_exited
); /* XXX */
3627 queue_sigchld_trap (children_exited
);
3630 /* We have successfully recorded the useful information about this process
3631 that has just changed state. If we notify asynchronously, and the job
3632 that this process belongs to is no longer running, then notify the user
3633 of that fact now. */
3634 if (asynchronous_notification
&& interactive
)
3635 notify_of_job_status ();
3637 return (children_exited
);
3640 /* Set the status of JOB and perform any necessary cleanup if the job is
3643 Currently, the cleanup activity is restricted to handling any SIGINT
3644 received while waiting for a foreground job to finish. */
3646 set_job_status_and_cleanup (job
)
3650 int tstatus
, job_state
, any_stopped
, any_tstped
, call_set_current
;
3651 SigHandler
*temp_handler
;
3653 child
= jobs
[job
]->pipe
;
3654 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3656 call_set_current
= 0;
3659 * COMPUTE JOB STATUS
3662 /* If all children are not running, but any of them is stopped, then
3663 the job is stopped, not dead. */
3664 job_state
= any_stopped
= any_tstped
= 0;
3667 job_state
|= PRUNNING (child
);
3669 if (PEXITED (child
) && (WIFSTOPPED (child
->status
)))
3671 /* Only checking for WIFSTOPPED now, not for PS_DONE */
3672 if (PSTOPPED (child
))
3676 any_tstped
|= job_control
&& (WSTOPSIG (child
->status
) == SIGTSTP
);
3678 child
= child
->next
;
3680 while (child
!= jobs
[job
]->pipe
);
3682 /* If job_state != 0, the job is still running, so don't bother with
3683 setting the process exit status and job state unless we're
3684 transitioning from stopped to running. */
3685 if (job_state
!= 0 && JOBSTATE(job
) != JSTOPPED
)
3692 /* The job is either stopped or dead. Set the state of the job accordingly. */
3695 jobs
[job
]->state
= JSTOPPED
;
3696 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3698 /* Suspending a job with SIGTSTP breaks all active loops. */
3699 if (any_tstped
&& loop_level
)
3700 breaking
= loop_level
;
3702 else if (job_state
!= 0) /* was stopped, now running */
3704 jobs
[job
]->state
= JRUNNING
;
3709 jobs
[job
]->state
= JDEAD
;
3713 if (IS_FOREGROUND (job
))
3717 /* If this job has a cleanup function associated with it, call it
3718 with `cleanarg' as the single argument, then set the function
3719 pointer to NULL so it is not inadvertently called twice. The
3720 cleanup function is responsible for deallocating cleanarg. */
3721 if (jobs
[job
]->j_cleanup
)
3723 (*jobs
[job
]->j_cleanup
) (jobs
[job
]->cleanarg
);
3724 jobs
[job
]->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
3731 * Currently, we just do special things if we got a SIGINT while waiting
3732 * for a foreground job to complete
3735 if (JOBSTATE (job
) == JDEAD
)
3737 /* If we're running a shell script and we get a SIGINT with a
3738 SIGINT trap handler, but the foreground job handles it and
3739 does not exit due to SIGINT, run the trap handler but do not
3740 otherwise act as if we got the interrupt. */
3741 if (wait_sigint_received
&& interactive_shell
== 0 &&
3742 child_caught_sigint
&& IS_FOREGROUND (job
) &&
3743 signal_is_trapped (SIGINT
))
3746 wait_sigint_received
= 0;
3747 last_command_exit_value
= process_exit_status (child
->status
);
3749 old_frozen
= jobs_list_frozen
;
3750 jobs_list_frozen
= 1;
3751 tstatus
= maybe_call_trap_handler (SIGINT
);
3752 jobs_list_frozen
= old_frozen
;
3755 /* If the foreground job is killed by SIGINT when job control is not
3756 active, we need to perform some special handling.
3758 The check of wait_sigint_received is a way to determine if the
3759 SIGINT came from the keyboard (in which case the shell has already
3760 seen it, and wait_sigint_received is non-zero, because keyboard
3761 signals are sent to process groups) or via kill(2) to the foreground
3762 process by another process (or itself). If the shell did receive the
3763 SIGINT, it needs to perform normal SIGINT processing. XXX - should
3764 this change its behavior depending on whether the last command in an
3765 pipeline exited due to SIGINT, or any process in the pipeline? Right
3766 now it does this if any process in the pipeline exits due to SIGINT. */
3767 else if (wait_sigint_received
&&
3768 child_caught_sigint
== 0 &&
3769 IS_FOREGROUND (job
) && IS_JOBCONTROL (job
) == 0)
3773 wait_sigint_received
= 0;
3775 /* If SIGINT is trapped, set the exit status so that the trap
3776 handler can see it. */
3777 if (signal_is_trapped (SIGINT
))
3778 last_command_exit_value
= process_exit_status (child
->status
);
3780 /* If the signal is trapped, let the trap handler get it no matter
3781 what and simply return if the trap handler returns.
3782 maybe_call_trap_handler() may cause dead jobs to be removed from
3783 the job table because of a call to execute_command. We work
3784 around this by setting JOBS_LIST_FROZEN. */
3785 old_frozen
= jobs_list_frozen
;
3786 jobs_list_frozen
= 1;
3787 tstatus
= maybe_call_trap_handler (SIGINT
);
3788 jobs_list_frozen
= old_frozen
;
3789 if (tstatus
== 0 && old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
3791 /* wait_sigint_handler () has already seen SIGINT and
3792 allowed the wait builtin to jump out. We need to
3793 call the original SIGINT handler, if necessary. If
3794 the original handler is SIG_DFL, we need to resend
3795 the signal to ourselves. */
3797 temp_handler
= old_sigint_handler
;
3799 /* Bogus. If we've reset the signal handler as the result
3800 of a trap caught on SIGINT, then old_sigint_handler
3801 will point to trap_handler, which now knows nothing about
3802 SIGINT (if we reset the sighandler to the default).
3803 In this case, we have to fix things up. What a crock. */
3804 if (temp_handler
== trap_handler
&& signal_is_trapped (SIGINT
) == 0)
3805 temp_handler
= trap_to_sighandler (SIGINT
);
3806 restore_sigint_handler ();
3807 if (temp_handler
== SIG_DFL
)
3808 termsig_handler (SIGINT
); /* XXX */
3809 else if (temp_handler
!= SIG_IGN
)
3810 (*temp_handler
) (SIGINT
);
3815 return call_set_current
;
3818 /* Build the array of values for the $PIPESTATUS variable from the set of
3819 exit statuses of all processes in the job J. */
3824 #if defined (ARRAY_VARS)
3826 register PROCESS
*p
;
3828 for (i
= 1, p
= jobs
[j
]->pipe
; p
->next
!= jobs
[j
]->pipe
; p
= p
->next
, i
++)
3833 pstatuses
= (int *)xrealloc (pstatuses
, i
* sizeof (int));
3840 pstatuses
[i
++] = process_exit_status (p
->status
);
3843 while (p
!= jobs
[j
]->pipe
);
3845 pstatuses
[i
] = -1; /* sentinel */
3846 set_pipestatus_array (pstatuses
, i
);
3851 run_sigchld_trap (nchild
)
3857 /* Turn off the trap list during the call to parse_and_execute ()
3858 to avoid potentially infinite recursive calls. Preserve the
3859 values of last_command_exit_value, last_made_pid, and the_pipeline
3860 around the execution of the trap commands. */
3861 trap_command
= savestring (trap_list
[SIGCHLD
]);
3863 begin_unwind_frame ("SIGCHLD trap");
3864 unwind_protect_int (last_command_exit_value
);
3865 unwind_protect_int (last_command_exit_signal
);
3866 unwind_protect_var (last_made_pid
);
3867 unwind_protect_int (interrupt_immediately
);
3868 unwind_protect_int (jobs_list_frozen
);
3869 unwind_protect_pointer (the_pipeline
);
3870 unwind_protect_pointer (subst_assign_varlist
);
3871 unwind_protect_pointer (this_shell_builtin
);
3872 unwind_protect_pointer (temporary_env
);
3874 /* We have to add the commands this way because they will be run
3875 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
3876 to reference freed memory. */
3877 add_unwind_protect (xfree
, trap_command
);
3878 add_unwind_protect (maybe_set_sigchld_trap
, trap_command
);
3880 subst_assign_varlist
= (WORD_LIST
*)NULL
;
3881 the_pipeline
= (PROCESS
*)NULL
;
3882 temporary_env
= 0; /* traps should not run with temporary env */
3884 running_trap
= SIGCHLD
+ 1;
3886 set_impossible_sigchld_trap ();
3887 jobs_list_frozen
= 1;
3888 for (i
= 0; i
< nchild
; i
++)
3891 interrupt_immediately
= 1;
3893 parse_and_execute (savestring (trap_command
), "trap", SEVAL_NOHIST
|SEVAL_RESETLINE
);
3896 run_unwind_frame ("SIGCHLD trap");
3900 /* Function to call when you want to notify people of changes
3901 in job status. This prints out all jobs which are pending
3902 notification to stderr, and marks those printed as already
3903 notified, thus making them candidates for cleanup. */
3905 notify_of_job_status ()
3907 register int job
, termsig
;
3912 if (jobs
== 0 || js
.j_jobslots
== 0)
3918 sigaddset (&set
, SIGCHLD
);
3919 sigaddset (&set
, SIGTTOU
);
3920 sigemptyset (&oset
);
3921 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3926 /* XXX could use js.j_firstj here */
3927 for (job
= 0, dir
= (char *)NULL
; job
< js
.j_jobslots
; job
++)
3929 if (jobs
[job
] && IS_NOTIFIED (job
) == 0)
3931 s
= raw_job_exit_status (job
);
3932 termsig
= WTERMSIG (s
);
3934 /* POSIX.2 says we have to hang onto the statuses of at most the
3935 last CHILD_MAX background processes if the shell is running a
3936 script. If the shell is running a script, either from a file
3937 or standard input, don't print anything unless the job was
3938 killed by a signal. */
3939 if (startup_state
== 0 && WIFSIGNALED (s
) == 0 &&
3940 ((DEADJOB (job
) && IS_FOREGROUND (job
) == 0) || STOPPED (job
)))
3944 /* If job control is disabled, don't print the status messages.
3945 Mark dead jobs as notified so that they get cleaned up. If
3946 startup_state == 2, we were started to run `-c command', so
3947 don't print anything. */
3948 if ((job_control
== 0 && interactive_shell
) || startup_state
== 2)
3950 /* If job control is disabled, don't print the status messages.
3951 Mark dead jobs as notified so that they get cleaned up. If
3952 startup_state == 2 and subshell_environment has the
3953 SUBSHELL_COMSUB bit turned on, we were started to run a command
3954 substitution, so don't print anything. */
3955 if ((job_control
== 0 && interactive_shell
) ||
3956 (startup_state
== 2 && (subshell_environment
& SUBSHELL_COMSUB
)))
3959 /* POSIX.2 compatibility: if the shell is not interactive,
3960 hang onto the job corresponding to the last asynchronous
3961 pid until the user has been notified of its status or does
3963 if (DEADJOB (job
) && (interactive_shell
|| (find_last_pid (job
, 0) != last_asynchronous_pid
)))
3964 jobs
[job
]->flags
|= J_NOTIFIED
;
3968 /* Print info on jobs that are running in the background,
3969 and on foreground jobs that were killed by anything
3970 except SIGINT (and possibly SIGPIPE). */
3971 switch (JOBSTATE (job
))
3974 if (interactive_shell
== 0 && termsig
&& WIFSIGNALED (s
) &&
3975 termsig
!= SIGINT
&&
3976 #if defined (DONT_REPORT_SIGTERM)
3977 termsig
!= SIGTERM
&&
3979 #if defined (DONT_REPORT_SIGPIPE)
3980 termsig
!= SIGPIPE
&&
3982 signal_is_trapped (termsig
) == 0)
3984 /* Don't print `0' for a line number. */
3985 fprintf (stderr
, _("%s: line %d: "), get_name_for_error (), (line_number
== 0) ? 1 : line_number
);
3986 pretty_print_job (job
, JLIST_NONINTERACTIVE
, stderr
);
3988 else if (IS_FOREGROUND (job
))
3990 #if !defined (DONT_REPORT_SIGPIPE)
3991 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
)
3993 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
&& termsig
!= SIGPIPE
)
3996 fprintf (stderr
, "%s", j_strsignal (termsig
));
3999 fprintf (stderr
, _(" (core dumped)"));
4001 fprintf (stderr
, "\n");
4004 else if (job_control
) /* XXX job control test added */
4007 dir
= current_working_directory ();
4008 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
4009 if (dir
&& strcmp (dir
, jobs
[job
]->wd
) != 0)
4011 _("(wd now: %s)\n"), polite_directory_format (dir
));
4014 jobs
[job
]->flags
|= J_NOTIFIED
;
4018 fprintf (stderr
, "\n");
4020 dir
= current_working_directory ();
4021 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
4022 if (dir
&& (strcmp (dir
, jobs
[job
]->wd
) != 0))
4024 _("(wd now: %s)\n"), polite_directory_format (dir
));
4025 jobs
[job
]->flags
|= J_NOTIFIED
;
4033 programming_error ("notify_of_job_status");
4038 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
4043 /* Initialize the job control mechanism, and set up the tty stuff. */
4045 initialize_job_control (force
)
4052 shell_pgrp
= getpgid (0);
4054 if (shell_pgrp
== -1)
4056 sys_error (_("initialize_job_control: getpgrp failed"));
4060 /* We can only have job control if we are interactive unless we force it. */
4061 if (interactive
== 0 && force
== 0)
4064 original_pgrp
= NO_PID
;
4065 shell_tty
= fileno (stderr
);
4066 terminal_pgrp
= tcgetpgrp (shell_tty
); /* for checking later */
4072 /* If forced_interactive is set, we skip the normal check that stderr
4073 is attached to a tty, so we need to check here. If it's not, we
4074 need to see whether we have a controlling tty by opening /dev/tty,
4075 since trying to use job control tty pgrp manipulations on a non-tty
4076 is going to fail. */
4077 if (forced_interactive
&& isatty (fileno (stderr
)) == 0)
4078 shell_tty
= open ("/dev/tty", O_RDWR
|O_NONBLOCK
);
4080 /* Get our controlling terminal. If job_control is set, or
4081 interactive is set, then this is an interactive shell no
4082 matter where fd 2 is directed. */
4083 if (shell_tty
== -1)
4084 shell_tty
= dup (fileno (stderr
)); /* fd 2 */
4086 if (shell_tty
!= -1)
4087 shell_tty
= move_to_high_fd (shell_tty
, 1, -1);
4089 /* Compensate for a bug in systems that compiled the BSD
4090 rlogind with DEBUG defined, like NeXT and Alliant. */
4091 if (shell_pgrp
== 0)
4093 shell_pgrp
= getpid ();
4094 setpgid (0, shell_pgrp
);
4095 if (shell_tty
!= -1)
4096 tcsetpgrp (shell_tty
, shell_pgrp
);
4099 while ((terminal_pgrp
= tcgetpgrp (shell_tty
)) != -1)
4101 if (shell_pgrp
!= terminal_pgrp
)
4105 ottin
= set_signal_handler (SIGTTIN
, SIG_DFL
);
4107 set_signal_handler (SIGTTIN
, ottin
);
4113 if (terminal_pgrp
== -1)
4116 /* Make sure that we are using the new line discipline. */
4117 if (set_new_line_discipline (shell_tty
) < 0)
4119 sys_error (_("initialize_job_control: line discipline"));
4124 original_pgrp
= shell_pgrp
;
4125 shell_pgrp
= getpid ();
4127 if ((original_pgrp
!= shell_pgrp
) && (setpgid (0, shell_pgrp
) < 0))
4129 sys_error (_("initialize_job_control: setpgid"));
4130 shell_pgrp
= original_pgrp
;
4135 /* If (and only if) we just set our process group to our pid,
4136 thereby becoming a process group leader, and the terminal
4137 is not in the same process group as our (new) process group,
4138 then set the terminal's process group to our (new) process
4139 group. If that fails, set our process group back to what it
4140 was originally (so we can still read from the terminal) and
4141 turn off job control. */
4142 if (shell_pgrp
!= original_pgrp
&& shell_pgrp
!= terminal_pgrp
)
4144 if (give_terminal_to (shell_pgrp
, 0) < 0)
4147 setpgid (0, original_pgrp
);
4148 shell_pgrp
= original_pgrp
;
4150 sys_error (_("cannot set terminal process group (%d)"), shell_pgrp
);
4155 if (job_control
&& ((t
= tcgetpgrp (shell_tty
)) == -1 || t
!= shell_pgrp
))
4159 sys_error (_("cannot set terminal process group (%d)"), t
);
4163 if (job_control
== 0)
4164 internal_error (_("no job control in this shell"));
4167 running_in_background
= terminal_pgrp
!= shell_pgrp
;
4169 if (shell_tty
!= fileno (stderr
))
4170 SET_CLOSE_ON_EXEC (shell_tty
);
4172 set_signal_handler (SIGCHLD
, sigchld_handler
);
4174 change_flag ('m', job_control
? '-' : '+');
4179 if (js
.c_childmax
< 0)
4180 js
.c_childmax
= getmaxchild ();
4181 if (js
.c_childmax
< 0)
4182 js
.c_childmax
= DEFAULT_CHILD_MAX
;
4185 if (js
.c_childmax
> MAX_CHILD_MAX
)
4186 js
.c_childmax
= MAX_CHILD_MAX
;
4194 debug_print_pgrps ()
4196 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
4197 (long)original_pgrp
, (long)shell_pgrp
, (long)terminal_pgrp
);
4198 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
4199 shell_tty
, (long)tcgetpgrp (shell_tty
), (long)getpgid(0));
4203 /* Set the line discipline to the best this system has to offer.
4204 Return -1 if this is not possible. */
4206 set_new_line_discipline (tty
)
4209 #if defined (NEW_TTY_DRIVER)
4212 if (ioctl (tty
, TIOCGETD
, &ldisc
) < 0)
4215 if (ldisc
!= NTTYDISC
)
4219 if (ioctl (tty
, TIOCSETD
, &ldisc
) < 0)
4223 #endif /* NEW_TTY_DRIVER */
4225 #if defined (TERMIO_TTY_DRIVER)
4226 # if defined (TERMIO_LDISC) && (NTTYDISC)
4227 if (ioctl (tty
, TCGETA
, &shell_tty_info
) < 0)
4230 if (shell_tty_info
.c_line
!= NTTYDISC
)
4232 shell_tty_info
.c_line
= NTTYDISC
;
4233 if (ioctl (tty
, TCSETAW
, &shell_tty_info
) < 0)
4236 # endif /* TERMIO_LDISC && NTTYDISC */
4238 #endif /* TERMIO_TTY_DRIVER */
4240 #if defined (TERMIOS_TTY_DRIVER)
4241 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
4242 if (tcgetattr (tty
, &shell_tty_info
) < 0)
4245 if (shell_tty_info
.c_line
!= NTTYDISC
)
4247 shell_tty_info
.c_line
= NTTYDISC
;
4248 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
4251 # endif /* TERMIOS_LDISC && NTTYDISC */
4253 #endif /* TERMIOS_TTY_DRIVER */
4255 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
4260 /* Setup this shell to handle C-C, etc. */
4262 initialize_job_signals ()
4266 set_signal_handler (SIGINT
, sigint_sighandler
);
4267 set_signal_handler (SIGTSTP
, SIG_IGN
);
4268 set_signal_handler (SIGTTOU
, SIG_IGN
);
4269 set_signal_handler (SIGTTIN
, SIG_IGN
);
4271 else if (job_control
)
4273 old_tstp
= set_signal_handler (SIGTSTP
, sigstop_sighandler
);
4274 old_ttin
= set_signal_handler (SIGTTIN
, sigstop_sighandler
);
4275 old_ttou
= set_signal_handler (SIGTTOU
, sigstop_sighandler
);
4277 /* Leave disposition unmodified for non-interactive shells without job
4281 /* Here we handle CONT signals. */
4283 sigcont_sighandler (sig
)
4286 initialize_job_signals ();
4287 set_signal_handler (SIGCONT
, old_cont
);
4288 kill (getpid (), SIGCONT
);
4293 /* Here we handle stop signals while we are running not as a login shell. */
4295 sigstop_sighandler (sig
)
4298 set_signal_handler (SIGTSTP
, old_tstp
);
4299 set_signal_handler (SIGTTOU
, old_ttou
);
4300 set_signal_handler (SIGTTIN
, old_ttin
);
4302 old_cont
= set_signal_handler (SIGCONT
, sigcont_sighandler
);
4304 give_terminal_to (shell_pgrp
, 0);
4306 kill (getpid (), sig
);
4311 /* Give the terminal to PGRP. */
4313 give_terminal_to (pgrp
, force
)
4321 if (job_control
|| force
)
4324 sigaddset (&set
, SIGTTOU
);
4325 sigaddset (&set
, SIGTTIN
);
4326 sigaddset (&set
, SIGTSTP
);
4327 sigaddset (&set
, SIGCHLD
);
4328 sigemptyset (&oset
);
4329 sigprocmask (SIG_BLOCK
, &set
, &oset
);
4331 if (tcsetpgrp (shell_tty
, pgrp
) < 0)
4333 /* Maybe we should print an error message? */
4335 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
4336 shell_tty
, (long)getpid(), (long)pgrp
);
4342 terminal_pgrp
= pgrp
;
4343 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
4352 /* Give terminal to NPGRP iff it's currently owned by OPGRP. FLAGS are the
4353 flags to pass to give_terminal_to(). */
4355 maybe_give_terminal_to (opgrp
, npgrp
, flags
)
4361 tpgrp
= tcgetpgrp (shell_tty
);
4362 if (tpgrp
< 0 && errno
== ENOTTY
)
4366 terminal_pgrp
= npgrp
;
4369 else if (tpgrp
!= opgrp
)
4372 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
);
4377 return (give_terminal_to (npgrp
, flags
));
4380 /* Clear out any jobs in the job array. This is intended to be used by
4381 children of the shell, who should not have any job structures as baggage
4382 when they start executing (forking subshells for parenthesized execution
4383 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
4384 is nonzero, only running jobs are removed from the table. */
4386 delete_all_jobs (running_only
)
4392 BLOCK_CHILD (set
, oset
);
4394 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
4397 js
.j_current
= js
.j_previous
= NO_JOB
;
4399 /* XXX could use js.j_firstj here */
4400 for (i
= 0; i
< js
.j_jobslots
; i
++)
4403 if (i
< js
.j_firstj
&& jobs
[i
])
4404 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4405 if (i
> js
.j_lastj
&& jobs
[i
])
4406 itrace("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4408 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
4409 /* We don't want to add any of these pids to bgpids. If running_only
4410 is non-zero, we don't want to add running jobs to the list.
4411 If we are interested in all jobs, not just running jobs, and
4412 we are going to clear the bgpids list below (bgp_clear()), we
4413 don't need to bother. */
4414 delete_job (i
, DEL_WARNSTOPPED
|DEL_NOBGPID
);
4416 if (running_only
== 0)
4418 free ((char *)jobs
);
4420 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
4424 if (running_only
== 0)
4427 UNBLOCK_CHILD (oset
);
4430 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
4431 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
4433 nohup_all_jobs (running_only
)
4439 BLOCK_CHILD (set
, oset
);
4443 /* XXX could use js.j_firstj here */
4444 for (i
= 0; i
< js
.j_jobslots
; i
++)
4445 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
4449 UNBLOCK_CHILD (oset
);
4458 /* This really counts all non-dead jobs. */
4459 BLOCK_CHILD (set
, oset
);
4460 /* XXX could use js.j_firstj here */
4461 for (i
= n
= 0; i
< js
.j_jobslots
; i
++)
4464 if (i
< js
.j_firstj
&& jobs
[i
])
4465 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4466 if (i
> js
.j_lastj
&& jobs
[i
])
4467 itrace("count_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4469 if (jobs
[i
] && DEADJOB(i
) == 0)
4472 UNBLOCK_CHILD (oset
);
4477 mark_all_jobs_as_dead ()
4482 if (js
.j_jobslots
== 0)
4485 BLOCK_CHILD (set
, oset
);
4487 /* XXX could use js.j_firstj here */
4488 for (i
= 0; i
< js
.j_jobslots
; i
++)
4491 jobs
[i
]->state
= JDEAD
;
4495 UNBLOCK_CHILD (oset
);
4498 /* Mark all dead jobs as notified, so delete_job () cleans them out
4499 of the job table properly. POSIX.2 says we need to save the
4500 status of the last CHILD_MAX jobs, so we count the number of dead
4501 jobs and mark only enough as notified to save CHILD_MAX statuses. */
4503 mark_dead_jobs_as_notified (force
)
4506 register int i
, ndead
, ndeadproc
;
4509 if (js
.j_jobslots
== 0)
4512 BLOCK_CHILD (set
, oset
);
4514 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
4515 around; just run through the array. */
4518 /* XXX could use js.j_firstj here */
4519 for (i
= 0; i
< js
.j_jobslots
; i
++)
4521 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
4522 jobs
[i
]->flags
|= J_NOTIFIED
;
4524 UNBLOCK_CHILD (oset
);
4528 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
4529 array with the corresponding not marked as notified. This is a better
4530 way to avoid pid aliasing and reuse problems than keeping the POSIX-
4531 mandated CHILD_MAX jobs around. delete_job() takes care of keeping the
4532 bgpids list regulated. */
4534 /* Count the number of dead jobs */
4535 /* XXX could use js.j_firstj here */
4536 for (i
= ndead
= ndeadproc
= 0; i
< js
.j_jobslots
; i
++)
4539 if (i
< js
.j_firstj
&& jobs
[i
])
4540 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4541 if (i
> js
.j_lastj
&& jobs
[i
])
4542 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4544 if (jobs
[i
] && DEADJOB (i
))
4547 ndeadproc
+= processes_in_job (i
);
4553 if (ndeadproc
!= js
.c_reaped
)
4554 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc
, js
.c_reaped
);
4556 if (ndead
!= js
.j_ndead
)
4557 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead
, js
.j_ndead
);
4560 if (js
.c_childmax
< 0)
4561 js
.c_childmax
= getmaxchild ();
4562 if (js
.c_childmax
< 0)
4563 js
.c_childmax
= DEFAULT_CHILD_MAX
;
4566 if (js
.c_childmax
> MAX_CHILD_MAX
)
4567 js
.c_childmax
= MAX_CHILD_MAX
;
4570 /* Don't do anything if the number of dead processes is less than CHILD_MAX
4571 and we're not forcing a cleanup. */
4572 if (ndeadproc
<= js
.c_childmax
)
4574 UNBLOCK_CHILD (oset
);
4579 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js
.c_childmax
, ndead
, ndeadproc
);
4582 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
4583 the list. This isn't exactly right yet; changes need to be made
4584 to stop_pipeline so we don't mark the newer jobs after we've
4585 created CHILD_MAX slots in the jobs array. This needs to be
4586 integrated with a way to keep the jobs array from growing without
4587 bound. Maybe we wrap back around to 0 after we reach some max
4588 limit, and there are sufficient job slots free (keep track of total
4589 size of jobs array (js.j_jobslots) and running count of number of jobs
4590 in jobs array. Then keep a job index corresponding to the `oldest job'
4591 and start this loop there, wrapping around as necessary. In effect,
4592 we turn the list into a circular buffer. */
4593 /* XXX could use js.j_firstj here */
4594 for (i
= 0; i
< js
.j_jobslots
; i
++)
4596 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
4599 if (i
< js
.j_firstj
&& jobs
[i
])
4600 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4601 if (i
> js
.j_lastj
&& jobs
[i
])
4602 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4604 /* If marking this job as notified would drop us down below
4605 child_max, don't mark it so we can keep at least child_max
4606 statuses. XXX -- need to check what Posix actually says
4607 about keeping statuses. */
4608 if ((ndeadproc
-= processes_in_job (i
)) <= js
.c_childmax
)
4610 jobs
[i
]->flags
|= J_NOTIFIED
;
4614 UNBLOCK_CHILD (oset
);
4617 /* Here to allow other parts of the shell (like the trap stuff) to
4618 freeze and unfreeze the jobs list. */
4624 o
= jobs_list_frozen
;
4625 jobs_list_frozen
= 1;
4630 unfreeze_jobs_list ()
4632 jobs_list_frozen
= 0;
4635 /* Allow or disallow job control to take place. Returns the old value
4638 set_job_control (arg
)
4646 if (terminal_pgrp
== NO_PID
)
4647 terminal_pgrp
= tcgetpgrp (shell_tty
);
4649 running_in_background
= (terminal_pgrp
!= shell_pgrp
);
4652 if (interactive_shell
== 0 && running_in_background
== 0 && job_control
!= old
)
4655 initialize_job_signals ();
4657 default_tty_job_signals ();
4661 /* If we're turning on job control, reset pipeline_pgrp so make_child will
4662 put new child processes into the right pgrp */
4663 if (job_control
!= old
&& job_control
)
4669 /* Turn off all traces of job control. This is run by children of the shell
4670 which are going to do shellsy things, like wait (), etc. */
4672 without_job_control ()
4674 stop_making_children ();
4676 #if defined (PGRP_PIPE)
4677 sh_closepipe (pgrp_pipe
);
4679 delete_all_jobs (0);
4680 set_job_control (0);
4683 /* If this shell is interactive, terminate all stopped jobs and
4684 restore the original terminal process group. This is done
4685 before the `exec' builtin calls shell_execve. */
4689 if (interactive_shell
|| job_control
) /* XXX - should it be just job_control? */
4691 terminate_stopped_jobs ();
4693 if (original_pgrp
>= 0)
4694 give_terminal_to (original_pgrp
, 1);
4697 if (original_pgrp
>= 0)
4698 setpgid (0, original_pgrp
);
4701 /* Restart job control by closing shell tty and reinitializing. This is
4702 called after an exec fails in an interactive shell and we do not exit. */
4704 restart_job_control ()
4706 if (shell_tty
!= -1)
4708 initialize_job_control (0);
4712 set_maxchild (nchild
)
4715 static int lmaxchild
= -1;
4718 lmaxchild
= getmaxchild ();
4720 lmaxchild
= DEFAULT_CHILD_MAX
;
4722 /* Clamp value we set. Minimum is what Posix requires, maximum is defined
4723 above as MAX_CHILD_MAX. */
4724 if (nchild
< lmaxchild
)
4726 else if (nchild
> MAX_CHILD_MAX
)
4727 nchild
= MAX_CHILD_MAX
;
4729 js
.c_childmax
= nchild
;
4732 /* Set the handler to run when the shell receives a SIGCHLD signal. */
4734 set_sigchld_handler ()
4736 set_signal_handler (SIGCHLD
, sigchld_handler
);
4739 #if defined (PGRP_PIPE)
4740 /* Read from the read end of a pipe. This is how the process group leader
4741 blocks until all of the processes in a pipeline have been made. */
4756 while (read (pp
[0], &ch
, 1) == -1 && errno
== EINTR
)
4761 /* Functional interface closes our local-to-job-control pipes. */
4765 sh_closepipe (pgrp_pipe
);
4769 save_pgrp_pipe (p
, clear
)
4773 p
[0] = pgrp_pipe
[0];
4774 p
[1] = pgrp_pipe
[1];
4776 pgrp_pipe
[0] = pgrp_pipe
[1] = -1;
4780 restore_pgrp_pipe (p
)
4783 pgrp_pipe
[0] = p
[0];
4784 pgrp_pipe
[1] = p
[1];
4787 #endif /* PGRP_PIPE */