update from Rick Macklem to generate proper error messages

[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 db8cb4a..c8dfcce 100644 (file)
--- a/usr/src/sys/kern/kern_clock.c
+++ b/usr/src/sys/kern/kern_clock.c
@@ -1,109 +1,153 @@
-/*     kern_clock.c    4.37    82/09/04        */
+/*
+ * 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 "../h/param.h"
-#include "../h/systm.h"
-#include "../h/dk.h"
-#include "../h/callout.h"
-#include "../h/seg.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/kernel.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/mtpr.h"
-#include "../h/cpu.h"
-#include "../h/protosw.h"
-#include "../h/socket.h"
-#include "../net/if.h"
-#ifdef MUSH
-#include "../h/quota.h"
-#include "../h/share.h"
+#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 "machine/reg.h"
+#include "machine/psl.h"
+
+#if defined(vax) || defined(tahoe)
+#include "machine/mtpr.h"
+#include "machine/clock.h"

 #endif
 
 #endif
 

-#include "bk.h"
-#include "dh.h"
-#include "dz.h"
-#include "ps.h"
+#ifdef GPROF
+#include "gprof.h"
+#endif
+
+#define ADJTIME                /* For now... */
+#define        ADJ_TICK 1000
+int    adjtimedelta;

 
 /*
 
 /*

- * Hardclock is called straight from
- * the real time clock interrupt.
- * We limit the work we do at real clock interrupt time to:
- *     reloading clock
- *     decrementing time to callouts
- *     recording cpu time usage
- *     modifying priority of current process
- *     arrange for soft clock interrupt
- *     kernel pc profiling
- *
- * At software (softclock) interrupt time we:
- *     implement callouts
- *     maintain date
- *     lightning bolt wakeup (every second)
- *     alarm clock signals
- *     jab the scheduler
+ * Clock handling routines.

  *
  *

- * On the vax softclock interrupts are implemented by
- * software interrupts.  Note that we may have multiple softclock
- * interrupts compressed into one (due to excessive interrupt load),
- * but that hardclock interrupts should never be lost.
+ * 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.
+ */
+
+/*
+ * TODO:
+ *     time of day, system/user timing, timeouts, profiling on separate timers
+ *     allocate more timeout table slots when table overflows.

  */
  */

-#ifdef GPROF
-extern int profiling;
-extern char *s_lowpc;
-extern u_long s_textsize;
-extern u_short *kcount;
-#endif

 
 /*
 
 /*

- * Protoslow is like lbolt, but for slow protocol timeouts, counting
- * up to (hz/PR_SLOWHZ), then causing a pfslowtimo().
- * Protofast is like lbolt, but for fast protocol timeouts, counting
- * up to (hz/PR_FASTHZ), then causing a pffasttimo().
+ * Bump a timeval by a small number of usec's.

  */
  */

-int    protoslow;
-int    protofast;
-int    ifnetslow;
+#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;
 /*ARGSUSED*/
 hardclock(pc, ps)
        caddr_t pc;

+       int ps;

 {
        register struct callout *p1;
 {
        register struct callout *p1;

-       register struct proc *pp;
-       register int s, cpstate;
-       extern double avenrun[];
-
-       /*
-        * reprime clock
-        */
+       register struct proc *p;
+       register int s;

 
 

-#if NPS > 0

        /*
        /*

-        * sync referesh of picture system
+        * 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.

         */
         */

-       psextsync(pc, ps);
-#endif
+       p1 = calltodo.c_next;
+       while (p1) {
+               if (--p1->c_time > 0)
+                       break;
+               if (p1->c_time == 0)
+                       break;
+               p1 = p1->c_next;
+       }

 
        /*
 
        /*

-        * update callout times
+        * 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.

         */
         */

-       for (p1 = calltodo.c_next; p1 && p1->c_time <= 0; p1 = p1->c_next)
-               ;
-       if (p1)
-               p1->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);
+       }

 
        /*
 
        /*

-        * Maintain iostat and per-process cpu statistics
+        * 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 (!noproc) {
+       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;
                s = u.u_procp->p_rssize;
                u.u_ru.ru_idrss += s;

-               u.u_ru.ru_isrss += 0;           /* XXX */
+#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;
 
                if (u.u_procp->p_textp) {
                        register int xrss = u.u_procp->p_textp->x_rssize;
 


@@ -112,458 +156,203 @@ hardclock(pc, ps)
                }
                if (s > u.u_ru.ru_maxrss)
                        u.u_ru.ru_maxrss = s;
                }
                if (s > u.u_ru.ru_maxrss)
                        u.u_ru.ru_maxrss = s;

