## diffname gnot/proc.c 1990/03091
## diff -e /dev/null /n/bootesdump/1990/03091/sys/src/9/68020/proc.c
0a
#include	"u.h"
#include	"lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"errno.h"

struct
{
	Lock;
	ulong	pid;
}pidalloc;

struct
{
	Lock;
	Proc	*arena;
	Proc	*free;
}procalloc;

struct
{
	Lock;
	Proc	*head;
	Proc	*tail;
}runq;

char *statename[]={	/* BUG: generate automatically */
	"Dead",
	"Moribund",
	"Zombie",
	"Ready",
	"Scheding",
	"Running",
	"Queueing",
	"MMUing",
	"Exiting",
	"Inwait",
	"Wakeme",
	"Broken",
};

/*
 * Always splhi()'ed.
 */
void
schedinit(void)		/* never returns */
{
	Proc *p;

	setlabel(&m->sched);
	if(u){
		m->proc = 0;
		p = u->p;
		putkmmu(USERADDR, INVALIDPTE);	/* safety first */
		u = 0;
		if(p->state == Running)
			ready(p);
		else if(p->state == Moribund){
			p->pid = 0;
			unlock(&p->debug);
			p->upage->ref--;
			/* procalloc already locked */
			p->qnext = procalloc.free;
			procalloc.free = p;
			p->upage = 0;
			unlock(&procalloc);
			p->state = Dead;
		}
		p->mach = 0;
	}
	sched();
}

void
sched(void)
{
	Proc *p;
	ulong tlbvirt, tlbphys;
	void (*f)(ulong);

	if(u){
		splhi();
		if(setlabel(&u->p->sched)){	/* woke up */
if(u->p->mach)panic("mach non zero");
			p = u->p;
			p->state = Running;
			p->mach = m;
			m->proc = p;
			spllo();
			return;
		}
		gotolabel(&m->sched);
	}
	spllo();
	p = runproc();
	splhi();
	mapstack(p);
	gotolabel(&p->sched);
}

void
ready(Proc *p)
{
	int s;

	s = splhi();
	lock(&runq);
	p->rnext = 0;
	if(runq.tail)
		runq.tail->rnext = p;
	else
		runq.head = p;
	runq.tail = p;
	p->state = Ready;
	unlock(&runq);
	splx(s);
}

/*
 * Always called spllo
 */
Proc*
runproc(void)
{
	Proc *p;

loop:
	do; while(runq.head == 0);
	splhi();
	lock(&runq);
	p = runq.head;
	if(p==0 || p->mach){	/* p->mach==0 only when process state is saved */
		unlock(&runq);
		spllo();
		goto loop;
	}
	if(p->rnext == 0)
		runq.tail = 0;
	runq.head = p->rnext;
	if(p->state != Ready)
		print("runproc %s %d %s\n", p->text, p->pid, statename[p->state]);
	unlock(&runq);
	p->state = Scheding;
	spllo();
	return p;
}

Proc*
newproc(void)
{
	Proc *p;

loop:
	lock(&procalloc);
	if(p = procalloc.free){		/* assign = */
		procalloc.free = p->qnext;
		p->state = Zombie;
		unlock(&procalloc);
		p->mach = 0;
		p->qnext = 0;
		p->kid = 0;
		p->sib = 0;
		p->pop = 0;
		p->nchild = 0;
		p->child = 0;
		p->exiting = 0;
		memset(p->pidonmach, 0, sizeof p->pidonmach);
		memset(p->seg, 0, sizeof p->seg);
		lock(&pidalloc);
		p->pid = ++pidalloc.pid;
		unlock(&pidalloc);
		if(p->pid == 0)
			panic("pidalloc");
		return p;
	}
	unlock(&procalloc);
	print("no procs\n");
	if(u == 0)
		panic("newproc");
	alarm(1000, wakeme, u->p);
	sched();
	goto loop;
}

void
procinit0(void)		/* bad planning - clashes with devproc.c */
{
	Proc *p;
	int i;

	procalloc.free = ialloc(conf.nproc*sizeof(Proc), 0);
	procalloc.arena = procalloc.free;

	p = procalloc.free;
	for(i=0; i<conf.nproc-1; i++,p++){
		lock(p);	/* allocate now, not during wakeup */
		unlock(p);
		p->qnext = p+1;
	}
	p->qnext = 0;
}

