X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/8add37d7099b7d36c98ca2766a90941c8b68fcef..5513375c86e602a9163497b7ad7e66f860de9efb:/usr/src/sys/kern/kern_clock.c

diff --git a/usr/src/sys/kern/kern_clock.c b/usr/src/sys/kern/kern_clock.c
index e2706faac4..fc68fc6e2d 100644
--- a/usr/src/sys/kern/kern_clock.c
+++ b/usr/src/sys/kern/kern_clock.c
@@ -1,7 +1,8 @@
-/*	kern_clock.c	3.2	%H%	*/
+/*	kern_clock.c	4.5	%G%	*/
 
 #include "../h/param.h"
 #include "../h/systm.h"
+#include "../h/dk.h"
 #include "../h/callo.h"
 #include "../h/seg.h"
 #include "../h/dir.h"
@@ -12,12 +13,22 @@
 #include "../h/vm.h"
 #include "../h/buf.h"
 #include "../h/text.h"
+#include "../h/vlimit.h"
+#include "../h/mtpr.h"
+#include "../h/clock.h"
+
+#include "dh.h"
+#include "dz.h"
 
 #define	SCHMAG	9/10
 
+/*
+ * Constant for decay filter for cpu usage.
+ */
+double	ccpu = 0.95122942450071400909;		/* exp(-1/20) */
 
 /*
- * clock is called straight from
+ * Clock is called straight from
  * the real time clock interrupt.
  *
  * Functions:
@@ -30,16 +41,23 @@
  *	jab the scheduler
  */
 #ifdef KPROF
-short	kcount[20000];
+unsigned short kcount[20000];
 #endif
 
+/*
+ * We handle regular calls to the dh and dz silo input processors
+ * without using timeouts to save a little time.
+ */
+int	rintvl = 0;		/* every 1/60'th of sec check receivers */
+int	rcnt;
+
 clock(pc, ps)
 caddr_t pc;
 {
 	register struct callo *p1, *p2;
 	register struct proc *pp;
 	register int s;
-	int a;
+	int a, cpstate, i;
 
 	/*
 	 * reprime clock
@@ -88,6 +106,31 @@ caddr_t pc;
 	 * and time of day
 	 */
 out:
+
+	/*
+	 * In order to not take input character interrupts to use
+	 * the input silo on DZ's we have to guarantee to echo
+	 * characters regularly.  This means that we have to
+	 * call the timer routines predictably.  Since blocking
+	 * in these routines is at spl5(), we have to make spl5()
+	 * really spl6() blocking off the clock to put this code
+	 * here.  Note also that it is critical that we run spl5()
+	 * (i.e. really spl6()) in the receiver interrupt routines
+	 * so we can't enter them recursively and transpose characters.
+	 */
+	if (rcnt >= rintvl) {
+#if NDH11 > 0
+		dhtimer();
+#endif
+#if NDZ11 > 0
+		dztimer();
+#endif
+		rcnt = 0;
+	} else
+		rcnt++;
+#ifdef CHAOS
+	ch_clock();
+#endif
 	if (!noproc) {
 		s = u.u_procp->p_rssize;
 		u.u_vm.vm_idsrss += s;
@@ -99,26 +142,36 @@ out:
 		}
 		if (s > u.u_vm.vm_maxrss)
 			u.u_vm.vm_maxrss = s;
+		if ((u.u_vm.vm_utime+u.u_vm.vm_stime+1)/HZ > u.u_limit[LIM_CPU]) {
+			psignal(u.u_procp, SIGXCPU);
+			if (u.u_limit[LIM_CPU] < INFINITY - 5)
+				u.u_limit[LIM_CPU] += 5;
+		}
 	}
-	a = dk_busy&07;
 	if (USERMODE(ps)) {
 		u.u_vm.vm_utime++;
 		if(u.u_procp->p_nice > NZERO)
-			a += 8;
+			cpstate = CP_NICE;
+		else
+			cpstate = CP_USER;
 	} else {
-		a += 16;
+		cpstate = CP_SYS;
 		if (noproc)
-			a += 8;
+			cpstate = CP_IDLE;
 		else
 			u.u_vm.vm_stime++;
 	}
