X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/06f9e71452a4aa4272c5715810dcef03e8b0369f..961945a80c6f995f4567dbce8881af0bbdee211c:/usr/src/sys/kern/kern_synch.c

diff --git a/usr/src/sys/kern/kern_synch.c b/usr/src/sys/kern/kern_synch.c
index 64cfef1bef..18438635cd 100644
--- a/usr/src/sys/kern/kern_synch.c
+++ b/usr/src/sys/kern/kern_synch.c
@@ -1,4 +1,6 @@
-/*	kern_synch.c	3.6	%H%	*/
+/*	kern_synch.c	4.25	82/12/17	*/
+
+#include "../machine/pte.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"
@@ -8,8 +10,93 @@
 #include "../h/file.h"
 #include "../h/inode.h"
 #include "../h/vm.h"
-#include "../h/pte.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))
@@ -27,154 +114,123 @@ struct proc *slpque[SQSIZE];
  * sleeping has gone away.
  */
 sleep(chan, pri)
-caddr_t chan;
+	caddr_t chan;
+	int pri;
 {
-	register struct proc *rp;
-	register s, h;
+	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_stat = SSLEEP;
 	rp->p_wchan = chan;
 	rp->p_slptime = 0;
 	rp->p_pri = pri;
-	h = HASH(chan);
-	rp->p_link = slpque[h];
-	slpque[h] = rp;
-	if(pri > PZERO) {
-		if(rp->p_sig && issig()) {
-			rp->p_wchan = 0;
+	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;
-			slpque[h] = rp->p_link;
-			VOID spl0();
+			(void) spl0();
 			goto psig;
 		}
-		VOID spl0();
-		if(runin != 0) {
-			runin = 0;
-			wakeup((caddr_t)&runin);
-		}
+		if (rp->p_wchan == 0)
+			goto out;
+		rp->p_stat = SSLEEP;
+		(void) spl0();
+		u.u_ru.ru_nvcsw++;
 		swtch();
-		if(rp->p_sig && issig())
+		if (ISSIG(rp))
 			goto psig;
 	} else {
-		VOID spl0();
+		rp->p_stat = SSLEEP;
+		(void) spl0();
+		u.u_ru.ru_nvcsw++;
 		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)
+	 * 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
+ * Remove a process from its wait queue
  */
-tsleep(chan, pri, seconds)
-caddr_t chan;
+unsleep(p)
+	register struct proc *p;
 {
-	label_t lqsav;
-	register struct proc *pp;
-	register sec, n, rval;
+	register struct proc **hp;
+	register s;
 
-	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;
+	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;
 	}
-	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);
+	splx(s);
 }
 
 /*
  * Wake up all processes sleeping on chan.
  */
 wakeup(chan)
-register caddr_t chan;
+	register caddr_t chan;
 {
-	register struct proc *p, *q;
-	register i;
+	register struct proc *p, **q, **h;
 	int s;
 
 	s = spl6();
-	i = HASH(chan);
+	h = &slpque[HASH(chan)];
 restart:
-	p = slpque[i];
-	q = NULL;
-	while(p != NULL) {
-		if (p->p_rlink || p->p_stat != SSLEEP)
+	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_stat!=SZOMB) {
-			if (q == NULL)
-				slpque[i] = p->p_link;
-			else
-				q->p_link = p->p_link;
+		if (p->p_wchan==chan) {
 			p->p_wchan = 0;
+			*q = p->p_link;
 			p->p_slptime = 0;
-			/* 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
-				setrq(p);
-#endif
-			}
-			if(p->p_pri < curpri)
-				runrun++;
-			if(runout != 0 && (p->p_flag&SLOAD) == 0) {
-				runout = 0;
-				wakeup((caddr_t)&runout);
+			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;
 			}
-			/* END INLINE EXPANSION */
-			goto restart;
-		}
-		q = p;
-		p = p->p_link;
+		} else
+			q = &p->p_link;
 	}
 	splx(s);
 }
 
-#ifdef FASTVAX
 /*
  * Initialize the (doubly-linked) run queues
  * to be empty.
@@ -186,17 +242,15 @@ rqinit()
 	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 caddr_t w;
-	register s;
+	register int s;
 
 	s = spl6();
 	switch (p->p_stat) {
@@ -208,27 +262,28 @@ register struct proc *p;
 	default:
 		panic("setrun");
 
+	case SSTOP:
 	case SSLEEP:
-		if (w = p->p_wchan) {
-			wakeup(w);
-			splx(s);
-			return;
-		}
+		unsleep(p);		/* e.g. when sending signals */
 		break;
 
 	case SIDL:
-	case SSTOP:
 		break;
 	}
 	p->p_stat = SRUN;
 	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++;
 	}
 }
 
@@ -239,153 +294,20 @@ register struct proc *p;
  * 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;
-	}
-	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_time = 0;
-	rpp->p_cpu = 0;
-	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;
+		aston();
 	}
-	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);
 }