1992/0607/port/pgrp.c (diff list | history)

port/pgrp.c on 1990/0227
1990/0227		#include "u.h"
1992/0321		#include "../port/lib.h"
1990/0227		#include "mem.h" #include "dat.h" #include "fns.h"
1992/0111		#include "../port/error.h"
1990/0227
1992/0128		Pgrps pgrpalloc;
1990/0227
1991/0705		struct { Lock; Egrp *free; }egrpalloc; struct { Lock; Fgrp *free; }fgrpalloc;
1990/0227		struct{ Lock; Mount *free;
1991/1011		Mhead *mhfree;
1990/0227		ulong mountid; }mountalloc; void
1991/0705		grpinit(void)
1990/0227		{ int i; Pgrp *p;
1991/0705		Egrp *e, *ee; Fgrp *f, *fe; Mount *m, *em;
1991/1011		Mhead *hm, *hem;
1991/1127		Crypt *cr;
1990/0227
1992/0128		i = conf.npgrp*sizeof(Crypt); cr = ialloc(i, 0); pgrpalloc.cryptbase = (ulong)cr; pgrpalloc.crypttop = (ulong)cr + i;
1990/1110		pgrpalloc.arena = ialloc(conf.npgrp*sizeof(Pgrp), 0); pgrpalloc.free = pgrpalloc.arena;
1990/0227		p = pgrpalloc.free;
1991/1011		for(i=0; i<conf.npgrp; i++,p++) {
1990/1110		p->index = i;
1990/0227		p->next = p+1;
1991/1127		p->crypt = cr++;
1990/0227		}
1990/0825		p[-1].next = 0;
1990/0227
1991/0705		egrpalloc.free = ialloc(conf.npgrp*sizeof(Egrp), 0); ee = &egrpalloc.free[conf.npgrp]; for(e = egrpalloc.free; e < ee; e++) { e->next = e+1;
1991/1018		e->etab = ialloc(conf.npgenv*sizeof(Env), 0);
1991/0705		} e[-1].next = 0;
1990/0227
1991/0705		fgrpalloc.free = ialloc(conf.nproc*sizeof(Fgrp), 0); fe = &fgrpalloc.free[conf.nproc-1]; for(f = fgrpalloc.free; f < fe; f++) f->next = f+1; f->next = 0;
1990/0227		} Pgrp*
1990/1110		pgrptab(int i) { return &pgrpalloc.arena[i]; } void
1992/0428		pgrpnote(ulong noteid, char *a, long n, int flag)
1990/1110		{
1992/0428		Proc *p, *ep;
1990/1110		char buf[ERRLEN]; if(n >= ERRLEN-1)
1990/11211		error(Etoobig);
1992/0428
1991/0318		memmove(buf, a, n);
1990/1110		buf[n] = 0; p = proctab(0);
1992/0428		ep = p+conf.nproc; for(; p < ep; p++) { if(p->state == Dead) continue; if(p->noteid == noteid && p->kp == 0) {
1991/1216		qlock(&p->debug);
1992/0428		if(p->pid==0 || p->noteid != noteid){
1991/1216		qunlock(&p->debug);
1990/1110		continue; }
1991/0125		if(!waserror()){ postnote(p, 0, buf, flag); poperror();
1990/1110		}
1991/1216		qunlock(&p->debug);
1990/1110		} } } Pgrp*
1990/0227		newpgrp(void) { Pgrp *p;
1991/0705		for(;;) { lock(&pgrpalloc); if(p = pgrpalloc.free){ pgrpalloc.free = p->next; p->ref = 1; p->pgrpid = ++pgrpalloc.pgrpid;
1991/1127		memset(p->crypt, 0, sizeof *p->crypt);
1991/0806		memset(p->rendhash, 0, sizeof(p->rendhash));
1991/1011		memset(p->mnthash, 0, sizeof(p->mnthash));
1991/0705		unlock(&pgrpalloc); return p; }
1990/0227		unlock(&pgrpalloc);
1991/0705		resrcwait("no pgrps");
1990/0227		}
1992/0520		return 0; /* not reached */
1991/0705		} Egrp* newegrp(void) { Egrp *e; for(;;) { lock(&egrpalloc); if(e = egrpalloc.free) { egrpalloc.free = e->next; e->ref = 1; e->nenv = 0; unlock(&egrpalloc); return e; } unlock(&egrpalloc); resrcwait("no envgrps"); }
1992/0520		return 0; /* not reached */
1991/0705		} Fgrp* newfgrp(void) { Fgrp *f; for(;;) { lock(&fgrpalloc); if(f = fgrpalloc.free) { fgrpalloc.free = f->next; f->ref = 1; f->maxfd = 0; memset(f->fd, 0, sizeof(f->fd)); unlock(&fgrpalloc); return f; } unlock(&fgrpalloc); resrcwait("no filegrps"); }
1992/0520		return 0; /* not reached */
1991/0705		} Fgrp* dupfgrp(Fgrp *f) { Fgrp *new; Chan *c; int i; new = newfgrp();
1992/0607		lock(f);
1991/0705		new->maxfd = f->maxfd; for(i = 0; i <= f->maxfd; i++) if(c = f->fd[i]){ incref(c); new->fd[i] = c; }
1992/0607		unlock(f);
1991/0705		return new; } void resrcwait(char *reason) {
1991/1110		char *p; p = u->p->psstate; if(reason) { u->p->psstate = reason;
1991/0710		print("%s\n", reason);
1991/1110		}
1990/0227		if(u == 0)
1991/0710		panic("resrcwait");
1992/0602		tsleep(&u->p->sleep, return0, 0, 1000);
1991/1110		u->p->psstate = p;
1990/0227		} void closepgrp(Pgrp *p) {
1991/1011		Mhead **h, **e, *f, *next;
1990/0227		if(decref(p) == 0){
1991/0212		qlock(&p->debug);
1990/1110		p->pgrpid = -1;
1991/1011		e = &p->mnthash[MNTHASH]; for(h = p->mnthash; h < e; h++) { for(f = *h; f; f = next) { close(f->from); mountfree(f->mount); next = f->hash; mntheadfree(f);
1990/0227		}
1991/1011		}
1990/0227		lock(&pgrpalloc); p->next = pgrpalloc.free; pgrpalloc.free = p;
1991/0212		qunlock(&p->debug);
1990/0227		unlock(&pgrpalloc); } }
1991/0705		void
1991/1018		closeegrp(Egrp *eg)
1991/0705		{
1991/1018		Env *e;
1991/0705		int i;
1991/1018		if(decref(eg) == 0) { e = eg->etab; for(i=0; i<eg->nenv; i++, e++) envpgclose(e);
1991/0705		lock(&egrpalloc);
1991/1018		eg->next = egrpalloc.free; egrpalloc.free = eg;
1991/0705		unlock(&egrpalloc); } } void closefgrp(Fgrp *f) { int i; Chan *c; if(decref(f) == 0) { for(i = 0; i <= f->maxfd; i++) if(c = f->fd[i]) close(c); lock(&fgrpalloc); f->next = fgrpalloc.free; fgrpalloc.free = f; unlock(&fgrpalloc); } }
1990/0227		Mount*
1991/1011		newmount(Mhead *mh, Chan *to)
1990/0227		{
1991/1011		Mount *m, *f, *e;
1990/0227
1991/1011		for(;;) { lock(&mountalloc); if(m = mountalloc.free){ /* assign = */ mountalloc.free = m->next; m->mountid = ++mountalloc.mountid; unlock(&mountalloc); m->next = 0; m->head = mh; m->to = to; incref(to); return m; }
1990/0227		unlock(&mountalloc);
1991/1011		m = (Mount*)VA(kmap(newpage(0, 0, 0))); e = &m[(BY2PG/sizeof(Mount))-1]; for(f = m; f < e; f++) f->next = f+1;
1990/0227		lock(&mountalloc);
1991/1011		e->next = mountalloc.free;
1990/0227		mountalloc.free = m; unlock(&mountalloc); }
1992/0520		return 0; /* not reached */
1990/0227		} void
1991/0705		envcpy(Egrp *to, Egrp *from)
1990/0227		{
1991/1018		Env *te, *fe; int i, nenv;
1990/0227
1991/1018		qlock(&from->ev); nenv = from->nenv; to->nenv = nenv; te = to->etab; fe = from->etab; for(i=0; i < nenv; i++, te++, fe++) envpgcopy(te, fe); qunlock(&from->ev);
1991/0514		} void pgrpcpy(Pgrp *to, Pgrp *from) {
1991/1113		Mhead **h, **e, *f, **tom, **l, *mh;
1991/1011		Mount *n, *m, **link;
1991/0514
1991/1011		rlock(&from->ns);
1991/1127		*to->crypt = *from->crypt;
1991/1011		e = &from->mnthash[MNTHASH];
1991/1113		tom = to->mnthash;
1991/1011		for(h = from->mnthash; h < e; h++) {
1991/1113		l = tom++;
1991/1011		for(f = *h; f; f = f->hash) { mh = newmnthead(); mh->from = f->from; incref(mh->from); *l = mh;
1991/1113		l = &mh->hash;
1991/1011		link = &mh->mount; for(m = f->mount; m; m = m->next) { n = newmount(mh, m->to); *link = n; link = &n->next; }
1991/0514		}
1991/1011		} runlock(&from->ns); }
1991/0514
1991/1011		Mhead * newmnthead(void) { Mhead *mh, *f, *e; for(;;) { lock(&mountalloc); if(mh = mountalloc.mhfree) { /* Assign '=' */ mountalloc.mhfree = mh->hash; unlock(&mountalloc); mh->hash = 0; mh->mount = 0; return mh; } unlock(&mountalloc); mh = (Mhead*)VA(kmap(newpage(0, 0, 0))); e = &mh[(BY2PG/sizeof(Mhead))-1]; for(f = mh; f < e; f++) f->hash = f+1; lock(&mountalloc); e->hash = mountalloc.mhfree; mountalloc.mhfree = mh; unlock(&mountalloc); }
1992/0520		return 0; /* not reached */
1991/1011		} void mntheadfree(Mhead *mh) { lock(&mountalloc); mh->hash = mountalloc.mhfree; mountalloc.mhfree = mh; unlock(&mountalloc); } void mountfree(Mount *m) { Mount *f; for(f = m; f->next; f = f->next) close(f->to); close(f->to); lock(&mountalloc); f->next = mountalloc.free; mountalloc.free = m; unlock(&mountalloc);
1990/0227		}