add memory filesystem initialization

[unix-history] / 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 4d7f9d4..c8dfcce 100644 (file)
--- a/usr/src/sys/kern/kern_clock.c
+++ b/usr/src/sys/kern/kern_clock.c
@@ -1,325 +1,445 @@
-/*     %H%     3.18    kern_clock.c    */
+/*
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ *
+ *     @(#)kern_clock.c        7.5 (Berkeley) %G%
+ */
+
+#include "param.h"
+#include "systm.h"
+#include "dkstat.h"
+#include "callout.h"
+#include "user.h"
+#include "kernel.h"
+#include "proc.h"
+#include "vm.h"
+#include "text.h"

 
 

-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/dk.h"
-#include "../h/callo.h"
-#include "../h/seg.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/proc.h"
-#include "../h/reg.h"
-#include "../h/psl.h"
-#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 "machine/reg.h"
+#include "machine/psl.h"

 
 

-#define        SCHMAG  9/10
+#if defined(vax) || defined(tahoe)
+#include "machine/mtpr.h"
+#include "machine/clock.h"
+#endif
+
+#ifdef GPROF
+#include "gprof.h"
+#endif

 
 

+#define ADJTIME                /* For now... */
+#define        ADJ_TICK 1000
+int    adjtimedelta;

 
 /*
 
 /*

- * clock is called straight from
- * the real time clock interrupt.
+ * Clock handling routines.

  *
  *

- * Functions:
- *     implement callouts
- *     maintain user/system times
- *     maintain date
- *     profile
- *     lightning bolt wakeup (every second)
- *     alarm clock signals
- *     jab the scheduler
+ * This code is written to operate with two timers which run
+ * independently of each other. The main clock, running at hz
+ * times per second, is used to do scheduling and timeout calculations.
+ * The second timer does resource utilization estimation statistically
+ * based on the state of the machine phz times a second. Both functions
+ * can be performed by a single clock (ie hz == phz), however the 
+ * statistics will be much more prone to errors. Ideally a machine
+ * would have separate clocks measuring time spent in user state, system
+ * state, interrupt state, and idle state. These clocks would allow a non-
+ * approximate measure of resource utilization.

  */
  */

-#ifdef KPROF
-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.
+ * TODO:
+ *     time of day, system/user timing, timeouts, profiling on separate timers
+ *     allocate more timeout table slots when table overflows.

  */
  */

-int    rintvl = 0;             /* every 1/60'th of sec check receivers */
-int    rcnt;

 
 