-               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;
-               }
-       }
-       /*
-        * Update iostat information.
-        */
-       if (USERMODE(ps)) {
-               u.u_ru.ru_utime.tv_usec += 1000000/hz;
-               if (u.u_ru.ru_utime.tv_usec > 1000000) {
-                       u.u_ru.ru_utime.tv_sec++;
-                       u.u_ru.ru_utime.tv_usec -= 1000000;
-               }
-               if (u.u_procp->p_nice > NZERO)
-                       cpstate = CP_NICE;
-               else
-                       cpstate = CP_USER;
-       } else {
-#ifdef GPROF
-               int k = pc - s_lowpc;
-               if (profiling < 2 && k < s_textsize)
-                       kcount[k / sizeof (*kcount)]++;
-#endif
-               cpstate = CP_SYS;
-               if (noproc) {
-                       if ((ps&PSL_IPL) != 0)
-                               cpstate = CP_IDLE;
-               } else {
-                       u.u_ru.ru_stime.tv_usec += 1000000/hz;
-                       if (u.u_ru.ru_stime.tv_usec > 1000000) {
-                               u.u_ru.ru_stime.tv_sec++;
-                               u.u_ru.ru_stime.tv_usec -= 1000000;
-                       }
-               }

        }
        }

-       cp_time[cpstate]++;
-       for (s = 0; s < DK_NDRIVE; s++)
-               if (dk_busy&(1<<s))
-                       dk_time[s]++;
+

        /*
        /*

-        * Adjust priority of current process.
+        * 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 (!noproc) {
         */
        if (!noproc) {

-               pp = u.u_procp;
-               pp->p_cpticks++;
-               if(++pp->p_cpu == 0)
-                       pp->p_cpu--;
-#ifdef MUSH
-               pp->p_quota->q_cost += (pp->p_nice > NZERO ?
-                   (shconsts.sc_tic * ((2*NZERO)-pp->p_nice)) / NZERO :
-                   shconsts.sc_tic) * (((int)avenrun[0]+2)/3);
-#endif
-               if(pp->p_cpu % 4 == 0) {
-                       (void) setpri(pp);
-                       if (pp->p_pri >= PUSER)
-                               pp->p_pri = pp->p_usrpri;
+               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;

                }
        }
                }
        }

-       /*
-        * Time moves on.
-        */
-       ++lbolt;

 
        /*
 
        /*

-        * Time moves on for protocols.
+        * If the alternate clock has not made itself known then
+        * we must gather the statistics.

         */
         */

-       --protoslow; --protofast; --ifnetslow;
+       if (phz == 0)
+               gatherstats(pc, ps);

 
 

-#if VAX780

        /*
        /*

-        * On 780's, impelement a fast UBA watcher,
-        * to make sure uba's don't get stuck.
+        * 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 (cpu == VAX_780 && panicstr == 0 && !BASEPRI(ps))
-               unhang();
+#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--;
+               }
+       }
+#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
 #endif

-       /*
-        * Schedule a software interrupt for the rest
-        * of clock activities.
-        */

        setsoftclock();
 }
 
        setsoftclock();
 }
 

+int    dk_ndrive = DK_NDRIVE;

 /*
 /*

- * The digital decay cpu usage priority assignment is scaled to run in
- * time as expanded by the 1 minute load average.  Each second we
- * multiply the the previous cpu usage estimate by
- *             nrscale*avenrun[0]
- * The following relates the load average to the period over which
- * cpu usage is 90% forgotten:
- *     loadav 1         5 seconds
- *     loadav 5        24 seconds
- *     loadav 10       47 seconds
- *     loadav 20       93 seconds
- * This is a great improvement on the previous algorithm which
- * decayed the priorities by a constant, and decayed away all knowledge
- * of previous activity in about 20 seconds.  Under heavy load,
- * the previous algorithm degenerated to round-robin with poor response
- * time when there was a high load average.
- */
-#undef ave
-#define        ave(a,b) ((int)(((int)(a*b))/(b+1)))
-int    nrscale = 2;
-double avenrun[];
-
-/*
- * Constant for decay filter for cpu usage field
- * in process table (used by ps au).
- */
-double ccpu = 0.95122942450071400909;          /* exp(-1/20) */
-
-#ifdef MELB
-/*
- * Automatic niceness rate & max constants
- */
-#define        MAXNICE (8 + NZERO)     /* maximum auto nice value */
-#define        NFACT   (40 * hz)       /* nice++ every 40 secs cpu+sys time */
-#endif
-
-/*
- * Software clock interrupt.
- * This routine runs at lower priority than device interrupts.
+ * 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*/
  */
 /*ARGSUSED*/

