ref: 4d919ab612f61c1ef1b21d41513f264d57c010d4
dir: /sys/src/lib9p/file.c/
#include <u.h>
#include <libc.h>
#include <auth.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>
/*
* To avoid deadlock, the following rules must be followed.
* Always lock child then parent, never parent then child.
* If holding the free file lock, do not lock any Files.
*/
struct Filelist
{
File *f;
Filelist *link;
};
struct Readdir
{
File *dir;
Filelist *fl;
};
static QLock filelk;
static File *freefilelist;
static File*
allocfile(void)
{
int i, a;
File *f;
enum { N = 16 };
qlock(&filelk);
if(freefilelist == nil){
f = emalloc9p(N*sizeof(*f));
for(i=0; i<N-1; i++)
f[i].aux = &f[i+1];
f[N-1].aux = nil;
f[0].allocd = 1;
freefilelist = f;
}
f = freefilelist;
freefilelist = f->aux;
qunlock(&filelk);
a = f->allocd;
memset(f, 0, sizeof *f);
f->allocd = a;
return f;
}
static void
freefile(File *f)
{
Filelist *fl, *flnext;
for(fl=f->filelist; fl; fl=flnext){
flnext = fl->link;
assert(fl->f == nil);
free(fl);
}
free(f->name);
free(f->uid);
free(f->gid);
free(f->muid);
qlock(&filelk);
assert(f->ref == 0);
f->aux = freefilelist;
freefilelist = f;
qunlock(&filelk);
}
static void
cleanfilelist(File *f)
{
Filelist **l;
Filelist *fl;
/*
* can't delete filelist structures while there
* are open readers of this directory, because
* they might have references to the structures.
* instead, just leave the empty refs in the list
* until there is no activity and then clean up.
*/
if(f->readers.ref != 0)
return;
if(f->nxchild == 0)
return;
/*
* no dir readers, file is locked, and
* there are empty entries in the file list.
* clean them out.
*/
for(l=&f->filelist; fl=*l; ){
if(fl->f == nil){
*l = (*l)->link;
free(fl);
}else
l = &(*l)->link;
}
f->nxchild = 0;
}
void
closefile(File *f)
{
if(decref(f) == 0){
f->tree->destroy(f);
freefile(f);
}
}
static void
nop(File*)
{
}
int
removefile(File *f)
{
File *fp;
Filelist *fl;
fp = f->parent;
if(fp == nil){
werrstr("no parent");
closefile(f);
return -1;
}
if(fp == f){
werrstr("cannot remove root");
closefile(f);
return -1;
}
wlock(f);
wlock(fp);
if(f->nchild != 0){
werrstr("has children");
wunlock(fp);
wunlock(f);
closefile(f);
return -1;
}
if(f->parent != fp){
werrstr("parent changed underfoot");
wunlock(fp);
wunlock(f);
closefile(f);
return -1;
}
for(fl=fp->filelist; fl; fl=fl->link)
if(fl->f == f)
break;
assert(fl != nil && fl->f == f);
fl->f = nil;
fp->nchild--;
fp->nxchild++;
f->parent = nil;
wunlock(f);
cleanfilelist(fp);
wunlock(fp);
closefile(fp); /* reference from child */
closefile(f); /* reference from tree */
closefile(f);
return 0;
}
File*
createfile(File *fp, char *name, char *uid, ulong perm, void *aux)
{
File *f;
Filelist **l, *fl;
Tree *t;
if((fp->qid.type&QTDIR) == 0){
werrstr("create in non-directory");
return nil;
}
wlock(fp);
if(fp->parent == nil){
wunlock(fp);
werrstr("create in deleted directory");
return nil;
}
/*
* We might encounter blank spots along the
* way due to deleted files that have not yet
* been flushed from the file list. Don't reuse
* those - some apps (e.g., omero) depend on
* the file order reflecting creation order.
* Always create at the end of the list.
*/
for(l=&fp->filelist; fl=*l; l=&fl->link){
if(fl->f && strcmp(fl->f->name, name) == 0){
wunlock(fp);
werrstr("file already exists");
return nil;
}
}
fl = emalloc9p(sizeof *fl);
*l = fl;
f = allocfile();
f->name = estrdup9p(name);
f->uid = estrdup9p(uid ? uid : fp->uid);
f->gid = estrdup9p(fp->gid);
f->muid = estrdup9p(uid ? uid : "unknown");
f->aux = aux;
f->mode = perm;
t = fp->tree;
lock(&t->genlock);
f->qid.path = t->qidgen++;
unlock(&t->genlock);
if(perm & DMDIR)
f->qid.type |= QTDIR;
if(perm & DMAPPEND)
f->qid.type |= QTAPPEND;
if(perm & DMEXCL)
f->qid.type |= QTEXCL;
f->atime = f->mtime = time(0);
f->length = 0;
f->parent = fp;
incref(fp);
f->tree = fp->tree;
incref(f); /* being returned */
incref(f); /* for the tree */
fl->f = f;
fp->nchild++;
wunlock(fp);
return f;
}
static File*
walkfile1(File *dir, char *elem)
{
File *fp;
Filelist *fl;
rlock(dir);
if(strcmp(elem, "..") == 0){
fp = dir->parent;
if(fp != nil)
incref(fp);
runlock(dir);
closefile(dir);
return fp;
}
fp = nil;
for(fl=dir->filelist; fl; fl=fl->link)
if(fl->f && strcmp(fl->f->name, elem)==0){
fp = fl->f;
incref(fp);
break;
}
runlock(dir);
closefile(dir);
return fp;
}
File*
walkfile(File *f, char *path)
{
char *os, *s, *nexts;
if(strchr(path, '/') == nil)
return walkfile1(f, path); /* avoid malloc */
os = s = estrdup9p(path);
for(; *s; s=nexts){
if(nexts = strchr(s, '/'))
*nexts++ = '\0';
else
nexts = s+strlen(s);
f = walkfile1(f, s);
if(f == nil)
break;
}
free(os);
return f;
}
Tree*
alloctree(char *uid, char *gid, ulong mode, void (*destroy)(File*))
{
char *muid;
Tree *t;
File *f;
t = emalloc9p(sizeof *t);
f = allocfile();
f->name = estrdup9p("/");
if(uid == nil){
uid = getuser();
if(uid == nil)
uid = "none";
}
uid = estrdup9p(uid);
if(gid == nil)
gid = estrdup9p(uid);
else
gid = estrdup9p(gid);
muid = estrdup9p(uid);
f->qid = (Qid){0, 0, QTDIR};
f->length = 0;
f->atime = f->mtime = time(0);
f->mode = DMDIR | mode;
f->tree = t;
f->parent = f;
f->uid = uid;
f->gid = gid;
f->muid = muid;
incref(f);
t->root = f;
t->qidgen = 0;
t->dirqidgen = 1;
if(destroy == nil)
destroy = nop;
t->destroy = destroy;
return t;
}
static void
_freefiles(File *f)
{
Filelist *fl, *flnext;
for(fl=f->filelist; fl; fl=flnext){
flnext = fl->link;
_freefiles(fl->f);
free(fl);
}
f->tree->destroy(f);
freefile(f);
}
void
freetree(Tree *t)
{
_freefiles(t->root);
free(t);
}
Readdir*
opendirfile(File *dir)
{
Readdir *r;
rlock(dir);
if((dir->mode & DMDIR)==0){
runlock(dir);
return nil;
}
r = emalloc9p(sizeof(*r));
/*
* This reference won't go away while we're
* using it because file list entries are not freed
* until the directory is removed and all refs to
* it (our fid is one!) have gone away.
*/
r->fl = dir->filelist;
r->dir = dir;
incref(&dir->readers);
runlock(dir);
return r;
}
long
readdirfile(Readdir *r, uchar *buf, long n, long o)
{
long x, m;
Filelist *fl;
if(o == 0)
fl = r->dir->filelist;
else
fl = r->fl;
for(m=0; fl && m+2<=n; fl=fl->link, m+=x){
if(fl->f == nil)
x = 0;
else if((x=convD2M(fl->f, buf+m, n-m)) <= BIT16SZ)
break;
}
r->fl = fl;
return m;
}
void
closedirfile(Readdir *r)
{
if(decref(&r->dir->readers) == 0){
wlock(r->dir);
cleanfilelist(r->dir);
wunlock(r->dir);
}
free(r);
}