#include <u.h>
#include <libc.h>
#include <auth.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>
#include "flashfs.h"

static  int     nextfnum;
static  Intmap* map;
static  Dir     dirproto;

static  char    user[]  = "flash";

       Entry   *root;
       ulong   used;
       ulong   limit;
       ulong   maxwrite;

enum
{
       debug   = 0,
};

static int
fnum(void)
{
       return ++nextfnum;
}

static void
maxfnum(int n)
{
       if(n > nextfnum)
               nextfnum = n;
}

static int
hash(char *s)
{
       int c, d, h;

       h = 0;
       while((c = *s++) != '\0') {
               d = c;
               c ^= c << 6;
               h += (c << 11) ^ (c >> 1);
               h ^= (d << 14) + (d << 7) + (d << 4) + d;
       }

       if(h < 0)
               return ~h;
       return h;
}

static void
dirinit(Entry *e)
{
       Entry **t;

       e->size = 0;
       t = emalloc9p(HSIZE * sizeof(Entry*));
       memset(t, 0, HSIZE * sizeof(Entry*));
       e->htab = t;
       e->files = nil;
       e->readers = nil;
}

static void
fileinit(Entry *e)
{
       e->size = 0;
       e->gen[0].head = nil;
       e->gen[0].tail = nil;
       e->gen[1].head = nil;
       e->gen[1].tail = nil;
}

static void
elfree(Extent *x)
{
       Extent *t;

       while(x != nil) {
               t = x->next;
               used -= x->size;
               free(x);
               x = t;
       }
}

static void
extfree(Entry *e)
{
       elfree(e->gen[0].head);
       elfree(e->gen[1].head);
}

static void
efree(Entry *e)
{
       if(debug)
               fprint(2, "free %s\n", e->name);

       if(e->mode & DMDIR)
               free(e->htab);
       else
               extfree(e);

       free(e->name);
       free(e);
}

void
einit(void)
{
       Entry *e;

       e = emalloc9p(sizeof(Entry));
       e->ref = 1;
       e->parent = nil;
       dirinit(e);
       e->name = estrdup9p("");
       e->fnum = 0;
       e->mode = DMDIR | 0775;
       e->mnum = 0;
       e->mtime = 0;
       root = e;
       map = allocmap(nil);
}

static void
dumptree(Entry *e, int n)
{
       Entry *l;

       if(debug)
               fprint(2, "%d %s %d\n", n, e->name, e->ref);

       if(e->mode & DMDIR) {
               n++;
               for(l = e->files; l != nil; l = l->fnext)
                       dumptree(l, n);
       }
}

void
edump(void)
{
       if(debug)
               dumptree(root, 0);
}

Entry *
elookup(ulong key)
{
       if(key == 0)
               return root;
       maxfnum(key);
       return lookupkey(map, key);
}

Extent *
esum(Entry *e, int sect, ulong addr, int *more)
{
       Exts *x;
       Extent *t, *u;

       x = &e->gen[eparity];
       t = x->tail;
       if(t == nil || t->sect != sect || t->addr != addr)
               return nil;
       u = t->prev;
       if(u != nil) {
               u->next = nil;
               *more = 1;
       }
       else {
               x->head = nil;
               *more = 0;
       }
       x->tail = u;
       x = &e->gen[eparity^1];
       u = x->head;
       t->next = u;
       x->head = t;
       if(u == nil)
               x->tail = t;
       else
               u->prev = t;
       return t;
}

void
edestroy(Entry *e)
{
       e->ref--;
       if(e->ref == 0)
               efree(e);
}