-clock(pc, ps)
-caddr_t pc;
+/*
+ * Bump a timeval by a small number of usec's.
+ */
+#define BUMPTIME(t, usec) { \
+       register struct timeval *tp = (t); \
+ \
+       tp->tv_usec += (usec); \
+       if (tp->tv_usec >= 1000000) { \
+               tp->tv_usec -= 1000000; \
+               tp->tv_sec++; \
+       } \
+}
+
+/*
+ * The hz hardware interval timer.
+ * We update the events relating to real time.
+ * If this timer is also being used to gather statistics,
+ * we run through the statistics gathering routine as well.
+ */
+/*ARGSUSED*/
+hardclock(pc, ps)
+       caddr_t pc;
+       int ps;

 {
 {

-       register struct callo *p1, *p2;
-       register struct proc *pp;
+       register struct callout *p1;
+       register struct proc *p;

        register int s;
        register int s;

-       int a, cpstate;

 
        /*
 
        /*

-        * reprime clock
+        * Update real-time timeout queue.
+        * At front of queue are some number of events which are ``due''.
+        * The time to these is <= 0 and if negative represents the
+        * number of ticks which have passed since it was supposed to happen.
+        * The rest of the q elements (times > 0) are events yet to happen,
+        * where the time for each is given as a delta from the previous.
+        * Decrementing just the first of these serves to decrement the time
+        * to all events.

         */
         */

-       clkreld();
+       p1 = calltodo.c_next;
+       while (p1) {
+               if (--p1->c_time > 0)
+                       break;
+               if (p1->c_time == 0)
+                       break;
+               p1 = p1->c_next;
+       }

 
        /*
 
        /*

-        * callouts
-        * else update first non-zero time
+        * Charge the time out based on the mode the cpu is in.
+        * Here again we fudge for the lack of proper interval timers
+        * assuming that the current state has been around at least
+        * one tick.

         */
         */

-
-       if(callout[0].c_func == NULL)
-               goto out;
-       p2 = &callout[0];
-       while(p2->c_time<=0 && p2->c_func!=NULL)
-               p2++;
-       p2->c_time--;
+       if (USERMODE(ps)) {
+               /*
+                * CPU was in user state.  Increment
+                * user time counter, and process process-virtual time
+                * interval timer. 
+                */
+               BUMPTIME(&u.u_ru.ru_utime, tick);
+               if (timerisset(&u.u_timer[ITIMER_VIRTUAL].it_value) &&
+                   itimerdecr(&u.u_timer[ITIMER_VIRTUAL], tick) == 0)
+                       psignal(u.u_procp, SIGVTALRM);
+       } else {
+               /*
+                * CPU was in system state.
+                */
+               if (!noproc)
+                       BUMPTIME(&u.u_ru.ru_stime, tick);
+       }

 
        /*
 
        /*

-        * if ps is high, just return
+        * If the cpu is currently scheduled to a process, then
+        * charge it with resource utilization for a tick, updating
+        * statistics which run in (user+system) virtual time,
+        * such as the cpu time limit and profiling timers.
+        * This assumes that the current process has been running
+        * the entire last tick.

         */
         */

-       if (BASEPRI(ps))
-               goto out;
+       if (noproc == 0) {
+               if ((u.u_ru.ru_utime.tv_sec+u.u_ru.ru_stime.tv_sec+1) >
+                   u.u_rlimit[RLIMIT_CPU].rlim_cur) {
+                       psignal(u.u_procp, SIGXCPU);
+                       if (u.u_rlimit[RLIMIT_CPU].rlim_cur <
+                           u.u_rlimit[RLIMIT_CPU].rlim_max)
+                               u.u_rlimit[RLIMIT_CPU].rlim_cur += 5;
+               }
+               if (timerisset(&u.u_timer[ITIMER_PROF].it_value) &&
+                   itimerdecr(&u.u_timer[ITIMER_PROF], tick) == 0)
+                       psignal(u.u_procp, SIGPROF);
+               s = u.u_procp->p_rssize;
+               u.u_ru.ru_idrss += s;
+#ifdef notdef
+               u.u_ru.ru_isrss += 0;           /* XXX (haven't got this) */
+#endif
+               if (u.u_procp->p_textp) {
+                       register int xrss = u.u_procp->p_textp->x_rssize;
+
+                       s += xrss;
+                       u.u_ru.ru_ixrss += xrss;
+               }
+               if (s > u.u_ru.ru_maxrss)
+                       u.u_ru.ru_maxrss = s;
+       }

 
        /*
 
        /*

-        * callout
+        * We adjust the priority of the current process.
+        * The priority of a process gets worse as it accumulates
+        * CPU time.  The cpu usage estimator (p_cpu) is increased here
+        * and the formula for computing priorities (in kern_synch.c)
+        * will compute a different value each time the p_cpu increases
+        * by 4.  The cpu usage estimator ramps up quite quickly when
+        * the process is running (linearly), and decays away exponentially,
+        * at a rate which is proportionally slower when the system is
+        * busy.  The basic principal is that the system will 90% forget
+        * that a process used a lot of CPU time in 5*loadav seconds.
+        * This causes the system to favor processes which haven't run
+        * much recently, and to round-robin among other processes.

         */
         */

-
-       if(callout[0].c_time <= 0) {
-               p1 = &callout[0];
-               while(p1->c_func != 0 && p1->c_time <= 0) {
-                       (*p1->c_func)(p1->c_arg);
-                       p1++;
-               }
-               p2 = &callout[0];
-               while(p2->c_func = p1->c_func) {
-                       p2->c_time = p1->c_time;
-                       p2->c_arg = p1->c_arg;
-                       p1++;
-                       p2++;
+       if (!noproc) {
+               p = u.u_procp;
+               p->p_cpticks++;
+               if (++p->p_cpu == 0)
+                       p->p_cpu--;
+               if ((p->p_cpu&3) == 0) {
+                       (void) setpri(p);
+                       if (p->p_pri >= PUSER)
+                               p->p_pri = p->p_usrpri;

                }
        }
 
        /*
                }
        }
 
        /*

-        * lightning bolt time-out
-        * and time of day
+        * If the alternate clock has not made itself known then
+        * we must gather the statistics.

         */
         */

-out:
+       if (phz == 0)
+               gatherstats(pc, ps);

 
        /*
 
        /*

-        * 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.
+        * Increment the time-of-day, and schedule
+        * processing of the callouts at a very low cpu priority,
+        * so we don't keep the relatively high clock interrupt
+        * priority any longer than necessary.

         */
         */

-       if (rcnt >= rintvl) {
-               dhtimer();
-               dztimer();
-               rcnt = 0;
-       } else
-               rcnt++;
-       if (!noproc) {
-               s = u.u_procp->p_rssize;
-               u.u_vm.vm_idsrss += s;
-               if (u.u_procp->p_textp) {
-                       register int xrss = u.u_procp->p_textp->x_rssize;
-
-                       s += xrss;
-                       u.u_vm.vm_ixrss += xrss;
+#ifdef ADJTIME
+       if (adjtimedelta == 0)
+               bumptime(&time, tick);
+       else {
+               if (adjtimedelta < 0) {
+                       bumptime(&time, tick-ADJ_TICK);
+                       adjtimedelta++;
+               } else {
+                       bumptime(&time, tick+ADJ_TICK);
+                       adjtimedelta--;

                }
                }

-               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;
+       }
+#else
+       if (timedelta == 0)
+               BUMPTIME(&time, tick)
+       else {
+               register delta;
+
+               if (timedelta < 0) {
+                       delta = tick - tickdelta;
+                       timedelta += tickdelta;
+               } else {
+                       delta = tick + tickdelta;
+                       timedelta -= tickdelta;

                }
                }

+               BUMPTIME(&time, delta);

        }
        }

+#endif
+       setsoftclock();
+}
+
+int    dk_ndrive = DK_NDRIVE;
+/*
+ * Gather statistics on resource utilization.
+ *
+ * We make a gross assumption: that the system has been in the
+ * state it is in (user state, kernel state, interrupt state,
+ * or idle state) for the entire last time interval, and
+ * update statistics accordingly.
+ */
+/*ARGSUSED*/
+gatherstats(pc, ps)
+       caddr_t pc;
+       int ps;
+{
+       register int cpstate, s;
+
+       /*
+        * Determine what state the cpu is in.
+        */

        if (USERMODE(ps)) {
        if (USERMODE(ps)) {

-               u.u_vm.vm_utime++;
-               if(u.u_procp->p_nice > NZERO)
+               /*
+                * CPU was in user state.
+                */
+               if (u.u_procp->p_nice > NZERO)

                        cpstate = CP_NICE;
                else
                        cpstate = CP_USER;
        } else {
                        cpstate = CP_NICE;
                else
                        cpstate = CP_USER;
        } else {

+               /*
+                * CPU was in system state.  If profiling kernel
+                * increment a counter.  If no process is running
+                * then this is a system tick if we were running
+                * at a non-zero IPL (in a driver).  If a process is running,
+                * then we charge it with system time even if we were
+                * at a non-zero IPL, since the system often runs
+                * this way during processing of system calls.
+                * This is approximate, but the lack of true interval
+                * timers makes doing anything else difficult.
+                */

                cpstate = CP_SYS;
                cpstate = CP_SYS;

-               if (noproc)
+               if (noproc && BASEPRI(ps))

                        cpstate = CP_IDLE;
                        cpstate = CP_IDLE;

-               else
-                       u.u_vm.vm_stime++;
-       }
-       dk_time[cpstate][dk_busy&(DK_NSTATES-1)]++;
-       if (!noproc) {
-               pp = u.u_procp;
-               if(++pp->p_cpu == 0)
-                       pp->p_cpu--;
-               if(pp->p_cpu % 16 == 0) {
-                       (void) setpri(pp);
-                       if (pp->p_pri >= PUSER)
-                               pp->p_pri = pp->p_usrpri;
-               }
-       }
-       ++lbolt;
-       if (lbolt % (HZ/4) == 0) {
-               vmpago();
-               runrun++;
+#ifdef GPROF
+               s = pc - s_lowpc;
+               if (profiling < 2 && s < s_textsize)
+                       kcount[s / (HISTFRACTION * sizeof (*kcount))]++;
+#endif

        }
        }

-       if (lbolt >= HZ) {
-               extern int hangcnt;
+       /*
+        * We maintain statistics shown by user-level statistics
+        * programs:  the amount of time in each cpu state, and
+        * the amount of time each of DK_NDRIVE ``drives'' is busy.
+        */
+       cp_time[cpstate]++;
+       for (s = 0; s < DK_NDRIVE; s++)
+               if (dk_busy&(1<<s))
+                       dk_time[s]++;
+}

 
 

-               if (BASEPRI(ps))
-                       return;
-               lbolt -= HZ;
-               ++time;
-               (void) spl1();
-               /*
-                * 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--;
-               runrun++;
-               wakeup((caddr_t)&lbolt);
-               for(pp = &proc[0]; pp < &proc[NPROC]; pp++)
-               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();
-                                               switch (pp->p_stat) {
+/*
+ * Software priority level clock interrupt.
+ * Run periodic events from timeout queue.
+ */
+/*ARGSUSED*/
+softclock(pc, ps)
+       caddr_t pc;
+       int ps;
+{

 
 

-                                               case SSLEEP:
-                                                       setrun(pp);
-                                                       break;
+       for (;;) {
+               register struct callout *p1;
+               register caddr_t arg;
+               register int (*func)();
+               register int a, s;

 
 

-                                               case SSTOP:
-                                                       unsleep(pp);
-                                                       break;
-                                               }
-                                               pp->p_flag &= ~STIMO;
-                                               splx(s);
-                                       } else
-                                               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;
-                       }
-                       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);
-                       s = spl6();
-                       if(pp->p_pri >= PUSER) {
-                               if ((pp != u.u_procp || noproc) &&
-                                   pp->p_stat == SRUN &&
-                                   (pp->p_flag & SLOAD) &&
-                                   pp->p_pri != pp->p_usrpri) {
-                                       remrq(pp);
-                                       pp->p_pri = pp->p_usrpri;
-                                       setrq(pp);
-                               } else
-                                       pp->p_pri = pp->p_usrpri;
-                       }
+               s = splhigh();
+               if ((p1 = calltodo.c_next) == 0 || p1->c_time > 0) {

                        splx(s);
                        splx(s);

+                       break;

                }
                }