-softclock(pc, ps)
+gatherstats(pc, ps)

        caddr_t pc;
        caddr_t pc;

+       int ps;

 {
 {

-       register struct callout *p1;
-       register struct proc *pp;
-       register int a, s;
-       caddr_t arg;
-       int (*func)();
-
-       /*
-        * Perform callouts (but not after panic's!)
-        */
-       if (panicstr == 0) {
-               for (;;) {
-                       s = spl7();
-                       if ((p1 = calltodo.c_next) == 0 || p1->c_time > 0) {
-                               splx(s);
-                               break;
-                       }
-                       calltodo.c_next = p1->c_next;
-                       arg = p1->c_arg;
-                       func = p1->c_func;
-                       p1->c_next = callfree;
-                       callfree = p1;
-                       (void) splx(s);
-                       (*func)(arg);
-               }
-       }
+       register int cpstate, s;

 
        /*
 
        /*

-        * Drain silos.
+        * Determine what state the cpu is in.

         */
         */

-#if NDH > 0
-       s = spl5(); dhtimer(); splx(s);
-#endif
-#if NDZ > 0
-       s = spl5(); dztimer(); splx(s);
-#endif
-
-       /*
-        * If idling and processes are waiting to swap in,
-        * check on them.
-        */
-       if (noproc && runin) {
-               runin = 0;
-               wakeup((caddr_t)&runin);
-       }
-
-       /*
-        * Run paging daemon every 1/4 sec.
-        */
-       if (lbolt % (hz/4) == 0) {
-               vmpago();
-       }
-
-       /*
-        * Reschedule every 1/10 sec.
-        */
-       if (lbolt % (hz/10) == 0) {
-               runrun++;
-               aston();
-       }
-
-       /*
-        * Run network slow and fast timeouts.
-        */
-       if (protofast <= 0) {
-               protofast = hz / PR_FASTHZ;
-               pffasttimo();
-       }
-       if (protoslow <= 0) {
-               protoslow = hz / PR_SLOWHZ;
-               pfslowtimo();
-       }
-       if (ifnetslow <= 0) {
-               ifnetslow = hz / IFNET_SLOWHZ;
-               if_slowtimo();
-       }
-
-       /*
-        * Lightning bolt every second:
-        *      sleep timeouts
-        *      process priority recomputation
-        *      process %cpu averaging
-        *      virtual memory metering
-        *      kick swapper if processes want in
-        */
-       if (lbolt >= hz) {
-               /*
-                * This doesn't mean much on VAX since we run at
-                * software interrupt time... if hardclock()
-                * calls softclock() directly, it prevents
-                * this code from running when the priority
-                * was raised when the clock interrupt occurred.
-                */
-               if (BASEPRI(ps))
-                       return;
-
-               /*
-                * If we didn't run a few times because of
-                * long blockage at high ipl, we don't
-                * really want to run this code several times,
-                * so squish out all multiples of hz here.
-                */
-               s = spl6();
-               time.tv_sec += lbolt / hz; lbolt %= hz;
-               splx(s);
-
+       if (USERMODE(ps)) {

                /*
                /*

-                * Wakeup lightning bolt sleepers.
-                * Processes sleep on lbolt to wait
-                * for short amounts of time (e.g. 1 second).
+                * CPU was in user state.

                 */
                 */

-               wakeup((caddr_t)&lbolt);
-
+               if (u.u_procp->p_nice > NZERO)
+                       cpstate = CP_NICE;
+               else
+                       cpstate = CP_USER;
+       } else {

                /*
                /*

-                * Recompute process priority and process
-                * sleep() system calls as well as internal
-                * sleeps with timeouts (tsleep() kernel routine).
+                * 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.

                 */
                 */

-               for (pp = proc; pp < procNPROC; pp++)
-               if (pp->p_stat && pp->p_stat!=SZOMB) {
-#ifdef MUSH
-                       /*
-                        * Charge process for memory in use
-                        */
-                       if (pp->p_quota->q_uid)
-                               pp->p_quota->q_cost +=
-                                   shconsts.sc_click * pp->p_rssize;
+               cpstate = CP_SYS;
+               if (noproc && BASEPRI(ps))
+                       cpstate = CP_IDLE;
+#ifdef GPROF
+               s = pc - s_lowpc;
+               if (profiling < 2 && s < s_textsize)
+                       kcount[s / (HISTFRACTION * sizeof (*kcount))]++;

 #endif
 #endif

-                       /*
-                        * Increase resident time, to max of 127 seconds
-                        * (it is kept in a character.)  For
-                        * loaded processes this is time in core; for
-                        * swapped processes, this is time on drum.
-                        */
-                       if (pp->p_time != 127)
-                               pp->p_time++;
-                       /*
-                        * Time processes out of select.
-                        */
-                       if (timerisset(&pp->p_seltimer) &&
-                            --pp->p_seltimer.tv_sec <= 0) {
-                               timerclear(&pp->p_seltimer);
-                               s = spl6();
-                               switch (pp->p_stat) {
+       }
+       /*
+        * 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]++;
+}

 
 

-                               case SSLEEP:
-                                       setrun(pp);
-                                       break;
+/*
+ * Software priority level clock interrupt.
+ * Run periodic events from timeout queue.
+ */
+/*ARGSUSED*/
+softclock(pc, ps)
+       caddr_t pc;
+       int ps;
+{

 
 

-                               case SSTOP:
-                                       unsleep(pp);
-                                       break;
-                               }
-                               splx(s);
-                       }
-                       if (timerisset(&pp->p_realtimer.itimer_value) &&
-                           itimerdecr(&pp->p_realtimer, 1000000) == 0)
-                               psignal(pp, SIGALRM);
+       for (;;) {
+               register struct callout *p1;
+               register caddr_t arg;
+               register int (*func)();
+               register int a, s;

 
 

-                       /*
-                        * If process is blocked, increment computed
-                        * time blocked.  This is used in swap scheduling.
-                        */
-                       if (pp->p_stat==SSLEEP || pp->p_stat==SSTOP)
-                               if (pp->p_slptime != 127)
-                                       pp->p_slptime++;
-                       /*
-                        * Update digital filter estimation of process
-                        * cpu utilization for loaded processes.
-                        */
-                       if (pp->p_flag&SLOAD)
-                               pp->p_pctcpu = ccpu * pp->p_pctcpu +
-                                   (1.0 - ccpu) * (pp->p_cpticks/(float)hz);
-                       /*
-                        * Recompute process priority.  The number p_cpu
-                        * is a weighted estimate of cpu time consumed.
-                        * A process which consumes cpu time has this
-                        * increase regularly.  We here decrease it by
-                        * a fraction based on load average giving a digital
-                        * decay filter which damps out in about 5 seconds
-                        * when seconds are measured in time expanded by the
-                        * load average.
-                        *
-                        * If a process is niced, then the nice directly
-                        * affects the new priority.  The final priority
-                        * is in the range 0 to 255, to fit in a character.
-                        */
-                       pp->p_cpticks = 0;
-#ifdef MUSH
-                       a = ave((pp->p_cpu & 0377), avenrun[0]*nrscale) +
-                            pp->p_nice - NZERO + pp->p_quota->q_nice;
-#else
-                       a = ave((pp->p_cpu & 0377), avenrun[0]*nrscale) +
-                            pp->p_nice - NZERO;
-#endif
-                       if (a < 0)
-                               a = 0;
-                       if (a > 255)
-                               a = 255;
-                       pp->p_cpu = a;
-                       (void) setpri(pp);
-                       /*
-                        * Now have computed new process priority
-                        * in p->p_usrpri.  Carefully change p->p_pri.
-                        * A process is on a run queue associated with
-                        * this priority, so we must block out process
-                        * state changes during the transition.
-                        */
-                       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;

                }
                }

+               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 trapped user-mode and profiling, give it
+        * a profiling tick.
+        */
+       if (USERMODE(ps)) {
+               register struct proc *p = u.u_procp;

 
 

-               /*
-                * Perform virtual memory metering.
-                */
-               vmmeter();
-
-               /*
-                * If the swap process is trying to bring
-                * a process in, have it look again to see
-                * if it is possible now.
-                */
-               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]);
-
-#ifdef MELB
-               /*
-                * If a process was running, see if time to make it nicer
-                */
-               if (!noproc) {
-                       pp = u.u_procp;
-                       if (pp->p_uid
-#ifdef MUSH
-                               && !(pp->p_flag & SLOGIN)
-#else
-                                    /* this is definitely not good enough */
-                               && (pp->p_pid != pp->p_pgrp || pp->p_ppid != 1)
-#endif
-                               && (u.u_ru.ru_utime + u.u_ru.ru_stime) >
-                                       (pp->p_nice-NZERO+1)*NFACT
-                               && pp->p_nice >= NZERO
-                               && pp->p_nice < MAXNICE
-                       ) {
-                               pp->p_nice++;
-                               (void) setpri(pp);
-                               pp->p_pri = pp->p_usrpri;
-                       }
+               if (u.u_prof.pr_scale) {
+                       p->p_flag |= SOWEUPC;
+                       aston();

                }
                }

-#else

                /*
                /*

-                * If the trap occurred from usermode,
-                * then check to see if it has now been
-                * running more than 10 minutes of user time
-                * and should thus run with reduced priority
-                * to give other processes a chance.
+                * Check to see if process has accumulated
+                * more than 10 minutes of user time.  If so
+                * reduce priority to give others a chance.

                 */
                 */

-               if (USERMODE(ps)) {
-                       pp = u.u_procp;
-                       if (pp->p_uid && pp->p_nice == NZERO &&
-                           u.u_ru.ru_utime.tv_sec > 600)
-                               pp->p_nice = NZERO+4;
-                       (void) setpri(pp);
-                       pp->p_pri = pp->p_usrpri;
+               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;

                }
                }

-#endif

        }
        }

