20070614-1508 initial vac things, man/lib

6 files changed, 2005 insertions, 0 deletions

diff --git a/appl/cmd/mkfile b/appl/cmd/mkfile
index 69cf60d0..29c1679f 100644
--- a/appl/cmd/mkfile
+++ b/appl/cmd/mkfile
@@ -160,6 +160,9 @@ TARG=\
 	unmount.dis\
 	uudecode.dis\
 	uuencode.dis\
+	vacfs.dis\
+	vacget.dis\
+	vacput.dis\
 	wav2iaf.dis\
 	wc.dis\
 	webgrab.dis\
@@ -216,3 +219,6 @@ rawdbfs.dis: $MODDIR/styxservers.m
 import.dis:	$MODDIR/encoding.m $MODDIR/factotum.m
 basename.dis: $MODDIR/names.m
 cleanname.dis: $MODDIR/names.m
+vacfs.dis:	$MODDIR/vac.m $MODDIR/venti.m
+vacget.dis:	$MODDIR/vac.m $MODDIR/venti.m
+vacput.dis:	$MODDIR/vac.m $MODDIR/venti.m
diff --git a/appl/cmd/vacfs.b b/appl/cmd/vacfs.b
new file mode 100644
index 00000000..5fffc98d
--- /dev/null
+++ b/appl/cmd/vacfs.b
@@ -0,0 +1,446 @@
+implement Vacfs;
+
+include "sys.m";
+	sys: Sys;
+include "draw.m";
+include "arg.m";
+include "string.m";
+include "daytime.m";
+include "venti.m";
+include "vac.m";
+include "styx.m";
+	styx: Styx;
+	Tmsg, Rmsg: import styx;
+include "styxservers.m";
+
+str: String;
+daytime: Daytime;
+venti: Venti;
+vac: Vac;
+styxservers: Styxservers;
+
+print, sprint, fprint, fildes: import sys;
+Score, Session: import venti;
+Roottype, Dirtype, Pointertype0, Datatype: import venti;
+Root, Entry, Direntry, Metablock, Metaentry, Entrysize, Modeperm, Modeappend, Modeexcl, Modedir, Modesnapshot, Vacdir, Vacfile, Source: import vac;
+Styxserver, Fid, Navigator, Navop, Enotfound: import styxservers;
+
+Vacfs: module {
+	init:	fn(nil: ref Draw->Context, args: list of string);
+};
+
+addr := "net!$venti!venti";
+dflag := pflag := 0;
+session: ref Session;
+
+ss: ref Styxserver;
+
+Elem: adt {
+	qid:	int;
+	de: 	ref Direntry;
+	size:	big;
+	pick {
+	File =>	vf: 	ref Vacfile;
+	Dir =>	vd:	ref Vacdir;
+		pqid:	int;
+		offset:	int;
+		nprev:	int;
+		prev:	array of ref Sys->Dir;
+	}
+
+	new:	fn(nqid: int, vd: ref Vacdir, de: ref Direntry, pqid: int): ref Elem;
+	stat:	fn(e: self ref Elem): ref Sys->Dir;
+};
+
+Qdir: adt {
+	qid:	int;
+	cqids:	list of (big, int);
+};
+
+elems := array[512] of list of ref Elem;
+qids := array[512] of list of ref Qdir;
+lastqid := 0;
+qidscores: list of (string, int);
+
+
+childget(qid: int, vqid: big): ref Elem
+{
+	for(l := qids[qid % len qids]; l != nil; l = tl l) {
+		if((hd l).qid != qid)
+			continue;
+		for(m := (hd l).cqids; m != nil; m = tl m) {
+			(vq, cq) := hd m;
+			if(vq == vqid)
+				return get(cq);
+		}
+	}
+	return nil;
+}
+
+childput(qid: int, vqid: big): int
+{
+	qd: ref Qdir;
+	for(l := qids[qid % len qids]; l != nil; l = tl l)
+		if((hd l).qid == qid) {
+			qd = hd l;
+			break;
+		}
+	if(qd == nil) {
+		qd = ref Qdir(qid, nil);
+		qids[qid % len qids] = qd::nil;
+	}
+	qd.cqids = (vqid, ++lastqid)::qd.cqids;
+	return lastqid;
+}
+
+scoreget(score: string): ref Elem
+{
+	for(l := qidscores; l != nil; l = tl l) {
+		(s, n) := hd l;
+		if(s == score)
+			return get(n);
+	}
+	return nil;
+}
+
+scoreput(score: string): int
+{
+	qidscores = (score, ++lastqid)::qidscores;
+	return lastqid;
+}
+
+
+Elem.new(nqid: int, vd: ref Vacdir, de: ref Direntry, pqid: int): ref Elem
+{
+	(e, me) := vd.open(de);
+	if(e == nil)
+		return nil;
+	if(de.mode & Vac->Modedir)
+		return ref Elem.Dir(nqid, de, e.size, Vacdir.new(session, e, me), pqid, 0, 0, nil);
+	return ref Elem.File(nqid, de, e.size, Vacfile.new(session, e));
+}
+
+Elem.stat(e: self ref Elem): ref Sys->Dir
+{
+	d := e.de.mkdir();
+	d.qid.path = big e.qid;
+	d.length = e.size;
+	return d;
+}
+
+walk(ed: ref Elem.Dir, name: string): (ref Elem, string)
+{
+	if(name == "..")
+		return (get(ed.pqid), nil);
+
+	if(ed.qid == 0) {
+		ne := scoreget(name);
+		if(ne == nil) {
+			(ok, score) := Score.parse(name);
+			if(ok != 0)
+				return (nil, "bad score: "+name);
+
+			(vd, de, err) := vac->vdroot(session, score);
+			if(err != nil)
+				return (nil, err);
+
+			nqid := scoreput(name);
+			ne = ref Elem.Dir(nqid, de, big 0, vd, ed.qid, 0, 0, nil);
+			set(ne);
+		}
+		return (ne, nil);
+	}
+
+	de := ed.vd.walk(name);
+	if(de == nil)
+		return (nil, sprint("%r"));
+	ne := childget(ed.qid, de.qid);
+	if(ne == nil) {
+		nqid := childput(ed.qid, de.qid);
+		ne = Elem.new(nqid, ed.vd, de, ed.qid);
+		set(ne);
+	}
+	return (ne, nil);
+}
+
+get(qid: int): ref Elem
+{
+	for(l := elems[qid % len elems]; l != nil; l = tl l)
+		if((hd l).qid == qid)
+			return hd l;
+	return nil;
+}
+
+set(e: ref Elem)
+{
+	elems[e.qid % len elems] = e::elems[e.qid % len elems];
+}
+
+getfile(qid: int): ref Elem.File
+{
+	pick file := get(qid) {
+	File =>	return file;
+	}
+	error("internal error, getfile");
+	return nil;
+}
+
+getdir(qid: int): ref Elem.Dir
+{
+	pick d := get(qid) {
+	Dir =>	return d;
+	}
+	error("internal error, getdir");
+	return nil;
+}
+
+init(nil: ref Draw->Context, args: list of string)
+{
+	sys = load Sys Sys->PATH;
+	arg := load Arg Arg->PATH;
+	str = load String String->PATH;
+	daytime = load Daytime Daytime->PATH;
+	venti = load Venti Venti->PATH;
+	styx = load Styx Styx->PATH;
+	styxservers = load Styxservers Styxservers->PATH;
+	vac = load Vac Vac->PATH;
+	if(venti == nil || vac == nil)
+		error("loading venti,vac");
+	sys->pctl(sys->NEWPGRP, nil);
+	venti->init();
+	vac->init();
+	styx->init();
+	styxservers->init(styx);
+
+	arg->init(args);
+	arg->setusage(arg->progname()+" [-Ddp] [-a addr] [[tag:]score]");
+	while((ch := arg->opt()) != 0)
+		case ch {
+		'D' =>	styxservers->traceset(1);
+		'a' =>	addr = arg->earg();
+		'd' =>	dflag++;
+			vac->dflag++;
+		'p' =>	pflag++;
+		* =>	warn(sprint("bad option: -%c", ch));
+			arg->usage();
+		}
+	args = arg->argv();
+	if(len args > 1)
+		arg->usage();
+
+	score: ref Score;
+	if(len args == 1) {
+		(tag, scorestr) := str->splitstrr(hd args, ":");
+		if(tag != nil)
+			tag = tag[:len tag-1];
+		if(tag == nil)
+			tag = "vac";
+		if(tag != "vac")
+			error("bad score type: "+tag);
+		(ok, s) := Score.parse(scorestr);
+		if(ok != 0)
+			error("bad score: "+scorestr);
+		score = ref s;
+	}
+
+	(cok, conn) := sys->dial(addr, nil);
+	if(cok < 0)
+		error(sprint("dialing %s: %r", addr));
+	say("have connection");
+
+	fd := conn.dfd;
+	session = Session.new(fd);
+	if(session == nil)
+		error(sprint("handshake: %r"));
+	say("have handshake");
+
+	rqid := 0;
+	red: ref Elem;
+	if(args == nil) {
+		de := Direntry.new();
+		de.uid = de.gid = de.mid = user();
+		de.ctime = de.atime = de.mtime = daytime->now();
+		de.mode = Vac->Modedir|8r755;
+		de.emode = Sys->DMDIR|8r755;
+		red = ref Elem.Dir(rqid, de, big 0, nil, rqid, 0, 0, nil);
+	} else {
+		(vd, de, err) := vac->vdroot(session, *score);
+		if(err != nil)
+			error(err);
+		rqid = ++lastqid;
+		red = ref Elem.Dir(rqid, de, big 0, vd, rqid, 0, 0, nil);
+	}
+	set(red);
+	say(sprint("have root, qid=%d", rqid));
+
+	navchan := chan of ref Navop;
+	nav := Navigator.new(navchan);
+	spawn navigator(navchan);
+
+	msgc: chan of ref Tmsg;
+	(msgc, ss) = Styxserver.new(sys->fildes(0), nav, big rqid);
+
+	for(;;) {
+		pick m := <- msgc {
+		Readerror =>
+			say("read error: "+m.error);
+
+		Read =>
+			say(sprint("have read, offset=%ubd count=%d", m.offset, m.count));
+			(c, err) := ss.canread(m);
+			if(c == nil){
+				ss.reply(ref Rmsg.Error(m.tag, err));
+				break;
+			}
+			if(c.qtype & Sys->QTDIR){
+				ss.default(m);
+				break;
+			}
+
+			ef := getfile(int c.path);
+			n := m.count;
+			a := array[n] of byte;
+			have := ef.vf.pread(a, n, m.offset);
+			if(have < 0) {
+				ss.reply(ref Rmsg.Error(m.tag, sprint("%r")));
+				break;
+			}
+			ss.reply(ref Rmsg.Read(m.tag, a[:have]));
+
+		Open =>
+			(c, mode, f, err) := canopen(m);
+			if(c == nil){
+				ss.reply(ref Rmsg.Error(m.tag, err));
+				break;
+			}
+			c.open(mode, f.qid);
+			ss.reply(ref Rmsg.Open(m.tag, f.qid, ss.iounit()));
+
+
+		* =>
+			ss.default(m);
+		}
+	}
+}
+
+canopen(m: ref Tmsg.Open): (ref Fid, int, ref Sys->Dir, string)
+{
+	c := ss.getfid(m.fid);
+	if(c == nil)
+		return (nil, 0, nil, Styxservers->Ebadfid);
+	if(c.isopen)
+		return (nil, 0, nil, Styxservers->Eopen);
+	(f, err) := ss.t.stat(c.path);
+	if(f == nil)
+		return (nil, 0, nil, err);
+	mode := styxservers->openmode(m.mode);
+	if(mode == -1)
+		return (nil, 0, nil, Styxservers->Ebadarg);
+	if(mode != Sys->OREAD && f.qid.qtype & Sys->QTDIR)
+		return (nil, 0, nil, Styxservers->Eperm);
+	if(!pflag && !styxservers->openok(c.uname, m.mode, f.mode, f.uid, f.gid))
+		return (nil, 0, nil, Styxservers->Eperm);
+	if(m.mode & Sys->ORCLOSE)
+		return (nil, 0, nil, Styxservers->Eperm);
+	return (c, mode, f, err);
+}
+
+navigator(c: chan of ref Navop)
+{
+loop:
+	for(;;) {
+		navop := <- c;
+		say(sprint("have navop, path=%bd", navop.path));
+		pick n := navop {
+		Stat =>
+			say(sprint("have stat"));
+			n.reply <-= (get(int n.path).stat(), nil);
+
+		Walk =>
+			say(sprint("have walk, name=%q", n.name));
+			ed := getdir(int n.path);
+			(ne, err) := walk(ed, n.name);
+			if(err != nil) {
+				n.reply <-= (nil, err);
+				break;
+			}
+			n.reply <-= (ne.stat(), nil);
+
+		Readdir =>
+			say(sprint("have readdir path=%bd offset=%d count=%d", n.path, n.offset, n.count));
+			if(n.path == big 0) {
+				n.reply <-= (nil, nil);
+				break;
+			}
+			ed := getdir(int n.path);
+			if(n.offset == 0) {
+				ed.vd.rewind();
+				ed.offset = 0;
+				ed.prev = array[0] of ref Sys->Dir;
+			}
+			skip := n.offset-ed.offset;
+			if(skip > 0) {
+				ed.prev = ed.prev[skip:];
+				ed.nprev -= skip;
+				ed.offset += skip;
+			}
+			if(len ed.prev < n.count) {
+				newprev := array[n.count] of ref Sys->Dir;
+				newprev[:] = ed.prev;
+				ed.prev = newprev;
+			}
+			while(ed.nprev < n.count) {
+				(ok, de) := ed.vd.readdir();
+				if(ok < 0) {
+					say(sprint("readdir error: %r"));
+					n.reply <-= (nil, sprint("reading directory: %r"));
+					continue loop;
+				}
+				if(de == nil)
+					break;
+				ne := childget(ed.qid, de.qid);
+				if(ne == nil) {
+					nqid := childput(ed.qid, de.qid);
+					ne = Elem.new(nqid, ed.vd, de, ed.qid);
+				}
+				d := ne.stat();
+				ed.prev[ed.nprev++] = d;
+				n.reply <-= (d, nil);
+			}
+			n.reply <-= (nil, nil);
+		}
+	}
+}
+
+user(): string
+{
+	if((fd := sys->open("/dev/user", Sys->OREAD)) != nil
+		&& (n := sys->read(fd, d := array[128] of byte, len d)) > 0)
+		return string d[:n];
+	return "nobody";
+}
+
+error(s: string)
+{
+	killgrp();
+	fprint(fildes(2), "%s\n", s);
+	raise "fail:"+s;
+}
+
+warn(s: string)
+{
+	fprint(fildes(2), "%s\n", s);
+}
+
+say(s: string)
+{
+	if(dflag)
+		warn(s);
+}
+
+killgrp()
+{
+	fd := sys->open("/prog/"+string sys->pctl(0, nil)+"/ctl", sys->OWRITE);
+	if(fd != nil)
+		sys->fprint(fd, "killgrp\n");
+}
diff --git a/appl/cmd/vacget.b b/appl/cmd/vacget.b
new file mode 100644
index 00000000..c14ad28a
--- /dev/null
+++ b/appl/cmd/vacget.b
@@ -0,0 +1,199 @@
+implement Vacget;
+
+include "sys.m";
+	sys: Sys;
+include "draw.m";
+include "bufio.m";
+	bufio: Bufio;
+	Iobuf: import bufio;
+include "arg.m";
+include "string.m";
+include "venti.m";
+include "vac.m";
+
+str: String;
+venti: Venti;
+vac: Vac;
+
+print, sprint, fprint, fildes: import sys;
+Score, Session: import venti;
+Roottype, Dirtype, Pointertype0, Datatype: import venti;
+Root, Entry, Direntry, Metablock, Metaentry, Entrysize, Modeperm, Modeappend, Modeexcl, Modedir, Modesnapshot, Vacdir, Vacfile, Source: import vac;
+
+Vacget: module {
+	init:	fn(nil: ref Draw->Context, args: list of string);
+};
+
+addr := "net!$venti!venti";
+dflag := vflag := pflag := tflag := 0;
+session: ref Session;
+
+init(nil: ref Draw->Context, args: list of string)
+{
+	sys = load Sys Sys->PATH;
+	bufio = load Bufio Bufio->PATH;
+	arg := load Arg Arg->PATH;
+	str = load String String->PATH;
+	venti = load Venti Venti->PATH;
+	vac = load Vac Vac->PATH;
+	if(venti == nil || vac == nil)
+		error("loading venti,vac");
+	venti->init();
+	vac->init();
+
+	arg->init(args);
+	arg->setusage(sprint("%s [-dtv] [-a addr] [tag:]score", arg->progname()));
+	while((c := arg->opt()) != 0)
+		case c {
+		'a' =>	addr = arg->earg();
+		'd' =>	dflag++;
+			vac->dflag++;
+		'p' =>	pflag++;
+		't' =>	tflag++;
+		'v' =>	vflag++;
+		* =>	warn(sprint("bad option: -%c", c));
+			arg->usage();
+		}
+	args = arg->argv();
+	if(len args != 1)
+		arg->usage();
+
+	(tag, scorestr) := str->splitstrr(hd args, ":");
+	if(tag != nil)
+		tag = tag[:len tag-1];
+	if(tag == nil)
+		tag = "vac";
+	if(tag != "vac")
+		error("bad score type: "+tag);
+
+	(sok, score) := Score.parse(scorestr);
+	if(sok != 0)
+		error("bad score: "+scorestr);
+	say("have score");
+
+	(cok, conn) := sys->dial(addr, nil);
+	if(cok < 0)
+		error(sprint("dialing %s: %r", addr));
+	say("have connection");
+
+	fd := conn.dfd;
+	session = Session.new(fd);
+	if(session == nil)
+		error(sprint("handshake: %r"));
+	say("have handshake");
+
+	(vd, nil, err) := vac->vdroot(session, score);
+	if(err != nil)
+		error(err);
+
+	say("starting walk");
+	walk(".", vd);
+}
+
+create(path: string, omode: int, de: ref Direntry): ref Sys->FD
+{
+	perm := Sys->DMDIR | Sys->DMAPPEND | Sys->DMEXCL | Sys->DMTMP;
+	perm &= de.emode;
+	perm |= 8r666;
+	if(de.emode & Sys->DMDIR)
+		perm |= 8r777;
+	fd := sys->create(path, omode, perm);
+	if(fd == nil)
+		return nil;
+	if(pflag) {
+		d := sys->nulldir;
+		d.uid = de.uid;
+		d.gid = de.gid;
+		d.mode = de.emode;
+		if(sys->fwstat(fd, d) != 0) {
+			warn(sprint("fwstat %s for uid/gid/mode: %r", path));
+			d.uid = d.gid = "";
+			sys->fwstat(fd, d);
+		}
+	}
+	return fd;
+}
+
+walk(path: string, vd: ref Vacdir)
+{
+	say("start of walk: "+path);
+	for(;;) {
+		(n, de) := vd.readdir();
+		if(n < 0)
+			error(sprint("reading direntry in %s: %r", path));
+		if(n == 0)
+			break;
+		say("walk: have direntry, elem="+de.elem);
+		newpath := path+"/"+de.elem;
+		(e, me) := vd.open(de);
+		if(e == nil)
+			error(sprint("reading entry for %s: %r", newpath));
+
+		oflags := de.mode&~(Modeperm|Modeappend|Modeexcl|Modedir|Modesnapshot);
+		if(oflags)
+			warn(sprint("%s: not all bits in mode can be set: 0x%x", newpath, oflags));
+
+		if(tflag || vflag)
+			print("%s\n", newpath);
+
+		if(me != nil) {
+			if(!tflag)
+				create(newpath, Sys->OREAD, de);
+				# ignore error, possibly for already existing dir.  
+				# if creating really failed, writing files in the dir will fail later on.
+			walk(newpath, Vacdir.new(session, e, me));
+		} else {
+			if(tflag)
+				continue;
+			say("writing file");
+			fd := create(newpath, sys->OWRITE, de);
+			if(fd == nil)
+				error(sprint("creating %s: %r", newpath));
+			bio := bufio->fopen(fd, bufio->OWRITE);
+			if(bio == nil)
+				error(sprint("bufio fopen %s: %r", newpath));
+
+			buf := array[sys->ATOMICIO] of byte;
+			vf := Vacfile.new(session, e);
+			for(;;) {
+				rn := vf.read(buf, len buf);
+				if(rn == 0)
+					break;
+				if(rn < 0)
+					error(sprint("reading vac %s: %r", newpath));
+				wn := bio.write(buf, rn);
+				if(wn != rn)
+					error(sprint("writing local %s: %r", newpath));
+			}
+			bok := bio.flush();
+			bio.close();
+			if(bok == bufio->ERROR || bok == bufio->EOF)
+				error(sprint("bufio close: %r"));
+
+			if(pflag) {
+				d := sys->nulldir;
+				d.mtime = de.mtime;
+				if(sys->fwstat(fd, d) < 0)
+					warn(sprint("fwstat %s for mtime: %r", newpath));
+			}
+			fd = nil;
+		}
+	}
+}
+
+error(s: string)
+{
+	fprint(fildes(2), "%s\n", s);
+	raise "fail:"+s;
+}
+
+warn(s: string)
+{
+	fprint(fildes(2), "%s\n", s);
+}
+
+say(s: string)
+{
+	if(dflag)
+		warn(s);
+}
diff --git a/appl/cmd/vacput.b b/appl/cmd/vacput.b
new file mode 100644
index 00000000..e01bdd36
--- /dev/null
+++ b/appl/cmd/vacput.b
@@ -0,0 +1,258 @@
+implement Vacput;
+
+include "sys.m";
+	sys: Sys;
+include "draw.m";
+include "daytime.m";
+include "bufio.m";
+	bufio: Bufio;
+	Iobuf: import bufio;
+include "arg.m";
+include "string.m";
+include "venti.m";
+include "vac.m";
+
+daytime: Daytime;
+str: String;
+venti: Venti;
+vac: Vac;
+
+print, sprint, fprint, fildes: import sys;
+Score, Session: import venti;
+Roottype, Dirtype, Pointertype0, Datatype: import venti;
+Root, Entry, Direntry, Metablock, Metaentry, Entrysize, File, Sink, MSink: import vac;
+
+Vacput: module {
+	init:	fn(nil: ref Draw->Context, args: list of string);
+};
+
+addr := "net!$venti!venti";
+dflag := 0;
+vflag := 0;
+blocksize := vac->Dsize;
+session: ref Session;
+name := "vac";
+
+init(nil: ref Draw->Context, args: list of string)
+{
+	sys = load Sys Sys->PATH;
+	daytime = load Daytime Daytime->PATH;
+	bufio = load Bufio Bufio->PATH;
+	arg := load Arg Arg->PATH;
+	str = load String String->PATH;
+	venti = load Venti Venti->PATH;
+	vac = load Vac Vac->PATH;
+	if(venti == nil || vac == nil)
+		error("loading venti,vac");
+	venti->init();
+	vac->init();
+
+	arg->init(args);
+	arg->setusage(sprint("%s [-dtv] [-a addr] [-b blocksize] [-n name] path ...", arg->progname()));
+	while((c := arg->opt()) != 0)
+		case c {
+		'a' =>	addr = arg->earg();
+		'b' =>	blocksize = int arg->earg();
+		'n' =>	name = arg->earg();
+		'd' =>	dflag++;
+			vac->dflag++;
+		'v' =>	vflag++;
+		* =>	warn(sprint("bad option: -%c", c));
+			arg->usage();
+		}
+	args = arg->argv();
+	if(len args == 0)
+		arg->usage();
+
+	(cok, conn) := sys->dial(addr, nil);
+	if(cok < 0)
+		error(sprint("dialing %s: %r", addr));
+	say("have connection");
+
+	fd := conn.dfd;
+	session = Session.new(fd);
+	if(session == nil)
+		error(sprint("handshake: %r"));
+	say("have handshake");
+
+	topde: ref Direntry;
+	if(len args == 1 && ((nil, d) := sys->stat(hd args)).t0 == 0 && d.mode&Sys->DMDIR) {
+		topde = Direntry.mk(d);
+		topde.elem = name;
+	} else {
+		topde = Direntry.new();
+		topde.elem = name;
+		topde.uid = topde.gid = user();
+		topde.mode = 8r777|Vac->Modedir;
+		topde.mtime = topde.atime = 0;
+	}
+	topde.ctime = daytime->now();
+
+	s := Sink.new(session, blocksize);
+	ms := MSink.new(session, blocksize);
+	for(; args != nil; args = tl args)
+		writepath(hd args, s, ms);
+	say("tree written");
+
+	e0 := s.finish();
+	if(e0 == nil)
+		error(sprint("writing top entry: %r"));
+	e1 := ms.finish();
+	if(e1 == nil)
+		error(sprint("writing top meta entry: %r"));
+	say(sprint("top entries written (%s, %s)", e0.score.text(), e1.score.text()));
+	s2 := MSink.new(session, blocksize);
+	if(s2.add(topde) < 0)
+		error(sprint("adding direntry for top entries: %r"));
+	e2 := s2.finish();
+	say("top meta entry written, "+e2.score.text());
+
+ 	td := array[Entrysize*3] of byte;
+ 	td[0*Entrysize:] = e0.pack();
+ 	td[1*Entrysize:] = e1.pack();
+ 	td[2*Entrysize:] = e2.pack();
+	(tok, tscore) := session.write(Dirtype, td);
+	if(tok < 0)
+		error(sprint("writing top-level entries: %r"));
+	say("top entry written, "+tscore.text());
+
+	root := Root.new(name, "vac", tscore, blocksize, nil);
+	rd := root.pack();
+	if(rd == nil)
+		error(sprint("root pack: %r"));
+	(rok, rscore) := session.write(Roottype, rd);
+	if(rok < 0)
+		error(sprint("writing root score: %r"));
+	say("root written, "+rscore.text());
+	print("vac:%s\n", rscore.text());
+	if(session.sync() < 0)
+		error(sprint("syncing server: %r"));
+}
+
+writepath(path: string, s: ref Sink, ms: ref MSink)
+{
+	if(vflag)
+		print("%s\n", path);
+say("writepath "+path);
+	fd := sys->open(path, sys->OREAD);
+	if(fd == nil)
+		error(sprint("opening %s: %r", path));
+	(ok, dir) := sys->fstat(fd);
+	if(ok < 0)
+		error(sprint("fstat %s: %r", path));
+say("writepath: file opened");
+	if(dir.mode&sys->DMAUTH) {
+		warn(path+": is auth file, skipping");
+		return;
+	}
+	if(dir.mode&sys->DMTMP) {
+		warn(path+": is temporary file, skipping");
+		return;
+	}
+
+	e, me: ref Entry;
+	de: ref Direntry;
+	if(dir.mode & sys->DMDIR) {
+say("writepath: file is dir");
+		ns := Sink.new(session, blocksize);
+		nms := MSink.new(session, blocksize);
+		for(;;) {
+			(n, dirs) := sys->dirread(fd);
+			if(n == 0)
+				break;
+			if(n < 0)
+				error(sprint("dirread %s: %r", path));
+			for(i := 0; i < len dirs; i++) {
+				d := dirs[i];
+				npath := path+"/"+d.name;
+				writepath(npath, ns, nms);
+			}
+		}
+		e = ns.finish();
+		if(e == nil)
+			error(sprint("error flushing dirsink for %s: %r", path));
+		me = nms.finish();
+		if(me == nil)
+			error(sprint("error flushing metasink for %s: %r", path));
+	} else {
+say("writepath: file is normale file");
+		e = writefile(path, fd);
+		if(e == nil)
+			error(sprint("error flushing filesink for %s: %r", path));
+	}
+say("writepath: wrote path, "+e.score.text());
+
+	de = Direntry.mk(dir);
+say("writepath: have direntry");
+
+	i := s.add(e);
+	if(i < 0)
+		error(sprint("adding entry to sink: %r"));
+	mi := 0;
+	if(me != nil)
+		mi = s.add(me);
+	if(mi < 0)
+		error(sprint("adding mentry to sink: %r"));
+	de.entry = i;
+	de.mentry = mi;
+	i = ms.add(de);
+	if(i < 0)
+		error(sprint("adding direntry to msink: %r"));
+say("writepath done");
+}
+
+writefile(path: string, fd: ref Sys->FD): ref Entry
+{
+	bio := bufio->fopen(fd, bufio->OREAD);
+	if(bio == nil)
+		error(sprint("bufio opening %s: %r", path));
+	say(sprint("bufio opened path %s", path));
+
+	f := File.new(session, Datatype, blocksize);
+	for(;;) {
+		buf := array[blocksize] of byte;
+		n := 0;
+		while(n < len buf) {
+			want := len buf - n;
+			have := bio.read(buf[n:], want);
+			if(have == 0)
+				break;
+			if(have < 0)
+				error(sprint("reading %s: %r", path));
+			n += have;
+		}
+		say(sprint("have buf, length %d", n));
+
+		if(f.write(buf[:n]) < 0)
+			error(sprint("writing %s: %r", path));
+		if(n != len buf)
+			break;
+	}
+	bio.close();
+	return f.finish();
+}
+
+user(): string
+{
+	if((fd := sys->open("/dev/user", Sys->OREAD)) != nil
+		&& (n := sys->read(fd, d := array[128] of byte, len d)) > 0)
+		return string d[:n];
+	return "nobody";
+}
+
+error(s: string)
+{
+	warn(s);
+	raise "fail:"+s;
+}
+
+warn(s: string)
+{
+	fprint(fildes(2), "%s\n", s);
+}
+
+say(s: string)
+{
+	if(dflag)
+		warn(s);
+}
diff --git a/appl/lib/mkfile b/appl/lib/mkfile
index a5736dbf..a6eaf912 100644
--- a/appl/lib/mkfile
+++ b/appl/lib/mkfile
@@ -137,6 +137,7 @@ TARG=\
 	translate.dis\
 	ubfa.dis\
 	url.dis\
