shithub: neoventi

Download patch

ref: 856790a4786cec575f3158b4faef98737a901e44
parent: 53f749d02ad4780eab161b856d49b84f54909bc1
author: Noam Preil <noam@pixelhero.dev>
date: Sun Dec 24 17:29:02 EST 2023 

further refactor


--- /dev/null
+++ b/disk.c
@@ -1,0 +1,380 @@
+#include <u.h>
+#include <libc.h>
+#include <bio.h>
+#include "neoventi.h"
+
+VtArena *arenas = nil;
+u32int numarenas = 0;
+
+VtISect
+isectforbucket(u32int buck)
+{
+	int r, l, m;
+
+	l = 1;
+	r = index.nsects - 1;
+	while(l <= r){
+		m = (r + l) >> 1;
+		if(index.sects[m].start <= buck)
+			l = m + 1;
+		else
+			r = m - 1;
+	}
+	return index.sects[l - 1];
+}
+
+static int
+bucketlookup(u8int *bucket, u16int nb, u8int *score, u16int *entry)
+{
+	for(*entry = 0; *entry <= nb; *entry += 1){
+		if(memcmp(&bucket[*entry * IEntrySize], score, 20) == 0)
+			return 1;
+	}
+	return 0;
+}
+
+static VtArena
+arenafromindex(u64int aindex)
+{
+	u64int i;
+	for(i = 0; i < numarenas; i += 1){
+		if(strcmp(arenas[i].name, index.amap[aindex].name) == 0)
+			return arenas[i];
+	}
+	sysfatal("arena not found");
+	return arenas[0];
+}
+
+static u64int
+aindexfromaddr(u64int addr)
+{
+	u64int a;
+	for(a = 0; a < index.namap; a += 1)
+		if(addr >= index.amap[a].start && addr < index.amap[a].stop)
+			return a;
+	sysfatal("internal corruption: arena not found for arenaindex");
+	return 0;
+}
+
+int
+vtreadlookup(u8int *score, VtArena *arena, u64int *addr, u16int *size, u8int *blocks)
+{
+	u8int *buf;
+	u16int bentries;
+	u64int bucket = U32GET(score) / index.div;
+	u16int entry;
+	u64int aindex;
+	VtISect sect = isectforbucket(bucket);
+	bucket -= sect.start;
+	buf = malloc(sect.blocksize);
+	if(buf == nil)
+		sysfatal("OOM");
+	if(pread(sect.fd, (char*)buf, sect.blocksize, sect.blockbase + (bucket << sect.blocklog)) != sect.blocksize)
+		sysfatal("Failed to read bucket");
+	bentries = U16GET(buf);
+	if(sect.bucketmagic && U32GET(buf + 2) != sect.bucketmagic)
+		sysfatal("index is corrupt: invalid bucket magic: sect %lux, buck %lux", sect.bucketmagic, U32GET(buf + 2));
+	if(!bucketlookup(buf + 6, bentries, score, &entry))
+		sysfatal("entry not found in bucket");
+	*addr = U64GET((buf + 6 + (entry * IEntrySize) + 26));
+	*size = U16GET((buf + 6 + (entry * IEntrySize) + 34));
+	*blocks = buf[6 + (entry*IEntrySize) + 37];
+	aindex = aindexfromaddr(*addr);
+	*arena = arenafromindex(aindex);
+	*addr -= index.amap[aindex].start;
+	free(buf);
+	return 1;
+}
+
+static u64int
+arenadirsize(VtArena arena)
+{
+	return ((arena.memstats.clumps / (arena.blocksize / 25)) + 1) * arena.blocksize;
+}
+
+static void
+vtreadarena(VtArena arena, u64int addr, uchar *dbuf, u16int *size)
+{
+	u64int end = arena.size - arenadirsize(arena);
+	char *buf = malloc(arena.blocksize);
+	u16int off, n, m;
+	if(addr + *size > end)
+		*size = end - addr;
+	addr += arena.base;
+	off = addr & (arena.blocksize-1);
+	addr -= off;
+	n = 0;
+	while(n < *size){
+		// Read the next block
+		if(pread(arena.fd, buf, arena.blocksize, addr) != arena.blocksize)
+			sysfatal("pread failed!");
+		m = arena.blocksize - off;
+		if(m > *size - n)
+			m = *size - n;
+		memmove(&dbuf[n], &buf[off], m);
+		n += m;
+		off = 0;
+		addr += arena.blocksize;
+	}
+}
+
+int
+readclump(uchar *dst, VtArena arena, u64int addr, u8int blocks)
+{
+	uchar *buf = malloc(blocks << ABlockLog);
+	u32int magic;
+	u16int size;
+	size = blocks<<ABlockLog;
+	vtreadarena(arena, addr, buf, &size);
+	size = U16GET(buf+7);
+	if(buf[29] == 2){
+		if(unwhack(dst, size, buf+38, U16GET(buf+5)) != size)
+			sysfatal("decompression failed: %r");
+	} else if(buf[29] == 1)
+		memcpy(dst, buf+38, size);
+	free(buf);
+	return 1;
+}
+
+static int
+parsemap(Biobufhdr *b, MapEntry **map, u32int *nmap)
+{
+	u32int i;
+	char *s;
+	char *fields[4];
+	if(!Brdu32(b, nmap))
+		return 0;
+	if(*nmap > MaxAMap)
+		return 0;
+	*map = realloc(*map, *nmap * sizeof(MapEntry));
+	for(i = 0; i < *nmap; i += 1){
+		s = Brdline(b, '\n');
+		if(getfields(s, fields, 3, 0, "\t") != 3)
+			sysfatal("corrupt index map: %s", s);
+		memcpy((*map)[i].name, fields[0], NameSize);
+		(*map)[i].name[NameSize-1] = 0;
+		if(stru64int(fields[1], &(*map)[i].start) < 0)
+			sysfatal("corrupt index map: %s", fields[1]);
+		if(stru64int(fields[2], &(*map)[i].stop) < 0)
+			sysfatal("corrupt index map: %s", fields[2]);
+	}
+	return 1;
+}
+
+static int
+partopen(char *path, u64int *size)
+{
+	Dir *dir;
+	int fd;
+	fd = open(path, OREAD);
+	if(fd < 0)
+		return fd;
+	dir = dirfstat(fd);
+	if(dir == nil || dir->length == 0)
+		sysfatal("cannot determine size of partition '%s'", path);
+	*size = dir->length;
+	free(dir);
+	return fd;
+}
+
+static u64int
+partlen(int fd, char *path)
+{
+	Dir *dir = dirfstat(fd);
+	u64int len;
+	if(dir == nil)
+		sysfatal("Cannot stat partition %s", path);
+	if(dir->length == 0)
+		sysfatal("can't determine size of partition %s", path);
+	len = dir->length;
+	free(dir);
+	return len;
+}
+
+static void
+loadarena(VtArena *arena)
+{
+	u32int magic, version;
+	char *buf = malloc(arena->blocksize);
+	u8int *p = (void*)buf;
+	if(pread(arena->fd, buf, arena->blocksize, arena->base + arena->size) != arena->blocksize)
+		sysfatal("failed to pread");
+	magic = U32GET(p);
+	version = U32GET(p + 4);
+	if(strncmp(arena->name, buf + 8, strlen(arena->name)) != 0)
+		sysfatal("arena name mismatch: %s vs %s, ver %d", arena->name, buf + 8, version);
+	
+}
+
+// FIXME see initarenapart and initarena/loadarena in venti/venti
+
+static void
+initarena(VtArena *arena, int fd, MapEntry entry, u32int blocksize)
+{
+	arena->fd = fd;
+	arena->blocksize = blocksize;
+	arena->clumpmax = blocksize / ClumpInfoSize;
+	arena->base = entry.start + blocksize;
+	arena->size = entry.stop - entry.start - 2*blocksize;
+	memcpy(arena->name, entry.name, NameSize);
+	loadarena(arena);
+}
+
+static void
+readarenatable(int fd, u32int tabbase, u32int tabsize, char *path, u32int blocksize)
+{
+	Biobufhdr bio;
+	char *buf;
+	MapEntry *map = nil;
+	u32int nmap;
+	buf = malloc(tabsize);
+	if(buf == nil)
+		sysfatal("oom; you're a loser: %r");
+	if(Binits(&bio, fd, OREAD, (uchar*)buf, tabsize))
+		sysfatal("failed to init biobuf: %r");
+	if(Bseek(&bio, tabbase, 0) != tabbase)
+		sysfatal("seek failed: %r");
+	parsemap(&bio, &map, &nmap);
+	arenas = realloc(arenas, sizeof(VtArena) * (nmap + numarenas));
+	if(!arenas)
+		sysfatal("oom");
+	for(; nmap > 0; nmap -= 1)
+		initarena(&arenas[numarenas++], fd, map[nmap-1], blocksize);
+	free(map);
+}
+
+static void
+initarenapart(char *path)
+{
+	u32int version, magic, blocksize, arenabase, tabbase, tabsize;
+	u64int size;
+	char buf[HeadSize];
+	u8int *p = (void*)buf;
+	MapEntry *map;
+	u32int nmap;
+	int fd;
+	
+	if((fd = open(path, OREAD)) < 0)
+		sysfatal("failed to open arena %s: %r", path);
+	if(pread(fd, buf, HeadSize, PartBlank) != HeadSize)
+		sysfatal("failed to read arena header table: %r");
+	magic = U32GET(p);
+	version = U32GET(p + 4);
+	blocksize = U32GET(p + 8);
+	arenabase = U32GET(p + 12);
+	if(magic != ArenaPartMagic)
+		sysfatal("bad arena partition magic number: %#ux expected ArenaPartMagic (%#ux)", magic, ArenaPartMagic);
+	if(version != 3)
+		sysfatal("bad arena partition version: only 3 is supported, found %d", version);
+	if(blocksize & (blocksize - 1))
+		sysfatal("invalid block size: %d is not a power of two", blocksize);
+	/* Head is not perfectly aligned; table must be aligned as first block */
+	tabbase = (PartBlank + HeadSize + blocksize - 1) & ~(blocksize - 1);
+	if(tabbase >= arenabase)
+		sysfatal("arena partition table overlaps with storage");
+	tabsize = arenabase - tabbase;
+	size = partlen(fd, path) & ~(u64int)(blocksize - 1);
+	
+	readarenatable(fd, tabbase, tabsize, path, blocksize);
+}
+
+void
+initarenas(void)
+{
+	initarenapart("/dev/" MACHINE "/arenas");
+}
+
+static void
+initisectpart(char *path)
+{
+	u32int magic;
+	char buf[HeadSize];
+	u8int *p = (void*)buf;
+
+	index.sects = realloc(index.sects, sizeof(VtISect) * (index.nsects + 1));
+	VtISect *sect = &index.sects[index.nsects++];
+	
+	if((sect->fd = open(path, OREAD)) < 0)
+		sysfatal("failed to open index section");
+	if(pread(sect->fd, buf, HeadSize, PartBlank) != HeadSize)
+		sysfatal("failed to read index section header");
+	magic = U32GET(p);
+	sect->version = U32GET(p + 4);
+	memcpy(sect->name, buf + 8, NameSize);
+	memcpy(sect->index, buf + 8 + NameSize, NameSize);
+	sect->blocksize = U32GET(p + 8 + 2*NameSize);
+	sect->blockbase = U32GET(p + 12 + 2*NameSize);
+	sect->blocks = U32GET(p + 16 + 2 * NameSize);
+	sect->start = U32GET(p + 20 + 2 * NameSize);
+	sect->stop = U32GET(p + 24 + 2 * NameSize);
+	sect->index[NameSize-1] = 0;
+	sect->name[NameSize-1] = 0;
+	sect->bucketmagic = 0;
+	if(magic != ISectMagic)
+		sysfatal("invalid / corrupt index section");
+	if(sect->version == 2)
+		sect->bucketmagic = U32GET(p + 28 + 2*NameSize);
+	else if(sect->version != 1)
+		sysfatal("unrecognized index section version %d; only 1 and 2 are supported", sect->version);
+	sect->buckmax = (sect->blocksize - IBucketSize) / IEntrySize;
+	sect->blocklog = u64log2(sect->blocksize);
+	if(sect->blocksize != (1 << sect->blocklog))
+		sysfatal("Illegal or corrupt index section");
+	sect->tabbase = (PartBlank + HeadSize + sect->blocksize - 1) & ~(sect->blocksize - 1);
+	if(sect->tabbase >= sect->blockbase)
+		sysfatal("illegal or corrupt index section: config table overlaps bucket store");
+	sect->tabsize = sect->blockbase - sect->tabbase;
+	if(sect->blockbase + (u64int)sect->blocks * sect->blocksize != partlen(sect->fd, path) & ~(u64int)(sect->blocksize - 1))
+		sysfatal("invalid or corrupt index section header: invalid blocks");
+	if(sect->stop - sect->start > sect->blocks)
+		sysfatal("invalid or corrupt index section: section overflows available space");
+	if(sect->stop < sect->start)
+		sysfatal("invalid or corrupt index section: impossible range");
+}
+
+static void
+parseindex(void)
+{
+	/* parse the index header from the first section */
+	u32int version;
+	int i;
+	Biobufhdr bio;
+	char *buf = malloc(index.sects[0].tabsize);
+	char *line;
+	if(Binits(&bio, index.sects[0].fd, OREAD, (uchar*)buf, index.sects[0].tabsize))
+		sysfatal("failed to init biobuf: %r");
+	if(Bseek(&bio, index.sects[0].tabbase, 0) != index.sects[0].tabbase)
+		sysfatal("seek failed: %r");
+	line = Brdline(&bio, '\n');
+	if(memcmp(line, "venti index configuration", 25) != 0)
+		sysfatal("invalid magic found in index header");
+	if(!Brdu32(&bio, &version) || version != 1)
+		sysfatal("failed to read version or version unsupported");
+	line = Brdline(&bio, '\n');
+	if(Blinelen(&bio) >= NameSize)
+		sysfatal("invalid or corrupt index: name too big");
+	if(memcmp(line, index.sects[0].index, strlen(index.sects[0].index)) != 0)
+		sysfatal("invalid or corrupt index: index/section mismatch");
+	if(!Brdu32(&bio, &index.blocksize))
+		sysfatal("invalid or corrupt index: failed to read blocksize");
+	/* Section map, then arena map; see parseamap */
+	/* Parse both maps, overwrite the section map; we don't need it */
+	parsemap(&bio, &index.amap, &index.namap);
+	parsemap(&bio, &index.amap, &index.namap);
+	/* Validation code here */
+	for(i = 0; i < index.nsects; i += 1){
+		/* TODO validate section */
+		index.buckets = index.sects[i].stop;
+	}
+	index.div = (((u64int)1<<32)+index.buckets-1) / index.buckets;
+	if((((u64int)1 << 32) - 1) / index.div + 1 != index.buckets)
+		sysfatal("corrupt index: divisor and buckets inconsistent");
+	/* Lastly, maparenas */
+}
+
+void
+initindex(void)
+{
+	initisectpart("/dev/" MACHINE "/isect");
+	parseindex();
+}
--- a/main.c
+++ b/main.c
@@ -1,12 +1,8 @@
 #include <u.h>
 #include <libc.h>
 #include <bio.h>
