## diffname port/devtinyfs.c 1996/0116
## diff -e /dev/null /n/fornaxdump/1996/0116/sys/src/brazil/port/devtinyfs.c
0a
/*
 *  template for making a new device
 */

#include	"u.h"
#include	"../port/lib.h"
#include	"mem.h"
#include	"dat.h"
#include	"fns.h"
#include	"../port/error.h"

#include	"devtab.h"

enum{
	Qdir,
	Qmedium,

	Nfile=	32,
};


struct {
	QLock;
	Chan	*c;
	Dirtab	file[Nfile];
	int	nfile;
} tinyfs;

void
tinyfsreset(void)
{
	Dirtab *d;

	d = tinyfs.file;
	memmove(d->name, "medium");
	d->qid.vers = 0;
	d->qid.path = Qdata;
	d->perm = 0666;
}

void
tinyfsinit(void)
{
}

Chan *
tinyfsattach(char *spec)
{
	return devattach('E', spec);
}

Chan *
tinyfsclone(Chan *c, Chan *nc)
{
	return devclone(c, nc);
}

int
tinyfswalk(Chan *c, char *name)
{
	return devwalk(c, name, tinyfs.file, tinyfs.nfile, devgen);
}

void
tinyfsstat(Chan *c, char *db)
{
	devstat(c, db, tinyfs.file, tinyfs.nfile, devgen);
}

Chan *
tinyfsopen(Chan *c, int omode)
{
	return devopen(c, omode, tinyfs.file, tinyfs.nfile, devgen);
}

void
tinyfscreate(Chan *c, char *name, int omode, ulong perm)
{
	Dirtab	*d;

	if(perm & CHDIR)
		error("directory creation illegal");

	if(waserror()){
		qunlock(&tinyfs);
		nexterror();
	}
	qlock(&tinyfs);

	if(tinyfs.nfile == Nfile)
		error("out of space");
	for(d = tinyfs.file; d < tinyfs.file[tinyfs.nfile]; d++)
		if(strcmp(name, d->name) == 0)
			error("create race");
	strncpy(d->name, name, sizeof(d->name)-1);
	d->perm = perm;
	d->qid.vers = 0;
	d->qid.path = tinyfs.high++;
	tinyfs.nfile++;
			
	qunlock(&tinyfs);

	c->mode = openmode(omode);
	c->flag |= COPEN;
	c->qid = d->qid;
}

void
tinyfsremove(Chan *c)
{
	USED(c);
	error(Eperm);
}

void
tinyfswstat(Chan *c, char *dp)
{
	USED(c, dp);
	error(Eperm);
}

void
tinyfsclose(Chan *c)
{
}

long
tinyfsread(Chan *c, void *a, long n, ulong offset)
{
	switch(c->qid.path & ~CHDIR){
	case Qdir:
		return devdirread(c, a, n, tinyfstab, Ntinyfstab, devgen);
	case Qdata:
		break;
	default:
		n=0;
		break;
	}
	return n;
}

Block*
tinyfsbread(Chan *c, long n, ulong offset)
{
	return devbread(c, n, offset);
}

long
tinyfswrite(Chan *c, char *a, long n, ulong offset)
{
	if(waserror()){
		qunlock(&tinyfs);
		nexterror();
	}
	qlock(&tinyfs);
	qunlock(&tinyfs);

	switch(c->qid.path & ~CHDIR){
	case Qdata:
		break;
	default:
		error(Ebadusefd);
	}
	return n;
}

long
tinyfsbwrite(Chan *c, Block *bp, ulong offset)
{
	return devbwrite(c, bp, offset);
}
.
## diffname port/devtinyfs.c 1996/0120
## diff -e /n/fornaxdump/1996/0116/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0120/sys/src/brazil/port/devtinyfs.c
100c

.
48a
	c = namec((char*)arg[0], Aopen, arg[1], 0);

.
38a
	tinyfs.nfile = 1;
.
37c
	d->qid.path = Qmedium;
.
25c
	Dirtab	file[Nfile+1];
.
18a
	Qmedium,
.
16,17d
## diffname port/devtinyfs.c 1996/0122
## diff -e /n/fornaxdump/1996/0120/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0122/sys/src/brazil/port/devtinyfs.c
51c
	cc = namec((char*)arg[0], Aopen, arg[1], 0);
	qlock(&tinyfs);
	l = &tinyfs.l;
	for(fs = tinyfs.l; fs != 0; fs = fs->next){
		if(eqchan(c, fs->c))
			break;
		l = &(fs->next);
	}
	if(fs){
		incref(&fs->r);
		qunlock(&tinyfs);
		close(cc);
	} else {
		fs = smalloc(sizeof(*fs));
		*l = fs;
		fs->c = cc;
		incref(&fs->r);
		qunlock(&tinyfs);
	}

	c = devattach('E', spec);
	c->aux = fs;
	c->dev = fs->dev;

	return c;
.
49c
	FS *fs, **l;
	Chan *c, *cc;
.
25a
	int	maxfile;
};

struct {
	QLock;
	FS	*l;
	int	hidev;
.
24c
	Dirtab	*file;
.
22a
	Ref	r;
	int	dev;
	FS	*next;
.
21c
struct FS {
.
19a
typedef struct FS FS;
.
## diffname port/devtinyfs.c 1996/0123
## diff -e /n/fornaxdump/1996/0122/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0123/sys/src/brazil/port/devtinyfs.c
126,140d
81a
	poperror();
.
79a
		if(waserror()){
			free(fs);
			nexterror();
		}
		if(fsinit(fs) < 0)
			fssetup(fs);
		poperror();
		*l = fs;
.
77d
63a
	if(waserror()){
		close(cc);
		unlock(&fs);
		nexterror();
	}
.
56a
#define GETS(x) ((x)[0]|((x)[1]<<8))
#define PUTS(x, v) {(x)[0] = (v);(x)[1] = ((v)>>8);}

#define GETL(x) (GETS(x)|(GETS(x+2)<<16))
#define PUTL(x, v) {PUTS(x, v);PUTS(x+2, (v)>>16)}; 

/*
 *  see if we have a reasonable fat/root directory
 */
static int
fsinit(FS *fs)
{
	uchar buf[DIRLEN];
	Dir d;
	ulong x;

	n = devtab[fs->c->type].read(fs->c, buf, Superlen, 0);
	if(n != Superlen)
		error(Eio);
	x = GETL(buf);
	if(x != Magic)
		return -1;
	fs->clustsize = GETL(buf+4);
	fs->nclust = GETL(buf+8);
	x = fs->clustsize*fs->nclust;

	devtab[fs->c->type].stat(fs->c, buf);
	convM2D(buf, &d);
	if(d.length < 128)
		error("tinyfs medium too small");
	if(d.length < x)
		return -1;

	fs->fat = smalloc(2*fs->nclust);
	n = devtab[fs->c->type].read(fs->c, buf, 2*fs->nclust, Superlen);
	fd(n != 2*fs->nclust)
		error(Eio);

	x = GETS(fs->fat);
	if(x == 0)
		return -1;

	return 0;
}

/*
 *  set up the fat and then a root directory (starting at first cluster (1))
 */
static void
fssetup(FS *fs)
{
	uchar buf[DIRLEN];
	Dir d;

	devtab[fs->c->type].stat(fs->c, buf);
	convM2D(buf, &d);
	fs->clustsize = d.length>>16;
	if(fs->clustsize < 64)
		fs->clustsize = 64;
	fs->nclust = (d.length - 12)/fs->clustsize;
	fs->fat = smalloc(2*fs->nclust);
	n = devtab[fs->c->type].write(fs->c, buf, 2*fs->nclust, Superlen);
	if(n < 2*fs->nclust)
		error(Eio);
	n = devtab[fs->c->type].write(fs->c, buf, Superlen, 0);
	if(n < Superlen)
		error(Eio);
}

.
42,49d
28,30c
	uchar	*fat;
	ulong	nclust;
	ulong	clustsize;
.
17a

