panicstr prevents calls to timeout returns

SCCS-vsn: sys/kern/kern_clock.c 4.15

diff --git a/usr/src/sys/kern/kern_clock.c b/usr/src/sys/kern/kern_clock.c
index f021224..a483580 100644 (file)
--- a/usr/src/sys/kern/kern_clock.c
+++ b/usr/src/sys/kern/kern_clock.c
@@ -1,4 +1,4 @@
-/*     kern_clock.c    4.14    %G%     */
+/*     kern_clock.c    4.15    %G%     */

 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"


@@ -122,7 +122,7 @@ out:
        }
        ++lbolt;
 #if VAX780
        }
        ++lbolt;
 #if VAX780

-       if (cpu == VAX_780 && !BASEPRI(ps))
+       if (cpu == VAX_780 && panicstr == 0 && !BASEPRI(ps))

                unhang();
 #endif
        setsoftclock();
                unhang();
 #endif
        setsoftclock();


@@ -147,16 +147,16 @@ softclock(pc, ps)
        register int a, s;
 
        /*
        register int a, s;
 
        /*

-        * callout
+        * Perform callouts (but not after panic's!)

         */
         */

-       if(callout[0].c_time <= 0) {
+       if (panicstr == 0 && callout[0].c_time <= 0) {

                p1 = &callout[0];
                p1 = &callout[0];

-               while(p1->c_func != 0 && p1->c_time <= 0) {
+               while (p1->c_func != 0 && p1->c_time <= 0) {

                        (*p1->c_func)(p1->c_arg);
                        p1++;
                }
                p2 = &callout[0];
                        (*p1->c_func)(p1->c_arg);
                        p1++;
                }
                p2 = &callout[0];

-               while(p2->c_func = p1->c_func) {
+               while (p2->c_func = p1->c_func) {

                        p2->c_time = p1->c_time;
                        p2->c_arg = p1->c_arg;
                        p1++;
                        p2->c_time = p1->c_time;
                        p2->c_arg = p1->c_arg;
                        p1++;


@@ -201,49 +201,113 @@ softclock(pc, ps)
         *      kick swapper if processes want in
         */
        if (lbolt >= hz) {
         *      kick swapper if processes want in
         */
        if (lbolt >= hz) {

+               /*
+                * This doesn't mean much 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 (BASEPRI(ps))
                        return;

-               lbolt -= hz;
-               ++time;
+
+               /*
+                * 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.
+                */
+               time += lbolt / hz;
+               lbolt %= hz;
+
+               /*
+                * Wakeup lightning bolt sleepers.
+                * Processes sleep on lbolt to wait
+                * for short amounts of time (e.g. 1 second).
+                */

                wakeup((caddr_t)&lbolt);
                wakeup((caddr_t)&lbolt);

-               for(pp = proc; pp < procNPROC; pp++)
+
+               /*
+                * Recompute process priority and process
+                * sleep() system calls as well as internal
+                * sleeps with timeouts (tsleep() kernel routine).
+                */
+               for (pp = proc; pp < procNPROC; pp++)

                if (pp->p_stat && pp->p_stat!=SZOMB) {
                if (pp->p_stat && pp->p_stat!=SZOMB) {

-                       if(pp->p_time != 127)
+                       /*
+                        * 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++;
                                pp->p_time++;

-                       if(pp->p_clktim)
-                               if(--pp->p_clktim == 0)
-                                       if (pp->p_flag & STIMO) {
-                                               s = spl6();
-                                               switch (pp->p_stat) {
+                       /*
+                        * If process has clock counting down, and it
+                        * expires, set it running (if this is a tsleep()),
+                        * or give it an SIGALRM (if the user process
+                        * is using alarm signals.
+                        */
+                       if (pp->p_clktim && --pp->p_clktim == 0)
+                               if (pp->p_flag & STIMO) {
+                                       s = spl6();
+                                       switch (pp->p_stat) {

 
 

-                                               case SSLEEP:
-                                                       setrun(pp);
-                                                       break;
+                                       case SSLEEP:
+                                               setrun(pp);
+                                               break;

 
 

-                                               case SSTOP:
-                                                       unsleep(pp);
-                                                       break;
-                                               }
-                                               pp->p_flag &= ~STIMO;
-                                               splx(s);
-                                       } else
-                                               psignal(pp, SIGALRM);
-                       if(pp->p_stat==SSLEEP||pp->p_stat==SSTOP)
+                                       case SSTOP:
+                                               unsleep(pp);
+                                               break;
+                                       }
+                                       pp->p_flag &= ~STIMO;
+                                       splx(s);
+                               } else
+                                       psignal(pp, SIGALRM);
+                       /*
+                        * 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++;
                                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);
                        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 (SCHMAG is 90%), giving a digital
+                        * decay filter which damps out in about 10 seconds.
+                        *
+                        * 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;
                        a = (pp->p_cpu & 0377)*SCHMAG + pp->p_nice - NZERO;
                        pp->p_cpticks = 0;
                        a = (pp->p_cpu & 0377)*SCHMAG + pp->p_nice - NZERO;

-                       if(a < 0)
+                       if (a < 0)

                                a = 0;
                                a = 0;

-                       if(a > 255)
+                       if (a > 255)

                                a = 255;
                        pp->p_cpu = a;
                        (void) setpri(pp);
                                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();
                        s = spl6();

-                       if(pp->p_pri >= PUSER) {
+                       if (pp->p_pri >= PUSER) {

                                if ((pp != u.u_procp || noproc) &&
                                    pp->p_stat == SRUN &&
                                    (pp->p_flag & SLOAD) &&
                                if ((pp != u.u_procp || noproc) &&
                                    pp->p_stat == SRUN &&
                                    (pp->p_flag & SLOAD) &&


@@ -256,11 +320,22 @@ softclock(pc, ps)
                        }
                        splx(s);
                }
                        }
                        splx(s);
                }

+
+               /*
+                * Perform virtual memory metering.
+                */

                vmmeter();
                vmmeter();

-               if(runin!=0) {
+
+               /*
+                * 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);
                }
                        runin = 0;
                        wakeup((caddr_t)&runin);
                }

+

                /*
                 * If there are pages that have been cleaned, 
                 * jolt the pageout daemon to process them.
                /*
                 * If there are pages that have been cleaned, 
                 * jolt the pageout daemon to process them.


@@ -270,15 +345,26 @@ softclock(pc, ps)
                 */
                if (bclnlist != NULL)
                        wakeup((caddr_t)&proc[2]);
                 */
                if (bclnlist != NULL)
                        wakeup((caddr_t)&proc[2]);

+
+               /*
+                * 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.
+                */

                if (USERMODE(ps)) {
                        pp = u.u_procp;
                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;
+                       if (pp->p_uid && 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;
                }
        }
                        (void) setpri(pp);
                        pp->p_pri = pp->p_usrpri;
                }
        }

+       /*
+        * If trapped user-mode, give it a profiling tick.
+        */

        if (USERMODE(ps) && u.u_prof.pr_scale) {
                u.u_procp->p_flag |= SOWEUPC;
                aston();
        if (USERMODE(ps) && u.u_prof.pr_scale) {
                u.u_procp->p_flag |= SOWEUPC;
                aston();