-               vmmeter();
-               if(runin!=0) {
-                       runin = 0;
-                       wakeup((caddr_t)&runin);
-               }
-               /*
-                * If there are pages that have been cleaned, 
-                * jolt the pageout daemon to process them.
-                * We do this here so that these pages will be
-                * freed if there is an abundance of memory and the
-                * daemon would not be awakened otherwise.
-                */
-               if (bclnlist != NULL)
-                       wakeup((caddr_t)&proc[2]);
-               if (USERMODE(ps)) {
-                       pp = u.u_procp;
-#ifdef ERNIE
-                       if (pp->p_uid)
-                               if (pp->p_nice == NZERO && u.u_vm.vm_utime > 600 * HZ)
-                                       pp->p_nice = NZERO+4;
-                       (void) setpri(pp);
-                       pp->p_pri = pp->p_usrpri;
-#endif
-               }
+               arg = p1->c_arg; func = p1->c_func; a = p1->c_time;
+               calltodo.c_next = p1->c_next;
+               p1->c_next = callfree;
+               callfree = p1;
+               splx(s);
+               (*func)(arg, a);

        }
        }

-       if (!BASEPRI(ps))
-               unhang();
+       /*
+        * If trapped user-mode and profiling, give it
+        * a profiling tick.
+        */

        if (USERMODE(ps)) {
        if (USERMODE(ps)) {

+               register struct proc *p = u.u_procp;
+
+               if (u.u_prof.pr_scale) {
+                       p->p_flag |= SOWEUPC;
+                       aston();
+               }

                /*
                /*

-                * We do this last since it
-                * may block on a page fault in user space.
+                * Check to see if process has accumulated
+                * more than 10 minutes of user time.  If so
+                * reduce priority to give others a chance.

                 */
                 */

-               if (u.u_prof.pr_scale)
-                       addupc(pc, &u.u_prof, 1);
+               if (p->p_uid && p->p_nice == NZERO &&
+                   u.u_ru.ru_utime.tv_sec > 10 * 60) {
+                       p->p_nice = NZERO+4;
+                       (void) setpri(p);
+                       p->p_pri = p->p_usrpri;
+               }

        }
        }

