Subversion Repositories planix.SVN

#include	"all.h"

Lock wpathlock;

struct {

	Lock	flock;

	File*	ffree;		/* free file structures */

	Wpath*	wfree;

} suballoc;

enum{

	Finc=	128,	/* allocation chunksize for files */

	Fmax=	10000,	/* maximum file structures to be allocated */

	Winc=	8*128,	/* allocation chunksize for wpath */

	Wmax=	8*10000,	/* maximum wpath structures to be allocated */

};

Filsys*

fsstr(char *p)

{

	Filsys *fs;

	for(fs=filesys; fs->name; fs++)

		if(strcmp(fs->name, p) == 0)

			return fs;

	return 0;

}

void

fileinit(Chan *cp)

{

	File *f;

	Tlock *t;

loop:

	lock(&cp->flock);

	f = cp->flist;

	if(!f) {

		unlock(&cp->flock);

		return;

	}

	cp->flist = f->next;

	unlock(&cp->flock);

	qlock(f);

	if(t = f->tlock) {

		t->time = 0;

		f->tlock = 0;

	}

	if(f->open & FREMOV)

		doremove(f, 0);

	freewp(f->wpath);

	f->open = 0;

	f->cp = 0;

	qunlock(f);

	goto loop;

}

/*

 * returns a locked file structure

 */

File*

filep(Chan *cp, int fid, int flag)

{

	File *f, *prev;

	if(fid == NOF)

		return 0;

loop:

	lock(&cp->flock);

	for(prev=0,f=cp->flist; f; prev=f,f=f->next) {

		if(f->fid != fid)

			continue;

		if(prev) {

			prev->next = f->next;

			f->next = cp->flist;

			cp->flist = f;

		}

		goto out;

	}

	if(flag) {

		f = newfp(cp);

		if(f) {

			f->fid = fid;

			goto out;

		}

	}

else print("cannot find %p.%d (list=%p)\n", cp, fid, cp->flist);

	unlock(&cp->flock);

	return 0;

out:

	unlock(&cp->flock);

	qlock(f);

	if(f->fid != fid) {

		qunlock(f);

		goto loop;

	}

	return f;

}

void

sublockinit(void)

{

	lock(&suballoc.flock);

	lock(&wpathlock);

	conf.nfile = 0;

	conf.nwpath = 0;

	unlock(&suballoc.flock);

	unlock(&wpathlock);

}	

/*

 * always called with cp->flock locked

 */

File*

newfp(Chan *cp)

{

	File *f, *e;

retry:

	lock(&suballoc.flock);

	f = suballoc.ffree;

	if(f != nil){

		suballoc.ffree = f->list;

		unlock(&suballoc.flock);

		f->list = 0;

		f->cp = cp;

		f->next = cp->flist;

		f->wpath = 0;

		f->tlock = 0;

		f->dslot = 0;

		f->doffset = 0;

		f->uid = 0;

		f->cuid = 0;

		cp->flist = f;

		return f;

	}

	unlock(&suballoc.flock);

	if(conf.nfile > Fmax){

		print("%d: out of files\n", cp->chan);

		return 0;

	}

	/*

	 *  create a few new files

	 */

	f = malloc(Finc*sizeof(*f));

	memset(f, 0, Finc*sizeof(*f));

	lock(&suballoc.flock);

	for(e = f+Finc; f < e; f++){

		qlock(f);

		qunlock(f);

		f->list = suballoc.ffree;

		suballoc.ffree = f;

	}

	conf.nfile += Finc;

	unlock(&suballoc.flock);

	goto retry;

}

void

freefp(File *fp)

{

	Chan *cp;

	File *f, *prev;

	if(!fp || !(cp = fp->cp))

		return;

	authfree(fp);

	lock(&cp->flock);

	for(prev=0,f=cp->flist; f; prev=f,f=f->next) {

		if(f != fp)

			continue;

		if(prev)

			prev->next = f->next;

		else

			cp->flist = f->next;

		f->cp = 0;

		lock(&suballoc.flock);

		f->list = suballoc.ffree;

		suballoc.ffree = f;

		unlock(&suballoc.flock);

		break;

	}

	unlock(&cp->flock);

}

