20111215-1640

34 files changed, 320 insertions, 302 deletions

diff --git a/liblogfs/boot.c b/liblogfs/boot.c
index 201f3307..e624c375 100644
--- a/liblogfs/boot.c
+++ b/liblogfs/boot.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
diff --git a/liblogfs/clunk.c b/liblogfs/clunk.c
index 329f3324..2210476f 100644
--- a/liblogfs/clunk.c
+++ b/liblogfs/clunk.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "fcall.h"
 #include "local.h"
diff --git a/liblogfs/conv.c b/liblogfs/conv.c
index fbc48130..cbae5792 100644
--- a/liblogfs/conv.c
+++ b/liblogfs/conv.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 #include "fcall.h"
diff --git a/liblogfs/create.c b/liblogfs/create.c
index be78fdda..548f5195 100644
--- a/liblogfs/create.c
+++ b/liblogfs/create.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
diff --git a/liblogfs/dump.c b/liblogfs/dump.c
index 90e2d1f4..cccfd48e 100644
--- a/liblogfs/dump.c
+++ b/liblogfs/dump.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 #include "fcall.h"
diff --git a/liblogfs/error.c b/liblogfs/error.c
index 742b5599..eaaaabf2 100644
--- a/liblogfs/error.c
+++ b/liblogfs/error.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
diff --git a/liblogfs/extentlist.c b/liblogfs/extentlist.c
index d045605e..90e125b6 100644
--- a/liblogfs/extentlist.c
+++ b/liblogfs/extentlist.c
@@ -1,11 +1,13 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
-typedef struct ExtentNode {
+typedef struct ExtentNode ExtentNode;
+
+struct ExtentNode {
 	Extent e;
-	struct ExtentNode *next;
-} ExtentNode;
+	ExtentNode *next;
+};
 
 struct ExtentList {
 	ExtentNode *head;
@@ -70,10 +72,11 @@ logfsextentlistinsert(ExtentList *l, Extent *add, Extent **new)
 					int trimmed;
 					/* but doesn't overlap end */
 					/* retain tail of old */
-					if(saved == nil)
+					if(saved == nil){
 						saved = logfsrealloc(nil, sizeof(*saved));
-					if(saved == nil)
-						goto nomem;
+						if(saved == nil)
+							return Enomem;
+					}
 					trimmed = add->max - old->e.min;
 					old->e.min += trimmed;
 					old->e.flashaddr += trimmed;
@@ -106,7 +109,7 @@ logfsextentlistinsert(ExtentList *l, Extent *add, Extent **new)
 						saved = logfsrealloc(nil, sizeof(*saved));
 					frag = logfsrealloc(nil, sizeof(*frag));
 					if(saved == nil || frag == nil)
-						goto nomem;
+						return Enomem;
 					frag->next = next;
 					old->next = frag;
 					frag->e.min = add->max;
@@ -121,10 +124,11 @@ logfsextentlistinsert(ExtentList *l, Extent *add, Extent **new)
 					 * will need at most one add extent, so create one
 					 * now before changing data structures
 					 */
-					if(saved == nil)
+					if(saved == nil){
 						saved = logfsrealloc(nil, sizeof(*saved));
-					if(saved == nil)
-						goto nomem;
+						if(saved == nil)
+							return Enomem;
+					}
 					old->e.max = add->min;		/* retain start of old */
 				}
 				/* old.max <= add.max ⇒ add covers tail of old */
@@ -136,11 +140,10 @@ logfsextentlistinsert(ExtentList *l, Extent *add, Extent **new)
 	/*
 	 * if here, and saved == nil, then there was no overlap
 	 */
-	if(saved == nil)
+	if(saved == nil){
 		saved = logfsrealloc(nil, sizeof(*saved));
-	if(saved == nil) {
-	nomem:
-		return Enomem;
+		if(saved == nil)
+			return Enomem;
 	}
 	saved->e = *add;
 	if(prev) {
diff --git a/liblogfs/fidmap.c b/liblogfs/fidmap.c
index 9973c312..6da1c8ca 100644
--- a/liblogfs/fidmap.c
+++ b/liblogfs/fidmap.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
@@ -12,9 +12,14 @@ logfshashulong(void *v, int size)
 	return (ulong)v % size;
 }
 
+/*
+ * TO DO: assumes map.c always passes sought key value as b, and value in map as a
+ */
 static int
-compare(Fid *f, ulong fid)
+compare(void *a, void *b)
 {
+	Fid *f = a;
+	ulong fid = (ulong)b;	/* sic */
 //print("fidcompare(%ld, %ld)\n", f->fid, fid);
 	return f->fid == fid;
 }
@@ -26,23 +31,24 @@ allocsize(void *key)
 	return sizeof(Fid);
 }
 
