ref: ee695eff4329234e20abb68ff3100d3b15929418
dir: /emu/port/devtinyfs.c/
#include "dat.h"
#include "fns.h"
#include "error.h"
enum{
Qdir,
Qmedium,
Maxfs= 10, /* max file systems */
Blen= 48, /* block length */
Nlen= 28, /* name length */
Dlen= Blen - 4,
Tagdir= 'd',
Tagdata= 'D',
Tagend= 'e',
Tagfree= 'f',
Notapin= 0xffff,
Notabno= 0xffff,
Fcreating= 1,
Frmonclose= 2
};
/* representation of a Tdir on medium */
typedef struct Mdir Mdir;
struct Mdir {
uchar type;
uchar bno[2];
uchar pin[2];
char name[Nlen];
char pad[Blen - Nlen - 6];
uchar sum;
};
/* representation of a Tdata/Tend on medium */
typedef struct Mdata Mdata;
struct Mdata {
uchar type;
uchar bno[2];
uchar data[Dlen];
uchar sum;
};
typedef struct Tfile Tfile;
struct Tfile {
int r;
char name[Nlen];
ushort bno;
ushort dbno;
ushort pin;
uchar flag;
ulong length;
/* hint to avoid egregious reading */
ushort fbno;
ulong finger;
};
typedef struct Tfs Tfs;
struct Tfs {
QLock ql;
int r;
Chan *c;
uchar *map;
int nblocks;
Tfile *f;
int nf;
int fsize;
};
static struct {
Tfs fs[Maxfs];
} tinyfs;
#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)};
static uchar
checksum(uchar *p)
{
uchar *e;
uchar s;
s = 0;
for(e = p + Blen; p < e; p++)
s += *p;
return s;
}
static void
mapclr(Tfs *fs, ulong bno)
{
fs->map[bno>>3] &= ~(1<<(bno&7));
}
static void
mapset(Tfs *fs, ulong bno)
{
fs->map[bno>>3] |= 1<<(bno&7);
}
static int
isalloced(Tfs *fs, ulong bno)
{
return fs->map[bno>>3] & (1<<(bno&7));
}
static int
mapalloc(Tfs *fs)
{
int i, j, lim;
uchar x;
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);
return i*8 + j;
}
}
return Notabno;
}
static Mdir*
validdir(Tfs *fs, uchar *p)
{
Mdir *md;
ulong x;
if(checksum(p) != 0)
return 0;
if(p[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, int *lenp)
{
Mdata *md;
ulong x;
if(checksum(p) != 0)
return 0;
md = (Mdata*)p;
switch(md->type){
case Tagdata:
x = GETS(md->bno);
if(x >= fs->nblocks)
return 0;
if(lenp)
*lenp = Dlen;
break;
case Tagend:
x = GETS(md->bno);
if(x > Dlen)
return 0;
if(lenp)
*lenp = x;
break;
default:
return 0;
}
return md;
}
static Mdata*
readdata(Tfs *fs, ulong bno, uchar *buf, int *lenp)
{
if(bno >= fs->nblocks)
return 0;
if(fs->c->dev->read(fs->c, buf, Blen, Blen*bno) != Blen)
error(Eio);
return validdata(fs, buf, lenp);
}
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(fs->c->dev->write(fs->c, &md, Blen, Blen*bno) != Blen)
error(Eio);
}
static void
writedir(Tfs *fs, Tfile *f)
{
Mdir *md;
uchar buf[Blen];
if(f->bno == Notabno)
return;
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);
md->sum = 0 - checksum(buf);
if(fs->c->dev->write(fs->c, buf, Blen, Blen*f->bno) != Blen)
error(Eio);
}
static void
freeblocks(Tfs *fs, ulong bno, ulong bend)
{
uchar buf[Blen];
Mdata *md;
if(waserror())
return;
while(bno != bend && bno != Notabno){
mapclr(fs, bno);
if(fs->c->dev->read(fs->c, buf, Blen, Blen*bno) != Blen)
break;
md = validdata(fs, buf, 0);
if(md == 0)
break;
if(md->type == Tagend)
break;
bno = GETS(md->bno);
}
poperror();
}
static void
freefile(Tfs *fs, Tfile *f, ulong bend)
{
uchar buf[Blen];
/* remove blocks from map */
freeblocks(fs, f->dbno, bend);
/* change file type to free on medium */
if(f->bno != Notabno){
memset(buf, 0x55, Blen);
fs->c->dev->write(fs->c, buf, Blen, Blen*f->bno);
mapclr(fs, f->bno);
}
/* forget we ever knew about it */
memset(f, 0, sizeof(*f));
}
static void
expand(Tfs *fs)
{
Tfile *f;
fs->fsize += 8;
f = malloc(fs->fsize*sizeof(*f));
if(f == nil)
error(Enomem);
if(fs->f){
memmove(f, fs->f, fs->nf*sizeof(*f));
free(fs->f);
}
fs->f = f;
}
static Tfile*
newfile(Tfs *fs, char *name)
{
int i;
volatile struct {
Tfile *f;
Tfs *fs;
} rock;
/* find free entry in file table */
rock.f = 0;
rock.fs = fs;
for(;;) {
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);
break;
}
}
if(i < rock.fs->fsize){
if(i >= rock.fs->nf)
rock.fs->nf = i+1;
break;
}
expand(rock.fs);
}
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;
/* write directory block */
if(waserror()){
freefile(rock.fs, rock.f, Notabno);
nexterror();
}
if(rock.f->bno == Notabno)
error("out of space");
writedir(rock.fs, rock.f);
poperror();
return rock.f;
}
/*
* Read the whole medium and build a file table and used
* block bitmap. Inconsistent files are purged. The medium
* had better be small or this could take a while.
*/
static void
tfsinit(Tfs *fs)
{
uchar dbuf[STATFIXLEN+32*4];
Dir d;
uchar buf[Blen];
ulong x, bno;
int n, done;
Tfile *f;
Mdir *mdir;
Mdata *mdata;
n = fs->c->dev->stat(fs->c, dbuf, sizeof(dbuf));
n = convM2D(dbuf, n, &d, nil);
if(n <= 0)
error("cannot stat tinyfs medium");
fs->nblocks = d.length/Blen;
if(fs->nblocks < 3)
error("tinyfs medium too small");
/* bitmap for block usage */
x = (fs->nblocks + 8 - 1)/8;
fs->map = malloc(x);
if(fs->map == nil)
error(Enomem);
for(bno = fs->nblocks; bno < x*8; bno++)
mapset(fs, bno);
/* find files */
for(bno = 0; bno < fs->nblocks; bno++){
n = fs->c->dev->read(fs->c, buf, Blen, Blen*bno);
if(n != Blen)
break;
mdir = validdir(fs, buf);
if(mdir == 0)
continue;
if(fs->nf >= 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;
f->fbno = Notabno;
}
/* follow files */
for(f = fs->f; f < &(fs->f[fs->nf]); f++){
bno = f->dbno;
for(done = 0; !done;) {
if(isalloced(fs, bno)){
freefile(fs, f, bno);
break;
}
n = fs->c->dev->read(fs->c, buf, Blen, Blen*bno);
if(n != Blen){
freefile(fs, f, bno);
break;
}
mdata = validdata(fs, buf, 0);
if(mdata == 0){
freefile(fs, f, bno);
break;
}
mapset(fs, bno);
switch(mdata->type){
case Tagdata:
bno = GETS(mdata->bno);
f->length += Dlen;
break;
case Tagend:
f->length += GETS(mdata->bno);
done = 1;
break;
}
if(done)
f->flag &= ~Fcreating;
}
}
}
/*
* single directory
*/
static int
tinyfsgen(Chan *c, char *name, Dirtab *tab, int ntab, int i, Dir *dp)
{
Tfs *fs;
Tfile *f;
Qid qid;
USED(name);
USED(ntab);
USED(tab);
fs = &tinyfs.fs[c->devno];
if(i >= fs->nf)
return -1;
qid.vers = 0;
if(i == DEVDOTDOT){
qid.type = QTDIR;
devdir(c, qid, ".", 0, eve, DMDIR|0555, dp);
return 1;
}
f = &fs->f[i];
if(f->name[0] == 0)
return 0;
qid.path = i+1;
qid.type = QTFILE;
devdir(c, qid, f->name, f->length, eve, 0664, dp);
return 1;
}
/*
* specifier is the name of a device in /dev
*/
static Chan *
tinyfsattach(char *spec)
{
Tfs *fs;
Chan *c;
volatile struct { Chan *cc; } rock;
int i;
char buf[KNAMELEN*3];
if(*spec == 0 || strchr(spec, '/') != nil)
error("bad specifier");
snprint(buf, sizeof(buf), "/dev/%s", spec);
rock.cc = namec(buf, Aopen, ORDWR, 0);
if(waserror()){
cclose(rock.cc);
nexterror();
}
fs = 0;
for(i = 0; i < Maxfs; i++){
fs = &tinyfs.fs[i];
qlock(&fs->ql);
if(fs->r && eqchan(rock.cc, fs->c, 1))
break;
qunlock(&fs->ql);
}
if(i < Maxfs){
fs->r++;
qunlock(&fs->ql);
cclose(rock.cc);
} else {
for(fs = tinyfs.fs; fs < &tinyfs.fs[Maxfs]; fs++){
qlock(&fs->ql);
if(fs->r == 0)
break;
qunlock(&fs->ql);
}
if(fs == &tinyfs.fs[Maxfs])
error("too many tinyfs's");
fs->c = rock.cc;
fs->r = 1;
fs->f = 0;
fs->nf = 0;
fs->fsize = 0;
tfsinit(fs);
qunlock(&fs->ql);
}
poperror();
c = devattach('F', spec);
c->devno = fs - tinyfs.fs;
c->qid.type = QTDIR;
c->qid.vers = 0;
return c;
}
static Walkqid*
tinyfswalk(Chan *c, Chan *nc, char **name, int nname)
{
Tfs *fs;
Walkqid *wq;
fs = &tinyfs.fs[c->devno];
qlock(&fs->ql);
wq = devwalk(c, nc, name, nname, 0, 0, tinyfsgen);
if(wq != nil && (nc = wq->clone) != nil && nc->qid.path != Qdir){
fs = &tinyfs.fs[nc->devno];
fs->f[nc->qid.path-1].r++;
}
qunlock(&fs->ql);
return wq;
}
static int
tinyfsstat(Chan *c, uchar *db, int n)
{
return devstat(c, db, n, 0, 0, tinyfsgen);
}
static Chan *
tinyfsopen(Chan *c, int omode)
{
Tfile *f;
volatile struct { Tfs *fs; } rock;
rock.fs = &tinyfs.fs[c->devno];
if(c->qid.type & QTDIR){
if(omode != OREAD)
error(Eperm);
} else {
qlock(&rock.fs->ql);
if(waserror()){
qunlock(&rock.fs->ql);
nexterror();
}
switch(omode){
case OTRUNC|ORDWR:
case OTRUNC|OWRITE:
f = newfile(rock.fs, rock.fs->f[c->qid.path-1].name);
rock.fs->f[c->qid.path-1].r--;
c->qid.path = f - rock.fs->f;
break;
case OREAD:
break;
default:
error(Eperm);
}
qunlock(&rock.fs->ql);
poperror();
}
return devopen(c, omode, 0, 0, tinyfsgen);
}
static void
tinyfscreate(Chan *c, char *name, int omode, ulong perm)
{
volatile struct { Tfs *fs; } rock;
Tfile *f;
USED(perm);
rock.fs = &tinyfs.fs[c->devno];
qlock(&rock.fs->ql);
if(waserror()){
qunlock(&rock.fs->ql);
nexterror();
}
f = newfile(rock.fs, name);
qunlock(&rock.fs->ql);
poperror();
c->qid.path = (f - rock.fs->f)+1;
c->qid.vers = 0;
c->qid.type = QTFILE;
c->mode = openmode(omode);
}
static void
tinyfsremove(Chan *c)
{
Tfs *fs;
Tfile *f;
if(c->qid.path == Qdir)
error(Eperm);
fs = &tinyfs.fs[c->devno];
f = &fs->f[c->qid.path-1];
qlock(&fs->ql);
freefile(fs, f, Notabno);
qunlock(&fs->ql);
}
static void
tinyfsclose(Chan *c)
{
volatile struct { Tfs *fs; } rock;
Tfile *f, *nf;
int i;
rock.fs = &tinyfs.fs[c->devno];
qlock(&rock.fs->ql);
/* dereference file and remove old versions */
if(!waserror()){
if(c->qid.path != Qdir){
f = &rock.fs->f[c->qid.path-1];
f->r--;
if(f->r == 0){
if(f->flag & Frmonclose)
freefile(rock.fs, f, Notabno);
else if(f->flag & Fcreating){
/* remove all other files with this name */
for(i = 0; i < rock.fs->fsize; i++){
nf = &rock.fs->f[i];
if(f == nf)
continue;
if(strcmp(nf->name, f->name) == 0){
if(nf->r)
nf->flag |= Frmonclose;
else
freefile(rock.fs, nf, Notabno);
}
}
f->flag &= ~Fcreating;
}
}
}
poperror();
}
/* 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;
}
qunlock(&rock.fs->ql);
}
static long
tinyfsread(Chan *c, void *a, long n, vlong offset)
{
volatile struct { Tfs *fs; } rock;
Tfile *f;
int sofar, i, off;
ulong bno;
Mdata *md;
uchar buf[Blen];
uchar *p;
if(c->qid.type & QTDIR)
return devdirread(c, a, n, 0, 0, tinyfsgen);
p = a;
rock.fs = &tinyfs.fs[c->devno];
f = &rock.fs->f[c->qid.path-1];
if(offset >= f->length)
return 0;
qlock(&rock.fs->ql);
if(waserror()){
qunlock(&rock.fs->ql);
nexterror();
}
if(n + offset >= f->length)
n = f->length - offset;
/* walk to starting data block */
if(0 && f->finger <= offset && f->fbno != Notabno){
sofar = f->finger;
bno = f->fbno;
} else {
sofar = 0;
bno = f->dbno;
}
for(; sofar + Dlen <= offset; sofar += Dlen){
md = readdata(rock.fs, bno, buf, 0);
if(md == 0)
error(Eio);
bno = GETS(md->bno);
}
/* read data */
off = offset%Dlen;
offset -= off;
for(sofar = 0; sofar < n; sofar += i){
md = readdata(rock.fs, bno, buf, &i);
if(md == 0)
error(Eio);
/* update finger for successful read */
f->finger = offset;
f->fbno = bno;
offset += Dlen;
i -= off;
if(i > n - sofar)
i = n - sofar;
memmove(p, md->data+off, i);
p += i;
bno = GETS(md->bno);
off = 0;
}
qunlock(&rock.fs->ql);
poperror();
return sofar;
}
/*
* if we get a write error in this routine, blocks will
* be lost. They should be recovered next fsinit.
*/
static long
tinyfswrite(Chan *c, void *a, long n, vlong offset)
{
Tfile *f;
int last, next, i, finger, off, used;
ulong bno, fbno;
Mdata *md;
uchar buf[Blen];
uchar *p;
volatile struct {
Tfs *fs;
ulong dbno;
} rock;
if(c->qid.type & QTDIR)
error(Eperm);
if(n == 0)
return 0;
p = a;
rock.fs = &tinyfs.fs[c->devno];
f = &rock.fs->f[c->qid.path-1];
qlock(&rock.fs->ql);
rock.dbno = Notabno;
if(waserror()){
freeblocks(rock.fs, rock.dbno, Notabno);
qunlock(&rock.fs->ql);
nexterror();
}
/* files are append only, anything else is illegal */
if(offset != f->length)
error("append only");
/* write blocks backwards */
p += n;
last = offset + n;
fbno = Notabno;
finger = 0;
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)
error("out of space");
i = last - next;
p -= i;
if(last == n+offset){
writedata(rock.fs, bno, rock.dbno, p, i, 1);
finger = next; /* remember for later */
fbno = bno;
} else {
writedata(rock.fs, bno, rock.dbno, p, i, 0);
}
rock.dbno = bno;
last = next;
}
/* walk to last data block */
md = (Mdata*)buf;
if(0 && f->finger < offset && f->fbno != Notabno){
next = f->finger;
bno = f->fbno;
} else {
next = 0;
bno = f->dbno;
}
used = 0;
while(bno != Notabno){
md = readdata(rock.fs, bno, buf, &used);
if(md == 0)
error(Eio);
if(md->type == Tagend){
if(next + Dlen < offset)
panic("devtinyfs1");
break;
}
next += Dlen;
if(next > offset)
panic("devtinyfs1");
bno = GETS(md->bno);
}
/* point to new blocks */
if(offset == 0){
/* first block in a file */
f->dbno = rock.dbno;
writedir(rock.fs, f);
} else {
/* updating a current block */
i = last - offset;
if(i > 0){
p -= i;
memmove(md->data + used, p, i);
used += i;
}
writedata(rock.fs, bno, rock.dbno, md->data, used, last == n+offset);
}
f->length += n;
/* update finger */
if(fbno != Notabno){
f->finger = finger;
f->fbno = fbno;
}
poperror();
qunlock(&rock.fs->ql);
return n;
}
Dev tinyfsdevtab = {
'F',
"tinyfs",
devreset,
devinit,
devshutdown,
tinyfsattach,
tinyfswalk,
tinyfsstat,
tinyfsopen,
tinyfscreate,
tinyfsclose,
tinyfsread,
devbread,
tinyfswrite,
devbwrite,
tinyfsremove,
devwstat
};