ref: b7af62b250e5dff30320a181ca9d53ab5a7c276d
dir: /liblogfs/sweep.c/
#include "logfsos.h"
#include "logfs.h"
#include "local.h"
enum {
ThrowAway,
Keep,
Repack,
Error,
};
#define setaction(a) if(*actionp < (a)) *actionp = a
#define REPACK setaction(Repack)
#define KEEP setaction(Keep)
#define OPTCOPYEX(name, etag, stag) \
if(e->etag != s->stag) { \
s->stag = e->etag; \
REPACK; \
}
#define OPTSTRCOPYEX(name, etag, stag) \
if(strcmp(e->etag, s->stag) != 0) { \
s->stag = e->etag; \
REPACK; \
}
#define OPTCOPY(name, tag, sunion) OPTCOPYEX(name, tag, u.sunion.tag)
#define OPTSTRCOPY(name, tag, sunion) OPTSTRCOPYEX(name, tag, u.sunion.tag)
static char *
sweepcreate(LogfsServer *server, LogMessage *s, int *actionp)
{
Entry *pe, *e;
e = logfspathmapfinde(server->pathmap, s->u.create.newpath);
if(e == nil)
/* file no longer exists */
return nil;
pe = logfspathmapfinde(server->pathmap, s->path);
if(pe == nil)
/* file exists but parent doesn't - not good, but can continue */
return "parent missing";
if((pe->perm & DMDIR) == 0 || (e->perm & DMDIR) != (s->u.create.perm & DMDIR))
/* parent must be a directory, and
* the directory mode cannot change
*/
return logfseinternal;
if((e->perm & DMDIR) == 0) {
OPTCOPYEX("cvers", u.file.cvers, u.create.cvers);
}
OPTSTRCOPY("name", name, create);
OPTCOPY("mtime", mtime, create);
OPTCOPY("perm", perm, create);
OPTSTRCOPY("uid", uid, create);
OPTSTRCOPY("gid", gid, create);
KEEP;
return nil;
}
static char *
sweepwrite(LogfsServer *server, LogMessage *s, int readoffset, Entry **ep, int *trimp, int *actionp)
{
Entry *e;
Extent extent;
Extent *ext;
*ep = nil;
e = logfspathmapfinde(server->pathmap, s->path);
if(e == nil)
/* gone, gone */
return nil;
if(e->perm & DMDIR)
return logfseinternal;
if(e->u.file.cvers != s->u.write.cvers)
/* trunced more recently */
return nil;
extent.min = s->u.write.offset;
extent.max = extent.min + s->u.write.count;
extent.flashaddr = s->u.write.flashaddr;
ext = logfsextentlistmatch(e->u.file.extent, &extent);
if(ext == nil)
return nil;
if(s->u.write.data) {
/*
* trim the front of the data so that when fixing up extents,
* flashaddr refers to the first byte
*/
int offset;
logfsflashaddr2o(server, ext->flashaddr, &offset);
*trimp = offset - readoffset;
*ep = e;
}
KEEP;
return nil;
}
typedef struct FixupState {
LogfsServer *server;
int oldoffset;
u32int newflashaddr;
} FixupState;
static int
fixup(void *magic, Extent *e)
{
FixupState *state = magic;
int offset;
logfsflashaddr2o(state->server, e->flashaddr, &offset);
e->flashaddr = state->newflashaddr + (offset - state->oldoffset);
return 1;
}
static char *
sweepblock(LogfsServer *server, uchar *buf)
{
char *errmsg;
LogSegment *active = server->activelog;
LogSegment *swept = server->sweptlog;
int pagesize, ppb, page;
LogfsLowLevel *ll = server->ll;
LogfsLowLevelReadResult llrr;
int markedbad;
long oblock;
if(active == nil)
return nil;
if(swept == nil) {
errmsg = logfslogsegmentnew(server, loggensucc(active->gen), &server->sweptlog);
if(errmsg)
return errmsg;
swept = server->sweptlog;
}
/*
* if this is last block in the active log, flush it, so that the read of the last page works
*/
if(active->unsweptblockindex == active->curblockindex)
logfslogsegmentflush(server, 1);
ppb = (1 << ll->l2pagesperblock);
pagesize = (1 << ll->l2pagesize);
for(page = 0; page < ppb; page++) {
uchar *p, *bufend;
errmsg = (*ll->readpagerange)(ll, buf, active->blockmap[active->unsweptblockindex], page, 0, pagesize, &llrr);
if(errmsg)
goto fail;
if(llrr != LogfsLowLevelReadResultOk)
logfsserverreplacelogblock(server, active, active->unsweptblockindex);
p = buf;
if(*p == 0xff)
break;
bufend = p + pagesize;
while(p < bufend) {
int action;
uint size;
LogMessage s;
Entry *e;
int trim;
size = logfsconvM2S(p, bufend - p, &s);
if(size == 0)
return "parse failure";
if(server->trace > 1) {
print("A>> ");
logfsdumpS(&s);
print("\n");
}
if(s.type == LogfsLogTend)
break;
action = ThrowAway;
switch(s.type) {
case LogfsLogTstart:
break;
case LogfsLogTcreate:
errmsg = sweepcreate(server, &s, &action);
break;
case LogfsLogTremove:
/* always obsolete; might check that path really doesn't exist */
break;
case LogfsLogTtrunc:
/* always obsolete, unless collecting out of order */
break;
case LogfsLogTwrite:
errmsg = sweepwrite(server, &s, s.u.write.data ? s.u.write.data - buf : 0, &e, &trim, &action);
break;
case LogfsLogTwstat:
/* always obsolete, unless collecting out of order */
break;
default:
return "bad tag in log page";
}
if(action == Error)
return errmsg;
if(errmsg)
print("bad sweep: %s\n", errmsg);
if(action == Keep)
action = Repack; /* input buffer has been wrecked, so can't just copy it */
if(action == Keep) {
/* write 'size' bytes to log */
errmsg = logfslogbytes(server, 0, p, size);
if(errmsg)
goto fail;
}
else if(action == Repack) {
/* TODO - handle writes */
if(s.type == LogfsLogTwrite && s.u.write.data) {
FixupState state;
errmsg = logfslogwrite(server, 0, s.path, s.u.write.offset + trim, s.u.write.count - trim,
s.u.write.mtime, s.u.write.cvers,
s.u.write.muid, s.u.write.data + trim, &state.newflashaddr);
if(errmsg == nil && s.u.write.data != nil) {
Extent extent;
/* TODO - deal with a failure to write the changes */
state.oldoffset = s.u.write.data - buf + trim;
state.server = server;
extent.min = s.u.write.offset;
extent.max = extent.min + s.u.write.count;
extent.flashaddr = s.u.write.flashaddr;
logfsextentlistmatchall(e->u.file.extent, fixup, &state, &extent);
}
}
else
errmsg = logfslog(server, 0, &s);
if(errmsg)
goto fail;
}
p += size;
}
}
/*
* this log block is no longer needed
*/
oblock = active->blockmap[active->unsweptblockindex++];
errmsg = logfsbootfettleblock(server->lb, oblock, LogfsTnone, ~0, &markedbad);
if(errmsg)
goto fail;
if(active->unsweptblockindex > active->curblockindex) {
/*
* the activelog is now empty, so make the sweptlog the active one
*/
logfslogsegmentfree(&active);
server->activelog = swept;
server->sweptlog = nil;
swept->dirty = 0;
}
return nil;
fail:
return errmsg;
}
char *
logfsserverlogsweep(LogfsServer *server, int justone, int *didsomething)
{
uchar *buf;
char *errmsg;
/*
* TODO - is it even worth doing?
*/
*didsomething = 0;
if(!server->activelog->dirty)
return nil;
buf = logfsrealloc(nil, (1 << server->ll->l2pagesize));
if(buf == nil)
return Enomem;
errmsg = nil;
while(server->activelog->unsweptblockindex <= server->activelog->curblockindex) {
errmsg = sweepblock(server, buf);
if(errmsg)
break;
if(server->sweptlog == nil || justone)
break;
}
logfsfreemem(buf);
*didsomething = 1;
return errmsg;
}