File *
fileGetParent(File *f)
{
if(fileIsRoot(f))
return fileIncRef(f);
return fileIncRef(f->up);
}
File *
_fileOpen(Fs *fs, char *path, int partial)
{
File *f, *ff;
char *p, elem[VtMaxStringSize], *opath;
int n;
f = fs->file;
fileIncRef(f);
opath = path;
while(*path != 0){
for(p = path; *p && *p != '/'; p++)
;
n = p - path;
if(n > 0){
if(n > VtMaxStringSize){
vtSetError("%s: element too long", EBadPath);
goto Err;
}
memmove(elem, path, n);
elem[n] = 0;
ff = _fileWalk(f, elem, partial && *p=='\0');
if(ff == nil){
vtSetError("%.*s: %R", utfnlen(opath, p-opath),
opath);
goto Err;
}
fileDecRef(f);
f = ff;
}
if(*p == '/')
p++;
path = p;
}
return f;
Err:
fileDecRef(f);
return nil;
}
DirEntryEnum *
deeOpen(File *f)
{
DirEntryEnum *dee;
File *p;
if(!fileIsDir(f)){
vtSetError(ENotDir);
fileDecRef(f);
return nil;
}
/* flush out meta data */
if(!fileLock(f))
return nil;
for(p=f->down; p; p=p->next)
fileMetaFlush2(p, nil);
fileUnlock(f);
dee = vtMemAllocZ(sizeof(DirEntryEnum));
dee->file = fileIncRef(f);
return dee;
}
File *
fileCreate(File *f, char *elem, ulong mode, char *uid)
{
File *ff;
DirEntry *dir;
Source *pr, *r, *mr;
int isdir;
if(!fileLock(f))
return nil;
r = nil;
mr = nil;
for(ff = f->down; ff; ff=ff->next){
if(strcmp(elem, ff->dir.elem) == 0 && !ff->removed){
ff = nil;
vtSetError(EExists);
goto Err1;
}
}
ff = dirLookup(f, elem);
if(ff != nil){
vtSetError(EExists);
goto Err1;
}
pr = f->source;
if(pr->mode != OReadWrite){
vtSetError(EReadOnly);
goto Err1;
}
if(!sourceLock2(f->source, f->msource, -1))
goto Err1;
ff = fileAlloc(f->fs);
isdir = mode & ModeDir;
r = sourceCreate(pr, pr->dsize, isdir, 0);
if(r == nil)
goto Err;
if(isdir){
mr = sourceCreate(pr, pr->dsize, 0, r->offset);
if(mr == nil)
goto Err;
}
dir = &ff->dir;
dir->elem = vtStrDup(elem);
dir->entry = r->offset;
dir->gen = r->gen;
if(isdir){
dir->mentry = mr->offset;
dir->mgen = mr->gen;
}
dir->size = 0;
if(!fsNextQid(f->fs, &dir->qid))
goto Err;
dir->uid = vtStrDup(uid);
dir->gid = vtStrDup(f->dir.gid);
dir->mid = vtStrDup(uid);
dir->mtime = time(0L);
dir->mcount = 0;
dir->ctime = dir->mtime;
dir->atime = dir->mtime;
dir->mode = mode;
ff->boff = fileMetaAlloc(f, dir, 0);
if(ff->boff == NilBlock)
goto Err;
sourceUnlock(f->source);
sourceUnlock(f->msource);
ff->source = r;
r->file = ff; /* point back */
ff->msource = mr;
if(mode&ModeTemporary){
if(!sourceLock2(r, mr, -1))
goto Err1;
fileSetTmp(ff, 1);
sourceUnlock(r);
if(mr)
sourceUnlock(mr);
}
/* committed */
/* link in and up parent ref count */
ff->next = f->down;
f->down = ff;
ff->up = f;
fileIncRef(f);
fileWAccess(f, uid);
fileUnlock(f);
return ff;
Err:
sourceUnlock(f->source);
sourceUnlock(f->msource);
Err1:
if(r){
sourceLock(r, -1);
sourceRemove(r);
}
if(mr){
sourceLock(mr, -1);
sourceRemove(mr);
}
if(ff)
fileDecRef(ff);
fileUnlock(f);
return 0;
}
File *
_fileWalk(File *f, char *elem, int partial)
{
File *ff;
fileRAccess(f);
if(elem[0] == 0){
vtSetError(EBadPath);
return nil;
}
if(!fileIsDir(f)){
vtSetError(ENotDir);
return nil;
}
if(strcmp(elem, ".") == 0){
return fileIncRef(f);
}
if(strcmp(elem, "..") == 0){
if(fileIsRoot(f))
return fileIncRef(f);
return fileIncRef(f->up);
}
if(!fileLock(f))
return nil;
for(ff = f->down; ff; ff=ff->next){
if(strcmp(elem, ff->dir.elem) == 0 && !ff->removed){
ff->ref++;
goto Exit;
}
}
ff = dirLookup(f, elem);
if(ff == nil)
goto Err;
if(ff->dir.mode & ModeSnapshot){
ff->mode = OReadOnly;
ff->issnapshot = 1;
}
if(partial){
/*
* Do nothing. We're opening this file only so we can clri it.
* Usually the sources can't be opened, hence we won't even bother.
* Be VERY careful with the returned file. If you hand it to a routine
* expecting ff->source and/or ff->msource to be non-nil, we're
* likely to dereference nil. FileClri should be the only routine
* setting partial.
*/
ff->partial = 1;
}else if(ff->dir.mode & ModeDir){
ff->source = fileOpenSource(f, ff->dir.entry, ff->dir.gen,
1, ff->mode, ff->issnapshot);
ff->msource = fileOpenSource(f, ff->dir.mentry, ff->dir.mgen,
0, ff->mode, ff->issnapshot);
if(ff->source == nil || ff->msource == nil)
goto Err;
}else{
ff->source = fileOpenSource(f, ff->dir.entry, ff->dir.gen,
0, ff->mode, ff->issnapshot);
if(ff->source == nil)
goto Err;
}
/* link in and up parent ref count */
if (ff->source)
ff->source->file = ff; /* point back */
ff->next = f->down;
f->down = ff;
ff->up = f;
fileIncRef(f);
Exit:
fileUnlock(f);
return ff;
Err:
fileUnlock(f);
if(ff != nil)
fileDecRef(ff);
return nil;
}
File *
fsGetRoot(Fs *fs)
{
return fileIncRef(fs->file);
}
