Subversion Repositories planix.SVN

#include	"u.h"

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

#include	"mem.h"

#include	"dat.h"

#include	"fns.h"

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

int chandebug=0;		/* toggled by sysr1 */

#define DBG if(chandebug)iprint

enum

{

	PATHSLOP	= 20,

	PATHMSLOP	= 20,

};

struct

{

	Lock;

	int	fid;

	Chan	*free;

	Chan	*list;

}chanalloc;

typedef struct Elemlist Elemlist;

struct Elemlist

{

	char	*aname;	/* original name */

	char	*name;	/* copy of name, so '/' can be overwritten */

	int	nelems;

	char	**elems;

	int	*off;

	int	mustbedir;

	int	nerror;

	int	prefix;

};

#define SEP(c) ((c) == 0 || (c) == '/')

static void

dumpmount(void)		/* DEBUGGING */

{

	Pgrp *pg;

	Mount *t;

	Mhead **h, **he, *f;

	if(up == nil){

		print("no process for dumpmount\n");

		return;

	}

	pg = up->pgrp;

	if(pg == nil){

		print("no pgrp for dumpmount\n");

		return;

	}

	rlock(&pg->ns);

	if(waserror()){

		runlock(&pg->ns);

		nexterror();

	}

	he = &pg->mnthash[MNTHASH];

	for(h = pg->mnthash; h < he; h++){

		for(f = *h; f; f = f->hash){

			print("head: %#p: %s %#llux.%lud %C %lud -> \n", f,

				f->from->path->s, f->from->qid.path,

				f->from->qid.vers, devtab[f->from->type]->dc,

				f->from->dev);

			for(t = f->mount; t; t = t->next)

				print("\t%#p: %s (umh %#p) (path %#.8llux dev %C %lud)\n", t, t->to->path->s, t->to->umh, t->to->qid.path, devtab[t->to->type]->dc, t->to->dev);

		}

	}

	poperror();

	runlock(&pg->ns);

}

char*

chanpath(Chan *c)

{

	if(c == nil)

		return "<nil chan>";

	if(c->path == nil)

		return "<nil path>";

	if(c->path->s == nil)

		return "<nil path.s>";

	return c->path->s;

}

int

isdotdot(char *p)

{

	return p[0]=='.' && p[1]=='.' && p[2]=='\0';

}

long

incref(Ref *r)

{

	long x;

	lock(r);

	x = ++r->ref;

	unlock(r);

	return x;

}

long

decref(Ref *r)

{

	long x;

	lock(r);

	x = --r->ref;

	unlock(r);

	if(x < 0)

		panic("decref pc=%#p", getcallerpc(&r));

	return x;

}

/*

 * Rather than strncpy, which zeros the rest of the buffer, kstrcpy

 * truncates if necessary, always zero terminates, does not zero fill,

 * and puts ... at the end of the string if it's too long.  Usually used to

 * save a string in up->genbuf;

 */

void

kstrcpy(char *s, char *t, int ns)

{

	int nt;

	nt = strlen(t);

	if(nt+1 <= ns){

		memmove(s, t, nt+1);

		return;

	}

	/* too long */

	if(ns < 4){

		/* but very short! */

		strncpy(s, t, ns);

		return;

	}

	/* truncate with ... at character boundary (very rare case) */

	memmove(s, t, ns-4);

	ns -= 4;

	s[ns] = '\0';

	/* look for first byte of UTF-8 sequence by skipping continuation bytes */

	while(ns>0 && (s[--ns]&0xC0)==0x80)

		;

	strcpy(s+ns, "...");

}

int

emptystr(char *s)

{

	if(s == nil)

		return 1;

	if(s[0] == '\0')

		return 1;

	return 0;

}

/*

 * Atomically replace *p with copy of s

 */

void

kstrdup(char **p, char *s)

{

	int n;

	char *t, *prev;

	n = strlen(s)+1;

	/* if it's a user, we can wait for memory; if not, something's very wrong */

	if(up){

		t = smalloc(n);

		setmalloctag(t, getcallerpc(&p));

	}else{

		t = malloc(n);

		if(t == nil)

			panic("kstrdup: no memory");

	}

	memmove(t, s, n);

	prev = *p;

	*p = t;

	free(prev);

}

