inferno-os/liblogfs/read.c

#include "logfsos.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;
		memmove(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
			 */
			memmove(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;
}