/* $NetBSD: jobs.c,v 1.19 2017/06/30 04:41:19 kamil Exp $ */ /* * Process and job control */ /* * Reworked/Rewritten version of Eric Gisin's/Ron Natalie's code by * Larry Bouzane (larry@cs.mun.ca) and hacked again by * Michael Rendell (michael@cs.mun.ca) * * The interface to the rest of the shell should probably be changed * to allow use of vfork() when available but that would be way too much * work :) * * Notes regarding the copious ifdefs: * - TTY_PGRP defined iff JOBS is defined - defined if there are tty * process groups * - NEED_PGRP_SYNC defined iff JOBS is defined - see comment below */ #include #ifndef lint __RCSID("$NetBSD: jobs.c,v 1.19 2017/06/30 04:41:19 kamil Exp $"); #endif #include #include #include #include "sh.h" #include "tty.h" /* Start of system configuration stuff */ /* We keep CHILD_MAX zombie processes around (exact value isn't critical) */ #ifndef CHILD_MAX # if defined(HAVE_SYSCONF) && defined(_SC_CHILD_MAX) # define CHILD_MAX sysconf(_SC_CHILD_MAX) # else /* _SC_CHILD_MAX */ # ifdef _POSIX_CHILD_MAX # define CHILD_MAX ((_POSIX_CHILD_MAX) * 2) # else /* _POSIX_CHILD_MAX */ # define CHILD_MAX 20 # endif /* _POSIX_CHILD_MAX */ # endif /* _SC_CHILD_MAX */ #endif /* !CHILD_MAX */ #ifdef JOBS # if defined(HAVE_TCSETPGRP) || defined(TIOCSPGRP) # define TTY_PGRP # endif # ifdef BSD_PGRP # define setpgid setpgrp # define getpgID() getpgrp(0) # else # define getpgID() getpgrp() # endif # if defined(TTY_PGRP) && !defined(HAVE_TCSETPGRP) int tcsetpgrp ARGS((int fd, pid_t grp)); int tcgetpgrp ARGS((int fd)); int tcsetpgrp(fd, grp) int fd; pid_t grp; { return ioctl(fd, TIOCSPGRP, &grp); } int tcgetpgrp(fd) int fd; { int r, grp; if ((r = ioctl(fd, TIOCGPGRP, &grp)) < 0) return r; return grp; } # endif /* !HAVE_TCSETPGRP && TIOCSPGRP */ #else /* JOBS */ /* These so we can use ifdef xxx instead of if defined(JOBS) && defined(xxx) */ # undef TTY_PGRP # undef NEED_PGRP_SYNC #endif /* JOBS */ /* End of system configuration stuff */ /* Order important! */ #define PRUNNING 0 #define PEXITED 1 #define PSIGNALLED 2 #define PSTOPPED 3 typedef struct proc Proc; struct proc { Proc *next; /* next process in pipeline (if any) */ int state; int status; /* wait status */ pid_t pid; /* process id */ char command[48]; /* process command string */ }; /* Notify/print flag - j_print() argument */ #define JP_NONE 0 /* don't print anything */ #define JP_SHORT 1 /* print signals processes were killed by */ #define JP_MEDIUM 2 /* print [job-num] -/+ command */ #define JP_LONG 3 /* print [job-num] -/+ pid command */ #define JP_PGRP 4 /* print pgrp */ /* put_job() flags */ #define PJ_ON_FRONT 0 /* at very front */ #define PJ_PAST_STOPPED 1 /* just past any stopped jobs */ /* Job.flags values */ #define JF_STARTED 0x001 /* set when all processes in job are started */ #define JF_WAITING 0x002 /* set if j_waitj() is waiting on job */ #define JF_W_ASYNCNOTIFY 0x004 /* set if waiting and async notification ok */ #define JF_XXCOM 0x008 /* set for `command` jobs */ #define JF_FG 0x010 /* running in foreground (also has tty pgrp) */ #define JF_SAVEDTTY 0x020 /* j->ttystate is valid */ #define JF_CHANGED 0x040 /* process has changed state */ #define JF_KNOWN 0x080 /* $! referenced */ #define JF_ZOMBIE 0x100 /* known, unwaited process */ #define JF_REMOVE 0x200 /* flagged for removal (j_jobs()/j_noityf()) */ #define JF_USETTYMODE 0x400 /* tty mode saved if process exits normally */ #define JF_SAVEDTTYPGRP 0x800 /* j->saved_ttypgrp is valid */ typedef struct job Job; struct job { Job *next; /* next job in list */ int job; /* job number: %n */ int flags; /* see JF_* */ int state; /* job state */ int status; /* exit status of last process */ pid_t pgrp; /* process group of job */ pid_t ppid; /* pid of process that forked job */ int_least32_t age; /* number of jobs started */ clock_t systime; /* system time used by job */ clock_t usrtime; /* user time used by job */ Proc *proc_list; /* process list */ Proc *last_proc; /* last process in list */ #ifdef KSH Coproc_id coproc_id; /* 0 or id of coprocess output pipe */ #endif /* KSH */ #ifdef TTY_PGRP TTY_state ttystate; /* saved tty state for stopped jobs */ pid_t saved_ttypgrp; /* saved tty process group for stopped jobs */ #endif /* TTY_PGRP */ }; /* Flags for j_waitj() */ #define JW_NONE 0x00 #define JW_INTERRUPT 0x01 /* ^C will stop the wait */ #define JW_ASYNCNOTIFY 0x02 /* asynchronous notification during wait ok */ #define JW_STOPPEDWAIT 0x04 /* wait even if job stopped */ /* Error codes for j_lookup() */ #define JL_OK 0 #define JL_NOSUCH 1 /* no such job */ #define JL_AMBIG 2 /* %foo or %?foo is ambiguous */ #define JL_INVALID 3 /* non-pid, non-% job id */ static const char *const lookup_msgs[] = { null, "no such job", "ambiguous", "argument must be %job or process id", (char *) 0 }; clock_t j_systime, j_usrtime; /* user and system time of last j_waitjed job */ static Job *job_list; /* job list */ static Job *last_job; static Job *async_job; static pid_t async_pid; static int nzombie; /* # of zombies owned by this process */ static int_least32_t njobs; /* # of jobs started */ static int child_max; /* CHILD_MAX */ /* held_sigchld is set if sigchld occurs before a job is completely started */ static int held_sigchld; #ifdef JOBS static struct shf *shl_j; #endif /* JOBS */ #ifdef NEED_PGRP_SYNC /* On some systems, the kernel doesn't count zombie processes when checking * if a process group is valid, which can cause problems in creating the * pipeline "cmd1 | cmd2": if cmd1 can die (and go into the zombie state) * before cmd2 is started, the kernel doesn't allow the setpgid() for cmd2 * to succeed. Solution is to create a pipe between the parent and the first * process; the first process doesn't do anything until the pipe is closed * and the parent doesn't close the pipe until all the processes are started. */ static int j_sync_pipe[2]; static int j_sync_open; #endif /* NEED_PGRP_SYNC */ #ifdef TTY_PGRP static int ttypgrp_ok; /* set if can use tty pgrps */ static pid_t restore_ttypgrp = -1; static pid_t our_pgrp; static int const tt_sigs[] = { SIGTSTP, SIGTTIN, SIGTTOU }; #endif /* TTY_PGRP */ static void j_set_async ARGS((Job *j)); static void j_startjob ARGS((Job *j)); static int j_waitj ARGS((Job *j, int flags, const char *where)); static RETSIGTYPE j_sigchld ARGS((int sig)); static void j_print ARGS((Job *j, int how, struct shf *shf)); static Job *j_lookup ARGS((const char *cp, int *ecodep)); static Job *new_job ARGS((void)); static Proc *new_proc ARGS((void)); static void check_job ARGS((Job *j)); static void put_job ARGS((Job *j, int where)); static void remove_job ARGS((Job *j, const char *where)); static int kill_job ARGS((Job *j, int sig)); /* initialize job control */ void j_init(mflagset) int mflagset; { child_max = CHILD_MAX; /* so syscon() isn't always being called */ sigemptyset(&sm_default); sigprocmask(SIG_SETMASK, &sm_default, (sigset_t *) 0); sigemptyset(&sm_sigchld); sigaddset(&sm_sigchld, SIGCHLD); setsig(&sigtraps[SIGCHLD], j_sigchld, SS_RESTORE_ORIG|SS_FORCE|SS_SHTRAP); #ifdef JOBS if (!mflagset && Flag(FTALKING)) Flag(FMONITOR) = 1; /* shl_j is used to do asynchronous notification (used in * an interrupt handler, so need a distinct shf) */ shl_j = shf_fdopen(2, SHF_WR, (struct shf *) 0); # ifdef TTY_PGRP if (Flag(FMONITOR) || Flag(FTALKING)) { int i; /* the TF_SHELL_USES test is a kludge that lets us know if * if the signals have been changed by the shell. */ for (i = NELEM(tt_sigs); --i >= 0; ) { sigtraps[tt_sigs[i]].flags |= TF_SHELL_USES; /* j_change() sets this to SS_RESTORE_DFL if FMONITOR */ setsig(&sigtraps[tt_sigs[i]], SIG_IGN, SS_RESTORE_IGN|SS_FORCE); } } # endif /* TTY_PGRP */ /* j_change() calls tty_init() */ if (Flag(FMONITOR)) j_change(); else #endif /* JOBS */ if (Flag(FTALKING)) tty_init(true); } /* job cleanup before shell exit */ void j_exit() { /* kill stopped, and possibly running, jobs */ Job *j; int killed = 0; for (j = job_list; j != (Job *) 0; j = j->next) { if (j->ppid == procpid && (j->state == PSTOPPED || (j->state == PRUNNING && ((j->flags & JF_FG) || (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid))))) { killed = 1; if (j->pgrp == 0) kill_job(j, SIGHUP); else killpg(j->pgrp, SIGHUP); #ifdef JOBS if (j->state == PSTOPPED) { if (j->pgrp == 0) kill_job(j, SIGCONT); else killpg(j->pgrp, SIGCONT); } #endif /* JOBS */ } } if (killed) sleep(1); j_notify(); #ifdef JOBS # ifdef TTY_PGRP if (kshpid == procpid && restore_ttypgrp >= 0) { /* Need to restore the tty pgrp to what it was when the * shell started up, so that the process that started us * will be able to access the tty when we are done. * Also need to restore our process group in case we are * about to do an exec so that both our parent and the * process we are to become will be able to access the tty. */ tcsetpgrp(tty_fd, restore_ttypgrp); setpgid(0, restore_ttypgrp); } # endif /* TTY_PGRP */ if (Flag(FMONITOR)) { Flag(FMONITOR) = 0; j_change(); } #endif /* JOBS */ } #ifdef JOBS /* turn job control on or off according to Flag(FMONITOR) */ void j_change() { int i; if (Flag(FMONITOR)) { /* Don't call get_tty() 'til we own the tty process group */ tty_init(false); # ifdef TTY_PGRP /* no controlling tty, no SIGT* */ ttypgrp_ok = tty_fd >= 0 && tty_devtty; if (ttypgrp_ok && (our_pgrp = getpgID()) < 0) { warningf(false, "j_init: getpgrp() failed: %s", strerror(errno)); ttypgrp_ok = 0; } if (ttypgrp_ok) { setsig(&sigtraps[SIGTTIN], SIG_DFL, SS_RESTORE_ORIG|SS_FORCE); /* wait to be given tty (POSIX.1, B.2, job control) */ while (1) { pid_t ttypgrp; if ((ttypgrp = tcgetpgrp(tty_fd)) < 0) { warningf(false, "j_init: tcgetpgrp() failed: %s", strerror(errno)); ttypgrp_ok = 0; break; } if (ttypgrp == our_pgrp) break; kill(0, SIGTTIN); } } for (i = NELEM(tt_sigs); --i >= 0; ) setsig(&sigtraps[tt_sigs[i]], SIG_IGN, SS_RESTORE_DFL|SS_FORCE); if (ttypgrp_ok && our_pgrp != kshpid) { if (setpgid(0, kshpid) < 0) { warningf(false, "j_init: setpgid() failed: %s", strerror(errno)); ttypgrp_ok = 0; } else { if (tcsetpgrp(tty_fd, kshpid) < 0) { warningf(false, "j_init: tcsetpgrp() failed: %s", strerror(errno)); ttypgrp_ok = 0; } else restore_ttypgrp = our_pgrp; our_pgrp = kshpid; } } # if defined(NTTYDISC) && defined(TIOCSETD) && !defined(HAVE_TERMIOS_H) && !defined(HAVE_TERMIO_H) if (ttypgrp_ok) { int ldisc = NTTYDISC; if (ioctl(tty_fd, TIOCSETD, &ldisc) < 0) warningf(false, "j_init: can't set new line discipline: %s", strerror(errno)); } # endif /* NTTYDISC && TIOCSETD */ if (!ttypgrp_ok) warningf(false, "warning: won't have full job control"); # endif /* TTY_PGRP */ if (tty_fd >= 0) get_tty(tty_fd, &tty_state); } else { # ifdef TTY_PGRP ttypgrp_ok = 0; if (Flag(FTALKING)) for (i = NELEM(tt_sigs); --i >= 0; ) setsig(&sigtraps[tt_sigs[i]], SIG_IGN, SS_RESTORE_IGN|SS_FORCE); else for (i = NELEM(tt_sigs); --i >= 0; ) { if (sigtraps[tt_sigs[i]].flags & (TF_ORIG_IGN |TF_ORIG_DFL)) setsig(&sigtraps[tt_sigs[i]], (sigtraps[tt_sigs[i]].flags & TF_ORIG_IGN) ? SIG_IGN : SIG_DFL, SS_RESTORE_ORIG|SS_FORCE); } # endif /* TTY_PGRP */ if (!Flag(FTALKING)) tty_close(); } } #endif /* JOBS */ /* execute tree in child subprocess */ int exchild(t, flags, close_fd) struct op *t; int flags; int close_fd; /* used if XPCLOSE or XCCLOSE */ { static Proc *last_proc; /* for pipelines */ int i; sigset_t omask; Proc *p; Job *j; int rv = 0; int forksleep; int ischild; if (flags & XEXEC) /* Clear XFORK|XPCLOSE|XCCLOSE|XCOPROC|XPIPEO|XPIPEI|XXCOM|XBGND * (also done in another execute() below) */ return execute(t, flags & (XEXEC | XERROK)); /* no SIGCHLD's while messing with job and process lists */ sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); p = new_proc(); p->next = (Proc *) 0; p->state = PRUNNING; p->status = 0; p->pid = 0; /* link process into jobs list */ if (flags&XPIPEI) { /* continuing with a pipe */ if (!last_job) internal_errorf(1, "exchild: XPIPEI and no last_job - pid %d", (int) procpid); j = last_job; last_proc->next = p; last_proc = p; } else { #ifdef NEED_PGRP_SYNC if (j_sync_open) { /* should never happen */ j_sync_open = 0; closepipe(j_sync_pipe); } /* don't do the sync pipe business if there is no pipeline */ if (flags & XPIPEO) { openpipe(j_sync_pipe); j_sync_open = 1; } #endif /* NEED_PGRP_SYNC */ j = new_job(); /* fills in j->job */ /* we don't consider XXCOM's foreground since they don't get * tty process group and we don't save or restore tty modes. */ j->flags = (flags & XXCOM) ? JF_XXCOM : ((flags & XBGND) ? 0 : (JF_FG|JF_USETTYMODE)); j->usrtime = j->systime = 0; j->state = PRUNNING; j->pgrp = 0; j->ppid = procpid; j->age = ++njobs; j->proc_list = p; #ifdef KSH j->coproc_id = 0; #endif /* KSH */ last_job = j; last_proc = p; put_job(j, PJ_PAST_STOPPED); } snptreef(p->command, sizeof(p->command), "%T", t); /* create child process */ forksleep = 1; while ((i = fork()) < 0 && errno == EAGAIN && forksleep < 32) { if (intrsig) /* allow user to ^C out... */ break; sleep(forksleep); forksleep <<= 1; } if (i < 0) { kill_job(j, SIGKILL); remove_job(j, "fork failed"); #ifdef NEED_PGRP_SYNC if (j_sync_open) { closepipe(j_sync_pipe); j_sync_open = 0; } #endif /* NEED_PGRP_SYNC */ sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); errorf("cannot fork - try again"); } ischild = i == 0; if (ischild) p->pid = procpid = getpid(); else p->pid = i; #ifdef JOBS /* job control set up */ if (Flag(FMONITOR) && !(flags&XXCOM)) { int dotty = 0; # ifdef NEED_PGRP_SYNC int first_child_sync = 0; # endif /* NEED_PGRP_SYNC */ # ifdef NEED_PGRP_SYNC if (j_sync_open) { /* * The Parent closes 0, keeps 1 open 'til the whole * pipeline is started. The First child closes 1, * keeps 0 open (reads from it). The remaining * children just have to close 1 (parent has already * closeed 0). */ if (j->pgrp == 0) { /* First process */ close(j_sync_pipe[ischild]); j_sync_pipe[ischild] = -1; first_child_sync = ischild; } else if (ischild) { j_sync_open = 0; closepipe(j_sync_pipe); } } # endif /* NEED_PGRP_SYNC */ if (j->pgrp == 0) { /* First process */ j->pgrp = p->pid; dotty = 1; } /* set pgrp in both parent and child to deal with race * condition */ setpgid(p->pid, j->pgrp); # ifdef TTY_PGRP /* YYY: should this be if (ttypgrp_ok && ischild && !(flags&XBGND)) tcsetpgrp(tty_fd, j->pgrp); instead? (see also YYY below) */ if (ttypgrp_ok && dotty && !(flags & XBGND)) tcsetpgrp(tty_fd, j->pgrp); # endif /* TTY_PGRP */ # ifdef NEED_PGRP_SYNC if (first_child_sync) { char c; while (read(j_sync_pipe[0], &c, 1) == -1 && errno == EINTR) ; close(j_sync_pipe[0]); j_sync_open = 0; } # endif /* NEED_PGRP_SYNC */ } #endif /* JOBS */ /* used to close pipe input fd */ if (close_fd >= 0 && (((flags & XPCLOSE) && !ischild) || ((flags & XCCLOSE) && ischild))) close(close_fd); if (ischild) { /* child */ #ifdef KSH /* Do this before restoring signal */ if (flags & XCOPROC) coproc_cleanup(false); #endif /* KSH */ sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); cleanup_parents_env(); #ifdef TTY_PGRP /* If FMONITOR or FTALKING is set, these signals are ignored, * if neither FMONITOR nor FTALKING are set, the signals have * their inherited values. */ if (Flag(FMONITOR) && !(flags & XXCOM)) { for (i = NELEM(tt_sigs); --i >= 0; ) setsig(&sigtraps[tt_sigs[i]], SIG_DFL, SS_RESTORE_DFL|SS_FORCE); } #endif /* TTY_PGRP */ #ifdef HAVE_NICE if (Flag(FBGNICE) && (flags & XBGND)) nice(4); #endif /* HAVE_NICE */ if ((flags & XBGND) && !Flag(FMONITOR)) { setsig(&sigtraps[SIGINT], SIG_IGN, SS_RESTORE_IGN|SS_FORCE); setsig(&sigtraps[SIGQUIT], SIG_IGN, SS_RESTORE_IGN|SS_FORCE); if (!(flags & (XPIPEI | XCOPROC))) { int fd = open("/dev/null", 0); if (fd != 0) { (void) ksh_dup2(fd, 0, true); close(fd); } } } remove_job(j, "child"); /* in case of `jobs` command */ nzombie = 0; #ifdef JOBS ttypgrp_ok = 0; Flag(FMONITOR) = 0; #endif /* JOBS */ Flag(FTALKING) = 0; tty_close(); cleartraps(); execute(t, (flags & XERROK) | XEXEC); /* no return */ internal_errorf(0, "exchild: execute() returned"); unwind(LLEAVE); /* NOTREACHED */ } /* shell (parent) stuff */ /* Ensure next child gets a (slightly) different $RANDOM sequence */ change_random(); if (!(flags & XPIPEO)) { /* last process in a job */ #ifdef TTY_PGRP /* YYY: Is this needed? (see also YYY above) if (Flag(FMONITOR) && !(flags&(XXCOM|XBGND))) tcsetpgrp(tty_fd, j->pgrp); */ #endif /* TTY_PGRP */ j_startjob(j); #ifdef KSH if (flags & XCOPROC) { j->coproc_id = coproc.id; coproc.njobs++; /* n jobs using co-process output */ coproc.job = (void *) j; /* j using co-process input */ } #endif /* KSH */ if (flags & XBGND) { j_set_async(j); if (Flag(FTALKING)) { shf_fprintf(shl_out, "[%d]", j->job); for (p = j->proc_list; p; p = p->next) shf_fprintf(shl_out, " %d", p->pid); shf_putchar('\n', shl_out); shf_flush(shl_out); } } else rv = j_waitj(j, JW_NONE, "jw:last proc"); } sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); return rv; } /* start the last job: only used for `command` jobs */ void startlast() { sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); if (last_job) { /* no need to report error - waitlast() will do it */ /* ensure it isn't removed by check_job() */ last_job->flags |= JF_WAITING; j_startjob(last_job); } sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); } /* wait for last job: only used for `command` jobs */ int waitlast() { int rv; Job *j; sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); j = last_job; if (!j || !(j->flags & JF_STARTED)) { if (!j) warningf(true, "waitlast: no last job"); else internal_errorf(0, "waitlast: not started"); sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); return 125; /* not so arbitrary, non-zero value */ } rv = j_waitj(j, JW_NONE, "jw:waitlast"); sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); return rv; } /* wait for child, interruptable. */ int waitfor(cp, sigp) const char *cp; int *sigp; { int rv; Job *j; int ecode; int flags = JW_INTERRUPT|JW_ASYNCNOTIFY; sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); *sigp = 0; if (cp == (char *) 0) { /* wait for an unspecified job - always returns 0, so * don't have to worry about exited/signaled jobs */ for (j = job_list; j; j = j->next) /* at&t ksh will wait for stopped jobs - we don't */ if (j->ppid == procpid && j->state == PRUNNING) break; if (!j) { sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); return -1; } } else if ((j = j_lookup(cp, &ecode))) { /* don't report normal job completion */ flags &= ~JW_ASYNCNOTIFY; if (j->ppid != procpid) { sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); return -1; } } else { sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); if (ecode != JL_NOSUCH) bi_errorf("%s: %s", cp, lookup_msgs[ecode]); return -1; } /* at&t ksh will wait for stopped jobs - we don't */ rv = j_waitj(j, flags, "jw:waitfor"); sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); if (rv < 0) /* we were interrupted */ *sigp = 128 + -rv; return rv; } /* kill (built-in) a job */ int j_kill(cp, sig) const char *cp; int sig; { Job *j; int rv = 0; int ecode; sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); if ((j = j_lookup(cp, &ecode)) == (Job *) 0) { sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); bi_errorf("%s: %s", cp, lookup_msgs[ecode]); return 1; } if (j->pgrp == 0) { /* started when !Flag(FMONITOR) */ if (kill_job(j, sig) < 0) { bi_errorf("%s: %s", cp, strerror(errno)); rv = 1; } } else { #ifdef JOBS if (j->state == PSTOPPED && (sig == SIGTERM || sig == SIGHUP)) (void) killpg(j->pgrp, SIGCONT); #endif /* JOBS */ if (killpg(j->pgrp, sig) < 0) { bi_errorf("%s: %s", cp, strerror(errno)); rv = 1; } } sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); return rv; } #ifdef JOBS /* fg and bg built-ins: called only if Flag(FMONITOR) set */ int j_resume(cp, bg) const char *cp; int bg; { Job *j; Proc *p; int ecode; int running; int rv = 0; sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); if ((j = j_lookup(cp, &ecode)) == (Job *) 0) { sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); bi_errorf("%s: %s", cp, lookup_msgs[ecode]); return 1; } if (j->pgrp == 0) { sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); bi_errorf("job not job-controlled"); return 1; } if (bg) shprintf("[%d] ", j->job); running = 0; if (writefd) dprintf(writefd, "cmd"); for (p = j->proc_list; p != (Proc *) 0; p = p->next) { if (p->state == PSTOPPED) { p->state = PRUNNING; p->status = 0; running = 1; } shprintf("%s%s", p->command, p->next ? "| " : null); if (writefd) dprintf(writefd, "%s%s", p->command, p->next ? "| " : null); } shprintf("%s", newline); shf_flush(shl_stdout); if (writefd) dprintf(writefd, "\n"); if (running) j->state = PRUNNING; put_job(j, PJ_PAST_STOPPED); if (bg) j_set_async(j); else { # ifdef TTY_PGRP /* attach tty to job */ if (j->state == PRUNNING) { if (ttypgrp_ok && (j->flags & JF_SAVEDTTY)) { set_tty(tty_fd, &j->ttystate, TF_NONE); } /* See comment in j_waitj regarding saved_ttypgrp. */ if (ttypgrp_ok && tcsetpgrp(tty_fd, (j->flags & JF_SAVEDTTYPGRP) ? j->saved_ttypgrp : j->pgrp) < 0) { if (j->flags & JF_SAVEDTTY) { set_tty(tty_fd, &tty_state, TF_NONE); } sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); bi_errorf("1st tcsetpgrp(%d, %d) failed: %s", tty_fd, (int) ((j->flags & JF_SAVEDTTYPGRP) ? j->saved_ttypgrp : j->pgrp), strerror(errno)); return 1; } } # endif /* TTY_PGRP */ j->flags |= JF_FG; j->flags &= ~JF_KNOWN; if (j == async_job) async_job = (Job *) 0; } if (j->state == PRUNNING && killpg(j->pgrp, SIGCONT) < 0) { int err = errno; if (!bg) { j->flags &= ~JF_FG; # ifdef TTY_PGRP if (ttypgrp_ok && (j->flags & JF_SAVEDTTY)) { set_tty(tty_fd, &tty_state, TF_NONE); } if (ttypgrp_ok && tcsetpgrp(tty_fd, our_pgrp) < 0) { warningf(true, "fg: 2nd tcsetpgrp(%d, %d) failed: %s", tty_fd, (int) our_pgrp, strerror(errno)); } # endif /* TTY_PGRP */ } sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); bi_errorf("cannot continue job %s: %s", cp, strerror(err)); return 1; } if (!bg) { # ifdef TTY_PGRP if (ttypgrp_ok) { j->flags &= ~(JF_SAVEDTTY | JF_SAVEDTTYPGRP); } # endif /* TTY_PGRP */ rv = j_waitj(j, JW_NONE, "jw:resume"); } sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); return rv; } #endif /* JOBS */ /* are there any running or stopped jobs ? */ int j_stopped_running() { Job *j; int which = 0; for (j = job_list; j != (Job *) 0; j = j->next) { #ifdef JOBS if (j->ppid == procpid && j->state == PSTOPPED) which |= 1; #endif /* JOBS */ if (Flag(FLOGIN) && !Flag(FNOHUP) && procpid == kshpid && j->ppid == procpid && j->state == PRUNNING) which |= 2; } if (which) { shellf("You have %s%s%s jobs\n", which & 1 ? "stopped" : "", which == 3 ? " and " : "", which & 2 ? "running" : ""); return 1; } return 0; } /* list jobs for jobs built-in */ int j_jobs(cp, slp, nflag) const char *cp; int slp; /* 0: short, 1: long, 2: pgrp */ int nflag; { Job *j, *tmp; int how; int zflag = 0; sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); if (nflag < 0) { /* kludge: print zombies */ nflag = 0; zflag = 1; } if (cp) { int ecode; if ((j = j_lookup(cp, &ecode)) == (Job *) 0) { sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); bi_errorf("%s: %s", cp, lookup_msgs[ecode]); return 1; } } else j = job_list; how = slp == 0 ? JP_MEDIUM : (slp == 1 ? JP_LONG : JP_PGRP); for (; j; j = j->next) { if ((!(j->flags & JF_ZOMBIE) || zflag) && (!nflag || (j->flags & JF_CHANGED))) { j_print(j, how, shl_stdout); if (j->state == PEXITED || j->state == PSIGNALLED) j->flags |= JF_REMOVE; } if (cp) break; } /* Remove jobs after printing so there won't be multiple + or - jobs */ for (j = job_list; j; j = tmp) { tmp = j->next; if (j->flags & JF_REMOVE) remove_job(j, "jobs"); } sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); return 0; } /* list jobs for top-level notification */ void j_notify() { Job *j, *tmp; sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); for (j = job_list; j; j = j->next) { #ifdef JOBS if (Flag(FMONITOR) && (j->flags & JF_CHANGED)) j_print(j, JP_MEDIUM, shl_out); #endif /* JOBS */ /* Remove job after doing reports so there aren't * multiple +/- jobs. */ if (j->state == PEXITED || j->state == PSIGNALLED) j->flags |= JF_REMOVE; } for (j = job_list; j; j = tmp) { tmp = j->next; if (j->flags & JF_REMOVE) remove_job(j, "notify"); } shf_flush(shl_out); sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); } /* Return pid of last process in last asynchronous job */ pid_t j_async() { sigset_t omask; sigprocmask(SIG_BLOCK, &sm_sigchld, &omask); if (async_job) async_job->flags |= JF_KNOWN; sigprocmask(SIG_SETMASK, &omask, (sigset_t *) 0); return async_pid; } /* Make j the last async process * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void j_set_async(j) Job *j; { Job *jl, *oldest; if (async_job && (async_job->flags & (JF_KNOWN|JF_ZOMBIE)) == JF_ZOMBIE) remove_job(async_job, "async"); if (!(j->flags & JF_STARTED)) { internal_errorf(0, "j_async: job not started"); return; } async_job = j; async_pid = j->last_proc->pid; while (nzombie > child_max) { oldest = (Job *) 0; for (jl = job_list; jl; jl = jl->next) if (jl != async_job && (jl->flags & JF_ZOMBIE) && (!oldest || jl->age < oldest->age)) oldest = jl; if (!oldest) { /* XXX debugging */ if (!(async_job->flags & JF_ZOMBIE) || nzombie != 1) { internal_errorf(0, "j_async: bad nzombie (%d)", nzombie); nzombie = 0; } break; } remove_job(oldest, "zombie"); } } /* Start a job: set STARTED, check for held signals and set j->last_proc * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void j_startjob(j) Job *j; { Proc *p; j->flags |= JF_STARTED; for (p = j->proc_list; p->next; p = p->next) ; j->last_proc = p; #ifdef NEED_PGRP_SYNC if (j_sync_open) { j_sync_open = 0; closepipe(j_sync_pipe); } #endif /* NEED_PGRP_SYNC */ if (held_sigchld) { held_sigchld = 0; /* Don't call j_sigchld() as it may remove job... */ kill(procpid, SIGCHLD); } } /* * wait for job to complete or change state * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static int j_waitj(j, flags, where) Job *j; int flags; /* see JW_* */ const char *where; { int rv; /* * No auto-notify on the job we are waiting on. */ j->flags |= JF_WAITING; if (flags & JW_ASYNCNOTIFY) j->flags |= JF_W_ASYNCNOTIFY; if (!Flag(FMONITOR)) flags |= JW_STOPPEDWAIT; while ((volatile int) j->state == PRUNNING || ((flags & JW_STOPPEDWAIT) && (volatile int) j->state == PSTOPPED)) { sigsuspend(&sm_default); if (fatal_trap) { int oldf = j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY); j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY); runtraps(TF_FATAL); j->flags |= oldf; /* not reached... */ } if ((flags & JW_INTERRUPT) && (rv = trap_pending())) { j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY); return -rv; } } j->flags &= ~(JF_WAITING|JF_W_ASYNCNOTIFY); if (j->flags & JF_FG) { int status; j->flags &= ~JF_FG; #ifdef TTY_PGRP if (Flag(FMONITOR) && ttypgrp_ok && j->pgrp) { /* * Save the tty's current pgrp so it can be restored * when the job is foregrounded. This is to * deal with things like the GNU su which does * a fork/exec instead of an exec (the fork means * the execed shell gets a different pid from its * pgrp, so naturally it sets its pgrp and gets hosed * when it gets foregrounded by the parent shell, which * has restored the tty's pgrp to that of the su * process). */ if (j->state == PSTOPPED && (j->saved_ttypgrp = tcgetpgrp(tty_fd)) >= 0) j->flags |= JF_SAVEDTTYPGRP; if (tcsetpgrp(tty_fd, our_pgrp) < 0) { warningf(true, "j_waitj: tcsetpgrp(%d, %d) failed: %s", tty_fd, (int) our_pgrp, strerror(errno)); } if (j->state == PSTOPPED) { j->flags |= JF_SAVEDTTY; get_tty(tty_fd, &j->ttystate); } } #endif /* TTY_PGRP */ if (tty_fd >= 0) { /* Only restore tty settings if job was originally * started in the foreground. Problems can be * caused by things like `more foobar &' which will * typically get and save the shell's vi/emacs tty * settings before setting up the tty for itself; * when more exits, it restores the `original' * settings, and things go down hill from there... */ if (j->state == PEXITED && j->status == 0 && (j->flags & JF_USETTYMODE)) { get_tty(tty_fd, &tty_state); } else { set_tty(tty_fd, &tty_state, (j->state == PEXITED) ? 0 : TF_MIPSKLUDGE); /* Don't use tty mode if job is stopped and * later restarted and exits. Consider * the sequence: * vi foo (stopped) * ... * stty something * ... * fg (vi; ZZ) * mode should be that of the stty, not what * was before the vi started. */ if (j->state == PSTOPPED) j->flags &= ~JF_USETTYMODE; } } #ifdef JOBS /* If it looks like user hit ^C to kill a job, pretend we got * one too to break out of for loops, etc. (at&t ksh does this * even when not monitoring, but this doesn't make sense since * a tty generated ^C goes to the whole process group) */ status = j->last_proc->status; if (Flag(FMONITOR) && j->state == PSIGNALLED && WIFSIGNALED(status) && (sigtraps[WTERMSIG(status)].flags & TF_TTY_INTR)) trapsig(WTERMSIG(status)); #endif /* JOBS */ } j_usrtime = j->usrtime; j_systime = j->systime; rv = j->status; if (!(flags & JW_ASYNCNOTIFY) && (!Flag(FMONITOR) || j->state != PSTOPPED)) { j_print(j, JP_SHORT, shl_out); shf_flush(shl_out); } if (j->state != PSTOPPED && (!Flag(FMONITOR) || !(flags & JW_ASYNCNOTIFY))) remove_job(j, where); return rv; } /* SIGCHLD handler to reap children and update job states * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static RETSIGTYPE j_sigchld(sig) int sig; { int errno_ = errno; Job *j; Proc UNINITIALIZED(*p); int pid; int status; struct tms t0, t1; /* Don't wait for any processes if a job is partially started. * This is so we don't do away with the process group leader * before all the processes in a pipe line are started (so the * setpgid() won't fail) */ for (j = job_list; j; j = j->next) if (j->ppid == procpid && !(j->flags & JF_STARTED)) { held_sigchld = 1; return RETSIGVAL; } times(&t0); do { pid = waitpid(-1, &status, (WNOHANG|WUNTRACED)); if (pid <= 0) /* return if would block (0) ... */ break; /* ... or no children or interrupted (-1) */ times(&t1); /* find job and process structures for this pid */ for (j = job_list; j != (Job *) 0; j = j->next) for (p = j->proc_list; p != (Proc *) 0; p = p->next) if (p->pid == pid) goto found; found: if (j == (Job *) 0) { /* Can occur if process has kids, then execs shell warningf(true, "bad process waited for (pid = %d)", pid); */ t0 = t1; continue; } j->usrtime += t1.tms_cutime - t0.tms_cutime; j->systime += t1.tms_cstime - t0.tms_cstime; t0 = t1; p->status = status; #ifdef JOBS if (WIFSTOPPED(status)) p->state = PSTOPPED; else #endif /* JOBS */ if (WIFSIGNALED(status)) p->state = PSIGNALLED; else p->state = PEXITED; check_job(j); /* check to see if entire job is done */ } while (1); errno = errno_; return RETSIGVAL; } /* * Called only when a process in j has exited/stopped (ie, called only * from j_sigchld()). If no processes are running, the job status * and state are updated, asynchronous job notification is done and, * if unneeded, the job is removed. * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void check_job(j) Job *j; { int jstate; Proc *p; /* XXX debugging (nasty - interrupt routine using shl_out) */ if (!(j->flags & JF_STARTED)) { internal_errorf(0, "check_job: job started (flags 0x%x)", j->flags); return; } jstate = PRUNNING; for (p=j->proc_list; p != (Proc *) 0; p = p->next) { if (p->state == PRUNNING) return; /* some processes still running */ if (p->state > jstate) jstate = p->state; } j->state = jstate; switch (j->last_proc->state) { case PEXITED: j->status = WEXITSTATUS(j->last_proc->status); break; case PSIGNALLED: j->status = 128 + WTERMSIG(j->last_proc->status); break; default: j->status = 0; break; } #ifdef KSH /* Note when co-process dies: can't be done in j_wait() nor * remove_job() since neither may be called for non-interactive * shells. */ if (j->state == PEXITED || j->state == PSIGNALLED) { /* No need to keep co-process input any more * (at least, this is what ksh93d thinks) */ if (coproc.job == j) { coproc.job = (void *) 0; /* XXX would be nice to get the closes out of here * so they aren't done in the signal handler. * Would mean a check in coproc_getfd() to * do "if job == 0 && write >= 0, close write". */ coproc_write_close(coproc.write); } /* Do we need to keep the output? */ if (j->coproc_id && j->coproc_id == coproc.id && --coproc.njobs == 0) coproc_readw_close(coproc.read); } #endif /* KSH */ j->flags |= JF_CHANGED; #ifdef JOBS if (Flag(FMONITOR) && !(j->flags & JF_XXCOM)) { /* Only put stopped jobs at the front to avoid confusing * the user (don't want finished jobs effecting %+ or %-) */ if (j->state == PSTOPPED) put_job(j, PJ_ON_FRONT); if (Flag(FNOTIFY) && (j->flags & (JF_WAITING|JF_W_ASYNCNOTIFY)) != JF_WAITING) { /* Look for the real file descriptor 2 */ { struct env *ep; int fd = 2; for (ep = e; ep; ep = ep->oenv) if (ep->savefd && ep->savefd[2]) fd = ep->savefd[2]; shf_reopen(fd, SHF_WR, shl_j); } /* Can't call j_notify() as it removes jobs. The job * must stay in the job list as j_waitj() may be * running with this job. */ j_print(j, JP_MEDIUM, shl_j); shf_flush(shl_j); if (!(j->flags & JF_WAITING) && j->state != PSTOPPED) remove_job(j, "notify"); } } #endif /* JOBS */ if (!Flag(FMONITOR) && !(j->flags & (JF_WAITING|JF_FG)) && j->state != PSTOPPED) { if (j == async_job || (j->flags & JF_KNOWN)) { j->flags |= JF_ZOMBIE; j->job = -1; nzombie++; } else remove_job(j, "checkjob"); } } /* * Print job status in either short, medium or long format. * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void j_print(j, how, shf) Job *j; int how; struct shf *shf; { Proc *p; int state; int status; int coredumped; char jobchar = ' '; char buf[64]; const char *filler; int output = 0; if (how == JP_PGRP) { /* POSIX doesn't say what to do it there is no process * group leader (ie, !FMONITOR). We arbitrarily return * last pid (which is what $! returns). */ shf_fprintf(shf, "%d\n", j->pgrp ? j->pgrp : (j->last_proc ? j->last_proc->pid : 0)); return; } j->flags &= ~JF_CHANGED; filler = j->job > 10 ? "\n " : "\n "; if (j == job_list) jobchar = '+'; else if (j == job_list->next) jobchar = '-'; for (p = j->proc_list; p != (Proc *) 0;) { coredumped = 0; switch (p->state) { case PRUNNING: strlcpy(buf, "Running", sizeof buf); break; case PSTOPPED: strlcpy(buf, sigtraps[WSTOPSIG(p->status)].mess, sizeof buf); break; case PEXITED: if (how == JP_SHORT) buf[0] = '\0'; else if (WEXITSTATUS(p->status) == 0) strlcpy(buf, "Done", sizeof buf); else shf_snprintf(buf, sizeof(buf), "Done (%d)", WEXITSTATUS(p->status)); break; case PSIGNALLED: if (WCOREDUMP(p->status)) coredumped = 1; /* kludge for not reporting `normal termination signals' * (ie, SIGINT, SIGPIPE) */ if (how == JP_SHORT && !coredumped && (WTERMSIG(p->status) == SIGINT || WTERMSIG(p->status) == SIGPIPE)) { buf[0] = '\0'; } else strlcpy(buf, sigtraps[WTERMSIG(p->status)].mess, sizeof buf); break; } if (how != JP_SHORT) { if (p == j->proc_list) shf_fprintf(shf, "[%d] %c ", j->job, jobchar); else shf_fprintf(shf, "%s", filler); } if (how == JP_LONG) shf_fprintf(shf, "%5d ", p->pid); if (how == JP_SHORT) { if (buf[0]) { output = 1; shf_fprintf(shf, "%s%s ", buf, coredumped ? " (core dumped)" : null); } } else { output = 1; shf_fprintf(shf, "%-20s %s%s%s", buf, p->command, p->next ? "|" : null, coredumped ? " (core dumped)" : null); } state = p->state; status = p->status; p = p->next; while (p && p->state == state && p->status == status) { if (how == JP_LONG) shf_fprintf(shf, "%s%5d %-20s %s%s", filler, p->pid, space, p->command, p->next ? "|" : null); else if (how == JP_MEDIUM) shf_fprintf(shf, " %s%s", p->command, p->next ? "|" : null); p = p->next; } } if (output) shf_fprintf(shf, newline); } /* Convert % sequence to job * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static Job * j_lookup(cp, ecodep) const char *cp; int *ecodep; { Job *j, *last_match; Proc *p; int len, job = 0; if (digit(*cp)) { job = atoi(cp); /* Look for last_proc->pid (what $! returns) first... */ for (j = job_list; j != (Job *) 0; j = j->next) if (j->last_proc && j->last_proc->pid == job) return j; /* ...then look for process group (this is non-POSIX), * but should not break anything (so FPOSIX isn't used). */ for (j = job_list; j != (Job *) 0; j = j->next) if (j->pgrp && j->pgrp == job) return j; if (ecodep) *ecodep = JL_NOSUCH; return (Job *) 0; } if (*cp != '%') { if (ecodep) *ecodep = JL_INVALID; return (Job *) 0; } switch (*++cp) { case '\0': /* non-standard */ case '+': case '%': if (job_list != (Job *) 0) return job_list; break; case '-': if (job_list != (Job *) 0 && job_list->next) return job_list->next; break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': job = atoi(cp); for (j = job_list; j != (Job *) 0; j = j->next) if (j->job == job) return j; break; case '?': /* %?string */ last_match = (Job *) 0; for (j = job_list; j != (Job *) 0; j = j->next) for (p = j->proc_list; p != (Proc *) 0; p = p->next) if (strstr(p->command, cp+1) != (char *) 0) { if (last_match) { if (ecodep) *ecodep = JL_AMBIG; return (Job *) 0; } last_match = j; } if (last_match) return last_match; break; default: /* %string */ len = strlen(cp); last_match = (Job *) 0; for (j = job_list; j != (Job *) 0; j = j->next) if (strncmp(cp, j->proc_list->command, len) == 0) { if (last_match) { if (ecodep) *ecodep = JL_AMBIG; return (Job *) 0; } last_match = j; } if (last_match) return last_match; break; } if (ecodep) *ecodep = JL_NOSUCH; return (Job *) 0; } static Job *free_jobs; static Proc *free_procs; /* allocate a new job and fill in the job number. * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static Job * new_job() { int i; Job *newj, *j; if (free_jobs != (Job *) 0) { newj = free_jobs; free_jobs = free_jobs->next; } else newj = (Job *) alloc(sizeof(Job), APERM); /* brute force method */ for (i = 1; ; i++) { for (j = job_list; j && j->job != i; j = j->next) ; if (j == (Job *) 0) break; } newj->job = i; return newj; } /* Allocate new process struct * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static Proc * new_proc() { Proc *p; if (free_procs != (Proc *) 0) { p = free_procs; free_procs = free_procs->next; } else p = (Proc *) alloc(sizeof(Proc), APERM); return p; } /* Take job out of job_list and put old structures into free list. * Keeps nzombies, last_job and async_job up to date. * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void remove_job(j, where) Job *j; const char *where; { Proc *p, *tmp; Job **prev, *curr; prev = &job_list; curr = *prev; for (; curr != (Job *) 0 && curr != j; prev = &curr->next, curr = *prev) ; if (curr != j) { internal_errorf(0, "remove_job: job not found (%s)", where); return; } *prev = curr->next; /* free up proc structures */ for (p = j->proc_list; p != (Proc *) 0; ) { tmp = p; p = p->next; tmp->next = free_procs; free_procs = tmp; } if ((j->flags & JF_ZOMBIE) && j->ppid == procpid) --nzombie; j->next = free_jobs; free_jobs = j; if (j == last_job) last_job = (Job *) 0; if (j == async_job) async_job = (Job *) 0; } /* put j in a particular location (taking it out job_list if it is there * already) * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static void put_job(j, where) Job *j; int where; { Job **prev, *curr; /* Remove job from list (if there) */ prev = &job_list; curr = job_list; for (; curr && curr != j; prev = &curr->next, curr = *prev) ; if (curr == j) *prev = curr->next; switch (where) { case PJ_ON_FRONT: j->next = job_list; job_list = j; break; case PJ_PAST_STOPPED: prev = &job_list; curr = job_list; for (; curr && curr->state == PSTOPPED; prev = &curr->next, curr = *prev) ; j->next = curr; *prev = j; break; } } /* nuke a job (called when unable to start full job). * * If jobs are compiled in then this routine expects sigchld to be blocked. */ static int kill_job(j, sig) Job *j; int sig; { Proc *p; int rval = 0; for (p = j->proc_list; p != (Proc *) 0; p = p->next) if (p->pid != 0) if (kill(p->pid, sig) < 0) rval = -1; return rval; }