-
 #include "neoventi.h"
 
-VtArena *arenas = nil;
-u32int numarenas = 0;
-
 void
 parseargs(int argc, char **argv)
 {
@@ -15,252 +11,9 @@
 		sysfatal("TODO arg parsing");
 }
 
-static int
-parsemap(Biobufhdr *b, MapEntry **map, u32int *nmap)
-{
-	u32int i;
-	char *s;
-	char *fields[4];
-	if(!Brdu32(b, nmap))
-		return 0;
-	if(*nmap > MaxAMap)
-		return 0;
-	*map = realloc(*map, *nmap * sizeof(MapEntry));
-	for(i = 0; i < *nmap; i += 1){
-		s = Brdline(b, '\n');
-		if(getfields(s, fields, 3, 0, "\t") != 3)
-			sysfatal("corrupt index map: %s", s);
-		memcpy((*map)[i].name, fields[0], NameSize);
-		(*map)[i].name[NameSize-1] = 0;
-		if(stru64int(fields[1], &(*map)[i].start) < 0)
-			sysfatal("corrupt index map: %s", fields[1]);
-		if(stru64int(fields[2], &(*map)[i].stop) < 0)
-			sysfatal("corrupt index map: %s", fields[2]);
-	}
-	return 1;
-}
-
-static int
-partopen(char *path, u64int *size)
-{
-	Dir *dir;
-	int fd;
-	fd = open(path, OREAD);
-	if(fd < 0)
-		return fd;
-	dir = dirfstat(fd);
-	if(dir == nil || dir->length == 0)
-		sysfatal("cannot determine size of partition '%s'", path);
-	*size = dir->length;
-	free(dir);
-	return fd;
-}
-
-static u64int
-partlen(int fd, char *path)
-{
-	Dir *dir = dirfstat(fd);
-	u64int len;
-	if(dir == nil)
-		sysfatal("Cannot stat partition %s", path);
-	if(dir->length == 0)
-		sysfatal("can't determine size of partition %s", path);
-	len = dir->length;
-	free(dir);
-	return len;
-}
-
 static void
