diff options
59 files changed, 494 insertions, 467 deletions
@@ -1,3 +1,5 @@ +20111215 + liblogfs,libnandfs: use logfsos.h (added to include) to make library source independent of os 20111214 change Linux port to use pthreads instead of clone directly emu/Linux: rename os.c to os-clone.c; rename osp.c to os.c diff --git a/include/logfs.h b/include/logfs.h index 7c95c27d..df0bbbf0 100755 --- a/include/logfs.h +++ b/include/logfs.h @@ -1,5 +1,21 @@ #pragma src "/usr/inferno/liblogfs" +typedef struct LogfsLowLevel LogfsLowLevel; +typedef struct LogfsBoot LogfsBoot; +typedef struct Logfs Logfs; +typedef struct LogfsServer LogfsServer; +typedef struct LogfsIdentityStore LogfsIdentityStore; + +#pragma incomplete Logfs +#pragma incomplete LogfsServer +#pragma incomplete LogfsIdentityStore +#pragma incomplete LogfsBoot + +typedef u64int Pageset; + +#define BITSPERSET (sizeof(Pageset)*8) +#define PAGETOP ((Pageset)1<<(BITSPERSET-1)) + enum { LogfsTnone = 0xff, LogfsTboot = 0x01, @@ -25,15 +41,6 @@ enum { LogfsOpenFlagWstatAllow = 2, }; -typedef struct LogfsLowLevel LogfsLowLevel; - -typedef enum LogfsLowLevelFettleAction { - LogfsLowLevelFettleActionMarkBad, - LogfsLowLevelFettleActionErase, - LogfsLowLevelFettleActionFormat, - LogfsLowLevelFettleActionEraseAndFormat, -} LogfsLowLevelFettleAction; - typedef enum LogfsLowLevelReadResult { LogfsLowLevelReadResultOk, LogfsLowLevelReadResultSoftError, @@ -42,30 +49,30 @@ typedef enum LogfsLowLevelReadResult { LogfsLowLevelReadResultAllOnes, } LogfsLowLevelReadResult; -typedef short LOGFSGETBLOCKTAGFN(LogfsLowLevel *ll, long block); -typedef void LOGFSSETBLOCKTAGFN(LogfsLowLevel *ll, long block, short tag); -typedef ulong LOGFSGETBLOCKPATHFN(LogfsLowLevel *ll, long block); -typedef void LOGFSSETBLOCKPATHFN(LogfsLowLevel *ll, long block, ulong path); -typedef long LOGFSFINDFREEBLOCKFN(LogfsLowLevel *ll, long *freeblocks); -typedef char *LOGFSREADBLOCKFN(LogfsLowLevel *ll, void *buf, long block, LogfsLowLevelReadResult *blocke); -typedef char *LOGFSWRITEBLOCKFN(LogfsLowLevel *ll, void *buf, uchar tag, ulong path, int xcount, long *xdata, long block); -typedef char *LOGFSERASEBLOCKFN(LogfsLowLevel *ll, long block, void **llsave, int *markedbad); -typedef char *LOGFSFORMATBLOCKFN(LogfsLowLevel *ll, long block, uchar tag, long path, long baseblock, long sizeinblocks, int xcount, long *xdata, void *llsave, int *markedbad); -typedef char *LOGFSREFORMATBLOCKFN(LogfsLowLevel *ll, long block, uchar tag, long path, int xcount, long *xdata, void *llsave, int *markedbad); -typedef void LOGFSMARKBLOCKBADFN(LogfsLowLevel *ll, long block); -typedef int LOGFSGETBLOCKSFN(LogfsLowLevel *ll); -typedef long LOGFSGETBASEBLOCKFN(LogfsLowLevel *ll); -typedef int LOGFSGETBLOCKSIZEFN(LogfsLowLevel *ll); -typedef int LOGFSGETBLOCKPARTIALFORMATSTATUSFN(LogfsLowLevel *ll, long block); -typedef ulong LOGFSCALCRAWADDRESSFN(LogfsLowLevel *ll, long pblock, int dataoffset); -typedef char *LOGFSOPENFN(LogfsLowLevel *ll, long base, long limit, int trace, int xcount, long *xdata); -typedef char *LOGFSGETBLOCKSTATUSFN(LogfsLowLevel *ll, long block, int *magicfound, void **llsave, LogfsLowLevelReadResult *result); -typedef int LOGFSCALCFORMATFN(LogfsLowLevel *ll, long base, long limit, long bootsize, long *baseblock, long *limitblock, long *bootblocks); -typedef int LOGFSGETOPENSTATUSFN(LogfsLowLevel *ll); -typedef void LOGFSFREEFN(LogfsLowLevel *ll); -typedef char *LOGFSREADPAGERANGEFN(LogfsLowLevel *ll, uchar *data, long block, int page, int offset, int count, LogfsLowLevelReadResult *result); -typedef char *LOGFSWRITEPAGEFN(LogfsLowLevel *ll, uchar *data, long block, int page); -typedef char *LOGFSSYNCFN(LogfsLowLevel *ll); +typedef short LOGFSGETBLOCKTAGFN(LogfsLowLevel*, long); +typedef void LOGFSSETBLOCKTAGFN(LogfsLowLevel*, long, short); +typedef ulong LOGFSGETBLOCKPATHFN(LogfsLowLevel*, long); +typedef void LOGFSSETBLOCKPATHFN(LogfsLowLevel*, long, ulong); +typedef long LOGFSFINDFREEBLOCKFN(LogfsLowLevel*, long*); +typedef char *LOGFSREADBLOCKFN(LogfsLowLevel*, void*, long, LogfsLowLevelReadResult*); +typedef char *LOGFSWRITEBLOCKFN(LogfsLowLevel*, void*, uchar, ulong, int, long*, long); +typedef char *LOGFSERASEBLOCKFN(LogfsLowLevel*, long, void **, int*); +typedef char *LOGFSFORMATBLOCKFN(LogfsLowLevel*, long, uchar, long, long, long, int, long*, void*, int*); +typedef char *LOGFSREFORMATBLOCKFN(LogfsLowLevel*, long, uchar, long, int, long*, void*, int*); +typedef void LOGFSMARKBLOCKBADFN(LogfsLowLevel*, long); +typedef int LOGFSGETBLOCKSFN(LogfsLowLevel*); +typedef long LOGFSGETBASEBLOCKFN(LogfsLowLevel*); +typedef int LOGFSGETBLOCKSIZEFN(LogfsLowLevel*); +typedef int LOGFSGETBLOCKPARTIALFORMATSTATUSFN(LogfsLowLevel*, long); +typedef ulong LOGFSCALCRAWADDRESSFN(LogfsLowLevel*, long, int); +typedef char *LOGFSOPENFN(LogfsLowLevel*, long, long, int, int, long*); +typedef char *LOGFSGETBLOCKSTATUSFN(LogfsLowLevel*, long, int*, void **, LogfsLowLevelReadResult*); +typedef int LOGFSCALCFORMATFN(LogfsLowLevel*, long, long, long, long*, long*, long*); +typedef int LOGFSGETOPENSTATUSFN(LogfsLowLevel*); +typedef void LOGFSFREEFN(LogfsLowLevel*); +typedef char *LOGFSREADPAGERANGEFN(LogfsLowLevel*, uchar*, long, int, int, int, LogfsLowLevelReadResult*); +typedef char *LOGFSWRITEPAGEFN(LogfsLowLevel*, uchar*, long, int); +typedef char *LOGFSSYNCFN(LogfsLowLevel*); struct LogfsLowLevel { int l2pagesize; @@ -97,60 +104,55 @@ struct LogfsLowLevel { LOGFSSYNCFN *sync; }; -extern char Eio[]; -extern char Ebadarg[]; -extern char Eperm[]; - -char *logfstagname(uchar tag); - -typedef struct LogfsIdentityStore LogfsIdentityStore; -char *logfsisnew(LogfsIdentityStore **isp); -void logfsisfree(LogfsIdentityStore **isp); -char *logfsisgroupcreate(LogfsIdentityStore *is, char *groupname, char *groupid); -char *logfsisgrouprename(LogfsIdentityStore *is, char *oldgroupname, char *newgroupname); -char *logfsisgroupsetleader(LogfsIdentityStore *is, char *groupname, char *leadername); -char *logfsisgroupaddmember(LogfsIdentityStore *is, char *groupname, char *membername); -char *logfsisgroupremovemember(LogfsIdentityStore *is, char *groupname, char *nonmembername); -char *logfsisusersread(LogfsIdentityStore *is, void *buf, long n, ulong offset, long *nr); - -typedef struct LogfsBoot LogfsBoot; -typedef struct Logfs Logfs; -typedef struct LogfsServer LogfsServer; - -char *logfsformat(LogfsLowLevel *ll, long base, long limit, long bootsize, int trace); -char *logfsbootopen(LogfsLowLevel *ll, long base, long limit, int trace, int printbad, LogfsBoot **lbp); -void logfsbootfree(LogfsBoot *lb); -char *logfsbootread(LogfsBoot *lb, void *buf, long n, ulong offset); -char *logfsbootwrite(LogfsBoot *lb, void *buf, long n, ulong offset); -char *logfsbootio(LogfsBoot *lb, void *buf, long n, ulong offset, int write); -char *logfsbootmap(LogfsBoot *lb, ulong laddress, ulong *lblockp, int *lboffsetp, int *lpagep, int *lpageoffsetp, ulong *pblockp, ulong *paddressp); -long logfsbootgetiosize(LogfsBoot *lb); -long logfsbootgetsize(LogfsBoot *lb); -void logfsboottrace(LogfsBoot *lb, int level); - -char *logfsserverattach(LogfsServer *s, u32int fid, char *uname, Qid *qid); -char *logfsserverclunk(LogfsServer *s, u32int fid); -char *logfsservercreate(LogfsServer *server, u32int fid, char *name, u32int perm, uchar mode, Qid *qid); -char *logfsserverflush(LogfsServer *server); -char *logfsservernew(LogfsBoot *lb, LogfsLowLevel *ll, LogfsIdentityStore *is, ulong openflags, int trace, LogfsServer **sp); -char *logfsserveropen(LogfsServer *s, u32int fid, uchar mode, Qid *qid); -char *logfsserverread(LogfsServer *s, u32int fid, u32int offset, u32int count, uchar *buf, u32int buflen, u32int *rcount); -char *logfsserverremove(LogfsServer *server, u32int fid); -char *logfsserverstat(LogfsServer *s, u32int fid, uchar *buf, u32int bufsize, ushort *count); -char *logfsserverwalk(LogfsServer *s, u32int fid, u32int newfid, ushort nwname, char **wname, ushort *nwqid, Qid *wqid); -char *logfsserverwrite(LogfsServer *server, u32int fid, u32int offset, u32int count, uchar *buf, u32int *rcount); -char *logfsserverwstat(LogfsServer *server, u32int fid, uchar *stat, ushort nstat); -void logfsserverfree(LogfsServer **sp); -char *logfsserverlogsweep(LogfsServer *server, int justone, int *didsomething); -char *logfsserverreadpathextent(LogfsServer *server, u32int path, int nth, u32int *flashaddrp, u32int *lengthp, - long *blockp, int *pagep, int *offsetp); - -char *logfsservertestcmd(LogfsServer *s, int argc, char **argv); -void logfsservertrace(LogfsServer *s, int level); +char *logfstagname(uchar); + +char *logfsisnew(LogfsIdentityStore **); +void logfsisfree(LogfsIdentityStore **); +char *logfsisgroupcreate(LogfsIdentityStore*, char*, char*); +char *logfsisgrouprename(LogfsIdentityStore*, char*, char*); +char *logfsisgroupsetleader(LogfsIdentityStore*, char*, char*); +char *logfsisgroupaddmember(LogfsIdentityStore*, char*, char*); +char *logfsisgroupremovemember(LogfsIdentityStore*, char*, char*); +char *logfsisusersread(LogfsIdentityStore*, void*, long, ulong, long*); + +char *logfsformat(LogfsLowLevel*, long, long, long, int); +char *logfsbootopen(LogfsLowLevel*, long, long, int, int, LogfsBoot**); +void logfsbootfree(LogfsBoot*); +char *logfsbootread(LogfsBoot*, void*, long, ulong); +char *logfsbootwrite(LogfsBoot*, void*, long, ulong); +char *logfsbootio(LogfsBoot*, void*, long, ulong, int); +char *logfsbootmap(LogfsBoot*, ulong, ulong*, int*, int*, int*, ulong*, ulong*); +long logfsbootgetiosize(LogfsBoot*); +long logfsbootgetsize(LogfsBoot*); +void logfsboottrace(LogfsBoot*, int); + +char *logfsserverattach(LogfsServer*, u32int, char*, Qid*); +char *logfsserverclunk(LogfsServer*, u32int); +char *logfsservercreate(LogfsServer*, u32int, char*, u32int, uchar, Qid*); +char *logfsserverflush(LogfsServer*); +char *logfsservernew(LogfsBoot*, LogfsLowLevel*, LogfsIdentityStore*, ulong, int, LogfsServer**); +char *logfsserveropen(LogfsServer*, u32int, uchar mode, Qid*); +char *logfsserverread(LogfsServer*, u32int, u32int, u32int, uchar*, u32int, u32int*); +char *logfsserverremove(LogfsServer*, u32int); +char *logfsserverstat(LogfsServer*, u32int, uchar*, u32int, ushort*); +char *logfsserverwalk(LogfsServer*, u32int, u32int, ushort, char **, ushort*, Qid*); +char *logfsserverwrite(LogfsServer*, u32int, u32int, u32int, uchar*, u32int*); +char *logfsserverwstat(LogfsServer*, u32int, uchar*, ushort nstat); +void logfsserverfree(LogfsServer **); +char *logfsserverlogsweep(LogfsServer*, int, int*); +char *logfsserverreadpathextent(LogfsServer*, u32int, int, u32int*, u32int*, long*, int*, int*); + +char *logfsservertestcmd(LogfsServer*, int, char **); +void logfsservertrace(LogfsServer*, int); /* * implemented by the environment */ ulong logfsnow(void); -void *logfsrealloc(void *p, ulong size); -void logfsfreemem(void *p); +void *logfsrealloc(void*, ulong); +void logfsfreemem(void*); +int nrand(int); + +extern char Eio[]; +extern char Ebadarg[]; +extern char Eperm[]; diff --git a/include/nandfs.h b/include/nandfs.h index 66842f6b..1b6eb54b 100644 --- a/include/nandfs.h +++ b/include/nandfs.h @@ -1,5 +1,10 @@ #pragma src "/usr/inferno/libnandfs" +typedef struct Nandfs Nandfs; +typedef struct NandfsTags NandfsTags; + +#pragma incomplete Nandfs + enum { NandfsL2PageSize = 9, NandfsPageSize = 1 << NandfsL2PageSize, @@ -11,62 +16,59 @@ enum { NandfsNeraseMask = ((1 << NandfsNeraseBits) - 1), }; -typedef struct Nandfs Nandfs; - -typedef struct NandfsTags { +struct NandfsTags { ulong path; // 26 bits ulong nerase; // 18 bits uchar tag; // 8 bits uchar magic; // 8 bits -} NandfsTags; +}; -char *nandfsinit(void *magic, long rawsize, long rawblocksize, - char *(*read)(void *magic, void *buf, long nbytes, ulong offset), - char *(*write)(void *magic, void *buf, long nbytes, ulong offset), - char *(*erase)(void *magic, long blockaddr), - char *(*sync)(void *magic), - LogfsLowLevel **llp); -void nandfsfree(Nandfs *nandfs); -char *nandfsreadpageauxiliary(Nandfs *nandfs, NandfsTags *tags, long block, int page, int correct, LogfsLowLevelReadResult *result); -void nandfssetmagic(Nandfs *nandfs, void *magic); -char *nandfswritepageauxiliary(Nandfs *nandfs, NandfsTags *tags, long absblock, int page); -char *nandfsreadpage(Nandfs *nandfs, void *buf, NandfsTags *tags, long block, int page, int reportbad, LogfsLowLevelReadResult *result); -char *nandfsreadpagerange(Nandfs *nandfs, void *buf, long block, int page, int offset, int count, LogfsLowLevelReadResult *result); -char *nandfsupdatepage(Nandfs *nandfs, void *buf, ulong path, uchar tag, long block, int page); +char *nandfsinit(void*, long, long, char *(*)(void*, void*, long, ulong), + char *(*)(void*, void*, long, ulong), + char *(*)(void*, long), + char *(*)(void*), + LogfsLowLevel **); +void nandfsfree(Nandfs*); +char *nandfsreadpageauxiliary(Nandfs*, NandfsTags*, long, int, int, LogfsLowLevelReadResult*); +void nandfssetmagic(Nandfs*, void*); +char *nandfswritepageauxiliary(Nandfs*, NandfsTags*, long, int); +char *nandfsreadpage(Nandfs*, void*, NandfsTags*, long, int, int, LogfsLowLevelReadResult*); +char *nandfsreadpagerange(Nandfs*, void*, long, int, int, int, LogfsLowLevelReadResult*); +char *nandfsupdatepage(Nandfs*, void*, ulong, uchar, long, int); -long nandfsgetnerase(Nandfs *nandfs, long block); -void nandfssetnerase(Nandfs *nandfs, long block, ulong nerase); -void nandfssetpartial(Nandfs *nandfs, long block, int partial); +long nandfsgetnerase(Nandfs*, long); +void nandfssetnerase(Nandfs*, long, ulong); +void nandfssetpartial(Nandfs*, long, int); -char *nandfsmarkabsblockbad(Nandfs *nandfs, long absblock); +char *nandfsmarkabsblockbad(Nandfs*, long); /* low level interface functions */ -char *nandfsopen(Nandfs *nandfs, long base, long limit, int trace, int xcount, long *data); -short nandfsgettag(Nandfs *nandfs, long block); -void nandfssettag(Nandfs *nandfs, long block, short tag); -long nandfsgetpath(Nandfs *nandfs, long block); -void nandfssetpath(Nandfs *nandfs, long block, ulong path); -int nandfsgetblockpartialformatstatus(Nandfs *nandfs, long block); -long nandfsfindfreeblock(Nandfs *nandfs, long *freeblocksp); -char *nandfsreadblock(Nandfs *nandfs, void *buf, long block, LogfsLowLevelReadResult *blocke); -char *nandfswriteblock(Nandfs *nandfs, void *buf, uchar tag, ulong path, int xcount, long *data, long block); -char *nandfswritepage(Nandfs *nandfs, void *buf, long block, int page); -char *nandfseraseblock(Nandfs *nandfs, long block, void **llsavep, int *markedbad); -char *nandfsformatblock(Nandfs *nandfs, long block, uchar tag, ulong path, long baseblock, long sizeinblocks, int xcount, long *xdata, void *llsave, int *markedbad); -char *nandfsreformatblock(Nandfs *nandfs, long block, uchar tag, ulong path, int xcount, long *xdata, void *llsave, int *markedbad); -char *nandfsmarkblockbad(Nandfs *nandfs, long block); -int nandfsgetpagesize(Nandfs *nandfs); -int nandfsgetpagesperblock(Nandfs *nandfs); -long nandfsgetblocks(Nandfs *nandfs); -long nandfsgetbaseblock(Nandfs *nandfs); -int nandfsgetblocksize(Nandfs *nandfs); -ulong nandfscalcrawaddress(Nandfs *nandfs, long pblock, int dataoffset); -char *nandfsgetblockstatus(Nandfs *nandfs, long block, int *magicfound, void **llsave, LogfsLowLevelReadResult *result); -int nandfscalcformat(Nandfs *nandfs, long base, long limit, long bootsize, long *baseblock, long *limitblock, long *bootblocks); -int nandfsgetopenstatus(Nandfs *nandfs); -char *nandfssync(Nandfs *nandfs); +char *nandfsopen(Nandfs*, long, long, int, int, long*); +short nandfsgettag(Nandfs*, long); +void nandfssettag(Nandfs*, long, short); +long nandfsgetpath(Nandfs*, long); +void nandfssetpath(Nandfs*, long, ulong); +int nandfsgetblockpartialformatstatus(Nandfs*, long); +long nandfsfindfreeblock(Nandfs*, long*); +char *nandfsreadblock(Nandfs*, void*, long, LogfsLowLevelReadResult*); +char *nandfswriteblock(Nandfs*, void*, uchar, ulong, int, long*, long); +char *nandfswritepage(Nandfs*, void*, long, int); +char *nandfseraseblock(Nandfs*, long, void **, int*); +char *nandfsformatblock(Nandfs*, long, uchar, ulong, long, long, int, long*, void*, int*); +char *nandfsreformatblock(Nandfs*, long, uchar, ulong, int, long*, void*, int*); +char *nandfsmarkblockbad(Nandfs*, long); +int nandfsgetpagesize(Nandfs*); +int nandfsgetpagesperblock(Nandfs*); +long nandfsgetblocks(Nandfs*); +long nandfsgetbaseblock(Nandfs*); +int nandfsgetblocksize(Nandfs*); +ulong nandfscalcrawaddress(Nandfs*, long, int); +char *nandfsgetblockstatus(Nandfs*, long, int*, void **, LogfsLowLevelReadResult*); +int nandfscalcformat(Nandfs*, long, long, long, long*, long*, long*); +int nandfsgetopenstatus(Nandfs*); +char *nandfssync(Nandfs*); /* defined in environment */ -void *nandfsrealloc(void *p, ulong size); -void nandfsfreemem(void *p); +void *nandfsrealloc(void*, ulong); +void nandfsfreemem(void*); diff --git a/include/version.h b/include/version.h index 195b2c37..46317ac1 100644 --- a/include/version.h +++ b/include/version.h @@ -1 +1 @@ -#define VERSION "Fourth Edition (20111214)" +#define VERSION "Fourth Edition (20111215)" 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; diff --git a/libnandfs/calcformat.c b/libnandfs/calcformat.c index 498427f5..e258c8f1 100644 --- a/libnandfs/calcformat.c +++ b/libnandfs/calcformat.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/correctauxilliary.c b/libnandfs/correctauxilliary.c index 510aeac4..09f60115 100644 --- a/libnandfs/correctauxilliary.c +++ b/libnandfs/correctauxilliary.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" @@ -60,7 +60,7 @@ _nandfscorrectauxiliary(NandfsAuxiliary *hdr) else { if (hdr->tag != LogfsTnone) { ulong tmp = getbig4(hdr->parth); - if (tmp != 0xfffffffff && _nandfshamming31_26correct(&tmp)) { + if (tmp != 0xffffffff && _nandfshamming31_26correct(&tmp)) { putbig4(hdr->parth, tmp); if (e != LogfsLowLevelReadResultOk) e = LogfsLowLevelReadResultSoftError; diff --git a/libnandfs/ecc.c b/libnandfs/ecc.c index 1cd86d20..c4c1612a 100644 --- a/libnandfs/ecc.c +++ b/libnandfs/ecc.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "nandecc.h" static uchar ecctab[] = { diff --git a/libnandfs/eraseblock.c b/libnandfs/eraseblock.c index 2ecd490f..1d4d8bbf 100644 --- a/libnandfs/eraseblock.c +++ b/libnandfs/eraseblock.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/extracttags.c b/libnandfs/extracttags.c index be3fc2da..f6a8aaee 100644 --- a/libnandfs/extracttags.c +++ b/libnandfs/extracttags.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/findfreeblock.c b/libnandfs/findfreeblock.c index e17f729a..b538ef0a 100644 --- a/libnandfs/findfreeblock.c +++ b/libnandfs/findfreeblock.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/formatblock.c b/libnandfs/formatblock.c index 8f37e2c9..146449b1 100644 --- a/libnandfs/formatblock.c +++ b/libnandfs/formatblock.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/getblockstatus.c b/libnandfs/getblockstatus.c index 0ebaf5e1..7cf59e38 100644 --- a/libnandfs/getblockstatus.c +++ b/libnandfs/getblockstatus.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/hamming31_26.c b/libnandfs/hamming31_26.c index a94262b7..331c9232 100644 --- a/libnandfs/hamming31_26.c +++ b/libnandfs/hamming31_26.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" diff --git a/libnandfs/init.c b/libnandfs/init.c index ebfd6a67..c0a926b8 100644 --- a/libnandfs/init.c +++ b/libnandfs/init.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/local.h b/libnandfs/local.h index d5b4eecb..5c3df452 100644 --- a/libnandfs/local.h +++ b/libnandfs/local.h @@ -1,16 +1,19 @@ -typedef struct NandfsBlockData { +typedef struct NandfsBlockData NandfsBlockData; +typedef struct NandfsAuxiliary NandfsAuxiliary; + +struct NandfsBlockData { ulong path; short tag; ulong nerase; int partial; -} NandfsBlockData; +}; struct Nandfs { LogfsLowLevel ll; - char *(*read)(void *magic, void *buf, long nbytes, ulong offset); - char *(*write)(void *magic, void *buf, long nbytes, ulong offset); - char *(*erase)(void *magic, long blockaddr); - char *(*sync)(void *magic); + char *(*read)(void*, void*, long, ulong); + char *(*write)(void*, void*, long, ulong); + char *(*erase)(void*, long blockaddr); + char *(*sync)(void*); void *magic; long rawblocksize; long baseblock; @@ -21,7 +24,7 @@ struct Nandfs { int printbad; }; -typedef struct NandfsAuxiliary { +struct NandfsAuxiliary { uchar parth[4]; // ggpppppp pppppppp pppppppp pp1hhhhh (bigendian) self-protected uchar tag; // self-protecting uchar blockstatus; // self-protecting @@ -29,7 +32,7 @@ typedef struct NandfsAuxiliary { uchar ecc2[3]; // self-protecting uchar nerasemagiclsw[2]; // mmmmmm mmeeeeee eeeeeeeeee ee1hhhhh (bigendian) self-protected uchar ecc1[3]; // self-protecting -} NandfsAuxiliary; +}; #define getbig2(p) (((p)[0] << 8) | (p)[1]) #define getbig4(p) (((p)[0] << 24) | ((p)[1] << 16) | ((p)[2] << 8) | (p)[3]) @@ -38,7 +41,7 @@ typedef struct NandfsAuxiliary { #define putbig2(p, q) ((p)[0] = (q) >> 8, (p)[1] = (q)) #define putbig4(p, q) ((p)[0] = (q) >> 24, (p)[1] = (q) >> 16, (p)[2] = (q) >> 8, (p)[3] = (q)) -LogfsLowLevelReadResult _nandfscorrectauxiliary(NandfsAuxiliary *hdr); +LogfsLowLevelReadResult _nandfscorrectauxiliary(NandfsAuxiliary*); extern uchar _nandfsvalidtags[]; extern int _nandfsvalidtagscount; @@ -46,6 +49,6 @@ extern int _nandfsvalidtagscount; ulong _nandfshamming31_26calc(ulong in); int _nandfshamming31_26correct(ulong *in); -void _nandfsextracttags(NandfsAuxiliary *hdr, NandfsTags *tags); +void _nandfsextracttags(NandfsAuxiliary*, NandfsTags*); extern char Enomem[], Eperm[], Eio[]; diff --git a/libnandfs/markblockbad.c b/libnandfs/markblockbad.c index 6414c8d2..f08726ce 100644 --- a/libnandfs/markblockbad.c +++ b/libnandfs/markblockbad.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/open.c b/libnandfs/open.c index 12b49849..8a20a52f 100644 --- a/libnandfs/open.c +++ b/libnandfs/open.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/readblock.c b/libnandfs/readblock.c index cbf3222b..4c4d9f7c 100644 --- a/libnandfs/readblock.c +++ b/libnandfs/readblock.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/readpage.c b/libnandfs/readpage.c index 9ae3ed43..9af91060 100644 --- a/libnandfs/readpage.c +++ b/libnandfs/readpage.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "nandecc.h" @@ -46,7 +46,7 @@ nandfsreadpagerange(Nandfs *nandfs, void *buf, long block, int page, int offset, uchar tmpbuf[NandfsPageSize]; errmsg = nandfsreadpage(nandfs, tmpbuf, nil, block, page, 1, result); if (errmsg == nil) - memcpy(buf, tmpbuf + offset, count); + memmove(buf, tmpbuf + offset, count); return errmsg; } diff --git a/libnandfs/readpageauxilliary.c b/libnandfs/readpageauxilliary.c index ba71d2b5..252d59ae 100644 --- a/libnandfs/readpageauxilliary.c +++ b/libnandfs/readpageauxilliary.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/reformatblock.c b/libnandfs/reformatblock.c index c0d790bf..9130552c 100644 --- a/libnandfs/reformatblock.c +++ b/libnandfs/reformatblock.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/setget.c b/libnandfs/setget.c index 4a25f494..c5efdeff 100644 --- a/libnandfs/setget.c +++ b/libnandfs/setget.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/updatepage.c b/libnandfs/updatepage.c index afe70b79..4acb65db 100644 --- a/libnandfs/updatepage.c +++ b/libnandfs/updatepage.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "nandecc.h" diff --git a/libnandfs/writeblock.c b/libnandfs/writeblock.c index 0e4b9c3d..695c96e7 100644 --- a/libnandfs/writeblock.c +++ b/libnandfs/writeblock.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" diff --git a/libnandfs/writepageauxilliary.c b/libnandfs/writepageauxilliary.c index 6d2d6b87..70b1a5f4 100644 --- a/libnandfs/writepageauxilliary.c +++ b/libnandfs/writepageauxilliary.c @@ -1,4 +1,4 @@ -#include "lib9.h" +#include "logfsos.h" #include "logfs.h" #include "nandfs.h" #include "local.h" |