/*********************************************************************** * * * This software is part of the ast package * * Copyright (c) 1982-2007 AT&T Intellectual Property * * and is licensed under the * * Common Public License, Version 1.0 * * by AT&T Intellectual Property * * * * A copy of the License is available at * * http://www.opensource.org/licenses/cpl1.0.txt * * (with md5 checksum 059e8cd6165cb4c31e351f2b69388fd9) * * * * Information and Software Systems Research * * AT&T Research * * Florham Park NJ * * * * David Korn * * * ***********************************************************************/ #pragma prototyped /* * Job control for UNIX Shell * * David Korn * AT&T Labs * * Written October, 1982 * Rewritten April, 1988 * Revised January, 1992 */ #include "defs.h" #include #include #include "io.h" #include "jobs.h" #include "history.h" #if !defined(WCONTINUED) || !defined(WIFCONTINUED) || defined(__APPLE__) # undef WCONTINUED # define WCONTINUED 0 # undef WIFCONTINUED # define WIFCONTINUED(wstat) (0) #endif #define NJOB_SAVELIST 4 /* * temporary hack to get W* macros to work */ #undef wait #define wait ______wait /* * This struct saves a link list of processes that have non-zero exit * status, have had $! saved, but haven't been waited for */ struct jobsave { struct jobsave *next; pid_t pid; unsigned short exitval; }; static struct jobsave *job_savelist; static int njob_savelist; static void init_savelist(void) { register struct jobsave *jp; while(njob_savelist < NJOB_SAVELIST) { jp = newof(0,struct jobsave,1,0); jp->next = job_savelist; job_savelist = jp; njob_savelist++; } } /* * return next on link list of jobsave free list */ static struct jobsave *jobsave_create(pid_t pid) { register struct jobsave *jp = job_savelist; if(jp) { njob_savelist--; job_savelist = jp->next; } else jp = newof(0,struct jobsave,1,0); if(jp) jp->pid = pid; return(jp); } struct back_save { int count; struct jobsave *list; struct back_save*free; }; #define BYTE(n) (((n)+CHAR_BIT-1)/CHAR_BIT) #define MAXMSG 25 #define SH_STOPSIG (SH_EXITSIG<<1) #ifdef VSUSP # ifndef CNSUSP # ifdef _POSIX_VDISABLE # define CNSUSP _POSIX_VDISABLE # else # define CNSUSP 0 # endif /* _POSIX_VDISABLE */ # endif /* CNSUSP */ # ifndef CSWTCH # ifdef CSUSP # define CSWTCH CSUSP # else # define CSWTCH ('z'&037) # endif /* CSUSP */ # endif /* CSWTCH */ #endif /* VSUSP */ /* Process states */ #define P_EXITSAVE 01 #define P_STOPPED 02 #define P_NOTIFY 04 #define P_SIGNALLED 010 #define P_STTY 020 #define P_DONE 040 #define P_COREDUMP 0100 #define P_DISOWN 0200 #define P_FG 0400 static int job_chksave(pid_t); static struct process *job_bypid(pid_t); static struct process *job_byjid(int); static char *job_sigmsg(int); static int job_alloc(void); static void job_free(int); static struct process *job_unpost(struct process*,int); static void job_unlink(struct process*); static void job_prmsg(struct process*); static struct process *freelist; static char beenhere; static char possible; static struct process dummy; static char by_number; static Sfio_t *outfile; static pid_t lastpid; static struct back_save bck; #ifdef JOBS static void job_set(struct process*); static void job_reset(struct process*); static void job_waitsafe(int); static struct process *job_byname(char*); static struct process *job_bystring(char*); static struct termios my_stty; /* terminal state for shell */ static char *job_string; #else extern const char e_coredump[]; #endif /* JOBS */ #ifdef SIGTSTP static void job_unstop(struct process*); static void job_fgrp(struct process*, int); # ifndef _lib_tcgetpgrp # ifdef TIOCGPGRP static int _i_; # define tcgetpgrp(a) (ioctl(a, TIOCGPGRP, &_i_)>=0?_i_:-1) # endif /* TIOCGPGRP */ int tcsetpgrp(int fd,pid_t pgrp) { int pgid = pgrp; # ifdef TIOCGPGRP return(ioctl(fd, TIOCSPGRP, &pgid)); # else return(-1); # endif /* TIOCGPGRP */ } # endif /* _lib_tcgetpgrp */ #else # define job_unstop(pw) # undef CNSUSP #endif /* SIGTSTP */ #ifndef OTTYDISC # undef NTTYDISC #endif /* OTTYDISC */ #ifdef JOBS typedef int (*Waitevent_f)(int,long,int); /* * Reap one job * When called with sig==0, it does a blocking wait */ int job_reap(register int sig) { register pid_t pid; register struct process *pw; struct process *px; register int flags; struct process dummy; struct jobsave *jp; struct back_save *bp; int nochild=0, oerrno, wstat; Waitevent_f waitevent = sh.waitevent; static int wcontinued = WCONTINUED; if(vmbusy()) { write(2,"vmbusy\n",7); abort(); } #ifdef DEBUG if(sfprintf(sfstderr,"ksh: job line %4d: reap pid=%d critical=%d signal=%d\n",__LINE__,getpid(),job.in_critical,sig) <=0) write(2,"waitsafe\n",9); sfsync(sfstderr); #endif /* DEBUG */ if(bp=bck.free) { struct jobsave *jpnext; struct back_save *bpfree; /* * dispose old job_subrestore() lists */ bck.free = 0; do { for(jp=bp->list; jp; jp=jpnext) { jpnext = jp->next; free(jp); } bpfree = bp->free; free(bp); } while(bp=bpfree); } job.savesig = 0; if(sig) flags = WNOHANG|WUNTRACED|wcontinued; else flags = WUNTRACED|wcontinued; sh.waitevent = 0; oerrno = errno; while(1) { if(!(flags&WNOHANG) && !sh.intrap && waitevent && job.pwlist) { if((*waitevent)(-1,-1L,0)) flags |= WNOHANG; } pid = waitpid((pid_t)-1,&wstat,flags); /* * some systems (linux 2.6) may return EINVAL * when there are no continued children */ if (pid<0 && errno==EINVAL && (flags&WCONTINUED)) pid = waitpid((pid_t)-1,&wstat,flags&=~WCONTINUED); sh_sigcheck(); if(sig && pid<0 && errno==EINTR) continue; if(pid<=0) break; flags |= WNOHANG; job.waitsafe++; jp = 0; if(!(pw=job_bypid(pid))) { #ifdef DEBUG sfprintf(sfstderr,"ksh: job line %4d: reap pid=%d critical=%d unknown job pid=%d pw=%x\n",__LINE__,getpid(),job.in_critical,pid,pw); #endif /* DEBUG */ pw = &dummy; pw->p_exit = 0; pw->p_pgrp = 0; pw->p_exitmin = 0; if(job.toclear) job_clear(); if(bck.count++ > sh.lim.child_max) job_chksave(0); if(jp = jobsave_create(pid)) { jp->next = bck.list; bck.list = jp; jp->exitval = 0; } pw->p_flag = 0; lastpid = pw->p_pid = pid; px = 0; if(jp && WIFSTOPPED(wstat)) { jp->exitval = SH_STOPSIG; continue; } } #ifdef SIGTSTP else px=job_byjid(pw->p_job); if(WIFSTOPPED(wstat)) { if(px) { /* move to top of job list */ job_unlink(px); px->p_nxtjob = job.pwlist; job.pwlist = px; } pw->p_flag |= (P_NOTIFY|P_SIGNALLED|P_STOPPED); pw->p_exit = WSTOPSIG(wstat); if(pw->p_pgrp && pw->p_pgrp==job.curpgid && sh_isstate(SH_STOPOK)) sh_fault(pw->p_exit); continue; } else if (WIFCONTINUED(wstat) && wcontinued) pw->p_flag &= ~(P_NOTIFY|P_SIGNALLED|P_STOPPED); else #endif /* SIGTSTP */ { /* check for coprocess completion */ if(pid==sh.cpid) { sh_close(sh.coutpipe); sh_close(sh.cpipe[1]); sh.cpipe[1] = -1; sh.coutpipe = -1; } if (WIFSIGNALED(wstat)) { pw->p_flag &= ~P_STOPPED; pw->p_flag |= (P_DONE|P_NOTIFY|P_SIGNALLED); if (WTERMCORE(wstat)) pw->p_flag |= P_COREDUMP; pw->p_exit = WTERMSIG(wstat); /* if process in current jobs terminates from * an interrupt, propogate to parent shell */ if(pw->p_pgrp && pw->p_pgrp==job.curpgid && pw->p_exit==SIGINT && sh_isstate(SH_STOPOK)) { pw->p_flag &= ~P_NOTIFY; sh_offstate(SH_STOPOK); sh_fault(SIGINT); sh_onstate(SH_STOPOK); } } else { pw->p_flag |= (P_DONE|P_NOTIFY); pw->p_exit = pw->p_exitmin; if(WEXITSTATUS(wstat) > pw->p_exitmin) pw->p_exit = WEXITSTATUS(wstat); } if(pw->p_pgrp==0) pw->p_flag &= ~P_NOTIFY; } if(jp && pw== &dummy) { jp->exitval = pw->p_exit; if(pw->p_flag&P_SIGNALLED) jp->exitval |= SH_EXITSIG; } #ifdef DEBUG sfprintf(sfstderr,"ksh: job line %4d: reap pid=%d critical=%d job %d with pid %d flags=%o complete with status=%x exit=%d\n",__LINE__,getpid(),job.in_critical,pw->p_job,pid,pw->p_flag,wstat,pw->p_exit); sfsync(sfstderr); #endif /* DEBUG*/ /* only top-level process in job should have notify set */ if(px && pw != px) pw->p_flag &= ~P_NOTIFY; } if(errno==ECHILD) { errno = oerrno; nochild = 1; } sh.waitevent = waitevent; if(!sh.intrap && sh.st.trapcom[SIGCHLD]) { sh.sigflag[SIGCHLD] |= SH_SIGTRAP; sh.trapnote |= SH_SIGTRAP; } if(sh_isoption(SH_NOTIFY) && sh_isstate(SH_TTYWAIT)) { outfile = sfstderr; job_list(pw,JOB_NFLAG|JOB_NLFLAG); job_unpost(pw,1); sfsync(sfstderr); } if(sig) signal(sig, job_waitsafe); return(nochild); } /* * This is the SIGCLD interrupt routine */ static void job_waitsafe(int sig) { if(job.in_critical || vmbusy()) { job.savesig = sig; job.waitsafe++; } else job_reap(sig); } /* * initialize job control if possible * if lflag is set the switching driver message will not print */ void job_init(int lflag) { register int ntry=0; job.fd = JOBTTY; signal(SIGCHLD,job_waitsafe); # if defined(SIGCLD) && (SIGCLD!=SIGCHLD) signal(SIGCLD,job_waitsafe); # endif if(njob_savelist < NJOB_SAVELIST) init_savelist(); if(!sh_isoption(SH_INTERACTIVE)) return; /* use new line discipline when available */ #ifdef NTTYDISC # ifdef FIOLOOKLD if((job.linedisc = ioctl(JOBTTY, FIOLOOKLD, 0)) <0) # else if(ioctl(JOBTTY,TIOCGETD,&job.linedisc) !=0) # endif /* FIOLOOKLD */ return; if(job.linedisc!=NTTYDISC && job.linedisc!=OTTYDISC) { /* no job control when running with MPX */ # if SHOPT_VSH sh_onoption(SH_VIRAW); # endif /* SHOPT_VSH */ return; } if(job.linedisc==NTTYDISC) job.linedisc = -1; #endif /* NTTYDISC */ job.mypgid = getpgrp(); /* some systems have job control, but not initialized */ if(job.mypgid<=0) { /* Get a controlling terminal and set process group */ /* This should have already been done by rlogin */ register int fd; register char *ttynam; #ifndef SIGTSTP setpgid(0,sh.pid); #endif /*SIGTSTP */ if(job.mypgid<0 || !(ttynam=ttyname(JOBTTY))) return; close(JOBTTY); if((fd = open(ttynam,O_RDWR)) <0) return; if(fd!=JOBTTY) sh_iorenumber(fd,JOBTTY); job.mypgid = sh.pid; #ifdef SIGTSTP tcsetpgrp(JOBTTY,sh.pid); setpgid(0,sh.pid); #endif /* SIGTSTP */ } #ifdef SIGTSTP if(possible = (setpgid(0,job.mypgid)>=0) || errno==EPERM) { /* wait until we are in the foreground */ while((job.mytgid=tcgetpgrp(JOBTTY)) != job.mypgid) { if(job.mytgid == -1) return; /* Stop this shell until continued */ signal(SIGTTIN,SIG_DFL); kill(sh.pid,SIGTTIN); /* resumes here after continue tries again */ if(ntry++ > IOMAXTRY) { errormsg(SH_DICT,0,e_no_start); return; } } } #endif /* SIGTTIN */ #ifdef NTTYDISC /* set the line discipline */ if(job.linedisc>=0) { int linedisc = NTTYDISC; # ifdef FIOPUSHLD tty_get(JOBTTY,&my_stty); if (ioctl(JOBTTY, FIOPOPLD, 0) < 0) return; if (ioctl(JOBTTY, FIOPUSHLD, &linedisc) < 0) { ioctl(JOBTTY, FIOPUSHLD, &job.linedisc); return; } tty_set(JOBTTY,TCSANOW,&my_stty); # else if(ioctl(JOBTTY,TIOCSETD,&linedisc) !=0) return; # endif /* FIOPUSHLD */ if(lflag==0) errormsg(SH_DICT,0,e_newtty); else job.linedisc = -1; } #endif /* NTTYDISC */ if(!possible) return; #ifdef SIGTSTP /* make sure that we are a process group leader */ setpgid(0,sh.pid); # if defined(SA_NOCLDWAIT) && defined(_lib_sigflag) sigflag(SIGCHLD, SA_NOCLDSTOP|SA_NOCLDWAIT, 0); # endif /* SA_NOCLDWAIT */ signal(SIGTTIN,SIG_IGN); signal(SIGTTOU,SIG_IGN); /* The shell now handles ^Z */ signal(SIGTSTP,sh_fault); tcsetpgrp(JOBTTY,sh.pid); # ifdef CNSUSP /* set the switch character */ tty_get(JOBTTY,&my_stty); job.suspend = (unsigned)my_stty.c_cc[VSUSP]; if(job.suspend == (unsigned char)CNSUSP) { my_stty.c_cc[VSUSP] = CSWTCH; tty_set(JOBTTY,TCSAFLUSH,&my_stty); } # endif /* CNSUSP */ sh_onoption(SH_MONITOR); job.jobcontrol++; job.mypid = sh.pid; #endif /* SIGTSTP */ return; } /* * see if there are any stopped jobs * restore tty driver and pgrp */ int job_close(void) { register struct process *pw; register int count = 0, running = 0; if(possible && !job.jobcontrol) return(0); else if(!possible && (!sh_isstate(SH_MONITOR) || sh_isstate(SH_FORKED))) return(0); else if(getpid() != job.mypid) return(0); job_lock(); if(!tty_check(0)) beenhere++; for(pw=job.pwlist;pw;pw=pw->p_nxtjob) { if(!(pw->p_flag&P_STOPPED)) { if(!(pw->p_flag&P_DONE)) running++; continue; } if(beenhere) killpg(pw->p_pgrp,SIGTERM); count++; } if(beenhere++ == 0 && job.pwlist) { if(count) { errormsg(SH_DICT,0,e_terminate); return(-1); } else if(running && sh.login_sh) { errormsg(SH_DICT,0,e_jobsrunning); return(-1); } } job_unlock(); # ifdef SIGTSTP if(possible && setpgid(0,job.mypgid)>=0) tcsetpgrp(job.fd,job.mypgid); # endif /* SIGTSTP */ # ifdef NTTYDISC if(job.linedisc>=0) { /* restore old line discipline */ # ifdef FIOPUSHLD tty_get(job.fd,&my_stty); if (ioctl(job.fd, FIOPOPLD, 0) < 0) return(0); if (ioctl(job.fd, FIOPUSHLD, &job.linedisc) < 0) { job.linedisc = NTTYDISC; ioctl(job.fd, FIOPUSHLD, &job.linedisc); return(0); } tty_set(job.fd,TCSAFLUSH,&my_stty); # else if(ioctl(job.fd,TIOCSETD,&job.linedisc) !=0) return(0); # endif /* FIOPUSHLD */ errormsg(SH_DICT,0,e_oldtty); } # endif /* NTTYDISC */ # ifdef CNSUSP if(possible && job.suspend==CNSUSP) { tty_get(job.fd,&my_stty); my_stty.c_cc[VSUSP] = CNSUSP; tty_set(job.fd,TCSAFLUSH,&my_stty); } # endif /* CNSUSP */ job.jobcontrol = 0; return(0); } static void job_set(register struct process *pw) { /* save current terminal state */ tty_get(job.fd,&my_stty); if(pw->p_flag&P_STTY) { /* restore terminal state for job */ tty_set(job.fd,TCSAFLUSH,&pw->p_stty); } #ifdef SIGTSTP if((pw->p_flag&P_STOPPED) || tcgetpgrp(job.fd) == sh.pid) tcsetpgrp(job.fd,pw->p_fgrp); /* if job is stopped, resume it in the background */ job_unstop(pw); #endif /* SIGTSTP */ } static void job_reset(register struct process *pw) { /* save the terminal state for current job */ #ifdef SIGTSTP job_fgrp(pw,tcgetpgrp(job.fd)); #ifdef SIGTTOU signal(SIGTTOU, SIG_IGN); #endif /* SIGTTOU */ if(tcsetpgrp(job.fd,sh.pid) !=0) return; #endif /* SIGTSTP */ /* force the following tty_get() to do a tcgetattr() unless fg */ if(!(pw->p_flag&P_FG)) tty_set(-1, 0, NIL(struct termios*)); if(pw && (pw->p_flag&P_SIGNALLED) && pw->p_exit!=SIGHUP) { if(tty_get(job.fd,&pw->p_stty) == 0) pw->p_flag |= P_STTY; /* restore terminal state for job */ tty_set(job.fd,TCSAFLUSH,&my_stty); } beenhere = 0; } #endif /* JOBS */ /* * wait built-in command */ void job_bwait(char **jobs) { register char *jp; register struct process *pw; register pid_t pid; if(*jobs==0) job_wait((pid_t)-1); else while(jp = *jobs++) { #ifdef JOBS if(*jp == '%') { job_lock(); pw = job_bystring(jp); job_unlock(); if(pw) pid = pw->p_pid; else return; } else #endif /* JOBS */ pid = (int)strtol(jp, (char**)0, 10); job_wait(-pid); } } #ifdef JOBS /* * execute function for each job */ int job_walk(Sfio_t *file,int (*fun)(struct process*,int),int arg,char *joblist[]) { register struct process *pw; register int r = 0; register char *jobid, **jobs=joblist; register struct process *px; job_string = 0; outfile = file; by_number = 0; job_lock(); pw = job.pwlist; if(jobs==0) { /* do all jobs */ for(;pw;pw=px) { px = pw->p_nxtjob; if(pw->p_env != sh.jobenv) continue; if((*fun)(pw,arg)) r = 2; } } else if(*jobs==0) /* current job */ { /* skip over non-stop jobs */ while(pw && (pw->p_env!=sh.jobenv || pw->p_pgrp==0)) pw = pw->p_nxtjob; if((*fun)(pw,arg)) r = 2; } else while(jobid = *jobs++) { job_string = jobid; if(*jobid==0) errormsg(SH_DICT,ERROR_exit(1),e_jobusage,job_string); if(*jobid == '%') pw = job_bystring(jobid); else { int pid = (int)strtol(jobid, (char**)0, 10); if(pid<0) jobid++; while(isdigit(*jobid)) jobid++; if(*jobid) errormsg(SH_DICT,ERROR_exit(1),e_jobusage,job_string); if(!(pw = job_bypid(pid))) { pw = &dummy; pw->p_pid = pid; pw->p_pgrp = pid; } by_number = 1; } if((*fun)(pw,arg)) r = 2; by_number = 0; } job_unlock(); return(r); } /* * send signal to background process group if not disowned */ int job_terminate(register struct process *pw,register int sig) { if(pw->p_pgrp && !(pw->p_flag&P_DISOWN)) job_kill(pw,sig); return(0); } /* * list the given job * flag JOB_LFLAG for long listing * flag JOB_NFLAG for list only jobs marked for notification * flag JOB_PFLAG for process id(s) only */ int job_list(struct process *pw,register int flag) { register struct process *px = pw; register int n; register const char *msg; register int msize; if(!pw || pw->p_job<=0) return(1); if(pw->p_env != sh.jobenv) return(0); if((flag&JOB_NFLAG) && (!(px->p_flag&P_NOTIFY)||px->p_pgrp==0)) return(0); if((flag&JOB_PFLAG)) { sfprintf(outfile,"%d\n",px->p_pgrp?px->p_pgrp:px->p_pid); return(0); } if((px->p_flag&P_DONE) && job.waitall && !(flag&JOB_LFLAG)) return(0); job_lock(); n = px->p_job; if(px==job.pwlist) msize = '+'; else if(px==job.pwlist->p_nxtjob) msize = '-'; else msize = ' '; if(flag&JOB_NLFLAG) sfputc(outfile,'\n'); sfprintf(outfile,"[%d] %c ",n, msize); do { n = 0; if(flag&JOB_LFLAG) sfprintf(outfile,"%d\t",px->p_pid); if(px->p_flag&P_SIGNALLED) msg = job_sigmsg((int)(px->p_exit)); else if(px->p_flag&P_NOTIFY) { msg = sh_translate(e_done); n = px->p_exit; } else msg = sh_translate(e_running); px->p_flag &= ~P_NOTIFY; sfputr(outfile,msg,-1); msize = strlen(msg); if(n) { sfprintf(outfile,"(%d)",(int)n); msize += (3+(n>10)+(n>100)); } if(px->p_flag&P_COREDUMP) { msg = sh_translate(e_coredump); sfputr(outfile, msg, -1); msize += strlen(msg); } sfnputc(outfile,' ',MAXMSG>msize?MAXMSG-msize:1); if(flag&JOB_LFLAG) px = px->p_nxtproc; else { while(px=px->p_nxtproc) px->p_flag &= ~P_NOTIFY; px = 0; } if(!px) hist_list(sh.hist_ptr,outfile,pw->p_name,0,";"); else sfputr(outfile, e_nlspace, -1); } while(px); job_unlock(); return(0); } /* * get the process group given the job number * This routine returns the process group number or -1 */ static struct process *job_bystring(register char *ajob) { register struct process *pw=job.pwlist; register int c; if(*ajob++ != '%' || !pw) return(NIL(struct process*)); c = *ajob; if(isdigit(c)) pw = job_byjid((int)strtol(ajob, (char**)0, 10)); else if(c=='+' || c=='%') ; else if(c=='-') { if(pw) pw = job.pwlist->p_nxtjob; } else pw = job_byname(ajob); if(pw && pw->p_flag) return(pw); return(NIL(struct process*)); } /* * Kill a job or process */ int job_kill(register struct process *pw,register int sig) { register pid_t pid; register int r; const char *msg; #ifdef SIGTSTP int stopsig = (sig==SIGSTOP||sig==SIGTSTP||sig==SIGTTIN||sig==SIGTTOU); #else # define stopsig 1 #endif /* SIGTSTP */ job_lock(); errno = ECHILD; if(pw==0) goto error; pid = pw->p_pid; if(by_number) { if(pid==0 && job.jobcontrol) r = job_walk(outfile, job_kill,sig, (char**)0); #ifdef SIGTSTP if(sig==SIGSTOP && pid==sh.pid && sh.ppid==1) { /* can't stop login shell */ errno = EPERM; r = -1; } else { if(pid>=0) { if((r = kill(pid,sig))>=0 && !stopsig) { if(pw->p_flag&P_STOPPED) pw->p_flag &= ~(P_STOPPED|P_SIGNALLED); if(sig) kill(pid,SIGCONT); } } else { if((r = killpg(-pid,sig))>=0 && !stopsig) { job_unstop(job_bypid(pw->p_pid)); if(sig) killpg(-pid,SIGCONT); } } } #else if(pid>=0) r = kill(pid,sig); else r = killpg(-pid,sig); #endif /* SIGTSTP */ } else { if(pid = pw->p_pgrp) { r = killpg(pid,sig); #ifdef SIGTSTP if(r>=0 && (sig==SIGHUP||sig==SIGTERM || sig==SIGCONT)) job_unstop(pw); #endif /* SIGTSTP */ if(r>=0) sh_delay(.05); } while(pw && pw->p_pgrp==0 && (r=kill(pw->p_pid,sig))>=0) { #ifdef SIGTSTP if(sig==SIGHUP || sig==SIGTERM) kill(pw->p_pid,SIGCONT); #endif /* SIGTSTP */ pw = pw->p_nxtproc; } } if(r<0 && job_string) { error: if(pw && by_number) msg = sh_translate(e_no_proc); else msg = sh_translate(e_no_job); if(errno == EPERM) msg = sh_translate(e_access); sfprintf(sfstderr,"kill: %s: %s\n",job_string, msg); r = 2; } sh_delay(.001); job_unlock(); return(r); } /* * Get process structure from first letters of jobname * */ static struct process *job_byname(char *name) { register struct process *pw = job.pwlist; register struct process *pz = 0; register int *flag = 0; register char *cp = name; int offset; if(!sh.hist_ptr) return(NIL(struct process*)); if(*cp=='?') cp++,flag= &offset; for(;pw;pw=pw->p_nxtjob) { if(hist_match(sh.hist_ptr,pw->p_name,cp,flag)>=0) { if(pz) errormsg(SH_DICT,ERROR_exit(1),e_jobusage,name-1); pz = pw; } } return(pz); } #else # define job_set(x) # define job_reset(x) #endif /* JOBS */ /* * Initialize the process posting array */ void job_clear(void) { register struct process *pw, *px; register struct process *pwnext; register int j = BYTE(sh.lim.child_max); register struct jobsave *jp,*jpnext; job_lock(); for(pw=job.pwlist; pw; pw=pwnext) { pwnext = pw->p_nxtjob; while(px=pw) { pw = pw->p_nxtproc; free((void*)px); } } for(jp=bck.list; jp;jp=jpnext) { jpnext = jp->next; free((void*)jp); } bck.list = 0; if(njob_savelist < NJOB_SAVELIST) init_savelist(); job.pwlist = NIL(struct process*); job.numpost=0; job.waitall = 0; job.curpgid = 0; job.toclear = 0; if(!job.freejobs) job.freejobs = (unsigned char*)malloc((unsigned)(j+1)); while(j >=0) job.freejobs[j--] = 0; job_unlock(); } /* * put the process on the process list and return the job number * if non-zero, is the process id of the job to join */ int job_post(pid_t pid, pid_t join) { register struct process *pw; register History_t *hp = sh.hist_ptr; sh.jobenv = sh.curenv; if(njob_savelist < NJOB_SAVELIST) init_savelist(); if(job.toclear) { job_clear(); return(0); } job_lock(); if(pw = job_bypid(pid)) job_unpost(pw,0); if(join && (pw=job_bypid(join))) { /* if job to join is not first move it to front */ if((pw=job_byjid(pw->p_job)) != job.pwlist) { job_unlink(pw); pw->p_nxtjob = job.pwlist; job.pwlist = pw; } } if(pw=freelist) freelist = pw->p_nxtjob; else pw = new_of(struct process,0); job.numpost++; if(join && job.pwlist) { /* join existing current job */ pw->p_nxtjob = job.pwlist->p_nxtjob; pw->p_nxtproc = job.pwlist; pw->p_job = job.pwlist->p_job; } else { /* create a new job */ while((pw->p_job = job_alloc()) < 0) job_wait((pid_t)1); pw->p_nxtjob = job.pwlist; pw->p_nxtproc = 0; } job.pwlist = pw; pw->p_env = sh.curenv; pw->p_pid = pid; pw->p_flag = P_EXITSAVE; pw->p_exitmin = sh.xargexit; pw->p_exit = 0; if(sh_isstate(SH_MONITOR)) { if(killpg(job.curpgid,0)<0 && errno==ESRCH) job.curpgid = pid; pw->p_fgrp = job.curpgid; } else pw->p_fgrp = 0; pw->p_pgrp = pw->p_fgrp; #ifdef DEBUG sfprintf(sfstderr,"ksh: job line %4d: post pid=%d critical=%d job=%d pid=%d pgid=%d savesig=%d join=%d\n",__LINE__,getpid(),job.in_critical,pw->p_job, pw->p_pid,pw->p_pgrp,job.savesig,join); sfsync(sfstderr); #endif /* DEBUG */ #ifdef JOBS if(hp && !sh_isstate(SH_PROFILE)) pw->p_name=hist_tell(sh.hist_ptr,(int)hp->histind-1); else pw->p_name = -1; #endif /* JOBS */ if(pid==lastpid) { int val = job_chksave(pid); pw->p_exit = val>0?val:0; if(pw->p_exit==SH_STOPSIG) { pw->p_flag |= (P_SIGNALLED|P_STOPPED); pw->p_exit = 0; } else pw->p_flag |= (P_DONE|P_NOTIFY); } lastpid = 0; job_unlock(); return(pw->p_job); } /* * Returns a process structure give a process id */ static struct process *job_bypid(pid_t pid) { register struct process *pw, *px; for(pw=job.pwlist; pw; pw=pw->p_nxtjob) for(px=pw; px; px=px->p_nxtproc) { if(px->p_pid==pid) return(px); } return(NIL(struct process*)); } /* * return a pointer to a job given the job id */ static struct process *job_byjid(int jobid) { register struct process *pw; for(pw=job.pwlist;pw; pw = pw->p_nxtjob) { if(pw->p_job==jobid) break; } return(pw); } /* * print a signal message */ static void job_prmsg(register struct process *pw) { if(pw->p_exit!=SIGINT && pw->p_exit!=SIGPIPE) { register const char *msg, *dump; msg = job_sigmsg((int)(pw->p_exit)); msg = sh_translate(msg); if(pw->p_flag&P_COREDUMP) dump = sh_translate(e_coredump); else dump = ""; if(sh_isstate(SH_INTERACTIVE)) sfprintf(sfstderr,"%s%s\n",msg,dump); else errormsg(SH_DICT,2,"%d: %s%s",pw->p_pid,msg,dump); } } /* * Wait for process pid to complete * If pid < -1, then wait can be interrupted, -pid is waited for (wait builtin) * pid=0 to unpost all done processes * pid=1 to wait for at least one process to complete * pid=-1 to wait for all runing processes */ void job_wait(register pid_t pid) { register struct process *pw=0,*px; register int jobid = 0; int nochild; char intr = 0; if(pid <= 0) { if(pid==0) goto done; pid = -pid; intr = 1; } job_lock(); if(pid > 1) { if(!(pw=job_bypid(pid))) { /* check to see whether job status has been saved */ if((sh.exitval = job_chksave(pid)) < 0) sh.exitval = ERROR_NOENT; exitset(); job_unlock(); return; } else if(intr && pw->p_env!=sh.curenv) { sh.exitval = ERROR_NOENT; job_unlock(); return; } jobid = pw->p_job; if(!intr) pw->p_flag &= ~P_EXITSAVE; if(pw->p_pgrp && job.parent!= (pid_t)-1) job_set(job_byjid(jobid)); } #ifdef DEBUG sfprintf(sfstderr,"ksh: job line %4d: wait pid=%d critical=%d job=%d pid=%d\n",__LINE__,getpid(),job.in_critical,jobid,pid); if(pw) sfprintf(sfstderr,"ksh: job line %4d: wait pid=%d critical=%d flags=%o\n",__LINE__,getpid(),job.in_critical,pw->p_flag); #endif /* DEBUG*/ errno = 0; while(1) { if(job.waitsafe) { for(px=job.pwlist;px; px = px->p_nxtjob) { if(px!=pw && (px->p_flag&P_NOTIFY)) { if(sh_isoption(SH_NOTIFY)) { outfile = sfstderr; job_list(px,JOB_NFLAG|JOB_NLFLAG); sfsync(sfstderr); } else if(!sh_isoption(SH_INTERACTIVE) && (px->p_flag&P_SIGNALLED)) { job_prmsg(px); px->p_flag &= ~P_NOTIFY; } } } } if(pw && (pw->p_flag&(P_DONE|P_STOPPED))) { #ifdef SIGTSTP if(pw->p_flag&P_STOPPED) { pw->p_flag |= P_EXITSAVE; if(sh_isoption(SH_INTERACTIVE) && !sh_isstate(SH_FORKED)) { if( pw->p_exit!=SIGTTIN && pw->p_exit!=SIGTTOU) break; killpg(pw->p_pgrp,SIGCONT); } else /* ignore stop when non-interactive */ pw->p_flag &= ~(P_NOTIFY|P_SIGNALLED|P_STOPPED|P_EXITSAVE); } else #endif /* SIGTSTP */ { if(pw->p_flag&P_SIGNALLED) { pw->p_flag &= ~P_NOTIFY; job_prmsg(pw); } else if(pw->p_flag&P_DONE) pw->p_flag &= ~P_NOTIFY; if(pw->p_job==jobid) { px = job_byjid(jobid); /* last process in job */ if(sh_isoption(SH_PIPEFAIL)) { /* last non-zero exit */ for(;px;px=px->p_nxtproc) { if(px->p_exit) break; } if(!px) px = pw; } else if(px!=pw) px = 0; if(px) { sh.exitval=px->p_exit; if(px->p_flag&P_SIGNALLED) sh.exitval |= SH_EXITSIG; if(intr) px->p_flag &= ~P_EXITSAVE; } } if(!job.waitall) { if(!sh_isoption(SH_PIPEFAIL)) job_unpost(pw,1); break; } else if(!(px=job_unpost(pw,1))) break; pw = px; continue; } } sfsync(sfstderr); job.waitsafe = 0; nochild = job_reap(job.savesig); if(job.waitsafe) continue; if(nochild) break; if(sh.sigflag[SIGALRM]&SH_SIGTRAP) sh_timetraps(); if((intr && sh.trapnote) || (pid==1 && !intr)) break; } job_unlock(); if(pid==1) return; exitset(); if(pw->p_pgrp) { job_reset(pw); /* propogate keyboard interrupts to parent */ if((pw->p_flag&P_SIGNALLED) && pw->p_exit==SIGINT && !(sh.sigflag[SIGINT]&SH_SIGOFF)) sh_fault(SIGINT); #ifdef SIGTSTP else if((pw->p_flag&P_STOPPED) && pw->p_exit==SIGTSTP) { job.parent = 0; sh_fault(SIGTSTP); } #endif /* SIGTSTP */ } else tty_set(-1, 0, NIL(struct termios*)); done: if(!job.waitall && sh_isoption(SH_PIPEFAIL)) return; if(!sh.intrap) { job_lock(); for(pw=job.pwlist; pw; pw=px) { px = pw->p_nxtjob; job_unpost(pw,0); } job_unlock(); } } /* * move job to foreground if bgflag == 'f' * move job to background if bgflag == 'b' * disown job if bgflag == 'd' */ int job_switch(register struct process *pw,int bgflag) { register const char *msg; job_lock(); if(!pw || !(pw=job_byjid((int)pw->p_job))) { job_unlock(); return(1); } if(bgflag=='d') { for(; pw; pw=pw->p_nxtproc) pw->p_flag |= P_DISOWN; job_unlock(); return(0); } #ifdef SIGTSTP if(bgflag=='b') { sfprintf(outfile,"[%d]\t",(int)pw->p_job); sh.bckpid = pw->p_pid; msg = "&"; } else { job_unlink(pw); pw->p_nxtjob = job.pwlist; job.pwlist = pw; msg = ""; } hist_list(sh.hist_ptr,outfile,pw->p_name,'&',";"); sfputr(outfile,msg,'\n'); sfsync(outfile); if(bgflag=='f') { if(!(pw=job_unpost(pw,1))) { job_unlock(); return(1); } job.waitall = 1; pw->p_flag |= P_FG; job_wait(pw->p_pid); job.waitall = 0; } else if(pw->p_flag&P_STOPPED) job_unstop(pw); #endif /* SIGTSTP */ job_unlock(); return(0); } #ifdef SIGTSTP /* * Set the foreground group associated with a job */ static void job_fgrp(register struct process *pw, int newgrp) { for(; pw; pw=pw->p_nxtproc) pw->p_fgrp = newgrp; } /* * turn off STOP state of a process group and send CONT signals */ static void job_unstop(register struct process *px) { register struct process *pw; register int num = 0; for(pw=px ;pw ;pw=pw->p_nxtproc) { if(pw->p_flag&P_STOPPED) { num++; pw->p_flag &= ~(P_STOPPED|P_SIGNALLED|P_NOTIFY); } } if(num!=0) { if(px->p_fgrp != px->p_pgrp) killpg(px->p_fgrp,SIGCONT); killpg(px->p_pgrp,SIGCONT); } } #endif /* SIGTSTP */ /* * remove a job from table * If all the processes have not completed, unpost first non-completed process * Otherwise the job is removed and job_unpost returns NULL. * pwlist is reset if the first job is removed * if is non-zero, then jobs with pending notifications are unposted */ static struct process *job_unpost(register struct process *pwtop,int notify) { register struct process *pw; /* make sure all processes are done */ #ifdef DEBUG sfprintf(sfstderr,"ksh: job line %4d: drop pid=%d critical=%d pid=%d env=%d\n",__LINE__,getpid(),job.in_critical,pwtop->p_pid,pwtop->p_env); sfsync(sfstderr); #endif /* DEBUG */ pwtop = pw = job_byjid((int)pwtop->p_job); for(; pw && (pw->p_flag&P_DONE)&&(notify||!(pw->p_flag&P_NOTIFY)||pw->p_env); pw=pw->p_nxtproc); if(pw) return(pw); /* all processes complete, unpost job */ if (pwtop) job_unlink(pwtop); for(pw=pwtop; pw; pw=pw->p_nxtproc) { /* save the exit status for background jobs */ if(pw->p_flag&P_EXITSAVE) { struct jobsave *jp; /* save status for future wait */ if(bck.count++ > sh.lim.child_max) job_chksave(0); if(jp = jobsave_create(pw->p_pid)) { jp->next = bck.list; bck.list = jp; jp->exitval = pw->p_exit; if(pw->p_flag&P_SIGNALLED) jp->exitval |= SH_EXITSIG; } pw->p_flag &= ~P_EXITSAVE; } pw->p_flag &= ~P_DONE; job.numpost--; pw->p_nxtjob = freelist; freelist = pw; } #ifdef DEBUG sfprintf(sfstderr,"ksh: job line %4d: free pid=%d critical=%d job=%d\n",__LINE__,getpid(),job.in_critical,pwtop->p_job); sfsync(sfstderr); #endif /* DEBUG */ if (pwtop) job_free((int)pwtop->p_job); return((struct process*)0); } /* * unlink a job form the job list */ static void job_unlink(register struct process *pw) { register struct process *px; if(pw==job.pwlist) { job.pwlist = pw->p_nxtjob; job.curpgid = 0; return; } for(px=job.pwlist;px;px=px->p_nxtjob) if(px->p_nxtjob == pw) { px->p_nxtjob = pw->p_nxtjob; return; } } /* * get an unused job number * freejobs is a bit vector, 0 is unused */ static int job_alloc(void) { register int j=0; register unsigned mask = 1; register unsigned char *freeword; register int jmax = BYTE(sh.lim.child_max); /* skip to first word with a free slot */ for(j=0;job.freejobs[j] == UCHAR_MAX; j++); if(j >= jmax) { register struct process *pw; for(j=1; j < sh.lim.child_max; j++) { if((pw=job_byjid(j))&& !job_unpost(pw,0)) break; } j /= CHAR_BIT; if(j >= jmax) return(-1); } freeword = &job.freejobs[j]; j *= CHAR_BIT; for(j++;mask&(*freeword);j++,mask <<=1); *freeword |= mask; return(j); } /* * return a job number */ static void job_free(register int n) { register int j = (--n)/CHAR_BIT; register unsigned mask; n -= j*CHAR_BIT; mask = 1 << n; job.freejobs[j] &= ~mask; } static char *job_sigmsg(int sig) { static char signo[40]; #ifdef apollo /* * This code handles the formatting for the apollo specific signal * SIGAPOLLO. */ extern char *apollo_error(void); if ( sig == SIGAPOLLO ) return( apollo_error() ); #endif /* apollo */ if(sig=SIGRTMIN && sig<=SIGRTMAX) { static char sigrt[20]; sfsprintf(sigrt,sizeof(sigrt),"SIGRTMIN+%d",sig-SIGRTMIN); return(sigrt); } #endif sfsprintf(signo,sizeof(signo),sh_translate(e_signo),sig); return(signo); } /* * see whether exit status has been saved and delete it * if pid==0, then oldest saved process is deleted * If pid is not found a -1 is returned. */ static int job_chksave(register pid_t pid) { register struct jobsave *jp = bck.list, *jpold=0; register int r= -1; while(jp) { if(jp->pid==pid) break; if(pid==0 && !jp->next) break; jpold = jp; jp = jp->next; } if(jp) { r = 0; if(pid) r = jp->exitval; if(jpold) jpold->next = jp->next; else bck.list = jp->next; bck.count--; if(njob_savelist < NJOB_SAVELIST) { njob_savelist++; jp->next = job_savelist; job_savelist = jp; } else free((void*)jp); } return(r); } void *job_subsave(void) { struct back_save *bp = new_of(struct back_save,0); job_lock(); *bp = bck; bck.count = 0; bck.list = 0; job_unlock(); return((void*)bp); } void job_subrestore(void* ptr) { register struct jobsave *jp; register struct back_save *bp = (struct back_save*)ptr; register struct process *pw, *px, *pwnext; job_lock(); for(pw=job.pwlist; pw; pw=pwnext) { pwnext = pw->p_nxtjob; if(pw->p_env != sh.curenv) continue; for(px=pw; px; px=px->p_nxtproc) px->p_flag |= P_DONE; job_unpost(pw,0); } /* * queue up old lists for disposal by job_reap() */ jp = bck.list; bp->free = bck.free; bck = *bp; bck.free = bp; bp->list = jp; job_unlock(); } int sh_waitsafe(void) { return(job.waitsafe); } void job_fork(pid_t parent) { #ifdef DEBUG sfprintf(sfstderr,"ksh: job line %4d: fork pid=%d critical=%d parent=%d\n",__LINE__,getpid(),job.in_critical,parent); #endif /* DEBUG */ switch (parent) { case -1: job_lock(); break; case 0: job_unlock(); job.waitsafe = 0; job.in_critical = 0; break; default: job_unlock(); break; } }