Wpath*

newwp(void)

{

	Wpath *w, *e;

retry:

	lock(&wpathlock);

	w = suballoc.wfree;

	if(w != nil){

		suballoc.wfree = w->list;

		unlock(&wpathlock);

		memset(w, 0, sizeof(*w));

		w->refs = 1;

		w->up = 0;

		return w;

	}

	unlock(&wpathlock);

	if(conf.nwpath > Wmax){

		print("out of wpaths\n");

		return 0;

	}

	/*

	 *  create a few new wpaths

	 */

	w = malloc(Winc*sizeof(*w));

	memset(w, 0, Winc*sizeof(*w));

	lock(&wpathlock);

	for(e = w+Winc; w < e; w++){

		w->list = suballoc.wfree;

		suballoc.wfree = w;

	}

	conf.nwpath += Winc;

	unlock(&wpathlock);

	goto retry;

}

/*

 *  increment the references for the whole path

 */

Wpath*

getwp(Wpath *w)

{

	Wpath *nw;

	lock(&wpathlock);

	for(nw = w; nw; nw=nw->up)

		nw->refs++;

	unlock(&wpathlock);

	return w;

}

/*

 *  decrement the reference for each element of the path

 */

void

freewp(Wpath *w)

{

	lock(&wpathlock);

	for(; w; w=w->up){

		w->refs--;

		if(w->refs == 0){

			w->list = suballoc.wfree;

			suballoc.wfree = w;

		}

	}

	unlock(&wpathlock);

}

/*

 *  decrement the reference for just this element

 */

void

putwp(Wpath *w)

{

	lock(&wpathlock);

	w->refs--;

	if(w->refs == 0){

		w->list = suballoc.wfree;

		suballoc.wfree = w;

	}

	unlock(&wpathlock);

}

int

iaccess(File *f, Dentry *d, int m)

{

	if(wstatallow)

		return 0;

	/*

	 * owner is next

	 */

	if(f->uid == d->uid)

		if((m<<6) & d->mode)

			return 0;

	/*

	 * group membership is hard

	 */

	if(ingroup(f->uid, d->gid))

		if((m<<3) & d->mode)

			return 0;

	/*

	 * other access for everyone except members of group 9999

	 */

	if(m & d->mode){

		/* 

		 *  walk directories regardless.

		 *  otherwise its impossible to get

		 *  from the root to noworld's directories.

		 */

		if((d->mode & DDIR) && (m == DEXEC))

			return 0;

		if(!ingroup(f->uid, 9999))

			return 0;

	}

	return 1;

}

Tlock*

tlocked(Iobuf *p, Dentry *d)

{

	Tlock *t, *t1;

	long qpath, tim;

	Device dev;

	tim = time(0);

	qpath = d->qid.path;

	dev = p->dev;

	t1 = 0;

	for(t=tlocks+NTLOCK-1; t>=tlocks; t--) {

		if(t->qpath == qpath)

		if(t->time >= tim)

		if(devcmp(t->dev, dev) == 0)

			return 0;		/* its locked */

		if(!t1 && t->time < tim)

			t1 = t;			/* steal first lock */

	}

	if(t1) {

		t1->dev = dev;

		t1->qpath = qpath;

		t1->time = tim + TLOCK;

	}

	/* botch

	 * out of tlock nodes simulates

	 * a locked file

	 */

	return t1;

}

Qid

newqid(Device dev)

{

	Iobuf *p;

	Superb *sb;

	Qid qid;

	p = getbuf(dev, superaddr(dev), Bread|Bmod);

	if(!p || checktag(p, Tsuper, QPSUPER))

		panic("newqid: super block");

	sb = (Superb*)p->iobuf;

	sb->qidgen++;

	qid.path = sb->qidgen;

	qid.vers = 0;

	qid.type = 0;

	putbuf(p);

	return qid;

}

/*

 * what are legal characters in a name?

 * only disallow control characters.

 * a) utf avoids control characters.

 * b) '/' may not be the separator

 */

int