void
sleep1(Rendez *r, int (*f)(void*), void *arg)
{
	Proc *p;
	int s;

	/*
	 * spl is to allow lock to be called
	 * at interrupt time. lock is mutual exclusion
	 */
	s = splhi();
	lock(r);

	/*
	 * if condition happened, never mind
	 */
	if((*f)(arg)){	
		unlock(r);
		splx(s);
		return;
	}

	/*
	 * now we are committed to
	 * change state and call scheduler
	 */
	p = u->p;
	if(r->p)
		print("double sleep %d %d\n", r->p->pid, p->pid);
	p->r = r;
	p->wokeup = 0;
	p->state = Wakeme;
	r->p = p;
	unlock(r);
}

void
sleep(Rendez *r, int (*f)(void*), void *arg)
{
	sleep1(r, f, arg);
	sched();
	if(u->p->wokeup){
		u->p->wokeup = 0;
		error(0, Eintr);
	}
}

void
tsleep(Rendez *r, int (*f)(void*), void *arg, int ms)
{
	Alarm *a;

	sleep1(r, f, arg);
	a = alarm(ms, twakeme, r);
	sched();
	cancel(a);
	if(u->p->wokeup){
		u->p->wokeup = 0;
		error(0, Eintr);
	}
}

void
wakeup(Rendez *r)
{
	Proc *p;
	int s;

	s = splhi();
	lock(r);
	p = r->p;
	if(p){
		r->p = 0;
		if(p->state != Wakeme)
			panic("wakeup: not Wakeme");
		p->r = 0;
		ready(p);
	}
	unlock(r);
	splx(s);
}

void
wakeme(Alarm *a)
{
	ready((Proc*)(a->arg));
	cancel(a);
}

void
twakeme(Alarm *a)
{
	wakeup((Rendez*)(a->arg));
}

int
postnote(Proc *p, int dolock, char *n, int flag)
{
	User *up;
	int s;
	Rendez *r;

	if(dolock)
		lock(&p->debug);
	up = (User*)(p->upage->pa|KZERO);
	if(flag!=NUser && (up->notify==0 || up->notified))
		up->nnote = 0;	/* force user's hand */
	else if(up->nnote == NNOTE-1)
		return 0;
	strcpy(up->note[up->nnote].msg, n);
	up->note[up->nnote++].flag = flag;
	if(dolock)
		unlock(&p->debug);
	if(r = p->r){	/* assign = */
		/* wake up */
		s = splhi();
		lock(r);
		if(p->r==r && r->p==p){
			r->p = 0;
			if(p->state != Wakeme)
				panic("postnote wakeup: not Wakeme");
			p->wokeup = 1;
			p->r = 0;
			ready(p);
		}
		unlock(r);
		splx(s);
	}
	return 1;
}

