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 while (js
.j_firstj
!= old
)
788 if (js
.j_firstj
>= js
.j_jobslots
)
790 if (jobs
[js
.j_firstj
])
794 if (js
.j_firstj
== old
)
795 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
797 if (jobs
[js
.j_lastj
] == 0)
800 while (js
.j_lastj
!= old
)
803 js
.j_lastj
= js
.j_jobslots
- 1;
804 if (jobs
[js
.j_lastj
])
808 if (js
.j_lastj
== old
)
809 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
813 /* Delete all DEAD jobs that the user had received notification about. */
820 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
825 /* XXX could use js.j_firstj and js.j_lastj here */
826 for (i
= 0; i
< js
.j_jobslots
; i
++)
829 if (i
< js
.j_firstj
&& jobs
[i
])
830 itrace("cleanup_dead_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
831 if (i
> js
.j_lastj
&& jobs
[i
])
832 itrace("cleanup_dead_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
835 if (jobs
[i
] && DEADJOB (i
) && IS_NOTIFIED (i
))
842 processes_in_job (job
)
854 while (p
!= jobs
[job
]->pipe
);
866 job
= find_job (pid
, 0, &p
);
870 itrace ("delete_old_job: found pid %d in job %d with state %d", pid
, job
, jobs
[job
]->state
);
872 if (JOBSTATE (job
) == JDEAD
)
873 delete_job (job
, DEL_NOBGPID
);
876 internal_warning (_("forked pid %d appears in running job %d"), pid
, job
);
883 /* Reallocate and compress the jobs list. This returns with a jobs array
884 whose size is a multiple of JOB_SLOTS and can hold the current number of
885 jobs. Heuristics are used to minimize the number of new reallocs. */
890 int nsize
, i
, j
, ncur
, nprev
;
893 ncur
= nprev
= NO_JOB
;
894 nsize
= ((js
.j_njobs
+ JOB_SLOTS
- 1) / JOB_SLOTS
);
896 i
= js
.j_njobs
% JOB_SLOTS
;
897 if (i
== 0 || i
> (JOB_SLOTS
>> 1))
900 BLOCK_CHILD (set
, oset
);
901 nlist
= (js
.j_jobslots
== nsize
) ? jobs
: (JOB
**) xmalloc (nsize
* sizeof (JOB
*));
903 for (i
= j
= 0; i
< js
.j_jobslots
; i
++)
906 if (i
== js
.j_current
)
908 if (i
== js
.j_previous
)
910 nlist
[j
++] = jobs
[i
];
914 itrace ("realloc_jobs_list: resize jobs list from %d to %d", js
.j_jobslots
, nsize
);
915 itrace ("realloc_jobs_list: j_lastj changed from %d to %d", js
.j_lastj
, (j
> 0) ? j
- 1 : 0);
916 itrace ("realloc_jobs_list: j_njobs changed from %d to %d", js
.j_njobs
, (j
> 0) ? j
- 1 : 0);
920 js
.j_lastj
= (j
> 0) ? j
- 1 : 0;
922 js
.j_jobslots
= nsize
;
924 /* Zero out remaining slots in new jobs list */
925 for ( ; j
< nsize
; j
++)
926 nlist
[j
] = (JOB
*)NULL
;
937 js
.j_previous
= nprev
;
939 /* Need to reset these */
940 if (js
.j_current
== NO_JOB
|| js
.j_previous
== NO_JOB
|| js
.j_current
> js
.j_lastj
|| js
.j_previous
> js
.j_lastj
)
944 itrace ("realloc_jobs_list: reset js.j_current (%d) and js.j_previous (%d)", js
.j_current
, js
.j_previous
);
947 UNBLOCK_CHILD (oset
);
950 /* Compact the jobs list by removing dead jobs. Assumed that we have filled
951 the jobs array to some predefined maximum. Called when the shell is not
952 the foreground process (subshell_environment != 0). Returns the first
953 available slot in the compacted list. If that value is js.j_jobslots, then
954 the list needs to be reallocated. The jobs array may be in new memory if
955 this returns > 0 and < js.j_jobslots. FLAGS is reserved for future use. */
957 compact_jobs_list (flags
)
960 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
961 return js
.j_jobslots
;
964 realloc_jobs_list ();
966 return (js
.j_lastj
? js
.j_lastj
+ 1 : 0);
969 /* Delete the job at INDEX from the job list. Must be called
970 with SIGCHLD blocked. */
972 delete_job (job_index
, dflags
)
973 int job_index
, dflags
;
979 if (js
.j_jobslots
== 0 || jobs_list_frozen
)
982 if ((dflags
& DEL_WARNSTOPPED
) && subshell_environment
== 0 && STOPPED (job_index
))
983 internal_warning (_("deleting stopped job %d with process group %ld"), job_index
+1, (long)jobs
[job_index
]->pgrp
);
984 temp
= jobs
[job_index
];
988 if ((dflags
& DEL_NOBGPID
) == 0)
990 proc
= find_last_proc (job_index
, 0);
991 /* Could do this just for J_ASYNC jobs, but we save all. */
993 bgp_add (proc
->pid
, process_exit_status (proc
->status
));
996 jobs
[job_index
] = (JOB
*)NULL
;
997 if (temp
== js
.j_lastmade
)
999 else if (temp
== js
.j_lastasync
)
1003 ndel
= discard_pipeline (temp
->pipe
);
1005 js
.c_injobs
-= ndel
;
1006 if (temp
->state
== JDEAD
)
1008 js
.c_reaped
-= ndel
;
1010 if (js
.c_reaped
< 0)
1013 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
);
1020 dispose_command (temp
->deferred
);
1025 if (js
.j_njobs
== 0)
1026 js
.j_firstj
= js
.j_lastj
= 0;
1027 else if (jobs
[js
.j_firstj
] == 0 || jobs
[js
.j_lastj
] == 0)
1028 reset_job_indices ();
1030 if (job_index
== js
.j_current
|| job_index
== js
.j_previous
)
1034 /* Must be called with SIGCHLD blocked. */
1036 nohup_job (job_index
)
1041 if (js
.j_jobslots
== 0)
1044 if (temp
= jobs
[job_index
])
1045 temp
->flags
|= J_NOHUP
;
1048 /* Get rid of the data structure associated with a process chain. */
1050 discard_pipeline (chain
)
1051 register PROCESS
*chain
;
1053 register PROCESS
*this, *next
;
1061 FREE (this->command
);
1066 while (this != chain
);
1071 /* Add this process to the chain being built in the_pipeline.
1072 NAME is the command string that will be exec'ed later.
1073 PID is the process id of the child. */
1075 add_process (name
, pid
)
1081 #if defined (RECYCLES_PIDS)
1083 p
= find_process (pid
, 0, &j
);
1088 internal_warning (_("add_process: process %5ld (%s) in the_pipeline"), (long)p
->pid
, p
->command
);
1091 internal_warning ("add_process: pid %5ld (%s) marked as still alive", (long)p
->pid
, p
->command
);
1092 p
->running
= PS_RECYCLED
; /* mark as recycled */
1096 t
= (PROCESS
*)xmalloc (sizeof (PROCESS
));
1097 t
->next
= the_pipeline
;
1099 WSTATUS (t
->status
) = 0;
1100 t
->running
= PS_RUNNING
;
1109 while (p
->next
!= t
->next
)
1116 /* Take the last job and make it the first job. Must be called with
1119 rotate_the_pipeline ()
1123 if (the_pipeline
->next
== the_pipeline
)
1125 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1130 /* Reverse the order of the processes in the_pipeline. Must be called with
1133 reverse_the_pipeline ()
1137 if (the_pipeline
->next
== the_pipeline
)
1140 for (p
= the_pipeline
; p
->next
!= the_pipeline
; p
= p
->next
)
1142 p
->next
= (PROCESS
*)NULL
;
1144 n
= REVERSE_LIST (the_pipeline
, PROCESS
*);
1147 for (p
= the_pipeline
; p
->next
; p
= p
->next
)
1149 p
->next
= the_pipeline
;
1153 /* Map FUNC over the list of jobs. If FUNC returns non-zero,
1154 then it is time to stop mapping, and that is the return value
1155 for map_over_jobs. FUNC is called with a JOB, arg1, arg2,
1158 map_over_jobs (func
, arg1
, arg2
)
1159 sh_job_map_func_t
*func
;
1166 if (js
.j_jobslots
== 0)
1169 BLOCK_CHILD (set
, oset
);
1171 /* XXX could use js.j_firstj here */
1172 for (i
= result
= 0; i
< js
.j_jobslots
; i
++)
1175 if (i
< js
.j_firstj
&& jobs
[i
])
1176 itrace("map_over_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1177 if (i
> js
.j_lastj
&& jobs
[i
])
1178 itrace("map_over_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1182 result
= (*func
)(jobs
[i
], arg1
, arg2
, i
);
1188 UNBLOCK_CHILD (oset
);
1193 /* Cause all the jobs in the current pipeline to exit. */
1195 terminate_current_pipeline ()
1197 if (pipeline_pgrp
&& pipeline_pgrp
!= shell_pgrp
)
1199 killpg (pipeline_pgrp
, SIGTERM
);
1200 killpg (pipeline_pgrp
, SIGCONT
);
1204 /* Cause all stopped jobs to exit. */
1206 terminate_stopped_jobs ()
1210 /* XXX could use js.j_firstj here */
1211 for (i
= 0; i
< js
.j_jobslots
; i
++)
1213 if (jobs
[i
] && STOPPED (i
))
1215 killpg (jobs
[i
]->pgrp
, SIGTERM
);
1216 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1221 /* Cause all jobs, running or stopped, to receive a hangup signal. If
1222 a job is marked J_NOHUP, don't send the SIGHUP. */
1228 /* XXX could use js.j_firstj here */
1229 for (i
= 0; i
< js
.j_jobslots
; i
++)
1233 if (jobs
[i
]->flags
& J_NOHUP
)
1235 killpg (jobs
[i
]->pgrp
, SIGHUP
);
1237 killpg (jobs
[i
]->pgrp
, SIGCONT
);
1243 kill_current_pipeline ()
1245 stop_making_children ();
1249 /* Return the pipeline that PID belongs to. Note that the pipeline
1250 doesn't have to belong to a job. Must be called with SIGCHLD blocked.
1251 If JOBP is non-null, return the index of the job containing PID. */
1253 find_pipeline (pid
, alive_only
, jobp
)
1256 int *jobp
; /* index into jobs list or NO_JOB */
1261 /* See if this process is in the pipeline that we are building. */
1269 /* Return it if we found it. Don't ever return a recycled pid. */
1270 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1275 while (p
!= the_pipeline
);
1278 job
= find_job (pid
, alive_only
, &p
);
1281 return (job
== NO_JOB
) ? (PROCESS
*)NULL
: jobs
[job
]->pipe
;
1284 /* Return the PROCESS * describing PID. If JOBP is non-null return the index
1285 into the jobs array of the job containing PID. Must be called with
1288 find_process (pid
, alive_only
, jobp
)
1291 int *jobp
; /* index into jobs list or NO_JOB */
1295 p
= find_pipeline (pid
, alive_only
, jobp
);
1296 while (p
&& p
->pid
!= pid
)
1301 /* Return the job index that PID belongs to, or NO_JOB if it doesn't
1302 belong to any job. Must be called with SIGCHLD blocked. */
1304 find_job (pid
, alive_only
, procp
)
1312 /* XXX could use js.j_firstj here, and should check js.j_lastj */
1313 for (i
= 0; i
< js
.j_jobslots
; i
++)
1316 if (i
< js
.j_firstj
&& jobs
[i
])
1317 itrace("find_job: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
1318 if (i
> js
.j_lastj
&& jobs
[i
])
1319 itrace("find_job: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
1327 if (p
->pid
== pid
&& ((alive_only
== 0 && PRECYCLED(p
) == 0) || PALIVE(p
)))
1336 while (p
!= jobs
[i
]->pipe
);
1343 /* Find a job given a PID. If BLOCK is non-zero, block SIGCHLD as
1344 required by find_job. */
1346 get_job_by_pid (pid
, block
)
1354 BLOCK_CHILD (set
, oset
);
1356 job
= find_job (pid
, 0, NULL
);
1359 UNBLOCK_CHILD (oset
);
1364 /* Print descriptive information about the job with leader pid PID. */
1372 BLOCK_CHILD (set
, oset
);
1374 job
= find_job (pid
, 0, NULL
);
1377 fprintf (stderr
, "[%d] %ld\n", job
+ 1, (long)pid
);
1379 programming_error (_("describe_pid: %ld: no such pid"), (long)pid
);
1381 UNBLOCK_CHILD (oset
);
1393 x
= retcode_name_buffer
;
1394 sprintf (x
, _("Signal %d"), s
);
1400 printable_job_status (j
, p
, format
)
1410 if (STOPPED (j
) && format
== 0)
1412 if (posixly_correct
== 0 || p
== 0 || (WIFSTOPPED (p
->status
) == 0))
1413 temp
= _("Stopped");
1416 temp
= retcode_name_buffer
;
1417 sprintf (temp
, _("Stopped(%s)"), signal_name (WSTOPSIG (p
->status
)));
1420 else if (RUNNING (j
))
1421 temp
= _("Running");
1424 if (WIFSTOPPED (p
->status
))
1425 temp
= j_strsignal (WSTOPSIG (p
->status
));
1426 else if (WIFSIGNALED (p
->status
))
1427 temp
= j_strsignal (WTERMSIG (p
->status
));
1428 else if (WIFEXITED (p
->status
))
1430 temp
= retcode_name_buffer
;
1431 es
= WEXITSTATUS (p
->status
);
1433 strcpy (temp
, _("Done"));
1434 else if (posixly_correct
)
1435 sprintf (temp
, _("Done(%d)"), es
);
1437 sprintf (temp
, _("Exit %d"), es
);
1440 temp
= _("Unknown status");
1446 /* This is the way to print out information on a job if you
1447 know the index. FORMAT is:
1449 JLIST_NORMAL) [1]+ Running emacs
1450 JLIST_LONG ) [1]+ 2378 Running emacs
1451 -1 ) [1]+ 2378 emacs
1453 JLIST_NORMAL) [1]+ Stopped ls | more
1454 JLIST_LONG ) [1]+ 2369 Stopped ls
1457 Just list the pid of the process group leader (really
1460 Use format JLIST_NORMAL, but list only jobs about which
1461 the user has not been notified. */
1463 /* Print status for pipeline P. If JOB_INDEX is >= 0, it is the index into
1464 the JOBS array corresponding to this pipeline. FORMAT is as described
1465 above. Must be called with SIGCHLD blocked.
1467 If you're printing a pipeline that's not in the jobs array, like the
1468 current pipeline as it's being created, pass -1 for JOB_INDEX */
1470 print_pipeline (p
, job_index
, format
, stream
)
1472 int job_index
, format
;
1475 PROCESS
*first
, *last
, *show
;
1476 int es
, name_padding
;
1483 while (last
->next
!= first
)
1489 fprintf (stream
, format
? " " : " |");
1491 if (format
!= JLIST_STANDARD
)
1492 fprintf (stream
, "%5ld", (long)p
->pid
);
1494 fprintf (stream
, " ");
1496 if (format
> -1 && job_index
>= 0)
1498 show
= format
? p
: last
;
1499 temp
= printable_job_status (job_index
, show
, format
);
1505 if (show
->running
== first
->running
&&
1506 WSTATUS (show
->status
) == WSTATUS (first
->status
))
1510 temp
= (char *)NULL
;
1515 fprintf (stream
, "%s", temp
);
1519 es
= 2; /* strlen ("| ") */
1520 name_padding
= LONGEST_SIGNAL_DESC
- es
;
1522 fprintf (stream
, "%*s", name_padding
, "");
1524 if ((WIFSTOPPED (show
->status
) == 0) &&
1525 (WIFCONTINUED (show
->status
) == 0) &&
1526 WIFCORED (show
->status
))
1527 fprintf (stream
, _("(core dumped) "));
1531 if (p
!= first
&& format
)
1532 fprintf (stream
, "| ");
1535 fprintf (stream
, "%s", p
->command
);
1537 if (p
== last
&& job_index
>= 0)
1539 temp
= current_working_directory ();
1541 if (RUNNING (job_index
) && (IS_FOREGROUND (job_index
) == 0))
1542 fprintf (stream
, " &");
1544 if (strcmp (temp
, jobs
[job_index
]->wd
) != 0)
1546 _(" (wd: %s)"), polite_directory_format (jobs
[job_index
]->wd
));
1549 if (format
|| (p
== last
))
1551 /* We need to add a CR only if this is an interactive shell, and
1552 we're reporting the status of a completed job asynchronously.
1553 We can't really check whether this particular job is being
1554 reported asynchronously, so just add the CR if the shell is
1555 currently interactive and asynchronous notification is enabled. */
1556 if (asynchronous_notification
&& interactive
)
1557 fprintf (stream
, "\r\n");
1559 fprintf (stream
, "\n");
1569 /* Print information to STREAM about jobs[JOB_INDEX] according to FORMAT.
1570 Must be called with SIGCHLD blocked or queued with queue_sigchld */
1572 pretty_print_job (job_index
, format
, stream
)
1573 int job_index
, format
;
1576 register PROCESS
*p
;
1578 /* Format only pid information about the process group leader? */
1579 if (format
== JLIST_PID_ONLY
)
1581 fprintf (stream
, "%ld\n", (long)jobs
[job_index
]->pipe
->pid
);
1585 if (format
== JLIST_CHANGED_ONLY
)
1587 if (IS_NOTIFIED (job_index
))
1589 format
= JLIST_STANDARD
;
1592 if (format
!= JLIST_NONINTERACTIVE
)
1593 fprintf (stream
, "[%d]%c ", job_index
+ 1,
1594 (job_index
== js
.j_current
) ? '+':
1595 (job_index
== js
.j_previous
) ? '-' : ' ');
1597 if (format
== JLIST_NONINTERACTIVE
)
1598 format
= JLIST_LONG
;
1600 p
= jobs
[job_index
]->pipe
;
1602 print_pipeline (p
, job_index
, format
, stream
);
1604 /* We have printed information about this job. When the job's
1605 status changes, waitchld () sets the notification flag to 0. */
1606 jobs
[job_index
]->flags
|= J_NOTIFIED
;
1610 print_job (job
, format
, state
, job_index
)
1612 int format
, state
, job_index
;
1614 if (state
== -1 || (JOB_STATE
)state
== job
->state
)
1615 pretty_print_job (job_index
, format
, stdout
);
1620 list_one_job (job
, format
, ignore
, job_index
)
1622 int format
, ignore
, job_index
;
1624 pretty_print_job (job_index
, format
, stdout
);
1628 list_stopped_jobs (format
)
1631 cleanup_dead_jobs ();
1632 map_over_jobs (print_job
, format
, (int)JSTOPPED
);
1636 list_running_jobs (format
)
1639 cleanup_dead_jobs ();
1640 map_over_jobs (print_job
, format
, (int)JRUNNING
);
1643 /* List jobs. If FORMAT is non-zero, then the long form of the information
1644 is printed, else just a short version. */
1646 list_all_jobs (format
)
1649 cleanup_dead_jobs ();
1650 map_over_jobs (print_job
, format
, -1);
1653 /* Fork, handling errors. Returns the pid of the newly made child, or 0.
1654 COMMAND is just for remembering the name of the command; we don't do
1655 anything else with it. ASYNC_P says what to do with the tty. If
1656 non-zero, then don't give it away. */
1658 make_child (command
, async_p
)
1666 sigaddset (&set
, SIGCHLD
);
1667 sigaddset (&set
, SIGINT
);
1668 sigemptyset (&oset
);
1669 sigprocmask (SIG_BLOCK
, &set
, &oset
);
1673 #if defined (BUFFERED_INPUT)
1674 /* If default_buffered_input is active, we are reading a script. If
1675 the command is asynchronous, we have already duplicated /dev/null
1676 as fd 0, but have not changed the buffered stream corresponding to
1677 the old fd 0. We don't want to sync the stream in this case. */
1678 if (default_buffered_input
!= -1 &&
1679 (!async_p
|| default_buffered_input
> 0))
1680 sync_buffered_stream (default_buffered_input
);
1681 #endif /* BUFFERED_INPUT */
1683 /* Create the child, handle severe errors. */
1684 if ((pid
= fork ()) < 0)
1688 /* Kill all of the processes in the current pipeline. */
1689 terminate_current_pipeline ();
1691 /* Discard the current pipeline, if any. */
1693 kill_current_pipeline ();
1695 throw_to_top_level (); /* Reset signals, etc. */
1700 /* In the child. Give this child the right process group, set the
1701 signals to the default state for a new process. */
1705 #if defined (BUFFERED_INPUT)
1706 /* Close default_buffered_input if it's > 0. We don't close it if it's
1707 0 because that's the file descriptor used when redirecting input,
1708 and it's wrong to close the file in that case. */
1709 unset_bash_input (0);
1710 #endif /* BUFFERED_INPUT */
1712 /* Restore top-level signal mask. */
1713 sigprocmask (SIG_SETMASK
, &top_level_mask
, (sigset_t
*)NULL
);
1717 /* All processes in this pipeline belong in the same
1720 if (pipeline_pgrp
== 0) /* This is the first child. */
1721 pipeline_pgrp
= mypid
;
1723 /* Check for running command in backquotes. */
1724 if (pipeline_pgrp
== shell_pgrp
)
1725 ignore_tty_job_signals ();
1727 default_tty_job_signals ();
1729 /* Set the process group before trying to mess with the terminal's
1730 process group. This is mandated by POSIX. */
1731 /* This is in accordance with the Posix 1003.1 standard,
1732 section B.7.2.4, which says that trying to set the terminal
1733 process group with tcsetpgrp() to an unused pgrp value (like
1734 this would have for the first child) is an error. Section
1735 B.4.3.3, p. 237 also covers this, in the context of job control
1737 if (setpgid (mypid
, pipeline_pgrp
) < 0)
1738 sys_error (_("child setpgid (%ld to %ld)"), (long)mypid
, (long)pipeline_pgrp
);
1740 /* By convention (and assumption above), if
1741 pipeline_pgrp == shell_pgrp, we are making a child for
1742 command substitution.
1743 In this case, we don't want to give the terminal to the
1744 shell's process group (we could be in the middle of a
1745 pipeline, for example). */
1746 if (async_p
== 0 && pipeline_pgrp
!= shell_pgrp
&& ((subshell_environment
&SUBSHELL_ASYNC
) == 0))
1747 give_terminal_to (pipeline_pgrp
, 0);
1749 #if defined (PGRP_PIPE)
1750 if (pipeline_pgrp
== mypid
)
1751 pipe_read (pgrp_pipe
);
1754 else /* Without job control... */
1756 if (pipeline_pgrp
== 0)
1757 pipeline_pgrp
= shell_pgrp
;
1759 /* If these signals are set to SIG_DFL, we encounter the curious
1760 situation of an interactive ^Z to a running process *working*
1761 and stopping the process, but being unable to do anything with
1762 that process to change its state. On the other hand, if they
1763 are set to SIG_IGN, jobs started from scripts do not stop when
1764 the shell running the script gets a SIGTSTP and stops. */
1766 default_tty_job_signals ();
1769 #if defined (PGRP_PIPE)
1770 /* Release the process group pipe, since our call to setpgid ()
1771 is done. The last call to pipe_close is done in stop_pipeline. */
1772 pipe_close (pgrp_pipe
);
1773 #endif /* PGRP_PIPE */
1777 last_asynchronous_pid
= mypid
; /* XXX */
1779 #if defined (RECYCLES_PIDS)
1780 else if (last_asynchronous_pid
== mypid
)
1781 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1782 last_asynchronous_pid
= 1;
1787 /* In the parent. Remember the pid of the child just created
1788 as the proper pgrp if this is the first child. */
1790 if (first_pid
== NO_PID
)
1792 else if (pid_wrap
== -1 && pid
< first_pid
)
1794 else if (pid_wrap
== 0 && pid
>= first_pid
)
1799 if (pipeline_pgrp
== 0)
1801 pipeline_pgrp
= pid
;
1802 /* Don't twiddle terminal pgrps in the parent! This is the bug,
1803 not the good thing of twiddling them in the child! */
1804 /* give_terminal_to (pipeline_pgrp, 0); */
1806 /* This is done on the recommendation of the Rationale section of
1807 the POSIX 1003.1 standard, where it discusses job control and
1808 shells. It is done to avoid possible race conditions. (Ref.
1809 1003.1 Rationale, section B.4.3.3, page 236). */
1810 setpgid (pid
, pipeline_pgrp
);
1814 if (pipeline_pgrp
== 0)
1815 pipeline_pgrp
= shell_pgrp
;
1818 /* Place all processes into the jobs array regardless of the
1819 state of job_control. */
1820 add_process (command
, pid
);
1823 last_asynchronous_pid
= pid
;
1824 #if defined (RECYCLES_PIDS)
1825 else if (last_asynchronous_pid
== pid
)
1826 /* Avoid pid aliasing. 1 seems like a safe, unusual pid value. */
1827 last_asynchronous_pid
= 1;
1831 delete_old_job (pid
);
1833 #if !defined (RECYCLES_PIDS)
1834 /* Only check for saved status if we've saved more than CHILD_MAX
1835 statuses, unless the system recycles pids. */
1836 if ((js
.c_reaped
+ bgpids
.npid
) >= js
.c_childmax
)
1838 bgp_delete (pid
); /* new process, discard any saved status */
1840 last_made_pid
= pid
;
1846 /* Unblock SIGINT and SIGCHLD unless creating a pipeline, in which case
1847 SIGCHLD remains blocked until all commands in the pipeline have been
1849 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
1855 /* These two functions are called only in child processes. */
1857 ignore_tty_job_signals ()
1859 set_signal_handler (SIGTSTP
, SIG_IGN
);
1860 set_signal_handler (SIGTTIN
, SIG_IGN
);
1861 set_signal_handler (SIGTTOU
, SIG_IGN
);
1865 default_tty_job_signals ()
1867 set_signal_handler (SIGTSTP
, SIG_DFL
);
1868 set_signal_handler (SIGTTIN
, SIG_DFL
);
1869 set_signal_handler (SIGTTOU
, SIG_DFL
);
1872 /* When we end a job abnormally, or if we stop a job, we set the tty to the
1873 state kept in here. When a job ends normally, we set the state in here
1874 to the state of the tty. */
1876 static TTYSTRUCT shell_tty_info
;
1878 #if defined (NEW_TTY_DRIVER)
1879 static struct tchars shell_tchars
;
1880 static struct ltchars shell_ltchars
;
1881 #endif /* NEW_TTY_DRIVER */
1883 #if defined (NEW_TTY_DRIVER) && defined (DRAIN_OUTPUT)
1884 /* Since the BSD tty driver does not allow us to change the tty modes
1885 while simultaneously waiting for output to drain and preserving
1886 typeahead, we have to drain the output ourselves before calling
1887 ioctl. We cheat by finding the length of the output queue, and
1888 using select to wait for an appropriate length of time. This is
1889 a hack, and should be labeled as such (it's a hastily-adapted
1890 mutation of a `usleep' implementation). It's only reason for
1891 existing is the flaw in the BSD tty driver. */
1893 static int ttspeeds
[] =
1895 0, 50, 75, 110, 134, 150, 200, 300, 600, 1200,
1896 1800, 2400, 4800, 9600, 19200, 38400
1903 register int delay
= ttspeeds
[ospeed
];
1909 while ((ioctl (fd
, TIOCOUTQ
, &n
) == 0) && n
)
1911 if (n
> (delay
/ 100))
1915 n
*= 10; /* 2 bits more for conservativeness. */
1916 tv
.tv_sec
= n
/ delay
;
1917 tv
.tv_usec
= ((n
% delay
) * 1000000) / delay
;
1918 select (fd
, (fd_set
*)0, (fd_set
*)0, (fd_set
*)0, &tv
);
1924 #endif /* NEW_TTY_DRIVER && DRAIN_OUTPUT */
1926 /* Return the fd from which we are actually getting input. */
1927 #define input_tty() (shell_tty != -1) ? shell_tty : fileno (stderr)
1929 /* Fill the contents of shell_tty_info with the current tty info. */
1938 #if defined (NEW_TTY_DRIVER)
1939 ioctl (tty
, TIOCGETP
, &shell_tty_info
);
1940 ioctl (tty
, TIOCGETC
, &shell_tchars
);
1941 ioctl (tty
, TIOCGLTC
, &shell_ltchars
);
1942 #endif /* NEW_TTY_DRIVER */
1944 #if defined (TERMIO_TTY_DRIVER)
1945 ioctl (tty
, TCGETA
, &shell_tty_info
);
1946 #endif /* TERMIO_TTY_DRIVER */
1948 #if defined (TERMIOS_TTY_DRIVER)
1949 if (tcgetattr (tty
, &shell_tty_info
) < 0)
1952 /* Only print an error message if we're really interactive at
1955 sys_error ("[%ld: %d] tcgetattr", (long)getpid (), shell_level
);
1959 #endif /* TERMIOS_TTY_DRIVER */
1960 if (check_window_size
)
1961 get_new_window_size (0, (int *)0, (int *)0);
1966 /* Make the current tty use the state in shell_tty_info. */
1975 #if defined (NEW_TTY_DRIVER)
1976 # if defined (DRAIN_OUTPUT)
1977 draino (tty
, shell_tty_info
.sg_ospeed
);
1978 # endif /* DRAIN_OUTPUT */
1979 ioctl (tty
, TIOCSETN
, &shell_tty_info
);
1980 ioctl (tty
, TIOCSETC
, &shell_tchars
);
1981 ioctl (tty
, TIOCSLTC
, &shell_ltchars
);
1982 #endif /* NEW_TTY_DRIVER */
1984 #if defined (TERMIO_TTY_DRIVER)
1985 ioctl (tty
, TCSETAW
, &shell_tty_info
);
1986 #endif /* TERMIO_TTY_DRIVER */
1988 #if defined (TERMIOS_TTY_DRIVER)
1989 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
1991 /* Only print an error message if we're really interactive at
1994 sys_error ("[%ld: %d] tcsetattr", (long)getpid (), shell_level
);
1997 #endif /* TERMIOS_TTY_DRIVER */
2002 /* Given an index into the jobs array JOB, return the PROCESS struct of the last
2003 process in that job's pipeline. This is the one whose exit status
2004 counts. Must be called with SIGCHLD blocked or queued. */
2006 find_last_proc (job
, block
)
2010 register PROCESS
*p
;
2014 BLOCK_CHILD (set
, oset
);
2016 p
= jobs
[job
]->pipe
;
2017 while (p
&& p
->next
!= jobs
[job
]->pipe
)
2021 UNBLOCK_CHILD (oset
);
2027 find_last_pid (job
, block
)
2033 p
= find_last_proc (job
, block
);
2034 /* Possible race condition here. */
2038 /* Wait for a particular child of the shell to finish executing.
2039 This low-level function prints an error message if PID is not
2040 a child of this shell. It returns -1 if it fails, or whatever
2041 wait_for returns otherwise. If the child is not found in the
2042 jobs table, it returns 127. */
2044 wait_for_single_pid (pid
)
2047 register PROCESS
*child
;
2051 BLOCK_CHILD (set
, oset
);
2052 child
= find_pipeline (pid
, 0, (int *)NULL
);
2053 UNBLOCK_CHILD (oset
);
2057 r
= bgp_search (pid
);
2064 internal_error (_("wait: pid %ld is not a child of this shell"), (long)pid
);
2070 /* POSIX.2: if we just waited for a job, we can remove it from the jobs
2072 BLOCK_CHILD (set
, oset
);
2073 job
= find_job (pid
, 0, NULL
);
2074 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2075 jobs
[job
]->flags
|= J_NOTIFIED
;
2076 UNBLOCK_CHILD (oset
);
2078 /* If running in posix mode, remove the job from the jobs table immediately */
2079 if (posixly_correct
)
2081 cleanup_dead_jobs ();
2088 /* Wait for all of the backgrounds of this shell to finish. */
2090 wait_for_background_pids ()
2092 register int i
, r
, waited_for
;
2096 for (waited_for
= 0;;)
2098 BLOCK_CHILD (set
, oset
);
2100 /* find first running job; if none running in foreground, break */
2101 /* XXX could use js.j_firstj and js.j_lastj here */
2102 for (i
= 0; i
< js
.j_jobslots
; i
++)
2105 if (i
< js
.j_firstj
&& jobs
[i
])
2106 itrace("wait_for_background_pids: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
2107 if (i
> js
.j_lastj
&& jobs
[i
])
2108 itrace("wait_for_background_pids: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
2110 if (jobs
[i
] && RUNNING (i
) && IS_FOREGROUND (i
) == 0)
2113 if (i
== js
.j_jobslots
)
2115 UNBLOCK_CHILD (oset
);
2119 /* now wait for the last pid in that job. */
2120 pid
= find_last_pid (i
, 0);
2121 UNBLOCK_CHILD (oset
);
2123 errno
= 0; /* XXX */
2124 r
= wait_for_single_pid (pid
);
2127 /* If we're mistaken about job state, compensate. */
2128 if (errno
== ECHILD
)
2129 mark_all_jobs_as_dead ();
2135 /* POSIX.2 says the shell can discard the statuses of all completed jobs if
2136 `wait' is called with no arguments. */
2137 mark_dead_jobs_as_notified (1);
2138 cleanup_dead_jobs ();
2142 /* Make OLD_SIGINT_HANDLER the SIGINT signal handler. */
2143 #define INVALID_SIGNAL_HANDLER (SigHandler *)wait_for_background_pids
2144 static SigHandler
*old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2147 restore_sigint_handler ()
2149 if (old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
2151 set_signal_handler (SIGINT
, old_sigint_handler
);
2152 old_sigint_handler
= INVALID_SIGNAL_HANDLER
;
2156 static int wait_sigint_received
;
2158 /* Handle SIGINT while we are waiting for children in a script to exit.
2159 The `wait' builtin should be interruptible, but all others should be
2160 effectively ignored (i.e. not cause the shell to exit). */
2162 wait_sigint_handler (sig
)
2165 SigHandler
*sigint_handler
;
2167 if (interrupt_immediately
||
2168 (this_shell_builtin
&& this_shell_builtin
== wait_builtin
))
2170 last_command_exit_value
= EXECUTION_FAILURE
;
2171 restore_sigint_handler ();
2172 /* If we got a SIGINT while in `wait', and SIGINT is trapped, do
2173 what POSIX.2 says (see builtins/wait.def for more info). */
2174 if (this_shell_builtin
&& this_shell_builtin
== wait_builtin
&&
2175 signal_is_trapped (SIGINT
) &&
2176 ((sigint_handler
= trap_to_sighandler (SIGINT
)) == trap_handler
))
2178 interrupt_immediately
= 0;
2179 trap_handler (SIGINT
); /* set pending_traps[SIGINT] */
2180 wait_signal_received
= SIGINT
;
2181 longjmp (wait_intr_buf
, 1);
2188 /* XXX - should this be interrupt_state? If it is, the shell will act
2189 as if it got the SIGINT interrupt. */
2190 wait_sigint_received
= 1;
2192 /* Otherwise effectively ignore the SIGINT and allow the running job to
2198 process_exit_signal (status
)
2201 return (WIFSIGNALED (status
) ? WTERMSIG (status
) : 0);
2205 process_exit_status (status
)
2208 if (WIFSIGNALED (status
))
2209 return (128 + WTERMSIG (status
));
2210 else if (WIFSTOPPED (status
) == 0)
2211 return (WEXITSTATUS (status
));
2213 return (EXECUTION_SUCCESS
);
2216 /* Return the exit status of the last process in the pipeline for job JOB.
2217 This is the exit status of the entire job. */
2219 raw_job_exit_status (job
)
2222 register PROCESS
*p
;
2228 p
= jobs
[job
]->pipe
;
2231 if (WSTATUS (p
->status
) != EXECUTION_SUCCESS
) fail
= WSTATUS(p
->status
);
2234 while (p
!= jobs
[job
]->pipe
);
2238 for (p
= jobs
[job
]->pipe
; p
->next
!= jobs
[job
]->pipe
; p
= p
->next
)
2243 /* Return the exit status of job JOB. This is the exit status of the last
2244 (rightmost) process in the job's pipeline, modified if the job was killed
2245 by a signal or stopped. */
2247 job_exit_status (job
)
2250 return (process_exit_status (raw_job_exit_status (job
)));
2254 job_exit_signal (job
)
2257 return (process_exit_signal (raw_job_exit_status (job
)));
2260 #define FIND_CHILD(pid, child) \
2263 child = find_pipeline (pid, 0, (int *)NULL); \
2266 give_terminal_to (shell_pgrp, 0); \
2267 UNBLOCK_CHILD (oset); \
2268 internal_error (_("wait_for: No record of process %ld"), (long)pid); \
2269 restore_sigint_handler (); \
2270 return (termination_state = 127); \
2275 /* Wait for pid (one of our children) to terminate, then
2276 return the termination state. Returns 127 if PID is not found in
2277 the jobs table. Returns -1 if waitchld() returns -1, indicating
2278 that there are no unwaited-for child processes. */
2283 int job
, termination_state
, r
;
2285 register PROCESS
*child
;
2287 register PROCESS
*p
;
2289 /* In the case that this code is interrupted, and we longjmp () out of it,
2290 we are relying on the code in throw_to_top_level () to restore the
2291 top-level signal mask. */
2292 BLOCK_CHILD (set
, oset
);
2294 /* Ignore interrupts while waiting for a job run without job control
2295 to finish. We don't want the shell to exit if an interrupt is
2296 received, only if one of the jobs run is killed via SIGINT. If
2297 job control is not set, the job will be run in the same pgrp as
2298 the shell, and the shell will see any signals the job gets. */
2300 /* This is possibly a race condition -- should it go in stop_pipeline? */
2301 wait_sigint_received
= 0;
2302 if (job_control
== 0)
2304 old_sigint_handler
= set_signal_handler (SIGINT
, wait_sigint_handler
);
2305 if (old_sigint_handler
== SIG_IGN
)
2306 set_signal_handler (SIGINT
, old_sigint_handler
);
2309 termination_state
= last_command_exit_value
;
2311 if (interactive
&& job_control
== 0)
2314 /* If we say wait_for (), then we have a record of this child somewhere.
2315 If it and none of its peers are running, don't call waitchld(). */
2320 FIND_CHILD (pid
, child
);
2322 /* If this child is part of a job, then we are really waiting for the
2323 job to finish. Otherwise, we are waiting for the child to finish.
2324 We check for JDEAD in case the job state has been set by waitchld
2325 after receipt of a SIGCHLD. */
2327 job
= find_job (pid
, 0, NULL
);
2329 /* waitchld() takes care of setting the state of the job. If the job
2330 has already exited before this is called, sigchld_handler will have
2331 called waitchld and the state will be set to JDEAD. */
2333 if (PRUNNING(child
) || (job
!= NO_JOB
&& RUNNING (job
)))
2335 #if defined (WAITPID_BROKEN) /* SCOv4 */
2336 sigset_t suspend_set
;
2337 sigemptyset (&suspend_set
);
2338 sigsuspend (&suspend_set
);
2339 #else /* !WAITPID_BROKEN */
2340 # if defined (MUST_UNBLOCK_CHLD)
2341 struct sigaction act
, oact
;
2342 sigset_t nullset
, chldset
;
2344 sigemptyset (&nullset
);
2345 sigemptyset (&chldset
);
2346 sigprocmask (SIG_SETMASK
, &nullset
, &chldset
);
2347 act
.sa_handler
= SIG_DFL
;
2348 sigemptyset (&act
.sa_mask
);
2349 sigemptyset (&oact
.sa_mask
);
2351 sigaction (SIGCHLD
, &act
, &oact
);
2354 r
= waitchld (pid
, 1);
2355 # if defined (MUST_UNBLOCK_CHLD)
2356 sigaction (SIGCHLD
, &oact
, (struct sigaction
*)NULL
);
2357 sigprocmask (SIG_SETMASK
, &chldset
, (sigset_t
*)NULL
);
2360 if (r
== -1 && errno
== ECHILD
&& this_shell_builtin
== wait_builtin
)
2362 termination_state
= -1;
2363 goto wait_for_return
;
2366 /* If child is marked as running, but waitpid() returns -1/ECHILD,
2367 there is something wrong. Somewhere, wait should have returned
2368 that child's pid. Mark the child as not running and the job,
2369 if it exists, as JDEAD. */
2370 if (r
== -1 && errno
== ECHILD
)
2372 child
->running
= PS_DONE
;
2373 WSTATUS (child
->status
) = 0; /* XXX -- can't find true status */
2374 js
.c_living
= 0; /* no living child processes */
2377 jobs
[job
]->state
= JDEAD
;
2382 #endif /* WAITPID_BROKEN */
2385 /* If the shell is interactive, and job control is disabled, see
2386 if the foreground process has died due to SIGINT and jump out
2387 of the wait loop if it has. waitchld has already restored the
2388 old SIGINT signal handler. */
2389 if (interactive
&& job_control
== 0)
2392 while (PRUNNING (child
) || (job
!= NO_JOB
&& RUNNING (job
)));
2394 /* The exit state of the command is either the termination state of the
2395 child, or the termination state of the job. If a job, the status
2396 of the last child in the pipeline is the significant one. If the command
2397 or job was terminated by a signal, note that value also. */
2398 termination_state
= (job
!= NO_JOB
) ? job_exit_status (job
)
2399 : process_exit_status (child
->status
);
2400 last_command_exit_signal
= (job
!= NO_JOB
) ? job_exit_signal (job
)
2401 : process_exit_signal (child
->status
);
2404 if ((job
!= NO_JOB
&& JOBSTATE (job
) == JSTOPPED
) || WIFSTOPPED (child
->status
))
2405 termination_state
= 128 + WSTOPSIG (child
->status
);
2407 if (job
== NO_JOB
|| IS_JOBCONTROL (job
))
2409 /* XXX - under what circumstances is a job not present in the jobs
2410 table (job == NO_JOB)?
2411 1. command substitution
2413 In the case of command substitution, at least, it's probably not
2414 the right thing to give the terminal to the shell's process group,
2415 even though there is code in subst.c:command_substitute to work
2419 $PROMPT_COMMAND execution
2420 process substitution
2424 itrace("wait_for: job == NO_JOB, giving the terminal to shell_pgrp (%ld)", (long)shell_pgrp
);
2426 give_terminal_to (shell_pgrp
, 0);
2429 /* If the command did not exit cleanly, or the job is just
2430 being stopped, then reset the tty state back to what it
2431 was before this command. Reset the tty state and notify
2432 the user of the job termination only if the shell is
2433 interactive. Clean up any dead jobs in either case. */
2436 if (interactive_shell
&& subshell_environment
== 0)
2438 /* This used to use `child->status'. That's wrong, however, for
2439 pipelines. `child' is the first process in the pipeline. It's
2440 likely that the process we want to check for abnormal termination
2441 or stopping is the last process in the pipeline, especially if
2442 it's long-lived and the first process is short-lived. Since we
2443 know we have a job here, we can check all the processes in this
2444 job's pipeline and see if one of them stopped or terminated due
2445 to a signal. We might want to change this later to just check
2446 the last process in the pipeline. If no process exits due to a
2447 signal, S is left as the status of the last job in the pipeline. */
2448 p
= jobs
[job
]->pipe
;
2452 if (WIFSIGNALED(s
) || WIFSTOPPED(s
))
2456 while (p
!= jobs
[job
]->pipe
);
2458 if (WIFSIGNALED (s
) || WIFSTOPPED (s
))
2462 /* If the current job was stopped or killed by a signal, and
2463 the user has requested it, get a possibly new window size */
2464 if (check_window_size
&& (job
== js
.j_current
|| IS_FOREGROUND (job
)))
2465 get_new_window_size (0, (int *)0, (int *)0);
2470 /* If job control is enabled, the job was started with job
2471 control, the job was the foreground job, and it was killed
2472 by SIGINT, then print a newline to compensate for the kernel
2473 printing the ^C without a trailing newline. */
2474 if (job_control
&& IS_JOBCONTROL (job
) && IS_FOREGROUND (job
) &&
2475 WIFSIGNALED (s
) && WTERMSIG (s
) == SIGINT
)
2477 /* If SIGINT is not trapped and the shell is in a for, while,
2478 or until loop, act as if the shell received SIGINT as
2479 well, so the loop can be broken. This doesn't call the
2480 SIGINT signal handler; maybe it should. */
2481 if (signal_is_trapped (SIGINT
) == 0 && loop_level
)
2491 /* Moved here from set_job_status_and_cleanup, which is in the SIGCHLD
2492 signal handler path */
2493 if (DEADJOB (job
) && IS_FOREGROUND (job
) /*&& subshell_environment == 0*/)
2496 /* If this job is dead, notify the user of the status. If the shell
2497 is interactive, this will display a message on the terminal. If
2498 the shell is not interactive, make sure we turn on the notify bit
2499 so we don't get an unwanted message about the job's termination,
2500 and so delete_job really clears the slot in the jobs table. */
2501 notify_and_cleanup ();
2506 UNBLOCK_CHILD (oset
);
2508 /* Restore the original SIGINT signal handler before we return. */
2509 restore_sigint_handler ();
2511 return (termination_state
);
2514 /* Wait for the last process in the pipeline for JOB. Returns whatever
2515 wait_for returns: the last process's termination state or -1 if there
2516 are no unwaited-for child processes or an error occurs. */
2525 BLOCK_CHILD(set
, oset
);
2526 if (JOBSTATE (job
) == JSTOPPED
)
2527 internal_warning (_("wait_for_job: job %d is stopped"), job
+1);
2529 pid
= find_last_pid (job
, 0);
2530 UNBLOCK_CHILD(oset
);
2533 /* POSIX.2: we can remove the job from the jobs table if we just waited
2535 BLOCK_CHILD (set
, oset
);
2536 if (job
!= NO_JOB
&& jobs
[job
] && DEADJOB (job
))
2537 jobs
[job
]->flags
|= J_NOTIFIED
;
2538 UNBLOCK_CHILD (oset
);
2543 /* Print info about dead jobs, and then delete them from the list
2544 of known jobs. This does not actually delete jobs when the
2545 shell is not interactive, because the dead jobs are not marked
2548 notify_and_cleanup ()
2550 if (jobs_list_frozen
)
2553 if (interactive
|| interactive_shell
== 0 || sourcelevel
)
2554 notify_of_job_status ();
2556 cleanup_dead_jobs ();
2559 /* Make dead jobs disappear from the jobs array without notification.
2560 This is used when the shell is not interactive. */
2564 mark_dead_jobs_as_notified (0);
2565 cleanup_dead_jobs ();
2568 /* Return the next closest (chronologically) job to JOB which is in
2569 STATE. STATE can be JSTOPPED, JRUNNING. NO_JOB is returned if
2570 there is no next recent job. */
2572 most_recent_job_in_state (job
, state
)
2576 register int i
, result
;
2579 BLOCK_CHILD (set
, oset
);
2581 for (result
= NO_JOB
, i
= job
- 1; i
>= 0; i
--)
2583 if (jobs
[i
] && (JOBSTATE (i
) == state
))
2590 UNBLOCK_CHILD (oset
);
2595 /* Return the newest *stopped* job older than JOB, or NO_JOB if not
2598 job_last_stopped (job
)
2601 return (most_recent_job_in_state (job
, JSTOPPED
));
2604 /* Return the newest *running* job older than JOB, or NO_JOB if not
2607 job_last_running (job
)
2610 return (most_recent_job_in_state (job
, JRUNNING
));
2613 /* Make JOB be the current job, and make previous be useful. Must be
2614 called with SIGCHLD blocked. */
2616 set_current_job (job
)
2621 if (js
.j_current
!= job
)
2623 js
.j_previous
= js
.j_current
;
2627 /* First choice for previous job is the old current job. */
2628 if (js
.j_previous
!= js
.j_current
&&
2629 js
.j_previous
!= NO_JOB
&&
2630 jobs
[js
.j_previous
] &&
2631 STOPPED (js
.j_previous
))
2634 /* Second choice: Newest stopped job that is older than
2637 if (STOPPED (js
.j_current
))
2639 candidate
= job_last_stopped (js
.j_current
);
2641 if (candidate
!= NO_JOB
)
2643 js
.j_previous
= candidate
;
2648 /* If we get here, there is either only one stopped job, in which case it is
2649 the current job and the previous job should be set to the newest running
2650 job, or there are only running jobs and the previous job should be set to
2651 the newest running job older than the current job. We decide on which
2652 alternative to use based on whether or not JOBSTATE(js.j_current) is
2655 candidate
= RUNNING (js
.j_current
) ? job_last_running (js
.j_current
)
2656 : job_last_running (js
.j_jobslots
);
2658 if (candidate
!= NO_JOB
)
2660 js
.j_previous
= candidate
;
2664 /* There is only a single job, and it is both `+' and `-'. */
2665 js
.j_previous
= js
.j_current
;
2668 /* Make current_job be something useful, if it isn't already. */
2670 /* Here's the deal: The newest non-running job should be `+', and the
2671 next-newest non-running job should be `-'. If there is only a single
2672 stopped job, the js.j_previous is the newest non-running job. If there
2673 are only running jobs, the newest running job is `+' and the
2674 next-newest running job is `-'. Must be called with SIGCHLD blocked. */
2681 if (js
.j_jobslots
&& js
.j_current
!= NO_JOB
&& jobs
[js
.j_current
] && STOPPED (js
.j_current
))
2682 candidate
= js
.j_current
;
2687 /* First choice: the previous job. */
2688 if (js
.j_previous
!= NO_JOB
&& jobs
[js
.j_previous
] && STOPPED (js
.j_previous
))
2689 candidate
= js
.j_previous
;
2691 /* Second choice: the most recently stopped job. */
2692 if (candidate
== NO_JOB
)
2693 candidate
= job_last_stopped (js
.j_jobslots
);
2695 /* Third choice: the newest running job. */
2696 if (candidate
== NO_JOB
)
2697 candidate
= job_last_running (js
.j_jobslots
);
2700 /* If we found a job to use, then use it. Otherwise, there
2701 are no jobs period. */
2702 if (candidate
!= NO_JOB
)
2703 set_current_job (candidate
);
2705 js
.j_current
= js
.j_previous
= NO_JOB
;
2708 /* Set up the job structures so we know the job and its processes are
2711 set_job_running (job
)
2714 register PROCESS
*p
;
2716 /* Each member of the pipeline is now running. */
2717 p
= jobs
[job
]->pipe
;
2721 if (WIFSTOPPED (p
->status
))
2722 p
->running
= PS_RUNNING
; /* XXX - could be PS_STOPPED */
2725 while (p
!= jobs
[job
]->pipe
);
2727 /* This means that the job is running. */
2728 JOBSTATE (job
) = JRUNNING
;
2731 /* Start a job. FOREGROUND if non-zero says to do that. Otherwise,
2732 start the job in the background. JOB is a zero-based index into
2733 JOBS. Returns -1 if it is unable to start a job, and the return
2734 status of the job otherwise. */
2736 start_job (job
, foreground
)
2737 int job
, foreground
;
2739 register PROCESS
*p
;
2740 int already_running
;
2743 static TTYSTRUCT save_stty
;
2745 BLOCK_CHILD (set
, oset
);
2749 internal_error (_("%s: job has terminated"), this_command_name
);
2750 UNBLOCK_CHILD (oset
);
2754 already_running
= RUNNING (job
);
2756 if (foreground
== 0 && already_running
)
2758 internal_error (_("%s: job %d already in background"), this_command_name
, job
+ 1);
2759 UNBLOCK_CHILD (oset
);
2760 return (0); /* XPG6/SUSv3 says this is not an error */
2763 wd
= current_working_directory ();
2765 /* You don't know about the state of this job. Do you? */
2766 jobs
[job
]->flags
&= ~J_NOTIFIED
;
2770 set_current_job (job
);
2771 jobs
[job
]->flags
|= J_FOREGROUND
;
2774 /* Tell the outside world what we're doing. */
2775 p
= jobs
[job
]->pipe
;
2777 if (foreground
== 0)
2779 /* POSIX.2 says `bg' doesn't give any indication about current or
2781 if (posixly_correct
== 0)
2782 s
= (job
== js
.j_current
) ? "+ ": ((job
== js
.j_previous
) ? "- " : " ");
2785 printf ("[%d]%s", job
+ 1, s
);
2791 p
->command
? p
->command
: "",
2792 p
->next
!= jobs
[job
]->pipe
? " | " : "");
2795 while (p
!= jobs
[job
]->pipe
);
2797 if (foreground
== 0)
2800 if (strcmp (wd
, jobs
[job
]->wd
) != 0)
2801 printf (" (wd: %s)", polite_directory_format (jobs
[job
]->wd
));
2806 if (already_running
== 0)
2807 set_job_running (job
);
2809 /* Save the tty settings before we start the job in the foreground. */
2813 save_stty
= shell_tty_info
;
2814 /* Give the terminal to this job. */
2815 if (IS_JOBCONTROL (job
))
2816 give_terminal_to (jobs
[job
]->pgrp
, 0);
2819 jobs
[job
]->flags
&= ~J_FOREGROUND
;
2821 /* If the job is already running, then don't bother jump-starting it. */
2822 if (already_running
== 0)
2824 jobs
[job
]->flags
|= J_NOTIFIED
;
2825 killpg (jobs
[job
]->pgrp
, SIGCONT
);
2833 pid
= find_last_pid (job
, 0);
2834 UNBLOCK_CHILD (oset
);
2835 st
= wait_for (pid
);
2836 shell_tty_info
= save_stty
;
2843 UNBLOCK_CHILD (oset
);
2848 /* Give PID SIGNAL. This determines what job the pid belongs to (if any).
2849 If PID does belong to a job, and the job is stopped, then CONTinue the
2850 job after giving it SIGNAL. Returns -1 on failure. If GROUP is non-null,
2851 then kill the process group associated with PID. */
2853 kill_pid (pid
, sig
, group
)
2857 register PROCESS
*p
;
2858 int job
, result
, negative
;
2864 group
= negative
= 1;
2869 result
= EXECUTION_SUCCESS
;
2872 BLOCK_CHILD (set
, oset
);
2873 p
= find_pipeline (pid
, 0, &job
);
2877 jobs
[job
]->flags
&= ~J_NOTIFIED
;
2879 /* Kill process in backquotes or one started without job control? */
2881 /* If we're passed a pid < -1, just call killpg and see what happens */
2882 if (negative
&& jobs
[job
]->pgrp
== shell_pgrp
)
2883 result
= killpg (pid
, sig
);
2884 /* If we're killing using job control notification, for example,
2885 without job control active, we have to do things ourselves. */
2886 else if (jobs
[job
]->pgrp
== shell_pgrp
)
2888 p
= jobs
[job
]->pipe
;
2891 if (PALIVE (p
) == 0)
2892 continue; /* avoid pid recycling problem */
2894 if (PEXITED (p
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
2895 kill (p
->pid
, SIGCONT
);
2898 while (p
!= jobs
[job
]->pipe
);
2902 result
= killpg (jobs
[job
]->pgrp
, sig
);
2903 if (p
&& STOPPED (job
) && (sig
== SIGTERM
|| sig
== SIGHUP
))
2904 killpg (jobs
[job
]->pgrp
, SIGCONT
);
2905 /* If we're continuing a stopped job via kill rather than bg or
2906 fg, emulate the `bg' behavior. */
2907 if (p
&& STOPPED (job
) && (sig
== SIGCONT
))
2909 set_job_running (job
);
2910 jobs
[job
]->flags
&= ~J_FOREGROUND
;
2911 jobs
[job
]->flags
|= J_NOTIFIED
;
2916 result
= killpg (pid
, sig
);
2918 UNBLOCK_CHILD (oset
);
2921 result
= kill (pid
, sig
);
2926 /* sigchld_handler () flushes at least one of the children that we are
2927 waiting for. It gets run when we have gotten a SIGCHLD signal. */
2929 sigchld_handler (sig
)
2935 REINSTALL_SIGCHLD_HANDLER
;
2938 if (queue_sigchld
== 0)
2939 n
= waitchld (-1, 0);
2944 /* waitchld() reaps dead or stopped children. It's called by wait_for and
2945 sigchld_handler, and runs until there aren't any children terminating any
2947 If BLOCK is 1, this is to be a blocking wait for a single child, although
2948 an arriving SIGCHLD could cause the wait to be non-blocking. It returns
2949 the number of children reaped, or -1 if there are no unwaited-for child
2952 waitchld (wpid
, block
)
2959 int call_set_current
, last_stopped_job
, job
, children_exited
, waitpid_flags
;
2960 static int wcontinued
= WCONTINUED
; /* run-time fix for glibc problem */
2962 call_set_current
= children_exited
= 0;
2963 last_stopped_job
= NO_JOB
;
2967 /* We don't want to be notified about jobs stopping if job control
2968 is not active. XXX - was interactive_shell instead of job_control */
2969 waitpid_flags
= (job_control
&& subshell_environment
== 0)
2970 ? (WUNTRACED
|wcontinued
)
2972 if (sigchld
|| block
== 0)
2973 waitpid_flags
|= WNOHANG
;
2975 pid
= WAITPID (-1, &status
, waitpid_flags
);
2977 /* WCONTINUED may be rejected by waitpid as invalid even when defined */
2978 if (wcontinued
&& pid
< 0 && errno
== EINVAL
)
2981 continue; /* jump back to the test and retry without WCONTINUED */
2984 /* The check for WNOHANG is to make sure we decrement sigchld only
2985 if it was non-zero before we called waitpid. */
2986 if (sigchld
> 0 && (waitpid_flags
& WNOHANG
))
2989 /* If waitpid returns -1 with errno == ECHILD, there are no more
2990 unwaited-for child processes of this shell. */
2991 if (pid
< 0 && errno
== ECHILD
)
2993 if (children_exited
== 0)
2999 /* If waitpid returns 0, there are running children. If it returns -1,
3000 the only other error POSIX says it can return is EINTR. */
3003 continue; /* jumps right to the test */
3005 /* children_exited is used to run traps on SIGCHLD. We don't want to
3006 run the trap if a process is just being continued. */
3007 if (WIFCONTINUED(status
) == 0)
3013 /* Locate our PROCESS for this pid. */
3014 child
= find_process (pid
, 1, &job
); /* want living procs only */
3016 /* It is not an error to have a child terminate that we did
3017 not have a record of. This child could have been part of
3018 a pipeline in backquote substitution. Even so, I'm not
3019 sure child is ever non-zero. */
3023 /* Remember status, and whether or not the process is running. */
3024 child
->status
= status
;
3025 child
->running
= WIFCONTINUED(status
) ? PS_RUNNING
: PS_DONE
;
3027 if (PEXITED (child
))
3037 call_set_current
+= set_job_status_and_cleanup (job
);
3040 last_stopped_job
= job
;
3041 else if (DEADJOB (job
) && last_stopped_job
== job
)
3042 last_stopped_job
= NO_JOB
;
3044 while ((sigchld
|| block
== 0) && pid
> (pid_t
)0);
3046 /* If a job was running and became stopped, then set the current
3047 job. Otherwise, don't change a thing. */
3048 if (call_set_current
)
3050 if (last_stopped_job
!= NO_JOB
)
3051 set_current_job (last_stopped_job
);
3056 /* Call a SIGCHLD trap handler for each child that exits, if one is set. */
3057 if (job_control
&& signal_is_trapped (SIGCHLD
) && children_exited
&&
3058 trap_list
[SIGCHLD
] != (char *)IGNORE_SIG
)
3059 run_sigchld_trap (children_exited
);
3061 /* We have successfully recorded the useful information about this process
3062 that has just changed state. If we notify asynchronously, and the job
3063 that this process belongs to is no longer running, then notify the user
3064 of that fact now. */
3065 if (asynchronous_notification
&& interactive
)
3066 notify_of_job_status ();
3068 return (children_exited
);
3071 /* Set the status of JOB and perform any necessary cleanup if the job is
3074 Currently, the cleanup activity is restricted to handling any SIGINT
3075 received while waiting for a foreground job to finish. */
3077 set_job_status_and_cleanup (job
)
3081 int tstatus
, job_state
, any_stopped
, any_tstped
, call_set_current
;
3082 SigHandler
*temp_handler
;
3084 child
= jobs
[job
]->pipe
;
3085 jobs
[job
]->flags
&= ~J_NOTIFIED
;
3087 call_set_current
= 0;
3090 * COMPUTE JOB STATUS
3093 /* If all children are not running, but any of them is stopped, then
3094 the job is stopped, not dead. */
3095 job_state
= any_stopped
= any_tstped
= 0;
3098 job_state
|= PRUNNING (child
);
3100 if (PEXITED (child
) && (WIFSTOPPED (child
->status
)))
3102 /* Only checking for WIFSTOPPED now, not for PS_DONE */
3103 if (PSTOPPED (child
))
3107 any_tstped
|= interactive
&& job_control
&&
3108 (WSTOPSIG (child
->status
) == SIGTSTP
);
3110 child
= child
->next
;
3112 while (child
!= jobs
[job
]->pipe
);
3114 /* If job_state != 0, the job is still running, so don't bother with
3115 setting the process exit status and job state unless we're
3116 transitioning from stopped to running. */
3117 if (job_state
!= 0 && JOBSTATE(job
) != JSTOPPED
)
3124 /* The job is either stopped or dead. Set the state of the job accordingly. */
3127 jobs
[job
]->state
= JSTOPPED
;
3128 jobs
[job
]->flags
&= ~J_FOREGROUND
;
3130 /* Suspending a job with SIGTSTP breaks all active loops. */
3131 if (any_tstped
&& loop_level
)
3132 breaking
= loop_level
;
3134 else if (job_state
!= 0) /* was stopped, now running */
3136 jobs
[job
]->state
= JRUNNING
;
3141 jobs
[job
]->state
= JDEAD
;
3145 if (IS_FOREGROUND (job
))
3149 /* If this job has a cleanup function associated with it, call it
3150 with `cleanarg' as the single argument, then set the function
3151 pointer to NULL so it is not inadvertently called twice. The
3152 cleanup function is responsible for deallocating cleanarg. */
3153 if (jobs
[job
]->j_cleanup
)
3155 (*jobs
[job
]->j_cleanup
) (jobs
[job
]->cleanarg
);
3156 jobs
[job
]->j_cleanup
= (sh_vptrfunc_t
*)NULL
;
3163 * Currently, we just do special things if we got a SIGINT while waiting
3164 * for a foreground job to complete
3167 if (JOBSTATE (job
) == JDEAD
)
3169 /* If we're running a shell script and we get a SIGINT with a
3170 SIGINT trap handler, but the foreground job handles it and
3171 does not exit due to SIGINT, run the trap handler but do not
3172 otherwise act as if we got the interrupt. */
3173 if (wait_sigint_received
&& interactive_shell
== 0 &&
3174 WIFSIGNALED (child
->status
) == 0 && IS_FOREGROUND (job
) &&
3175 signal_is_trapped (SIGINT
))
3178 wait_sigint_received
= 0;
3179 last_command_exit_value
= process_exit_status (child
->status
);
3181 old_frozen
= jobs_list_frozen
;
3182 jobs_list_frozen
= 1;
3183 tstatus
= maybe_call_trap_handler (SIGINT
);
3184 jobs_list_frozen
= old_frozen
;
3187 /* If the foreground job is killed by SIGINT when job control is not
3188 active, we need to perform some special handling.
3190 The check of wait_sigint_received is a way to determine if the
3191 SIGINT came from the keyboard (in which case the shell has already
3192 seen it, and wait_sigint_received is non-zero, because keyboard
3193 signals are sent to process groups) or via kill(2) to the foreground
3194 process by another process (or itself). If the shell did receive the
3195 SIGINT, it needs to perform normal SIGINT processing. */
3196 else if (wait_sigint_received
&& (WTERMSIG (child
->status
) == SIGINT
) &&
3197 IS_FOREGROUND (job
) && IS_JOBCONTROL (job
) == 0)
3201 wait_sigint_received
= 0;
3203 /* If SIGINT is trapped, set the exit status so that the trap
3204 handler can see it. */
3205 if (signal_is_trapped (SIGINT
))
3206 last_command_exit_value
= process_exit_status (child
->status
);
3208 /* If the signal is trapped, let the trap handler get it no matter
3209 what and simply return if the trap handler returns.
3210 maybe_call_trap_handler() may cause dead jobs to be removed from
3211 the job table because of a call to execute_command. We work
3212 around this by setting JOBS_LIST_FROZEN. */
3213 old_frozen
= jobs_list_frozen
;
3214 jobs_list_frozen
= 1;
3215 tstatus
= maybe_call_trap_handler (SIGINT
);
3216 jobs_list_frozen
= old_frozen
;
3217 if (tstatus
== 0 && old_sigint_handler
!= INVALID_SIGNAL_HANDLER
)
3219 /* wait_sigint_handler () has already seen SIGINT and
3220 allowed the wait builtin to jump out. We need to
3221 call the original SIGINT handler, if necessary. If
3222 the original handler is SIG_DFL, we need to resend
3223 the signal to ourselves. */
3225 temp_handler
= old_sigint_handler
;
3227 /* Bogus. If we've reset the signal handler as the result
3228 of a trap caught on SIGINT, then old_sigint_handler
3229 will point to trap_handler, which now knows nothing about
3230 SIGINT (if we reset the sighandler to the default).
3231 In this case, we have to fix things up. What a crock. */
3232 if (temp_handler
== trap_handler
&& signal_is_trapped (SIGINT
) == 0)
3233 temp_handler
= trap_to_sighandler (SIGINT
);
3234 restore_sigint_handler ();
3235 if (temp_handler
== SIG_DFL
)
3236 termsig_handler (SIGINT
);
3237 else if (temp_handler
!= SIG_IGN
)
3238 (*temp_handler
) (SIGINT
);
3243 return call_set_current
;
3246 /* Build the array of values for the $PIPESTATUS variable from the set of
3247 exit statuses of all processes in the job J. */
3252 #if defined (ARRAY_VARS)
3254 register PROCESS
*p
;
3256 for (i
= 1, p
= jobs
[j
]->pipe
; p
->next
!= jobs
[j
]->pipe
; p
= p
->next
, i
++)
3261 pstatuses
= (int *)xrealloc (pstatuses
, i
* sizeof (int));
3268 pstatuses
[i
++] = process_exit_status (p
->status
);
3271 while (p
!= jobs
[j
]->pipe
);
3273 pstatuses
[i
] = -1; /* sentinel */
3274 set_pipestatus_array (pstatuses
, i
);
3279 run_sigchld_trap (nchild
)
3285 /* Turn off the trap list during the call to parse_and_execute ()
3286 to avoid potentially infinite recursive calls. Preserve the
3287 values of last_command_exit_value, last_made_pid, and the_pipeline
3288 around the execution of the trap commands. */
3289 trap_command
= savestring (trap_list
[SIGCHLD
]);
3291 begin_unwind_frame ("SIGCHLD trap");
3292 unwind_protect_int (last_command_exit_value
);
3293 unwind_protect_int (last_command_exit_signal
);
3294 unwind_protect_var (last_made_pid
);
3295 unwind_protect_int (interrupt_immediately
);
3296 unwind_protect_int (jobs_list_frozen
);
3297 unwind_protect_pointer (the_pipeline
);
3298 unwind_protect_pointer (subst_assign_varlist
);
3300 /* We have to add the commands this way because they will be run
3301 in reverse order of adding. We don't want maybe_set_sigchld_trap ()
3302 to reference freed memory. */
3303 add_unwind_protect (xfree
, trap_command
);
3304 add_unwind_protect (maybe_set_sigchld_trap
, trap_command
);
3306 subst_assign_varlist
= (WORD_LIST
*)NULL
;
3307 the_pipeline
= (PROCESS
*)NULL
;
3309 restore_default_signal (SIGCHLD
);
3310 jobs_list_frozen
= 1;
3311 for (i
= 0; i
< nchild
; i
++)
3313 interrupt_immediately
= 1;
3314 parse_and_execute (savestring (trap_command
), "trap", SEVAL_NOHIST
|SEVAL_RESETLINE
);
3317 run_unwind_frame ("SIGCHLD trap");
3320 /* Function to call when you want to notify people of changes
3321 in job status. This prints out all jobs which are pending
3322 notification to stderr, and marks those printed as already
3323 notified, thus making them candidates for cleanup. */
3325 notify_of_job_status ()
3327 register int job
, termsig
;
3332 if (jobs
== 0 || js
.j_jobslots
== 0)
3338 sigaddset (&set
, SIGCHLD
);
3339 sigaddset (&set
, SIGTTOU
);
3340 sigemptyset (&oset
);
3341 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3346 /* XXX could use js.j_firstj here */
3347 for (job
= 0, dir
= (char *)NULL
; job
< js
.j_jobslots
; job
++)
3349 if (jobs
[job
] && IS_NOTIFIED (job
) == 0)
3351 s
= raw_job_exit_status (job
);
3352 termsig
= WTERMSIG (s
);
3354 /* POSIX.2 says we have to hang onto the statuses of at most the
3355 last CHILD_MAX background processes if the shell is running a
3356 script. If the shell is running a script, either from a file
3357 or standard input, don't print anything unless the job was
3358 killed by a signal. */
3359 if (startup_state
== 0 && WIFSIGNALED (s
) == 0 &&
3360 ((DEADJOB (job
) && IS_FOREGROUND (job
) == 0) || STOPPED (job
)))
3364 /* If job control is disabled, don't print the status messages.
3365 Mark dead jobs as notified so that they get cleaned up. If
3366 startup_state == 2, we were started to run `-c command', so
3367 don't print anything. */
3368 if ((job_control
== 0 && interactive_shell
) || startup_state
== 2)
3370 /* If job control is disabled, don't print the status messages.
3371 Mark dead jobs as notified so that they get cleaned up. If
3372 startup_state == 2 and subshell_environment has the
3373 SUBSHELL_COMSUB bit turned on, we were started to run a command
3374 substitution, so don't print anything. */
3375 if ((job_control
== 0 && interactive_shell
) ||
3376 (startup_state
== 2 && (subshell_environment
& SUBSHELL_COMSUB
)))
3379 /* POSIX.2 compatibility: if the shell is not interactive,
3380 hang onto the job corresponding to the last asynchronous
3381 pid until the user has been notified of its status or does
3383 if (DEADJOB (job
) && (interactive_shell
|| (find_last_pid (job
, 0) != last_asynchronous_pid
)))
3384 jobs
[job
]->flags
|= J_NOTIFIED
;
3388 /* Print info on jobs that are running in the background,
3389 and on foreground jobs that were killed by anything
3390 except SIGINT (and possibly SIGPIPE). */
3391 switch (JOBSTATE (job
))
3394 if (interactive_shell
== 0 && termsig
&& WIFSIGNALED (s
) &&
3395 termsig
!= SIGINT
&&
3396 #if defined (DONT_REPORT_SIGPIPE)
3397 termsig
!= SIGPIPE
&&
3399 signal_is_trapped (termsig
) == 0)
3401 /* Don't print `0' for a line number. */
3402 fprintf (stderr
, _("%s: line %d: "), get_name_for_error (), (line_number
== 0) ? 1 : line_number
);
3403 pretty_print_job (job
, JLIST_NONINTERACTIVE
, stderr
);
3405 else if (IS_FOREGROUND (job
))
3407 #if !defined (DONT_REPORT_SIGPIPE)
3408 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
)
3410 if (termsig
&& WIFSIGNALED (s
) && termsig
!= SIGINT
&& termsig
!= SIGPIPE
)
3413 fprintf (stderr
, "%s", j_strsignal (termsig
));
3416 fprintf (stderr
, _(" (core dumped)"));
3418 fprintf (stderr
, "\n");
3421 else if (job_control
) /* XXX job control test added */
3424 dir
= current_working_directory ();
3425 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3426 if (dir
&& strcmp (dir
, jobs
[job
]->wd
) != 0)
3428 _("(wd now: %s)\n"), polite_directory_format (dir
));
3431 jobs
[job
]->flags
|= J_NOTIFIED
;
3435 fprintf (stderr
, "\n");
3437 dir
= current_working_directory ();
3438 pretty_print_job (job
, JLIST_STANDARD
, stderr
);
3439 if (dir
&& (strcmp (dir
, jobs
[job
]->wd
) != 0))
3441 _("(wd now: %s)\n"), polite_directory_format (dir
));
3442 jobs
[job
]->flags
|= J_NOTIFIED
;
3450 programming_error ("notify_of_job_status");
3455 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
3460 /* Initialize the job control mechanism, and set up the tty stuff. */
3462 initialize_job_control (force
)
3465 shell_pgrp
= getpgid (0);
3467 if (shell_pgrp
== -1)
3469 sys_error (_("initialize_job_control: getpgrp failed"));
3473 /* We can only have job control if we are interactive. */
3474 if (interactive
== 0)
3477 original_pgrp
= NO_PID
;
3478 shell_tty
= fileno (stderr
);
3482 /* Get our controlling terminal. If job_control is set, or
3483 interactive is set, then this is an interactive shell no
3484 matter where fd 2 is directed. */
3485 shell_tty
= dup (fileno (stderr
)); /* fd 2 */
3487 shell_tty
= move_to_high_fd (shell_tty
, 1, -1);
3489 /* Compensate for a bug in systems that compiled the BSD
3490 rlogind with DEBUG defined, like NeXT and Alliant. */
3491 if (shell_pgrp
== 0)
3493 shell_pgrp
= getpid ();
3494 setpgid (0, shell_pgrp
);
3495 tcsetpgrp (shell_tty
, shell_pgrp
);
3498 while ((terminal_pgrp
= tcgetpgrp (shell_tty
)) != -1)
3500 if (shell_pgrp
!= terminal_pgrp
)
3504 ottin
= set_signal_handler(SIGTTIN
, SIG_DFL
);
3506 set_signal_handler (SIGTTIN
, ottin
);
3512 /* Make sure that we are using the new line discipline. */
3513 if (set_new_line_discipline (shell_tty
) < 0)
3515 sys_error (_("initialize_job_control: line discipline"));
3520 original_pgrp
= shell_pgrp
;
3521 shell_pgrp
= getpid ();
3523 if ((original_pgrp
!= shell_pgrp
) && (setpgid (0, shell_pgrp
) < 0))
3525 sys_error (_("initialize_job_control: setpgid"));
3526 shell_pgrp
= original_pgrp
;
3531 /* If (and only if) we just set our process group to our pid,
3532 thereby becoming a process group leader, and the terminal
3533 is not in the same process group as our (new) process group,
3534 then set the terminal's process group to our (new) process
3535 group. If that fails, set our process group back to what it
3536 was originally (so we can still read from the terminal) and
3537 turn off job control. */
3538 if (shell_pgrp
!= original_pgrp
&& shell_pgrp
!= terminal_pgrp
)
3540 if (give_terminal_to (shell_pgrp
, 0) < 0)
3542 setpgid (0, original_pgrp
);
3543 shell_pgrp
= original_pgrp
;
3548 if (job_control
== 0)
3549 internal_error (_("no job control in this shell"));
3552 if (shell_tty
!= fileno (stderr
))
3553 SET_CLOSE_ON_EXEC (shell_tty
);
3555 set_signal_handler (SIGCHLD
, sigchld_handler
);
3557 change_flag ('m', job_control
? '-' : '+');
3562 if (js
.c_childmax
< 0)
3563 js
.c_childmax
= getmaxchild ();
3564 if (js
.c_childmax
< 0)
3565 js
.c_childmax
= DEFAULT_CHILD_MAX
;
3572 debug_print_pgrps ()
3574 itrace("original_pgrp = %ld shell_pgrp = %ld terminal_pgrp = %ld",
3575 (long)original_pgrp
, (long)shell_pgrp
, (long)terminal_pgrp
);
3576 itrace("tcgetpgrp(%d) -> %ld, getpgid(0) -> %ld",
3577 shell_tty
, (long)tcgetpgrp (shell_tty
), (long)getpgid(0));
3581 /* Set the line discipline to the best this system has to offer.
3582 Return -1 if this is not possible. */
3584 set_new_line_discipline (tty
)
3587 #if defined (NEW_TTY_DRIVER)
3590 if (ioctl (tty
, TIOCGETD
, &ldisc
) < 0)
3593 if (ldisc
!= NTTYDISC
)
3597 if (ioctl (tty
, TIOCSETD
, &ldisc
) < 0)
3601 #endif /* NEW_TTY_DRIVER */
3603 #if defined (TERMIO_TTY_DRIVER)
3604 # if defined (TERMIO_LDISC) && (NTTYDISC)
3605 if (ioctl (tty
, TCGETA
, &shell_tty_info
) < 0)
3608 if (shell_tty_info
.c_line
!= NTTYDISC
)
3610 shell_tty_info
.c_line
= NTTYDISC
;
3611 if (ioctl (tty
, TCSETAW
, &shell_tty_info
) < 0)
3614 # endif /* TERMIO_LDISC && NTTYDISC */
3616 #endif /* TERMIO_TTY_DRIVER */
3618 #if defined (TERMIOS_TTY_DRIVER)
3619 # if defined (TERMIOS_LDISC) && defined (NTTYDISC)
3620 if (tcgetattr (tty
, &shell_tty_info
) < 0)
3623 if (shell_tty_info
.c_line
!= NTTYDISC
)
3625 shell_tty_info
.c_line
= NTTYDISC
;
3626 if (tcsetattr (tty
, TCSADRAIN
, &shell_tty_info
) < 0)
3629 # endif /* TERMIOS_LDISC && NTTYDISC */
3631 #endif /* TERMIOS_TTY_DRIVER */
3633 #if !defined (NEW_TTY_DRIVER) && !defined (TERMIO_TTY_DRIVER) && !defined (TERMIOS_TTY_DRIVER)
3638 /* Setup this shell to handle C-C, etc. */
3640 initialize_job_signals ()
3644 set_signal_handler (SIGINT
, sigint_sighandler
);
3645 set_signal_handler (SIGTSTP
, SIG_IGN
);
3646 set_signal_handler (SIGTTOU
, SIG_IGN
);
3647 set_signal_handler (SIGTTIN
, SIG_IGN
);
3649 else if (job_control
)
3651 old_tstp
= set_signal_handler (SIGTSTP
, sigstop_sighandler
);
3652 old_ttin
= set_signal_handler (SIGTTIN
, sigstop_sighandler
);
3653 old_ttou
= set_signal_handler (SIGTTOU
, sigstop_sighandler
);
3655 /* Leave these things alone for non-interactive shells without job
3659 /* Here we handle CONT signals. */
3661 sigcont_sighandler (sig
)
3664 initialize_job_signals ();
3665 set_signal_handler (SIGCONT
, old_cont
);
3666 kill (getpid (), SIGCONT
);
3671 /* Here we handle stop signals while we are running not as a login shell. */
3673 sigstop_sighandler (sig
)
3676 set_signal_handler (SIGTSTP
, old_tstp
);
3677 set_signal_handler (SIGTTOU
, old_ttou
);
3678 set_signal_handler (SIGTTIN
, old_ttin
);
3680 old_cont
= set_signal_handler (SIGCONT
, sigcont_sighandler
);
3682 give_terminal_to (shell_pgrp
, 0);
3684 kill (getpid (), sig
);
3689 /* Give the terminal to PGRP. */
3691 give_terminal_to (pgrp
, force
)
3699 if (job_control
|| force
)
3702 sigaddset (&set
, SIGTTOU
);
3703 sigaddset (&set
, SIGTTIN
);
3704 sigaddset (&set
, SIGTSTP
);
3705 sigaddset (&set
, SIGCHLD
);
3706 sigemptyset (&oset
);
3707 sigprocmask (SIG_BLOCK
, &set
, &oset
);
3709 if (tcsetpgrp (shell_tty
, pgrp
) < 0)
3711 /* Maybe we should print an error message? */
3713 sys_error ("tcsetpgrp(%d) failed: pid %ld to pgrp %ld",
3714 shell_tty
, (long)getpid(), (long)pgrp
);
3719 terminal_pgrp
= pgrp
;
3720 sigprocmask (SIG_SETMASK
, &oset
, (sigset_t
*)NULL
);
3726 /* Clear out any jobs in the job array. This is intended to be used by
3727 children of the shell, who should not have any job structures as baggage
3728 when they start executing (forking subshells for parenthesized execution
3729 and functions with pipes are the two that spring to mind). If RUNNING_ONLY
3730 is nonzero, only running jobs are removed from the table. */
3732 delete_all_jobs (running_only
)
3738 BLOCK_CHILD (set
, oset
);
3740 /* XXX - need to set j_lastj, j_firstj appropriately if running_only != 0. */
3743 js
.j_current
= js
.j_previous
= NO_JOB
;
3745 /* XXX could use js.j_firstj here */
3746 for (i
= 0; i
< js
.j_jobslots
; i
++)
3749 if (i
< js
.j_firstj
&& jobs
[i
])
3750 itrace("delete_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3751 if (i
> js
.j_lastj
&& jobs
[i
])
3752 itrace("delete_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
3754 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
3755 delete_job (i
, DEL_WARNSTOPPED
);
3757 if (running_only
== 0)
3759 free ((char *)jobs
);
3761 js
.j_firstj
= js
.j_lastj
= js
.j_njobs
= 0;
3765 if (running_only
== 0)
3768 UNBLOCK_CHILD (oset
);
3771 /* Mark all jobs in the job array so that they don't get a SIGHUP when the
3772 shell gets one. If RUNNING_ONLY is nonzero, mark only running jobs. */
3774 nohup_all_jobs (running_only
)
3780 BLOCK_CHILD (set
, oset
);
3784 /* XXX could use js.j_firstj here */
3785 for (i
= 0; i
< js
.j_jobslots
; i
++)
3786 if (jobs
[i
] && (running_only
== 0 || (running_only
&& RUNNING(i
))))
3790 UNBLOCK_CHILD (oset
);
3799 /* This really counts all non-dead jobs. */
3800 BLOCK_CHILD (set
, oset
);
3801 /* XXX could use js.j_firstj here */
3802 for (i
= n
= 0; i
< js
.j_jobslots
; i
++)
3805 if (i
< js
.j_firstj
&& jobs
[i
])
3806 itrace("count_all_jobs: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3807 if (i
> js
.j_lastj
&& jobs
[i
])
3808 itrace("count_all_jobs: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
3810 if (jobs
[i
] && DEADJOB(i
) == 0)
3813 UNBLOCK_CHILD (oset
);
3818 mark_all_jobs_as_dead ()
3823 if (js
.j_jobslots
== 0)
3826 BLOCK_CHILD (set
, oset
);
3828 /* XXX could use js.j_firstj here */
3829 for (i
= 0; i
< js
.j_jobslots
; i
++)
3832 jobs
[i
]->state
= JDEAD
;
3836 UNBLOCK_CHILD (oset
);
3839 /* Mark all dead jobs as notified, so delete_job () cleans them out
3840 of the job table properly. POSIX.2 says we need to save the
3841 status of the last CHILD_MAX jobs, so we count the number of dead
3842 jobs and mark only enough as notified to save CHILD_MAX statuses. */
3844 mark_dead_jobs_as_notified (force
)
3847 register int i
, ndead
, ndeadproc
;
3850 if (js
.j_jobslots
== 0)
3853 BLOCK_CHILD (set
, oset
);
3855 /* If FORCE is non-zero, we don't have to keep CHILD_MAX statuses
3856 around; just run through the array. */
3859 /* XXX could use js.j_firstj here */
3860 for (i
= 0; i
< js
.j_jobslots
; i
++)
3862 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
3863 jobs
[i
]->flags
|= J_NOTIFIED
;
3865 UNBLOCK_CHILD (oset
);
3869 /* Mark enough dead jobs as notified to keep CHILD_MAX processes left in the
3870 array with the corresponding not marked as notified. This is a better
3871 way to avoid pid aliasing and reuse problems than keeping the POSIX-
3872 mandated CHILD_MAX jobs around. delete_job() takes care of keeping the
3873 bgpids list regulated. */
3875 /* Count the number of dead jobs */
3876 /* XXX could use js.j_firstj here */
3877 for (i
= ndead
= ndeadproc
= 0; i
< js
.j_jobslots
; i
++)
3880 if (i
< js
.j_firstj
&& jobs
[i
])
3881 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3882 if (i
> js
.j_lastj
&& jobs
[i
])
3883 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
3885 if (jobs
[i
] && DEADJOB (i
))
3888 ndeadproc
+= processes_in_job (i
);
3893 if (ndeadproc
!= js
.c_reaped
)
3894 itrace("mark_dead_jobs_as_notified: ndeadproc (%d) != js.c_reaped (%d)", ndeadproc
, js
.c_reaped
);
3895 if (ndead
!= js
.j_ndead
)
3896 itrace("mark_dead_jobs_as_notified: ndead (%d) != js.j_ndead (%d)", ndead
, js
.j_ndead
);
3899 if (js
.c_childmax
< 0)
3900 js
.c_childmax
= getmaxchild ();
3901 if (js
.c_childmax
< 0)
3902 js
.c_childmax
= DEFAULT_CHILD_MAX
;
3904 /* Don't do anything if the number of dead processes is less than CHILD_MAX
3905 and we're not forcing a cleanup. */
3906 if (ndeadproc
<= js
.c_childmax
)
3908 UNBLOCK_CHILD (oset
);
3913 itrace("mark_dead_jobs_as_notified: child_max = %d ndead = %d ndeadproc = %d", js
.c_childmax
, ndead
, ndeadproc
);
3916 /* Mark enough dead jobs as notified that we keep CHILD_MAX jobs in
3917 the list. This isn't exactly right yet; changes need to be made
3918 to stop_pipeline so we don't mark the newer jobs after we've
3919 created CHILD_MAX slots in the jobs array. This needs to be
3920 integrated with a way to keep the jobs array from growing without
3921 bound. Maybe we wrap back around to 0 after we reach some max
3922 limit, and there are sufficient job slots free (keep track of total
3923 size of jobs array (js.j_jobslots) and running count of number of jobs
3924 in jobs array. Then keep a job index corresponding to the `oldest job'
3925 and start this loop there, wrapping around as necessary. In effect,
3926 we turn the list into a circular buffer. */
3927 /* XXX could use js.j_firstj here */
3928 for (i
= 0; i
< js
.j_jobslots
; i
++)
3930 if (jobs
[i
] && DEADJOB (i
) && (interactive_shell
|| (find_last_pid (i
, 0) != last_asynchronous_pid
)))
3933 if (i
< js
.j_firstj
&& jobs
[i
])
3934 itrace("mark_dead_jobs_as_notified: job %d non-null before js.j_firstj (%d)", i
, js
.j_firstj
);
3935 if (i
> js
.j_lastj
&& jobs
[i
])
3936 itrace("mark_dead_jobs_as_notified: job %d non-null after js.j_lastj (%d)", i
, js
.j_lastj
);
3938 /* If marking this job as notified would drop us down below
3939 child_max, don't mark it so we can keep at least child_max
3940 statuses. XXX -- need to check what Posix actually says
3941 about keeping statuses. */
3942 if ((ndeadproc
-= processes_in_job (i
)) <= js
.c_childmax
)
3944 jobs
[i
]->flags
|= J_NOTIFIED
;
3948 UNBLOCK_CHILD (oset
);
3951 /* Here to allow other parts of the shell (like the trap stuff) to
3952 unfreeze the jobs list. */
3954 unfreeze_jobs_list ()
3956 jobs_list_frozen
= 0;
3959 /* Allow or disallow job control to take place. Returns the old value
3962 set_job_control (arg
)
3970 /* If we're turning on job control, reset pipeline_pgrp so make_child will
3971 put new child processes into the right pgrp */
3972 if (job_control
!= old
&& job_control
)
3978 /* Turn off all traces of job control. This is run by children of the shell
3979 which are going to do shellsy things, like wait (), etc. */
3981 without_job_control ()
3983 stop_making_children ();
3985 #if defined (PGRP_PIPE)
3986 pipe_close (pgrp_pipe
);
3988 delete_all_jobs (0);
3989 set_job_control (0);
3992 /* If this shell is interactive, terminate all stopped jobs and
3993 restore the original terminal process group. This is done
3994 before the `exec' builtin calls shell_execve. */
3998 if (interactive_shell
) /* XXX - should it be interactive? */
4000 terminate_stopped_jobs ();
4002 if (original_pgrp
>= 0)
4003 give_terminal_to (original_pgrp
, 1);
4006 if (original_pgrp
>= 0)
4007 setpgid (0, original_pgrp
);
4010 /* Restart job control by closing shell tty and reinitializing. This is
4011 called after an exec fails in an interactive shell and we do not exit. */
4013 restart_job_control ()
4015 if (shell_tty
!= -1)
4017 initialize_job_control (0);
4020 /* Set the handler to run when the shell receives a SIGCHLD signal. */
4022 set_sigchld_handler ()
4024 set_signal_handler (SIGCHLD
, sigchld_handler
);
4027 #if defined (PGRP_PIPE)
4028 /* Read from the read end of a pipe. This is how the process group leader
4029 blocks until all of the processes in a pipeline have been made. */
4044 while (read (pp
[0], &ch
, 1) == -1 && errno
== EINTR
)
4049 /* Close the read and write ends of PP, an array of file descriptors. */
4063 /* Functional interface closes our local-to-job-control pipes. */
4067 pipe_close (pgrp_pipe
);
4070 #endif /* PGRP_PIPE */