20060303a

1 files changed, 253 insertions, 0 deletions

diff --git a/liblogfs/read.c b/liblogfs/read.c
new file mode 100644
index 00000000..e97a934f
--- /dev/null
+++ b/liblogfs/read.c
@@ -0,0 +1,253 @@
+#include "lib9.h"
+#include "logfs.h"
+#include "local.h"
+#include "fcall.h"
+
+struct DirReadState {
+	u32int offset;
+	u32int lastoffset;
+	u32int limit;
+	uchar *data;
+};
+
+typedef struct ReaderState {
+	uchar *buf;
+	u32int maxoffset;
+	LogfsServer *server;
+	char *errmsg;
+} ReaderState;
+
+static DirReadState *
+drsinit(LogfsIdentityStore *is, Entry *list, uchar *buf, u32int buflen, u32int *rcount)
+{
+	Entry *p, *q;
+	DirReadState *drs;
+	u32int k;
+	/*
+	 * stash as many entries as will fit in the read buffer
+	 */
+	*rcount = 0;
+	for(p = list; p; p = p->next) {
+		uint len = logfsflattenentry(is, buf, buflen, p);
+		if(len == 0)
+			break;
+		*rcount += len;
+		buf += len;
+		buflen -= len;
+	}
+	drs = logfsrealloc(nil, sizeof(*drs));
+	if(drs == nil)
+		return nil;
+	drs->offset = *rcount;
+	drs->lastoffset = drs->offset;
+	k = 0;
+	for(q = p; q; q = q->next)
+		k += logfsflattenentry(is, nil, 0, q);
+	if(k) {
+		u32int k2;
+//		print("drsinit: %ud bytes extra\n", k);
+		drs->data = logfsrealloc(nil, k);
+		if(drs->data == nil) {
+			logfsfreemem(drs);
+			return nil;
+		}
+		k2 = 0;
+		for(q = p; q; q = q->next)
+			k2 += logfsflattenentry(is, drs->data + k2, k - k2, q);
+		drs->limit = drs->offset + k;
+	}
+//	print("drsinit: rcount %ud\n", *rcount);
+	return drs;
+}
+
+static void
+drsread(DirReadState *drs, uchar *buf, u32int buflen, u32int *rcount)
+{
+	uchar *p;
+	*rcount = 0;
+	p = drs->data + drs->lastoffset - drs->offset;
+	while(drs->lastoffset < drs->limit) {
+		/*
+		 * copy an entry, if it fits
+		 */
+		uint len = GBIT16(p) + BIT16SZ;
+		if(len > buflen)
+			break;
+		memcpy(buf, p, len);
+		drs->lastoffset += len;
+		*rcount += len;
+		buf += len;
+		buflen -= len;
+		p += len;
+	}
+	if(drs->lastoffset >= drs->limit) {
+		logfsfreemem(drs->data);
+		drs->data = nil;
+	}
+}
+
+void
+logfsdrsfree(DirReadState **drsp)
+{
+	DirReadState *drs = *drsp;
+	if(drs) {
+		logfsfreemem(drs->data);
+		logfsfreemem(drs);
+		*drsp = nil;
+	}
+}
+
+static int
+reader(void *magic, u32int baseoffset, u32int limitoffset, Extent *e, u32int extentoffset)
+{
+	ReaderState *s = magic;
+	LogfsServer *server;
+	LogfsLowLevel *ll;
+	LogfsLowLevelReadResult llrr;
+	long seq;
+	int page;
+	int offset;
+	long block;
+	int pagesize;
+	LogSegment *seg;
+	int replace;
+
+	if(e == nil) {
+//print("fill(%d, %d)\n", baseoffset, limitoffset);
+		memset(s->buf + baseoffset, 0, limitoffset - baseoffset);
+		if(limitoffset > s->maxoffset)
+			s->maxoffset = limitoffset;
+		return 1;
+	}
+	server = s->server;
+	ll = server->ll;
+	/*
+	 * extentoffset is how much to trim off the front of the extent
+	 */
+	logfsflashaddr2spo(server, e->flashaddr + extentoffset, &seq, &page, &offset);
+	/*
+	 * offset is the offset within the page to where e->min is stored
+	 */
+//print("read(%d, %d, %c%ld/%ud/%ud)\n",
+//	baseoffset, limitoffset, (e->flashaddr & LogAddr) ? 'L' :  'D', seq, page, offset);
+	if(e->flashaddr & LogAddr) {
+		if(seq >= server->activelog->unsweptblockindex && seq <= server->activelog->curblockindex)
+			seg = server->activelog;
+		else if(server->sweptlog && seq <= server->sweptlog->curblockindex)
+			seg = server->sweptlog;
+		else {
+			print("logfsserverread: illegal log sequence number %ld (active=[%ld, %ld], swept=[%ld, %ld])\n",
+				seq, server->activelog->unsweptblockindex, server->activelog->curblockindex,
+				server->sweptlog ? 0L : -1L, server->sweptlog ? server->sweptlog->curblockindex : -1L);
+			s->errmsg = logfseinternal;
+			return -1;
+		}
+		if(seg->curpage == page && seg->curblockindex == seq) {
+			/*
+			 * it hasn't made it to disk yet
+			 */
+			memcpy(s->buf + baseoffset, seg->pagebuf + offset, limitoffset - baseoffset);
+			goto done;
+		}
+		if(seq < seg->unsweptblockindex) {
+			/* data already swept */
+			print("logfsserverread: log address has been swept\n");
+			s->errmsg = logfseinternal;
+			return -1;
+		}
+		block = seg->blockmap[seq];
+	}
+	else {
+		seg = nil;
+		if(seq >= server->ndatablocks)
+			block = -1;
+		else
+			block = server->datablock[seq].block;
+		if(block < 0) {
+			print("logfsserveread: data address does not exist\n");
+			s->errmsg = logfseinternal;
+			return -1;
+		}
+	}
+	/*
+	 * read as many pages as necessary to get to the limitoffset
+	 */
+	pagesize = 1 << ll->l2pagesize;
+	replace = 0;
+	while(baseoffset < limitoffset) {
+		u32int thistime;
+		thistime = pagesize - offset;
+		if(thistime > (limitoffset - baseoffset))
+			thistime = limitoffset - baseoffset;
+		s->errmsg = (*ll->readpagerange)(ll, s->buf + baseoffset, block, page,
+			offset, thistime, &llrr);
+		if(s->errmsg)
+			return -1;
+		if(llrr != LogfsLowLevelReadResultOk) {
+			replace = 1;
+		}
+		baseoffset += thistime;
+		page++;
+		offset = 0;
+	}
+	if(replace) {
+		s->errmsg = logfsserverreplaceblock(server, seg, seq);
+		if(s->errmsg)
+			return -1;
+	}
+done:
+	if(limitoffset > s->maxoffset)
+		s->maxoffset = limitoffset;
+	return 1;
+}
+
+char *
+logfsserverread(LogfsServer *server, u32int fid, u32int offset, u32int count, uchar *buf, u32int buflen, u32int *rcount)
+{
+	Fid *f;
+	Entry *e;
+	ReaderState s;
+	int rv;
+
+	if(server->trace > 1)
+		print("logfsserverread(%ud, %ud, %ud)\n", fid, offset, count);
+	f = logfsfidmapfindentry(server->fidmap, fid);
+	if(f == nil)
+		return logfsebadfid;
+	if(f->openmode < 0)
+		return logfsefidnotopen;
+	if((f->openmode & 3) == OWRITE)
+		return logfseaccess;
+	if(count > buflen)
+		return Etoobig;
+	e = f->entry;
+	if(e->deadandgone)
+		return Eio;
+	if(e->qid.type & QTDIR) {
+		if(offset != 0) {
+			if(f->drs == nil || f->drs->lastoffset != offset)
+				return Eio;
+			drsread(f->drs, buf, count, rcount);
+		}
+		else {
+			logfsdrsfree(&f->drs);
+			f->drs = drsinit(server->is, e->u.dir.list, buf, count, rcount);
+			if(f->drs == nil)
+				return Enomem;
+		}
+		return nil;
+	}
+	if(offset >= e->u.file.length) {
+		*rcount = 0;
+		return nil;
+	}
+	s.buf = buf;
+	s.server = server;
+	s.maxoffset = 0;
+	rv = logfsextentlistwalkrange(e->u.file.extent, reader, &s, offset, offset + count);
+	if(rv < 0)
+		return s.errmsg;
+	*rcount = s.maxoffset;
+	return nil;
+}
+