ref: 52d407f86f35b4a9f2be36c6d61032e2ecb9f754
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 x, m; Filelist *fl; for(fl=r->fl, 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); }