-loadarena(VtArena *arena)
-{
-	u32int magic, version;
-	char *buf = malloc(arena->blocksize);
-	u8int *p = (void*)buf;
-	if(pread(arena->fd, buf, arena->blocksize, arena->base + arena->size) != arena->blocksize)
-		sysfatal("failed to pread");
-	magic = U32GET(p);
-	version = U32GET(p + 4);
-	if(strncmp(arena->name, buf + 8, strlen(arena->name)) != 0)
-		sysfatal("arena name mismatch: %s vs %s, ver %d", arena->name, buf + 8, version);
-	
-}
-
-// FIXME see initarenapart and initarena/loadarena in venti/venti
-
-static void
-initarena(VtArena *arena, int fd, MapEntry entry, u32int blocksize)
-{
-	arena->fd = fd;
-	arena->blocksize = blocksize;
-	arena->clumpmax = blocksize / ClumpInfoSize;
-	arena->base = entry.start + blocksize;
-	arena->size = entry.stop - entry.start - 2*blocksize;
-	memcpy(arena->name, entry.name, NameSize);
-	loadarena(arena);
-}
-
-static void
-readarenatable(int fd, u32int tabbase, u32int tabsize, char *path, u32int blocksize)
-{
-	Biobufhdr bio;
-	char *buf;
-	MapEntry *map = nil;
-	u32int nmap;
-	buf = malloc(tabsize);
-	if(buf == nil)
-		sysfatal("oom; you're a loser: %r");
-	if(Binits(&bio, fd, OREAD, (uchar*)buf, tabsize))
-		sysfatal("failed to init biobuf: %r");
-	if(Bseek(&bio, tabbase, 0) != tabbase)
-		sysfatal("seek failed: %r");
-	parsemap(&bio, &map, &nmap);
-	arenas = realloc(arenas, sizeof(VtArena) * (nmap + numarenas));
-	if(!arenas)
-		sysfatal("oom");
-	for(; nmap > 0; nmap -= 1)
-		initarena(&arenas[numarenas++], fd, map[nmap-1], blocksize);
-	free(map);
-}
-
-static void
-initarenapart(char *path)
-{
-	u32int version, magic, blocksize, arenabase, tabbase, tabsize;
-	u64int size;
-	char buf[HeadSize];
-	u8int *p = (void*)buf;
-	MapEntry *map;
-	u32int nmap;
-	int fd;
-	
-	if((fd = open(path, OREAD)) < 0)
-		sysfatal("failed to open arena %s: %r", path);
-	if(pread(fd, buf, HeadSize, PartBlank) != HeadSize)
-		sysfatal("failed to read arena header table: %r");
-	magic = U32GET(p);
-	version = U32GET(p + 4);
-	blocksize = U32GET(p + 8);
-	arenabase = U32GET(p + 12);
-	if(magic != ArenaPartMagic)
-		sysfatal("bad arena partition magic number: %#ux expected ArenaPartMagic (%#ux)", magic, ArenaPartMagic);
-	if(version != 3)
-		sysfatal("bad arena partition version: only 3 is supported, found %d", version);
-	if(blocksize & (blocksize - 1))
-		sysfatal("invalid block size: %d is not a power of two", blocksize);
-	/* Head is not perfectly aligned; table must be aligned as first block */
-	tabbase = (PartBlank + HeadSize + blocksize - 1) & ~(blocksize - 1);
-	if(tabbase >= arenabase)
-		sysfatal("arena partition table overlaps with storage");
-	tabsize = arenabase - tabbase;
-	size = partlen(fd, path) & ~(u64int)(blocksize - 1);
-	
-	readarenatable(fd, tabbase, tabsize, path, blocksize);
-}
-
-static void
-initarenas(void)
-{
-	initarenapart("/dev/" MACHINE "/arenas");
-}
-
-static void
-initisectpart(char *path)
-{
-	u32int magic;
-	char buf[HeadSize];
-	u8int *p = (void*)buf;
-
-	index.sects = realloc(index.sects, sizeof(VtISect) * (index.nsects + 1));
-	VtISect *sect = &index.sects[index.nsects++];
-	
-	if((sect->fd = open(path, OREAD)) < 0)
-		sysfatal("failed to open index section");
-	if(pread(sect->fd, buf, HeadSize, PartBlank) != HeadSize)
-		sysfatal("failed to read index section header");
-	magic = U32GET(p);
-	sect->version = U32GET(p + 4);
-	memcpy(sect->name, buf + 8, NameSize);
-	memcpy(sect->index, buf + 8 + NameSize, NameSize);
-	sect->blocksize = U32GET(p + 8 + 2*NameSize);
-	sect->blockbase = U32GET(p + 12 + 2*NameSize);
-	sect->blocks = U32GET(p + 16 + 2 * NameSize);
-	sect->start = U32GET(p + 20 + 2 * NameSize);
-	sect->stop = U32GET(p + 24 + 2 * NameSize);
-	sect->index[NameSize-1] = 0;
-	sect->name[NameSize-1] = 0;
-	sect->bucketmagic = 0;
-	if(magic != ISectMagic)
-		sysfatal("invalid / corrupt index section");
-	if(sect->version == 2)
-		sect->bucketmagic = U32GET(p + 28 + 2*NameSize);
-	else if(sect->version != 1)
-		sysfatal("unrecognized index section version %d; only 1 and 2 are supported", sect->version);
-	sect->buckmax = (sect->blocksize - IBucketSize) / IEntrySize;
-	sect->blocklog = u64log2(sect->blocksize);
-	if(sect->blocksize != (1 << sect->blocklog))
-		sysfatal("Illegal or corrupt index section");
-	sect->tabbase = (PartBlank + HeadSize + sect->blocksize - 1) & ~(sect->blocksize - 1);
-	if(sect->tabbase >= sect->blockbase)
-		sysfatal("illegal or corrupt index section: config table overlaps bucket store");
-	sect->tabsize = sect->blockbase - sect->tabbase;
-	if(sect->blockbase + (u64int)sect->blocks * sect->blocksize != partlen(sect->fd, path) & ~(u64int)(sect->blocksize - 1))
-		sysfatal("invalid or corrupt index section header: invalid blocks");
-	if(sect->stop - sect->start > sect->blocks)
-		sysfatal("invalid or corrupt index section: section overflows available space");
-	if(sect->stop < sect->start)
-		sysfatal("invalid or corrupt index section: impossible range");
-}
-
-static void
-parseindex(void)
+init(void)
 {
-	/* parse the index header from the first section */
-	u32int version;
-	int i;
-	Biobufhdr bio;
-	char *buf = malloc(index.sects[0].tabsize);
-	char *line;
-	if(Binits(&bio, index.sects[0].fd, OREAD, (uchar*)buf, index.sects[0].tabsize))
-		sysfatal("failed to init biobuf: %r");
-	if(Bseek(&bio, index.sects[0].tabbase, 0) != index.sects[0].tabbase)
-		sysfatal("seek failed: %r");
-	line = Brdline(&bio, '\n');
-	if(memcmp(line, "venti index configuration", 25) != 0)
-		sysfatal("invalid magic found in index header");
-	if(!Brdu32(&bio, &version) || version != 1)
-		sysfatal("failed to read version or version unsupported");
-	line = Brdline(&bio, '\n');
-	if(Blinelen(&bio) >= NameSize)
-		sysfatal("invalid or corrupt index: name too big");
-	if(memcmp(line, index.sects[0].index, strlen(index.sects[0].index)) != 0)
-		sysfatal("invalid or corrupt index: index/section mismatch");
-	if(!Brdu32(&bio, &index.blocksize))
-		sysfatal("invalid or corrupt index: failed to read blocksize");
-	/* Section map, then arena map; see parseamap */
-	/* Parse both maps, overwrite the section map; we don't need it */
-	parsemap(&bio, &index.amap, &index.namap);
-	parsemap(&bio, &index.amap, &index.namap);
-	/* Validation code here */
-	for(i = 0; i < index.nsects; i += 1){
-		/* TODO validate section */
-		index.buckets = index.sects[i].stop;
-	}
-	index.div = (((u64int)1<<32)+index.buckets-1) / index.buckets;
-	if((((u64int)1 << 32) - 1) / index.div + 1 != index.buckets)
-		sysfatal("corrupt index: divisor and buckets inconsistent");
-	/* Lastly, maparenas */
-}
-
-static void
-initindex(void)
-{
-	initisectpart("/dev/" MACHINE "/isect");
-	parseindex();
-}
-
-static void
-init(void)
-{
 	initarenas();
 	initindex();
 }