-       /*
-        * If trapped user-mode, give it a profiling tick.
-        */
-       if (USERMODE(ps) &&
-           timerisset(&u.u_timer[ITIMER_VIRTUAL].itimer_value) &&
-           itimerdecr(&u.u_timer[ITIMER_VIRTUAL].itimer_value, 1000000/hz) == 0)
-               psignal(u.u_procp, SIGPROF);

 }
 
 /*
 }
 
 /*

- * Timeout is called to arrange that
- * fun(arg) is called in tim/hz seconds.
- * An entry is linked 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.
+ * Arrange that (*fun)(arg) is called in t/hz seconds.

  */
  */

-timeout(fun, arg, tim)
+timeout(fun, arg, t)

        int (*fun)();
        caddr_t arg;
        int (*fun)();
        caddr_t arg;

+       register int t;

 {
        register struct callout *p1, *p2, *pnew;
 {
        register struct callout *p1, *p2, *pnew;

-       register int t;
-       int s;
+       register int s = splhigh();

 
 

-       t = tim;
-       s = spl7();
+       if (t <= 0)
+               t = 1;

        pnew = callfree;
        if (pnew == NULL)
                panic("timeout table overflow");
        pnew = callfree;
        if (pnew == NULL)
                panic("timeout table overflow");


@@ -571,7 +360,8 @@ timeout(fun, arg, tim)
        pnew->c_arg = arg;
        pnew->c_func = fun;
        for (p1 = &calltodo; (p2 = p1->c_next) && p2->c_time < t; p1 = p2)
        pnew->c_arg = arg;
        pnew->c_func = fun;
        for (p1 = &calltodo; (p2 = p1->c_next) && p2->c_time < t; p1 = p2)

-               t -= p2->c_time;
+               if (p2->c_time > 0)
+                       t -= p2->c_time;

        p1->c_next = pnew;
        pnew->c_next = p2;
        pnew->c_time = t;
        p1->c_next = pnew;
        pnew->c_next = p2;
        pnew->c_time = t;


@@ -580,23 +370,21 @@ timeout(fun, arg, tim)
        splx(s);
 }
 
        splx(s);
 }
 

-#ifdef notdef

 /*
  * untimeout is called to remove a function timeout call
  * from the callout structure.
  */
 /*
  * untimeout is called to remove a function timeout call
  * from the callout structure.
  */

-untimeout (fun, arg)
+untimeout(fun, arg)

        int (*fun)();
        caddr_t arg;
 {
        int (*fun)();
        caddr_t arg;
 {

-

        register struct callout *p1, *p2;
        register int s;
 
        register struct callout *p1, *p2;
        register int s;
 

-       s = spl7();
+       s = splhigh();

        for (p1 = &calltodo; (p2 = p1->c_next) != 0; p1 = p2) {
                if (p2->c_func == fun && p2->c_arg == arg) {
        for (p1 = &calltodo; (p2 = p1->c_next) != 0; p1 = p2) {
                if (p2->c_func == fun && p2->c_arg == arg) {

-                       if (p2->c_next)
+                       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;
                                p2->c_next->c_time += p2->c_time;
                        p1->c_next = p2->c_next;
                        p2->c_next = callfree;


@@ -606,4 +394,52 @@ untimeout (fun, arg)
        }
        splx(s);
 }
        }
        splx(s);
 }

-#endif
+
+/*
+ * 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;
+}