+	vac.dis\
 	venti.dis\
 	virgil.dis\
 	volume.dis\
@@ -232,3 +233,4 @@ rfc822.dis:	$ROOT/module/rfc822.m
 csv.dis: $ROOT/module/csv.m
 json.dis: $ROOT/module/json.m
 lists.dis:	$ROOT/module/lists.m
+vac.dis:	$ROOT/module/vac.m $ROOT/module/venti.m
diff --git a/appl/lib/vac.b b/appl/lib/vac.b
new file mode 100644
index 00000000..53967661
--- /dev/null
+++ b/appl/lib/vac.b
@@ -0,0 +1,1094 @@
+implement Vac;
+
+include "sys.m";
+include "venti.m";
+include "vac.m";
+
+sys: Sys;
+venti: Venti;
+
+werrstr, sprint, fprint, fildes: import sys;
+Roottype, Dirtype, Pointertype0, Datatype: import venti;
+Score, Session, Scoresize: import venti;
+
+dflag = 0;
+
+# from venti.b
+BIT8SZ:	con 1;
+BIT16SZ:        con 2;
+BIT32SZ:        con 4;
+BIT48SZ:        con 6;
+BIT64SZ:	con 8;
+
+Rootnamelen:	con 128;
+Rootversion:	con 2;
+Direntrymagic:	con 16r1c4d9072;
+Metablockmagic:	con 16r5656fc79;
+Maxstringsize: con 1000;
+
+blankroot: Root;
+blankentry: Entry;
+blankdirentry: Direntry;
+blankmetablock: Metablock;
+blankmetaentry: Metaentry;
+
+
+init()
+{
+	sys = load Sys Sys->PATH;
+	venti = load Venti Venti->PATH;
+	venti->init();
+}
+
+pstring(a: array of byte, o: int, s: string): int
+{
+	sa := array of byte s;	# could do conversion ourselves
+	n := len sa;
+	a[o] = byte (n >> 8);
+	a[o+1] = byte n;
+	a[o+2:] = sa;
+	return o+BIT16SZ+n;
+}
+
+gstring(a: array of byte, o: int): (string, int)
+{
+	if(o < 0 || o+BIT16SZ > len a)
+		return (nil, -1);
+	l := (int a[o] << 8) | int a[o+1];
+	if(l > Maxstringsize)
+		return (nil, -1);
+	o += BIT16SZ;
+	e := o+l;
+	if(e > len a)
+		return (nil, -1);
+	return (string a[o:e], e);
+}
+
+gtstring(a: array of byte, o: int, n: int): string
+{
+	e := o + n;
+	if(e > len a)
+		return nil;
+	for(i := o; i < e; i++)
+		if(a[i] == byte 0)
+			break;
+	return string a[o:i];
+}
+
+
+Root.new(name, rtype: string, score: Score, blocksize: int, prev: ref Score): ref Root
+{
+	return ref Root(Rootversion, name, rtype, score, blocksize, prev);
+}
+
+Root.pack(r: self ref Root): array of byte
+{
+	d := array[Rootsize] of byte;
+	i := 0;
+	i = p16(d, i, r.version);
+	i = ptstring(d, i, r.name, Rootnamelen);
+	if(i < 0)
+		return nil;
+	i = ptstring(d, i, r.rtype, Rootnamelen);
+	if(i < 0)
+		return nil;
+	i = pscore(d, i, r.score);
+	i = p16(d, i, r.blocksize);
+	if(r.prev == nil) {
+		for(j := 0; j < Scoresize; j++)
+			d[i+j] = byte 0;
+		i += Scoresize;
+	} else 
+		i = pscore(d, i, *r.prev);
+	if(i != len d) {
+		sys->werrstr("root pack, bad length: "+string i);
+		return nil;
+	}
+	return d;
+}
+
+Root.unpack(d: array of byte): ref Root
+{
+	if(len d != Rootsize){
+		sys->werrstr("root entry is wrong length");
+		return nil;
+	}
+	r := ref blankroot;
+	r.version = g16(d, 0);
+	if(r.version != Rootversion){
+		sys->werrstr("unknown root version");
+		return nil;
+	}
+	o := BIT16SZ;
+	r.name = gtstring(d, o, Rootnamelen);
+	o += Rootnamelen;
+	r.rtype = gtstring(d, o, Rootnamelen);
+	o += Rootnamelen;
+	r.score = gscore(d, o);
+	o += Scoresize;
+	r.blocksize = g16(d, o);
+	o += BIT16SZ;
+	r.prev = ref gscore(d, o);
+	return r;
+}
+
+Entry.new(psize, dsize, flags: int, size: big, score: Venti->Score): ref Entry
+{
+	return ref Entry(0, psize, dsize, (flags&Entrydepthmask)>>Entrydepthshift, flags, size, score);
+}
+
+Entry.pack(e: self ref Entry): array of byte
+{
+	d := array[Entrysize] of byte;
+	i := 0;
+	i = p32(d, i, e.gen);
+	i = p16(d, i, e.psize);
+	i = p16(d, i, e.dsize);
+	e.flags |= e.depth<<Entrydepthshift;
+	d[i++] = byte e.flags;
+	for(j := 0; j < 5; j++)
+		d[i++] = byte 0;
+	i = p48(d, i, e.size);
+	i = pscore(d, i, e.score);
+	if(i != len d) {
+		werrstr(sprint("bad length, have %d, want %d", i, len d));
+		return nil;
+	}
+	return d;
+}
+
+Entry.unpack(d: array of byte): ref Entry
+{
+	if(len d != Entrysize){
+		sys->werrstr("entry is wrong length");
+		return nil;
+	}
+	e := ref blankentry;
+	i := 0;
+	e.gen = g32(d, i);
+	i += BIT32SZ;
+	e.psize = g16(d, i);
+	i += BIT16SZ;
+	e.dsize = g16(d, i);
+	i += BIT16SZ;
+	e.flags = int d[i];
+	e.depth = (e.flags & Entrydepthmask) >> Entrydepthshift;
+	e.flags &= ~Entrydepthmask;
+	i += BIT8SZ;
+	i += 5;			# skip something...
+	e.size = g48(d, i);
+	i += BIT48SZ;
+	e.score = gscore(d, i);
+	i += Scoresize;
+	if((e.flags & Entryactive) == 0)
+		return e;
+	if(!checksize(e.psize) || !checksize(e.dsize)){
+		sys->werrstr(sys->sprint("bad blocksize (%d or %d)", e.psize, e.dsize));
+		return nil;
+	}
+	return e;
+}
+
+Direntry.new(): ref Direntry
+{
+	return ref Direntry(9, "", 0, 0, 0, 0, big 0, "", "", "", 0, 0, 0, 0, 0, 0);
+}
+
+Direntry.mk(d: Sys->Dir): ref Direntry
+{
+	atime := 0; # d.atime;
+	mode := d.mode&Modeperm;
+	if(d.mode&sys->DMAPPEND)
+		mode |= Modeappend;
+	if(d.mode&sys->DMEXCL)
+		mode |= Modeexcl;
+	if(d.mode&sys->DMDIR)
+		mode |= Modedir;
+	if(d.mode&sys->DMTMP)
+		mode |= Modetemp;
+	return ref Direntry(9, d.name, 0, 0, 0, 0, d.qid.path, d.uid, d.gid, d.muid, d.mtime, 0, 0, atime, mode, d.mode);
+}
+
+Direntry.mkdir(de: self ref Direntry): ref Sys->Dir
+{
+        d := ref sys->nulldir;
+        d.name = de.elem;
+        d.uid = de.uid;
+        d.gid = de.gid;
+        d.muid = de.mid;
+        d.qid.path = de.qid;
+        d.qid.vers = 0;
+        d.qid.qtype = de.emode>>24;
+        d.mode = de.emode;
+        d.atime = de.atime;
+        d.mtime = de.mtime;
+        d.length = big 0;
+        return d;
+}
+
+strlen(s: string): int
+{
+	return 2+len array of byte s;
+}
+
+Direntry.pack(de: self ref Direntry): array of byte
+{
+	# assume version 9
+	length := 4+2+strlen(de.elem)+4+4+4+4+8+strlen(de.uid)+strlen(de.gid)+strlen(de.mid)+4+4+4+4+4; # + qidspace?
+
+	d := array[length] of byte;
+	i := 0;
+	i = p32(d, i, Direntrymagic);
+	i = p16(d, i, de.version);
+	i = pstring(d, i, de.elem);
+	i = p32(d, i, de.entry);
+	if(de.version == 9) {
+		i = p32(d, i, de.gen);
+		i = p32(d, i, de.mentry);
+		i = p32(d, i, de.mgen);
+	}
+	i = p64(d, i, de.qid);
+	i = pstring(d, i, de.uid);
+	i = pstring(d, i, de.gid);
+	i = pstring(d, i, de.mid);
+	i = p32(d, i, de.mtime);
+	i = p32(d, i, de.mcount);
+	i = p32(d, i, de.ctime);
+	i = p32(d, i, de.atime);
+	i = p32(d, i, de.mode);
+	if(i != len d) {
+		werrstr(sprint("bad length for direntry (expected %d, have %d)", len d, i));
+		return nil;
+	}
+	return d;
+}
+
+Direntry.unpack(d: array of byte): ref Direntry
+{
+	{
+		de := ref blankdirentry;
+		i := 0;
+		magic: int;
+		(magic, i) = eg32(d, i);
+		if(magic != Direntrymagic) {
+			werrstr(sprint("bad magic (%x, want %x)", magic, Direntrymagic));
+			return nil;
+		}
+		(de.version, i) = eg16(d, i);
+		if(de.version != 8 && de.version != 9) {
+			werrstr(sprint("bad version (%d)", de.version));
+			return nil;
+		}
+		(de.elem, i) = egstring(d, i);
+		(de.entry, i) = eg32(d, i);
+		case de.version {
+		8 =>
+			de.gen = 0;
+			de.mentry = de.entry+1;
+			de.mgen = 0;
+		9 =>
+			(de.gen, i) = eg32(d, i);
+			(de.mentry, i) = eg32(d, i);
+			(de.mgen, i) = eg32(d, i);
+		}
+		(de.qid, i) = eg64(d, i);
+		(de.uid, i) = egstring(d, i);
+		(de.gid, i) = egstring(d, i);
+		(de.mid, i) = egstring(d, i);
+		(de.mtime, i) = eg32(d, i);
+		(de.mcount, i) = eg32(d, i);
+		(de.ctime, i) = eg32(d, i);
+		(de.atime, i) = eg32(d, i);
+		(de.mode, i) = eg32(d, i);
+		de.emode = de.mode&Modeperm;
+		if(de.mode&Modeappend)
+			de.emode |= sys->DMAPPEND;
+		if(de.mode&Modeexcl)
+			de.emode |= sys->DMEXCL;
+		if(de.mode&Modedir)
+			de.emode |= sys->DMDIR;
+		if(de.mode&Modetemp)
+			de.emode |= sys->DMTMP;
+		if(de.version == 9)
+			; # xxx handle qid space?, can be in here
+		return de;
+	} exception e {
+	"too small:*" =>
+		werrstr("direntry "+e);
+		return nil;
+	* =>
+		raise e;
+	}
+}
+
+
+Metablock.new(): ref Metablock
+{
+	return ref Metablock(0, 0, 0, 0);
+}
+
+Metablock.pack(mb: self ref Metablock, d: array of byte)
+{
+	i := 0;
+	i = p32(d, i, Metablockmagic);
+	i = p16(d, i, mb.size);
+	i = p16(d, i, mb.free);
+	i = p16(d, i, mb.maxindex);
+	i = p16(d, i, mb.nindex);
+}
+
+Metablock.unpack(d: array of byte): ref Metablock
+{
+	if(len d < Metablocksize) {
+		werrstr(sprint("bad length for metablock (%d, want %d)", len d, Metablocksize));
+		return nil;
+	}
+	i := 0;
+	magic := g32(d, i);
+	if(magic != Metablockmagic && magic != Metablockmagic+1) {
+		werrstr(sprint("bad magic for metablock (%x, need %x)", magic, Metablockmagic));
+		return nil;
+	}
+	i += BIT32SZ;
+
+	mb := ref blankmetablock;
+	mb.size = g16(d, i);
+	i += BIT16SZ;
+	mb.free = g16(d, i);
+	i += BIT16SZ;
+	mb.maxindex = g16(d, i);
+	i += BIT16SZ;
+	mb.nindex = g16(d, i);
+	i += BIT16SZ;
+	if(mb.nindex == 0) {
+		werrstr("bad metablock, nindex=0");
+		return nil;
+	}
+	return mb;
+}
+
+Metaentry.pack(me: self ref Metaentry, d: array of byte)
+{
+	i := 0;
+	i = p16(d, i, me.offset);
+	i = p16(d, i, me.size);
+}
+
+Metaentry.unpack(d: array of byte, i: int): ref Metaentry
+{
+	o := Metablocksize+i*Metaentrysize;
+	if(o+Metaentrysize > len d) {
+		werrstr(sprint("meta entry lies outside meta block, i=%d", i));
+		return nil;
+	}
+
+	me := ref blankmetaentry;
+	me.offset = g16(d, o);
+	o += BIT16SZ;
+	me.size = g16(d, o);
+	o += BIT16SZ;
+	if(me.offset+me.size > len d) {
+		werrstr(sprint("meta entry points outside meta block, i=%d", i));
+		return nil;
+	}
+	return me;
+}
+
+
+Page.new(dsize: int): ref Page
+{
+	psize := (dsize/Scoresize)*Scoresize;
+	return ref Page(array[psize] of byte, 0);
+}
+
+Page.add(p: self ref Page, s: Score)
+{
+	for(i := 0; i < Scoresize; i++)
+		p.d[p.o+i] = s.a[i];
+	p.o += Scoresize;
+}
+
+Page.full(p: self ref Page): int
+{
+	return p.o+Scoresize > len p.d;
+}
+
+Page.data(p: self ref Page): array of byte
+{
+	for(i := p.o; i >= Scoresize; i -= Scoresize)
+		if(!Score(p.d[i-Scoresize:i]).eq(Score.zero()))
+			break;
+	return p.d[:i];
+}
+
+
+File.new(s: ref Session, dtype, dsize: int): ref File
+{
+	p := array[1] of ref Page;
+	p[0] = Page.new(dsize);
+	return ref File(p, dtype, dsize, big 0, s);
+}
+
+fflush(f: ref File, last: int): (int, ref Entry)
+{
+	for(i := 0; i < len f.p; i++) {
+		if(!last && !f.p[i].full())
+			return (0, nil);
+		if(last && f.p[i].o == Scoresize) {
+			flags := Entryactive;
+			if(f.dtype & Dirtype)
+				flags |= Entrydir;
+			flags |= i<<Entrydepthshift;
+			score := Score(f.p[i].data());
+			if(len score.a == 0)
+				score = Score.zero();
+			return (0, Entry.new(len f.p[i].d, f.dsize, flags, f.size, score));
+		}
+		(ok, score) := f.s.write(Pointertype0+i, f.p[i].data());
+		if(ok < 0)
+			return (-1, nil);
+		f.p[i] = Page.new(f.dsize);
+		if(i+1 == len f.p) {
+			newp := array[len f.p+1] of ref Page;
+			newp[:] = f.p;
+			newp[len newp-1] = Page.new(f.dsize);
+			f.p = newp;
+		}
+		f.p[i+1].add(score);
+	}
+	werrstr("internal error in fflush");
+	return (-1, nil);
+}
+
+File.write(f: self ref File, d: array of byte): int
+{
+	(fok, nil) := fflush(f, 0);
+	if(fok < 0)
+		return -1;
+	length := len d;
+	for(i := len d; i > 0; i--)
+		if(d[i-1] != byte 0)
+			break;
+	d = d[:i];
+	(ok, score) := f.s.write(f.dtype, d);
+	if(ok < 0)
+		return -1;
+	f.size += big length;
+	f.p[0].add(score);
+	return 0;
+}
+
+File.finish(f: self ref File): ref Entry
+{
+	(ok, e) := fflush(f, 1);
+	if(ok < 0)
+		return nil;
+	return e;
+}
+
+
+Sink.new(s: ref Venti->Session, dsize: int): ref Sink
+{
+	dirdsize := (dsize/Entrysize)*Entrysize;
+	return ref Sink(File.new(s, Dirtype, dsize), array[dirdsize] of byte, 0, 0);
+}
+
+Sink.add(m: self ref Sink, e: ref Entry): int
+{
+	ed := e.pack();
+	if(ed == nil)
+		return -1;
+	n := len m.d - m.nd;
+	if(n > len ed)
+		n = len ed;
+	m.d[m.nd:] = ed[:n];
+	m.nd += n;
+	if(n < len ed) {
+		if(m.f.write(m.d) < 0)
+			return -1;
+		m.nd = len ed - n;
+		m.d[:] = ed[n:];
+	}
+	return m.ne++;
+}
+
+Sink.finish(m: self ref Sink): ref Entry
+{
+	if(m.nd > 0)
+		if(m.f.write(m.d[:m.nd]) < 0)
+			return nil;
+	e := m.f.finish();
+	e.dsize = len m.d;
+	return e;
+}
+
+
+elemcmp(a, b: array of byte, fossil: int): int
+{
+	for(i := 0; i < len a && i < len b; i++)
+		if(a[i] != b[i])
+			return (int a[i] - int b[i]);
+	if(fossil)
+		return len a - len b;
+	return len b - len a;
+}
+
+Mentry.cmp(a, b: ref Mentry): int
+{
+	return elemcmp(array of byte a.elem, array of byte b.elem, 0);
+}
+
+MSink.new(s: ref Venti->Session, dsize: int): ref MSink
+{
+	return ref MSink(File.new(s, Dirtype, dsize), array[dsize] of byte, 0, nil);
+}
+
+l2a[T](l: list of T): array of T
+{
+	a := array[len l] of T;
+	i := 0;
+	for(; l != nil; l = tl l)
+		a[i++] = hd l;
+	return a;
+}
+
+insertsort[T](a: array of T)
+	for { T =>	cmp:	fn(a, b: T): int; }
+{
+	for(i := 1; i < len a; i++) {
+		tmp := a[i];
+		for(j := i; j > 0 && T.cmp(a[j-1], tmp) > 0; j--)
+			a[j] = a[j-1];
+		a[j] = tmp;
+	}
+}
+
+mflush(m: ref MSink, last: int): int
+{
+	d := array[len m.de] of byte;
+
+	me := l2a(m.l);
+	insertsort(me);
+	o := Metablocksize;
+	deo := o+len m.l*Metaentrysize;
+	for(i := 0; i < len me; i++) {
+		me[i].me.offset += deo;
+		me[i].me.pack(d[o:]);
+		o += Metaentrysize;
+	}
+	d[o:] = m.de[:m.nde];
+	o += m.nde;
+	if(!last)
+		while(o < len d)
+			d[o++] = byte 0;
+
+	mb := Metablock.new();
+	mb.nindex = len m.l;
+	mb.maxindex = mb.nindex;
+	mb.free = 0;
+	mb.size = o;
+	mb.pack(d);
+
+	if(m.f.write(d[:o]) < 0)
+		return -1;
+	m.nde = 0;
+	m.l = nil;
+	return 0;
+}
+
+MSink.add(m: self ref MSink, de: ref Direntry): int
+{
+	d := de.pack();
+	if(d == nil)
+		return -1;
+say(sprint("msink: adding direntry, length %d", len d));
+	if(Metablocksize+len m.l*Metaentrysize+m.nde + Metaentrysize+len d > len m.de)
+		if(mflush(m, 0) < 0)
+			return -1;
+	m.de[m.nde:] = d;
+	m.l = ref Mentry(de.elem, ref Metaentry(m.nde, len d))::m.l;
+	m.nde += len d;
+	return 0;
+}
+
+MSink.finish(m: self ref MSink): ref Entry
+{
+	if(m.nde > 0)
+		mflush(m, 1);
+	return m.f.finish();
+}
+
+Source.new(s: ref Session, e: ref Entry): ref Source
+{
+	return ref Source(s, e);
+}
+
+power(b, e: int): big
+{
+	r := big 1;
+	while(e-- > 0)
+		r *= big b;
+	return r;
+}
+
+blocksize(e: ref Entry): int
+{
+	if(e.psize > e.dsize)
+		return e.psize;
+	return e.dsize;
+}
+
+Source.get(s: self ref Source, i: big, d: array of byte): int
+{
+	npages := (s.e.size+big (s.e.dsize-1))/big s.e.dsize;
+	if(i*big s.e.dsize >= s.e.size)
+		return 0;
+
+	want := s.e.dsize;
+	if(i == npages-big 1)
+		want = int (s.e.size - i*big s.e.dsize);
+	last := s.e.score;
+	bsize := blocksize(s.e);
+	buf: array of byte;
+
+	npp := s.e.psize/Scoresize;	# scores per pointer block
+	np := power(npp, s.e.depth-1);	# blocks referenced by score at this depth
+	for(depth := s.e.depth; depth >= 0; depth--) {
+		dtype := Pointertype0+depth-1;
+		if(depth == 0) {
+			dtype = Datatype;
+			if(s.e.flags & Entrydir)
+				dtype = Dirtype;
+			bsize = want;
+		}
+		buf = s.session.read(last, dtype, bsize);
+		if(buf == nil)
+			return -1;
+		if(depth > 0) {
+			pi := int (i / np);
+			i %= np;
+			np /= big npp;
+			o := (pi+1)*Scoresize;
+			if(o <= len buf)
+				last = Score(buf[o-Scoresize:o]);
+			else
+				last = Score.zero();
+		}
+	}
+	for(j := len buf; j < want; j++)
+		d[j] = byte 0;
+	d[:] = buf;
+	return want;
+}
+
+
+Vacfile.mk(s: ref Source): ref Vacfile
+{
+	return ref Vacfile(s, big 0);
+}
+
+Vacfile.new(s: ref Session, e: ref Entry): ref Vacfile
+{
+	return Vacfile.mk(Source.new(s, e));
+}
+
+Vacfile.seek(v: self ref Vacfile, offset: big): big
+{
+	v.o += offset;
+	if(v.o > v.s.e.size)
+		v.o = v.s.e.size;
+	return v.o;
+}
+
+Vacfile.read(v: self ref Vacfile, d: array of byte, n: int): int
+{
+	have := v.pread(d, n, v.o);
+	if(have > 0)
+		v.o += big have;
+	return have;
+}
+
+Vacfile.pread(v: self ref Vacfile, d: array of byte, n: int, offset: big): int
+{
+	dsize := v.s.e.dsize;
+	have := v.s.get(big (offset/big dsize), buf := array[dsize] of byte);
+	if(have <= 0)
+		return have;
+say(sprint("vacfile.read: have=%d dsize=%d", have, dsize));
+	o := int (offset % big dsize);
+	have -= o;
+	if(have > n)
+		have = n;
+	if(have <= 0)
+		return 0;
+	d[:] = buf[o:o+have];
+	return have;
+}
+
+
+Vacdir.mk(vf: ref Vacfile, ms: ref Source): ref Vacdir
+{
+	return ref Vacdir(vf, ms, big 0, 0);
+}
+
+Vacdir.new(session: ref Session, e, me: ref Entry): ref Vacdir
+{
+        vf := Vacfile.new(session, e);
+        ms := Source.new(session, me);
+        return Vacdir.mk(vf, ms);
+
+}
+
+mecmp(d: array of byte, i: int, elem: string, fromfossil: int): (int, int)
+{
+	me := Metaentry.unpack(d, i);
+	if(me == nil)
+		return (0, 1);
+	o := me.offset+6;
+	n := g16(d, o);
+	o += BIT16SZ;
+	if(o+n > len d) {
+		werrstr("bad elem in direntry");
+		return (0, 1);
+	}
+	return (elemcmp(d[o:o+n], array of byte elem, fromfossil), 0);
+}
+
+finddirentry(d: array of byte, elem: string): (int, ref Direntry)
+{
+	mb := Metablock.unpack(d);
+	if(mb == nil)
+		return (-1, nil);
+	fromfossil := g32(d, 0) == Metablockmagic+1;
+
+        left := 0;
+        right := mb.nindex;
+	while(left+1 != right) {
+                mid := (left+right)/2;
+		(c, err) := mecmp(d, mid, elem, fromfossil);
+		if(err)
+			return (-1, nil);
+		if(c <= 0)
+			left = mid;
+		else
+			right = mid;
+		if(c == 0)
+			break;
+        }
+	de := readdirentry(d, left);
+	if(de != nil && de.elem == elem)
+		return (1, de);
+	return (0, nil);
+}
+
+Vacdir.walk(v: self ref Vacdir, elem: string): ref Direntry
+{
+	i := big 0;
+	for(;;) {
+		n := v.ms.get(i, buf := array[v.ms.e.dsize] of byte);
+		if(n < 0)
+			return nil;
+		if(n == 0)
+			break;
+		(ok, de) := finddirentry(buf[:n], elem);
+		if(ok < 0)
+			return nil;
+		if(de != nil)
+			return de;
+		i++;
+	}
+	werrstr(sprint("no such file or directory"));
+	return nil;
+}
+
+vfreadentry(vf: ref Vacfile, entry: int): ref Entry
+{
+say(sprint("vfreadentry: reading entry=%d", entry));
+	ebuf := array[Entrysize] of byte;
+	n := vf.pread(ebuf, len ebuf, big entry*big Entrysize);
+	if(n < 0)
+		return nil;
+	if(n != len ebuf) {
+		werrstr(sprint("bad archive, entry=%d not present", entry));
+		return nil;
+	}
+	e := Entry.unpack(ebuf);
+	if(~e.flags&Entryactive) {
+		werrstr("entry not active");
+		return nil;
+	}
+	if(e.flags&Entrylocal) {
+		werrstr("entry is local");
+		return nil;
+	}
+say(sprint("vreadentry: have entry, score=%s", e.score.text()));
+	return e;
+}
+
+Vacdir.open(vd: self ref Vacdir, de: ref Direntry): (ref Entry, ref Entry)
+{
+say(sprint("vacdir.open: opening entry=%d", de.entry));
+	e := vfreadentry(vd.vf, de.entry);
+	if(e == nil)
+		return (nil, nil);
+	isdir1 := de.mode & Modedir;
+	isdir2 := e.flags & Entrydir;
+	if(isdir1 && !isdir2 || !isdir1 && isdir2) {
+		werrstr("direntry directory bit does not match entry directory bit");
+		return (nil, nil);
+	}
+say(sprint("vacdir.open: have entry, score=%s size=%bd", e.score.text(), e.size));
+	me: ref Entry;
+	if(de.mode&Modedir) {
+		me = vfreadentry(vd.vf, de.mentry);
+		if(me == nil)
+			return (nil, nil);
+say(sprint("vacdir.open: have mentry, score=%s size=%bd", me.score.text(), e.size));
+	}
+	return (e, me);
+}
+
+readdirentry(buf: array of byte, i: int): ref Direntry
+{
+	me := Metaentry.unpack(buf, i);
+	if(me == nil)
+		return nil;
+	o := me.offset;
+	de := Direntry.unpack(buf[o:o+me.size]);
+	if(badelem(de.elem)) {
+		werrstr(sprint("bad direntry: %s", de.elem));
+		return nil;
+	}
+	return de;
+}
+	
+has(c: int, s: string): int
+{
+	for(i := 0; i < len s; i++)
+		if(s[i] == c)
+			return 1;
+	return 0;
+}
+
+badelem(elem: string): int
+{
+	return elem == "" || elem == "." || elem == ".." || has('/', elem) || has(0, elem);
+}
+
+Vacdir.readdir(vd: self ref Vacdir): (int, ref Direntry)
+{
+say(sprint("vacdir.readdir: ms.e.size=%bd vd.p=%bd vd.i=%d", vd.ms.e.size, vd.p, vd.i));
+	dsize := vd.ms.e.dsize;
+	n := vd.ms.get(vd.p, buf := array[dsize] of byte);
+	if(n <= 0)
+		return (n, nil);
+say(sprint("vacdir.readdir: have buf, length=%d e.size=%bd", n, vd.ms.e.size));
+	mb := Metablock.unpack(buf);
+	if(mb == nil)
+		return (-1, nil);
+	de := readdirentry(buf, vd.i);
+	if(de == nil)
+		return (-1, nil);
+	vd.i++;
+	if(vd.i >= mb.nindex) {
+		vd.p++;
+		vd.i = 0;
+	}
+say("vacdir.readdir: have entry");
+	return (1, de);
+}
+
+Vacdir.rewind(vd: self ref Vacdir)
+{
+	vd.p = big 0;
+	vd.i = 0;
+}
+
+
+vdroot(session: ref Session, score: Venti->Score): (ref Vacdir, ref Direntry, string)
+{
+	d := session.read(score, Roottype, Rootsize);
+	if(d == nil)
+		return (nil, nil, sprint("reading vac score: %r"));
+	r := Root.unpack(d);
+	if(r == nil)
+		return (nil, nil, sprint("bad vac root block: %r"));
+	say("have root");
+	topscore := r.score;
+
+	d = session.read(topscore, Dirtype, 3*Entrysize);
+	if(d == nil)
+		return (nil, nil, sprint("reading rootdir score: %r"));
+	if(len d != 3*Entrysize) {
+		say("top entries not in directory of 3 elements, assuming it's from fossil");
+		if(len d % Entrysize != 0 && len d == 2*Entrysize != 0)	# what's in the second 40 bytes?  looks like 2nd 20 bytes of it is zero score
+			return (nil, nil, sprint("bad fossil rootdir, have %d bytes, need %d or %d", len d, Entrysize, 2*Entrysize));
+		e := Entry.unpack(d[:Entrysize]);
+		if(e == nil)
+			return (nil, nil, sprint("unpacking fossil top-level entry: %r"));
+		topscore = e.score;
+		d = session.read(topscore, Dirtype, 3*Entrysize);
+		if(d == nil)
+			return (nil, nil, sprint("reading fossil rootdir block: %r"));
+		say("have fossil top entries");
+	}
+	say("have top entries");
+
+	e := array[3] of ref Entry;
+	j := 0;
+	for(i := 0; i+Entrysize <= len d; i += Entrysize) {
+		e[j] = Entry.unpack(d[i:i+Entrysize]);
+		if(e[j] == nil)
+			return (nil, nil, sprint("reading root entry %d: %r", j));
+		j++;
+	}
+	say("top entries unpacked");
+
+	mroot := Vacdir.new(session, nil, e[2]);
+	(ok, de) := mroot.readdir();
+	if(ok <= 0)
+		return (nil, nil, sprint("reading root meta entry: %r"));
+
+say(sprint("vdroot: new score=%s", score.text()));
+	return (Vacdir.new(session, e[0], e[1]), de, nil);
+}
+
+
+checksize(n: int): int
+{
+	if(n < 256 || n > Venti->Maxlumpsize) {
+		sys->werrstr("bad block size");
+		return 0;
+	}
+	return 1;
+}
+
+gscore(f: array of byte, i: int): Score
+{
+	s := Score(array[Scoresize] of byte);
+	s.a[0:] = f[i:i+Scoresize];
+	return s;
+}
+
+g16(f: array of byte, i: int): int
+{
+	return (int f[i] << 8) | int f[i+1];
+}
+
+g32(f: array of byte, i: int): int
+{
+	return (((((int f[i+0] << 8) | int f[i+1]) << 8) | int f[i+2]) << 8) | int f[i+3];
+}
+
+g48(f: array of byte, i: int): big
+{
+	b1 := (((((int f[i+0] << 8) | int f[i+1]) << 8) | int f[i+2]) << 8) | int f[i+3];
+	b0 := (int f[i+4] << 8) | int f[i+5];
+	return (big b1 << 16) | big b0;
+}
+
+g64(f: array of byte, i: int): big
+{
+	b0 := (((((int f[i+3] << 8) | int f[i+2]) << 8) | int f[i+1]) << 8) | int f[i];
+	b1 := (((((int f[i+7] << 8) | int f[i+6]) << 8) | int f[i+5]) << 8) | int f[i+4];
+	return (big b1 << 32) | (big b0 & 16rFFFFFFFF);
+}
+
+p16(d: array of byte, i: int, v: int): int
+{
+	d[i+0] = byte (v>>8);
+	d[i+1] = byte v;
+	return i+BIT16SZ;
+}
+
+p32(d: array of byte, i: int, v: int): int
+{
+	p16(d, i+0, v>>16);
+	p16(d, i+2, v);
+	return i+BIT32SZ;
+}
+
+p48(d: array of byte, i: int, v: big): int
+{
+	p16(d, i+0, int (v>>32));
+	p32(d, i+2, int v);
+	return i+BIT48SZ;
+}
+
+p64(d: array of byte, i: int, v: big): int
+{
+	p32(d, i+0, int (v>>32));
+	p32(d, i+0, int v);
+	return i+BIT64SZ;
+}
+
+ptstring(d: array of byte, i: int, s: string, l: int): int
+{
+	a := array of byte s;
+	if(len a > l) {
+		sys->werrstr("string too long: "+s);
+		return -1;
+	}
+	for(j := 0; j < len a; j++)
+		d[i+j] = a[j];
+	while(j < l)
+		d[i+j++] = byte 0;
+	return i+l;
+}
+
+pscore(d: array of byte, i: int, s: Score): int
+{
+	for(j := 0; j < Scoresize; j++)
+		d[i+j] = s.a[j];
+	return i+Scoresize;
+}
+
+echeck(f: array of byte, i: int, l: int)
+{
+	if(i+l > len f)
+		raise sprint("too small: buffer length is %d, requested %d bytes starting at offset %d", len f, l, i);
+}
+
+egscore(f: array of byte, i: int): (Score, int)
+{
+	echeck(f, i, Scoresize);
+	return (gscore(f, i), i+Scoresize);
+}
+
+egstring(a: array of byte, o: int): (string, int)
+{
+	(s, no) := gstring(a, o);
+	if(no == -1)
+		raise sprint("too small: string runs outside buffer (length %d)", len a);
+	return (s, no);
+}
+
+eg16(f: array of byte, i: int): (int, int)
+{
+	echeck(f, i, BIT16SZ);
+	return (g16(f, i), i+BIT16SZ);
+}
+
+eg32(f: array of byte, i: int): (int, int)
+{
+	echeck(f, i, BIT32SZ);
+	return (g32(f, i), i+BIT32SZ);
+}
+
+eg48(f: array of byte, i: int): (big, int)
+{
+	echeck(f, i, BIT48SZ);
+	return (g48(f, i), i+BIT48SZ);
+}
+
+eg64(f: array of byte, i: int): (big, int)
+{
+	echeck(f, i, BIT64SZ);
+	return (g64(f, i), i+BIT64SZ);
+}
+
+say(s: string)
+{
+	if(dflag)
+		fprint(fildes(2), "%s\n", s);
+}