@@ -269,189 +22,6 @@
 validate(void)
 {
 //	sysfatal("valid arenas are impossible.");
-}
-
-static void
-vtversion(VtConn conn)
-{
-	char c;
-	if(fprint(conn.fd, "venti-02-neoventi\n") == 18)
-		while(read(conn.fd, &c, 1) == 1)
-			if(c == '\n')
-				return;
-	fprint(conn.fd, "FUCK OFF\n");
-	close(conn.fd);
-	sysfatal("venti handshake failed: %r");
-}
-
-static int
-vtrecv(VtConn conn, char *buf)
-{
-	u16int len;
-	if(read(conn.fd, buf, 2) != 2){
-		werrstr("Failed to read message size: %r");
-		return 0;
-	}
-	len = (buf[0] << 8 | buf[1]);
-	if(read(conn.fd, buf + 2, len) != len){
-		werrstr("Failed to read message: %r");
-		return 0;
-	}
-	return 1;
-}
-
-VtISect
-isectforbucket(u32int buck)
-{
-	int r, l, m;
-
-	l = 1;
-	r = index.nsects - 1;
-	while(l <= r){
-		m = (r + l) >> 1;
-		if(index.sects[m].start <= buck)
-			l = m + 1;
-		else
-			r = m - 1;
-	}
-	return index.sects[l - 1];
-}
-
-static int
-bucketlookup(u8int *bucket, u16int nb, u8int *score, u16int *entry)
-{
-	for(*entry = 0; *entry <= nb; *entry += 1){
-		if(memcmp(&bucket[*entry * IEntrySize], score, 20) == 0)
-			return 1;
-	}
-	return 0;
-}
-
-static VtArena
-arenafromindex(u64int aindex)
-{
-	u64int i;
-	for(i = 0; i < numarenas; i += 1){
-		if(strcmp(arenas[i].name, index.amap[aindex].name) == 0)
-			return arenas[i];
-	}
-	sysfatal("arena not found");
-	return arenas[0];
-}
-
-static u64int
-aindexfromaddr(u64int addr)
-{
-	u64int a;
-	for(a = 0; a < index.namap; a += 1)
-		if(addr >= index.amap[a].start && addr < index.amap[a].stop)
-			return a;
-	sysfatal("internal corruption: arena not found for arenaindex");
-	return 0;
-}
-
-int
-vtreadlookup(u8int *score, VtArena *arena, u64int *addr, u16int *size, u8int *blocks)
-{
-	u8int *buf;
-	u16int bentries;
-	u64int bucket = U32GET(score) / index.div;
-	u16int entry;
-	u64int aindex;
-	VtISect sect = isectforbucket(bucket);
-	bucket -= sect.start;
-	buf = malloc(sect.blocksize);
-	if(buf == nil)
-		sysfatal("OOM");
-	if(pread(sect.fd, (char*)buf, sect.blocksize, sect.blockbase + (bucket << sect.blocklog)) != sect.blocksize)
-		sysfatal("Failed to read bucket");
-	bentries = U16GET(buf);
-	if(sect.bucketmagic && U32GET(buf + 2) != sect.bucketmagic)
-		sysfatal("index is corrupt: invalid bucket magic: sect %lux, buck %lux", sect.bucketmagic, U32GET(buf + 2));
-	if(!bucketlookup(buf + 6, bentries, score, &entry))
-		sysfatal("entry not found in bucket");
-	*addr = U64GET((buf + 6 + (entry * IEntrySize) + 26));
-	*size = U16GET((buf + 6 + (entry * IEntrySize) + 34));
-	*blocks = buf[6 + (entry*IEntrySize) + 37];
-	aindex = aindexfromaddr(*addr);
-	*arena = arenafromindex(aindex);
-	*addr -= index.amap[aindex].start;
-	free(buf);
-	return 1;
-}
-
-static u64int
-arenadirsize(VtArena arena)
-{
-	return ((arena.memstats.clumps / (arena.blocksize / 25)) + 1) * arena.blocksize;
-}
-
-static void
-vtreadarena(VtArena arena, u64int addr, uchar *dbuf, u16int *size)
-{
-	u64int end = arena.size - arenadirsize(arena);
-	char *buf = malloc(arena.blocksize);
-	u16int off, n, m;
-	if(addr + *size > end)
-		*size = end - addr;
-	addr += arena.base;
-	off = addr & (arena.blocksize-1);
-	addr -= off;
-	n = 0;
-	while(n < *size){
-		// Read the next block
-		if(pread(arena.fd, buf, arena.blocksize, addr) != arena.blocksize)
-			sysfatal("pread failed!");
-		m = arena.blocksize - off;
-		if(m > *size - n)
-			m = *size - n;
-		memmove(&dbuf[n], &buf[off], m);
-		n += m;
-		off = 0;
-		addr += arena.blocksize;
-	}
-}
-
-int
-readclump(uchar *dst, VtArena arena, u64int addr, u8int blocks)
-{
-	uchar *buf = malloc(blocks << ABlockLog);
-	u32int magic;
-	u16int size;
-	size = blocks<<ABlockLog;
-	vtreadarena(arena, addr, buf, &size);
-	size = U16GET(buf+7);
-	if(buf[29] == 2){
-		if(unwhack(dst, size, buf+38, U16GET(buf+5)) != size)
-			sysfatal("decompression failed: %r");
-	} else if(buf[29] == 1)
-		memcpy(dst, buf+38, size);
-	free(buf);
-	return 1;
-}
-
-static void
-vtread(VtConn conn, char *buf)
-{
-	u8int *score;
-	VtArena arena;
-	u64int addr;
-	u16int size;
-	u32int off;
-	u8int blocks;
-	uchar *dbuf;
-	score = (u8int*)buf + 4;
-	if(!vtreadlookup(score, &arena, &addr, &size, &blocks))
-		sysfatal("todo graceful read errors");
-	// Response: VtRread, msg tag, data
-	dbuf = malloc(4 + size);
-	dbuf[0] = (size+2)>>8;
-	dbuf[1] = (size+2) & 0xFF;
-	dbuf[2] = VtRread;
-	dbuf[3] = buf[3];
-	readclump(dbuf+4, arena, addr, blocks);
-	if(write(conn.fd, dbuf, size + 4) != size+4)
-		sysfatal("failed to write data");
 }
 
 void
--- a/mkfile
+++ b/mkfile
@@ -2,7 +2,7 @@
 
 TARG=neoventi
 BIN=/$objtype/bin
-OFILES=main.$O unwhack.$O server.$O util.$O
+OFILES=main.$O unwhack.$O server.$O util.$O disk.$O
 
 HFILES=\
 
--- a/neoventi.h
+++ b/neoventi.h
@@ -125,3 +125,6 @@
 int stru32int(char *s, u32int *r);
 int stru64int(char *s, u64int *r);
 int u64log2(u64int v);
+
+void initarenas(void);
+void initindex(void);