diff options
Diffstat (limited to 'appl/cmd/memfs.b')
| -rw-r--r-- | appl/cmd/memfs.b | 648 |
1 files changed, 648 insertions, 0 deletions
diff --git a/appl/cmd/memfs.b b/appl/cmd/memfs.b new file mode 100644 index 00000000..e18388c5 --- /dev/null +++ b/appl/cmd/memfs.b @@ -0,0 +1,648 @@ +implement MemFS; + +include "sys.m"; + sys: Sys; + OTRUNC, ORCLOSE, OREAD, OWRITE: import Sys; +include "styx.m"; + styx: Styx; + Tmsg, Rmsg: import styx; +include "styxlib.m"; + styxlib: Styxlib; + Styxserver: import styxlib; +include "draw.m"; +include "arg.m"; + +MemFS: module { + init: fn(ctxt: ref Draw->Context, args: list of string); +}; + + +blksz : con 512; +Efull : con "filesystem full"; + +Memfile : adt { + name : string; + owner : string; + qid : Sys->Qid; + perm : int; + atime : int; + mtime : int; + nopen : int; + data : array of array of byte; # allocated in blks, no holes + length : int; + parent : cyclic ref Memfile; # Dir entry linkage + kids : cyclic ref Memfile; + prev : cyclic ref Memfile; + next : cyclic ref Memfile; + hashnext : cyclic ref Memfile; # Qid hash linkage +}; + +Qidhash : adt { + buckets : array of ref Memfile; + nextqid : int; + new : fn () : ref Qidhash; + add : fn (h : self ref Qidhash, mf : ref Memfile); + remove : fn (h : self ref Qidhash, mf : ref Memfile); + lookup : fn (h : self ref Qidhash, qid : Sys->Qid) : ref Memfile; +}; + +timefd: ref Sys->FD; + +init(nil: ref Draw->Context, argv: list of string) +{ + sys = load Sys Sys->PATH; + styx = checkload(load Styx Styx->PATH, Styx->PATH); + styxlib = checkload(load Styxlib Styxlib->PATH, Styxlib->PATH); + arg := checkload(load Arg Arg->PATH, Arg->PATH); + + amode := Sys->MREPL; + maxsz := 16r7fffffff; + srv := 0; + mntpt := "/tmp"; + + arg->init(argv); + arg->setusage("memfs [-s] [-rab] [-m size] [mountpoint]"); + while((opt := arg->opt()) != 0) { + case opt{ + 's' => + srv = 1; + 'r' => + amode = Sys->MREPL; + 'a' => + amode = Sys->MAFTER; + 'b' => + amode = Sys->MBEFORE; + 'm' => + maxsz = int arg->earg(); + * => + arg->usage(); + } + } + argv = arg->argv(); + arg = nil; + if (argv != nil) + mntpt = hd argv; + + srvfd: ref Sys->FD; + mntfd: ref Sys->FD; + if (srv) + srvfd = sys->fildes(0); + else { + p := array [2] of ref Sys->FD; + if (sys->pipe(p) == -1) + error(sys->sprint("cannot create pipe: %r")); + mntfd = p[0]; + srvfd = p[1]; + } + styx->init(); + styxlib->init(styx); + timefd = sys->open("/dev/time", sys->OREAD); + + (tc, styxsrv) := Styxserver.new(srvfd); + if (srv) + memfs(maxsz, tc, styxsrv, nil); + else { + sync := chan of int; + spawn memfs(maxsz, tc, styxsrv, sync); + <-sync; + if (sys->mount(mntfd, nil, mntpt, amode | Sys->MCREATE, nil) == -1) + error(sys->sprint("failed to mount onto %s: %r", mntpt)); + } +} + +checkload[T](x: T, p: string): T +{ + if(x == nil) + error(sys->sprint("cannot load %s: %r", p)); + return x; +} + +stderr(): ref Sys->FD +{ + return sys->fildes(2); +} + +error(e: string) +{ + sys->fprint(stderr(), "memfs: %s\n", e); + raise "fail:error"; +} + +freeblks: int; + +memfs(maxsz : int, tc : chan of ref Tmsg, srv : ref Styxserver, sync: chan of int) +{ + sys->pctl(Sys->NEWNS, nil); + if (sync != nil) + sync <-= 1; + freeblks = (maxsz / blksz); + qhash := Qidhash.new(); + + # init root + root := newmf(qhash, nil, "memfs", srv.uname, 8r755 | Sys->DMDIR); + root.parent = root; + + while((tmsg := <-tc) != nil) { +# sys->print("%s\n", tmsg.text()); + Msg: + pick tm := tmsg { + Readerror => + break; + Version => + srv.devversion(tm); + Auth => + srv.devauth(tm); + Flush => + srv.reply(ref Rmsg.Flush(tm.tag)); + Walk => + (err, c, mf) := fidtomf(srv, qhash, tm.fid); + if (err != "") { + srv.reply(ref Rmsg.Error(tm.tag, err)); + continue; + } + nc: ref styxlib->Chan; + if (tm.newfid != tm.fid) { + nc = srv.clone(c, tm.newfid); + if (nc == nil) { + srv.reply(ref Rmsg.Error(tm.tag, "fid in use")); + continue; + } + c = nc; + } + qids: array of Sys->Qid; + if (len tm.names > 0) { + oqid := c.qid; + opath := c.path; + qids = array[len tm.names] of Sys->Qid; + wmf := mf; + for (i := 0; i < len tm.names; i++) { + wmf = dirlookup(wmf, tm.names[i]); + if (wmf == nil) { + if (nc == nil) { + c.qid = oqid; + c.path = opath; + } else + srv.chanfree(nc); + if (i == 0) + srv.reply(ref Rmsg.Error(tm.tag, Styxlib->Enotfound)); + else + srv.reply(ref Rmsg.Walk(tm.tag, qids[0:i])); + break Msg; + } + c.qid = wmf.qid; + qids[i] = wmf.qid; + } + } + srv.reply(ref Rmsg.Walk(tm.tag, qids)); + Open => + (err, c, mf) := fidtomf(srv, qhash, tm.fid); + if (err == "" && c.open) + err = Styxlib->Eopen; + if (err == "" && !modeok(tm.mode, mf.perm, c.uname, mf.owner)) + err = Styxlib->Eperm; + if (err == "" && (mf.perm & Sys->DMDIR) && (tm.mode & (OTRUNC|OWRITE|ORCLOSE))) + err = Styxlib->Eperm; + if (err == "" && (tm.mode & ORCLOSE)) { + p := mf.parent; + if (p == nil || !modeok(OWRITE, p.perm, c.uname, p.owner)) + err = Styxlib->Eperm; + } + + if (err != "") { + srv.reply(ref Rmsg.Error(tm.tag, err)); + continue; + } + + c.open = 1; + c.mode = tm.mode; + c.qid.vers = mf.qid.vers; + mf.nopen++; + if (tm.mode & OTRUNC) { + # OTRUNC cannot be set for a directory + # always at least one blk so don't need to check fs limit + freeblks += (len mf.data); + mf.data = nil; + freeblks--; + mf.data = array[1] of {* => array [blksz] of byte}; + mf.length = 0; + mf.mtime = now(); + } + srv.reply(ref Rmsg.Open(tm.tag, mf.qid, Styx->MAXFDATA)); + Create => + (err, c, parent) := fidtomf(srv, qhash, tm.fid); + if (err == "" && c.open) + err = Styxlib->Eopen; + if (err == "" && !(parent.qid.qtype & Sys->QTDIR)) + err = Styxlib->Enotdir; + if (err == "" && !modeok(OWRITE, parent.perm, c.uname, parent.owner)) + err = Styxlib->Eperm; + if (err == "" && (tm.perm & Sys->DMDIR) && (tm.mode & (OTRUNC|OWRITE|ORCLOSE))) + err = Styxlib->Eperm; + if (err == "" && dirlookup(parent, tm.name) != nil) + err = Styxlib->Eexists; + + if (err != "") { + srv.reply(ref Rmsg.Error(tm.tag, err)); + continue; + } + + isdir := tm.perm & Sys->DMDIR; + if (!isdir && freeblks <= 0) { + srv.reply(ref Rmsg.Error(tm.tag, Efull)); + continue; + } + + # modify perms as per Styx specification... + perm : int; + if (isdir) + perm = (tm.perm&~8r777) | (parent.perm&tm.perm&8r777); + else + perm = (tm.perm&(~8r777|8r111)) | (parent.perm&tm.perm& 8r666); + + nmf := newmf(qhash, parent, tm.name, c.uname, perm); + if (!isdir) { + freeblks--; + nmf.data = array[1] of {* => array [blksz] of byte}; + } + + # link in the new MemFile + nmf.next = parent.kids; + if (parent.kids != nil) + parent.kids.prev = nmf; + parent.kids = nmf; + + c.open = 1; + c.mode = tm.mode; + c.qid = nmf.qid; + nmf.nopen = 1; + srv.reply(ref Rmsg.Create(tm.tag, nmf.qid, Styx->MAXFDATA)); + Read => + (err, c, mf) := fidtomf(srv, qhash, tm.fid); + if (err == "" && !c.open) + err = Styxlib->Ebadfid; + + if (err != "") { + srv.reply(ref Rmsg.Error(tm.tag, err)); + continue; + } + data: array of byte = nil; + if (mf.perm & Sys->DMDIR) + data = dirdata(mf, int tm.offset, tm.count); + else + data = filedata(mf, int tm.offset, tm.count); + mf.atime = now(); + srv.reply(ref Rmsg.Read(tm.tag, data)); + Write => + (err, c, mf) := fidtomf(srv, qhash, tm.fid); + if (c != nil && !c.open) + err = Styxlib->Ebadfid; + if (err == nil && (mf.perm & Sys->DMDIR)) + err = Styxlib->Eperm; + if (err == nil) + err = writefile(mf, int tm.offset, tm.data); + if (err != nil) { + srv.reply(ref Rmsg.Error(tm.tag, err)); + continue; + } + srv.reply(ref Rmsg.Write(tm.tag, len tm.data)); + Clunk => + (err, c, mf) := fidtomf(srv, qhash, tm.fid); + if (c != nil) + srv.chanfree(c); + if (err != nil) { + srv.reply(ref Rmsg.Error(tm.tag, err)); + continue; + } + if (c.open) { + if (c.mode & ORCLOSE) + unlink(mf); + mf.nopen--; + freeblks += delfile(qhash, mf); + } + srv.reply(ref Rmsg.Clunk(tm.tag)); + Stat => + (err, c, mf) := fidtomf(srv, qhash, tm.fid); + if (err != nil) { + srv.reply(ref Rmsg.Error(tm.tag, err)); + continue; + } + srv.reply(ref Rmsg.Stat(tm.tag, fileinfo(mf))); + Remove => + (err, c, mf) := fidtomf(srv, qhash, tm.fid); + if (err != nil) { + srv.reply(ref Rmsg.Error(tm.tag, err)); + continue; + } + srv.chanfree(c); + parent := mf.parent; + if (!modeok(OWRITE, parent.perm, c.uname, parent.owner)) + err = Styxlib->Eperm; + if (err == "" && (mf.perm & Sys->DMDIR) && mf.kids != nil) + err = "directory not empty"; + if (err == "" && mf == root) + err = "root directory"; + if (err != nil) { + srv.reply(ref Rmsg.Error(tm.tag, err)); + continue; + } + + unlink(mf); + if (c.open) + mf.nopen--; + freeblks += delfile(qhash, mf); + srv.reply(ref Rmsg.Remove(tm.tag)); + Wstat => + (err, c, mf) := fidtomf(srv, qhash, tm.fid); + stat := tm.stat; + perm := mf.perm & ~Sys->DMDIR; + if (err == nil && stat.name != mf.name) { + parent := mf.parent; + if (!modeok(OWRITE, parent.perm, c.uname, parent.owner)) + err = Styxlib->Eperm; + else if (dirlookup(parent, stat.name) != nil) + err = Styxlib->Eexists; + } + if (err == nil && (stat.mode != mf.perm || stat.mtime != mf.mtime)) { + if (c.uname != mf.owner) + err = Styxlib->Eperm; + } + if (err != nil) { + srv.reply(ref Rmsg.Error(tm.tag, err)); + continue; + } + isdir := mf.perm & Sys->DMDIR; + if(stat.name != nil) + mf.name = stat.name; + if(stat.mode != ~0) + mf.perm = stat.mode | isdir; + if(stat.mtime != ~0) + mf.mtime = stat.mtime; + if(stat.uid != nil) + mf.owner = stat.uid; + t := now(); + mf.atime = t; + mf.parent.mtime = t; + # not supporting group id at the moment + srv.reply(ref Rmsg.Wstat(tm.tag)); + Attach => + c := srv.newchan(tm.fid); + if (c == nil) { + srv.reply(ref Rmsg.Error(tm.tag, Styxlib->Einuse)); + continue; + } + c.uname = tm.uname; + c.qid = root.qid; + srv.reply(ref Rmsg.Attach(tm.tag, c.qid)); + } + } +} + +writefile(mf: ref Memfile, offset: int, data: array of byte): string +{ + if(mf.perm & Sys->DMAPPEND) + offset = mf.length; + startblk := offset/blksz; + nblks := ((len data + offset) - (startblk * blksz))/blksz; + lastblk := startblk + nblks; + need := lastblk + 1 - len mf.data; + if (need > 0) { + if (need > freeblks) + return Efull; + mf.data = (array [lastblk+1] of array of byte)[:] = mf.data; + freeblks -= need; + } + mf.length = max(mf.length, offset + len data); + + # handle (possibly incomplete first block) separately + offset %= blksz; + end := min(blksz-offset, len data); + if (mf.data[startblk] == nil) + mf.data[startblk] = array [blksz] of byte; + mf.data[startblk++][offset:] = data[:end]; + + ix := blksz - offset; + while (ix < len data) { + if (mf.data[startblk] == nil) + mf.data[startblk] = array [blksz] of byte; + end = min(ix+blksz,len data); + mf.data[startblk++][:] = data[ix:end]; + ix += blksz; + } + mf.mtime = now(); + return nil; +} + +filedata(mf: ref Memfile, offset, n: int): array of byte +{ + if (offset +n > mf.length) + n = mf.length - offset; + if (n == 0) + return nil; + + data := array [n] of byte; + startblk := offset/blksz; + offset %= blksz; + rn := min(blksz - offset, n); + data[:] = mf.data[startblk++][offset:offset+rn]; + ix := blksz - offset; + while (ix < n) { + rn = blksz; + if (ix+rn > n) + rn = n - ix; + data[ix:] = mf.data[startblk++][:rn]; + ix += blksz; + } + return data; +} + +QHSIZE: con 256; +QHMASK: con QHSIZE-1; + +Qidhash.new() : ref Qidhash +{ + qh := ref Qidhash; + qh.buckets = array [QHSIZE] of ref Memfile; + qh.nextqid = 0; + return qh; +} + +Qidhash.add(h : self ref Qidhash, mf : ref Memfile) +{ + path := h.nextqid++; + mf.qid = Sys->Qid(big path, 0, Sys->QTFILE); + bix := path & QHMASK; + mf.hashnext = h.buckets[bix]; + h.buckets[bix] = mf; +} + +Qidhash.remove(h : self ref Qidhash, mf : ref Memfile) +{ + + bix := int mf.qid.path & QHMASK; + prev : ref Memfile; + for (cur := h.buckets[bix]; cur != nil; cur = cur.hashnext) { + if (cur == mf) + break; + prev = cur; + } + if (cur != nil) { + if (prev != nil) + prev.hashnext = cur.hashnext; + else + h.buckets[bix] = cur.hashnext; + cur.hashnext = nil; + } +} + +Qidhash.lookup(h : self ref Qidhash, qid : Sys->Qid) : ref Memfile +{ + bix := int qid.path & QHMASK; + for (mf := h.buckets[bix]; mf != nil; mf = mf.hashnext) + if (mf.qid.path == qid.path) + break; + return mf; +} + +newmf(qh : ref Qidhash, parent : ref Memfile, name, owner : string, perm : int) : ref Memfile +{ + # qid gets set by Qidhash.add() + t := now(); + mf := ref Memfile (name, owner, Sys->Qid(big 0,0,Sys->QTFILE), perm, t, t, 0, nil, 0, parent, nil, nil, nil, nil); + qh.add(mf); + if(perm & Sys->DMDIR) + mf.qid.qtype = Sys->QTDIR; + return mf; +} + +fidtomf(srv : ref Styxserver, qh : ref Qidhash, fid : int) : (string, ref Styxlib->Chan, ref Memfile) +{ + c := srv.fidtochan(fid); + if (c == nil) + return (Styxlib->Ebadfid, nil, nil); + mf := qh.lookup(c.qid); + if (mf == nil) + return (Styxlib->Enotfound, c, nil); + return (nil, c, mf); +} + +unlink(mf : ref Memfile) +{ + parent := mf.parent; + if (parent == nil) + return; + if (mf.next != nil) + mf.next.prev = mf.prev; + if (mf.prev != nil) + mf.prev.next = mf.next; + else + mf.parent.kids = mf.next; + mf.parent = nil; + mf.prev = nil; + mf.next = nil; +} + +delfile(qh : ref Qidhash, mf : ref Memfile) : int +{ + if (mf.nopen <= 0 && mf.parent == nil && mf.kids == nil + && mf.prev == nil && mf.next == nil) { + qh.remove(mf); + nblks := len mf.data; + mf.data = nil; + return nblks; + } + return 0; +} + +dirlookup(dir : ref Memfile, name : string) : ref Memfile +{ + if (name == ".") + return dir; + if (name == "..") + return dir.parent; + for (mf := dir.kids; mf != nil; mf = mf.next) { + if (mf.name == name) + break; + } + return mf; +} + +access := array[] of {8r400, 8r200, 8r600, 8r100}; +modeok(mode, perm : int, user, owner : string) : int +{ + if(mode >= (OTRUNC|ORCLOSE|OREAD|OWRITE)) + return 0; + + # not handling groups! + if (user != owner) + perm <<= 6; + + if ((mode & OTRUNC) && !(perm & 8r200)) + return 0; + + a := access[mode &3]; + if ((a & perm) != a) + return 0; + return 1; +} + +dirdata(dir : ref Memfile, start, n : int) : array of byte +{ + data := array[Styx->MAXFDATA] of byte; + for (k := dir.kids; start > 0 && k != nil; k = k.next) { + a := styx->packdir(fileinfo(k)); + start -= len a; + } + r := 0; + for (; r < n && k != nil; k = k.next) { + a := styx->packdir(fileinfo(k)); + if(r+len a > n) + break; + data[r:] = a; + r += len a; + } + return data[0:r]; +} + +fileinfo(f : ref Memfile) : Sys->Dir +{ + dir := sys->zerodir; + dir.name = f.name; + dir.uid = f.owner; + dir.gid = "memfs"; + dir.qid = f.qid; + dir.mode = f.perm; + dir.atime = f.atime; + dir.mtime = f.mtime; + dir.length = big f.length; + dir.dtype = 0; + dir.dev = 0; + return dir; +} + +min(a, b : int) : int +{ + if (a < b) + return a; + return b; +} + +max(a, b : int) : int +{ + if (a > b) + return a; + return b; +} + +now(): int +{ + if (timefd == nil) + return 0; + buf := array[128] of byte; + sys->seek(timefd, big 0, 0); + n := sys->read(timefd, buf, len buf); + if(n < 0) + return 0; + + t := (big string buf[0:n]) / big 1000000; + return int t; +} |