int
fileTruncate(File *f, char *uid)
{
if(fileIsDir(f)){
vtSetError(ENotFile);
return 0;
}
if(!fileLock(f))
return 0;
if(f->source->mode != OReadWrite){
vtSetError(EReadOnly);
fileUnlock(f);
return 0;
}
if(!sourceLock(f->source, -1)){
fileUnlock(f);
return 0;
}
if(!sourceTruncate(f->source)){
sourceUnlock(f->source);
fileUnlock(f);
return 0;
}
sourceUnlock(f->source);
fileUnlock(f);
fileWAccess(f, uid);
return 1;
}
/*
* Changes the file block bn to be the given block score.
* Very sneaky. Only used by flfmt.
*/
int
fileMapBlock(File *f, ulong bn, uchar score[VtScoreSize], ulong tag)
{
Block *b;
Entry e;
Source *s;
if(!fileLock(f))
return 0;
s = nil;
if(f->dir.mode & ModeDir){
vtSetError(ENotFile);
goto Err;
}
if(f->source->mode != OReadWrite){
vtSetError(EReadOnly);
goto Err;
}
if(!sourceLock(f->source, -1))
goto Err;
s = f->source;
b = _sourceBlock(s, bn, OReadWrite, 1, tag);
if(b == nil)
goto Err;
if(!sourceGetEntry(s, &e))
goto Err;
if(b->l.type == BtDir){
memmove(e.score, score, VtScoreSize);
assert(e.tag == tag || e.tag == 0);
e.tag = tag;
e.flags |= VtEntryLocal;
entryPack(&e, b->data, f->source->offset % f->source->epb);
}else
memmove(b->data + (bn%(e.psize/VtScoreSize))*VtScoreSize, score, VtScoreSize);
blockDirty(b);
blockPut(b);
sourceUnlock(s);
fileUnlock(f);
return 1;
Err:
if(s)
sourceUnlock(s);
fileUnlock(f);
return 0;
}
int
fileRemove(File *f, char *uid)
{
File *ff;
/* can not remove the root */
if(fileIsRoot(f)){
vtSetError(ERoot);
return 0;
}
if(!fileLock(f))
return 0;
if(f->source->mode != OReadWrite){
vtSetError(EReadOnly);
goto Err1;
}
if(!sourceLock2(f->source, f->msource, -1))
goto Err1;
if(fileIsDir(f) && !fileCheckEmpty(f))
goto Err;
for(ff=f->down; ff; ff=ff->next)
assert(ff->removed);
sourceRemove(f->source);
f->source->file = nil; /* erase back pointer */
f->source = nil;
if(f->msource){
sourceRemove(f->msource);
f->msource = nil;
}
fileUnlock(f);
if(!fileMetaRemove(f, uid))
return 0;
return 1;
Err:
sourceUnlock(f->source);
if(f->msource)
sourceUnlock(f->msource);
Err1:
fileUnlock(f);
return 0;
}
int
fileMetaFlush(File *f, int rec)
{
File **kids, *p;
int nkids;
int i, rv;
fileMetaLock(f);
rv = fileMetaFlush2(f, nil);
fileMetaUnlock(f);
if(!rec || !fileIsDir(f))
return rv;
if(!fileLock(f))
return rv;
nkids = 0;
for(p=f->down; p; p=p->next)
nkids++;
kids = vtMemAlloc(nkids*sizeof(File*));
i = 0;
for(p=f->down; p; p=p->next){
kids[i++] = p;
p->ref++;
}
fileUnlock(f);
for(i=0; i<nkids; i++){
rv |= fileMetaFlush(kids[i], 1);
fileDecRef(kids[i]);
}
vtMemFree(kids);
return rv;
}
XmlErr XmlProfile::XmlParseFile(char *path) {
struct stat fileStat;
if(!path) return XML_BADARGS;
stat(path,&fileStat);
FILE *inFile=NULL;
XmlErr err;
cTag=NULL;
if(fileStat.st_size>0) {
char *buffer;
inFile=fopen(path,"r");
if(inFile) {
if(!fileLock(inFile)) {
error("Can't lock %s for opening ",path);
return -1;
}
buffer=(char *)malloc(fileStat.st_size+1);
fread(buffer,1,fileStat.st_size,inFile);
buffer[fileStat.st_size]=0;
err=XmlParseBuffer(buffer);
free(buffer);
fileUnlock(inFile);
fclose(inFile);
}
else {
error("Can't open xmlfile %s",path);
return -1;
}
}
}
static int
fileLock(File *f)
{
assert(!vtCanLock(f->fs->elk));
vtLock(f->lk);
if(!chkSource(f)){
fileUnlock(f);
return 0;
}
return 1;
}
static int
fileLock(File *f)
{
assert(!canwlock(&f->fs->elk));
wlock(&f->lk);
if(!chkSource(f)){
fileUnlock(f);
return 0;
}
return 1;
}
int
fileSetQidSpace(File *f, u64int offset, u64int max)
{
int ret;
if(!fileLock(f))
return 0;
fileMetaLock(f);
f->dir.qidSpace = 1;
f->dir.qidOffset = offset;
f->dir.qidMax = max;
ret = fileMetaFlush2(f, nil)>=0;
fileMetaUnlock(f);
fileUnlock(f);
return ret;
}
int
fileSetSize(File *f, uvlong size)
{
int r;
if(!fileLock(f))
return 0;
r = 0;
if(f->dir.mode & ModeDir){
vtSetError(ENotFile);
goto Err;
}
if(f->source->mode != OReadWrite){
vtSetError(EReadOnly);
goto Err;
}
if(!sourceLock(f->source, -1))
goto Err;
r = sourceSetSize(f->source, size);
sourceUnlock(f->source);
Err:
fileUnlock(f);
return r;
}
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;
}
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;
}
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;
}
