usr/src/sys/kern/kern_synch.c

/*      kern_synch.c    4.6     %G%     */

#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"
#include "../h/inline.h"
#include "../h/mtpr.h"

#define SQSIZE 0100     /* Must be power of 2 */
#define HASH(x) (( (int) x >> 5) & (SQSIZE-1))
struct proc *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.
 */
sleep(chan, pri)
caddr_t chan;
{
        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->p_wchan = chan;
        rp->p_slptime = 0;
        rp->p_pri = pri;
        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;
                        (void) spl0();
                        goto psig;
                }
                if (rp->p_wchan == 0)
                        goto out;
                rp->p_stat = SSLEEP;
                (void) spl0();
                swtch();
                if(ISSIG(rp))
                        goto psig;
        } else {
                rp->p_stat = SSLEEP;
                (void) spl0();
                swtch();
        }
out:
        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*/
}

/*
 * 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
 */
tsleep(chan, pri, seconds)
caddr_t chan;
{
        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)
register caddr_t chan;
{
        register struct proc *p, **q, **h;
        int s;

        s = spl6();
        h = &slpque[HASH(chan)];
restart:
        for (q = h; p = *q; ) {
                if (p->p_rlink || p->p_stat != SSLEEP && p->p_stat != SSTOP)
                        panic("wakeup");
                if (p->p_wchan==chan) {
                        p->p_wchan = 0;
                        *q = p->p_link;
                        p->p_slptime = 0;
                        if (p->p_stat == SSLEEP) {
                                /* 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_pri < curpri) {
                                        runrun++;
                                        aston();
                                }
                                if(runout != 0 && (p->p_flag&SLOAD) == 0) {
                                        runout = 0;
                                        wakeup((caddr_t)&runout);
                                }
                                /* END INLINE EXPANSION */
                                goto restart;
                        }
                } else
                        q = &p->p_link;
        }
        splx(s);
}

#ifdef FASTVAX
/*
 * Initialize the (doubly-linked) run queues
 * to be empty.
 */
rqinit()
{
        register int 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)
register struct proc *p;
{
        register s;

        s = spl6();
        switch (p->p_stat) {

        case 0:
        case SWAIT:
        case SRUN:
        case SZOMB:
        default:
                panic("setrun");

        case SSTOP:
        case SSLEEP:
                unsleep(p);             /* e.g. when sending signals */
                break;

        case SIDL:
                break;
        }
        p->p_stat = SRUN;
        if (p->p_flag & SLOAD)
                setrq(p);
        splx(s);
        if(p->p_pri < curpri) {
                runrun++;
                aston();
        }
        if(runout != 0 && (p->p_flag&SLOAD) == 0) {
                runout = 0;
                wakeup((caddr_t)&runout);
        }
}

/*
 * Set user priority.
 * The rescheduling flag (runrun)
 * is set if the priority is better
 * than the currently running process.
 */
setpri(pp)
register struct proc *pp;
{
        register p;

        p = (pp->p_cpu & 0377)/16;
        p += PUSER + 2*(pp->p_nice - NZERO);
        if(p > 127)
                p = 127;
        if(p < curpri) {
                runrun++;
                aston();
        }
        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|SDETACH|SNUSIG));
        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_pptr = rip;
        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));
                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;
        }
        rpp->p_rssize = 0;
        rpp->p_wchan = 0;
        rpp->p_slptime = 0;
        rpp->p_pctcpu = 0;
        rpp->p_cpticks = 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) {
#ifdef UCBIPC
                        if (u.u_pofile[n] & ISPORT)
                                u.u_oport[n]->pt_count++;
                        else {
#endif
                                u.u_ofile[n]->f_count++;
                                if(!isvfork && u.u_vrpages[n])
                                        u.u_ofile[n]->f_inode->i_vfdcnt++;
#ifdef UCBIPC
                        }
#endif UCBIPC
                }

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

        (void) spl6();
        rpp->p_stat = SRUN;
        setrq(rpp);
        (void) 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);
}