void
pexit(char *s, int freemem)
{
	char status[64];
	ulong mypid;
	Proc *p, *c, *k, *l;
	Waitmsg w;
	int n;
	Chan *ch;
	ulong *up, *ucp, *wp;

	c = u->p;
	mypid = c->pid;
	if(s)
		strcpy(status, s);
	else
		status[0] = 0;
	if(freemem){
		freesegs(-1);
		closepgrp(c->pgrp);
		close(u->dot);
	}
	for(n=0; n<=u->maxfd; n++)
		if(ch = u->fd[n])	/* assign = */
			close(ch);
	/*
	 * Any of my children exiting?
	 */
	while(c->nchild){
		lock(&c->wait.queue);
		if(canlock(&c->wait.use)){	/* no child is exiting */
			c->exiting = 1;
			unlock(&c->wait.use);
			unlock(&c->wait.queue);
			break;
		}else{				/* must wait for child */
			unlock(&c->wait.queue);
			pwait(0);
		}
	}

	c->time[TReal] = MACHP(0)->ticks - c->time[TReal];
	/*
	 * Tell my parent
	 */
	p = c->parent;
	if(p == 0)
		goto out;
	qlock(&p->wait);
	lock(&p->wait.queue);
	if(p->pid==c->parentpid && !p->exiting){
		w.pid = mypid;
		strcpy(w.msg, status);
		wp = &w.time[TUser];
		up = &c->time[TUser];
		ucp = &c->time[TCUser];
		*wp++ = (*up++ + *ucp++)*MS2HZ;
		*wp++ = (*up++ + *ucp  )*MS2HZ;
		*wp   = (*up           )*MS2HZ;
		p->child = c;
		/*
		 * Pass info through back door, to avoid huge Proc's
		 */
		p->waitmsg = (Waitmsg*)(c->upage->pa|(((ulong)&w)&(BY2PG-1))|KZERO);
		c->state = Exiting;
		if(p->state == Inwait)
			ready(p);
		unlock(&p->wait.queue);
		sched();
	}else{
		unlock(&p->wait.queue);
		qunlock(&p->wait);
	}
   out:
	if(!freemem){
		c->state = Broken;
		sched();		/* until someone lets us go */
		freesegs(-1);
		closepgrp(c->pgrp);
		close(u->dot);
	}

	/*
	 * Rearrange inheritance hierarchy
	 * 1. my children's pop is now my pop
	 */
	lock(&c->kidlock);
	p = c->pop;
	if(k = c->kid)		/* assign = */
		do{
			k->pop = p;
			k = k->sib;
		}while(k != c->kid);

	/*
	 * 2. cut me from pop's tree
	 */
	if(p == 0)	/* init process only; fix pops */
		goto done;
	lock(&p->kidlock);
	k = p->kid;
	while(k->sib != c)
		k = k->sib;
	if(k == c)
		p->kid = 0;
	else{
		if(p->kid == c)
			p->kid = c->sib;
		k->sib = c->sib;
	}

	/*
	 * 3. pass my children (pop's grandchildren) to pop
	 */
	if(k = c->kid){		/* assign = */
		if(p->kid == 0)
			p->kid = k;
		else{
			l = k->sib;
			k->sib = p->kid->sib;
			p->kid->sib = l;
		}
	}
	unlock(&p->kidlock);
    done:
	unlock(&c->kidlock);

	lock(&procalloc);	/* sched() can't do this */
	lock(&c->debug);	/* sched() can't do this */
	c->state = Moribund;
	sched();	/* never returns */
}

ulong
pwait(Waitmsg *w)
{
	Proc *c, *p;
	ulong cpid;

	p = u->p;
again:
	while(canlock(&p->wait.use)){
		if(p->nchild == 0){
			qunlock(&p->wait);
			error(0, Enochild);
		}
		p->state = Inwait;
		qunlock(&p->wait);
		sched();
	}
	lock(&p->wait.queue);	/* wait until child is finished */
	c = p->child;
	if(c == 0){
		print("pwait %d\n", p->pid);
		p->state = Inwait;
		unlock(&p->wait.queue);
		sched();
		goto again;
	}
	p->child = 0;
	if(w)
		*w = *p->waitmsg;
	cpid = p->waitmsg->pid;
	p->time[TCUser] += c->time[TUser] + c->time[TCUser];
	p->time[TCSys] += c->time[TSys] + c->time[TCSys];
	p->time[TCReal] += c->time[TReal];
	p->nchild--;
	unlock(&p->wait.queue);
	qunlock(&p->wait);
	ready(c);
	return cpid;
}

Proc*
proctab(int i)
{
	return &procalloc.arena[i];
}

#include <ureg.h>
DEBUG()
{
	int i;
	Proc *p;

	print("DEBUG\n");
	for(i=0; i<conf.nproc; i++){
		p = procalloc.arena+i;
		if(p->state != Dead)
			print("%d:%s upc %lux %s ut %ld st %ld\n",
				p->pid, p->text, p->pc, statename[p->state],
				p->time[0], p->time[1]);
	}
}
.
## diffname gnot/proc.c 1990/0310
## diff -e /n/bootesdump/1990/03091/sys/src/9/68020/proc.c /n/bootesdump/1990/0310/sys/src/9/68020/proc.c
200d
196,198c
	for(i=0; i<conf.nproc-1; i++,p++)
