inferno-os/liblogfs/log.c

#include "logfsos.h"
#include "logfs.h"
#include "local.h"
#include "fcall.h"

void
logfsflashaddr2spo(LogfsServer *server, u32int flashaddr, long *seq, int *page, int *offset)
{
	LogfsLowLevel *ll = server->ll;
	flashaddr &= ~LogAddr;
	*offset = flashaddr & ((1 << ll->l2pagesize) - 1);
	flashaddr >>= ll->l2pagesize;
	*page = flashaddr & ((1 << ll->l2pagesperblock) - 1);
	flashaddr >>= ll->l2pagesperblock;
	*seq = flashaddr;
}

u32int
logfsspo2flashaddr(LogfsServer *server, long seq, int page, int offset)
{
//print("logfsspo2flashaddr(%ld, %d, %d)\n", seq, page, offset);
	return (((seq << server->ll->l2pagesperblock) + page) << server->ll->l2pagesize) + offset;
}

void
logfsflashaddr2o(LogfsServer *server, u32int flashaddr, int *offset)
{
	LogfsLowLevel *ll = server->ll;
	flashaddr &= ~LogAddr;
	*offset = flashaddr & ((1 << ll->l2pagesize) - 1);
}

char *
logfslogsegmentnew(LogfsServer *server, int gen, LogSegment **segp)
{
	LogSegment *seg;
	seg = logfsrealloc(nil, sizeof(LogSegment) + (server->ll->blocks - 1) * sizeof(long));
	if(seg == nil)
		return Enomem;
	seg->pagebuf = logfsrealloc(nil, 1 << server->ll->l2pagesize);
	if(seg->pagebuf == nil) {
		logfsfreemem(seg);
		return Enomem;
	}
	seg->curpage = -1;
	seg->curblockindex = -1;
	seg->gen = gen;
	*segp = seg;
	return nil;
}

void
logfslogsegmentfree(LogSegment **segp)
{
	LogSegment *seg = *segp;
	if(seg) {
		logfsfreemem(seg->pagebuf);
		logfsfreemem(seg);
		*segp = nil;
	}
}

char *
logfslogsegmentflush(LogfsServer *server, int active)
{
	LogSegment *seg;
	seg = active ? server->activelog : server->sweptlog;
	if(seg == nil)
		return nil;
	if(seg->curpage >= 0 && seg->nbytes) {
		char *errmsg;
		LogfsLowLevel *ll = server->ll;
		int pagesize = 1 << ll->l2pagesize;
//print("curblockindex %ld curpage %d nbytes %d\n", seg->curblockindex, seg->curpage, seg->nbytes);
		if(seg->nbytes < pagesize)
			seg->pagebuf[seg->nbytes++] = LogfsLogTend;
		memset(seg->pagebuf + seg->nbytes, 0xff, pagesize - seg->nbytes);
		for(;;) {
			errmsg = (*ll->writepage)(ll, seg->pagebuf,
				seg->blockmap[seg->curblockindex], seg->curpage);
			if(errmsg == nil)
				break;
			if(strcmp(errmsg, Eio) != 0)
				return errmsg;
			errmsg = logfsserverreplacelogblock(server, seg, seg->curblockindex);
			if(errmsg)
				return errmsg;
		}
		seg->curpage++;
		if(seg->curpage == (1 << ll->l2pagesperblock))
			seg->curpage = -1;
		seg->nbytes = 0;
	}
	return nil;
}