Entry *
ecreate(Entry *d, char *name, ulong n, ulong mode, ulong mtime, char **err)
{
       int h;
       Entry *e, *f;

       h = hash(name) & HMASK;
       for(e = d->htab[h]; e != nil; e = e->hnext) {
               if(strcmp(e->name, name) == 0) {
                       *err = Eexists;
                       return nil;
               }
       }

       e = emalloc9p(sizeof(Entry));
       e->ref = 1;
       e->parent = d;
       d->ref++;
       f = d->htab[h];
       e->hnext = f;
       e->hprev = nil;
       if(f != nil)
               f->hprev = e;
       d->htab[h] = e;
       f = d->files;
       e->fnext = f;
       e->fprev = nil;
       if(f != nil)
               f->fprev = e;
       d->files = e;

       d->ref--;
       e->ref++;
       e->name = estrdup9p(name);
       if(n == 0)
               n = fnum();
       else
               maxfnum(n);
       insertkey(map, n, e);
       e->fnum = n;
       e->mode = mode & d->mode;
       e->mnum = 0;
       e->mtime = mtime;

       if(e->mode & DMDIR)
               dirinit(e);
       else
               fileinit(e);

       d->mtime = mtime;
       return e;
}

void
etrunc(Entry *e, ulong n, ulong mtime)
{
       extfree(e);
       deletekey(map, e->fnum);
       if(n == 0)
               n = fnum();
       else
               maxfnum(n);
       e->fnum = n;
       e->mnum = 0;
       e->mtime = mtime;
       insertkey(map, n, e);
       fileinit(e);
       e->parent->mtime = mtime;
}

char *
eremove(Entry *e)
{
       Dirr *r;
       Entry *d, *n, *p;

       d = e->parent;
       if(d == nil)
               return Eperm;

       if((e->mode & DMDIR) != 0 && e->files != nil)
               return Edirnotempty;

       p = e->hprev;
       n = e->hnext;
       if(n != nil)
               n->hprev = p;
       if(p != nil)
               p->hnext = n;
       else
               d->htab[hash(e->name) & HMASK] = n;

       for(r = d->readers; r != nil; r = r->next) {
               if(r->cur == e)
                       r->cur = e->fnext;
       }

       p = e->fprev;
       n = e->fnext;
       if(n != nil)
               n->fprev = p;
       if(p != nil)
               p->fnext = n;
       else
               d->files = n;

       e->parent = nil;
       d->ref--;
       deletekey(map, e->fnum);
       edestroy(e);
       return nil;
}

Entry *
ewalk(Entry *d, char *name, char **err)
{
       Entry *e;

       if((d->mode & DMDIR) == 0) {
               *err = Enotdir;
               return nil;
       }

       if(strcmp(name, "..") == 0) {
               e = d->parent;
               if(e == nil)
                       return d;
               edestroy(d);
               e->ref++;
               return e;
       }

       for(e = d->htab[hash(name) & HMASK]; e != nil; e = e->hnext) {
               if(strcmp(e->name, name) == 0) {
                       d->ref--;
                       e->ref++;
                       return e;
               }
       }

       *err = Enonexist;
       return nil;
}

static void
eread0(Extent *e, Extent *x, uchar *a, ulong n, ulong off)
{
       uchar *a0, *a1;
       ulong n0, n1, o0, o1, d, z;

       for(;;) {
               while(e != nil) {
                       if(off < e->off + e->size && off + n > e->off) {
                               if(off >= e->off) {
                                       d = off - e->off;
                                       z = e->size - d;
                                       if(n <= z) {
                                               readdata(e->sect, a, n, e->addr + d);
                                               return;
                                       }
                                       readdata(e->sect, a, z, e->addr + d);
                                       a += z;
                                       n -= z;
                                       off += z;
                               }
                               else {
                                       a0 = a;
                                       n0 = e->off - off;
                                       o0 = off;
                                       a += n0;
                                       n -= n0;
                                       off += n0;
                                       z = e->size;
                                       if(n <= z) {
                                               readdata(e->sect, a, n, e->addr);
                                               a = a0;
                                               n = n0;
                                               off = o0;
                                       }
                                       else {
                                               readdata(e->sect, a, z, e->addr);
                                               a1 = a + z;
                                               n1 = n - z;
                                               o1 = off + z;
                                               if(n0 < n1) {
                                                       eread0(e->next, x, a0, n0, o0);
                                                       a = a1;
                                                       n = n1;
                                                       off = o1;
                                               }
                                               else {
                                                       eread0(e->next, x, a1, n1, o1);
                                                       a = a0;
                                                       n = n0;
                                                       off = o0;
                                               }
                                       }
                               }
                       }
                       e = e->next;
               }

               if(x == nil)
                       break;

               e = x;
               x = nil;
       }

       memset(a, 0, n);
}