static int debugstart = 1;

void

chandevreset(void)

{

	int i;

	todinit();	/* avoid later reentry causing infinite recursion */

	debugstart = getconf("*debugstart") != nil;

	if(debugstart)

		iprint("reset:");

	for(i=0; devtab[i] != nil; i++) {

		if(debugstart)

			iprint(" %s", devtab[i]->name);

		devtab[i]->reset();

	}

	if(debugstart)

		iprint("\n");

}

void

chandevinit(void)

{

	int i;

	if(debugstart)

		iprint("init:");

	for(i=0; devtab[i] != nil; i++) {

		if(debugstart)

			iprint(" %s", devtab[i]->name);

		devtab[i]->init();

	}

	if(debugstart)

		iprint("\n");

}

void

chandevshutdown(void)

{

	int i;

	/* shutdown in reverse order */

	for(i=0; devtab[i] != nil; i++)

		;

	for(i--; i >= 0; i--)

		devtab[i]->shutdown();

}

Chan*

newchan(void)

{

	Chan *c;

	lock(&chanalloc);

	c = chanalloc.free;

	if(c != 0)

		chanalloc.free = c->next;

	unlock(&chanalloc);

	if(c == nil){

		c = smalloc(sizeof(Chan));

		lock(&chanalloc);

		c->fid = ++chanalloc.fid;

		c->link = chanalloc.list;

		chanalloc.list = c;

		unlock(&chanalloc);

	}

	/* if you get an error before associating with a dev,

	   close calls rootclose, a nop */

	c->type = 0;

	c->flag = 0;

	c->ref = 1;

	c->dev = 0;

	c->offset = 0;

	c->devoffset = 0;

	c->iounit = 0;

	c->umh = 0;

	c->uri = 0;

	c->dri = 0;

	c->aux = 0;

	c->mchan = 0;

	c->mcp = 0;

	c->mux = 0;

	memset(&c->mqid, 0, sizeof(c->mqid));

	c->path = 0;

	c->ismtpt = 0;

	return c;

}

Ref npath;

Path*

newpath(char *s)

{

	int i;

	Path *p;

	p = smalloc(sizeof(Path));

	i = strlen(s);

	p->len = i;

	p->alen = i+PATHSLOP;

	p->s = smalloc(p->alen);

	memmove(p->s, s, i+1);

	p->ref = 1;

	incref(&npath);

	/*

	 * Cannot use newpath for arbitrary names because the mtpt 

	 * array will not be populated correctly.  The names #/ and / are

	 * allowed, but other names with / in them draw warnings.

	 */

	if(strchr(s, '/') && strcmp(s, "#/") != 0 && strcmp(s, "/") != 0)

		print("newpath: %s from %#p\n", s, getcallerpc(&s));

	p->mlen = 1;

	p->malen = PATHMSLOP;

	p->mtpt = smalloc(p->malen*sizeof p->mtpt[0]);

	return p;

}

static Path*

copypath(Path *p)

{

	int i;

	Path *pp;

	pp = smalloc(sizeof(Path));

	pp->ref = 1;

	incref(&npath);

	DBG("copypath %s %p => %p\n", p->s, p, pp);

	pp->len = p->len;

	pp->alen = p->alen;

	pp->s = smalloc(p->alen);

	memmove(pp->s, p->s, p->len+1);

	pp->mlen = p->mlen;

	pp->malen = p->malen;

	pp->mtpt = smalloc(p->malen*sizeof pp->mtpt[0]);

	for(i=0; i<pp->mlen; i++){

		pp->mtpt[i] = p->mtpt[i];

		if(pp->mtpt[i])

			incref(pp->mtpt[i]);

	}

	return pp;

}

void

pathclose(Path *p)

{

	int i;

	if(p == nil)

		return;

//XXX

	DBG("pathclose %p %s ref=%ld =>", p, p->s, p->ref);

	for(i=0; i<p->mlen; i++)

		DBG(" %p", p->mtpt[i]);

	DBG("\n");

	if(decref(p))

		return;

	decref(&npath);

	free(p->s);

	for(i=0; i<p->mlen; i++)

		if(p->mtpt[i])

			cclose(p->mtpt[i]);

	free(p->mtpt);

	free(p);

}

