/* slp.c 4.14 81/06/11 */ #include "../h/param.h" #include "../h/systm.h" #include "../h/dir.h" #include "../h/user.h" #include "../h/proc.h" #include "../h/file.h" #include "../h/inode.h" #include "../h/vm.h" #include "../h/pte.h" #include "../h/inline.h" #include "../h/mtpr.h" #define SQSIZE 0100 /* Must be power of 2 */ #define HASH(x) (( (int) x >> 5) & (SQSIZE-1)) struct proc *slpque[SQSIZE]; /* * Give up the processor till a wakeup occurs * on chan, at which time the process * enters the scheduling queue at priority pri. * The most important effect of pri is that when * pri<=PZERO a signal cannot disturb the sleep; * if pri>PZERO signals will be processed. * Callers of this routine must be prepared for * premature return, and check that the reason for * sleeping has gone away. */ sleep(chan, pri) caddr_t chan; { register struct proc *rp, **hp; register s; rp = u.u_procp; s = spl6(); if (chan==0 || rp->p_stat != SRUN || rp->p_rlink) panic("sleep"); rp->p_wchan = chan; rp->p_slptime = 0; rp->p_pri = pri; hp = &slpque[HASH(chan)]; rp->p_link = *hp; *hp = rp; if(pri > PZERO) { if(ISSIG(rp)) { if (rp->p_wchan) unsleep(rp); rp->p_stat = SRUN; (void) spl0(); goto psig; } if (rp->p_wchan == 0) goto out; rp->p_stat = SSLEEP; (void) spl0(); swtch(); if(ISSIG(rp)) goto psig; } else { rp->p_stat = SSLEEP; (void) spl0(); swtch(); } out: splx(s); return; /* * If priority was low (>PZERO) and * there has been a signal, * execute non-local goto to * the qsav location. * (see trap1/trap.c) */ psig: longjmp(u.u_qsav); /*NOTREACHED*/ } /* * Sleep on chan at pri. * Return in no more than the indicated number of seconds. * (If seconds==0, no timeout implied) * Return TS_OK if chan was awakened normally * TS_TIME if timeout occurred * TS_SIG if asynchronous signal occurred */ tsleep(chan, pri, seconds) caddr_t chan; { label_t lqsav; register struct proc *pp; register sec, n, rval; pp = u.u_procp; n = spl7(); sec = 0; rval = 0; if (pp->p_clktim && pp->p_clktim<seconds) seconds = 0; if (seconds) { pp->p_flag |= STIMO; sec = pp->p_clktim-seconds; pp->p_clktim = seconds; } bcopy((caddr_t)u.u_qsav, (caddr_t)lqsav, sizeof (label_t)); if (setjmp(u.u_qsav)) rval = TS_SIG; else { sleep(chan, pri); if ((pp->p_flag&STIMO)==0 && seconds) rval = TS_TIME; else rval = TS_OK; } pp->p_flag &= ~STIMO; bcopy((caddr_t)lqsav, (caddr_t)u.u_qsav, sizeof (label_t)); if (sec > 0) pp->p_clktim += sec; else pp->p_clktim = 0; splx(n); return(rval); } /* * Remove a process from its wait queue */ unsleep(p) register struct proc *p; { register struct proc **hp; register s; s = spl6(); if (p->p_wchan) { hp = &slpque[HASH(p->p_wchan)]; while (*hp != p) hp = &(*hp)->p_link; *hp = p->p_link; p->p_wchan = 0; } splx(s); } /* * Wake up all processes sleeping on chan. */ wakeup(chan) register caddr_t chan; { register struct proc *p, **q, **h; int s; s = spl6(); h = &slpque[HASH(chan)]; restart: for (q = h; p = *q; ) { if (p->p_rlink || p->p_stat != SSLEEP && p->p_stat != SSTOP) panic("wakeup"); if (p->p_wchan==chan) { p->p_wchan = 0; *q = p->p_link; p->p_slptime = 0; if (p->p_stat == SSLEEP) { /* OPTIMIZED INLINE EXPANSION OF setrun(p) */ p->p_stat = SRUN; if (p->p_flag & SLOAD) setrq(p); if(p->p_pri < curpri) { runrun++; aston(); } if ((p->p_flag&SLOAD) == 0) { if (runout != 0) { runout = 0; wakeup((caddr_t)&runout); } wantin++; } /* END INLINE EXPANSION */ goto restart; } } else q = &p->p_link; } splx(s); } /* * Initialize the (doubly-linked) run queues * to be empty. */ rqinit() { register int i; for (i = 0; i < NQS; i++) qs[i].ph_link = qs[i].ph_rlink = (struct proc *)&qs[i]; } /* * Set the process running; * arrange for it to be swapped in if necessary. */ setrun(p) register struct proc *p; { register s; s = spl6(); switch (p->p_stat) { case 0: case SWAIT: case SRUN: case SZOMB: default: panic("setrun"); case SSTOP: case SSLEEP: unsleep(p); /* e.g. when sending signals */ break; case SIDL: break; } p->p_stat = SRUN; if (p->p_flag & SLOAD) setrq(p); splx(s); if(p->p_pri < curpri) { runrun++; aston(); } if ((p->p_flag&SLOAD) == 0) { if(runout != 0) { runout = 0; wakeup((caddr_t)&runout); } wantin++; } } /* * Set user priority. * The rescheduling flag (runrun) * is set if the priority is better * than the currently running process. */ setpri(pp) register struct proc *pp; { register p; p = (pp->p_cpu & 0377)/4; p += PUSER + 2*(pp->p_nice - NZERO); if (pp->p_rssize > pp->p_maxrss && freemem < desfree) p += 2*4; /* effectively, nice(4) */ if(p > 127) p = 127; if(p < curpri) { runrun++; aston(); } pp->p_usrpri = p; return(p); } /* * Create a new process-- the internal version of * sys fork. * It returns 1 in the new process, 0 in the old. */ newproc(isvfork) { register struct proc *p; register struct proc *rpp, *rip; register int n; p = NULL; /* * First, just locate a slot for a process * and copy the useful info from this process into it. * The panic "cannot happen" because fork has already * checked for the existence of a slot. */ retry: mpid++; if(mpid >= 30000) { mpid = 0; goto retry; } for(rpp = proc; rpp < procNPROC; rpp++) { if(rpp->p_stat == NULL && p==NULL) p = rpp; if (rpp->p_pid==mpid || rpp->p_pgrp==mpid) goto retry; } if ((rpp = p)==NULL) panic("no procs"); /* * make proc entry for new proc */ rip = u.u_procp; rpp->p_stat = SIDL; rpp->p_clktim = 0; rpp->p_flag = SLOAD | (rip->p_flag & (SPAGI|SDETACH|SNUSIG)); if (isvfork) { rpp->p_flag |= SVFORK; rpp->p_ndx = rip->p_ndx; } else rpp->p_ndx = rpp - proc; rpp->p_uid = rip->p_uid; rpp->p_pgrp = rip->p_pgrp; rpp->p_nice = rip->p_nice; rpp->p_textp = isvfork ? 0 : rip->p_textp; rpp->p_pid = mpid; rpp->p_ppid = rip->p_pid; rpp->p_pptr = rip; rpp->p_time = 0; rpp->p_cpu = 0; rpp->p_siga0 = rip->p_siga0; rpp->p_siga1 = rip->p_siga1; /* take along any pending signals, like stops? */ if (isvfork) { rpp->p_tsize = rpp->p_dsize = rpp->p_ssize = 0; rpp->p_szpt = clrnd(ctopt(UPAGES)); forkstat.cntvfork++; forkstat.sizvfork += rip->p_dsize + rip->p_ssize; } else { rpp->p_tsize = rip->p_tsize; rpp->p_dsize = rip->p_dsize; rpp->p_ssize = rip->p_ssize; rpp->p_szpt = rip->p_szpt; forkstat.cntfork++; forkstat.sizfork += rip->p_dsize + rip->p_ssize; } rpp->p_rssize = 0; rpp->p_maxrss = rip->p_maxrss; rpp->p_wchan = 0; rpp->p_slptime = 0; rpp->p_pctcpu = 0; rpp->p_cpticks = 0; n = PIDHASH(rpp->p_pid); p->p_idhash = pidhash[n]; pidhash[n] = rpp - proc; /* * make duplicate entries * where needed */ multprog++; for(n=0; n<NOFILE; n++) if(u.u_ofile[n] != NULL) { u.u_ofile[n]->f_count++; if(!isvfork && u.u_vrpages[n]) u.u_ofile[n]->f_inode->i_vfdcnt++; } u.u_cdir->i_count++; if (u.u_rdir) u.u_rdir->i_count++; /* * Partially simulate the environment * of the new process so that when it is actually * created (by copying) it will look right. */ rip->p_flag |= SKEEP; /* prevent parent from being swapped */ if (procdup(rpp, isvfork)) return (1); (void) spl6(); rpp->p_stat = SRUN; setrq(rpp); (void) spl0(); /* SSWAP NOT NEEDED IN THIS CASE AS u.u_pcb.pcb_sswap SUFFICES */ /* rpp->p_flag |= SSWAP; */ rip->p_flag &= ~SKEEP; if (isvfork) { u.u_procp->p_xlink = rpp; u.u_procp->p_flag |= SNOVM; while (rpp->p_flag & SVFORK) sleep((caddr_t)rpp, PZERO - 1); if ((rpp->p_flag & SLOAD) == 0) panic("newproc vfork"); uaccess(rpp, Vfmap, &vfutl); u.u_procp->p_xlink = 0; vpassvm(rpp, u.u_procp, &vfutl, &u, Vfmap); for (n = 0; n < NOFILE; n++) if (vfutl.u_vrpages[n]) { if ((u.u_vrpages[n] = vfutl.u_vrpages[n] - 1) == 0) if (--u.u_ofile[n]->f_inode->i_vfdcnt < 0) panic("newproc i_vfdcnt"); vfutl.u_vrpages[n] = 0; } u.u_procp->p_flag &= ~SNOVM; rpp->p_ndx = rpp - proc; rpp->p_flag |= SVFDONE; wakeup((caddr_t)rpp); } return (0); }