shutdown; clear suid; get/set hostname; nbio in state not options fixes

[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 0166b10..89afab1 100644 (file)
--- a/usr/src/sys/kern/kern_synch.c
+++ b/usr/src/sys/kern/kern_synch.c
@@ -1,4 +1,4 @@
-/*     kern_synch.c    3.2     %H%     */
+/*     kern_synch.c    4.16    82/01/24        */

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


@@ -9,10 +9,8 @@
 #include "../h/inode.h"
 #include "../h/vm.h"
 #include "../h/pte.h"
 #include "../h/inode.h"
 #include "../h/vm.h"
 #include "../h/pte.h"

-
-#ifdef FASTVAX
-asm(" .globl _eintr");
-#endif
+#include "../h/inline.h"
+#include "../h/mtpr.h"

 
 #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))


@@ -32,115 +30,168 @@ struct proc *slpque[SQSIZE];
 sleep(chan, pri)
 caddr_t chan;
 {
 sleep(chan, pri)
 caddr_t chan;
 {

-       register struct proc *rp;
-       register s, h;
+       register struct proc *rp, **hp;
+       register s;

 
        rp = u.u_procp;
        s = spl6();
        if (chan==0 || rp->p_stat != SRUN || rp->p_rlink)
                panic("sleep");
 
        rp = u.u_procp;
        s = spl6();
        if (chan==0 || rp->p_stat != SRUN || rp->p_rlink)
                panic("sleep");

-       rp->p_stat = SSLEEP;

        rp->p_wchan = chan;
        rp->p_slptime = 0;
        rp->p_pri = pri;
        rp->p_wchan = chan;
        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;
+       hp = &slpque[HASH(chan)];
+       rp->p_link = *hp;
+       *hp = rp;
+       if (pri > PZERO) {
+               if (ISSIG(rp)) {
+                       if (rp->p_wchan)
+                               unsleep(rp);

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

-                       slpque[h] = rp->p_link;
-                       VOID spl0();
+                       (void) spl0();

                        goto psig;
                }
                        goto psig;
                }

-               VOID spl0();
-               if(runin != 0) {
-                       runin = 0;
-                       wakeup((caddr_t)&runin);
-               }
+               if (rp->p_wchan == 0)
+                       goto out;
+               rp->p_stat = SSLEEP;
+               (void) spl0();

                swtch();
                swtch();

-               if(rp->p_sig && issig())
+               if (ISSIG(rp))

                        goto psig;
        } else {
                        goto psig;
        } else {

-               VOID spl0();
+               rp->p_stat = SSLEEP;
+               (void) spl0();

                swtch();
        }
                swtch();
        }

+out:

        splx(s);
        return;
 
        /*
         * If priority was low (>PZERO) and
        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)
+        * there has been a signal, execute non-local goto through
+        * u.u_qsav, aborting the system call in progress (see trap.c)
+        * (or finishing a tsleep, see below)

         */
 psig:
         */
 psig:

-#ifndef FASTVAX

        longjmp(u.u_qsav);
        longjmp(u.u_qsav);

-#else
-       asm(".set U_SSAV,140");
-       asm("movl _u+U_SSAV,fp");
-       asm("movl _u+U_SSAV+4,sp");
-       asm("movl _u+U_SSAV+8,r11");
-       u.u_error = EINTR;
-       asm("jmp _eintr");
-#endif

        /*NOTREACHED*/
 }
 
        /*NOTREACHED*/
 }
 

