ref: c116550e6a41572796e4db65e4f6acbcb3d9d6f8
dir: /liblogfs/scan.c/
#include "logfsos.h"
#include "logfs.h"
#include "local.h"
#include "fcall.h"
typedef struct PathEnt {
ulong path;
long block;
} PathEnt;
typedef struct GenInfo {
long start;
long end;
int gaps;
} GenInfo;
static int
dataorder(ulong p1, ulong p2)
{
int o;
o = dataseqof(p1) - dataseqof(p2);
if(o != 0)
return o;
return copygenof(p1) - copygenof(p2);
}
static int
logorder(ulong p1, ulong p2)
{
int o;
o = loggenof(p1) - loggenof(p2);
if(o != 0)
return o;
o = logseqof(p1) - logseqof(p2);
if(o != 0)
return o;
return copygenof(p1) - copygenof(p2);
}
static void
insert(PathEnt *pathmap, long entries, ulong path, long block, int (*order)(ulong p1, ulong p2))
{
long i;
for(i = 0; i < entries; i++)
if((*order)(path, pathmap[i].path) < 0)
break;
memmove(&pathmap[i + 1], &pathmap[i], (entries - i) * sizeof(PathEnt));
pathmap[i].path = path;
pathmap[i].block = block;
}
static void
populate(LogSegment *seg, int gen, long unsweptblockindex, long curblockindex, PathEnt *pathent)
{
long i;
seg->gen = gen;
seg->unsweptblockindex = unsweptblockindex;
seg->curblockindex = curblockindex;
for(i = unsweptblockindex; i <= curblockindex; i++) {
// print("populate %d: %d\n", i, pathent[i - unsweptblockindex].block);
seg->blockmap[i] = pathent->block;
pathent++;
}
}
static int
dataduplicate(PathEnt *p1, PathEnt *p2)
{
return dataseqof(p2->path) == dataseqof(p1->path)
&& copygenof(p2->path) == copygensucc(copygenof(p1->path));
}
static char *
eliminateduplicates(LogfsServer *server, char *name, PathEnt *map, long *entriesp)
{
long i;
long k = *entriesp;
for(i = 0; i < k;) {
PathEnt *prev = &map[i - 1];
PathEnt *this = &map[i];
if(i > 0 && dataduplicate(prev, this)) {
print("%s duplicate detected\n", name);
if(i + 1 < k && dataduplicate(this, &map[i + 1]))
return "three or more copies of same block";
/*
* check that the copy generations are in order
*/
if(copygensucc(copygenof(this->path)) == copygenof(prev->path)) {
PathEnt m;
/*
* previous entry is newer, so swap
*/
m = *this;
*this = *prev;
*prev = m;
}
else if(copygensucc(copygenof(prev->path)) != copygenof(this->path))
return "duplicate blocks but copy generations not sequential";
/* erase and format previous block */
logfsbootfettleblock(server->lb, prev->block, LogfsTnone, ~0, nil);
/*
* remove entry from table
*/
memmove(prev, this, sizeof(PathEnt) * (k - i));
k--;
continue;
}
i++;
}
*entriesp = k;
return nil;
}
char *
logfsscan(LogfsServer *server)
{
LogfsLowLevel *ll = server->ll;
long b;
long i;
long logfound = 0;
long datafound = 0;
PathEnt *logpathmap, *datapathmap;
GenInfo geninfo[1 << L2LogSweeps];
int gensfound, lastgenfound;
int g0, g1;
char *errmsg;
//print("logfsscan %ld blocks\n", server->ll->blocks);
logpathmap = logfsrealloc(nil, sizeof(PathEnt) * server->ll->blocks);
datapathmap = logfsrealloc(nil, sizeof(PathEnt) * server->ll->blocks);
if(logpathmap == nil || datapathmap == nil)
return Enomem;
for(b = 0; b < ll->blocks; b++) {
short tag = (*ll->getblocktag)(ll, b);
ulong path = (*ll->getblockpath)(ll, b);
//print("scan: %ld: %d %ld\n", b, tag, path);
switch(tag) {
case LogfsTlog:
insert(logpathmap, logfound++, path, b, logorder);
break;
case LogfsTdata:
insert(datapathmap, datafound++, path, b, dataorder);
break;
}
}
if(server->trace > 1) {
for(i = 0; i < logfound; i++)
print("log gen %lud seq %lud copygen %lud block %ld\n",
loggenof(logpathmap[i].path), logseqof(logpathmap[i].path), copygenof(datapathmap[i].path), logpathmap[i].block);
for(i = 0; i < datafound; i++)
print("data seq %lud copygen %lud block %ld\n",
dataseqof(datapathmap[i].path), copygenof(datapathmap[i].path), datapathmap[i].block);
}
/*
* sort out data first
*/
errmsg = eliminateduplicates(server, "data", datapathmap, &datafound);
if(errmsg)
goto fail;
/*
* data blocks guaranteed to be ordered
*/
if(datafound)
server->ndatablocks = dataseqof(datapathmap[datafound - 1].path) + 1;
else
server->ndatablocks = 0;
for(i = 0; i < server->ndatablocks; i++)
server->datablock[i].block = -1;
for(i = 0; i < datafound; i++) {
long j;
j = dataseqof(datapathmap[i].path);
server->datablock[j].path = datapathmap[i].path;
server->datablock[j].block = datapathmap[i].block;
/*
* mark pages as free and dirty, which indicates they cannot be used
*/
server->datablock[j].dirty = server->datablock[j].free = logfsdatapagemask(1 << ll->l2pagesperblock, 0);
}
/*
* find how many generations are present, and whether there are any gaps
*/
errmsg = eliminateduplicates(server, "log", logpathmap, &logfound);
if(errmsg)
goto fail;
gensfound = 0;
lastgenfound = -1;
for(i = 0; i < nelem(geninfo); i++)
geninfo[i].start = -1;
for(i = 0; i < logfound; i++) {
int gen;
gen = loggenof(logpathmap[i].path);
if(geninfo[gen].start < 0) {
if(lastgenfound >= 0)
geninfo[lastgenfound].end = i;
geninfo[gen].start = i;
lastgenfound = gen;
geninfo[gen].gaps = 0;
gensfound++;
}
else if(!geninfo[lastgenfound].gaps && logseqof(logpathmap[i - 1].path) + 1 != logseqof(logpathmap[i].path)) {
geninfo[lastgenfound].gaps = 1;
print("generation %d has gaps (%lud, %lud)\n", lastgenfound,
logseqof(logpathmap[i - 1].path), logseqof(logpathmap[i].path));
}
}
if(lastgenfound >= 0)
geninfo[lastgenfound].end = i;
if(server->trace > 1) {
for(i = 0; i < nelem(geninfo); i++)
print("geninfo: %ld: start %ld end %ld gaps %d\n", i, geninfo[i].start, geninfo[i].end, geninfo[i].gaps);
}
switch(gensfound) {
case 0:
/* active log - empty */
break;
case 1:
/*
* one log, active
*/
for(g0 = 0; g0 < nelem(geninfo); g0++)
if(geninfo[g0].start >= 0)
break;
if(geninfo[g0].gaps || geninfo[g0].start != 0) {
errmsg = "missing log blocks";
goto fail;
}
populate(server->activelog, g0, 0, geninfo[g0].end - geninfo[g0].start - 1, logpathmap + geninfo[g0].start);
break;
case 2:
/*
* two logs, active, swept
*/
g0 = -1;
for(g1 = 0; g1 < nelem(geninfo); g1++)
if(geninfo[g1].start >= 0) {
if(g0 < 0)
g0 = g1;
else
break;
}
if(geninfo[g0].gaps || geninfo[g1].gaps) {
errmsg = "missing log blocks";
goto fail;
}
if(g0 == loggensucc(g1)) {
int tmp = g0;
g0 = g1;
g1 = tmp;
}
else if(g1 != loggensucc(g0)) {
errmsg = "nonsequential generations in log";
goto fail;
}
if(logseqof(logpathmap[geninfo[g1].start].path) != 0) {
errmsg = "swept log does not start at 0";
goto fail;
}
if(logseqof(logpathmap[geninfo[g0].start].path) == logseqof(logpathmap[geninfo[g1].end - 1].path)) {
/*
* duplicate block
* as the log never gets bigger, information from active[n] is either entirely in swept[n],
* or split between swept[n-1] and swept[n]. we can safely remove swept[n]. this might
* leave some duplication between swept[n - 1] and active[n], but this is always true
* for a partially swept log
*/
logfsbootfettleblock(server->lb, logpathmap[geninfo[g1].end - 1].block, LogfsTnone, ~0, nil);
geninfo[g1].end--;
}
if(logseqof(logpathmap[geninfo[g0].start].path) < logseqof(logpathmap[geninfo[g1].end - 1].path)) {
errmsg = "active log overlaps end of swept log";
goto fail;
}
populate(server->activelog, g0, logseqof(logpathmap[geninfo[g0].start].path),
logseqof(logpathmap[geninfo[g0].end - 1].path), logpathmap + geninfo[g0].start);
if(server->sweptlog == nil) {
errmsg = logfslogsegmentnew(server, g1, &server->sweptlog);
if(errmsg)
goto fail;
}
populate(server->sweptlog, g1, logseqof(logpathmap[geninfo[g1].start].path),
logseqof(logpathmap[geninfo[g1].end - 1].path), logpathmap + geninfo[g1].start);
break;
default:
errmsg = "more than two generations in log";
goto fail;
}
goto ok;
fail:
logfslogsegmentfree(&server->sweptlog);
ok:
logfsfreemem(logpathmap);
logfsfreemem(datapathmap);
return errmsg;
}