+#
+/*
+ */
+
+#include "../param.h"
+#include "../user.h"
+#include "../proc.h"
+#include "../text.h"
+#include "../systm.h"
+#include "../file.h"
+#include "../inode.h"
+#include "../buf.h"
+
+/*
+ * 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<0 a signal cannot disturb the sleep;
+ * if pri>=0 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)
+{
+ register *rp, s;
+
+ s = PS->integ;
+ rp = u.u_procp;
+ if(pri >= 0) {
+ if(issig())
+ goto psig;
+ spl6();
+ rp->p_wchan = chan;
+ rp->p_stat = SWAIT;
+ rp->p_pri = pri;
+ spl0();
+ if(runin != 0) {
+ runin = 0;
+ wakeup(&runin);
+ }
+ swtch();
+ if(issig())
+ goto psig;
+ } else {
+ spl6();
+ rp->p_wchan = chan;
+ rp->p_stat = SSLEEP;
+ rp->p_pri = pri;
+ spl0();
+ swtch();
+ }
+ PS->integ = s;
+ return;
+
+ /*
+ * If priority was low (>=0) and
+ * there has been a signal,
+ * execute non-local goto to
+ * the qsav location.
+ * (see trap1/trap.c)
+ */
+psig:
+ aretu(u.u_qsav);
+}
+
+/*
+ * Wake up all processes sleeping on chan.
+ */
+wakeup(chan)
+{
+ register struct proc *p;
+ register c, i;
+
+ c = chan;
+ p = &proc[0];
+ i = NPROC;
+ do {
+ if(p->p_wchan == c) {
+ setrun(p);
+ }
+ p++;
+ } while(--i);
+}
+
+/*
+ * Set the process running;
+ * arrange for it to be swapped in if necessary.
+ */
+setrun(p)
+{
+ register struct proc *rp;
+
+ rp = p;
+ rp->p_wchan = 0;
+ rp->p_stat = SRUN;
+ if(rp->p_pri < curpri)
+ runrun++;
+ if(runout != 0 && (rp->p_flag&SLOAD) == 0) {
+ runout = 0;
+ wakeup(&runout);
+ }
+}
+
+/*
+ * Set user priority.
+ * The rescheduling flag (runrun)
+ * is set if the priority is higher
+ * than the currently running process.
+ */
+setpri(up)
+{
+ register *pp, p;
+
+ pp = up;
+ p = (pp->p_cpu & 0377)/16;
+ p =+ PUSER + pp->p_nice;
+ if(p > 127)
+ p = 127;
+ if(p > curpri)
+ runrun++;
+ pp->p_pri = p;
+}
+
+/*
+ * The main loop of the scheduling (swapping)
+ * process.
+ * The basic idea is:
+ * see if anyone wants to be swapped in;
+ * swap out processes until there is room;
+ * swap him in;
+ * repeat.
+ * Although it is not remarkably evident, the basic
+ * synchronization here is on the runin flag, which is
+ * slept on and is set once per second by the clock routine.
+ * Core shuffling therefore takes place once per second.
+ *
+ * panic: swap error -- IO error while swapping.
+ * this is the one panic that should be
+ * handled in a less drastic way. Its
+ * very hard.
+ */
+sched()
+{
+ struct proc *p1;
+ register struct proc *rp;
+ register a, n;
+
+ /*
+ * find user to swap in
+ * of users ready, select one out longest
+ */
+
+ goto loop;
+
+sloop:
+ runin++;
+ sleep(&runin, PSWP);
+
+loop:
+ spl6();
+ n = -1;
+ for(rp = &proc[0]; rp < &proc[NPROC]; rp++)
+ if(rp->p_stat==SRUN && (rp->p_flag&SLOAD)==0 &&
+ rp->p_time > n) {
+ p1 = rp;
+ n = rp->p_time;
+ }
+ if(n == -1) {
+ runout++;
+ sleep(&runout, PSWP);
+ goto loop;
+ }
+
+ /*
+ * see if there is core for that process
+ */
+
+ spl0();
+ rp = p1;
+ a = rp->p_size;
+ if((rp=rp->p_textp) != NULL)
+ if(rp->x_ccount == 0)
+ a =+ rp->x_size;
+ if((a=malloc(coremap, a)) != NULL)
+ goto found2;
+
+ /*
+ * none found,
+ * look around for easy core
+ */
+
+ spl6();
+ for(rp = &proc[0]; rp < &proc[NPROC]; rp++)
+ if((rp->p_flag&(SSYS|SLOCK|SLOAD))==SLOAD &&
+ (rp->p_stat == SWAIT || rp->p_stat==SSTOP))
+ goto found1;
+
+ /*
+ * no easy core,
+ * if this process is deserving,
+ * look around for
+ * oldest process in core
+ */
+
+ if(n < 3)
+ goto sloop;
+ n = -1;
+ for(rp = &proc[0]; rp < &proc[NPROC]; rp++)
+ if((rp->p_flag&(SSYS|SLOCK|SLOAD))==SLOAD &&
+ (rp->p_stat==SRUN || rp->p_stat==SSLEEP) &&
+ rp->p_time > n) {
+ p1 = rp;
+ n = rp->p_time;
+ }
+ if(n < 2)
+ goto sloop;
+ rp = p1;
+
+ /*
+ * swap user out
+ */
+
+found1:
+ spl0();
+ rp->p_flag =& ~SLOAD;
+ xswap(rp, 1, 0);
+ goto loop;
+
+ /*
+ * swap user in
+ */
+
+found2:
+ if((rp=p1->p_textp) != NULL) {
+ if(rp->x_ccount == 0) {
+ if(swap(rp->x_daddr, a, rp->x_size, B_READ))
+ goto swaper;
+ rp->x_caddr = a;
+ a =+ rp->x_size;
+ }
+ rp->x_ccount++;
+ }
+ rp = p1;
+ if(swap(rp->p_addr, a, rp->p_size, B_READ))
+ goto swaper;
+ mfree(swapmap, (rp->p_size+7)/8, rp->p_addr);
+ rp->p_addr = a;
+ rp->p_flag =| SLOAD;
+ rp->p_time = 0;
+ goto loop;
+
+swaper:
+ panic("swap error");
+}
+
+/*
+ * This routine is called to reschedule the CPU.
+ * if the calling process is not in RUN state,
+ * arrangements for it to restart must have
+ * been made elsewhere, usually by calling via sleep.
+ */
+swtch()
+{
+ static struct proc *p;
+ register i, n;
+ register struct proc *rp;
+
+ if(p == NULL)
+ p = &proc[0];
+ /*
+ * Remember stack of caller
+ */
+ savu(u.u_rsav);
+ /*
+ * Switch to scheduler's stack
+ */
+ retu(proc[0].p_addr);
+
+loop:
+ runrun = 0;
+ rp = p;
+ p = NULL;
+ n = 128;
+ /*
+ * Search for highest-priority runnable process
+ */
+ i = NPROC;
+ do {
+ rp++;
+ if(rp >= &proc[NPROC])
+ rp = &proc[0];
+ if(rp->p_stat==SRUN && (rp->p_flag&SLOAD)!=0) {
+ if(rp->p_pri < n) {
+ p = rp;
+ n = rp->p_pri;
+ }
+ }
+ } while(--i);
+ /*
+ * If no process is runnable, idle.
+ */
+ if(p == NULL) {
+ p = rp;
+ idle();
+ goto loop;
+ }
+ rp = p;
+ curpri = n;
+ /*
+ * Switch to stack of the new process and set up
+ * his segmentation registers.
+ */
+ retu(rp->p_addr);
+ sureg();
+ /*
+ * If the new process paused because it was
+ * swapped out, set the stack level to the last call
+ * to savu(u_ssav). This means that the return
+ * which is executed immediately after the call to aretu
+ * actually returns from the last routine which did
+ * the savu.
+ *
+ * You are not expected to understand this.
+ */
+ if(rp->p_flag&SSWAP) {
+ rp->p_flag =& ~SSWAP;
+ aretu(u.u_ssav);
+ }
+ /*
+ * The value returned here has many subtle implications.
+ * See the newproc comments.
+ */
+ return(1);
+}
+
+/*
+ * Create a new process-- the internal version of
+ * sys fork.
+ * It returns 1 in the new process.
+ * How this happens is rather hard to understand.
+ * The essential fact is that the new process is created
+ * in such a way that appears to have started executing
+ * in the same call to newproc as the parent;
+ * but in fact the code that runs is that of swtch.
+ * The subtle implication of the returned value of swtch
+ * (see above) is that this is the value that newproc's
+ * caller in the new process sees.
+ */
+newproc()
+{
+ int a1, a2;
+ struct proc *p, *up;
+ register struct proc *rpp;
+ register *rip, 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 < 0) {
+ 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)
+ goto retry;
+ }
+ if ((rpp = p)==NULL)
+ panic("no procs");
+
+ /*
+ * make proc entry for new proc
+ */
+
+ rip = u.u_procp;
+ up = rip;
+ rpp->p_stat = SRUN;
+ rpp->p_flag = SLOAD;
+ rpp->p_uid = rip->p_uid;
+ rpp->p_ttyp = rip->p_ttyp;
+ rpp->p_nice = rip->p_nice;
+ rpp->p_textp = rip->p_textp;
+ rpp->p_pid = mpid;
+ rpp->p_ppid = rip->p_pid;
+ rpp->p_time = 0;
+
+ /*
+ * make duplicate entries
+ * where needed
+ */
+
+ for(rip = &u.u_ofile[0]; rip < &u.u_ofile[NOFILE];)
+ if((rpp = *rip++) != NULL)
+ rpp->f_count++;
+ if((rpp=up->p_textp) != NULL) {
+ rpp->x_count++;
+ rpp->x_ccount++;
+ }
+ u.u_cdir->i_count++;
+ /*
+ * Partially simulate the environment
+ * of the new process so that when it is actually
+ * created (by copying) it will look right.
+ */
+ savu(u.u_rsav);
+ rpp = p;
+ u.u_procp = rpp;
+ rip = up;
+ n = rip->p_size;
+ a1 = rip->p_addr;
+ rpp->p_size = n;
+ a2 = malloc(coremap, n);
+ /*
+ * If there is not enough core for the
+ * new process, swap out the current process to generate the
+ * copy.
+ */
+ if(a2 == NULL) {
+ rip->p_stat = SIDL;
+ rpp->p_addr = a1;
+ savu(u.u_ssav);
+ xswap(rpp, 0, 0);
+ rpp->p_flag =| SSWAP;
+ rip->p_stat = SRUN;
+ } else {
+ /*
+ * There is core, so just copy.
+ */
+ rpp->p_addr = a2;
+ while(n--)
+ copyseg(a1++, a2++);
+ }
+ u.u_procp = rip;
+ return(0);
+}
+
+/*
+ * Change the size of the data+stack regions of the process.
+ * If the size is shrinking, it's easy-- just release the extra core.
+ * If it's growing, and there is core, just allocate it
+ * and copy the image, taking care to reset registers to account
+ * for the fact that the system's stack has moved.
+ * If there is no core, arrange for the process to be swapped
+ * out after adjusting the size requirement-- when it comes
+ * in, enough core will be allocated.
+ * Because of the ssave and SSWAP flags, control will
+ * resume after the swap in swtch, which executes the return
+ * from this stack level.
+ *
+ * After the expansion, the caller will take care of copying
+ * the user's stack towards or away from the data area.
+ */
+expand(newsize)
+{
+ int i, n;
+ register *p, a1, a2;
+
+ p = u.u_procp;
+ n = p->p_size;
+ p->p_size = newsize;
+ a1 = p->p_addr;
+ if(n >= newsize) {
+ mfree(coremap, n-newsize, a1+newsize);
+ return;
+ }
+ savu(u.u_rsav);
+ a2 = malloc(coremap, newsize);
+ if(a2 == NULL) {
+ savu(u.u_ssav);
+ xswap(p, 1, n);
+ p->p_flag =| SSWAP;
+ swtch();
+ /* no return */
+ }
+ p->p_addr = a2;
+ for(i=0; i<n; i++)
+ copyseg(a1+i, a2++);
+ mfree(coremap, n, a1);
+ retu(p->p_addr);
+ sureg();
+}
projects / unix-history / commitdiff