ulong
eread(Entry *e, int parity, void *a, ulong n, ulong off)
{
       if(n + off >= e->size)
               n = e->size - off;
       if(n <= 0)
               return 0;
       eread0(e->gen[parity].head, e->gen[parity^1].head, a, n, off);
       return n;
}

void
ewrite(Entry *e, Extent *x, int parity, ulong mtime)
{
       ulong z;
       Extent *t;

       t = e->gen[parity].head;
       x->next = t;
       x->prev = nil;
       e->gen[parity].head = x;
       if(t == nil)
               e->gen[parity].tail = x;
       else
               t->prev = x;
       if(mtime != 0)
               e->mtime = mtime;
       used += x->size;
       z = x->off + x->size;
       if(z > e->size)
               e->size = z;
}

ulong
echmod(Entry *e, ulong mode, ulong mnum)
{
       if(mnum != 0)
               e->mnum = mnum;
       else
               e->mnum++;
       e->mode &= ~0777;
       e->mode |= mode;
       return e->mnum;
}

Qid
eqid(Entry *e)
{
       Qid qid;

       if(e->mode & DMDIR)
               qid.type = QTDIR;
       else
               qid.type = 0;
       qid.path = e->fnum;
       return qid;
}

void
estat(Entry *e, Dir *d, int alloc)
{
       d->type = 'z';
       d->dev = 0;
       if(alloc) {
               d->uid = estrdup9p(user);
               d->gid = estrdup9p(user);
               d->muid = estrdup9p(user);
               d->name = estrdup9p(e->name);
       }
       else {
               d->uid = user;
               d->gid = user;
               d->muid = user;
               d->name = e->name;
       }
       d->mode = e->mode;
       d->length = e->size;
       d->atime = e->mtime;
       d->mtime = e->mtime;
       d->qid = eqid(e);
}

Dirr *
ediropen(Entry *e)
{
       Dirr *d, *t;

       d = emalloc9p(sizeof(Dirr));
       d->dir = e;
       d->cur = e->files;
       t = e->readers;
       d->next = t;
       d->prev = nil;
       if(t != nil)
               t->prev = d;
       e->readers = d;
       e->ref++;
       return d;
}

int
edirread(Dirr *r, char *a, long n)
{
       Dir d;
       Entry *e;
       int m, x;

       m = 0;
       for(e = r->cur; e != nil; e = e->fnext) {
               estat(e, &d, 0);
               x = convD2M(&d, (uchar *)a, n);
               if(x <= BIT16SZ)
                       break;
               a += x;
               n -= x;
               m += x;
       }

       r->cur = e;
       return m;
}

void
edirclose(Dirr *d)
{
       Entry *e;
       Dirr *p, *n;

       e = d->dir;
       p = d->prev;
       n = d->next;
       if(n != nil)
               n->prev = p;
       if(p != nil)
               p->next = n;
       else
               e->readers = n;

       edestroy(e);
       free(d);
}

static  Renum   R;

static void
xrenum(Extent *x)
{
       while(x != nil) {
               if(x->sect == R.old)
                       x->sect = R.new;
               x = x->next;
       }
}

static void
renum(Entry *e)
{
       if(e->mode & DMDIR) {
               for(e = e->files; e != nil; e = e->fnext)
                       renum(e);
       }
       else {
               xrenum(e->gen[0].head);
               xrenum(e->gen[1].head);
       }
}

void
erenum(Renum *r)
{
       R = *r;
       renum(root);
}

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.