/* assume file is locked, assume f->msource is locked */
static int
fileCheckEmpty(File *f)
{
u32int i, n;
Block *b;
MetaBlock mb;
Source *r;
r = f->msource;
n = (sourceGetSize(r)+r->dsize-1)/r->dsize;
for(i=0; i<n; i++){
b = sourceBlock(r, i, OReadOnly);
if(b == nil)
goto Err;
if(!mbUnpack(&mb, b->data, r->dsize))
goto Err;
if(mb.nindex > 0){
vtSetError(ENotEmpty);
goto Err;
}
blockPut(b);
}
return 1;
Err:
blockPut(b);
return 0;
}
static void
scanSource(Fsck *chk, char *name, Source *r)
{
u32int a, nb, o;
Block *b;
Entry e;
if(!chk->useventi && globalToLocal(r->score)==NilBlock)
return;
if(!sourceGetEntry(r, &e)){
error(chk, "could not get entry for %s", name);
return;
}
a = globalToLocal(e.score);
if(!chk->useventi && a==NilBlock)
return;
if(getBit(chk->smap, a))
return;
setBit(chk->smap, a);
nb = (sourceGetSize(r) + r->dsize-1) / r->dsize;
for(o = 0; o < nb; o++){
b = sourceBlock(r, o, OReadOnly);
if(b == nil){
error(chk, "could not read block in data file %s", name);
continue;
}
if(b->addr != NilBlock && getBit(chk->errmap, b->addr)){
warn(chk, "previously reported error in block %ux is in file %s",
b->addr, name);
}
blockPut(b);
}
}
int
deeRead(DirEntryEnum *dee, DirEntry *de)
{
int ret, didread;
File *f;
u32int nb;
if(dee == nil){
vtSetError("cannot happen in deeRead");
return -1;
}
f = dee->file;
if(!fileRLock(f))
return -1;
if(!sourceLock2(f->source, f->msource, OReadOnly)){
fileRUnlock(f);
return -1;
}
nb = (sourceGetSize(f->msource)+f->msource->dsize-1)/f->msource->dsize;
didread = 0;
while(dee->i >= dee->n){
if(dee->boff >= nb){
ret = 0;
goto Return;
}
didread = 1;
if(!deeFill(dee)){
ret = -1;
goto Return;
}
}
memmove(de, dee->buf + dee->i, sizeof(DirEntry));
dee->i++;
ret = 1;
Return:
sourceUnlock(f->source);
sourceUnlock(f->msource);
fileRUnlock(f);
if(didread)
fileRAccess(f);
return ret;
}
int
fileGetSize(File *f, uvlong *size)
{
if(!fileRLock(f))
return 0;
if(!sourceLock(f->source, OReadOnly)){
fileRUnlock(f);
return 0;
}
*size = sourceGetSize(f->source);
sourceUnlock(f->source);
fileRUnlock(f);
return 1;
}
uint32_t
sourceGetDirSize(Source *r)
{
uint32_t ds;
uint64_t size;
int epb;
assert(sourceIsLocked(r));
epb = r->dsize/VtEntrySize;
size = sourceGetSize(r);
ds = epb*(size/r->dsize);
ds += (size%r->dsize)/VtEntrySize;
return ds;
}
/*
* the file is locked already
* f->msource is unlocked
*/
static File *
dirLookup(File *f, char *elem)
{
int i;
MetaBlock mb;
MetaEntry me;
Block *b;
Source *meta;
File *ff;
u32int bo, nb;
meta = f->msource;
b = nil;
if(!sourceLock(meta, -1))
return nil;
nb = (sourceGetSize(meta)+meta->dsize-1)/meta->dsize;
for(bo=0; bo<nb; bo++){
b = sourceBlock(meta, bo, OReadOnly);
if(b == nil)
goto Err;
if(!mbUnpack(&mb, b->data, meta->dsize))
goto Err;
if(mbSearch(&mb, elem, &i, &me)){
ff = fileAlloc(f->fs);
if(!deUnpack(&ff->dir, &me)){
fileFree(ff);
goto Err;
}
sourceUnlock(meta);
blockPut(b);
ff->boff = bo;
ff->mode = f->mode;
ff->issnapshot = f->issnapshot;
return ff;
}
blockPut(b);
b = nil;
}
vtSetError(ENoFile);
/* fall through */
Err:
sourceUnlock(meta);
blockPut(b);
return nil;
}
int
fileGetDir(File *f, DirEntry *dir)
{
if(!fileRLock(f))
return 0;
fileMetaLock(f);
deCopy(dir, &f->dir);
fileMetaUnlock(f);
if(!fileIsDir(f)){
if(!sourceLock(f->source, OReadOnly)){
fileRUnlock(f);
return 0;
}
dir->size = sourceGetSize(f->source);
sourceUnlock(f->source);
}
fileRUnlock(f);
return 1;
}
int
fileSetDir(File *f, DirEntry *dir, char *uid)
{
File *ff;
char *oelem;
u32int mask;
u64int size;
/* can not set permissions for the root */
if(fileIsRoot(f)){
vtSetError(ERoot);
return 0;
}
if(!fileLock(f))
return 0;
if(f->source->mode != OReadWrite){
vtSetError(EReadOnly);
fileUnlock(f);
return 0;
}
fileMetaLock(f);
/* check new name does not already exist */
if(strcmp(f->dir.elem, dir->elem) != 0){
for(ff = f->up->down; ff; ff=ff->next){
if(strcmp(dir->elem, ff->dir.elem) == 0 && !ff->removed){
vtSetError(EExists);
goto Err;
}
}
ff = dirLookup(f->up, dir->elem);
if(ff != nil){
fileDecRef(ff);
vtSetError(EExists);
goto Err;
}
}
if(!sourceLock2(f->source, f->msource, -1))
goto Err;
if(!fileIsDir(f)){
size = sourceGetSize(f->source);
if(size != dir->size){
if(!sourceSetSize(f->source, dir->size)){
sourceUnlock(f->source);
if(f->msource)
sourceUnlock(f->msource);
goto Err;
}
/* commited to changing it now */
}
}
/* commited to changing it now */
if((f->dir.mode&ModeTemporary) != (dir->mode&ModeTemporary))
fileSetTmp(f, dir->mode&ModeTemporary);
sourceUnlock(f->source);
if(f->msource)
sourceUnlock(f->msource);
oelem = nil;
if(strcmp(f->dir.elem, dir->elem) != 0){
oelem = f->dir.elem;
f->dir.elem = vtStrDup(dir->elem);
}
if(strcmp(f->dir.uid, dir->uid) != 0){
vtMemFree(f->dir.uid);
f->dir.uid = vtStrDup(dir->uid);
}
if(strcmp(f->dir.gid, dir->gid) != 0){
vtMemFree(f->dir.gid);
f->dir.gid = vtStrDup(dir->gid);
}
f->dir.mtime = dir->mtime;
f->dir.atime = dir->atime;
//fprint(2, "mode %x %x ", f->dir.mode, dir->mode);
mask = ~(ModeDir|ModeSnapshot);
f->dir.mode &= ~mask;
f->dir.mode |= mask & dir->mode;
f->dirty = 1;
//fprint(2, "->%x\n", f->dir.mode);
fileMetaFlush2(f, oelem);
vtMemFree(oelem);
fileMetaUnlock(f);
fileUnlock(f);
fileWAccess(f->up, uid);
return 1;
Err:
fileMetaUnlock(f);
fileUnlock(f);
return 0;
}
int
fileWrite(File *f, void *buf, int cnt, vlong offset, char *uid)
{
Source *s;
ulong bn;
int off, dsize, n;
Block *b;
uchar *p;
vlong eof;
if(0)fprint(2, "fileWrite: %s %d, %lld\n", f->dir.elem, cnt, offset);
if(!fileLock(f))
return -1;
s = nil;
if(f->dir.mode & ModeDir){
vtSetError(ENotFile);
goto Err;
}
if(f->source->mode != OReadWrite){
vtSetError(EReadOnly);
goto Err;
}
if(offset < 0){
vtSetError(EBadOffset);
goto Err;
}
fileWAccess(f, uid);
if(!sourceLock(f->source, -1))
goto Err;
s = f->source;
dsize = s->dsize;
eof = sourceGetSize(s);
if(f->dir.mode & ModeAppend)
offset = eof;
bn = offset/dsize;
off = offset%dsize;
p = buf;
while(cnt > 0){
n = cnt;
if(n > dsize-off)
n = dsize-off;
b = sourceBlock(s, bn, n<dsize?OReadWrite:OOverWrite);
if(b == nil){
if(offset > eof)
sourceSetSize(s, offset);
goto Err;
}
memmove(b->data+off, p, n);
off = 0;
cnt -= n;
p += n;
offset += n;
bn++;
blockDirty(b);
blockPut(b);
}
if(offset > eof && !sourceSetSize(s, offset))
goto Err;
sourceUnlock(s);
fileUnlock(f);
return p-(uchar*)buf;
Err:
if(s)
sourceUnlock(s);
fileUnlock(f);
return -1;
}
int
fileRead(File *f, void *buf, int cnt, vlong offset)
{
Source *s;
uvlong size;
u32int bn;
int off, dsize, n, nn;
Block *b;
uchar *p;
if(0)fprint(2, "fileRead: %s %d, %lld\n", f->dir.elem, cnt, offset);
if(!fileRLock(f))
return -1;
if(offset < 0){
vtSetError(EBadOffset);
goto Err1;
}
fileRAccess(f);
if(!sourceLock(f->source, OReadOnly))
goto Err1;
s = f->source;
dsize = s->dsize;
size = sourceGetSize(s);
if(offset >= size)
offset = size;
if(cnt > size-offset)
cnt = size-offset;
bn = offset/dsize;
off = offset%dsize;
p = buf;
while(cnt > 0){
b = sourceBlock(s, bn, OReadOnly);
if(b == nil)
goto Err;
n = cnt;
if(n > dsize-off)
n = dsize-off;
nn = dsize-off;
if(nn > n)
nn = n;
memmove(p, b->data+off, nn);
memset(p+nn, 0, nn-n);
off = 0;
bn++;
cnt -= n;
p += n;
blockPut(b);
}
sourceUnlock(s);
fileRUnlock(f);
return p-(uchar*)buf;
Err:
sourceUnlock(s);
Err1:
fileRUnlock(f);
return -1;
}
/*
* 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;
}
/*
* Walk the source tree making sure that the BtData
* sources containing directory entries are okay.
*/
static void
chkDir(Fsck *chk, char *name, Source *source, Source *meta)
{
int i;
u32int a1, a2, nb, o;
char *s, *nn;
uchar *bm;
Block *b, *bb;
DirEntry de;
Entry e1, e2;
MetaBlock mb;
MetaEntry me;
Source *r, *mr;
if(!chk->useventi && globalToLocal(source->score)==NilBlock &&
globalToLocal(meta->score)==NilBlock)
return;
if(!sourceLock2(source, meta, OReadOnly)){
warn(chk, "could not lock sources for %s: %R", name);
return;
}
if(!sourceGetEntry(source, &e1) || !sourceGetEntry(meta, &e2)){
warn(chk, "could not load entries for %s: %R", name);
return;
}
a1 = globalToLocal(e1.score);
a2 = globalToLocal(e2.score);
if((!chk->useventi && a1==NilBlock && a2==NilBlock)
|| (getBit(chk->smap, a1) && getBit(chk->smap, a2))){
sourceUnlock(source);
sourceUnlock(meta);
return;
}
setBit(chk->smap, a1);
setBit(chk->smap, a2);
bm = vtMemAllocZ(sourceGetDirSize(source)/8 + 1);
nb = (sourceGetSize(meta) + meta->dsize - 1)/meta->dsize;
for(o = 0; o < nb; o++){
b = sourceBlock(meta, o, OReadOnly);
if(b == nil){
error(chk, "could not read block in meta file: %s[%ud]: %R",
name, o);
continue;
}
if(0) fprint(2, "source %V:%d block %d addr %d\n", source->score,
source->offset, o, b->addr);
if(b->addr != NilBlock && getBit(chk->errmap, b->addr))
warn(chk, "previously reported error in block %ux is in %s",
b->addr, name);
if(!mbUnpack(&mb, b->data, meta->dsize)){
error(chk, "could not unpack meta block: %s[%ud]: %R",
name, o);
blockPut(b);
continue;
}
if(!chkMetaBlock(&mb)){
error(chk, "bad meta block: %s[%ud]: %R", name, o);
blockPut(b);
continue;
}
s = nil;
for(i=mb.nindex-1; i>=0; i--){
meUnpack(&me, &mb, i);
if(!deUnpack(&de, &me)){
error(chk,
"could not unpack dir entry: %s[%ud][%d]: %R",
name, o, i);
continue;
}
if(s && strcmp(s, de.elem) <= 0)
error(chk,
"dir entry out of order: %s[%ud][%d] = %s last = %s",
name, o, i, de.elem, s);
vtMemFree(s);
s = vtStrDup(de.elem);
nn = smprint("%s/%s", name, de.elem);
if(nn == nil){
error(chk, "out of memory");
continue;
}
if(chk->printdirs)
if(de.mode&ModeDir)
chk->print("%s/\n", nn);
if(chk->printfiles)
if(!(de.mode&ModeDir))
chk->print("%s\n", nn);
if(!(de.mode & ModeDir)){
r = openSource(chk, source, nn, bm, de.entry,
de.gen, 0, &mb, i, b);
if(r != nil){
if(sourceLock(r, OReadOnly)){
scanSource(chk, nn, r);
sourceUnlock(r);
}
sourceClose(r);
}
deCleanup(&de);
free(nn);
continue;
}
r = openSource(chk, source, nn, bm, de.entry,
de.gen, 1, &mb, i, b);
if(r == nil){
deCleanup(&de);
free(nn);
continue;
}
mr = openSource(chk, source, nn, bm, de.mentry,
de.mgen, 0, &mb, i, b);
if(mr == nil){
sourceClose(r);
deCleanup(&de);
free(nn);
continue;
}
if(!(de.mode&ModeSnapshot) || chk->walksnapshots)
chkDir(chk, nn, r, mr);
sourceClose(mr);
sourceClose(r);
deCleanup(&de);
free(nn);
deCleanup(&de);
}
vtMemFree(s);
blockPut(b);
}
nb = sourceGetDirSize(source);
for(o=0; o<nb; o++){
if(getBit(bm, o))
continue;
r = sourceOpen(source, o, OReadOnly, 0);
if(r == nil)
continue;
warn(chk, "non referenced entry in source %s[%d]", name, o);
if((bb = sourceBlock(source, o/(source->dsize/VtEntrySize),
OReadOnly)) != nil){
if(bb->addr != NilBlock){
setBit(chk->errmap, bb->addr);
chk->clre(chk, bb, o%(source->dsize/VtEntrySize));
chk->nclre++;
}
blockPut(bb);
}
sourceClose(r);
}
sourceUnlock(source);
sourceUnlock(meta);
vtMemFree(bm);
}