1 /* The thing that makes children, remembers them, and contains wait loops. */
3 /* This file works with both POSIX and BSD systems. It implements job
6 /* Copyright (C) 1989-2007 Free Software Foundation, Inc.
8 This file is part of GNU Bash, the Bourne Again SHell.
10 Bash is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
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
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
22 Foundation, 59 Temple Place, Suite 330, Boston, MA 02111 USA. */
26 #include "bashtypes.h"
32 #if defined (HAVE_UNISTD_H)
36 #include "posixtime.h"
38 #if defined (HAVE_SYS_RESOURCE_H) && defined (HAVE_WAIT3) && !defined (_POSIX_VERSION) && !defined (RLIMTYPE)
39 # include <sys/resource.h>
40 #endif /* !_POSIX_VERSION && HAVE_SYS_RESOURCE_H && HAVE_WAIT3 && !RLIMTYPE */
42 #if defined (HAVE_SYS_FILE_H)
43 # include <sys/file.h>
47 #include <sys/ioctl.h>
48 #include <sys/param.h>
50 #if defined (BUFFERED_INPUT)
54 /* Need to include this up here for *_TTY_DRIVER definitions. */
57 /* Define this if your output is getting swallowed. It's a no-op on
58 machines with the termio or termios tty drivers. */
59 /* #define DRAIN_OUTPUT */
61 /* For the TIOCGPGRP and TIOCSPGRP ioctl parameters on HP-UX */
62 #if defined (hpux) && !defined (TERMIOS_TTY_DRIVER)
64 #endif /* hpux && !TERMIOS_TTY_DRIVER */
72 #include "builtins/builtext.h"
73 #include "builtins/common.h"
79 #define DEFAULT_CHILD_MAX 32
81 #define MAX_JOBS_IN_ARRAY 4096 /* production */
83 #define MAX_JOBS_IN_ARRAY 128 /* testing */
86 /* Flag values for second argument to delete_job */
87 #define DEL_WARNSTOPPED 1 /* warn about deleting stopped jobs */
88 #define DEL_NOBGPID 2 /* don't add pgrp leader to bgpids */
90 /* Take care of system dependencies that must be handled when waiting for
91 children. The arguments to the WAITPID macro match those to the Posix.1
92 waitpid() function. */
94 #if defined (ultrix) && defined (mips) && defined (_POSIX_VERSION)
95 # define WAITPID(pid, statusp, options) \
96 wait3 ((union wait *)statusp, options, (struct rusage *)0)
98 # if defined (_POSIX_VERSION) || defined (HAVE_WAITPID)
99 # define WAITPID(pid, statusp, options) \
100 waitpid ((pid_t)pid, statusp, options)
102 # if defined (HAVE_WAIT3)
103 # define WAITPID(pid, statusp, options) \
104 wait3 (statusp, options, (struct rusage *)0)
106 # define WAITPID(pid, statusp, options) \
107 wait3 (statusp, options, (int *)0)
108 # endif /* HAVE_WAIT3 */
109 # endif /* !_POSIX_VERSION && !HAVE_WAITPID*/
110 #endif /* !(Ultrix && mips && _POSIX_VERSION) */
112 /* getpgrp () varies between systems. Even systems that claim to be
113 Posix.1 compatible lie sometimes (Ultrix, SunOS4, apollo). */
114 #if defined (GETPGRP_VOID)
115 # define getpgid(p) getpgrp ()
117 # define getpgid(p) getpgrp (p)
118 #endif /* !GETPGRP_VOID */
120 /* If the system needs it, REINSTALL_SIGCHLD_HANDLER will reinstall the
121 handler for SIGCHLD. */
122 #if defined (MUST_REINSTALL_SIGHANDLERS)
123 # define REINSTALL_SIGCHLD_HANDLER signal (SIGCHLD, sigchld_handler)
125 # define REINSTALL_SIGCHLD_HANDLER
126 #endif /* !MUST_REINSTALL_SIGHANDLERS */
128 /* Some systems let waitpid(2) tell callers about stopped children. */
129 #if !defined (WCONTINUED) || defined (WCONTINUED_BROKEN)
131 # define WCONTINUED 0
133 #if !defined (WIFCONTINUED)
134 # define WIFCONTINUED(s) (0)
137 /* The number of additional slots to allocate when we run out. */
140 typedef int sh_job_map_func_t
__P((JOB
*, int, int, int));
142 /* Variables used here but defined in other files. */
143 extern int subshell_environment
, line_number
;
144 extern int posixly_correct
, shell_level
;
145 extern int last_command_exit_value
, last_command_exit_signal
;
146 extern int loop_level
, breaking
;
147 extern int sourcelevel
;
148 extern int running_trap
;
149 extern sh_builtin_func_t
*this_shell_builtin
;
150 extern char *shell_name
, *this_command_name
;
151 extern sigset_t top_level_mask
;
152 extern procenv_t wait_intr_buf
;
153 extern int wait_signal_received
;
154 extern WORD_LIST
*subst_assign_varlist
;
156 static struct jobstats zerojs
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
157 struct jobstats js
= { -1L, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, NO_JOB
, NO_JOB
, 0, 0 };
159 struct bgpids bgpids
= { 0, 0, 0 };
161 /* The array of known jobs. */
162 JOB
**jobs
= (JOB
**)NULL
;
165 /* The number of slots currently allocated to JOBS. */
169 /* The controlling tty for this shell. */
172 /* The shell's process group. */
173 pid_t shell_pgrp
= NO_PID
;
175 /* The terminal's process group. */
176 pid_t terminal_pgrp
= NO_PID
;
178 /* The process group of the shell's parent. */
179 pid_t original_pgrp
= NO_PID
;
181 /* The process group of the pipeline currently being made. */
182 pid_t pipeline_pgrp
= (pid_t
)0;
184 #if defined (PGRP_PIPE)
185 /* Pipes which each shell uses to communicate with the process group leader
186 until all of the processes in a pipeline have been started. Then the
187 process leader is allowed to continue. */
188 int pgrp_pipe
[2] = { -1, -1 };
192 /* The job which is current; i.e. the one that `%+' stands for. */
193 int current_job
= NO_JOB
;
195 /* The previous job; i.e. the one that `%-' stands for. */
196 int previous_job
= NO_JOB
;
199 /* Last child made by the shell. */
200 pid_t last_made_pid
= NO_PID
;
202 /* Pid of the last asynchronous child. */
203 pid_t last_asynchronous_pid
= NO_PID
;
205 /* The pipeline currently being built. */
206 PROCESS
*the_pipeline
= (PROCESS
*)NULL
;
208 /* If this is non-zero, do job control. */
211 /* Call this when you start making children. */
212 int already_making_children
= 0;
214 /* If this is non-zero, $LINES and $COLUMNS are reset after every process
215 exits from get_tty_state(). */
216 int check_window_size
;
218 /* Functions local to this file. */
220 static void run_sigchld_trap
__P((int));
222 static sighandler wait_sigint_handler
__P((int));
223 static sighandler sigchld_handler
__P((int));
224 static sighandler sigcont_sighandler
__P((int));
225 static sighandler sigstop_sighandler
__P((int));
227 static int waitchld
__P((pid_t
, int));
229 static PROCESS
*find_pipeline
__P((pid_t
, int, int *));
230 static PROCESS
*find_process
__P((pid_t
, int, int *));
232 static char *current_working_directory
__P((void));
233 static char *job_working_directory
__P((void));
234 static char *j_strsignal
__P((int));
235 static char *printable_job_status
__P((int, PROCESS
*, int));
237 static PROCESS
*find_last_proc
__P((int, int));
238 static pid_t find_last_pid
__P((int, int));
240 static int set_new_line_discipline
__P((int));
241 static int map_over_jobs
__P((sh_job_map_func_t
*, int, int));
242 static int job_last_stopped
__P((int));
243 static int job_last_running
__P((int));
244 static int most_recent_job_in_state
__P((int, JOB_STATE
));
245 static int find_job
__P((pid_t
, int, PROCESS
**));
246 static int print_job
__P((JOB
*, int, int, int));
247 static int process_exit_status
__P((WAIT
));
248 static int process_exit_signal
__P((WAIT
));
249 static int job_exit_status
__P((int));
250 static int job_exit_signal
__P((int));
251 static int set_job_status_and_cleanup
__P((int));
253 static WAIT raw_job_exit_status
__P((int));
255 static void notify_of_job_status
__P((void));
256 static void reset_job_indices
__P((void));
257 static void cleanup_dead_jobs
__P((void));
258 static int processes_in_job
__P((int));
259 static void realloc_jobs_list
__P((void));
260 static int compact_jobs_list
__P((int));
261 static int discard_pipeline
__P((PROCESS
*));
262 static void add_process
__P((char *, pid_t
));
263 static void print_pipeline
__P((PROCESS
*, int, int, FILE *));
264 static void pretty_print_job
__P((int, int, FILE *));
265 static void set_current_job
__P((int));
266 static void reset_current
__P((void));
267 static void set_job_running
__P((int));
268 static void setjstatus
__P((int));
269 static void mark_all_jobs_as_dead
__P((void));
270 static void mark_dead_jobs_as_notified
__P((int));
271 static void restore_sigint_handler
__P((void));
272 #if defined (PGRP_PIPE)
273 static void pipe_read
__P((int *));
274 static void pipe_close
__P((int *));
277 static struct pidstat
*bgp_alloc
__P((pid_t
, int));
278 static struct pidstat
*bgp_add
__P((pid_t
, int));
279 static int bgp_delete
__P((pid_t
));
280 static void bgp_clear
__P((void));
281 static int bgp_search
__P((pid_t
));
282 static void bgp_prune
__P((void));
284 #if defined (ARRAY_VARS)
285 static int *pstatuses
; /* list of pipeline statuses */
289 /* Used to synchronize between wait_for and other functions and the SIGCHLD
292 static int queue_sigchld
;
294 #define QUEUE_SIGCHLD(os) (os) = sigchld, queue_sigchld++
296 #define UNQUEUE_SIGCHLD(os) \
299 if (queue_sigchld == 0 && os != sigchld) \
303 static SigHandler
*old_tstp
, *old_ttou
, *old_ttin
;
304 static SigHandler
*old_cont
= (SigHandler
*)SIG_DFL
;
306 /* A place to temporarily save the current pipeline. */
307 static PROCESS
*saved_pipeline
;
308 static int saved_already_making_children
;
310 /* Set this to non-zero whenever you don't want the jobs list to change at
311 all: no jobs deleted and no status change notifications. This is used,
312 for example, when executing SIGCHLD traps, which may run arbitrary
314 static int jobs_list_frozen
;
316 static char retcode_name_buffer
[64];
318 /* flags to detect pid wraparound */
319 static pid_t first_pid
= NO_PID
;
320 static int pid_wrap
= -1;
322 #if !defined (_POSIX_VERSION)
324 /* These are definitions to map POSIX 1003.1 functions onto existing BSD
325 library functions and system calls. */
326 #define setpgid(pid, pgrp) setpgrp (pid, pgrp)
327 #define tcsetpgrp(fd, pgrp) ioctl ((fd), TIOCSPGRP, &(pgrp))
335 /* ioctl will handle setting errno correctly. */
336 if (ioctl (fd
, TIOCGPGRP
, &pgrp
) < 0)
341 #endif /* !_POSIX_VERSION */
343 /* Initialize the global job stats structure and other bookkeeping variables */
352 /* Return the working directory for the current process. Unlike
353 job_working_directory, this does not call malloc (), nor do any
354 of the functions it calls. This is so that it can safely be called
355 from a signal handler. */
357 current_working_directory ()
360 static char d
[PATH_MAX
];
362 dir
= get_string_value ("PWD");
364 if (dir
== 0 && the_current_working_directory
&& no_symbolic_links
)
365 dir
= the_current_working_directory
;
369 dir
= getcwd (d
, sizeof(d
));
374 return (dir
== 0) ? "<unknown>" : dir
;
377 /* Return the working directory for the current process. */
379 job_working_directory ()
383 dir
= get_string_value ("PWD");
385 return (savestring (dir
));
387 dir
= get_working_directory ("job-working-directory");
391 return (savestring ("<unknown>"));
397 if (already_making_children
)
400 already_making_children
= 1;
405 stop_making_children ()
407 already_making_children
= 0;
411 cleanup_the_pipeline ()
416 BLOCK_CHILD (set
, oset
);
417 disposer
= the_pipeline
;
418 the_pipeline
= (PROCESS
*)NULL
;
419 UNBLOCK_CHILD (oset
);
422 discard_pipeline (disposer
);
426 save_pipeline (clear
)
429 saved_pipeline
= the_pipeline
;
431 the_pipeline
= (PROCESS
*)NULL
;
432 saved_already_making_children
= already_making_children
;
436 restore_pipeline (discard
)
439 PROCESS
*old_pipeline
;
441 old_pipeline
= the_pipeline
;
442 the_pipeline
= saved_pipeline
;
443 already_making_children
= saved_already_making_children
;
445 discard_pipeline (old_pipeline
);
448 /* Start building a pipeline. */
454 cleanup_the_pipeline ();
456 #if defined (PGRP_PIPE)
457 pipe_close (pgrp_pipe
);
461 #if defined (PGRP_PIPE)
464 if (pipe (pgrp_pipe
) == -1)
465 sys_error (_("start_pipeline: pgrp pipe"));
470 /* Stop building a pipeline. Install the process list in the job array.
471 This returns the index of the newly installed job.
472 DEFERRED is a command structure to be executed upon satisfactory
473 execution exit of this pipeline. */
475 stop_pipeline (async
, deferred
)
483 BLOCK_CHILD (set
, oset
);
485 #if defined (PGRP_PIPE)
486 /* The parent closes the process group synchronization pipe. */
487 pipe_close (pgrp_pipe
);
490 cleanup_dead_jobs ();
492 if (js
.j_jobslots
== 0)
494 js
.j_jobslots
= JOB_SLOTS
;
495 jobs
= (JOB
**)xmalloc (js
.j_jobslots
* sizeof (JOB
*));
497 /* Now blank out these new entries. */
498 for (i
= 0; i
< js
.j_jobslots
; i
++)
499 jobs
[i
] = (JOB
*)NULL
;
501 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
504 /* Scan from the last slot backward, looking for the next free one. */
505 /* XXX - revisit this interactive assumption */
506 /* XXX - this way for now */
509 for (i
= js
.j_jobslots
; i
; i
--)
516 /* This wraps around, but makes it inconvenient to extend the array */
517 for (i
= js
.j_lastj
+1; i
!= js
.j_lastj
; i
++)
519 if (i
>= js
.j_jobslots
)
527 /* This doesn't wrap around yet. */
528 for (i
= js
.j_lastj
? js
.j_lastj
+ 1 : js
.j_lastj
; i
< js
.j_jobslots
; i
++)
534 /* Do we need more room? */
536 /* First try compaction */
537 if ((interactive_shell
== 0 || subshell_environment
) && i
== js
.j_jobslots
&& js
.j_jobslots
>= MAX_JOBS_IN_ARRAY
)
538 i
= compact_jobs_list (0);
540 /* If we can't compact, reallocate */
541 if (i
== js
.j_jobslots
)
543 js
.j_jobslots
+= JOB_SLOTS
;
544 jobs
= (JOB
**)xrealloc (jobs
, (js
.j_jobslots
* sizeof (JOB
*)));
546 for (j
= i
; j
< js
.j_jobslots
; j
++)
547 jobs
[j
] = (JOB
*)NULL
;
550 /* Add the current pipeline to the job list. */
554 int any_running
, any_stopped
, n
;
556 newjob
= (JOB
*)xmalloc (sizeof (JOB
));
558 for (n
= 1, p
= the_pipeline
; p
->next
!= the_pipeline
; n
++, p
= p
->next
)
560 p
->next
= (PROCESS
*)NULL
;
561 newjob
->pipe
= REVERSE_LIST (the_pipeline
, PROCESS
*);
562 for (p
= newjob
->pipe
; p
->next
; p
= p
->next
)
564 p
->next
= newjob
->pipe
;
566 the_pipeline
= (PROCESS
*)NULL
;
567 newjob
->pgrp
= pipeline_pgrp
;
572 /* Flag to see if in another pgrp. */
574 newjob
->flags
|= J_JOBCONTROL
;
576 /* Set the state of this pipeline. */
578 any_running
= any_stopped
= 0;
581 any_running
|= PRUNNING (p
);
582 any_stopped
|= PSTOPPED (p
);
585 while (p
!= newjob
->pipe
);
587 newjob
->state
= any_running
? JRUNNING
: (any_stopped
? JSTOPPED
: JDEAD
);
588 newjob
->wd
= job_working_directory ();
589 newjob
->deferred
= deferred
;
591 newjob
->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
592 newjob
->cleanarg
= (PTR_T
) NULL
;
595 if (newjob
->state
== JDEAD
&& (newjob
->flags
& J_FOREGROUND
))
597 if (newjob
->state
== JDEAD
)
599 js
.c_reaped
+= n
; /* wouldn't have been done since this was not part of a job */
608 newjob
= (JOB
*)NULL
;
611 js
.j_lastmade
= newjob
;
617 newjob
->flags
&= ~J_FOREGROUND
;
618 newjob
->flags
|= J_ASYNC
;
619 js
.j_lastasync
= newjob
;
627 newjob
->flags
|= J_FOREGROUND
;
629 * !!!!! NOTE !!!!! (chet@ins.cwru.edu)
631 * The currently-accepted job control wisdom says to set the
632 * terminal's process group n+1 times in an n-step pipeline:
633 * once in the parent and once in each child. This is where
634 * the parent gives it away.
636 * Don't give the terminal away if this shell is an asynchronous
640 if (job_control
&& newjob
->pgrp
&& (subshell_environment
&SUBSHELL_ASYNC
) == 0)
641 give_terminal_to (newjob
->pgrp
, 0);
645 stop_making_children ();
646 UNBLOCK_CHILD (oset
);
647 return (js
.j_current
);
650 /* Functions to manage the list of exited background pids whose status has
653 static struct pidstat
*
654 bgp_alloc (pid
, status
)
660 ps
= (struct pidstat
*)xmalloc (sizeof (struct pidstat
));
663 ps
->next
= (struct pidstat
*)0;
667 static struct pidstat
*
668 bgp_add (pid
, status
)
674 ps
= bgp_alloc (pid
, status
);
676 if (bgpids
.list
== 0)
678 bgpids
.list
= bgpids
.end
= ps
;
679 bgpids
.npid
= 0; /* just to make sure */
683 bgpids
.end
->next
= ps
;
688 if (bgpids
.npid
> js
.c_childmax
)
698 struct pidstat
*prev
, *p
;
700 for (prev
= p
= bgpids
.list
; p
; prev
= p
, p
= p
->next
)
703 prev
->next
= p
->next
; /* remove from list */
708 return 0; /* not found */
711 itrace("bgp_delete: deleting %d", pid
);
714 /* Housekeeping in the border cases. */
715 if (p
== bgpids
.list
)
716 bgpids
.list
= bgpids
.list
->next
;
717 else if (p
== bgpids
.end
)
721 if (bgpids
.npid
== 0)
722 bgpids
.list
= bgpids
.end
= 0;
723 else if (bgpids
.npid
== 1)
724 bgpids
.end
= bgpids
.list
; /* just to make sure */
730 /* Clear out the list of saved statuses */
734 struct pidstat
*ps
, *p
;
736 for (ps
= bgpids
.list
; ps
; )
742 bgpids
.list
= bgpids
.end
= 0;
746 /* Search for PID in the list of saved background pids; return its status if
747 found. If not found, return -1. */
754 for (ps
= bgpids
.list
; ps
; ps
= ps
->next
)
765 while (bgpids
.npid
> js
.c_childmax
)
768 bgpids
.list
= bgpids
.list
->next
;
774 /* Reset the values of js.j_lastj and js.j_firstj after one or both have
775 been deleted. The caller should check whether js.j_njobs is 0 before
776 calling this. This wraps around, but the rest of the code does not. At
777 this point, it should not matter. */
783 if (jobs
[js
.j_firstj
] == 0)
786 if (old
>= js
.j_jobslots
)
787 old
= js
.j_jobslots
- 1;
788 while (js
.j_firstj
!= old
)
790 if (js
.j_firstj
>= js
.j_jobslots
)
792 if (jobs
[js
.j_firstj
] || js
.j_firstj
== old
) /* needed if old == 0 */
796 if (js
.j_firstj
== old
)
797 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
799 if (jobs
[js
.j_lastj
] == 0)
804 while (js
.j_lastj
!= old
)
807 js
.j_lastj
= js
.j_jobslots
- 1;
808 if (jobs
[js
.j_lastj
] || js
.j_lastj
== old
) /* needed if old == js.j_jobslots */
812 if (js
.j_lastj
== old
)
813 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
817 /* Delete all DEAD jobs that the user had received notification about. */
824 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
829 /* XXX could use js.j_firstj and js.j_lastj here */
830 for (i
= 0; i
< js
.j_jobslots
; i
++)
833 if (i
< js
.j_firstj
&& jobs
[i
])
834 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
835 if (i
> js
.j_lastj
&& jobs
[i
])
836 itrace("cleanup_dead_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
839 if (jobs
[i
] && DEADJOB (i
) && IS_NOTIFIED (i
))
846 processes_in_job (job
)
858 while (p
!= jobs
[job
]->pipe
);
870 job
= find_job (pid
, 0, &p
);
874 itrace ("delete_old_job: found pid %d in job %d with state %d", pid
, job
, jobs
[job
]->state
);
876 if (JOBSTATE (job
) == JDEAD
)
877 delete_job (job
, DEL_NOBGPID
);
880 internal_warning (_("forked pid %d appears in running job %d"), pid
, job
);
887 /* Reallocate and compress the jobs list. This returns with a jobs array
888 whose size is a multiple of JOB_SLOTS and can hold the current number of
889 jobs. Heuristics are used to minimize the number of new reallocs. */
894 int nsize
, i
, j
, ncur
, nprev
;
897 ncur
= nprev
= NO_JOB
;
898 nsize
= ((js
.j_njobs
+ JOB_SLOTS
- 1) / JOB_SLOTS
);
900 i
= js
.j_njobs
% JOB_SLOTS
;
901 if (i
== 0 || i
> (JOB_SLOTS
>> 1))
904 BLOCK_CHILD (set
, oset
);
905 nlist
= (js
.j_jobslots
== nsize
) ? jobs
: (JOB
**) xmalloc (nsize
* sizeof (JOB
*));
907 js
.c_reaped
= js
.j_ndead
= 0;
908 for (i
= j
= 0; i
< js
.j_jobslots
; i
++)
911 if (i
== js
.j_current
)
913 if (i
== js
.j_previous
)
915 nlist
[j
++] = jobs
[i
];
916 if (jobs
[i
]->state
== JDEAD
)
919 js
.c_reaped
+= processes_in_job (i
);
924 itrace ("realloc_jobs_list: resize jobs list from %d to %d", js
.j_jobslots
, nsize
);
925 itrace ("realloc_jobs_list: j_lastj changed from %d to %d", js
.j_lastj
, (j
> 0) ? j
- 1 : 0);
926 itrace ("realloc_jobs_list: j_njobs changed from %d to %d", js
.j_njobs
, j
);
927 itrace ("realloc_jobs_list: js.j_ndead %d js.c_reaped %d", js
.j_ndead
, js
.c_reaped
);
931 js
.j_lastj
= (j
> 0) ? j
- 1 : 0;
933 js
.j_jobslots
= nsize
;
935 /* Zero out remaining slots in new jobs list */
936 for ( ; j
< nsize
; j
++)
937 nlist
[j
] = (JOB
*)NULL
;
948 js
.j_previous
= nprev
;
950 /* Need to reset these */
951 if (js
.j_current
== NO_JOB
|| js
.j_previous
== NO_JOB
|| js
.j_current
> js
.j_lastj
|| js
.j_previous
> js
.j_lastj
)
955 itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js
.j_current
, js
.j_previous
);
958 UNBLOCK_CHILD (oset
);
961 /* Compact the jobs list by removing dead jobs. Assumed that we have filled
962 the jobs array to some predefined maximum. Called when the shell is not
963 the foreground process (subshell_environment != 0). Returns the first
964 available slot in the compacted list. If that value is js.j_jobslots, then
965 the list needs to be reallocated. The jobs array may be in new memory if
966 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
968 compact_jobs_list (flags
)
971 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
972 return js
.j_jobslots
;
975 realloc_jobs_list ();
978 itrace("compact_jobs_list: returning %d", (js
.j_lastj
|| jobs
[js
.j_lastj
]) ? js
.j_lastj
+ 1 : 0);
981 return ((js
.j_lastj
|| jobs
[js
.j_lastj
]) ? js
.j_lastj
+ 1 : 0);
984 /* Delete the job at INDEX from the job list. Must be called
985 with SIGCHLD blocked. */
987 delete_job (job_index
, dflags
)
988 int job_index
, dflags
;
994 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
997 if ((dflags
& DEL_WARNSTOPPED
) && subshell_environment
== 0 && STOPPED (job_index
))
998 internal_warning (_("deleting stopped job %d with process group %ld"), job_index
+1, (long)jobs
[job_index
]->pgrp
);
999 temp
= jobs
[job_index
];
1003 if ((dflags
& DEL_NOBGPID
) == 0)
1005 proc
= find_last_proc (job_index
, 0);
1006 /* Could do this just for J_ASYNC jobs, but we save all. */
1008 bgp_add (proc
->pid
, process_exit_status (proc
->status
));
1011 jobs
[job_index
] = (JOB
*)NULL
;
1012 if (temp
== js
.j_lastmade
)
1014 else if (temp
== js
.j_lastasync
)
1018 ndel
= discard_pipeline (temp
->pipe
);
1020 js
.c_injobs
-= ndel
;
1021 if (temp
->state
== JDEAD
)
1023 js
.c_reaped
-= ndel
;
1025 if (js
.c_reaped
< 0)
1028 itrace("delete_job (%d pgrp %d): js.c_reaped (%d) < 0 ndel = %d js.j_ndead = %d", job_index
, temp
->pgrp
, js
.c_reaped
, ndel
, js
.j_ndead
);
1035 dispose_command (temp
->deferred
);
1040 if (js
.j_njobs
== 0)
1041 js
.j_firstj
= js
.j_lastj
= 0;
1042 else if (jobs
[js
.j_firstj
] == 0 || jobs
[js
.j_lastj
] == 0)
1043 reset_job_indices ();
1045 if (job_index
== js
.j_current
|| job_index
== js
.j_previous
)
1049 /* Must be called with SIGCHLD blocked. */
1051 nohup_job (job_index
)
1056 if (js
.j_jobslots
== 0)
1059 if (temp
= jobs
[job_index
])
1060 temp
->flags
|= J_NOHUP
;
1063 /* Get rid of the data structure associated with a process chain. */
1065 discard_pipeline (chain
)
1066 register PROCESS
*chain
;
1068 register PROCESS
*this, *next
;
1076 FREE (this->command
);
1081 while (this != chain
);
1086 /* Add this process to the chain being built in the_pipeline.
1087 NAME is the command string that will be exec'ed later.
1088 PID is the process id of the child. */
1090 add_process (name
, pid
)
1096 #if defined (RECYCLES_PIDS)
1098 p
= find_process (pid
, 0, &j
);
1103 internal_warning (_("add_process: process %5ld (%s) in the_pipeline"), (long)p
->pid
, p
->command
);
1106 internal_warning ("add_process: pid %5ld (%s) marked as still alive", (long)p
->pid
, p
->command
);
1107 p
->running
= PS_RECYCLED
; /* mark as recycled */
1111 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1112 t
->next
= the_pipeline
;
1114 WSTATUS (t
->status
) = 0;
1115 t
->running
= PS_RUNNING
;
1124 while (p
->next
!= t
->next
)
1131 /* Take the last job and make it the first job. Must be called with
1134 rotate_the_pipeline ()
1138 if (the_pipeline
->next
== the_pipeline
)
1140 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1145 /* Reverse the order of the processes in the_pipeline. Must be called with
1148 reverse_the_pipeline ()
1152 if (the_pipeline
->next
== the_pipeline
)
1155 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1157 p
->next
= (PROCESS
*)NULL
;
1159 n
= REVERSE_LIST (the_pipeline
, PROCESS
*);
1162 for (p
= the_pipeline
; p
->next
; p
= p
->next
)
1164 p
->next
= the_pipeline
;
1168 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
1169 then it is time to stop mapping, and that is the return value
1170 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
1173 map_over_jobs (func
, arg1
, arg2
)
1174 sh_job_map_func_t
*func
;
1181 if (js
.j_jobslots
== 0)
1184 BLOCK_CHILD (set
, oset
);
1186 /* XXX could use js.j_firstj here */
1187 for (i
= result
= 0; i
< js
.j_jobslots
; i
++)
1190 if (i
< js
.j_firstj
&& jobs
[i
])
1191 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1192 if (i
> js
.j_lastj
&& jobs
[i
])
1193 itrace("map_over_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1197 result
= (*func
)(jobs
[i
], arg1
, arg2
, i
);
1203 UNBLOCK_CHILD (oset
);
1208 /* Cause all the jobs in the current pipeline to exit. */
1210 terminate_current_pipeline ()
1212 if (pipeline_pgrp
&& pipeline_pgrp
!= shell_pgrp
)
1214 killpg (pipeline_pgrp
, SIGTERM
);
1215 killpg (pipeline_pgrp
, SIGCONT
);
1219 /* Cause all stopped jobs to exit. */
1221 terminate_stopped_jobs ()
1225 /* XXX could use js.j_firstj here */
1226 for (i
= 0; i
< js
.j_jobslots
; i
++)
1228 if (jobs
[i
] && STOPPED (i
))
1230 killpg (jobs
[i
]->pgrp
, SIGTERM
);
1231 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1236 /* Cause all jobs, running or stopped, to receive a hangup signal. If
1237 a job is marked J_NOHUP, don't send the SIGHUP. */
1243 /* XXX could use js.j_firstj here */
1244 for (i
= 0; i
< js
.j_jobslots
; i
++)
1248 if (jobs
[i
]->flags
& J_NOHUP
)
1250 killpg (jobs
[i
]->pgrp
, SIGHUP
);
1252 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1258 kill_current_pipeline ()
1260 stop_making_children ();
1264 /* Return the pipeline that PID belongs to. Note that the pipeline
1265 doesn't have to belong to a job. Must be called with SIGCHLD blocked.
1266 If JOBP is non-null, return the index of the job containing PID. */
1268 find_pipeline (pid
, alive_only
, jobp
)
1271 int *jobp
; /* index into jobs list or NO_JOB */
1276 /* See if this process is in the pipeline that we are building. */
1284 /* Return it if we found it. Don't ever return a recycled pid. */
1285 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1290 while (p
!= the_pipeline
);
1293 job
= find_job (pid
, alive_only
, &p
);
1296 return (job
== NO_JOB
) ? (PROCESS
*)NULL
: jobs
[job
]->pipe
;
1299 /* Return the PROCESS * describing PID. If JOBP is non-null return the index
1300 into the jobs array of the job containing PID. Must be called with
1303 find_process (pid
, alive_only
, jobp
)
1306 int *jobp
; /* index into jobs list or NO_JOB */
1310 p
= find_pipeline (pid
, alive_only
, jobp
);
1311 while (p
&& p
->pid
!= pid
)
1316 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1317 belong to any job. Must be called with SIGCHLD blocked. */
1319 find_job (pid
, alive_only
, procp
)
1327 /* XXX could use js.j_firstj here, and should check js.j_lastj */
1328 for (i
= 0; i
< js
.j_jobslots
; i
++)
1331 if (i
< js
.j_firstj
&& jobs
[i
])
1332 itrace("find_job: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1333 if (i
> js
.j_lastj
&& jobs
[i
])
1334 itrace("find_job: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1342 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1351 while (p
!= jobs
[i
]->pipe
);
1358 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1359 required by find_job. */
1361 get_job_by_pid (pid
, block
)
1369 BLOCK_CHILD (set
, oset
);
1371 job
= find_job (pid
, 0, NULL
);
1374 UNBLOCK_CHILD (oset
);
1379 /* Print descriptive information about the job with leader pid PID. */
1387 BLOCK_CHILD (set
, oset
);
1389 job
= find_job (pid
, 0, NULL
);
1392 fprintf (stderr
, "[%d] %ld\n", job
+ 1, (long)pid
);
1394 programming_error (_("describe_pid: %ld: no such pid"), (long)pid
);
1396 UNBLOCK_CHILD (oset
);
1408 x
= retcode_name_buffer
;
1409 sprintf (x
, _("Signal %d"), s
);
1415 printable_job_status (j
, p
, format
)
1425 if (STOPPED (j
) && format
== 0)
1427 if (posixly_correct
== 0 || p
== 0 || (WIFSTOPPED (p
->status
) == 0))
1428 temp
= _("Stopped");
1431 temp
= retcode_name_buffer
;
1432 sprintf (temp
, _("Stopped(%s)"), signal_name (WSTOPSIG (p
->status
)));
1435 else if (RUNNING (j
))
1436 temp
= _("Running");
1439 if (WIFSTOPPED (p
->status
))
1440 temp
= j_strsignal (WSTOPSIG (p
->status
));
1441 else if (WIFSIGNALED (p
->status
))
1442 temp
= j_strsignal (WTERMSIG (p
->status
));
1443 else if (WIFEXITED (p
->status
))
1445 temp
= retcode_name_buffer
;
1446 es
= WEXITSTATUS (p
->status
);
1448 strcpy (temp
, _("Done"));
1449 else if (posixly_correct
)
1450 sprintf (temp
, _("Done(%d)"), es
);
1452 sprintf (temp
, _("Exit %d"), es
);
1455 temp
= _("Unknown status");
1461 /* This is the way to print out information on a job if you
1462 know the index. FORMAT is:
1464 JLIST_NORMAL) [1]+ Running emacs
1465 JLIST_LONG ) [1]+ 2378 Running emacs
1466 -1 ) [1]+ 2378 emacs
1468 JLIST_NORMAL) [1]+ Stopped ls | more
1469 JLIST_LONG ) [1]+ 2369 Stopped ls
1472 Just list the pid of the process group leader (really
1475 Use format JLIST_NORMAL, but list only jobs about which
1476 the user has not been notified. */
1478 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1479 the JOBS array corresponding to this pipeline. FORMAT is as described
1480 above. Must be called with SIGCHLD blocked.
1482 If you're printing a pipeline that's not in the jobs array, like the
1483 current pipeline as it's being created, pass -1 for JOB_INDEX */
1485 print_pipeline (p
, job_index
, format
, stream
)
1487 int job_index
, format
;
1490 PROCESS
*first
, *last
, *show
;
1491 int es
, name_padding
;
1498 while (last
->next
!= first
)
1504 fprintf (stream
, format
? " " : " |");
1506 if (format
!= JLIST_STANDARD
)
1507 fprintf (stream
, "%5ld", (long)p
->pid
);
1509 fprintf (stream
, " ");
1511 if (format
> -1 && job_index
>= 0)
1513 show
= format
? p
: last
;
1514 temp
= printable_job_status (job_index
, show
, format
);
1520 if (show
->running
== first
->running
&&
1521 WSTATUS (show
->status
) == WSTATUS (first
->status
))
1525 temp
= (char *)NULL
;
1530 fprintf (stream
, "%s", temp
);
1534 es
= 2; /* strlen ("| ") */
1535 name_padding
= LONGEST_SIGNAL_DESC
- es
;
1537 fprintf (stream
, "%*s", name_padding
, "");
1539 if ((WIFSTOPPED (show
->status
) == 0) &&
1540 (WIFCONTINUED (show
->status
) == 0) &&
1541 WIFCORED (show
->status
))
1542 fprintf (stream
, _("(core dumped) "));
1546 if (p
!= first
&& format
)
1547 fprintf (stream
, "| ");
1550 fprintf (stream
, "%s", p
->command
);
1552 if (p
== last
&& job_index
>= 0)
1554 temp
= current_working_directory ();
1556 if (RUNNING (job_index
) && (IS_FOREGROUND (job_index
) == 0))
1557 fprintf (stream
, " &");
1559 if (strcmp (temp
, jobs
[job_index
]->wd
) != 0)
1561 _(" (wd: %s)"), polite_directory_format (jobs
[job_index
]->wd
));
1564 if (format
|| (p
== last
))
1566 /* We need to add a CR only if this is an interactive shell, and
1567 we're reporting the status of a completed job asynchronously.
1568 We can't really check whether this particular job is being
1569 reported asynchronously, so just add the CR if the shell is
1570 currently interactive and asynchronous notification is enabled. */
1571 if (asynchronous_notification
&& interactive
)
1572 fprintf (stream
, "\r\n");
1574 fprintf (stream
, "\n");
1584 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1585 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1587 pretty_print_job (job_index
, format
, stream
)
1588 int job_index
, format
;
1591 register PROCESS
*p
;
1593 /* Format only pid information about the process group leader? */
1594 if (format
== JLIST_PID_ONLY
)
1596 fprintf (stream
, "%ld\n", (long)jobs
[job_index
]->pipe
->pid
);
1600 if (format
== JLIST_CHANGED_ONLY
)
1602 if (IS_NOTIFIED (job_index
))
1604 format
= JLIST_STANDARD
;
1607 if (format
!= JLIST_NONINTERACTIVE
)
1608 fprintf (stream
, "[%d]%c ", job_index
+ 1,
1609 (job_index
== js
.j_current
) ? '+':
1610 (job_index
== js
.j_previous
) ? '-' : ' ');
1612 if (format
== JLIST_NONINTERACTIVE
)
1613 format
= JLIST_LONG
;
1615 p
= jobs
[job_index
]->pipe
;
1617 print_pipeline (p
, job_index
, format
, stream
);
1619 /* We have printed information about this job. When the job's
1620 status changes, waitchld () sets the notification flag to 0. */
1621 jobs
[job_index
]->flags
|= J_NOTIFIED
;
1625 print_job (job
, format
, state
, job_index
)
1627 int format
, state
, job_index
;
1629 if (state
== -1 || (JOB_STATE
)state
== job
->state
)
1630 pretty_print_job (job_index
, format
, stdout
);
1635 list_one_job (job
, format
, ignore
, job_index
)
1637 int format
, ignore
, job_index
;
1639 pretty_print_job (job_index
, format
, stdout
);
1643 list_stopped_jobs (format
)
1646 cleanup_dead_jobs ();
1647 map_over_jobs (print_job
, format
, (int)JSTOPPED
);
1651 list_running_jobs (format
)
1654 cleanup_dead_jobs ();
1655 map_over_jobs (print_job
, format
, (int)JRUNNING
);
1658 /* List jobs. If FORMAT is non-zero, then the long form of the information
1659 is printed, else just a short version. */
1661 list_all_jobs (format
)
1664 cleanup_dead_jobs ();
1665 map_over_jobs (print_job
, format
, -1);
1668 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1669 COMMAND is just for remembering the name of the command; we don't do
1670 anything else with it. ASYNC_P says what to do with the tty. If
1671 non-zero, then don't give it away. */
1673 make_child (command
, async_p
)
1681 sigaddset (&set
, SIGCHLD
);
1682 sigaddset (&set
, SIGINT
);
1683 sigemptyset (&oset
);
1684 sigprocmask (SIG_BLOCK
, &set
, &oset
);
1688 #if defined (BUFFERED_INPUT)
1689 /* If default_buffered_input is active, we are reading a script. If
1690 the command is asynchronous, we have already duplicated /dev/null
1691 as fd 0, but have not changed the buffered stream corresponding to
1692 the old fd 0. We don't want to sync the stream in this case. */
1693 if (default_buffered_input
!= -1 &&
1694 (!async_p
|| default_buffered_input
> 0))
1695 sync_buffered_stream (default_buffered_input
);
1696 #endif /* BUFFERED_INPUT */
1698 /* Create the child, handle severe errors. */
1699 if ((pid
= fork ()) < 0)
1703 /* Kill all of the processes in the current pipeline. */
1704 terminate_current_pipeline ();
1706 /* Discard the current pipeline, if any. */
1708 kill_current_pipeline ();
1710 throw_to_top_level (); /* Reset signals, etc. */
1715 /* In the child. Give this child the right process group, set the
1716 signals to the default state for a new process. */
1720 #if defined (BUFFERED_INPUT)
1721 /* Close default_buffered_input if it's > 0. We don't close it if it's
1722 0 because that's the file descriptor used when redirecting input,
1723 and it's wrong to close the file in that case. */
1724 unset_bash_input (0);
1725 #endif /* BUFFERED_INPUT */
1727 /* Restore top-level signal mask. */
1728 sigprocmask (SIG_SETMASK
, &top_level_mask
, (sigset_t
*)NULL
);
1732 /* All processes in this pipeline belong in the same
1735 if (pipeline_pgrp
== 0) /* This is the first child. */
1736 pipeline_pgrp
= mypid
;
1738 /* Check for running command in backquotes. */
1739 if (pipeline_pgrp
== shell_pgrp
)
1740 ignore_tty_job_signals ();
1742 default_tty_job_signals ();
1744 /* Set the process group before trying to mess with the terminal's
1745 process group. This is mandated by POSIX. */
1746 /* This is in accordance with the Posix 1003.1 standard,
1747 section B.7.2.4, which says that trying to set the terminal
1748 process group with tcsetpgrp() to an unused pgrp value (like
1749 this would have for the first child) is an error. Section
1750 B.4.3.3, p. 237 also covers this, in the context of job control
1752 if (setpgid (mypid
, pipeline_pgrp
) < 0)
1753 sys_error (_("child setpgid (%ld to %ld)"), (long)mypid
, (long)pipeline_pgrp
);
1755 /* By convention (and assumption above), if
1756 pipeline_pgrp == shell_pgrp, we are making a child for
1757 command substitution.
1758 In this case, we don't want to give the terminal to the
1759 shell's process group (we could be in the middle of a
1760 pipeline, for example). */
1761 if (async_p
== 0 && pipeline_pgrp
!= shell_pgrp
&& ((subshell_environment
&SUBSHELL_ASYNC
) == 0))
1762 give_terminal_to (pipeline_pgrp
, 0);
1764 #if defined (PGRP_PIPE)
1765 if (pipeline_pgrp
== mypid
)
1766 pipe_read (pgrp_pipe
);
1769 else /* Without job control... */
1771 if (pipeline_pgrp
== 0)
1772 pipeline_pgrp
= shell_pgrp
;
1774 /* If these signals are set to SIG_DFL, we encounter the curious
1775 situation of an interactive ^Z to a running process *working*
1776 and stopping the process, but being unable to do anything with
1777 that process to change its state. On the other hand, if they
1778 are set to SIG_IGN, jobs started from scripts do not stop when
1779 the shell running the script gets a SIGTSTP and stops. */
1781 default_tty_job_signals ();
1784 #if defined (PGRP_PIPE)
1785 /* Release the process group pipe, since our call to setpgid ()
1786 is done. The last call to pipe_close is done in stop_pipeline. */
1787 pipe_close (pgrp_pipe
);
1788 #endif /* PGRP_PIPE */
1792 last_asynchronous_pid
= mypid
; /* XXX */
1794 #if defined (RECYCLES_PIDS)
1795 else if (last_asynchronous_pid
== mypid
)
1796 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1797 last_asynchronous_pid
= 1;
1802 /* In the parent. Remember the pid of the child just created
1803 as the proper pgrp if this is the first child. */
1805 if (first_pid
== NO_PID
)
1807 else if (pid_wrap
== -1 && pid
< first_pid
)
1809 else if (pid_wrap
== 0 && pid
>= first_pid
)
1814 if (pipeline_pgrp
== 0)
1816 pipeline_pgrp
= pid
;
1817 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1818 not the good thing of twiddling them in the child! */
1819 /* give_terminal_to (pipeline_pgrp, 0); */
1821 /* This is done on the recommendation of the Rationale section of
1822 the POSIX 1003.1 standard, where it discusses job control and
1823 shells. It is done to avoid possible race conditions. (Ref.
1824 1003.1 Rationale, section B.4.3.3, page 236). */
1825 setpgid (pid
, pipeline_pgrp
);
1829 if (pipeline_pgrp
== 0)
1830 pipeline_pgrp
= shell_pgrp
;
1833 /* Place all processes into the jobs array regardless of the
1834 state of job_control. */
1835 add_process (command
, pid
);
1838 last_asynchronous_pid
= pid
;
1839 #if defined (RECYCLES_PIDS)
1840 else if (last_asynchronous_pid
== pid
)
1841 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1842 last_asynchronous_pid
= 1;
1846 delete_old_job (pid
);
1848 #if !defined (RECYCLES_PIDS)
1849 /* Only check for saved status if we've saved more than CHILD_MAX
1850 statuses, unless the system recycles pids. */
1851 if ((js
.c_reaped
+ bgpids
.npid
) >= js
.c_childmax
)
1853 bgp_delete (pid
); /* new process, discard any saved status */
1855 last_made_pid
= pid
;
1861 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1862 SIGCHLD remains blocked until all commands in the pipeline have been
1864 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
1870 /* These two functions are called only in child processes. */
1872 ignore_tty_job_signals ()
1874 set_signal_handler (SIGTSTP
, SIG_IGN
);
1875 set_signal_handler (SIGTTIN
, SIG_IGN
);
1876 set_signal_handler (SIGTTOU
, SIG_IGN
);
1880 default_tty_job_signals ()
1882 set_signal_handler (SIGTSTP
, SIG_DFL
);
1883 set_signal_handler (SIGTTIN
, SIG_DFL
);
1884 set_signal_handler (SIGTTOU
, SIG_DFL
);
1887 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1888 state kept in here. When a job ends normally, we set the state in here
1889 to the state of the tty. */
1891 static TTYSTRUCT shell_tty_info
;
1893 #if defined (NEW_TTY_DRIVER)
1894 static struct tchars shell_tchars
;
1895 static struct ltchars shell_ltchars
;
1896 #endif /* NEW_TTY_DRIVER */
1898 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1899 /* Since the BSD tty driver does not allow us to change the tty modes
1900 while simultaneously waiting for output to drain and preserving
1901 typeahead, we have to drain the output ourselves before calling
1902 ioctl. We cheat by finding the length of the output queue, and
1903 using select to wait for an appropriate length of time. This is
1904 a hack, and should be labeled as such (it's a hastily-adapted
1905 mutation of a `usleep' implementation). It's only reason for
1906 existing is the flaw in the BSD tty driver. */
1908 static int ttspeeds
[] =
1910 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1911 1800, 2400, 4800, 9600, 19200, 38400
1918 register int delay
= ttspeeds
[ospeed
];
1924 while ((ioctl (fd
, TIOCOUTQ
, &n
) == 0) && n
)
1926 if (n
> (delay
/ 100))
1930 n
*= 10; /* 2 bits more for conservativeness. */
1931 tv
.tv_sec
= n
/ delay
;
1932 tv
.tv_usec
= ((n
% delay
) * 1000000) / delay
;
1933 select (fd
, (fd_set
*)0, (fd_set
*)0, (fd_set
*)0, &tv
);
1939 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1941 /* Return the fd from which we are actually getting input. */
1942 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
1944 /* Fill the contents of shell_tty_info with the current tty info. */
1953 #if defined (NEW_TTY_DRIVER)
1954 ioctl (tty
, TIOCGETP
, &shell_tty_info
);
1955 ioctl (tty
, TIOCGETC
, &shell_tchars
);
1956 ioctl (tty
, TIOCGLTC
, &shell_ltchars
);
1957 #endif /* NEW_TTY_DRIVER */
1959 #if defined (TERMIO_TTY_DRIVER)
1960 ioctl (tty
, TCGETA
, &shell_tty_info
);
1961 #endif /* TERMIO_TTY_DRIVER */
1963 #if defined (TERMIOS_TTY_DRIVER)
1964 if (tcgetattr (tty
, &shell_tty_info
) < 0)
1967 /* Only print an error message if we're really interactive at
1970 sys_error ("[%ld: %d (%d)] tcgetattr", (long)getpid (), shell_level
, tty
);
1974 #endif /* TERMIOS_TTY_DRIVER */
1975 if (check_window_size
)
1976 get_new_window_size (0, (int *)0, (int *)0);
1981 /* Make the current tty use the state in shell_tty_info. */
1990 #if defined (NEW_TTY_DRIVER)
1991 # if defined (DRAIN_OUTPUT)
1992 draino (tty
, shell_tty_info
.sg_ospeed
);
1993 # endif /* DRAIN_OUTPUT */
1994 ioctl (tty
, TIOCSETN
, &shell_tty_info
);
1995 ioctl (tty
, TIOCSETC
, &shell_tchars
);
1996 ioctl (tty
, TIOCSLTC
, &shell_ltchars
);
1997 #endif /* NEW_TTY_DRIVER */
1999 #if defined (TERMIO_TTY_DRIVER)
2000 ioctl (tty
, TCSETAW
, &shell_tty_info
);
2001 #endif /* TERMIO_TTY_DRIVER */
2003 #if defined (TERMIOS_TTY_DRIVER)
2004 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
2006 /* Only print an error message if we're really interactive at
2009 sys_error ("[%ld: %d (%d)] tcsetattr", (long)getpid (), shell_level
, tty
);
2012 #endif /* TERMIOS_TTY_DRIVER */
2017 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
2018 process in that job's pipeline. This is the one whose exit status
2019 counts. Must be called with SIGCHLD blocked or queued. */
2021 find_last_proc (job
, block
)
2025 register PROCESS
*p
;
2029 BLOCK_CHILD (set
, oset
);
2031 p
= jobs
[job
]->pipe
;
2032 while (p
&& p
->next
!= jobs
[job
]->pipe
)
2036 UNBLOCK_CHILD (oset
);
2042 find_last_pid (job
, block
)
2048 p
= find_last_proc (job
, block
);
2049 /* Possible race condition here. */
2053 /* Wait for a particular child of the shell to finish executing.
2054 This low-level function prints an error message if PID is not
2055 a child of this shell. It returns -1 if it fails, or whatever
2056 wait_for returns otherwise. If the child is not found in the
2057 jobs table, it returns 127. */
2059 wait_for_single_pid (pid
)
2062 register PROCESS
*child
;
2066 BLOCK_CHILD (set
, oset
);
2067 child
= find_pipeline (pid
, 0, (int *)NULL
);
2068 UNBLOCK_CHILD (oset
);
2072 r
= bgp_search (pid
);
2079 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid
);
2085 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
2087 BLOCK_CHILD (set
, oset
);
2088 job
= find_job (pid
, 0, NULL
);
2089 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2090 jobs
[job
]->flags
|= J_NOTIFIED
;
2091 UNBLOCK_CHILD (oset
);
2093 /* If running in posix mode, remove the job from the jobs table immediately */
2094 if (posixly_correct
)
2096 cleanup_dead_jobs ();
2103 /* Wait for all of the backgrounds of this shell to finish. */
2105 wait_for_background_pids ()
2107 register int i
, r
, waited_for
;
2111 for (waited_for
= 0;;)
2113 BLOCK_CHILD (set
, oset
);
2115 /* find first running job; if none running in foreground, break */
2116 /* XXX could use js.j_firstj and js.j_lastj here */
2117 for (i
= 0; i
< js
.j_jobslots
; i
++)
2120 if (i
< js
.j_firstj
&& jobs
[i
])
2121 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
2122 if (i
> js
.j_lastj
&& jobs
[i
])
2123 itrace("wait_for_background_pids: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
2125 if (jobs
[i
] && RUNNING (i
) && IS_FOREGROUND (i
) == 0)
2128 if (i
== js
.j_jobslots
)
2130 UNBLOCK_CHILD (oset
);
2134 /* now wait for the last pid in that job. */
2135 pid
= find_last_pid (i
, 0);
2136 UNBLOCK_CHILD (oset
);
2138 errno
= 0; /* XXX */
2139 r
= wait_for_single_pid (pid
);
2142 /* If we're mistaken about job state, compensate. */
2143 if (errno
== ECHILD
)
2144 mark_all_jobs_as_dead ();
2150 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2151 `wait' is called with no arguments. */
2152 mark_dead_jobs_as_notified (1);
2153 cleanup_dead_jobs ();
2157 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2158 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2159 static SigHandler
*old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2162 restore_sigint_handler ()
2164 if (old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
2166 set_signal_handler (SIGINT
, old_sigint_handler
);
2167 old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2171 static int wait_sigint_received
;
2173 /* Handle SIGINT while we are waiting for children in a script to exit.
2174 The `wait' builtin should be interruptible, but all others should be
2175 effectively ignored (i.e. not cause the shell to exit). */
2177 wait_sigint_handler (sig
)
2180 SigHandler
*sigint_handler
;
2182 if (interrupt_immediately
||
2183 (this_shell_builtin
&& this_shell_builtin
== wait_builtin
))
2185 last_command_exit_value
= EXECUTION_FAILURE
;
2186 restore_sigint_handler ();
2187 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2188 what POSIX.2 says (see builtins/wait.def for more info). */
2189 if (this_shell_builtin
&& this_shell_builtin
== wait_builtin
&&
2190 signal_is_trapped (SIGINT
) &&
2191 ((sigint_handler
= trap_to_sighandler (SIGINT
)) == trap_handler
))
2193 interrupt_immediately
= 0;
2194 trap_handler (SIGINT
); /* set pending_traps[SIGINT] */
2195 wait_signal_received
= SIGINT
;
2196 longjmp (wait_intr_buf
, 1);
2203 /* XXX - should this be interrupt_state? If it is, the shell will act
2204 as if it got the SIGINT interrupt. */
2205 wait_sigint_received
= 1;
2207 /* Otherwise effectively ignore the SIGINT and allow the running job to
2213 process_exit_signal (status
)
2216 return (WIFSIGNALED (status
) ? WTERMSIG (status
) : 0);
2220 process_exit_status (status
)
2223 if (WIFSIGNALED (status
))
2224 return (128 + WTERMSIG (status
));
2225 else if (WIFSTOPPED (status
) == 0)
2226 return (WEXITSTATUS (status
));
2228 return (EXECUTION_SUCCESS
);
2231 /* Return the exit status of the last process in the pipeline for job JOB.
2232 This is the exit status of the entire job. */
2234 raw_job_exit_status (job
)
2237 register PROCESS
*p
;
2243 p
= jobs
[job
]->pipe
;
2246 if (WSTATUS (p
->status
) != EXECUTION_SUCCESS
) fail
= WSTATUS(p
->status
);
2249 while (p
!= jobs
[job
]->pipe
);
2253 for (p
= jobs
[job
]->pipe
; p
->next
!= jobs
[job
]->pipe
; p
= p
->next
)
2258 /* Return the exit status of job JOB. This is the exit status of the last
2259 (rightmost) process in the job's pipeline, modified if the job was killed
2260 by a signal or stopped. */
2262 job_exit_status (job
)
2265 return (process_exit_status (raw_job_exit_status (job
)));
2269 job_exit_signal (job
)
2272 return (process_exit_signal (raw_job_exit_status (job
)));
2275 #define FIND_CHILD(pid, child) \
2278 child = find_pipeline (pid, 0, (int *)NULL); \
2281 give_terminal_to (shell_pgrp, 0); \
2282 UNBLOCK_CHILD (oset); \
2283 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2284 restore_sigint_handler (); \
2285 return (termination_state = 127); \
2290 /* Wait for pid (one of our children) to terminate, then
2291 return the termination state. Returns 127 if PID is not found in
2292 the jobs table. Returns -1 if waitchld() returns -1, indicating
2293 that there are no unwaited-for child processes. */
2298 int job
, termination_state
, r
;
2300 register PROCESS
*child
;
2302 register PROCESS
*p
;
2304 /* In the case that this code is interrupted, and we longjmp () out of it,
2305 we are relying on the code in throw_to_top_level () to restore the
2306 top-level signal mask. */
2307 BLOCK_CHILD (set
, oset
);
2309 /* Ignore interrupts while waiting for a job run without job control
2310 to finish. We don't want the shell to exit if an interrupt is
2311 received, only if one of the jobs run is killed via SIGINT. If
2312 job control is not set, the job will be run in the same pgrp as
2313 the shell, and the shell will see any signals the job gets. */
2315 /* This is possibly a race condition -- should it go in stop_pipeline? */
2316 wait_sigint_received
= 0;
2317 if (job_control
== 0)
2319 old_sigint_handler
= set_signal_handler (SIGINT
, wait_sigint_handler
);
2320 if (old_sigint_handler
== SIG_IGN
)
2321 set_signal_handler (SIGINT
, old_sigint_handler
);
2324 termination_state
= last_command_exit_value
;
2326 if (interactive
&& job_control
== 0)
2329 /* If we say wait_for (), then we have a record of this child somewhere.
2330 If it and none of its peers are running, don't call waitchld(). */
2335 FIND_CHILD (pid
, child
);
2337 /* If this child is part of a job, then we are really waiting for the
2338 job to finish. Otherwise, we are waiting for the child to finish.
2339 We check for JDEAD in case the job state has been set by waitchld
2340 after receipt of a SIGCHLD. */
2342 job
= find_job (pid
, 0, NULL
);
2344 /* waitchld() takes care of setting the state of the job. If the job
2345 has already exited before this is called, sigchld_handler will have
2346 called waitchld and the state will be set to JDEAD. */
2348 if (PRUNNING(child
) || (job
!= NO_JOB
&& RUNNING (job
)))
2350 #if defined (WAITPID_BROKEN) /* SCOv4 */
2351 sigset_t suspend_set
;
2352 sigemptyset (&suspend_set
);
2353 sigsuspend (&suspend_set
);
2354 #else /* !WAITPID_BROKEN */
2355 # if defined (MUST_UNBLOCK_CHLD)
2356 struct sigaction act
, oact
;
2357 sigset_t nullset
, chldset
;
2359 sigemptyset (&nullset
);
2360 sigemptyset (&chldset
);
2361 sigprocmask (SIG_SETMASK
, &nullset
, &chldset
);
2362 act
.sa_handler
= SIG_DFL
;
2363 sigemptyset (&act
.sa_mask
);
2364 sigemptyset (&oact
.sa_mask
);
2366 sigaction (SIGCHLD
, &act
, &oact
);
2369 r
= waitchld (pid
, 1);
2370 # if defined (MUST_UNBLOCK_CHLD)
2371 sigaction (SIGCHLD
, &oact
, (struct sigaction
*)NULL
);
2372 sigprocmask (SIG_SETMASK
, &chldset
, (sigset_t
*)NULL
);
2375 if (r
== -1 && errno
== ECHILD
&& this_shell_builtin
== wait_builtin
)
2377 termination_state
= -1;
2378 goto wait_for_return
;
2381 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2382 there is something wrong. Somewhere, wait should have returned
2383 that child's pid. Mark the child as not running and the job,
2384 if it exists, as JDEAD. */
2385 if (r
== -1 && errno
== ECHILD
)
2387 child
->running
= PS_DONE
;
2388 WSTATUS (child
->status
) = 0; /* XXX -- can't find true status */
2389 js
.c_living
= 0; /* no living child processes */
2392 jobs
[job
]->state
= JDEAD
;
2397 #endif /* WAITPID_BROKEN */
2400 /* If the shell is interactive, and job control is disabled, see
2401 if the foreground process has died due to SIGINT and jump out
2402 of the wait loop if it has. waitchld has already restored the
2403 old SIGINT signal handler. */
2404 if (interactive
&& job_control
== 0)
2407 while (PRUNNING (child
) || (job
!= NO_JOB
&& RUNNING (job
)));
2409 /* The exit state of the command is either the termination state of the
2410 child, or the termination state of the job. If a job, the status
2411 of the last child in the pipeline is the significant one. If the command
2412 or job was terminated by a signal, note that value also. */
2413 termination_state
= (job
!= NO_JOB
) ? job_exit_status (job
)
2414 : process_exit_status (child
->status
);
2415 last_command_exit_signal
= (job
!= NO_JOB
) ? job_exit_signal (job
)
2416 : process_exit_signal (child
->status
);
2419 if ((job
!= NO_JOB
&& JOBSTATE (job
) == JSTOPPED
) || WIFSTOPPED (child
->status
))
2420 termination_state
= 128 + WSTOPSIG (child
->status
);
2422 if (job
== NO_JOB
|| IS_JOBCONTROL (job
))
2424 /* XXX - under what circumstances is a job not present in the jobs
2425 table (job == NO_JOB)?
2426 1. command substitution
2428 In the case of command substitution, at least, it's probably not
2429 the right thing to give the terminal to the shell's process group,
2430 even though there is code in subst.c:command_substitute to work
2434 $PROMPT_COMMAND execution
2435 process substitution
2439 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp
);
2441 give_terminal_to (shell_pgrp
, 0);
2444 /* If the command did not exit cleanly, or the job is just
2445 being stopped, then reset the tty state back to what it
2446 was before this command. Reset the tty state and notify
2447 the user of the job termination only if the shell is
2448 interactive. Clean up any dead jobs in either case. */
2451 if (interactive_shell
&& subshell_environment
== 0)
2453 /* This used to use `child->status'. That's wrong, however, for
2454 pipelines. `child' is the first process in the pipeline. It's
2455 likely that the process we want to check for abnormal termination
2456 or stopping is the last process in the pipeline, especially if
2457 it's long-lived and the first process is short-lived. Since we
2458 know we have a job here, we can check all the processes in this
2459 job's pipeline and see if one of them stopped or terminated due
2460 to a signal. We might want to change this later to just check
2461 the last process in the pipeline. If no process exits due to a
2462 signal, S is left as the status of the last job in the pipeline. */
2463 p
= jobs
[job
]->pipe
;
2467 if (WIFSIGNALED(s
) || WIFSTOPPED(s
))
2471 while (p
!= jobs
[job
]->pipe
);
2473 if (WIFSIGNALED (s
) || WIFSTOPPED (s
))
2477 /* If the current job was stopped or killed by a signal, and
2478 the user has requested it, get a possibly new window size */
2479 if (check_window_size
&& (job
== js
.j_current
|| IS_FOREGROUND (job
)))
2480 get_new_window_size (0, (int *)0, (int *)0);
2485 /* If job control is enabled, the job was started with job
2486 control, the job was the foreground job, and it was killed
2487 by SIGINT, then print a newline to compensate for the kernel
2488 printing the ^C without a trailing newline. */
2489 if (job_control
&& IS_JOBCONTROL (job
) && IS_FOREGROUND (job
) &&
2490 WIFSIGNALED (s
) && WTERMSIG (s
) == SIGINT
)
2492 /* If SIGINT is not trapped and the shell is in a for, while,
2493 or until loop, act as if the shell received SIGINT as
2494 well, so the loop can be broken. This doesn't call the
2495 SIGINT signal handler; maybe it should. */
2496 if (signal_is_trapped (SIGINT
) == 0 && loop_level
)
2506 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2507 signal handler path */
2508 if (DEADJOB (job
) && IS_FOREGROUND (job
) /*&& subshell_environment == 0*/)
2511 /* If this job is dead, notify the user of the status. If the shell
2512 is interactive, this will display a message on the terminal. If
2513 the shell is not interactive, make sure we turn on the notify bit
2514 so we don't get an unwanted message about the job's termination,
2515 and so delete_job really clears the slot in the jobs table. */
2516 notify_and_cleanup ();
2521 UNBLOCK_CHILD (oset
);
2523 /* Restore the original SIGINT signal handler before we return. */
2524 restore_sigint_handler ();
2526 return (termination_state
);
2529 /* Wait for the last process in the pipeline for JOB. Returns whatever
2530 wait_for returns: the last process's termination state or -1 if there
2531 are no unwaited-for child processes or an error occurs. */
2540 BLOCK_CHILD(set
, oset
);
2541 if (JOBSTATE (job
) == JSTOPPED
)
2542 internal_warning (_("wait_for_job: job %d is stopped"), job
+1);
2544 pid
= find_last_pid (job
, 0);
2545 UNBLOCK_CHILD(oset
);
2548 /* POSIX.2: we can remove the job from the jobs table if we just waited
2550 BLOCK_CHILD (set
, oset
);
2551 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2552 jobs
[job
]->flags
|= J_NOTIFIED
;
2553 UNBLOCK_CHILD (oset
);
2558 /* Print info about dead jobs, and then delete them from the list
2559 of known jobs. This does not actually delete jobs when the
2560 shell is not interactive, because the dead jobs are not marked
2563 notify_and_cleanup ()
2565 if (jobs_list_frozen
)
2568 if (interactive
|| interactive_shell
== 0 || sourcelevel
)
2569 notify_of_job_status ();
2571 cleanup_dead_jobs ();
2574 /* Make dead jobs disappear from the jobs array without notification.
2575 This is used when the shell is not interactive. */
2579 mark_dead_jobs_as_notified (0);
2580 cleanup_dead_jobs ();
2583 /* Return the next closest (chronologically) job to JOB which is in
2584 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2585 there is no next recent job. */
2587 most_recent_job_in_state (job
, state
)
2591 register int i
, result
;
2594 BLOCK_CHILD (set
, oset
);
2596 for (result
= NO_JOB
, i
= job
- 1; i
>= 0; i
--)
2598 if (jobs
[i
] && (JOBSTATE (i
) == state
))
2605 UNBLOCK_CHILD (oset
);
2610 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2613 job_last_stopped (job
)
2616 return (most_recent_job_in_state (job
, JSTOPPED
));
2619 /* Return the newest *running* job older than JOB, or NO_JOB if not
2622 job_last_running (job
)
2625 return (most_recent_job_in_state (job
, JRUNNING
));
2628 /* Make JOB be the current job, and make previous be useful. Must be
2629 called with SIGCHLD blocked. */
2631 set_current_job (job
)
2636 if (js
.j_current
!= job
)
2638 js
.j_previous
= js
.j_current
;
2642 /* First choice for previous job is the old current job. */
2643 if (js
.j_previous
!= js
.j_current
&&
2644 js
.j_previous
!= NO_JOB
&&
2645 jobs
[js
.j_previous
] &&
2646 STOPPED (js
.j_previous
))
2649 /* Second choice: Newest stopped job that is older than
2652 if (STOPPED (js
.j_current
))
2654 candidate
= job_last_stopped (js
.j_current
);
2656 if (candidate
!= NO_JOB
)
2658 js
.j_previous
= candidate
;
2663 /* If we get here, there is either only one stopped job, in which case it is
2664 the current job and the previous job should be set to the newest running
2665 job, or there are only running jobs and the previous job should be set to
2666 the newest running job older than the current job. We decide on which
2667 alternative to use based on whether or not JOBSTATE(js.j_current) is
2670 candidate
= RUNNING (js
.j_current
) ? job_last_running (js
.j_current
)
2671 : job_last_running (js
.j_jobslots
);
2673 if (candidate
!= NO_JOB
)
2675 js
.j_previous
= candidate
;
2679 /* There is only a single job, and it is both `+' and `-'. */
2680 js
.j_previous
= js
.j_current
;
2683 /* Make current_job be something useful, if it isn't already. */
2685 /* Here's the deal: The newest non-running job should be `+', and the
2686 next-newest non-running job should be `-'. If there is only a single
2687 stopped job, the js.j_previous is the newest non-running job. If there
2688 are only running jobs, the newest running job is `+' and the
2689 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2696 if (js
.j_jobslots
&& js
.j_current
!= NO_JOB
&& jobs
[js
.j_current
] && STOPPED (js
.j_current
))
2697 candidate
= js
.j_current
;
2702 /* First choice: the previous job. */
2703 if (js
.j_previous
!= NO_JOB
&& jobs
[js
.j_previous
] && STOPPED (js
.j_previous
))
2704 candidate
= js
.j_previous
;
2706 /* Second choice: the most recently stopped job. */
2707 if (candidate
== NO_JOB
)
2708 candidate
= job_last_stopped (js
.j_jobslots
);
2710 /* Third choice: the newest running job. */
2711 if (candidate
== NO_JOB
)
2712 candidate
= job_last_running (js
.j_jobslots
);
2715 /* If we found a job to use, then use it. Otherwise, there
2716 are no jobs period. */
2717 if (candidate
!= NO_JOB
)
2718 set_current_job (candidate
);
2720 js
.j_current
= js
.j_previous
= NO_JOB
;
2723 /* Set up the job structures so we know the job and its processes are
2726 set_job_running (job
)
2729 register PROCESS
*p
;
2731 /* Each member of the pipeline is now running. */
2732 p
= jobs
[job
]->pipe
;
2736 if (WIFSTOPPED (p
->status
))
2737 p
->running
= PS_RUNNING
; /* XXX - could be PS_STOPPED */
2740 while (p
!= jobs
[job
]->pipe
);
2742 /* This means that the job is running. */
2743 JOBSTATE (job
) = JRUNNING
;
2746 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2747 start the job in the background. JOB is a zero-based index into
2748 JOBS. Returns -1 if it is unable to start a job, and the return
2749 status of the job otherwise. */
2751 start_job (job
, foreground
)
2752 int job
, foreground
;
2754 register PROCESS
*p
;
2755 int already_running
;
2758 static TTYSTRUCT save_stty
;
2760 BLOCK_CHILD (set
, oset
);
2764 internal_error (_("%s: job has terminated"), this_command_name
);
2765 UNBLOCK_CHILD (oset
);
2769 already_running
= RUNNING (job
);
2771 if (foreground
== 0 && already_running
)
2773 internal_error (_("%s: job %d already in background"), this_command_name
, job
+ 1);
2774 UNBLOCK_CHILD (oset
);
2775 return (0); /* XPG6/SUSv3 says this is not an error */
2778 wd
= current_working_directory ();
2780 /* You don't know about the state of this job. Do you? */
2781 jobs
[job
]->flags
&= ~J_NOTIFIED
;
2785 set_current_job (job
);
2786 jobs
[job
]->flags
|= J_FOREGROUND
;
2789 /* Tell the outside world what we're doing. */
2790 p
= jobs
[job
]->pipe
;
2792 if (foreground
== 0)
2794 /* POSIX.2 says `bg' doesn't give any indication about current or
2796 if (posixly_correct
== 0)
2797 s
= (job
== js
.j_current
) ? "+ ": ((job
== js
.j_previous
) ? "- " : " ");
2800 printf ("[%d]%s", job
+ 1, s
);
2806 p
->command
? p
->command
: "",
2807 p
->next
!= jobs
[job
]->pipe
? " | " : "");
2810 while (p
!= jobs
[job
]->pipe
);
2812 if (foreground
== 0)
2815 if (strcmp (wd
, jobs
[job
]->wd
) != 0)
2816 printf (" (wd: %s)", polite_directory_format (jobs
[job
]->wd
));
2821 if (already_running
== 0)
2822 set_job_running (job
);
2824 /* Save the tty settings before we start the job in the foreground. */
2828 save_stty
= shell_tty_info
;
2829 /* Give the terminal to this job. */
2830 if (IS_JOBCONTROL (job
))
2831 give_terminal_to (jobs
[job
]->pgrp
, 0);
2834 jobs
[job
]->flags
&= ~J_FOREGROUND
;
2836 /* If the job is already running, then don't bother jump-starting it. */
2837 if (already_running
== 0)
2839 jobs
[job
]->flags
|= J_NOTIFIED
;
2840 killpg (jobs
[job
]->pgrp
, SIGCONT
);
2848 pid
= find_last_pid (job
, 0);
2849 UNBLOCK_CHILD (oset
);
2850 st
= wait_for (pid
);
2851 shell_tty_info
= save_stty
;
2858 UNBLOCK_CHILD (oset
);
2863 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
2864 If PID does belong to a job, and the job is stopped, then CONTinue the
2865 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
2866 then kill the process group associated with PID. */
2868 kill_pid (pid
, sig
, group
)
2872 register PROCESS
*p
;
2873 int job
, result
, negative
;
2879 group
= negative
= 1;
2884 result
= EXECUTION_SUCCESS
;
2887 BLOCK_CHILD (set
, oset
);
2888 p
= find_pipeline (pid
, 0, &job
);
2892 jobs
[job
]->flags
&= ~J_NOTIFIED
;
2894 /* Kill process in backquotes or one started without job control? */
2896 /* If we're passed a pid < -1, just call killpg and see what happens */
2897 if (negative
&& jobs
[job
]->pgrp
== shell_pgrp
)
2898 result
= killpg (pid
, sig
);
2899 /* If we're killing using job control notification, for example,
2900 without job control active, we have to do things ourselves. */
2901 else if (jobs
[job
]->pgrp
== shell_pgrp
)
2903 p
= jobs
[job
]->pipe
;
2906 if (PALIVE (p
) == 0)
2907 continue; /* avoid pid recycling problem */
2909 if (PEXITED (p
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
2910 kill (p
->pid
, SIGCONT
);
2913 while (p
!= jobs
[job
]->pipe
);
2917 result
= killpg (jobs
[job
]->pgrp
, sig
);
2918 if (p
&& STOPPED (job
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
2919 killpg (jobs
[job
]->pgrp
, SIGCONT
);
2920 /* If we're continuing a stopped job via kill rather than bg or
2921 fg, emulate the `bg' behavior. */
2922 if (p
&& STOPPED (job
) && (sig
== SIGCONT
))
2924 set_job_running (job
);
2925 jobs
[job
]->flags
&= ~J_FOREGROUND
;
2926 jobs
[job
]->flags
|= J_NOTIFIED
;
2931 result
= killpg (pid
, sig
);
2933 UNBLOCK_CHILD (oset
);
2936 result
= kill (pid
, sig
);
2941 /* sigchld_handler () flushes at least one of the children that we are
2942 waiting for. It gets run when we have gotten a SIGCHLD signal. */
2944 sigchld_handler (sig
)
2950 REINSTALL_SIGCHLD_HANDLER
;
2953 if (queue_sigchld
== 0)
2954 n
= waitchld (-1, 0);
2959 /* waitchld() reaps dead or stopped children. It's called by wait_for and
2960 sigchld_handler, and runs until there aren't any children terminating any
2962 If BLOCK is 1, this is to be a blocking wait for a single child, although
2963 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
2964 the number of children reaped, or -1 if there are no unwaited-for child
2967 waitchld (wpid
, block
)
2974 int call_set_current
, last_stopped_job
, job
, children_exited
, waitpid_flags
;
2975 static int wcontinued
= WCONTINUED
; /* run-time fix for glibc problem */
2977 call_set_current
= children_exited
= 0;
2978 last_stopped_job
= NO_JOB
;
2982 /* We don't want to be notified about jobs stopping if job control
2983 is not active. XXX - was interactive_shell instead of job_control */
2984 waitpid_flags
= (job_control
&& subshell_environment
== 0)
2985 ? (WUNTRACED
|wcontinued
)
2987 if (sigchld
|| block
== 0)
2988 waitpid_flags
|= WNOHANG
;
2990 pid
= WAITPID (-1, &status
, waitpid_flags
);
2992 /* WCONTINUED may be rejected by waitpid as invalid even when defined */
2993 if (wcontinued
&& pid
< 0 && errno
== EINVAL
)
2996 continue; /* jump back to the test and retry without WCONTINUED */
2999 /* The check for WNOHANG is to make sure we decrement sigchld only
3000 if it was non-zero before we called waitpid. */
3001 if (sigchld
> 0 && (waitpid_flags
& WNOHANG
))
3004 /* If waitpid returns -1 with errno == ECHILD, there are no more
3005 unwaited-for child processes of this shell. */
3006 if (pid
< 0 && errno
== ECHILD
)
3008 if (children_exited
== 0)
3014 /* If waitpid returns 0, there are running children. If it returns -1,
3015 the only other error POSIX says it can return is EINTR. */
3018 continue; /* jumps right to the test */
3020 /* children_exited is used to run traps on SIGCHLD. We don't want to
3021 run the trap if a process is just being continued. */
3022 if (WIFCONTINUED(status
) == 0)
3028 /* Locate our PROCESS for this pid. */
3029 child
= find_process (pid
, 1, &job
); /* want living procs only */
3031 /* It is not an error to have a child terminate that we did
3032 not have a record of. This child could have been part of
3033 a pipeline in backquote substitution. Even so, I'm not
3034 sure child is ever non-zero. */
3038 /* Remember status, and whether or not the process is running. */
3039 child
->status
= status
;
3040 child
->running
= WIFCONTINUED(status
) ? PS_RUNNING
: PS_DONE
;
3042 if (PEXITED (child
))
3052 call_set_current
+= set_job_status_and_cleanup (job
);
3055 last_stopped_job
= job
;
3056 else if (DEADJOB (job
) && last_stopped_job
== job
)
3057 last_stopped_job
= NO_JOB
;
3059 while ((sigchld
|| block
== 0) && pid
> (pid_t
)0);
3061 /* If a job was running and became stopped, then set the current
3062 job. Otherwise, don't change a thing. */
3063 if (call_set_current
)
3065 if (last_stopped_job
!= NO_JOB
)
3066 set_current_job (last_stopped_job
);
3071 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
3072 if (job_control
&& signal_is_trapped (SIGCHLD
) && children_exited
&&
3073 trap_list
[SIGCHLD
] != (char *)IGNORE_SIG
)
3074 run_sigchld_trap (children_exited
);
3076 /* We have successfully recorded the useful information about this process
3077 that has just changed state. If we notify asynchronously, and the job
3078 that this process belongs to is no longer running, then notify the user
3079 of that fact now. */
3080 if (asynchronous_notification
&& interactive
)
3081 notify_of_job_status ();
3083 return (children_exited
);
3086 /* Set the status of JOB and perform any necessary cleanup if the job is
3089 Currently, the cleanup activity is restricted to handling any SIGINT
3090 received while waiting for a foreground job to finish. */
3092 set_job_status_and_cleanup (job
)
3096 int tstatus
, job_state
, any_stopped
, any_tstped
, call_set_current
;
3097 SigHandler
*temp_handler
;
3099 child
= jobs
[job
]->pipe
;
3100 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3102 call_set_current
= 0;
3105 * COMPUTE JOB STATUS
3108 /* If all children are not running, but any of them is stopped, then
3109 the job is stopped, not dead. */
3110 job_state
= any_stopped
= any_tstped
= 0;
3113 job_state
|= PRUNNING (child
);
3115 if (PEXITED (child
) && (WIFSTOPPED (child
->status
)))
3117 /* Only checking for WIFSTOPPED now, not for PS_DONE */
3118 if (PSTOPPED (child
))
3122 any_tstped
|= interactive
&& job_control
&&
3123 (WSTOPSIG (child
->status
) == SIGTSTP
);
3125 child
= child
->next
;
3127 while (child
!= jobs
[job
]->pipe
);
3129 /* If job_state != 0, the job is still running, so don't bother with
3130 setting the process exit status and job state unless we're
3131 transitioning from stopped to running. */
3132 if (job_state
!= 0 && JOBSTATE(job
) != JSTOPPED
)
3139 /* The job is either stopped or dead. Set the state of the job accordingly. */
3142 jobs
[job
]->state
= JSTOPPED
;
3143 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3145 /* Suspending a job with SIGTSTP breaks all active loops. */
3146 if (any_tstped
&& loop_level
)
3147 breaking
= loop_level
;
3149 else if (job_state
!= 0) /* was stopped, now running */
3151 jobs
[job
]->state
= JRUNNING
;
3156 jobs
[job
]->state
= JDEAD
;
3160 if (IS_FOREGROUND (job
))
3164 /* If this job has a cleanup function associated with it, call it
3165 with `cleanarg' as the single argument, then set the function
3166 pointer to NULL so it is not inadvertently called twice. The
3167 cleanup function is responsible for deallocating cleanarg. */
3168 if (jobs
[job
]->j_cleanup
)
3170 (*jobs
[job
]->j_cleanup
) (jobs
[job
]->cleanarg
);
3171 jobs
[job
]->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
3178 * Currently, we just do special things if we got a SIGINT while waiting
3179 * for a foreground job to complete
3182 if (JOBSTATE (job
) == JDEAD
)
3184 /* If we're running a shell script and we get a SIGINT with a
3185 SIGINT trap handler, but the foreground job handles it and
3186 does not exit due to SIGINT, run the trap handler but do not
3187 otherwise act as if we got the interrupt. */
3188 if (wait_sigint_received
&& interactive_shell
== 0 &&
3189 WIFSIGNALED (child
->status
) == 0 && IS_FOREGROUND (job
) &&
3190 signal_is_trapped (SIGINT
))
3193 wait_sigint_received
= 0;
3194 last_command_exit_value
= process_exit_status (child
->status
);
3196 old_frozen
= jobs_list_frozen
;
3197 jobs_list_frozen
= 1;
3198 tstatus
= maybe_call_trap_handler (SIGINT
);
3199 jobs_list_frozen
= old_frozen
;
3202 /* If the foreground job is killed by SIGINT when job control is not
3203 active, we need to perform some special handling.
3205 The check of wait_sigint_received is a way to determine if the
3206 SIGINT came from the keyboard (in which case the shell has already
3207 seen it, and wait_sigint_received is non-zero, because keyboard
3208 signals are sent to process groups) or via kill(2) to the foreground
3209 process by another process (or itself). If the shell did receive the
3210 SIGINT, it needs to perform normal SIGINT processing. */
3211 else if (wait_sigint_received
&& (WTERMSIG (child
->status
) == SIGINT
) &&
3212 IS_FOREGROUND (job
) && IS_JOBCONTROL (job
) == 0)
3216 wait_sigint_received
= 0;
3218 /* If SIGINT is trapped, set the exit status so that the trap
3219 handler can see it. */
3220 if (signal_is_trapped (SIGINT
))
3221 last_command_exit_value
= process_exit_status (child
->status
);
3223 /* If the signal is trapped, let the trap handler get it no matter
3224 what and simply return if the trap handler returns.
3225 maybe_call_trap_handler() may cause dead jobs to be removed from
3226 the job table because of a call to execute_command. We work
3227 around this by setting JOBS_LIST_FROZEN. */
3228 old_frozen
= jobs_list_frozen
;
3229 jobs_list_frozen
= 1;
3230 tstatus
= maybe_call_trap_handler (SIGINT
);
3231 jobs_list_frozen
= old_frozen
;
3232 if (tstatus
== 0 && old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
3234 /* wait_sigint_handler () has already seen SIGINT and
3235 allowed the wait builtin to jump out. We need to
3236 call the original SIGINT handler, if necessary. If
3237 the original handler is SIG_DFL, we need to resend
3238 the signal to ourselves. */
3240 temp_handler
= old_sigint_handler
;
3242 /* Bogus. If we've reset the signal handler as the result
3243 of a trap caught on SIGINT, then old_sigint_handler
3244 will point to trap_handler, which now knows nothing about
3245 SIGINT (if we reset the sighandler to the default).
3246 In this case, we have to fix things up. What a crock. */
3247 if (temp_handler
== trap_handler
&& signal_is_trapped (SIGINT
) == 0)
3248 temp_handler
= trap_to_sighandler (SIGINT
);
3249 restore_sigint_handler ();
3250 if (temp_handler
== SIG_DFL
)
3251 termsig_handler (SIGINT
);
3252 else if (temp_handler
!= SIG_IGN
)
3253 (*temp_handler
) (SIGINT
);
3258 return call_set_current
;
3261 /* Build the array of values for the $PIPESTATUS variable from the set of
3262 exit statuses of all processes in the job J. */
3267 #if defined (ARRAY_VARS)
3269 register PROCESS
*p
;
3271 for (i
= 1, p
= jobs
[j
]->pipe
; p
->next
!= jobs
[j
]->pipe
; p
= p
->next
, i
++)
3276 pstatuses
= (int *)xrealloc (pstatuses
, i
* sizeof (int));
3283 pstatuses
[i
++] = process_exit_status (p
->status
);
3286 while (p
!= jobs
[j
]->pipe
);
3288 pstatuses
[i
] = -1; /* sentinel */
3289 set_pipestatus_array (pstatuses
, i
);
3294 run_sigchld_trap (nchild
)
3300 /* Turn off the trap list during the call to parse_and_execute ()
3301 to avoid potentially infinite recursive calls. Preserve the
3302 values of last_command_exit_value, last_made_pid, and the_pipeline
3303 around the execution of the trap commands. */
3304 trap_command
= savestring (trap_list
[SIGCHLD
]);
3306 begin_unwind_frame ("SIGCHLD trap");
3307 unwind_protect_int (last_command_exit_value
);
3308 unwind_protect_int (last_command_exit_signal
);
3309 unwind_protect_var (last_made_pid
);
3310 unwind_protect_int (interrupt_immediately
);
3311 unwind_protect_int (jobs_list_frozen
);
3312 unwind_protect_pointer (the_pipeline
);
3313 unwind_protect_pointer (subst_assign_varlist
);
3315 /* We have to add the commands this way because they will be run
3316 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
3317 to reference freed memory. */
3318 add_unwind_protect (xfree
, trap_command
);
3319 add_unwind_protect (maybe_set_sigchld_trap
, trap_command
);
3321 subst_assign_varlist
= (WORD_LIST
*)NULL
;
3322 the_pipeline
= (PROCESS
*)NULL
;
3324 restore_default_signal (SIGCHLD
);
3325 jobs_list_frozen
= 1;
3326 for (i
= 0; i
< nchild
; i
++)
3328 interrupt_immediately
= 1;
3329 parse_and_execute (savestring (trap_command
), "trap", SEVAL_NOHIST
|SEVAL_RESETLINE
);
3332 run_unwind_frame ("SIGCHLD trap");
3335 /* Function to call when you want to notify people of changes
3336 in job status. This prints out all jobs which are pending
3337 notification to stderr, and marks those printed as already
3338 notified, thus making them candidates for cleanup. */
3340 notify_of_job_status ()
3342 register int job
, termsig
;
3347 if (jobs
== 0 || js
.j_jobslots
== 0)
3353 sigaddset (&set
, SIGCHLD
);
3354 sigaddset (&set
, SIGTTOU
);
3355 sigemptyset (&oset
);
3356 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3361 /* XXX could use js.j_firstj here */
3362 for (job
= 0, dir
= (char *)NULL
; job
< js
.j_jobslots
; job
++)
3364 if (jobs
[job
] && IS_NOTIFIED (job
) == 0)
3366 s
= raw_job_exit_status (job
);
3367 termsig
= WTERMSIG (s
);
3369 /* POSIX.2 says we have to hang onto the statuses of at most the
3370 last CHILD_MAX background processes if the shell is running a
3371 script. If the shell is running a script, either from a file
3372 or standard input, don't print anything unless the job was
3373 killed by a signal. */
3374 if (startup_state
== 0 && WIFSIGNALED (s
) == 0 &&
3375 ((DEADJOB (job
) && IS_FOREGROUND (job
) == 0) || STOPPED (job
)))
3379 /* If job control is disabled, don't print the status messages.
3380 Mark dead jobs as notified so that they get cleaned up. If
3381 startup_state == 2, we were started to run `-c command', so
3382 don't print anything. */
3383 if ((job_control
== 0 && interactive_shell
) || startup_state
== 2)
3385 /* If job control is disabled, don't print the status messages.
3386 Mark dead jobs as notified so that they get cleaned up. If
3387 startup_state == 2 and subshell_environment has the
3388 SUBSHELL_COMSUB bit turned on, we were started to run a command
3389 substitution, so don't print anything. */
3390 if ((job_control
== 0 && interactive_shell
) ||
3391 (startup_state
== 2 && (subshell_environment
& SUBSHELL_COMSUB
)))
3394 /* POSIX.2 compatibility: if the shell is not interactive,
3395 hang onto the job corresponding to the last asynchronous
3396 pid until the user has been notified of its status or does
3398 if (DEADJOB (job
) && (interactive_shell
|| (find_last_pid (job
, 0) != last_asynchronous_pid
)))
3399 jobs
[job
]->flags
|= J_NOTIFIED
;
3403 /* Print info on jobs that are running in the background,
3404 and on foreground jobs that were killed by anything
3405 except SIGINT (and possibly SIGPIPE). */
3406 switch (JOBSTATE (job
))
3409 if (interactive_shell
== 0 && termsig
&& WIFSIGNALED (s
) &&
3410 termsig
!= SIGINT
&&
3411 #if defined (DONT_REPORT_SIGPIPE)
3412 termsig
!= SIGPIPE
&&
3414 signal_is_trapped (termsig
) == 0)
3416 /* Don't print `0' for a line number. */
3417 fprintf (stderr
, _("%s: line %d: "), get_name_for_error (), (line_number
== 0) ? 1 : line_number
);
3418 pretty_print_job (job
, JLIST_NONINTERACTIVE
, stderr
);
3420 else if (IS_FOREGROUND (job
))
3422 #if !defined (DONT_REPORT_SIGPIPE)
3423 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
)
3425 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
&& termsig
!= SIGPIPE
)
3428 fprintf (stderr
, "%s", j_strsignal (termsig
));
3431 fprintf (stderr
, _(" (core dumped)"));
3433 fprintf (stderr
, "\n");
3436 else if (job_control
) /* XXX job control test added */
3439 dir
= current_working_directory ();
3440 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3441 if (dir
&& strcmp (dir
, jobs
[job
]->wd
) != 0)
3443 _("(wd now: %s)\n"), polite_directory_format (dir
));
3446 jobs
[job
]->flags
|= J_NOTIFIED
;
3450 fprintf (stderr
, "\n");
3452 dir
= current_working_directory ();
3453 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3454 if (dir
&& (strcmp (dir
, jobs
[job
]->wd
) != 0))
3456 _("(wd now: %s)\n"), polite_directory_format (dir
));
3457 jobs
[job
]->flags
|= J_NOTIFIED
;
3465 programming_error ("notify_of_job_status");
3470 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
3475 /* Initialize the job control mechanism, and set up the tty stuff. */
3477 initialize_job_control (force
)
3484 shell_pgrp
= getpgid (0);
3486 if (shell_pgrp
== -1)
3488 sys_error (_("initialize_job_control: getpgrp failed"));
3492 /* We can only have job control if we are interactive. */
3493 if (interactive
== 0)
3496 original_pgrp
= NO_PID
;
3497 shell_tty
= fileno (stderr
);
3503 /* If forced_interactive is set, we skip the normal check that stderr
3504 is attached to a tty, so we need to check here. If it's not, we
3505 need to see whether we have a controlling tty by opening /dev/tty,
3506 since trying to use job control tty pgrp manipulations on a non-tty
3507 is going to fail. */
3508 if (forced_interactive
&& isatty (fileno (stderr
)) == 0)
3509 shell_tty
= open ("/dev/tty", O_RDWR
|O_NONBLOCK
);
3511 /* Get our controlling terminal. If job_control is set, or
3512 interactive is set, then this is an interactive shell no
3513 matter where fd 2 is directed. */
3514 if (shell_tty
== -1)
3515 shell_tty
= dup (fileno (stderr
)); /* fd 2 */
3517 shell_tty
= move_to_high_fd (shell_tty
, 1, -1);
3519 /* Compensate for a bug in systems that compiled the BSD
3520 rlogind with DEBUG defined, like NeXT and Alliant. */
3521 if (shell_pgrp
== 0)
3523 shell_pgrp
= getpid ();
3524 setpgid (0, shell_pgrp
);
3525 tcsetpgrp (shell_tty
, shell_pgrp
);
3528 while ((terminal_pgrp
= tcgetpgrp (shell_tty
)) != -1)
3530 if (shell_pgrp
!= terminal_pgrp
)
3534 ottin
= set_signal_handler(SIGTTIN
, SIG_DFL
);
3536 set_signal_handler (SIGTTIN
, ottin
);
3542 if (terminal_pgrp
== -1)
3545 /* Make sure that we are using the new line discipline. */
3546 if (set_new_line_discipline (shell_tty
) < 0)
3548 sys_error (_("initialize_job_control: line discipline"));
3553 original_pgrp
= shell_pgrp
;
3554 shell_pgrp
= getpid ();
3556 if ((original_pgrp
!= shell_pgrp
) && (setpgid (0, shell_pgrp
) < 0))
3558 sys_error (_("initialize_job_control: setpgid"));
3559 shell_pgrp
= original_pgrp
;
3564 /* If (and only if) we just set our process group to our pid,
3565 thereby becoming a process group leader, and the terminal
3566 is not in the same process group as our (new) process group,
3567 then set the terminal's process group to our (new) process
3568 group. If that fails, set our process group back to what it
3569 was originally (so we can still read from the terminal) and
3570 turn off job control. */
3571 if (shell_pgrp
!= original_pgrp
&& shell_pgrp
!= terminal_pgrp
)
3573 if (give_terminal_to (shell_pgrp
, 0) < 0)
3576 setpgid (0, original_pgrp
);
3577 shell_pgrp
= original_pgrp
;
3582 if (job_control
&& ((t
= tcgetpgrp (shell_tty
)) == -1 || t
!= shell_pgrp
))
3586 sys_error (_("cannot set terminal process group (%d)"), t
);
3590 if (job_control
== 0)
3591 internal_error (_("no job control in this shell"));
3594 if (shell_tty
!= fileno (stderr
))
3595 SET_CLOSE_ON_EXEC (shell_tty
);
3597 set_signal_handler (SIGCHLD
, sigchld_handler
);
3599 change_flag ('m', job_control
? '-' : '+');
3604 if (js
.c_childmax
< 0)
3605 js
.c_childmax
= getmaxchild ();
3606 if (js
.c_childmax
< 0)
3607 js
.c_childmax
= DEFAULT_CHILD_MAX
;
3614 debug_print_pgrps ()
3616 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3617 (long)original_pgrp
, (long)shell_pgrp
, (long)terminal_pgrp
);
3618 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3619 shell_tty
, (long)tcgetpgrp (shell_tty
), (long)getpgid(0));
3623 /* Set the line discipline to the best this system has to offer.
3624 Return -1 if this is not possible. */
3626 set_new_line_discipline (tty
)
3629 #if defined (NEW_TTY_DRIVER)
3632 if (ioctl (tty
, TIOCGETD
, &ldisc
) < 0)
3635 if (ldisc
!= NTTYDISC
)
3639 if (ioctl (tty
, TIOCSETD
, &ldisc
) < 0)
3643 #endif /* NEW_TTY_DRIVER */
3645 #if defined (TERMIO_TTY_DRIVER)
3646 # if defined (TERMIO_LDISC) && (NTTYDISC)
3647 if (ioctl (tty
, TCGETA
, &shell_tty_info
) < 0)
3650 if (shell_tty_info
.c_line
!= NTTYDISC
)
3652 shell_tty_info
.c_line
= NTTYDISC
;
3653 if (ioctl (tty
, TCSETAW
, &shell_tty_info
) < 0)
3656 # endif /* TERMIO_LDISC && NTTYDISC */
3658 #endif /* TERMIO_TTY_DRIVER */
3660 #if defined (TERMIOS_TTY_DRIVER)
3661 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3662 if (tcgetattr (tty
, &shell_tty_info
) < 0)
3665 if (shell_tty_info
.c_line
!= NTTYDISC
)
3667 shell_tty_info
.c_line
= NTTYDISC
;
3668 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
3671 # endif /* TERMIOS_LDISC && NTTYDISC */
3673 #endif /* TERMIOS_TTY_DRIVER */
3675 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3680 /* Setup this shell to handle C-C, etc. */
3682 initialize_job_signals ()
3686 set_signal_handler (SIGINT
, sigint_sighandler
);
3687 set_signal_handler (SIGTSTP
, SIG_IGN
);
3688 set_signal_handler (SIGTTOU
, SIG_IGN
);
3689 set_signal_handler (SIGTTIN
, SIG_IGN
);
3691 else if (job_control
)
3693 old_tstp
= set_signal_handler (SIGTSTP
, sigstop_sighandler
);
3694 old_ttin
= set_signal_handler (SIGTTIN
, sigstop_sighandler
);
3695 old_ttou
= set_signal_handler (SIGTTOU
, sigstop_sighandler
);
3697 /* Leave these things alone for non-interactive shells without job
3701 /* Here we handle CONT signals. */
3703 sigcont_sighandler (sig
)
3706 initialize_job_signals ();
3707 set_signal_handler (SIGCONT
, old_cont
);
3708 kill (getpid (), SIGCONT
);
3713 /* Here we handle stop signals while we are running not as a login shell. */
3715 sigstop_sighandler (sig
)
3718 set_signal_handler (SIGTSTP
, old_tstp
);
3719 set_signal_handler (SIGTTOU
, old_ttou
);
3720 set_signal_handler (SIGTTIN
, old_ttin
);
3722 old_cont
= set_signal_handler (SIGCONT
, sigcont_sighandler
);
3724 give_terminal_to (shell_pgrp
, 0);
3726 kill (getpid (), sig
);
3731 /* Give the terminal to PGRP. */
3733 give_terminal_to (pgrp
, force
)
3741 if (job_control
|| force
)
3744 sigaddset (&set
, SIGTTOU
);
3745 sigaddset (&set
, SIGTTIN
);
3746 sigaddset (&set
, SIGTSTP
);
3747 sigaddset (&set
, SIGCHLD
);
3748 sigemptyset (&oset
);
3749 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3751 if (tcsetpgrp (shell_tty
, pgrp
) < 0)
3753 /* Maybe we should print an error message? */
3755 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
3756 shell_tty
, (long)getpid(), (long)pgrp
);
3762 terminal_pgrp
= pgrp
;
3763 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
3771 /* Clear out any jobs in the job array. This is intended to be used by
3772 children of the shell, who should not have any job structures as baggage
3773 when they start executing (forking subshells for parenthesized execution
3774 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
3775 is nonzero, only running jobs are removed from the table. */
3777 delete_all_jobs (running_only
)
3783 BLOCK_CHILD (set
, oset
);
3785 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
3788 js
.j_current
= js
.j_previous
= NO_JOB
;
3790 /* XXX could use js.j_firstj here */
3791 for (i
= 0; i
< js
.j_jobslots
; i
++)
3794 if (i
< js
.j_firstj
&& jobs
[i
])
3795 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3796 if (i
> js
.j_lastj
&& jobs
[i
])
3797 itrace("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
3799 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
3800 delete_job (i
, DEL_WARNSTOPPED
);
3802 if (running_only
== 0)
3804 free ((char *)jobs
);
3806 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
3810 if (running_only
== 0)
3813 UNBLOCK_CHILD (oset
);
3816 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
3817 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
3819 nohup_all_jobs (running_only
)
3825 BLOCK_CHILD (set
, oset
);
3829 /* XXX could use js.j_firstj here */
3830 for (i
= 0; i
< js
.j_jobslots
; i
++)
3831 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
3835 UNBLOCK_CHILD (oset
);
3844 /* This really counts all non-dead jobs. */
3845 BLOCK_CHILD (set
, oset
);
3846 /* XXX could use js.j_firstj here */
3847 for (i
= n
= 0; i
< js
.j_jobslots
; i
++)
3850 if (i
< js
.j_firstj
&& jobs
[i
])
3851 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3852 if (i
> js
.j_lastj
&& jobs
[i
])
3853 itrace("count_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
3855 if (jobs
[i
] && DEADJOB(i
) == 0)
3858 UNBLOCK_CHILD (oset
);
3863 mark_all_jobs_as_dead ()
3868 if (js
.j_jobslots
== 0)
3871 BLOCK_CHILD (set
, oset
);
3873 /* XXX could use js.j_firstj here */
3874 for (i
= 0; i
< js
.j_jobslots
; i
++)
3877 jobs
[i
]->state
= JDEAD
;
3881 UNBLOCK_CHILD (oset
);
3884 /* Mark all dead jobs as notified, so delete_job () cleans them out
3885 of the job table properly. POSIX.2 says we need to save the
3886 status of the last CHILD_MAX jobs, so we count the number of dead
3887 jobs and mark only enough as notified to save CHILD_MAX statuses. */
3889 mark_dead_jobs_as_notified (force
)
3892 register int i
, ndead
, ndeadproc
;
3895 if (js
.j_jobslots
== 0)
3898 BLOCK_CHILD (set
, oset
);
3900 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
3901 around; just run through the array. */
3904 /* XXX could use js.j_firstj here */
3905 for (i
= 0; i
< js
.j_jobslots
; i
++)
3907 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
3908 jobs
[i
]->flags
|= J_NOTIFIED
;
3910 UNBLOCK_CHILD (oset
);
3914 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
3915 array with the corresponding not marked as notified. This is a better
3916 way to avoid pid aliasing and reuse problems than keeping the POSIX-
3917 mandated CHILD_MAX jobs around. delete_job() takes care of keeping the
3918 bgpids list regulated. */
3920 /* Count the number of dead jobs */
3921 /* XXX could use js.j_firstj here */
3922 for (i
= ndead
= ndeadproc
= 0; i
< js
.j_jobslots
; i
++)
3925 if (i
< js
.j_firstj
&& jobs
[i
])
3926 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3927 if (i
> js
.j_lastj
&& jobs
[i
])
3928 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
3930 if (jobs
[i
] && DEADJOB (i
))
3933 ndeadproc
+= processes_in_job (i
);
3938 if (ndeadproc
!= js
.c_reaped
)
3939 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc
, js
.c_reaped
);
3940 if (ndead
!= js
.j_ndead
)
3941 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead
, js
.j_ndead
);
3944 if (js
.c_childmax
< 0)
3945 js
.c_childmax
= getmaxchild ();
3946 if (js
.c_childmax
< 0)
3947 js
.c_childmax
= DEFAULT_CHILD_MAX
;
3949 /* Don't do anything if the number of dead processes is less than CHILD_MAX
3950 and we're not forcing a cleanup. */
3951 if (ndeadproc
<= js
.c_childmax
)
3953 UNBLOCK_CHILD (oset
);
3958 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js
.c_childmax
, ndead
, ndeadproc
);
3961 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
3962 the list. This isn't exactly right yet; changes need to be made
3963 to stop_pipeline so we don't mark the newer jobs after we've
3964 created CHILD_MAX slots in the jobs array. This needs to be
3965 integrated with a way to keep the jobs array from growing without
3966 bound. Maybe we wrap back around to 0 after we reach some max
3967 limit, and there are sufficient job slots free (keep track of total
3968 size of jobs array (js.j_jobslots) and running count of number of jobs
3969 in jobs array. Then keep a job index corresponding to the `oldest job'
3970 and start this loop there, wrapping around as necessary. In effect,
3971 we turn the list into a circular buffer. */
3972 /* XXX could use js.j_firstj here */
3973 for (i
= 0; i
< js
.j_jobslots
; i
++)
3975 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
3978 if (i
< js
.j_firstj
&& jobs
[i
])
3979 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3980 if (i
> js
.j_lastj
&& jobs
[i
])
3981 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
3983 /* If marking this job as notified would drop us down below
3984 child_max, don't mark it so we can keep at least child_max
3985 statuses. XXX -- need to check what Posix actually says
3986 about keeping statuses. */
3987 if ((ndeadproc
-= processes_in_job (i
)) <= js
.c_childmax
)
3989 jobs
[i
]->flags
|= J_NOTIFIED
;
3993 UNBLOCK_CHILD (oset
);
3996 /* Here to allow other parts of the shell (like the trap stuff) to
3997 unfreeze the jobs list. */
3999 unfreeze_jobs_list ()
4001 jobs_list_frozen
= 0;
4004 /* Allow or disallow job control to take place. Returns the old value
4007 set_job_control (arg
)
4015 /* If we're turning on job control, reset pipeline_pgrp so make_child will
4016 put new child processes into the right pgrp */
4017 if (job_control
!= old
&& job_control
)
4023 /* Turn off all traces of job control. This is run by children of the shell
4024 which are going to do shellsy things, like wait (), etc. */
4026 without_job_control ()
4028 stop_making_children ();
4030 #if defined (PGRP_PIPE)
4031 pipe_close (pgrp_pipe
);
4033 delete_all_jobs (0);
4034 set_job_control (0);
4037 /* If this shell is interactive, terminate all stopped jobs and
4038 restore the original terminal process group. This is done
4039 before the `exec' builtin calls shell_execve. */
4043 if (interactive_shell
) /* XXX - should it be interactive? */
4045 terminate_stopped_jobs ();
4047 if (original_pgrp
>= 0)
4048 give_terminal_to (original_pgrp
, 1);
4051 if (original_pgrp
>= 0)
4052 setpgid (0, original_pgrp
);
4055 /* Restart job control by closing shell tty and reinitializing. This is
4056 called after an exec fails in an interactive shell and we do not exit. */
4058 restart_job_control ()
4060 if (shell_tty
!= -1)
4062 initialize_job_control (0);
4065 /* Set the handler to run when the shell receives a SIGCHLD signal. */
4067 set_sigchld_handler ()
4069 set_signal_handler (SIGCHLD
, sigchld_handler
);
4072 #if defined (PGRP_PIPE)
4073 /* Read from the read end of a pipe. This is how the process group leader
4074 blocks until all of the processes in a pipeline have been made. */
4089 while (read (pp
[0], &ch
, 1) == -1 && errno
== EINTR
)
4094 /* Close the read and write ends of PP, an array of file descriptors. */
4108 /* Functional interface closes our local-to-job-control pipes. */
4112 pipe_close (pgrp_pipe
);
4115 #endif /* PGRP_PIPE */