ref: 197550f634b54088c39c337ce55f6b01097659b8
dir: /unionfs.c/
#include <u.h> #include <libc.h> #include <fcall.h> #include <thread.h> #include <9p.h> typedef struct Union Union; typedef struct Fil Fil; typedef struct Flist Flist; typedef struct Fstate Fstate; typedef struct Qidmap Qidmap; struct Union { char *root; int create; Union *prev, *next; }; enum { Nqidbits = 5, Nqidmap = 1 << Nqidbits, }; struct Qidmap { Ref; ushort type; uint dev; uvlong path; uvlong qpath; Qidmap *next; }; struct Fil { Ref; Dir; Qidmap *qmap; char *path; /* real path */ char *fspath; /* internal path */ }; struct Flist { Fil *file; Flist *next; }; struct Fstate { int fd; Fil *file; Flist *dir, *idx; }; Union u0 = {.next = &u0, .prev = &u0}; Union *unionlist = &u0; uvlong qidnext; Qidmap *qidmap[Nqidmap]; void LOG(char *fmt, ...) { static int fd = -1; va_list args; if(fd < 0 && (fd = open("/mnt/log/log", OWRITE)) < 0){ fprint(2, "failed to open log pipe\n"); return; } va_start(args, fmt); vfprint(fd, fmt, args); va_end(args); } void* emalloc(ulong sz) { void *v; if((v = malloc(sz)) == nil) sysfatal("emalloc: %r"); memset(v, 0, sz); setmalloctag(v, getcallerpc(&sz)); return v; } char* estrdup(char *s) { char *p; if((p = strdup(s)) == nil) sysfatal("estrdup: %r"); setmalloctag(p, getcallerpc(&s)); return p; } char* esmprint(char *fmt, ...) { char *s; va_list arg; va_start(arg, fmt); s = vsmprint(fmt, arg); va_end(arg); if(s == nil) sysfatal("esmprint: %r"); return s; } Ref* copyref(Ref *r) { incref(r); return r; } int qidhash(uvlong path) { int h, n; h = 0; for(n = 0; n < 64; n += Nqidbits){ h ^= path; path >>= Nqidbits; } return h & (Nqidmap-1); } Qidmap* qidlookup(Dir *d) { int h; Qidmap *q; h = qidhash(d->qid.path); for(q = qidmap[h]; q != nil; q = q->next) if(q->type == d->type && q->dev == d->dev && q->path == d->qid.path) return q; return nil; } int qidexists(uvlong path) { int h; Qidmap *q; for(h = 0; h < Nqidmap; h++) for(q = qidmap[h]; q != nil; q = q->next) if(q->qpath == path) return 1; return 0; } Qidmap* qidnew(Dir *d) { int h; uvlong path; Qidmap *q; q = qidlookup(d); if(q != nil) return (Qidmap*)copyref(q); path = d->qid.path; while(qidexists(path)){ path &= (1LL<<48)-1; if(++qidnext >= 1<<16) qidnext = 1; path |= qidnext<<48; } q = emalloc(sizeof(*q)); q->type = d->type; q->dev = d->dev; q->path = d->qid.path; q->qpath = path; h = qidhash(q->path); q->next = qidmap[h]; qidmap[h] = q; return (Qidmap*)copyref(q); } void qidfree(Qidmap *q) { int h; Qidmap *l; if(q == nil) return; if(decref(q)) return; h = qidhash(q->path); if(qidmap[h] == q) qidmap[h] = q->next; else{ for(l = qidmap[h]; l->next != q; l = l->next) ; l->next = q->next; } free(q); } void unionlink(Union *p, Union *n) { p = p->prev; n->next = p->next; n->prev = p; p->next->prev = n; p->next = n; } Fil* filenew(Dir *d) { Fil *f; f = emalloc(sizeof(*f)); f->ref = 1; f->qmap = qidnew(d); f->Dir = *d; f->qid.path = f->qmap->qpath; f->name = estrdup(d->name); f->uid = estrdup(d->uid); f->gid = estrdup(d->gid); f->muid = estrdup(d->muid); return f; } void filefree(Fil *f) { if(f == nil) return; if(decref(f)) return; // qidfree(f->qmap); free(f->name); free(f->uid); free(f->gid); free(f->muid); free(f->path); free(f->fspath); free(f); } void flistadd(Flist **list, Fil *f) { Flist *p; p = emalloc(sizeof(*p)); p->file = f; p->next = *list; *list = p; } void flistfree(Flist *l) { Flist *lp; for(lp = l; lp != nil; l = lp){ lp = lp->next; filefree(l->file); free(l); } } int flisthas(Flist *list, char *name) { for(; list != nil; list = list->next) if(strcmp(list->file->name, name) == 0) return 1; return 0; } Fstate* fstatenew(Fil *f) { Fstate *st; st = emalloc(sizeof(*st)); st->fd = -1; st->file = (Fil*)copyref(f); return st; } void fstatefree(Fstate *st) { if(st == nil) return; filefree(st->file); flistfree(st->dir); close(st->fd); free(st); } void fsattach(Req *r) { Dir d; Fil *root; Fstate *st; nulldir(&d); d.qid = (Qid){0, 0, QTDIR}; d.name = "."; d.mode = 0777|DMDIR; d.uid = r->fid->uid; d.gid = r->fid->uid; d.muid = r->fid->uid; d.mtime = time(0); d.atime = time(0); d.length = 0; root = filenew(&d); root->fspath = estrdup(d.name); root->path = estrdup(d.name); st = fstatenew(root); decref(root); r->fid->aux = st; r->fid->qid = root->qid; r->ofcall.qid = root->qid; respond(r, nil); } Fil* filewalk(Fil *p, char *name) { char *path; char *s; Dir *d; Fil *f; Union *u; if(strcmp(name, "..") == 0){ s = strrchr(p->fspath, '/'); if(s == nil) return p; *s = 0; return filewalk(p, ""); } for(u = unionlist->next; u != unionlist; u = u->next){ path = esmprint("%s/%s/%s", u->root, p->fspath, name); d = dirstat(path); if(d != nil){ f = filenew(d); free(d); f->fspath = cleanname(esmprint("%s/%s", p->fspath, name)); f->path = cleanname(path); return f; } free(path); } return nil; } char* walk1(Fid *fid, char *name, void *) { Fil *p, *f; Fstate *st; st = fid->aux; p = st->file; f = filewalk(p, name); if(f == nil) return "no file"; st->file = f; filefree(p); fid->qid = f->qid; return nil; } char* clone(Fid *old, Fid *new, void*) { Fstate *fs; fs = old->aux; new->aux = fstatenew(fs->file); return nil; } void destroyfid(Fid *fid) { fstatefree((Fstate*)fid->aux); } void fswalk(Req *r) { walkandclone(r, walk1, clone, nil); } Flist* filereaddir(Fil *p) { int fd; long i, n; Dir *dir, *d; char *path; Union *u; Fil *f; Flist *list; list = nil; for(u = unionlist->next; u != unionlist; u = u->next){ path = esmprint("%s/%s", u->root, p->fspath); d = dirstat(path); if(d == nil){ free(path); continue; } free(d); fd = open(path, OREAD); if(fd < 0){ free(path); continue; } free(path); n = dirreadall(fd, &dir); close(fd); if(n < 0) continue; for(i = 0; i < n; i++){ if(flisthas(list, dir[i].name)) continue; f = filenew(&dir[i]); flistadd(&list, f); } free(dir); } return list; } void fsopen(Req *r) { Fcall *i, *o; Fstate *st; Fil *f; i = &r->ifcall; o = &r->ofcall; st = r->fid->aux; f = st->file; if(f->mode&DMDIR){ st->dir = filereaddir(f); st->idx = st->dir; }else{ st->fd = open(f->path, i->mode); if(st->fd < 0){ responderror(r); return; } o->iounit = iounit(st->fd); } respond(r, nil); } void fscreate(Req *r) { char *path, *npath; Dir *d; Fcall *i, *o; Union *u; Fstate *st; Fil *f, *nf; i = &r->ifcall; o = &r->ofcall; st = r->fid->aux; f = st->file; for(u = unionlist->next; u != unionlist; u = u->next) if(u->create == 1) break; assert(u != unionlist); path = cleanname(esmprint("%s/%s", u->root, f->fspath)); d = dirstat(path); if(d != nil) goto work; for(u = unionlist->next; u != unionlist; u = u->next){ if(u->create == 1) continue; free(path); path = cleanname(esmprint("%s/%s", u->root, f->fspath)); d = dirstat(path); if(d != nil){ free(d); goto work; } } sysfatal("something's fucked"); work: npath = cleanname(esmprint("%s/%s", path, i->name)); free(path); st = emalloc(sizeof(*st)); st->fd = create(npath, i->mode, i->perm); if(st->fd < 0){ responderror(r); return; } d = dirfstat(st->fd); if(d == nil){ fstatefree(st); responderror(r); return; } nf = filenew(d); free(d); nf->path = npath; nf->fspath = estrdup(f->fspath); st->file = nf; r->fid->aux = st; r->fid->qid = f->qid; o->qid = f->qid; respond(r, nil); } void fsremove(Req *r) { Fstate *st; Fil *f; st = r->fid->aux; f = st->file; if(remove(f->path) < 0){ responderror(r); return; } respond(r, nil); } void dirfill(Dir *dir, Fil *f) { *dir = f->Dir; dir->qid = f->qid; dir->name = estrdup(f->name); dir->uid = estrdup(f->uid); dir->gid = estrdup(f->gid); dir->muid = estrdup(f->muid); } int dirgen(int, Dir *dir, void *aux) { Fstate *fs; Flist *l; fs = aux; l = fs->idx; if(l == nil) return -1; dirfill(dir, l->file); fs->idx = l->next; return 0; } void fsread(Req *r) { long n; Fcall *i, *o; Fil *f; Fstate *st; i = &r->ifcall; o = &r->ofcall; st = r->fid->aux; f = st->file; if(f->mode&DMDIR){ dirread9p(r, dirgen, st); respond(r, nil); return; } if((n = pread(st->fd, o->data, i->count, i->offset)) < 0){ responderror(r); return; } r->ofcall.count = n; respond(r, nil); } void fswrite(Req *r) { Fcall *i, *o; Fstate *fs; i = &r->ifcall; o = &r->ofcall; fs = r->fid->aux; if((o->count = pwrite(fs->fd, i->data, i->count, i->offset)) != i->count){ responderror(r); return; } respond(r, nil); } void fsstat(Req *r) { Fstate *st; st = r->fid->aux; dirfill(&r->d, st->file); respond(r, nil); } void fswstat(Req *r) { Fstate *st; Fil *f; st = r->fid->aux; f = st->file; if(dirwstat(f->path, &r->d) < 0){ responderror(r); return; } respond(r, nil); } Srv fs = { .attach = fsattach, .walk = fswalk, .open = fsopen, .create = fscreate, .remove = fsremove, .read = fsread, .write = fswrite, .stat = fsstat, .wstat = fswstat, .destroyfid = destroyfid, }; void usage(void) { fprint(2, "%s [-D] [-abC] -m mtpt | -s srv [[-c] path ...]\n", argv0); exits("usage"); } void main(int argc, char *argv[]) { int c, i; int mflag; char *mtpt, *srv; Union *u; c = 0; mflag = MREPL|MCREATE; mtpt = nil; srv = nil; ARGBEGIN{ case 'a': mflag |= MAFTER; break; case 'b': mflag |= MBEFORE; break; case 'c': c++; break; case 'C': mflag |= MCACHE; break; case 'D': chatty9p++; break; case 'm': mtpt = EARGF(usage()); break; case 's': srv = EARGF(usage()); break; default: usage(); }ARGEND; if(argc < 1) usage(); if(mtpt == nil && srv == nil) usage(); for(i = 0; i < argc; i++){ if(strncmp(argv[i], "-c", 2) == 0){ c++; continue; } u = emalloc(sizeof(*u)); u->create = c == 1 ? c : 0; u->root = estrdup(cleanname(argv[i])); unionlink(unionlist, u); } if(c == 0) unionlist->next->create = 1; postmountsrv(&fs, srv, mtpt, mflag); exits(nil); }