ref: c116550e6a41572796e4db65e4f6acbcb3d9d6f8
dir: /liblogfs/boot.c/
#include "logfsos.h"
#include "logfs.h"
#include "local.h"
struct LogfsBoot {
LogfsLowLevel *ll;
long bootblocks;
long blocksize;
long size;
long *map;
int trace;
int printbad;
// ulong bootpathmask;
// int bootgenshift;
};
typedef struct LogfsBootPath LogfsBootPath;
//#define LogfsBootGenBits 2
//#define LogfsBootGenMask ((1 << LogfsBootGenBits) - 1)
#define LogfsBootGenMask ((1 << L2BlockCopies) - 1)
struct LogfsBootPath {
ulong path;
uchar gen;
};
#define LOGFSMKBOOTPATH(lb, p) mkdatapath((p)->path, (p)->gen)
#define LOGFSSPLITBOOTPATHEX(bgs, bpm, p, v) ((p)->path = dataseqof(v), (p)->gen = copygenof(v))
#define LOGFSSPLITBOOTPATH(lb, p, v) LOGFSSPLITBOOTPATHEX(0, 0, p, v)
//#define LOGFSMKBOOTPATH(lb, p) (((p)->path & (lb)->bootpathmask) | (((p)->gen & LogfsBootGenMask) << (lb)->bootgenshift))
//#define LOGFSSPLITBOOTPATHEX(bgs, bpm, p, v) ((p)->path = (v) & (bpm), (p)->gen = ((v) >> (bgs)) & LogfsBootGenMask)
//#define LOGFSSPLITBOOTPATH(lb, p, v) LOGFSSPLITBOOTPATHEX((lb)->bootgenshift, (lb)->bootpathmask, p, v)
extern LogfsBootPath logfsbooterasedpath;
static char Ecorrupt[] = "filesystem corrupt";
static char Enospc[] = "no free blocks";
static char Eaddress[] = "address out of range";
static char *
logfsbootblockupdate(LogfsBoot *lb, void *buf, LogfsBootPath *path, uchar tag, ulong block)
{
LogfsLowLevel *ll = lb->ll;
char *errmsg;
ulong packedpath;
if(lb->trace > 1)
print("logfsbootblockupdate: path 0x%.8lux(%d) tag %s block %lud\n",
path->path, path->gen, logfstagname(tag), block);
packedpath = LOGFSMKBOOTPATH(lb, path);
errmsg = (*ll->writeblock)(ll, buf, tag, packedpath, 1, &lb->bootblocks, block);
if(errmsg) {
/*
* ensure block never used again until file system reinitialised
* We have absolutely no idea what state it's in. This is most
* likely if someone turns off the power (or at least threatens
* the power supply), during a block update. This way the block
* is protected until the file system in reinitialised. An alternative
* would be check the file system after a power fail false alarm,
* and erase any Tworse blocks
*/
(*ll->setblocktag)(ll, block, LogfsTworse);
return errmsg;
}
(*ll->setblocktag)(ll, block, tag);
(*ll->setblockpath)(ll, block, packedpath);
return nil;
}
char *
logfsbootfettleblock(LogfsBoot *lb, long block, uchar tag, long path, int *markedbad)
{
LogfsLowLevel *ll = lb->ll;
char *errmsg;
void *llsave;
errmsg = (*ll->eraseblock)(ll, block, &llsave, markedbad);
if(errmsg || (markedbad && *markedbad)) {
logfsfreemem(llsave);
return errmsg;
}
errmsg = (*ll->reformatblock)(ll, block, tag, path, 1, &lb->bootblocks, llsave, markedbad);
logfsfreemem(llsave);
return errmsg;
}
/*
* block transfer is the critical unit of update
* we are going to assume that page writes and block erases are atomic
* this can pretty much be assured by not starting a page write or block erase
* if the device feels it is in power fail
*/
static char *
logfsbootblocktransfer(LogfsBoot *lb, void *buf, ulong oldblock, int markbad)
{
LogfsLowLevel *ll = lb->ll;
long bestnewblock;
ulong oldpackedpath;
LogfsBootPath oldpath;
short oldtag;
char *errmsg;
int markedbad;
oldpackedpath = (*ll->getblockpath)(ll, oldblock);
oldtag = (*ll->getblocktag)(ll, oldblock);
LOGFSSPLITBOOTPATH(lb, &oldpath, oldpackedpath);
for(;;) {
LogfsBootPath newpath;
bestnewblock = logfsfindfreeblock(ll, markbad ? AllocReasonReplace : AllocReasonTransfer);
if(lb->trace > 0 && markbad)
print("logfsbootblocktransfer: block %lud is bad, copying to %ld\n",
oldblock, bestnewblock);
if(lb->trace > 1 && !markbad)
print("logfsbootblocktransfer: copying block %lud to %ld\n",
oldblock, bestnewblock);
if(bestnewblock == -1)
return Enospc;
newpath = oldpath;
// newpath.gen = (newpath.gen + 1) & LogfsBootGenMask;
newpath.gen = copygensucc(newpath.gen);
errmsg = logfsbootblockupdate(lb, buf, &newpath, oldtag, bestnewblock);
if(errmsg == nil)
break;
if(strcmp(errmsg, Eio) != 0)
return errmsg;
(*ll->markblockbad)(ll, bestnewblock);
}
#ifdef LOGFSTEST
if(logfstest.partialupdate) {
print("skipping erase\n");
logfstest.partialupdate = 0;
return nil;
}
if(logfstest.updatenoerase) {
print("skipping erase\n");
logfstest.updatenoerase = 0;
return nil;
}
#endif
if(oldtag == LogfsTboot)
lb->map[oldpath.path] = bestnewblock;
return logfsbootfettleblock(lb, oldblock, LogfsTnone, ~0, &markedbad);
}
static char *
logfsbootblockread(LogfsBoot *lb, void *buf, long block, LogfsLowLevelReadResult *blocke)
{
LogfsLowLevel *ll = lb->ll;
char *errmsg;
*blocke = LogfsLowLevelReadResultOk;
errmsg = (*ll->readblock)(ll, buf, block, blocke);
if(errmsg)
return errmsg;
if(*blocke != LogfsLowLevelReadResultOk) {
char *errmsg = logfsbootblocktransfer(lb, buf, block, 1);
if(errmsg)
return errmsg;
}
if(*blocke == LogfsLowLevelReadResultHardError)
return Eio;
return nil;
}
char *
logfsbootread(LogfsBoot *lb, void *buf, long n, ulong offset)
{
int i;
if(lb->trace > 0)
print("logfsbootread(0x%.8lux, 0x%lx, 0x%lux)\n", (ulong)buf, n, offset);
if(offset % lb->blocksize || n % lb->blocksize)
return Eio;
n /= lb->blocksize;
offset /= lb->blocksize;
if(offset + n > lb->bootblocks)
return Eio;
for(i = 0; i < n; i++) {
LogfsLowLevelReadResult result;
char *errmsg = logfsbootblockread(lb, buf, lb->map[offset + i], &result);
if(errmsg)
return errmsg;
buf = (uchar *)buf + lb->blocksize;
}
return nil;
}
static char *
logfsbootblockreplace(LogfsBoot *lb, void *buf, ulong logicalblock)
{
uchar *oldblockbuf;
ulong oldblock;
char *errmsg;
LogfsLowLevelReadResult result;
oldblock = lb->map[logicalblock];
oldblockbuf = logfsrealloc(nil, lb->blocksize);
if(oldblockbuf == nil)
return Enomem;
errmsg = logfsbootblockread(lb, oldblockbuf, oldblock, &result);
if(errmsg == nil && memcmp(oldblockbuf, buf, lb->blocksize) != 0)
errmsg = logfsbootblocktransfer(lb, buf, oldblock, 0);
logfsfreemem(oldblockbuf);
return errmsg;
}
char *
logfsbootwrite(LogfsBoot *lb, void *buf, long n, ulong offset)
{
int i;
if(lb->trace > 0)
print("logfsbootwrite(0x%.8lux, 0x%lux, 0x%lux)\n", (ulong)buf, n, offset);
/*
* don't even get started on a write if the power has failed
*/
if(offset % lb->blocksize || n % lb->blocksize)
return Eio;
n /= lb->blocksize;
offset /= lb->blocksize;
if(offset + n > lb->bootblocks)
return Eio;
for(i = 0; i < n; i++) {
logfsbootblockreplace(lb, buf, offset + i);
buf = (uchar *)buf + lb->blocksize;
}
return nil;
}
char *
logfsbootio(LogfsBoot *lb, void *buf, long n, ulong offset, int write)
{
return (write ? logfsbootwrite : logfsbootread)(lb, buf, n, offset);
}
static char *
eraseandformatblock(LogfsBoot *lb, long block, int trace)
{
char *errmsg;
int markedbad;
errmsg = logfsbootfettleblock(lb, block, LogfsTnone, ~0, &markedbad);
if(errmsg)
return errmsg;
if(markedbad && trace > 1)
print("erase/format failed - marked bad\n");
return nil;
}
char *
logfsbootopen(LogfsLowLevel *ll, long base, long limit, int trace, int printbad, LogfsBoot **lbp)
{
long *reversemap;
ulong blocksize;
ulong blocks;
long i;
long bootblockmax;
LogfsBoot *lb = nil;
ulong baseblock;
char *errmsg;
// int bootgenshift = ll->pathbits- LogfsBootGenBits;
// ulong bootpathmask = (1 << (ll->pathbits - LogfsBootGenBits)) - 1;
long expectedbootblocks;
errmsg = (*ll->open)(ll, base, limit, trace, 1, &expectedbootblocks);
if(errmsg)
return errmsg;
bootblockmax = -1;
blocks = ll->blocks;
baseblock = (*ll->getbaseblock)(ll);
blocksize = (*ll->getblocksize)(ll);
for(i = 0; i < blocks; i++) {
if((*ll->getblocktag)(ll, i) == LogfsTboot) {
long path = (*ll->getblockpath)(ll, i);
LogfsBootPath lp;
LOGFSSPLITBOOTPATHEX(bootgenshift, bootpathmask, &lp, path);
if((long)lp.path > bootblockmax)
bootblockmax = lp.path;
}
}
if(bootblockmax + 1 >= blocks) {
if(printbad)
print("logfsbootinit: bootblockmax %ld exceeds number of blocks\n", bootblockmax);
return Ecorrupt;
}
if(bootblockmax < 0) {
if(printbad)
print("logfsbootopen: no boot area\n");
return Ecorrupt;
}
if(bootblockmax + 1 != expectedbootblocks) {
if(printbad)
print("logfsbootopen: wrong number of bootblocks (found %lud, expected %lud)\n",
bootblockmax + 1, expectedbootblocks);
}
reversemap = logfsrealloc(nil, sizeof(*reversemap) * (bootblockmax + 1));
if(reversemap == nil)
return Enomem;
for(i = 0; i <= bootblockmax; i++)
reversemap[i] = -1;
for(i = 0; i < blocks; i++) {
LogfsBootPath ipath;
long rm;
ulong ip;
if((*ll->getblocktag)(ll, i) != LogfsTboot)
continue;
ip = (*ll->getblockpath)(ll, i);
LOGFSSPLITBOOTPATHEX(bootgenshift, bootpathmask, &ipath, ip);
rm = reversemap[ipath.path];
if(rm != -1) {
if(printbad)
print("logfsbootopen: blockaddr 0x%.8lux: path %ld(%d): duplicate\n",
blocksize * (baseblock + i), ipath.path, ipath.gen);
/*
* resolve collision
* if this one is partial, then erase it
* if the existing one is partial, erase that
* if both valid, give up
*/
if((*ll->getblockpartialformatstatus)(ll, i)) {
errmsg = eraseandformatblock(lb, i, trace);
if(errmsg)
goto error;
}
else if((*ll->getblockpartialformatstatus)(ll, rm)) {
errmsg = eraseandformatblock(lb, rm, trace);
if(errmsg)
goto error;
reversemap[ipath.path] = i;
}
else {
int d;
ulong rmp;
LogfsBootPath rmpath;
rmp = (*ll->getblockpath)(ll, rm);
LOGFSSPLITBOOTPATHEX(bootgenshift, bootpathmask, &rmpath, rmp);
d = (ipath.gen - rmpath.gen) & LogfsBootGenMask;
if(printbad)
print("i.gen = %d rm.gen = %d d = %d\n", ipath.gen, rmpath.gen, d);
if(d == 1) {
/* i is newer;
* keep the OLDER one because
* we might have had a write failure on the last page, but lost the
* power before being able to mark the first page bad
* if, worse, the auxiliary area's tag is the same for first and last page,
* this looks like a successfully written page. so, we cannot believe the
* data in the newer block unless we erased the old one, and then of
* course, we wouldn't have a duplicate.
*/
errmsg = eraseandformatblock(lb, i, trace);
if(errmsg)
goto error;
}
else if(d == LogfsBootGenMask) {
/* rm is newer */
errmsg = eraseandformatblock(lb, rm, trace);
if(errmsg)
goto error;
reversemap[ipath.path] = i;
}
else {
errmsg = Ecorrupt;
goto error;
}
}
}
else
reversemap[ipath.path] = i;
}
/*
* final checks; not partial blocks, and no holes
*/
for(i = 0; i <= bootblockmax; i++) {
long rm;
rm = reversemap[i];
if(rm == -1) {
if(printbad)
print("logfsbootopen: missing boot block %ld\n", i);
errmsg = Ecorrupt;
goto error;
}
if((*ll->getblockpartialformatstatus)(ll, rm)) {
if(printbad)
print("logfsbootopen: boot block %ld partially written\n", rm);
errmsg = Ecorrupt;
goto error;
}
}
/* the reverse map is consistent */
lb = logfsrealloc(nil, sizeof(*lb));
if(lb == nil) {
errmsg = Enomem;
goto error;
}
lb->blocksize = blocksize;
lb->bootblocks = bootblockmax + 1;
lb->map = reversemap;
lb->trace = trace;
lb->printbad = printbad;
lb->ll = ll;
lb->size = blocksize * lb->bootblocks;
// lb->bootgenshift = bootgenshift;
// lb->bootpathmask = bootpathmask;
*lbp = lb;
if(trace)
print("logfsbootopen: success\n");
return nil;
error:
logfsfreemem(reversemap);
logfsfreemem(lb);
return errmsg;
}
void
logfsbootfree(LogfsBoot *lb)
{
if(lb) {
logfsfreemem(lb->map);
logfsfreemem(lb);
}
}
char *
logfsbootmap(LogfsBoot *lb, ulong laddress, ulong *lblockp, int *lboffsetp, int *lpagep, int *lpageoffsetp, ulong *pblockp, ulong *paddressp)
{
LogfsLowLevel *ll = lb->ll;
ulong lblock;
ulong lboffset, lpageoffset, lpage;
ulong pblock;
ulong paddress;
lblock = laddress / lb->blocksize;
if(lblock >= lb->bootblocks)
return Eaddress;
lboffset = laddress % lb->blocksize;
pblock = lb->map[lblock];
paddress = (*ll->calcrawaddress)(ll, pblock, lboffset);
lpage = lboffset >> ll->l2pagesize;
lpageoffset = lboffset & ((1 << ll->l2pagesize) - 1);
if(lblockp)
*lblockp = lblock;
if(lboffsetp)
*lboffsetp = lboffset;
if(lpagep)
*lpagep = lpage;
if(lpageoffsetp)
*lpageoffsetp = lpageoffset;
if(pblockp)
*pblockp = pblock;
if(paddressp)
*paddressp = paddress;
return nil;
}
long
logfsbootgetiosize(LogfsBoot *lb)
{
return lb->blocksize;
}
long
logfsbootgetsize(LogfsBoot *lb)
{
return lb->size;
}
void
logfsboottrace(LogfsBoot *lb, int level)
{
lb->trace = level;
}