plan 9 kernel history: overview | file list | diff list

1990/11211/port/proc.c (diff list | history)

port/proc.c on 1990/0227
1990/0227    
#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; 
		puttlbx(0, KZERO | PTEPID(0), 0);	/* safety first */ 
		u = 0; 
		if(p->state == Running) 
			ready(p); 
		else if(p->state == Moribund){ 
			p->pid = 0; 
			unlock(&p->debug);
1990/0801    
			unusepage(p->upage, 1);
1990/0227    
			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;
1990/0731    
	void (*f)(ulong, ulong);
1990/0227    
 
	if(u){ 
		splhi(); 
		if(setlabel(&u->p->sched)){	/* woke up */ 
			p = u->p; 
			p->state = Running; 
			p->mach = m; 
			m->proc = p; 
			spllo(); 
			return; 
		} 
		gotolabel(&m->sched); 
	} 
	if(f = m->intr){			/* assign = */ 
		m->intr = 0;
1990/0731    
		(*f)(m->cause, m->pc);
1990/0227    
	} 
	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; 
	int i; 
 
loop: 
	while(runq.head == 0) 
		for(i=0; i<10; i++) 
			; 
	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;
1990/03081    
		p->kid = 0; 
		p->sib = 0;
1990/0309    
		p->pop = 0;
1990/0227    
		p->nchild = 0; 
		p->child = 0; 
		p->exiting = 0;
1990/0722    
		p->fpstate = FPinit;
1990/0227    
		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");
1990/0619    
	u->p->state = Wakeme;
1990/0227    
	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;
1990/0310    
	for(i=0; i<conf.nproc-1; i++,p++)
1990/0227    
		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)
1990/03013    
		print("double sleep %d %d\n", r->p->pid, p->pid);
1990/0227    
	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;
1990/11211    
		error(Eintr);
1990/0227    
	} 
} 
 
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;
1990/11211    
		error(Eintr);
1990/0227    
	} 
} 
 
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); 
}
1990/03091    
void 
wakeme(Alarm *a) 
{ 
	ready((Proc*)(a->arg)); 
	cancel(a); 
} 
 
void 
twakeme(Alarm *a) 
{ 
	wakeup((Rendez*)(a->arg)); 
}
1990/0227    
int 
postnote(Proc *p, int dolock, char *n, int flag) 
{ 
	User *up;
1990/0617    
	KMap *k;
1990/0227    
	int s; 
	Rendez *r; 
 
	if(dolock) 
		lock(&p->debug);
1990/0617    
	k = kmap(p->upage); 
	up = (User*)VA(k);
1990/0227    
	if(flag!=NUser && (up->notify==0 || up->notified)) 
		up->nnote = 0;	/* force user's hand */
1990/0617    
	else if(up->nnote == NNOTE-1){ 
		kunmap(k);
1990/0227    
		return 0;
1990/0617    
	}
1990/0227    
	strcpy(up->note[up->nnote].msg, n); 
	up->note[up->nnote++].flag = flag;
1990/0617    
	kunmap(k);
1990/0227    
	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; 
}
1990/1101    
 
/* 
 * weird thing: keep at most NBROKEN around 
 */ 
#define	NBROKEN 4 
struct{ 
	Lock; 
	int	n; 
	Proc	*p[NBROKEN]; 
}broken;
1990/0227    
void
1990/1101    
addbroken(Proc *c) 
{ 
	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); 
	c->state = Broken; 
	sched();		/* until someone lets us go */ 
	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); 
} 
 
int 
freebroken(void) 
{ 
	int n; 
 
 
	lock(&broken); 
	n = broken.n; 
	while(broken.n > 0){ 
		ready(broken.p[0]); 
		memcpy(&broken.p[0], &broken.p[1], sizeof(Proc*)*(NBROKEN-1)); 
		--broken.n; 
	} 
	unlock(&broken); 
	return n; 
} 
 
void
1990/0227    
pexit(char *s, int freemem) 
{ 
	char status[64]; 
	ulong mypid;
1990/03081    
	Proc *p, *c, *k, *l;
1990/0227    
	Waitmsg w; 
	int n;
1990/03081    
	Chan *ch;
1990/0227    
	ulong *up, *ucp, *wp;
1990/03081    
	c = u->p; 
	mypid = c->pid;
1990/0227    
	if(s) 
		strcpy(status, s); 
	else 
		status[0] = 0; 
	if(freemem){ 
		freesegs(-1);
1990/03081    
		closepgrp(c->pgrp);
1990/0227    
		close(u->dot); 
	} 
	for(n=0; n<=u->maxfd; n++)
1990/03081    
		if(ch = u->fd[n])	/* assign = */ 
			close(ch);
1990/0227    
	/* 
	 * Any of my children exiting? 
	 */
1990/03081    
	while(c->nchild){
1990/0324    
		lock(&c->wait.queue); 
		if(canlock(&c->wait.use)){	/* no child is exiting */
1990/03081    
			c->exiting = 1;
1990/0324    
			unlock(&c->wait.use); 
			unlock(&c->wait.queue);
1990/0227    
			break; 
		}else{				/* must wait for child */
1990/0324    
			unlock(&c->wait.queue);
1990/0227    
			pwait(0); 
		} 
	}
1990/03081    
	c->time[TReal] = MACHP(0)->ticks - c->time[TReal];
1990/0227    
	/* 
	 * Tell my parent 
	 */
1990/03081    
	p = c->parent;
1990/0227    
	if(p == 0) 
		goto out; 
	qlock(&p->wait);
1990/0324    
	lock(&p->wait.queue);
1990/03081    
	if(p->pid==c->parentpid && !p->exiting){
1990/0227    
		w.pid = mypid; 
		strcpy(w.msg, status); 
		wp = &w.time[TUser];
1990/03081    
		up = &c->time[TUser]; 
		ucp = &c->time[TCUser];
1990/0614    
		*wp++ = TK2MS(*up++ + *ucp++); 
		*wp++ = TK2MS(*up++ + *ucp  ); 
		*wp   = TK2MS(*up           );
1990/03081    
		p->child = c;
1990/0227    
		/* 
		 * Pass info through back door, to avoid huge Proc's 
		 */
1990/0617    
		p->waitmsg = (((ulong)&w)&(BY2PG-1));
1990/03081    
		c->state = Exiting;
1990/0227    
		if(p->state == Inwait) 
			ready(p);
1990/0324    
		unlock(&p->wait.queue);
1990/0227    
		sched(); 
	}else{
1990/0324    
		unlock(&p->wait.queue);
1990/0227    
		qunlock(&p->wait); 
	} 
   out: 
	if(!freemem){
1990/1101    
		addbroken(c);
1990/0227    
		freesegs(-1);
1990/03081    
		closepgrp(c->pgrp);
1990/0227    
		close(u->dot); 
	}
1990/03081    
 
	/* 
	 * 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);
1990/0227    
	lock(&procalloc);	/* sched() can't do this */
1990/03081    
	lock(&c->debug);	/* sched() can't do this */ 
	c->state = Moribund;
1990/0227    
	sched();	/* never returns */ 
} 
 