checkname(char *n)

{

	int i, c;

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

		c = *n & 0xff;

		if(c == 0) {

			if(i == 0)

				return 1;

			memset(n, 0, NAMELEN-i);

			return 0;

		}

		if(c <= 040)

			return 1;

		n++;

	}

	return 1;	/* too long */

}

void

bfree(Device dev, long addr, int d)

{

	Iobuf *p;

	long a;

	int i;

	if(!addr)

		return;

	if(d > 0) {

		d--;

		p = getbuf(dev, addr, Bread);

		if(p) {

			for(i=INDPERBUF-1; i>=0; i--) {

				a = ((long*)p->iobuf)[i];

				bfree(dev, a, d);

			}

			putbuf(p);

		}

	}

	/*

	 * stop outstanding i/o

	 */

	p = getbuf(dev, addr, Bprobe);

	if(p) {

		p->flags &= ~(Bmod|Bimm);

		putbuf(p);

	}

	/*

	 * dont put written worm

	 * blocks into free list

	 */

	if(nofree(dev, addr))

		return;

	p = getbuf(dev, superaddr(dev), Bread|Bmod);

	if(!p || checktag(p, Tsuper, QPSUPER))

		panic("bfree: super block");

	addfree(dev, addr, (Superb*)p->iobuf);

	putbuf(p);

}

long

balloc(Device dev, int tag, long qid)

{

	Iobuf *bp, *p;

	Superb *sb;

	long a;

	int n;

	p = getbuf(dev, superaddr(dev), Bread|Bmod);

	if(!p || checktag(p, Tsuper, QPSUPER))

		panic("balloc: super block");

	sb = (Superb*)p->iobuf;

loop:

	n = --sb->fbuf.nfree;

	sb->tfree--;

	if(n < 0 || n >= FEPERBUF)

		panic("balloc: bad freelist");

	a = sb->fbuf.free[n];

	if(n <= 0) {

		if(a == 0) {

			sb->tfree = 0;

			sb->fbuf.nfree = 1;

			if(devgrow(dev, sb))

				goto loop;

			putbuf(p);

			return 0;

		}

		bp = getbuf(dev, a, Bread);

		if(!bp || checktag(bp, Tfree, QPNONE)) {

			if(bp)

				putbuf(bp);

			putbuf(p);

			return 0;

		}

		memmove(&sb->fbuf, bp->iobuf, (FEPERBUF+1)*sizeof(long));

		putbuf(bp);

	}

	bp = getbuf(dev, a, Bmod);

	memset(bp->iobuf, 0, RBUFSIZE);

	settag(bp, tag, qid);

	if(tag == Tind1 || tag == Tind2 || tag == Tdir)

		bp->flags |= Bimm;

	putbuf(bp);

	putbuf(p);

	return a;

}

void

addfree(Device dev, long addr, Superb *sb)

{

	int n;

	Iobuf *p;

	if(addr >= sb->fsize){

		print("addfree: bad addr %lux\n", addr);

		return;

	}

	n = sb->fbuf.nfree;

	if(n < 0 || n > FEPERBUF)

		panic("addfree: bad freelist");

	if(n >= FEPERBUF) {

		p = getbuf(dev, addr, Bmod);

		if(p == 0)

			panic("addfree: getbuf");

		memmove(p->iobuf, &sb->fbuf, (FEPERBUF+1)*sizeof(long));

		settag(p, Tfree, QPNONE);

		putbuf(p);

		n = 0;

	}

	sb->fbuf.free[n++] = addr;

	sb->fbuf.nfree = n;

	sb->tfree++;

	if(addr >= sb->fsize)

		sb->fsize = addr+1;

}

int

Cfmt(Fmt *f1)

{

	Chan *cp;

	cp = va_arg(f1->args, Chan*);

	return fmtprint(f1, "C%d.%.3d", cp->type, cp->chan);

}

int

Dfmt(Fmt *f1)

{

	Device d;

	d = va_arg(f1->args, Device);

	return fmtprint(f1, "D%d.%d.%d.%d", d.type, d.ctrl, d.unit, d.part);

}