	Magic=		0xfeedbeef,
	Superlen=	64,
.
16c
	Nfile=		32,
.
## diffname port/devtinyfs.c 1996/0131
## diff -e /n/fornaxdump/1996/0123/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0131/sys/src/brazil/port/devtinyfs.c
90,94c
	for(bno = 0; bno < fs->nblocks; bno++){
		n = devtab[fs->c->type].read(fs->c, buf, Blen, Blen*bno);
		if(n != Blen)
			break;
		if(checksum(buf) != 0)
			continue;
		switch(buf[0]){
		case Tdir:
			mapset(fs, bno);
			break;
		}
	}
.
85,88c
	/* bitmap for block usage */
	x = (fs->nblocks + 8 - 1)/8;
	fs->map = malloc(x);
	memset(fs->map, 0x0, x);
	for(bno = fs->nblocks; bno < x*8; bno++)
		mapset(fs, bno);
.
82,83d
80c
	fs->nblocks = d.length/Blen;
	if(fs->nblocks < 3)
.
68,77d
66c
	ulong x, bno;
.
64c
	uchar buf[Blen+DIRLEN];
.
57a
static void
mapclr(FS *fs, int bno)
{
	fs->map[bno>>3] &= ~(1<<(bno&7));
}

static void
mapset(FS *fs, int bno)
{
	fs->map[bno>>3] |= 1<<(bno&7);
}

static int
mapalloc(FS *fs)
{
	int i, j, lim;
	uchar x;

	qlock(fs);
	lim = (fs->nblocks + 8 - 1)/8;
	for(i = 0; i < lim; i++){
		x = fs->map[i];
		if(x == 0xff)
			continue;
		for(j = 0; j < 8; j++)
			if((x & (1<<j)) == 0){
				fs->map[i] = x|(1<<j);
				qunlock(fs);
				return i*8 + j;
			}
	}
	qunlock(fs);
	return -1;
}

.
55,56c
	s = 0;
	for(e = p + Blen; p < e; p++)
		s += *p;
}
.
52,53c
static uchar
checksum(uchar *p)
{
	uchar *e;
	uchar s;
.
41a
#define GETS(x) ((x)[0]|((x)[1]<<8))
#define PUTS(x, v) {(x)[0] = (v);(x)[1] = ((v)>>8);}

#define GETL(x) (GETS(x)|(GETS(x+2)<<16))
#define PUTL(x, v) {PUTS(x, v);PUTS(x+2, (v)>>16)};

.
31,33c
	uchar	*map;
	int	nblocks;
.
24d
19,20c
	Blen=	48,

	Tdir=	0,
	Tdata,
	Tend,
.
16d
## diffname port/devtinyfs.c 1996/0201
## diff -e /n/fornaxdump/1996/0131/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0201/sys/src/brazil/port/devtinyfs.c
276c
		return devdirread(c, a, n, tinyfstab, Ntinyfstab, tinyfsgen);
.
268a
	Tfs *fs, **l;
	Tfile *f, *nf;

	fs = c->aux;
	lock(fs);
	fs->ref--;
	unlock(fs);

	if(fs->ref)
		return;

	qlock(&tinyfs);
	lock(fs);
	if(fs->ref == 0){
		for(l = &fs->l; *l;){
			if(*l == fs){
				*l = fs->next;
				break;
			}
			l = &(*l)->next;
		}
		for(f = fs->f; f; f = nf){
			nf = f->next;
			free(f);
		}
		free(fs->map);
		close(fs->c);
		free(fs);
	}
	unlock(fs);
	qunlock(&tinyfs);
.
249d
246a
	unlock(fs);

	c->qid.path = f - fs->f;
	c->qid.vers = 1;		/* creating */
.
243,245c
	fs = &tinyfs.fs[c->dev];
	for(;;) {
		lock(fs);
		for(i = 0; i < fs->fsize; i++){
			f = &fs->f[i];
			if(f->name[0] == 0){
				strncpy(f->name, name, sizeof(f->name)-1);
				break;
			}
		}
		if(i < fs->fsize)
			break;

		unlock(fs);
		expand(fs);
.
238c
	Tfs *fs;
	Tfile *f;
.
232c
	Tfs *fs;
	Tfile *f;

	fs = &tinyfs.fs[c->dev];

	if(c->path & CHDIR){
		if(omode != OREAD)
			error(Eperm);
	} else {
		lock(fs);
		f = fs->f[c->path];
		unlock(fs);

		if(f->pin == Nopin){
			if(omode != OREAD)
				error(Eperm);
		} else {
			if(omode != ORDWR)
				error(Eperm);
		}
	}

	return devopen(c, omode, 0, 0, tinyfsgen);
.
226c
	devstat(c, db, 0, 0, tinyfsgen);
.
220c
	return devwalk(c, name, 0, 0, tinyfsgen);
.
204,206c
	c = devattach('U', spec);
	c->dev = fs - tinyfs.fs;
	c->qid.path = CHDIR;
	c->qid.vers = 0;
.
201a
	qunlock(&tinyfs);
.
191,200c
		fs->r = 1;
		fsinit(fs);
		tinyfs.nfs++;
.
189c
		if(tinyfs.nfs >= Maxfs)
			error("too many tinyfs's");
		fs = &tinyfs.fs[tinyfs.nfs];
		memset(fs, 0, sizeof(*fs));
.
184,186c
	if(i < tinyfs.nfs){
		lock(fs);
		fs->r++;
		unlock(fs);
.
182d
178,180c
	for(i = 0; i < tinyfs.nfs; i++){
		fs = &tinyfs.fs[i];
		if(fs && eqchan(c, fs->c))
.
176a

.
174c
		qunlock(&tinyfs);
.
169a
	int i;
.
168c
	Tfs *fs;
.
164a
void
tinyfsreset(void)
{
	if(Nlen > NAMELEN)
		panic("tinyfsreset");
}

void
tinyfsinit(void)
{
}

.
150,162c
	fs = &tinyfs.fs[c->dev];
	if(i >= fs->nf)
		return -1;
	f = &fs->f[i];
	qid.path = i;
	qid.vers = 0;
	devdir(c, qid, f->name, f->length, eve, f->pin==Nopin?0444:0666, dp);
	return 1;
.
147,148c
	Tfs *fs;
	Tfile *f;
	Qid qid;
.
141,145c
static int
tinyfsgen(Chan *c, Dirtab *tab, int ntab, int i, Dir *dp)
.
136c
			switch(mdata->type){
			case Tagdata:
				bno = GETS(mdata->bno);
				f->len += Dlen;
				break;
			case Tagend:
				f->len += GETS(mdata->bno);
				break;
			}
.
133,134c

		if(fs->nfs <= fs->fsize)
			expand(fs);
		f = &fs->f[fs->nf++];

		x = GETS(mdir->bno);
		mapset(fs, bno);
		strncpy(f->name, mdir->name, sizeof(f->name));
		f->pin = GETS(mdir->pin);
		f->bno = bno;
		f->dbno = x;
	}

	/* follow files */
	for(f = fs->f; f; f = f->next){
		bno = fs->dbno;
		for(;;) {
			if(isalloced(fs, bno)){
				freefile(f, bno);
				break;
			}
			n = devtab[fs->c->type].read(fs->c, buf, Blen, Blen*bno);
			if(n != Blen){
				freefile(fs, f, bno);
				break;
			}
			mdata = validdata(fs, buf);
			if(mdata == 0){
				freefile(fs, f, bno);
				break;
			}
.
131c

		mdir = validdir(buf);
		if(mdir == 0)
.
126a
	/* find files */
.
122c
	fs->map = smalloc(x);
.
112a
	int n;
	Tfile *f;
	Mdir *mdir;
	Mdata *mdat;
.
107,108c
static void
fsinit(Tfs *fs)
.
103a
static Mdir*
validdir(Tfs *fs, uchar *p)
{
	Mdir *md;
	ulong x;

	if(checksum(p) != 0)
		return 0;
	if(buf[0] != Tagdir)
		return 0;
	md = (Mdir*)p;
	x = GETS(md->bno);
	if(x >= fs->nblocks)
		return 0;
	return md;
}

static Mdata*
validdata(Tfs *fs, uchar *p)
{
	Mdata *md;
	ulong x;

	if(checksum(p) != 0)
		return 0;
	md = (Mdir*)p;
	switch(buf[0]){
	case Tagdata:
		x = GETS(md->bno);
		if(x >= fs->nblocks)
			return 0;
		break;
	case Tagend:
		x = GETS(md->bno);
		if(x > Blen - 4)
			return 0;
		break;
	}
	return md;
}

static void
freefile(Tfs *fs, Tfile *f, ulong bend)
{
	uchar buf[Blen];
	ulong bno;
	int n;
	Mdata *md;

	/* remove blocks from map */
	bno = f->dbno;
	while(bend != bno){
		mapclr(fs, bno);
		n = devtab[fs->c->type].read(fs->c, buf, Blen, Blen*bno);
		if(n != Blen)
			break;
		md = validdata(buf);
		if(md == 0)
			break;
		if(md->type == Tagend)
			break;
		bno = GETS(md->bno);
	}

	/* change file type to free on medium */
	n = devtab[fs->c->type].read(fs->c, buf, Blen, Blen*f->bno);
	if(n != Blen)
		return;
	buf[0] = Tagfree;
	devtab[fs->c->type].write(fs->c, buf, Blen, Blen*f->bno);

	/* forget we ever knew about it */
	memset(f, 0, sizeof(*f));
}

static void
expand(Tfs *fs)
{
	Tfile *f;

	fs->fsize += 8;
	f = smalloc(fs->fsize*sizeof(*f));

	lock(fs);
	memmove(f, fs->f, fs->nf*sizoef(f));
	free(fs->f);
	fs->f = f;
	unlock(fs);
}

.
83a
	return fs->map[bno>>3] & (1<<(bno&7));
}

static int
mapalloc(Tfs *fs)
{
.
82c
isalloced(Tfs *fs, ulong bno)
.
76c
mapset(Tfs *fs, ulong bno)
.
70c
mapclr(Tfs *fs, ulong bno)
.
48,57d
38,39c
	Tfs	fs[Maxfs];
	short	nfs;
.
33a
	Tfile	*f;
	int	nf;
	int	fsize;
.
25,30c
/* medium representation of a Tdir */
typedef struct Mdir Mdir;
struct Mdir {
	uchar	type;
	uchar	bno[2];
	uchar	pin[2];
	char	name[Nlen];
	char	pad[Blen - Nlen - 6];
	uchar	sum;
};

/* medium representation of a Tdata/Tend */
typedef struct Mdata Mdata;
struct Mdata {
	uchar	type;
	uchar	bno[2];
	char	data[Dlen];
	uchar	sum;
};

typedef struct Tfile Tfile;
struct Tfile {
	char	name[NAMELEN];
	ushort	bno;
	ushort	dbno;
	ushort	pin;
	ulong	length;
};

typedef struct Tfs Tfs;
struct Tfs {
	Lock;
	int	r;
.
20,22c
	Blen=		48,	/* block length */
	Nlen=		28,	/* name length */
	Dlen=		Blen - 4,

	Tagdir=		'd',
	Tagdata=	'D',
	Tagend=		'e',
	Tagfree=	'f',

	Nopin=		0xffff;
.
18c
	Maxfs=		10,	/* max file systems */
.
## diffname port/devtinyfs.c 1996/0202
## diff -e /n/fornaxdump/1996/0201/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0202/sys/src/brazil/port/devtinyfs.c
490,491c
	/* dereference file and remove old versions */
	if(c->qid.path != CHDIR){
		f = &fs->f[c->qid.path];
		f->r--;
		if(f->r == 0 && f->creating){
			/* remove all other files with this name */
			for(i = 0; i < fs->fsize; i++){
				nf = &fs->f[i];
				if(f == nf)
					continue;
				if(strcmp(nf->name, f->name) == 0)
					freefile(fs, nf, Notabno);
			}
		}
	}

	/* dereference fs and remove on zero refs */
	fs->r--;
.
487,488c
	qlock(fs);
.
483,485d
480a
	int i;
.
459d
457c
	c->qid.vers = 0;
.
451,455d
438,449c
	qlock(fs);
	f = newfile(fs, name);
	qunlock(fs);
.
423a
		qunlock(fs);
.
413,422c
		qlock(fs);
		if(omode == (OTRUNC|ORDWR)){
			f = newfile(fs, fs->f[c->qid.path]);
			c->qid.path = f - fs->f;
		} else if(omode != OREAD){
			qunlock(fs);
			error(Eperm);
.
392c
	int n;

	qlock(fs);
	n = devwalk(c, name, 0, 0, tinyfsgen);
	if(n != 0 && c->qid.path != CHDIR){
		fs = &tinyfs.fs[c->dev];
		fs->f[c->qid.path].r++;
	}
	qunlock(fs);
	return n;
.
385a
	qlock(fs);
	fs->r++;
	qunlock(fs);

.
360c
		qunlock(fs);
.
358c
		qlock(fs);
.
321c
	devdir(c, qid, f->name, f->length, eve, 0664, dp);
.
307a
/*
 *  single directory
 */
.
265a

.
228c
 *  Read the whole medium and build a file table and used
 *  block bitmap.  Inconsistent files are purged.
.
226a
static Tfile*
newfile(Tfs *fs, char *name)
{
	int i;
	Tfile *f;

	/* find free entry in file table */
	for(;;) {
		for(i = 0; i < fs->fsize; i++){
			f = &fs->f[i];
			if(f->name[0] == 0){
				strncpy(f->name, name, sizeof(f->name)-1);
				break;
			}
		}

		if(i < fs->fsize)
			break;

		expand(fs);
	}

	f->creating = 1;
	f->dbno = Notabno;
	f->bno = mapalloc(fs);

	/* write directory block */
	if(waserror()){
		filefree(fs, f, Notabno);
		nexterror();
	}
	if(b->bno == Notabno)
		error("out of space");
	writedir(fs, f);
	poperror();
	
	return f;
}

.
224d
220d
202,206c
	if(f->bno != Notabno){
		n = devtab[fs->c->type].read(fs->c, buf, Blen, Blen*f->bno);
		if(n != Blen)
			return;
		buf[0] = Tagfree;
		devtab[fs->c->type].write(fs->c, buf, Blen, Blen*f->bno);
	}
.
188c
	while(bno != bend && bno != Notabno){
.
177a
static int
writedir(Tfs *fs, Tfile *f)
{
	Mdir *md;
	int n;
	uchar buf[Blen];

	if(f->bno == Notabno)
		return Blen;

	md = (Mdir*)buf;
	memset(buf, 0, Blen);
	md->type = Tagdir;
	strncpy(md->name, f->name, sizeof(md->name)-1);
	PUTS(md->bno, f->dbno);
	PUTS(md->pin, f->pin);
	f->sum = 0 - checksum(buf);

	return devtab[fs->c->type].write(fs->c, buf, Blen, Blen*f->bno);
}

.
93a
	return s;
.
63c
	QLock;
.
57a
	char	creating;
.
53a
	int	r;
.
43c
/* representation of a Tdata/Tend on medium */
.
32c
/* representation of a Tdir on medium */
.
29c
	Notapin=		0xffff,
	Notabno=		0xffff,
.
2c
 *  a pity the code isn't also tiny...
.
## diffname port/devtinyfs.c 1996/0203
## diff -e /n/fornaxdump/1996/0202/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0203/sys/src/brazil/port/devtinyfs.c
596,601c

	fs = tinyfs.fs[c->dev];
	f = &fs->f[c->qid.path];
	if(offset >= f->length)
		return 0;
	if(n + offset >= f->length)
		n = f->length - offset;

.
593,594c
	Tfs *fs;
	Tfile *f;
	int sofar, i;

	if(c->qid.path & CHDIR)
.
586d
584c
		memset(fs, 0, sizeof(*fs));
.
578,581c
		free(fs-f);
.
569a
	unlock(fs);
	qlock(&tinyfs);
.
564a
			if(f->flag & Frmonclose){
				freefile(fs, f, Notabno);
.
556,563c
		if(f->r == 0){
			if(f->creating){
				/* remove all other files with this name */
				for(i = 0; i < fs->fsize; i++){
					nf = &fs->f[i];
					if(f == nf)
						continue;
					if(strcmp(nf->name, f->name) == 0){
						if(nf->r)
							nf->flag |= Frmonclose;
						else
							freefile(fs, nf, Notabno);
					}
				}
				f->flag &= ~(Frmonclose|Fcreating);
.
274c
	f->flag = Fcreating;
.
60c
	uchar	flag;
.
30a

	Fcreating=	1,
	Frmonclose=	2,
.
## diffname port/devtinyfs.c 1996/0206
## diff -e /n/fornaxdump/1996/0203/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0206/sys/src/brazil/port/devtinyfs.c
615a

	/* walk to first data block */
	bno = f->dbno;
	for(sofar = 0; sofar < offset; sofar += Blen){
		md = readdata(fs, bno, buf);
		if(md == 0)
			error(Eio);
		bno = GETS(md->bno);
	}

	/* read first block */
	i = offset%Blen;

	/* read data */
	for(sofar = 0; sofar+Blen < offset; sofar += Blen){
	
.
605a
	ulong bno, tbno;
	Mdata *md;
	uchar buf[Blen];
.
184a
static Mdata*
readdata(Tfs *fs, ulong bno, uchar *buf)
{
	if(bno >= fs->nblocks)
		return 0;
	n = devtab[fs->c->type].read(fs->c, buf, Blen, Blen*bno);
	if(n != Blen)
		return 0;
	return validdata(fs, buf);
}

.
57a
	Lock;
.
## diffname port/devtinyfs.c 1996/0217
## diff -e /n/fornaxdump/1996/0206/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0217/sys/src/brazil/port/devtinyfs.c
673c

	return sofar;
.
667,671c
	/* write data */
	offset = offset%Blen;
	for(sofar = 0; sofar < n; sofar += i){
		md = readdata(fs, bno, buf, 0);
		if(md == 0)
			error(Eio);
		i = Blen - offset;
		if(i > n)
			i = n;
		memmove(p, a, i);
		bno = GETS(md->bno);
		offset = 0;
.
664,665d
660,662c
	Tfs *fs;
	Tfile *f;
	int sofar, i;
	ulong bno, tbno;
	Mdata *md;
	uchar buf[Blen];
	uchar *p = a;

	if(c->qid.path & CHDIR)
		error(Eperm);

	fs = tinyfs.fs[c->dev];
	f = &fs->f[c->qid.path];

	/* walk to first data block */
	bno = f->dbno;
	for(sofar = 0; sofar + Blen < offset; sofar += Blen){
		md = readdata(fs, bno, buf, 0);
		if(md == 0)
			error(Eio);
		bno = GETS(md->bno);
.
648c
	return sofar;
.
645,646c
	offset = offset%Blen;
	for(sofar = 0; sofar < n; sofar += i){
		md = readdata(fs, bno, buf, &i);
		if(md == 0)
			error(Eio);
		i -= offset;
		if(i > n)
			i = n;
		if(i < 0)
			break;
		memmove(p, md->data, i);
		p += i;
		bno = GETS(md->bno);
		offset = 0;
	}
.
641,643d
634,635c
	for(sofar = 0; sofar + Blen < offset; sofar += Blen){
		md = readdata(fs, bno, buf, 0);
.
632c
	/* walk to starting data block */
.
623c
		return devdirread(c, a, n, 0, 0, tinyfsgen);
.
620a
	uchar *p = a;
.
604c
		free(fs->f);
.
572c
			if(f->flag & Fcreating){
.
384a
			if(done)
				f->flag &= ~Fcreating;
.
382a
				done = 1;
.
370c
			mdata = validdata(fs, buf, 0);
.
360c
		for(done = 0; !done;) {
.
358c
	for(f = fs->f; f < &(fs->f[fs->nf]); f++){
.
344c
		if(fs->nfs >= fs->fsize)
.
316c
	int n, done;
.
308c
 *  block bitmap.  Inconsistent files are purged.  The medium
 *  had better be small or this could take a while.
.
262c
	memmove(f, fs->f, fs->nf*sizeof(f));
.
233c
		md = validdata(fs, buf, 0);
.
194c
	return validdata(fs, buf, lenp);
.
188a
	Mdata *md;

.
187c
readdata(Tfs *fs, ulong bno, uchar *buf, int *lenp)
.
180a
		if(lenp)
			*lenp = x;
.
179c
		if(x > Dlen)
.
175a
		if(lenp)
			*lenp = Dlen;
.
163c
validdata(Tfs *fs, uchar *p, int *lenp)
.
## diffname port/devtinyfs.c 1996/0218
## diff -e /n/fornaxdump/1996/0217/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0218/sys/src/brazil/port/devtinyfs.c
716a

	while(x = n - sofar) {
		tbno = mapalloc(fs);
		if(f->length == 0){
			f->dbno = tbno;
			writedir(fs, f);
		} else {
			writedata(fs, bno, tbno, md->data, Dlen, 0);
		}
		if(x > Dlen)
			x = Dlen;
		memmove(md->data, p + sofar, x);
		sofar += x;
		f->length += x;
		bno = tbno;
	}

	i = f->length%Dlen;
	if(i == 0)
		i = Dlen;
	writedata(fs, bno, tbno, md->data, i, 1);

	poperror();
	qunlock(fs);
.
704,715c
	sofar = 0;
	i = offset%Dlen;
	if(i){
		x = n;
		if(i + x > Dlen)
			x = Dlen - i;
		memmove(md->data + i, p, sofar);
		f->length += x;
		sofar += x;
.
699,700c
		if(md->type == Tagend)
			break;
.
695c
	/* files are append only, anything else is illegal */
	if(offset != f->length)
		error("append only");

	qlock(fs);
	if(waserror()){
		f->flag |= Frmonclose;
		qunlock(fs);
		nexterror();
	}

	/* walk to last data block */
.
691a
	if(n == 0)
		return 0;

.
683c
	int sofar, i, x;
.
656,657d
647,648d
628c
	ulong bno;
.
606c
	if(fs->r == 0){
.
604c
	qunlock(fs);
.
597c
			if(f->flag & Frmonclose)
.
573c
	fs = &tinyfs.fs[c->dev];
.
542a
	fs = &tinyfs.fs[c->dev];

.
522c
			f = newfile(fs, fs->f[c->qid.path].name);
.
516c
	if(c->qid.path & CHDIR){
.
491a
	fs = &tinyfs.fs[c->dev];

.
490a
	Tfs *fs;
.
479a
	Tfs *fs;

	fs = &tinyfs.fs[c->dev];

.
448c
		if(fs && eqchan(cc, fs->c, 0))
.
445a
	fs = 0;
.
438c
	cc = namec(spec, Aopen, ORDWR, 0);
.
408a
	USED(ntab, tab);

.
389c
				f->length += GETS(mdata->bno);
.
386c
				f->length += Dlen;
.
369c
				freefile(fs, f, bno);
.
366c
		bno = f->dbno;
.
351c
		if(fs->nf >= fs->fsize)
.
347c
		mdir = validdir(fs, buf);
.
328,329c
	devtab[fs->c->type].stat(fs->c, dbuf);
	convM2D(dbuf, &d);
.
326c
	Mdata *mdata;
.
321a
	uchar buf[Blen];
.
320c
	char dbuf[DIRLEN];
.
304c
	if(f->bno == Notabno)
.
301c
		freefile(fs, f, Notabno);
.
279a
	f = 0;
.
221c
	if(devtab[fs->c->type].write(fs->c, buf, Blen, Blen*f->bno) != Blen)
		error(Eio);
.
219c
	md->sum = 0 - checksum(buf);
.
211c
		return;
.
207d
203c
static void
writedata(Tfs *fs, ulong bno, ulong next, uchar *buf, int len, int last)
{
	Mdata md;

	if(bno >= fs->nblocks)
		error(Eio);
	if(len > Dlen)
		len = Dlen;
	if(len < 0)
		error(Eio);
	memset(&md, 0, sizeof(md));
	if(last){
		md.type = Tagend;
		PUTS(md.bno, len);
	} else {
		md.type = Tagdata;
		PUTS(md.bno, next);
	}
	memmove(md.data, buf, len);
	md.sum = 0 - checksum((uchar*)&md);
	
	if(devtab[fs->c->type].write(fs->c, &md, Blen, Blen*bno) != Blen)
		error(Eio);
}

static void
.
197,199c
	if(devtab[fs->c->type].read(fs->c, buf, Blen, Blen*bno) != Blen)
		error(Eio);
.
193,194d
170,171c
	md = (Mdata*)p;
	switch(md->type){
.
153c
	if(p[0] != Tagdir)
.
## diffname port/devtinyfs.c 1996/0220
## diff -e /n/fornaxdump/1996/0218/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0220/sys/src/brazil/port/devtinyfs.c
786c
	return n;
.
778,782c
	/* update finger */
	if(fbno != Notabno){
		f->finger = finger;
		f->fbno =  fbno;
	}
.
776a
	f->length += n;
.
770,775c
		writedata(fs, bno, dbno, md->data, i+next, last == n+offset);
.
751,768c
	/* point to new blocks */
	if(offset == 0){
		f->dbno = dbno;
		writedir(fs, f);
	} else {
		i = last - offset;
		next = offset%Dlen;
		if(i > 0){
			p -= i;
			memmove(md->data + next, p, i);
.
745a
		if(md == 0)
			error(Eio);
.
743,744c
	md = (Mdata*)buf;
	if(f->finger < offset && f->fbno != Notabno){
		next = f->finger;
		bno = f->fbno;
	} else {
		next = 0;
		bno = f->dbno;
	}
	for(; next < offset; next += Dlen){
.
741a
	/* write blocks backwards */
	p += n;
	last = offset + n;
	off = offset;
	fbno = Notabno;
	finger = 0;
	for(next = (last/Dlen)*Dlen; next >= off; next -= Dlen){
		bno = mapalloc(fs);
		if(bno == Notabno){
			error("out of space");
		}
		i = last - next;
		p -= i;
		if(last == n+offset){
			writedata(fs, bno, dbno, p, i, 1);
			finger = next;	/* remember for later */
			fbno = bno;
		} else
			writedata(fs, bno, dbno, p, i, 0);
		dbno = bno;
		last = next;
	}

.
737c
		freeblocks(fs, dbno, Notabno);
.
735a
	dbno = Notabno;
.
728c
	fs = &tinyfs.fs[c->dev];
.
716,717c
	int last, next, i, off, finger;
	ulong bno, dbno, fbno;
.
712c
tinyfswrite(Chan *c, void *a, long n, ulong offset)
.
710a
/*
 *  if we get a write error in this routine, blocks will
 *  be lost.  They should be recovered next fsinit.
 */
.
700a
	qunlock(fs);
	poperror();
.
699c
		off = 0;
.
694,695d
691c
		if(md == 0)
			error(Eio);

		/* update finger for successful read */
		f->finger = offset + sofar;
		f->fbno = bno;

		i -= off;
.
688c
	off = offset%Dlen;
	offset -= off;
.
683a
		if(md == 0)
			error(Eio);
.
681,682c
	if(f->finger < offset && f->fbno != Notabno){
		sofar = f->finger;
		bno = f->fbno;
	} else {
		sofar = 0;
		bno = f->dbno;
	}
	for(; sofar + Dlen < offset; sofar += Dlen){
.
676a

	qlock(fs);
	if(waserror()){
		qunlock(fs);
		nexterror();
	}
.
673c
	fs = &tinyfs.fs[c->dev];
.
664c
	int sofar, i, off;
.
656c
	qunlock(fs);
.
654c
		fs->c = 0;
.
644,652c
		if(fs->f)
			free(fs->f);
		fs->f = 0;
		fs->nf = 0;
		fs->fsize = 0;
		if(fs->map)
			free(fs->map);
		fs->map = 0;
.
641,642d
636a
		poperror();
.
634,635d
632d
630a
					f->flag &= ~Fcreating;
.
615,629c
	if(!waserror()){
		if(c->qid.path != CHDIR){
			f = &fs->f[c->qid.path];
			f->r--;
			if(f->r == 0){
				if(f->flag & Frmonclose)
					freefile(fs, f, Notabno);
				else if(f->flag & Fcreating){
					/* remove all other files with this name */
					for(i = 0; i < fs->fsize; i++){
						nf = &fs->f[i];
						if(f == nf)
							continue;
						if(strcmp(nf->name, f->name) == 0){
							if(nf->r)
								nf->flag |= Frmonclose;
							else
								freefile(fs, nf, Notabno);
						}
.
606c
	Tfs *fs;
.
592,593c
	Tfs *fs;
	Tfile *f;

	if(c->qid.path == CHDIR)
		error(Eperm);
	fs = &tinyfs.fs[c->dev];
	f = &fs->f[c->qid.path];
	qlock(fs);
	freefile(fs, f, Notabno);
	qunlock(fs);
.
582a
	poperror();
.
580a
	if(waserror()){
		qunlock(fs);
		nexterror();
	}
.
575,576c
	USED(perm);
.
563a
		poperror();
.
559,560c
			break;
		case OREAD:
			break;
		default:
.
557a
			fs->f[c->qid.path].r--;
.
556c
		if(waserror()){
			qunlock(fs);
			nexterror();
		}
		switch(omode){
		case OTRUNC|ORDWR:
		case OTRUNC|OWRITE:
.
494d
492c
		qunlock(fs);
.
490a
		fs->f = 0;
		fs->nf = 0;
		fs->fsize = 0;
.
487,488d
485c
		for(fs = tinyfs.fs; fs < &tinyfs.fs[Maxfs]; fs++){
			qlock(fs);
			if(fs->r == 0)
				break;
			qunlock(fs);
		}
		if(fs == &tinyfs.fs[Maxfs])
.
479,480c
	if(i < Maxfs){
.
477a
		qunlock(fs);
.
476c
		qlock(fs);
		if(fs->r && eqchan(cc, fs->c, 0))
.
474c
	for(i = 0; i < Maxfs; i++){
.
472d
468d
465c
	p = 0;
	if(strcmp(spec, "hd0") == 0)
		p = "#H/hd0nvram";
	else
		error("bad spec");

	cc = namec(p, Aopen, ORDWR, 0);
.
463a
	char *p;
.
439a
	if(f->name[0] == 0)
		return 0;
.
321a
	f->fbno = Notabno;
	f->r = 1;
.
314a
		}
.
313c
		if(i < fs->fsize){
			if(i >= fs->nf)
				fs->nf = i+1;
.
291,292c
	if(fs->f){
		memmove(f, fs->f, fs->nf*sizeof(*f));
		free(fs->f);
	}
.
276a
		mapclr(fs, f->bno);
.
272,273c
		if(devtab[fs->c->type].read(fs->c, buf, Blen, Blen*f->bno) != Blen)
.
269a
	poperror();
}

static void
freefile(Tfs *fs, Tfile *f, ulong bend)
{
	uchar buf[Blen];

	/* remove blocks from map */
	freeblocks(fs, f->dbno, bend);

.
259,260c
		if(devtab[fs->c->type].read(fs->c, buf, Blen, Blen*bno) != Blen)
.
255,256c
	if(waserror())
		return;

.
251,252d
248c
freeblocks(Tfs *fs, ulong bno, ulong bend)
.
141,142c

	return Notabno;
.
137d
128d
83d
65a

	/* hint to avoid egregious reading */
	ushort	fbno;
	ulong	finger;
.
52c
	uchar	data[Dlen];
.
## diffname port/devtinyfs.c 1996/0221
## diff -e /n/fornaxdump/1996/0220/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0221/sys/src/brazil/port/devtinyfs.c
487a
	else if(strncmp(spec, "hd1") == 0)
		p = "#H/hd1nvram";
	else if(strncmp(spec, "sd0") == 0)
		p = "#H/sd0nvram";
	else if(strncmp(spec, "sd1") == 0)
		p = "#H/sd1nvram";
.
486c
	if(strncmp(spec, "hd0") == 0)
.
## diffname port/devtinyfs.c 1996/0223
## diff -e /n/fornaxdump/1996/0221/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0223/sys/src/brazil/port/devtinyfs.c
12d
## diffname port/devtinyfs.c 1996/0226
## diff -e /n/fornaxdump/1996/0223/sys/src/brazil/port/devtinyfs.c /n/fornaxdump/1996/0226/sys/src/brazil/port/devtinyfs.c
889c
	qunlock(&fs->ql);
.
823c
		qunlock(&fs->ql);
.
819c
	qlock(&fs->ql);
.
779c
	qunlock(&fs->ql);
.
738c
		qunlock(&fs->ql);
.
736c
	qlock(&fs->ql);
.
714c
	qunlock(&fs->ql);
.
670c
	qlock(&fs->ql);
.
651c
	qunlock(&fs->ql);
.
649c
	qlock(&fs->ql);
.
631c
	qunlock(&fs->ql);
.
627c
		qunlock(&fs->ql);
.
625c
	qlock(&fs->ql);
.
608c
		qunlock(&fs->ql);
.
593c
			qunlock(&fs->ql);
.
591c
		qlock(&fs->ql);
.
569c
	qunlock(&fs->ql);
.
563c
	qlock(&fs->ql);
.
550c
	qunlock(&fs->ql);
.
548c
	qlock(&fs->ql);
.
529c
		qunlock(&fs->ql);
.
519c
			qunlock(&fs->ql);
.
516c
			qlock(&fs->ql);
.
512c
		qunlock(&fs->ql);
.
508c
		qunlock(&fs->ql);
.
505c
		qlock(&fs->ql);
.
485,492c
	if(strncmp(spec, "hd0", 3) == 0)
		p = "/dev/hd0nvram";
	else if(strncmp(spec, "hd1", 3) == 0)
		p = "/dev/hd1nvram";
	else if(strncmp(spec, "sd0", 3) == 0)
		p = "/dev/sd0nvram";
	else if(strncmp(spec, "sd1", 3) == 0)
		p = "/dev/sd1nvram";
.
84d
73c
	QLock	ql;
.
57d
## diffname port/devtinyfs.c 1997/0327
## diff -e /n/fornaxdump/1996/0226/sys/src/brazil/port/devtinyfs.c /n/emeliedump/1997/0327/sys/src/brazil/port/devtinyfs.c
892,896c
Dev tinyfsdevtab = {
	tinyfsreset,
	devinit,
	tinyfsattach,
	tinyfsclone,
	tinyfswalk,
	tinyfsstat,
	tinyfsopen,
	tinyfscreate,
	tinyfsclose,
	tinyfsread,
	devbread,
	tinyfswrite,
	devbwrite,
	tinyfsremove,
	devwstat,
};
.
793c
static long
.
783,788d
715c
static long
.
709c
		cclose(fs->c);
.
652,659c
static void
.
637c
static void
.
613c
static void
.
577c
static Chan*
.
571c
static void
.
553c
static int
.
539c
static Chan*
.
511c
		cclose(cc);
.
496c
		cclose(cc);
.
469,474c
static Chan*
.
462c
static void
.
411c
			n = devtab[fs->c->type]->read(fs->c, buf, Blen, Blen*bno);
.
382c
		n = devtab[fs->c->type]->read(fs->c, buf, Blen, Blen*bno);
.
367c
	devtab[fs->c->type]->stat(fs->c, dbuf);
.
282c
		devtab[fs->c->type]->write(fs->c, buf, Blen, Blen*f->bno);
.
279c
		if(devtab[fs->c->type]->read(fs->c, buf, Blen, Blen*f->bno) != Blen)
.
256c
		if(devtab[fs->c->type]->read(fs->c, buf, Blen, Blen*bno) != Blen)
.
241c
	if(devtab[fs->c->type]->write(fs->c, buf, Blen, Blen*f->bno) != Blen)
.
220c
	if(devtab[fs->c->type]->write(fs->c, &md, Blen, Blen*bno) != Blen)
.
193c
	if(devtab[fs->c->type]->read(fs->c, buf, Blen, Blen*bno) != Blen)
.
## diffname port/devtinyfs.c 1997/0408
## diff -e /n/emeliedump/1997/0327/sys/src/brazil/port/devtinyfs.c /n/emeliedump/1997/0408/sys/src/brazil/port/devtinyfs.c
874a
	'U',
	"tinyfs",

.
## diffname port/devtinyfs.c 1999/0612
## diff -e /n/emeliedump/1997/0408/sys/src/brazil/port/devtinyfs.c /n/emeliedump/1999/0612/sys/src/brazil/port/devtinyfs.c
878,879c
	devreset,
	tinyfsinit,
.
875c
	'F',
.
869c
	qunlock(&rock.fs->ql);
.
859c
		writedata(rock.fs, bno, rock.dbno, md->data, used, last == n+offset);
.
857c
			memmove(md->data + used, p, i);
			used += i;
.
854d
852a
		/* updating a current block */
.
850,851c
		/* first block in a file */
		f->dbno = rock.dbno;
		writedir(rock.fs, f);
.
844a
		}
		next += Dlen;
		if(next > offset)
			panic("devtinyfs1");
.
843c
		if(md->type == Tagend){
			if(next + Dlen < offset)
				panic("devtinyfs1");
.
839,840c

	used = 0;
	while(bno != Notabno){
		md = readdata(rock.fs, bno, buf, &used);
.
832c
	if(0 && f->finger < offset && f->fbno != Notabno){
.
824,826c
		} else {
			writedata(rock.fs, bno, rock.dbno, p, i, 0);
		}
		rock.dbno = bno;
.
821c
			writedata(rock.fs, bno, rock.dbno, p, i, 1);
.
817d
813,815c
	off = offset; /* so we have something signed to compare against */
	for(next = ((last-1)/Dlen)*Dlen; next >= off; next -= Dlen){
		bno = mapalloc(rock.fs);
		if(bno == Notabno)
.
810d
806a
	/* files are append only, anything else is illegal */
	if(offset != f->length)
		error("append only");

.
802,803c
		freeblocks(rock.fs, rock.dbno, Notabno);
		qunlock(&rock.fs->ql);
.
795,800c
	qlock(&rock.fs->ql);
	rock.dbno = Notabno;
.
792,793c
	p = a;
	rock.fs = &tinyfs.fs[c->dev];
	f = &rock.fs->f[c->qid.path];
.
784c
	uchar *p;
	volatile struct {
		Tfs *fs;
		ulong dbno;
	} rock;
.
780,781c
	int last, next, i, finger, off, used;
	ulong bno, fbno;
.
778d
776c
tinyfswrite(Chan *c, void *a, long n, vlong offset)
.
765c
	qunlock(&rock.fs->ql);
.
758,760c
		if(i > n - sofar)
			i = n - sofar;
		memmove(p, md->data+off, i);
.
755a
		offset += Dlen;
.
754c
		f->finger = offset;
.
749c
		md = readdata(rock.fs, bno, buf, &i);
.
738,739c
	for(; sofar + Dlen <= offset; sofar += Dlen){
		md = readdata(rock.fs, bno, buf, 0);
.
731c
	if(0 && f->finger <= offset && f->fbno != Notabno){
.
724c
		qunlock(&rock.fs->ql);
.
722c
	qlock(&rock.fs->ql);
.
717,718c
	p = a;
	rock.fs = &tinyfs.fs[c->dev];
	f = &rock.fs->f[c->qid.path];
.
712c
	uchar *p;
.
706c
	volatile struct { Tfs *fs; } rock;
.
704c
tinyfsread(Chan *c, void *a, long n, vlong offset)
.
700c
	qunlock(&rock.fs->ql);
.
686,698c
	/* dereference rock.fs and remove on zero refs */
	rock.fs->r--;
	if(rock.fs->r == 0){
		if(rock.fs->f)
			free(rock.fs->f);
		rock.fs->f = 0;
		rock.fs->nf = 0;
		rock.fs->fsize = 0;
		if(rock.fs->map)
			free(rock.fs->map);
		rock.fs->map = 0;
		cclose(rock.fs->c);
		rock.fs->c = 0;
.
676c
								freefile(rock.fs, nf, Notabno);
.
668,669c
					for(i = 0; i < rock.fs->fsize; i++){
						nf = &rock.fs->f[i];
.
665c
					freefile(rock.fs, f, Notabno);
.
661c
			f = &rock.fs->f[c->qid.path];
.
656c
	qlock(&rock.fs->ql);
.
654c
	rock.fs = &tinyfs.fs[c->dev];
.
650c
	volatile struct { Tfs *fs; } rock;
.
627c
	c->qid.path = f - rock.fs->f;
.
623,624c
	f = newfile(rock.fs, name);
	qunlock(&rock.fs->ql);
.
620c
		qunlock(&rock.fs->ql);
.
618c
	qlock(&rock.fs->ql);
.
616c
	rock.fs = &tinyfs.fs[c->dev];
.
611c
	volatile struct { Tfs *fs; } rock;
.
601c
		qunlock(&rock.fs->ql);
.
592,594c
			f = newfile(rock.fs, rock.fs->f[c->qid.path].name);
			rock.fs->f[c->qid.path].r--;
			c->qid.path = f - rock.fs->f;
.
586c
			qunlock(&rock.fs->ql);
.
584c
		qlock(&rock.fs->ql);
.
578c
	rock.fs = &tinyfs.fs[c->dev];
.
576a
	volatile struct { Tfs *fs; } rock;
.
575d
526c
	c = devattach('F', spec);
.
521c
		tfsinit(fs);
.
516c
		fs->c = rock.cc;
.
506c
		cclose(rock.cc);
.
499c
		if(fs->r && eqchan(rock.cc, fs->c, 1))
.
491c
		cclose(rock.cc);
.
489c
	rock.cc = fdtochan(fd, ORDWR, 0, 1);
.
477,487c
	fd = atoi(spec);
	if(fd < 0)
		error("bad specifier");
.
473,475c
	Chan *c;
	volatile struct { Chan *cc; } rock;
	int i, fd;
.
470c
tinyfsattach(void *spec)
.
468a
/*
 *  specifier is an open file descriptor
 */
.
466c
		panic("tinyfsinit");
.
463c
tinyfsinit(void)
.
448c
	USED(ntab);
	USED(tab);
.
400a
		f->fbno = Notabno;
.
375c
	fs->map = malloc(x);
.
356c
tfsinit(Tfs *fs)
.
347c
	return rock.f;
.
344c
	writedir(rock.fs, rock.f);
.
342c
	if(rock.f->bno == Notabno)
.
339c
		freefile(rock.fs, rock.f, Notabno);
.
331,335c
	rock.f->flag = Fcreating;
	rock.f->dbno = Notabno;
	rock.f->bno = mapalloc(rock.fs);
	rock.f->fbno = Notabno;
	rock.f->r = 1;
	rock.f->pin = Notapin;  // what is a pin??
.
328c
		expand(rock.fs);
.
322,324c
		if(i < rock.fs->fsize){
			if(i >= rock.fs->nf)
				rock.fs->nf = i+1;
.
314,317c
		for(i = 0; i < rock.fs->fsize; i++){
			rock.f = &rock.fs->f[i];
			if(rock.f->name[0] == 0){
				strncpy(rock.f->name, name, sizeof(rock.f->name)-1);
.
312c
	rock.f = 0;
	rock.fs = fs;
.
309c
	volatile struct {
		Tfile *f;
		Tfs *fs;
	} rock;
.
296c
	f = malloc(fs->fsize*sizeof(*f));
.
279,281c
		memset(buf, 0x55, Blen);
.
240c
	
.
183a
	default:
		return 0;
.
32c
	Frmonclose=	2
.
5,12d
3a
#include "u.h"
#include "../port/lib.h"
#include "../port/error.h"
#include "mem.h"
#include "dat.h"
#include "fns.h"
.
## diffname port/devtinyfs.c 1999/0618
## diff -e /n/emeliedump/1999/0612/sys/src/brazil/port/devtinyfs.c /n/emeliedump/1999/0618/sys/src/brazil/port/devtinyfs.c
596a
		case OEXEC:
.
489d
485,487c
	snprint(buf, sizeof(buf), "/dev/%s", spec);
	rock.cc = namec(buf, Aopen, ORDWR, 0);
.
483c
	int i;
	char buf[NAMELEN*2];
.
463c
	devdir(c, qid, f->name, f->length, eve, 0775, dp);
.
## diffname port/devtinyfs.c 1999/0623
## diff -e /n/emeliedump/1999/0618/sys/src/brazil/port/devtinyfs.c /n/emeliedump/1999/0623/sys/src/brazil/port/devtinyfs.c
478c
tinyfsattach(char *spec)
.
## diffname port/devtinyfs.c 1999/1230
## diff -e /n/emeliedump/1999/0623/sys/src/brazil/port/devtinyfs.c /n/emeliedump/1999/1230/sys/src/9/port/devtinyfs.c
462d
457a
	if(i == DEVDOTDOT){
		qid.path = CHDIR;
		devdir(c, qid, ".", 0, eve, 0555, dp);
		return 1;
	}
.
454a
	qid.vers = 0;
.