.
## diffname gnot/proc.c 1990/0312
## diff -e /n/bootesdump/1990/0310/sys/src/9/68020/proc.c /n/bootesdump/1990/0312/sys/src/9/68020/proc.c
524a
}

void
kproc(char *name, void (*func)(void *), void *arg)
{
	Proc *p;
	int n;
	ulong upa;
	int lastvar;	/* used to compute stack address */
	User *up;

	/*
	 * Kernel stack
	 */
	p = newproc();
	p->upage = newpage(1, 0, USERADDR|(p->pid&0xFFFF));
	upa = p->upage->pa|KZERO;
	up = (User *)upa;

	/*
	 * Save time: only copy u-> data and useful stack
	 */
	memcpy((void*)upa, u, sizeof(User));
	n = USERADDR+BY2PG - (ulong)&lastvar;
	n = (n+32) & ~(BY2WD-1);	/* be safe & word align */
	memcpy((void*)(upa+BY2PG-n), (void*)((u->p->upage->pa|KZERO)+BY2PG-n), n);
	((User *)upa)->p = p;

	/*
	 * Refs
	 */
	incref(up->dot);
	for(n=0; n<=up->maxfd; n++)
		up->fd[n] = 0;
	up->maxfd = 0;

	/*
	 * Sched
	 */
	if(setlabel(&p->sched)){
		u->p = p;
		p->state = Running;
		p->mach = m;
		m->proc = p;
		spllo();
		strncpy(p->text, name, sizeof p->text);
		(*func)(arg);
		pexit(0, 1);
	}
	p->pgrp = u->p->pgrp;
	incref(p->pgrp);
	p->nchild = 0;
	p->parent = 0;
	memset(p->time, 0, sizeof(p->time));
	p->time[TReal] = MACHP(0)->ticks;
	ready(p);
	flushmmu();
.
174a
print("allocate process %d\n", p->pid);
DEBUG();
.
## diffname gnot/proc.c 1990/0315
## diff -e /n/bootesdump/1990/0312/sys/src/9/68020/proc.c /n/bootesdump/1990/0315/sys/src/9/68020/proc.c
175,176d
## diffname gnot/proc.c 1990/0321
## diff -e /n/bootesdump/1990/0315/sys/src/9/68020/proc.c /n/bootesdump/1990/0321/sys/src/9/68020/proc.c
119a
void
checksched(void)		/* just for efficiency; don't sched if no need */
{
	if(runq.head)
		sched();
}

.
## diffname gnot/proc.c 1990/0509
## diff -e /n/bootesdump/1990/0321/sys/src/9/68020/proc.c /n/bootesdump/1990/0509/sys/src/9/68020/proc.c
415a
		lock(&broken);
		for(b=0; b<NBROKEN; b++)
			if(broken.p[b] == c){
				broken.n--;
				memcpy(&broken.p[b], &broken.p[b+1], sizeof(Proc*)*(NBROKEN-(b+1)));
				break;
			}
		unlock(&broken);
.
413a
		/*
		 * weird thing: keep at most NBROKEN around
		 */
		#define	NBROKEN 4
		static struct{
			Lock;
			int	n;
			Proc	*p[NBROKEN];
		}broken;
		int b;

		lock(&broken);
		if(broken.n == NBROKEN){
			ready(broken.p[0]);
			memcpy(&broken.p[0], &broken.p[1], sizeof(Proc*)*(NBROKEN-1));
			--broken.n;
		}
		broken.p[broken.n++] = c;
		unlock(&broken);
.
## diffname gnot/proc.c 1990/05313
## diff -e /n/bootesdump/1990/0509/sys/src/9/68020/proc.c /n/bootesdump/1990/05313/sys/src/9/68020/proc.c
557c
				p->time[0], p->time[1], p->qlock);
