/* $Header: /cvs/gridengine/source/3rdparty/qtcsh/sh.proc.c,v 1.2 2005/01/19 11:12:51 ernst Exp $ */ /* * sh.proc.c: Job manipulations */ /*- * Copyright (c) 1980, 1991 The Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include "sh.h" RCSID("$Id: sh.proc.c,v 1.2 2005/01/19 11:12:51 ernst Exp $") #include "ed.h" #include "tc.h" #include "tc.wait.h" #ifdef WINNT #undef POSIX #define POSIX #endif /* WINNT */ #ifdef aiws # undef HZ # define HZ 16 #endif /* aiws */ #if defined(_BSD) || (defined(IRIS4D) && __STDC__) || defined(__lucid) || defined(linux) # define BSDWAIT #endif /* _BSD || (IRIS4D && __STDC__) || __lucid || linux */ #ifndef WTERMSIG # define WTERMSIG(w) (((union wait *) &(w))->w_termsig) # ifndef BSDWAIT # define BSDWAIT # endif /* !BSDWAIT */ #endif /* !WTERMSIG */ #ifndef WEXITSTATUS # define WEXITSTATUS(w) (((union wait *) &(w))->w_retcode) #endif /* !WEXITSTATUS */ #ifndef WSTOPSIG # define WSTOPSIG(w) (((union wait *) &(w))->w_stopsig) #endif /* !WSTOPSIG */ #ifdef __osf__ # ifndef WCOREDUMP # define WCOREDUMP(x) (_W_INT(x) & WCOREFLAG) # endif #endif #ifndef WCOREDUMP # ifdef BSDWAIT # define WCOREDUMP(w) (((union wait *) &(w))->w_coredump) # else /* !BSDWAIT */ # define WCOREDUMP(w) ((w) & 0200) # endif /* !BSDWAIT */ #endif /* !WCOREDUMP */ /* * C Shell - functions that manage processes, handling hanging, termination */ #define BIGINDEX 9 /* largest desirable job index */ #ifdef BSDTIMES # ifdef convex /* use 'cvxrusage' to get parallel statistics */ static struct cvxrusage zru = {{0L, 0L}, {0L, 0L}, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, {0L, 0L}, 0LL, 0LL, 0LL, 0LL, 0L, 0L, 0L, 0LL, 0LL, {0L, 0L, 0L, 0L, 0L}}; # else # if defined(SUNOS4) || defined(hp9000) || (defined(__alpha) && defined(__osf__)) static struct rusage zru = {{0L, 0L}, {0L, 0L}, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L}; # else /* !SUNOS4 && !hp9000 && !(__alpha && __osf__) */ # ifdef masscomp /* * Initialization of this structure under RTU 4.1A & RTU 5.0 is problematic * because the first two elements are unions of a time_t and a struct timeval. * So we'll just have to trust the loader to do the "right thing", DAS DEC-90. */ static struct rusage zru; # else /* masscomp */ static struct rusage zru = {{0L, 0L}, {0L, 0L}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # endif /* masscomp */ # endif /* SUNOS4 || hp9000 || (__alpha && __osf__) */ # endif /* convex */ #else /* !BSDTIMES */ # ifdef _SEQUENT_ static struct process_stats zru = {{0L, 0L}, {0L, 0L}, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; # else /* !_SEQUENT_ */ # ifdef _SX static struct tms zru = {0, 0, 0, 0}, lru = {0, 0, 0, 0}; # else /* !_SX */ static struct tms zru = {0L, 0L, 0L, 0L}, lru = {0L, 0L, 0L, 0L}; # endif /* !_SX */ # endif /* !_SEQUENT_ */ #endif /* !BSDTIMES */ #ifndef RUSAGE_CHILDREN # define RUSAGE_CHILDREN -1 #endif /* RUSAGE_CHILDREN */ static void pflushall __P((void)); static void pflush __P((struct process *)); static void pfree __P((struct process *)); static void pclrcurr __P((struct process *)); static void padd __P((struct command *)); static int pprint __P((struct process *, int)); static void ptprint __P((struct process *)); static void pads __P((Char *)); static void pkill __P((Char **, int)); static struct process *pgetcurr __P((struct process *)); static void okpcntl __P((void)); static void setttypgrp __P((int)); /* * pchild - called at interrupt level by the SIGCHLD signal * indicating that at least one child has terminated or stopped * thus at least one wait system call will definitely return a * childs status. Top level routines (like pwait) must be sure * to mask interrupts when playing with the proclist data structures! */ sigret_t /*ARGSUSED*/ pchild(snum) int snum; { register struct process *pp; register struct process *fp; register int pid; #if defined(BSDJOBS) || (!defined(BSDTIMES) && (defined(INTERIX) || defined(ODT) || defined(aiws) || defined(uts))) extern int insource; #endif /* BSDJOBS || (!BSDTIMES && (ODT || aiws || uts)) */ #ifdef BSDWAIT union wait w; #else /* !BSDWAIT */ int w; #endif /* !BSDWAIT */ int jobflags; #ifdef BSDTIMES struct sysrusage ru; #else /* !BSDTIMES */ # ifdef _SEQUENT_ struct process_stats ru; struct process_stats cpst1, cpst2; timeval_t tv; # else /* !_SEQUENT_ */ struct tms proctimes; USE(snum); if (!timesdone) { timesdone++; (void) times(&shtimes); } # endif /* !_SEQUENT_ */ #endif /* !BSDTIMES */ #ifdef JOBDEBUG xprintf("pchild()\n"); #endif /* JOBDEBUG */ /* Christos on where the signal(SIGCHLD, pchild) shoud be: * * I think that it should go *after* the wait, unlike most signal handlers. * * In release two (for which I have manuals), it says that wait will remove * the first child from the queue of dead children. * All the rest of the children that die while in the signal handler of the * SIGC(H)LD, will be placed in the queue. If signal is called to re-establish * the signal handler, and there are items in the queue, the process will * receive another SIGC(H)LD before signal returns. BTW this is from the * manual page on comp-sim... Maybe it is not applicable to the hp's, but * I read on the news in comp.unix.wizards or comp.unix.questions yesterday * that another person was claiming the the signal() call should be after * the wait(). */ loop: errno = 0; /* reset, just in case */ #ifdef JOBDEBUG xprintf("Waiting...\n"); flush(); #endif /* JOBDEBUG */ #ifndef WINNT # ifdef BSDJOBS # ifdef BSDTIMES # ifdef convex /* use 'cvxwait' to get parallel statistics */ pid = cvxwait(&w, (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru); # else /* both a wait3 and rusage */ # if !defined(BSDWAIT) || defined(NeXT) || defined(MACH) || defined(linux) || (defined(IRIS4D) && (__STDC__ || defined(FUNCPROTO)) && SYSVREL <= 3) || defined(__lucid) || defined(__osf__) pid = wait3(&w, (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru); # else /* BSDWAIT */ pid = wait3(&w.w_status, (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), &ru); # endif /* BSDWAIT */ # endif /* convex */ # else /* !BSDTIMES */ # ifdef _SEQUENT_ (void) get_process_stats(&tv, PS_SELF, 0, &cpst1); pid = waitpid(-1, &w, (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG)); (void) get_process_stats(&tv, PS_SELF, 0, &cpst2); pr_stat_sub(&cpst2, &cpst1, &ru); # else /* !_SEQUENT_ */ # ifndef POSIX /* we have a wait3, but no rusage stuff */ pid = wait3(&w.w_status, (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), 0); # else /* POSIX */ pid = waitpid(-1, &w, (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG)); # endif /* POSIX */ # endif /* !_SEQUENT_ */ # endif /* !BSDTIMES */ # else /* !BSDJOBS */ # ifdef BSDTIMES # define HAVEwait3 /* both a wait3 and rusage */ # ifdef hpux pid = wait3(&w.w_status, WNOHANG, 0); # else /* !hpux */ pid = wait3(&w.w_status, WNOHANG, &ru); # endif /* !hpux */ # else /* !BSDTIMES */ # if defined(INTERIX) || defined(ODT) /* For Sco Unix 3.2.0 or ODT 1.0 */ # define HAVEwait3 pid = waitpid(-1, &w, (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG)); # endif /* ODT */ # if defined(aiws) || defined(uts) # define HAVEwait3 pid = wait3(&w.w_status, (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG), 0); # endif /* aiws || uts */ # ifndef HAVEwait3 # ifdef UNRELSIGS /* no wait3, therefore no rusage */ /* on Sys V, this may hang. I hope it's not going to be a problem */ # ifdef _MINIX pid = wait(&w); # else /* !_MINIX */ pid = ourwait(&w.w_status); # endif /* _MINIX */ # else /* !UNRELSIGS */ /* * XXX: for greater than 3 we should use waitpid(). * but then again, SVR4 falls into the POSIX/BSDJOBS category. */ pid = wait(&w.w_status); # endif /* !UNRELSIGS */ # endif /* !HAVEwait3 */ # endif /* !BSDTIMES */ # ifndef BSDSIGS (void) sigset(SIGCHLD, pchild); # endif /* !BSDSIGS */ # endif /* !BSDJOBS */ #else /* WINNT */ { extern int insource; pid = waitpid(-1, &w, (setintr && (intty || insource) ? WNOHANG | WUNTRACED : WNOHANG)); } #endif /* WINNT */ #ifdef JOBDEBUG xprintf("parent %d pid %d, retval %x termsig %x retcode %x\n", getpid(), pid, w, WTERMSIG(w), WEXITSTATUS(w)); flush(); #endif /* JOBDEBUG */ if ((pid == 0) || (pid == -1)) { #ifdef JOBDEBUG xprintf("errno == %d\n", errno); #endif /* JOBDEBUG */ if (errno == EINTR) { errno = 0; goto loop; } pnoprocesses = pid == -1; #ifndef SIGVOID return (0); #else /* !SIGVOID */ return; #endif /* !SIGVOID */ } for (pp = proclist.p_next; pp != NULL; pp = pp->p_next) if (pid == pp->p_procid) goto found; #if !defined(BSDJOBS) && !defined(WINNT) /* this should never have happened */ stderror(ERR_SYNC, pid); xexit(0); #else /* BSDJOBS || WINNT */ goto loop; #endif /* !BSDJOBS && !WINNT */ found: pp->p_flags &= ~(PRUNNING | PSTOPPED | PREPORTED); if (WIFSTOPPED(w)) { pp->p_flags |= PSTOPPED; pp->p_reason = WSTOPSIG(w); } else { if (pp->p_flags & (PTIME | PPTIME) || adrof(STRtime)) #ifndef BSDTIMES # ifdef _SEQUENT_ (void) get_process_stats(&pp->p_etime, PS_SELF, NULL, NULL); # else /* !_SEQUENT_ */ # ifndef COHERENT pp->p_etime = times(&proctimes); # else /* COHERENT */ pp->p_etime = HZ * time(NULL); times(&proctimes); # endif /* COHERENT */ # endif /* !_SEQUENT_ */ #else /* BSDTIMES */ (void) gettimeofday(&pp->p_etime, NULL); #endif /* BSDTIMES */ #if defined(BSDTIMES) || defined(_SEQUENT_) pp->p_rusage = ru; #else /* !BSDTIMES && !_SEQUENT_ */ (void) times(&proctimes); pp->p_utime = proctimes.tms_cutime - shtimes.tms_cutime; pp->p_stime = proctimes.tms_cstime - shtimes.tms_cstime; shtimes = proctimes; #endif /* !BSDTIMES && !_SEQUENT_ */ if (WIFSIGNALED(w)) { if (WTERMSIG(w) == SIGINT) pp->p_flags |= PINTERRUPTED; else pp->p_flags |= PSIGNALED; if (WCOREDUMP(w)) pp->p_flags |= PDUMPED; pp->p_reason = WTERMSIG(w); } else { pp->p_reason = WEXITSTATUS(w); if (pp->p_reason != 0) pp->p_flags |= PAEXITED; else pp->p_flags |= PNEXITED; } } jobflags = 0; fp = pp; do { if ((fp->p_flags & (PPTIME | PRUNNING | PSTOPPED)) == 0 && !child && adrof(STRtime) && #ifdef BSDTIMES fp->p_rusage.ru_utime.tv_sec + fp->p_rusage.ru_stime.tv_sec #else /* !BSDTIMES */ # ifdef _SEQUENT_ fp->p_rusage.ps_utime.tv_sec + fp->p_rusage.ps_stime.tv_sec # else /* !_SEQUENT_ */ # ifndef POSIX (fp->p_utime + fp->p_stime) / HZ # else /* POSIX */ (fp->p_utime + fp->p_stime) / clk_tck # endif /* POSIX */ # endif /* !_SEQUENT_ */ #endif /* !BSDTIMES */ >= atoi(short2str(varval(STRtime)))) fp->p_flags |= PTIME; jobflags |= fp->p_flags; } while ((fp = fp->p_friends) != pp); pp->p_flags &= ~PFOREGND; if (pp == pp->p_friends && (pp->p_flags & PPTIME)) { pp->p_flags &= ~PPTIME; pp->p_flags |= PTIME; } if ((jobflags & (PRUNNING | PREPORTED)) == 0) { fp = pp; do { if (fp->p_flags & PSTOPPED) fp->p_flags |= PREPORTED; } while ((fp = fp->p_friends) != pp); while (fp->p_procid != fp->p_jobid) fp = fp->p_friends; if (jobflags & PSTOPPED) { if (pcurrent && pcurrent != fp) pprevious = pcurrent; pcurrent = fp; } else pclrcurr(fp); if (jobflags & PFOREGND) { if (!(jobflags & (PSIGNALED | PSTOPPED | PPTIME) || #ifdef notdef jobflags & PAEXITED || #endif /* notdef */ !eq(dcwd->di_name, fp->p_cwd->di_name))) { /* PWP: print a newline after ^C */ if (jobflags & PINTERRUPTED) { #ifdef SHORT_STRINGS xputchar('\r' | QUOTE), xputchar('\n'); #else /* !SHORT_STRINGS */ xprintf("\215\n"); /* \215 is a quoted ^M */ #endif /* !SHORT_STRINGS */ } #ifdef notdef else if ((jobflags & (PTIME|PSTOPPED)) == PTIME) ptprint(fp); #endif /* notdef */ } } else { if (jobflags & PNOTIFY || adrof(STRnotify)) { #ifdef SHORT_STRINGS xputchar('\r' | QUOTE), xputchar('\n'); #else /* !SHORT_STRINGS */ xprintf("\215\n"); /* \215 is a quoted ^M */ #endif /* !SHORT_STRINGS */ (void) pprint(pp, NUMBER | NAME | REASON); if ((jobflags & PSTOPPED) == 0) pflush(pp); { extern Char GettingInput; if (GettingInput) { errno = 0; (void) Rawmode(); #ifdef notdef /* * don't really want to do that, because it * will erase our message in case of multi-line * input */ ClearLines(); #endif /* notdef */ ClearDisp(); Refresh(); } } } else { fp->p_flags |= PNEEDNOTE; neednote++; } } } #if defined(BSDJOBS) || defined(HAVEwait3) goto loop; #endif /* BSDJOBS || HAVEwait3 */ } void pnote() { register struct process *pp; int flags; #ifdef BSDSIGS sigmask_t omask; #endif /* BSDSIGS */ neednote = 0; for (pp = proclist.p_next; pp != NULL; pp = pp->p_next) { if (pp->p_flags & PNEEDNOTE) { #ifdef BSDSIGS omask = sigblock(sigmask(SIGCHLD)); #else /* !BSDSIGS */ (void) sighold(SIGCHLD); #endif /* !BSDSIGS */ pp->p_flags &= ~PNEEDNOTE; flags = pprint(pp, NUMBER | NAME | REASON); if ((flags & (PRUNNING | PSTOPPED)) == 0) pflush(pp); #ifdef BSDSIGS (void) sigsetmask(omask); #else /* !BSDSIGS */ (void) sigrelse(SIGCHLD); #endif /* !BSDSIGS */ } } } static void pfree(pp) struct process *pp; { xfree((ptr_t) pp->p_command); if (pp->p_cwd && --pp->p_cwd->di_count == 0) if (pp->p_cwd->di_next == 0) dfree(pp->p_cwd); xfree((ptr_t) pp); } /* * pwait - wait for current job to terminate, maintaining integrity * of current and previous job indicators. */ void pwait() { register struct process *fp, *pp; #ifdef BSDSIGS sigmask_t omask; #endif /* BSDSIGS */ /* * Here's where dead procs get flushed. */ #ifdef BSDSIGS omask = sigblock(sigmask(SIGCHLD)); #else /* !BSDSIGS */ (void) sighold(SIGCHLD); #endif /* !BSDSIGS */ for (pp = (fp = &proclist)->p_next; pp != NULL; pp = (fp = pp)->p_next) if (pp->p_procid == 0) { fp->p_next = pp->p_next; pfree(pp); pp = fp; } #ifdef BSDSIGS (void) sigsetmask(omask); #else /* !BSDSIGS */ (void) sigrelse(SIGCHLD); # ifdef notdef if (setintr) sigignore(SIGINT); # endif /* notdef */ #endif /* !BSDSIGS */ pjwait(pcurrjob); } /* * pjwait - wait for a job to finish or become stopped * It is assumed to be in the foreground state (PFOREGND) */ void pjwait(pp) register struct process *pp; { register struct process *fp; int jobflags, reason; #ifdef BSDSIGS sigmask_t omask; #endif /* BSDSIGS */ #ifdef UNRELSIGS signalfun_t inthandler; #endif /* UNRELSIGS */ while (pp->p_procid != pp->p_jobid) pp = pp->p_friends; fp = pp; do { if ((fp->p_flags & (PFOREGND | PRUNNING)) == PRUNNING) xprintf(CGETS(17, 1, "BUG: waiting for background job!\n")); } while ((fp = fp->p_friends) != pp); /* * Now keep pausing as long as we are not interrupted (SIGINT), and the * target process, or any of its friends, are running */ fp = pp; #ifdef BSDSIGS omask = sigblock(sigmask(SIGCHLD)); #endif /* BSDSIGS */ #ifdef UNRELSIGS if (setintr) inthandler = signal(SIGINT, SIG_IGN); #endif /* UNRELSIGS */ for (;;) { #ifndef BSDSIGS (void) sighold(SIGCHLD); #endif /* !BSDSIGS */ jobflags = 0; do jobflags |= fp->p_flags; while ((fp = (fp->p_friends)) != pp); if ((jobflags & PRUNNING) == 0) break; #ifdef JOBDEBUG xprintf("%d starting to sigpause for SIGCHLD on %d\n", getpid(), fp->p_procid); #endif /* JOBDEBUG */ #ifdef BSDSIGS /* (void) sigpause(sigblock((sigmask_t) 0) &~ sigmask(SIGCHLD)); */ (void) sigpause(omask & ~sigmask(SIGCHLD)); #else /* !BSDSIGS */ (void) sigpause(SIGCHLD); #endif /* !BSDSIGS */ } #ifdef JOBDEBUG xprintf("%d returned from sigpause loop\n", getpid()); #endif /* JOBDEBUG */ #ifdef BSDSIGS (void) sigsetmask(omask); #else /* !BSDSIGS */ (void) sigrelse(SIGCHLD); #endif /* !BSDSIGS */ #ifdef UNRELSIGS if (setintr) (void) signal(SIGINT, inthandler); #endif /* UNRELSIGS */ #ifdef BSDJOBS if (tpgrp > 0) /* get tty back */ (void) tcsetpgrp(FSHTTY, tpgrp); #endif /* BSDJOBS */ if ((jobflags & (PSIGNALED | PSTOPPED | PTIME)) || !eq(dcwd->di_name, fp->p_cwd->di_name)) { if (jobflags & PSTOPPED) { xputchar('\n'); if (adrof(STRlistjobs)) { Char *jobcommand[3]; jobcommand[0] = STRjobs; if (eq(varval(STRlistjobs), STRlong)) jobcommand[1] = STRml; else jobcommand[1] = NULL; jobcommand[2] = NULL; dojobs(jobcommand, NULL); (void) pprint(pp, SHELLDIR); } else (void) pprint(pp, AREASON | SHELLDIR); } else (void) pprint(pp, AREASON | SHELLDIR); } if ((jobflags & (PINTERRUPTED | PSTOPPED)) && setintr && (!gointr || !eq(gointr, STRminus))) { if ((jobflags & PSTOPPED) == 0) pflush(pp); pintr1(0); /* NOTREACHED */ } reason = 0; fp = pp; do { if (fp->p_reason) reason = fp->p_flags & (PSIGNALED | PINTERRUPTED) ? fp->p_reason | META : fp->p_reason; } while ((fp = fp->p_friends) != pp); /* * Don't report on backquoted jobs, cause it will mess up * their output. */ if ((reason != 0) && (adrof(STRprintexitvalue)) && (pp->p_flags & PBACKQ) == 0) xprintf(CGETS(17, 2, "Exit %d\n"), reason); set(STRstatus, putn(reason), VAR_READWRITE); if (reason && exiterr) exitstat(); pflush(pp); } /* * dowait - wait for all processes to finish */ /*ARGSUSED*/ void dowait(v, c) Char **v; struct command *c; { register struct process *pp; #ifdef BSDSIGS sigmask_t omask; #endif /* BSDSIGS */ USE(c); USE(v); pjobs++; #ifdef BSDSIGS omask = sigblock(sigmask(SIGCHLD)); loop: #else /* !BSDSIGS */ if (setintr) (void) sigrelse(SIGINT); loop: (void) sighold(SIGCHLD); #endif /* !BSDSIGS */ for (pp = proclist.p_next; pp; pp = pp->p_next) if (pp->p_procid && /* pp->p_procid == pp->p_jobid && */ pp->p_flags & PRUNNING) { #ifdef BSDSIGS (void) sigpause((sigmask_t) 0); #else /* !BSDSIGS */ (void) sigpause(SIGCHLD); #endif /* !BSDSIGS */ goto loop; } #ifdef BSDSIGS (void) sigsetmask(omask); #else /* !BSDSIGS */ (void) sigrelse(SIGCHLD); #endif /* !BSDSIGS */ pjobs = 0; } /* * pflushall - flush all jobs from list (e.g. at fork()) */ static void pflushall() { register struct process *pp; for (pp = proclist.p_next; pp != NULL; pp = pp->p_next) if (pp->p_procid) pflush(pp); } /* * pflush - flag all process structures in the same job as the * the argument process for deletion. The actual free of the * space is not done here since pflush is called at interrupt level. */ static void pflush(pp) register struct process *pp; { register struct process *np; register int idx; if (pp->p_procid == 0) { xprintf(CGETS(17, 3, "BUG: process flushed twice")); return; } while (pp->p_procid != pp->p_jobid) pp = pp->p_friends; pclrcurr(pp); if (pp == pcurrjob) pcurrjob = 0; idx = pp->p_index; np = pp; do { np->p_index = np->p_procid = 0; np->p_flags &= ~PNEEDNOTE; } while ((np = np->p_friends) != pp); if (idx == pmaxindex) { for (np = proclist.p_next, idx = 0; np; np = np->p_next) if (np->p_index > idx) idx = np->p_index; pmaxindex = idx; } } /* * pclrcurr - make sure the given job is not the current or previous job; * pp MUST be the job leader */ static void pclrcurr(pp) register struct process *pp; { if (pp == pcurrent) { if (pprevious != NULL) { pcurrent = pprevious; pprevious = pgetcurr(pp); } else { pcurrent = pgetcurr(pp); pprevious = pgetcurr(pp); } } else if (pp == pprevious) pprevious = pgetcurr(pp); } /* +4 here is 1 for '\0', 1 ea for << >& >> */ static Char command[PMAXLEN + 4]; static int cmdlen; static Char *cmdp; /* * palloc - allocate a process structure and fill it up. * an important assumption is made that the process is running. */ void palloc(pid, t) int pid; register struct command *t; { register struct process *pp; int i; pp = (struct process *) xcalloc(1, (size_t) sizeof(struct process)); pp->p_procid = pid; pp->p_flags = ((t->t_dflg & F_AMPERSAND) ? 0 : PFOREGND) | PRUNNING; if (t->t_dflg & F_TIME) pp->p_flags |= PPTIME; if (t->t_dflg & F_BACKQ) pp->p_flags |= PBACKQ; if (t->t_dflg & F_HUP) pp->p_flags |= PHUP; cmdp = command; cmdlen = 0; padd(t); *cmdp++ = 0; if (t->t_dflg & F_PIPEOUT) { pp->p_flags |= PPOU; if (t->t_dflg & F_STDERR) pp->p_flags |= PDIAG; } pp->p_command = Strsave(command); if (pcurrjob) { struct process *fp; /* careful here with interrupt level */ pp->p_cwd = 0; pp->p_index = pcurrjob->p_index; pp->p_friends = pcurrjob; pp->p_jobid = pcurrjob->p_procid; for (fp = pcurrjob; fp->p_friends != pcurrjob; fp = fp->p_friends) continue; fp->p_friends = pp; } else { pcurrjob = pp; pp->p_jobid = pid; pp->p_friends = pp; pp->p_cwd = dcwd; dcwd->di_count++; if (pmaxindex < BIGINDEX) pp->p_index = ++pmaxindex; else { struct process *np; for (i = 1;; i++) { for (np = proclist.p_next; np; np = np->p_next) if (np->p_index == i) goto tryagain; pp->p_index = i; if (i > pmaxindex) pmaxindex = i; break; tryagain:; } } if (pcurrent == NULL) pcurrent = pp; else if (pprevious == NULL) pprevious = pp; } pp->p_next = proclist.p_next; proclist.p_next = pp; #ifdef BSDTIMES (void) gettimeofday(&pp->p_btime, NULL); #else /* !BSDTIMES */ # ifdef _SEQUENT_ (void) get_process_stats(&pp->p_btime, PS_SELF, NULL, NULL); # else /* !_SEQUENT_ */ { struct tms tmptimes; # ifndef COHERENT pp->p_btime = times(&tmptimes); # else /* !COHERENT */ pp->p_btime = HZ * time(NULL); times(&tmptimes); # endif /* !COHERENT */ } # endif /* !_SEQUENT_ */ #endif /* !BSDTIMES */ } static void padd(t) register struct command *t; { Char **argp; if (t == 0) return; switch (t->t_dtyp) { case NODE_PAREN: pads(STRLparensp); padd(t->t_dspr); pads(STRspRparen); break; case NODE_COMMAND: for (argp = t->t_dcom; *argp; argp++) { pads(*argp); if (argp[1]) pads(STRspace); } break; case NODE_OR: case NODE_AND: case NODE_PIPE: case NODE_LIST: padd(t->t_dcar); switch (t->t_dtyp) { case NODE_OR: pads(STRspor2sp); break; case NODE_AND: pads(STRspand2sp); break; case NODE_PIPE: pads(STRsporsp); break; case NODE_LIST: pads(STRsemisp); break; default: break; } padd(t->t_dcdr); return; default: break; } if ((t->t_dflg & F_PIPEIN) == 0 && t->t_dlef) { pads((t->t_dflg & F_READ) ? STRspLarrow2sp : STRspLarrowsp); pads(t->t_dlef); } if ((t->t_dflg & F_PIPEOUT) == 0 && t->t_drit) { pads((t->t_dflg & F_APPEND) ? STRspRarrow2 : STRspRarrow); if (t->t_dflg & F_STDERR) pads(STRand); pads(STRspace); pads(t->t_drit); } } static void pads(cp) Char *cp; { register int i; /* * Avoid the Quoted Space alias hack! Reported by: * sam@john-bigboote.ICS.UCI.EDU (Sam Horrocks) */ if (cp[0] == STRQNULL[0]) cp++; i = (int) Strlen(cp); if (cmdlen >= PMAXLEN) return; if (cmdlen + i >= PMAXLEN) { (void) Strcpy(cmdp, STRsp3dots); cmdlen = PMAXLEN; cmdp += 4; return; } (void) Strcpy(cmdp, cp); cmdp += i; cmdlen += i; } /* * psavejob - temporarily save the current job on a one level stack * so another job can be created. Used for { } in exp6 * and `` in globbing. */ void psavejob() { pholdjob = pcurrjob; pcurrjob = NULL; } /* * prestjob - opposite of psavejob. This may be missed if we are interrupted * somewhere, but pendjob cleans up anyway. */ void prestjob() { pcurrjob = pholdjob; pholdjob = NULL; } /* * pendjob - indicate that a job (set of commands) has been completed * or is about to begin. */ void pendjob() { register struct process *pp, *tp; if (pcurrjob && (pcurrjob->p_flags & (PFOREGND | PSTOPPED)) == 0) { pp = pcurrjob; while (pp->p_procid != pp->p_jobid) pp = pp->p_friends; xprintf("[%d]", pp->p_index); tp = pp; do { xprintf(" %d", pp->p_procid); pp = pp->p_friends; } while (pp != tp); xputchar('\n'); } pholdjob = pcurrjob = 0; } /* * pprint - print a job */ /* * Hacks have been added for SVR4 to deal with pipe's being spawned in * reverse order * * David Dawes (dawes@physics.su.oz.au) Oct 1991 */ static int pprint(pp, flag) register struct process *pp; bool flag; { int status, reason; struct process *tp; extern char *linp, linbuf[]; int jobflags, pstatus, pcond; char *format; #ifdef BACKPIPE struct process *pipehead = NULL, *pipetail = NULL, *pmarker = NULL; int inpipe = 0; #endif /* BACKPIPE */ while (pp->p_procid != pp->p_jobid) pp = pp->p_friends; if (pp == pp->p_friends && (pp->p_flags & PPTIME)) { pp->p_flags &= ~PPTIME; pp->p_flags |= PTIME; } tp = pp; status = reason = -1; jobflags = 0; do { #ifdef BACKPIPE /* * The pipeline is reversed, so locate the real head of the pipeline * if pp is at the tail of a pipe (and not already in a pipeline) */ if ((pp->p_friends->p_flags & PPOU) && !inpipe && (flag & NAME)) { inpipe = 1; pipetail = pp; do pp = pp->p_friends; while (pp->p_friends->p_flags & PPOU); pipehead = pp; pmarker = pp; /* * pmarker is used to hold the place of the proc being processed, so * we can search for the next one downstream later. */ } pcond = (int) (tp != pp || (inpipe && tp == pp)); #else /* !BACKPIPE */ pcond = (int) (tp != pp); #endif /* BACKPIPE */ jobflags |= pp->p_flags; pstatus = (int) (pp->p_flags & PALLSTATES); if (pcond && linp != linbuf && !(flag & FANCY) && ((pstatus == status && pp->p_reason == reason) || !(flag & REASON))) xputchar(' '); else { if (pcond && linp != linbuf) xputchar('\n'); if (flag & NUMBER) { #ifdef BACKPIPE pcond = ((pp == tp && !inpipe) || (inpipe && pipetail == tp && pp == pipehead)); #else /* BACKPIPE */ pcond = (pp == tp); #endif /* BACKPIPE */ if (pcond) xprintf("[%d]%s %c ", pp->p_index, pp->p_index < 10 ? " " : "", pp == pcurrent ? '+' : (pp == pprevious ? '-' : ' ')); else xprintf(" "); } if (flag & FANCY) { #ifdef TCF extern char *sitename(); #endif /* TCF */ xprintf("%5d ", pp->p_procid); #ifdef TCF xprintf("%11s ", sitename(pp->p_procid)); #endif /* TCF */ } if (flag & (REASON | AREASON)) { if (flag & NAME) format = "%-30s"; else format = "%s"; if (pstatus == status) { if (pp->p_reason == reason) { xprintf(format, ""); goto prcomd; } else reason = (int) pp->p_reason; } else { status = pstatus; reason = (int) pp->p_reason; } switch (status) { case PRUNNING: xprintf(format, CGETS(17, 4, "Running ")); break; case PINTERRUPTED: case PSTOPPED: case PSIGNALED: /* * tell what happened to the background job * From: Michael Schroeder * */ if ((flag & REASON) || ((flag & AREASON) && reason != SIGINT && (reason != SIGPIPE || (pp->p_flags & PPOU) == 0))) { char *ptr; char buf[1024]; if ((ptr = mesg[pp->p_reason & ASCII].pname) == NULL) xsnprintf(ptr = buf, sizeof(buf), "%s %d", CGETS(17, 5, "Signal"), pp->p_reason & ASCII); xprintf(format, ptr); } else reason = -1; break; case PNEXITED: case PAEXITED: if (flag & REASON) { if (pp->p_reason) xprintf(CGETS(17, 6, "Exit %-25d"), pp->p_reason); else xprintf(format, CGETS(17, 7, "Done")); } break; default: xprintf(CGETS(17, 8, "BUG: status=%-9o"), status); } } } prcomd: if (flag & NAME) { xprintf("%S", pp->p_command); if (pp->p_flags & PPOU) xprintf(" |"); if (pp->p_flags & PDIAG) xprintf("&"); } if (flag & (REASON | AREASON) && pp->p_flags & PDUMPED) xprintf(CGETS(17, 9, " (core dumped)")); if (tp == pp->p_friends) { if (flag & AMPERSAND) xprintf(" &"); if (flag & JOBDIR && !eq(tp->p_cwd->di_name, dcwd->di_name)) { xprintf(CGETS(17, 10, " (wd: ")); dtildepr(tp->p_cwd->di_name); xprintf(")"); } } if (pp->p_flags & PPTIME && !(status & (PSTOPPED | PRUNNING))) { if (linp != linbuf) xprintf("\n\t"); #if defined(BSDTIMES) || defined(_SEQUENT_) prusage(&zru, &pp->p_rusage, &pp->p_etime, &pp->p_btime); #else /* !BSDTIMES && !SEQUENT */ lru.tms_utime = pp->p_utime; lru.tms_stime = pp->p_stime; lru.tms_cutime = 0; lru.tms_cstime = 0; prusage(&zru, &lru, pp->p_etime, pp->p_btime); #endif /* !BSDTIMES && !SEQUENT */ } #ifdef BACKPIPE pcond = ((tp == pp->p_friends && !inpipe) || (inpipe && pipehead->p_friends == tp && pp == pipetail)); #else /* !BACKPIPE */ pcond = (tp == pp->p_friends); #endif /* BACKPIPE */ if (pcond) { if (linp != linbuf) xputchar('\n'); if (flag & SHELLDIR && !eq(tp->p_cwd->di_name, dcwd->di_name)) { xprintf(CGETS(17, 11, "(wd now: ")); dtildepr(dcwd->di_name); xprintf(")\n"); } } #ifdef BACKPIPE if (inpipe) { /* * if pmaker == pipetail, we are finished that pipeline, and * can now skip to past the head */ if (pmarker == pipetail) { inpipe = 0; pp = pipehead; } else { /* * set pp to one before the one we want next, so the while below * increments to the correct spot. */ do pp = pp->p_friends; while (pp->p_friends->p_friends != pmarker); pmarker = pp->p_friends; } } pcond = ((pp = pp->p_friends) != tp || inpipe); #else /* !BACKPIPE */ pcond = ((pp = pp->p_friends) != tp); #endif /* BACKPIPE */ } while (pcond); if (jobflags & PTIME && (jobflags & (PSTOPPED | PRUNNING)) == 0) { if (jobflags & NUMBER) xprintf(" "); ptprint(tp); } return (jobflags); } /* * All 4.3 BSD derived implementations are buggy and I've had enough. * The following implementation produces similar code and works in all * cases. The 4.3BSD one works only for <, >, != */ # undef timercmp # define timercmp(tvp, uvp, cmp) \ (((tvp)->tv_sec == (uvp)->tv_sec) ? \ ((tvp)->tv_usec cmp (uvp)->tv_usec) : \ ((tvp)->tv_sec cmp (uvp)->tv_sec)) static void ptprint(tp) register struct process *tp; { #ifdef BSDTIMES struct timeval tetime, diff; static struct timeval ztime; struct sysrusage ru; register struct process *pp = tp; ru = zru; tetime = ztime; do { ruadd(&ru, &pp->p_rusage); tvsub(&diff, &pp->p_etime, &pp->p_btime); if (timercmp(&diff, &tetime, >)) tetime = diff; } while ((pp = pp->p_friends) != tp); prusage(&zru, &ru, &tetime, &ztime); #else /* !BSDTIMES */ # ifdef _SEQUENT_ timeval_t tetime, diff; static timeval_t ztime; struct process_stats ru; register struct process *pp = tp; ru = zru; tetime = ztime; do { ruadd(&ru, &pp->p_rusage); tvsub(&diff, &pp->p_etime, &pp->p_btime); if (timercmp(&diff, &tetime, >)) tetime = diff; } while ((pp = pp->p_friends) != tp); prusage(&zru, &ru, &tetime, &ztime); # else /* !_SEQUENT_ */ # ifndef POSIX static time_t ztime = 0; static time_t zu_time = 0; static time_t zs_time = 0; time_t tetime, diff; time_t u_time, s_time; # else /* POSIX */ static clock_t ztime = 0; static clock_t zu_time = 0; static clock_t zs_time = 0; clock_t tetime, diff; clock_t u_time, s_time; # endif /* POSIX */ struct tms zts, rts; register struct process *pp = tp; u_time = zu_time; s_time = zs_time; tetime = ztime; do { u_time += pp->p_utime; s_time += pp->p_stime; diff = pp->p_etime - pp->p_btime; if (diff > tetime) tetime = diff; } while ((pp = pp->p_friends) != tp); zts.tms_utime = zu_time; zts.tms_stime = zs_time; zts.tms_cutime = 0; zts.tms_cstime = 0; rts.tms_utime = u_time; rts.tms_stime = s_time; rts.tms_cutime = 0; rts.tms_cstime = 0; prusage(&zts, &rts, tetime, ztime); # endif /* !_SEQUENT_ */ #endif /* !BSDTIMES */ } /* * dojobs - print all jobs */ /*ARGSUSED*/ void dojobs(v, c) Char **v; struct command *c; { register struct process *pp; register int flag = NUMBER | NAME | REASON; int i; USE(c); if (chkstop) chkstop = 2; if (*++v) { if (v[1] || !eq(*v, STRml)) stderror(ERR_JOBS); flag |= FANCY | JOBDIR; } for (i = 1; i <= pmaxindex; i++) for (pp = proclist.p_next; pp; pp = pp->p_next) if (pp->p_index == i && pp->p_procid == pp->p_jobid) { pp->p_flags &= ~PNEEDNOTE; if (!(pprint(pp, flag) & (PRUNNING | PSTOPPED))) pflush(pp); break; } } /* * dofg - builtin - put the job into the foreground */ /*ARGSUSED*/ void dofg(v, c) Char **v; struct command *c; { register struct process *pp; USE(c); okpcntl(); ++v; do { pp = pfind(*v); if (!pstart(pp, 1)) { pp->p_procid = 0; stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno)); continue; } #ifndef BSDSIGS # ifdef notdef if (setintr) sigignore(SIGINT); # endif #endif /* !BSDSIGS */ pjwait(pp); } while (*v && *++v); } /* * %... - builtin - put the job into the foreground */ /*ARGSUSED*/ void dofg1(v, c) Char **v; struct command *c; { register struct process *pp; USE(c); okpcntl(); pp = pfind(v[0]); if (!pstart(pp, 1)) { pp->p_procid = 0; stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno)); return; } #ifndef BSDSIGS # ifdef notdef if (setintr) sigignore(SIGINT); # endif #endif /* !BSDSIGS */ pjwait(pp); } /* * dobg - builtin - put the job into the background */ /*ARGSUSED*/ void dobg(v, c) Char **v; struct command *c; { register struct process *pp; USE(c); okpcntl(); ++v; do { pp = pfind(*v); if (!pstart(pp, 0)) { pp->p_procid = 0; stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno)); } } while (*v && *++v); } /* * %... & - builtin - put the job into the background */ /*ARGSUSED*/ void dobg1(v, c) Char **v; struct command *c; { register struct process *pp; USE(c); pp = pfind(v[0]); if (!pstart(pp, 0)) { pp->p_procid = 0; stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno)); } } /* * dostop - builtin - stop the job */ /*ARGSUSED*/ void dostop(v, c) Char **v; struct command *c; { USE(c); #ifdef BSDJOBS pkill(++v, SIGSTOP); #endif /* BSDJOBS */ } /* * dokill - builtin - superset of kill (1) */ /*ARGSUSED*/ void dokill(v, c) Char **v; struct command *c; { register int signum, len = 0; register char *name; extern int T_Cols; extern int nsig; USE(c); v++; if (v[0] && v[0][0] == '-') { if (v[0][1] == 'l') { for (signum = 0; signum <= nsig; signum++) { if ((name = mesg[signum].iname) != NULL) { len += strlen(name) + 1; if (len >= T_Cols - 1) { xputchar('\n'); len = strlen(name) + 1; } xprintf("%s ", name); } } xputchar('\n'); return; } if (Isdigit(v[0][1])) { signum = atoi(short2str(v[0] + 1)); if (signum < 0 || signum > (MAXSIG-1)) stderror(ERR_NAME | ERR_BADSIG); } else { for (signum = 0; signum <= nsig; signum++) if (mesg[signum].iname && eq(&v[0][1], str2short(mesg[signum].iname))) goto gotsig; setname(short2str(&v[0][1])); stderror(ERR_NAME | ERR_UNKSIG); } gotsig: v++; } else signum = SIGTERM; pkill(v, signum); } static void pkill(v, signum) Char **v; int signum; { register struct process *pp, *np; int jobflags = 0, err1 = 0; pid_t pid; #ifdef BSDSIGS sigmask_t omask; #endif /* BSDSIGS */ Char *cp, **vp; #ifdef BSDSIGS omask = sigmask(SIGCHLD); if (setintr) omask |= sigmask(SIGINT); omask = sigblock(omask) & ~omask; #else /* !BSDSIGS */ if (setintr) (void) sighold(SIGINT); (void) sighold(SIGCHLD); #endif /* !BSDSIGS */ /* Avoid globbing %?x patterns */ for (vp = v; vp && *vp; vp++) if (**vp == '%') (void) quote(*vp); gflag = 0, tglob(v); if (gflag) { v = globall(v); if (v == 0) stderror(ERR_NAME | ERR_NOMATCH); } else { v = gargv = saveblk(v); trim(v); } while (v && (cp = *v)) { if (*cp == '%') { np = pp = pfind(cp); do jobflags |= np->p_flags; while ((np = np->p_friends) != pp); #ifdef BSDJOBS switch (signum) { case SIGSTOP: case SIGTSTP: case SIGTTIN: case SIGTTOU: if ((jobflags & PRUNNING) == 0) { # ifdef SUSPENDED xprintf(CGETS(17, 12, "%S: Already suspended\n"), cp); # else /* !SUSPENDED */ xprintf(CGETS(17, 13, "%S: Already stopped\n"), cp); # endif /* !SUSPENDED */ err1++; goto cont; } break; /* * suspend a process, kill -CONT %, then type jobs; the shell * says it is suspended, but it is running; thanks jaap.. */ case SIGCONT: if (!pstart(pp, 0)) { pp->p_procid = 0; stderror(ERR_NAME|ERR_BADJOB, pp->p_command, strerror(errno)); } goto cont; default: break; } #endif /* BSDJOBS */ if (killpg(pp->p_jobid, signum) < 0) { xprintf("%S: %s\n", cp, strerror(errno)); err1++; } #ifdef BSDJOBS if (signum == SIGTERM || signum == SIGHUP) (void) killpg(pp->p_jobid, SIGCONT); #endif /* BSDJOBS */ } else if (!(Isdigit(*cp) || *cp == '-')) stderror(ERR_NAME | ERR_JOBARGS); else { #ifndef WINNT pid = atoi(short2str(cp)); #else pid = strtoul(short2str(cp),NULL,0); #endif /* WINNT */ if (kill(pid, signum) < 0) { xprintf("%d: %s\n", pid, strerror(errno)); err1++; goto cont; } #ifdef BSDJOBS if (signum == SIGTERM || signum == SIGHUP) (void) kill(pid, SIGCONT); #endif /* BSDJOBS */ } cont: v++; } if (gargv) blkfree(gargv), gargv = 0; #ifdef BSDSIGS (void) sigsetmask(omask); #else /* !BSDSIGS */ (void) sigrelse(SIGCHLD); if (setintr) (void) sigrelse(SIGINT); #endif /* !BSDSIGS */ if (err1) stderror(ERR_SILENT); } /* * pstart - start the job in foreground/background */ int pstart(pp, foregnd) register struct process *pp; int foregnd; { int rv = 0; register struct process *np; #ifdef BSDSIGS sigmask_t omask; #endif /* BSDSIGS */ /* We don't use jobflags in this function right now (see below) */ /* long jobflags = 0; */ #ifdef BSDSIGS omask = sigblock(sigmask(SIGCHLD)); #else /* !BSDSIGS */ (void) sighold(SIGCHLD); #endif np = pp; do { /* We don't use jobflags in this function right now (see below) */ /* jobflags |= np->p_flags; */ if (np->p_flags & (PRUNNING | PSTOPPED)) { np->p_flags |= PRUNNING; np->p_flags &= ~PSTOPPED; if (foregnd) np->p_flags |= PFOREGND; else np->p_flags &= ~PFOREGND; } } while ((np = np->p_friends) != pp); if (!foregnd) pclrcurr(pp); (void) pprint(pp, foregnd ? NAME | JOBDIR : NUMBER | NAME | AMPERSAND); #ifdef BSDJOBS if (foregnd) { rv = tcsetpgrp(FSHTTY, pp->p_jobid); } /* * 1. child process of csh (shell script) receives SIGTTIN/SIGTTOU * 2. parent process (csh) receives SIGCHLD * 3. The "csh" signal handling function pchild() is invoked * with a SIGCHLD signal. * 4. pchild() calls wait3(WNOHANG) which returns 0. * The child process is NOT ready to be waited for at this time. * pchild() returns without picking-up the correct status * for the child process which generated the SIGCHILD. * 5. CONSEQUENCE : csh is UNaware that the process is stopped * 6. THIS LINE HAS BEEN COMMENTED OUT : if (jobflags&PSTOPPED) * (beto@aixwiz.austin.ibm.com - aug/03/91) * 7. I removed the line completely and added extra checks for * pstart, so that if a job gets attached to and dies inside * a debugger it does not confuse the shell. [christos] * 8. on the nec sx-4 there seems to be a problem, which requires * a syscall(151, getpid(), getpid()) in osinit. Don't ask me * what this is doing. [schott@rzg.mpg.de] */ if (rv != -1) rv = killpg(pp->p_jobid, SIGCONT); #endif /* BSDJOBS */ #ifdef BSDSIGS (void) sigsetmask(omask); #else /* !BSDSIGS */ (void) sigrelse(SIGCHLD); #endif /* !BSDSIGS */ return rv != -1; } void panystop(neednl) bool neednl; { register struct process *pp; chkstop = 2; for (pp = proclist.p_next; pp; pp = pp->p_next) if (pp->p_flags & PSTOPPED) stderror(ERR_STOPPED, neednl ? "\n" : ""); } struct process * pfind(cp) Char *cp; { register struct process *pp, *np; if (cp == 0 || cp[1] == 0 || eq(cp, STRcent2) || eq(cp, STRcentplus)) { if (pcurrent == NULL) stderror(ERR_NAME | ERR_JOBCUR); return (pcurrent); } if (eq(cp, STRcentminus) || eq(cp, STRcenthash)) { if (pprevious == NULL) stderror(ERR_NAME | ERR_JOBPREV); return (pprevious); } if (Isdigit(cp[1])) { int idx = atoi(short2str(cp + 1)); for (pp = proclist.p_next; pp; pp = pp->p_next) if (pp->p_index == idx && pp->p_procid == pp->p_jobid) return (pp); stderror(ERR_NAME | ERR_NOSUCHJOB); } np = NULL; for (pp = proclist.p_next; pp; pp = pp->p_next) if (pp->p_procid == pp->p_jobid) { if (cp[1] == '?') { register Char *dp; for (dp = pp->p_command; *dp; dp++) { if (*dp != cp[2]) continue; if (prefix(cp + 2, dp)) goto match; } } else if (prefix(cp + 1, pp->p_command)) { match: if (np) stderror(ERR_NAME | ERR_AMBIG); np = pp; } } if (np) return (np); stderror(ERR_NAME | (cp[1] == '?' ? ERR_JOBPAT : ERR_NOSUCHJOB)); /* NOTREACHED */ return (0); } /* * pgetcurr - find most recent job that is not pp, preferably stopped */ static struct process * pgetcurr(pp) register struct process *pp; { register struct process *np; register struct process *xp = NULL; for (np = proclist.p_next; np; np = np->p_next) if (np != pcurrent && np != pp && np->p_procid && np->p_procid == np->p_jobid) { if (np->p_flags & PSTOPPED) return (np); if (xp == NULL) xp = np; } return (xp); } /* * donotify - flag the job so as to report termination asynchronously */ /*ARGSUSED*/ void donotify(v, c) Char **v; struct command *c; { register struct process *pp; USE(c); pp = pfind(*++v); pp->p_flags |= PNOTIFY; } /* * Do the fork and whatever should be done in the child side that * should not be done if we are not forking at all (like for simple builtin's) * Also do everything that needs any signals fiddled with in the parent side * * Wanttty tells whether process and/or tty pgrps are to be manipulated: * -1: leave tty alone; inherit pgrp from parent * 0: already have tty; manipulate process pgrps only * 1: want to claim tty; manipulate process and tty pgrps * It is usually just the value of tpgrp. */ int pfork(t, wanttty) struct command *t; /* command we are forking for */ int wanttty; { register int pid; bool ignint = 0; int pgrp; #ifdef BSDSIGS sigmask_t omask = 0; #endif /* BSDSIGS */ #ifdef SIGSYNCH sigvec_t osv; static sigvec_t nsv = {synch_handler, (sigset_t) ~0, 0}; #endif /* SIGSYNCH */ /* * A child will be uninterruptible only under very special conditions. * Remember that the semantics of '&' is implemented by disconnecting the * process from the tty so signals do not need to ignored just for '&'. * Thus signals are set to default action for children unless: we have had * an "onintr -" (then specifically ignored) we are not playing with * signals (inherit action) */ if (setintr) ignint = (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT)) || (gointr && eq(gointr, STRminus)); #ifdef COHERENT ignint |= gointr && eq(gointr, STRminus); #endif /* COHERENT */ /* * Check for maximum nesting of 16 processes to avoid Forking loops */ if (child == 16) stderror(ERR_NESTING, 16); #ifdef SIGSYNCH if (mysigvec(SIGSYNCH, &nsv, &osv)) stderror(ERR_SYSTEM, "pfork: sigvec set", strerror(errno)); #endif /* SIGSYNCH */ /* * Hold SIGCHLD until we have the process installed in our table. */ if (wanttty < 0) { #ifdef BSDSIGS omask = sigblock(sigmask(SIGCHLD)); #else /* !BSDSIGS */ (void) sighold(SIGCHLD); #endif /* !BSDSIGS */ } while ((pid = fork()) == -1) if (setintr == 0) (void) sleep(FORKSLEEP); else { if (wanttty < 0) #ifdef BSDSIGS (void) sigsetmask(omask); #else /* !BSDSIGS */ (void) sigrelse(SIGCHLD); (void) sigrelse(SIGINT); #endif /* !BSDSIGS */ stderror(ERR_NOPROC); } if (pid == 0) { settimes(); pgrp = pcurrjob ? pcurrjob->p_jobid : getpid(); pflushall(); pcurrjob = NULL; #if !defined(BSDTIMES) && !defined(_SEQUENT_) timesdone = 0; #endif /* !defined(BSDTIMES) && !defined(_SEQUENT_) */ child++; if (setintr) { setintr = 0; /* until I think otherwise */ #ifndef BSDSIGS if (wanttty < 0) (void) sigrelse(SIGCHLD); #endif /* !BSDSIGS */ /* * Children just get blown away on SIGINT, SIGQUIT unless "onintr * -" seen. */ (void) signal(SIGINT, ignint ? SIG_IGN : SIG_DFL); (void) signal(SIGQUIT, ignint ? SIG_IGN : SIG_DFL); #ifdef BSDJOBS if (wanttty >= 0) { /* make stoppable */ (void) signal(SIGTSTP, SIG_DFL); (void) signal(SIGTTIN, SIG_DFL); (void) signal(SIGTTOU, SIG_DFL); } #endif /* BSDJOBS */ (void) signal(SIGTERM, parterm); } else if (tpgrp == -1 && (t->t_dflg & F_NOINTERRUPT)) { (void) signal(SIGINT, SIG_IGN); (void) signal(SIGQUIT, SIG_IGN); } #ifdef OREO sigignore(SIGIO); /* ignore SIGIO in child too */ #endif /* OREO */ pgetty(wanttty, pgrp); /* * Nohup and nice apply only to NODE_COMMAND's but it would be nice * (?!?) if you could say "nohup (foo;bar)" Then the parser would have * to know about nice/nohup/time */ if (t->t_dflg & F_NOHUP) (void) signal(SIGHUP, SIG_IGN); if (t->t_dflg & F_NICE) { int nval = SIGN_EXTEND_CHAR(t->t_nice); #ifdef BSDNICE (void) setpriority(PRIO_PROCESS, 0, nval); #else /* !BSDNICE */ (void) nice(nval); #endif /* !BSDNICE */ } #ifdef F_VER if (t->t_dflg & F_VER) { tsetenv(STRSYSTYPE, t->t_systype ? STRbsd43 : STRsys53); dohash(NULL, NULL); } #endif /* F_VER */ #ifdef SIGSYNCH /* rfw 8/89 now parent can continue */ if (kill(getppid(), SIGSYNCH)) stderror(ERR_SYSTEM, "pfork child: kill", strerror(errno)); #endif /* SIGSYNCH */ } else { #ifdef POSIXJOBS if (wanttty >= 0) { /* * `Walking' process group fix from Beto Appleton. * (beto@aixwiz.austin.ibm.com) * If setpgid fails at this point that means that * our process leader has died. We flush the current * job and become the process leader ourselves. * The parent will figure that out later. */ pgrp = pcurrjob ? pcurrjob->p_jobid : pid; if (setpgid(pid, pgrp) == -1 && errno == EPERM) { pcurrjob = NULL; /* * We don't care if this causes an error here; * then we are already in the right process group */ (void) setpgid(pid, pgrp = pid); } } #endif /* POSIXJOBS */ palloc(pid, t); #ifdef SIGSYNCH /* * rfw 8/89 Wait for child to own terminal. Solves half of ugly * synchronization problem. With this change, we know that the only * reason setpgrp to a previous process in a pipeline can fail is that * the previous process has already exited. Without this hack, he may * either have exited or not yet started to run. Two uglies become * one. */ (void) sigpause(omask & ~SYNCHMASK); if (mysigvec(SIGSYNCH, &osv, NULL)) stderror(ERR_SYSTEM, "pfork parent: sigvec restore", strerror(errno)); #endif /* SIGSYNCH */ if (wanttty < 0) { #ifdef BSDSIGS (void) sigsetmask(omask); #else /* !BSDSIGS */ (void) sigrelse(SIGCHLD); #endif /* !BSDSIGS */ } } return (pid); } static void okpcntl() { if (tpgrp == -1) stderror(ERR_JOBCONTROL); if (tpgrp == 0) stderror(ERR_JOBCTRLSUB); } static void setttypgrp(pgrp) int pgrp; { /* * If we are piping out a builtin, eg. 'echo | more' things can go * out of sequence, i.e. the more can run before the echo. This * can happen even if we have vfork, since the echo will be forked * with the regular fork. In this case, we need to set the tty * pgrp ourselves. If that happens, then the process will be still * alive. And the tty process group will already be set. * This should fix the famous sequent problem as a side effect: * The controlling terminal is lost if all processes in the * terminal process group are zombies. In this case tcgetpgrp() * returns 0. If this happens we must set the terminal process * group again. */ if (tcgetpgrp(FSHTTY) != pgrp) { #ifdef POSIXJOBS /* * tcsetpgrp will set SIGTTOU to all the the processes in * the background according to POSIX... We ignore this here. */ signalfun_t old = sigset(SIGTTOU, SIG_IGN); #endif (void) tcsetpgrp(FSHTTY, pgrp); # ifdef POSIXJOBS (void) sigset(SIGTTOU, old); # endif } } /* * if we don't have vfork(), things can still go in the wrong order * resulting in the famous 'Stopped (tty output)'. But some systems * don't permit the setpgid() call, (these are more recent secure * systems such as ibm's aix), when they do. Then we'd rather print * an error message than hang the shell! * I am open to suggestions how to fix that. */ void pgetty(wanttty, pgrp) int wanttty, pgrp; { #ifdef BSDJOBS # if defined(BSDSIGS) && defined(POSIXJOBS) sigmask_t omask = 0; # endif /* BSDSIGS && POSIXJOBS */ # ifdef JOBDEBUG xprintf("wanttty %d pid %d opgrp%d pgrp %d tpgrp %d\n", wanttty, getpid(), pgrp, mygetpgrp(), tcgetpgrp(FSHTTY)); # endif /* JOBDEBUG */ # ifdef POSIXJOBS /* * christos: I am blocking the tty signals till I've set things * correctly.... */ if (wanttty > 0) # ifdef BSDSIGS omask = sigblock(sigmask(SIGTSTP)|sigmask(SIGTTIN)); # else /* !BSDSIGS */ { (void) sighold(SIGTSTP); (void) sighold(SIGTTIN); } # endif /* !BSDSIGS */ # endif /* POSIXJOBS */ # ifndef POSIXJOBS if (wanttty > 0) setttypgrp(pgrp); # endif /* !POSIXJOBS */ /* * From: Michael Schroeder * Don't check for tpgrp >= 0 so even non-interactive shells give * background jobs process groups Same for the comparison in the other part * of the #ifdef */ if (wanttty >= 0) { if (setpgid(0, pgrp) == -1) { # ifdef POSIXJOBS /* Walking process group fix; see above */ if (setpgid(0, pgrp = getpid()) == -1) { # endif /* POSIXJOBS */ stderror(ERR_SYSTEM, "setpgid child:\n", strerror(errno)); xexit(0); # ifdef POSIXJOBS } wanttty = pgrp; /* Now we really want the tty, since we became the * the process group leader */ # endif /* POSIXJOBS */ } } # ifdef POSIXJOBS if (wanttty > 0) setttypgrp(pgrp); # ifdef BSDSIGS (void) sigsetmask(omask); # else /* BSDSIGS */ (void) sigrelse(SIGTSTP); (void) sigrelse(SIGTTIN); # endif /* !BSDSIGS */ # endif /* POSIXJOBS */ # ifdef JOBDEBUG xprintf("wanttty %d pid %d pgrp %d tpgrp %d\n", wanttty, getpid(), mygetpgrp(), tcgetpgrp(FSHTTY)); # endif /* JOBDEBUG */ if (tpgrp > 0) tpgrp = 0; /* gave tty away */ #endif /* BSDJOBS */ }