static char *
logspace(LogfsServer *server, int active, int takearisk, int nbytes, uchar **where, u32int *flashaddr)
{
	char *errmsg;
	LogfsLowLevel *ll = server->ll;
	int pagesize = 1 << ll->l2pagesize;
	LogSegment *seg;

	if(nbytes > pagesize)
		return logfselogmsgtoobig;
retry:
	seg = active ? server->activelog : server->sweptlog;
	for(;;) {
//print("curpage %d nbytes %d\n", seg->curpage, seg->nbytes);
		if(seg->curpage >= 0) {
			if(seg->nbytes + nbytes < pagesize)
				break;
			errmsg = logfslogsegmentflush(server, active);
			if(errmsg)
				return errmsg;
		}
		if(seg->curpage < 0) {
			long block;
			long path;
			block = logfsfindfreeblock(ll,
				active ? (takearisk ? AllocReasonLogExtend : AllocReasonDataExtend) : AllocReasonTransfer);
			if(block < 0) {
				if(active) {
					int didsomething;
					errmsg = logfsserverlogsweep(server, 0, &didsomething);
					if(errmsg)
						return errmsg;
					if(didsomething)
						goto retry;
				}
				return logfselogfull;
			}
			seg->blockmap[++seg->curblockindex] = block;
			path = mklogpath(seg->curblockindex, seg->gen, 0);
			(*ll->setblocktag)(ll, block, LogfsTlog);
			(*ll->setblockpath)(ll, block, path);
			seg->curpage = 0;
#ifdef FUTURE
			/* TODO - do we need one of these if the underlying system supports erase counting? */
			seg->pagebuf[0] = LogfsLogTstart;
			PBIT16(seg->pagebuf + 1, 8);
			PBIT32(seg->pagebuf + 3, path);	/* TODO duplicate information */
			PBIT32(seg->pagebuf + 7, 0);		/* TODO don't have this - discuss with forsyth */
			seg->nbytes = 11;
#else
			seg->nbytes = 0;
#endif
		}
	}
	*where = seg->pagebuf + seg->nbytes;
	if(flashaddr)
		*flashaddr = logfsspo2flashaddr(server, seg->curblockindex, seg->curpage, seg->nbytes);
	seg->nbytes += nbytes;
	return nil;
}

static void
logdirty(LogfsServer *server, int active)
{
	if(active)
		server->activelog->dirty = 1;
	else
		server->sweptlog->dirty = 1;
}

char *
logfslogbytes(LogfsServer *server, int active, uchar *msg, uint size)
{
	char *errmsg;
	uchar *p;

	errmsg = logspace(server, active, 0, size, &p, nil);
	if(errmsg)
		return errmsg;
	memmove(p, msg, size);
	logdirty(server, active);
	return nil;
}

char *
logfslog(LogfsServer *server, int active, LogMessage *s)
{
	uint size = logfssizeS2M(s);
	char *errmsg;
	uchar *p;
	int takearisk;

	if(server->trace > 1) {
		print("%c<< ", active ? 'A' : 'S');
		logfsdumpS(s);
		print("\n");
	}
	if(active) {
		switch(s->type) {
		case LogfsLogTremove:
		case LogfsLogTtrunc:
			takearisk = 1;
			break;
		default:
			takearisk = 0;
		}
	}
	else
		takearisk = 0;
	errmsg = logspace(server, active, takearisk, size, &p, nil);
	if(errmsg)
		return errmsg;
	if(logfsconvS2M(s, p, size) != size)
		return "bad conversion";
	logdirty(server, active);
	return nil;
}

int
lognicesizeforwrite(LogfsServer *server, int active, u32int count, int muidlen)
{
	int rawspace;
	LogSegment *seg;
	if(count > LogDataLimit)
		return 0;
	seg = active ? server->activelog : server->sweptlog;
	if(seg->curpage < 0)
		return LogDataLimit;
	rawspace = (1 << server->ll->l2pagesize) - seg->nbytes;
	if(rawspace < 5 * 4 + 2 + muidlen + 1)
		return LogDataLimit;
	return 5 * 4 + 2 + muidlen - rawspace;
}

char *
logfslogwrite(LogfsServer *server, int active, u32int path, u32int offset, int count, u32int mtime, u32int cvers,
	char *muid, uchar *data, u32int *flashaddr)
{
	/* 'w' size[2] path[4] offset[4] count[2] mtime[4] cvers[4] muid[s] flashaddr[4] [data[n]] */
	LogMessage s;
	uint size;
	char *errmsg;
	uchar *p;
	u32int faddr;
	uint asize;

	s.type = LogfsLogTwrite;
	s.path = path;
	s.u.write.offset = offset;
	s.u.write.count = count;
	s.u.write.mtime = mtime;
	s.u.write.cvers = cvers;
	s.u.write.muid = muid;
	s.u.write.data = data;
	size = logfssizeS2M(&s);
	errmsg = logspace(server, active, 0, size, &p, &faddr);
	if(errmsg)
		return errmsg;
	if(data)
		*flashaddr = (faddr + size - count) | LogAddr;
	s.u.write.flashaddr = *flashaddr;
	if(server->trace > 1) {
		print("%c<< ", active ? 'A' : 'S');
		logfsdumpS(&s);
		print("\n");
	}
	if((asize = logfsconvS2M(&s, p, size)) != size) {
		print("expected %d actual %d\n", size, asize);
		return "bad conversion";
	}
	logdirty(server, active);
	return nil;
}