/*

 * In place, rewrite name to compress multiple /, eliminate ., and process ..

 * (Really only called to remove a trailing .. that has been added.

 * Otherwise would need to update n->mtpt as well.)

 */

static void

fixdotdotname(Path *p)

{

	char *r;

	if(p->s[0] == '#'){

		r = strchr(p->s, '/');

		if(r == nil)

			return;

		cleanname(r);

		/*

		 * The correct name is #i rather than #i/,

		 * but the correct name of #/ is #/.

		 */

		if(strcmp(r, "/")==0 && p->s[1] != '/')

			*r = '\0';

	}else

		cleanname(p->s);

	p->len = strlen(p->s);

}

static Path*

uniquepath(Path *p)

{

	Path *new;

	if(p->ref > 1){

		/* copy on write */

		new = copypath(p);

		pathclose(p);

		p = new;

	}

	return p;

}

static Path*

addelem(Path *p, char *s, Chan *from)

{

	char *t;

	int a, i;

	Chan *c, **tt;

	if(s[0]=='.' && s[1]=='\0')

		return p;

	p = uniquepath(p);

	i = strlen(s);

	if(p->len+1+i+1 > p->alen){

		a = p->len+1+i+1 + PATHSLOP;

		t = smalloc(a);

		memmove(t, p->s, p->len+1);

		free(p->s);

		p->s = t;

		p->alen = a;

	}

	/* don't insert extra slash if one is present */

	if(p->len>0 && p->s[p->len-1]!='/' && s[0]!='/')

		p->s[p->len++] = '/';

	memmove(p->s+p->len, s, i+1);

	p->len += i;

	if(isdotdot(s)){

		fixdotdotname(p);

		DBG("addelem %s .. => rm %p\n", p->s, p->mtpt[p->mlen-1]);

		if(p->mlen>1 && (c = p->mtpt[--p->mlen])){

			p->mtpt[p->mlen] = nil;

			cclose(c);

		}

	}else{

		if(p->mlen >= p->malen){

			p->malen = p->mlen+1+PATHMSLOP;

			tt = smalloc(p->malen*sizeof tt[0]);

			memmove(tt, p->mtpt, p->mlen*sizeof tt[0]);

			free(p->mtpt);

			p->mtpt = tt;

		}

		DBG("addelem %s %s => add %p\n", p->s, s, from);

		p->mtpt[p->mlen++] = from;

		if(from)

			incref(from);

	}

	return p;

}

void

chanfree(Chan *c)

{

	c->flag = CFREE;

	if(c->dirrock != nil){

		free(c->dirrock);

		c->dirrock = 0;

		c->nrock = 0;

		c->mrock = 0;

	}

	if(c->umh != nil){

		putmhead(c->umh);

		c->umh = nil;

	}

	if(c->umc != nil){

		cclose(c->umc);

		c->umc = nil;

	}

	if(c->mux != nil){

		muxclose(c->mux);

		c->mux = nil;

	}

	if(c->mchan != nil){

		cclose(c->mchan);

		c->mchan = nil;

	}

	pathclose(c->path);

	c->path = nil;

	lock(&chanalloc);

	c->next = chanalloc.free;

	chanalloc.free = c;

	unlock(&chanalloc);

}

void

cclose(Chan *c)

{

	if(c->flag&CFREE)

		panic("cclose %#p", getcallerpc(&c));

	DBG("cclose %p name=%s ref=%ld\n", c, c->path->s, c->ref);

	if(decref(c))

		return;

	if(!waserror()){

		devtab[c->type]->close(c);

		poperror();

	}

	chanfree(c);

}

/*

 * Queue a chan to be closed by one of the clunk procs.

 */

struct {

	Chan *head;

	Chan *tail;

	int nqueued;

	int nclosed;

	Lock l;

	QLock q;

	Rendez r;

} clunkq;

void closeproc(void*);

void

ccloseq(Chan *c)

{

	if(c->flag&CFREE)

		panic("cclose %#p", getcallerpc(&c));

	DBG("ccloseq %p name=%s ref=%ld\n", c, c->path->s, c->ref);

	if(decref(c))

		return;

	lock(&clunkq.l);

	clunkq.nqueued++;

	c->next = nil;

	if(clunkq.head)

		clunkq.tail->next = c;

	else

		clunkq.head = c;

	clunkq.tail = c;

	unlock(&clunkq.l);

	if(!wakeup(&clunkq.r))

		kproc("closeproc", closeproc, nil);	

}

