new calling convension for system calls

[unix-history] / 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 4a63a89..61b3f79 100644 (file)
--- a/usr/src/sys/kern/kern_synch.c
+++ b/usr/src/sys/kern/kern_synch.c
@@ -1,134 +1,462 @@
-/*     kern_synch.c    3.3     %H%     */
+/*
+ * Copyright (c) 1982, 1986, 1990 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ *
+ *     @(#)kern_synch.c        7.11 (Berkeley) %G%
+ */
+
+#include "machine/pte.h"
+#include "machine/psl.h"
+#include "machine/mtpr.h"
+
+#include "param.h"
+#include "systm.h"
+#include "user.h"
+#include "proc.h"
+#include "vm.h"
+#include "kernel.h"
+#include "buf.h"
+
+/*
+ * Force switch among equal priority processes every 100ms.
+ */
+roundrobin()
+{
+
+       runrun++;
+       aston();
+       timeout(roundrobin, (caddr_t)0, hz / 10);
+}

 
 

-#include "../h/param.h"
-#include "../h/systm.h"
-#include "../h/dir.h"
-#include "../h/user.h"
-#include "../h/proc.h"
-#include "../h/file.h"
-#include "../h/inode.h"
-#include "../h/vm.h"
-#include "../h/pte.h"
+/*
+ * constants for digital decay and forget
+ *     90% of (p_cpu) usage in 5*loadav time
+ *     95% of (p_pctcpu) usage in 60 seconds (load insensitive)
+ *          Note that, as ps(1) mentions, this can let percentages
+ *          total over 100% (I've seen 137.9% for 3 processes).
+ *
+ * Note that hardclock updates p_cpu and p_cpticks independently.
+ *
+ * We wish to decay away 90% of p_cpu in (5 * loadavg) seconds.
+ * That is, the system wants to compute a value of decay such
+ * that the following for loop:
+ *     for (i = 0; i < (5 * loadavg); i++)
+ *             p_cpu *= decay;
+ * will compute
+ *     p_cpu *= 0.1;
+ * for all values of loadavg:
+ *
+ * Mathematically this loop can be expressed by saying:
+ *     decay ** (5 * loadavg) ~= .1
+ *
+ * The system computes decay as:
+ *     decay = (2 * loadavg) / (2 * loadavg + 1)
+ *
+ * We wish to prove that the system's computation of decay
+ * will always fulfill the equation:
+ *     decay ** (5 * loadavg) ~= .1
+ *
+ * If we compute b as:
+ *     b = 2 * loadavg
+ * then
+ *     decay = b / (b + 1)
+ *
+ * We now need to prove two things:
+ *     1) Given factor ** (5 * loadavg) ~= .1, prove factor == b/(b+1)
+ *     2) Given b/(b+1) ** power ~= .1, prove power == (5 * loadavg)
+ *     
+ * Facts:
+ *         For x close to zero, exp(x) =~ 1 + x, since
+ *              exp(x) = 0! + x**1/1! + x**2/2! + ... .
+ *              therefore exp(-1/b) =~ 1 - (1/b) = (b-1)/b.
+ *         For x close to zero, ln(1+x) =~ x, since
+ *              ln(1+x) = x - x**2/2 + x**3/3 - ...     -1 < x < 1
+ *              therefore ln(b/(b+1)) = ln(1 - 1/(b+1)) =~ -1/(b+1).
+ *         ln(.1) =~ -2.30
+ *
+ * Proof of (1):
+ *    Solve (factor)**(power) =~ .1 given power (5*loadav):
+ *     solving for factor,
+ *      ln(factor) =~ (-2.30/5*loadav), or
+ *      factor =~ exp(-1/((5/2.30)*loadav) =~ exp(-1/(2*loadav)) =
+ *          exp(-1/b) =~ (b-1)/b =~ b/(b+1).                    QED
+ *
+ * Proof of (2):
+ *    Solve (factor)**(power) =~ .1 given factor == (b/(b+1)):
+ *     solving for power,
+ *      power*ln(b/(b+1)) =~ -2.30, or
+ *      power =~ 2.3 * (b + 1) = 4.6*loadav + 2.3 =~ 5*loadav.  QED
+ *
+ * Actual power values for the implemented algorithm are as follows:
+ *      loadav: 1       2       3       4
+ *      power:  5.68    10.32   14.94   19.55
+ */

 
 

