1993/0501/port/proc.c (diff list | history)

1993/0309/sys/src/9/port/proc.c:51,86 – 1993/0501/sys/src/9/port/proc.c:51,82 (short | long | prev | next)
Rewrite sched - remove upage. Much code cleanup, converting u->p to up. Change in postnote: always ready(p) for rendezvous case again. (BUG FIX?) rsc Mon Mar 20 17:45:30 2006
1990/0227		void schedinit(void) /* never returns */ { Proc *p;                  setlabel(&m->sched); if(u){
1993/0501		if(up) {
1990/0227		m->proc = 0; p = u->p;
1990/1211		invalidateu(); /* safety first */
1990/0227		u = 0; if(p->state == Running) ready(p);
1992/0619		else if(p->state == Moribund) {
1990/0227		p->pid = 0;
1992/0620		p->state = Dead;
1993/0501		switch(up->state) { case Running: ready(up); break; case Moribund: up->pid = 0; up->state = Dead;
1991/0705		/*
1991/0717		* Holding locks from pexit:
1991/0705		* procalloc, debug, palloc */
1991/1003		mmurelease(p); simpleputpage(p->upage);
1991/0705		p->upage = 0;
1993/0501		mmurelease(up);
1991/0705
1990/0227		p->qnext = procalloc.free; procalloc.free = p;
1993/0501		up->qnext = procalloc.free; procalloc.free = up;
1991/0705		unlock(&palloc);
1991/1216		qunlock(&p->debug);
1993/0501		qunlock(&up->debug);
1990/0227		unlock(&procalloc);
1993/0501		break;
1990/0227		} p->mach = 0;
1993/0501		up->mach = 0; up = 0;
1990/0227		} sched(); }
1993/0309/sys/src/9/port/proc.c:88,113 – 1993/0501/sys/src/9/port/proc.c:84,106
1990/0227		void sched(void) { Proc *p;                  if(u){
1993/0501		if(up) {
1990/0227		splhi();
1991/0425		m->cs++;
1992/0122		procsave(u->p);
1990/0227		if(setlabel(&u->p->sched)){ /* woke up */ p = u->p; p->state = Running; p->mach = m; m->proc = p;
1992/0122		procrestore(p);
1993/0501		procsave(up); if(setlabel(&up->sched)) { procrestore(up);
1990/0227		spllo(); return; } gotolabel(&m->sched); } p = runproc(); mapstack(p); gotolabel(&p->sched);
1993/0501		up = runproc(); up->state = Running; up->mach = m; m->proc = up; mmuswitch(up); gotolabel(&up->sched);
1990/0227		}
1990/1227		int
1993/0309/sys/src/9/port/proc.c:119,133 – 1993/0501/sys/src/9/port/proc.c:112,125
1990/0227		void ready(Proc *p) {
1991/0420		Schedq *rq;
1990/0227		int s;
1993/0501		Schedq *rq;
1990/0227		s = splhi();
1991/0501
1993/0501		rq = &runhiq;
1991/0420		if(p->state == Running) rq = &runloq; else rq = &runhiq; lock(&runhiq);
1990/0227		p->rnext = 0;
1993/0309/sys/src/9/port/proc.c:154,160 – 1993/0501/sys/src/9/port/proc.c:146,152
1990/0227		loop:
1992/0603		spllo();
1991/0420		while(runhiq.head==0 && runloq.head==0)
1993/0501		while(runhiq.head == 0 && runloq.head == 0)
1992/0622		;
1990/0227		splhi();
1992/0622
1993/0309/sys/src/9/port/proc.c:165,171 – 1993/0501/sys/src/9/port/proc.c:157,164
1991/0420		rq = &runloq; p = rq->head;
1990/0227		if(p==0 || p->mach){ /* p->mach==0 only when process state is saved */
1993/0501		/* p->mach==0 only when process state is saved */ if(p == 0 || p->mach){
1991/0420		unlock(&runhiq);
1990/0227		goto loop; }
1993/0309/sys/src/9/port/proc.c:203,239 – 1993/0501/sys/src/9/port/proc.c:196,238
1990/0227		{ Proc *p;
1993/0501		lock(&procalloc);
1991/1110		for(;;) { lock(&procalloc); if(p = procalloc.free){ /* assign = */ procalloc.free = p->qnext; p->state = Scheding; p->psstate = "New"; unlock(&procalloc); p->mach = 0; p->qnext = 0; p->nchild = 0; p->nwait = 0; p->waitq = 0; p->pgrp = 0; p->egrp = 0; p->fgrp = 0; p->pdbg = 0; p->fpstate = FPinit; p->kp = 0; p->procctl = 0; p->notepending = 0; memset(p->seg, 0, sizeof p->seg);
1992/0309		p->pid = incref(&pidalloc);
1992/0428		p->noteid = incref(¬eidalloc); if(p->pid==0 || p->noteid==0)
1991/1110		panic("pidalloc"); return p; }
1993/0501		if(p = procalloc.free) break;
1990/0227		unlock(&procalloc);
1991/1110		resrcwait("no procs");
1993/0501		lock(&procalloc);
1990/0227		}
1992/0520		return 0; /* not reached */
1993/0501		procalloc.free = p->qnext; unlock(&procalloc); procalloc.free = p->qnext; p->state = Scheding; p->psstate = "New"; p->mach = 0; p->qnext = 0; p->nchild = 0; p->nwait = 0; p->waitq = 0; p->pgrp = 0; p->egrp = 0; p->fgrp = 0; p->pdbg = 0; p->fpstate = FPinit; p->kp = 0; p->procctl = 0; p->notepending = 0; memset(p->seg, 0, sizeof p->seg); p->pid = incref(&pidalloc); p->noteid = incref(¬eidalloc); if(p->pid==0 || p->noteid==0) panic("pidalloc"); if(p->kstack == 0) p->kstack = smalloc(KSTACK); return p;
1990/0227		} void
1993/0309/sys/src/9/port/proc.c:254,260 – 1993/0501/sys/src/9/port/proc.c:253,258
1990/0227		void sleep1(Rendez *r, int (*f)(void*), void *arg) { Proc *p; int s; /*
1993/0309/sys/src/9/port/proc.c:262,269 – 1993/0501/sys/src/9/port/proc.c:260,266
1990/0227		* at interrupt time. lock is mutual exclusion */ s = splhi();
1991/0727		p = u->p; p->r = r; /* early so postnote knows */
1993/0501		up->r = r; /* early so postnote knows */
1990/0227		lock(r); /*
1993/0309/sys/src/9/port/proc.c:270,276 – 1993/0501/sys/src/9/port/proc.c:267,273
1990/0227		* if condition happened, never mind */
1991/0727		if((*f)(arg)){ p->r = 0;
1993/0501		up->r = 0;
1990/0227		unlock(r); splx(s); return;
1993/0309/sys/src/9/port/proc.c:281,291 – 1993/0501/sys/src/9/port/proc.c:278,288
1990/0227		* change state and call scheduler */
1991/0807		if(r->p){
1990/03013		print("double sleep %d %d\n", r->p->pid, p->pid);
1993/0501		print("double sleep %d %d\n", r->p->pid, up->pid);
1991/0807		dumpstack(); }
1990/0227		p->state = Wakeme; r->p = p;
1993/0501		up->state = Wakeme; r->p = up;
1990/0227		unlock(r); }
1993/0309/sys/src/9/port/proc.c:292,309 – 1993/0501/sys/src/9/port/proc.c:289,305
1990/0227		void sleep(Rendez *r, int (*f)(void*), void *arg) {
1991/0727		Proc *p;
1992/0519		int s;
1991/0727		p = u->p;
1990/0227		sleep1(r, f, arg);
1991/0727		if(p->notepending == 0)
1993/0501		if(up->notepending == 0)
1991/0727		sched(); /* notepending may go true while asleep */ if(p->notepending){ p->notepending = 0;
1993/0501		if(up->notepending) { up->notepending = 0;
1992/0519		s = splhi();
1991/0805		lock(r); if(r->p == p)
1993/0501		if(r->p == up)
1991/0805		r->p = 0; unlock(r);
1992/0519		splx(s);
1993/0309/sys/src/9/port/proc.c:314,323 – 1993/0501/sys/src/9/port/proc.c:310,316
1992/0617		int tfn(void *arg) { Proc *p;                  p = u->p; return MACHP(0)->ticks >= p->twhen || (*p->tfn)(arg);
1993/0501		return MACHP(0)->ticks >= up->twhen || (*up->tfn)(arg);
1992/0617		}
1990/0227		void
1993/0309/sys/src/9/port/proc.c:324,341 – 1993/0501/sys/src/9/port/proc.c:317,333
1992/0602		tsleep(Rendez *r, int (*fn)(void*), void *arg, int ms)
1990/0227		{
1992/0602		ulong when;
1992/0701		Proc *p, *f, **l;
1993/0501		Proc *f, **l;
1990/0227
1991/0727		p = u->p;
1992/0602		when = MS2TK(ms)+MACHP(0)->ticks; lock(&talarm);
1992/0701		/* take out of list if checkalarm didn't */ if(p->trend) {
1993/0501		if(up->trend) {
1992/0701		l = &talarm.list; for(f = *l; f; f = f->tlink) { if(f == p) { *l = p->tlink;
1993/0501		if(f == up) { *l = up->tlink;
1992/0701		break; } l = &f->tlink;
1993/0309/sys/src/9/port/proc.c:348,362 – 1993/0501/sys/src/9/port/proc.c:340,354
1992/0701		break;
1992/0602		l = &f->tlink;
1991/0727		}
1992/0602		p->trend = r; p->twhen = when;
1992/0617		p->tfn = fn;
1992/0701		p->tlink = *l; *l = p;
1993/0501		up->trend = r; up->twhen = when; up->tfn = fn; up->tlink = *l; *l = up;
1992/0602		unlock(&talarm);
1992/0617		sleep(r, tfn, arg);
1992/0602		p->twhen = 0;
1993/0501		up->twhen = 0;
1990/0227		}
1992/0909		/*
1993/0309/sys/src/9/port/proc.c:385,392 – 1993/0501/sys/src/9/port/proc.c:377,382
1990/0227		int postnote(Proc *p, int dolock, char *n, int flag) { User *up;
1990/0617		KMap *k;
1991/1120		int s, ret;
1990/0227		Rendez *r;
1991/0806		Proc *d, **l;
1993/0309/sys/src/9/port/proc.c:397,433 – 1993/0501/sys/src/9/port/proc.c:387,406
1993/0112		if(p->kp) print("sending %s to kproc %d %s\n", n, p->pid, p->text);
1991/0810		if(p->upage == 0){ if(dolock)
1991/1216		qunlock(&p->debug);
1992/0527		return 0;
1991/0810		}
1993/0501		if(flag != NUser && (p->notify == 0 || p->notified)) p->nnote = 0;
1991/0425
1991/1115		SET(k);
1991/0523		if(u == 0 || p != u->p){
1991/0109		k = kmap(p->upage); up = (User*)VA(k);
1991/1115		}else
1991/0109		up = u;
1991/1127		USED(k);
1991/0523
1990/0227		if(flag!=NUser && (up->notify==0 || up->notified)) up->nnote = 0; /* force user's hand */
1991/1120		ret = 0; if(up->nnote < NNOTE){ strcpy(up->note[up->nnote].msg, n); up->note[up->nnote++].flag = flag;
1993/0501		if(p->nnote < NNOTE) { strcpy(p->note[up->nnote].msg, n); p->note[p->nnote++].flag = flag;
1991/1120		ret = 1;
1990/0617		}
1991/0727		p->notepending = 1;
1991/0109		if(up != u) kunmap(k);
1990/0227		if(dolock)
1991/1216		qunlock(&p->debug);
1991/0705
1991/0727		if(r = p->r){ /* assign = */ /* wake up; can't call wakeup itself because we're racing with it */
1993/0501		if(r = p->r) {
1992/0909		for(;;) { s = splhi(); if(canlock(r))
1993/0309/sys/src/9/port/proc.c:434,440 – 1993/0501/sys/src/9/port/proc.c:407,414
1992/0909		break; splx(s); } if(p->r==r && r->p==p && p->state==Wakeme){ /* check we won the race */
1993/0501		/* check we won the race */ if(p->r == r && r->p == p && p->state==Wakeme) {
1992/0909		r->p = 0; p->r = 0; ready(p);
1993/0309/sys/src/9/port/proc.c:454,464 – 1993/0501/sys/src/9/port/proc.c:428,438
1992/1206		for(d = *l; d; d = d->rendhash) { if(d == p) { *l = p->rendhash;
1993/0216		ready(p);
1992/1206		break;
1991/0806		}
1992/1206		l = &d->rendhash;
1991/0806		}
1993/0501		ready(p);
1991/0806		}
1992/1206		unlock(p->pgrp);
1991/1120		return ret;
1993/0309/sys/src/9/port/proc.c:529,555 – 1993/0501/sys/src/9/port/proc.c:503,529
1991/0717		pexit(char *exitstr, int freemem)
1990/0227		{
1991/1218		int n;
1992/0205		long utime, stime;
1991/0926		Proc *p, *c;
1993/0501		Proc *p;
1992/1206		Segment **s, **es;
1993/0501		long utime, stime;
1991/0926		Waitq *wq, *f, *next;
1990/0227
1990/03081		c = u->p;
1991/0513		c->alarm = 0;
1993/0501		up->alarm = 0;
1991/0517
1991/0712		if(c->fgrp) closefgrp(c->fgrp);
1991/1024		closepgrp(c->pgrp); close(u->dot); if(c->egrp) closeegrp(c->egrp);
1993/0501		if(up->fgrp) closefgrp(up->fgrp); if(up->egrp) closeegrp(up->egrp);
1991/0517
1993/0501		close(up->dot); closepgrp(up->pgrp);
1992/0115		/* * if not a kernel process and have a parent, * do some housekeeping. */
1992/0303		if(c->kp == 0) {
1992/1206		p = c->parent;
1993/0501		if(up->kp == 0) { p = up->parent;
1992/1206		if(p == 0) {
1992/0902		if(exitstr == 0) exitstr = "unknown";
1993/0309/sys/src/9/port/proc.c:557,577 – 1993/0501/sys/src/9/port/proc.c:531,552
1992/0902		}
1992/0805		while(waserror()) ;
1993/0501		;
1992/0620		wq = smalloc(sizeof(Waitq));
1992/0805		poperror();
1992/0309		readnum(0, wq->w.pid, NUMSIZE, c->pid, NUMSIZE);
1992/0205		utime = c->time[TUser] + c->time[TCUser]; stime = c->time[TSys] + c->time[TCSys];
1993/0501		readnum(0, wq->w.pid, NUMSIZE, up->pid, NUMSIZE); utime = up->time[TUser] + up->time[TCUser]; stime = up->time[TSys] + up->time[TCSys];
1992/0309		readnum(0, &wq->w.time[TUser*12], NUMSIZE, TK2MS(utime), NUMSIZE); readnum(0, &wq->w.time[TSys*12], NUMSIZE, TK2MS(stime), NUMSIZE); readnum(0, &wq->w.time[TReal*12], NUMSIZE, TK2MS(MACHP(0)->ticks - c->time[TReal]), NUMSIZE);
1993/0501		TK2MS(MACHP(0)->ticks - up->time[TReal]), NUMSIZE);
1991/1218		if(exitstr && exitstr[0]){ n = sprint(wq->w.msg, "%s %d:", c->text, c->pid);
1993/0501		n = sprint(wq->w.msg, "%s %d:", up->text, up->pid);
1991/1218		strncpy(wq->w.msg+n, exitstr, ERRLEN-n);
1992/1206		} else
1993/0309/sys/src/9/port/proc.c:578,587 – 1993/0501/sys/src/9/port/proc.c:553,563
1991/1006		wq->w.msg[0] = '\0';
1991/1005		lock(&p->exl);
1992/0309		/* My parent still alive, processes are limited to 128 Zombies to
1992/0620		* prevent a badly written daemon lots of wait records
1993/0501		/* My parent still alive, processes are limited to 128 * Zombies to prevent a badly written daemon lots of wait * records
1992/0620		*/
1991/1005		if(p->pid == c->parentpid && p->state != Broken && p->nwait < 128) {
1993/0501		if(p->pid == up->parentpid && p->state != Broken && p->nwait < 128) {
1991/1005		p->nchild--;
1992/0205		p->time[TCUser] += utime; p->time[TCSys] += stime;
1993/0309/sys/src/9/port/proc.c:590,596 – 1993/0501/sys/src/9/port/proc.c:566,572
1991/1005		p->waitq = wq; p->nwait++; unlock(&p->exl);
1993/0309
1993/0501
1991/1005		wakeup(&p->waitr); } else {
1993/0309/sys/src/9/port/proc.c:600,617 – 1993/0501/sys/src/9/port/proc.c:576,593
1990/0227		}
1990/03081
1991/0926		if(!freemem) addbroken(c);
1993/0501		addbroken(up);
1990/03081
1991/0926		es = &c->seg[NSEG]; for(s = c->seg; s < es; s++)
1993/0501		es = &up->seg[NSEG]; for(s = up->seg; s < es; s++)
1992/1206		if(*s) putseg(*s);
1991/0926		lock(&c->exl); /* Prevent my children from leaving waits */ c->pid = 0; unlock(&c->exl);
1993/0501		lock(&up->exl); /* Prevent my children from leaving waits */ up->pid = 0; unlock(&up->exl);
1991/0926		for(f = c->waitq; f; f = next) {
1993/0501		for(f = up->waitq; f; f = next) {
1991/0926		next = f->next;
1992/0620		free(f);
1991/0926		}
1993/0309/sys/src/9/port/proc.c:619,635 – 1993/0501/sys/src/9/port/proc.c:595,611
1991/0705		/* * sched() cannot wait on these locks */
1991/1216		qlock(&c->debug);
1993/0501		qlock(&up->debug);
1991/1110		/* release debuggers */ if(c->pdbg) { wakeup(&c->pdbg->sleep); c->pdbg = 0;
1993/0501		if(up->pdbg) { wakeup(&up->pdbg->sleep); up->pdbg = 0;
1991/1110		} lock(&procalloc);
1991/0705		lock(&palloc);
1990/03081		c->state = Moribund;
1993/0501		up->state = Moribund;
1991/0705		sched(); panic("pexit");
1990/0227		}
1993/0309/sys/src/9/port/proc.c:646,681 – 1993/0501/sys/src/9/port/proc.c:622,654
1990/0227		ulong pwait(Waitmsg *w) {
1991/0926		Proc *p;
1990/0227		ulong cpid;
1991/0926		Waitq *wq;
1990/0227		p = u->p;
1991/0926
1993/0309		if(!canqlock(&p->qwaitr))
1993/0501		if(!canqlock(&up->qwaitr))
1993/0309		error(Einuse); if(waserror()) { qunlock(&p->qwaitr);
1993/0501		qunlock(&up->qwaitr);
1993/0309		nexterror(); }
1991/0926		lock(&p->exl); if(p->nchild == 0 && p->waitq == 0) { unlock(&p->exl);
1993/0501		lock(&up->exl); if(up->nchild == 0 && up->waitq == 0) { unlock(&up->exl);
1991/0926		error(Enochild);
1990/0227		}
1991/0926		unlock(&p->exl);
1993/0501		unlock(&up->exl);
1991/0926		sleep(&p->waitr, haswaitq, u->p);
1993/0501		sleep(&up->waitr, haswaitq, up);
1991/0926		lock(&p->exl); wq = p->waitq; p->waitq = wq->next; p->nwait--; unlock(&p->exl);
1993/0501		lock(&up->exl); wq = up->waitq; up->waitq = wq->next; up->nwait--; unlock(&up->exl);
1993/0309		qunlock(&p->qwaitr);
1993/0501		qunlock(&up->qwaitr);
1993/0309		poperror();
1991/0926
1990/0227		if(w)
1993/0309/sys/src/9/port/proc.c:699,719 – 1993/0501/sys/src/9/port/proc.c:672,691
1990/0227		Proc *p;
1992/0805		ulong bss;
1990/0227		for(i=0; i<conf.nproc; i++){ p = procalloc.arena+i;
1990/0312		if(p->state != Dead){
1992/0805		bss = 0; if(p->seg[BSEG]) bss = p->seg[BSEG]->top;
1993/0501		for(i=0; i<conf.nproc; i++) { p = &procalloc.arena[i]; if(p->state == Dead) continue; bss = 0; if(p->seg[BSEG]) bss = p->seg[BSEG]->top;
1992/0805		s = p->psstate; if(s == 0) s = "kproc"; print("%3d:%10s %10s pc %8lux %8s (%s) ut %ld st %ld r %lux qpc %lux bss %lux\n",
1991/1105		p->pid, p->text, p->user, p->pc,
1992/0805		s, statename[p->state], p->time[0], p->time[1], p->r, p->qlockpc, bss);
1990/0312		}
1993/0501		s = p->psstate; if(s == 0) s = "kproc"; print("%3d:%10s pc %8lux %8s (%s) ut %ld st %ld bss %lux\n", p->pid, p->text, p->pc, s, statename[p->state], p->time[0], p->time[1], bss);
1990/0227		} }
1993/0309/sys/src/9/port/proc.c:721,778 – 1993/0501/sys/src/9/port/proc.c:693,726
1990/0227		kproc(char *name, void (*func)(void *), void *arg) { Proc *p; int n; ulong upa;
1990/0617		User *up; KMap *k;
1990/0722		static Pgrp *kpgrp;
1991/0705		char *user;
1992/0703		int lastvar; /* used to compute stack address */
1990/0227		/* * Kernel stack */ p = newproc();
1991/0926		p->psstate = 0;
1991/1112		p->procmode = 0644;
1990/1212		p->kp = 1;
1990/0227		p->upage = newpage(1, 0, USERADDR|(p->pid&0xFFFF));
1990/0617		k = kmap(p->upage); upa = VA(k); up = (User*)upa;
1990/0227		/* * Save time: only copy u-> data and useful stack */
1991/0318		memmove(up, u, sizeof(User));
1990/0227		n = USERADDR+BY2PG - (ulong)&lastvar; n = (n+32) & ~(BY2WD-1); /* be safe & word align */
1991/0318		memmove((void*)(upa+BY2PG-n), (void*)(USERADDR+BY2PG-n), n);
1991/0820		up->p = p;
1993/0501		p->fpsave = up->fpsave; p->scallnr = up->scallnr; p->s = up->s; p->nerrlab = 0; p->slash = up->slash; p->dot = up->dot; incref(p->dot);
1990/0227		/* * Refs */ incref(up->dot);
1990/0617		kunmap(k);
1993/0501		memmove(p->note, up->note, sizeof(p->note)); p->nnote = up->nnote; p->notified = 0; p->lastnote = up->lastnote; p->notify = up->notify; p->ureg = 0; p->dbgreg = 0;
1990/0227		/* * Sched */ if(setlabel(&p->sched)){ p->state = Running; p->mach = m; m->proc = p; spllo(); (*func)(arg); pexit(0, 1); }
1993/0501		kprocchild(p, func, arg);
1991/0705
1991/1109		user = eve;
1991/1105		strcpy(p->user, user);
1990/0722		if(kpgrp == 0){
1993/0501		strcpy(p->user, eve); if(kpgrp == 0)
1990/0722		kpgrp = newpgrp(); } p->pgrp = kpgrp; incref(kpgrp);
1991/0705
1993/0309/sys/src/9/port/proc.c:802,812 – 1993/0501/sys/src/9/port/proc.c:750,760
1991/1108
1991/0705		switch(p->procctl) { case Proc_exitme:
1992/0609		spllo(); /* pexit has locks in it */
1993/0501		spllo(); /* pexit has locks in it */
1991/0705		pexit("Killed", 1);
1992/0620
1991/1110		case Proc_traceme: if(u->nnote == 0)
1993/0501		if(p->nnote == 0)
1991/1110		return; /* No break */
1992/0620
1993/0309/sys/src/9/port/proc.c:834,840 – 1993/0501/sys/src/9/port/proc.c:782,788
1991/0710		void
1992/0604		error(char *err)
1991/0710		{
1992/0111		strncpy(u->error, err, ERRLEN);
1993/0501		strncpy(up->error, err, ERRLEN);
1991/0710		nexterror(); }
1993/0309/sys/src/9/port/proc.c:841,847 – 1993/0501/sys/src/9/port/proc.c:789,795
1991/0710		void
1992/0114		nexterror(void)
1991/0710		{
1992/0114		gotolabel(&u->errlab[--u->nerrlab]);
1993/0501		gotolabel(&up->errlab[--up->nerrlab]);
1991/0710		} void