-#ifdef KPROF
-       else if (!noproc) {
-               register int indx = ((int)pc & 0x7fffffff) / 4;
+}

 
 

-               if (indx >= 0 && indx < 20000)
-                       if (++kcount[indx] == 0)
-                               --kcount[indx];
-       }
-#endif
+/*
+ * Arrange that (*fun)(arg) is called in t/hz seconds.
+ */
+timeout(fun, arg, t)
+       int (*fun)();
+       caddr_t arg;
+       register int t;
+{
+       register struct callout *p1, *p2, *pnew;
+       register int s = splhigh();
+
+       if (t <= 0)
+               t = 1;
+       pnew = callfree;
+       if (pnew == NULL)
+               panic("timeout table overflow");
+       callfree = pnew->c_next;
+       pnew->c_arg = arg;
+       pnew->c_func = fun;
+       for (p1 = &calltodo; (p2 = p1->c_next) && p2->c_time < t; p1 = p2)
+               if (p2->c_time > 0)
+                       t -= p2->c_time;
+       p1->c_next = pnew;
+       pnew->c_next = p2;
+       pnew->c_time = t;
+       if (p2)
+               p2->c_time -= t;
+       splx(s);

 }
 
 /*
 }
 
 /*

- * timeout is called to arrange that
- * fun(arg) is called in tim/HZ seconds.
- * An entry is sorted into the callout
- * structure. The time in each structure
- * entry is the number of HZ's more
- * than the previous entry.
- * In this way, decrementing the
- * first entry has the effect of
- * updating all entries.
- *
- * The panic is there because there is nothing
- * intelligent to be done if an entry won't fit.
+ * untimeout is called to remove a function timeout call
+ * from the callout structure.

  */
  */