.
555c
			print("%d:%s upc %lux %s ut %ld st %ld %lux\n",
.
519d
175d
## diffname gnot/proc.c 1990/06021
## diff -e /n/bootesdump/1990/05313/sys/src/9/68020/proc.c /n/bootesdump/1990/06021/sys/src/9/68020/proc.c
591a
	kunmap(k);
.
582,583c
	memcpy((void*)(upa+BY2PG-n), (void*)(USERADDR+BY2PG-n), n);
.
579c
	memcpy(up, u, sizeof(User));
.
573,574c
	k = kmap(p->upage);
	upa = k->va;
	up = (User*)upa;
	up->p = p;
.
566a
	KMap *k;
.
525,526c
		*w = *(Waitmsg*)(p->waitmsg|k->va);
	cpid = ((Waitmsg*)(p->waitmsg|k->va))->pid;
	kunmap(k);
.
523a
	k = kmap(c->upage);
.
501a
	KMap *k;
.
401c
		p->waitmsg = (((ulong)&w)&(BY2PG-1));
.
317a
	kunmap(k);
.
315a
	}
.
314c
	else if(up->nnote == NNOTE-1){
		kunmap(k);
.
311c
	k = kmap(p->upage);
	up = (User*)k->va;
.
305a
	KMap *k;
.
## diffname gnot/proc.c 1990/06111
## diff -e /n/bootesdump/1990/06021/sys/src/9/68020/proc.c /n/bootesdump/1990/06111/sys/src/9/68020/proc.c
399,401c
		*wp++ = TK2MS(*up++ + *ucp++);
		*wp++ = TK2MS(*up++ + *ucp  );
		*wp   = TK2MS(*up           );
.
## diffname gnot/proc.c 1990/0614
## diff -e /n/bootesdump/1990/06111/sys/src/9/68020/proc.c /n/bootesdump/1990/0614/sys/src/9/68020/proc.c
583c
	upa = VA(k);
.
532,533c
		*w = *(Waitmsg*)(p->waitmsg|VA(k));
	cpid = ((Waitmsg*)(p->waitmsg|VA(k)))->pid;
.
313c
	up = (User*)VA(k);
.
## diffname gnot/proc.c 1990/0619
## diff -e /n/bootesdump/1990/0614/sys/src/9/68020/proc.c /n/bootesdump/1990/0619/sys/src/9/68020/proc.c
186a
	u->p->state = Wakeme;
.
## diffname gnot/proc.c 1990/0629
## diff -e /n/bootesdump/1990/0619/sys/src/9/68020/proc.c /n/bootesdump/1990/0629/sys/src/9/68020/proc.c
564c
				p->time[0], p->time[1], p->qlock, p->r);