ulong 
pwait(Waitmsg *w) 
{ 
	Proc *c, *p;
1990/0617    
	KMap *k;
1990/0227    
	ulong cpid; 
 
	p = u->p; 
again:
1990/0324    
	while(canlock(&p->wait.use)){
1990/0227    
		if(p->nchild == 0){ 
			qunlock(&p->wait);
1990/11211    
			error(Enochild);
1990/0227    
		} 
		p->state = Inwait; 
		qunlock(&p->wait); 
		sched(); 
	}
1990/0324    
	lock(&p->wait.queue);	/* wait until child is finished */
1990/0227    
	c = p->child; 
	if(c == 0){ 
		p->state = Inwait;
1990/0324    
		unlock(&p->wait.queue);
1990/0227    
		sched(); 
		goto again; 
	} 
	p->child = 0;
1990/0617    
	k = kmap(c->upage);
1990/0227    
	if(w)
1990/0617    
		*w = *(Waitmsg*)(p->waitmsg|VA(k)); 
	cpid = ((Waitmsg*)(p->waitmsg|VA(k)))->pid; 
	kunmap(k);
1990/0227    
	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--;
1990/0324    
	unlock(&p->wait.queue);
1990/0227    
	qunlock(&p->wait); 
	ready(c); 
	return cpid; 
} 
 
 
Proc* 
proctab(int i) 
{ 
	return &procalloc.arena[i]; 
} 
 
#include <ureg.h> 
DEBUG() 
{
1990/0330    
	int i;
1990/0227    
	Proc *p;
1990/0312    
	Orig *o;
1990/0227    
 
	print("DEBUG\n"); 
	for(i=0; i<conf.nproc; i++){ 
		p = procalloc.arena+i;
1990/0312    
		if(p->state != Dead){
1990/0704    
			print("%d:%s %s upc %lux %s ut %ld st %ld r %lux\n", 
				p->pid, p->text, p->pgrp->user, p->pc, statename[p->state],
1990/0629    
				p->time[0], p->time[1], p->r);
1990/0312    
		}
1990/0227    
	} 
} 
 
void 
kproc(char *name, void (*func)(void *), void *arg) 
{ 
	Proc *p; 
	int n; 
	ulong upa;
1990/0424    
	int lastvar;	/* used to compute stack address */
1990/0617    
	User *up; 
	KMap *k;
1990/0722    
	static Pgrp *kpgrp;
1990/0227    
 
	/* 
	 * Kernel stack 
	 */ 
	p = newproc(); 
	p->upage = newpage(1, 0, USERADDR|(p->pid&0xFFFF));
1990/0617    
	k = kmap(p->upage); 
	upa = VA(k); 
	up = (User*)upa; 
	up->p = p;
1990/0227    
 
	/* 
	 * Save time: only copy u-> data and useful stack 
	 */
1990/0617    
	memcpy(up, u, sizeof(User));
1990/0227    
	n = USERADDR+BY2PG - (ulong)&lastvar; 
	n = (n+32) & ~(BY2WD-1);	/* be safe & word align */
1990/0617    
	memcpy((void*)(upa+BY2PG-n), (void*)(USERADDR+BY2PG-n), n);
1990/0227    
 
	/* 
	 * Refs 
	 */ 
	incref(up->dot); 
	for(n=0; n<=up->maxfd; n++) 
		up->fd[n] = 0; 
	up->maxfd = 0;
1990/0617    
	kunmap(k);
1990/0227    
 
	/* 
	 * Sched 
	 */ 
	if(setlabel(&p->sched)){ 
		u->p = p; 
		p->state = Running; 
		p->mach = m; 
		m->proc = p; 
		spllo(); 
		(*func)(arg); 
		pexit(0, 1); 
	}
1990/0722    
	if(kpgrp == 0){ 
		kpgrp = newpgrp(); 
		strcpy(kpgrp->user, "bootes"); 
	} 
	p->pgrp = kpgrp; 
	incref(kpgrp); 
	sprint(p->text, "%s.%.6s", name, u->p->pgrp->user);
1990/0227    
	p->nchild = 0; 
	p->parent = 0; 
	memset(p->time, 0, sizeof(p->time)); 
	p->time[TReal] = MACHP(0)->ticks; 
	ready(p); 
	flushmmu(); 
}


source code copyright © 1990-2005 Lucent Technologies; see license
Plan 9 distribution
comments to russ cox (rsc@swtch.com)