X-Git-Url: https://git.subgeniuskitty.com/unix-history/.git/blobdiff_plain/7ac934046c5dd1ae94f5dd6c44466c4d201b17d4..961945a80c6f995f4567dbce8881af0bbdee211c:/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 89afab14df..18438635cd 100644 --- a/usr/src/sys/kern/kern_synch.c +++ b/usr/src/sys/kern/kern_synch.c @@ -1,4 +1,6 @@ -/* kern_synch.c 4.16 82/01/24 */ +/* kern_synch.c 4.25 82/12/17 */ + +#include "../machine/pte.h" #include "../h/param.h" #include "../h/systm.h" @@ -8,9 +10,93 @@ #include "../h/file.h" #include "../h/inode.h" #include "../h/vm.h" -#include "../h/pte.h" -#include "../h/inline.h" -#include "../h/mtpr.h" +#ifdef MUSH +#include "../h/quota.h" +#include "../h/share.h" +#endif +#include "../h/kernel.h" +#include "../h/buf.h" + +#ifdef vax +#include "../vax/mtpr.h" /* XXX */ +#endif +/* + * Force switch among equal priority processes every 100ms. + */ +roundrobin() +{ + + runrun++; + aston(); + timeout(roundrobin, (caddr_t)0, hz / 10); +} + +/* constants to digital decay and forget 90% of usage in 5*loadav time */ +#undef ave +#define ave(a,b) ((int)(((int)(a*b))/(b+1))) +int nrscale = 2; +double ccpu = 0.95122942450071400909; /* exp(-1/20) */ + +/* + * Recompute process priorities, once a second + */ +schedcpu() +{ + register struct proc *p; + register int s, a; + + wakeup((caddr_t)&lbolt); + for (p = proc; p < procNPROC; p++) if (p->p_stat && p->p_stat!=SZOMB) { +#ifdef MUSH + if (p->p_quota->q_uid) + p->p_quota->q_cost += + shconsts.sc_click * p->p_rssize; +#endif + 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++; + if (p->p_flag&SLOAD) + p->p_pctcpu = ccpu * p->p_pctcpu + + (1.0 - ccpu) * (p->p_cpticks/(float)hz); + p->p_cpticks = 0; +#ifdef MUSH + a = ave((p->p_cpu & 0377), avenrun[0]*nrscale) + + p->p_nice - NZERO + p->p_quota->q_nice; +#else + a = ave((p->p_cpu & 0377), avenrun[0]*nrscale) + + p->p_nice - NZERO; +#endif + if (a < 0) + a = 0; + if (a > 255) + a = 255; + p->p_cpu = a; + (void) setpri(p); + s = spl6(); /* prevent state changes */ + if (p->p_pri >= PUSER) { + if ((p != u.u_procp || noproc) && + p->p_stat == SRUN && + (p->p_flag & SLOAD) && + p->p_pri != p->p_usrpri) { + 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); +} #define SQSIZE 0100 /* Must be power of 2 */ #define HASH(x) (( (int) x >> 5) & (SQSIZE-1)) @@ -28,7 +114,8 @@ struct proc *slpque[SQSIZE]; * sleeping has gone away. */ sleep(chan, pri) -caddr_t chan; + caddr_t chan; + int pri; { register struct proc *rp, **hp; register s; @@ -55,12 +142,14 @@ caddr_t chan; goto out; rp->p_stat = SSLEEP; (void) spl0(); + u.u_ru.ru_nvcsw++; swtch(); if (ISSIG(rp)) goto psig; } else { rp->p_stat = SSLEEP; (void) spl0(); + u.u_ru.ru_nvcsw++; swtch(); } out: @@ -70,64 +159,14 @@ out: /* * If priority was low (>PZERO) and * there has been a signal, execute non-local goto through - * u.u_qsav, aborting the system call in progress (see trap.c) + * u.u_qsave, aborting the system call in progress (see trap.c) * (or finishing a tsleep, see below) */ psig: - longjmp(u.u_qsav); + longjmp(&u.u_qsave); /*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_clktimp_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 */ @@ -272,155 +311,3 @@ setpri(pp) 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) - int 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; rpp < procNPROC; 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 a proc table entry for the new process. - */ - rip = u.u_procp; - rpp->p_stat = SIDL; - rpp->p_clktim = 0; - rpp->p_flag = SLOAD | (rip->p_flag & (SPAGI|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_maxrss = rip->p_maxrss; - 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; - multprog++; - - /* - * Increase reference counts on shared objects. - */ - for(n=0; nf_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. - * This begins the section where we must prevent the parent - * from being swapped. - */ - rip->p_flag |= SKEEP; - if (procdup(rpp, isvfork)) - return (1); - - /* - * Make child runnable and add to run queue. - */ - (void) spl6(); - rpp->p_stat = SRUN; - setrq(rpp); - (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; */ - - /* - * Now can be swapped. - */ - 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; - 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); - 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); -}