-timeout(fun, arg, tim)
-int (*fun)();
-caddr_t arg;
+untimeout(fun, arg)
+       int (*fun)();
+       caddr_t arg;

 {
 {

-       register struct callo *p1, *p2;
-       register int t;
-       int s;
+       register struct callout *p1, *p2;
+       register int s;

 
 

-       t = tim;
-       p1 = &callout[0];
-       s = spl7();
-       while(p1->c_func != 0 && p1->c_time <= t) {
-               t -= p1->c_time;
-               p1++;
-       }
-       if (p1 >= &callout[NCALL-1])
-               panic("Timeout table overflow");
-       p1->c_time -= t;
-       p2 = p1;
-       while(p2->c_func != 0)
-               p2++;
-       while(p2 >= p1) {
-               (p2+1)->c_time = p2->c_time;
-               (p2+1)->c_func = p2->c_func;
-               (p2+1)->c_arg = p2->c_arg;
-               p2--;
+       s = splhigh();
+       for (p1 = &calltodo; (p2 = p1->c_next) != 0; p1 = p2) {
+               if (p2->c_func == fun && p2->c_arg == arg) {
+                       if (p2->c_next && p2->c_time > 0)
+                               p2->c_next->c_time += p2->c_time;
+                       p1->c_next = p2->c_next;
+                       p2->c_next = callfree;
+                       callfree = p2;
+                       break;
+               }

        }
        }

-       p1->c_time = t;
-       p1->c_func = fun;
-       p1->c_arg = arg;

        splx(s);
 }
        splx(s);
 }

+
+/*
+ * Compute number of hz until specified time.
+ * Used to compute third argument to timeout() from an
+ * absolute time.
+ */
+hzto(tv)
+       struct timeval *tv;
+{
+       register long ticks;
+       register long sec;
+       int s = splhigh();
+
+       /*
+        * If number of milliseconds will fit in 32 bit arithmetic,
+        * then compute number of milliseconds to time and scale to
+        * ticks.  Otherwise just compute number of hz in time, rounding
+        * times greater than representible to maximum value.
+        *
+        * Delta times less than 25 days can be computed ``exactly''.
+        * Maximum value for any timeout in 10ms ticks is 250 days.
+        */
+       sec = tv->tv_sec - time.tv_sec;
+       if (sec <= 0x7fffffff / 1000 - 1000)
+               ticks = ((tv->tv_sec - time.tv_sec) * 1000 +
+                       (tv->tv_usec - time.tv_usec) / 1000) / (tick / 1000);
+       else if (sec <= 0x7fffffff / hz)
+               ticks = sec * hz;
+       else
+               ticks = 0x7fffffff;
+       splx(s);
+       return (ticks);
+}
+
+profil()
+{
+       register struct a {
+               short   *bufbase;
+               unsigned bufsize;
+               unsigned pcoffset;
+               unsigned pcscale;
+       } *uap = (struct a *)u.u_ap;
+       register struct uprof *upp = &u.u_prof;
+
+       upp->pr_base = uap->bufbase;
+       upp->pr_size = uap->bufsize;
+       upp->pr_off = uap->pcoffset;
+       upp->pr_scale = uap->pcscale;
+}