int

Afmt(Fmt *f1)

{

	Filta a;

	a = va_arg(f1->args, Filta);

	return fmtprint(f1, "%6lud %6lud %6lud",

		fdf(a.f->filter[0], a.scale*60),

		fdf(a.f->filter[1], a.scale*600),

		fdf(a.f->filter[2], a.scale*6000));

}

int

Gfmt(Fmt *f1)

{

	int t;

	t = va_arg(f1->args, int);

	if(t >= 0 && t < MAXTAG)

		return fmtstrcpy(f1, tagnames[t]);

	else

		return fmtprint(f1, "<badtag %d>", t);

}

void

formatinit(void)

{

	fmtinstall('C', Cfmt);	/* print channels */

	fmtinstall('D', Dfmt);	/* print devices */

	fmtinstall('A', Afmt);	/* print filters */

	fmtinstall('G', Gfmt);	/* print tags */

	fmtinstall('T', Tfmt);	/* print times */

	fmtinstall('O', ofcallfmt);	/* print old fcalls */

}

int

devcmp(Device d1, Device d2)

{

	if(d1.type == d2.type)

	if(d1.ctrl == d2.ctrl)

	if(d1.unit == d2.unit)

	if(d1.part == d2.part)

		return 0;

	return 1;

}

void

rootream(Device dev, long addr)

{

	Iobuf *p;

	Dentry *d;

	p = getbuf(dev, addr, Bmod|Bimm);

	memset(p->iobuf, 0, RBUFSIZE);

	settag(p, Tdir, QPROOT);

	d = getdir(p, 0);

	strcpy(d->name, "/");

	d->uid = -1;

	d->gid = -1;

	d->mode = DALLOC | DDIR |

		((DREAD|DWRITE|DEXEC) << 6) |

		((DREAD|DWRITE|DEXEC) << 3) |

		((DREAD|DWRITE|DEXEC) << 0);

	d->qid = QID9P1(QPROOT|QPDIR,0);

	d->atime = time(0);

	d->mtime = d->atime;

	putbuf(p);

}

int

superok(Device dev, long addr, int set)

{

	Iobuf *p;

	Superb *s;

	int ok;

	p = getbuf(dev, addr, Bread|Bmod|Bimm);

	s = (Superb*)p->iobuf;

	ok = s->fsok;

	s->fsok = set;

	putbuf(p);

	return ok;

}

void

superream(Device dev, long addr)

{

	Iobuf *p;

	Superb *s;

	long i;

	p = getbuf(dev, addr, Bmod|Bimm);

	memset(p->iobuf, 0, RBUFSIZE);

	settag(p, Tsuper, QPSUPER);

	s = (Superb*)p->iobuf;

	s->fstart = 1;

	s->fsize = devsize(dev);

	s->fbuf.nfree = 1;

	s->qidgen = 10;

	for(i=s->fsize-1; i>=addr+2; i--)

		addfree(dev, i, s);

	putbuf(p);

}

/*

 * returns 1 if n is prime

 * used for adjusting lengths

 * of hashing things.

 * there is no need to be clever

 */

int

prime(long n)

{

	long i;

	if((n%2) == 0)

		return 0;

	for(i=3;; i+=2) {

		if((n%i) == 0)

			return 0;

		if(i*i >= n)

			return 1;

	}

}

void

hexdump(void *a, int n)

{

	char s1[30], s2[4];

	uchar *p;

	int i;

	p = a;

	s1[0] = 0;

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

		sprint(s2, " %.2ux", p[i]);

		strcat(s1, s2);

		if((i&7) == 7) {

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

			s1[0] = 0;

		}

	}

	if(s1[0])

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

}

long

qidpathgen(Device *dev)

{

	Iobuf *p;

	Superb *sb;

	long path;

	p = getbuf(*dev, superaddr((*dev)), Bread|Bmod);

	if(!p || checktag(p, Tsuper, QPSUPER))

		panic("newqid: super block");

	sb = (Superb*)p->iobuf;

	sb->qidgen++;

	path = sb->qidgen;

	putbuf(p);

	return path;

}