-	dk_time[a]++;
+	cp_time[cpstate]++;
+	for (i = 0; i < DK_NDRIVE; i++)
+		if (dk_busy&(1<<i))
+			dk_time[i]++;
 	if (!noproc) {
 		pp = u.u_procp;
+		pp->p_cpticks++;
 		if(++pp->p_cpu == 0)
 			pp->p_cpu--;
 		if(pp->p_cpu % 16 == 0) {
-			VOID setpri(pp);
+			(void) setpri(pp);
 			if (pp->p_pri >= PUSER)
 				pp->p_pri = pp->p_usrpri;
 		}
@@ -129,41 +182,63 @@ out:
 		runrun++;
 	}
 	if (lbolt >= HZ) {
+#if VAX==780
+		extern int hangcnt;
+#endif
+
 		if (BASEPRI(ps))
 			return;
 		lbolt -= HZ;
 		++time;
-		VOID spl1();
+		(void) spl1();
+#if VAX==780
+		/*
+		 * machdep.c:unhang uses hangcnt to make sure uba
+		 * doesn't forget to interrupt (this has been observed).
+		 * This prevents an accumulation of < 5 second uba failures
+		 * from summing to a uba reset.
+		 */
+		if (hangcnt)
+			hangcnt--;
+#endif
 		runrun++;
 		wakeup((caddr_t)&lbolt);
 		for(pp = &proc[0]; pp < &proc[NPROC]; pp++)
-		if (pp->p_stat && pp->p_stat<SZOMB) {
+		if (pp->p_stat && pp->p_stat!=SZOMB) {
 			if(pp->p_time != 127)
 				pp->p_time++;
 			if(pp->p_clktim)
 				if(--pp->p_clktim == 0)
 					if (pp->p_flag & STIMO) {
 						s = spl6();
-						if (pp->p_stat == SSLEEP)
+						switch (pp->p_stat) {
+
+						case SSLEEP:
 							setrun(pp);
+							break;
+
+						case SSTOP:
+							unsleep(pp);
+							break;
+						}
 						pp->p_flag &= ~STIMO;
 						splx(s);
 					} else
-						psignal(pp, SIGCLK);
+						psignal(pp, SIGALRM);
 			if(pp->p_stat==SSLEEP||pp->p_stat==SSTOP)
 				if (pp->p_slptime != 127)
 					pp->p_slptime++;
-			if(pp->p_flag&SLOAD) {
-				ave(pp->p_aveflt, pp->p_faults, 5);
-				pp->p_faults = 0;
-			}
+			if (pp->p_flag&SLOAD)
+				pp->p_pctcpu = ccpu * pp->p_pctcpu +
+				    (1.0 - ccpu) * (pp->p_cpticks/(float)HZ);
+			pp->p_cpticks = 0;
 			a = (pp->p_cpu & 0377)*SCHMAG + pp->p_nice - NZERO;
 			if(a < 0)
 				a = 0;
 			if(a > 255)
 				a = 255;
 			pp->p_cpu = a;
-			VOID setpri(pp);
+			(void) setpri(pp);
 			s = spl6();
 			if(pp->p_pri >= PUSER) {
 				if ((pp != u.u_procp || noproc) &&
@@ -192,17 +267,19 @@ out:
 		 */
 		if (bclnlist != NULL)
 			wakeup((caddr_t)&proc[2]);
-#ifdef ERNIE
 		if (USERMODE(ps)) {
 			pp = u.u_procp;
 			if (pp->p_uid)
 				if (pp->p_nice == NZERO && u.u_vm.vm_utime > 600 * HZ)
 					pp->p_nice = NZERO+4;
-			VOID setpri(pp);
+			(void) setpri(pp);
 			pp->p_pri = pp->p_usrpri;
 		}
-#endif
 	}
+#if VAX==780
+	if (!BASEPRI(ps))
+		unhang();
+#endif
 	if (USERMODE(ps)) {
 		/*
 		 * We do this last since it
@@ -213,10 +290,11 @@ out:
 	}
 #ifdef KPROF
 	else if (!noproc) {
-		register int indx = ((int)pc & 0x7fffffff) / 8;
+		register int indx = ((int)pc & 0x7fffffff) / 4;
 
 		if (indx >= 0 && indx < 20000)
-			kcount[indx]++;
+			if (++kcount[indx] == 0)
+				--kcount[indx];
 	}
 #endif
 }