+/* calculations for digital decay to forget 90% of usage in 5*loadav sec */
+#define        get_b(loadav)           (2 * (loadav))
+#define        get_pcpu(b, cpu)        (((b) * ((cpu) & 0377)) / ((b) + FSCALE))
+
+/* decay 95% of `p_pctcpu' in 60 seconds; see CCPU_SHIFT before changing */
+fixpt_t        ccpu = 0.95122942450071400909 * FSCALE;         /* exp(-1/20) */
+
+/*
+ * If `ccpu' is not equal to `exp(-1/20)' and you still want to use the
+ * faster/more-accurate formula, you'll have to estimate CCPU_SHIFT below
+ * and possibly adjust FSHIFT in "param.h" so that (FSHIFT >= CCPU_SHIFT).
+ *
+ * To estimate CCPU_SHIFT for exp(-1/20), the following formula was used:
+ *     1 - exp(-1/20) ~= 0.0487 ~= 0.0488 == 1 (fixed pt, *11* bits).
+ *
+ * If you dont want to bother with the faster/more-accurate formula, you
+ * can set CCPU_SHIFT to (FSHIFT + 1) which will use a slower/less-accurate
+ * (more general) method of calculating the %age of CPU used by a process.
+ */
+#define        CCPU_SHIFT      11
+
+/*
+ * Recompute process priorities, once a second
+ */
+schedcpu()
+{
+       register fixpt_t b = get_b(averunnable[0]);
+       register struct proc *p;
+       register int s, a;
+
+       wakeup((caddr_t)&lbolt);
+       for (p = allproc; p != NULL; p = p->p_nxt) {
+               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++;
+               p->p_pctcpu = (p->p_pctcpu * ccpu) >> FSHIFT;
+               /*
+                * If the process has slept the entire second,
+                * stop recalculating its priority until it wakes up.
+                */
+               if (p->p_slptime > 1)
+                       continue;
+               /*
+                * p_pctcpu is only for ps.
+                */
+#if    (FSHIFT >= CCPU_SHIFT)
+               p->p_pctcpu += (hz == 100)?
+                       ((fixpt_t) p->p_cpticks) << (FSHIFT - CCPU_SHIFT):
+                       100 * (((fixpt_t) p->p_cpticks)
+                               << (FSHIFT - CCPU_SHIFT)) / hz;
+#else
+               p->p_pctcpu += ((FSCALE - ccpu) *
+                       (p->p_cpticks * FSCALE / hz)) >> FSHIFT;
+#endif
+               p->p_cpticks = 0;
+               a = (int) get_pcpu(b, p->p_cpu) + p->p_nice;
+               if (a < 0)
+                       a = 0;
+               if (a > 255)
+                       a = 255;
+               p->p_cpu = a;
+               (void) setpri(p);
+               s = splhigh();  /* prevent state changes */
+               if (p->p_pri >= PUSER) {
+#define        PPQ     (128 / NQS)
+                       if ((p != u.u_procp || noproc) &&
+                           p->p_stat == SRUN &&
+                           (p->p_flag & SLOAD) &&
+                           (p->p_pri / PPQ) != (p->p_usrpri / PPQ)) {
+                               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);
+}
+
+/*
+ * Recalculate the priority of a process after it has slept for a while.
+ */
+updatepri(p)
+       register struct proc *p;
+{
+       register int a = p->p_cpu & 0377;
+       register fixpt_t b = get_b(averunnable[0]);
+
+       p->p_slptime--;         /* the first time was done in schedcpu */
+       while (a && --p->p_slptime)
+               a = (int) get_pcpu(b, a) /* + p->p_nice */;
+       p->p_slptime = 0;
+       if (a < 0)
+               a = 0;
+       if (a > 255)
+               a = 255;
+       p->p_cpu = a;
+       (void) setpri(p);
+}

 
 #define SQSIZE 0100    /* Must be power of 2 */
 #define HASH(x)        (( (int) x >> 5) & (SQSIZE-1))
 
 #define SQSIZE 0100    /* Must be power of 2 */
 #define HASH(x)        (( (int) x >> 5) & (SQSIZE-1))

-struct proc *slpque[SQSIZE];
+struct slpque {
+       struct proc *sq_head;
+       struct proc **sq_tailp;
+} slpque[SQSIZE];

 
 /*
 
 /*

- * Give up the processor till a wakeup occurs
- * on chan, at which time the process
- * enters the scheduling queue at priority pri.
- * The most important effect of pri is that when
- * pri<=PZERO a signal cannot disturb the sleep;
- * if pri>PZERO signals will be processed.
- * Callers of this routine must be prepared for
- * premature return, and check that the reason for
- * sleeping has gone away.
+ * General sleep call.
+ * Suspends current process until a wakeup is made on chan.
+ * The process will then be made runnable with priority pri.
+ * Sleeps at most timo/hz seconds (0 means no timeout).
+ * If pri includes PCATCH flag, signals are checked
+ * before and after sleeping, else signals are not checked.
+ * Returns 0 if awakened, EWOULDBLOCK if the timeout expires.
+ * If PCATCH is set and a signal needs to be delivered,
+ * ERESTART is returned if the current system call should be restarted
+ * if possible, and EINTR is returned if the system call should
+ * be interrupted by the signal (return EINTR).

  */
  */

-sleep(chan, pri)
-caddr_t chan;
+tsleep(chan, pri, wmesg, timo)
+       caddr_t chan;
+       int pri;
+       char *wmesg;
+       int timo;

 {
        register struct proc *rp;
 {
        register struct proc *rp;

-       register s, h;
+       register struct slpque *qp;
+       register s;
+       int sig, catch = pri & PCATCH;
+       extern int cold;
+       int endtsleep();

 
        rp = u.u_procp;
 
        rp = u.u_procp;

-       s = spl6();
-       if (chan==0 || rp->p_stat != SRUN || rp->p_rlink)
-               panic("sleep");
-       rp->p_stat = SSLEEP;
+       s = splhigh();
+       if (cold || panicstr) {
+               /*
+                * After a panic, or during autoconfiguration,
+                * just give interrupts a chance, then just return;
+                * don't run any other procs or panic below,
+                * in case this is the idle process and already asleep.
+                */
+               (void) spl0();
+               splx(s);
+               return (0);
+       }
+#ifdef DIAGNOSTIC
+       if (chan == 0 || rp->p_stat != SRUN || rp->p_rlink)
+               panic("tsleep");
+#endif

        rp->p_wchan = chan;
        rp->p_wchan = chan;

+       rp->p_wmesg = wmesg;

        rp->p_slptime = 0;
        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;
+       rp->p_pri = pri & PRIMASK;
+       qp = &slpque[HASH(chan)];
+       if (qp->sq_head == 0)
+               qp->sq_head = rp;
+       else
+               *qp->sq_tailp = rp;
+       *(qp->sq_tailp = &rp->p_link) = 0;
+       /*
+        * If we stop in CURSIG/issig(), wakeup may already
+        * have happened when we return.
+        * rp->p_wchan will then be 0.
+        */
+       if (catch) {
+               if (sig = CURSIG(rp)) {
+                       if (rp->p_wchan)
+                               unsleep(rp);

                        rp->p_stat = SRUN;
                        rp->p_stat = SRUN;

-                       slpque[h] = rp->p_link;
-                       VOID spl0();
-                       goto psig;
+                       splx(s);
+                       if (u.u_sigintr & sigmask(sig))
+                               return (EINTR);
+                       return (ERESTART);

                }
                }

-               VOID spl0();
-               if(runin != 0) {
-                       runin = 0;
-                       wakeup((caddr_t)&runin);
+               if (rp->p_wchan == 0) {
+                       splx(s);
+                       return (0);

                }
                }

-               swtch();
-               if(rp->p_sig && issig())
-                       goto psig;
-       } else {
-               VOID spl0();
-               swtch();
+               rp->p_flag |= SSINTR;
+       }
+       rp->p_stat = SSLEEP;
+       if (timo)
+               timeout(endtsleep, (caddr_t)rp, timo);
+       (void) spl0();
+       u.u_ru.ru_nvcsw++;
+       swtch();
+       curpri = rp->p_usrpri;
+       splx(s);
+       rp->p_flag &= ~SSINTR;
+       if (rp->p_flag & STIMO) {
+               rp->p_flag &= ~STIMO;
+               return (EWOULDBLOCK);
+       }
+       if (timo)
+               untimeout(endtsleep, (caddr_t)rp);
+       if (catch && (sig = CURSIG(rp))) {
+               if (u.u_sigintr & sigmask(sig))
+                       return (EINTR);
+               return (ERESTART);
+       }
+       return (0);
+}
+
+/*
+ * Implement timeout for tsleep.
+ * If process hasn't been awakened (wchan non-zero),
+ * set timeout flag and undo the sleep.  If proc
+ * is stopped, just unsleep so it will remain stopped.
+ */
+endtsleep(p)
+       register struct proc *p;
+{
+       int s = splhigh();
+
+       if (p->p_wchan) {
+               if (p->p_stat == SSLEEP)
+                       setrun(p);
+               else
+                       unsleep(p);
+               p->p_flag |= STIMO;

        }
        splx(s);
        }
        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)
-        */
-psig:
-       longjmp(u.u_qsav);
-       /*NOTREACHED*/
+/*
+ * Short-term, non-interruptable sleep.
+ */
+sleep(chan, pri)
+       caddr_t chan;
+       int pri;
+{
+       register struct proc *rp;
+       register struct slpque *qp;
+       register s;
+       extern int cold;
+
+#ifdef DIAGNOSTIC
+       if (pri > PZERO) {
+               printf("sleep called with pri %d > PZERO, wchan: %x\n",
+                       pri, chan);
+               panic("old sleep");
+       }
+#endif
+       rp = u.u_procp;
+       s = splhigh();
+       if (cold || panicstr) {
+               /*
+                * After a panic, or during autoconfiguration,
+                * just give interrupts a chance, then just return;
+                * don't run any other procs or panic below,
+                * in case this is the idle process and already asleep.
+                */
+               (void) spl0();
+               splx(s);
+               return;
+       }
+#ifdef DIAGNOSTIC
+       if (chan==0 || rp->p_stat != SRUN || rp->p_rlink)
+               panic("sleep");
+#endif
+       rp->p_wchan = chan;
+       rp->p_wmesg = NULL;
+       rp->p_slptime = 0;
+       rp->p_pri = pri;
+       qp = &slpque[HASH(chan)];
+       if (qp->sq_head == 0)
+               qp->sq_head = rp;
+       else
+               *qp->sq_tailp = rp;
+       *(qp->sq_tailp = &rp->p_link) = 0;
+       rp->p_stat = SSLEEP;
+       (void) spl0();
+       u.u_ru.ru_nvcsw++;
+       swtch();
+       curpri = rp->p_usrpri;
+       splx(s);
+}
+
+/*
+ * Remove a process from its wait queue
+ */
+unsleep(p)
+       register struct proc *p;
+{
+       register struct slpque *qp;
+       register struct proc **hp;
+       int s;
+
+       s = splhigh();
+       if (p->p_wchan) {
+               hp = &(qp = &slpque[HASH(p->p_wchan)])->sq_head;
+               while (*hp != p)
+                       hp = &(*hp)->p_link;
+               *hp = p->p_link;
+               if (qp->sq_tailp == &p->p_link)
+                       qp->sq_tailp = hp;
+               p->p_wchan = 0;
+       }
+       splx(s);

 }
 
 /*
  * Wake up all processes sleeping on chan.
  */
 wakeup(chan)
 }
 
 /*
  * 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 slpque *qp;
+       register struct proc *p, **q;

        int s;
 
        int s;
 

-       s = spl6();
-       i = HASH(chan);
+       s = splhigh();
+       qp = &slpque[HASH(chan)];

 restart:
 restart:

-       p = slpque[i];
-       q = NULL;
-       while(p != NULL) {
-               if (p->p_rlink || p->p_stat != SSLEEP)
+       for (q = &qp->sq_head; p = *q; ) {
+#ifdef DIAGNOSTIC
+               if (p->p_rlink || p->p_stat != SSLEEP && p->p_stat != SSTOP)

                        panic("wakeup");
                        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;
-                       p->p_wchan = 0;
-                       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
 #endif

-                       }
-                       if(p->p_pri < curpri)
+               if (p->p_wchan==chan) {
+                       p->p_wchan = 0;
+                       *q = p->p_link;
+                       if (qp->sq_tailp == &p->p_link)
+                               qp->sq_tailp = q;
+                       if (p->p_stat == SSLEEP) {
+                               /* OPTIMIZED INLINE EXPANSION OF setrun(p) */
+                               if (p->p_slptime > 1)
+                                       updatepri(p);
+                               p->p_stat = SRUN;
+                               if (p->p_flag & SLOAD)
+                                       setrq(p);
+                               /*
+                                * Since curpri is a usrpri,
+                                * p->p_pri is always better than curpri.
+                                */

                                runrun++;
                                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++;