-void
-fidfree(Fid *f)
+static void
+fidfree(void *a)
 {
+	Fid *f = a;
 	logfsdrsfree(&f->drs);
 }
 
 char *
 logfsfidmapnew(FidMap **fidmapp)
 {
-	return logfsmapnew(FIDMOD, logfshashulong, (int (*)(void *, void *))compare, allocsize, (void (*)(void *))fidfree, fidmapp);
+	return logfsmapnew(FIDMOD, logfshashulong, compare, allocsize, fidfree, fidmapp);
 }
 
 int
 logfsfidmapclunk(FidMap *m, ulong fid)
 {
 	Fid *f = logfsfidmapfindentry(m, fid);
-	if(f) {
+	if(f != nil){
 		logfsentryclunk(f->entry);
 		logfsmapdeleteentry(m, (void *)fid);
 		return 1;
@@ -54,7 +60,7 @@ char *
 logfsfidmapnewentry(FidMap *m, ulong fid, Fid **fidmapp)
 {
 	char *errmsg;
-	errmsg = logfsmapnewentry(m, (void *)fid, fidmapp);
+	errmsg = logfsmapnewentry(m, (void*)fid, fidmapp);
 	if(errmsg)
 		return errmsg;
 	if(*fidmapp == nil)
@@ -63,4 +69,3 @@ logfsfidmapnewentry(FidMap *m, ulong fid, Fid **fidmapp)
 	(*fidmapp)->openmode = -1;
 	return nil;
 }
-
diff --git a/liblogfs/findfreeblock.c b/liblogfs/findfreeblock.c
index 04d3be7e..e1fcee0a 100644
--- a/liblogfs/findfreeblock.c
+++ b/liblogfs/findfreeblock.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
diff --git a/liblogfs/flush.c b/liblogfs/flush.c
index cf5dfb3c..a2aaeed8 100644
--- a/liblogfs/flush.c
+++ b/liblogfs/flush.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "fcall.h"
 #include "local.h"
diff --git a/liblogfs/format.c b/liblogfs/format.c
index f270c84f..4615a893 100644
--- a/liblogfs/format.c
+++ b/liblogfs/format.c
@@ -1,8 +1,6 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
-#include "mp.h"
-#include "libsec.h"
 
 char *
 logfsformat(LogfsLowLevel *ll, long base, long limit, long bootsize, int trace)
@@ -70,7 +68,7 @@ logfsformat(LogfsLowLevel *ll, long base, long limit, long bootsize, int trace)
 			if(trace > 1)
 				print(" previously formatted");
 		}
-		r = rand() % (sizeinblocks - u);
+		r = nrand(sizeinblocks - u);
 		if(bootblocksdone < bootblocks && r < (bootblocks - bootblocksdone)) {
 			tag = LogfsTboot;
 			path = mkdatapath(bootblocksdone, 0);
diff --git a/liblogfs/gn.c b/liblogfs/gn.c
index c5d02977..005bcdeb 100644
--- a/liblogfs/gn.c
+++ b/liblogfs/gn.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "fcall.h"
 #include "local.h"
diff --git a/liblogfs/group.c b/liblogfs/group.c
index 7e187e63..8a83b1e2 100644
--- a/liblogfs/group.c
+++ b/liblogfs/group.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
@@ -7,14 +7,18 @@ enum {
 };
 
 static int
-groupcompare(Group *g, char *uid)
+groupcompare(void *a, void *b)
 {
+	Group *g = a;
+	char *uid = b;
 	return g->uid == uid;
 }
 
 static int
-unamecompare(Uname *u, char *uname)
+unamecompare(void *a, void *b)
 {
+	Uname *u = a;
+	char *uname = b;
 	return u->uname == uname;
 }
 
@@ -36,12 +40,10 @@ char *
 logfsgroupmapnew(GroupMap **groupmapp, UnameMap **unamemapp)
 {
 	char *errmsg;
-	errmsg = logfsmapnew(GROUPMOD, logfshashulong, (int (*)(void *, void *))groupcompare,
-		groupallocsize, nil, groupmapp);
+	errmsg = logfsmapnew(GROUPMOD, logfshashulong, groupcompare, groupallocsize, nil, groupmapp);
 	if(errmsg)
 		return errmsg;
-	errmsg = logfsmapnew(GROUPMOD, logfshashulong, (int (*)(void *, void *))unamecompare,
-		unameallocsize, nil, unamemapp);
+	errmsg = logfsmapnew(GROUPMOD, logfshashulong, unamecompare, unameallocsize, nil, unamemapp);
 	if(errmsg)
 		logfsmapfree(groupmapp);
 	return errmsg;
@@ -54,18 +56,22 @@ logfsgroupmapnewentry(GroupMap *gm, UnameMap *um, char *uid, char *uname, Group
 	errmsg = logfsmapnewentry(gm, uid, groupp);
 	if(errmsg)
 		return errmsg;
+	if(*groupp == nil)
+		return "uid already exists";
+	(*groupp)->uid = uid;
 	errmsg = logfsgroupsetnew(&(*groupp)->members);
 	if(errmsg) {
 		logfsmapdeleteentry(gm, uid);
 		return errmsg;
 	}
 	errmsg = logfsmapnewentry(um, uname, unamep);
+	if(errmsg == nil && *unamep == nil)
+		errmsg = "uname already exists";
 	if(errmsg) {
 		logfsgroupsetfree(&(*groupp)->members);
 		logfsmapdeleteentry(gm, uid);
 		return errmsg;
 	}
-	(*groupp)->uid = uid;
 	(*groupp)->uname = uname;
 	(*unamep)->uname = uname;
 	(*unamep)->g = *groupp;
diff --git a/liblogfs/groupset.c b/liblogfs/groupset.c
index 91b18c9e..ec41ec65 100644
--- a/liblogfs/groupset.c
+++ b/liblogfs/groupset.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
@@ -44,8 +44,8 @@ logfsgroupsetadd(GroupSet *gs, Group *g)
 		if(gs->entry[x] == g)
 			return 1;
 	if(gs->nentries >= gs->maxentries) {
-		Group **ne = logfsrealloc(gs->entry, sizeof(Group *) + (gs->maxentries * 2));
-		if(ne)
+		Group **ne = logfsrealloc(gs->entry, sizeof(Group*)*(gs->maxentries * 2));
+		if(ne == nil)
 			return 0;
 		gs->entry = ne;
 		gs->maxentries *= 2;
diff --git a/liblogfs/is.c b/liblogfs/is.c
index dfd6f95f..62920d33 100644
--- a/liblogfs/is.c
+++ b/liblogfs/is.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "fcall.h"
 #include "local.h"
@@ -206,7 +206,7 @@ printgroup(void *magic, Group *g)
 			buf -= trim;
 		if(ds->printoffset + ds->printn > ds->offset + ds->n)
 			ds->printn = ds->offset + ds->n - ds->printoffset;
-		memcpy(buf, printbuf, ds->printn);
+		memmove(buf, printbuf, ds->printn);
 	}
 	/*
 	 * advance print position
diff --git a/liblogfs/local.h b/liblogfs/local.h
index d614c062..06c71672 100644
--- a/liblogfs/local.h
+++ b/liblogfs/local.h
@@ -1,33 +1,55 @@
+typedef struct DataBlock DataBlock;
+typedef struct Extent Extent;
+typedef struct Entry Entry;
+typedef struct ExtentList ExtentList;
+typedef struct Fid Fid;
+typedef struct Map Map;
+typedef struct GroupSet GroupSet;
+typedef struct Group Group;
+typedef struct Uname Uname;
+typedef struct LogMessage LogMessage;
+typedef struct LogSegment LogSegment;
+typedef struct Path Path;
+typedef struct DirReadState DirReadState;
+
+typedef struct Map PathMap;
+typedef struct Map FidMap;
+typedef struct Map GroupMap;
+typedef struct Map UnameMap;
+typedef struct Map Ust;
+
+#pragma incomplete Extent
+#pragma incomplete ExtentList
+#pragma incomplete Map
+#pragma incomplete DirReadState
 
 enum {
 	L2LogSweeps = 2,
 	L2BlockCopies = 2,
 	LogDataLimit = 128,
 	LogAddr = (1 << 31),
-	Replacements = 2,		/* how much free space must be available for replacements */
-	Transfers = 2,			/* how much additional space must be available for transfers */
-	LogSlack = 1,			/* how much additional space must be available for data allocation */
+	Replacements = 2,		/* extra space for replacements */
+	Transfers = 2,			/* extra space available for transfers */
+	LogSlack = 1,			/* extra space for data allocation */
 };
 
-typedef struct Extent {
+struct Extent {
 	u32int min, max;
 	u32int flashaddr;		/* encode block index, page number, and offset within page to min */
-} Extent;
-
-typedef struct ExtentList ExtentList;
+};
 
-char *logfsextentlistnew(ExtentList **l);
-void logfsextentlistfree(ExtentList **l);
-char *logfsextentlistinsert(ExtentList *l, Extent *add, Extent **new);
-int logfsextentlistwalk(ExtentList *l, int (*func)(void *magic, Extent *e, int hole),void *magic);
-Extent *logfsextentlistmatch(ExtentList *l, Extent *e);
-int logfsextentlistwalkrange(ExtentList *l,
-	int (*func)(void *magic, u32int baseoffset, u32int limitoffset, Extent *, u32int extentoffset),
-	void *magic, u32int base, u32int limit);
-int logfsextentlistmatchall(ExtentList *l, int (*func)(void *magic, Extent *), void *magic, Extent *e);
-void logfsextentlistreset(ExtentList *l);
-
-typedef struct Entry {
+char *logfsextentlistnew(ExtentList **);
+void logfsextentlistfree(ExtentList **);
+char *logfsextentlistinsert(ExtentList *, Extent *, Extent **);
+int logfsextentlistwalk(ExtentList *, int (*)(void *, Extent *, int),void *);
+Extent *logfsextentlistmatch(ExtentList *, Extent *);
+int logfsextentlistwalkrange(ExtentList *,
+	int (*)(void *, u32int, u32int, Extent *, u32int),
+	void *, u32int, u32int);
+int logfsextentlistmatchall(ExtentList *, int (*)(void *, Extent *), void *, Extent *);
+void logfsextentlistreset(ExtentList *);
+
+struct Entry {
 	int inuse;
 	int deadandgone;	/* removed */
 	Qid qid;
@@ -49,56 +71,44 @@ typedef struct Entry {
 			struct Entry *list;
 		} dir;
 	} u;
-} Entry;
+};
 
-char *logfsentrynew(LogfsServer *server, int inuse, u32int path, Entry *parent,
-	char *name, char *uid, char *gid,
-	u32int mtime, char *muid, u32int perm, ulong cvers, ulong length, Entry **ep);
-void logfsentryclunk(Entry *e);
+char *logfsentrynew(LogfsServer *, int, u32int, Entry *,
+	char *, char *, char *,
+	u32int, char *, u32int, ulong, ulong, Entry **);
+void logfsentryclunk(Entry *);
 
-typedef struct DirReadState DirReadState;
-void logfsdrsfree(DirReadState **drsp);
+void logfsdrsfree(DirReadState **);
 
-typedef struct Fid {
+struct Fid {
 	ulong fid;
 	int openmode;
 	Entry *entry;
 	char *uname;
 	DirReadState *drs;
-} Fid;
-
-typedef struct Map Map;
-typedef int LOGFSMAPWALKFN(void *magic, void *entry);
-char *logfsmapnew(int size, int (*hash)(void *key, int size), int (*compare)(void *entry, void *key), int (*allocsize)(void *key), void (*free)(void *), Map **mapp);
-void logfsmapfree(Map **mp);
-char *logfsmapnewentry(Map *m, void *key, void **entryp);
-void *logfsmapfindentry(Map *m, void *key);
-int logfsmapdeleteentry(Map *m, void *key);
-int logfsmapwalk(Map *m, LOGFSMAPWALKFN *func, void *magic);
+};
 
-typedef struct Map FidMap;
+typedef int LOGFSMAPWALKFN(void*, void*);
+char *logfsmapnew(int, int (*)(void*, int), int (*)(void*, void*), int (*)(void*), void (*)(void*), Map **);
+void logfsmapfree(Map **);
+char *logfsmapnewentry(Map*, void*, void **);
+void *logfsmapfindentry(Map*, void*);
+int logfsmapdeleteentry(Map*, void*);
+int logfsmapwalk(Map*, LOGFSMAPWALKFN*, void*);
 
-char *logfsfidmapnew(FidMap **fidmapmapp);
+char *logfsfidmapnew(FidMap **);
 #define logfsfidmapfree(mp) logfsmapfree(mp)
-char *logfsfidmapnewentry(FidMap *m, ulong fid, Fid **fidmapp);
+char *logfsfidmapnewentry(FidMap *, ulong, Fid **);
 #define logfsfidmapfindentry(m, fid) logfsmapfindentry(m, (void *)fid)
-int logfsfidmapclunk(FidMap *m, ulong fid);
+int logfsfidmapclunk(FidMap *, ulong);
 
 struct Logfs {
 	int trace;
 };
 
-typedef struct Map Ust;
-char *logfsustnew(Ust **ustp);
-#define logfsustfree(m) logfsmapfree(m)
-char *logfsustadd(Ust *m, char *s);
-
-typedef struct GroupSet GroupSet;
-
-typedef struct Group Group;
-typedef struct Map GroupMap;
-typedef struct Uname Uname;
-typedef struct Map UnameMap;
+char *logfsustnew(Ust**);
+#define logfsustfree(m) logfsmapfree((m))
+char *logfsustadd(Ust*, char*);
 
 struct Group {
 	char *uid;
@@ -118,35 +128,35 @@ struct LogfsIdentityStore {
 	UnameMap *unamemap;
 };
 
-char *logfsgroupmapnew(GroupMap **groupmapp, UnameMap **unamemapp);
+char *logfsgroupmapnew(GroupMap **, UnameMap **);
 #define logfsgroupmapfree(mp) logfsmapfree(mp)
 #define logfsunamemapfree(mp) logfsmapfree(mp)
-char *logfsgroupmapnewentry(GroupMap *gm, UnameMap *um, char *uid, char *uname, Group **groupp, Uname **unamep);
+char *logfsgroupmapnewentry(GroupMap *, UnameMap *, char *, char *, Group **, Uname **);
 #define logfsgroupmapdeleteentry(m, uid) logfsmapdeleteentry(m, (void *)uid)
 #define logfsgroupmapfindentry(m, uid) logfsmapfindentry(m, uid)
 #define logfsunamemapfindentry(m, uname) logfsmapfindentry(m, uname)
-char *logfsgroupmapfinduname(GroupMap *m, char *uid);
-char *logfsunamemapfinduid(UnameMap *m, char *uid);
+char *logfsgroupmapfinduname(GroupMap *, char *);
+char *logfsunamemapfinduid(UnameMap *, char *);
 #define logfsunamemapdeleteentry(m, uname) logfsmapdeleteentry(m, (void *)uname)
 
-typedef int LOGFSGROUPSETWALKFN(void *magic, Group *g);
-char *logfsgroupsetnew(GroupSet **sp);
-void logfsgroupsetfree(GroupSet **sp);
-int logfsgroupsetadd(GroupSet *s, Group *g);
-int logfsgroupsetremove(GroupSet *s, Group *g);
-int logfsgroupsetwalk(GroupSet *s, LOGFSGROUPSETWALKFN *func, void *magic);
-int logfsgroupsetismember(GroupSet *gs, Group *g);
-char *logfsisfindidfromname(LogfsIdentityStore *is, char *name);
-char *logfsisfindnamefromid(LogfsIdentityStore *is, char *id);
+typedef int LOGFSGROUPSETWALKFN(void *, Group *);
+char *logfsgroupsetnew(GroupSet **);
+void logfsgroupsetfree(GroupSet **);
+int logfsgroupsetadd(GroupSet *, Group *);
+int logfsgroupsetremove(GroupSet *, Group *);
+int logfsgroupsetwalk(GroupSet *, LOGFSGROUPSETWALKFN *, void *);
+int logfsgroupsetismember(GroupSet *, Group *);
+char *logfsisfindidfromname(LogfsIdentityStore *, char *);
+char *logfsisfindnamefromid(LogfsIdentityStore *, char *);
 #define logfsisfindgroupfromid(is, id) logfsgroupmapfindentry((is)->groupmap, id)
-Group *logfsisfindgroupfromname(LogfsIdentityStore *is, char *uname);
+Group *logfsisfindgroupfromname(LogfsIdentityStore *, char *);
 #define logfsisustadd(is, s) logfsustadd((is)->ids, s)
-int logfsisgroupunameismember(LogfsIdentityStore *is, Group *g, char *uname);
-int logfsisgroupuidismember(LogfsIdentityStore *is, Group *g, char *uid);
-int logfsisgroupuidisleader(LogfsIdentityStore *is, Group *g, char *uid);
+int logfsisgroupunameismember(LogfsIdentityStore *, Group *, char *);
+int logfsisgroupuidismember(LogfsIdentityStore *, Group *, char *);
+int logfsisgroupuidisleader(LogfsIdentityStore *, Group *, char *);
 extern char *logfsisgroupnonename;
 
-typedef struct LogMessage {
+struct LogMessage {
 	uchar type;
 	u32int path;
 	union {
@@ -189,14 +199,12 @@ typedef struct LogMessage {
 			char *muid;
 		} wstat;
 	} u;
-} LogMessage;
+};
 
-uint logfsconvM2S(uchar *ap, uint nap, LogMessage *f);
-uint logfssizeS2M(LogMessage *f);
-uint logfsconvS2M(LogMessage *f, uchar *ap, uint nap);
-void logfsdumpS(LogMessage *s);
-
-typedef struct LogSegment LogSegment;
+uint logfsconvM2S(uchar *, uint, LogMessage *);
+uint logfssizeS2M(LogMessage *);
+uint logfsconvS2M(LogMessage *, uchar *, uint);
+void logfsdumpS(LogMessage *);
 
 struct LogSegment {
 	int gen;				/* generation number of this log */
@@ -209,42 +217,36 @@ struct LogSegment {
 	long blockmap[1];		/* there are ll->blocks of these */
 };
 
-char *logfslogsegmentnew(LogfsServer *server, int gen, LogSegment **segp);
-void logfslogsegmentfree(LogSegment **segp);
-char *logfslogbytes(LogfsServer *server, int active, uchar *msg, uint size);
-char *logfslog(LogfsServer *server, int active, LogMessage *s);
-char *logfslogwrite(LogfsServer *server, int active, u32int path, u32int offset, int count, u32int mtime,
-	u32int cvers, char *muid, uchar *data, u32int *flashaddr);
-char *logfslogsegmentflush(LogfsServer *server, int active);
-int lognicesizeforwrite(LogfsServer *server, int active, u32int count, int muidlen);
-char *logfsscan(LogfsServer *server);
-
-typedef struct DataBlock DataBlock;
+char *logfslogsegmentnew(LogfsServer *, int, LogSegment **);
+void logfslogsegmentfree(LogSegment **);
+char *logfslogbytes(LogfsServer *, int, uchar *, uint);
+char *logfslog(LogfsServer *, int, LogMessage *);
+char *logfslogwrite(LogfsServer *, int, u32int, u32int, int, u32int,
+	u32int, char *, uchar *, u32int *);
+char *logfslogsegmentflush(LogfsServer *, int);
+int lognicesizeforwrite(LogfsServer *, int, u32int, int);
+char *logfsscan(LogfsServer *);
 
 struct DataBlock {
-	u32int free;
-	u32int dirty;
+	Pageset free;
+	Pageset dirty;
 	long path;			/* includes generation */
 	long block;
 };
 
-u32int logfsdatapagemask(int pages, int base);
-
-typedef struct Path Path;
+Pageset logfsdatapagemask(int, int);
 
 struct Path {
 	ulong path;
 	Entry *entry;
 };
 
-typedef struct Map PathMap;
-
-char *logfspathmapnew(PathMap **pathmapmapp);
+char *logfspathmapnew(PathMap **);
 #define logfspathmapfree(mp) logfsmapfree(mp)
-char *logfspathmapnewentry(PathMap *m, ulong path, Entry *e, Path **pathmapp);
+char *logfspathmapnewentry(PathMap *, ulong, Entry *, Path **);
 #define logfspathmapfindentry(m, path) (Path *)logfsmapfindentry(m, (void *)path)
 #define logfspathmapdeleteentry(m, path) logfsmapdeleteentry(m, (void *)path)
-Entry *logfspathmapfinde(PathMap *m, ulong path);
+Entry *logfspathmapfinde(PathMap *, ulong);
 
 enum {
 	LogfsTestDontFettleDataBlock = 1,
@@ -267,31 +269,31 @@ struct LogfsServer {
 	ulong testflags;
 };
 
-int logfshashulong(void *v, int size);
+int logfshashulong(void *, int);
 
-int logfsuserpermcheck(LogfsServer *s, Entry *e, Fid *f, ulong modemask);
-u32int logfsflattenentry(LogfsIdentityStore *is, uchar *buf, u32int buflen, Entry *e);
-char *logfsreplay(LogfsServer *server, LogSegment *seg, int disableerrorsforfirstblock);
-void logfsreplayfinddata(LogfsServer *server);
+int logfsuserpermcheck(LogfsServer *, Entry *, Fid *, ulong);
+u32int logfsflattenentry(LogfsIdentityStore *, uchar *, u32int, Entry *);
+char *logfsreplay(LogfsServer *, LogSegment *, int);
+void logfsreplayfinddata(LogfsServer *);
 
 #define dataseqof(path) ((path) >> L2BlockCopies)
 #define copygenof(path) ((path) & ((1 << L2BlockCopies) -1))
 #define mkdatapath(seq, gen) (((seq) << L2BlockCopies) | (gen))
 #define gensucc(g, l2) (((g) + 1) & ((1 << (l2)) - 1))
-#define copygensucc(g) gensucc(g, L2BlockCopies)
+#define copygensucc(g) gensucc((g), L2BlockCopies)
 #define loggenof(path) ((path >> L2BlockCopies) & ((1 << L2LogSweeps) - 1))
 #define logseqof(path) ((path) >> (L2BlockCopies + L2LogSweeps))
 #define mklogpath(seq, gen, copygen) (((((seq) << L2LogSweeps) | (gen)) << L2BlockCopies) | (copygen))
-#define loggensucc(g) gensucc(g, L2LogSweeps)
+#define loggensucc(g) gensucc((g), L2LogSweeps)
 
-int logfsunconditionallymarkfreeanddirty(void *magic, Extent *e, int hole);
-void logfsflashaddr2spo(LogfsServer *server, u32int flashaddr, long *seq, int *page, int *offset);
-int logfsgn(uchar **pp, uchar *mep, char **v);
-u32int logfsspo2flashaddr(LogfsServer *server, long seq, int page, int offset);
-int logfsgn(uchar **pp, uchar *mep, char **v);
-void logfsflashaddr2o(LogfsServer *server, u32int flashaddr, int *offset);
-void logfsfreedatapages(LogfsServer *server, long seq, u32int mask);
-void logfsfreeanddirtydatablockcheck(LogfsServer *server, long seq);
+int logfsunconditionallymarkfreeanddirty(void *, Extent *, int);
+void logfsflashaddr2spo(LogfsServer *, u32int, long *, int *, int *);
+int logfsgn(uchar **, uchar *, char **);
+u32int logfsspo2flashaddr(LogfsServer *, long, int, int);
+int logfsgn(uchar **, uchar *, char **);
+void logfsflashaddr2o(LogfsServer *, u32int, int *);
+void logfsfreedatapages(LogfsServer *, long, Pageset);
+void logfsfreeanddirtydatablockcheck(LogfsServer *, long);
 
 typedef enum AllocReason {
 	AllocReasonReplace,
@@ -300,18 +302,18 @@ typedef enum AllocReason {
 	AllocReasonDataExtend,
 } AllocReason;
 
-long logfsfindfreeblock(LogfsLowLevel *ll, AllocReason reason);
-char *logfsbootfettleblock(LogfsBoot *lb, long block, uchar tag, long path, int *markedbad);
-char *logfsserverreplacedatablock(LogfsServer *server, long index);
-char *logfsserverreplacelogblock(LogfsServer *server, LogSegment *seg, long index);
-char *logfsserverreplaceblock(LogfsServer *server, LogSegment *seg, long seq);
-char *logfsservercopyactivedata(LogfsServer *server, long newb, long oldblockindex, int forcepage0,
-	LogfsLowLevelReadResult *llrrp, int *markedbadp);
+long logfsfindfreeblock(LogfsLowLevel *, AllocReason);
+char *logfsbootfettleblock(LogfsBoot *, long, uchar tag, long, int *);
+char *logfsserverreplacedatablock(LogfsServer *, long);
+char *logfsserverreplacelogblock(LogfsServer *, LogSegment *, long);
+char *logfsserverreplaceblock(LogfsServer *, LogSegment *, long);
+char *logfsservercopyactivedata(LogfsServer *, long, long, int,
+	LogfsLowLevelReadResult *, int *);
 
-char *logfsstrdup(char *);
+char *logfsstrdup(char*);
 
 extern char Enomem[];
-extern char Emsgsize[];
+extern char Eshortstat[];
 extern char Enonexist[];
 extern char Etoobig[];
 extern char Eexist[];
diff --git a/liblogfs/log.c b/liblogfs/log.c
index 83217152..008f2b69 100644
--- a/liblogfs/log.c
+++ b/liblogfs/log.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 #include "fcall.h"
@@ -173,7 +173,7 @@ logfslogbytes(LogfsServer *server, int active, uchar *msg, uint size)
 	errmsg = logspace(server, active, 0, size, &p, nil);
 	if(errmsg)
 		return errmsg;
-	memcpy(p, msg, size);
+	memmove(p, msg, size);
 	logdirty(server, active);
 	return nil;
 }
diff --git a/liblogfs/map.c b/liblogfs/map.c
index 7642475e..b2def4fa 100644
--- a/liblogfs/map.c
+++ b/liblogfs/map.c
@@ -1,11 +1,13 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
-typedef struct MapNode {
-	struct MapNode *next;
+typedef struct MapNode MapNode;
+
+struct MapNode {
+	MapNode *next;
 	uchar e[1];	// entry goes here, inline
-} MapNode;
+};
 
 struct Map {
 	int size;
@@ -61,6 +63,7 @@ find(FidMap *m, void *key, int create, void **ep)
 {
 	MapNode *n;
 	int i;
+
 	i = (*m->hash)(key, m->size);
 	n = m->head[i];
 	while(n && !(*m->compare)(n->e, key))
diff --git a/liblogfs/open.c b/liblogfs/open.c
index 688e8822..ad8a451a 100644
--- a/liblogfs/open.c
+++ b/liblogfs/open.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
diff --git a/liblogfs/path.c b/liblogfs/path.c
index 81379e12..f82e5b5e 100644
--- a/liblogfs/path.c
+++ b/liblogfs/path.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
@@ -7,8 +7,10 @@ enum {
 };
 
 static int
-compare(Path *f, ulong path)
+compare(void *a, void *b)
 {
+	Path *f = a;
+	ulong path = (ulong)b;	/* sic */
 	return f->path == path;
 }
 
@@ -22,14 +24,14 @@ allocsize(void *key)
 char *
 logfspathmapnew(PathMap **pathmapp)
 {
-	return logfsmapnew(PATHMOD, logfshashulong, (int (*)(void *, void *))compare, allocsize, nil, pathmapp);
+	return logfsmapnew(PATHMOD, logfshashulong, compare, allocsize, nil, pathmapp);
 }
 
 char *
 logfspathmapnewentry(PathMap *m, ulong path, Entry *e, Path **pathmapp)
 {
 	char *errmsg;
-	errmsg = logfsmapnewentry(m, (void *)path, pathmapp);
+	errmsg = logfsmapnewentry(m, (void*)path, pathmapp);
 	if(errmsg)
 		return errmsg;
 	if(*pathmapp == nil)
diff --git a/liblogfs/perm.c b/liblogfs/perm.c
index 9ac8d976..b5553c93 100644
--- a/liblogfs/perm.c
+++ b/liblogfs/perm.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
diff --git a/liblogfs/read.c b/liblogfs/read.c
index e97a934f..b47f7825 100644
--- a/liblogfs/read.c
+++ b/liblogfs/read.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 #include "fcall.h"
@@ -73,7 +73,7 @@ drsread(DirReadState *drs, uchar *buf, u32int buflen, u32int *rcount)
 		uint len = GBIT16(p) + BIT16SZ;
 		if(len > buflen)
 			break;
-		memcpy(buf, p, len);
+		memmove(buf, p, len);
 		drs->lastoffset += len;
 		*rcount += len;
 		buf += len;
@@ -146,7 +146,7 @@ reader(void *magic, u32int baseoffset, u32int limitoffset, Extent *e, u32int ext
 			/*
 			 * it hasn't made it to disk yet
 			 */
-			memcpy(s->buf + baseoffset, seg->pagebuf + offset, limitoffset - baseoffset);
+			memmove(s->buf + baseoffset, seg->pagebuf + offset, limitoffset - baseoffset);
 			goto done;
 		}
 		if(seq < seg->unsweptblockindex) {
diff --git a/liblogfs/remove.c b/liblogfs/remove.c
index acc85dd2..c97e733c 100644
--- a/liblogfs/remove.c
+++ b/liblogfs/remove.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
@@ -6,7 +6,7 @@ void
 logfsfreeanddirtydatablockcheck(LogfsServer *server, long seq)
 {
 	DataBlock *db;
-	u32int mask;
+	Pageset mask, allpages;
 
 	if(seq >= server->ndatablocks)
 		return;
@@ -16,7 +16,7 @@ logfsfreeanddirtydatablockcheck(LogfsServer *server, long seq)
 
 	mask = db->dirty & db->free;
 	if(mask) {
-		u32int allpages = logfsdatapagemask(1 << server->ll->l2pagesperblock, 0);
+		allpages = logfsdatapagemask(1 << server->ll->l2pagesperblock, 0);
 		if((mask & allpages) == allpages) {
 //print("logfsfreedatapages: returning block to the wild\n");
 			logfsbootfettleblock(server->lb, db->block, LogfsTnone, ~0, nil);
@@ -28,7 +28,7 @@ logfsfreeanddirtydatablockcheck(LogfsServer *server, long seq)
 }
 
 void
-logfsfreedatapages(LogfsServer *server, long seq, u32int mask)
+logfsfreedatapages(LogfsServer *server, long seq, Pageset mask)
 {
 	DataBlock *db;
 	if(seq >= server->ndatablocks)
@@ -50,11 +50,13 @@ logfsunconditionallymarkfreeanddirty(void *magic, Extent *e, int hole)
 		LogfsLowLevel *ll = server->ll;
 		DataBlock *db;
 		long blockindex;
-		int page, offset;
+		int page, offset, npages;
+		Pageset mask;
+
 		logfsflashaddr2spo(server, e->flashaddr, &blockindex, &page, &offset);
 		if(blockindex < server->ndatablocks && (db = server->datablock + blockindex)->block >= 0) {
-			int npages = ((offset + e->max - e->min) + (1 << ll->l2pagesize) - 1) >> ll->l2pagesize;
-			u32int mask = logfsdatapagemask(npages, page);
+			npages = ((offset + e->max - e->min) + (1 << ll->l2pagesize) - 1) >> ll->l2pagesize;
+			mask = logfsdatapagemask(npages, page);
 			if((db->dirty & mask) != mask)
 				print("markfreeandirty: not all pages dirty\n");
 //print("markfreeanddirty: datablock %ld mask 0x%.8ux\n", blockindex, mask);
@@ -144,4 +146,3 @@ clunk:
 	logfsfidmapclunk(server->fidmap, fid);
 	return errmsg;
 }
-
diff --git a/liblogfs/replace.c b/liblogfs/replace.c
index b29e4c28..3435c323 100644
--- a/liblogfs/replace.c
+++ b/liblogfs/replace.c
@@ -1,10 +1,10 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 #include "fcall.h"
 
 static char *
-copypages(LogfsServer *server, long newb, long oldb, ulong copymask, LogfsLowLevelReadResult *llrrp, int *markedbadp)
+copypages(LogfsServer *server, long newb, long oldb, Pageset copymask, LogfsLowLevelReadResult *llrrp, int *markedbadp)
 {
 	char *errmsg;
 	int page;
@@ -28,7 +28,7 @@ copypages(LogfsServer *server, long newb, long oldb, ulong copymask, LogfsLowLev
 		return Enomem;
 
 	for(page = ppb - 1; page >= 0; page--) {
-		ulong m;
+		Pageset m;
 
 		m = logfsdatapagemask(1, page);
 
@@ -66,28 +66,24 @@ logfsservercopyactivedata(LogfsServer *server, long newb, long oldblockindex, in
 	ulong newpath;
 	DataBlock *ob;
 	char *errmsg;
+	Pageset copymask;
 
 	ob = server->datablock + oldblockindex;
-	if(forcepage0) {
-		u32int mask;
-		mask = logfsdatapagemask(1, 0);
-		if(ob->free & mask) {
-			ob->dirty |= mask;
-			ob->free |= mask;
-		}
-	}
+	copymask = ~ob->free;
+	if(forcepage0)
+		copymask |= logfsdatapagemask(1, 0);
 	if(server->trace > 1)
 		print("copyactivedata %ld: (%ld -> %ld)\n", oldblockindex, ob->block, newb);
 	newpath = mkdatapath(dataseqof(ob->path), copygensucc(copygenof(ob->path)));
 	(*ll->setblocktag)(ll, newb, LogfsTdata);
 	(*ll->setblockpath)(ll, newb, newpath);
-	errmsg = copypages(server, newb, ob->block, ~ob->free, llrrp, markedbadp);
+	errmsg = copypages(server, newb, ob->block, copymask, llrrp, markedbadp);
 	if(errmsg)
 		return errmsg;
 	/*
-	 * anything dirty and free is now not dirty and free
+	 * anything not copied is now not dirty
 	 */
-	ob->dirty &= ~(ob->dirty & ob->free);
+	ob->dirty &= copymask;
 	ob->block = newb;
 	ob->path = newpath;
 	return nil;
diff --git a/liblogfs/replay.c b/liblogfs/replay.c
index a0f7a88d..50ccbe64 100644
--- a/liblogfs/replay.c
+++ b/liblogfs/replay.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 #include "fcall.h"
@@ -171,7 +171,7 @@ rewstat(LogfsServer *server, LogMessage *s, int *ok)
 	ustgid = nil;
 	ustmuid = nil;
 	if(s->u.wstat.name) {
-		cname = strdup(s->u.wstat.name);
+		cname = logfsstrdup(s->u.wstat.name);
 		if(cname == nil) {
 		memerror:
 			errmsg = Enomem;
@@ -299,7 +299,7 @@ map(void *magic, Extent *x, int hole)
 	long seq;
 	int page;
 	int offset;
-	u32int mask;
+	Pageset mask;
 	DataBlock *db;
 
 	if(hole || (x->flashaddr & LogAddr) != 0)
@@ -314,8 +314,8 @@ map(void *magic, Extent *x, int hole)
 	mask = logfsdatapagemask((x->max - x->min + offset + (1 << ll->l2pagesize) - 1) >> ll->l2pagesize, page);
 //print("mask 0x%.8ux free 0x%.8ux dirty 0x%.8ux\n", mask, db->free, db->dirty);
 	if((db->free & mask) != mask)
-		print("huntfordata: data referenced more than once: block %ld(%ld) free 0x%.8ux mask 0x%.8ux\n",
-			seq, db->block, db->free, mask);
+		print("huntfordata: data referenced more than once: block %ld(%ld) free 0x%.8llux mask 0x%.8llux\n",
+			seq, db->block, (u64int)db->free, (u64int)mask);
 	db->free &= ~mask;
 	db->dirty |= mask;
 	return 1;
@@ -380,7 +380,7 @@ logfsreplayfinddata(LogfsServer *server)
 		for(i = 0, db = server->datablock; i < server->ndatablocks; i++, db++) {
 			logfsfreeanddirtydatablockcheck(server, i);
 			if(db->block >= 0)
-				print("%4ld: free 0x%.8ux dirty 0x%.8ux\n", i, server->datablock[i].free, server->datablock[i].dirty);
+				print("%4ld: free 0x%.8llux dirty 0x%.8llux\n", i, (u64int)server->datablock[i].free, (u64int)server->datablock[i].dirty);
 		}
 	}
 }
diff --git a/liblogfs/scan.c b/liblogfs/scan.c
index 5f4d9cf7..73017f33 100644
--- a/liblogfs/scan.c
+++ b/liblogfs/scan.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 #include "fcall.h"
diff --git a/liblogfs/srv.c b/liblogfs/srv.c
index efb590d3..610ca9a1 100644
--- a/liblogfs/srv.c
+++ b/liblogfs/srv.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "fcall.h"
 #include "local.h"
@@ -260,23 +260,23 @@ logfsflattenentry(LogfsIdentityStore *is, uchar *buf, u32int limit, Entry *e)
 					PBIT32(p, e->u.file.length); p += BIT32SZ;
 					PBIT32(p, 0); p += BIT32SZ;
 				}
-	/* name */	PBIT16(p, namelen); p += BIT16SZ; memcpy(p, e->name, namelen); p+= namelen;
+	/* name */	PBIT16(p, namelen); p += BIT16SZ; memmove(p, e->name, namelen); p+= namelen;
 	/* uid */		PBIT16(p, unamelen + unamebad); p += BIT16SZ;
 				if(unamebad)
 					*p++ = '(';
-				memcpy(p, uname, unamelen + unamebad); p+= unamelen;
+				memmove(p, uname, unamelen + unamebad); p+= unamelen;
 				if(unamebad)
 					*p++ = ')';
 	/* gid */		PBIT16(p, gnamelen + gnamebad); p += BIT16SZ;
 				if(gnamebad)
 					*p++ = '(';
-				memcpy(p, gname, gnamelen); p+= gnamelen;
+				memmove(p, gname, gnamelen); p+= gnamelen;
 				if(gnamebad)
 					*p++ = ')';
 	/* muid */	PBIT16(p, munamelen + munamebad); p += BIT16SZ;
 				if(munamebad)
 					*p++ = '(';
-				memcpy(p, muname, munamelen); p+= munamelen;
+				memmove(p, muname, munamelen); p+= munamelen;
 				if(munamebad)
 					*p = ')';
 //print("len %ud p - buf %ld\n", len, p - buf);
@@ -296,7 +296,7 @@ logfsserverstat(LogfsServer *server, u32int fid, uchar *buf, u32int bufsize, ush
 		return Eio;
 	*nstat = logfsflattenentry(server->is, buf, bufsize, f->entry);
 	if(*nstat == 0)
-		return Emsgsize;
+		return Eshortstat;
 	return nil;
 }
 
diff --git a/liblogfs/sweep.c b/liblogfs/sweep.c
index f52509fd..3e66196e 100644
--- a/liblogfs/sweep.c
+++ b/liblogfs/sweep.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
diff --git a/liblogfs/tagname.c b/liblogfs/tagname.c
index 88713c3d..c36174f3 100644
--- a/liblogfs/tagname.c
+++ b/liblogfs/tagname.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
diff --git a/liblogfs/test.c b/liblogfs/test.c
index bff41492..e21f9a5a 100644
--- a/liblogfs/test.c
+++ b/liblogfs/test.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
diff --git a/liblogfs/ust.c b/liblogfs/ust.c
index 119ed33a..ba2368fb 100644
--- a/liblogfs/ust.c
+++ b/liblogfs/ust.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
@@ -30,9 +30,9 @@ logfshashstring(void *s, int n)
 }
 
 static int
-compare(char *entry, char *key)
+compare(void *entry, void *key)
 {
-	return strcmp(entry, key) == 0;
+	return strcmp((char*)entry, (char*)key) == 0;
 }
 
 static int
@@ -44,7 +44,7 @@ allocsize(void *key)
 char *
 logfsustnew(Ust **ustp)
 {
-	return logfsmapnew(USTMOD, logfshashstring, (int (*)(void *, void *))compare, allocsize, nil, ustp);
+	return logfsmapnew(USTMOD, logfshashstring, compare, allocsize, nil, ustp);
 }
 
 char *
@@ -53,12 +53,12 @@ logfsustadd(Ust *ust, char *s)
 	char *errmsg;
 	char *ep;
 	ep = logfsmapfindentry(ust, s);
-	if(ep) {
+	if(ep != nil) {
 //		print("ust: found %s\n", s);
 		return ep;
 	}
 	errmsg = logfsmapnewentry(ust, s, &ep);
-	if(errmsg)
+	if(errmsg != nil)
 		return errmsg;
 //	print("ust: new %s\n", s);
 	return strcpy(ep, s);
diff --git a/liblogfs/walk.c b/liblogfs/walk.c
index 05ae3f9c..6993a033 100644
--- a/liblogfs/walk.c
+++ b/liblogfs/walk.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "fcall.h"
 #include "local.h"
diff --git a/liblogfs/write.c b/liblogfs/write.c
index 3c1d9a6b..e84faa84 100644
--- a/liblogfs/write.c
+++ b/liblogfs/write.c
@@ -1,26 +1,27 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "local.h"
 
-typedef struct AllocState {
+typedef struct AllocState AllocState;
+struct AllocState {
 	long oldblock;
 	int markbad;
-} AllocState;
+};
 
-u32int
+Pageset
 logfsdatapagemask(int pages, int base)
 {
-	if(pages == 32)
-		return 0xffffffff;
-	return (((u32int)1 << pages) - 1) << (32 - base - pages);
+	if(pages == BITSPERSET)
+		return ~(Pageset)0;
+	return (((Pageset)1 << pages) - 1) << (BITSPERSET - base - pages);
 }
 
-static u32int
-fastgap(u32int w, u32int n)
+static Pageset
+fastgap(Pageset w, uint n)
 {
-	u32int s;
+	Pageset s;
 //print("fastgap(0x%.8ux, %d)\n", w, n);
-	if(w == 0 || n < 1 || n > 32)
+	if(w == 0 || n < 1 || n > BITSPERSET)
 		return 0;
 /*
 #	unroll the following loop 5 times:
@@ -43,33 +44,27 @@ fastgap(u32int w, u32int n)
 	w &= w << s;
 	n -= s;
 	s = n >> 1;
-	return w & (w << s);
-}
-
-static u32int
-page0gap(u32int w, u32int n)
-{
-	int p;
-	for(p = 1; p <= n; p++) {
-		u32int m = logfsdatapagemask(p, 0);
-		if((w & m) != m)
-			return logfsdatapagemask(p - 1, 0);
+	if(BITSPERSET == 64){	/* extra time if 64 bits */
+		w &= w << s;
+		n -= s;
+		s = n >> 1;
 	}
-	return 0;
+	return w & (w << s);
 }
 
-int
-nlz(u32int x)
+static int
+nlz(Pageset x)
 {
 	int n, c;
+
 	if(x == 0)
-		return 32;
-	if(x & 0x80000000)
-		return (~x >> 26) & 0x20;
-	n = 32;
-	c = 16;
+		return BITSPERSET;
+	if(x & PAGETOP)
+		return 0;
+	n = BITSPERSET;
+	c = BITSPERSET/2;
 	do {
-		u32int y;
+		Pageset y;
 		y = x >> c;
 		if(y != 0) {
 			n -= c;
@@ -79,10 +74,11 @@ nlz(u32int x)
 	return n - x;
 }
 
-static u32int
-findgap(u32int w, u32int n)
+static Pageset
+findgap(Pageset w, uint n)
 {
-	u32int m;
+	Pageset m;
+
 	do {
 		m  = fastgap(w, n);
 		if(m)
@@ -95,11 +91,13 @@ findgap(u32int w, u32int n)
 }
 
 static int
-bitcount(ulong mask)
+bitcount(Pageset mask)
 {
-	ulong m;
+	Pageset m;
 	int rv;
-	for(rv = 0, m = 0x80000000; m; m >>= 1)
+
+	rv = 0;
+	for(m = PAGETOP; m != 0; m >>= 1)
 		if(mask & m)
 			rv++;
 	return rv;
@@ -174,7 +172,7 @@ allocdatapages(LogfsServer *server, u32int count, int *countp, long *blockindexp
 				b = logfsfindfreeblock(ll, AllocReasonTransfer);
 			}
 			else {
-				u32int available;
+				Pageset available;
 				/*
 				 * if page0 is free, then we must ensure that we use it otherwise
 				 * in tagged storage such as nand, the block tag is not written
@@ -186,6 +184,8 @@ allocdatapages(LogfsServer *server, u32int count, int *countp, long *blockindexp
 				state->oldblock = oldblock;
 				state->markbad = llrr != LogfsLowLevelReadResultOk;
 				available = db->free & ~db->dirty;
+				if(available & PAGETOP)
+					available = logfsdatapagemask(nlz(~available), 0);
 				gapmask = findgap(available, pages);
 				goto done;
 			}
@@ -243,8 +243,8 @@ done:
 	if(server->trace > 1)
 		print("allocdatapages: block %ld(%ld) pages %d mask 0x%.8ux pagebase %d apages %d\n",
 			blockindex, db->block, pages, gapmask, pagebase, apages);
-//	db->free &= ~gapmask;
-//	db->dirty |= gapmask;
+	db->free &= ~gapmask;
+	db->dirty |= gapmask;
 	*pagep = pagebase;
 	*blockindexp = blockindex;
 	*flashaddr = logfsspo2flashaddr(server, blockindex, pagebase, 0);
@@ -309,7 +309,7 @@ deltapages(DataStructure *ds, LogfsLowLevel *ll, u32int baseflashaddr, int range
 
 //print("deltapages(%ud, %ud, %d, %d)\n", baseflashaddr, limitflashaddr, add, delta);
 	logfsflashaddr2spo(ds->server, baseflashaddr, &seq, &page, &offset);
-	pages = (range + (1 << ll->l2pagesize) - 1) >> ll->l2pagesize;
+	pages = (offset + range + (1 << ll->l2pagesize) - 1) >> ll->l2pagesize;
 	pageaddr = (seq << ll->l2pagesperblock) + page;
  	for(x = 0; x < pages; x++, pageaddr++)
 		if(!deltapage(ds, pageaddr, add, delta))
@@ -360,11 +360,12 @@ static char *
 zappages(LogfsServer *server, Entry *e, u32int min, u32int max)
 {
 	DataStructure ds;
-	int x, rv;
+	long seq;
+	int x, rv, page;
+	Page *p;
 
 	if(min >= e->u.file.length)
-		/* no checks necessary */
-		return nil;
+		return nil;		/* no checks necessary */
 	if(min == 0 && max >= e->u.file.length) {
 		/* replacing entire file */
 		logfsextentlistwalk(e->u.file.extent, logfsunconditionallymarkfreeanddirty, server);
@@ -383,30 +384,31 @@ zappages(LogfsServer *server, Entry *e, u32int min, u32int max)
 	ds.maxentries = 0;
 	ds.array = nil;
 	rv = logfsextentlistwalkrange(e->u.file.extent, findpageset, &ds, min, max);
-/*
-	print("pass 1\n");
-	for(x = 0; x < ds.nentries; x++)
-		print("block %ud page %ud ref %d\n", ds.array[x].pageaddr / server->ll->pagesperblock,
-			ds.array[x].pageaddr % server->ll->pagesperblock, ds.array[x].ref);
-*/
-	if(rv >= 0) {
-		Page *p;
-		if(ds.nentries == 0)
-			print("pass 2 cancelled\n");
-		else {
-			rv = logfsextentlistwalk(e->u.file.extent, addpagereferences, &ds);
-//			print("pass 2\n");
-			for(x = 0, p = ds.array; x < ds.nentries; x++, p++) {
-//				print("block %ud page %ud ref %d\n", p->pageaddr / server->ll->pagesperblock,
-//					p->pageaddr % server->ll->pagesperblock, p->ref);
-				if(rv >= 0 && p->ref == 0) {
-					long seq = p->pageaddr >> server->ll->l2pagesperblock;
-					int page = p->pageaddr & ((1 << server->ll->l2pagesperblock) - 1);
-					logfsfreedatapages(server, seq, 1 << (31 - page));
-				}
-			}
+	if(rv < 0 || ds.nentries == 0)
+		goto Out;
+	if(server->trace > 1){
+		print("pass 1\n");
+		for(x = 0; x < ds.nentries; x++){
+			p = &ds.array[x];
+			seq = p->pageaddr >> server->ll->l2pagesperblock;
+			page = p->pageaddr & ((1 << server->ll->l2pagesperblock) - 1);
+			print("block %lud page %ud ref %d\n", seq, page, p->ref);
+		}
+		print("pass 2\n");
+	}
+	rv = logfsextentlistwalk(e->u.file.extent, addpagereferences, &ds);
+	if(rv >= 0){
+		for(x = 0; x < ds.nentries; x++){
+			p = &ds.array[x];
+			seq = p->pageaddr >> server->ll->l2pagesperblock;
+			page = p->pageaddr & ((1 << server->ll->l2pagesperblock) - 1);
+			if(server->trace > 1)
+				print("block %lud page %ud ref %d\n", seq, page, p->ref);
+			if(p->ref == 0)
+				logfsfreedatapages(server, seq, logfsdatapagemask(1, page));
 		}
 	}
+Out:
 	logfsfreemem(ds.array);
 	return rv < 0 ? Enomem : nil;
 }
diff --git a/liblogfs/wstat.c b/liblogfs/wstat.c
index 85f112da..dae7008d 100644
--- a/liblogfs/wstat.c
+++ b/liblogfs/wstat.c
@@ -1,4 +1,4 @@
-#include "lib9.h"
+#include "logfsos.h"
 #include "logfs.h"
 #include "fcall.h"
 #include "local.h"
@@ -26,11 +26,11 @@ logfsserverwstat(LogfsServer *server, u32int fid, uchar *stat, ushort nstat)
 	if(server->trace > 1)
 		print("logfsserverwstat(%ud, %ud)\n", fid, nstat);
 	if(nstat < 49)
-		return Emsgsize;
+		return Eshortstat;
 	p  = stat;
 	len = GBIT16(p); p += BIT16SZ;
 	if(len + BIT16SZ  != nstat)
-		return Emsgsize;
+		return Eshortstat;
 	mep = p + len;
 	p += BIT16SZ + BIT32SZ;		/* skip type and dev */
 	qid.type = *p++;
@@ -42,9 +42,9 @@ logfsserverwstat(LogfsServer *server, u32int fid, uchar *stat, ushort nstat)
 	length = GBIT64(p); p+= BIT64SZ;
 	if(!logfsgn(&p, mep, &name) || !logfsgn(&p, mep, &uname)
 		|| !logfsgn(&p, mep, &gname) || !logfsgn(&p, mep, &muname))
-		return Emsgsize;
+		return Eshortstat;
 	if(p != mep)
-		return Emsgsize;
+		return Eshortstat;
 	qiddonttouch = qid.type == (uchar)~0 && qid.vers == ~0 && qid.path == ~(uvlong)0;
 	permdonttouch = perm == ~0;
 	mtimedonttouch = mtime == ~0;