static int

clunkwork(void*)

{

	return clunkq.head != nil;

}

void

closeproc(void*)

{

	Chan *c;

	for(;;){

		qlock(&clunkq.q);

		if(clunkq.head == nil){

			if(!waserror()){

				tsleep(&clunkq.r, clunkwork, nil, 5000);

				poperror();

			}

			if(clunkq.head == nil){

				qunlock(&clunkq.q);

				pexit("no work", 1);

			}

		}

		lock(&clunkq.l);

		c = clunkq.head;

		clunkq.head = c->next;

		clunkq.nclosed++;

		unlock(&clunkq.l);

		qunlock(&clunkq.q);

		if(!waserror()){

			devtab[c->type]->close(c);

			poperror();

		}

		chanfree(c);

	}

}

/*

 * Make sure we have the only copy of c.  (Copy on write.)

 */

Chan*

cunique(Chan *c)

{

	Chan *nc;

	if(c->ref != 1){

		nc = cclone(c);

		cclose(c);

		c = nc;

	}

	return c;

}

int

eqqid(Qid a, Qid b)

{

	return a.path==b.path && a.vers==b.vers;

}

int

eqchan(Chan *a, Chan *b, int skipvers)

{

	if(a->qid.path != b->qid.path)

		return 0;

	if(!skipvers && a->qid.vers!=b->qid.vers)

		return 0;

	if(a->type != b->type)

		return 0;

	if(a->dev != b->dev)

		return 0;

	return 1;

}

int

eqchantdqid(Chan *a, int type, int dev, Qid qid, int skipvers)

{

	if(a->qid.path != qid.path)

		return 0;

	if(!skipvers && a->qid.vers!=qid.vers)

		return 0;

	if(a->type != type)

		return 0;

	if(a->dev != dev)

		return 0;

	return 1;

}

Mhead*

newmhead(Chan *from)

{

	Mhead *mh;

	mh = smalloc(sizeof(Mhead));

	mh->ref = 1;

	mh->from = from;

	incref(from);

	return mh;

}

int

cmount(Chan **newp, Chan *old, int flag, char *spec)

{

	int order, flg;

	Chan *new;

	Mhead *m, **l, *mh;

	Mount *nm, *f, *um, **h;

	Pgrp *pg;

	if(QTDIR & (old->qid.type^(*newp)->qid.type))

		error(Emount);

	if(old->umh)

		print("cmount: unexpected umh, caller %#p\n", getcallerpc(&newp));

	order = flag&MORDER;

	if((old->qid.type&QTDIR)==0 && order != MREPL)

		error(Emount);

	new = *newp;

	mh = new->umh;

	/*

	 * Not allowed to bind when the old directory is itself a union. 

	 * (Maybe it should be allowed, but I don't see what the semantics

	 * would be.)

	 *

	 * We need to check mh->mount->next to tell unions apart from

	 * simple mount points, so that things like

	 *	mount -c fd /root

	 *	bind -c /root /

	 * work.  

	 * 

	 * The check of mount->mflag allows things like

	 *	mount fd /root

	 *	bind -c /root /

	 * 

	 * This is far more complicated than it should be, but I don't

	 * see an easier way at the moment.

	 */

	if((flag&MCREATE) && mh && mh->mount

	&& (mh->mount->next || !(mh->mount->mflag&MCREATE)))

		error(Emount);

	pg = up->pgrp;

	wlock(&pg->ns);

	l = &MOUNTH(pg, old->qid);

	for(m = *l; m; m = m->hash){

		if(eqchan(m->from, old, 1))

			break;

		l = &m->hash;

	}

	if(m == nil){

		/*

		 *  nothing mounted here yet.  create a mount

		 *  head and add to the hash table.

		 */

		m = newmhead(old);

		*l = m;

		/*

		 *  if this is a union mount, add the old

		 *  node to the mount chain.

		 */

		if(order != MREPL)

			m->mount = newmount(m, old, 0, 0);

	}

	wlock(&m->lock);

	if(waserror()){

		wunlock(&m->lock);

		nexterror();

	}

	wunlock(&pg->ns);

	nm = newmount(m, new, flag, spec);

	if(mh != nil && mh->mount != nil){

		/*

		 *  copy a union when binding it onto a directory

		 */

		flg = order;

		if(order == MREPL)

			flg = MAFTER;

		h = &nm->next;

		um = mh->mount;

		for(um = um->next; um; um = um->next){

			f = newmount(m, um->to, flg, um->spec);

			*h = f;

			h = &f->next;

		}

	}

	if(m->mount && order == MREPL){

		mountfree(m->mount);

		m->mount = 0;

	}

	if(flag & MCREATE)

		nm->mflag |= MCREATE;

	if(m->mount && order == MAFTER){

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

			;

		f->next = nm;

	}else{

		for(f = nm; f->next; f = f->next)

			;

		f->next = m->mount;

		m->mount = nm;

	}

	wunlock(&m->lock);

	poperror();

	return nm->mountid;

}

