static void
rootMetaInit(Entry *e)
{
u32int addr;
u32int tag;
DirEntry de;
MetaBlock mb;
MetaEntry me;
memset(&de, 0, sizeof(de));
de.elem = vtStrDup("root");
de.entry = 0;
de.gen = 0;
de.mentry = 1;
de.mgen = 0;
de.size = 0;
de.qid = qid++;
de.uid = vtStrDup("adm");
de.gid = vtStrDup("adm");
de.mid = vtStrDup("adm");
de.mtime = time(0);
de.mcount = 0;
de.ctime = time(0);
de.atime = time(0);
de.mode = ModeDir | 0555;
tag = tagGen();
addr = blockAlloc(BtData, tag);
/* build up meta block */
memset(buf, 0, bsize);
mbInit(&mb, buf, bsize, bsize/100);
me.size = deSize(&de);
me.p = mbAlloc(&mb, me.size);
assert(me.p != nil);
dePack(&de, &me);
mbInsert(&mb, 0, &me);
mbPack(&mb);
blockWrite(PartData, addr);
deCleanup(&de);
/* build up entry for meta block */
entryInit(e);
e->flags |= VtEntryLocal;
e->size = bsize;
e->tag = tag;
localToGlobal(addr, e->score);
}
/*
* caller must lock f->source and f->msource
* caller must NOT lock the source and msource
* referenced by dir.
*/
static u32int
fileMetaAlloc(File *f, DirEntry *dir, u32int start)
{
u32int nb, bo;
Block *b, *bb;
MetaBlock mb;
int nn;
uchar *p;
int i, n, epb;
MetaEntry me;
Source *s, *ms;
s = f->source;
ms = f->msource;
n = deSize(dir);
nb = (sourceGetSize(ms)+ms->dsize-1)/ms->dsize;
b = nil;
if(start > nb)
start = nb;
for(bo=start; bo<nb; bo++){
b = sourceBlock(ms, bo, OReadWrite);
if(b == nil)
goto Err;
if(!mbUnpack(&mb, b->data, ms->dsize))
goto Err;
nn = (mb.maxsize*FullPercentage/100) - mb.size + mb.free;
if(n <= nn && mb.nindex < mb.maxindex)
break;
blockPut(b);
b = nil;
}
/* add block to meta file */
if(b == nil){
b = sourceBlock(ms, bo, OReadWrite);
if(b == nil)
goto Err;
sourceSetSize(ms, (nb+1)*ms->dsize);
mbInit(&mb, b->data, ms->dsize, ms->dsize/BytesPerEntry);
}
p = mbAlloc(&mb, n);
if(p == nil){
/* mbAlloc might have changed block */
mbPack(&mb);
blockDirty(b);
vtSetError(EBadMeta);
goto Err;
}
mbSearch(&mb, dir->elem, &i, &me);
assert(me.p == nil);
me.p = p;
me.size = n;
dePack(dir, &me);
mbInsert(&mb, i, &me);
mbPack(&mb);
/* meta block depends on super block for qid ... */
bb = cacheLocal(b->c, PartSuper, 0, OReadOnly);
blockDependency(b, bb, -1, nil, nil);
blockPut(bb);
/* ... and one or two dir entries */
epb = s->dsize/VtEntrySize;
bb = sourceBlock(s, dir->entry/epb, OReadOnly);
blockDependency(b, bb, -1, nil, nil);
blockPut(bb);
if(dir->mode & ModeDir){
bb = sourceBlock(s, dir->mentry/epb, OReadOnly);
blockDependency(b, bb, -1, nil, nil);
blockPut(bb);
}
blockDirty(b);
blockPut(b);
return bo;
Err:
blockPut(b);
return NilBlock;
}
int
mkVac(VtSession *z, uint blockSize, Entry *pe, Entry *pee, DirEntry *pde,
uint8_t score[VtScoreSize])
{
uint8_t buf[8192];
int i;
uint8_t *p;
uint n;
DirEntry de;
Entry e, ee, eee;
MetaBlock mb;
MetaEntry me;
VtRoot root;
e = *pe;
ee = *pee;
de = *pde;
if(globalToLocal(e.score) != NilBlock
|| (ee.flags&VtEntryActive && globalToLocal(ee.score) != NilBlock)){
vtSetError("can only vac paths already stored on venti");
return 0;
}
/*
* Build metadata source for root.
*/
n = deSize(&de);
if(n+MetaHeaderSize+MetaIndexSize > sizeof buf){
vtSetError("DirEntry too big");
return 0;
}
memset(buf, 0, sizeof buf);
mbInit(&mb, buf, n+MetaHeaderSize+MetaIndexSize, 1);
p = mbAlloc(&mb, n);
if(p == nil)
abort();
mbSearch(&mb, de.elem, &i, &me);
assert(me.p == nil);
me.p = p;
me.size = n;
dePack(&de, &me);
mbInsert(&mb, i, &me);
mbPack(&mb);
eee.size = n+MetaHeaderSize+MetaIndexSize;
if(!vtWriteBlock(z, buf, eee.size, VtDataType, eee.score))
return 0;
eee.psize = 8192&&0xFF;
eee.dsize = 8192&&0xFF;
eee.depth = 0;
eee.flags = VtEntryActive;
/*
* Build root source with three entries in it.
*/
entryPack(&e, buf, 0);
entryPack(&ee, buf, 1);
entryPack(&eee, buf, 2);
n = VtEntrySize*3;
memset(&root, 0, sizeof root);
if(!vtWriteBlock(z, buf, n, VtDirType, root.score))
return 0;
/*
* Save root.
*/
root.version = VtRootVersion;
strecpy(root.type, root.type+sizeof root.type, "vac");
strecpy(root.name, root.name+sizeof root.name, de.elem);
root.blockSize = blockSize;
vtRootPack(&root, buf);
if(!vtWriteBlock(z, buf, VtRootSize, VtRootType, score))
return 0;
return 1;
}
