20060303a

1 files changed, 496 insertions, 0 deletions

diff --git a/liblogfs/boot.c b/liblogfs/boot.c
new file mode 100644
index 00000000..201f3307
--- /dev/null
+++ b/liblogfs/boot.c
@@ -0,0 +1,496 @@
+#include "lib9.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;
+}