harvey/sys/src/cmd/disk/kfs/sub.c

#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;
}