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