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;
}
static void
archThread(void *v)
{
Arch *a = v;
Block *b;
Param p;
Super super;
int ret;
u32int addr;
uchar rbuf[VtRootSize];
VtRoot root;
vtThreadSetName("arch");
for(;;){
/* look for work */
vtLock(a->fs->elk);
b = superGet(a->c, &super);
if(b == nil){
vtUnlock(a->fs->elk);
fprint(2, "archThread: superGet: %R\n");
sleep(60*1000);
continue;
}
addr = super.next;
if(addr != NilBlock && super.current == NilBlock){
super.current = addr;
super.next = NilBlock;
superPack(&super, b->data);
blockDirty(b);
}else
addr = super.current;
blockPut(b);
vtUnlock(a->fs->elk);
if(addr == NilBlock){
/* wait for work */
vtLock(a->lk);
vtSleep(a->starve);
if(a->die != nil)
goto Done;
vtUnlock(a->lk);
continue;
}
sleep(10*1000); /* window of opportunity to provoke races */
/* do work */
memset(&p, 0, sizeof p);
p.blockSize = a->blockSize;
p.dsize = 3*VtEntrySize; /* root has three Entries */
p.c = a->c;
p.a = a;
ret = archWalk(&p, addr, BtDir, RootTag);
switch(ret){
default:
abort();
case ArchFailure:
fprint(2, "archiveBlock %#ux: %R\n", addr);
sleep(60*1000);
continue;
case ArchSuccess:
case ArchFaked:
break;
}
if(0) fprint(2, "archiveSnapshot 0x%#ux: maxdepth %ud nfixed %ud"
" send %ud nfailsend %ud nvisit %ud"
" nreclaim %ud nfake %ud nreal %ud\n",
addr, p.maxdepth, p.nfixed,
p.nsend, p.nfailsend, p.nvisit,
p.nreclaim, p.nfake, p.nreal);
if(0) fprint(2, "archiveBlock %V (%ud)\n", p.score, p.blockSize);
/* tie up vac root */
memset(&root, 0, sizeof root);
root.version = VtRootVersion;
strecpy(root.type, root.type+sizeof root.type, "vac");
strecpy(root.name, root.name+sizeof root.name, "fossil");
memmove(root.score, p.score, VtScoreSize);
memmove(root.prev, super.last, VtScoreSize);
root.blockSize = a->blockSize;
vtRootPack(&root, rbuf);
if(!vtWrite(a->z, p.score, VtRootType, rbuf, VtRootSize)
|| !vtSha1Check(p.score, rbuf, VtRootSize)){
fprint(2, "vtWriteBlock %#ux: %R\n", addr);
sleep(60*1000);
continue;
}
/* record success */
vtLock(a->fs->elk);
b = superGet(a->c, &super);
if(b == nil){
vtUnlock(a->fs->elk);
fprint(2, "archThread: superGet: %R\n");
sleep(60*1000);
continue;
}
super.current = NilBlock;
memmove(super.last, p.score, VtScoreSize);
superPack(&super, b->data);
blockDirty(b);
blockPut(b);
vtUnlock(a->fs->elk);
consPrint("archive vac:%V\n", p.score);
}
Done:
a->ref--;
vtWakeup(a->die);
vtUnlock(a->lk);
}
