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-2011 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 #include <sys/param.h>
50 #if defined (BUFFERED_INPUT)
54 /* Need to include this up here for *_TTY_DRIVER definitions. */
57 /* Define this if your output is getting swallowed. It's a no-op on
58 machines with the termio or termios tty drivers. */
59 /* #define DRAIN_OUTPUT */
61 /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
62 #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
64 #endif /* hpux && !TERMIOS_TTY_DRIVER */
70 #include "execute_cmd.h"
73 #include "builtins/builtext.h"
74 #include "builtins/common.h"
80 #if !defined (HAVE_KILLPG)
81 extern int killpg
__P((pid_t
, int));
84 #define DEFAULT_CHILD_MAX 32
86 #define MAX_JOBS_IN_ARRAY 4096 /* production */
88 #define MAX_JOBS_IN_ARRAY 128 /* testing */
91 /* Flag values for second argument to delete_job */
92 #define DEL_WARNSTOPPED 1 /* warn about deleting stopped jobs */
93 #define DEL_NOBGPID 2 /* don't add pgrp leader to bgpids */
95 /* Take care of system dependencies that must be handled when waiting for
96 children. The arguments to the WAITPID macro match those to the Posix.1
97 waitpid() function. */
99 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
100 # define WAITPID(pid, statusp, options) \
101 wait3 ((union wait *)statusp, options, (struct rusage *)0)
103 # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
104 # define WAITPID(pid, statusp, options) \
105 waitpid ((pid_t)pid, statusp, options)
107 # if defined (HAVE_WAIT3)
108 # define WAITPID(pid, statusp, options) \
109 wait3 (statusp, options, (struct rusage *)0)
111 # define WAITPID(pid, statusp, options) \
112 wait3 (statusp, options, (int *)0)
113 # endif /* HAVE_WAIT3 */
114 # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
115 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
117 /* getpgrp () varies between systems. Even systems that claim to be
118 Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
119 #if defined (GETPGRP_VOID)
120 # define getpgid(p) getpgrp ()
122 # define getpgid(p) getpgrp (p)
123 #endif /* !GETPGRP_VOID */
125 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
126 handler for SIGCHLD. */
127 #if defined (MUST_REINSTALL_SIGHANDLERS)
128 # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
130 # define REINSTALL_SIGCHLD_HANDLER
131 #endif /* !MUST_REINSTALL_SIGHANDLERS */
133 /* Some systems let waitpid(2) tell callers about stopped children. */
134 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
136 # define WCONTINUED 0
138 #if !defined (WIFCONTINUED)
139 # define WIFCONTINUED(s) (0)
142 /* The number of additional slots to allocate when we run out. */
145 typedef int sh_job_map_func_t
__P((JOB
*, int, int, int));
147 /* Variables used here but defined in other files. */
148 extern int subshell_environment
, line_number
;
149 extern int posixly_correct
, shell_level
;
150 extern int last_command_exit_value
, last_command_exit_signal
;
151 extern int loop_level
, breaking
;
152 extern int executing_list
;
153 extern int sourcelevel
;
154 extern int running_trap
;
155 extern sh_builtin_func_t
*this_shell_builtin
;
156 extern char *shell_name
, *this_command_name
;
157 extern sigset_t top_level_mask
;
158 extern procenv_t wait_intr_buf
;
159 extern int wait_signal_received
;
160 extern WORD_LIST
*subst_assign_varlist
;
162 static struct jobstats zerojs
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
163 struct jobstats js
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
165 struct bgpids bgpids
= { 0, 0, 0 };
167 /* The array of known jobs. */
168 JOB
**jobs
= (JOB
**)NULL
;
171 /* The number of slots currently allocated to JOBS. */
175 /* The controlling tty for this shell. */
178 /* The shell's process group. */
179 pid_t shell_pgrp
= NO_PID
;
181 /* The terminal's process group. */
182 pid_t terminal_pgrp
= NO_PID
;
184 /* The process group of the shell's parent. */
185 pid_t original_pgrp
= NO_PID
;
187 /* The process group of the pipeline currently being made. */
188 pid_t pipeline_pgrp
= (pid_t
)0;
190 #if defined (PGRP_PIPE)
191 /* Pipes which each shell uses to communicate with the process group leader
192 until all of the processes in a pipeline have been started. Then the
193 process leader is allowed to continue. */
194 int pgrp_pipe
[2] = { -1, -1 };
198 /* The job which is current; i.e. the one that `%+' stands for. */
199 int current_job
= NO_JOB
;
201 /* The previous job; i.e. the one that `%-' stands for. */
202 int previous_job
= NO_JOB
;
205 /* Last child made by the shell. */
206 pid_t last_made_pid
= NO_PID
;
208 /* Pid of the last asynchronous child. */
209 pid_t last_asynchronous_pid
= NO_PID
;
211 /* The pipeline currently being built. */
212 PROCESS
*the_pipeline
= (PROCESS
*)NULL
;
214 /* If this is non-zero, do job control. */
217 /* Call this when you start making children. */
218 int already_making_children
= 0;
220 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
221 exits from get_tty_state(). */
222 int check_window_size
;
224 /* Functions local to this file. */
226 static sighandler wait_sigint_handler
__P((int));
227 static sighandler sigchld_handler
__P((int));
228 static sighandler sigcont_sighandler
__P((int));
229 static sighandler sigstop_sighandler
__P((int));
231 static int waitchld
__P((pid_t
, int));
233 static PROCESS
*find_pipeline
__P((pid_t
, int, int *));
234 static PROCESS
*find_process
__P((pid_t
, int, int *));
236 static char *current_working_directory
__P((void));
237 static char *job_working_directory
__P((void));
238 static char *j_strsignal
__P((int));
239 static char *printable_job_status
__P((int, PROCESS
*, int));
241 static PROCESS
*find_last_proc
__P((int, int));
242 static pid_t find_last_pid
__P((int, int));
244 static int set_new_line_discipline
__P((int));
245 static int map_over_jobs
__P((sh_job_map_func_t
*, int, int));
246 static int job_last_stopped
__P((int));
247 static int job_last_running
__P((int));
248 static int most_recent_job_in_state
__P((int, JOB_STATE
));
249 static int find_job
__P((pid_t
, int, PROCESS
**));
250 static int print_job
__P((JOB
*, int, int, int));
251 static int process_exit_status
__P((WAIT
));
252 static int process_exit_signal
__P((WAIT
));
253 static int set_job_status_and_cleanup
__P((int));
255 static WAIT job_signal_status
__P((int));
256 static WAIT raw_job_exit_status
__P((int));
258 static void notify_of_job_status
__P((void));
259 static void reset_job_indices
__P((void));
260 static void cleanup_dead_jobs
__P((void));
261 static int processes_in_job
__P((int));
262 static void realloc_jobs_list
__P((void));
263 static int compact_jobs_list
__P((int));
264 static int discard_pipeline
__P((PROCESS
*));
265 static void add_process
__P((char *, pid_t
));
266 static void print_pipeline
__P((PROCESS
*, int, int, FILE *));
267 static void pretty_print_job
__P((int, int, FILE *));
268 static void set_current_job
__P((int));
269 static void reset_current
__P((void));
270 static void set_job_running
__P((int));
271 static void setjstatus
__P((int));
272 static int maybe_give_terminal_to
__P((pid_t
, pid_t
, int));
273 static void mark_all_jobs_as_dead
__P((void));
274 static void mark_dead_jobs_as_notified
__P((int));
275 static void restore_sigint_handler
__P((void));
276 #if defined (PGRP_PIPE)
277 static void pipe_read
__P((int *));
280 static struct pidstat
*bgp_alloc
__P((pid_t
, int));
281 static struct pidstat
*bgp_add
__P((pid_t
, int));
282 static int bgp_delete
__P((pid_t
));
283 static void bgp_clear
__P((void));
284 static int bgp_search
__P((pid_t
));
285 static void bgp_prune
__P((void));
287 #if defined (ARRAY_VARS)
288 static int *pstatuses
; /* list of pipeline statuses */
292 /* Used to synchronize between wait_for and other functions and the SIGCHLD
295 static int queue_sigchld
;
297 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
299 #define UNQUEUE_SIGCHLD(os) \
302 if (queue_sigchld == 0 && os != sigchld) \
306 static SigHandler
*old_tstp
, *old_ttou
, *old_ttin
;
307 static SigHandler
*old_cont
= (SigHandler
*)SIG_DFL
;
309 /* A place to temporarily save the current pipeline. */
310 static PROCESS
*saved_pipeline
;
311 static int saved_already_making_children
;
313 /* Set this to non-zero whenever you don't want the jobs list to change at
314 all: no jobs deleted and no status change notifications. This is used,
315 for example, when executing SIGCHLD traps, which may run arbitrary
317 static int jobs_list_frozen
;
319 static char retcode_name_buffer
[64];
321 /* flags to detect pid wraparound */
322 static pid_t first_pid
= NO_PID
;
323 static int pid_wrap
= -1;
325 #if !defined (_POSIX_VERSION)
327 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
328 library functions and system calls. */
329 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
330 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
338 /* ioctl will handle setting errno correctly. */
339 if (ioctl (fd
, TIOCGPGRP
, &pgrp
) < 0)
344 #endif /* !_POSIX_VERSION */
346 /* Initialize the global job stats structure and other bookkeeping variables */
355 /* Return the working directory for the current process. Unlike
356 job_working_directory, this does not call malloc (), nor do any
357 of the functions it calls. This is so that it can safely be called
358 from a signal handler. */
360 current_working_directory ()
363 static char d
[PATH_MAX
];
365 dir
= get_string_value ("PWD");
367 if (dir
== 0 && the_current_working_directory
&& no_symbolic_links
)
368 dir
= the_current_working_directory
;
372 dir
= getcwd (d
, sizeof(d
));
377 return (dir
== 0) ? "<unknown>" : dir
;
380 /* Return the working directory for the current process. */
382 job_working_directory ()
386 dir
= get_string_value ("PWD");
388 return (savestring (dir
));
390 dir
= get_working_directory ("job-working-directory");
394 return (savestring ("<unknown>"));
400 if (already_making_children
)
403 already_making_children
= 1;
408 stop_making_children ()
410 already_making_children
= 0;
414 cleanup_the_pipeline ()
419 BLOCK_CHILD (set
, oset
);
420 disposer
= the_pipeline
;
421 the_pipeline
= (PROCESS
*)NULL
;
422 UNBLOCK_CHILD (oset
);
425 discard_pipeline (disposer
);
429 save_pipeline (clear
)
432 saved_pipeline
= the_pipeline
;
434 the_pipeline
= (PROCESS
*)NULL
;
435 saved_already_making_children
= already_making_children
;
439 restore_pipeline (discard
)
442 PROCESS
*old_pipeline
;
444 old_pipeline
= the_pipeline
;
445 the_pipeline
= saved_pipeline
;
446 already_making_children
= saved_already_making_children
;
447 if (discard
&& old_pipeline
)
448 discard_pipeline (old_pipeline
);
451 /* Start building a pipeline. */
457 cleanup_the_pipeline ();
459 #if defined (PGRP_PIPE)
460 sh_closepipe (pgrp_pipe
);
464 #if defined (PGRP_PIPE)
467 if (pipe (pgrp_pipe
) == -1)
468 sys_error (_("start_pipeline: pgrp pipe"));
473 /* Stop building a pipeline. Install the process list in the job array.
474 This returns the index of the newly installed job.
475 DEFERRED is a command structure to be executed upon satisfactory
476 execution exit of this pipeline. */
478 stop_pipeline (async
, deferred
)
486 BLOCK_CHILD (set
, oset
);
488 #if defined (PGRP_PIPE)
489 /* The parent closes the process group synchronization pipe. */
490 sh_closepipe (pgrp_pipe
);
493 cleanup_dead_jobs ();
495 if (js
.j_jobslots
== 0)
497 js
.j_jobslots
= JOB_SLOTS
;
498 jobs
= (JOB
**)xmalloc (js
.j_jobslots
* sizeof (JOB
*));
500 /* Now blank out these new entries. */
501 for (i
= 0; i
< js
.j_jobslots
; i
++)
502 jobs
[i
] = (JOB
*)NULL
;
504 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
507 /* Scan from the last slot backward, looking for the next free one. */
508 /* XXX - revisit this interactive assumption */
509 /* XXX - this way for now */
512 for (i
= js
.j_jobslots
; i
; i
--)
519 /* This wraps around, but makes it inconvenient to extend the array */
520 for (i
= js
.j_lastj
+1; i
!= js
.j_lastj
; i
++)
522 if (i
>= js
.j_jobslots
)
530 /* This doesn't wrap around yet. */
531 for (i
= js
.j_lastj
? js
.j_lastj
+ 1 : js
.j_lastj
; i
< js
.j_jobslots
; i
++)
537 /* Do we need more room? */
539 /* First try compaction */
540 if ((interactive_shell
== 0 || subshell_environment
) && i
== js
.j_jobslots
&& js
.j_jobslots
>= MAX_JOBS_IN_ARRAY
)
541 i
= compact_jobs_list (0);
543 /* If we can't compact, reallocate */
544 if (i
== js
.j_jobslots
)
546 js
.j_jobslots
+= JOB_SLOTS
;
547 jobs
= (JOB
**)xrealloc (jobs
, (js
.j_jobslots
* sizeof (JOB
*)));
549 for (j
= i
; j
< js
.j_jobslots
; j
++)
550 jobs
[j
] = (JOB
*)NULL
;
553 /* Add the current pipeline to the job list. */
557 int any_running
, any_stopped
, n
;
559 newjob
= (JOB
*)xmalloc (sizeof (JOB
));
561 for (n
= 1, p
= the_pipeline
; p
->next
!= the_pipeline
; n
++, p
= p
->next
)
563 p
->next
= (PROCESS
*)NULL
;
564 newjob
->pipe
= REVERSE_LIST (the_pipeline
, PROCESS
*);
565 for (p
= newjob
->pipe
; p
->next
; p
= p
->next
)
567 p
->next
= newjob
->pipe
;
569 the_pipeline
= (PROCESS
*)NULL
;
570 newjob
->pgrp
= pipeline_pgrp
;
575 /* Flag to see if in another pgrp. */
577 newjob
->flags
|= J_JOBCONTROL
;
579 /* Set the state of this pipeline. */
581 any_running
= any_stopped
= 0;
584 any_running
|= PRUNNING (p
);
585 any_stopped
|= PSTOPPED (p
);
588 while (p
!= newjob
->pipe
);
590 newjob
->state
= any_running
? JRUNNING
: (any_stopped
? JSTOPPED
: JDEAD
);
591 newjob
->wd
= job_working_directory ();
592 newjob
->deferred
= deferred
;
594 newjob
->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
595 newjob
->cleanarg
= (PTR_T
) NULL
;
598 if (newjob
->state
== JDEAD
&& (newjob
->flags
& J_FOREGROUND
))
600 if (newjob
->state
== JDEAD
)
602 js
.c_reaped
+= n
; /* wouldn't have been done since this was not part of a job */
611 newjob
= (JOB
*)NULL
;
614 js
.j_lastmade
= newjob
;
620 newjob
->flags
&= ~J_FOREGROUND
;
621 newjob
->flags
|= J_ASYNC
;
622 js
.j_lastasync
= newjob
;
630 newjob
->flags
|= J_FOREGROUND
;
632 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
634 * The currently-accepted job control wisdom says to set the
635 * terminal's process group n+1 times in an n-step pipeline:
636 * once in the parent and once in each child. This is where
637 * the parent gives it away.
639 * Don't give the terminal away if this shell is an asynchronous
643 if (job_control
&& newjob
->pgrp
&& (subshell_environment
&SUBSHELL_ASYNC
) == 0)
644 maybe_give_terminal_to (shell_pgrp
, newjob
->pgrp
, 0);
648 stop_making_children ();
649 UNBLOCK_CHILD (oset
);
650 return (newjob
? i
: js
.j_current
);
653 /* Functions to manage the list of exited background pids whose status has
656 static struct pidstat
*
657 bgp_alloc (pid
, status
)
663 ps
= (struct pidstat
*)xmalloc (sizeof (struct pidstat
));
666 ps
->next
= (struct pidstat
*)0;
670 static struct pidstat
*
671 bgp_add (pid
, status
)
677 ps
= bgp_alloc (pid
, status
);
679 if (bgpids
.list
== 0)
681 bgpids
.list
= bgpids
.end
= ps
;
682 bgpids
.npid
= 0; /* just to make sure */
686 bgpids
.end
->next
= ps
;
691 if (bgpids
.npid
> js
.c_childmax
)
701 struct pidstat
*prev
, *p
;
703 for (prev
= p
= bgpids
.list
; p
; prev
= p
, p
= p
->next
)
706 prev
->next
= p
->next
; /* remove from list */
711 return 0; /* not found */
714 itrace("bgp_delete: deleting %d", pid
);
717 /* Housekeeping in the border cases. */
718 if (p
== bgpids
.list
)
719 bgpids
.list
= bgpids
.list
->next
;
720 else if (p
== bgpids
.end
)
724 if (bgpids
.npid
== 0)
725 bgpids
.list
= bgpids
.end
= 0;
726 else if (bgpids
.npid
== 1)
727 bgpids
.end
= bgpids
.list
; /* just to make sure */
733 /* Clear out the list of saved statuses */
737 struct pidstat
*ps
, *p
;
739 for (ps
= bgpids
.list
; ps
; )
745 bgpids
.list
= bgpids
.end
= 0;
749 /* Search for PID in the list of saved background pids; return its status if
750 found. If not found, return -1. */
757 for (ps
= bgpids
.list
; ps
; ps
= ps
->next
)
768 while (bgpids
.npid
> js
.c_childmax
)
771 bgpids
.list
= bgpids
.list
->next
;
777 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
778 been deleted. The caller should check whether js.j_njobs is 0 before
779 calling this. This wraps around, but the rest of the code does not. At
780 this point, it should not matter. */
786 if (jobs
[js
.j_firstj
] == 0)
789 if (old
>= js
.j_jobslots
)
790 old
= js
.j_jobslots
- 1;
791 while (js
.j_firstj
!= old
)
793 if (js
.j_firstj
>= js
.j_jobslots
)
795 if (jobs
[js
.j_firstj
] || js
.j_firstj
== old
) /* needed if old == 0 */
799 if (js
.j_firstj
== old
)
800 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
802 if (jobs
[js
.j_lastj
] == 0)
807 while (js
.j_lastj
!= old
)
810 js
.j_lastj
= js
.j_jobslots
- 1;
811 if (jobs
[js
.j_lastj
] || js
.j_lastj
== old
) /* needed if old == js.j_jobslots */
815 if (js
.j_lastj
== old
)
816 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
820 /* Delete all DEAD jobs that the user had received notification about. */
827 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
832 /* XXX could use js.j_firstj and js.j_lastj here */
833 for (i
= 0; i
< js
.j_jobslots
; i
++)
836 if (i
< js
.j_firstj
&& jobs
[i
])
837 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
838 if (i
> js
.j_lastj
&& jobs
[i
])
839 itrace("cleanup_dead_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
842 if (jobs
[i
] && DEADJOB (i
) && IS_NOTIFIED (i
))
846 #if defined (COPROCESS_SUPPORT)
854 processes_in_job (job
)
867 while (p
!= jobs
[job
]->pipe
);
879 job
= find_job (pid
, 0, &p
);
883 itrace ("delete_old_job: found pid %d in job %d with state %d", pid
, job
, jobs
[job
]->state
);
885 if (JOBSTATE (job
) == JDEAD
)
886 delete_job (job
, DEL_NOBGPID
);
889 internal_warning (_("forked pid %d appears in running job %d"), pid
, job
);
896 /* Reallocate and compress the jobs list. This returns with a jobs array
897 whose size is a multiple of JOB_SLOTS and can hold the current number of
898 jobs. Heuristics are used to minimize the number of new reallocs. */
903 int nsize
, i
, j
, ncur
, nprev
;
906 ncur
= nprev
= NO_JOB
;
907 nsize
= ((js
.j_njobs
+ JOB_SLOTS
- 1) / JOB_SLOTS
);
909 i
= js
.j_njobs
% JOB_SLOTS
;
910 if (i
== 0 || i
> (JOB_SLOTS
>> 1))
913 BLOCK_CHILD (set
, oset
);
914 nlist
= (js
.j_jobslots
== nsize
) ? jobs
: (JOB
**) xmalloc (nsize
* sizeof (JOB
*));
916 js
.c_reaped
= js
.j_ndead
= 0;
917 for (i
= j
= 0; i
< js
.j_jobslots
; i
++)
920 if (i
== js
.j_current
)
922 if (i
== js
.j_previous
)
924 nlist
[j
++] = jobs
[i
];
925 if (jobs
[i
]->state
== JDEAD
)
928 js
.c_reaped
+= processes_in_job (i
);
933 itrace ("realloc_jobs_list: resize jobs list from %d to %d", js
.j_jobslots
, nsize
);
934 itrace ("realloc_jobs_list: j_lastj changed from %d to %d", js
.j_lastj
, (j
> 0) ? j
- 1 : 0);
935 itrace ("realloc_jobs_list: j_njobs changed from %d to %d", js
.j_njobs
, j
);
936 itrace ("realloc_jobs_list: js.j_ndead %d js.c_reaped %d", js
.j_ndead
, js
.c_reaped
);
940 js
.j_lastj
= (j
> 0) ? j
- 1 : 0;
942 js
.j_jobslots
= nsize
;
944 /* Zero out remaining slots in new jobs list */
945 for ( ; j
< nsize
; j
++)
946 nlist
[j
] = (JOB
*)NULL
;
957 js
.j_previous
= nprev
;
959 /* Need to reset these */
960 if (js
.j_current
== NO_JOB
|| js
.j_previous
== NO_JOB
|| js
.j_current
> js
.j_lastj
|| js
.j_previous
> js
.j_lastj
)
964 itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js
.j_current
, js
.j_previous
);
967 UNBLOCK_CHILD (oset
);
970 /* Compact the jobs list by removing dead jobs. Assumed that we have filled
971 the jobs array to some predefined maximum. Called when the shell is not
972 the foreground process (subshell_environment != 0). Returns the first
973 available slot in the compacted list. If that value is js.j_jobslots, then
974 the list needs to be reallocated. The jobs array may be in new memory if
975 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
977 compact_jobs_list (flags
)
980 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
981 return js
.j_jobslots
;
984 realloc_jobs_list ();
987 itrace("compact_jobs_list: returning %d", (js
.j_lastj
|| jobs
[js
.j_lastj
]) ? js
.j_lastj
+ 1 : 0);
990 return ((js
.j_lastj
|| jobs
[js
.j_lastj
]) ? js
.j_lastj
+ 1 : 0);
993 /* Delete the job at INDEX from the job list. Must be called
994 with SIGCHLD blocked. */
996 delete_job (job_index
, dflags
)
997 int job_index
, dflags
;
1003 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
1006 if ((dflags
& DEL_WARNSTOPPED
) && subshell_environment
== 0 && STOPPED (job_index
))
1007 internal_warning (_("deleting stopped job %d with process group %ld"), job_index
+1, (long)jobs
[job_index
]->pgrp
);
1008 temp
= jobs
[job_index
];
1012 if ((dflags
& DEL_NOBGPID
) == 0)
1014 proc
= find_last_proc (job_index
, 0);
1015 /* Could do this just for J_ASYNC jobs, but we save all. */
1017 bgp_add (proc
->pid
, process_exit_status (proc
->status
));
1020 jobs
[job_index
] = (JOB
*)NULL
;
1021 if (temp
== js
.j_lastmade
)
1023 else if (temp
== js
.j_lastasync
)
1027 ndel
= discard_pipeline (temp
->pipe
);
1029 js
.c_injobs
-= ndel
;
1030 if (temp
->state
== JDEAD
)
1032 js
.c_reaped
-= ndel
;
1034 if (js
.c_reaped
< 0)
1037 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
);
1044 dispose_command (temp
->deferred
);
1049 if (js
.j_njobs
== 0)
1050 js
.j_firstj
= js
.j_lastj
= 0;
1051 else if (jobs
[js
.j_firstj
] == 0 || jobs
[js
.j_lastj
] == 0)
1052 reset_job_indices ();
1054 if (job_index
== js
.j_current
|| job_index
== js
.j_previous
)
1058 /* Must be called with SIGCHLD blocked. */
1060 nohup_job (job_index
)
1065 if (js
.j_jobslots
== 0)
1068 if (temp
= jobs
[job_index
])
1069 temp
->flags
|= J_NOHUP
;
1072 /* Get rid of the data structure associated with a process chain. */
1074 discard_pipeline (chain
)
1075 register PROCESS
*chain
;
1077 register PROCESS
*this, *next
;
1085 FREE (this->command
);
1090 while (this != chain
);
1095 /* Add this process to the chain being built in the_pipeline.
1096 NAME is the command string that will be exec'ed later.
1097 PID is the process id of the child. */
1099 add_process (name
, pid
)
1105 #if defined (RECYCLES_PIDS)
1107 p
= find_process (pid
, 0, &j
);
1112 internal_warning (_("add_process: process %5ld (%s) in the_pipeline"), (long)p
->pid
, p
->command
);
1115 internal_warning (_("add_process: pid %5ld (%s) marked as still alive"), (long)p
->pid
, p
->command
);
1116 p
->running
= PS_RECYCLED
; /* mark as recycled */
1120 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1121 t
->next
= the_pipeline
;
1123 WSTATUS (t
->status
) = 0;
1124 t
->running
= PS_RUNNING
;
1133 while (p
->next
!= t
->next
)
1139 /* Create a (dummy) PROCESS with NAME, PID, and STATUS, and make it the last
1140 process in jobs[JID]->pipe. Used by the lastpipe code. */
1142 append_process (name
, pid
, status
, jid
)
1150 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1151 t
->next
= (PROCESS
*)NULL
;
1153 /* set process exit status using offset discovered by configure */
1154 t
->status
= (status
& 0xff) << WEXITSTATUS_OFFSET
;
1155 t
->running
= PS_DONE
;
1158 js
.c_reaped
++; /* XXX */
1160 for (p
= jobs
[jid
]->pipe
; p
->next
!= jobs
[jid
]->pipe
; p
= p
->next
)
1163 t
->next
= jobs
[jid
]->pipe
;
1167 /* Take the last job and make it the first job. Must be called with
1170 rotate_the_pipeline ()
1174 if (the_pipeline
->next
== the_pipeline
)
1176 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1181 /* Reverse the order of the processes in the_pipeline. Must be called with
1184 reverse_the_pipeline ()
1188 if (the_pipeline
->next
== the_pipeline
)
1191 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1193 p
->next
= (PROCESS
*)NULL
;
1195 n
= REVERSE_LIST (the_pipeline
, PROCESS
*);
1198 for (p
= the_pipeline
; p
->next
; p
= p
->next
)
1200 p
->next
= the_pipeline
;
1204 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
1205 then it is time to stop mapping, and that is the return value
1206 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
1209 map_over_jobs (func
, arg1
, arg2
)
1210 sh_job_map_func_t
*func
;
1217 if (js
.j_jobslots
== 0)
1220 BLOCK_CHILD (set
, oset
);
1222 /* XXX could use js.j_firstj here */
1223 for (i
= result
= 0; i
< js
.j_jobslots
; i
++)
1226 if (i
< js
.j_firstj
&& jobs
[i
])
1227 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1228 if (i
> js
.j_lastj
&& jobs
[i
])
1229 itrace("map_over_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1233 result
= (*func
)(jobs
[i
], arg1
, arg2
, i
);
1239 UNBLOCK_CHILD (oset
);
1244 /* Cause all the jobs in the current pipeline to exit. */
1246 terminate_current_pipeline ()
1248 if (pipeline_pgrp
&& pipeline_pgrp
!= shell_pgrp
)
1250 killpg (pipeline_pgrp
, SIGTERM
);
1251 killpg (pipeline_pgrp
, SIGCONT
);
1255 /* Cause all stopped jobs to exit. */
1257 terminate_stopped_jobs ()
1261 /* XXX could use js.j_firstj here */
1262 for (i
= 0; i
< js
.j_jobslots
; i
++)
1264 if (jobs
[i
] && STOPPED (i
))
1266 killpg (jobs
[i
]->pgrp
, SIGTERM
);
1267 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1272 /* Cause all jobs, running or stopped, to receive a hangup signal. If
1273 a job is marked J_NOHUP, don't send the SIGHUP. */
1279 /* XXX could use js.j_firstj here */
1280 for (i
= 0; i
< js
.j_jobslots
; i
++)
1284 if (jobs
[i
]->flags
& J_NOHUP
)
1286 killpg (jobs
[i
]->pgrp
, SIGHUP
);
1288 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1294 kill_current_pipeline ()
1296 stop_making_children ();
1300 /* Return the pipeline that PID belongs to. Note that the pipeline
1301 doesn't have to belong to a job. Must be called with SIGCHLD blocked.
1302 If JOBP is non-null, return the index of the job containing PID. */
1304 find_pipeline (pid
, alive_only
, jobp
)
1307 int *jobp
; /* index into jobs list or NO_JOB */
1312 /* See if this process is in the pipeline that we are building. */
1320 /* Return it if we found it. Don't ever return a recycled pid. */
1321 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1326 while (p
!= the_pipeline
);
1329 job
= find_job (pid
, alive_only
, &p
);
1332 return (job
== NO_JOB
) ? (PROCESS
*)NULL
: jobs
[job
]->pipe
;
1335 /* Return the PROCESS * describing PID. If JOBP is non-null return the index
1336 into the jobs array of the job containing PID. Must be called with
1339 find_process (pid
, alive_only
, jobp
)
1342 int *jobp
; /* index into jobs list or NO_JOB */
1346 p
= find_pipeline (pid
, alive_only
, jobp
);
1347 while (p
&& p
->pid
!= pid
)
1352 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1353 belong to any job. Must be called with SIGCHLD blocked. */
1355 find_job (pid
, alive_only
, procp
)
1363 /* XXX could use js.j_firstj here, and should check js.j_lastj */
1364 for (i
= 0; i
< js
.j_jobslots
; i
++)
1367 if (i
< js
.j_firstj
&& jobs
[i
])
1368 itrace("find_job: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1369 if (i
> js
.j_lastj
&& jobs
[i
])
1370 itrace("find_job: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1378 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1387 while (p
!= jobs
[i
]->pipe
);
1394 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1395 required by find_job. */
1397 get_job_by_pid (pid
, block
)
1405 BLOCK_CHILD (set
, oset
);
1407 job
= find_job (pid
, 0, NULL
);
1410 UNBLOCK_CHILD (oset
);
1415 /* Print descriptive information about the job with leader pid PID. */
1423 BLOCK_CHILD (set
, oset
);
1425 job
= find_job (pid
, 0, NULL
);
1428 fprintf (stderr
, "[%d] %ld\n", job
+ 1, (long)pid
);
1430 programming_error (_("describe_pid: %ld: no such pid"), (long)pid
);
1432 UNBLOCK_CHILD (oset
);
1444 x
= retcode_name_buffer
;
1445 sprintf (x
, _("Signal %d"), s
);
1451 printable_job_status (j
, p
, format
)
1461 if (STOPPED (j
) && format
== 0)
1463 if (posixly_correct
== 0 || p
== 0 || (WIFSTOPPED (p
->status
) == 0))
1464 temp
= _("Stopped");
1467 temp
= retcode_name_buffer
;
1468 sprintf (temp
, _("Stopped(%s)"), signal_name (WSTOPSIG (p
->status
)));
1471 else if (RUNNING (j
))
1472 temp
= _("Running");
1475 if (WIFSTOPPED (p
->status
))
1476 temp
= j_strsignal (WSTOPSIG (p
->status
));
1477 else if (WIFSIGNALED (p
->status
))
1478 temp
= j_strsignal (WTERMSIG (p
->status
));
1479 else if (WIFEXITED (p
->status
))
1481 temp
= retcode_name_buffer
;
1482 es
= WEXITSTATUS (p
->status
);
1484 strcpy (temp
, _("Done"));
1485 else if (posixly_correct
)
1486 sprintf (temp
, _("Done(%d)"), es
);
1488 sprintf (temp
, _("Exit %d"), es
);
1491 temp
= _("Unknown status");
1497 /* This is the way to print out information on a job if you
1498 know the index. FORMAT is:
1500 JLIST_NORMAL) [1]+ Running emacs
1501 JLIST_LONG ) [1]+ 2378 Running emacs
1502 -1 ) [1]+ 2378 emacs
1504 JLIST_NORMAL) [1]+ Stopped ls | more
1505 JLIST_LONG ) [1]+ 2369 Stopped ls
1508 Just list the pid of the process group leader (really
1511 Use format JLIST_NORMAL, but list only jobs about which
1512 the user has not been notified. */
1514 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1515 the JOBS array corresponding to this pipeline. FORMAT is as described
1516 above. Must be called with SIGCHLD blocked.
1518 If you're printing a pipeline that's not in the jobs array, like the
1519 current pipeline as it's being created, pass -1 for JOB_INDEX */
1521 print_pipeline (p
, job_index
, format
, stream
)
1523 int job_index
, format
;
1526 PROCESS
*first
, *last
, *show
;
1527 int es
, name_padding
;
1534 while (last
->next
!= first
)
1540 fprintf (stream
, format
? " " : " |");
1542 if (format
!= JLIST_STANDARD
)
1543 fprintf (stream
, "%5ld", (long)p
->pid
);
1545 fprintf (stream
, " ");
1547 if (format
> -1 && job_index
>= 0)
1549 show
= format
? p
: last
;
1550 temp
= printable_job_status (job_index
, show
, format
);
1556 if (show
->running
== first
->running
&&
1557 WSTATUS (show
->status
) == WSTATUS (first
->status
))
1561 temp
= (char *)NULL
;
1566 fprintf (stream
, "%s", temp
);
1570 es
= 2; /* strlen ("| ") */
1571 name_padding
= LONGEST_SIGNAL_DESC
- es
;
1573 fprintf (stream
, "%*s", name_padding
, "");
1575 if ((WIFSTOPPED (show
->status
) == 0) &&
1576 (WIFCONTINUED (show
->status
) == 0) &&
1577 WIFCORED (show
->status
))
1578 fprintf (stream
, _("(core dumped) "));
1582 if (p
!= first
&& format
)
1583 fprintf (stream
, "| ");
1586 fprintf (stream
, "%s", p
->command
);
1588 if (p
== last
&& job_index
>= 0)
1590 temp
= current_working_directory ();
1592 if (RUNNING (job_index
) && (IS_FOREGROUND (job_index
) == 0))
1593 fprintf (stream
, " &");
1595 if (strcmp (temp
, jobs
[job_index
]->wd
) != 0)
1597 _(" (wd: %s)"), polite_directory_format (jobs
[job_index
]->wd
));
1600 if (format
|| (p
== last
))
1602 /* We need to add a CR only if this is an interactive shell, and
1603 we're reporting the status of a completed job asynchronously.
1604 We can't really check whether this particular job is being
1605 reported asynchronously, so just add the CR if the shell is
1606 currently interactive and asynchronous notification is enabled. */
1607 if (asynchronous_notification
&& interactive
)
1608 fprintf (stream
, "\r\n");
1610 fprintf (stream
, "\n");
1620 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1621 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1623 pretty_print_job (job_index
, format
, stream
)
1624 int job_index
, format
;
1627 register PROCESS
*p
;
1629 /* Format only pid information about the process group leader? */
1630 if (format
== JLIST_PID_ONLY
)
1632 fprintf (stream
, "%ld\n", (long)jobs
[job_index
]->pipe
->pid
);
1636 if (format
== JLIST_CHANGED_ONLY
)
1638 if (IS_NOTIFIED (job_index
))
1640 format
= JLIST_STANDARD
;
1643 if (format
!= JLIST_NONINTERACTIVE
)
1644 fprintf (stream
, "[%d]%c ", job_index
+ 1,
1645 (job_index
== js
.j_current
) ? '+':
1646 (job_index
== js
.j_previous
) ? '-' : ' ');
1648 if (format
== JLIST_NONINTERACTIVE
)
1649 format
= JLIST_LONG
;
1651 p
= jobs
[job_index
]->pipe
;
1653 print_pipeline (p
, job_index
, format
, stream
);
1655 /* We have printed information about this job. When the job's
1656 status changes, waitchld () sets the notification flag to 0. */
1657 jobs
[job_index
]->flags
|= J_NOTIFIED
;
1661 print_job (job
, format
, state
, job_index
)
1663 int format
, state
, job_index
;
1665 if (state
== -1 || (JOB_STATE
)state
== job
->state
)
1666 pretty_print_job (job_index
, format
, stdout
);
1671 list_one_job (job
, format
, ignore
, job_index
)
1673 int format
, ignore
, job_index
;
1675 pretty_print_job (job_index
, format
, stdout
);
1679 list_stopped_jobs (format
)
1682 cleanup_dead_jobs ();
1683 map_over_jobs (print_job
, format
, (int)JSTOPPED
);
1687 list_running_jobs (format
)
1690 cleanup_dead_jobs ();
1691 map_over_jobs (print_job
, format
, (int)JRUNNING
);
1694 /* List jobs. If FORMAT is non-zero, then the long form of the information
1695 is printed, else just a short version. */
1697 list_all_jobs (format
)
1700 cleanup_dead_jobs ();
1701 map_over_jobs (print_job
, format
, -1);
1704 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1705 COMMAND is just for remembering the name of the command; we don't do
1706 anything else with it. ASYNC_P says what to do with the tty. If
1707 non-zero, then don't give it away. */
1709 make_child (command
, async_p
)
1718 sigaddset (&set
, SIGCHLD
);
1719 sigaddset (&set
, SIGINT
);
1720 sigemptyset (&oset
);
1721 sigprocmask (SIG_BLOCK
, &set
, &oset
);
1727 #if defined (BUFFERED_INPUT)
1728 /* If default_buffered_input is active, we are reading a script. If
1729 the command is asynchronous, we have already duplicated /dev/null
1730 as fd 0, but have not changed the buffered stream corresponding to
1731 the old fd 0. We don't want to sync the stream in this case. */
1732 if (default_buffered_input
!= -1 &&
1733 (!async_p
|| default_buffered_input
> 0))
1734 sync_buffered_stream (default_buffered_input
);
1735 #endif /* BUFFERED_INPUT */
1737 /* Create the child, handle severe errors. Retry on EAGAIN. */
1738 while ((pid
= fork ()) < 0 && errno
== EAGAIN
&& forksleep
< FORKSLEEP_MAX
)
1741 /* If we can't create any children, try to reap some dead ones. */
1744 sys_error ("fork: retry");
1745 if (sleep (forksleep
) != 0)
1754 /* Kill all of the processes in the current pipeline. */
1755 terminate_current_pipeline ();
1757 /* Discard the current pipeline, if any. */
1759 kill_current_pipeline ();
1761 last_command_exit_value
= EX_NOEXEC
;
1762 throw_to_top_level (); /* Reset signals, etc. */
1767 /* In the child. Give this child the right process group, set the
1768 signals to the default state for a new process. */
1772 #if defined (BUFFERED_INPUT)
1773 /* Close default_buffered_input if it's > 0. We don't close it if it's
1774 0 because that's the file descriptor used when redirecting input,
1775 and it's wrong to close the file in that case. */
1776 unset_bash_input (0);
1777 #endif /* BUFFERED_INPUT */
1779 /* Restore top-level signal mask. */
1780 sigprocmask (SIG_SETMASK
, &top_level_mask
, (sigset_t
*)NULL
);
1784 /* All processes in this pipeline belong in the same
1787 if (pipeline_pgrp
== 0) /* This is the first child. */
1788 pipeline_pgrp
= mypid
;
1790 /* Check for running command in backquotes. */
1791 if (pipeline_pgrp
== shell_pgrp
)
1792 ignore_tty_job_signals ();
1794 default_tty_job_signals ();
1796 /* Set the process group before trying to mess with the terminal's
1797 process group. This is mandated by POSIX. */
1798 /* This is in accordance with the Posix 1003.1 standard,
1799 section B.7.2.4, which says that trying to set the terminal
1800 process group with tcsetpgrp() to an unused pgrp value (like
1801 this would have for the first child) is an error. Section
1802 B.4.3.3, p. 237 also covers this, in the context of job control
1804 if (setpgid (mypid
, pipeline_pgrp
) < 0)
1805 sys_error (_("child setpgid (%ld to %ld)"), (long)mypid
, (long)pipeline_pgrp
);
1807 /* By convention (and assumption above), if
1808 pipeline_pgrp == shell_pgrp, we are making a child for
1809 command substitution.
1810 In this case, we don't want to give the terminal to the
1811 shell's process group (we could be in the middle of a
1812 pipeline, for example). */
1813 if (async_p
== 0 && pipeline_pgrp
!= shell_pgrp
&& ((subshell_environment
&SUBSHELL_ASYNC
) == 0))
1814 give_terminal_to (pipeline_pgrp
, 0);
1816 #if defined (PGRP_PIPE)
1817 if (pipeline_pgrp
== mypid
)
1818 pipe_read (pgrp_pipe
);
1821 else /* Without job control... */
1823 if (pipeline_pgrp
== 0)
1824 pipeline_pgrp
= shell_pgrp
;
1826 /* If these signals are set to SIG_DFL, we encounter the curious
1827 situation of an interactive ^Z to a running process *working*
1828 and stopping the process, but being unable to do anything with
1829 that process to change its state. On the other hand, if they
1830 are set to SIG_IGN, jobs started from scripts do not stop when
1831 the shell running the script gets a SIGTSTP and stops. */
1833 default_tty_job_signals ();
1836 #if defined (PGRP_PIPE)
1837 /* Release the process group pipe, since our call to setpgid ()
1838 is done. The last call to sh_closepipe is done in stop_pipeline. */
1839 sh_closepipe (pgrp_pipe
);
1840 #endif /* PGRP_PIPE */
1843 /* Don't set last_asynchronous_pid in the child */
1845 last_asynchronous_pid
= mypid
; /* XXX */
1848 #if defined (RECYCLES_PIDS)
1849 if (last_asynchronous_pid
== mypid
)
1850 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1851 last_asynchronous_pid
= 1;
1856 /* In the parent. Remember the pid of the child just created
1857 as the proper pgrp if this is the first child. */
1859 if (first_pid
== NO_PID
)
1861 else if (pid_wrap
== -1 && pid
< first_pid
)
1863 else if (pid_wrap
== 0 && pid
>= first_pid
)
1868 if (pipeline_pgrp
== 0)
1870 pipeline_pgrp
= pid
;
1871 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1872 not the good thing of twiddling them in the child! */
1873 /* give_terminal_to (pipeline_pgrp, 0); */
1875 /* This is done on the recommendation of the Rationale section of
1876 the POSIX 1003.1 standard, where it discusses job control and
1877 shells. It is done to avoid possible race conditions. (Ref.
1878 1003.1 Rationale, section B.4.3.3, page 236). */
1879 setpgid (pid
, pipeline_pgrp
);
1883 if (pipeline_pgrp
== 0)
1884 pipeline_pgrp
= shell_pgrp
;
1887 /* Place all processes into the jobs array regardless of the
1888 state of job_control. */
1889 add_process (command
, pid
);
1892 last_asynchronous_pid
= pid
;
1893 #if defined (RECYCLES_PIDS)
1894 else if (last_asynchronous_pid
== pid
)
1895 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1896 last_asynchronous_pid
= 1;
1900 delete_old_job (pid
);
1902 #if !defined (RECYCLES_PIDS)
1903 /* Only check for saved status if we've saved more than CHILD_MAX
1904 statuses, unless the system recycles pids. */
1905 if ((js
.c_reaped
+ bgpids
.npid
) >= js
.c_childmax
)
1907 bgp_delete (pid
); /* new process, discard any saved status */
1909 last_made_pid
= pid
;
1915 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1916 SIGCHLD remains blocked until all commands in the pipeline have been
1918 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
1924 /* These two functions are called only in child processes. */
1926 ignore_tty_job_signals ()
1928 set_signal_handler (SIGTSTP
, SIG_IGN
);
1929 set_signal_handler (SIGTTIN
, SIG_IGN
);
1930 set_signal_handler (SIGTTOU
, SIG_IGN
);
1934 default_tty_job_signals ()
1936 set_signal_handler (SIGTSTP
, SIG_DFL
);
1937 set_signal_handler (SIGTTIN
, SIG_DFL
);
1938 set_signal_handler (SIGTTOU
, SIG_DFL
);
1941 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1942 state kept in here. When a job ends normally, we set the state in here
1943 to the state of the tty. */
1945 static TTYSTRUCT shell_tty_info
;
1947 #if defined (NEW_TTY_DRIVER)
1948 static struct tchars shell_tchars
;
1949 static struct ltchars shell_ltchars
;
1950 #endif /* NEW_TTY_DRIVER */
1952 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1953 /* Since the BSD tty driver does not allow us to change the tty modes
1954 while simultaneously waiting for output to drain and preserving
1955 typeahead, we have to drain the output ourselves before calling
1956 ioctl. We cheat by finding the length of the output queue, and
1957 using select to wait for an appropriate length of time. This is
1958 a hack, and should be labeled as such (it's a hastily-adapted
1959 mutation of a `usleep' implementation). It's only reason for
1960 existing is the flaw in the BSD tty driver. */
1962 static int ttspeeds
[] =
1964 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1965 1800, 2400, 4800, 9600, 19200, 38400
1972 register int delay
= ttspeeds
[ospeed
];
1978 while ((ioctl (fd
, TIOCOUTQ
, &n
) == 0) && n
)
1980 if (n
> (delay
/ 100))
1984 n
*= 10; /* 2 bits more for conservativeness. */
1985 tv
.tv_sec
= n
/ delay
;
1986 tv
.tv_usec
= ((n
% delay
) * 1000000) / delay
;
1987 select (fd
, (fd_set
*)0, (fd_set
*)0, (fd_set
*)0, &tv
);
1993 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1995 /* Return the fd from which we are actually getting input. */
1996 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
1998 /* Fill the contents of shell_tty_info with the current tty info. */
2007 #if defined (NEW_TTY_DRIVER)
2008 ioctl (tty
, TIOCGETP
, &shell_tty_info
);
2009 ioctl (tty
, TIOCGETC
, &shell_tchars
);
2010 ioctl (tty
, TIOCGLTC
, &shell_ltchars
);
2011 #endif /* NEW_TTY_DRIVER */
2013 #if defined (TERMIO_TTY_DRIVER)
2014 ioctl (tty
, TCGETA
, &shell_tty_info
);
2015 #endif /* TERMIO_TTY_DRIVER */
2017 #if defined (TERMIOS_TTY_DRIVER)
2018 if (tcgetattr (tty
, &shell_tty_info
) < 0)
2021 /* Only print an error message if we're really interactive at
2024 sys_error ("[%ld: %d (%d)] tcgetattr", (long)getpid (), shell_level
, tty
);
2028 #endif /* TERMIOS_TTY_DRIVER */
2029 if (check_window_size
)
2030 get_new_window_size (0, (int *)0, (int *)0);
2035 /* Make the current tty use the state in shell_tty_info. */
2044 #if defined (NEW_TTY_DRIVER)
2045 # if defined (DRAIN_OUTPUT)
2046 draino (tty
, shell_tty_info
.sg_ospeed
);
2047 # endif /* DRAIN_OUTPUT */
2048 ioctl (tty
, TIOCSETN
, &shell_tty_info
);
2049 ioctl (tty
, TIOCSETC
, &shell_tchars
);
2050 ioctl (tty
, TIOCSLTC
, &shell_ltchars
);
2051 #endif /* NEW_TTY_DRIVER */
2053 #if defined (TERMIO_TTY_DRIVER)
2054 ioctl (tty
, TCSETAW
, &shell_tty_info
);
2055 #endif /* TERMIO_TTY_DRIVER */
2057 #if defined (TERMIOS_TTY_DRIVER)
2058 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
2060 /* Only print an error message if we're really interactive at
2063 sys_error ("[%ld: %d (%d)] tcsetattr", (long)getpid (), shell_level
, tty
);
2066 #endif /* TERMIOS_TTY_DRIVER */
2071 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
2072 process in that job's pipeline. This is the one whose exit status
2073 counts. Must be called with SIGCHLD blocked or queued. */
2075 find_last_proc (job
, block
)
2079 register PROCESS
*p
;
2083 BLOCK_CHILD (set
, oset
);
2085 p
= jobs
[job
]->pipe
;
2086 while (p
&& p
->next
!= jobs
[job
]->pipe
)
2090 UNBLOCK_CHILD (oset
);
2096 find_last_pid (job
, block
)
2102 p
= find_last_proc (job
, block
);
2103 /* Possible race condition here. */
2107 /* Wait for a particular child of the shell to finish executing.
2108 This low-level function prints an error message if PID is not
2109 a child of this shell. It returns -1 if it fails, or whatever
2110 wait_for returns otherwise. If the child is not found in the
2111 jobs table, it returns 127. */
2113 wait_for_single_pid (pid
)
2116 register PROCESS
*child
;
2120 BLOCK_CHILD (set
, oset
);
2121 child
= find_pipeline (pid
, 0, (int *)NULL
);
2122 UNBLOCK_CHILD (oset
);
2126 r
= bgp_search (pid
);
2133 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid
);
2139 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
2141 BLOCK_CHILD (set
, oset
);
2142 job
= find_job (pid
, 0, NULL
);
2143 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2144 jobs
[job
]->flags
|= J_NOTIFIED
;
2145 UNBLOCK_CHILD (oset
);
2147 /* If running in posix mode, remove the job from the jobs table immediately */
2148 if (posixly_correct
)
2150 cleanup_dead_jobs ();
2157 /* Wait for all of the background processes started by this shell to finish. */
2159 wait_for_background_pids ()
2161 register int i
, r
, waited_for
;
2165 for (waited_for
= 0;;)
2167 BLOCK_CHILD (set
, oset
);
2169 /* find first running job; if none running in foreground, break */
2170 /* XXX could use js.j_firstj and js.j_lastj here */
2171 for (i
= 0; i
< js
.j_jobslots
; i
++)
2174 if (i
< js
.j_firstj
&& jobs
[i
])
2175 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
2176 if (i
> js
.j_lastj
&& jobs
[i
])
2177 itrace("wait_for_background_pids: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
2179 if (jobs
[i
] && RUNNING (i
) && IS_FOREGROUND (i
) == 0)
2182 if (i
== js
.j_jobslots
)
2184 UNBLOCK_CHILD (oset
);
2188 /* now wait for the last pid in that job. */
2189 pid
= find_last_pid (i
, 0);
2190 UNBLOCK_CHILD (oset
);
2192 errno
= 0; /* XXX */
2193 r
= wait_for_single_pid (pid
);
2196 /* If we're mistaken about job state, compensate. */
2197 if (errno
== ECHILD
)
2198 mark_all_jobs_as_dead ();
2204 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2205 `wait' is called with no arguments. */
2206 mark_dead_jobs_as_notified (1);
2207 cleanup_dead_jobs ();
2211 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2212 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2213 static SigHandler
*old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2215 static int wait_sigint_received
;
2216 static int child_caught_sigint
;
2217 static int waiting_for_child
;
2220 restore_sigint_handler ()
2222 if (old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
2224 set_signal_handler (SIGINT
, old_sigint_handler
);
2225 old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2226 waiting_for_child
= 0;
2230 /* Handle SIGINT while we are waiting for children in a script to exit.
2231 The `wait' builtin should be interruptible, but all others should be
2232 effectively ignored (i.e. not cause the shell to exit). */
2234 wait_sigint_handler (sig
)
2237 SigHandler
*sigint_handler
;
2239 if (interrupt_immediately
||
2240 (this_shell_builtin
&& this_shell_builtin
== wait_builtin
))
2242 last_command_exit_value
= EXECUTION_FAILURE
;
2243 restore_sigint_handler ();
2244 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2245 what POSIX.2 says (see builtins/wait.def for more info). */
2246 if (this_shell_builtin
&& this_shell_builtin
== wait_builtin
&&
2247 signal_is_trapped (SIGINT
) &&
2248 ((sigint_handler
= trap_to_sighandler (SIGINT
)) == trap_handler
))
2250 interrupt_immediately
= 0;
2251 trap_handler (SIGINT
); /* set pending_traps[SIGINT] */
2252 wait_signal_received
= SIGINT
;
2253 longjmp (wait_intr_buf
, 1);
2260 /* XXX - should this be interrupt_state? If it is, the shell will act
2261 as if it got the SIGINT interrupt. */
2262 if (waiting_for_child
)
2263 wait_sigint_received
= 1;
2266 last_command_exit_value
= 128+SIGINT
;
2267 restore_sigint_handler ();
2268 kill (getpid (), SIGINT
);
2271 /* Otherwise effectively ignore the SIGINT and allow the running job to
2277 process_exit_signal (status
)
2280 return (WIFSIGNALED (status
) ? WTERMSIG (status
) : 0);
2284 process_exit_status (status
)
2287 if (WIFSIGNALED (status
))
2288 return (128 + WTERMSIG (status
));
2289 else if (WIFSTOPPED (status
) == 0)
2290 return (WEXITSTATUS (status
));
2292 return (EXECUTION_SUCCESS
);
2296 job_signal_status (job
)
2299 register PROCESS
*p
;
2302 p
= jobs
[job
]->pipe
;
2306 if (WIFSIGNALED(s
) || WIFSTOPPED(s
))
2310 while (p
!= jobs
[job
]->pipe
);
2315 /* Return the exit status of the last process in the pipeline for job JOB.
2316 This is the exit status of the entire job. */
2318 raw_job_exit_status (job
)
2321 register PROCESS
*p
;
2328 p
= jobs
[job
]->pipe
;
2331 if (WSTATUS (p
->status
) != EXECUTION_SUCCESS
)
2332 fail
= WSTATUS(p
->status
);
2335 while (p
!= jobs
[job
]->pipe
);
2336 WSTATUS (ret
) = fail
;
2340 for (p
= jobs
[job
]->pipe
; p
->next
!= jobs
[job
]->pipe
; p
= p
->next
)
2345 /* Return the exit status of job JOB. This is the exit status of the last
2346 (rightmost) process in the job's pipeline, modified if the job was killed
2347 by a signal or stopped. */
2349 job_exit_status (job
)
2352 return (process_exit_status (raw_job_exit_status (job
)));
2356 job_exit_signal (job
)
2359 return (process_exit_signal (raw_job_exit_status (job
)));
2362 #define FIND_CHILD(pid, child) \
2365 child = find_pipeline (pid, 0, (int *)NULL); \
2368 give_terminal_to (shell_pgrp, 0); \
2369 UNBLOCK_CHILD (oset); \
2370 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2371 restore_sigint_handler (); \
2372 return (termination_state = 127); \
2377 /* Wait for pid (one of our children) to terminate, then
2378 return the termination state. Returns 127 if PID is not found in
2379 the jobs table. Returns -1 if waitchld() returns -1, indicating
2380 that there are no unwaited-for child processes. */
2385 int job
, termination_state
, r
;
2387 register PROCESS
*child
;
2390 /* In the case that this code is interrupted, and we longjmp () out of it,
2391 we are relying on the code in throw_to_top_level () to restore the
2392 top-level signal mask. */
2393 BLOCK_CHILD (set
, oset
);
2395 /* Ignore interrupts while waiting for a job run without job control
2396 to finish. We don't want the shell to exit if an interrupt is
2397 received, only if one of the jobs run is killed via SIGINT. If
2398 job control is not set, the job will be run in the same pgrp as
2399 the shell, and the shell will see any signals the job gets. In
2400 fact, we want this set every time the waiting shell and the waited-
2401 for process are in the same process group, including command
2404 /* This is possibly a race condition -- should it go in stop_pipeline? */
2405 wait_sigint_received
= child_caught_sigint
= 0;
2406 if (job_control
== 0 || (subshell_environment
&SUBSHELL_COMSUB
))
2408 old_sigint_handler
= set_signal_handler (SIGINT
, wait_sigint_handler
);
2409 waiting_for_child
= 0;
2410 if (old_sigint_handler
== SIG_IGN
)
2411 set_signal_handler (SIGINT
, old_sigint_handler
);
2414 termination_state
= last_command_exit_value
;
2416 if (interactive
&& job_control
== 0)
2418 /* Check for terminating signals and exit the shell if we receive one */
2421 /* If we say wait_for (), then we have a record of this child somewhere.
2422 If it and none of its peers are running, don't call waitchld(). */
2427 FIND_CHILD (pid
, child
);
2429 /* If this child is part of a job, then we are really waiting for the
2430 job to finish. Otherwise, we are waiting for the child to finish.
2431 We check for JDEAD in case the job state has been set by waitchld
2432 after receipt of a SIGCHLD. */
2434 job
= find_job (pid
, 0, NULL
);
2436 /* waitchld() takes care of setting the state of the job. If the job
2437 has already exited before this is called, sigchld_handler will have
2438 called waitchld and the state will be set to JDEAD. */
2440 if (PRUNNING(child
) || (job
!= NO_JOB
&& RUNNING (job
)))
2442 #if defined (WAITPID_BROKEN) /* SCOv4 */
2443 sigset_t suspend_set
;
2444 sigemptyset (&suspend_set
);
2445 sigsuspend (&suspend_set
);
2446 #else /* !WAITPID_BROKEN */
2447 # if defined (MUST_UNBLOCK_CHLD)
2448 struct sigaction act
, oact
;
2449 sigset_t nullset
, chldset
;
2451 sigemptyset (&nullset
);
2452 sigemptyset (&chldset
);
2453 sigprocmask (SIG_SETMASK
, &nullset
, &chldset
);
2454 act
.sa_handler
= SIG_DFL
;
2455 sigemptyset (&act
.sa_mask
);
2456 sigemptyset (&oact
.sa_mask
);
2458 sigaction (SIGCHLD
, &act
, &oact
);
2461 waiting_for_child
++;
2462 r
= waitchld (pid
, 1);
2463 waiting_for_child
--;
2464 # if defined (MUST_UNBLOCK_CHLD)
2465 sigaction (SIGCHLD
, &oact
, (struct sigaction
*)NULL
);
2466 sigprocmask (SIG_SETMASK
, &chldset
, (sigset_t
*)NULL
);
2469 if (r
== -1 && errno
== ECHILD
&& this_shell_builtin
== wait_builtin
)
2471 termination_state
= -1;
2472 goto wait_for_return
;
2475 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2476 there is something wrong. Somewhere, wait should have returned
2477 that child's pid. Mark the child as not running and the job,
2478 if it exists, as JDEAD. */
2479 if (r
== -1 && errno
== ECHILD
)
2481 child
->running
= PS_DONE
;
2482 WSTATUS (child
->status
) = 0; /* XXX -- can't find true status */
2483 js
.c_living
= 0; /* no living child processes */
2486 jobs
[job
]->state
= JDEAD
;
2491 #endif /* WAITPID_BROKEN */
2494 /* If the shell is interactive, and job control is disabled, see
2495 if the foreground process has died due to SIGINT and jump out
2496 of the wait loop if it has. waitchld has already restored the
2497 old SIGINT signal handler. */
2498 if (interactive
&& job_control
== 0)
2500 /* Check for terminating signals and exit the shell if we receive one */
2503 while (PRUNNING (child
) || (job
!= NO_JOB
&& RUNNING (job
)));
2505 /* Restore the original SIGINT signal handler before we return. */
2506 restore_sigint_handler ();
2508 /* The exit state of the command is either the termination state of the
2509 child, or the termination state of the job. If a job, the status
2510 of the last child in the pipeline is the significant one. If the command
2511 or job was terminated by a signal, note that value also. */
2512 termination_state
= (job
!= NO_JOB
) ? job_exit_status (job
)
2513 : process_exit_status (child
->status
);
2514 last_command_exit_signal
= (job
!= NO_JOB
) ? job_exit_signal (job
)
2515 : process_exit_signal (child
->status
);
2518 if ((job
!= NO_JOB
&& JOBSTATE (job
) == JSTOPPED
) || WIFSTOPPED (child
->status
))
2519 termination_state
= 128 + WSTOPSIG (child
->status
);
2521 if (job
== NO_JOB
|| IS_JOBCONTROL (job
))
2523 /* XXX - under what circumstances is a job not present in the jobs
2524 table (job == NO_JOB)?
2525 1. command substitution
2527 In the case of command substitution, at least, it's probably not
2528 the right thing to give the terminal to the shell's process group,
2529 even though there is code in subst.c:command_substitute to work
2533 $PROMPT_COMMAND execution
2534 process substitution
2538 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp
);
2540 give_terminal_to (shell_pgrp
, 0);
2543 /* If the command did not exit cleanly, or the job is just
2544 being stopped, then reset the tty state back to what it
2545 was before this command. Reset the tty state and notify
2546 the user of the job termination only if the shell is
2547 interactive. Clean up any dead jobs in either case. */
2550 if (interactive_shell
&& subshell_environment
== 0)
2552 /* This used to use `child->status'. That's wrong, however, for
2553 pipelines. `child' is the first process in the pipeline. It's
2554 likely that the process we want to check for abnormal termination
2555 or stopping is the last process in the pipeline, especially if
2556 it's long-lived and the first process is short-lived. Since we
2557 know we have a job here, we can check all the processes in this
2558 job's pipeline and see if one of them stopped or terminated due
2559 to a signal. We might want to change this later to just check
2560 the last process in the pipeline. If no process exits due to a
2561 signal, S is left as the status of the last job in the pipeline. */
2562 s
= job_signal_status (job
);
2564 if (WIFSIGNALED (s
) || WIFSTOPPED (s
))
2568 /* If the current job was stopped or killed by a signal, and
2569 the user has requested it, get a possibly new window size */
2570 if (check_window_size
&& (job
== js
.j_current
|| IS_FOREGROUND (job
)))
2571 get_new_window_size (0, (int *)0, (int *)0);
2576 /* If job control is enabled, the job was started with job
2577 control, the job was the foreground job, and it was killed
2578 by SIGINT, then print a newline to compensate for the kernel
2579 printing the ^C without a trailing newline. */
2580 if (job_control
&& IS_JOBCONTROL (job
) && IS_FOREGROUND (job
) &&
2581 WIFSIGNALED (s
) && WTERMSIG (s
) == SIGINT
)
2583 /* If SIGINT is not trapped and the shell is in a for, while,
2584 or until loop, act as if the shell received SIGINT as
2585 well, so the loop can be broken. This doesn't call the
2586 SIGINT signal handler; maybe it should. */
2587 if (signal_is_trapped (SIGINT
) == 0 && (loop_level
|| (shell_compatibility_level
> 32 && executing_list
)))
2596 else if ((subshell_environment
& (SUBSHELL_COMSUB
|SUBSHELL_PIPE
)) && wait_sigint_received
)
2598 /* If waiting for a job in a subshell started to do command
2599 substitution or to run a pipeline element that consists of
2600 something like a while loop or a for loop, simulate getting
2601 and being killed by the SIGINT to pass the status back to our
2603 s
= job_signal_status (job
);
2605 if (child_caught_sigint
== 0 && signal_is_trapped (SIGINT
) == 0)
2607 UNBLOCK_CHILD (oset
);
2608 old_sigint_handler
= set_signal_handler (SIGINT
, SIG_DFL
);
2609 if (old_sigint_handler
== SIG_IGN
)
2610 restore_sigint_handler ();
2612 kill (getpid (), SIGINT
);
2616 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2617 signal handler path */
2618 if (DEADJOB (job
) && IS_FOREGROUND (job
) /*&& subshell_environment == 0*/)
2621 /* If this job is dead, notify the user of the status. If the shell
2622 is interactive, this will display a message on the terminal. If
2623 the shell is not interactive, make sure we turn on the notify bit
2624 so we don't get an unwanted message about the job's termination,
2625 and so delete_job really clears the slot in the jobs table. */
2626 notify_and_cleanup ();
2631 UNBLOCK_CHILD (oset
);
2633 return (termination_state
);
2636 /* Wait for the last process in the pipeline for JOB. Returns whatever
2637 wait_for returns: the last process's termination state or -1 if there
2638 are no unwaited-for child processes or an error occurs. */
2647 BLOCK_CHILD(set
, oset
);
2648 if (JOBSTATE (job
) == JSTOPPED
)
2649 internal_warning (_("wait_for_job: job %d is stopped"), job
+1);
2651 pid
= find_last_pid (job
, 0);
2652 UNBLOCK_CHILD(oset
);
2655 /* POSIX.2: we can remove the job from the jobs table if we just waited
2657 BLOCK_CHILD (set
, oset
);
2658 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2659 jobs
[job
]->flags
|= J_NOTIFIED
;
2660 UNBLOCK_CHILD (oset
);
2665 /* Print info about dead jobs, and then delete them from the list
2666 of known jobs. This does not actually delete jobs when the
2667 shell is not interactive, because the dead jobs are not marked
2670 notify_and_cleanup ()
2672 if (jobs_list_frozen
)
2675 if (interactive
|| interactive_shell
== 0 || sourcelevel
)
2676 notify_of_job_status ();
2678 cleanup_dead_jobs ();
2681 /* Make dead jobs disappear from the jobs array without notification.
2682 This is used when the shell is not interactive. */
2686 mark_dead_jobs_as_notified (0);
2687 cleanup_dead_jobs ();
2690 /* Return the next closest (chronologically) job to JOB which is in
2691 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2692 there is no next recent job. */
2694 most_recent_job_in_state (job
, state
)
2698 register int i
, result
;
2701 BLOCK_CHILD (set
, oset
);
2703 for (result
= NO_JOB
, i
= job
- 1; i
>= 0; i
--)
2705 if (jobs
[i
] && (JOBSTATE (i
) == state
))
2712 UNBLOCK_CHILD (oset
);
2717 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2720 job_last_stopped (job
)
2723 return (most_recent_job_in_state (job
, JSTOPPED
));
2726 /* Return the newest *running* job older than JOB, or NO_JOB if not
2729 job_last_running (job
)
2732 return (most_recent_job_in_state (job
, JRUNNING
));
2735 /* Make JOB be the current job, and make previous be useful. Must be
2736 called with SIGCHLD blocked. */
2738 set_current_job (job
)
2743 if (js
.j_current
!= job
)
2745 js
.j_previous
= js
.j_current
;
2749 /* First choice for previous job is the old current job. */
2750 if (js
.j_previous
!= js
.j_current
&&
2751 js
.j_previous
!= NO_JOB
&&
2752 jobs
[js
.j_previous
] &&
2753 STOPPED (js
.j_previous
))
2756 /* Second choice: Newest stopped job that is older than
2759 if (STOPPED (js
.j_current
))
2761 candidate
= job_last_stopped (js
.j_current
);
2763 if (candidate
!= NO_JOB
)
2765 js
.j_previous
= candidate
;
2770 /* If we get here, there is either only one stopped job, in which case it is
2771 the current job and the previous job should be set to the newest running
2772 job, or there are only running jobs and the previous job should be set to
2773 the newest running job older than the current job. We decide on which
2774 alternative to use based on whether or not JOBSTATE(js.j_current) is
2777 candidate
= RUNNING (js
.j_current
) ? job_last_running (js
.j_current
)
2778 : job_last_running (js
.j_jobslots
);
2780 if (candidate
!= NO_JOB
)
2782 js
.j_previous
= candidate
;
2786 /* There is only a single job, and it is both `+' and `-'. */
2787 js
.j_previous
= js
.j_current
;
2790 /* Make current_job be something useful, if it isn't already. */
2792 /* Here's the deal: The newest non-running job should be `+', and the
2793 next-newest non-running job should be `-'. If there is only a single
2794 stopped job, the js.j_previous is the newest non-running job. If there
2795 are only running jobs, the newest running job is `+' and the
2796 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2803 if (js
.j_jobslots
&& js
.j_current
!= NO_JOB
&& jobs
[js
.j_current
] && STOPPED (js
.j_current
))
2804 candidate
= js
.j_current
;
2809 /* First choice: the previous job. */
2810 if (js
.j_previous
!= NO_JOB
&& jobs
[js
.j_previous
] && STOPPED (js
.j_previous
))
2811 candidate
= js
.j_previous
;
2813 /* Second choice: the most recently stopped job. */
2814 if (candidate
== NO_JOB
)
2815 candidate
= job_last_stopped (js
.j_jobslots
);
2817 /* Third choice: the newest running job. */
2818 if (candidate
== NO_JOB
)
2819 candidate
= job_last_running (js
.j_jobslots
);
2822 /* If we found a job to use, then use it. Otherwise, there
2823 are no jobs period. */
2824 if (candidate
!= NO_JOB
)
2825 set_current_job (candidate
);
2827 js
.j_current
= js
.j_previous
= NO_JOB
;
2830 /* Set up the job structures so we know the job and its processes are
2833 set_job_running (job
)
2836 register PROCESS
*p
;
2838 /* Each member of the pipeline is now running. */
2839 p
= jobs
[job
]->pipe
;
2843 if (WIFSTOPPED (p
->status
))
2844 p
->running
= PS_RUNNING
; /* XXX - could be PS_STOPPED */
2847 while (p
!= jobs
[job
]->pipe
);
2849 /* This means that the job is running. */
2850 JOBSTATE (job
) = JRUNNING
;
2853 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2854 start the job in the background. JOB is a zero-based index into
2855 JOBS. Returns -1 if it is unable to start a job, and the return
2856 status of the job otherwise. */
2858 start_job (job
, foreground
)
2859 int job
, foreground
;
2861 register PROCESS
*p
;
2862 int already_running
;
2865 static TTYSTRUCT save_stty
;
2867 BLOCK_CHILD (set
, oset
);
2871 internal_error (_("%s: job has terminated"), this_command_name
);
2872 UNBLOCK_CHILD (oset
);
2876 already_running
= RUNNING (job
);
2878 if (foreground
== 0 && already_running
)
2880 internal_error (_("%s: job %d already in background"), this_command_name
, job
+ 1);
2881 UNBLOCK_CHILD (oset
);
2882 return (0); /* XPG6/SUSv3 says this is not an error */
2885 wd
= current_working_directory ();
2887 /* You don't know about the state of this job. Do you? */
2888 jobs
[job
]->flags
&= ~J_NOTIFIED
;
2892 set_current_job (job
);
2893 jobs
[job
]->flags
|= J_FOREGROUND
;
2896 /* Tell the outside world what we're doing. */
2897 p
= jobs
[job
]->pipe
;
2899 if (foreground
== 0)
2901 /* POSIX.2 says `bg' doesn't give any indication about current or
2903 if (posixly_correct
== 0)
2904 s
= (job
== js
.j_current
) ? "+ ": ((job
== js
.j_previous
) ? "- " : " ");
2907 printf ("[%d]%s", job
+ 1, s
);
2913 p
->command
? p
->command
: "",
2914 p
->next
!= jobs
[job
]->pipe
? " | " : "");
2917 while (p
!= jobs
[job
]->pipe
);
2919 if (foreground
== 0)
2922 if (strcmp (wd
, jobs
[job
]->wd
) != 0)
2923 printf (" (wd: %s)", polite_directory_format (jobs
[job
]->wd
));
2928 if (already_running
== 0)
2929 set_job_running (job
);
2931 /* Save the tty settings before we start the job in the foreground. */
2935 save_stty
= shell_tty_info
;
2936 /* Give the terminal to this job. */
2937 if (IS_JOBCONTROL (job
))
2938 give_terminal_to (jobs
[job
]->pgrp
, 0);
2941 jobs
[job
]->flags
&= ~J_FOREGROUND
;
2943 /* If the job is already running, then don't bother jump-starting it. */
2944 if (already_running
== 0)
2946 jobs
[job
]->flags
|= J_NOTIFIED
;
2947 killpg (jobs
[job
]->pgrp
, SIGCONT
);
2955 pid
= find_last_pid (job
, 0);
2956 UNBLOCK_CHILD (oset
);
2957 st
= wait_for (pid
);
2958 shell_tty_info
= save_stty
;
2965 UNBLOCK_CHILD (oset
);
2970 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
2971 If PID does belong to a job, and the job is stopped, then CONTinue the
2972 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
2973 then kill the process group associated with PID. */
2975 kill_pid (pid
, sig
, group
)
2979 register PROCESS
*p
;
2980 int job
, result
, negative
;
2986 group
= negative
= 1;
2991 result
= EXECUTION_SUCCESS
;
2994 BLOCK_CHILD (set
, oset
);
2995 p
= find_pipeline (pid
, 0, &job
);
2999 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3001 /* Kill process in backquotes or one started without job control? */
3003 /* If we're passed a pid < -1, just call killpg and see what happens */
3004 if (negative
&& jobs
[job
]->pgrp
== shell_pgrp
)
3005 result
= killpg (pid
, sig
);
3006 /* If we're killing using job control notification, for example,
3007 without job control active, we have to do things ourselves. */
3008 else if (jobs
[job
]->pgrp
== shell_pgrp
)
3010 p
= jobs
[job
]->pipe
;
3013 if (PALIVE (p
) == 0)
3014 continue; /* avoid pid recycling problem */
3016 if (PEXITED (p
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
3017 kill (p
->pid
, SIGCONT
);
3020 while (p
!= jobs
[job
]->pipe
);
3024 result
= killpg (jobs
[job
]->pgrp
, sig
);
3025 if (p
&& STOPPED (job
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
3026 killpg (jobs
[job
]->pgrp
, SIGCONT
);
3027 /* If we're continuing a stopped job via kill rather than bg or
3028 fg, emulate the `bg' behavior. */
3029 if (p
&& STOPPED (job
) && (sig
== SIGCONT
))
3031 set_job_running (job
);
3032 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3033 jobs
[job
]->flags
|= J_NOTIFIED
;
3038 result
= killpg (pid
, sig
);
3040 UNBLOCK_CHILD (oset
);
3043 result
= kill (pid
, sig
);
3048 /* sigchld_handler () flushes at least one of the children that we are
3049 waiting for. It gets run when we have gotten a SIGCHLD signal. */
3051 sigchld_handler (sig
)
3057 REINSTALL_SIGCHLD_HANDLER
;
3060 if (queue_sigchld
== 0)
3061 n
= waitchld (-1, 0);
3066 /* waitchld() reaps dead or stopped children. It's called by wait_for and
3067 sigchld_handler, and runs until there aren't any children terminating any
3069 If BLOCK is 1, this is to be a blocking wait for a single child, although
3070 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
3071 the number of children reaped, or -1 if there are no unwaited-for child
3074 waitchld (wpid
, block
)
3081 int call_set_current
, last_stopped_job
, job
, children_exited
, waitpid_flags
;
3082 static int wcontinued
= WCONTINUED
; /* run-time fix for glibc problem */
3084 call_set_current
= children_exited
= 0;
3085 last_stopped_job
= NO_JOB
;
3089 /* We don't want to be notified about jobs stopping if job control
3090 is not active. XXX - was interactive_shell instead of job_control */
3091 waitpid_flags
= (job_control
&& subshell_environment
== 0)
3092 ? (WUNTRACED
|wcontinued
)
3094 if (sigchld
|| block
== 0)
3095 waitpid_flags
|= WNOHANG
;
3096 /* Check for terminating signals and exit the shell if we receive one */
3099 if (block
== 1 && queue_sigchld
== 0 && (waitpid_flags
& WNOHANG
) == 0)
3101 internal_warning (_("waitchld: turning on WNOHANG to avoid indefinite block"));
3102 waitpid_flags
|= WNOHANG
;
3105 pid
= WAITPID (-1, &status
, waitpid_flags
);
3107 /* WCONTINUED may be rejected by waitpid as invalid even when defined */
3108 if (wcontinued
&& pid
< 0 && errno
== EINVAL
)
3111 continue; /* jump back to the test and retry without WCONTINUED */
3114 /* The check for WNOHANG is to make sure we decrement sigchld only
3115 if it was non-zero before we called waitpid. */
3116 if (sigchld
> 0 && (waitpid_flags
& WNOHANG
))
3119 /* If waitpid returns -1 with errno == ECHILD, there are no more
3120 unwaited-for child processes of this shell. */
3121 if (pid
< 0 && errno
== ECHILD
)
3123 if (children_exited
== 0)
3129 /* If waitpid returns 0, there are running children. If it returns -1,
3130 the only other error POSIX says it can return is EINTR. */
3133 /* If waitpid returns -1/EINTR and the shell saw a SIGINT, then we
3134 assume the child has blocked or handled SIGINT. In that case, we
3135 require the child to actually die due to SIGINT to act on the
3136 SIGINT we received; otherwise we assume the child handled it and
3138 if (pid
< 0 && errno
== EINTR
&& wait_sigint_received
)
3139 child_caught_sigint
= 1;
3142 continue; /* jumps right to the test */
3144 /* If the child process did die due to SIGINT, forget our assumption
3145 that it caught or otherwise handled it. */
3146 if (WIFSIGNALED (status
) && WTERMSIG (status
) == SIGINT
)
3147 child_caught_sigint
= 0;
3149 /* children_exited is used to run traps on SIGCHLD. We don't want to
3150 run the trap if a process is just being continued. */
3151 if (WIFCONTINUED(status
) == 0)
3157 /* Locate our PROCESS for this pid. */
3158 child
= find_process (pid
, 1, &job
); /* want living procs only */
3160 #if defined (COPROCESS_SUPPORT)
3161 coproc_pidchk (pid
, status
);
3164 /* It is not an error to have a child terminate that we did
3165 not have a record of. This child could have been part of
3166 a pipeline in backquote substitution. Even so, I'm not
3167 sure child is ever non-zero. */
3170 if (WIFEXITED (status
) || WIFSIGNALED (status
))
3175 /* Remember status, and whether or not the process is running. */
3176 child
->status
= status
;
3177 child
->running
= WIFCONTINUED(status
) ? PS_RUNNING
: PS_DONE
;
3179 if (PEXITED (child
))
3189 call_set_current
+= set_job_status_and_cleanup (job
);
3192 last_stopped_job
= job
;
3193 else if (DEADJOB (job
) && last_stopped_job
== job
)
3194 last_stopped_job
= NO_JOB
;
3196 while ((sigchld
|| block
== 0) && pid
> (pid_t
)0);
3198 /* If a job was running and became stopped, then set the current
3199 job. Otherwise, don't change a thing. */
3200 if (call_set_current
)
3202 if (last_stopped_job
!= NO_JOB
)
3203 set_current_job (last_stopped_job
);
3208 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
3209 if (job_control
&& signal_is_trapped (SIGCHLD
) && children_exited
&&
3210 trap_list
[SIGCHLD
] != (char *)IGNORE_SIG
)
3212 if (posixly_correct
&& this_shell_builtin
&& this_shell_builtin
== wait_builtin
)
3214 interrupt_immediately
= 0;
3215 trap_handler (SIGCHLD
); /* set pending_traps[SIGCHLD] */
3216 wait_signal_received
= SIGCHLD
;
3217 longjmp (wait_intr_buf
, 1);
3220 run_sigchld_trap (children_exited
);
3223 /* We have successfully recorded the useful information about this process
3224 that has just changed state. If we notify asynchronously, and the job
3225 that this process belongs to is no longer running, then notify the user
3226 of that fact now. */
3227 if (asynchronous_notification
&& interactive
)
3228 notify_of_job_status ();
3230 return (children_exited
);
3233 /* Set the status of JOB and perform any necessary cleanup if the job is
3236 Currently, the cleanup activity is restricted to handling any SIGINT
3237 received while waiting for a foreground job to finish. */
3239 set_job_status_and_cleanup (job
)
3243 int tstatus
, job_state
, any_stopped
, any_tstped
, call_set_current
;
3244 SigHandler
*temp_handler
;
3246 child
= jobs
[job
]->pipe
;
3247 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3249 call_set_current
= 0;
3252 * COMPUTE JOB STATUS
3255 /* If all children are not running, but any of them is stopped, then
3256 the job is stopped, not dead. */
3257 job_state
= any_stopped
= any_tstped
= 0;
3260 job_state
|= PRUNNING (child
);
3262 if (PEXITED (child
) && (WIFSTOPPED (child
->status
)))
3264 /* Only checking for WIFSTOPPED now, not for PS_DONE */
3265 if (PSTOPPED (child
))
3269 any_tstped
|= interactive
&& job_control
&&
3270 (WSTOPSIG (child
->status
) == SIGTSTP
);
3272 child
= child
->next
;
3274 while (child
!= jobs
[job
]->pipe
);
3276 /* If job_state != 0, the job is still running, so don't bother with
3277 setting the process exit status and job state unless we're
3278 transitioning from stopped to running. */
3279 if (job_state
!= 0 && JOBSTATE(job
) != JSTOPPED
)
3286 /* The job is either stopped or dead. Set the state of the job accordingly. */
3289 jobs
[job
]->state
= JSTOPPED
;
3290 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3292 /* Suspending a job with SIGTSTP breaks all active loops. */
3293 if (any_tstped
&& loop_level
)
3294 breaking
= loop_level
;
3296 else if (job_state
!= 0) /* was stopped, now running */
3298 jobs
[job
]->state
= JRUNNING
;
3303 jobs
[job
]->state
= JDEAD
;
3307 if (IS_FOREGROUND (job
))
3311 /* If this job has a cleanup function associated with it, call it
3312 with `cleanarg' as the single argument, then set the function
3313 pointer to NULL so it is not inadvertently called twice. The
3314 cleanup function is responsible for deallocating cleanarg. */
3315 if (jobs
[job
]->j_cleanup
)
3317 (*jobs
[job
]->j_cleanup
) (jobs
[job
]->cleanarg
);
3318 jobs
[job
]->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
3325 * Currently, we just do special things if we got a SIGINT while waiting
3326 * for a foreground job to complete
3329 if (JOBSTATE (job
) == JDEAD
)
3331 /* If we're running a shell script and we get a SIGINT with a
3332 SIGINT trap handler, but the foreground job handles it and
3333 does not exit due to SIGINT, run the trap handler but do not
3334 otherwise act as if we got the interrupt. */
3335 if (wait_sigint_received
&& interactive_shell
== 0 &&
3336 child_caught_sigint
&& IS_FOREGROUND (job
) &&
3337 signal_is_trapped (SIGINT
))
3340 wait_sigint_received
= 0;
3341 last_command_exit_value
= process_exit_status (child
->status
);
3343 old_frozen
= jobs_list_frozen
;
3344 jobs_list_frozen
= 1;
3345 tstatus
= maybe_call_trap_handler (SIGINT
);
3346 jobs_list_frozen
= old_frozen
;
3349 /* If the foreground job is killed by SIGINT when job control is not
3350 active, we need to perform some special handling.
3352 The check of wait_sigint_received is a way to determine if the
3353 SIGINT came from the keyboard (in which case the shell has already
3354 seen it, and wait_sigint_received is non-zero, because keyboard
3355 signals are sent to process groups) or via kill(2) to the foreground
3356 process by another process (or itself). If the shell did receive the
3357 SIGINT, it needs to perform normal SIGINT processing. */
3358 else if (wait_sigint_received
&&
3359 child_caught_sigint
== 0 &&
3360 IS_FOREGROUND (job
) && IS_JOBCONTROL (job
) == 0)
3364 wait_sigint_received
= 0;
3366 /* If SIGINT is trapped, set the exit status so that the trap
3367 handler can see it. */
3368 if (signal_is_trapped (SIGINT
))
3369 last_command_exit_value
= process_exit_status (child
->status
);
3371 /* If the signal is trapped, let the trap handler get it no matter
3372 what and simply return if the trap handler returns.
3373 maybe_call_trap_handler() may cause dead jobs to be removed from
3374 the job table because of a call to execute_command. We work
3375 around this by setting JOBS_LIST_FROZEN. */
3376 old_frozen
= jobs_list_frozen
;
3377 jobs_list_frozen
= 1;
3378 tstatus
= maybe_call_trap_handler (SIGINT
);
3379 jobs_list_frozen
= old_frozen
;
3380 if (tstatus
== 0 && old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
3382 /* wait_sigint_handler () has already seen SIGINT and
3383 allowed the wait builtin to jump out. We need to
3384 call the original SIGINT handler, if necessary. If
3385 the original handler is SIG_DFL, we need to resend
3386 the signal to ourselves. */
3388 temp_handler
= old_sigint_handler
;
3390 /* Bogus. If we've reset the signal handler as the result
3391 of a trap caught on SIGINT, then old_sigint_handler
3392 will point to trap_handler, which now knows nothing about
3393 SIGINT (if we reset the sighandler to the default).
3394 In this case, we have to fix things up. What a crock. */
3395 if (temp_handler
== trap_handler
&& signal_is_trapped (SIGINT
) == 0)
3396 temp_handler
= trap_to_sighandler (SIGINT
);
3397 restore_sigint_handler ();
3398 if (temp_handler
== SIG_DFL
)
3399 termsig_handler (SIGINT
); /* XXX */
3400 else if (temp_handler
!= SIG_IGN
)
3401 (*temp_handler
) (SIGINT
);
3406 return call_set_current
;
3409 /* Build the array of values for the $PIPESTATUS variable from the set of
3410 exit statuses of all processes in the job J. */
3415 #if defined (ARRAY_VARS)
3417 register PROCESS
*p
;
3419 for (i
= 1, p
= jobs
[j
]->pipe
; p
->next
!= jobs
[j
]->pipe
; p
= p
->next
, i
++)
3424 pstatuses
= (int *)xrealloc (pstatuses
, i
* sizeof (int));
3431 pstatuses
[i
++] = process_exit_status (p
->status
);
3434 while (p
!= jobs
[j
]->pipe
);
3436 pstatuses
[i
] = -1; /* sentinel */
3437 set_pipestatus_array (pstatuses
, i
);
3442 run_sigchld_trap (nchild
)
3448 /* Turn off the trap list during the call to parse_and_execute ()
3449 to avoid potentially infinite recursive calls. Preserve the
3450 values of last_command_exit_value, last_made_pid, and the_pipeline
3451 around the execution of the trap commands. */
3452 trap_command
= savestring (trap_list
[SIGCHLD
]);
3454 begin_unwind_frame ("SIGCHLD trap");
3455 unwind_protect_int (last_command_exit_value
);
3456 unwind_protect_int (last_command_exit_signal
);
3457 unwind_protect_var (last_made_pid
);
3458 unwind_protect_int (interrupt_immediately
);
3459 unwind_protect_int (jobs_list_frozen
);
3460 unwind_protect_pointer (the_pipeline
);
3461 unwind_protect_pointer (subst_assign_varlist
);
3463 /* We have to add the commands this way because they will be run
3464 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
3465 to reference freed memory. */
3466 add_unwind_protect (xfree
, trap_command
);
3467 add_unwind_protect (maybe_set_sigchld_trap
, trap_command
);
3469 subst_assign_varlist
= (WORD_LIST
*)NULL
;
3470 the_pipeline
= (PROCESS
*)NULL
;
3472 set_impossible_sigchld_trap ();
3473 jobs_list_frozen
= 1;
3474 for (i
= 0; i
< nchild
; i
++)
3476 interrupt_immediately
= 1;
3477 parse_and_execute (savestring (trap_command
), "trap", SEVAL_NOHIST
|SEVAL_RESETLINE
);
3480 run_unwind_frame ("SIGCHLD trap");
3483 /* Function to call when you want to notify people of changes
3484 in job status. This prints out all jobs which are pending
3485 notification to stderr, and marks those printed as already
3486 notified, thus making them candidates for cleanup. */
3488 notify_of_job_status ()
3490 register int job
, termsig
;
3495 if (jobs
== 0 || js
.j_jobslots
== 0)
3501 sigaddset (&set
, SIGCHLD
);
3502 sigaddset (&set
, SIGTTOU
);
3503 sigemptyset (&oset
);
3504 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3509 /* XXX could use js.j_firstj here */
3510 for (job
= 0, dir
= (char *)NULL
; job
< js
.j_jobslots
; job
++)
3512 if (jobs
[job
] && IS_NOTIFIED (job
) == 0)
3514 s
= raw_job_exit_status (job
);
3515 termsig
= WTERMSIG (s
);
3517 /* POSIX.2 says we have to hang onto the statuses of at most the
3518 last CHILD_MAX background processes if the shell is running a
3519 script. If the shell is running a script, either from a file
3520 or standard input, don't print anything unless the job was
3521 killed by a signal. */
3522 if (startup_state
== 0 && WIFSIGNALED (s
) == 0 &&
3523 ((DEADJOB (job
) && IS_FOREGROUND (job
) == 0) || STOPPED (job
)))
3527 /* If job control is disabled, don't print the status messages.
3528 Mark dead jobs as notified so that they get cleaned up. If
3529 startup_state == 2, we were started to run `-c command', so
3530 don't print anything. */
3531 if ((job_control
== 0 && interactive_shell
) || startup_state
== 2)
3533 /* If job control is disabled, don't print the status messages.
3534 Mark dead jobs as notified so that they get cleaned up. If
3535 startup_state == 2 and subshell_environment has the
3536 SUBSHELL_COMSUB bit turned on, we were started to run a command
3537 substitution, so don't print anything. */
3538 if ((job_control
== 0 && interactive_shell
) ||
3539 (startup_state
== 2 && (subshell_environment
& SUBSHELL_COMSUB
)))
3542 /* POSIX.2 compatibility: if the shell is not interactive,
3543 hang onto the job corresponding to the last asynchronous
3544 pid until the user has been notified of its status or does
3546 if (DEADJOB (job
) && (interactive_shell
|| (find_last_pid (job
, 0) != last_asynchronous_pid
)))
3547 jobs
[job
]->flags
|= J_NOTIFIED
;
3551 /* Print info on jobs that are running in the background,
3552 and on foreground jobs that were killed by anything
3553 except SIGINT (and possibly SIGPIPE). */
3554 switch (JOBSTATE (job
))
3557 if (interactive_shell
== 0 && termsig
&& WIFSIGNALED (s
) &&
3558 termsig
!= SIGINT
&&
3559 #if defined (DONT_REPORT_SIGPIPE)
3560 termsig
!= SIGPIPE
&&
3562 signal_is_trapped (termsig
) == 0)
3564 /* Don't print `0' for a line number. */
3565 fprintf (stderr
, _("%s: line %d: "), get_name_for_error (), (line_number
== 0) ? 1 : line_number
);
3566 pretty_print_job (job
, JLIST_NONINTERACTIVE
, stderr
);
3568 else if (IS_FOREGROUND (job
))
3570 #if !defined (DONT_REPORT_SIGPIPE)
3571 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
)
3573 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
&& termsig
!= SIGPIPE
)
3576 fprintf (stderr
, "%s", j_strsignal (termsig
));
3579 fprintf (stderr
, _(" (core dumped)"));
3581 fprintf (stderr
, "\n");
3584 else if (job_control
) /* XXX job control test added */
3587 dir
= current_working_directory ();
3588 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3589 if (dir
&& strcmp (dir
, jobs
[job
]->wd
) != 0)
3591 _("(wd now: %s)\n"), polite_directory_format (dir
));
3594 jobs
[job
]->flags
|= J_NOTIFIED
;
3598 fprintf (stderr
, "\n");
3600 dir
= current_working_directory ();
3601 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3602 if (dir
&& (strcmp (dir
, jobs
[job
]->wd
) != 0))
3604 _("(wd now: %s)\n"), polite_directory_format (dir
));
3605 jobs
[job
]->flags
|= J_NOTIFIED
;
3613 programming_error ("notify_of_job_status");
3618 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
3623 /* Initialize the job control mechanism, and set up the tty stuff. */
3625 initialize_job_control (force
)
3632 shell_pgrp
= getpgid (0);
3634 if (shell_pgrp
== -1)
3636 sys_error (_("initialize_job_control: getpgrp failed"));
3640 /* We can only have job control if we are interactive. */
3641 if (interactive
== 0)
3644 original_pgrp
= NO_PID
;
3645 shell_tty
= fileno (stderr
);
3651 /* If forced_interactive is set, we skip the normal check that stderr
3652 is attached to a tty, so we need to check here. If it's not, we
3653 need to see whether we have a controlling tty by opening /dev/tty,
3654 since trying to use job control tty pgrp manipulations on a non-tty
3655 is going to fail. */
3656 if (forced_interactive
&& isatty (fileno (stderr
)) == 0)
3657 shell_tty
= open ("/dev/tty", O_RDWR
|O_NONBLOCK
);
3659 /* Get our controlling terminal. If job_control is set, or
3660 interactive is set, then this is an interactive shell no
3661 matter where fd 2 is directed. */
3662 if (shell_tty
== -1)
3663 shell_tty
= dup (fileno (stderr
)); /* fd 2 */
3665 shell_tty
= move_to_high_fd (shell_tty
, 1, -1);
3667 /* Compensate for a bug in systems that compiled the BSD
3668 rlogind with DEBUG defined, like NeXT and Alliant. */
3669 if (shell_pgrp
== 0)
3671 shell_pgrp
= getpid ();
3672 setpgid (0, shell_pgrp
);
3673 tcsetpgrp (shell_tty
, shell_pgrp
);
3676 while ((terminal_pgrp
= tcgetpgrp (shell_tty
)) != -1)
3678 if (shell_pgrp
!= terminal_pgrp
)
3682 ottin
= set_signal_handler(SIGTTIN
, SIG_DFL
);
3684 set_signal_handler (SIGTTIN
, ottin
);
3690 if (terminal_pgrp
== -1)
3693 /* Make sure that we are using the new line discipline. */
3694 if (set_new_line_discipline (shell_tty
) < 0)
3696 sys_error (_("initialize_job_control: line discipline"));
3701 original_pgrp
= shell_pgrp
;
3702 shell_pgrp
= getpid ();
3704 if ((original_pgrp
!= shell_pgrp
) && (setpgid (0, shell_pgrp
) < 0))
3706 sys_error (_("initialize_job_control: setpgid"));
3707 shell_pgrp
= original_pgrp
;
3712 /* If (and only if) we just set our process group to our pid,
3713 thereby becoming a process group leader, and the terminal
3714 is not in the same process group as our (new) process group,
3715 then set the terminal's process group to our (new) process
3716 group. If that fails, set our process group back to what it
3717 was originally (so we can still read from the terminal) and
3718 turn off job control. */
3719 if (shell_pgrp
!= original_pgrp
&& shell_pgrp
!= terminal_pgrp
)
3721 if (give_terminal_to (shell_pgrp
, 0) < 0)
3724 setpgid (0, original_pgrp
);
3725 shell_pgrp
= original_pgrp
;
3730 if (job_control
&& ((t
= tcgetpgrp (shell_tty
)) == -1 || t
!= shell_pgrp
))
3734 sys_error (_("cannot set terminal process group (%d)"), t
);
3738 if (job_control
== 0)
3739 internal_error (_("no job control in this shell"));
3742 if (shell_tty
!= fileno (stderr
))
3743 SET_CLOSE_ON_EXEC (shell_tty
);
3745 set_signal_handler (SIGCHLD
, sigchld_handler
);
3747 change_flag ('m', job_control
? '-' : '+');
3752 if (js
.c_childmax
< 0)
3753 js
.c_childmax
= getmaxchild ();
3754 if (js
.c_childmax
< 0)
3755 js
.c_childmax
= DEFAULT_CHILD_MAX
;
3762 debug_print_pgrps ()
3764 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3765 (long)original_pgrp
, (long)shell_pgrp
, (long)terminal_pgrp
);
3766 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3767 shell_tty
, (long)tcgetpgrp (shell_tty
), (long)getpgid(0));
3771 /* Set the line discipline to the best this system has to offer.
3772 Return -1 if this is not possible. */
3774 set_new_line_discipline (tty
)
3777 #if defined (NEW_TTY_DRIVER)
3780 if (ioctl (tty
, TIOCGETD
, &ldisc
) < 0)
3783 if (ldisc
!= NTTYDISC
)
3787 if (ioctl (tty
, TIOCSETD
, &ldisc
) < 0)
3791 #endif /* NEW_TTY_DRIVER */
3793 #if defined (TERMIO_TTY_DRIVER)
3794 # if defined (TERMIO_LDISC) && (NTTYDISC)
3795 if (ioctl (tty
, TCGETA
, &shell_tty_info
) < 0)
3798 if (shell_tty_info
.c_line
!= NTTYDISC
)
3800 shell_tty_info
.c_line
= NTTYDISC
;
3801 if (ioctl (tty
, TCSETAW
, &shell_tty_info
) < 0)
3804 # endif /* TERMIO_LDISC && NTTYDISC */
3806 #endif /* TERMIO_TTY_DRIVER */
3808 #if defined (TERMIOS_TTY_DRIVER)
3809 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3810 if (tcgetattr (tty
, &shell_tty_info
) < 0)
3813 if (shell_tty_info
.c_line
!= NTTYDISC
)
3815 shell_tty_info
.c_line
= NTTYDISC
;
3816 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
3819 # endif /* TERMIOS_LDISC && NTTYDISC */
3821 #endif /* TERMIOS_TTY_DRIVER */
3823 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3828 /* Setup this shell to handle C-C, etc. */
3830 initialize_job_signals ()
3834 set_signal_handler (SIGINT
, sigint_sighandler
);
3835 set_signal_handler (SIGTSTP
, SIG_IGN
);
3836 set_signal_handler (SIGTTOU
, SIG_IGN
);
3837 set_signal_handler (SIGTTIN
, SIG_IGN
);
3839 else if (job_control
)
3841 old_tstp
= set_signal_handler (SIGTSTP
, sigstop_sighandler
);
3842 old_ttin
= set_signal_handler (SIGTTIN
, sigstop_sighandler
);
3843 old_ttou
= set_signal_handler (SIGTTOU
, sigstop_sighandler
);
3845 /* Leave these things alone for non-interactive shells without job
3849 /* Here we handle CONT signals. */
3851 sigcont_sighandler (sig
)
3854 initialize_job_signals ();
3855 set_signal_handler (SIGCONT
, old_cont
);
3856 kill (getpid (), SIGCONT
);
3861 /* Here we handle stop signals while we are running not as a login shell. */
3863 sigstop_sighandler (sig
)
3866 set_signal_handler (SIGTSTP
, old_tstp
);
3867 set_signal_handler (SIGTTOU
, old_ttou
);
3868 set_signal_handler (SIGTTIN
, old_ttin
);
3870 old_cont
= set_signal_handler (SIGCONT
, sigcont_sighandler
);
3872 give_terminal_to (shell_pgrp
, 0);
3874 kill (getpid (), sig
);
3879 /* Give the terminal to PGRP. */
3881 give_terminal_to (pgrp
, force
)
3889 if (job_control
|| force
)
3892 sigaddset (&set
, SIGTTOU
);
3893 sigaddset (&set
, SIGTTIN
);
3894 sigaddset (&set
, SIGTSTP
);
3895 sigaddset (&set
, SIGCHLD
);
3896 sigemptyset (&oset
);
3897 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3899 if (tcsetpgrp (shell_tty
, pgrp
) < 0)
3901 /* Maybe we should print an error message? */
3903 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
3904 shell_tty
, (long)getpid(), (long)pgrp
);
3910 terminal_pgrp
= pgrp
;
3911 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
3920 /* Give terminal to NPGRP iff it's currently owned by OPGRP. FLAGS are the
3921 flags to pass to give_terminal_to(). */
3923 maybe_give_terminal_to (opgrp
, npgrp
, flags
)
3929 tpgrp
= tcgetpgrp (shell_tty
);
3930 if (tpgrp
< 0 && errno
== ENOTTY
)
3934 terminal_pgrp
= npgrp
;
3937 else if (tpgrp
!= opgrp
)
3940 internal_warning ("maybe_give_terminal_to: terminal pgrp == %d shell pgrp = %d new pgrp = %d", tpgrp
, opgrp
, npgrp
);
3945 return (give_terminal_to (npgrp
, flags
));
3948 /* Clear out any jobs in the job array. This is intended to be used by
3949 children of the shell, who should not have any job structures as baggage
3950 when they start executing (forking subshells for parenthesized execution
3951 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
3952 is nonzero, only running jobs are removed from the table. */
3954 delete_all_jobs (running_only
)
3960 BLOCK_CHILD (set
, oset
);
3962 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
3965 js
.j_current
= js
.j_previous
= NO_JOB
;
3967 /* XXX could use js.j_firstj here */
3968 for (i
= 0; i
< js
.j_jobslots
; i
++)
3971 if (i
< js
.j_firstj
&& jobs
[i
])
3972 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3973 if (i
> js
.j_lastj
&& jobs
[i
])
3974 itrace("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
3976 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
3977 delete_job (i
, DEL_WARNSTOPPED
);
3979 if (running_only
== 0)
3981 free ((char *)jobs
);
3983 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
3987 if (running_only
== 0)
3990 UNBLOCK_CHILD (oset
);
3993 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
3994 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
3996 nohup_all_jobs (running_only
)
4002 BLOCK_CHILD (set
, oset
);
4006 /* XXX could use js.j_firstj here */
4007 for (i
= 0; i
< js
.j_jobslots
; i
++)
4008 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
4012 UNBLOCK_CHILD (oset
);
4021 /* This really counts all non-dead jobs. */
4022 BLOCK_CHILD (set
, oset
);
4023 /* XXX could use js.j_firstj here */
4024 for (i
= n
= 0; i
< js
.j_jobslots
; i
++)
4027 if (i
< js
.j_firstj
&& jobs
[i
])
4028 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4029 if (i
> js
.j_lastj
&& jobs
[i
])
4030 itrace("count_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4032 if (jobs
[i
] && DEADJOB(i
) == 0)
4035 UNBLOCK_CHILD (oset
);
4040 mark_all_jobs_as_dead ()
4045 if (js
.j_jobslots
== 0)
4048 BLOCK_CHILD (set
, oset
);
4050 /* XXX could use js.j_firstj here */
4051 for (i
= 0; i
< js
.j_jobslots
; i
++)
4054 jobs
[i
]->state
= JDEAD
;
4058 UNBLOCK_CHILD (oset
);
4061 /* Mark all dead jobs as notified, so delete_job () cleans them out
4062 of the job table properly. POSIX.2 says we need to save the
4063 status of the last CHILD_MAX jobs, so we count the number of dead
4064 jobs and mark only enough as notified to save CHILD_MAX statuses. */
4066 mark_dead_jobs_as_notified (force
)
4069 register int i
, ndead
, ndeadproc
;
4072 if (js
.j_jobslots
== 0)
4075 BLOCK_CHILD (set
, oset
);
4077 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
4078 around; just run through the array. */
4081 /* XXX could use js.j_firstj here */
4082 for (i
= 0; i
< js
.j_jobslots
; i
++)
4084 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
4085 jobs
[i
]->flags
|= J_NOTIFIED
;
4087 UNBLOCK_CHILD (oset
);
4091 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
4092 array with the corresponding not marked as notified. This is a better
4093 way to avoid pid aliasing and reuse problems than keeping the POSIX-
4094 mandated CHILD_MAX jobs around. delete_job() takes care of keeping the
4095 bgpids list regulated. */
4097 /* Count the number of dead jobs */
4098 /* XXX could use js.j_firstj here */
4099 for (i
= ndead
= ndeadproc
= 0; i
< js
.j_jobslots
; i
++)
4102 if (i
< js
.j_firstj
&& jobs
[i
])
4103 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4104 if (i
> js
.j_lastj
&& jobs
[i
])
4105 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4107 if (jobs
[i
] && DEADJOB (i
))
4110 ndeadproc
+= processes_in_job (i
);
4115 if (ndeadproc
!= js
.c_reaped
)
4116 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc
, js
.c_reaped
);
4117 if (ndead
!= js
.j_ndead
)
4118 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead
, js
.j_ndead
);
4121 if (js
.c_childmax
< 0)
4122 js
.c_childmax
= getmaxchild ();
4123 if (js
.c_childmax
< 0)
4124 js
.c_childmax
= DEFAULT_CHILD_MAX
;
4126 /* Don't do anything if the number of dead processes is less than CHILD_MAX
4127 and we're not forcing a cleanup. */
4128 if (ndeadproc
<= js
.c_childmax
)
4130 UNBLOCK_CHILD (oset
);
4135 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js
.c_childmax
, ndead
, ndeadproc
);
4138 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
4139 the list. This isn't exactly right yet; changes need to be made
4140 to stop_pipeline so we don't mark the newer jobs after we've
4141 created CHILD_MAX slots in the jobs array. This needs to be
4142 integrated with a way to keep the jobs array from growing without
4143 bound. Maybe we wrap back around to 0 after we reach some max
4144 limit, and there are sufficient job slots free (keep track of total
4145 size of jobs array (js.j_jobslots) and running count of number of jobs
4146 in jobs array. Then keep a job index corresponding to the `oldest job'
4147 and start this loop there, wrapping around as necessary. In effect,
4148 we turn the list into a circular buffer. */
4149 /* XXX could use js.j_firstj here */
4150 for (i
= 0; i
< js
.j_jobslots
; i
++)
4152 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
4155 if (i
< js
.j_firstj
&& jobs
[i
])
4156 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
4157 if (i
> js
.j_lastj
&& jobs
[i
])
4158 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
4160 /* If marking this job as notified would drop us down below
4161 child_max, don't mark it so we can keep at least child_max
4162 statuses. XXX -- need to check what Posix actually says
4163 about keeping statuses. */
4164 if ((ndeadproc
-= processes_in_job (i
)) <= js
.c_childmax
)
4166 jobs
[i
]->flags
|= J_NOTIFIED
;
4170 UNBLOCK_CHILD (oset
);
4173 /* Here to allow other parts of the shell (like the trap stuff) to
4174 freeze and unfreeze the jobs list. */
4178 jobs_list_frozen
= 1;
4182 unfreeze_jobs_list ()
4184 jobs_list_frozen
= 0;
4187 /* Allow or disallow job control to take place. Returns the old value
4190 set_job_control (arg
)
4198 /* If we're turning on job control, reset pipeline_pgrp so make_child will
4199 put new child processes into the right pgrp */
4200 if (job_control
!= old
&& job_control
)
4206 /* Turn off all traces of job control. This is run by children of the shell
4207 which are going to do shellsy things, like wait (), etc. */
4209 without_job_control ()
4211 stop_making_children ();
4213 #if defined (PGRP_PIPE)
4214 sh_closepipe (pgrp_pipe
);
4216 delete_all_jobs (0);
4217 set_job_control (0);
4220 /* If this shell is interactive, terminate all stopped jobs and
4221 restore the original terminal process group. This is done
4222 before the `exec' builtin calls shell_execve. */
4226 if (interactive_shell
) /* XXX - should it be interactive? */
4228 terminate_stopped_jobs ();
4230 if (original_pgrp
>= 0)
4231 give_terminal_to (original_pgrp
, 1);
4234 if (original_pgrp
>= 0)
4235 setpgid (0, original_pgrp
);
4238 /* Restart job control by closing shell tty and reinitializing. This is
4239 called after an exec fails in an interactive shell and we do not exit. */
4241 restart_job_control ()
4243 if (shell_tty
!= -1)
4245 initialize_job_control (0);
4248 /* Set the handler to run when the shell receives a SIGCHLD signal. */
4250 set_sigchld_handler ()
4252 set_signal_handler (SIGCHLD
, sigchld_handler
);
4255 #if defined (PGRP_PIPE)
4256 /* Read from the read end of a pipe. This is how the process group leader
4257 blocks until all of the processes in a pipeline have been made. */
4272 while (read (pp
[0], &ch
, 1) == -1 && errno
== EINTR
)
4277 /* Functional interface closes our local-to-job-control pipes. */
4281 sh_closepipe (pgrp_pipe
);
4285 save_pgrp_pipe (p
, clear
)
4289 p
[0] = pgrp_pipe
[0];
4290 p
[1] = pgrp_pipe
[1];
4292 pgrp_pipe
[0] = pgrp_pipe
[1] = -1;
4296 restore_pgrp_pipe (p
)
4299 pgrp_pipe
[0] = p
[0];
4300 pgrp_pipe
[1] = p
[1];
4303 #endif /* PGRP_PIPE */