.
562c
			print("%d:%s upc %lux %s ut %ld st %ld q %lux r %lux\n",
.
## diffname gnot/proc.c 1990/0705
## diff -e /n/bootesdump/1990/0629/sys/src/9/68020/proc.c /n/bootesdump/1990/0705/sys/src/9/68020/proc.c
513c
	while(canqlock(&p->wait)){
.
## diffname gnot/proc.c 1990/0722
## diff -e /n/bootesdump/1990/0705/sys/src/9/68020/proc.c /n/bootesdump/1990/0722/sys/src/9/68020/proc.c
174a
		p->fpstate = FPinit;
.
## diffname gnot/proc.c 1990/0725
## diff -e /n/bootesdump/1990/0722/sys/src/9/68020/proc.c /n/bootesdump/1990/0725/sys/src/9/68020/proc.c
619,620c
	if(kpgrp == 0){
		kpgrp = newpgrp();
		strcpy(kpgrp->user, "bootes");
	}
	p->pgrp = kpgrp;
	incref(kpgrp);
	sprint(p->text, "%s.%.6s", name, u->p->pgrp->user);
.
615d
577a
	static Pgrp *kpgrp;
.
## diffname gnot/proc.c 1990/0726
## diff -e /n/bootesdump/1990/0725/sys/src/9/68020/proc.c /n/bootesdump/1990/0726/sys/src/9/68020/proc.c
619,625c
	p->pgrp = u->p->pgrp;
	incref(p->pgrp);
.
615a
		strncpy(p->text, name, sizeof p->text);
.
578d
## diffname gnot/proc.c 1990/0728
## diff -e /n/bootesdump/1990/0726/sys/src/9/68020/proc.c /n/bootesdump/1990/0728/sys/src/9/68020/proc.c
619,620c
	if(kpgrp == 0){
		kpgrp = newpgrp();
		strcpy(kpgrp->user, "bootes");
	}
	p->pgrp = kpgrp;
	incref(kpgrp);
	sprint(p->text, "%s.%.6s", name, u->p->pgrp->user);
.
615d
577a
	static Pgrp *kpgrp;
.
## diffname gnot/proc.c 1990/08163
## diff -e /n/bootesdump/1990/0728/sys/src/9/68020/proc.c /n/bootesdump/1990/08163/sys/src/9/68020/proc.c
89a
			if(p->fpstate != m->fpstate){
				if(p->fpstate == FPinit){
					u->p->fpstate = FPinit;
					fprestore((FPsave*)&fpnull);
					m->fpstate = FPinit;
				}else{
					fpregrestore(u->fpsave.reg);
					fprestore(&u->fpsave);
					m->fpstate = FPdirty;
				}
			}
.
83a
		fpsave(&u->fpsave);
		if(u->fpsave.type){
			fpregsave(u->fpsave.reg);
			u->p->fpstate = FPactive;
			m->fpstate = FPdirty;
		}
.
80a
	long fpnull = 0;
.
## diffname gnot/proc.c 1990/0902
## diff -e /n/bootesdump/1990/08163/sys/src/9/68020/proc.c /n/bootesdump/1990/0902/sys/src/9/68020/proc.c
107a
			if(balu.cr0 != 0xFFFFFFFF)	/* balu busy */
				memcpy(BALU, &balu, sizeof balu);
.
90a
		if(BALU->cr0 != 0xFFFFFFFF)	/* balu busy */
			memcpy(&balu, BALU, sizeof balu);
		else{
			balu.cr0 = 0xFFFFFFFF;
			BALU->cr0 = 0xFFFFFFFF;
		}
.
84a

.
81a
	Balu balu;
.
7a
#include	<balu.h>

.
## diffname gnot/proc.c 1990/0905
## diff -e /n/bootesdump/1990/0902/sys/src/9/68020/proc.c /n/bootesdump/1990/0905/sys/src/9/68020/proc.c
110c
					fprestore(&initfp);
.
90a
			if(u->fpsave.size > sizeof u->fpsave.junk)
				panic("fpsize %d max %d\n", u->fpsave.size, sizeof u->fpsave.junk);
.
82,83d
8c
#include	<gnot.h>
.
## diffname gnot/proc.c 1990/0914
## diff -e /n/bootesdump/1990/0905/sys/src/9/68020/proc.c /n/bootesdump/1990/0914/sys/src/9/68020/proc.c
7a
#include	<libg.h>
.
## diffname gnot/proc.c 1990/0921
## diff -e /n/bootesdump/1990/0914/sys/src/9/68020/proc.c /n/bootesdump/1990/0921/sys/src/9/68020/proc.c
623a
	clearmmucache();
.
## diffname gnot/proc.c 1990/0928
## diff -e /n/bootesdump/1990/0921/sys/src/9/68020/proc.c /n/bootesdump/1990/0928/sys/src/9/68020/proc.c
624d
## diffname gnot/proc.c 1990/1004
## diff -e /n/bootesdump/1990/0928/sys/src/9/68020/proc.c /n/bootesdump/1990/1004/sys/src/9/68020/proc.c
642,646c
		restore();
.
635a
	up->p = p;
.
623a
	clearmmucache();
.
619d
614a
	p->kp = 1;
.
585c
void
DEBUG(void)
.
532a

	/*
	 * Call the scheduler.  This process gets cleaned up in restore() by the next
	 * process that runs.  That means that if there is no other process, we'll
	 * hang around for a little while.
	 */
.
206a
		p->kp = 0;
.
162,187d
151,160d
137a
	if (p->spin) {
		p->state = Running;
		return;
	}
.
127,130c

	/*
	 * Jumped to by schedinit.  Restore the process state.
	 */
	if (p->fpstate != m->fpstate)
		if (p->fpstate == FPinit) {
			initfp = 0;
			fprestore((FPsave *) &initfp);
			m->fpstate = FPinit;
		}
		else {
			fpregrestore(u->fpsave.reg);
			fprestore(&u->fpsave);
			m->fpstate = FPdirty;
		}
	if (balu.cr0 != 0xFFFFFFFF)	/* balu busy */
		memcpy(BALU, &balu, sizeof balu);

	/*
	 * Complete restoring the process.
	 */
	restore();
.
125a
	p->spin = 0;

	/*
	 * The first process on the run queue is the process we are going to run.  First
	 * save our state before we jump to schedinit.  If this process was running, put
	 * it on the run queue.
	 */
	if (p->state == Running) {
		p->state = Ready;
		p->rnext = 0;
		runq.tail->rnext = p;
		runq.tail = p;
	}

	/*
	 * Save some process state (if we haven't done that already) and save/restore
	 * pc and sp.  We have to jump to schedinit() because we are going to remap the
	 * stack.
	 */
	if (!saved)
		save(&balu);
	if (setlabel(&p->sched) == 0)
		gotolabel(&m->sched);

	/*
	 * Interrupts are ok now.  Note that the process state is still not Running,
	 * so no rescheduling.
	 */
.
119,124c
	
		/*
		 * Disable clock interrupts so that there will be no rescheduling in this
		 * section (on this machine).  If there is still a process on the run
		 * queue, break out of this loop.
		 */
		splhi();
		lock(&runq);
		if (runq.head != 0)
			break;
		unlock(&runq);
.
88,117c
	/*
	 * Look for a new process to be run.
	 */
	for (;;) {
		spllo();

		/*
		 * Idle loop.  Return when this process becomes runnable.  If nothing else
		 * to do, start saving some of the process state.
		 */
		while (runq.head == 0)
			if (p->state == Running)
				return;
			else if (!saved) {
				save(&balu);
				saved = 1;
.
85,86c
	/*
	 * Record that the process is spinning instead of blocked.  Ready() uses this
	 * information to decide what to do with the process.
	 */
	p->spin = 1;
.
83a
	int saved = 0;
.
81,82c
	Proc *p = u->p;
	long initfp;
.
78a
save(Balu *balu)
{
	fpsave(&u->fpsave);
	if (u->fpsave.type) {
		if(u->fpsave.size > sizeof u->fpsave.junk)
			panic("fpsize %d max %d\n", u->fpsave.size, sizeof u->fpsave.junk);
		fpregsave(u->fpsave.reg);
		u->p->fpstate = FPactive;
		m->fpstate = FPdirty;
	}
	if (BALU->cr0 != 0xFFFFFFFF)	/* balu busy */
		memcpy(balu, BALU, sizeof *balu);
	else {
		balu->cr0 = 0xFFFFFFFF;
		BALU->cr0 = 0xFFFFFFFF;
	}
}

/*
 * Reschedule the process.  We do not know whether the interrupt level is low or high
 * here, but we set it to low in any case.  If there is no other process to run, and
 * this process is Running, return immediately.  If this process is blocked, and there
 * is no other process to run, keep spinning until either this process or another
 * process becomes runnable.  If it was this process, we can return immediately.
 */
void
.
77a
/*
 * Save part of the process state.  Note: this is not the counterpart of restore().
 */
.
75d
55,73c

	/*
	 * Take a process from the run queue.  The run queue is locked here, and guaranteed
	 * to have a process on it.
	 */
	p = runq.head;
	if ((runq.head = p->rnext) == 0)
		runq.tail = 0;
	unlock(&runq);

	/*
	 * Ok, here we go.  We have a process and we can start running.
	 */
	mapstack(p);
	gotolabel(&p->sched);
}

/*
 * Complete the restoring of a process after mapstack().  The interrupt level here is low.
 * However, since the process is not Running, it cannot be rescheduled at this point.  We
 * set the process state to Running.  If the previous process was dead, clean it up.
 */
void
restore(void)
{
	Proc *p = m->proc;	/* previous process */

	u->p->mach = m;
	m->proc = u->p;
	u->p->state = Running;
	if (p->state == Moribund) {
		p->pid = 0;
		unlock(&p->debug);		/* set in pexit */
		p->upage->ref--;
		p->upage = 0;
		p->qnext = procalloc.free;
		procalloc.free = p;
		unlock(&procalloc);		/* set in pexit */
		p->state = Dead;
.
53a
	/*
	 * At init time:  wait for a process on the run queue.
	 */
	for (;;) {
		spllo();
		while (runq.head == 0)
			/* idle loop */;
		splhi();
		lock(&runq);
		if (runq.head != 0)
			break;
		unlock(&runq);
	}

	/*
	 * Set the u pointer and leave it there.  In fact, it might as well be a define.
	 */
	u = (User *) USERADDR;

	/*
	 * For later rescheduling.  Jumped to by sched() on stack switch.
	 */
.
47c
 * Called as the last routine in main().  Wait for a process on the run queue, grab it,
 * and run it.  Note that in this routine the interrupts are enabled for the first time.
.
45a
int page_alloc(int);	/* !ORIG */
void page_free(int, int);

.
## diffname gnot/proc.c 1990/1104
## diff -e /n/bootesdump/1990/1004/sys/src/9/68020/proc.c /n/bootesdump/1990/1104/sys/src/9/68020/proc.c
751a
	return p;
.
739,744c
	if(func){
		if(kpgrp == 0){
			kpgrp = newpgrp();
			strcpy(kpgrp->user, "bootes");
		}
		p->pgrp = kpgrp;
	} else
		p->pgrp = u->p->pgrp;
	incref(p->pgrp);
.
736,737c
		if(func){
			(*func)(arg);
			pexit(0, 1);
		} else
			return 0;
.
691c
/*
 *  create a kernel process.  if func is nonzero put the process in the kernel
 *  process group, have it call func, and exit.
 *
 *  otherwise, the new process stays in the same process group and returns.
 */
Proc *
.
## diffname gnot/proc.c 1990/1106
## diff -e /n/bootesdump/1990/1104/sys/src/9/68020/proc.c /n/bootesdump/1990/1106/sys/src/9/68020/proc.c
257d
254a
		splx(s);
.
253c
	s = splhi();
	if(p->spin){
.
239c
	if(balu.cr0 != 0xFFFFFFFF)	/* balu busy */
.
234c
		else{
.
228,229c
	if(p->fpstate != m->fpstate)
		if(p->fpstate == FPinit){
.
216c
	if(setlabel(&p->sched) == 0)
.
214c
	if(!saved)
.
202c
	if(p->state == Running){
.
191c
		if(runq.head != 0)
.
179c
			else if(!saved){
.
177c
			if(p->state == Running)
.
169c
	for (;;){
.
139c
	else{
.
137c
	if(BALU->cr0 != 0xFFFFFFFF)	/* balu busy */
.
130c
	if(u->fpsave.type){
.
111c
	if(p->state == Moribund){
.
87c
	if((runq.head = p->rnext) == 0)
.
67c
		if(runq.head != 0)
.
61c
	for(;;){
.
## diffname gnot/proc.c 1990/11062
## diff -e /n/bootesdump/1990/1106/sys/src/9/68020/proc.c /n/bootesdump/1990/11062/sys/src/9/68020/proc.c
138c
		memcpy(balu, BALU, sizeof(Balu));
.
## diffname gnot/proc.c 1990/1110
## diff -e /n/bootesdump/1990/11062/sys/src/9/68020/proc.c /n/bootesdump/1990/1110/sys/src/9/68020/proc.c
733,734c
		if(func)
			up->fd[n] = 0;
		else if(c = u->fd[n])		/* assign = */
			incref(c);
	if(!func)
		up->maxfd = 0;
.
701a
	Chan *c;
.
## diffname gnot/proc.c 1990/11211
## diff -e /n/bootesdump/1990/1110/sys/src/9/68020/proc.c /n/bootesdump/1990/11211/sys/src/9/68020/proc.c
639c
			error(Enochild);
.
383c
		error(Eintr);
.
368c
		error(Eintr);
.
## diffname gnot/proc.c 1990/1124
## diff -e /n/bootesdump/1990/11211/sys/src/9/68020/proc.c /n/bootesdump/1990/1124/sys/src/9/68020/proc.c
613d
570,611d
353c
		print("double sleep %lux %d %d\n", r, r->p->pid, p->pid);
.
284,286d
## diffname gnot/proc.c 1990/1211 # deleted
## diff -e /n/bootesdump/1990/1124/sys/src/9/68020/proc.c /n/bootesdump/1990/1211/sys/src/9/68020/proc.c
1,725d