]>
Commit | Line | Data |
---|---|---|
726f6388 JA |
1 | /* The thing that makes children, remembers them, and contains wait loops. */ |
2 | ||
ccc6cda3 JA |
3 | /* This file works with both POSIX and BSD systems. It implements job |
4 | control. */ | |
726f6388 JA |
5 | |
6 | /* Copyright (C) 1989, 1992 Free Software Foundation, Inc. | |
7 | ||
8 | This file is part of GNU Bash, the Bourne Again SHell. | |
9 | ||
10 | Bash is free software; you can redistribute it and/or modify it under | |
11 | the terms of the GNU General Public License as published by the Free | |
bb70624e | 12 | Software Foundation; either version 2, or (at your option) any later |
726f6388 JA |
13 | version. |
14 | ||
15 | Bash is distributed in the hope that it will be useful, but WITHOUT ANY | |
16 | WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
17 | FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
18 | for more details. | |
19 | ||
20 | You should have received a copy of the GNU General Public License along | |
21 | with Bash; see the file COPYING. If not, write to the Free Software | |
bb70624e | 22 | Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */ |
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 JA |
41 | |
42 | #include <sys/file.h> | |
43 | #include "filecntl.h" | |
44 | #include <sys/ioctl.h> | |
45 | #include <sys/param.h> | |
46 | ||
47 | #if defined (BUFFERED_INPUT) | |
48 | # include "input.h" | |
49 | #endif | |
50 | ||
ccc6cda3 | 51 | /* Need to include this up here for *_TTY_DRIVER definitions. */ |
bb70624e | 52 | #include "shtty.h" |
726f6388 JA |
53 | |
54 | /* Define this if your output is getting swallowed. It's a no-op on | |
55 | machines with the termio or termios tty drivers. */ | |
56 | /* #define DRAIN_OUTPUT */ | |
57 | ||
726f6388 | 58 | /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */ |
726f6388 JA |
59 | #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER) |
60 | # include <bsdtty.h> | |
61 | #endif /* hpux && !TERMIOS_TTY_DRIVER */ | |
62 | ||
d166f048 | 63 | #if !defined (STRUCT_WINSIZE_IN_SYS_IOCTL) |
ccc6cda3 JA |
64 | /* For struct winsize on SCO */ |
65 | /* sys/ptem.h has winsize but needs mblk_t from sys/stream.h */ | |
d166f048 JA |
66 | # if defined (HAVE_SYS_PTEM_H) && defined (TIOCGWINSZ) && defined (SIGWINCH) |
67 | # if defined (HAVE_SYS_STREAM_H) | |
68 | # include <sys/stream.h> | |
69 | # endif | |
70 | # include <sys/ptem.h> | |
71 | # endif /* HAVE_SYS_PTEM_H && TIOCGWINSZ && SIGWINCH */ | |
72 | #endif /* !STRUCT_WINSIZE_IN_SYS_IOCTL */ | |
ccc6cda3 | 73 | |
726f6388 JA |
74 | #include "bashansi.h" |
75 | #include "shell.h" | |
76 | #include "jobs.h" | |
ccc6cda3 | 77 | #include "flags.h" |
726f6388 JA |
78 | |
79 | #include "builtins/builtext.h" | |
80 | #include "builtins/common.h" | |
81 | ||
726f6388 JA |
82 | #if !defined (errno) |
83 | extern int errno; | |
84 | #endif /* !errno */ | |
85 | ||
7117c2d2 JA |
86 | #define DEFAULT_CHILD_MAX 32 |
87 | #define MAX_JOBS_IN_ARRAY 4096 /* testing */ | |
b72432fd | 88 | |
ccc6cda3 JA |
89 | /* Take care of system dependencies that must be handled when waiting for |
90 | children. The arguments to the WAITPID macro match those to the Posix.1 | |
91 | waitpid() function. */ | |
92 | ||
93 | #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION) | |
94 | # define WAITPID(pid, statusp, options) \ | |
95 | wait3 ((union wait *)statusp, options, (struct rusage *)0) | |
96 | #else | |
97 | # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID) | |
98 | # define WAITPID(pid, statusp, options) \ | |
99 | waitpid ((pid_t)pid, statusp, options) | |
100 | # else | |
101 | # if defined (HAVE_WAIT3) | |
102 | # define WAITPID(pid, statusp, options) \ | |
103 | wait3 (statusp, options, (struct rusage *)0) | |
104 | # else | |
105 | # define WAITPID(pid, statusp, options) \ | |
106 | wait3 (statusp, options, (int *)0) | |
107 | # endif /* HAVE_WAIT3 */ | |
108 | # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/ | |
109 | #endif /* !(Ultrix && mips && _POSIX_VERSION) */ | |
110 | ||
111 | /* getpgrp () varies between systems. Even systems that claim to be | |
112 | Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */ | |
113 | #if defined (GETPGRP_VOID) | |
114 | # define getpgid(p) getpgrp () | |
115 | #else | |
116 | # define getpgid(p) getpgrp (p) | |
117 | #endif /* !GETPGRP_VOID */ | |
118 | ||
119 | /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the | |
120 | handler for SIGCHLD. */ | |
121 | #if defined (MUST_REINSTALL_SIGHANDLERS) | |
122 | # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler) | |
123 | #else | |
124 | # define REINSTALL_SIGCHLD_HANDLER | |
125 | #endif /* !MUST_REINSTALL_SIGHANDLERS */ | |
126 | ||
f73dda09 JA |
127 | /* Some systems let waitpid(2) tell callers about stopped children. */ |
128 | #if !defined (WCONTINUED) | |
129 | # define WCONTINUED 0 | |
130 | # define WIFCONTINUED(s) (0) | |
131 | #endif | |
132 | ||
ccc6cda3 JA |
133 | /* The number of additional slots to allocate when we run out. */ |
134 | #define JOB_SLOTS 8 | |
135 | ||
f73dda09 JA |
136 | typedef int sh_job_map_func_t __P((JOB *, int, int, int)); |
137 | ||
d166f048 | 138 | #if defined (READLINE) |
28ef6c31 | 139 | extern void rl_set_screen_size __P((int, int)); |
d166f048 JA |
140 | #endif |
141 | ||
726f6388 | 142 | /* Variables used here but defined in other files. */ |
7117c2d2 | 143 | extern int subshell_environment, line_number; |
f73dda09 | 144 | extern int posixly_correct, shell_level; |
726f6388 JA |
145 | extern int interrupt_immediately, last_command_exit_value; |
146 | extern int loop_level, breaking; | |
28ef6c31 | 147 | extern int sourcelevel; |
f73dda09 | 148 | extern sh_builtin_func_t *this_shell_builtin; |
726f6388 JA |
149 | extern char *shell_name, *this_command_name; |
150 | extern sigset_t top_level_mask; | |
bb70624e | 151 | extern procenv_t wait_intr_buf; |
7117c2d2 | 152 | extern int wait_signal_received; |
bb70624e | 153 | extern WORD_LIST *subst_assign_varlist; |
726f6388 JA |
154 | |
155 | /* The array of known jobs. */ | |
156 | JOB **jobs = (JOB **)NULL; | |
157 | ||
158 | /* The number of slots currently allocated to JOBS. */ | |
159 | int job_slots = 0; | |
160 | ||
726f6388 JA |
161 | /* The controlling tty for this shell. */ |
162 | int shell_tty = -1; | |
163 | ||
164 | /* The shell's process group. */ | |
165 | pid_t shell_pgrp = NO_PID; | |
166 | ||
167 | /* The terminal's process group. */ | |
168 | pid_t terminal_pgrp = NO_PID; | |
169 | ||
170 | /* The process group of the shell's parent. */ | |
171 | pid_t original_pgrp = NO_PID; | |
172 | ||
173 | /* The process group of the pipeline currently being made. */ | |
174 | pid_t pipeline_pgrp = (pid_t)0; | |
175 | ||
176 | #if defined (PGRP_PIPE) | |
177 | /* Pipes which each shell uses to communicate with the process group leader | |
178 | until all of the processes in a pipeline have been started. Then the | |
179 | process leader is allowed to continue. */ | |
180 | int pgrp_pipe[2] = { -1, -1 }; | |
181 | #endif | |
ccc6cda3 | 182 | |
726f6388 JA |
183 | /* The job which is current; i.e. the one that `%+' stands for. */ |
184 | int current_job = NO_JOB; | |
185 | ||
186 | /* The previous job; i.e. the one that `%-' stands for. */ | |
187 | int previous_job = NO_JOB; | |
188 | ||
189 | /* Last child made by the shell. */ | |
190 | pid_t last_made_pid = NO_PID; | |
191 | ||
192 | /* Pid of the last asynchronous child. */ | |
193 | pid_t last_asynchronous_pid = NO_PID; | |
194 | ||
195 | /* The pipeline currently being built. */ | |
196 | PROCESS *the_pipeline = (PROCESS *)NULL; | |
197 | ||
198 | /* If this is non-zero, do job control. */ | |
199 | int job_control = 1; | |
200 | ||
201 | /* Call this when you start making children. */ | |
202 | int already_making_children = 0; | |
203 | ||
ccc6cda3 JA |
204 | /* If this is non-zero, $LINES and $COLUMNS are reset after every process |
205 | exits from get_tty_state(). */ | |
206 | int check_window_size; | |
207 | ||
726f6388 | 208 | /* Functions local to this file. */ |
f73dda09 JA |
209 | |
210 | static void get_new_window_size __P((int)); | |
211 | ||
212 | static void run_sigchld_trap __P((int)); | |
213 | ||
214 | static sighandler wait_sigint_handler __P((int)); | |
215 | static sighandler sigchld_handler __P((int)); | |
216 | static sighandler sigwinch_sighandler __P((int)); | |
217 | static sighandler sigcont_sighandler __P((int)); | |
218 | static sighandler sigstop_sighandler __P((int)); | |
219 | ||
220 | static int waitchld __P((pid_t, int)); | |
221 | ||
7117c2d2 | 222 | static PROCESS *find_pipeline __P((pid_t, int, int *)); |
f73dda09 JA |
223 | |
224 | static char *current_working_directory __P((void)); | |
225 | static char *job_working_directory __P((void)); | |
226 | static char *printable_job_status __P((int, PROCESS *, int)); | |
227 | ||
7117c2d2 | 228 | static pid_t find_last_pid __P((int, int)); |
f73dda09 JA |
229 | |
230 | static int set_new_line_discipline __P((int)); | |
231 | static int map_over_jobs __P((sh_job_map_func_t *, int, int)); | |
232 | static int job_last_stopped __P((int)); | |
233 | static int job_last_running __P((int)); | |
234 | static int most_recent_job_in_state __P((int, JOB_STATE)); | |
7117c2d2 | 235 | static int find_job __P((pid_t, int)); |
f73dda09 JA |
236 | static int print_job __P((JOB *, int, int, int)); |
237 | static int process_exit_status __P((WAIT)); | |
238 | static int job_exit_status __P((int)); | |
239 | static int set_job_status_and_cleanup __P((int)); | |
240 | ||
241 | static WAIT raw_job_exit_status __P((int)); | |
242 | ||
243 | static void notify_of_job_status __P((void)); | |
244 | static void cleanup_dead_jobs __P((void)); | |
7117c2d2 | 245 | static int compact_jobs_list __P((int)); |
f73dda09 JA |
246 | static void discard_pipeline __P((PROCESS *)); |
247 | static void add_process __P((char *, pid_t)); | |
248 | static void print_pipeline __P((PROCESS *, int, int, FILE *)); | |
249 | static void pretty_print_job __P((int, int, FILE *)); | |
250 | static void set_current_job __P((int)); | |
251 | static void reset_current __P((void)); | |
252 | static void set_job_running __P((int)); | |
253 | static void setjstatus __P((int)); | |
254 | static void mark_all_jobs_as_dead __P((void)); | |
255 | static void mark_dead_jobs_as_notified __P((int)); | |
256 | static void restore_sigint_handler __P((void)); | |
726f6388 | 257 | #if defined (PGRP_PIPE) |
f73dda09 JA |
258 | static void pipe_read __P((int *)); |
259 | static void pipe_close __P((int *)); | |
726f6388 JA |
260 | #endif |
261 | ||
7117c2d2 JA |
262 | #if defined (ARRAY_VARS) |
263 | static int *pstatuses; /* list of pipeline statuses */ | |
264 | static int statsize; | |
265 | #endif | |
266 | ||
267 | /* Used to synchronize between wait_for and other functions and the SIGCHLD | |
268 | signal handler. */ | |
ccc6cda3 | 269 | static int sigchld; |
7117c2d2 JA |
270 | static int queue_sigchld; |
271 | ||
272 | #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++ | |
273 | ||
274 | #define UNQUEUE_SIGCHLD(os) \ | |
275 | do { \ | |
276 | queue_sigchld--; \ | |
277 | if (queue_sigchld == 0 && os != sigchld) \ | |
278 | waitchld (-1, 0); \ | |
279 | } while (0) | |
280 | ||
281 | static SigHandler *old_tstp, *old_ttou, *old_ttin; | |
282 | static SigHandler *old_cont = (SigHandler *)SIG_DFL; | |
283 | ||
284 | #if defined (TIOCGWINSZ) && defined (SIGWINCH) | |
285 | static SigHandler *old_winch = (SigHandler *)SIG_DFL; | |
286 | #endif | |
ccc6cda3 JA |
287 | |
288 | /* A place to temporarily save the current pipeline. */ | |
289 | static PROCESS *saved_pipeline; | |
290 | static int saved_already_making_children; | |
726f6388 JA |
291 | |
292 | /* Set this to non-zero whenever you don't want the jobs list to change at | |
293 | all: no jobs deleted and no status change notifications. This is used, | |
294 | for example, when executing SIGCHLD traps, which may run arbitrary | |
295 | commands. */ | |
ccc6cda3 | 296 | static int jobs_list_frozen; |
726f6388 | 297 | |
28ef6c31 JA |
298 | static char retcode_name_buffer[64]; |
299 | ||
7117c2d2 JA |
300 | static long child_max = -1L; |
301 | ||
726f6388 JA |
302 | #if !defined (_POSIX_VERSION) |
303 | ||
304 | /* These are definitions to map POSIX 1003.1 functions onto existing BSD | |
305 | library functions and system calls. */ | |
306 | #define setpgid(pid, pgrp) setpgrp (pid, pgrp) | |
307 | #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp)) | |
308 | ||
309 | pid_t | |
310 | tcgetpgrp (fd) | |
311 | int fd; | |
312 | { | |
313 | pid_t pgrp; | |
314 | ||
315 | /* ioctl will handle setting errno correctly. */ | |
316 | if (ioctl (fd, TIOCGPGRP, &pgrp) < 0) | |
317 | return (-1); | |
318 | return (pgrp); | |
319 | } | |
320 | ||
726f6388 JA |
321 | #endif /* !_POSIX_VERSION */ |
322 | ||
323 | /* Return the working directory for the current process. Unlike | |
324 | job_working_directory, this does not call malloc (), nor do any | |
325 | of the functions it calls. This is so that it can safely be called | |
326 | from a signal handler. */ | |
327 | static char * | |
328 | current_working_directory () | |
329 | { | |
330 | char *dir; | |
ccc6cda3 | 331 | static char d[PATH_MAX]; |
726f6388 JA |
332 | |
333 | dir = get_string_value ("PWD"); | |
334 | ||
ccc6cda3 | 335 | if (dir == 0 && the_current_working_directory && no_symbolic_links) |
726f6388 JA |
336 | dir = the_current_working_directory; |
337 | ||
ccc6cda3 | 338 | if (dir == 0) |
726f6388 | 339 | { |
ccc6cda3 | 340 | dir = getcwd (d, sizeof(d)); |
726f6388 JA |
341 | if (dir) |
342 | dir = d; | |
343 | } | |
344 | ||
ccc6cda3 | 345 | return (dir == 0) ? "<unknown>" : dir; |
726f6388 JA |
346 | } |
347 | ||
348 | /* Return the working directory for the current process. */ | |
349 | static char * | |
350 | job_working_directory () | |
351 | { | |
352 | char *dir; | |
353 | ||
354 | dir = get_string_value ("PWD"); | |
355 | if (dir) | |
356 | return (savestring (dir)); | |
357 | ||
358 | dir = get_working_directory ("job-working-directory"); | |
359 | if (dir) | |
360 | return (dir); | |
361 | ||
362 | return (savestring ("<unknown>")); | |
363 | } | |
364 | ||
365 | void | |
366 | making_children () | |
367 | { | |
368 | if (already_making_children) | |
369 | return; | |
370 | ||
371 | already_making_children = 1; | |
372 | start_pipeline (); | |
373 | } | |
374 | ||
375 | void | |
376 | stop_making_children () | |
377 | { | |
378 | already_making_children = 0; | |
379 | } | |
380 | ||
381 | void | |
382 | cleanup_the_pipeline () | |
383 | { | |
384 | if (the_pipeline) | |
385 | { | |
386 | discard_pipeline (the_pipeline); | |
387 | the_pipeline = (PROCESS *)NULL; | |
388 | } | |
389 | } | |
390 | ||
ccc6cda3 JA |
391 | void |
392 | save_pipeline (clear) | |
393 | int clear; | |
394 | { | |
395 | saved_pipeline = the_pipeline; | |
396 | saved_already_making_children = already_making_children; | |
397 | if (clear) | |
398 | the_pipeline = (PROCESS *)NULL; | |
399 | } | |
400 | ||
401 | void | |
402 | restore_pipeline (discard) | |
403 | int discard; | |
404 | { | |
405 | PROCESS *old_pipeline; | |
406 | ||
407 | old_pipeline = the_pipeline; | |
408 | the_pipeline = saved_pipeline; | |
409 | already_making_children = saved_already_making_children; | |
410 | if (discard) | |
411 | discard_pipeline (old_pipeline); | |
412 | } | |
413 | ||
726f6388 JA |
414 | /* Start building a pipeline. */ |
415 | void | |
416 | start_pipeline () | |
417 | { | |
418 | if (the_pipeline) | |
419 | { | |
ccc6cda3 | 420 | cleanup_the_pipeline (); |
726f6388 JA |
421 | pipeline_pgrp = 0; |
422 | #if defined (PGRP_PIPE) | |
423 | pipe_close (pgrp_pipe); | |
424 | #endif | |
425 | } | |
426 | ||
427 | #if defined (PGRP_PIPE) | |
428 | if (job_control) | |
429 | { | |
430 | if (pipe (pgrp_pipe) == -1) | |
ccc6cda3 | 431 | sys_error ("start_pipeline: pgrp pipe"); |
726f6388 JA |
432 | } |
433 | #endif | |
434 | } | |
435 | ||
436 | /* Stop building a pipeline. Install the process list in the job array. | |
437 | This returns the index of the newly installed job. | |
438 | DEFERRED is a command structure to be executed upon satisfactory | |
439 | execution exit of this pipeline. */ | |
440 | int | |
441 | stop_pipeline (async, deferred) | |
442 | int async; | |
443 | COMMAND *deferred; | |
444 | { | |
445 | register int i, j; | |
ccc6cda3 | 446 | JOB *newjob; |
726f6388 JA |
447 | sigset_t set, oset; |
448 | ||
449 | BLOCK_CHILD (set, oset); | |
450 | ||
451 | #if defined (PGRP_PIPE) | |
452 | /* The parent closes the process group synchronization pipe. */ | |
453 | pipe_close (pgrp_pipe); | |
454 | #endif | |
ccc6cda3 | 455 | |
726f6388 JA |
456 | cleanup_dead_jobs (); |
457 | ||
ccc6cda3 | 458 | if (job_slots == 0) |
726f6388 | 459 | { |
ccc6cda3 JA |
460 | job_slots = JOB_SLOTS; |
461 | jobs = (JOB **)xmalloc (job_slots * sizeof (JOB *)); | |
726f6388 JA |
462 | |
463 | /* Now blank out these new entries. */ | |
464 | for (i = 0; i < job_slots; i++) | |
465 | jobs[i] = (JOB *)NULL; | |
466 | } | |
467 | ||
468 | /* Scan from the last slot backward, looking for the next free one. */ | |
469 | if (interactive) | |
470 | { | |
471 | for (i = job_slots; i; i--) | |
472 | if (jobs[i - 1]) | |
473 | break; | |
474 | } | |
475 | else | |
476 | { | |
477 | /* If we're not interactive, we don't need to monotonically increase | |
478 | the job number (in fact, we don't care about the job number at all), | |
479 | so we can simply scan for the first free slot. This helps to keep | |
480 | us from continuously reallocating the jobs array when running | |
481 | certain kinds of shell loops, and saves time spent searching. */ | |
482 | for (i = 0; i < job_slots; i++) | |
ccc6cda3 | 483 | if (jobs[i] == 0) |
726f6388 JA |
484 | break; |
485 | } | |
486 | ||
487 | /* Do we need more room? */ | |
7117c2d2 JA |
488 | |
489 | /* First try compaction */ | |
490 | if (subshell_environment && interactive_shell && i == job_slots && job_slots >= MAX_JOBS_IN_ARRAY) | |
491 | i = compact_jobs_list (0); | |
492 | ||
493 | /* If we can't compact, reallocate */ | |
726f6388 JA |
494 | if (i == job_slots) |
495 | { | |
496 | job_slots += JOB_SLOTS; | |
497 | jobs = (JOB **)xrealloc (jobs, ((1 + job_slots) * sizeof (JOB *))); | |
498 | ||
499 | for (j = i; j < job_slots; j++) | |
500 | jobs[j] = (JOB *)NULL; | |
501 | } | |
502 | ||
503 | /* Add the current pipeline to the job list. */ | |
504 | if (the_pipeline) | |
505 | { | |
506 | register PROCESS *p; | |
ccc6cda3 | 507 | int any_alive, any_stopped; |
726f6388 JA |
508 | |
509 | newjob = (JOB *)xmalloc (sizeof (JOB)); | |
510 | ||
ccc6cda3 JA |
511 | for (p = the_pipeline; p->next != the_pipeline; p = p->next) |
512 | ; | |
726f6388 JA |
513 | p->next = (PROCESS *)NULL; |
514 | newjob->pipe = REVERSE_LIST (the_pipeline, PROCESS *); | |
ccc6cda3 JA |
515 | for (p = newjob->pipe; p->next; p = p->next) |
516 | ; | |
726f6388 JA |
517 | p->next = newjob->pipe; |
518 | ||
519 | the_pipeline = (PROCESS *)NULL; | |
520 | newjob->pgrp = pipeline_pgrp; | |
521 | pipeline_pgrp = 0; | |
522 | ||
523 | newjob->flags = 0; | |
524 | ||
525 | /* Flag to see if in another pgrp. */ | |
526 | if (job_control) | |
527 | newjob->flags |= J_JOBCONTROL; | |
528 | ||
529 | /* Set the state of this pipeline. */ | |
ccc6cda3 JA |
530 | p = newjob->pipe; |
531 | any_alive = any_stopped = 0; | |
532 | do | |
533 | { | |
534 | any_alive |= p->running; | |
535 | any_stopped |= WIFSTOPPED (p->status); | |
536 | p = p->next; | |
537 | } | |
538 | while (p != newjob->pipe); | |
726f6388 | 539 | |
ccc6cda3 | 540 | newjob->state = any_alive ? JRUNNING : (any_stopped ? JSTOPPED : JDEAD); |
726f6388 JA |
541 | newjob->wd = job_working_directory (); |
542 | newjob->deferred = deferred; | |
543 | ||
f73dda09 | 544 | newjob->j_cleanup = (sh_vptrfunc_t *)NULL; |
ccc6cda3 JA |
545 | newjob->cleanarg = (PTR_T) NULL; |
546 | ||
726f6388 | 547 | jobs[i] = newjob; |
ccc6cda3 JA |
548 | if (newjob->state == JDEAD && (newjob->flags & J_FOREGROUND)) |
549 | setjstatus (i); | |
726f6388 | 550 | } |
ccc6cda3 JA |
551 | else |
552 | newjob = (JOB *)NULL; | |
726f6388 JA |
553 | |
554 | if (async) | |
555 | { | |
556 | if (newjob) | |
557 | newjob->flags &= ~J_FOREGROUND; | |
558 | reset_current (); | |
559 | } | |
560 | else | |
561 | { | |
562 | if (newjob) | |
563 | { | |
564 | newjob->flags |= J_FOREGROUND; | |
565 | /* | |
566 | * !!!!! NOTE !!!!! (chet@ins.cwru.edu) | |
567 | * | |
568 | * The currently-accepted job control wisdom says to set the | |
569 | * terminal's process group n+1 times in an n-step pipeline: | |
570 | * once in the parent and once in each child. This is where | |
571 | * the parent gives it away. | |
572 | * | |
573 | */ | |
574 | if (job_control && newjob->pgrp) | |
28ef6c31 | 575 | give_terminal_to (newjob->pgrp, 0); |
726f6388 JA |
576 | } |
577 | } | |
578 | ||
579 | stop_making_children (); | |
580 | UNBLOCK_CHILD (oset); | |
581 | return (current_job); | |
582 | } | |
583 | ||
584 | /* Delete all DEAD jobs that the user had received notification about. */ | |
585 | static void | |
586 | cleanup_dead_jobs () | |
587 | { | |
588 | register int i; | |
7117c2d2 | 589 | int os; |
726f6388 | 590 | |
ccc6cda3 | 591 | if (job_slots == 0 || jobs_list_frozen) |
726f6388 JA |
592 | return; |
593 | ||
7117c2d2 | 594 | QUEUE_SIGCHLD(os); |
726f6388 JA |
595 | |
596 | for (i = 0; i < job_slots; i++) | |
ccc6cda3 | 597 | if (jobs[i] && DEADJOB (i) && IS_NOTIFIED (i)) |
cce855bc | 598 | delete_job (i, 0); |
726f6388 | 599 | |
7117c2d2 JA |
600 | UNQUEUE_SIGCHLD(os); |
601 | } | |
602 | ||
603 | /* Compact the jobs list by removing dead jobs. Assumed that we have filled | |
604 | the jobs array to some predefined maximum. Called when the shell is not | |
605 | the foreground process (subshell_environment != 0). Returns the first | |
606 | available slot in the compacted list. If that value is job_slots, then | |
607 | the list needs to be reallocated. The jobs array is in new memory if | |
608 | this returns > 0 and < job_slots. FLAGS is reserved for future use. */ | |
609 | static int | |
610 | compact_jobs_list (flags) | |
611 | int flags; | |
612 | { | |
613 | sigset_t set, oset; | |
614 | register int i, j; | |
615 | int nremove, ndel; | |
616 | JOB **newlist; | |
617 | ||
618 | if (job_slots == 0 || jobs_list_frozen) | |
619 | return job_slots; | |
620 | ||
621 | if (child_max < 0) | |
622 | child_max = getmaxchild (); | |
623 | ||
624 | /* Take out at most a quarter of the jobs in the jobs array, but leave at | |
625 | least child_max */ | |
626 | nremove = job_slots >> 2; | |
627 | if ((job_slots - nremove) < child_max) | |
628 | nremove = job_slots - child_max; | |
629 | ||
630 | /* need to increase jobs list to at least CHILD_MAX entries */ | |
631 | if (nremove < 0) | |
632 | return job_slots; | |
633 | ||
634 | BLOCK_CHILD (set, oset); | |
635 | ||
636 | for (ndel = i = 0; i < job_slots; i++) | |
637 | if (jobs[i]) | |
638 | { | |
639 | if (DEADJOB (i) && (find_last_pid (i, 0) != last_asynchronous_pid)) | |
640 | { | |
641 | delete_job (i, 0); | |
642 | ndel++; | |
643 | if (ndel == nremove) | |
644 | break; | |
645 | } | |
646 | } | |
647 | ||
648 | if (ndel == 0) | |
649 | { | |
650 | UNBLOCK_CHILD (oset); | |
651 | return job_slots; | |
652 | } | |
653 | ||
654 | newlist = (JOB **)xmalloc ((1 + job_slots) * sizeof (JOB *)); | |
655 | for (i = j = 0; i < job_slots; i++) | |
656 | if (jobs[i]) | |
657 | newlist[j++] = jobs[i]; | |
658 | ||
659 | ndel = j; | |
660 | for ( ; j < job_slots; j++) | |
661 | newlist[j] = (JOB *)NULL; | |
662 | ||
663 | free (jobs); | |
664 | jobs = newlist; | |
665 | ||
726f6388 | 666 | UNBLOCK_CHILD (oset); |
7117c2d2 JA |
667 | |
668 | return ndel; | |
726f6388 JA |
669 | } |
670 | ||
671 | /* Delete the job at INDEX from the job list. Must be called | |
672 | with SIGCHLD blocked. */ | |
673 | void | |
cce855bc JA |
674 | delete_job (job_index, warn_stopped) |
675 | int job_index, warn_stopped; | |
726f6388 JA |
676 | { |
677 | register JOB *temp; | |
678 | ||
cce855bc | 679 | if (job_slots == 0 || jobs_list_frozen) |
726f6388 JA |
680 | return; |
681 | ||
cce855bc | 682 | if (warn_stopped && subshell_environment == 0 && STOPPED (job_index)) |
f73dda09 | 683 | internal_warning ("deleting stopped job %d with process group %ld", job_index+1, (long)jobs[job_index]->pgrp); |
cce855bc | 684 | |
726f6388 JA |
685 | temp = jobs[job_index]; |
686 | if (job_index == current_job || job_index == previous_job) | |
687 | reset_current (); | |
688 | ||
689 | jobs[job_index] = (JOB *)NULL; | |
690 | ||
691 | free (temp->wd); | |
692 | discard_pipeline (temp->pipe); | |
693 | ||
694 | if (temp->deferred) | |
695 | dispose_command (temp->deferred); | |
696 | ||
697 | free (temp); | |
698 | } | |
699 | ||
ccc6cda3 JA |
700 | /* Must be called with SIGCHLD blocked. */ |
701 | void | |
702 | nohup_job (job_index) | |
703 | int job_index; | |
704 | { | |
705 | register JOB *temp; | |
706 | ||
cce855bc JA |
707 | if (job_slots == 0) |
708 | return; | |
709 | ||
d166f048 | 710 | if (temp = jobs[job_index]) |
ccc6cda3 JA |
711 | temp->flags |= J_NOHUP; |
712 | } | |
713 | ||
726f6388 JA |
714 | /* Get rid of the data structure associated with a process chain. */ |
715 | static void | |
716 | discard_pipeline (chain) | |
717 | register PROCESS *chain; | |
718 | { | |
719 | register PROCESS *this, *next; | |
720 | ||
721 | this = chain; | |
722 | do | |
723 | { | |
724 | next = this->next; | |
ccc6cda3 | 725 | FREE (this->command); |
726f6388 JA |
726 | free (this); |
727 | this = next; | |
728 | } | |
729 | while (this != chain); | |
730 | } | |
731 | ||
732 | /* Add this process to the chain being built in the_pipeline. | |
733 | NAME is the command string that will be exec'ed later. | |
734 | PID is the process id of the child. */ | |
735 | static void | |
736 | add_process (name, pid) | |
737 | char *name; | |
738 | pid_t pid; | |
739 | { | |
ccc6cda3 | 740 | PROCESS *t, *p; |
726f6388 | 741 | |
ccc6cda3 | 742 | t = (PROCESS *)xmalloc (sizeof (PROCESS)); |
726f6388 JA |
743 | t->next = the_pipeline; |
744 | t->pid = pid; | |
745 | WSTATUS (t->status) = 0; | |
7117c2d2 | 746 | t->running = PS_RUNNING; |
726f6388 JA |
747 | t->command = name; |
748 | the_pipeline = t; | |
749 | ||
ccc6cda3 | 750 | if (t->next == 0) |
726f6388 JA |
751 | t->next = t; |
752 | else | |
753 | { | |
ccc6cda3 | 754 | p = t->next; |
726f6388 JA |
755 | while (p->next != t->next) |
756 | p = p->next; | |
757 | p->next = t; | |
758 | } | |
759 | } | |
760 | ||
761 | #if 0 | |
762 | /* Take the last job and make it the first job. Must be called with | |
763 | SIGCHLD blocked. */ | |
ccc6cda3 | 764 | int |
726f6388 JA |
765 | rotate_the_pipeline () |
766 | { | |
767 | PROCESS *p; | |
768 | ||
769 | if (the_pipeline->next == the_pipeline) | |
770 | return; | |
771 | for (p = the_pipeline; p->next != the_pipeline; p = p->next) | |
772 | ; | |
773 | the_pipeline = p; | |
774 | } | |
775 | ||
776 | /* Reverse the order of the processes in the_pipeline. Must be called with | |
777 | SIGCHLD blocked. */ | |
ccc6cda3 | 778 | int |
726f6388 JA |
779 | reverse_the_pipeline () |
780 | { | |
781 | PROCESS *p, *n; | |
782 | ||
783 | if (the_pipeline->next == the_pipeline) | |
784 | return; | |
785 | ||
786 | for (p = the_pipeline; p->next != the_pipeline; p = p->next) | |
787 | ; | |
788 | p->next = (PROCESS *)NULL; | |
789 | ||
790 | n = REVERSE_LIST (the_pipeline, PROCESS *); | |
791 | ||
792 | the_pipeline = n; | |
793 | for (p = the_pipeline; p->next; p = p->next) | |
794 | ; | |
795 | p->next = the_pipeline; | |
796 | } | |
797 | #endif | |
798 | ||
799 | /* Map FUNC over the list of jobs. If FUNC returns non-zero, | |
800 | then it is time to stop mapping, and that is the return value | |
801 | for map_over_jobs. FUNC is called with a JOB, arg1, arg2, | |
802 | and INDEX. */ | |
803 | static int | |
804 | map_over_jobs (func, arg1, arg2) | |
f73dda09 | 805 | sh_job_map_func_t *func; |
726f6388 JA |
806 | int arg1, arg2; |
807 | { | |
808 | register int i; | |
809 | int result; | |
810 | sigset_t set, oset; | |
811 | ||
28ef6c31 JA |
812 | if (job_slots == 0) |
813 | return 0; | |
814 | ||
726f6388 | 815 | BLOCK_CHILD (set, oset); |
726f6388 | 816 | |
ccc6cda3 | 817 | for (i = result = 0; i < job_slots; i++) |
726f6388 JA |
818 | { |
819 | if (jobs[i]) | |
820 | { | |
821 | result = (*func)(jobs[i], arg1, arg2, i); | |
822 | if (result) | |
823 | break; | |
824 | } | |
825 | } | |
826 | ||
827 | UNBLOCK_CHILD (oset); | |
ccc6cda3 | 828 | |
726f6388 JA |
829 | return (result); |
830 | } | |
831 | ||
832 | /* Cause all the jobs in the current pipeline to exit. */ | |
833 | void | |
834 | terminate_current_pipeline () | |
835 | { | |
836 | if (pipeline_pgrp && pipeline_pgrp != shell_pgrp) | |
837 | { | |
838 | killpg (pipeline_pgrp, SIGTERM); | |
839 | killpg (pipeline_pgrp, SIGCONT); | |
840 | } | |
841 | } | |
842 | ||
843 | /* Cause all stopped jobs to exit. */ | |
844 | void | |
845 | terminate_stopped_jobs () | |
846 | { | |
847 | register int i; | |
848 | ||
849 | for (i = 0; i < job_slots; i++) | |
850 | { | |
ccc6cda3 | 851 | if (jobs[i] && STOPPED (i)) |
726f6388 JA |
852 | { |
853 | killpg (jobs[i]->pgrp, SIGTERM); | |
854 | killpg (jobs[i]->pgrp, SIGCONT); | |
855 | } | |
856 | } | |
857 | } | |
858 | ||
ccc6cda3 JA |
859 | /* Cause all jobs, running or stopped, to receive a hangup signal. If |
860 | a job is marked J_NOHUP, don't send the SIGHUP. */ | |
726f6388 JA |
861 | void |
862 | hangup_all_jobs () | |
863 | { | |
864 | register int i; | |
865 | ||
866 | for (i = 0; i < job_slots; i++) | |
867 | { | |
868 | if (jobs[i]) | |
869 | { | |
ccc6cda3 JA |
870 | if ((jobs[i]->flags & J_NOHUP) == 0) |
871 | killpg (jobs[i]->pgrp, SIGHUP); | |
872 | if (STOPPED (i)) | |
726f6388 JA |
873 | killpg (jobs[i]->pgrp, SIGCONT); |
874 | } | |
875 | } | |
876 | } | |
877 | ||
878 | void | |
879 | kill_current_pipeline () | |
880 | { | |
881 | stop_making_children (); | |
882 | start_pipeline (); | |
883 | } | |
884 | ||
885 | /* Return the pipeline that PID belongs to. Note that the pipeline | |
886 | doesn't have to belong to a job. Must be called with SIGCHLD blocked. */ | |
887 | static PROCESS * | |
7117c2d2 | 888 | find_pipeline (pid, running_only, jobp) |
726f6388 | 889 | pid_t pid; |
7117c2d2 JA |
890 | int running_only; |
891 | int *jobp; /* index into jobs list or NO_JOB */ | |
726f6388 JA |
892 | { |
893 | int job; | |
ccc6cda3 | 894 | register PROCESS *p; |
726f6388 JA |
895 | |
896 | /* See if this process is in the pipeline that we are building. */ | |
7117c2d2 JA |
897 | if (jobp) |
898 | *jobp = NO_JOB; | |
726f6388 JA |
899 | if (the_pipeline) |
900 | { | |
ccc6cda3 | 901 | p = the_pipeline; |
726f6388 JA |
902 | do |
903 | { | |
904 | /* Return it if we found it. */ | |
905 | if (p->pid == pid) | |
7117c2d2 JA |
906 | { |
907 | if ((running_only && PRUNNING(p)) || (running_only == 0)) | |
908 | return (p); | |
909 | } | |
726f6388 JA |
910 | |
911 | p = p->next; | |
912 | } | |
913 | while (p != the_pipeline); | |
914 | } | |
915 | ||
7117c2d2 JA |
916 | job = find_job (pid, running_only); |
917 | if (jobp) | |
918 | *jobp = job; | |
ccc6cda3 | 919 | return (job == NO_JOB) ? (PROCESS *)NULL : jobs[job]->pipe; |
726f6388 JA |
920 | } |
921 | ||
922 | /* Return the job index that PID belongs to, or NO_JOB if it doesn't | |
923 | belong to any job. Must be called with SIGCHLD blocked. */ | |
924 | static int | |
7117c2d2 | 925 | find_job (pid, running_only) |
726f6388 | 926 | pid_t pid; |
7117c2d2 | 927 | int running_only; |
726f6388 JA |
928 | { |
929 | register int i; | |
930 | register PROCESS *p; | |
931 | ||
932 | for (i = 0; i < job_slots; i++) | |
933 | { | |
934 | if (jobs[i]) | |
935 | { | |
936 | p = jobs[i]->pipe; | |
937 | ||
938 | do | |
939 | { | |
940 | if (p->pid == pid) | |
7117c2d2 JA |
941 | { |
942 | if ((running_only && PRUNNING(p)) || (running_only == 0)) | |
943 | return (i); | |
944 | } | |
726f6388 JA |
945 | |
946 | p = p->next; | |
947 | } | |
948 | while (p != jobs[i]->pipe); | |
949 | } | |
950 | } | |
951 | ||
952 | return (NO_JOB); | |
953 | } | |
954 | ||
d166f048 JA |
955 | /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as |
956 | required by find_job. */ | |
957 | int | |
958 | get_job_by_pid (pid, block) | |
959 | pid_t pid; | |
960 | int block; | |
961 | { | |
962 | int job; | |
963 | sigset_t set, oset; | |
964 | ||
965 | if (block) | |
966 | BLOCK_CHILD (set, oset); | |
7117c2d2 JA |
967 | |
968 | job = find_job (pid, 0); | |
969 | ||
d166f048 JA |
970 | if (block) |
971 | UNBLOCK_CHILD (oset); | |
972 | ||
973 | return job; | |
974 | } | |
975 | ||
726f6388 JA |
976 | /* Print descriptive information about the job with leader pid PID. */ |
977 | void | |
978 | describe_pid (pid) | |
979 | pid_t pid; | |
980 | { | |
981 | int job; | |
982 | sigset_t set, oset; | |
983 | ||
984 | BLOCK_CHILD (set, oset); | |
985 | ||
7117c2d2 | 986 | job = find_job (pid, 0); |
726f6388 JA |
987 | |
988 | if (job != NO_JOB) | |
f73dda09 | 989 | printf ("[%d] %ld\n", job + 1, (long)pid); |
726f6388 | 990 | else |
f73dda09 | 991 | programming_error ("describe_pid: %ld: no such pid", (long)pid); |
726f6388 JA |
992 | |
993 | UNBLOCK_CHILD (oset); | |
994 | } | |
995 | ||
28ef6c31 JA |
996 | static char * |
997 | printable_job_status (j, p, format) | |
998 | int j; | |
999 | PROCESS *p; | |
1000 | int format; | |
1001 | { | |
1002 | static char *temp; | |
1003 | int es; | |
1004 | ||
1005 | temp = "Done"; | |
1006 | ||
1007 | if (STOPPED (j) && format == 0) | |
1008 | { | |
1009 | if (posixly_correct == 0 || p == 0 || (WIFSTOPPED (p->status) == 0)) | |
1010 | temp = "Stopped"; | |
1011 | else | |
1012 | { | |
1013 | temp = retcode_name_buffer; | |
1014 | sprintf (temp, "Stopped(%s)", signal_name (WSTOPSIG (p->status))); | |
1015 | } | |
1016 | } | |
1017 | else if (RUNNING (j)) | |
1018 | temp = "Running"; | |
1019 | else | |
1020 | { | |
1021 | if (WIFSTOPPED (p->status)) | |
f73dda09 | 1022 | temp = strsignal (WSTOPSIG (p->status)); |
28ef6c31 | 1023 | else if (WIFSIGNALED (p->status)) |
f73dda09 | 1024 | temp = strsignal (WTERMSIG (p->status)); |
28ef6c31 JA |
1025 | else if (WIFEXITED (p->status)) |
1026 | { | |
1027 | temp = retcode_name_buffer; | |
1028 | es = WEXITSTATUS (p->status); | |
1029 | if (es == 0) | |
1030 | strcpy (temp, "Done"); | |
1031 | else if (posixly_correct) | |
1032 | sprintf (temp, "Done(%d)", es); | |
1033 | else | |
1034 | sprintf (temp, "Exit %d", es); | |
1035 | } | |
1036 | else | |
1037 | temp = "Unknown status"; | |
1038 | } | |
1039 | ||
1040 | return temp; | |
1041 | } | |
1042 | ||
726f6388 JA |
1043 | /* This is the way to print out information on a job if you |
1044 | know the index. FORMAT is: | |
1045 | ||
1046 | JLIST_NORMAL) [1]+ Running emacs | |
1047 | JLIST_LONG ) [1]+ 2378 Running emacs | |
1048 | -1 ) [1]+ 2378 emacs | |
1049 | ||
1050 | JLIST_NORMAL) [1]+ Stopped ls | more | |
1051 | JLIST_LONG ) [1]+ 2369 Stopped ls | |
1052 | 2367 | more | |
1053 | JLIST_PID_ONLY) | |
1054 | Just list the pid of the process group leader (really | |
1055 | the process group). | |
1056 | JLIST_CHANGED_ONLY) | |
1057 | Use format JLIST_NORMAL, but list only jobs about which | |
1058 | the user has not been notified. */ | |
ccc6cda3 JA |
1059 | |
1060 | /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into | |
1061 | the JOBS array corresponding to this pipeline. FORMAT is as described | |
1062 | above. Must be called with SIGCHLD blocked. | |
1063 | ||
1064 | If you're printing a pipeline that's not in the jobs array, like the | |
1065 | current pipeline as it's being created, pass -1 for JOB_INDEX */ | |
726f6388 | 1066 | static void |
ccc6cda3 JA |
1067 | print_pipeline (p, job_index, format, stream) |
1068 | PROCESS *p; | |
726f6388 JA |
1069 | int job_index, format; |
1070 | FILE *stream; | |
1071 | { | |
ccc6cda3 JA |
1072 | PROCESS *first, *last, *show; |
1073 | int es, name_padding; | |
28ef6c31 | 1074 | char *temp; |
726f6388 | 1075 | |
ccc6cda3 JA |
1076 | if (p == 0) |
1077 | return; | |
726f6388 | 1078 | |
ccc6cda3 | 1079 | first = last = p; |
726f6388 JA |
1080 | while (last->next != first) |
1081 | last = last->next; | |
1082 | ||
726f6388 JA |
1083 | for (;;) |
1084 | { | |
1085 | if (p != first) | |
1086 | fprintf (stream, format ? " " : " |"); | |
1087 | ||
ccc6cda3 | 1088 | if (format != JLIST_STANDARD) |
f73dda09 | 1089 | fprintf (stream, "%5ld", (long)p->pid); |
726f6388 JA |
1090 | |
1091 | fprintf (stream, " "); | |
1092 | ||
ccc6cda3 | 1093 | if (format > -1 && job_index >= 0) |
726f6388 | 1094 | { |
ccc6cda3 | 1095 | show = format ? p : last; |
28ef6c31 | 1096 | temp = printable_job_status (job_index, show, format); |
726f6388 JA |
1097 | |
1098 | if (p != first) | |
1099 | { | |
1100 | if (format) | |
1101 | { | |
1102 | if (show->running == first->running && | |
1103 | WSTATUS (show->status) == WSTATUS (first->status)) | |
1104 | temp = ""; | |
1105 | } | |
1106 | else | |
1107 | temp = (char *)NULL; | |
1108 | } | |
1109 | ||
1110 | if (temp) | |
1111 | { | |
726f6388 JA |
1112 | fprintf (stream, "%s", temp); |
1113 | ||
ccc6cda3 JA |
1114 | es = STRLEN (temp); |
1115 | if (es == 0) | |
28ef6c31 | 1116 | es = 2; /* strlen ("| ") */ |
ccc6cda3 | 1117 | name_padding = LONGEST_SIGNAL_DESC - es; |
726f6388 JA |
1118 | |
1119 | fprintf (stream, "%*s", name_padding, ""); | |
1120 | ||
f73dda09 JA |
1121 | if ((WIFSTOPPED (show->status) == 0) && |
1122 | (WIFCONTINUED (show->status) == 0) && | |
1123 | WIFCORED (show->status)) | |
726f6388 JA |
1124 | fprintf (stream, "(core dumped) "); |
1125 | } | |
1126 | } | |
1127 | ||
1128 | if (p != first && format) | |
1129 | fprintf (stream, "| "); | |
1130 | ||
1131 | if (p->command) | |
1132 | fprintf (stream, "%s", p->command); | |
1133 | ||
ccc6cda3 | 1134 | if (p == last && job_index >= 0) |
726f6388 | 1135 | { |
ccc6cda3 | 1136 | temp = current_working_directory (); |
726f6388 | 1137 | |
ccc6cda3 | 1138 | if (RUNNING (job_index) && (IS_FOREGROUND (job_index) == 0)) |
726f6388 JA |
1139 | fprintf (stream, " &"); |
1140 | ||
ccc6cda3 | 1141 | if (strcmp (temp, jobs[job_index]->wd) != 0) |
726f6388 | 1142 | fprintf (stream, |
ccc6cda3 | 1143 | " (wd: %s)", polite_directory_format (jobs[job_index]->wd)); |
726f6388 JA |
1144 | } |
1145 | ||
1146 | if (format || (p == last)) | |
cce855bc JA |
1147 | { |
1148 | /* We need to add a CR only if this is an interactive shell, and | |
1149 | we're reporting the status of a completed job asynchronously. | |
1150 | We can't really check whether this particular job is being | |
1151 | reported asynchronously, so just add the CR if the shell is | |
1152 | currently interactive and asynchronous notification is enabled. */ | |
1153 | if (asynchronous_notification && interactive) | |
1154 | fprintf (stream, "\r\n"); | |
1155 | else | |
1156 | fprintf (stream, "\n"); | |
1157 | } | |
726f6388 JA |
1158 | |
1159 | if (p == last) | |
1160 | break; | |
1161 | p = p->next; | |
1162 | } | |
726f6388 | 1163 | fflush (stream); |
ccc6cda3 JA |
1164 | } |
1165 | ||
7117c2d2 JA |
1166 | /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT. |
1167 | Must be called with SIGCHLD blocked or queued with queue_sigchld */ | |
ccc6cda3 JA |
1168 | static void |
1169 | pretty_print_job (job_index, format, stream) | |
1170 | int job_index, format; | |
1171 | FILE *stream; | |
1172 | { | |
1173 | register PROCESS *p; | |
ccc6cda3 JA |
1174 | |
1175 | /* Format only pid information about the process group leader? */ | |
1176 | if (format == JLIST_PID_ONLY) | |
1177 | { | |
f73dda09 | 1178 | fprintf (stream, "%ld\n", (long)jobs[job_index]->pipe->pid); |
ccc6cda3 JA |
1179 | return; |
1180 | } | |
1181 | ||
1182 | if (format == JLIST_CHANGED_ONLY) | |
1183 | { | |
1184 | if (IS_NOTIFIED (job_index)) | |
7117c2d2 | 1185 | return; |
ccc6cda3 JA |
1186 | format = JLIST_STANDARD; |
1187 | } | |
1188 | ||
1189 | if (format != JLIST_NONINTERACTIVE) | |
1190 | fprintf (stream, "[%d]%c ", job_index + 1, | |
1191 | (job_index == current_job) ? '+': | |
28ef6c31 | 1192 | (job_index == previous_job) ? '-' : ' '); |
ccc6cda3 JA |
1193 | |
1194 | if (format == JLIST_NONINTERACTIVE) | |
1195 | format = JLIST_LONG; | |
1196 | ||
1197 | p = jobs[job_index]->pipe; | |
1198 | ||
cce855bc JA |
1199 | print_pipeline (p, job_index, format, stream); |
1200 | ||
ccc6cda3 JA |
1201 | /* We have printed information about this job. When the job's |
1202 | status changes, waitchld () sets the notification flag to 0. */ | |
1203 | jobs[job_index]->flags |= J_NOTIFIED; | |
726f6388 JA |
1204 | } |
1205 | ||
ccc6cda3 JA |
1206 | static int |
1207 | print_job (job, format, state, job_index) | |
1208 | JOB *job; | |
1209 | int format, state, job_index; | |
1210 | { | |
1211 | if (state == -1 || (JOB_STATE)state == job->state) | |
1212 | pretty_print_job (job_index, format, stdout); | |
1213 | return (0); | |
1214 | } | |
1215 | ||
1216 | void | |
726f6388 JA |
1217 | list_one_job (job, format, ignore, job_index) |
1218 | JOB *job; | |
1219 | int format, ignore, job_index; | |
1220 | { | |
7117c2d2 | 1221 | pretty_print_job (job_index, format, stdout); |
ccc6cda3 JA |
1222 | } |
1223 | ||
1224 | void | |
1225 | list_stopped_jobs (format) | |
1226 | int format; | |
1227 | { | |
1228 | cleanup_dead_jobs (); | |
1229 | map_over_jobs (print_job, format, (int)JSTOPPED); | |
1230 | } | |
1231 | ||
1232 | void | |
1233 | list_running_jobs (format) | |
1234 | int format; | |
1235 | { | |
1236 | cleanup_dead_jobs (); | |
1237 | map_over_jobs (print_job, format, (int)JRUNNING); | |
726f6388 JA |
1238 | } |
1239 | ||
1240 | /* List jobs. If FORMAT is non-zero, then the long form of the information | |
1241 | is printed, else just a short version. */ | |
1242 | void | |
ccc6cda3 | 1243 | list_all_jobs (format) |
726f6388 JA |
1244 | int format; |
1245 | { | |
1246 | cleanup_dead_jobs (); | |
ccc6cda3 | 1247 | map_over_jobs (print_job, format, -1); |
726f6388 JA |
1248 | } |
1249 | ||
1250 | /* Fork, handling errors. Returns the pid of the newly made child, or 0. | |
1251 | COMMAND is just for remembering the name of the command; we don't do | |
1252 | anything else with it. ASYNC_P says what to do with the tty. If | |
1253 | non-zero, then don't give it away. */ | |
1254 | pid_t | |
1255 | make_child (command, async_p) | |
1256 | char *command; | |
1257 | int async_p; | |
1258 | { | |
1259 | sigset_t set, oset; | |
1260 | pid_t pid; | |
1261 | ||
1262 | sigemptyset (&set); | |
1263 | sigaddset (&set, SIGCHLD); | |
1264 | sigaddset (&set, SIGINT); | |
1265 | sigemptyset (&oset); | |
1266 | sigprocmask (SIG_BLOCK, &set, &oset); | |
1267 | ||
1268 | making_children (); | |
1269 | ||
1270 | #if defined (BUFFERED_INPUT) | |
1271 | /* If default_buffered_input is active, we are reading a script. If | |
1272 | the command is asynchronous, we have already duplicated /dev/null | |
1273 | as fd 0, but have not changed the buffered stream corresponding to | |
1274 | the old fd 0. We don't want to sync the stream in this case. */ | |
1275 | if (default_buffered_input != -1 && | |
1276 | (!async_p || default_buffered_input > 0)) | |
1277 | sync_buffered_stream (default_buffered_input); | |
1278 | #endif /* BUFFERED_INPUT */ | |
1279 | ||
1280 | /* Create the child, handle severe errors. */ | |
1281 | if ((pid = fork ()) < 0) | |
1282 | { | |
ccc6cda3 | 1283 | sys_error ("fork"); |
726f6388 JA |
1284 | |
1285 | /* Kill all of the processes in the current pipeline. */ | |
1286 | terminate_current_pipeline (); | |
1287 | ||
1288 | /* Discard the current pipeline, if any. */ | |
1289 | if (the_pipeline) | |
1290 | kill_current_pipeline (); | |
1291 | ||
1292 | throw_to_top_level (); /* Reset signals, etc. */ | |
1293 | } | |
1294 | ||
1295 | if (pid == 0) | |
1296 | { | |
1297 | /* In the child. Give this child the right process group, set the | |
1298 | signals to the default state for a new process. */ | |
b72432fd | 1299 | pid_t mypid; |
726f6388 | 1300 | |
b72432fd | 1301 | mypid = getpid (); |
726f6388 JA |
1302 | #if defined (BUFFERED_INPUT) |
1303 | /* Close default_buffered_input if it's > 0. We don't close it if it's | |
1304 | 0 because that's the file descriptor used when redirecting input, | |
1305 | and it's wrong to close the file in that case. */ | |
cce855bc | 1306 | unset_bash_input (0); |
726f6388 JA |
1307 | #endif /* BUFFERED_INPUT */ |
1308 | ||
1309 | /* Restore top-level signal mask. */ | |
1310 | sigprocmask (SIG_SETMASK, &top_level_mask, (sigset_t *)NULL); | |
1311 | ||
1312 | if (job_control) | |
1313 | { | |
1314 | /* All processes in this pipeline belong in the same | |
1315 | process group. */ | |
1316 | ||
ccc6cda3 | 1317 | if (pipeline_pgrp == 0) /* This is the first child. */ |
b72432fd | 1318 | pipeline_pgrp = mypid; |
726f6388 JA |
1319 | |
1320 | /* Check for running command in backquotes. */ | |
1321 | if (pipeline_pgrp == shell_pgrp) | |
ccc6cda3 | 1322 | ignore_tty_job_signals (); |
726f6388 | 1323 | else |
ccc6cda3 | 1324 | default_tty_job_signals (); |
726f6388 JA |
1325 | |
1326 | /* Set the process group before trying to mess with the terminal's | |
1327 | process group. This is mandated by POSIX. */ | |
1328 | /* This is in accordance with the Posix 1003.1 standard, | |
1329 | section B.7.2.4, which says that trying to set the terminal | |
1330 | process group with tcsetpgrp() to an unused pgrp value (like | |
1331 | this would have for the first child) is an error. Section | |
1332 | B.4.3.3, p. 237 also covers this, in the context of job control | |
1333 | shells. */ | |
b72432fd | 1334 | if (setpgid (mypid, pipeline_pgrp) < 0) |
f73dda09 | 1335 | sys_error ("child setpgid (%ld to %ld)", (long)mypid, (long)pipeline_pgrp); |
726f6388 | 1336 | #if defined (PGRP_PIPE) |
b72432fd | 1337 | if (pipeline_pgrp == mypid) |
726f6388 JA |
1338 | { |
1339 | #endif | |
28ef6c31 | 1340 | /* By convention (and assumption above), if |
b72432fd JA |
1341 | pipeline_pgrp == shell_pgrp, we are making a child for |
1342 | command substitution. | |
1343 | In this case, we don't want to give the terminal to the | |
1344 | shell's process group (we could be in the middle of a | |
1345 | pipeline, for example). */ | |
bc4cd23c | 1346 | if (async_p == 0 && pipeline_pgrp != shell_pgrp) |
28ef6c31 | 1347 | give_terminal_to (pipeline_pgrp, 0); |
726f6388 JA |
1348 | |
1349 | #if defined (PGRP_PIPE) | |
1350 | pipe_read (pgrp_pipe); | |
1351 | } | |
1352 | #endif | |
1353 | } | |
1354 | else /* Without job control... */ | |
1355 | { | |
ccc6cda3 | 1356 | if (pipeline_pgrp == 0) |
726f6388 JA |
1357 | pipeline_pgrp = shell_pgrp; |
1358 | ||
1359 | /* If these signals are set to SIG_DFL, we encounter the curious | |
1360 | situation of an interactive ^Z to a running process *working* | |
1361 | and stopping the process, but being unable to do anything with | |
1362 | that process to change its state. On the other hand, if they | |
1363 | are set to SIG_IGN, jobs started from scripts do not stop when | |
1364 | the shell running the script gets a SIGTSTP and stops. */ | |
1365 | ||
ccc6cda3 | 1366 | default_tty_job_signals (); |
726f6388 JA |
1367 | } |
1368 | ||
1369 | #if defined (PGRP_PIPE) | |
1370 | /* Release the process group pipe, since our call to setpgid () | |
1371 | is done. The last call to pipe_close is done in stop_pipeline. */ | |
1372 | pipe_close (pgrp_pipe); | |
1373 | #endif /* PGRP_PIPE */ | |
1374 | ||
1375 | if (async_p) | |
1376 | last_asynchronous_pid = getpid (); | |
1377 | } | |
1378 | else | |
1379 | { | |
1380 | /* In the parent. Remember the pid of the child just created | |
1381 | as the proper pgrp if this is the first child. */ | |
1382 | ||
1383 | if (job_control) | |
1384 | { | |
ccc6cda3 | 1385 | if (pipeline_pgrp == 0) |
726f6388 JA |
1386 | { |
1387 | pipeline_pgrp = pid; | |
1388 | /* Don't twiddle terminal pgrps in the parent! This is the bug, | |
1389 | not the good thing of twiddling them in the child! */ | |
28ef6c31 | 1390 | /* give_terminal_to (pipeline_pgrp, 0); */ |
726f6388 JA |
1391 | } |
1392 | /* This is done on the recommendation of the Rationale section of | |
1393 | the POSIX 1003.1 standard, where it discusses job control and | |
1394 | shells. It is done to avoid possible race conditions. (Ref. | |
1395 | 1003.1 Rationale, section B.4.3.3, page 236). */ | |
1396 | setpgid (pid, pipeline_pgrp); | |
1397 | } | |
1398 | else | |
1399 | { | |
ccc6cda3 | 1400 | if (pipeline_pgrp == 0) |
726f6388 JA |
1401 | pipeline_pgrp = shell_pgrp; |
1402 | } | |
1403 | ||
1404 | /* Place all processes into the jobs array regardless of the | |
1405 | state of job_control. */ | |
1406 | add_process (command, pid); | |
1407 | ||
1408 | if (async_p) | |
1409 | last_asynchronous_pid = pid; | |
1410 | ||
1411 | last_made_pid = pid; | |
1412 | ||
1413 | /* Unblock SIGINT and SIGCHLD. */ | |
1414 | sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL); | |
1415 | } | |
1416 | ||
1417 | return (pid); | |
1418 | } | |
1419 | ||
7117c2d2 | 1420 | /* These two functions are called only in child processes. */ |
ccc6cda3 JA |
1421 | void |
1422 | ignore_tty_job_signals () | |
1423 | { | |
1424 | set_signal_handler (SIGTSTP, SIG_IGN); | |
1425 | set_signal_handler (SIGTTIN, SIG_IGN); | |
1426 | set_signal_handler (SIGTTOU, SIG_IGN); | |
1427 | } | |
1428 | ||
1429 | void | |
1430 | default_tty_job_signals () | |
1431 | { | |
1432 | set_signal_handler (SIGTSTP, SIG_DFL); | |
1433 | set_signal_handler (SIGTTIN, SIG_DFL); | |
1434 | set_signal_handler (SIGTTOU, SIG_DFL); | |
1435 | } | |
1436 | ||
726f6388 JA |
1437 | /* When we end a job abnormally, or if we stop a job, we set the tty to the |
1438 | state kept in here. When a job ends normally, we set the state in here | |
1439 | to the state of the tty. */ | |
1440 | ||
28ef6c31 JA |
1441 | static TTYSTRUCT shell_tty_info; |
1442 | ||
726f6388 | 1443 | #if defined (NEW_TTY_DRIVER) |
726f6388 JA |
1444 | static struct tchars shell_tchars; |
1445 | static struct ltchars shell_ltchars; | |
1446 | #endif /* NEW_TTY_DRIVER */ | |
1447 | ||
726f6388 JA |
1448 | #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT) |
1449 | /* Since the BSD tty driver does not allow us to change the tty modes | |
1450 | while simultaneously waiting for output to drain and preserving | |
1451 | typeahead, we have to drain the output ourselves before calling | |
1452 | ioctl. We cheat by finding the length of the output queue, and | |
1453 | using select to wait for an appropriate length of time. This is | |
1454 | a hack, and should be labeled as such (it's a hastily-adapted | |
1455 | mutation of a `usleep' implementation). It's only reason for | |
1456 | existing is the flaw in the BSD tty driver. */ | |
1457 | ||
1458 | static int ttspeeds[] = | |
1459 | { | |
1460 | 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, | |
1461 | 1800, 2400, 4800, 9600, 19200, 38400 | |
1462 | }; | |
1463 | ||
1464 | static void | |
1465 | draino (fd, ospeed) | |
1466 | int fd, ospeed; | |
1467 | { | |
1468 | register int delay = ttspeeds[ospeed]; | |
1469 | int n; | |
1470 | ||
1471 | if (!delay) | |
1472 | return; | |
1473 | ||
1474 | while ((ioctl (fd, TIOCOUTQ, &n) == 0) && n) | |
1475 | { | |
1476 | if (n > (delay / 100)) | |
1477 | { | |
1478 | struct timeval tv; | |
1479 | ||
1480 | n *= 10; /* 2 bits more for conservativeness. */ | |
1481 | tv.tv_sec = n / delay; | |
1482 | tv.tv_usec = ((n % delay) * 1000000) / delay; | |
1483 | select (fd, (fd_set *)0, (fd_set *)0, (fd_set *)0, &tv); | |
1484 | } | |
1485 | else | |
1486 | break; | |
1487 | } | |
1488 | } | |
1489 | #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */ | |
1490 | ||
1491 | /* Return the fd from which we are actually getting input. */ | |
1492 | #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr) | |
1493 | ||
1494 | /* Fill the contents of shell_tty_info with the current tty info. */ | |
ccc6cda3 | 1495 | int |
726f6388 JA |
1496 | get_tty_state () |
1497 | { | |
ccc6cda3 | 1498 | int tty; |
726f6388 | 1499 | |
ccc6cda3 | 1500 | tty = input_tty (); |
726f6388 JA |
1501 | if (tty != -1) |
1502 | { | |
1503 | #if defined (NEW_TTY_DRIVER) | |
1504 | ioctl (tty, TIOCGETP, &shell_tty_info); | |
1505 | ioctl (tty, TIOCGETC, &shell_tchars); | |
1506 | ioctl (tty, TIOCGLTC, &shell_ltchars); | |
1507 | #endif /* NEW_TTY_DRIVER */ | |
1508 | ||
1509 | #if defined (TERMIO_TTY_DRIVER) | |
1510 | ioctl (tty, TCGETA, &shell_tty_info); | |
1511 | #endif /* TERMIO_TTY_DRIVER */ | |
1512 | ||
1513 | #if defined (TERMIOS_TTY_DRIVER) | |
1514 | if (tcgetattr (tty, &shell_tty_info) < 0) | |
1515 | { | |
1516 | #if 0 | |
1517 | /* Only print an error message if we're really interactive at | |
1518 | this time. */ | |
1519 | if (interactive) | |
f73dda09 | 1520 | sys_error ("[%ld: %d] tcgetattr", (long)getpid (), shell_level); |
726f6388 JA |
1521 | #endif |
1522 | return -1; | |
1523 | } | |
1524 | #endif /* TERMIOS_TTY_DRIVER */ | |
ccc6cda3 JA |
1525 | if (check_window_size) |
1526 | get_new_window_size (0); | |
726f6388 JA |
1527 | } |
1528 | return 0; | |
1529 | } | |
1530 | ||
1531 | /* Make the current tty use the state in shell_tty_info. */ | |
ccc6cda3 | 1532 | int |
726f6388 JA |
1533 | set_tty_state () |
1534 | { | |
d166f048 | 1535 | int tty; |
726f6388 | 1536 | |
d166f048 | 1537 | tty = input_tty (); |
726f6388 JA |
1538 | if (tty != -1) |
1539 | { | |
1540 | #if defined (NEW_TTY_DRIVER) | |
1541 | # if defined (DRAIN_OUTPUT) | |
1542 | draino (tty, shell_tty_info.sg_ospeed); | |
1543 | # endif /* DRAIN_OUTPUT */ | |
1544 | ioctl (tty, TIOCSETN, &shell_tty_info); | |
1545 | ioctl (tty, TIOCSETC, &shell_tchars); | |
1546 | ioctl (tty, TIOCSLTC, &shell_ltchars); | |
1547 | #endif /* NEW_TTY_DRIVER */ | |
1548 | ||
1549 | #if defined (TERMIO_TTY_DRIVER) | |
1550 | ioctl (tty, TCSETAW, &shell_tty_info); | |
1551 | #endif /* TERMIO_TTY_DRIVER */ | |
1552 | ||
1553 | #if defined (TERMIOS_TTY_DRIVER) | |
1554 | if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0) | |
1555 | { | |
1556 | /* Only print an error message if we're really interactive at | |
1557 | this time. */ | |
1558 | if (interactive) | |
f73dda09 | 1559 | sys_error ("[%ld: %d] tcsetattr", (long)getpid (), shell_level); |
726f6388 JA |
1560 | return -1; |
1561 | } | |
1562 | #endif /* TERMIOS_TTY_DRIVER */ | |
1563 | } | |
1564 | return 0; | |
1565 | } | |
1566 | ||
1567 | /* Given an index into the jobs array JOB, return the pid of the last | |
1568 | process in that job's pipeline. This is the one whose exit status | |
7117c2d2 | 1569 | counts. Must be called with SIGCHLD blocked or queued. */ |
726f6388 | 1570 | static pid_t |
7117c2d2 | 1571 | find_last_pid (job, block) |
726f6388 | 1572 | int job; |
7117c2d2 | 1573 | int block; |
726f6388 JA |
1574 | { |
1575 | register PROCESS *p; | |
7117c2d2 JA |
1576 | sigset_t set, oset; |
1577 | ||
1578 | if (block) | |
1579 | BLOCK_CHILD (set, oset); | |
726f6388 JA |
1580 | |
1581 | p = jobs[job]->pipe; | |
1582 | while (p->next != jobs[job]->pipe) | |
1583 | p = p->next; | |
1584 | ||
7117c2d2 JA |
1585 | if (block) |
1586 | UNBLOCK_CHILD (oset); | |
cce855bc | 1587 | |
7117c2d2 | 1588 | return (p->pid); |
cce855bc JA |
1589 | } |
1590 | ||
726f6388 JA |
1591 | /* Wait for a particular child of the shell to finish executing. |
1592 | This low-level function prints an error message if PID is not | |
7117c2d2 JA |
1593 | a child of this shell. It returns -1 if it fails, or whatever |
1594 | wait_for returns otherwise. If the child is not found in the | |
bb70624e | 1595 | jobs table, it returns 127. */ |
726f6388 JA |
1596 | int |
1597 | wait_for_single_pid (pid) | |
1598 | pid_t pid; | |
1599 | { | |
1600 | register PROCESS *child; | |
ccc6cda3 | 1601 | sigset_t set, oset; |
cce855bc | 1602 | int r, job; |
726f6388 | 1603 | |
ccc6cda3 | 1604 | BLOCK_CHILD (set, oset); |
7117c2d2 | 1605 | child = find_pipeline (pid, 0, (int *)NULL); |
ccc6cda3 | 1606 | UNBLOCK_CHILD (oset); |
726f6388 | 1607 | |
ccc6cda3 | 1608 | if (child == 0) |
726f6388 | 1609 | { |
f73dda09 | 1610 | internal_error ("wait: pid %ld is not a child of this shell", (long)pid); |
726f6388 JA |
1611 | return (127); |
1612 | } | |
1613 | ||
cce855bc JA |
1614 | r = wait_for (pid); |
1615 | ||
b72432fd JA |
1616 | /* POSIX.2: if we just waited for a job, we can remove it from the jobs |
1617 | table. */ | |
1618 | BLOCK_CHILD (set, oset); | |
7117c2d2 | 1619 | job = find_job (pid, 0); |
b72432fd JA |
1620 | if (job != NO_JOB && jobs[job] && DEADJOB (job)) |
1621 | jobs[job]->flags |= J_NOTIFIED; | |
1622 | UNBLOCK_CHILD (oset); | |
cce855bc JA |
1623 | |
1624 | return r; | |
726f6388 JA |
1625 | } |
1626 | ||
1627 | /* Wait for all of the backgrounds of this shell to finish. */ | |
1628 | void | |
1629 | wait_for_background_pids () | |
1630 | { | |
7117c2d2 | 1631 | register int i, r, waited_for; |
ccc6cda3 JA |
1632 | sigset_t set, oset; |
1633 | pid_t pid; | |
726f6388 | 1634 | |
bb70624e | 1635 | for (waited_for = 0;;) |
ccc6cda3 | 1636 | { |
726f6388 JA |
1637 | BLOCK_CHILD (set, oset); |
1638 | ||
7117c2d2 | 1639 | /* find first running job; if none running in foreground, break */ |
726f6388 | 1640 | for (i = 0; i < job_slots; i++) |
ccc6cda3 | 1641 | if (jobs[i] && RUNNING (i) && IS_FOREGROUND (i) == 0) |
7117c2d2 | 1642 | break; |
726f6388 | 1643 | |
7117c2d2 | 1644 | if (i == job_slots) |
726f6388 JA |
1645 | { |
1646 | UNBLOCK_CHILD (oset); | |
1647 | break; | |
1648 | } | |
1649 | ||
7117c2d2 JA |
1650 | /* now wait for the last pid in that job. */ |
1651 | pid = find_last_pid (i, 0); | |
1652 | UNBLOCK_CHILD (oset); | |
1653 | QUIT; | |
1654 | errno = 0; /* XXX */ | |
1655 | r = wait_for_single_pid (pid); | |
1656 | if (r == -1) | |
1657 | { | |
1658 | /* If we're mistaken about job state, compensate. */ | |
1659 | if (errno == ECHILD) | |
1660 | mark_all_jobs_as_dead (); | |
1661 | } | |
1662 | else | |
1663 | waited_for++; | |
726f6388 | 1664 | } |
b72432fd JA |
1665 | |
1666 | /* POSIX.2 says the shell can discard the statuses of all completed jobs if | |
1667 | `wait' is called with no arguments. */ | |
1668 | mark_dead_jobs_as_notified (1); | |
1669 | cleanup_dead_jobs (); | |
726f6388 JA |
1670 | } |
1671 | ||
1672 | /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */ | |
1673 | #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids | |
1674 | static SigHandler *old_sigint_handler = INVALID_SIGNAL_HANDLER; | |
1675 | ||
1676 | static void | |
1677 | restore_sigint_handler () | |
1678 | { | |
1679 | if (old_sigint_handler != INVALID_SIGNAL_HANDLER) | |
1680 | { | |
1681 | set_signal_handler (SIGINT, old_sigint_handler); | |
1682 | old_sigint_handler = INVALID_SIGNAL_HANDLER; | |
1683 | } | |
1684 | } | |
1685 | ||
ccc6cda3 | 1686 | static int wait_sigint_received; |
726f6388 JA |
1687 | |
1688 | /* Handle SIGINT while we are waiting for children in a script to exit. | |
1689 | The `wait' builtin should be interruptible, but all others should be | |
1690 | effectively ignored (i.e. not cause the shell to exit). */ | |
1691 | static sighandler | |
1692 | wait_sigint_handler (sig) | |
1693 | int sig; | |
1694 | { | |
bb70624e JA |
1695 | SigHandler *sigint_handler; |
1696 | ||
726f6388 JA |
1697 | if (interrupt_immediately || |
1698 | (this_shell_builtin && this_shell_builtin == wait_builtin)) | |
1699 | { | |
1700 | last_command_exit_value = EXECUTION_FAILURE; | |
1701 | restore_sigint_handler (); | |
bb70624e | 1702 | /* If we got a SIGINT while in `wait', and SIGINT is trapped, do |
28ef6c31 | 1703 | what POSIX.2 says (see builtins/wait.def for more info). */ |
bb70624e JA |
1704 | if (this_shell_builtin && this_shell_builtin == wait_builtin && |
1705 | signal_is_trapped (SIGINT) && | |
1706 | ((sigint_handler = trap_to_sighandler (SIGINT)) == trap_handler)) | |
1707 | { | |
1708 | interrupt_immediately = 0; | |
1709 | trap_handler (SIGINT); /* set pending_traps[SIGINT] */ | |
7117c2d2 | 1710 | wait_signal_received = SIGINT; |
bb70624e JA |
1711 | longjmp (wait_intr_buf, 1); |
1712 | } | |
1713 | ||
ccc6cda3 | 1714 | ADDINTERRUPT; |
726f6388 JA |
1715 | QUIT; |
1716 | } | |
1717 | ||
ccc6cda3 JA |
1718 | /* XXX - should this be interrupt_state? If it is, the shell will act |
1719 | as if it got the SIGINT interrupt. */ | |
1720 | wait_sigint_received = 1; | |
1721 | ||
726f6388 JA |
1722 | /* Otherwise effectively ignore the SIGINT and allow the running job to |
1723 | be killed. */ | |
ccc6cda3 | 1724 | SIGRETURN (0); |
726f6388 JA |
1725 | } |
1726 | ||
1727 | static int | |
1728 | process_exit_status (status) | |
1729 | WAIT status; | |
1730 | { | |
1731 | if (WIFSIGNALED (status)) | |
1732 | return (128 + WTERMSIG (status)); | |
ccc6cda3 | 1733 | else if (WIFSTOPPED (status) == 0) |
726f6388 JA |
1734 | return (WEXITSTATUS (status)); |
1735 | else | |
1736 | return (EXECUTION_SUCCESS); | |
1737 | } | |
1738 | ||
28ef6c31 JA |
1739 | /* Return the exit status of the last process in the pipeline for job JOB. |
1740 | This is the exit status of the entire job. */ | |
1741 | static WAIT | |
bb70624e | 1742 | raw_job_exit_status (job) |
f73dda09 | 1743 | int job; |
ccc6cda3 JA |
1744 | { |
1745 | register PROCESS *p; | |
1746 | for (p = jobs[job]->pipe; p->next != jobs[job]->pipe; p = p->next) | |
1747 | ; | |
bb70624e JA |
1748 | return (p->status); |
1749 | } | |
1750 | ||
28ef6c31 JA |
1751 | /* Return the exit status of job JOB. This is the exit status of the last |
1752 | (rightmost) process in the job's pipeline, modified if the job was killed | |
1753 | by a signal or stopped. */ | |
f73dda09 | 1754 | static int |
bb70624e JA |
1755 | job_exit_status (job) |
1756 | int job; | |
1757 | { | |
1758 | return (process_exit_status (raw_job_exit_status (job))); | |
ccc6cda3 JA |
1759 | } |
1760 | ||
ccc6cda3 JA |
1761 | #define FIND_CHILD(pid, child) \ |
1762 | do \ | |
1763 | { \ | |
7117c2d2 | 1764 | child = find_pipeline (pid, 0, (int *)NULL); \ |
ccc6cda3 JA |
1765 | if (child == 0) \ |
1766 | { \ | |
28ef6c31 | 1767 | give_terminal_to (shell_pgrp, 0); \ |
ccc6cda3 | 1768 | UNBLOCK_CHILD (oset); \ |
f73dda09 | 1769 | internal_error ("wait_for: No record of process %ld", (long)pid); \ |
ccc6cda3 JA |
1770 | restore_sigint_handler (); \ |
1771 | return (termination_state = 127); \ | |
1772 | } \ | |
1773 | } \ | |
1774 | while (0) | |
1775 | ||
bb70624e JA |
1776 | /* Wait for pid (one of our children) to terminate, then |
1777 | return the termination state. Returns 127 if PID is not found in | |
1778 | the jobs table. Returns -1 if waitchld() returns -1, indicating | |
1779 | that there are no unwaited-for child processes. */ | |
726f6388 JA |
1780 | int |
1781 | wait_for (pid) | |
1782 | pid_t pid; | |
1783 | { | |
28ef6c31 JA |
1784 | int job, termination_state, r; |
1785 | WAIT s; | |
726f6388 JA |
1786 | register PROCESS *child; |
1787 | sigset_t set, oset; | |
ccc6cda3 | 1788 | register PROCESS *p; |
726f6388 JA |
1789 | |
1790 | /* In the case that this code is interrupted, and we longjmp () out of it, | |
1791 | we are relying on the code in throw_to_top_level () to restore the | |
1792 | top-level signal mask. */ | |
1793 | BLOCK_CHILD (set, oset); | |
1794 | ||
1795 | /* Ignore interrupts while waiting for a job run without job control | |
1796 | to finish. We don't want the shell to exit if an interrupt is | |
1797 | received, only if one of the jobs run is killed via SIGINT. If | |
ccc6cda3 | 1798 | job control is not set, the job will be run in the same pgrp as |
726f6388 JA |
1799 | the shell, and the shell will see any signals the job gets. */ |
1800 | ||
1801 | /* This is possibly a race condition -- should it go in stop_pipeline? */ | |
1802 | wait_sigint_received = 0; | |
ccc6cda3 | 1803 | if (job_control == 0) |
726f6388 JA |
1804 | old_sigint_handler = set_signal_handler (SIGINT, wait_sigint_handler); |
1805 | ||
1806 | termination_state = last_command_exit_value; | |
1807 | ||
ccc6cda3 | 1808 | if (interactive && job_control == 0) |
726f6388 JA |
1809 | QUIT; |
1810 | ||
ccc6cda3 JA |
1811 | /* If we say wait_for (), then we have a record of this child somewhere. |
1812 | If it and none of its peers are running, don't call waitchld(). */ | |
726f6388 | 1813 | |
ccc6cda3 JA |
1814 | job = NO_JOB; |
1815 | do | |
726f6388 | 1816 | { |
ccc6cda3 | 1817 | FIND_CHILD (pid, child); |
726f6388 | 1818 | |
ccc6cda3 | 1819 | /* If this child is part of a job, then we are really waiting for the |
28ef6c31 JA |
1820 | job to finish. Otherwise, we are waiting for the child to finish. |
1821 | We check for JDEAD in case the job state has been set by waitchld | |
1822 | after receipt of a SIGCHLD. */ | |
ccc6cda3 | 1823 | if (job == NO_JOB) |
7117c2d2 | 1824 | job = find_job (pid, 0); |
726f6388 | 1825 | |
28ef6c31 JA |
1826 | /* waitchld() takes care of setting the state of the job. If the job |
1827 | has already exited before this is called, sigchld_handler will have | |
1828 | called waitchld and the state will be set to JDEAD. */ | |
726f6388 | 1829 | |
ccc6cda3 JA |
1830 | if (child->running || (job != NO_JOB && RUNNING (job))) |
1831 | { | |
1832 | #if defined (WAITPID_BROKEN) /* SCOv4 */ | |
1833 | sigset_t suspend_set; | |
1834 | sigemptyset (&suspend_set); | |
1835 | sigsuspend (&suspend_set); | |
726f6388 | 1836 | #else /* !WAITPID_BROKEN */ |
ccc6cda3 JA |
1837 | # if defined (MUST_UNBLOCK_CHLD) |
1838 | struct sigaction act, oact; | |
1839 | sigset_t nullset, chldset; | |
1840 | ||
1841 | sigemptyset (&nullset); | |
1842 | sigemptyset (&chldset); | |
1843 | sigprocmask (SIG_SETMASK, &nullset, &chldset); | |
1844 | act.sa_handler = SIG_DFL; | |
1845 | sigemptyset (&act.sa_mask); | |
1846 | sigemptyset (&oact.sa_mask); | |
1847 | act.sa_flags = 0; | |
1848 | sigaction (SIGCHLD, &act, &oact); | |
726f6388 | 1849 | # endif |
7117c2d2 | 1850 | queue_sigchld = 1; |
bb70624e | 1851 | r = waitchld (pid, 1); |
ccc6cda3 JA |
1852 | # if defined (MUST_UNBLOCK_CHLD) |
1853 | sigaction (SIGCHLD, &oact, (struct sigaction *)NULL); | |
1854 | sigprocmask (SIG_SETMASK, &chldset, (sigset_t *)NULL); | |
726f6388 | 1855 | # endif |
7117c2d2 | 1856 | queue_sigchld = 0; |
bb70624e JA |
1857 | if (r == -1 && errno == ECHILD && this_shell_builtin == wait_builtin) |
1858 | { | |
1859 | termination_state = -1; | |
1860 | goto wait_for_return; | |
1861 | } | |
28ef6c31 JA |
1862 | |
1863 | /* If child is marked as running, but waitpid() returns -1/ECHILD, | |
1864 | there is something wrong. Somewhere, wait should have returned | |
1865 | that child's pid. Mark the child as not running and the job, | |
1866 | if it exists, as JDEAD. */ | |
1867 | if (r == -1 && errno == ECHILD) | |
1868 | { | |
7117c2d2 JA |
1869 | child->running = PS_DONE; |
1870 | child->status = 0; /* XXX -- can't find true status */ | |
28ef6c31 JA |
1871 | if (job != NO_JOB) |
1872 | jobs[job]->state = JDEAD; | |
1873 | } | |
ccc6cda3 JA |
1874 | #endif /* WAITPID_BROKEN */ |
1875 | } | |
1876 | ||
1877 | /* If the shell is interactive, and job control is disabled, see | |
1878 | if the foreground process has died due to SIGINT and jump out | |
1879 | of the wait loop if it has. waitchld has already restored the | |
1880 | old SIGINT signal handler. */ | |
1881 | if (interactive && job_control == 0) | |
1882 | QUIT; | |
726f6388 | 1883 | } |
ccc6cda3 | 1884 | while (child->running || (job != NO_JOB && RUNNING (job))); |
726f6388 JA |
1885 | |
1886 | /* The exit state of the command is either the termination state of the | |
1887 | child, or the termination state of the job. If a job, the status | |
1888 | of the last child in the pipeline is the significant one. */ | |
726f6388 | 1889 | if (job != NO_JOB) |
ccc6cda3 | 1890 | termination_state = job_exit_status (job); |
726f6388 JA |
1891 | else |
1892 | termination_state = process_exit_status (child->status); | |
1893 | ||
ccc6cda3 | 1894 | if (job == NO_JOB || IS_JOBCONTROL (job)) |
b72432fd JA |
1895 | { |
1896 | /* XXX - under what circumstances is a job not present in the jobs | |
1897 | table (job == NO_JOB)? | |
1898 | 1. command substitution | |
1899 | ||
1900 | In the case of command substitution, at least, it's probably not | |
1901 | the right thing to give the terminal to the shell's process group, | |
1902 | even though there is code in subst.c:command_substitute to work | |
1903 | around it. | |
1904 | ||
1905 | Things that don't: | |
1906 | $PROMPT_COMMAND execution | |
1907 | process substitution | |
1908 | */ | |
1909 | #if 0 | |
1910 | if (job == NO_JOB) | |
f73dda09 | 1911 | itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp); |
b72432fd JA |
1912 | #endif |
1913 | ||
28ef6c31 | 1914 | give_terminal_to (shell_pgrp, 0); |
b72432fd | 1915 | } |
726f6388 JA |
1916 | |
1917 | /* If the command did not exit cleanly, or the job is just | |
1918 | being stopped, then reset the tty state back to what it | |
1919 | was before this command. Reset the tty state and notify | |
1920 | the user of the job termination only if the shell is | |
1921 | interactive. Clean up any dead jobs in either case. */ | |
1922 | if (job != NO_JOB) | |
1923 | { | |
ccc6cda3 | 1924 | if (interactive_shell && subshell_environment == 0) |
726f6388 | 1925 | { |
bb70624e JA |
1926 | /* This used to use `child->status'. That's wrong, however, for |
1927 | pipelines. `child' is the first process in the pipeline. It's | |
1928 | likely that the process we want to check for abnormal termination | |
1929 | or stopping is the last process in the pipeline, especially if | |
1930 | it's long-lived and the first process is short-lived. Since we | |
1931 | know we have a job here, we can check all the processes in this | |
1932 | job's pipeline and see if one of them stopped or terminated due | |
1933 | to a signal. We might want to change this later to just check | |
1934 | the last process in the pipeline. If no process exits due to a | |
1935 | signal, S is left as the status of the last job in the pipeline. */ | |
1936 | p = jobs[job]->pipe; | |
1937 | do | |
1938 | { | |
1939 | s = p->status; | |
1940 | if (WIFSIGNALED(s) || WIFSTOPPED(s)) | |
1941 | break; | |
1942 | p = p->next; | |
1943 | } | |
1944 | while (p != jobs[job]->pipe); | |
1945 | ||
1946 | if (WIFSIGNALED (s) || WIFSTOPPED (s)) | |
e8ce775d JA |
1947 | { |
1948 | set_tty_state (); | |
28ef6c31 | 1949 | |
bb70624e JA |
1950 | /* If the current job was stopped or killed by a signal, and |
1951 | the user has requested it, get a possibly new window size */ | |
1952 | if (check_window_size && job == current_job) | |
e8ce775d JA |
1953 | get_new_window_size (0); |
1954 | } | |
726f6388 JA |
1955 | else |
1956 | get_tty_state (); | |
1957 | ||
1958 | /* If job control is enabled, the job was started with job | |
1959 | control, the job was the foreground job, and it was killed | |
1960 | by SIGINT, then print a newline to compensate for the kernel | |
1961 | printing the ^C without a trailing newline. */ | |
ccc6cda3 | 1962 | if (job_control && IS_JOBCONTROL (job) && IS_FOREGROUND (job) && |
bb70624e | 1963 | WIFSIGNALED (s) && WTERMSIG (s) == SIGINT) |
726f6388 | 1964 | { |
ccc6cda3 JA |
1965 | /* If SIGINT is not trapped and the shell is in a for, while, |
1966 | or until loop, act as if the shell received SIGINT as | |
1967 | well, so the loop can be broken. This doesn't call the | |
1968 | SIGINT signal handler; maybe it should. */ | |
1969 | if (signal_is_trapped (SIGINT) == 0 && loop_level) | |
1970 | ADDINTERRUPT; | |
1971 | else | |
726f6388 | 1972 | { |
ccc6cda3 JA |
1973 | putchar ('\n'); |
1974 | fflush (stdout); | |
726f6388 JA |
1975 | } |
1976 | } | |
726f6388 | 1977 | } |
28ef6c31 | 1978 | |
7117c2d2 JA |
1979 | /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD |
1980 | signal handler path */ | |
1981 | if (DEADJOB (job) && IS_FOREGROUND (job) /*&& subshell_environment == 0*/) | |
1982 | setjstatus (job); | |
1983 | ||
28ef6c31 JA |
1984 | /* If this job is dead, notify the user of the status. If the shell |
1985 | is interactive, this will display a message on the terminal. If | |
1986 | the shell is not interactive, make sure we turn on the notify bit | |
1987 | so we don't get an unwanted message about the job's termination, | |
1988 | and so delete_job really clears the slot in the jobs table. */ | |
1989 | notify_and_cleanup (); | |
726f6388 | 1990 | } |
ccc6cda3 | 1991 | |
bb70624e JA |
1992 | wait_for_return: |
1993 | ||
726f6388 JA |
1994 | UNBLOCK_CHILD (oset); |
1995 | ||
1996 | /* Restore the original SIGINT signal handler before we return. */ | |
1997 | restore_sigint_handler (); | |
1998 | ||
1999 | return (termination_state); | |
2000 | } | |
2001 | ||
bb70624e JA |
2002 | /* Wait for the last process in the pipeline for JOB. Returns whatever |
2003 | wait_for returns: the last process's termination state or -1 if there | |
2004 | are no unwaited-for child processes or an error occurs. */ | |
726f6388 JA |
2005 | int |
2006 | wait_for_job (job) | |
2007 | int job; | |
2008 | { | |
ccc6cda3 | 2009 | pid_t pid; |
cce855bc JA |
2010 | int r; |
2011 | sigset_t set, oset; | |
2012 | ||
2013 | BLOCK_CHILD(set, oset); | |
2014 | if (JOBSTATE (job) == JSTOPPED) | |
2015 | internal_warning ("wait_for_job: job %d is stopped", job+1); | |
ccc6cda3 | 2016 | |
7117c2d2 JA |
2017 | pid = find_last_pid (job, 0); |
2018 | UNBLOCK_CHILD(oset); | |
cce855bc JA |
2019 | r = wait_for (pid); |
2020 | ||
b72432fd JA |
2021 | /* POSIX.2: we can remove the job from the jobs table if we just waited |
2022 | for it. */ | |
2023 | BLOCK_CHILD (set, oset); | |
2024 | if (job != NO_JOB && jobs[job] && DEADJOB (job)) | |
2025 | jobs[job]->flags |= J_NOTIFIED; | |
2026 | UNBLOCK_CHILD (oset); | |
cce855bc JA |
2027 | |
2028 | return r; | |
726f6388 JA |
2029 | } |
2030 | ||
2031 | /* Print info about dead jobs, and then delete them from the list | |
2032 | of known jobs. This does not actually delete jobs when the | |
2033 | shell is not interactive, because the dead jobs are not marked | |
2034 | as notified. */ | |
2035 | void | |
2036 | notify_and_cleanup () | |
2037 | { | |
ccc6cda3 | 2038 | if (jobs_list_frozen) |
726f6388 JA |
2039 | return; |
2040 | ||
28ef6c31 | 2041 | if (interactive || interactive_shell == 0 || sourcelevel) |
726f6388 JA |
2042 | notify_of_job_status (); |
2043 | ||
2044 | cleanup_dead_jobs (); | |
2045 | } | |
2046 | ||
2047 | /* Make dead jobs disappear from the jobs array without notification. | |
2048 | This is used when the shell is not interactive. */ | |
2049 | void | |
2050 | reap_dead_jobs () | |
2051 | { | |
b72432fd | 2052 | mark_dead_jobs_as_notified (0); |
726f6388 JA |
2053 | cleanup_dead_jobs (); |
2054 | } | |
2055 | ||
2056 | /* Return the next closest (chronologically) job to JOB which is in | |
2057 | STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if | |
2058 | there is no next recent job. */ | |
2059 | static int | |
2060 | most_recent_job_in_state (job, state) | |
2061 | int job; | |
2062 | JOB_STATE state; | |
2063 | { | |
2064 | register int i, result; | |
2065 | sigset_t set, oset; | |
2066 | ||
2067 | BLOCK_CHILD (set, oset); | |
7117c2d2 | 2068 | |
ccc6cda3 | 2069 | for (result = NO_JOB, i = job - 1; i >= 0; i--) |
726f6388 | 2070 | { |
ccc6cda3 | 2071 | if (jobs[i] && (JOBSTATE (i) == state)) |
726f6388 | 2072 | { |
ccc6cda3 JA |
2073 | result = i; |
2074 | break; | |
726f6388 JA |
2075 | } |
2076 | } | |
7117c2d2 | 2077 | |
726f6388 | 2078 | UNBLOCK_CHILD (oset); |
ccc6cda3 | 2079 | |
726f6388 JA |
2080 | return (result); |
2081 | } | |
2082 | ||
2083 | /* Return the newest *stopped* job older than JOB, or NO_JOB if not | |
2084 | found. */ | |
2085 | static int | |
28ef6c31 | 2086 | job_last_stopped (job) |
726f6388 JA |
2087 | int job; |
2088 | { | |
2089 | return (most_recent_job_in_state (job, JSTOPPED)); | |
2090 | } | |
2091 | ||
2092 | /* Return the newest *running* job older than JOB, or NO_JOB if not | |
2093 | found. */ | |
2094 | static int | |
28ef6c31 | 2095 | job_last_running (job) |
726f6388 JA |
2096 | int job; |
2097 | { | |
2098 | return (most_recent_job_in_state (job, JRUNNING)); | |
2099 | } | |
2100 | ||
2101 | /* Make JOB be the current job, and make previous be useful. Must be | |
2102 | called with SIGCHLD blocked. */ | |
2103 | static void | |
2104 | set_current_job (job) | |
2105 | int job; | |
2106 | { | |
ccc6cda3 | 2107 | int candidate; |
726f6388 JA |
2108 | |
2109 | if (current_job != job) | |
2110 | { | |
2111 | previous_job = current_job; | |
2112 | current_job = job; | |
2113 | } | |
2114 | ||
2115 | /* First choice for previous_job is the old current_job. */ | |
2116 | if (previous_job != current_job && | |
2117 | previous_job != NO_JOB && | |
2118 | jobs[previous_job] && | |
ccc6cda3 | 2119 | STOPPED (previous_job)) |
726f6388 JA |
2120 | return; |
2121 | ||
2122 | /* Second choice: Newest stopped job that is older than | |
2123 | the current job. */ | |
ccc6cda3 JA |
2124 | candidate = NO_JOB; |
2125 | if (STOPPED (current_job)) | |
726f6388 | 2126 | { |
28ef6c31 | 2127 | candidate = job_last_stopped (current_job); |
726f6388 JA |
2128 | |
2129 | if (candidate != NO_JOB) | |
2130 | { | |
2131 | previous_job = candidate; | |
2132 | return; | |
2133 | } | |
2134 | } | |
2135 | ||
2136 | /* If we get here, there is either only one stopped job, in which case it is | |
2137 | the current job and the previous job should be set to the newest running | |
2138 | job, or there are only running jobs and the previous job should be set to | |
2139 | the newest running job older than the current job. We decide on which | |
2140 | alternative to use based on whether or not JOBSTATE(current_job) is | |
2141 | JSTOPPED. */ | |
2142 | ||
28ef6c31 JA |
2143 | candidate = RUNNING (current_job) ? job_last_running (current_job) |
2144 | : job_last_running (job_slots); | |
726f6388 JA |
2145 | |
2146 | if (candidate != NO_JOB) | |
2147 | { | |
2148 | previous_job = candidate; | |
2149 | return; | |
2150 | } | |
2151 | ||
2152 | /* There is only a single job, and it is both `+' and `-'. */ | |
2153 | previous_job = current_job; | |
2154 | } | |
2155 | ||
2156 | /* Make current_job be something useful, if it isn't already. */ | |
2157 | ||
2158 | /* Here's the deal: The newest non-running job should be `+', and the | |
2159 | next-newest non-running job should be `-'. If there is only a single | |
2160 | stopped job, the previous_job is the newest non-running job. If there | |
2161 | are only running jobs, the newest running job is `+' and the | |
2162 | next-newest running job is `-'. Must be called with SIGCHLD blocked. */ | |
ccc6cda3 | 2163 | |
726f6388 JA |
2164 | static void |
2165 | reset_current () | |
2166 | { | |
ccc6cda3 | 2167 | int candidate; |
726f6388 | 2168 | |
ccc6cda3 JA |
2169 | if (job_slots && current_job != NO_JOB && jobs[current_job] && STOPPED (current_job)) |
2170 | candidate = current_job; | |
726f6388 JA |
2171 | else |
2172 | { | |
ccc6cda3 JA |
2173 | candidate = NO_JOB; |
2174 | ||
2175 | /* First choice: the previous job. */ | |
2176 | if (previous_job != NO_JOB && jobs[previous_job] && STOPPED (previous_job)) | |
726f6388 JA |
2177 | candidate = previous_job; |
2178 | ||
2179 | /* Second choice: the most recently stopped job. */ | |
2180 | if (candidate == NO_JOB) | |
28ef6c31 | 2181 | candidate = job_last_stopped (job_slots); |
726f6388 | 2182 | |
ccc6cda3 | 2183 | /* Third choice: the newest running job. */ |
726f6388 | 2184 | if (candidate == NO_JOB) |
28ef6c31 | 2185 | candidate = job_last_running (job_slots); |
726f6388 JA |
2186 | } |
2187 | ||
2188 | /* If we found a job to use, then use it. Otherwise, there | |
2189 | are no jobs period. */ | |
2190 | if (candidate != NO_JOB) | |
2191 | set_current_job (candidate); | |
2192 | else | |
2193 | current_job = previous_job = NO_JOB; | |
2194 | } | |
2195 | ||
d166f048 JA |
2196 | /* Set up the job structures so we know the job and its processes are |
2197 | all running. */ | |
2198 | static void | |
2199 | set_job_running (job) | |
2200 | int job; | |
2201 | { | |
2202 | register PROCESS *p; | |
2203 | ||
2204 | /* Each member of the pipeline is now running. */ | |
2205 | p = jobs[job]->pipe; | |
2206 | ||
2207 | do | |
2208 | { | |
2209 | if (WIFSTOPPED (p->status)) | |
7117c2d2 | 2210 | p->running = PS_RUNNING; /* XXX - could be PS_STOPPED */ |
d166f048 JA |
2211 | p = p->next; |
2212 | } | |
2213 | while (p != jobs[job]->pipe); | |
2214 | ||
2215 | /* This means that the job is running. */ | |
2216 | JOBSTATE (job) = JRUNNING; | |
2217 | } | |
2218 | ||
726f6388 JA |
2219 | /* Start a job. FOREGROUND if non-zero says to do that. Otherwise, |
2220 | start the job in the background. JOB is a zero-based index into | |
2221 | JOBS. Returns -1 if it is unable to start a job, and the return | |
2222 | status of the job otherwise. */ | |
2223 | int | |
2224 | start_job (job, foreground) | |
2225 | int job, foreground; | |
2226 | { | |
2227 | register PROCESS *p; | |
2228 | int already_running; | |
2229 | sigset_t set, oset; | |
2230 | char *wd; | |
28ef6c31 | 2231 | static TTYSTRUCT save_stty; |
726f6388 JA |
2232 | |
2233 | BLOCK_CHILD (set, oset); | |
726f6388 | 2234 | |
ccc6cda3 | 2235 | if (DEADJOB (job)) |
726f6388 | 2236 | { |
ccc6cda3 | 2237 | internal_error ("%s: job has terminated", this_command_name); |
726f6388 JA |
2238 | UNBLOCK_CHILD (oset); |
2239 | return (-1); | |
2240 | } | |
2241 | ||
ccc6cda3 JA |
2242 | already_running = RUNNING (job); |
2243 | ||
2244 | if (foreground == 0 && already_running) | |
726f6388 | 2245 | { |
ccc6cda3 | 2246 | internal_error ("%s: bg background job?", this_command_name); |
726f6388 JA |
2247 | UNBLOCK_CHILD (oset); |
2248 | return (-1); | |
2249 | } | |
2250 | ||
2251 | wd = current_working_directory (); | |
2252 | ||
2253 | /* You don't know about the state of this job. Do you? */ | |
2254 | jobs[job]->flags &= ~J_NOTIFIED; | |
2255 | ||
2256 | if (foreground) | |
2257 | { | |
2258 | set_current_job (job); | |
2259 | jobs[job]->flags |= J_FOREGROUND; | |
2260 | } | |
2261 | ||
2262 | /* Tell the outside world what we're doing. */ | |
2263 | p = jobs[job]->pipe; | |
2264 | ||
ccc6cda3 | 2265 | if (foreground == 0) |
726f6388 JA |
2266 | fprintf (stderr, "[%d]%c ", job + 1, |
2267 | (job == current_job) ? '+': ((job == previous_job) ? '-' : ' ')); | |
2268 | ||
2269 | do | |
2270 | { | |
2271 | fprintf (stderr, "%s%s", | |
2272 | p->command ? p->command : "", | |
2273 | p->next != jobs[job]->pipe? " | " : ""); | |
2274 | p = p->next; | |
2275 | } | |
2276 | while (p != jobs[job]->pipe); | |
2277 | ||
ccc6cda3 | 2278 | if (foreground == 0) |
726f6388 JA |
2279 | fprintf (stderr, " &"); |
2280 | ||
2281 | if (strcmp (wd, jobs[job]->wd) != 0) | |
2282 | fprintf (stderr, " (wd: %s)", polite_directory_format (jobs[job]->wd)); | |
2283 | ||
2284 | fprintf (stderr, "\n"); | |
2285 | ||
2286 | /* Run the job. */ | |
ccc6cda3 | 2287 | if (already_running == 0) |
d166f048 | 2288 | set_job_running (job); |
726f6388 JA |
2289 | |
2290 | /* Save the tty settings before we start the job in the foreground. */ | |
2291 | if (foreground) | |
2292 | { | |
2293 | get_tty_state (); | |
2294 | save_stty = shell_tty_info; | |
ccc6cda3 JA |
2295 | /* Give the terminal to this job. */ |
2296 | if (IS_JOBCONTROL (job)) | |
28ef6c31 | 2297 | give_terminal_to (jobs[job]->pgrp, 0); |
726f6388 JA |
2298 | } |
2299 | else | |
2300 | jobs[job]->flags &= ~J_FOREGROUND; | |
2301 | ||
2302 | /* If the job is already running, then don't bother jump-starting it. */ | |
ccc6cda3 | 2303 | if (already_running == 0) |
726f6388 JA |
2304 | { |
2305 | jobs[job]->flags |= J_NOTIFIED; | |
2306 | killpg (jobs[job]->pgrp, SIGCONT); | |
2307 | } | |
2308 | ||
726f6388 JA |
2309 | if (foreground) |
2310 | { | |
ccc6cda3 JA |
2311 | pid_t pid; |
2312 | int s; | |
726f6388 | 2313 | |
7117c2d2 JA |
2314 | pid = find_last_pid (job, 0); |
2315 | UNBLOCK_CHILD (oset); | |
ccc6cda3 | 2316 | s = wait_for (pid); |
726f6388 JA |
2317 | shell_tty_info = save_stty; |
2318 | set_tty_state (); | |
2319 | return (s); | |
2320 | } | |
2321 | else | |
2322 | { | |
726f6388 JA |
2323 | reset_current (); |
2324 | UNBLOCK_CHILD (oset); | |
2325 | return (0); | |
2326 | } | |
2327 | } | |
2328 | ||
2329 | /* Give PID SIGNAL. This determines what job the pid belongs to (if any). | |
2330 | If PID does belong to a job, and the job is stopped, then CONTinue the | |
2331 | job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null, | |
2332 | then kill the process group associated with PID. */ | |
2333 | int | |
2334 | kill_pid (pid, sig, group) | |
2335 | pid_t pid; | |
2336 | int sig, group; | |
2337 | { | |
2338 | register PROCESS *p; | |
ccc6cda3 | 2339 | int job, result; |
726f6388 JA |
2340 | sigset_t set, oset; |
2341 | ||
ccc6cda3 | 2342 | result = EXECUTION_SUCCESS; |
726f6388 JA |
2343 | if (group) |
2344 | { | |
f73dda09 | 2345 | BLOCK_CHILD (set, oset); |
7117c2d2 | 2346 | p = find_pipeline (pid, 0, &job); |
f73dda09 | 2347 | |
726f6388 JA |
2348 | if (job != NO_JOB) |
2349 | { | |
2350 | jobs[job]->flags &= ~J_NOTIFIED; | |
2351 | ||
2352 | /* Kill process in backquotes or one started without job control? */ | |
2353 | if (jobs[job]->pgrp == shell_pgrp) | |
2354 | { | |
2355 | p = jobs[job]->pipe; | |
2356 | ||
2357 | do | |
2358 | { | |
2359 | kill (p->pid, sig); | |
7117c2d2 | 2360 | if (p->running == PS_DONE && (sig == SIGTERM || sig == SIGHUP)) |
726f6388 JA |
2361 | kill (p->pid, SIGCONT); |
2362 | p = p->next; | |
2363 | } | |
2364 | while (p != jobs[job]->pipe); | |
2365 | } | |
2366 | else | |
2367 | { | |
2368 | result = killpg (jobs[job]->pgrp, sig); | |
ccc6cda3 | 2369 | if (p && STOPPED (job) && (sig == SIGTERM || sig == SIGHUP)) |
726f6388 | 2370 | killpg (jobs[job]->pgrp, SIGCONT); |
d166f048 JA |
2371 | /* If we're continuing a stopped job via kill rather than bg or |
2372 | fg, emulate the `bg' behavior. */ | |
2373 | if (p && STOPPED (job) && (sig == SIGCONT)) | |
2374 | { | |
2375 | set_job_running (job); | |
2376 | jobs[job]->flags &= ~J_FOREGROUND; | |
2377 | jobs[job]->flags |= J_NOTIFIED; | |
2378 | } | |
726f6388 JA |
2379 | } |
2380 | } | |
2381 | else | |
2382 | result = killpg (pid, sig); | |
f73dda09 JA |
2383 | |
2384 | UNBLOCK_CHILD (oset); | |
726f6388 JA |
2385 | } |
2386 | else | |
2387 | result = kill (pid, sig); | |
2388 | ||
726f6388 JA |
2389 | return (result); |
2390 | } | |
2391 | ||
ccc6cda3 JA |
2392 | /* sigchld_handler () flushes at least one of the children that we are |
2393 | waiting for. It gets run when we have gotten a SIGCHLD signal. */ | |
726f6388 | 2394 | static sighandler |
ccc6cda3 | 2395 | sigchld_handler (sig) |
726f6388 JA |
2396 | int sig; |
2397 | { | |
bb70624e | 2398 | int n, oerrno; |
ccc6cda3 | 2399 | |
bb70624e | 2400 | oerrno = errno; |
726f6388 JA |
2401 | REINSTALL_SIGCHLD_HANDLER; |
2402 | sigchld++; | |
ccc6cda3 | 2403 | n = 0; |
7117c2d2 | 2404 | if (queue_sigchld == 0) |
ccc6cda3 | 2405 | n = waitchld (-1, 0); |
bb70624e | 2406 | errno = oerrno; |
ccc6cda3 | 2407 | SIGRETURN (n); |
726f6388 | 2408 | } |
ccc6cda3 JA |
2409 | |
2410 | /* waitchld() reaps dead or stopped children. It's called by wait_for and | |
bb70624e JA |
2411 | sigchld_handler, and runs until there aren't any children terminating any |
2412 | more. | |
ccc6cda3 | 2413 | If BLOCK is 1, this is to be a blocking wait for a single child, although |
bb70624e JA |
2414 | an arriving SIGCHLD could cause the wait to be non-blocking. It returns |
2415 | the number of children reaped, or -1 if there are no unwaited-for child | |
2416 | processes. */ | |
726f6388 | 2417 | static int |
ccc6cda3 JA |
2418 | waitchld (wpid, block) |
2419 | pid_t wpid; | |
2420 | int block; | |
726f6388 JA |
2421 | { |
2422 | WAIT status; | |
2423 | PROCESS *child; | |
2424 | pid_t pid; | |
28ef6c31 | 2425 | int call_set_current, last_stopped_job, job, children_exited, waitpid_flags; |
ccc6cda3 JA |
2426 | |
2427 | call_set_current = children_exited = 0; | |
2428 | last_stopped_job = NO_JOB; | |
726f6388 JA |
2429 | |
2430 | do | |
2431 | { | |
d166f048 | 2432 | /* We don't want to be notified about jobs stopping if job control |
28ef6c31 | 2433 | is not active. XXX - was interactive_shell instead of job_control */ |
d166f048 | 2434 | waitpid_flags = (job_control && subshell_environment == 0) |
f73dda09 | 2435 | ? (WUNTRACED|WCONTINUED) |
ccc6cda3 JA |
2436 | : 0; |
2437 | if (sigchld || block == 0) | |
2438 | waitpid_flags |= WNOHANG; | |
2439 | pid = WAITPID (-1, &status, waitpid_flags); | |
f73dda09 | 2440 | |
ccc6cda3 JA |
2441 | /* The check for WNOHANG is to make sure we decrement sigchld only |
2442 | if it was non-zero before we called waitpid. */ | |
2443 | if (sigchld > 0 && (waitpid_flags & WNOHANG)) | |
2444 | sigchld--; | |
bb70624e JA |
2445 | |
2446 | /* If waitpid returns -1 with errno == ECHILD, there are no more | |
2447 | unwaited-for child processes of this shell. */ | |
2448 | if (pid < 0 && errno == ECHILD) | |
2449 | { | |
2450 | if (children_exited == 0) | |
2451 | return -1; | |
2452 | else | |
2453 | break; | |
2454 | } | |
ccc6cda3 | 2455 | |
bb70624e JA |
2456 | /* If waitpid returns 0, there are running children. If it returns -1, |
2457 | the only other error POSIX says it can return is EINTR. */ | |
ccc6cda3 JA |
2458 | if (pid <= 0) |
2459 | continue; /* jumps right to the test */ | |
2460 | ||
f73dda09 JA |
2461 | /* children_exited is used to run traps on SIGCHLD. We don't want to |
2462 | run the trap if a process is just being continued. */ | |
2463 | if (WIFCONTINUED(status) == 0) | |
2464 | children_exited++; | |
ccc6cda3 JA |
2465 | |
2466 | /* Locate our PROCESS for this pid. */ | |
7117c2d2 | 2467 | child = find_pipeline (pid, 1, &job); /* want running procs only */ |
ccc6cda3 JA |
2468 | |
2469 | /* It is not an error to have a child terminate that we did | |
2470 | not have a record of. This child could have been part of | |
2471 | a pipeline in backquote substitution. Even so, I'm not | |
2472 | sure child is ever non-zero. */ | |
2473 | if (child == 0) | |
2474 | continue; | |
2475 | ||
2476 | while (child->pid != pid) | |
2477 | child = child->next; | |
2478 | ||
f73dda09 | 2479 | /* Remember status, and whether or not the process is running. */ |
ccc6cda3 | 2480 | child->status = status; |
7117c2d2 | 2481 | child->running = WIFCONTINUED(status) ? PS_RUNNING : PS_DONE; |
ccc6cda3 | 2482 | |
ccc6cda3 | 2483 | if (job == NO_JOB) |
28ef6c31 | 2484 | continue; |
726f6388 | 2485 | |
28ef6c31 | 2486 | call_set_current += set_job_status_and_cleanup (job); |
726f6388 | 2487 | |
28ef6c31 JA |
2488 | if (STOPPED (job)) |
2489 | last_stopped_job = job; | |
2490 | else if (DEADJOB (job) && last_stopped_job == job) | |
2491 | last_stopped_job = NO_JOB; | |
726f6388 | 2492 | } |
ccc6cda3 | 2493 | while ((sigchld || block == 0) && pid > (pid_t)0); |
726f6388 JA |
2494 | |
2495 | /* If a job was running and became stopped, then set the current | |
2496 | job. Otherwise, don't change a thing. */ | |
2497 | if (call_set_current) | |
bb70624e JA |
2498 | { |
2499 | if (last_stopped_job != NO_JOB) | |
2500 | set_current_job (last_stopped_job); | |
2501 | else | |
2502 | reset_current (); | |
2503 | } | |
726f6388 JA |
2504 | |
2505 | /* Call a SIGCHLD trap handler for each child that exits, if one is set. */ | |
bb70624e | 2506 | if (job_control && signal_is_trapped (SIGCHLD) && children_exited && |
726f6388 | 2507 | trap_list[SIGCHLD] != (char *)IGNORE_SIG) |
28ef6c31 | 2508 | run_sigchld_trap (children_exited); |
726f6388 JA |
2509 | |
2510 | /* We have successfully recorded the useful information about this process | |
2511 | that has just changed state. If we notify asynchronously, and the job | |
2512 | that this process belongs to is no longer running, then notify the user | |
2513 | of that fact now. */ | |
2514 | if (asynchronous_notification && interactive) | |
2515 | notify_of_job_status (); | |
2516 | ||
ccc6cda3 | 2517 | return (children_exited); |
726f6388 JA |
2518 | } |
2519 | ||
28ef6c31 JA |
2520 | /* Set the status of JOB and perform any necessary cleanup if the job is |
2521 | marked as JDEAD. | |
2522 | ||
2523 | Currently, the cleanup activity is restricted to handling any SIGINT | |
2524 | received while waiting for a foreground job to finish. */ | |
2525 | static int | |
2526 | set_job_status_and_cleanup (job) | |
2527 | int job; | |
2528 | { | |
2529 | PROCESS *child; | |
2530 | int tstatus, job_state, any_stopped, any_tstped, call_set_current; | |
2531 | SigHandler *temp_handler; | |
2532 | ||
2533 | child = jobs[job]->pipe; | |
2534 | jobs[job]->flags &= ~J_NOTIFIED; | |
2535 | ||
2536 | call_set_current = 0; | |
2537 | ||
2538 | /* | |
2539 | * COMPUTE JOB STATUS | |
2540 | */ | |
2541 | ||
2542 | /* If all children are not running, but any of them is stopped, then | |
2543 | the job is stopped, not dead. */ | |
2544 | job_state = any_stopped = any_tstped = 0; | |
2545 | do | |
2546 | { | |
2547 | job_state |= child->running; | |
7117c2d2 | 2548 | if (child->running == PS_DONE && (WIFSTOPPED (child->status))) |
28ef6c31 JA |
2549 | { |
2550 | any_stopped = 1; | |
2551 | any_tstped |= interactive && job_control && | |
2552 | (WSTOPSIG (child->status) == SIGTSTP); | |
2553 | } | |
2554 | child = child->next; | |
2555 | } | |
2556 | while (child != jobs[job]->pipe); | |
2557 | ||
2558 | /* If job_state != 0, the job is still running, so don't bother with | |
f73dda09 JA |
2559 | setting the process exit status and job state unless we're |
2560 | transitioning from stopped to running. */ | |
2561 | if (job_state != 0 && JOBSTATE(job) != JSTOPPED) | |
28ef6c31 JA |
2562 | return 0; |
2563 | ||
2564 | /* | |
2565 | * SET JOB STATUS | |
2566 | */ | |
2567 | ||
2568 | /* The job is either stopped or dead. Set the state of the job accordingly. */ | |
2569 | if (any_stopped) | |
2570 | { | |
2571 | jobs[job]->state = JSTOPPED; | |
2572 | jobs[job]->flags &= ~J_FOREGROUND; | |
2573 | call_set_current++; | |
2574 | /* Suspending a job with SIGTSTP breaks all active loops. */ | |
2575 | if (any_tstped && loop_level) | |
2576 | breaking = loop_level; | |
2577 | } | |
f73dda09 JA |
2578 | else if (job_state != 0) /* was stopped, now running */ |
2579 | { | |
2580 | jobs[job]->state = JRUNNING; | |
2581 | call_set_current++; | |
2582 | } | |
28ef6c31 JA |
2583 | else |
2584 | { | |
2585 | jobs[job]->state = JDEAD; | |
2586 | ||
7117c2d2 | 2587 | #if 0 |
28ef6c31 JA |
2588 | if (IS_FOREGROUND (job)) |
2589 | setjstatus (job); | |
7117c2d2 | 2590 | #endif |
28ef6c31 JA |
2591 | |
2592 | /* If this job has a cleanup function associated with it, call it | |
2593 | with `cleanarg' as the single argument, then set the function | |
2594 | pointer to NULL so it is not inadvertently called twice. The | |
2595 | cleanup function is responsible for deallocating cleanarg. */ | |
2596 | if (jobs[job]->j_cleanup) | |
2597 | { | |
2598 | (*jobs[job]->j_cleanup) (jobs[job]->cleanarg); | |
f73dda09 | 2599 | jobs[job]->j_cleanup = (sh_vptrfunc_t *)NULL; |
28ef6c31 JA |
2600 | } |
2601 | } | |
2602 | ||
2603 | /* | |
2604 | * CLEANUP | |
2605 | * | |
2606 | * Currently, we just do special things if we got a SIGINT while waiting | |
2607 | * for a foreground job to complete | |
2608 | */ | |
2609 | ||
2610 | if (jobs[job]->state == JDEAD) | |
2611 | { | |
2612 | /* If we're running a shell script and we get a SIGINT with a | |
2613 | SIGINT trap handler, but the foreground job handles it and | |
2614 | does not exit due to SIGINT, run the trap handler but do not | |
2615 | otherwise act as if we got the interrupt. */ | |
2616 | if (wait_sigint_received && interactive_shell == 0 && | |
2617 | WIFSIGNALED (child->status) == 0 && IS_FOREGROUND (job) && | |
2618 | signal_is_trapped (SIGINT)) | |
2619 | { | |
7117c2d2 | 2620 | int old_frozen; |
28ef6c31 JA |
2621 | wait_sigint_received = 0; |
2622 | last_command_exit_value = process_exit_status (child->status); | |
2623 | ||
7117c2d2 | 2624 | old_frozen = jobs_list_frozen; |
28ef6c31 JA |
2625 | jobs_list_frozen = 1; |
2626 | tstatus = maybe_call_trap_handler (SIGINT); | |
7117c2d2 | 2627 | jobs_list_frozen = old_frozen; |
28ef6c31 JA |
2628 | } |
2629 | ||
2630 | /* If the foreground job is killed by SIGINT when job control is not | |
2631 | active, we need to perform some special handling. | |
2632 | ||
2633 | The check of wait_sigint_received is a way to determine if the | |
2634 | SIGINT came from the keyboard (in which case the shell has already | |
2635 | seen it, and wait_sigint_received is non-zero, because keyboard | |
2636 | signals are sent to process groups) or via kill(2) to the foreground | |
2637 | process by another process (or itself). If the shell did receive the | |
2638 | SIGINT, it needs to perform normal SIGINT processing. */ | |
2639 | else if (wait_sigint_received && (WTERMSIG (child->status) == SIGINT) && | |
2640 | IS_FOREGROUND (job) && IS_JOBCONTROL (job) == 0) | |
2641 | { | |
7117c2d2 JA |
2642 | int old_frozen; |
2643 | ||
28ef6c31 JA |
2644 | wait_sigint_received = 0; |
2645 | ||
2646 | /* If SIGINT is trapped, set the exit status so that the trap | |
2647 | handler can see it. */ | |
2648 | if (signal_is_trapped (SIGINT)) | |
2649 | last_command_exit_value = process_exit_status (child->status); | |
2650 | ||
2651 | /* If the signal is trapped, let the trap handler get it no matter | |
2652 | what and simply return if the trap handler returns. | |
2653 | maybe_call_trap_handler() may cause dead jobs to be removed from | |
2654 | the job table because of a call to execute_command. We work | |
2655 | around this by setting JOBS_LIST_FROZEN. */ | |
7117c2d2 | 2656 | old_frozen = jobs_list_frozen; |
28ef6c31 JA |
2657 | jobs_list_frozen = 1; |
2658 | tstatus = maybe_call_trap_handler (SIGINT); | |
7117c2d2 | 2659 | jobs_list_frozen = old_frozen; |
28ef6c31 JA |
2660 | if (tstatus == 0 && old_sigint_handler != INVALID_SIGNAL_HANDLER) |
2661 | { | |
2662 | /* wait_sigint_handler () has already seen SIGINT and | |
2663 | allowed the wait builtin to jump out. We need to | |
2664 | call the original SIGINT handler, if necessary. If | |
2665 | the original handler is SIG_DFL, we need to resend | |
2666 | the signal to ourselves. */ | |
2667 | ||
2668 | temp_handler = old_sigint_handler; | |
2669 | ||
2670 | /* Bogus. If we've reset the signal handler as the result | |
2671 | of a trap caught on SIGINT, then old_sigint_handler | |
2672 | will point to trap_handler, which now knows nothing about | |
2673 | SIGINT (if we reset the sighandler to the default). | |
2674 | In this case, we have to fix things up. What a crock. */ | |
2675 | if (temp_handler == trap_handler && signal_is_trapped (SIGINT) == 0) | |
2676 | temp_handler = trap_to_sighandler (SIGINT); | |
2677 | restore_sigint_handler (); | |
2678 | if (temp_handler == SIG_DFL) | |
2679 | termination_unwind_protect (SIGINT); | |
2680 | else if (temp_handler != SIG_IGN) | |
2681 | (*temp_handler) (SIGINT); | |
2682 | } | |
2683 | } | |
2684 | } | |
2685 | ||
2686 | return call_set_current; | |
2687 | } | |
2688 | ||
2689 | /* Build the array of values for the $PIPESTATUS variable from the set of | |
2690 | exit statuses of all processes in the job J. */ | |
2691 | static void | |
2692 | setjstatus (j) | |
2693 | int j; | |
2694 | { | |
2695 | #if defined (ARRAY_VARS) | |
2696 | register int i; | |
2697 | register PROCESS *p; | |
2698 | ||
2699 | for (i = 1, p = jobs[j]->pipe; p->next != jobs[j]->pipe; p = p->next, i++) | |
2700 | ; | |
2701 | i++; | |
7117c2d2 | 2702 | if (statsize < i) |
28ef6c31 JA |
2703 | { |
2704 | pstatuses = (int *)xrealloc (pstatuses, i * sizeof (int)); | |
2705 | statsize = i; | |
2706 | } | |
2707 | i = 0; | |
2708 | p = jobs[j]->pipe; | |
2709 | do | |
2710 | { | |
2711 | pstatuses[i++] = process_exit_status (p->status); | |
2712 | p = p->next; | |
2713 | } | |
2714 | while (p != jobs[j]->pipe); | |
2715 | ||
2716 | pstatuses[i] = -1; /* sentinel */ | |
7117c2d2 | 2717 | set_pipestatus_array (pstatuses, i); |
28ef6c31 JA |
2718 | #endif |
2719 | } | |
2720 | ||
2721 | static void | |
2722 | run_sigchld_trap (nchild) | |
2723 | int nchild; | |
2724 | { | |
2725 | char *trap_command; | |
2726 | int i; | |
2727 | ||
2728 | /* Turn off the trap list during the call to parse_and_execute () | |
2729 | to avoid potentially infinite recursive calls. Preserve the | |
2730 | values of last_command_exit_value, last_made_pid, and the_pipeline | |
2731 | around the execution of the trap commands. */ | |
2732 | trap_command = savestring (trap_list[SIGCHLD]); | |
2733 | ||
2734 | begin_unwind_frame ("SIGCHLD trap"); | |
2735 | unwind_protect_int (last_command_exit_value); | |
f73dda09 | 2736 | unwind_protect_var (last_made_pid); |
28ef6c31 JA |
2737 | unwind_protect_int (interrupt_immediately); |
2738 | unwind_protect_int (jobs_list_frozen); | |
2739 | unwind_protect_pointer (the_pipeline); | |
2740 | unwind_protect_pointer (subst_assign_varlist); | |
2741 | ||
2742 | /* We have to add the commands this way because they will be run | |
2743 | in reverse order of adding. We don't want maybe_set_sigchld_trap () | |
2744 | to reference freed memory. */ | |
2745 | add_unwind_protect ((Function *)xfree, trap_command); | |
2746 | add_unwind_protect ((Function *)maybe_set_sigchld_trap, trap_command); | |
2747 | ||
2748 | subst_assign_varlist = (WORD_LIST *)NULL; | |
2749 | the_pipeline = (PROCESS *)NULL; | |
2750 | ||
2751 | restore_default_signal (SIGCHLD); | |
2752 | jobs_list_frozen = 1; | |
2753 | for (i = 0; i < nchild; i++) | |
2754 | { | |
2755 | interrupt_immediately = 1; | |
2756 | parse_and_execute (savestring (trap_command), "trap", SEVAL_NOHIST); | |
2757 | } | |
2758 | ||
2759 | run_unwind_frame ("SIGCHLD trap"); | |
2760 | } | |
2761 | ||
726f6388 JA |
2762 | /* Function to call when you want to notify people of changes |
2763 | in job status. This prints out all jobs which are pending | |
2764 | notification to stderr, and marks those printed as already | |
2765 | notified, thus making them candidates for cleanup. */ | |
2766 | static void | |
2767 | notify_of_job_status () | |
2768 | { | |
2769 | register int job, termsig; | |
2770 | char *dir; | |
2771 | sigset_t set, oset; | |
ccc6cda3 | 2772 | WAIT s; |
726f6388 | 2773 | |
28ef6c31 JA |
2774 | if (jobs == 0 || job_slots == 0) |
2775 | return; | |
2776 | ||
7117c2d2 JA |
2777 | if (old_ttou != 0) |
2778 | { | |
2779 | sigemptyset (&set); | |
2780 | sigaddset (&set, SIGCHLD); | |
2781 | sigaddset (&set, SIGTTOU); | |
2782 | sigemptyset (&oset); | |
2783 | sigprocmask (SIG_BLOCK, &set, &oset); | |
2784 | } | |
2785 | else | |
2786 | queue_sigchld++; | |
726f6388 | 2787 | |
ccc6cda3 | 2788 | for (job = 0, dir = (char *)NULL; job < job_slots; job++) |
726f6388 | 2789 | { |
ccc6cda3 | 2790 | if (jobs[job] && IS_NOTIFIED (job) == 0) |
726f6388 | 2791 | { |
bb70624e | 2792 | s = raw_job_exit_status (job); |
726f6388 JA |
2793 | termsig = WTERMSIG (s); |
2794 | ||
b72432fd JA |
2795 | /* POSIX.2 says we have to hang onto the statuses of at most the |
2796 | last CHILD_MAX background processes if the shell is running a | |
2797 | script. If the shell is not interactive, don't print anything | |
2798 | unless the job was killed by a signal. */ | |
2799 | if (startup_state == 0 && WIFSIGNALED (s) == 0 && | |
2800 | ((DEADJOB (job) && IS_FOREGROUND (job) == 0) || STOPPED (job))) | |
2801 | continue; | |
2802 | ||
726f6388 | 2803 | /* If job control is disabled, don't print the status messages. |
ccc6cda3 JA |
2804 | Mark dead jobs as notified so that they get cleaned up. If |
2805 | startup_state == 2, we were started to run `-c command', so | |
b72432fd JA |
2806 | don't print anything. */ |
2807 | if ((job_control == 0 && interactive_shell) || startup_state == 2) | |
726f6388 | 2808 | { |
cce855bc JA |
2809 | /* POSIX.2 compatibility: if the shell is not interactive, |
2810 | hang onto the job corresponding to the last asynchronous | |
2811 | pid until the user has been notified of its status or does | |
2812 | a `wait'. */ | |
7117c2d2 | 2813 | if (DEADJOB (job) && (interactive_shell || (find_last_pid (job, 0) != last_asynchronous_pid))) |
726f6388 JA |
2814 | jobs[job]->flags |= J_NOTIFIED; |
2815 | continue; | |
2816 | } | |
2817 | ||
ccc6cda3 JA |
2818 | /* Print info on jobs that are running in the background, |
2819 | and on foreground jobs that were killed by anything | |
d166f048 | 2820 | except SIGINT (and possibly SIGPIPE). */ |
726f6388 JA |
2821 | switch (JOBSTATE (job)) |
2822 | { | |
726f6388 | 2823 | case JDEAD: |
ccc6cda3 | 2824 | if (interactive_shell == 0 && termsig && WIFSIGNALED (s) && |
cce855bc | 2825 | termsig != SIGINT && |
cce855bc JA |
2826 | #if defined (DONT_REPORT_SIGPIPE) |
2827 | termsig != SIGPIPE && | |
2828 | #endif | |
ccc6cda3 | 2829 | signal_is_trapped (termsig) == 0) |
28ef6c31 | 2830 | { |
ccc6cda3 JA |
2831 | fprintf (stderr, "%s: line %d: ", get_name_for_error (), line_number); |
2832 | pretty_print_job (job, JLIST_NONINTERACTIVE, stderr); | |
2833 | } | |
2834 | else if (IS_FOREGROUND (job)) | |
726f6388 | 2835 | { |
d166f048 | 2836 | #if !defined (DONT_REPORT_SIGPIPE) |
726f6388 | 2837 | if (termsig && WIFSIGNALED (s) && termsig != SIGINT) |
d166f048 JA |
2838 | #else |
2839 | if (termsig && WIFSIGNALED (s) && termsig != SIGINT && termsig != SIGPIPE) | |
2840 | #endif | |
726f6388 JA |
2841 | { |
2842 | fprintf (stderr, "%s", strsignal (termsig)); | |
2843 | ||
2844 | if (WIFCORED (s)) | |
2845 | fprintf (stderr, " (core dumped)"); | |
2846 | ||
2847 | fprintf (stderr, "\n"); | |
2848 | } | |
2849 | } | |
2850 | else | |
2851 | { | |
ccc6cda3 | 2852 | if (dir == 0) |
726f6388 | 2853 | dir = current_working_directory (); |
ccc6cda3 | 2854 | pretty_print_job (job, JLIST_STANDARD, stderr); |
726f6388 JA |
2855 | if (dir && strcmp (dir, jobs[job]->wd) != 0) |
2856 | fprintf (stderr, | |
2857 | "(wd now: %s)\n", polite_directory_format (dir)); | |
2858 | } | |
2859 | ||
2860 | jobs[job]->flags |= J_NOTIFIED; | |
2861 | break; | |
2862 | ||
2863 | case JSTOPPED: | |
2864 | fprintf (stderr, "\n"); | |
ccc6cda3 | 2865 | if (dir == 0) |
726f6388 | 2866 | dir = current_working_directory (); |
ccc6cda3 | 2867 | pretty_print_job (job, JLIST_STANDARD, stderr); |
726f6388 JA |
2868 | if (dir && (strcmp (dir, jobs[job]->wd) != 0)) |
2869 | fprintf (stderr, | |
2870 | "(wd now: %s)\n", polite_directory_format (dir)); | |
2871 | jobs[job]->flags |= J_NOTIFIED; | |
2872 | break; | |
2873 | ||
2874 | case JRUNNING: | |
2875 | case JMIXED: | |
2876 | break; | |
2877 | ||
2878 | default: | |
2879 | programming_error ("notify_of_job_status"); | |
2880 | } | |
2881 | } | |
2882 | } | |
7117c2d2 JA |
2883 | if (old_ttou != 0) |
2884 | sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL); | |
2885 | else | |
2886 | queue_sigchld--; | |
726f6388 JA |
2887 | } |
2888 | ||
726f6388 | 2889 | /* Initialize the job control mechanism, and set up the tty stuff. */ |
ccc6cda3 | 2890 | int |
d166f048 JA |
2891 | initialize_job_control (force) |
2892 | int force; | |
726f6388 JA |
2893 | { |
2894 | shell_pgrp = getpgid (0); | |
2895 | ||
2896 | if (shell_pgrp == -1) | |
2897 | { | |
d166f048 | 2898 | sys_error ("initialize_job_control: getpgrp failed"); |
726f6388 JA |
2899 | exit (1); |
2900 | } | |
2901 | ||
ccc6cda3 JA |
2902 | /* We can only have job control if we are interactive. */ |
2903 | if (interactive == 0) | |
726f6388 JA |
2904 | { |
2905 | job_control = 0; | |
2906 | original_pgrp = NO_PID; | |
d166f048 | 2907 | shell_tty = fileno (stderr); |
726f6388 JA |
2908 | } |
2909 | else | |
2910 | { | |
726f6388 JA |
2911 | /* Get our controlling terminal. If job_control is set, or |
2912 | interactive is set, then this is an interactive shell no | |
ccc6cda3 JA |
2913 | matter where fd 2 is directed. */ |
2914 | shell_tty = dup (fileno (stderr)); /* fd 2 */ | |
726f6388 | 2915 | |
d166f048 | 2916 | shell_tty = move_to_high_fd (shell_tty, 1, -1); |
726f6388 | 2917 | |
726f6388 | 2918 | /* Compensate for a bug in systems that compiled the BSD |
ccc6cda3 | 2919 | rlogind with DEBUG defined, like NeXT and Alliant. */ |
726f6388 JA |
2920 | if (shell_pgrp == 0) |
2921 | { | |
2922 | shell_pgrp = getpid (); | |
2923 | setpgid (0, shell_pgrp); | |
2924 | tcsetpgrp (shell_tty, shell_pgrp); | |
2925 | } | |
726f6388 JA |
2926 | |
2927 | while ((terminal_pgrp = tcgetpgrp (shell_tty)) != -1) | |
2928 | { | |
2929 | if (shell_pgrp != terminal_pgrp) | |
2930 | { | |
7117c2d2 | 2931 | SigHandler *ottin; |
ccc6cda3 | 2932 | |
7117c2d2 | 2933 | ottin = set_signal_handler(SIGTTIN, SIG_DFL); |
726f6388 | 2934 | kill (0, SIGTTIN); |
7117c2d2 | 2935 | set_signal_handler (SIGTTIN, ottin); |
726f6388 JA |
2936 | continue; |
2937 | } | |
2938 | break; | |
2939 | } | |
2940 | ||
ccc6cda3 | 2941 | /* Make sure that we are using the new line discipline. */ |
726f6388 JA |
2942 | if (set_new_line_discipline (shell_tty) < 0) |
2943 | { | |
d166f048 | 2944 | sys_error ("initialize_job_control: line discipline"); |
726f6388 JA |
2945 | job_control = 0; |
2946 | } | |
2947 | else | |
2948 | { | |
2949 | original_pgrp = shell_pgrp; | |
2950 | shell_pgrp = getpid (); | |
2951 | ||
2952 | if ((original_pgrp != shell_pgrp) && (setpgid (0, shell_pgrp) < 0)) | |
2953 | { | |
d166f048 | 2954 | sys_error ("initialize_job_control: setpgid"); |
726f6388 JA |
2955 | shell_pgrp = original_pgrp; |
2956 | } | |
2957 | ||
2958 | job_control = 1; | |
ccc6cda3 JA |
2959 | |
2960 | /* If (and only if) we just set our process group to our pid, | |
2961 | thereby becoming a process group leader, and the terminal | |
2962 | is not in the same process group as our (new) process group, | |
2963 | then set the terminal's process group to our (new) process | |
2964 | group. If that fails, set our process group back to what it | |
2965 | was originally (so we can still read from the terminal) and | |
2966 | turn off job control. */ | |
2967 | if (shell_pgrp != original_pgrp && shell_pgrp != terminal_pgrp) | |
2968 | { | |
28ef6c31 | 2969 | if (give_terminal_to (shell_pgrp, 0) < 0) |
ccc6cda3 | 2970 | { |
28ef6c31 JA |
2971 | setpgid (0, original_pgrp); |
2972 | shell_pgrp = original_pgrp; | |
2973 | job_control = 0; | |
ccc6cda3 JA |
2974 | } |
2975 | } | |
726f6388 JA |
2976 | } |
2977 | if (job_control == 0) | |
28ef6c31 | 2978 | internal_error ("no job control in this shell"); |
726f6388 JA |
2979 | } |
2980 | ||
2981 | if (shell_tty != fileno (stderr)) | |
2982 | SET_CLOSE_ON_EXEC (shell_tty); | |
2983 | ||
ccc6cda3 | 2984 | set_signal_handler (SIGCHLD, sigchld_handler); |
726f6388 JA |
2985 | |
2986 | change_flag ('m', job_control ? '-' : '+'); | |
2987 | ||
2988 | if (interactive) | |
2989 | get_tty_state (); | |
ccc6cda3 | 2990 | |
726f6388 JA |
2991 | return job_control; |
2992 | } | |
2993 | ||
28ef6c31 JA |
2994 | #ifdef DEBUG |
2995 | void | |
2996 | debug_print_pgrps () | |
2997 | { | |
f73dda09 JA |
2998 | itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld", |
2999 | (long)original_pgrp, (long)shell_pgrp, (long)terminal_pgrp); | |
3000 | itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld", | |
3001 | shell_tty, (long)tcgetpgrp (shell_tty), (long)getpgid(0)); | |
28ef6c31 JA |
3002 | } |
3003 | #endif | |
3004 | ||
726f6388 JA |
3005 | /* Set the line discipline to the best this system has to offer. |
3006 | Return -1 if this is not possible. */ | |
3007 | static int | |
3008 | set_new_line_discipline (tty) | |
3009 | int tty; | |
3010 | { | |
3011 | #if defined (NEW_TTY_DRIVER) | |
3012 | int ldisc; | |
3013 | ||
3014 | if (ioctl (tty, TIOCGETD, &ldisc) < 0) | |
3015 | return (-1); | |
3016 | ||
3017 | if (ldisc != NTTYDISC) | |
3018 | { | |
3019 | ldisc = NTTYDISC; | |
3020 | ||
3021 | if (ioctl (tty, TIOCSETD, &ldisc) < 0) | |
3022 | return (-1); | |
3023 | } | |
3024 | return (0); | |
3025 | #endif /* NEW_TTY_DRIVER */ | |
3026 | ||
3027 | #if defined (TERMIO_TTY_DRIVER) | |
ccc6cda3 | 3028 | # if defined (TERMIO_LDISC) && (NTTYDISC) |
726f6388 JA |
3029 | if (ioctl (tty, TCGETA, &shell_tty_info) < 0) |
3030 | return (-1); | |
3031 | ||
3032 | if (shell_tty_info.c_line != NTTYDISC) | |
3033 | { | |
3034 | shell_tty_info.c_line = NTTYDISC; | |
3035 | if (ioctl (tty, TCSETAW, &shell_tty_info) < 0) | |
3036 | return (-1); | |
3037 | } | |
ccc6cda3 | 3038 | # endif /* TERMIO_LDISC && NTTYDISC */ |
726f6388 JA |
3039 | return (0); |
3040 | #endif /* TERMIO_TTY_DRIVER */ | |
3041 | ||
3042 | #if defined (TERMIOS_TTY_DRIVER) | |
ccc6cda3 | 3043 | # if defined (TERMIOS_LDISC) && defined (NTTYDISC) |
726f6388 JA |
3044 | if (tcgetattr (tty, &shell_tty_info) < 0) |
3045 | return (-1); | |
3046 | ||
3047 | if (shell_tty_info.c_line != NTTYDISC) | |
3048 | { | |
3049 | shell_tty_info.c_line = NTTYDISC; | |
3050 | if (tcsetattr (tty, TCSADRAIN, &shell_tty_info) < 0) | |
3051 | return (-1); | |
3052 | } | |
ccc6cda3 | 3053 | # endif /* TERMIOS_LDISC && NTTYDISC */ |
726f6388 JA |
3054 | return (0); |
3055 | #endif /* TERMIOS_TTY_DRIVER */ | |
3056 | ||
3057 | #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER) | |
3058 | return (-1); | |
3059 | #endif | |
3060 | } | |
3061 | ||
ccc6cda3 | 3062 | #if defined (TIOCGWINSZ) && defined (SIGWINCH) |
ccc6cda3 JA |
3063 | static void |
3064 | get_new_window_size (from_sig) | |
3065 | int from_sig; | |
726f6388 JA |
3066 | { |
3067 | struct winsize win; | |
3068 | ||
726f6388 JA |
3069 | if ((ioctl (shell_tty, TIOCGWINSZ, &win) == 0) && |
3070 | win.ws_row > 0 && win.ws_col > 0) | |
3071 | { | |
3072 | #if defined (aixpc) | |
3073 | shell_tty_info.c_winsize = win; /* structure copying */ | |
3074 | #endif | |
28ef6c31 | 3075 | sh_set_lines_and_columns (win.ws_row, win.ws_col); |
ccc6cda3 | 3076 | #if defined (READLINE) |
28ef6c31 | 3077 | rl_set_screen_size (win.ws_row, win.ws_col); |
ccc6cda3 | 3078 | #endif |
726f6388 JA |
3079 | } |
3080 | } | |
ccc6cda3 JA |
3081 | |
3082 | static sighandler | |
3083 | sigwinch_sighandler (sig) | |
3084 | int sig; | |
3085 | { | |
3086 | #if defined (MUST_REINSTALL_SIGHANDLERS) | |
3087 | set_signal_handler (SIGWINCH, sigwinch_sighandler); | |
3088 | #endif /* MUST_REINSTALL_SIGHANDLERS */ | |
3089 | get_new_window_size (1); | |
d166f048 | 3090 | SIGRETURN (0); |
ccc6cda3 JA |
3091 | } |
3092 | #else | |
3093 | static void | |
3094 | get_new_window_size (from_sig) | |
3095 | int from_sig; | |
3096 | { | |
3097 | } | |
3098 | #endif /* TIOCGWINSZ && SIGWINCH */ | |
3099 | ||
3100 | void | |
3101 | set_sigwinch_handler () | |
3102 | { | |
3103 | #if defined (TIOCGWINSZ) && defined (SIGWINCH) | |
3104 | old_winch = set_signal_handler (SIGWINCH, sigwinch_sighandler); | |
3105 | #endif | |
3106 | } | |
3107 | ||
3108 | void | |
3109 | unset_sigwinch_handler () | |
3110 | { | |
3111 | #if defined (TIOCGWINSZ) && defined (SIGWINCH) | |
3112 | set_signal_handler (SIGWINCH, old_winch); | |
3113 | #endif | |
3114 | } | |
726f6388 JA |
3115 | |
3116 | /* Setup this shell to handle C-C, etc. */ | |
3117 | void | |
3118 | initialize_job_signals () | |
3119 | { | |
3120 | if (interactive) | |
3121 | { | |
3122 | set_signal_handler (SIGINT, sigint_sighandler); | |
3123 | set_signal_handler (SIGTSTP, SIG_IGN); | |
3124 | set_signal_handler (SIGTTOU, SIG_IGN); | |
3125 | set_signal_handler (SIGTTIN, SIG_IGN); | |
ccc6cda3 | 3126 | set_sigwinch_handler (); |
726f6388 JA |
3127 | } |
3128 | else if (job_control) | |
3129 | { | |
28ef6c31 | 3130 | old_tstp = set_signal_handler (SIGTSTP, sigstop_sighandler); |
28ef6c31 | 3131 | old_ttin = set_signal_handler (SIGTTIN, sigstop_sighandler); |
7117c2d2 | 3132 | old_ttou = set_signal_handler (SIGTTOU, sigstop_sighandler); |
726f6388 JA |
3133 | } |
3134 | /* Leave these things alone for non-interactive shells without job | |
3135 | control. */ | |
3136 | } | |
3137 | ||
3138 | /* Here we handle CONT signals. */ | |
3139 | static sighandler | |
28ef6c31 | 3140 | sigcont_sighandler (sig) |
726f6388 JA |
3141 | int sig; |
3142 | { | |
3143 | initialize_job_signals (); | |
3144 | set_signal_handler (SIGCONT, old_cont); | |
3145 | kill (getpid (), SIGCONT); | |
3146 | ||
ccc6cda3 | 3147 | SIGRETURN (0); |
726f6388 JA |
3148 | } |
3149 | ||
3150 | /* Here we handle stop signals while we are running not as a login shell. */ | |
3151 | static sighandler | |
28ef6c31 | 3152 | sigstop_sighandler (sig) |
726f6388 JA |
3153 | int sig; |
3154 | { | |
3155 | set_signal_handler (SIGTSTP, old_tstp); | |
3156 | set_signal_handler (SIGTTOU, old_ttou); | |
3157 | set_signal_handler (SIGTTIN, old_ttin); | |
3158 | ||
28ef6c31 | 3159 | old_cont = set_signal_handler (SIGCONT, sigcont_sighandler); |
726f6388 | 3160 | |
28ef6c31 | 3161 | give_terminal_to (shell_pgrp, 0); |
726f6388 JA |
3162 | |
3163 | kill (getpid (), sig); | |
3164 | ||
ccc6cda3 | 3165 | SIGRETURN (0); |
726f6388 JA |
3166 | } |
3167 | ||
3168 | /* Give the terminal to PGRP. */ | |
ccc6cda3 | 3169 | int |
28ef6c31 | 3170 | give_terminal_to (pgrp, force) |
726f6388 | 3171 | pid_t pgrp; |
28ef6c31 | 3172 | int force; |
726f6388 JA |
3173 | { |
3174 | sigset_t set, oset; | |
ccc6cda3 | 3175 | int r; |
726f6388 | 3176 | |
ccc6cda3 | 3177 | r = 0; |
28ef6c31 | 3178 | if (job_control || force) |
726f6388 JA |
3179 | { |
3180 | sigemptyset (&set); | |
3181 | sigaddset (&set, SIGTTOU); | |
3182 | sigaddset (&set, SIGTTIN); | |
3183 | sigaddset (&set, SIGTSTP); | |
3184 | sigaddset (&set, SIGCHLD); | |
3185 | sigemptyset (&oset); | |
3186 | sigprocmask (SIG_BLOCK, &set, &oset); | |
3187 | ||
3188 | if (tcsetpgrp (shell_tty, pgrp) < 0) | |
3189 | { | |
3190 | /* Maybe we should print an error message? */ | |
ccc6cda3 | 3191 | #if 0 |
f73dda09 JA |
3192 | sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld", |
3193 | shell_tty, (long)getpid(), (long)pgrp); | |
ccc6cda3 | 3194 | #endif |
726f6388 JA |
3195 | r = -1; |
3196 | } | |
3197 | else | |
3198 | terminal_pgrp = pgrp; | |
726f6388 JA |
3199 | sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL); |
3200 | } | |
3201 | ||
3202 | return r; | |
3203 | } | |
3204 | ||
3205 | /* Clear out any jobs in the job array. This is intended to be used by | |
3206 | children of the shell, who should not have any job structures as baggage | |
3207 | when they start executing (forking subshells for parenthesized execution | |
cce855bc JA |
3208 | and functions with pipes are the two that spring to mind). If RUNNING_ONLY |
3209 | is nonzero, only running jobs are removed from the table. */ | |
d166f048 | 3210 | void |
cce855bc JA |
3211 | delete_all_jobs (running_only) |
3212 | int running_only; | |
726f6388 JA |
3213 | { |
3214 | register int i; | |
3215 | sigset_t set, oset; | |
3216 | ||
ccc6cda3 JA |
3217 | BLOCK_CHILD (set, oset); |
3218 | ||
726f6388 JA |
3219 | if (job_slots) |
3220 | { | |
ccc6cda3 | 3221 | current_job = previous_job = NO_JOB; |
726f6388 | 3222 | |
ccc6cda3 | 3223 | for (i = 0; i < job_slots; i++) |
cce855bc JA |
3224 | if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i)))) |
3225 | delete_job (i, 1); | |
726f6388 | 3226 | |
cce855bc JA |
3227 | if (running_only == 0) |
3228 | { | |
3229 | free ((char *)jobs); | |
3230 | job_slots = 0; | |
3231 | } | |
726f6388 | 3232 | } |
ccc6cda3 JA |
3233 | |
3234 | UNBLOCK_CHILD (oset); | |
726f6388 JA |
3235 | } |
3236 | ||
d166f048 | 3237 | /* Mark all jobs in the job array so that they don't get a SIGHUP when the |
cce855bc | 3238 | shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */ |
d166f048 | 3239 | void |
cce855bc JA |
3240 | nohup_all_jobs (running_only) |
3241 | int running_only; | |
d166f048 JA |
3242 | { |
3243 | register int i; | |
3244 | sigset_t set, oset; | |
3245 | ||
3246 | BLOCK_CHILD (set, oset); | |
3247 | ||
3248 | if (job_slots) | |
3249 | { | |
3250 | for (i = 0; i < job_slots; i++) | |
cce855bc | 3251 | if (jobs[i] && (running_only == 0 || (running_only && RUNNING(i)))) |
d166f048 JA |
3252 | nohup_job (i); |
3253 | } | |
3254 | ||
3255 | UNBLOCK_CHILD (oset); | |
3256 | } | |
3257 | ||
bb70624e JA |
3258 | int |
3259 | count_all_jobs () | |
3260 | { | |
3261 | int i, n; | |
3262 | sigset_t set, oset; | |
3263 | ||
3264 | BLOCK_CHILD (set, oset); | |
3265 | for (i = n = 0; i < job_slots; i++) | |
3266 | if (jobs[i] && DEADJOB(i) == 0) | |
3267 | n++; | |
3268 | UNBLOCK_CHILD (oset); | |
3269 | return n; | |
3270 | } | |
3271 | ||
3272 | static void | |
3273 | mark_all_jobs_as_dead () | |
3274 | { | |
3275 | register int i; | |
3276 | sigset_t set, oset; | |
3277 | ||
7117c2d2 JA |
3278 | if (job_slots == 0) |
3279 | return; | |
bb70624e | 3280 | |
7117c2d2 | 3281 | BLOCK_CHILD (set, oset); |
bb70624e | 3282 | |
7117c2d2 JA |
3283 | for (i = 0; i < job_slots; i++) |
3284 | if (jobs[i]) | |
3285 | jobs[i]->state = JDEAD; | |
3286 | ||
3287 | UNBLOCK_CHILD (oset); | |
bb70624e JA |
3288 | } |
3289 | ||
726f6388 | 3290 | /* Mark all dead jobs as notified, so delete_job () cleans them out |
b72432fd JA |
3291 | of the job table properly. POSIX.2 says we need to save the |
3292 | status of the last CHILD_MAX jobs, so we count the number of dead | |
3293 | jobs and mark only enough as notified to save CHILD_MAX statuses. */ | |
726f6388 | 3294 | static void |
b72432fd JA |
3295 | mark_dead_jobs_as_notified (force) |
3296 | int force; | |
726f6388 | 3297 | { |
b72432fd | 3298 | register int i, ndead; |
726f6388 JA |
3299 | sigset_t set, oset; |
3300 | ||
7117c2d2 JA |
3301 | if (job_slots == 0) |
3302 | return; | |
b72432fd | 3303 | |
7117c2d2 | 3304 | BLOCK_CHILD (set, oset); |
b72432fd | 3305 | |
7117c2d2 JA |
3306 | /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses |
3307 | around; just run through the array. */ | |
3308 | if (force) | |
3309 | { | |
726f6388 | 3310 | for (i = 0; i < job_slots; i++) |
28ef6c31 | 3311 | { |
7117c2d2 JA |
3312 | if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid))) |
3313 | jobs[i]->flags |= J_NOTIFIED; | |
28ef6c31 | 3314 | } |
7117c2d2 JA |
3315 | UNBLOCK_CHILD (oset); |
3316 | return; | |
3317 | } | |
3318 | ||
3319 | /* Mark enough dead jobs as notified to keep CHILD_MAX jobs left in the | |
3320 | array not marked as notified. */ | |
3321 | ||
3322 | /* Count the number of dead jobs */ | |
3323 | for (i = ndead = 0; i < job_slots; i++) | |
3324 | { | |
3325 | if (jobs[i] && DEADJOB (i)) | |
3326 | ndead++; | |
3327 | } | |
3328 | ||
3329 | if (child_max < 0) | |
3330 | child_max = getmaxchild (); | |
3331 | if (child_max < 0) | |
3332 | child_max = DEFAULT_CHILD_MAX; | |
726f6388 | 3333 | |
7117c2d2 JA |
3334 | /* Don't do anything if the number of dead jobs is less than CHILD_MAX and |
3335 | we're not forcing a cleanup. */ | |
3336 | if (ndead <= child_max) | |
3337 | { | |
726f6388 | 3338 | UNBLOCK_CHILD (oset); |
7117c2d2 | 3339 | return; |
726f6388 | 3340 | } |
7117c2d2 JA |
3341 | |
3342 | /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in | |
3343 | the list. This isn't exactly right yet; changes need to be made | |
3344 | to stop_pipeline so we don't mark the newer jobs after we've | |
3345 | created CHILD_MAX slots in the jobs array. */ | |
3346 | for (i = 0; i < job_slots; i++) | |
3347 | { | |
3348 | if (jobs[i] && DEADJOB (i) && (interactive_shell || (find_last_pid (i, 0) != last_asynchronous_pid))) | |
3349 | { | |
3350 | jobs[i]->flags |= J_NOTIFIED; | |
3351 | if (--ndead <= child_max) | |
3352 | break; | |
3353 | } | |
3354 | } | |
3355 | ||
3356 | UNBLOCK_CHILD (oset); | |
726f6388 JA |
3357 | } |
3358 | ||
ccc6cda3 JA |
3359 | /* Here to allow other parts of the shell (like the trap stuff) to |
3360 | unfreeze the jobs list. */ | |
3361 | void | |
3362 | unfreeze_jobs_list () | |
3363 | { | |
3364 | jobs_list_frozen = 0; | |
3365 | } | |
3366 | ||
726f6388 JA |
3367 | /* Allow or disallow job control to take place. Returns the old value |
3368 | of job_control. */ | |
3369 | int | |
3370 | set_job_control (arg) | |
3371 | int arg; | |
3372 | { | |
3373 | int old; | |
3374 | ||
3375 | old = job_control; | |
3376 | job_control = arg; | |
3377 | return (old); | |
3378 | } | |
3379 | ||
3380 | /* Turn off all traces of job control. This is run by children of the shell | |
3381 | which are going to do shellsy things, like wait (), etc. */ | |
3382 | void | |
3383 | without_job_control () | |
3384 | { | |
3385 | stop_making_children (); | |
3386 | start_pipeline (); | |
cce855bc | 3387 | delete_all_jobs (0); |
726f6388 JA |
3388 | set_job_control (0); |
3389 | } | |
3390 | ||
3391 | /* If this shell is interactive, terminate all stopped jobs and | |
3392 | restore the original terminal process group. This is done | |
3393 | before the `exec' builtin calls shell_execve. */ | |
3394 | void | |
3395 | end_job_control () | |
3396 | { | |
3397 | if (interactive_shell) /* XXX - should it be interactive? */ | |
3398 | { | |
3399 | terminate_stopped_jobs (); | |
3400 | ||
3401 | if (original_pgrp >= 0) | |
28ef6c31 | 3402 | give_terminal_to (original_pgrp, 1); |
726f6388 JA |
3403 | } |
3404 | ||
3405 | if (original_pgrp >= 0) | |
3406 | setpgid (0, original_pgrp); | |
3407 | } | |
3408 | ||
3409 | /* Restart job control by closing shell tty and reinitializing. This is | |
3410 | called after an exec fails in an interactive shell and we do not exit. */ | |
3411 | void | |
3412 | restart_job_control () | |
3413 | { | |
3414 | if (shell_tty != -1) | |
3415 | close (shell_tty); | |
d166f048 | 3416 | initialize_job_control (0); |
726f6388 JA |
3417 | } |
3418 | ||
3419 | /* Set the handler to run when the shell receives a SIGCHLD signal. */ | |
3420 | void | |
3421 | set_sigchld_handler () | |
3422 | { | |
ccc6cda3 | 3423 | set_signal_handler (SIGCHLD, sigchld_handler); |
726f6388 JA |
3424 | } |
3425 | ||
3426 | #if defined (PGRP_PIPE) | |
3427 | /* Read from the read end of a pipe. This is how the process group leader | |
3428 | blocks until all of the processes in a pipeline have been made. */ | |
3429 | static void | |
3430 | pipe_read (pp) | |
3431 | int *pp; | |
3432 | { | |
3433 | char ch; | |
3434 | ||
3435 | if (pp[1] >= 0) | |
3436 | { | |
3437 | close (pp[1]); | |
3438 | pp[1] = -1; | |
3439 | } | |
3440 | ||
3441 | if (pp[0] >= 0) | |
3442 | { | |
3443 | while (read (pp[0], &ch, 1) == -1 && errno == EINTR) | |
bb70624e | 3444 | ; |
726f6388 JA |
3445 | } |
3446 | } | |
3447 | ||
3448 | /* Close the read and write ends of PP, an array of file descriptors. */ | |
3449 | static void | |
3450 | pipe_close (pp) | |
3451 | int *pp; | |
3452 | { | |
3453 | if (pp[0] >= 0) | |
3454 | close (pp[0]); | |
3455 | ||
3456 | if (pp[1] >= 0) | |
3457 | close (pp[1]); | |
3458 | ||
3459 | pp[0] = pp[1] = -1; | |
3460 | } | |
3461 | ||
3462 | /* Functional interface closes our local-to-job-control pipes. */ | |
ccc6cda3 | 3463 | void |
726f6388 JA |
3464 | close_pgrp_pipe () |
3465 | { | |
3466 | pipe_close (pgrp_pipe); | |
3467 | } | |
3468 | ||
3469 | #endif /* PGRP_PIPE */ |