]>
Commit | Line | Data |
---|---|---|
3185942a | 1 | /* jobs.c - functions that make children, remember them, and handle their termination. */ |
726f6388 | 2 | |
ccc6cda3 JA |
3 | /* This file works with both POSIX and BSD systems. It implements job |
4 | control. */ | |
726f6388 | 5 | |
495aee44 | 6 | /* Copyright (C) 1989-2010 Free Software Foundation, Inc. |
726f6388 JA |
7 | |
8 | This file is part of GNU Bash, the Bourne Again SHell. | |
9 | ||
3185942a JA |
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. | |
726f6388 | 14 | |
3185942a JA |
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. | |
726f6388 | 19 | |
3185942a JA |
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/>. | |
22 | */ | |
726f6388 | 23 | |
726f6388 JA |
24 | #include "config.h" |
25 | ||
726f6388 JA |
26 | #include "bashtypes.h" |
27 | #include "trap.h" | |
28 | #include <stdio.h> | |
29 | #include <signal.h> | |
30 | #include <errno.h> | |
31 | ||
ccc6cda3 JA |
32 | #if defined (HAVE_UNISTD_H) |
33 | # include <unistd.h> | |
34 | #endif | |
726f6388 | 35 | |
f73dda09 | 36 | #include "posixtime.h" |
ccc6cda3 | 37 | |
cce855bc | 38 | #if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE) |
ccc6cda3 | 39 | # include <sys/resource.h> |
cce855bc | 40 | #endif /* !_POSIX_VERSION && HAVE_SYS_RESOURCE_H && HAVE_WAIT3 && !RLIMTYPE */ |
726f6388 | 41 | |
b80f6443 JA |
42 | #if defined (HAVE_SYS_FILE_H) |
43 | # include <sys/file.h> | |
44 | #endif | |
45 | ||
726f6388 JA |
46 | #include "filecntl.h" |
47 | #include <sys/ioctl.h> | |
48 | #include <sys/param.h> | |
49 | ||
50 | #if defined (BUFFERED_INPUT) | |
51 | # include "input.h" | |
52 | #endif | |
53 | ||
ccc6cda3 | 54 | /* Need to include this up here for *_TTY_DRIVER definitions. */ |
bb70624e | 55 | #include "shtty.h" |
726f6388 JA |
56 | |
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 */ | |
60 | ||
726f6388 | 61 | /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */ |
726f6388 JA |
62 | #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER) |
63 | # include <bsdtty.h> | |
64 | #endif /* hpux && !TERMIOS_TTY_DRIVER */ | |
65 | ||
66 | #include "bashansi.h" | |
b80f6443 | 67 | #include "bashintl.h" |
726f6388 JA |
68 | #include "shell.h" |
69 | #include "jobs.h" | |
3185942a | 70 | #include "execute_cmd.h" |
ccc6cda3 | 71 | #include "flags.h" |
726f6388 JA |
72 | |
73 | #include "builtins/builtext.h" | |
74 | #include "builtins/common.h" | |
75 | ||
726f6388 JA |
76 | #if !defined (errno) |
77 | extern int errno; | |
78 | #endif /* !errno */ | |
79 | ||
495aee44 CR |
80 | #if !defined (HAVE_KILLPG) |
81 | extern int killpg __P((pid_t, int)); | |
82 | #endif | |
83 | ||
7117c2d2 | 84 | #define DEFAULT_CHILD_MAX 32 |
0628567a JA |
85 | #if !defined (DEBUG) |
86 | #define MAX_JOBS_IN_ARRAY 4096 /* production */ | |
87 | #else | |
88 | #define MAX_JOBS_IN_ARRAY 128 /* testing */ | |
89 | #endif | |
90 | ||
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 */ | |
b72432fd | 94 | |
ccc6cda3 JA |
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. */ | |
98 | ||
99 | #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION) | |
100 | # define WAITPID(pid, statusp, options) \ | |
101 | wait3 ((union wait *)statusp, options, (struct rusage *)0) | |
102 | #else | |
103 | # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID) | |
104 | # define WAITPID(pid, statusp, options) \ | |
105 | waitpid ((pid_t)pid, statusp, options) | |
106 | # else | |
107 | # if defined (HAVE_WAIT3) | |
108 | # define WAITPID(pid, statusp, options) \ | |
109 | wait3 (statusp, options, (struct rusage *)0) | |
110 | # else | |
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) */ | |
116 | ||
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 () | |
121 | #else | |
122 | # define getpgid(p) getpgrp (p) | |
123 | #endif /* !GETPGRP_VOID */ | |
124 | ||
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) | |
129 | #else | |
130 | # define REINSTALL_SIGCHLD_HANDLER | |
131 | #endif /* !MUST_REINSTALL_SIGHANDLERS */ | |
132 | ||
f73dda09 | 133 | /* Some systems let waitpid(2) tell callers about stopped children. */ |
95732b49 JA |
134 | #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN) |
135 | # undef WCONTINUED | |
f73dda09 | 136 | # define WCONTINUED 0 |
b80f6443 JA |
137 | #endif |
138 | #if !defined (WIFCONTINUED) | |
f73dda09 JA |
139 | # define WIFCONTINUED(s) (0) |
140 | #endif | |
141 | ||
ccc6cda3 JA |
142 | /* The number of additional slots to allocate when we run out. */ |
143 | #define JOB_SLOTS 8 | |
144 | ||
f73dda09 JA |
145 | typedef int sh_job_map_func_t __P((JOB *, int, int, int)); |
146 | ||
726f6388 | 147 | /* Variables used here but defined in other files. */ |
7117c2d2 | 148 | extern int subshell_environment, line_number; |
f73dda09 | 149 | extern int posixly_correct, shell_level; |
b80f6443 | 150 | extern int last_command_exit_value, last_command_exit_signal; |
726f6388 | 151 | extern int loop_level, breaking; |
3185942a | 152 | extern int executing_list; |
28ef6c31 | 153 | extern int sourcelevel; |
0628567a | 154 | extern int running_trap; |
f73dda09 | 155 | extern sh_builtin_func_t *this_shell_builtin; |
726f6388 JA |
156 | extern char *shell_name, *this_command_name; |
157 | extern sigset_t top_level_mask; | |
bb70624e | 158 | extern procenv_t wait_intr_buf; |
7117c2d2 | 159 | extern int wait_signal_received; |
bb70624e | 160 | extern WORD_LIST *subst_assign_varlist; |
726f6388 | 161 | |
95732b49 JA |
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 }; | |
164 | ||
165 | struct bgpids bgpids = { 0, 0, 0 }; | |
166 | ||
726f6388 JA |
167 | /* The array of known jobs. */ |
168 | JOB **jobs = (JOB **)NULL; | |
169 | ||
95732b49 | 170 | #if 0 |
726f6388 JA |
171 | /* The number of slots currently allocated to JOBS. */ |
172 | int job_slots = 0; | |
95732b49 | 173 | #endif |
726f6388 | 174 | |
726f6388 JA |
175 | /* The controlling tty for this shell. */ |
176 | int shell_tty = -1; | |
177 | ||
178 | /* The shell's process group. */ | |
179 | pid_t shell_pgrp = NO_PID; | |
180 | ||
181 | /* The terminal's process group. */ | |
182 | pid_t terminal_pgrp = NO_PID; | |
183 | ||
184 | /* The process group of the shell's parent. */ | |
185 | pid_t original_pgrp = NO_PID; | |
186 | ||
187 | /* The process group of the pipeline currently being made. */ | |
188 | pid_t pipeline_pgrp = (pid_t)0; | |
189 | ||
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 }; | |
195 | #endif | |
ccc6cda3 | 196 | |
95732b49 | 197 | #if 0 |
726f6388 JA |
198 | /* The job which is current; i.e. the one that `%+' stands for. */ |
199 | int current_job = NO_JOB; | |
200 | ||
201 | /* The previous job; i.e. the one that `%-' stands for. */ | |
202 | int previous_job = NO_JOB; | |
95732b49 | 203 | #endif |
726f6388 JA |
204 | |
205 | /* Last child made by the shell. */ | |
206 | pid_t last_made_pid = NO_PID; | |
207 | ||
208 | /* Pid of the last asynchronous child. */ | |
209 | pid_t last_asynchronous_pid = NO_PID; | |
210 | ||
211 | /* The pipeline currently being built. */ | |
212 | PROCESS *the_pipeline = (PROCESS *)NULL; | |
213 | ||
214 | /* If this is non-zero, do job control. */ | |
215 | int job_control = 1; | |
216 | ||
217 | /* Call this when you start making children. */ | |
218 | int already_making_children = 0; | |
219 | ||
ccc6cda3 JA |
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; | |
223 | ||
726f6388 | 224 | /* Functions local to this file. */ |
f73dda09 | 225 | |
f73dda09 JA |
226 | static sighandler wait_sigint_handler __P((int)); |
227 | static sighandler sigchld_handler __P((int)); | |
f73dda09 JA |
228 | static sighandler sigcont_sighandler __P((int)); |
229 | static sighandler sigstop_sighandler __P((int)); | |
230 | ||
231 | static int waitchld __P((pid_t, int)); | |
232 | ||
7117c2d2 | 233 | static PROCESS *find_pipeline __P((pid_t, int, int *)); |
95732b49 | 234 | static PROCESS *find_process __P((pid_t, int, int *)); |
f73dda09 JA |
235 | |
236 | static char *current_working_directory __P((void)); | |
237 | static char *job_working_directory __P((void)); | |
b80f6443 | 238 | static char *j_strsignal __P((int)); |
f73dda09 JA |
239 | static char *printable_job_status __P((int, PROCESS *, int)); |
240 | ||
95732b49 | 241 | static PROCESS *find_last_proc __P((int, int)); |
7117c2d2 | 242 | static pid_t find_last_pid __P((int, int)); |
f73dda09 JA |
243 | |
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)); | |
95732b49 | 249 | static int find_job __P((pid_t, int, PROCESS **)); |
f73dda09 JA |
250 | static int print_job __P((JOB *, int, int, int)); |
251 | static int process_exit_status __P((WAIT)); | |
b80f6443 | 252 | static int process_exit_signal __P((WAIT)); |
f73dda09 JA |
253 | static int set_job_status_and_cleanup __P((int)); |
254 | ||
f1be666c | 255 | static WAIT job_signal_status __P((int)); |
f73dda09 JA |
256 | static WAIT raw_job_exit_status __P((int)); |
257 | ||
258 | static void notify_of_job_status __P((void)); | |
95732b49 | 259 | static void reset_job_indices __P((void)); |
f73dda09 | 260 | static void cleanup_dead_jobs __P((void)); |
95732b49 JA |
261 | static int processes_in_job __P((int)); |
262 | static void realloc_jobs_list __P((void)); | |
7117c2d2 | 263 | static int compact_jobs_list __P((int)); |
95732b49 | 264 | static int discard_pipeline __P((PROCESS *)); |
f73dda09 JA |
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)); | |
3185942a | 272 | static int maybe_give_terminal_to __P((pid_t, pid_t, int)); |
f73dda09 JA |
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)); | |
726f6388 | 276 | #if defined (PGRP_PIPE) |
f73dda09 | 277 | static void pipe_read __P((int *)); |
726f6388 JA |
278 | #endif |
279 | ||
95732b49 JA |
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)); | |
286 | ||
7117c2d2 JA |
287 | #if defined (ARRAY_VARS) |
288 | static int *pstatuses; /* list of pipeline statuses */ | |
289 | static int statsize; | |
290 | #endif | |
291 | ||
292 | /* Used to synchronize between wait_for and other functions and the SIGCHLD | |
293 | signal handler. */ | |
ccc6cda3 | 294 | static int sigchld; |
7117c2d2 JA |
295 | static int queue_sigchld; |
296 | ||
297 | #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++ | |
298 | ||
299 | #define UNQUEUE_SIGCHLD(os) \ | |
300 | do { \ | |
301 | queue_sigchld--; \ | |
302 | if (queue_sigchld == 0 && os != sigchld) \ | |
303 | waitchld (-1, 0); \ | |
304 | } while (0) | |
305 | ||
306 | static SigHandler *old_tstp, *old_ttou, *old_ttin; | |
307 | static SigHandler *old_cont = (SigHandler *)SIG_DFL; | |
308 | ||
ccc6cda3 JA |
309 | /* A place to temporarily save the current pipeline. */ |
310 | static PROCESS *saved_pipeline; | |
311 | static int saved_already_making_children; | |
726f6388 JA |
312 | |
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 | |
316 | commands. */ | |
ccc6cda3 | 317 | static int jobs_list_frozen; |
726f6388 | 318 | |
28ef6c31 JA |
319 | static char retcode_name_buffer[64]; |
320 | ||
0628567a JA |
321 | /* flags to detect pid wraparound */ |
322 | static pid_t first_pid = NO_PID; | |
323 | static int pid_wrap = -1; | |
324 | ||
726f6388 JA |
325 | #if !defined (_POSIX_VERSION) |
326 | ||
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)) | |
331 | ||
332 | pid_t | |
333 | tcgetpgrp (fd) | |
334 | int fd; | |
335 | { | |
336 | pid_t pgrp; | |
337 | ||
338 | /* ioctl will handle setting errno correctly. */ | |
339 | if (ioctl (fd, TIOCGPGRP, &pgrp) < 0) | |
340 | return (-1); | |
341 | return (pgrp); | |
342 | } | |
343 | ||
726f6388 JA |
344 | #endif /* !_POSIX_VERSION */ |
345 | ||
0628567a | 346 | /* Initialize the global job stats structure and other bookkeeping variables */ |
95732b49 JA |
347 | void |
348 | init_job_stats () | |
349 | { | |
350 | js = zerojs; | |
0628567a JA |
351 | first_pid = NO_PID; |
352 | pid_wrap = -1; | |
95732b49 JA |
353 | } |
354 | ||
726f6388 JA |
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. */ | |
359 | static char * | |
360 | current_working_directory () | |
361 | { | |
362 | char *dir; | |
ccc6cda3 | 363 | static char d[PATH_MAX]; |
726f6388 JA |
364 | |
365 | dir = get_string_value ("PWD"); | |
366 | ||
ccc6cda3 | 367 | if (dir == 0 && the_current_working_directory && no_symbolic_links) |
726f6388 JA |
368 | dir = the_current_working_directory; |
369 | ||
ccc6cda3 | 370 | if (dir == 0) |
726f6388 | 371 | { |
ccc6cda3 | 372 | dir = getcwd (d, sizeof(d)); |
726f6388 JA |
373 | if (dir) |
374 | dir = d; | |
375 | } | |
376 | ||
ccc6cda3 | 377 | return (dir == 0) ? "<unknown>" : dir; |
726f6388 JA |
378 | } |
379 | ||
380 | /* Return the working directory for the current process. */ | |
381 | static char * | |
382 | job_working_directory () | |
383 | { | |
384 | char *dir; | |
385 | ||
386 | dir = get_string_value ("PWD"); | |
387 | if (dir) | |
388 | return (savestring (dir)); | |
389 | ||
390 | dir = get_working_directory ("job-working-directory"); | |
391 | if (dir) | |
392 | return (dir); | |
393 | ||
394 | return (savestring ("<unknown>")); | |
395 | } | |
396 | ||
397 | void | |
398 | making_children () | |
399 | { | |
400 | if (already_making_children) | |
401 | return; | |
402 | ||
403 | already_making_children = 1; | |
404 | start_pipeline (); | |
405 | } | |
406 | ||
407 | void | |
408 | stop_making_children () | |
409 | { | |
410 | already_making_children = 0; | |
411 | } | |
412 | ||
413 | void | |
414 | cleanup_the_pipeline () | |
415 | { | |
95732b49 JA |
416 | PROCESS *disposer; |
417 | sigset_t set, oset; | |
418 | ||
419 | BLOCK_CHILD (set, oset); | |
420 | disposer = the_pipeline; | |
421 | the_pipeline = (PROCESS *)NULL; | |
422 | UNBLOCK_CHILD (oset); | |
423 | ||
424 | if (disposer) | |
425 | discard_pipeline (disposer); | |
726f6388 JA |
426 | } |
427 | ||
ccc6cda3 JA |
428 | void |
429 | save_pipeline (clear) | |
430 | int clear; | |
431 | { | |
432 | saved_pipeline = the_pipeline; | |
ccc6cda3 JA |
433 | if (clear) |
434 | the_pipeline = (PROCESS *)NULL; | |
95732b49 | 435 | saved_already_making_children = already_making_children; |
ccc6cda3 JA |
436 | } |
437 | ||
438 | void | |
439 | restore_pipeline (discard) | |
440 | int discard; | |
441 | { | |
442 | PROCESS *old_pipeline; | |
443 | ||
444 | old_pipeline = the_pipeline; | |
445 | the_pipeline = saved_pipeline; | |
446 | already_making_children = saved_already_making_children; | |
89a92869 | 447 | if (discard && old_pipeline) |
ccc6cda3 JA |
448 | discard_pipeline (old_pipeline); |
449 | } | |
450 | ||
726f6388 JA |
451 | /* Start building a pipeline. */ |
452 | void | |
453 | start_pipeline () | |
454 | { | |
455 | if (the_pipeline) | |
456 | { | |
ccc6cda3 | 457 | cleanup_the_pipeline (); |
726f6388 JA |
458 | pipeline_pgrp = 0; |
459 | #if defined (PGRP_PIPE) | |
3185942a | 460 | sh_closepipe (pgrp_pipe); |
726f6388 JA |
461 | #endif |
462 | } | |
463 | ||
464 | #if defined (PGRP_PIPE) | |
465 | if (job_control) | |
466 | { | |
467 | if (pipe (pgrp_pipe) == -1) | |
3185942a | 468 | sys_error (_("start_pipeline: pgrp pipe")); |
726f6388 JA |
469 | } |
470 | #endif | |
471 | } | |
472 | ||
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. */ | |
477 | int | |
478 | stop_pipeline (async, deferred) | |
479 | int async; | |
480 | COMMAND *deferred; | |
481 | { | |
482 | register int i, j; | |
ccc6cda3 | 483 | JOB *newjob; |
726f6388 JA |
484 | sigset_t set, oset; |
485 | ||
486 | BLOCK_CHILD (set, oset); | |
487 | ||
488 | #if defined (PGRP_PIPE) | |
489 | /* The parent closes the process group synchronization pipe. */ | |
3185942a | 490 | sh_closepipe (pgrp_pipe); |
726f6388 | 491 | #endif |
ccc6cda3 | 492 | |
726f6388 JA |
493 | cleanup_dead_jobs (); |
494 | ||
95732b49 | 495 | if (js.j_jobslots == 0) |
726f6388 | 496 | { |
95732b49 JA |
497 | js.j_jobslots = JOB_SLOTS; |
498 | jobs = (JOB **)xmalloc (js.j_jobslots * sizeof (JOB *)); | |
726f6388 JA |
499 | |
500 | /* Now blank out these new entries. */ | |
95732b49 | 501 | for (i = 0; i < js.j_jobslots; i++) |
726f6388 | 502 | jobs[i] = (JOB *)NULL; |
95732b49 JA |
503 | |
504 | js.j_firstj = js.j_lastj = js.j_njobs = 0; | |
726f6388 JA |
505 | } |
506 | ||
507 | /* Scan from the last slot backward, looking for the next free one. */ | |
b80f6443 | 508 | /* XXX - revisit this interactive assumption */ |
95732b49 | 509 | /* XXX - this way for now */ |
726f6388 JA |
510 | if (interactive) |
511 | { | |
95732b49 | 512 | for (i = js.j_jobslots; i; i--) |
726f6388 JA |
513 | if (jobs[i - 1]) |
514 | break; | |
515 | } | |
516 | else | |
517 | { | |
95732b49 JA |
518 | #if 0 |
519 | /* This wraps around, but makes it inconvenient to extend the array */ | |
520 | for (i = js.j_lastj+1; i != js.j_lastj; i++) | |
521 | { | |
522 | if (i >= js.j_jobslots) | |
523 | i = 0; | |
524 | if (jobs[i] == 0) | |
525 | break; | |
526 | } | |
527 | if (i == js.j_lastj) | |
528 | i = js.j_jobslots; | |
529 | #else | |
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++) | |
ccc6cda3 | 532 | if (jobs[i] == 0) |
726f6388 | 533 | break; |
95732b49 | 534 | #endif |
726f6388 JA |
535 | } |
536 | ||
537 | /* Do we need more room? */ | |
7117c2d2 JA |
538 | |
539 | /* First try compaction */ | |
95732b49 | 540 | if ((interactive_shell == 0 || subshell_environment) && i == js.j_jobslots && js.j_jobslots >= MAX_JOBS_IN_ARRAY) |
7117c2d2 JA |
541 | i = compact_jobs_list (0); |
542 | ||
543 | /* If we can't compact, reallocate */ | |
95732b49 | 544 | if (i == js.j_jobslots) |
726f6388 | 545 | { |
95732b49 JA |
546 | js.j_jobslots += JOB_SLOTS; |
547 | jobs = (JOB **)xrealloc (jobs, (js.j_jobslots * sizeof (JOB *))); | |
726f6388 | 548 | |
95732b49 | 549 | for (j = i; j < js.j_jobslots; j++) |
726f6388 JA |
550 | jobs[j] = (JOB *)NULL; |
551 | } | |
552 | ||
553 | /* Add the current pipeline to the job list. */ | |
554 | if (the_pipeline) | |
555 | { | |
556 | register PROCESS *p; | |
95732b49 | 557 | int any_running, any_stopped, n; |
726f6388 JA |
558 | |
559 | newjob = (JOB *)xmalloc (sizeof (JOB)); | |
560 | ||
95732b49 | 561 | for (n = 1, p = the_pipeline; p->next != the_pipeline; n++, p = p->next) |
ccc6cda3 | 562 | ; |
726f6388 JA |
563 | p->next = (PROCESS *)NULL; |
564 | newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *); | |
ccc6cda3 JA |
565 | for (p = newjob->pipe; p->next; p = p->next) |
566 | ; | |
726f6388 JA |
567 | p->next = newjob->pipe; |
568 | ||
569 | the_pipeline = (PROCESS *)NULL; | |
570 | newjob->pgrp = pipeline_pgrp; | |
571 | pipeline_pgrp = 0; | |
572 | ||
573 | newjob->flags = 0; | |
574 | ||
575 | /* Flag to see if in another pgrp. */ | |
576 | if (job_control) | |
577 | newjob->flags |= J_JOBCONTROL; | |
578 | ||
579 | /* Set the state of this pipeline. */ | |
ccc6cda3 | 580 | p = newjob->pipe; |
95732b49 | 581 | any_running = any_stopped = 0; |
ccc6cda3 JA |
582 | do |
583 | { | |
95732b49 JA |
584 | any_running |= PRUNNING (p); |
585 | any_stopped |= PSTOPPED (p); | |
ccc6cda3 JA |
586 | p = p->next; |
587 | } | |
588 | while (p != newjob->pipe); | |
726f6388 | 589 | |
95732b49 | 590 | newjob->state = any_running ? JRUNNING : (any_stopped ? JSTOPPED : JDEAD); |
726f6388 JA |
591 | newjob->wd = job_working_directory (); |
592 | newjob->deferred = deferred; | |
593 | ||
f73dda09 | 594 | newjob->j_cleanup = (sh_vptrfunc_t *)NULL; |
ccc6cda3 JA |
595 | newjob->cleanarg = (PTR_T) NULL; |
596 | ||
726f6388 | 597 | jobs[i] = newjob; |
ccc6cda3 JA |
598 | if (newjob->state == JDEAD && (newjob->flags & J_FOREGROUND)) |
599 | setjstatus (i); | |
95732b49 JA |
600 | if (newjob->state == JDEAD) |
601 | { | |
602 | js.c_reaped += n; /* wouldn't have been done since this was not part of a job */ | |
603 | js.j_ndead++; | |
604 | } | |
605 | js.c_injobs += n; | |
606 | ||
607 | js.j_lastj = i; | |
608 | js.j_njobs++; | |
726f6388 | 609 | } |
ccc6cda3 JA |
610 | else |
611 | newjob = (JOB *)NULL; | |
726f6388 | 612 | |
95732b49 JA |
613 | if (newjob) |
614 | js.j_lastmade = newjob; | |
615 | ||
726f6388 JA |
616 | if (async) |
617 | { | |
618 | if (newjob) | |
95732b49 JA |
619 | { |
620 | newjob->flags &= ~J_FOREGROUND; | |
621 | newjob->flags |= J_ASYNC; | |
622 | js.j_lastasync = newjob; | |
623 | } | |
726f6388 JA |
624 | reset_current (); |
625 | } | |
626 | else | |
627 | { | |
628 | if (newjob) | |
629 | { | |
630 | newjob->flags |= J_FOREGROUND; | |
631 | /* | |
632 | * !!!!! NOTE !!!!! (chet@ins.cwru.edu) | |
633 | * | |
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. | |
638 | * | |
0628567a JA |
639 | * Don't give the terminal away if this shell is an asynchronous |
640 | * subshell. | |
641 | * | |
726f6388 | 642 | */ |
0628567a | 643 | if (job_control && newjob->pgrp && (subshell_environment&SUBSHELL_ASYNC) == 0) |
3185942a | 644 | maybe_give_terminal_to (shell_pgrp, newjob->pgrp, 0); |
726f6388 JA |
645 | } |
646 | } | |
647 | ||
648 | stop_making_children (); | |
649 | UNBLOCK_CHILD (oset); | |
495aee44 | 650 | return (newjob ? i : js.j_current); |
95732b49 JA |
651 | } |
652 | ||
653 | /* Functions to manage the list of exited background pids whose status has | |
654 | been saved. */ | |
655 | ||
656 | static struct pidstat * | |
657 | bgp_alloc (pid, status) | |
658 | pid_t pid; | |
659 | int status; | |
660 | { | |
661 | struct pidstat *ps; | |
662 | ||
663 | ps = (struct pidstat *)xmalloc (sizeof (struct pidstat)); | |
664 | ps->pid = pid; | |
665 | ps->status = status; | |
666 | ps->next = (struct pidstat *)0; | |
667 | return ps; | |
726f6388 JA |
668 | } |
669 | ||
95732b49 JA |
670 | static struct pidstat * |
671 | bgp_add (pid, status) | |
672 | pid_t pid; | |
673 | int status; | |
674 | { | |
675 | struct pidstat *ps; | |
676 | ||
677 | ps = bgp_alloc (pid, status); | |
678 | ||
679 | if (bgpids.list == 0) | |
680 | { | |
681 | bgpids.list = bgpids.end = ps; | |
682 | bgpids.npid = 0; /* just to make sure */ | |
683 | } | |
684 | else | |
685 | { | |
686 | bgpids.end->next = ps; | |
687 | bgpids.end = ps; | |
688 | } | |
689 | bgpids.npid++; | |
690 | ||
691 | if (bgpids.npid > js.c_childmax) | |
692 | bgp_prune (); | |
693 | ||
694 | return ps; | |
695 | } | |
696 | ||
697 | static int | |
698 | bgp_delete (pid) | |
699 | pid_t pid; | |
700 | { | |
701 | struct pidstat *prev, *p; | |
702 | ||
703 | for (prev = p = bgpids.list; p; prev = p, p = p->next) | |
704 | if (p->pid == pid) | |
705 | { | |
0001803f CR |
706 | prev->next = p->next; /* remove from list */ |
707 | break; | |
95732b49 JA |
708 | } |
709 | ||
710 | if (p == 0) | |
711 | return 0; /* not found */ | |
712 | ||
713 | #if defined (DEBUG) | |
714 | itrace("bgp_delete: deleting %d", pid); | |
715 | #endif | |
716 | ||
717 | /* Housekeeping in the border cases. */ | |
718 | if (p == bgpids.list) | |
719 | bgpids.list = bgpids.list->next; | |
720 | else if (p == bgpids.end) | |
721 | bgpids.end = prev; | |
722 | ||
723 | bgpids.npid--; | |
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 */ | |
728 | ||
729 | free (p); | |
730 | return 1; | |
731 | } | |
732 | ||
733 | /* Clear out the list of saved statuses */ | |
734 | static void | |
735 | bgp_clear () | |
736 | { | |
737 | struct pidstat *ps, *p; | |
738 | ||
739 | for (ps = bgpids.list; ps; ) | |
740 | { | |
741 | p = ps; | |
742 | ps = ps->next; | |
743 | free (p); | |
744 | } | |
745 | bgpids.list = bgpids.end = 0; | |
746 | bgpids.npid = 0; | |
747 | } | |
748 | ||
749 | /* Search for PID in the list of saved background pids; return its status if | |
750 | found. If not found, return -1. */ | |
751 | static int | |
752 | bgp_search (pid) | |
753 | pid_t pid; | |
754 | { | |
755 | struct pidstat *ps; | |
756 | ||
757 | for (ps = bgpids.list ; ps; ps = ps->next) | |
758 | if (ps->pid == pid) | |
759 | return ps->status; | |
760 | return -1; | |
761 | } | |
762 | ||
763 | static void | |
764 | bgp_prune () | |
765 | { | |
0628567a | 766 | struct pidstat *ps; |
95732b49 JA |
767 | |
768 | while (bgpids.npid > js.c_childmax) | |
769 | { | |
770 | ps = bgpids.list; | |
771 | bgpids.list = bgpids.list->next; | |
772 | free (ps); | |
773 | bgpids.npid--; | |
774 | } | |
775 | } | |
3185942a | 776 | |
95732b49 JA |
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. */ | |
781 | static void | |
782 | reset_job_indices () | |
783 | { | |
784 | int old; | |
785 | ||
786 | if (jobs[js.j_firstj] == 0) | |
787 | { | |
788 | old = js.j_firstj++; | |
f1be666c JA |
789 | if (old >= js.j_jobslots) |
790 | old = js.j_jobslots - 1; | |
95732b49 JA |
791 | while (js.j_firstj != old) |
792 | { | |
793 | if (js.j_firstj >= js.j_jobslots) | |
794 | js.j_firstj = 0; | |
f1be666c | 795 | if (jobs[js.j_firstj] || js.j_firstj == old) /* needed if old == 0 */ |
95732b49 JA |
796 | break; |
797 | js.j_firstj++; | |
798 | } | |
799 | if (js.j_firstj == old) | |
800 | js.j_firstj = js.j_lastj = js.j_njobs = 0; | |
801 | } | |
802 | if (jobs[js.j_lastj] == 0) | |
803 | { | |
804 | old = js.j_lastj--; | |
f1be666c JA |
805 | if (old < 0) |
806 | old = 0; | |
95732b49 JA |
807 | while (js.j_lastj != old) |
808 | { | |
809 | if (js.j_lastj < 0) | |
810 | js.j_lastj = js.j_jobslots - 1; | |
f1be666c | 811 | if (jobs[js.j_lastj] || js.j_lastj == old) /* needed if old == js.j_jobslots */ |
95732b49 JA |
812 | break; |
813 | js.j_lastj--; | |
814 | } | |
815 | if (js.j_lastj == old) | |
816 | js.j_firstj = js.j_lastj = js.j_njobs = 0; | |
817 | } | |
818 | } | |
819 | ||
726f6388 JA |
820 | /* Delete all DEAD jobs that the user had received notification about. */ |
821 | static void | |
822 | cleanup_dead_jobs () | |
823 | { | |
824 | register int i; | |
7117c2d2 | 825 | int os; |
726f6388 | 826 | |
95732b49 | 827 | if (js.j_jobslots == 0 || jobs_list_frozen) |
726f6388 JA |
828 | return; |
829 | ||
7117c2d2 | 830 | QUEUE_SIGCHLD(os); |
726f6388 | 831 | |
0628567a | 832 | /* XXX could use js.j_firstj and js.j_lastj here */ |
95732b49 JA |
833 | for (i = 0; i < js.j_jobslots; i++) |
834 | { | |
835 | #if defined (DEBUG) | |
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); | |
0628567a JA |
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); | |
95732b49 | 840 | #endif |
726f6388 | 841 | |
95732b49 JA |
842 | if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i)) |
843 | delete_job (i, 0); | |
844 | } | |
17345e5a JA |
845 | |
846 | #if defined (COPROCESS_SUPPORT) | |
847 | coproc_reap (); | |
848 | #endif | |
849 | ||
7117c2d2 JA |
850 | UNQUEUE_SIGCHLD(os); |
851 | } | |
852 | ||
7117c2d2 | 853 | static int |
95732b49 | 854 | processes_in_job (job) |
3185942a | 855 | int job; |
7117c2d2 | 856 | { |
95732b49 JA |
857 | int nproc; |
858 | register PROCESS *p; | |
7117c2d2 | 859 | |
95732b49 JA |
860 | nproc = 0; |
861 | p = jobs[job]->pipe; | |
862 | do | |
863 | { | |
864 | p = p->next; | |
865 | nproc++; | |
866 | } | |
867 | while (p != jobs[job]->pipe); | |
7117c2d2 | 868 | |
95732b49 JA |
869 | return nproc; |
870 | } | |
7117c2d2 | 871 | |
0628567a JA |
872 | static void |
873 | delete_old_job (pid) | |
874 | pid_t pid; | |
875 | { | |
876 | PROCESS *p; | |
877 | int job; | |
878 | ||
879 | job = find_job (pid, 0, &p); | |
880 | if (job != NO_JOB) | |
881 | { | |
882 | #ifdef DEBUG | |
883 | itrace ("delete_old_job: found pid %d in job %d with state %d", pid, job, jobs[job]->state); | |
884 | #endif | |
885 | if (JOBSTATE (job) == JDEAD) | |
886 | delete_job (job, DEL_NOBGPID); | |
887 | else | |
888 | { | |
889 | internal_warning (_("forked pid %d appears in running job %d"), pid, job); | |
890 | if (p) | |
891 | p->pid = 0; | |
892 | } | |
893 | } | |
894 | } | |
895 | ||
95732b49 JA |
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. */ | |
899 | static void | |
900 | realloc_jobs_list () | |
901 | { | |
902 | sigset_t set, oset; | |
0628567a | 903 | int nsize, i, j, ncur, nprev; |
95732b49 | 904 | JOB **nlist; |
7117c2d2 | 905 | |
0628567a | 906 | ncur = nprev = NO_JOB; |
95732b49 JA |
907 | nsize = ((js.j_njobs + JOB_SLOTS - 1) / JOB_SLOTS); |
908 | nsize *= JOB_SLOTS; | |
909 | i = js.j_njobs % JOB_SLOTS; | |
910 | if (i == 0 || i > (JOB_SLOTS >> 1)) | |
911 | nsize += JOB_SLOTS; | |
7117c2d2 | 912 | |
95732b49 | 913 | BLOCK_CHILD (set, oset); |
0628567a JA |
914 | nlist = (js.j_jobslots == nsize) ? jobs : (JOB **) xmalloc (nsize * sizeof (JOB *)); |
915 | ||
3185942a | 916 | js.c_reaped = js.j_ndead = 0; |
95732b49 | 917 | for (i = j = 0; i < js.j_jobslots; i++) |
7117c2d2 | 918 | if (jobs[i]) |
0628567a JA |
919 | { |
920 | if (i == js.j_current) | |
921 | ncur = j; | |
922 | if (i == js.j_previous) | |
923 | nprev = j; | |
924 | nlist[j++] = jobs[i]; | |
3185942a JA |
925 | if (jobs[i]->state == JDEAD) |
926 | { | |
927 | js.j_ndead++; | |
928 | js.c_reaped += processes_in_job (i); | |
929 | } | |
0628567a JA |
930 | } |
931 | ||
932 | #if defined (DEBUG) | |
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); | |
3185942a JA |
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); | |
0628567a | 937 | #endif |
7117c2d2 | 938 | |
95732b49 | 939 | js.j_firstj = 0; |
0628567a JA |
940 | js.j_lastj = (j > 0) ? j - 1 : 0; |
941 | js.j_njobs = j; | |
95732b49 | 942 | js.j_jobslots = nsize; |
7117c2d2 | 943 | |
0628567a JA |
944 | /* Zero out remaining slots in new jobs list */ |
945 | for ( ; j < nsize; j++) | |
946 | nlist[j] = (JOB *)NULL; | |
947 | ||
948 | if (jobs != nlist) | |
949 | { | |
950 | free (jobs); | |
951 | jobs = nlist; | |
952 | } | |
953 | ||
954 | if (ncur != NO_JOB) | |
955 | js.j_current = ncur; | |
956 | if (nprev != NO_JOB) | |
957 | js.j_previous = nprev; | |
958 | ||
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) | |
961 | reset_current (); | |
962 | ||
963 | #ifdef DEBUG | |
964 | itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js.j_current, js.j_previous); | |
965 | #endif | |
7117c2d2 | 966 | |
726f6388 | 967 | UNBLOCK_CHILD (oset); |
95732b49 JA |
968 | } |
969 | ||
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 | |
0628567a | 974 | the list needs to be reallocated. The jobs array may be in new memory if |
95732b49 JA |
975 | this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */ |
976 | static int | |
977 | compact_jobs_list (flags) | |
978 | int flags; | |
979 | { | |
980 | if (js.j_jobslots == 0 || jobs_list_frozen) | |
981 | return js.j_jobslots; | |
982 | ||
983 | reap_dead_jobs (); | |
984 | realloc_jobs_list (); | |
7117c2d2 | 985 | |
f1be666c JA |
986 | #ifdef DEBUG |
987 | itrace("compact_jobs_list: returning %d", (js.j_lastj || jobs[js.j_lastj]) ? js.j_lastj + 1 : 0); | |
988 | #endif | |
989 | ||
990 | return ((js.j_lastj || jobs[js.j_lastj]) ? js.j_lastj + 1 : 0); | |
726f6388 JA |
991 | } |
992 | ||
993 | /* Delete the job at INDEX from the job list. Must be called | |
994 | with SIGCHLD blocked. */ | |
995 | void | |
0628567a JA |
996 | delete_job (job_index, dflags) |
997 | int job_index, dflags; | |
726f6388 JA |
998 | { |
999 | register JOB *temp; | |
95732b49 | 1000 | PROCESS *proc; |
0628567a | 1001 | int ndel; |
726f6388 | 1002 | |
95732b49 | 1003 | if (js.j_jobslots == 0 || jobs_list_frozen) |
726f6388 JA |
1004 | return; |
1005 | ||
0628567a | 1006 | if ((dflags & DEL_WARNSTOPPED) && subshell_environment == 0 && STOPPED (job_index)) |
b80f6443 | 1007 | internal_warning (_("deleting stopped job %d with process group %ld"), job_index+1, (long)jobs[job_index]->pgrp); |
726f6388 | 1008 | temp = jobs[job_index]; |
0628567a JA |
1009 | if (temp == 0) |
1010 | return; | |
726f6388 | 1011 | |
0628567a JA |
1012 | if ((dflags & DEL_NOBGPID) == 0) |
1013 | { | |
1014 | proc = find_last_proc (job_index, 0); | |
1015 | /* Could do this just for J_ASYNC jobs, but we save all. */ | |
1016 | if (proc) | |
1017 | bgp_add (proc->pid, process_exit_status (proc->status)); | |
1018 | } | |
95732b49 | 1019 | |
726f6388 | 1020 | jobs[job_index] = (JOB *)NULL; |
95732b49 JA |
1021 | if (temp == js.j_lastmade) |
1022 | js.j_lastmade = 0; | |
1023 | else if (temp == js.j_lastasync) | |
1024 | js.j_lastasync = 0; | |
1025 | ||
726f6388 | 1026 | free (temp->wd); |
95732b49 JA |
1027 | ndel = discard_pipeline (temp->pipe); |
1028 | ||
1029 | js.c_injobs -= ndel; | |
1030 | if (temp->state == JDEAD) | |
1031 | { | |
1032 | js.c_reaped -= ndel; | |
1033 | js.j_ndead--; | |
1034 | if (js.c_reaped < 0) | |
1035 | { | |
1036 | #ifdef DEBUG | |
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); | |
1038 | #endif | |
1039 | js.c_reaped = 0; | |
1040 | } | |
1041 | } | |
726f6388 JA |
1042 | |
1043 | if (temp->deferred) | |
1044 | dispose_command (temp->deferred); | |
1045 | ||
1046 | free (temp); | |
95732b49 JA |
1047 | |
1048 | js.j_njobs--; | |
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 (); | |
f1be666c JA |
1053 | |
1054 | if (job_index == js.j_current || job_index == js.j_previous) | |
1055 | reset_current (); | |
726f6388 JA |
1056 | } |
1057 | ||
ccc6cda3 JA |
1058 | /* Must be called with SIGCHLD blocked. */ |
1059 | void | |
1060 | nohup_job (job_index) | |
1061 | int job_index; | |
1062 | { | |
1063 | register JOB *temp; | |
1064 | ||
95732b49 | 1065 | if (js.j_jobslots == 0) |
cce855bc JA |
1066 | return; |
1067 | ||
d166f048 | 1068 | if (temp = jobs[job_index]) |
ccc6cda3 JA |
1069 | temp->flags |= J_NOHUP; |
1070 | } | |
1071 | ||
726f6388 | 1072 | /* Get rid of the data structure associated with a process chain. */ |
95732b49 | 1073 | static int |
726f6388 JA |
1074 | discard_pipeline (chain) |
1075 | register PROCESS *chain; | |
1076 | { | |
1077 | register PROCESS *this, *next; | |
95732b49 | 1078 | int n; |
726f6388 JA |
1079 | |
1080 | this = chain; | |
95732b49 | 1081 | n = 0; |
726f6388 JA |
1082 | do |
1083 | { | |
1084 | next = this->next; | |
ccc6cda3 | 1085 | FREE (this->command); |
726f6388 | 1086 | free (this); |
95732b49 | 1087 | n++; |
726f6388 JA |
1088 | this = next; |
1089 | } | |
1090 | while (this != chain); | |
95732b49 JA |
1091 | |
1092 | return n; | |
726f6388 JA |
1093 | } |
1094 | ||
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. */ | |
1098 | static void | |
1099 | add_process (name, pid) | |
1100 | char *name; | |
1101 | pid_t pid; | |
1102 | { | |
ccc6cda3 | 1103 | PROCESS *t, *p; |
726f6388 | 1104 | |
95732b49 JA |
1105 | #if defined (RECYCLES_PIDS) |
1106 | int j; | |
1107 | p = find_process (pid, 0, &j); | |
1108 | if (p) | |
1109 | { | |
1110 | # ifdef DEBUG | |
1111 | if (j == NO_JOB) | |
3185942a | 1112 | internal_warning (_("add_process: process %5ld (%s) in the_pipeline"), (long)p->pid, p->command); |
95732b49 JA |
1113 | # endif |
1114 | if (PALIVE (p)) | |
3185942a | 1115 | internal_warning (_("add_process: pid %5ld (%s) marked as still alive"), (long)p->pid, p->command); |
95732b49 JA |
1116 | p->running = PS_RECYCLED; /* mark as recycled */ |
1117 | } | |
1118 | #endif | |
1119 | ||
ccc6cda3 | 1120 | t = (PROCESS *)xmalloc (sizeof (PROCESS)); |
726f6388 JA |
1121 | t->next = the_pipeline; |
1122 | t->pid = pid; | |
1123 | WSTATUS (t->status) = 0; | |
7117c2d2 | 1124 | t->running = PS_RUNNING; |
726f6388 JA |
1125 | t->command = name; |
1126 | the_pipeline = t; | |
1127 | ||
ccc6cda3 | 1128 | if (t->next == 0) |
726f6388 JA |
1129 | t->next = t; |
1130 | else | |
1131 | { | |
ccc6cda3 | 1132 | p = t->next; |
726f6388 JA |
1133 | while (p->next != t->next) |
1134 | p = p->next; | |
1135 | p->next = t; | |
1136 | } | |
1137 | } | |
1138 | ||
495aee44 CR |
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. */ | |
1141 | void | |
1142 | append_process (name, pid, status, jid) | |
1143 | char *name; | |
1144 | pid_t pid; | |
1145 | int status; | |
1146 | int jid; | |
1147 | { | |
1148 | PROCESS *t, *p; | |
1149 | ||
1150 | t = (PROCESS *)xmalloc (sizeof (PROCESS)); | |
1151 | t->next = (PROCESS *)NULL; | |
1152 | t->pid = pid; | |
1153 | /* set process exit status using offset discovered by configure */ | |
1154 | t->status = (status & 0xff) << WEXITSTATUS_OFFSET; | |
1155 | t->running = PS_DONE; | |
1156 | t->command = name; | |
1157 | ||
1158 | js.c_reaped++; /* XXX */ | |
1159 | ||
1160 | for (p = jobs[jid]->pipe; p->next != jobs[jid]->pipe; p = p->next) | |
1161 | ; | |
1162 | p->next = t; | |
1163 | t->next = jobs[jid]->pipe; | |
1164 | } | |
1165 | ||
726f6388 JA |
1166 | #if 0 |
1167 | /* Take the last job and make it the first job. Must be called with | |
1168 | SIGCHLD blocked. */ | |
ccc6cda3 | 1169 | int |
726f6388 JA |
1170 | rotate_the_pipeline () |
1171 | { | |
1172 | PROCESS *p; | |
1173 | ||
1174 | if (the_pipeline->next == the_pipeline) | |
1175 | return; | |
1176 | for (p = the_pipeline; p->next != the_pipeline; p = p->next) | |
1177 | ; | |
1178 | the_pipeline = p; | |
1179 | } | |
1180 | ||
1181 | /* Reverse the order of the processes in the_pipeline. Must be called with | |
1182 | SIGCHLD blocked. */ | |
ccc6cda3 | 1183 | int |
726f6388 JA |
1184 | reverse_the_pipeline () |
1185 | { | |
1186 | PROCESS *p, *n; | |
1187 | ||
1188 | if (the_pipeline->next == the_pipeline) | |
1189 | return; | |
1190 | ||
1191 | for (p = the_pipeline; p->next != the_pipeline; p = p->next) | |
1192 | ; | |
1193 | p->next = (PROCESS *)NULL; | |
1194 | ||
1195 | n = REVERSE_LIST (the_pipeline, PROCESS *); | |
1196 | ||
1197 | the_pipeline = n; | |
1198 | for (p = the_pipeline; p->next; p = p->next) | |
1199 | ; | |
1200 | p->next = the_pipeline; | |
1201 | } | |
1202 | #endif | |
1203 | ||
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, | |
1207 | and INDEX. */ | |
1208 | static int | |
1209 | map_over_jobs (func, arg1, arg2) | |
f73dda09 | 1210 | sh_job_map_func_t *func; |
726f6388 JA |
1211 | int arg1, arg2; |
1212 | { | |
1213 | register int i; | |
1214 | int result; | |
1215 | sigset_t set, oset; | |
1216 | ||
95732b49 | 1217 | if (js.j_jobslots == 0) |
28ef6c31 JA |
1218 | return 0; |
1219 | ||
726f6388 | 1220 | BLOCK_CHILD (set, oset); |
726f6388 | 1221 | |
95732b49 JA |
1222 | /* XXX could use js.j_firstj here */ |
1223 | for (i = result = 0; i < js.j_jobslots; i++) | |
726f6388 | 1224 | { |
95732b49 JA |
1225 | #if defined (DEBUG) |
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); | |
0628567a JA |
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); | |
95732b49 | 1230 | #endif |
726f6388 JA |
1231 | if (jobs[i]) |
1232 | { | |
1233 | result = (*func)(jobs[i], arg1, arg2, i); | |
1234 | if (result) | |
1235 | break; | |
1236 | } | |
1237 | } | |
1238 | ||
1239 | UNBLOCK_CHILD (oset); | |
ccc6cda3 | 1240 | |
726f6388 JA |
1241 | return (result); |
1242 | } | |
1243 | ||
1244 | /* Cause all the jobs in the current pipeline to exit. */ | |
1245 | void | |
1246 | terminate_current_pipeline () | |
1247 | { | |
1248 | if (pipeline_pgrp && pipeline_pgrp != shell_pgrp) | |
1249 | { | |
1250 | killpg (pipeline_pgrp, SIGTERM); | |
1251 | killpg (pipeline_pgrp, SIGCONT); | |
1252 | } | |
1253 | } | |
1254 | ||
1255 | /* Cause all stopped jobs to exit. */ | |
1256 | void | |
1257 | terminate_stopped_jobs () | |
1258 | { | |
1259 | register int i; | |
1260 | ||
95732b49 JA |
1261 | /* XXX could use js.j_firstj here */ |
1262 | for (i = 0; i < js.j_jobslots; i++) | |
726f6388 | 1263 | { |
ccc6cda3 | 1264 | if (jobs[i] && STOPPED (i)) |
726f6388 JA |
1265 | { |
1266 | killpg (jobs[i]->pgrp, SIGTERM); | |
1267 | killpg (jobs[i]->pgrp, SIGCONT); | |
1268 | } | |
1269 | } | |
1270 | } | |
1271 | ||
ccc6cda3 JA |
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. */ | |
726f6388 JA |
1274 | void |
1275 | hangup_all_jobs () | |
1276 | { | |
1277 | register int i; | |
1278 | ||
95732b49 JA |
1279 | /* XXX could use js.j_firstj here */ |
1280 | for (i = 0; i < js.j_jobslots; i++) | |
726f6388 JA |
1281 | { |
1282 | if (jobs[i]) | |
1283 | { | |
0628567a JA |
1284 | if (jobs[i]->flags & J_NOHUP) |
1285 | continue; | |
1286 | killpg (jobs[i]->pgrp, SIGHUP); | |
ccc6cda3 | 1287 | if (STOPPED (i)) |
726f6388 JA |
1288 | killpg (jobs[i]->pgrp, SIGCONT); |
1289 | } | |
1290 | } | |
1291 | } | |
1292 | ||
1293 | void | |
1294 | kill_current_pipeline () | |
1295 | { | |
1296 | stop_making_children (); | |
1297 | start_pipeline (); | |
1298 | } | |
1299 | ||
1300 | /* Return the pipeline that PID belongs to. Note that the pipeline | |
95732b49 JA |
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. */ | |
726f6388 | 1303 | static PROCESS * |
95732b49 | 1304 | find_pipeline (pid, alive_only, jobp) |
726f6388 | 1305 | pid_t pid; |
95732b49 | 1306 | int alive_only; |
7117c2d2 | 1307 | int *jobp; /* index into jobs list or NO_JOB */ |
726f6388 JA |
1308 | { |
1309 | int job; | |
95732b49 | 1310 | PROCESS *p; |
726f6388 JA |
1311 | |
1312 | /* See if this process is in the pipeline that we are building. */ | |
7117c2d2 JA |
1313 | if (jobp) |
1314 | *jobp = NO_JOB; | |
726f6388 JA |
1315 | if (the_pipeline) |
1316 | { | |
ccc6cda3 | 1317 | p = the_pipeline; |
726f6388 JA |
1318 | do |
1319 | { | |
95732b49 JA |
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))) | |
1322 | return (p); | |
726f6388 JA |
1323 | |
1324 | p = p->next; | |
1325 | } | |
1326 | while (p != the_pipeline); | |
1327 | } | |
1328 | ||
95732b49 | 1329 | job = find_job (pid, alive_only, &p); |
7117c2d2 JA |
1330 | if (jobp) |
1331 | *jobp = job; | |
ccc6cda3 | 1332 | return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe; |
726f6388 JA |
1333 | } |
1334 | ||
95732b49 JA |
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 | |
1337 | SIGCHLD blocked. */ | |
1338 | static PROCESS * | |
1339 | find_process (pid, alive_only, jobp) | |
1340 | pid_t pid; | |
1341 | int alive_only; | |
1342 | int *jobp; /* index into jobs list or NO_JOB */ | |
1343 | { | |
1344 | PROCESS *p; | |
1345 | ||
1346 | p = find_pipeline (pid, alive_only, jobp); | |
1347 | while (p && p->pid != pid) | |
1348 | p = p->next; | |
1349 | return p; | |
1350 | } | |
1351 | ||
726f6388 JA |
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. */ | |
1354 | static int | |
95732b49 | 1355 | find_job (pid, alive_only, procp) |
726f6388 | 1356 | pid_t pid; |
95732b49 JA |
1357 | int alive_only; |
1358 | PROCESS **procp; | |
726f6388 JA |
1359 | { |
1360 | register int i; | |
95732b49 | 1361 | PROCESS *p; |
726f6388 | 1362 | |
0628567a | 1363 | /* XXX could use js.j_firstj here, and should check js.j_lastj */ |
95732b49 | 1364 | for (i = 0; i < js.j_jobslots; i++) |
726f6388 | 1365 | { |
95732b49 JA |
1366 | #if defined (DEBUG) |
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); | |
0628567a JA |
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); | |
95732b49 | 1371 | #endif |
726f6388 JA |
1372 | if (jobs[i]) |
1373 | { | |
1374 | p = jobs[i]->pipe; | |
1375 | ||
1376 | do | |
1377 | { | |
95732b49 | 1378 | if (p->pid == pid && ((alive_only == 0 && PRECYCLED(p) == 0) || PALIVE(p))) |
7117c2d2 | 1379 | { |
95732b49 JA |
1380 | if (procp) |
1381 | *procp = p; | |
1382 | return (i); | |
7117c2d2 | 1383 | } |
726f6388 JA |
1384 | |
1385 | p = p->next; | |
1386 | } | |
1387 | while (p != jobs[i]->pipe); | |
1388 | } | |
1389 | } | |
1390 | ||
1391 | return (NO_JOB); | |
1392 | } | |
1393 | ||
d166f048 JA |
1394 | /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as |
1395 | required by find_job. */ | |
1396 | int | |
1397 | get_job_by_pid (pid, block) | |
1398 | pid_t pid; | |
1399 | int block; | |
1400 | { | |
1401 | int job; | |
1402 | sigset_t set, oset; | |
1403 | ||
1404 | if (block) | |
1405 | BLOCK_CHILD (set, oset); | |
7117c2d2 | 1406 | |
95732b49 | 1407 | job = find_job (pid, 0, NULL); |
7117c2d2 | 1408 | |
d166f048 JA |
1409 | if (block) |
1410 | UNBLOCK_CHILD (oset); | |
1411 | ||
1412 | return job; | |
1413 | } | |
1414 | ||
726f6388 JA |
1415 | /* Print descriptive information about the job with leader pid PID. */ |
1416 | void | |
1417 | describe_pid (pid) | |
1418 | pid_t pid; | |
1419 | { | |
1420 | int job; | |
1421 | sigset_t set, oset; | |
1422 | ||
1423 | BLOCK_CHILD (set, oset); | |
1424 | ||
95732b49 | 1425 | job = find_job (pid, 0, NULL); |
726f6388 JA |
1426 | |
1427 | if (job != NO_JOB) | |
95732b49 | 1428 | fprintf (stderr, "[%d] %ld\n", job + 1, (long)pid); |
726f6388 | 1429 | else |
b80f6443 | 1430 | programming_error (_("describe_pid: %ld: no such pid"), (long)pid); |
726f6388 JA |
1431 | |
1432 | UNBLOCK_CHILD (oset); | |
1433 | } | |
1434 | ||
b80f6443 JA |
1435 | static char * |
1436 | j_strsignal (s) | |
1437 | int s; | |
1438 | { | |
1439 | char *x; | |
1440 | ||
1441 | x = strsignal (s); | |
1442 | if (x == 0) | |
1443 | { | |
1444 | x = retcode_name_buffer; | |
3185942a | 1445 | sprintf (x, _("Signal %d"), s); |
b80f6443 JA |
1446 | } |
1447 | return x; | |
1448 | } | |
1449 | ||
28ef6c31 JA |
1450 | static char * |
1451 | printable_job_status (j, p, format) | |
1452 | int j; | |
1453 | PROCESS *p; | |
1454 | int format; | |
1455 | { | |
1456 | static char *temp; | |
1457 | int es; | |
1458 | ||
3185942a | 1459 | temp = _("Done"); |
28ef6c31 JA |
1460 | |
1461 | if (STOPPED (j) && format == 0) | |
1462 | { | |
1463 | if (posixly_correct == 0 || p == 0 || (WIFSTOPPED (p->status) == 0)) | |
3185942a | 1464 | temp = _("Stopped"); |
28ef6c31 JA |
1465 | else |
1466 | { | |
1467 | temp = retcode_name_buffer; | |
3185942a | 1468 | sprintf (temp, _("Stopped(%s)"), signal_name (WSTOPSIG (p->status))); |
28ef6c31 JA |
1469 | } |
1470 | } | |
1471 | else if (RUNNING (j)) | |
3185942a | 1472 | temp = _("Running"); |
28ef6c31 JA |
1473 | else |
1474 | { | |
1475 | if (WIFSTOPPED (p->status)) | |
b80f6443 | 1476 | temp = j_strsignal (WSTOPSIG (p->status)); |
28ef6c31 | 1477 | else if (WIFSIGNALED (p->status)) |
b80f6443 | 1478 | temp = j_strsignal (WTERMSIG (p->status)); |
28ef6c31 JA |
1479 | else if (WIFEXITED (p->status)) |
1480 | { | |
1481 | temp = retcode_name_buffer; | |
1482 | es = WEXITSTATUS (p->status); | |
1483 | if (es == 0) | |
3185942a | 1484 | strcpy (temp, _("Done")); |
28ef6c31 | 1485 | else if (posixly_correct) |
3185942a | 1486 | sprintf (temp, _("Done(%d)"), es); |
28ef6c31 | 1487 | else |
3185942a | 1488 | sprintf (temp, _("Exit %d"), es); |
28ef6c31 JA |
1489 | } |
1490 | else | |
3185942a | 1491 | temp = _("Unknown status"); |
28ef6c31 JA |
1492 | } |
1493 | ||
1494 | return temp; | |
1495 | } | |
1496 | ||
726f6388 JA |
1497 | /* This is the way to print out information on a job if you |
1498 | know the index. FORMAT is: | |
1499 | ||
1500 | JLIST_NORMAL) [1]+ Running emacs | |
1501 | JLIST_LONG ) [1]+ 2378 Running emacs | |
1502 | -1 ) [1]+ 2378 emacs | |
1503 | ||
1504 | JLIST_NORMAL) [1]+ Stopped ls | more | |
1505 | JLIST_LONG ) [1]+ 2369 Stopped ls | |
1506 | 2367 | more | |
1507 | JLIST_PID_ONLY) | |
1508 | Just list the pid of the process group leader (really | |
1509 | the process group). | |
1510 | JLIST_CHANGED_ONLY) | |
1511 | Use format JLIST_NORMAL, but list only jobs about which | |
1512 | the user has not been notified. */ | |
ccc6cda3 JA |
1513 | |
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. | |
1517 | ||
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 */ | |
726f6388 | 1520 | static void |
ccc6cda3 JA |
1521 | print_pipeline (p, job_index, format, stream) |
1522 | PROCESS *p; | |
726f6388 JA |
1523 | int job_index, format; |
1524 | FILE *stream; | |
1525 | { | |
ccc6cda3 JA |
1526 | PROCESS *first, *last, *show; |
1527 | int es, name_padding; | |
28ef6c31 | 1528 | char *temp; |
726f6388 | 1529 | |
ccc6cda3 JA |
1530 | if (p == 0) |
1531 | return; | |
726f6388 | 1532 | |
ccc6cda3 | 1533 | first = last = p; |
726f6388 JA |
1534 | while (last->next != first) |
1535 | last = last->next; | |
1536 | ||
726f6388 JA |
1537 | for (;;) |
1538 | { | |
1539 | if (p != first) | |
1540 | fprintf (stream, format ? " " : " |"); | |
1541 | ||
ccc6cda3 | 1542 | if (format != JLIST_STANDARD) |
f73dda09 | 1543 | fprintf (stream, "%5ld", (long)p->pid); |
726f6388 JA |
1544 | |
1545 | fprintf (stream, " "); | |
1546 | ||
ccc6cda3 | 1547 | if (format > -1 && job_index >= 0) |
726f6388 | 1548 | { |
ccc6cda3 | 1549 | show = format ? p : last; |
28ef6c31 | 1550 | temp = printable_job_status (job_index, show, format); |
726f6388 JA |
1551 | |
1552 | if (p != first) | |
1553 | { | |
1554 | if (format) | |
1555 | { | |
1556 | if (show->running == first->running && | |
1557 | WSTATUS (show->status) == WSTATUS (first->status)) | |
1558 | temp = ""; | |
1559 | } | |
1560 | else | |
1561 | temp = (char *)NULL; | |
1562 | } | |
1563 | ||
1564 | if (temp) | |
1565 | { | |
726f6388 JA |
1566 | fprintf (stream, "%s", temp); |
1567 | ||
ccc6cda3 JA |
1568 | es = STRLEN (temp); |
1569 | if (es == 0) | |
28ef6c31 | 1570 | es = 2; /* strlen ("| ") */ |
ccc6cda3 | 1571 | name_padding = LONGEST_SIGNAL_DESC - es; |
726f6388 JA |
1572 | |
1573 | fprintf (stream, "%*s", name_padding, ""); | |
1574 | ||
f73dda09 JA |
1575 | if ((WIFSTOPPED (show->status) == 0) && |
1576 | (WIFCONTINUED (show->status) == 0) && | |
1577 | WIFCORED (show->status)) | |
3185942a | 1578 | fprintf (stream, _("(core dumped) ")); |
726f6388 JA |
1579 | } |
1580 | } | |
1581 | ||
1582 | if (p != first && format) | |
1583 | fprintf (stream, "| "); | |
1584 | ||
1585 | if (p->command) | |
1586 | fprintf (stream, "%s", p->command); | |
1587 | ||
ccc6cda3 | 1588 | if (p == last && job_index >= 0) |
726f6388 | 1589 | { |
ccc6cda3 | 1590 | temp = current_working_directory (); |
726f6388 | 1591 | |
ccc6cda3 | 1592 | if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0)) |
726f6388 JA |
1593 | fprintf (stream, " &"); |
1594 | ||
ccc6cda3 | 1595 | if (strcmp (temp, jobs[job_index]->wd) != 0) |
726f6388 | 1596 | fprintf (stream, |
3185942a | 1597 | _(" (wd: %s)"), polite_directory_format (jobs[job_index]->wd)); |
726f6388 JA |
1598 | } |
1599 | ||
1600 | if (format || (p == last)) | |
cce855bc JA |
1601 | { |
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"); | |
1609 | else | |
1610 | fprintf (stream, "\n"); | |
1611 | } | |
726f6388 JA |
1612 | |
1613 | if (p == last) | |
1614 | break; | |
1615 | p = p->next; | |
1616 | } | |
726f6388 | 1617 | fflush (stream); |
ccc6cda3 JA |
1618 | } |
1619 | ||
7117c2d2 JA |
1620 | /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT. |
1621 | Must be called with SIGCHLD blocked or queued with queue_sigchld */ | |
ccc6cda3 JA |
1622 | static void |
1623 | pretty_print_job (job_index, format, stream) | |
1624 | int job_index, format; | |
1625 | FILE *stream; | |
1626 | { | |
1627 | register PROCESS *p; | |
ccc6cda3 JA |
1628 | |
1629 | /* Format only pid information about the process group leader? */ | |
1630 | if (format == JLIST_PID_ONLY) | |
1631 | { | |
f73dda09 | 1632 | fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid); |
ccc6cda3 JA |
1633 | return; |
1634 | } | |
1635 | ||
1636 | if (format == JLIST_CHANGED_ONLY) | |
1637 | { | |
1638 | if (IS_NOTIFIED (job_index)) | |
7117c2d2 | 1639 | return; |
ccc6cda3 JA |
1640 | format = JLIST_STANDARD; |
1641 | } | |
1642 | ||
1643 | if (format != JLIST_NONINTERACTIVE) | |
1644 | fprintf (stream, "[%d]%c ", job_index + 1, | |
95732b49 JA |
1645 | (job_index == js.j_current) ? '+': |
1646 | (job_index == js.j_previous) ? '-' : ' '); | |
ccc6cda3 JA |
1647 | |
1648 | if (format == JLIST_NONINTERACTIVE) | |
1649 | format = JLIST_LONG; | |
1650 | ||
1651 | p = jobs[job_index]->pipe; | |
1652 | ||
cce855bc JA |
1653 | print_pipeline (p, job_index, format, stream); |
1654 | ||
ccc6cda3 JA |
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; | |
726f6388 JA |
1658 | } |
1659 | ||
ccc6cda3 JA |
1660 | static int |
1661 | print_job (job, format, state, job_index) | |
1662 | JOB *job; | |
1663 | int format, state, job_index; | |
1664 | { | |
1665 | if (state == -1 || (JOB_STATE)state == job->state) | |
1666 | pretty_print_job (job_index, format, stdout); | |
1667 | return (0); | |
1668 | } | |
1669 | ||
1670 | void | |
726f6388 JA |
1671 | list_one_job (job, format, ignore, job_index) |
1672 | JOB *job; | |
1673 | int format, ignore, job_index; | |
1674 | { | |
7117c2d2 | 1675 | pretty_print_job (job_index, format, stdout); |
ccc6cda3 JA |
1676 | } |
1677 | ||
1678 | void | |
1679 | list_stopped_jobs (format) | |
1680 | int format; | |
1681 | { | |
1682 | cleanup_dead_jobs (); | |
1683 | map_over_jobs (print_job, format, (int)JSTOPPED); | |
1684 | } | |
1685 | ||
1686 | void | |
1687 | list_running_jobs (format) | |
1688 | int format; | |
1689 | { | |
1690 | cleanup_dead_jobs (); | |
1691 | map_over_jobs (print_job, format, (int)JRUNNING); | |
726f6388 JA |
1692 | } |
1693 | ||
1694 | /* List jobs. If FORMAT is non-zero, then the long form of the information | |
1695 | is printed, else just a short version. */ | |
1696 | void | |
ccc6cda3 | 1697 | list_all_jobs (format) |
726f6388 JA |
1698 | int format; |
1699 | { | |
1700 | cleanup_dead_jobs (); | |
ccc6cda3 | 1701 | map_over_jobs (print_job, format, -1); |
726f6388 JA |
1702 | } |
1703 | ||
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. */ | |
1708 | pid_t | |
1709 | make_child (command, async_p) | |
1710 | char *command; | |
1711 | int async_p; | |
1712 | { | |
3185942a | 1713 | int forksleep; |
726f6388 JA |
1714 | sigset_t set, oset; |
1715 | pid_t pid; | |
1716 | ||
1717 | sigemptyset (&set); | |
1718 | sigaddset (&set, SIGCHLD); | |
1719 | sigaddset (&set, SIGINT); | |
1720 | sigemptyset (&oset); | |
1721 | sigprocmask (SIG_BLOCK, &set, &oset); | |
1722 | ||
1723 | making_children (); | |
1724 | ||
3185942a JA |
1725 | forksleep = 1; |
1726 | ||
726f6388 JA |
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 */ | |
1736 | ||
3185942a JA |
1737 | /* Create the child, handle severe errors. Retry on EAGAIN. */ |
1738 | while ((pid = fork ()) < 0 && errno == EAGAIN && forksleep < FORKSLEEP_MAX) | |
1739 | { | |
495aee44 | 1740 | /* bash-4.2 */ |
0001803f CR |
1741 | /* If we can't create any children, try to reap some dead ones. */ |
1742 | waitchld (-1, 0); | |
495aee44 | 1743 | |
3185942a JA |
1744 | sys_error ("fork: retry"); |
1745 | if (sleep (forksleep) != 0) | |
1746 | break; | |
1747 | forksleep <<= 1; | |
1748 | } | |
1749 | ||
1750 | if (pid < 0) | |
726f6388 | 1751 | { |
ccc6cda3 | 1752 | sys_error ("fork"); |
726f6388 JA |
1753 | |
1754 | /* Kill all of the processes in the current pipeline. */ | |
1755 | terminate_current_pipeline (); | |
1756 | ||
1757 | /* Discard the current pipeline, if any. */ | |
1758 | if (the_pipeline) | |
1759 | kill_current_pipeline (); | |
1760 | ||
0001803f | 1761 | last_command_exit_value = EX_NOEXEC; |
726f6388 JA |
1762 | throw_to_top_level (); /* Reset signals, etc. */ |
1763 | } | |
1764 | ||
1765 | if (pid == 0) | |
1766 | { | |
1767 | /* In the child. Give this child the right process group, set the | |
1768 | signals to the default state for a new process. */ | |
b72432fd | 1769 | pid_t mypid; |
726f6388 | 1770 | |
b72432fd | 1771 | mypid = getpid (); |
726f6388 JA |
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. */ | |
cce855bc | 1776 | unset_bash_input (0); |
726f6388 JA |
1777 | #endif /* BUFFERED_INPUT */ |
1778 | ||
1779 | /* Restore top-level signal mask. */ | |
1780 | sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL); | |
1781 | ||
1782 | if (job_control) | |
1783 | { | |
1784 | /* All processes in this pipeline belong in the same | |
1785 | process group. */ | |
1786 | ||
ccc6cda3 | 1787 | if (pipeline_pgrp == 0) /* This is the first child. */ |
b72432fd | 1788 | pipeline_pgrp = mypid; |
726f6388 JA |
1789 | |
1790 | /* Check for running command in backquotes. */ | |
1791 | if (pipeline_pgrp == shell_pgrp) | |
ccc6cda3 | 1792 | ignore_tty_job_signals (); |
726f6388 | 1793 | else |
ccc6cda3 | 1794 | default_tty_job_signals (); |
726f6388 JA |
1795 | |
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 | |
1803 | shells. */ | |
b72432fd | 1804 | if (setpgid (mypid, pipeline_pgrp) < 0) |
3185942a | 1805 | sys_error (_("child setpgid (%ld to %ld)"), (long)mypid, (long)pipeline_pgrp); |
b80f6443 JA |
1806 | |
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). */ | |
0628567a | 1813 | if (async_p == 0 && pipeline_pgrp != shell_pgrp && ((subshell_environment&SUBSHELL_ASYNC) == 0)) |
b80f6443 | 1814 | give_terminal_to (pipeline_pgrp, 0); |
726f6388 JA |
1815 | |
1816 | #if defined (PGRP_PIPE) | |
b80f6443 JA |
1817 | if (pipeline_pgrp == mypid) |
1818 | pipe_read (pgrp_pipe); | |
726f6388 JA |
1819 | #endif |
1820 | } | |
1821 | else /* Without job control... */ | |
1822 | { | |
ccc6cda3 | 1823 | if (pipeline_pgrp == 0) |
726f6388 JA |
1824 | pipeline_pgrp = shell_pgrp; |
1825 | ||
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. */ | |
1832 | ||
ccc6cda3 | 1833 | default_tty_job_signals (); |
726f6388 JA |
1834 | } |
1835 | ||
1836 | #if defined (PGRP_PIPE) | |
1837 | /* Release the process group pipe, since our call to setpgid () | |
3185942a JA |
1838 | is done. The last call to sh_closepipe is done in stop_pipeline. */ |
1839 | sh_closepipe (pgrp_pipe); | |
726f6388 JA |
1840 | #endif /* PGRP_PIPE */ |
1841 | ||
3185942a JA |
1842 | #if 0 |
1843 | /* Don't set last_asynchronous_pid in the child */ | |
726f6388 | 1844 | if (async_p) |
3185942a JA |
1845 | last_asynchronous_pid = mypid; /* XXX */ |
1846 | else | |
1847 | #endif | |
95732b49 | 1848 | #if defined (RECYCLES_PIDS) |
3185942a | 1849 | if (last_asynchronous_pid == mypid) |
95732b49 JA |
1850 | /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */ |
1851 | last_asynchronous_pid = 1; | |
1852 | #endif | |
726f6388 JA |
1853 | } |
1854 | else | |
1855 | { | |
1856 | /* In the parent. Remember the pid of the child just created | |
1857 | as the proper pgrp if this is the first child. */ | |
1858 | ||
0628567a JA |
1859 | if (first_pid == NO_PID) |
1860 | first_pid = pid; | |
1861 | else if (pid_wrap == -1 && pid < first_pid) | |
1862 | pid_wrap = 0; | |
1863 | else if (pid_wrap == 0 && pid >= first_pid) | |
1864 | pid_wrap = 1; | |
1865 | ||
726f6388 JA |
1866 | if (job_control) |
1867 | { | |
ccc6cda3 | 1868 | if (pipeline_pgrp == 0) |
726f6388 JA |
1869 | { |
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! */ | |
28ef6c31 | 1873 | /* give_terminal_to (pipeline_pgrp, 0); */ |
726f6388 JA |
1874 | } |
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); | |
1880 | } | |
1881 | else | |
1882 | { | |
ccc6cda3 | 1883 | if (pipeline_pgrp == 0) |
726f6388 JA |
1884 | pipeline_pgrp = shell_pgrp; |
1885 | } | |
1886 | ||
1887 | /* Place all processes into the jobs array regardless of the | |
1888 | state of job_control. */ | |
1889 | add_process (command, pid); | |
1890 | ||
1891 | if (async_p) | |
1892 | last_asynchronous_pid = pid; | |
95732b49 JA |
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; | |
1897 | #endif | |
1898 | ||
0628567a JA |
1899 | if (pid_wrap > 0) |
1900 | delete_old_job (pid); | |
1901 | ||
95732b49 JA |
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) | |
1906 | #endif | |
1907 | bgp_delete (pid); /* new process, discard any saved status */ | |
726f6388 JA |
1908 | |
1909 | last_made_pid = pid; | |
1910 | ||
95732b49 JA |
1911 | /* keep stats */ |
1912 | js.c_totforked++; | |
1913 | js.c_living++; | |
1914 | ||
1915 | /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case | |
1916 | SIGCHLD remains blocked until all commands in the pipeline have been | |
1917 | created. */ | |
726f6388 JA |
1918 | sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL); |
1919 | } | |
1920 | ||
1921 | return (pid); | |
1922 | } | |
1923 | ||
7117c2d2 | 1924 | /* These two functions are called only in child processes. */ |
ccc6cda3 JA |
1925 | void |
1926 | ignore_tty_job_signals () | |
1927 | { | |
1928 | set_signal_handler (SIGTSTP, SIG_IGN); | |
1929 | set_signal_handler (SIGTTIN, SIG_IGN); | |
1930 | set_signal_handler (SIGTTOU, SIG_IGN); | |
1931 | } | |
1932 | ||
1933 | void | |
1934 | default_tty_job_signals () | |
1935 | { | |
1936 | set_signal_handler (SIGTSTP, SIG_DFL); | |
1937 | set_signal_handler (SIGTTIN, SIG_DFL); | |
1938 | set_signal_handler (SIGTTOU, SIG_DFL); | |
1939 | } | |
1940 | ||
726f6388 JA |
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. */ | |
1944 | ||
28ef6c31 JA |
1945 | static TTYSTRUCT shell_tty_info; |
1946 | ||
726f6388 | 1947 | #if defined (NEW_TTY_DRIVER) |
726f6388 JA |
1948 | static struct tchars shell_tchars; |
1949 | static struct ltchars shell_ltchars; | |
1950 | #endif /* NEW_TTY_DRIVER */ | |
1951 | ||
726f6388 JA |
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. */ | |
1961 | ||
1962 | static int ttspeeds[] = | |
1963 | { | |
1964 | 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, | |
1965 | 1800, 2400, 4800, 9600, 19200, 38400 | |
1966 | }; | |
1967 | ||
1968 | static void | |
1969 | draino (fd, ospeed) | |
1970 | int fd, ospeed; | |
1971 | { | |
1972 | register int delay = ttspeeds[ospeed]; | |
1973 | int n; | |
1974 | ||
1975 | if (!delay) | |
1976 | return; | |
1977 | ||
1978 | while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n) | |
1979 | { | |
1980 | if (n > (delay / 100)) | |
1981 | { | |
1982 | struct timeval tv; | |
1983 | ||
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); | |
1988 | } | |
1989 | else | |
1990 | break; | |
1991 | } | |
1992 | } | |
1993 | #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */ | |
1994 | ||
1995 | /* Return the fd from which we are actually getting input. */ | |
1996 | #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr) | |
1997 | ||
1998 | /* Fill the contents of shell_tty_info with the current tty info. */ | |
ccc6cda3 | 1999 | int |
726f6388 JA |
2000 | get_tty_state () |
2001 | { | |
ccc6cda3 | 2002 | int tty; |
726f6388 | 2003 | |
ccc6cda3 | 2004 | tty = input_tty (); |
726f6388 JA |
2005 | if (tty != -1) |
2006 | { | |
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 */ | |
2012 | ||
2013 | #if defined (TERMIO_TTY_DRIVER) | |
2014 | ioctl (tty, TCGETA, &shell_tty_info); | |
2015 | #endif /* TERMIO_TTY_DRIVER */ | |
2016 | ||
2017 | #if defined (TERMIOS_TTY_DRIVER) | |
2018 | if (tcgetattr (tty, &shell_tty_info) < 0) | |
2019 | { | |
2020 | #if 0 | |
2021 | /* Only print an error message if we're really interactive at | |
2022 | this time. */ | |
2023 | if (interactive) | |
3185942a | 2024 | sys_error ("[%ld: %d (%d)] tcgetattr", (long)getpid (), shell_level, tty); |
726f6388 JA |
2025 | #endif |
2026 | return -1; | |
2027 | } | |
2028 | #endif /* TERMIOS_TTY_DRIVER */ | |
ccc6cda3 | 2029 | if (check_window_size) |
95732b49 | 2030 | get_new_window_size (0, (int *)0, (int *)0); |
726f6388 JA |
2031 | } |
2032 | return 0; | |
2033 | } | |
2034 | ||
2035 | /* Make the current tty use the state in shell_tty_info. */ | |
ccc6cda3 | 2036 | int |
726f6388 JA |
2037 | set_tty_state () |
2038 | { | |
d166f048 | 2039 | int tty; |
726f6388 | 2040 | |
d166f048 | 2041 | tty = input_tty (); |
726f6388 JA |
2042 | if (tty != -1) |
2043 | { | |
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 */ | |
2052 | ||
2053 | #if defined (TERMIO_TTY_DRIVER) | |
2054 | ioctl (tty, TCSETAW, &shell_tty_info); | |
2055 | #endif /* TERMIO_TTY_DRIVER */ | |
2056 | ||
2057 | #if defined (TERMIOS_TTY_DRIVER) | |
2058 | if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0) | |
2059 | { | |
2060 | /* Only print an error message if we're really interactive at | |
2061 | this time. */ | |
2062 | if (interactive) | |
3185942a | 2063 | sys_error ("[%ld: %d (%d)] tcsetattr", (long)getpid (), shell_level, tty); |
726f6388 JA |
2064 | return -1; |
2065 | } | |
2066 | #endif /* TERMIOS_TTY_DRIVER */ | |
2067 | } | |
2068 | return 0; | |
2069 | } | |
2070 | ||
95732b49 | 2071 | /* Given an index into the jobs array JOB, return the PROCESS struct of the last |
726f6388 | 2072 | process in that job's pipeline. This is the one whose exit status |
7117c2d2 | 2073 | counts. Must be called with SIGCHLD blocked or queued. */ |
95732b49 JA |
2074 | static PROCESS * |
2075 | find_last_proc (job, block) | |
726f6388 | 2076 | int job; |
7117c2d2 | 2077 | int block; |
726f6388 JA |
2078 | { |
2079 | register PROCESS *p; | |
7117c2d2 JA |
2080 | sigset_t set, oset; |
2081 | ||
2082 | if (block) | |
2083 | BLOCK_CHILD (set, oset); | |
726f6388 JA |
2084 | |
2085 | p = jobs[job]->pipe; | |
0628567a | 2086 | while (p && p->next != jobs[job]->pipe) |
726f6388 JA |
2087 | p = p->next; |
2088 | ||
7117c2d2 JA |
2089 | if (block) |
2090 | UNBLOCK_CHILD (oset); | |
cce855bc | 2091 | |
95732b49 | 2092 | return (p); |
cce855bc JA |
2093 | } |
2094 | ||
95732b49 JA |
2095 | static pid_t |
2096 | find_last_pid (job, block) | |
2097 | int job; | |
2098 | int block; | |
2099 | { | |
2100 | PROCESS *p; | |
2101 | ||
2102 | p = find_last_proc (job, block); | |
2103 | /* Possible race condition here. */ | |
2104 | return p->pid; | |
2105 | } | |
2106 | ||
726f6388 JA |
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 | |
7117c2d2 JA |
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 | |
bb70624e | 2111 | jobs table, it returns 127. */ |
726f6388 JA |
2112 | int |
2113 | wait_for_single_pid (pid) | |
2114 | pid_t pid; | |
2115 | { | |
2116 | register PROCESS *child; | |
ccc6cda3 | 2117 | sigset_t set, oset; |
cce855bc | 2118 | int r, job; |
726f6388 | 2119 | |
ccc6cda3 | 2120 | BLOCK_CHILD (set, oset); |
7117c2d2 | 2121 | child = find_pipeline (pid, 0, (int *)NULL); |
ccc6cda3 | 2122 | UNBLOCK_CHILD (oset); |
726f6388 | 2123 | |
95732b49 JA |
2124 | if (child == 0) |
2125 | { | |
2126 | r = bgp_search (pid); | |
2127 | if (r >= 0) | |
2128 | return r; | |
2129 | } | |
2130 | ||
ccc6cda3 | 2131 | if (child == 0) |
726f6388 | 2132 | { |
b80f6443 | 2133 | internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid); |
726f6388 JA |
2134 | return (127); |
2135 | } | |
2136 | ||
cce855bc JA |
2137 | r = wait_for (pid); |
2138 | ||
b72432fd JA |
2139 | /* POSIX.2: if we just waited for a job, we can remove it from the jobs |
2140 | table. */ | |
2141 | BLOCK_CHILD (set, oset); | |
95732b49 | 2142 | job = find_job (pid, 0, NULL); |
b72432fd JA |
2143 | if (job != NO_JOB && jobs[job] && DEADJOB (job)) |
2144 | jobs[job]->flags |= J_NOTIFIED; | |
2145 | UNBLOCK_CHILD (oset); | |
cce855bc | 2146 | |
95732b49 JA |
2147 | /* If running in posix mode, remove the job from the jobs table immediately */ |
2148 | if (posixly_correct) | |
2149 | { | |
2150 | cleanup_dead_jobs (); | |
2151 | bgp_delete (pid); | |
2152 | } | |
2153 | ||
cce855bc | 2154 | return r; |
726f6388 JA |
2155 | } |
2156 | ||
495aee44 | 2157 | /* Wait for all of the background processes started by this shell to finish. */ |
726f6388 JA |
2158 | void |
2159 | wait_for_background_pids () | |
2160 | { | |
7117c2d2 | 2161 | register int i, r, waited_for; |
ccc6cda3 JA |
2162 | sigset_t set, oset; |
2163 | pid_t pid; | |
726f6388 | 2164 | |
bb70624e | 2165 | for (waited_for = 0;;) |
ccc6cda3 | 2166 | { |
726f6388 JA |
2167 | BLOCK_CHILD (set, oset); |
2168 | ||
7117c2d2 | 2169 | /* find first running job; if none running in foreground, break */ |
0628567a | 2170 | /* XXX could use js.j_firstj and js.j_lastj here */ |
95732b49 JA |
2171 | for (i = 0; i < js.j_jobslots; i++) |
2172 | { | |
2173 | #if defined (DEBUG) | |
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); | |
0628567a JA |
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); | |
95732b49 JA |
2178 | #endif |
2179 | if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0) | |
2180 | break; | |
2181 | } | |
2182 | if (i == js.j_jobslots) | |
726f6388 JA |
2183 | { |
2184 | UNBLOCK_CHILD (oset); | |
2185 | break; | |
2186 | } | |
2187 | ||
7117c2d2 JA |
2188 | /* now wait for the last pid in that job. */ |
2189 | pid = find_last_pid (i, 0); | |
2190 | UNBLOCK_CHILD (oset); | |
2191 | QUIT; | |
2192 | errno = 0; /* XXX */ | |
2193 | r = wait_for_single_pid (pid); | |
2194 | if (r == -1) | |
2195 | { | |
2196 | /* If we're mistaken about job state, compensate. */ | |
2197 | if (errno == ECHILD) | |
2198 | mark_all_jobs_as_dead (); | |
2199 | } | |
2200 | else | |
2201 | waited_for++; | |
726f6388 | 2202 | } |
b72432fd JA |
2203 | |
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 (); | |
95732b49 | 2208 | bgp_clear (); |
726f6388 JA |
2209 | } |
2210 | ||
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; | |
2214 | ||
2215 | static void | |
2216 | restore_sigint_handler () | |
2217 | { | |
2218 | if (old_sigint_handler != INVALID_SIGNAL_HANDLER) | |
2219 | { | |
2220 | set_signal_handler (SIGINT, old_sigint_handler); | |
2221 | old_sigint_handler = INVALID_SIGNAL_HANDLER; | |
2222 | } | |
2223 | } | |
2224 | ||
ccc6cda3 | 2225 | static int wait_sigint_received; |
726f6388 JA |
2226 | |
2227 | /* Handle SIGINT while we are waiting for children in a script to exit. | |
2228 | The `wait' builtin should be interruptible, but all others should be | |
2229 | effectively ignored (i.e. not cause the shell to exit). */ | |
2230 | static sighandler | |
2231 | wait_sigint_handler (sig) | |
2232 | int sig; | |
2233 | { | |
bb70624e JA |
2234 | SigHandler *sigint_handler; |
2235 | ||
726f6388 JA |
2236 | if (interrupt_immediately || |
2237 | (this_shell_builtin && this_shell_builtin == wait_builtin)) | |
2238 | { | |
2239 | last_command_exit_value = EXECUTION_FAILURE; | |
2240 | restore_sigint_handler (); | |
bb70624e | 2241 | /* If we got a SIGINT while in `wait', and SIGINT is trapped, do |
28ef6c31 | 2242 | what POSIX.2 says (see builtins/wait.def for more info). */ |
bb70624e JA |
2243 | if (this_shell_builtin && this_shell_builtin == wait_builtin && |
2244 | signal_is_trapped (SIGINT) && | |
2245 | ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler)) | |
2246 | { | |
2247 | interrupt_immediately = 0; | |
2248 | trap_handler (SIGINT); /* set pending_traps[SIGINT] */ | |
7117c2d2 | 2249 | wait_signal_received = SIGINT; |
bb70624e JA |
2250 | longjmp (wait_intr_buf, 1); |
2251 | } | |
2252 | ||
ccc6cda3 | 2253 | ADDINTERRUPT; |
726f6388 JA |
2254 | QUIT; |
2255 | } | |
2256 | ||
ccc6cda3 JA |
2257 | /* XXX - should this be interrupt_state? If it is, the shell will act |
2258 | as if it got the SIGINT interrupt. */ | |
2259 | wait_sigint_received = 1; | |
2260 | ||
726f6388 JA |
2261 | /* Otherwise effectively ignore the SIGINT and allow the running job to |
2262 | be killed. */ | |
ccc6cda3 | 2263 | SIGRETURN (0); |
726f6388 JA |
2264 | } |
2265 | ||
b80f6443 JA |
2266 | static int |
2267 | process_exit_signal (status) | |
2268 | WAIT status; | |
2269 | { | |
2270 | return (WIFSIGNALED (status) ? WTERMSIG (status) : 0); | |
2271 | } | |
2272 | ||
726f6388 JA |
2273 | static int |
2274 | process_exit_status (status) | |
2275 | WAIT status; | |
2276 | { | |
2277 | if (WIFSIGNALED (status)) | |
2278 | return (128 + WTERMSIG (status)); | |
ccc6cda3 | 2279 | else if (WIFSTOPPED (status) == 0) |
726f6388 JA |
2280 | return (WEXITSTATUS (status)); |
2281 | else | |
2282 | return (EXECUTION_SUCCESS); | |
2283 | } | |
2284 | ||
f1be666c JA |
2285 | static WAIT |
2286 | job_signal_status (job) | |
2287 | int job; | |
2288 | { | |
2289 | register PROCESS *p; | |
2290 | WAIT s; | |
2291 | ||
2292 | p = jobs[job]->pipe; | |
2293 | do | |
2294 | { | |
2295 | s = p->status; | |
2296 | if (WIFSIGNALED(s) || WIFSTOPPED(s)) | |
2297 | break; | |
2298 | p = p->next; | |
2299 | } | |
2300 | while (p != jobs[job]->pipe); | |
2301 | ||
2302 | return s; | |
2303 | } | |
2304 | ||
28ef6c31 JA |
2305 | /* Return the exit status of the last process in the pipeline for job JOB. |
2306 | This is the exit status of the entire job. */ | |
2307 | static WAIT | |
bb70624e | 2308 | raw_job_exit_status (job) |
f73dda09 | 2309 | int job; |
ccc6cda3 JA |
2310 | { |
2311 | register PROCESS *p; | |
b80f6443 | 2312 | int fail; |
3185942a | 2313 | WAIT ret; |
b80f6443 JA |
2314 | |
2315 | if (pipefail_opt) | |
2316 | { | |
2317 | fail = 0; | |
eb873671 JA |
2318 | p = jobs[job]->pipe; |
2319 | do | |
2320 | { | |
3185942a JA |
2321 | if (WSTATUS (p->status) != EXECUTION_SUCCESS) |
2322 | fail = WSTATUS(p->status); | |
eb873671 JA |
2323 | p = p->next; |
2324 | } | |
2325 | while (p != jobs[job]->pipe); | |
3185942a JA |
2326 | WSTATUS (ret) = fail; |
2327 | return ret; | |
b80f6443 JA |
2328 | } |
2329 | ||
ccc6cda3 JA |
2330 | for (p = jobs[job]->pipe; p->next != jobs[job]->pipe; p = p->next) |
2331 | ; | |
bb70624e JA |
2332 | return (p->status); |
2333 | } | |
2334 | ||
28ef6c31 JA |
2335 | /* Return the exit status of job JOB. This is the exit status of the last |
2336 | (rightmost) process in the job's pipeline, modified if the job was killed | |
2337 | by a signal or stopped. */ | |
495aee44 | 2338 | int |
bb70624e JA |
2339 | job_exit_status (job) |
2340 | int job; | |
2341 | { | |
2342 | return (process_exit_status (raw_job_exit_status (job))); | |
ccc6cda3 JA |
2343 | } |
2344 | ||
495aee44 | 2345 | int |
b80f6443 JA |
2346 | job_exit_signal (job) |
2347 | int job; | |
2348 | { | |
2349 | return (process_exit_signal (raw_job_exit_status (job))); | |
2350 | } | |
2351 | ||
ccc6cda3 JA |
2352 | #define FIND_CHILD(pid, child) \ |
2353 | do \ | |
2354 | { \ | |
7117c2d2 | 2355 | child = find_pipeline (pid, 0, (int *)NULL); \ |
ccc6cda3 JA |
2356 | if (child == 0) \ |
2357 | { \ | |
28ef6c31 | 2358 | give_terminal_to (shell_pgrp, 0); \ |
ccc6cda3 | 2359 | UNBLOCK_CHILD (oset); \ |
b80f6443 | 2360 | internal_error (_("wait_for: No record of process %ld"), (long)pid); \ |
ccc6cda3 JA |
2361 | restore_sigint_handler (); \ |
2362 | return (termination_state = 127); \ | |
2363 | } \ | |
2364 | } \ | |
2365 | while (0) | |
2366 | ||
bb70624e JA |
2367 | /* Wait for pid (one of our children) to terminate, then |
2368 | return the termination state. Returns 127 if PID is not found in | |
2369 | the jobs table. Returns -1 if waitchld() returns -1, indicating | |
2370 | that there are no unwaited-for child processes. */ | |
726f6388 JA |
2371 | int |
2372 | wait_for (pid) | |
2373 | pid_t pid; | |
2374 | { | |
28ef6c31 JA |
2375 | int job, termination_state, r; |
2376 | WAIT s; | |
726f6388 JA |
2377 | register PROCESS *child; |
2378 | sigset_t set, oset; | |
2379 | ||
2380 | /* In the case that this code is interrupted, and we longjmp () out of it, | |
2381 | we are relying on the code in throw_to_top_level () to restore the | |
2382 | top-level signal mask. */ | |
2383 | BLOCK_CHILD (set, oset); | |
2384 | ||
2385 | /* Ignore interrupts while waiting for a job run without job control | |
2386 | to finish. We don't want the shell to exit if an interrupt is | |
2387 | received, only if one of the jobs run is killed via SIGINT. If | |
ccc6cda3 | 2388 | job control is not set, the job will be run in the same pgrp as |
f1be666c JA |
2389 | the shell, and the shell will see any signals the job gets. In |
2390 | fact, we want this set every time the waiting shell and the waited- | |
2391 | for process are in the same process group, including command | |
2392 | substitution. */ | |
726f6388 JA |
2393 | |
2394 | /* This is possibly a race condition -- should it go in stop_pipeline? */ | |
2395 | wait_sigint_received = 0; | |
f1be666c | 2396 | if (job_control == 0 || (subshell_environment&SUBSHELL_COMSUB)) |
0628567a JA |
2397 | { |
2398 | old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler); | |
2399 | if (old_sigint_handler == SIG_IGN) | |
2400 | set_signal_handler (SIGINT, old_sigint_handler); | |
2401 | } | |
726f6388 JA |
2402 | |
2403 | termination_state = last_command_exit_value; | |
2404 | ||
ccc6cda3 | 2405 | if (interactive && job_control == 0) |
726f6388 | 2406 | QUIT; |
0001803f CR |
2407 | /* Check for terminating signals and exit the shell if we receive one */ |
2408 | CHECK_TERMSIG; | |
726f6388 | 2409 | |
ccc6cda3 JA |
2410 | /* If we say wait_for (), then we have a record of this child somewhere. |
2411 | If it and none of its peers are running, don't call waitchld(). */ | |
726f6388 | 2412 | |
ccc6cda3 JA |
2413 | job = NO_JOB; |
2414 | do | |
726f6388 | 2415 | { |
ccc6cda3 | 2416 | FIND_CHILD (pid, child); |
726f6388 | 2417 | |
ccc6cda3 | 2418 | /* If this child is part of a job, then we are really waiting for the |
28ef6c31 JA |
2419 | job to finish. Otherwise, we are waiting for the child to finish. |
2420 | We check for JDEAD in case the job state has been set by waitchld | |
2421 | after receipt of a SIGCHLD. */ | |
ccc6cda3 | 2422 | if (job == NO_JOB) |
95732b49 | 2423 | job = find_job (pid, 0, NULL); |
726f6388 | 2424 | |
28ef6c31 JA |
2425 | /* waitchld() takes care of setting the state of the job. If the job |
2426 | has already exited before this is called, sigchld_handler will have | |
2427 | called waitchld and the state will be set to JDEAD. */ | |
726f6388 | 2428 | |
95732b49 | 2429 | if (PRUNNING(child) || (job != NO_JOB && RUNNING (job))) |
ccc6cda3 JA |
2430 | { |
2431 | #if defined (WAITPID_BROKEN) /* SCOv4 */ | |
2432 | sigset_t suspend_set; | |
2433 | sigemptyset (&suspend_set); | |
2434 | sigsuspend (&suspend_set); | |
726f6388 | 2435 | #else /* !WAITPID_BROKEN */ |
ccc6cda3 JA |
2436 | # if defined (MUST_UNBLOCK_CHLD) |
2437 | struct sigaction act, oact; | |
2438 | sigset_t nullset, chldset; | |
2439 | ||
2440 | sigemptyset (&nullset); | |
2441 | sigemptyset (&chldset); | |
2442 | sigprocmask (SIG_SETMASK, &nullset, &chldset); | |
2443 | act.sa_handler = SIG_DFL; | |
2444 | sigemptyset (&act.sa_mask); | |
2445 | sigemptyset (&oact.sa_mask); | |
2446 | act.sa_flags = 0; | |
2447 | sigaction (SIGCHLD, &act, &oact); | |
726f6388 | 2448 | # endif |
7117c2d2 | 2449 | queue_sigchld = 1; |
bb70624e | 2450 | r = waitchld (pid, 1); |
ccc6cda3 JA |
2451 | # if defined (MUST_UNBLOCK_CHLD) |
2452 | sigaction (SIGCHLD, &oact, (struct sigaction *)NULL); | |
2453 | sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL); | |
726f6388 | 2454 | # endif |
7117c2d2 | 2455 | queue_sigchld = 0; |
bb70624e JA |
2456 | if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin) |
2457 | { | |
2458 | termination_state = -1; | |
2459 | goto wait_for_return; | |
2460 | } | |
28ef6c31 JA |
2461 | |
2462 | /* If child is marked as running, but waitpid() returns -1/ECHILD, | |
2463 | there is something wrong. Somewhere, wait should have returned | |
2464 | that child's pid. Mark the child as not running and the job, | |
2465 | if it exists, as JDEAD. */ | |
2466 | if (r == -1 && errno == ECHILD) | |
2467 | { | |
7117c2d2 | 2468 | child->running = PS_DONE; |
3185942a | 2469 | WSTATUS (child->status) = 0; /* XXX -- can't find true status */ |
0628567a | 2470 | js.c_living = 0; /* no living child processes */ |
28ef6c31 | 2471 | if (job != NO_JOB) |
95732b49 JA |
2472 | { |
2473 | jobs[job]->state = JDEAD; | |
2474 | js.c_reaped++; | |
2475 | js.j_ndead++; | |
2476 | } | |
28ef6c31 | 2477 | } |
ccc6cda3 JA |
2478 | #endif /* WAITPID_BROKEN */ |
2479 | } | |
2480 | ||
2481 | /* If the shell is interactive, and job control is disabled, see | |
2482 | if the foreground process has died due to SIGINT and jump out | |
2483 | of the wait loop if it has. waitchld has already restored the | |
2484 | old SIGINT signal handler. */ | |
2485 | if (interactive && job_control == 0) | |
2486 | QUIT; | |
0001803f CR |
2487 | /* Check for terminating signals and exit the shell if we receive one */ |
2488 | CHECK_TERMSIG; | |
726f6388 | 2489 | } |
95732b49 | 2490 | while (PRUNNING (child) || (job != NO_JOB && RUNNING (job))); |
726f6388 JA |
2491 | |
2492 | /* The exit state of the command is either the termination state of the | |
2493 | child, or the termination state of the job. If a job, the status | |
b80f6443 JA |
2494 | of the last child in the pipeline is the significant one. If the command |
2495 | or job was terminated by a signal, note that value also. */ | |
2496 | termination_state = (job != NO_JOB) ? job_exit_status (job) | |
2497 | : process_exit_status (child->status); | |
2498 | last_command_exit_signal = (job != NO_JOB) ? job_exit_signal (job) | |
2499 | : process_exit_signal (child->status); | |
726f6388 | 2500 | |
95732b49 JA |
2501 | /* XXX */ |
2502 | if ((job != NO_JOB && JOBSTATE (job) == JSTOPPED) || WIFSTOPPED (child->status)) | |
2503 | termination_state = 128 + WSTOPSIG (child->status); | |
2504 | ||
ccc6cda3 | 2505 | if (job == NO_JOB || IS_JOBCONTROL (job)) |
b72432fd JA |
2506 | { |
2507 | /* XXX - under what circumstances is a job not present in the jobs | |
2508 | table (job == NO_JOB)? | |
2509 | 1. command substitution | |
2510 | ||
2511 | In the case of command substitution, at least, it's probably not | |
2512 | the right thing to give the terminal to the shell's process group, | |
2513 | even though there is code in subst.c:command_substitute to work | |
2514 | around it. | |
2515 | ||
2516 | Things that don't: | |
2517 | $PROMPT_COMMAND execution | |
2518 | process substitution | |
2519 | */ | |
2520 | #if 0 | |
2521 | if (job == NO_JOB) | |
f73dda09 | 2522 | itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp); |
b72432fd | 2523 | #endif |
28ef6c31 | 2524 | give_terminal_to (shell_pgrp, 0); |
b72432fd | 2525 | } |
726f6388 JA |
2526 | |
2527 | /* If the command did not exit cleanly, or the job is just | |
2528 | being stopped, then reset the tty state back to what it | |
2529 | was before this command. Reset the tty state and notify | |
2530 | the user of the job termination only if the shell is | |
2531 | interactive. Clean up any dead jobs in either case. */ | |
2532 | if (job != NO_JOB) | |
2533 | { | |
ccc6cda3 | 2534 | if (interactive_shell && subshell_environment == 0) |
726f6388 | 2535 | { |
bb70624e JA |
2536 | /* This used to use `child->status'. That's wrong, however, for |
2537 | pipelines. `child' is the first process in the pipeline. It's | |
2538 | likely that the process we want to check for abnormal termination | |
2539 | or stopping is the last process in the pipeline, especially if | |
2540 | it's long-lived and the first process is short-lived. Since we | |
2541 | know we have a job here, we can check all the processes in this | |
2542 | job's pipeline and see if one of them stopped or terminated due | |
2543 | to a signal. We might want to change this later to just check | |
2544 | the last process in the pipeline. If no process exits due to a | |
2545 | signal, S is left as the status of the last job in the pipeline. */ | |
f1be666c | 2546 | s = job_signal_status (job); |
bb70624e JA |
2547 | |
2548 | if (WIFSIGNALED (s) || WIFSTOPPED (s)) | |
e8ce775d JA |
2549 | { |
2550 | set_tty_state (); | |
28ef6c31 | 2551 | |
bb70624e JA |
2552 | /* If the current job was stopped or killed by a signal, and |
2553 | the user has requested it, get a possibly new window size */ | |
95732b49 JA |
2554 | if (check_window_size && (job == js.j_current || IS_FOREGROUND (job))) |
2555 | get_new_window_size (0, (int *)0, (int *)0); | |
e8ce775d | 2556 | } |
726f6388 JA |
2557 | else |
2558 | get_tty_state (); | |
2559 | ||
2560 | /* If job control is enabled, the job was started with job | |
2561 | control, the job was the foreground job, and it was killed | |
2562 | by SIGINT, then print a newline to compensate for the kernel | |
2563 | printing the ^C without a trailing newline. */ | |
ccc6cda3 | 2564 | if (job_control && IS_JOBCONTROL (job) && IS_FOREGROUND (job) && |
bb70624e | 2565 | WIFSIGNALED (s) && WTERMSIG (s) == SIGINT) |
726f6388 | 2566 | { |
ccc6cda3 JA |
2567 | /* If SIGINT is not trapped and the shell is in a for, while, |
2568 | or until loop, act as if the shell received SIGINT as | |
2569 | well, so the loop can be broken. This doesn't call the | |
2570 | SIGINT signal handler; maybe it should. */ | |
3185942a | 2571 | if (signal_is_trapped (SIGINT) == 0 && (loop_level || (shell_compatibility_level > 32 && executing_list))) |
ccc6cda3 JA |
2572 | ADDINTERRUPT; |
2573 | else | |
726f6388 | 2574 | { |
ccc6cda3 JA |
2575 | putchar ('\n'); |
2576 | fflush (stdout); | |
726f6388 JA |
2577 | } |
2578 | } | |
726f6388 | 2579 | } |
495aee44 | 2580 | else if ((subshell_environment & (SUBSHELL_COMSUB|SUBSHELL_PIPE)) && wait_sigint_received) |
f1be666c JA |
2581 | { |
2582 | /* If waiting for a job in a subshell started to do command | |
495aee44 CR |
2583 | substitution or to run a pipeline element that consists of |
2584 | something like a while loop or a for loop, simulate getting | |
2585 | and being killed by the SIGINT to pass the status back to our | |
2586 | parent. */ | |
f1be666c JA |
2587 | s = job_signal_status (job); |
2588 | ||
2589 | if (WIFSIGNALED (s) && WTERMSIG (s) == SIGINT && signal_is_trapped (SIGINT) == 0) | |
2590 | { | |
2591 | UNBLOCK_CHILD (oset); | |
2592 | restore_sigint_handler (); | |
2593 | old_sigint_handler = set_signal_handler (SIGINT, SIG_DFL); | |
2594 | if (old_sigint_handler == SIG_IGN) | |
2595 | restore_sigint_handler (); | |
2596 | else | |
2597 | kill (getpid (), SIGINT); | |
2598 | } | |
2599 | } | |
28ef6c31 | 2600 | |
7117c2d2 JA |
2601 | /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD |
2602 | signal handler path */ | |
2603 | if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/) | |
2604 | setjstatus (job); | |
2605 | ||
28ef6c31 JA |
2606 | /* If this job is dead, notify the user of the status. If the shell |
2607 | is interactive, this will display a message on the terminal. If | |
2608 | the shell is not interactive, make sure we turn on the notify bit | |
2609 | so we don't get an unwanted message about the job's termination, | |
2610 | and so delete_job really clears the slot in the jobs table. */ | |
2611 | notify_and_cleanup (); | |
726f6388 | 2612 | } |
ccc6cda3 | 2613 | |
bb70624e JA |
2614 | wait_for_return: |
2615 | ||
726f6388 JA |
2616 | UNBLOCK_CHILD (oset); |
2617 | ||
2618 | /* Restore the original SIGINT signal handler before we return. */ | |
2619 | restore_sigint_handler (); | |
2620 | ||
2621 | return (termination_state); | |
2622 | } | |
2623 | ||
bb70624e JA |
2624 | /* Wait for the last process in the pipeline for JOB. Returns whatever |
2625 | wait_for returns: the last process's termination state or -1 if there | |
2626 | are no unwaited-for child processes or an error occurs. */ | |
726f6388 JA |
2627 | int |
2628 | wait_for_job (job) | |
2629 | int job; | |
2630 | { | |
ccc6cda3 | 2631 | pid_t pid; |
cce855bc JA |
2632 | int r; |
2633 | sigset_t set, oset; | |
2634 | ||
2635 | BLOCK_CHILD(set, oset); | |
2636 | if (JOBSTATE (job) == JSTOPPED) | |
b80f6443 | 2637 | internal_warning (_("wait_for_job: job %d is stopped"), job+1); |
ccc6cda3 | 2638 | |
7117c2d2 JA |
2639 | pid = find_last_pid (job, 0); |
2640 | UNBLOCK_CHILD(oset); | |
cce855bc JA |
2641 | r = wait_for (pid); |
2642 | ||
b72432fd JA |
2643 | /* POSIX.2: we can remove the job from the jobs table if we just waited |
2644 | for it. */ | |
2645 | BLOCK_CHILD (set, oset); | |
2646 | if (job != NO_JOB && jobs[job] && DEADJOB (job)) | |
2647 | jobs[job]->flags |= J_NOTIFIED; | |
2648 | UNBLOCK_CHILD (oset); | |
cce855bc JA |
2649 | |
2650 | return r; | |
726f6388 JA |
2651 | } |
2652 | ||
2653 | /* Print info about dead jobs, and then delete them from the list | |
2654 | of known jobs. This does not actually delete jobs when the | |
2655 | shell is not interactive, because the dead jobs are not marked | |
2656 | as notified. */ | |
2657 | void | |
2658 | notify_and_cleanup () | |
2659 | { | |
ccc6cda3 | 2660 | if (jobs_list_frozen) |
726f6388 JA |
2661 | return; |
2662 | ||
28ef6c31 | 2663 | if (interactive || interactive_shell == 0 || sourcelevel) |
726f6388 JA |
2664 | notify_of_job_status (); |
2665 | ||
2666 | cleanup_dead_jobs (); | |
2667 | } | |
2668 | ||
2669 | /* Make dead jobs disappear from the jobs array without notification. | |
2670 | This is used when the shell is not interactive. */ | |
2671 | void | |
2672 | reap_dead_jobs () | |
2673 | { | |
b72432fd | 2674 | mark_dead_jobs_as_notified (0); |
726f6388 JA |
2675 | cleanup_dead_jobs (); |
2676 | } | |
2677 | ||
2678 | /* Return the next closest (chronologically) job to JOB which is in | |
2679 | STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if | |
2680 | there is no next recent job. */ | |
2681 | static int | |
2682 | most_recent_job_in_state (job, state) | |
2683 | int job; | |
2684 | JOB_STATE state; | |
2685 | { | |
2686 | register int i, result; | |
2687 | sigset_t set, oset; | |
2688 | ||
2689 | BLOCK_CHILD (set, oset); | |
7117c2d2 | 2690 | |
ccc6cda3 | 2691 | for (result = NO_JOB, i = job - 1; i >= 0; i--) |
726f6388 | 2692 | { |
ccc6cda3 | 2693 | if (jobs[i] && (JOBSTATE (i) == state)) |
726f6388 | 2694 | { |
ccc6cda3 JA |
2695 | result = i; |
2696 | break; | |
726f6388 JA |
2697 | } |
2698 | } | |
7117c2d2 | 2699 | |
726f6388 | 2700 | UNBLOCK_CHILD (oset); |
ccc6cda3 | 2701 | |
726f6388 JA |
2702 | return (result); |
2703 | } | |
2704 | ||
2705 | /* Return the newest *stopped* job older than JOB, or NO_JOB if not | |
2706 | found. */ | |
2707 | static int | |
28ef6c31 | 2708 | job_last_stopped (job) |
726f6388 JA |
2709 | int job; |
2710 | { | |
2711 | return (most_recent_job_in_state (job, JSTOPPED)); | |
2712 | } | |
2713 | ||
2714 | /* Return the newest *running* job older than JOB, or NO_JOB if not | |
2715 | found. */ | |
2716 | static int | |
28ef6c31 | 2717 | job_last_running (job) |
726f6388 JA |
2718 | int job; |
2719 | { | |
2720 | return (most_recent_job_in_state (job, JRUNNING)); | |
2721 | } | |
2722 | ||
2723 | /* Make JOB be the current job, and make previous be useful. Must be | |
2724 | called with SIGCHLD blocked. */ | |
2725 | static void | |
2726 | set_current_job (job) | |
2727 | int job; | |
2728 | { | |
ccc6cda3 | 2729 | int candidate; |
726f6388 | 2730 | |
95732b49 | 2731 | if (js.j_current != job) |
726f6388 | 2732 | { |
95732b49 JA |
2733 | js.j_previous = js.j_current; |
2734 | js.j_current = job; | |
726f6388 JA |
2735 | } |
2736 | ||
95732b49 JA |
2737 | /* First choice for previous job is the old current job. */ |
2738 | if (js.j_previous != js.j_current && | |
2739 | js.j_previous != NO_JOB && | |
2740 | jobs[js.j_previous] && | |
2741 | STOPPED (js.j_previous)) | |
726f6388 JA |
2742 | return; |
2743 | ||
2744 | /* Second choice: Newest stopped job that is older than | |
2745 | the current job. */ | |
ccc6cda3 | 2746 | candidate = NO_JOB; |
95732b49 | 2747 | if (STOPPED (js.j_current)) |
726f6388 | 2748 | { |
95732b49 | 2749 | candidate = job_last_stopped (js.j_current); |
726f6388 JA |
2750 | |
2751 | if (candidate != NO_JOB) | |
2752 | { | |
95732b49 | 2753 | js.j_previous = candidate; |
726f6388 JA |
2754 | return; |
2755 | } | |
2756 | } | |
2757 | ||
2758 | /* If we get here, there is either only one stopped job, in which case it is | |
2759 | the current job and the previous job should be set to the newest running | |
2760 | job, or there are only running jobs and the previous job should be set to | |
2761 | the newest running job older than the current job. We decide on which | |
95732b49 | 2762 | alternative to use based on whether or not JOBSTATE(js.j_current) is |
726f6388 JA |
2763 | JSTOPPED. */ |
2764 | ||
95732b49 JA |
2765 | candidate = RUNNING (js.j_current) ? job_last_running (js.j_current) |
2766 | : job_last_running (js.j_jobslots); | |
726f6388 JA |
2767 | |
2768 | if (candidate != NO_JOB) | |
2769 | { | |
95732b49 | 2770 | js.j_previous = candidate; |
726f6388 JA |
2771 | return; |
2772 | } | |
2773 | ||
2774 | /* There is only a single job, and it is both `+' and `-'. */ | |
95732b49 | 2775 | js.j_previous = js.j_current; |
726f6388 JA |
2776 | } |
2777 | ||
2778 | /* Make current_job be something useful, if it isn't already. */ | |
2779 | ||
2780 | /* Here's the deal: The newest non-running job should be `+', and the | |
2781 | next-newest non-running job should be `-'. If there is only a single | |
95732b49 | 2782 | stopped job, the js.j_previous is the newest non-running job. If there |
726f6388 JA |
2783 | are only running jobs, the newest running job is `+' and the |
2784 | next-newest running job is `-'. Must be called with SIGCHLD blocked. */ | |
ccc6cda3 | 2785 | |
726f6388 JA |
2786 | static void |
2787 | reset_current () | |
2788 | { | |
ccc6cda3 | 2789 | int candidate; |
726f6388 | 2790 | |
95732b49 JA |
2791 | if (js.j_jobslots && js.j_current != NO_JOB && jobs[js.j_current] && STOPPED (js.j_current)) |
2792 | candidate = js.j_current; | |
726f6388 JA |
2793 | else |
2794 | { | |
ccc6cda3 JA |
2795 | candidate = NO_JOB; |
2796 | ||
2797 | /* First choice: the previous job. */ | |
95732b49 JA |
2798 | if (js.j_previous != NO_JOB && jobs[js.j_previous] && STOPPED (js.j_previous)) |
2799 | candidate = js.j_previous; | |
726f6388 JA |
2800 | |
2801 | /* Second choice: the most recently stopped job. */ | |
2802 | if (candidate == NO_JOB) | |
95732b49 | 2803 | candidate = job_last_stopped (js.j_jobslots); |
726f6388 | 2804 | |
ccc6cda3 | 2805 | /* Third choice: the newest running job. */ |
726f6388 | 2806 | if (candidate == NO_JOB) |
95732b49 | 2807 | candidate = job_last_running (js.j_jobslots); |
726f6388 JA |
2808 | } |
2809 | ||
2810 | /* If we found a job to use, then use it. Otherwise, there | |
2811 | are no jobs period. */ | |
2812 | if (candidate != NO_JOB) | |
2813 | set_current_job (candidate); | |
2814 | else | |
95732b49 | 2815 | js.j_current = js.j_previous = NO_JOB; |
726f6388 JA |
2816 | } |
2817 | ||
d166f048 JA |
2818 | /* Set up the job structures so we know the job and its processes are |
2819 | all running. */ | |
2820 | static void | |
2821 | set_job_running (job) | |
2822 | int job; | |
2823 | { | |
2824 | register PROCESS *p; | |
2825 | ||
2826 | /* Each member of the pipeline is now running. */ | |
2827 | p = jobs[job]->pipe; | |
2828 | ||
2829 | do | |
2830 | { | |
2831 | if (WIFSTOPPED (p->status)) | |
7117c2d2 | 2832 | p->running = PS_RUNNING; /* XXX - could be PS_STOPPED */ |
d166f048 JA |
2833 | p = p->next; |
2834 | } | |
2835 | while (p != jobs[job]->pipe); | |
2836 | ||
2837 | /* This means that the job is running. */ | |
2838 | JOBSTATE (job) = JRUNNING; | |
2839 | } | |
2840 | ||
726f6388 JA |
2841 | /* Start a job. FOREGROUND if non-zero says to do that. Otherwise, |
2842 | start the job in the background. JOB is a zero-based index into | |
2843 | JOBS. Returns -1 if it is unable to start a job, and the return | |
2844 | status of the job otherwise. */ | |
2845 | int | |
2846 | start_job (job, foreground) | |
2847 | int job, foreground; | |
2848 | { | |
2849 | register PROCESS *p; | |
2850 | int already_running; | |
2851 | sigset_t set, oset; | |
95732b49 | 2852 | char *wd, *s; |
28ef6c31 | 2853 | static TTYSTRUCT save_stty; |
726f6388 JA |
2854 | |
2855 | BLOCK_CHILD (set, oset); | |
726f6388 | 2856 | |
ccc6cda3 | 2857 | if (DEADJOB (job)) |
726f6388 | 2858 | { |
b80f6443 | 2859 | internal_error (_("%s: job has terminated"), this_command_name); |
726f6388 JA |
2860 | UNBLOCK_CHILD (oset); |
2861 | return (-1); | |
2862 | } | |
2863 | ||
ccc6cda3 JA |
2864 | already_running = RUNNING (job); |
2865 | ||
2866 | if (foreground == 0 && already_running) | |
726f6388 | 2867 | { |
b80f6443 | 2868 | internal_error (_("%s: job %d already in background"), this_command_name, job + 1); |
726f6388 | 2869 | UNBLOCK_CHILD (oset); |
95732b49 | 2870 | return (0); /* XPG6/SUSv3 says this is not an error */ |
726f6388 JA |
2871 | } |
2872 | ||
2873 | wd = current_working_directory (); | |
2874 | ||
2875 | /* You don't know about the state of this job. Do you? */ | |
2876 | jobs[job]->flags &= ~J_NOTIFIED; | |
2877 | ||
2878 | if (foreground) | |
2879 | { | |
2880 | set_current_job (job); | |
2881 | jobs[job]->flags |= J_FOREGROUND; | |
2882 | } | |
2883 | ||
2884 | /* Tell the outside world what we're doing. */ | |
2885 | p = jobs[job]->pipe; | |
2886 | ||
ccc6cda3 | 2887 | if (foreground == 0) |
95732b49 JA |
2888 | { |
2889 | /* POSIX.2 says `bg' doesn't give any indication about current or | |
2890 | previous job. */ | |
2891 | if (posixly_correct == 0) | |
2892 | s = (job == js.j_current) ? "+ ": ((job == js.j_previous) ? "- " : " "); | |
2893 | else | |
2894 | s = " "; | |
2895 | printf ("[%d]%s", job + 1, s); | |
2896 | } | |
726f6388 JA |
2897 | |
2898 | do | |
2899 | { | |
95732b49 | 2900 | printf ("%s%s", |
726f6388 JA |
2901 | p->command ? p->command : "", |
2902 | p->next != jobs[job]->pipe? " | " : ""); | |
2903 | p = p->next; | |
2904 | } | |
2905 | while (p != jobs[job]->pipe); | |
2906 | ||
ccc6cda3 | 2907 | if (foreground == 0) |
95732b49 | 2908 | printf (" &"); |
726f6388 JA |
2909 | |
2910 | if (strcmp (wd, jobs[job]->wd) != 0) | |
95732b49 | 2911 | printf (" (wd: %s)", polite_directory_format (jobs[job]->wd)); |
726f6388 | 2912 | |
95732b49 | 2913 | printf ("\n"); |
726f6388 JA |
2914 | |
2915 | /* Run the job. */ | |
ccc6cda3 | 2916 | if (already_running == 0) |
d166f048 | 2917 | set_job_running (job); |
726f6388 JA |
2918 | |
2919 | /* Save the tty settings before we start the job in the foreground. */ | |
2920 | if (foreground) | |
2921 | { | |
2922 | get_tty_state (); | |
2923 | save_stty = shell_tty_info; | |
ccc6cda3 JA |
2924 | /* Give the terminal to this job. */ |
2925 | if (IS_JOBCONTROL (job)) | |
28ef6c31 | 2926 | give_terminal_to (jobs[job]->pgrp, 0); |
726f6388 JA |
2927 | } |
2928 | else | |
2929 | jobs[job]->flags &= ~J_FOREGROUND; | |
2930 | ||
2931 | /* If the job is already running, then don't bother jump-starting it. */ | |
ccc6cda3 | 2932 | if (already_running == 0) |
726f6388 JA |
2933 | { |
2934 | jobs[job]->flags |= J_NOTIFIED; | |
2935 | killpg (jobs[job]->pgrp, SIGCONT); | |
2936 | } | |
2937 | ||
726f6388 JA |
2938 | if (foreground) |
2939 | { | |
ccc6cda3 | 2940 | pid_t pid; |
0628567a | 2941 | int st; |
726f6388 | 2942 | |
7117c2d2 JA |
2943 | pid = find_last_pid (job, 0); |
2944 | UNBLOCK_CHILD (oset); | |
0628567a | 2945 | st = wait_for (pid); |
726f6388 JA |
2946 | shell_tty_info = save_stty; |
2947 | set_tty_state (); | |
0628567a | 2948 | return (st); |
726f6388 JA |
2949 | } |
2950 | else | |
2951 | { | |
726f6388 JA |
2952 | reset_current (); |
2953 | UNBLOCK_CHILD (oset); | |
2954 | return (0); | |
2955 | } | |
2956 | } | |
2957 | ||
2958 | /* Give PID SIGNAL. This determines what job the pid belongs to (if any). | |
2959 | If PID does belong to a job, and the job is stopped, then CONTinue the | |
2960 | job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null, | |
2961 | then kill the process group associated with PID. */ | |
2962 | int | |
2963 | kill_pid (pid, sig, group) | |
2964 | pid_t pid; | |
2965 | int sig, group; | |
2966 | { | |
2967 | register PROCESS *p; | |
95732b49 | 2968 | int job, result, negative; |
726f6388 JA |
2969 | sigset_t set, oset; |
2970 | ||
95732b49 JA |
2971 | if (pid < -1) |
2972 | { | |
2973 | pid = -pid; | |
2974 | group = negative = 1; | |
2975 | } | |
2976 | else | |
2977 | negative = 0; | |
2978 | ||
ccc6cda3 | 2979 | result = EXECUTION_SUCCESS; |
726f6388 JA |
2980 | if (group) |
2981 | { | |
f73dda09 | 2982 | BLOCK_CHILD (set, oset); |
7117c2d2 | 2983 | p = find_pipeline (pid, 0, &job); |
f73dda09 | 2984 | |
726f6388 JA |
2985 | if (job != NO_JOB) |
2986 | { | |
2987 | jobs[job]->flags &= ~J_NOTIFIED; | |
2988 | ||
2989 | /* Kill process in backquotes or one started without job control? */ | |
95732b49 JA |
2990 | |
2991 | /* If we're passed a pid < -1, just call killpg and see what happens */ | |
2992 | if (negative && jobs[job]->pgrp == shell_pgrp) | |
2993 | result = killpg (pid, sig); | |
2994 | /* If we're killing using job control notification, for example, | |
2995 | without job control active, we have to do things ourselves. */ | |
2996 | else if (jobs[job]->pgrp == shell_pgrp) | |
726f6388 JA |
2997 | { |
2998 | p = jobs[job]->pipe; | |
726f6388 JA |
2999 | do |
3000 | { | |
95732b49 JA |
3001 | if (PALIVE (p) == 0) |
3002 | continue; /* avoid pid recycling problem */ | |
726f6388 | 3003 | kill (p->pid, sig); |
95732b49 | 3004 | if (PEXITED (p) && (sig == SIGTERM || sig == SIGHUP)) |
726f6388 JA |
3005 | kill (p->pid, SIGCONT); |
3006 | p = p->next; | |
3007 | } | |
95732b49 | 3008 | while (p != jobs[job]->pipe); |
726f6388 JA |
3009 | } |
3010 | else | |
3011 | { | |
3012 | result = killpg (jobs[job]->pgrp, sig); | |
ccc6cda3 | 3013 | if (p && STOPPED (job) && (sig == SIGTERM || sig == SIGHUP)) |
726f6388 | 3014 | killpg (jobs[job]->pgrp, SIGCONT); |
d166f048 JA |
3015 | /* If we're continuing a stopped job via kill rather than bg or |
3016 | fg, emulate the `bg' behavior. */ | |
3017 | if (p && STOPPED (job) && (sig == SIGCONT)) | |
3018 | { | |
3019 | set_job_running (job); | |
3020 | jobs[job]->flags &= ~J_FOREGROUND; | |
3021 | jobs[job]->flags |= J_NOTIFIED; | |
3022 | } | |
726f6388 JA |
3023 | } |
3024 | } | |
3025 | else | |
3026 | result = killpg (pid, sig); | |
f73dda09 JA |
3027 | |
3028 | UNBLOCK_CHILD (oset); | |
726f6388 JA |
3029 | } |
3030 | else | |
3031 | result = kill (pid, sig); | |
3032 | ||
726f6388 JA |
3033 | return (result); |
3034 | } | |
3035 | ||
ccc6cda3 JA |
3036 | /* sigchld_handler () flushes at least one of the children that we are |
3037 | waiting for. It gets run when we have gotten a SIGCHLD signal. */ | |
726f6388 | 3038 | static sighandler |
ccc6cda3 | 3039 | sigchld_handler (sig) |
726f6388 JA |
3040 | int sig; |
3041 | { | |
bb70624e | 3042 | int n, oerrno; |
ccc6cda3 | 3043 | |
bb70624e | 3044 | oerrno = errno; |
726f6388 JA |
3045 | REINSTALL_SIGCHLD_HANDLER; |
3046 | sigchld++; | |
ccc6cda3 | 3047 | n = 0; |
7117c2d2 | 3048 | if (queue_sigchld == 0) |
ccc6cda3 | 3049 | n = waitchld (-1, 0); |
bb70624e | 3050 | errno = oerrno; |
ccc6cda3 | 3051 | SIGRETURN (n); |
726f6388 | 3052 | } |
ccc6cda3 JA |
3053 | |
3054 | /* waitchld() reaps dead or stopped children. It's called by wait_for and | |
bb70624e JA |
3055 | sigchld_handler, and runs until there aren't any children terminating any |
3056 | more. | |
ccc6cda3 | 3057 | If BLOCK is 1, this is to be a blocking wait for a single child, although |
bb70624e JA |
3058 | an arriving SIGCHLD could cause the wait to be non-blocking. It returns |
3059 | the number of children reaped, or -1 if there are no unwaited-for child | |
3060 | processes. */ | |
726f6388 | 3061 | static int |
ccc6cda3 JA |
3062 | waitchld (wpid, block) |
3063 | pid_t wpid; | |
3064 | int block; | |
726f6388 JA |
3065 | { |
3066 | WAIT status; | |
3067 | PROCESS *child; | |
3068 | pid_t pid; | |
28ef6c31 | 3069 | int call_set_current, last_stopped_job, job, children_exited, waitpid_flags; |
95732b49 | 3070 | static int wcontinued = WCONTINUED; /* run-time fix for glibc problem */ |
ccc6cda3 JA |
3071 | |
3072 | call_set_current = children_exited = 0; | |
3073 | last_stopped_job = NO_JOB; | |
726f6388 JA |
3074 | |
3075 | do | |
3076 | { | |
d166f048 | 3077 | /* We don't want to be notified about jobs stopping if job control |
28ef6c31 | 3078 | is not active. XXX - was interactive_shell instead of job_control */ |
d166f048 | 3079 | waitpid_flags = (job_control && subshell_environment == 0) |
95732b49 | 3080 | ? (WUNTRACED|wcontinued) |
ccc6cda3 JA |
3081 | : 0; |
3082 | if (sigchld || block == 0) | |
3083 | waitpid_flags |= WNOHANG; | |
0001803f | 3084 | /* Check for terminating signals and exit the shell if we receive one */ |
0628567a | 3085 | CHECK_TERMSIG; |
3185942a | 3086 | |
0001803f CR |
3087 | if (block == 1 && queue_sigchld == 0 && (waitpid_flags & WNOHANG) == 0) |
3088 | { | |
3089 | internal_warning (_("waitchld: turning on WNOHANG to avoid indefinite block")); | |
3090 | waitpid_flags |= WNOHANG; | |
3091 | } | |
3092 | ||
ccc6cda3 | 3093 | pid = WAITPID (-1, &status, waitpid_flags); |
f73dda09 | 3094 | |
95732b49 JA |
3095 | /* WCONTINUED may be rejected by waitpid as invalid even when defined */ |
3096 | if (wcontinued && pid < 0 && errno == EINVAL) | |
3097 | { | |
3098 | wcontinued = 0; | |
3099 | continue; /* jump back to the test and retry without WCONTINUED */ | |
3100 | } | |
3101 | ||
ccc6cda3 JA |
3102 | /* The check for WNOHANG is to make sure we decrement sigchld only |
3103 | if it was non-zero before we called waitpid. */ | |
3104 | if (sigchld > 0 && (waitpid_flags & WNOHANG)) | |
3105 | sigchld--; | |
bb70624e JA |
3106 | |
3107 | /* If waitpid returns -1 with errno == ECHILD, there are no more | |
3108 | unwaited-for child processes of this shell. */ | |
3109 | if (pid < 0 && errno == ECHILD) | |
3110 | { | |
3111 | if (children_exited == 0) | |
3112 | return -1; | |
3113 | else | |
3114 | break; | |
3115 | } | |
ccc6cda3 | 3116 | |
bb70624e JA |
3117 | /* If waitpid returns 0, there are running children. If it returns -1, |
3118 | the only other error POSIX says it can return is EINTR. */ | |
0628567a | 3119 | CHECK_TERMSIG; |
ccc6cda3 JA |
3120 | if (pid <= 0) |
3121 | continue; /* jumps right to the test */ | |
3122 | ||
f73dda09 JA |
3123 | /* children_exited is used to run traps on SIGCHLD. We don't want to |
3124 | run the trap if a process is just being continued. */ | |
3125 | if (WIFCONTINUED(status) == 0) | |
0628567a JA |
3126 | { |
3127 | children_exited++; | |
3128 | js.c_living--; | |
3129 | } | |
ccc6cda3 JA |
3130 | |
3131 | /* Locate our PROCESS for this pid. */ | |
95732b49 | 3132 | child = find_process (pid, 1, &job); /* want living procs only */ |
ccc6cda3 | 3133 | |
3185942a | 3134 | #if defined (COPROCESS_SUPPORT) |
17345e5a | 3135 | coproc_pidchk (pid, status); |
3185942a JA |
3136 | #endif |
3137 | ||
ccc6cda3 JA |
3138 | /* It is not an error to have a child terminate that we did |
3139 | not have a record of. This child could have been part of | |
3140 | a pipeline in backquote substitution. Even so, I'm not | |
3141 | sure child is ever non-zero. */ | |
3142 | if (child == 0) | |
3185942a JA |
3143 | { |
3144 | if (WIFEXITED (status) || WIFSIGNALED (status)) | |
3145 | js.c_reaped++; | |
3146 | continue; | |
3147 | } | |
ccc6cda3 | 3148 | |
f73dda09 | 3149 | /* Remember status, and whether or not the process is running. */ |
ccc6cda3 | 3150 | child->status = status; |
7117c2d2 | 3151 | child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE; |
ccc6cda3 | 3152 | |
95732b49 JA |
3153 | if (PEXITED (child)) |
3154 | { | |
3155 | js.c_totreaped++; | |
3156 | if (job != NO_JOB) | |
3157 | js.c_reaped++; | |
3158 | } | |
3159 | ||
ccc6cda3 | 3160 | if (job == NO_JOB) |
28ef6c31 | 3161 | continue; |
726f6388 | 3162 | |
28ef6c31 | 3163 | call_set_current += set_job_status_and_cleanup (job); |
726f6388 | 3164 | |
28ef6c31 JA |
3165 | if (STOPPED (job)) |
3166 | last_stopped_job = job; | |
3167 | else if (DEADJOB (job) && last_stopped_job == job) | |
3168 | last_stopped_job = NO_JOB; | |
726f6388 | 3169 | } |
ccc6cda3 | 3170 | while ((sigchld || block == 0) && pid > (pid_t)0); |
726f6388 JA |
3171 | |
3172 | /* If a job was running and became stopped, then set the current | |
3173 | job. Otherwise, don't change a thing. */ | |
3174 | if (call_set_current) | |
bb70624e JA |
3175 | { |
3176 | if (last_stopped_job != NO_JOB) | |
3177 | set_current_job (last_stopped_job); | |
3178 | else | |
3179 | reset_current (); | |
3180 | } | |
726f6388 JA |
3181 | |
3182 | /* Call a SIGCHLD trap handler for each child that exits, if one is set. */ | |
bb70624e | 3183 | if (job_control && signal_is_trapped (SIGCHLD) && children_exited && |
726f6388 | 3184 | trap_list[SIGCHLD] != (char *)IGNORE_SIG) |
3185942a | 3185 | { |
0001803f | 3186 | if (posixly_correct && this_shell_builtin && this_shell_builtin == wait_builtin) |
3185942a JA |
3187 | { |
3188 | interrupt_immediately = 0; | |
3189 | trap_handler (SIGCHLD); /* set pending_traps[SIGCHLD] */ | |
3190 | wait_signal_received = SIGCHLD; | |
3191 | longjmp (wait_intr_buf, 1); | |
3192 | } | |
3193 | ||
3194 | run_sigchld_trap (children_exited); | |
3195 | } | |
726f6388 JA |
3196 | |
3197 | /* We have successfully recorded the useful information about this process | |
3198 | that has just changed state. If we notify asynchronously, and the job | |
3199 | that this process belongs to is no longer running, then notify the user | |
3200 | of that fact now. */ | |
3201 | if (asynchronous_notification && interactive) | |
3202 | notify_of_job_status (); | |
3203 | ||
ccc6cda3 | 3204 | return (children_exited); |
726f6388 JA |
3205 | } |
3206 | ||
28ef6c31 JA |
3207 | /* Set the status of JOB and perform any necessary cleanup if the job is |
3208 | marked as JDEAD. | |
3209 | ||
3210 | Currently, the cleanup activity is restricted to handling any SIGINT | |
3211 | received while waiting for a foreground job to finish. */ | |
3212 | static int | |
3213 | set_job_status_and_cleanup (job) | |
3214 | int job; | |
3215 | { | |
3216 | PROCESS *child; | |
3217 | int tstatus, job_state, any_stopped, any_tstped, call_set_current; | |
3218 | SigHandler *temp_handler; | |
3219 | ||
3220 | child = jobs[job]->pipe; | |
3221 | jobs[job]->flags &= ~J_NOTIFIED; | |
3222 | ||
3223 | call_set_current = 0; | |
3224 | ||
3225 | /* | |
3226 | * COMPUTE JOB STATUS | |
3227 | */ | |
3228 | ||
3229 | /* If all children are not running, but any of them is stopped, then | |
3230 | the job is stopped, not dead. */ | |
3231 | job_state = any_stopped = any_tstped = 0; | |
3232 | do | |
3233 | { | |
95732b49 JA |
3234 | job_state |= PRUNNING (child); |
3235 | #if 0 | |
3236 | if (PEXITED (child) && (WIFSTOPPED (child->status))) | |
3237 | #else | |
3238 | /* Only checking for WIFSTOPPED now, not for PS_DONE */ | |
3239 | if (PSTOPPED (child)) | |
3240 | #endif | |
28ef6c31 JA |
3241 | { |
3242 | any_stopped = 1; | |
3243 | any_tstped |= interactive && job_control && | |
3244 | (WSTOPSIG (child->status) == SIGTSTP); | |
3245 | } | |
3246 | child = child->next; | |
3247 | } | |
3248 | while (child != jobs[job]->pipe); | |
3249 | ||
3250 | /* If job_state != 0, the job is still running, so don't bother with | |
f73dda09 JA |
3251 | setting the process exit status and job state unless we're |
3252 | transitioning from stopped to running. */ | |
3253 | if (job_state != 0 && JOBSTATE(job) != JSTOPPED) | |
28ef6c31 JA |
3254 | return 0; |
3255 | ||
3256 | /* | |
3257 | * SET JOB STATUS | |
3258 | */ | |
3259 | ||
3260 | /* The job is either stopped or dead. Set the state of the job accordingly. */ | |
3261 | if (any_stopped) | |
3262 | { | |
3263 | jobs[job]->state = JSTOPPED; | |
3264 | jobs[job]->flags &= ~J_FOREGROUND; | |
3265 | call_set_current++; | |
3266 | /* Suspending a job with SIGTSTP breaks all active loops. */ | |
3267 | if (any_tstped && loop_level) | |
3268 | breaking = loop_level; | |
3269 | } | |
f73dda09 JA |
3270 | else if (job_state != 0) /* was stopped, now running */ |
3271 | { | |
3272 | jobs[job]->state = JRUNNING; | |
3273 | call_set_current++; | |
3274 | } | |
28ef6c31 JA |
3275 | else |
3276 | { | |
3277 | jobs[job]->state = JDEAD; | |
95732b49 | 3278 | js.j_ndead++; |
28ef6c31 | 3279 | |
7117c2d2 | 3280 | #if 0 |
28ef6c31 JA |
3281 | if (IS_FOREGROUND (job)) |
3282 | setjstatus (job); | |
7117c2d2 | 3283 | #endif |
28ef6c31 JA |
3284 | |
3285 | /* If this job has a cleanup function associated with it, call it | |
3286 | with `cleanarg' as the single argument, then set the function | |
3287 | pointer to NULL so it is not inadvertently called twice. The | |
3288 | cleanup function is responsible for deallocating cleanarg. */ | |
3289 | if (jobs[job]->j_cleanup) | |
3290 | { | |
3291 | (*jobs[job]->j_cleanup) (jobs[job]->cleanarg); | |
f73dda09 | 3292 | jobs[job]->j_cleanup = (sh_vptrfunc_t *)NULL; |
28ef6c31 JA |
3293 | } |
3294 | } | |
3295 | ||
3296 | /* | |
3297 | * CLEANUP | |
3298 | * | |
3299 | * Currently, we just do special things if we got a SIGINT while waiting | |
3300 | * for a foreground job to complete | |
3301 | */ | |
3302 | ||
95732b49 | 3303 | if (JOBSTATE (job) == JDEAD) |
28ef6c31 JA |
3304 | { |
3305 | /* If we're running a shell script and we get a SIGINT with a | |
3306 | SIGINT trap handler, but the foreground job handles it and | |
3307 | does not exit due to SIGINT, run the trap handler but do not | |
3308 | otherwise act as if we got the interrupt. */ | |
3309 | if (wait_sigint_received && interactive_shell == 0 && | |
3310 | WIFSIGNALED (child->status) == 0 && IS_FOREGROUND (job) && | |
3311 | signal_is_trapped (SIGINT)) | |
3312 | { | |
7117c2d2 | 3313 | int old_frozen; |
28ef6c31 JA |
3314 | wait_sigint_received = 0; |
3315 | last_command_exit_value = process_exit_status (child->status); | |
3316 | ||
7117c2d2 | 3317 | old_frozen = jobs_list_frozen; |
28ef6c31 JA |
3318 | jobs_list_frozen = 1; |
3319 | tstatus = maybe_call_trap_handler (SIGINT); | |
7117c2d2 | 3320 | jobs_list_frozen = old_frozen; |
28ef6c31 JA |
3321 | } |
3322 | ||
3323 | /* If the foreground job is killed by SIGINT when job control is not | |
3324 | active, we need to perform some special handling. | |
3325 | ||
3326 | The check of wait_sigint_received is a way to determine if the | |
3327 | SIGINT came from the keyboard (in which case the shell has already | |
3328 | seen it, and wait_sigint_received is non-zero, because keyboard | |
3329 | signals are sent to process groups) or via kill(2) to the foreground | |
3330 | process by another process (or itself). If the shell did receive the | |
3331 | SIGINT, it needs to perform normal SIGINT processing. */ | |
3332 | else if (wait_sigint_received && (WTERMSIG (child->status) == SIGINT) && | |
3333 | IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0) | |
3334 | { | |
7117c2d2 JA |
3335 | int old_frozen; |
3336 | ||
28ef6c31 JA |
3337 | wait_sigint_received = 0; |
3338 | ||
3339 | /* If SIGINT is trapped, set the exit status so that the trap | |
3340 | handler can see it. */ | |
3341 | if (signal_is_trapped (SIGINT)) | |
3342 | last_command_exit_value = process_exit_status (child->status); | |
3343 | ||
3344 | /* If the signal is trapped, let the trap handler get it no matter | |
3345 | what and simply return if the trap handler returns. | |
3346 | maybe_call_trap_handler() may cause dead jobs to be removed from | |
3347 | the job table because of a call to execute_command. We work | |
3348 | around this by setting JOBS_LIST_FROZEN. */ | |
7117c2d2 | 3349 | old_frozen = jobs_list_frozen; |
28ef6c31 JA |
3350 | jobs_list_frozen = 1; |
3351 | tstatus = maybe_call_trap_handler (SIGINT); | |
7117c2d2 | 3352 | jobs_list_frozen = old_frozen; |
28ef6c31 JA |
3353 | if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER) |
3354 | { | |
3355 | /* wait_sigint_handler () has already seen SIGINT and | |
3356 | allowed the wait builtin to jump out. We need to | |
3357 | call the original SIGINT handler, if necessary. If | |
3358 | the original handler is SIG_DFL, we need to resend | |
3359 | the signal to ourselves. */ | |
3360 | ||
3361 | temp_handler = old_sigint_handler; | |
3362 | ||
3363 | /* Bogus. If we've reset the signal handler as the result | |
3364 | of a trap caught on SIGINT, then old_sigint_handler | |
3365 | will point to trap_handler, which now knows nothing about | |
3366 | SIGINT (if we reset the sighandler to the default). | |
3367 | In this case, we have to fix things up. What a crock. */ | |
3368 | if (temp_handler == trap_handler && signal_is_trapped (SIGINT) == 0) | |
3369 | temp_handler = trap_to_sighandler (SIGINT); | |
3370 | restore_sigint_handler (); | |
95732b49 | 3371 | if (temp_handler == SIG_DFL) |
0628567a | 3372 | termsig_handler (SIGINT); |
95732b49 JA |
3373 | else if (temp_handler != SIG_IGN) |
3374 | (*temp_handler) (SIGINT); | |
28ef6c31 JA |
3375 | } |
3376 | } | |
3377 | } | |
3378 | ||
3379 | return call_set_current; | |
3380 | } | |
3381 | ||
3382 | /* Build the array of values for the $PIPESTATUS variable from the set of | |
3383 | exit statuses of all processes in the job J. */ | |
3384 | static void | |
3385 | setjstatus (j) | |
3386 | int j; | |
3387 | { | |
3388 | #if defined (ARRAY_VARS) | |
3389 | register int i; | |
3390 | register PROCESS *p; | |
3391 | ||
3392 | for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++) | |
3393 | ; | |
3394 | i++; | |
7117c2d2 | 3395 | if (statsize < i) |
28ef6c31 JA |
3396 | { |
3397 | pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int)); | |
3398 | statsize = i; | |
3399 | } | |
3400 | i = 0; | |
3401 | p = jobs[j]->pipe; | |
3402 | do | |
3403 | { | |
3404 | pstatuses[i++] = process_exit_status (p->status); | |
3405 | p = p->next; | |
3406 | } | |
3407 | while (p != jobs[j]->pipe); | |
3408 | ||
3409 | pstatuses[i] = -1; /* sentinel */ | |
7117c2d2 | 3410 | set_pipestatus_array (pstatuses, i); |
28ef6c31 JA |
3411 | #endif |
3412 | } | |
3413 | ||
3185942a | 3414 | void |
28ef6c31 JA |
3415 | run_sigchld_trap (nchild) |
3416 | int nchild; | |
3417 | { | |
3418 | char *trap_command; | |
3419 | int i; | |
3420 | ||
3421 | /* Turn off the trap list during the call to parse_and_execute () | |
3422 | to avoid potentially infinite recursive calls. Preserve the | |
3423 | values of last_command_exit_value, last_made_pid, and the_pipeline | |
3424 | around the execution of the trap commands. */ | |
3425 | trap_command = savestring (trap_list[SIGCHLD]); | |
3426 | ||
3427 | begin_unwind_frame ("SIGCHLD trap"); | |
3428 | unwind_protect_int (last_command_exit_value); | |
b80f6443 | 3429 | unwind_protect_int (last_command_exit_signal); |
f73dda09 | 3430 | unwind_protect_var (last_made_pid); |
28ef6c31 JA |
3431 | unwind_protect_int (interrupt_immediately); |
3432 | unwind_protect_int (jobs_list_frozen); | |
3433 | unwind_protect_pointer (the_pipeline); | |
3434 | unwind_protect_pointer (subst_assign_varlist); | |
3435 | ||
3436 | /* We have to add the commands this way because they will be run | |
3437 | in reverse order of adding. We don't want maybe_set_sigchld_trap () | |
3438 | to reference freed memory. */ | |
b80f6443 JA |
3439 | add_unwind_protect (xfree, trap_command); |
3440 | add_unwind_protect (maybe_set_sigchld_trap, trap_command); | |
28ef6c31 JA |
3441 | |
3442 | subst_assign_varlist = (WORD_LIST *)NULL; | |
3443 | the_pipeline = (PROCESS *)NULL; | |
3444 | ||
3185942a | 3445 | set_impossible_sigchld_trap (); |
28ef6c31 JA |
3446 | jobs_list_frozen = 1; |
3447 | for (i = 0; i < nchild; i++) | |
3448 | { | |
3449 | interrupt_immediately = 1; | |
b80f6443 | 3450 | parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST|SEVAL_RESETLINE); |
28ef6c31 JA |
3451 | } |
3452 | ||
3453 | run_unwind_frame ("SIGCHLD trap"); | |
3454 | } | |
3455 | ||
726f6388 JA |
3456 | /* Function to call when you want to notify people of changes |
3457 | in job status. This prints out all jobs which are pending | |
3458 | notification to stderr, and marks those printed as already | |
3459 | notified, thus making them candidates for cleanup. */ | |
3460 | static void | |
3461 | notify_of_job_status () | |
3462 | { | |
3463 | register int job, termsig; | |
3464 | char *dir; | |
3465 | sigset_t set, oset; | |
ccc6cda3 | 3466 | WAIT s; |
726f6388 | 3467 | |
95732b49 | 3468 | if (jobs == 0 || js.j_jobslots == 0) |
28ef6c31 JA |
3469 | return; |
3470 | ||
7117c2d2 JA |
3471 | if (old_ttou != 0) |
3472 | { | |
3473 | sigemptyset (&set); | |
3474 | sigaddset (&set, SIGCHLD); | |
3475 | sigaddset (&set, SIGTTOU); | |
3476 | sigemptyset (&oset); | |
3477 | sigprocmask (SIG_BLOCK, &set, &oset); | |
3478 | } | |
3479 | else | |
3480 | queue_sigchld++; | |
726f6388 | 3481 | |
95732b49 JA |
3482 | /* XXX could use js.j_firstj here */ |
3483 | for (job = 0, dir = (char *)NULL; job < js.j_jobslots; job++) | |
726f6388 | 3484 | { |
ccc6cda3 | 3485 | if (jobs[job] && IS_NOTIFIED (job) == 0) |
726f6388 | 3486 | { |
bb70624e | 3487 | s = raw_job_exit_status (job); |
726f6388 JA |
3488 | termsig = WTERMSIG (s); |
3489 | ||
b72432fd JA |
3490 | /* POSIX.2 says we have to hang onto the statuses of at most the |
3491 | last CHILD_MAX background processes if the shell is running a | |
95732b49 JA |
3492 | script. If the shell is running a script, either from a file |
3493 | or standard input, don't print anything unless the job was | |
3494 | killed by a signal. */ | |
b72432fd JA |
3495 | if (startup_state == 0 && WIFSIGNALED (s) == 0 && |
3496 | ((DEADJOB (job) && IS_FOREGROUND (job) == 0) || STOPPED (job))) | |
3497 | continue; | |
3498 | ||
b80f6443 | 3499 | #if 0 |
726f6388 | 3500 | /* If job control is disabled, don't print the status messages. |
ccc6cda3 JA |
3501 | Mark dead jobs as notified so that they get cleaned up. If |
3502 | startup_state == 2, we were started to run `-c command', so | |
b72432fd JA |
3503 | don't print anything. */ |
3504 | if ((job_control == 0 && interactive_shell) || startup_state == 2) | |
b80f6443 JA |
3505 | #else |
3506 | /* If job control is disabled, don't print the status messages. | |
3507 | Mark dead jobs as notified so that they get cleaned up. If | |
3508 | startup_state == 2 and subshell_environment has the | |
3509 | SUBSHELL_COMSUB bit turned on, we were started to run a command | |
3510 | substitution, so don't print anything. */ | |
3511 | if ((job_control == 0 && interactive_shell) || | |
3512 | (startup_state == 2 && (subshell_environment & SUBSHELL_COMSUB))) | |
3513 | #endif | |
726f6388 | 3514 | { |
cce855bc JA |
3515 | /* POSIX.2 compatibility: if the shell is not interactive, |
3516 | hang onto the job corresponding to the last asynchronous | |
3517 | pid until the user has been notified of its status or does | |
3518 | a `wait'. */ | |
7117c2d2 | 3519 | if (DEADJOB (job) && (interactive_shell || (find_last_pid (job, 0) != last_asynchronous_pid))) |
726f6388 JA |
3520 | jobs[job]->flags |= J_NOTIFIED; |
3521 | continue; | |
3522 | } | |
3523 | ||
ccc6cda3 JA |
3524 | /* Print info on jobs that are running in the background, |
3525 | and on foreground jobs that were killed by anything | |
d166f048 | 3526 | except SIGINT (and possibly SIGPIPE). */ |
726f6388 JA |
3527 | switch (JOBSTATE (job)) |
3528 | { | |
726f6388 | 3529 | case JDEAD: |
ccc6cda3 | 3530 | if (interactive_shell == 0 && termsig && WIFSIGNALED (s) && |
cce855bc | 3531 | termsig != SIGINT && |
cce855bc JA |
3532 | #if defined (DONT_REPORT_SIGPIPE) |
3533 | termsig != SIGPIPE && | |
3534 | #endif | |
ccc6cda3 | 3535 | signal_is_trapped (termsig) == 0) |
28ef6c31 | 3536 | { |
b80f6443 | 3537 | /* Don't print `0' for a line number. */ |
3185942a | 3538 | fprintf (stderr, _("%s: line %d: "), get_name_for_error (), (line_number == 0) ? 1 : line_number); |
ccc6cda3 JA |
3539 | pretty_print_job (job, JLIST_NONINTERACTIVE, stderr); |
3540 | } | |
3541 | else if (IS_FOREGROUND (job)) | |
726f6388 | 3542 | { |
d166f048 | 3543 | #if !defined (DONT_REPORT_SIGPIPE) |
726f6388 | 3544 | if (termsig && WIFSIGNALED (s) && termsig != SIGINT) |
d166f048 JA |
3545 | #else |
3546 | if (termsig && WIFSIGNALED (s) && termsig != SIGINT && termsig != SIGPIPE) | |
3547 | #endif | |
726f6388 | 3548 | { |
b80f6443 | 3549 | fprintf (stderr, "%s", j_strsignal (termsig)); |
726f6388 JA |
3550 | |
3551 | if (WIFCORED (s)) | |
3185942a | 3552 | fprintf (stderr, _(" (core dumped)")); |
726f6388 JA |
3553 | |
3554 | fprintf (stderr, "\n"); | |
3555 | } | |
3556 | } | |
95732b49 | 3557 | else if (job_control) /* XXX job control test added */ |
726f6388 | 3558 | { |
ccc6cda3 | 3559 | if (dir == 0) |
726f6388 | 3560 | dir = current_working_directory (); |
ccc6cda3 | 3561 | pretty_print_job (job, JLIST_STANDARD, stderr); |
726f6388 JA |
3562 | if (dir && strcmp (dir, jobs[job]->wd) != 0) |
3563 | fprintf (stderr, | |
3185942a | 3564 | _("(wd now: %s)\n"), polite_directory_format (dir)); |
726f6388 JA |
3565 | } |
3566 | ||
3567 | jobs[job]->flags |= J_NOTIFIED; | |
3568 | break; | |
3569 | ||
3570 | case JSTOPPED: | |
3571 | fprintf (stderr, "\n"); | |
ccc6cda3 | 3572 | if (dir == 0) |
726f6388 | 3573 | dir = current_working_directory (); |
ccc6cda3 | 3574 | pretty_print_job (job, JLIST_STANDARD, stderr); |
726f6388 JA |
3575 | if (dir && (strcmp (dir, jobs[job]->wd) != 0)) |
3576 | fprintf (stderr, | |
3185942a | 3577 | _("(wd now: %s)\n"), polite_directory_format (dir)); |
726f6388 JA |
3578 | jobs[job]->flags |= J_NOTIFIED; |
3579 | break; | |
3580 | ||
3581 | case JRUNNING: | |
3582 | case JMIXED: | |
3583 | break; | |
3584 | ||
3585 | default: | |
3586 | programming_error ("notify_of_job_status"); | |
3587 | } | |
3588 | } | |
3589 | } | |
7117c2d2 JA |
3590 | if (old_ttou != 0) |
3591 | sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL); | |
3592 | else | |
3593 | queue_sigchld--; | |
726f6388 JA |
3594 | } |
3595 | ||
726f6388 | 3596 | /* Initialize the job control mechanism, and set up the tty stuff. */ |
ccc6cda3 | 3597 | int |
d166f048 JA |
3598 | initialize_job_control (force) |
3599 | int force; | |
726f6388 | 3600 | { |
3185942a JA |
3601 | pid_t t; |
3602 | int t_errno; | |
3603 | ||
3604 | t_errno = -1; | |
726f6388 JA |
3605 | shell_pgrp = getpgid (0); |
3606 | ||
3607 | if (shell_pgrp == -1) | |
3608 | { | |
3185942a | 3609 | sys_error (_("initialize_job_control: getpgrp failed")); |
726f6388 JA |
3610 | exit (1); |
3611 | } | |
3612 | ||
ccc6cda3 JA |
3613 | /* We can only have job control if we are interactive. */ |
3614 | if (interactive == 0) | |
726f6388 JA |
3615 | { |
3616 | job_control = 0; | |
3617 | original_pgrp = NO_PID; | |
d166f048 | 3618 | shell_tty = fileno (stderr); |
726f6388 JA |
3619 | } |
3620 | else | |
3621 | { | |
3185942a JA |
3622 | shell_tty = -1; |
3623 | ||
3624 | /* If forced_interactive is set, we skip the normal check that stderr | |
3625 | is attached to a tty, so we need to check here. If it's not, we | |
3626 | need to see whether we have a controlling tty by opening /dev/tty, | |
3627 | since trying to use job control tty pgrp manipulations on a non-tty | |
3628 | is going to fail. */ | |
3629 | if (forced_interactive && isatty (fileno (stderr)) == 0) | |
3630 | shell_tty = open ("/dev/tty", O_RDWR|O_NONBLOCK); | |
3631 | ||
726f6388 JA |
3632 | /* Get our controlling terminal. If job_control is set, or |
3633 | interactive is set, then this is an interactive shell no | |
ccc6cda3 | 3634 | matter where fd 2 is directed. */ |
3185942a JA |
3635 | if (shell_tty == -1) |
3636 | shell_tty = dup (fileno (stderr)); /* fd 2 */ | |
726f6388 | 3637 | |
d166f048 | 3638 | shell_tty = move_to_high_fd (shell_tty, 1, -1); |
726f6388 | 3639 | |
726f6388 | 3640 | /* Compensate for a bug in systems that compiled the BSD |
ccc6cda3 | 3641 | rlogind with DEBUG defined, like NeXT and Alliant. */ |
726f6388 JA |
3642 | if (shell_pgrp == 0) |
3643 | { | |
3644 | shell_pgrp = getpid (); | |
3645 | setpgid (0, shell_pgrp); | |
3646 | tcsetpgrp (shell_tty, shell_pgrp); | |
3647 | } | |
726f6388 JA |
3648 | |
3649 | while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1) | |
3650 | { | |
3651 | if (shell_pgrp != terminal_pgrp) | |
3652 | { | |
7117c2d2 | 3653 | SigHandler *ottin; |
ccc6cda3 | 3654 | |
7117c2d2 | 3655 | ottin = set_signal_handler(SIGTTIN, SIG_DFL); |
726f6388 | 3656 | kill (0, SIGTTIN); |
7117c2d2 | 3657 | set_signal_handler (SIGTTIN, ottin); |
726f6388 JA |
3658 | continue; |
3659 | } | |
3660 | break; | |
3661 | } | |
3662 | ||
3185942a JA |
3663 | if (terminal_pgrp == -1) |
3664 | t_errno = errno; | |
3665 | ||
ccc6cda3 | 3666 | /* Make sure that we are using the new line discipline. */ |
726f6388 JA |
3667 | if (set_new_line_discipline (shell_tty) < 0) |
3668 | { | |
3185942a | 3669 | sys_error (_("initialize_job_control: line discipline")); |
726f6388 JA |
3670 | job_control = 0; |
3671 | } | |
3672 | else | |
3673 | { | |
3674 | original_pgrp = shell_pgrp; | |
3675 | shell_pgrp = getpid (); | |
3676 | ||
3677 | if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0)) | |
3678 | { | |
3185942a | 3679 | sys_error (_("initialize_job_control: setpgid")); |
726f6388 JA |
3680 | shell_pgrp = original_pgrp; |
3681 | } | |
3682 | ||
3683 | job_control = 1; | |
ccc6cda3 JA |
3684 | |
3685 | /* If (and only if) we just set our process group to our pid, | |
3686 | thereby becoming a process group leader, and the terminal | |
3687 | is not in the same process group as our (new) process group, | |
3688 | then set the terminal's process group to our (new) process | |
3689 | group. If that fails, set our process group back to what it | |
3690 | was originally (so we can still read from the terminal) and | |
3691 | turn off job control. */ | |
3692 | if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp) | |
3693 | { | |
28ef6c31 | 3694 | if (give_terminal_to (shell_pgrp, 0) < 0) |
ccc6cda3 | 3695 | { |
3185942a | 3696 | t_errno = errno; |
28ef6c31 JA |
3697 | setpgid (0, original_pgrp); |
3698 | shell_pgrp = original_pgrp; | |
3699 | job_control = 0; | |
ccc6cda3 JA |
3700 | } |
3701 | } | |
3185942a JA |
3702 | |
3703 | if (job_control && ((t = tcgetpgrp (shell_tty)) == -1 || t != shell_pgrp)) | |
3704 | { | |
3705 | if (t_errno != -1) | |
3706 | errno = t_errno; | |
3707 | sys_error (_("cannot set terminal process group (%d)"), t); | |
3708 | job_control = 0; | |
3709 | } | |
726f6388 JA |
3710 | } |
3711 | if (job_control == 0) | |
b80f6443 | 3712 | internal_error (_("no job control in this shell")); |
726f6388 JA |
3713 | } |
3714 | ||
3715 | if (shell_tty != fileno (stderr)) | |
3716 | SET_CLOSE_ON_EXEC (shell_tty); | |
3717 | ||
ccc6cda3 | 3718 | set_signal_handler (SIGCHLD, sigchld_handler); |
726f6388 JA |
3719 | |
3720 | change_flag ('m', job_control ? '-' : '+'); | |
3721 | ||
3722 | if (interactive) | |
3723 | get_tty_state (); | |
ccc6cda3 | 3724 | |
95732b49 JA |
3725 | if (js.c_childmax < 0) |
3726 | js.c_childmax = getmaxchild (); | |
3727 | if (js.c_childmax < 0) | |
3728 | js.c_childmax = DEFAULT_CHILD_MAX; | |
3729 | ||
726f6388 JA |
3730 | return job_control; |
3731 | } | |
3732 | ||
28ef6c31 JA |
3733 | #ifdef DEBUG |
3734 | void | |
3735 | debug_print_pgrps () | |
3736 | { | |
f73dda09 JA |
3737 | itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld", |
3738 | (long)original_pgrp, (long)shell_pgrp, (long)terminal_pgrp); | |
3739 | itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld", | |
3740 | shell_tty, (long)tcgetpgrp (shell_tty), (long)getpgid(0)); | |
28ef6c31 JA |
3741 | } |
3742 | #endif | |
3743 | ||
726f6388 JA |
3744 | /* Set the line discipline to the best this system has to offer. |
3745 | Return -1 if this is not possible. */ | |
3746 | static int | |
3747 | set_new_line_discipline (tty) | |
3748 | int tty; | |
3749 | { | |
3750 | #if defined (NEW_TTY_DRIVER) | |
3751 | int ldisc; | |
3752 | ||
3753 | if (ioctl (tty, TIOCGETD, &ldisc) < 0) | |
3754 | return (-1); | |
3755 | ||
3756 | if (ldisc != NTTYDISC) | |
3757 | { | |
3758 | ldisc = NTTYDISC; | |
3759 | ||
3760 | if (ioctl (tty, TIOCSETD, &ldisc) < 0) | |
3761 | return (-1); | |
3762 | } | |
3763 | return (0); | |
3764 | #endif /* NEW_TTY_DRIVER */ | |
3765 | ||
3766 | #if defined (TERMIO_TTY_DRIVER) | |
ccc6cda3 | 3767 | # if defined (TERMIO_LDISC) && (NTTYDISC) |
726f6388 JA |
3768 | if (ioctl (tty, TCGETA, &shell_tty_info) < 0) |
3769 | return (-1); | |
3770 | ||
3771 | if (shell_tty_info.c_line != NTTYDISC) | |
3772 | { | |
3773 | shell_tty_info.c_line = NTTYDISC; | |
3774 | if (ioctl (tty, TCSETAW, &shell_tty_info) < 0) | |
3775 | return (-1); | |
3776 | } | |
ccc6cda3 | 3777 | # endif /* TERMIO_LDISC && NTTYDISC */ |
726f6388 JA |
3778 | return (0); |
3779 | #endif /* TERMIO_TTY_DRIVER */ | |
3780 | ||
3781 | #if defined (TERMIOS_TTY_DRIVER) | |
ccc6cda3 | 3782 | # if defined (TERMIOS_LDISC) && defined (NTTYDISC) |
726f6388 JA |
3783 | if (tcgetattr (tty, &shell_tty_info) < 0) |
3784 | return (-1); | |
3785 | ||
3786 | if (shell_tty_info.c_line != NTTYDISC) | |
3787 | { | |
3788 | shell_tty_info.c_line = NTTYDISC; | |
3789 | if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0) | |
3790 | return (-1); | |
3791 | } | |
ccc6cda3 | 3792 | # endif /* TERMIOS_LDISC && NTTYDISC */ |
726f6388 JA |
3793 | return (0); |
3794 | #endif /* TERMIOS_TTY_DRIVER */ | |
3795 | ||
3796 | #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER) | |
3797 | return (-1); | |
3798 | #endif | |
3799 | } | |
3800 | ||
726f6388 JA |
3801 | /* Setup this shell to handle C-C, etc. */ |
3802 | void | |
3803 | initialize_job_signals () | |
3804 | { | |
3805 | if (interactive) | |
3806 | { | |
3807 | set_signal_handler (SIGINT, sigint_sighandler); | |
3808 | set_signal_handler (SIGTSTP, SIG_IGN); | |
3809 | set_signal_handler (SIGTTOU, SIG_IGN); | |
3810 | set_signal_handler (SIGTTIN, SIG_IGN); | |
726f6388 JA |
3811 | } |
3812 | else if (job_control) | |
3813 | { | |
28ef6c31 | 3814 | old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler); |
28ef6c31 | 3815 | old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler); |
7117c2d2 | 3816 | old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler); |
726f6388 JA |
3817 | } |
3818 | /* Leave these things alone for non-interactive shells without job | |
3819 | control. */ | |
3820 | } | |
3821 | ||
3822 | /* Here we handle CONT signals. */ | |
3823 | static sighandler | |
28ef6c31 | 3824 | sigcont_sighandler (sig) |
726f6388 JA |
3825 | int sig; |
3826 | { | |
3827 | initialize_job_signals (); | |
3828 | set_signal_handler (SIGCONT, old_cont); | |
3829 | kill (getpid (), SIGCONT); | |
3830 | ||
ccc6cda3 | 3831 | SIGRETURN (0); |
726f6388 JA |
3832 | } |
3833 | ||
3834 | /* Here we handle stop signals while we are running not as a login shell. */ | |
3835 | static sighandler | |
28ef6c31 | 3836 | sigstop_sighandler (sig) |
726f6388 JA |
3837 | int sig; |
3838 | { | |
3839 | set_signal_handler (SIGTSTP, old_tstp); | |
3840 | set_signal_handler (SIGTTOU, old_ttou); | |
3841 | set_signal_handler (SIGTTIN, old_ttin); | |
3842 | ||
28ef6c31 | 3843 | old_cont = set_signal_handler (SIGCONT, sigcont_sighandler); |
726f6388 | 3844 | |
28ef6c31 | 3845 | give_terminal_to (shell_pgrp, 0); |
726f6388 JA |
3846 | |
3847 | kill (getpid (), sig); | |
3848 | ||
ccc6cda3 | 3849 | SIGRETURN (0); |
726f6388 JA |
3850 | } |
3851 | ||
3852 | /* Give the terminal to PGRP. */ | |
ccc6cda3 | 3853 | int |
28ef6c31 | 3854 | give_terminal_to (pgrp, force) |
726f6388 | 3855 | pid_t pgrp; |
28ef6c31 | 3856 | int force; |
726f6388 JA |
3857 | { |
3858 | sigset_t set, oset; | |
3185942a | 3859 | int r, e; |
726f6388 | 3860 | |
ccc6cda3 | 3861 | r = 0; |
28ef6c31 | 3862 | if (job_control || force) |
726f6388 JA |
3863 | { |
3864 | sigemptyset (&set); | |
3865 | sigaddset (&set, SIGTTOU); | |
3866 | sigaddset (&set, SIGTTIN); | |
3867 | sigaddset (&set, SIGTSTP); | |
3868 | sigaddset (&set, SIGCHLD); | |
3869 | sigemptyset (&oset); | |
3870 | sigprocmask (SIG_BLOCK, &set, &oset); | |
3871 | ||
3872 | if (tcsetpgrp (shell_tty, pgrp) < 0) | |
3873 | { | |
3874 | /* Maybe we should print an error message? */ | |
ccc6cda3 | 3875 | #if 0 |
f73dda09 JA |
3876 | sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld", |
3877 | shell_tty, (long)getpid(), (long)pgrp); | |
ccc6cda3 | 3878 | #endif |
726f6388 | 3879 | r = -1; |
3185942a | 3880 | e = errno; |
726f6388 JA |
3881 | } |
3882 | else | |
3883 | terminal_pgrp = pgrp; | |
726f6388 JA |
3884 | sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL); |
3885 | } | |
3886 | ||
3185942a JA |
3887 | if (r == -1) |
3888 | errno = e; | |
3889 | ||
726f6388 JA |
3890 | return r; |
3891 | } | |
3892 | ||
3185942a JA |
3893 | /* Give terminal to NPGRP iff it's currently owned by OPGRP. FLAGS are the |
3894 | flags to pass to give_terminal_to(). */ | |
3895 | static int | |
3896 | maybe_give_terminal_to (opgrp, npgrp, flags) | |
3897 | pid_t opgrp, npgrp; | |
3898 | int flags; | |
3899 | { | |
3900 | int tpgrp; | |
3901 | ||
3902 | tpgrp = tcgetpgrp (shell_tty); | |
3903 | if (tpgrp < 0 && errno == ENOTTY) | |
3904 | return -1; | |
3905 | if (tpgrp == npgrp) | |
3906 | { | |
3907 | terminal_pgrp = npgrp; | |
3908 | return 0; | |
3909 | } | |
3910 | else if (tpgrp != opgrp) | |
3911 | { | |
3912 | #if defined (DEBUG) | |
3913 | internal_warning ("maybe_give_terminal_to: terminal pgrp == %d shell pgrp = %d new pgrp = %d", tpgrp, opgrp, npgrp); | |
3914 | #endif | |
3915 | return -1; | |
3916 | } | |
3917 | else | |
3918 | return (give_terminal_to (npgrp, flags)); | |
3919 | } | |
3920 | ||
726f6388 JA |
3921 | /* Clear out any jobs in the job array. This is intended to be used by |
3922 | children of the shell, who should not have any job structures as baggage | |
3923 | when they start executing (forking subshells for parenthesized execution | |
cce855bc JA |
3924 | and functions with pipes are the two that spring to mind). If RUNNING_ONLY |
3925 | is nonzero, only running jobs are removed from the table. */ | |
d166f048 | 3926 | void |
cce855bc JA |
3927 | delete_all_jobs (running_only) |
3928 | int running_only; | |
726f6388 JA |
3929 | { |
3930 | register int i; | |
3931 | sigset_t set, oset; | |
3932 | ||
ccc6cda3 JA |
3933 | BLOCK_CHILD (set, oset); |
3934 | ||
95732b49 JA |
3935 | /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */ |
3936 | if (js.j_jobslots) | |
726f6388 | 3937 | { |
95732b49 | 3938 | js.j_current = js.j_previous = NO_JOB; |
726f6388 | 3939 | |
95732b49 JA |
3940 | /* XXX could use js.j_firstj here */ |
3941 | for (i = 0; i < js.j_jobslots; i++) | |
3942 | { | |
3943 | #if defined (DEBUG) | |
3944 | if (i < js.j_firstj && jobs[i]) | |
3945 | itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); | |
0628567a JA |
3946 | if (i > js.j_lastj && jobs[i]) |
3947 | itrace("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); | |
95732b49 JA |
3948 | #endif |
3949 | if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i)))) | |
0628567a | 3950 | delete_job (i, DEL_WARNSTOPPED); |
95732b49 | 3951 | } |
cce855bc JA |
3952 | if (running_only == 0) |
3953 | { | |
3954 | free ((char *)jobs); | |
95732b49 JA |
3955 | js.j_jobslots = 0; |
3956 | js.j_firstj = js.j_lastj = js.j_njobs = 0; | |
cce855bc | 3957 | } |
726f6388 | 3958 | } |
ccc6cda3 | 3959 | |
95732b49 JA |
3960 | if (running_only == 0) |
3961 | bgp_clear (); | |
3962 | ||
ccc6cda3 | 3963 | UNBLOCK_CHILD (oset); |
726f6388 JA |
3964 | } |
3965 | ||
d166f048 | 3966 | /* Mark all jobs in the job array so that they don't get a SIGHUP when the |
cce855bc | 3967 | shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */ |
d166f048 | 3968 | void |
cce855bc JA |
3969 | nohup_all_jobs (running_only) |
3970 | int running_only; | |
d166f048 JA |
3971 | { |
3972 | register int i; | |
3973 | sigset_t set, oset; | |
3974 | ||
3975 | BLOCK_CHILD (set, oset); | |
3976 | ||
95732b49 | 3977 | if (js.j_jobslots) |
d166f048 | 3978 | { |
95732b49 JA |
3979 | /* XXX could use js.j_firstj here */ |
3980 | for (i = 0; i < js.j_jobslots; i++) | |
cce855bc | 3981 | if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i)))) |
d166f048 JA |
3982 | nohup_job (i); |
3983 | } | |
3984 | ||
3985 | UNBLOCK_CHILD (oset); | |
3986 | } | |
3987 | ||
bb70624e JA |
3988 | int |
3989 | count_all_jobs () | |
3990 | { | |
3991 | int i, n; | |
3992 | sigset_t set, oset; | |
3993 | ||
95732b49 | 3994 | /* This really counts all non-dead jobs. */ |
bb70624e | 3995 | BLOCK_CHILD (set, oset); |
95732b49 JA |
3996 | /* XXX could use js.j_firstj here */ |
3997 | for (i = n = 0; i < js.j_jobslots; i++) | |
3998 | { | |
3999 | #if defined (DEBUG) | |
4000 | if (i < js.j_firstj && jobs[i]) | |
4001 | itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); | |
0628567a JA |
4002 | if (i > js.j_lastj && jobs[i]) |
4003 | itrace("count_all_jobs: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); | |
95732b49 JA |
4004 | #endif |
4005 | if (jobs[i] && DEADJOB(i) == 0) | |
4006 | n++; | |
4007 | } | |
bb70624e JA |
4008 | UNBLOCK_CHILD (oset); |
4009 | return n; | |
4010 | } | |
4011 | ||
4012 | static void | |
4013 | mark_all_jobs_as_dead () | |
4014 | { | |
4015 | register int i; | |
4016 | sigset_t set, oset; | |
4017 | ||
95732b49 | 4018 | if (js.j_jobslots == 0) |
7117c2d2 | 4019 | return; |
bb70624e | 4020 | |
7117c2d2 | 4021 | BLOCK_CHILD (set, oset); |
bb70624e | 4022 | |
95732b49 JA |
4023 | /* XXX could use js.j_firstj here */ |
4024 | for (i = 0; i < js.j_jobslots; i++) | |
7117c2d2 | 4025 | if (jobs[i]) |
95732b49 JA |
4026 | { |
4027 | jobs[i]->state = JDEAD; | |
4028 | js.j_ndead++; | |
4029 | } | |
7117c2d2 JA |
4030 | |
4031 | UNBLOCK_CHILD (oset); | |
bb70624e JA |
4032 | } |
4033 | ||
726f6388 | 4034 | /* Mark all dead jobs as notified, so delete_job () cleans them out |
b72432fd JA |
4035 | of the job table properly. POSIX.2 says we need to save the |
4036 | status of the last CHILD_MAX jobs, so we count the number of dead | |
4037 | jobs and mark only enough as notified to save CHILD_MAX statuses. */ | |
726f6388 | 4038 | static void |
b72432fd JA |
4039 | mark_dead_jobs_as_notified (force) |
4040 | int force; | |
726f6388 | 4041 | { |
95732b49 | 4042 | register int i, ndead, ndeadproc; |
726f6388 JA |
4043 | sigset_t set, oset; |
4044 | ||
95732b49 | 4045 | if (js.j_jobslots == 0) |
7117c2d2 | 4046 | return; |
b72432fd | 4047 | |
7117c2d2 | 4048 | BLOCK_CHILD (set, oset); |
b72432fd | 4049 | |
7117c2d2 JA |
4050 | /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses |
4051 | around; just run through the array. */ | |
4052 | if (force) | |
4053 | { | |
95732b49 JA |
4054 | /* XXX could use js.j_firstj here */ |
4055 | for (i = 0; i < js.j_jobslots; i++) | |
28ef6c31 | 4056 | { |
7117c2d2 JA |
4057 | if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid))) |
4058 | jobs[i]->flags |= J_NOTIFIED; | |
28ef6c31 | 4059 | } |
7117c2d2 JA |
4060 | UNBLOCK_CHILD (oset); |
4061 | return; | |
4062 | } | |
4063 | ||
95732b49 JA |
4064 | /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the |
4065 | array with the corresponding not marked as notified. This is a better | |
4066 | way to avoid pid aliasing and reuse problems than keeping the POSIX- | |
4067 | mandated CHILD_MAX jobs around. delete_job() takes care of keeping the | |
4068 | bgpids list regulated. */ | |
7117c2d2 JA |
4069 | |
4070 | /* Count the number of dead jobs */ | |
95732b49 JA |
4071 | /* XXX could use js.j_firstj here */ |
4072 | for (i = ndead = ndeadproc = 0; i < js.j_jobslots; i++) | |
7117c2d2 | 4073 | { |
95732b49 JA |
4074 | #if defined (DEBUG) |
4075 | if (i < js.j_firstj && jobs[i]) | |
4076 | itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); | |
0628567a JA |
4077 | if (i > js.j_lastj && jobs[i]) |
4078 | itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); | |
95732b49 | 4079 | #endif |
7117c2d2 | 4080 | if (jobs[i] && DEADJOB (i)) |
95732b49 JA |
4081 | { |
4082 | ndead++; | |
4083 | ndeadproc += processes_in_job (i); | |
4084 | } | |
7117c2d2 JA |
4085 | } |
4086 | ||
95732b49 JA |
4087 | #ifdef DEBUG |
4088 | if (ndeadproc != js.c_reaped) | |
4089 | itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc, js.c_reaped); | |
4090 | if (ndead != js.j_ndead) | |
4091 | itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead, js.j_ndead); | |
4092 | #endif | |
4093 | ||
4094 | if (js.c_childmax < 0) | |
4095 | js.c_childmax = getmaxchild (); | |
4096 | if (js.c_childmax < 0) | |
4097 | js.c_childmax = DEFAULT_CHILD_MAX; | |
726f6388 | 4098 | |
95732b49 JA |
4099 | /* Don't do anything if the number of dead processes is less than CHILD_MAX |
4100 | and we're not forcing a cleanup. */ | |
4101 | if (ndeadproc <= js.c_childmax) | |
7117c2d2 | 4102 | { |
726f6388 | 4103 | UNBLOCK_CHILD (oset); |
7117c2d2 | 4104 | return; |
726f6388 | 4105 | } |
7117c2d2 | 4106 | |
95732b49 JA |
4107 | #if 0 |
4108 | itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js.c_childmax, ndead, ndeadproc); | |
4109 | #endif | |
4110 | ||
7117c2d2 JA |
4111 | /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in |
4112 | the list. This isn't exactly right yet; changes need to be made | |
4113 | to stop_pipeline so we don't mark the newer jobs after we've | |
95732b49 JA |
4114 | created CHILD_MAX slots in the jobs array. This needs to be |
4115 | integrated with a way to keep the jobs array from growing without | |
4116 | bound. Maybe we wrap back around to 0 after we reach some max | |
4117 | limit, and there are sufficient job slots free (keep track of total | |
4118 | size of jobs array (js.j_jobslots) and running count of number of jobs | |
4119 | in jobs array. Then keep a job index corresponding to the `oldest job' | |
4120 | and start this loop there, wrapping around as necessary. In effect, | |
4121 | we turn the list into a circular buffer. */ | |
4122 | /* XXX could use js.j_firstj here */ | |
4123 | for (i = 0; i < js.j_jobslots; i++) | |
7117c2d2 JA |
4124 | { |
4125 | if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid))) | |
4126 | { | |
95732b49 JA |
4127 | #if defined (DEBUG) |
4128 | if (i < js.j_firstj && jobs[i]) | |
4129 | itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i, js.j_firstj); | |
0628567a JA |
4130 | if (i > js.j_lastj && jobs[i]) |
4131 | itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i, js.j_lastj); | |
95732b49 JA |
4132 | #endif |
4133 | /* If marking this job as notified would drop us down below | |
4134 | child_max, don't mark it so we can keep at least child_max | |
4135 | statuses. XXX -- need to check what Posix actually says | |
4136 | about keeping statuses. */ | |
4137 | if ((ndeadproc -= processes_in_job (i)) <= js.c_childmax) | |
7117c2d2 | 4138 | break; |
95732b49 | 4139 | jobs[i]->flags |= J_NOTIFIED; |
7117c2d2 JA |
4140 | } |
4141 | } | |
4142 | ||
4143 | UNBLOCK_CHILD (oset); | |
726f6388 JA |
4144 | } |
4145 | ||
ccc6cda3 | 4146 | /* Here to allow other parts of the shell (like the trap stuff) to |
495aee44 CR |
4147 | freeze and unfreeze the jobs list. */ |
4148 | void | |
4149 | freeze_jobs_list () | |
4150 | { | |
4151 | jobs_list_frozen = 1; | |
4152 | } | |
4153 | ||
ccc6cda3 JA |
4154 | void |
4155 | unfreeze_jobs_list () | |
4156 | { | |
4157 | jobs_list_frozen = 0; | |
4158 | } | |
4159 | ||
726f6388 JA |
4160 | /* Allow or disallow job control to take place. Returns the old value |
4161 | of job_control. */ | |
4162 | int | |
4163 | set_job_control (arg) | |
4164 | int arg; | |
4165 | { | |
4166 | int old; | |
4167 | ||
4168 | old = job_control; | |
4169 | job_control = arg; | |
b80f6443 JA |
4170 | |
4171 | /* If we're turning on job control, reset pipeline_pgrp so make_child will | |
4172 | put new child processes into the right pgrp */ | |
4173 | if (job_control != old && job_control) | |
4174 | pipeline_pgrp = 0; | |
4175 | ||
726f6388 JA |
4176 | return (old); |
4177 | } | |
4178 | ||
4179 | /* Turn off all traces of job control. This is run by children of the shell | |
4180 | which are going to do shellsy things, like wait (), etc. */ | |
4181 | void | |
4182 | without_job_control () | |
4183 | { | |
4184 | stop_making_children (); | |
4185 | start_pipeline (); | |
95732b49 | 4186 | #if defined (PGRP_PIPE) |
3185942a | 4187 | sh_closepipe (pgrp_pipe); |
95732b49 | 4188 | #endif |
cce855bc | 4189 | delete_all_jobs (0); |
726f6388 JA |
4190 | set_job_control (0); |
4191 | } | |
4192 | ||
4193 | /* If this shell is interactive, terminate all stopped jobs and | |
4194 | restore the original terminal process group. This is done | |
4195 | before the `exec' builtin calls shell_execve. */ | |
4196 | void | |
4197 | end_job_control () | |
4198 | { | |
4199 | if (interactive_shell) /* XXX - should it be interactive? */ | |
4200 | { | |
4201 | terminate_stopped_jobs (); | |
4202 | ||
4203 | if (original_pgrp >= 0) | |
28ef6c31 | 4204 | give_terminal_to (original_pgrp, 1); |
726f6388 JA |
4205 | } |
4206 | ||
4207 | if (original_pgrp >= 0) | |
4208 | setpgid (0, original_pgrp); | |
4209 | } | |
4210 | ||
4211 | /* Restart job control by closing shell tty and reinitializing. This is | |
4212 | called after an exec fails in an interactive shell and we do not exit. */ | |
4213 | void | |
4214 | restart_job_control () | |
4215 | { | |
4216 | if (shell_tty != -1) | |
4217 | close (shell_tty); | |
d166f048 | 4218 | initialize_job_control (0); |
726f6388 JA |
4219 | } |
4220 | ||
4221 | /* Set the handler to run when the shell receives a SIGCHLD signal. */ | |
4222 | void | |
4223 | set_sigchld_handler () | |
4224 | { | |
ccc6cda3 | 4225 | set_signal_handler (SIGCHLD, sigchld_handler); |
726f6388 JA |
4226 | } |
4227 | ||
4228 | #if defined (PGRP_PIPE) | |
4229 | /* Read from the read end of a pipe. This is how the process group leader | |
4230 | blocks until all of the processes in a pipeline have been made. */ | |
4231 | static void | |
4232 | pipe_read (pp) | |
4233 | int *pp; | |
4234 | { | |
4235 | char ch; | |
4236 | ||
4237 | if (pp[1] >= 0) | |
4238 | { | |
4239 | close (pp[1]); | |
4240 | pp[1] = -1; | |
4241 | } | |
4242 | ||
4243 | if (pp[0] >= 0) | |
4244 | { | |
4245 | while (read (pp[0], &ch, 1) == -1 && errno == EINTR) | |
bb70624e | 4246 | ; |
726f6388 JA |
4247 | } |
4248 | } | |
4249 | ||
726f6388 | 4250 | /* Functional interface closes our local-to-job-control pipes. */ |
ccc6cda3 | 4251 | void |
726f6388 JA |
4252 | close_pgrp_pipe () |
4253 | { | |
3185942a | 4254 | sh_closepipe (pgrp_pipe); |
726f6388 JA |
4255 | } |
4256 | ||
89a92869 CR |
4257 | void |
4258 | save_pgrp_pipe (p, clear) | |
4259 | int *p; | |
4260 | int clear; | |
4261 | { | |
4262 | p[0] = pgrp_pipe[0]; | |
4263 | p[1] = pgrp_pipe[1]; | |
4264 | if (clear) | |
4265 | pgrp_pipe[0] = pgrp_pipe[1] = -1; | |
4266 | } | |
4267 | ||
4268 | void | |
4269 | restore_pgrp_pipe (p) | |
4270 | int *p; | |
4271 | { | |
4272 | pgrp_pipe[0] = p[0]; | |
4273 | pgrp_pipe[1] = p[1]; | |
4274 | } | |
4275 | ||
726f6388 | 4276 | #endif /* PGRP_PIPE */ |