+                               }
+                               /* END INLINE EXPANSION */
+                               goto restart;

                        }
                        }

-                       /* END INLINE EXPANSION */
-                       goto restart;
-               }
-               q = p;
-               p = p->p_link;
+               } else
+                       q = &p->p_link;

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

-#ifdef FASTVAX

 /*
  * Initialize the (doubly-linked) run queues
  * to be empty.
 /*
  * Initialize the (doubly-linked) run queues
  * to be empty.


@@ -140,19 +468,17 @@ rqinit()
        for (i = 0; i < NQS; i++)
                qs[i].ph_link = qs[i].ph_rlink = (struct proc *)&qs[i];
 }
        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)
 
 /*
  * 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();
+       s = splhigh();

        switch (p->p_stat) {
 
        case 0:
        switch (p->p_stat) {
 
        case 0:


@@ -162,27 +488,30 @@ register struct proc *p;
        default:
                panic("setrun");
 
        default:
                panic("setrun");
 

+       case SSTOP:

        case SSLEEP:
        case SSLEEP:

-               if (w = p->p_wchan) {
-                       wakeup(w);
-                       splx(s);
-                       return;
-               }
+               unsleep(p);             /* e.g. when sending signals */

                break;
 
        case SIDL:
                break;
 
        case SIDL:

-       case SSTOP:

                break;
        }
        p->p_stat = SRUN;
        if (p->p_flag & SLOAD)
                setrq(p);
        splx(s);
                break;
        }
        p->p_stat = SRUN;
        if (p->p_flag & SLOAD)
                setrq(p);
        splx(s);

-       if(p->p_pri < curpri)
+       if (p->p_slptime > 1)
+               updatepri(p);
+       if (p->p_pri < curpri) {

                runrun++;
                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++;

        }
 }
 
        }
 }
 


@@ -193,153 +522,20 @@ register struct proc *p;
  * than the currently running process.
  */
 setpri(pp)
  * 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;
+       if (pp->p_rssize > pp->p_maxrss && freemem < desfree)
+               p += 2*4;       /* effectively, nice(4) */
+       if (p > 127)

                p = 127;
                p = 127;

-       if(p < curpri)
+       if (p < curpri) {

                runrun++;
                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);

 }
 }