+/*
+ * Sleep on chan at pri.
+ * Return in no more than the indicated number of seconds.
+ * (If seconds==0, no timeout implied)
+ * Return      TS_OK if chan was awakened normally
+ *             TS_TIME if timeout occurred
+ *             TS_SIG if asynchronous signal occurred
+ *
+ * SHOULD HAVE OPTION TO SLEEP TO ABSOLUTE TIME OR AN
+ * INCREMENT IN MILLISECONDS!
+ */
+tsleep(chan, pri, seconds)
+       caddr_t chan;
+       int pri, seconds;
+{
+       label_t lqsav;
+       register struct proc *pp;
+       register sec, n, rval;
+
+       pp = u.u_procp;
+       n = spl7();
+       sec = 0;
+       rval = 0;
+       if (pp->p_clktim && pp->p_clktim<seconds)
+               seconds = 0;
+       if (seconds) {
+               pp->p_flag |= STIMO;
+               sec = pp->p_clktim-seconds;
+               pp->p_clktim = seconds;
+       }
+       bcopy((caddr_t)u.u_qsav, (caddr_t)lqsav, sizeof (label_t));
+       if (setjmp(u.u_qsav))
+               rval = TS_SIG;
+       else {
+               sleep(chan, pri);
+               if ((pp->p_flag&STIMO)==0 && seconds)
+                       rval = TS_TIME;
+               else
+                       rval = TS_OK;
+       }
+       pp->p_flag &= ~STIMO;
+       bcopy((caddr_t)lqsav, (caddr_t)u.u_qsav, sizeof (label_t));
+       if (sec > 0)
+               pp->p_clktim += sec;
+       else
+               pp->p_clktim = 0;
+       splx(n);
+       return (rval);
+}
+
+/*
+ * Remove a process from its wait queue
+ */
+unsleep(p)
+       register struct proc *p;
+{
+       register struct proc **hp;
+       register s;
+
+       s = spl6();
+       if (p->p_wchan) {
+               hp = &slpque[HASH(p->p_wchan)];
+               while (*hp != p)
+                       hp = &(*hp)->p_link;
+               *hp = p->p_link;
+               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 proc *p, **q, **h;

        int s;
 
        s = spl6();
        int s;
 
        s = spl6();

-       i = HASH(chan);
+       h = &slpque[HASH(chan)];

 restart:
 restart:

-       p = slpque[i];
-       q = NULL;
-       while(p != NULL) {
-               if (p->p_rlink || p->p_stat != SSLEEP)
+       for (q = h; p = *q; ) {
+               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;
+               if (p->p_wchan==chan) {

                        p->p_wchan = 0;
                        p->p_wchan = 0;

+                       *q = p->p_link;

                        p->p_slptime = 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
+                       if (p->p_stat == SSLEEP) {
+                               /* OPTIMIZED INLINE EXPANSION OF setrun(p) */
+                               p->p_stat = SRUN;
+                               if (p->p_flag & SLOAD)
+                                       setrq(p);
+                               if (p->p_pri < curpri) {
+                                       runrun++;
+                                       aston();
+                               }
+                               if ((p->p_flag&SLOAD) == 0) {
+                                       if (runout != 0) {
+                                               runout = 0;
+                                               wakeup((caddr_t)&runout);
+                                       }
+                                       wantin++;
+                               }
+                               /* END INLINE EXPANSION */
+                               goto restart;

                        }
                        }

-                       if(p->p_pri < curpri)
-                               runrun++;
-                       if(runout != 0 && (p->p_flag&SLOAD) == 0) {
-                               runout = 0;
-                               wakeup((caddr_t)&runout);
-                       }
-                       /* 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.


@@ -152,17 +203,15 @@ 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();
        switch (p->p_stat) {
 
        s = spl6();
        switch (p->p_stat) {


@@ -174,27 +223,28 @@ 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_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++;

        }
 }
 
        }
 }
 


@@ -205,18 +255,22 @@ 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 - NZERO);
+       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++;

+               aston();
+       }

        pp->p_usrpri = p;
        pp->p_usrpri = p;

-       return(p);
+       return (p);

 }
 
 /*
 }
 
 /*


@@ -225,6 +279,7 @@ register struct proc *pp;
  * It returns 1 in the new process, 0 in the old.
  */
 newproc(isvfork)
  * It returns 1 in the new process, 0 in the old.
  */
 newproc(isvfork)

+       int isvfork;

 {
        register struct proc *p;
        register struct proc *rpp, *rip;
 {
        register struct proc *p;
        register struct proc *rpp, *rip;


@@ -239,27 +294,26 @@ newproc(isvfork)
         */
 retry:
        mpid++;
         */
 retry:
        mpid++;

-       if(mpid >= 30000) {
+       if (mpid >= 30000) {

                mpid = 0;
                goto retry;
        }
                mpid = 0;
                goto retry;
        }

-       for(rpp = &proc[0]; rpp < &proc[NPROC]; rpp++) {
-               if(rpp->p_stat == NULL && p==NULL)
+       for (rpp = proc; rpp < procNPROC; rpp++) {
+               if (rpp->p_stat == NULL && p==NULL)

                        p = rpp;
                if (rpp->p_pid==mpid || rpp->p_pgrp==mpid)
                        goto retry;
        }
                        p = rpp;
                if (rpp->p_pid==mpid || rpp->p_pgrp==mpid)
                        goto retry;
        }

-       if ((rpp = p)==NULL)
+       if ((rpp = p) == NULL)

                panic("no procs");
 
        /*
                panic("no procs");
 
        /*

-        * make proc entry for new proc
+        * Make a proc table entry for the new process.

         */
         */

-

        rip = u.u_procp;
        rpp->p_stat = SIDL;
        rpp->p_clktim = 0;
        rip = u.u_procp;
        rpp->p_stat = SIDL;
        rpp->p_clktim = 0;

-       rpp->p_flag = SLOAD | (rip->p_flag & SPAGI);
+       rpp->p_flag = SLOAD | (rip->p_flag & (SPAGI|SNUSIG));

        if (isvfork) {
                rpp->p_flag |= SVFORK;
                rpp->p_ndx = rip->p_ndx;
        if (isvfork) {
                rpp->p_flag |= SVFORK;
                rpp->p_ndx = rip->p_ndx;


@@ -271,8 +325,12 @@ retry:
        rpp->p_textp = isvfork ? 0 : rip->p_textp;
        rpp->p_pid = mpid;
        rpp->p_ppid = rip->p_pid;
        rpp->p_textp = isvfork ? 0 : rip->p_textp;
        rpp->p_pid = mpid;
        rpp->p_ppid = rip->p_pid;

+       rpp->p_pptr = rip;

        rpp->p_time = 0;
        rpp->p_cpu = 0;
        rpp->p_time = 0;
        rpp->p_cpu = 0;

+       rpp->p_siga0 = rip->p_siga0;
+       rpp->p_siga1 = rip->p_siga1;
+       /* take along any pending signals, like stops? */

        if (isvfork) {
                rpp->p_tsize = rpp->p_dsize = rpp->p_ssize = 0;
                rpp->p_szpt = clrnd(ctopt(UPAGES));
        if (isvfork) {
                rpp->p_tsize = rpp->p_dsize = rpp->p_ssize = 0;
                rpp->p_szpt = clrnd(ctopt(UPAGES));


@@ -287,50 +345,64 @@ retry:
                forkstat.sizfork += rip->p_dsize + rip->p_ssize;
        }
        rpp->p_rssize = 0;
                forkstat.sizfork += rip->p_dsize + rip->p_ssize;
        }
        rpp->p_rssize = 0;

+       rpp->p_maxrss = rip->p_maxrss;

        rpp->p_wchan = 0;
        rpp->p_slptime = 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;
+       rpp->p_pctcpu = 0;
+       rpp->p_cpticks = 0;

        n = PIDHASH(rpp->p_pid);
        p->p_idhash = pidhash[n];
        pidhash[n] = rpp - proc;
        n = PIDHASH(rpp->p_pid);
        p->p_idhash = pidhash[n];
        pidhash[n] = rpp - proc;

+       multprog++;

 
        /*
 
        /*

-        * make duplicate entries
-        * where needed
+        * Increase reference counts on shared objects.

         */
         */

-
-       multprog++;
-

        for(n=0; n<NOFILE; n++)
        for(n=0; n<NOFILE; n++)

-               if(u.u_ofile[n] != NULL) {
+               if (u.u_ofile[n] != NULL)

                        u.u_ofile[n]->f_count++;
                        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++;
        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.
        /*
         * Partially simulate the environment
         * of the new process so that when it is actually
         * created (by copying) it will look right.

+        * This begins the section where we must prevent the parent
+        * from being swapped.

         */
         */

-
-       rip->p_flag |= SKEEP;   /* prevent parent from being swapped */
-
+       rip->p_flag |= SKEEP;

        if (procdup(rpp, isvfork))
                return (1);
 
        if (procdup(rpp, isvfork))
                return (1);
 

-       spl6();
+       /*
+        * Make child runnable and add to run queue.
+        */
+       (void) spl6();

        rpp->p_stat = SRUN;
        setrq(rpp);
        rpp->p_stat = SRUN;
        setrq(rpp);

-       spl0();
-       /* SSWAP NOT NEEDED IN THIS CASE AS u.u_pcb.pcb_sswap SUFFICES */
+       (void) spl0();
+
+       /*
+        * Cause child to take a non-local goto as soon as it runs.
+        * On older systems this was done with SSWAP bit in proc
+        * table; on VAX we use u.u_pcb.pcb_sswap so don't need
+        * to do rpp->p_flag |= SSWAP.  Actually do nothing here.
+        */

        /* rpp->p_flag |= SSWAP; */
        /* rpp->p_flag |= SSWAP; */

+
+       /*
+        * Now can be swapped.
+        */

        rip->p_flag &= ~SKEEP;
        rip->p_flag &= ~SKEEP;

+
+       /*
+        * If vfork make chain from parent process to child
+        * (where virtal memory is temporarily).  Wait for
+        * child to finish, steal virtual memory back,
+        * and wakeup child to let it die.
+        */

        if (isvfork) {
                u.u_procp->p_xlink = rpp;
                u.u_procp->p_flag |= SNOVM;
        if (isvfork) {
                u.u_procp->p_xlink = rpp;
                u.u_procp->p_flag |= SNOVM;


@@ -341,17 +413,14 @@ retry:
                uaccess(rpp, Vfmap, &vfutl);
                u.u_procp->p_xlink = 0;
                vpassvm(rpp, u.u_procp, &vfutl, &u, Vfmap);
                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);
        }
                u.u_procp->p_flag &= ~SNOVM;
                rpp->p_ndx = rpp - proc;
                rpp->p_flag |= SVFDONE;
                wakeup((caddr_t)rpp);
        }

+
+       /*
+        * 0 return means parent.
+        */

        return (0);
 }
        return (0);
 }