ref: 8a7863faefd9f656ca9f298743f515d9ca275692
dir: /disk.c/
#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;
u16int entry;
u64int aindex;
u64int bucket = U32GET(score) / index.div;
VtISect sect = isectforbucket(bucket);
bucket -= sect.start;
buf = malloc(sect.blocksize);
if(buf == nil)
sysfatal("OOM, blocksize: %d", sect.blocksize);
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 %ux, buck %ux", 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);
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 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");
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);
}
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, 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;
char buf[HeadSize];
u8int *p = (void*)buf;
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;
readarenatable(fd, tabbase, tabsize, 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();
}