-/* kern_synch.c 3.11 %G% */
+/* kern_synch.c 4.25 82/12/17 */
+
+#include "../machine/pte.h"
#include "../h/param.h"
#include "../h/systm.h"
#include "../h/file.h"
#include "../h/inode.h"
#include "../h/vm.h"
-#include "../h/pte.h"
-#include "../h/inline.h"
+#ifdef MUSH
+#include "../h/quota.h"
+#include "../h/share.h"
+#endif
+#include "../h/kernel.h"
+#include "../h/buf.h"
+
+#ifdef vax
+#include "../vax/mtpr.h" /* XXX */
+#endif
+/*
+ * Force switch among equal priority processes every 100ms.
+ */
+roundrobin()
+{
+ runrun++;
+ aston();
+ timeout(roundrobin, (caddr_t)0, hz / 10);
+}
+
+/* constants to digital decay and forget 90% of usage in 5*loadav time */
+#undef ave
+#define ave(a,b) ((int)(((int)(a*b))/(b+1)))
+int nrscale = 2;
+double ccpu = 0.95122942450071400909; /* exp(-1/20) */
+
+/*
+ * Recompute process priorities, once a second
+ */
+schedcpu()
+{
+ register struct proc *p;
+ register int s, a;
+
+ wakeup((caddr_t)&lbolt);
+ for (p = proc; p < procNPROC; p++) if (p->p_stat && p->p_stat!=SZOMB) {
+#ifdef MUSH
+ if (p->p_quota->q_uid)
+ p->p_quota->q_cost +=
+ shconsts.sc_click * p->p_rssize;
+#endif
+ if (p->p_time != 127)
+ p->p_time++;
+ if (p->p_stat==SSLEEP || p->p_stat==SSTOP)
+ if (p->p_slptime != 127)
+ p->p_slptime++;
+ if (p->p_flag&SLOAD)
+ p->p_pctcpu = ccpu * p->p_pctcpu +
+ (1.0 - ccpu) * (p->p_cpticks/(float)hz);
+ p->p_cpticks = 0;
+#ifdef MUSH
+ a = ave((p->p_cpu & 0377), avenrun[0]*nrscale) +
+ p->p_nice - NZERO + p->p_quota->q_nice;
+#else
+ a = ave((p->p_cpu & 0377), avenrun[0]*nrscale) +
+ p->p_nice - NZERO;
+#endif
+ if (a < 0)
+ a = 0;
+ if (a > 255)
+ a = 255;
+ p->p_cpu = a;
+ (void) setpri(p);
+ s = spl6(); /* prevent state changes */
+ if (p->p_pri >= PUSER) {
+ if ((p != u.u_procp || noproc) &&
+ p->p_stat == SRUN &&
+ (p->p_flag & SLOAD) &&
+ p->p_pri != p->p_usrpri) {
+ remrq(p);
+ p->p_pri = p->p_usrpri;
+ setrq(p);
+ } else
+ p->p_pri = p->p_usrpri;
+ }
+ splx(s);
+ }
+ vmmeter();
+ if (runin!=0) {
+ runin = 0;
+ wakeup((caddr_t)&runin);
+ }
+ if (bclnlist != NULL)
+ wakeup((caddr_t)&proc[2]);
+ timeout(schedcpu, (caddr_t)0, hz);
+}
#define SQSIZE 0100 /* Must be power of 2 */
#define HASH(x) (( (int) x >> 5) & (SQSIZE-1))
* sleeping has gone away.
*/
sleep(chan, pri)
-caddr_t chan;
+ caddr_t chan;
+ int pri;
{
register struct proc *rp, **hp;
register s;
hp = &slpque[HASH(chan)];
rp->p_link = *hp;
*hp = rp;
- if(pri > PZERO) {
- if(ISSIG(rp)) {
+ if (pri > PZERO) {
+ if (ISSIG(rp)) {
if (rp->p_wchan)
unsleep(rp);
rp->p_stat = SRUN;
goto out;
rp->p_stat = SSLEEP;
(void) spl0();
- if(runin != 0) {
- runin = 0;
- wakeup((caddr_t)&runin);
- }
+ u.u_ru.ru_nvcsw++;
swtch();
- if(ISSIG(rp))
+ if (ISSIG(rp))
goto psig;
} else {
rp->p_stat = SSLEEP;
(void) spl0();
+ u.u_ru.ru_nvcsw++;
swtch();
}
out:
/*
* If priority was low (>PZERO) and
- * there has been a signal,
- * execute non-local goto to
- * the qsav location.
- * (see trap1/trap.c)
+ * there has been a signal, execute non-local goto through
+ * u.u_qsave, aborting the system call in progress (see trap.c)
+ * (or finishing a tsleep, see below)
*/
psig:
- longjmp(u.u_qsav);
+ longjmp(&u.u_qsave);
/*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 *p;
{
register struct proc **hp;
register s;
* Wake up all processes sleeping on chan.
*/
wakeup(chan)
-register caddr_t chan;
+ register caddr_t chan;
{
register struct proc *p, **q, **h;
int s;
if (p->p_stat == SSLEEP) {
/* OPTIMIZED INLINE EXPANSION OF setrun(p) */
p->p_stat = SRUN;
- if (p->p_flag & SLOAD) {
-#ifndef FASTVAX
- p->p_link = runq;
- runq = p->p_link;
-#else
+ if (p->p_flag & SLOAD)
setrq(p);
-#endif
- }
- if(p->p_pri < curpri)
+ if (p->p_pri < curpri) {
runrun++;
- if(runout != 0 && (p->p_flag&SLOAD) == 0) {
- runout = 0;
- wakeup((caddr_t)&runout);
+ aston();
+ }
+ if ((p->p_flag&SLOAD) == 0) {
+ if (runout != 0) {
+ runout = 0;
+ wakeup((caddr_t)&runout);
+ }
+ wantin++;
}
/* END INLINE EXPANSION */
goto restart;
splx(s);
}
-#ifdef FASTVAX
/*
* Initialize the (doubly-linked) run queues
* to be empty.
for (i = 0; i < NQS; i++)
qs[i].ph_link = qs[i].ph_rlink = (struct proc *)&qs[i];
}
-#endif
/*
* Set the process running;
* arrange for it to be swapped in if necessary.
*/
setrun(p)
-register struct proc *p;
+ register struct proc *p;
{
- register s;
+ register int s;
s = spl6();
switch (p->p_stat) {
if (p->p_flag & SLOAD)
setrq(p);
splx(s);
- if(p->p_pri < curpri)
+ if (p->p_pri < curpri) {
runrun++;
- if(runout != 0 && (p->p_flag&SLOAD) == 0) {
- runout = 0;
- wakeup((caddr_t)&runout);
+ aston();
+ }
+ if ((p->p_flag&SLOAD) == 0) {
+ if (runout != 0) {
+ runout = 0;
+ wakeup((caddr_t)&runout);
+ }
+ wantin++;
}
}
* than the currently running process.
*/
setpri(pp)
-register struct proc *pp;
+ register struct proc *pp;
{
- register p;
+ register int p;
- p = (pp->p_cpu & 0377)/16;
- p += PUSER + pp->p_nice - NZERO;
- if(p > 127)
+ 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)
+ if (p < curpri) {
runrun++;
- 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;
+ aston();
}
- for(rpp = &proc[0]; rpp < &proc[NPROC]; 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);
- 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_wchan = 0;
- rpp->p_slptime = 0;
- rpp->p_aveflt = rip->p_aveflt;
- rate.v_pgin += rip->p_aveflt;
- rpp->p_faults = 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);
-
- spl6();
- rpp->p_stat = SRUN;
- setrq(rpp);
- 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);
+ pp->p_usrpri = p;
+ return (p);
}