Subversion Repositories planix.SVN

#include	"u.h"

#include	"../port/lib.h"

#include	"mem.h"

#include	"dat.h"

#include	"fns.h"

#include	"../port/error.h"

enum {

	Whinesecs = 10,		/* frequency of out-of-resources printing */

};

static Ref pgrpid;

static Ref mountid;

void

pgrpnote(ulong noteid, char *a, long n, int flag)

{

	Proc *p, *ep;

	char buf[ERRMAX];

	if(n >= ERRMAX-1)

		error(Etoobig);

	memmove(buf, a, n);

	buf[n] = 0;

	p = proctab(0);

	ep = p+conf.nproc;

	for(; p < ep; p++) {

		if(p->state == Dead)

			continue;

		if(up != p && p->noteid == noteid && p->kp == 0) {

			qlock(&p->debug);

			if(p->pid == 0 || p->noteid != noteid){

				qunlock(&p->debug);

				continue;

			}

			if(!waserror()) {

				postnote(p, 0, buf, flag);

				poperror();

			}

			qunlock(&p->debug);

		}

	}

}

Pgrp*

newpgrp(void)

{

	Pgrp *p;

	p = smalloc(sizeof(Pgrp));

	p->ref = 1;

	p->pgrpid = incref(&pgrpid);

	return p;

}

Rgrp*

newrgrp(void)

{

	Rgrp *r;

	r = smalloc(sizeof(Rgrp));

	r->ref = 1;

	return r;

}

void

closergrp(Rgrp *r)

{

	if(decref(r) == 0)

		free(r);

}

void

closepgrp(Pgrp *p)

{

	Mhead **h, **e, *f, *next;

	if(decref(p) != 0)

		return;

	qlock(&p->debug);

	wlock(&p->ns);

	p->pgrpid = -1;

	e = &p->mnthash[MNTHASH];

	for(h = p->mnthash; h < e; h++) {

		for(f = *h; f; f = next) {

			wlock(&f->lock);

			cclose(f->from);

			mountfree(f->mount);

			f->mount = nil;

			next = f->hash;

			wunlock(&f->lock);

			putmhead(f);

		}

	}

	wunlock(&p->ns);

	qunlock(&p->debug);

	free(p);

}

void

pgrpinsert(Mount **order, Mount *m)

{

	Mount *f;

	m->order = 0;

	if(*order == 0) {

		*order = m;

		return;

	}

	for(f = *order; f; f = f->order) {

		if(m->mountid < f->mountid) {

			m->order = f;

			*order = m;

			return;

		}

		order = &f->order;

	}

	*order = m;

}

/*

 * pgrpcpy MUST preserve the mountid allocation order of the parent group

 */

void

pgrpcpy(Pgrp *to, Pgrp *from)

{

	int i;

	Mount *n, *m, **link, *order;

	Mhead *f, **tom, **l, *mh;

	wlock(&from->ns);

	order = 0;

	tom = to->mnthash;

	for(i = 0; i < MNTHASH; i++) {

		l = tom++;

		for(f = from->mnthash[i]; f; f = f->hash) {

			rlock(&f->lock);

			mh = newmhead(f->from);

			*l = mh;

			l = &mh->hash;

			link = &mh->mount;

			for(m = f->mount; m; m = m->next) {

				n = newmount(mh, m->to, m->mflag, m->spec);

				m->copy = n;

				pgrpinsert(&order, m);

				*link = n;

				link = &n->next;

			}

			runlock(&f->lock);

		}

	}

	/*

	 * Allocate mount ids in the same sequence as the parent group

	 */

	lock(&mountid);

	for(m = order; m; m = m->order)

		m->copy->mountid = mountid.ref++;

	unlock(&mountid);

	wunlock(&from->ns);

}

Fgrp*

dupfgrp(Fgrp *f)

{

	Fgrp *new;

	Chan *c;

	int i;

	new = smalloc(sizeof(Fgrp));

	if(f == nil){

		new->fd = smalloc(DELTAFD*sizeof(Chan*));

		new->nfd = DELTAFD;

		new->ref = 1;

		return new;

	}

	lock(f);

	/* Make new fd list shorter if possible, preserving quantization */

	new->nfd = f->maxfd+1;

	i = new->nfd%DELTAFD;

	if(i != 0)

		new->nfd += DELTAFD - i;

	new->fd = malloc(new->nfd*sizeof(Chan*));

	if(new->fd == nil){

		unlock(f);

		free(new);

		error("no memory for fgrp");

	}

	new->ref = 1;

	new->maxfd = f->maxfd;

	for(i = 0; i <= f->maxfd; i++) {

		if(c = f->fd[i]){

			incref(c);

			new->fd[i] = c;

		}

	}

	unlock(f);

	return new;

}

void

closefgrp(Fgrp *f)

{

	int i;

	Chan *c;

	if(f == 0)

		return;

	if(decref(f) != 0)

		return;

	/*

	 * If we get into trouble, forceclosefgrp

	 * will bail us out.

	 */

	up->closingfgrp = f;

	for(i = 0; i <= f->maxfd; i++)

		if(c = f->fd[i]){

			f->fd[i] = nil;

			cclose(c);

		}

	up->closingfgrp = nil;

	free(f->fd);

	free(f);

}

/*

 * Called from sleep because up is in the middle

 * of closefgrp and just got a kill ctl message.

 * This usually means that up has wedged because

 * of some kind of deadly embrace with mntclose

 * trying to talk to itself.  To break free, hand the

 * unclosed channels to the close queue.  Once they

 * are finished, the blocked cclose that we've 

 * interrupted will finish by itself.

 */

void

forceclosefgrp(void)

{

	int i;

	Chan *c;

	Fgrp *f;

	if(up->procctl != Proc_exitme || up->closingfgrp == nil){

		print("bad forceclosefgrp call");

		return;

	}

	f = up->closingfgrp;

	for(i = 0; i <= f->maxfd; i++)

		if(c = f->fd[i]){

			f->fd[i] = nil;

			ccloseq(c);

		}

}

Mount*

newmount(Mhead *mh, Chan *to, int flag, char *spec)

{

	Mount *m;

	m = smalloc(sizeof(Mount));

	m->to = to;

	m->head = mh;

	incref(to);

	m->mountid = incref(&mountid);

	m->mflag = flag;

	if(spec != 0)

		kstrdup(&m->spec, spec);

	return m;

}

void

mountfree(Mount *m)

{

	Mount *f;

	while(m) {

		f = m->next;

		cclose(m->to);

		m->mountid = 0;

		free(m->spec);

		free(m);

		m = f;

	}

}

void

resrcwait(char *reason)

{

	ulong now;

	char *p;

	static ulong lastwhine;

	if(up == 0)

		panic("resrcwait");

	p = up->psstate;

	if(reason) {

		up->psstate = reason;

		now = seconds();

		/* don't tie up the console with complaints */

		if(now - lastwhine > Whinesecs) {

			lastwhine = now;

			print("%s\n", reason);

		}

	}

	tsleep(&up->sleep, return0, 0, 300);

	up->psstate = p;

}