void

cunmount(Chan *mnt, Chan *mounted)

{

	Pgrp *pg;

	Mhead *m, **l;

	Mount *f, **p;

	if(mnt->umh)	/* should not happen */

		print("cunmount newp extra umh %p has %p\n", mnt, mnt->umh);

	/*

	 * It _can_ happen that mounted->umh is non-nil, 

	 * because mounted is the result of namec(Aopen)

	 * (see sysfile.c:/^sysunmount).

	 * If we open a union directory, it will have a umh.

	 * Although surprising, this is okay, since the

	 * cclose will take care of freeing the umh.

	 */

	pg = up->pgrp;

	wlock(&pg->ns);

	l = &MOUNTH(pg, mnt->qid);

	for(m = *l; m; m = m->hash){

		if(eqchan(m->from, mnt, 1))

			break;

		l = &m->hash;

	}

	if(m == 0){

		wunlock(&pg->ns);

		error(Eunmount);

	}

	wlock(&m->lock);

	if(mounted == 0){

		*l = m->hash;

		wunlock(&pg->ns);

		mountfree(m->mount);

		m->mount = nil;

		cclose(m->from);

		wunlock(&m->lock);

		putmhead(m);

		return;

	}

	p = &m->mount;

	for(f = *p; f; f = f->next){

		/* BUG: Needs to be 2 pass */

		if(eqchan(f->to, mounted, 1) ||

		  (f->to->mchan && eqchan(f->to->mchan, mounted, 1))){

			*p = f->next;

			f->next = 0;

			mountfree(f);

			if(m->mount == nil){

				*l = m->hash;

				cclose(m->from);

				wunlock(&m->lock);

				wunlock(&pg->ns);

				putmhead(m);

				return;

			}

			wunlock(&m->lock);

			wunlock(&pg->ns);

			return;

		}

		p = &f->next;

	}

	wunlock(&m->lock);

	wunlock(&pg->ns);

	error(Eunion);

}

Chan*

cclone(Chan *c)

{

	Chan *nc;

	Walkqid *wq;

	wq = devtab[c->type]->walk(c, nil, nil, 0);

	if(wq == nil)

		error("clone failed");

	nc = wq->clone;

	free(wq);

	nc->path = c->path;

	if(c->path)

		incref(c->path);

	return nc;

}

/* also used by sysfile.c:/^mountfix */

int

findmount(Chan **cp, Mhead **mp, int type, int dev, Qid qid)

{

	Pgrp *pg;

	Mhead *m;

	pg = up->pgrp;

	rlock(&pg->ns);

	for(m = MOUNTH(pg, qid); m; m = m->hash){

		rlock(&m->lock);

		if(m->from == nil){

			print("m %p m->from 0\n", m);

			runlock(&m->lock);

			continue;

		}

		if(eqchantdqid(m->from, type, dev, qid, 1)){

			runlock(&pg->ns);

			if(mp != nil){

				incref(m);

				if(*mp != nil)

					putmhead(*mp);

				*mp = m;

			}

			if(*cp != nil)

				cclose(*cp);

			incref(m->mount->to);

			*cp = m->mount->to;

			runlock(&m->lock);

			return 1;

		}

		runlock(&m->lock);

	}

	runlock(&pg->ns);