Subversion Repositories planix.SVN

#include        "u.h"
#include        "lib.h"
#include        "dat.h"
#include        "fns.h"
#include        "error.h"

typedef struct Fid      Fid;
typedef struct Export   Export;
typedef struct Exq      Exq;

#define nil     ((void*)0)

enum
{
        Nfidhash        = 1,
        MAXRPC          = MAXMSG+MAXFDATA,
        MAXDIRREAD      = (MAXFDATA/DIRLEN)*DIRLEN
};

struct Export
{
        Ref     r;
        Exq*    work;
        Lock    fidlock;
        Fid*    fid[Nfidhash];
        Chan*   root;
        Chan*   io;
        Pgrp*   pgrp;
        int     npart;
        char    part[MAXRPC];
};

struct Fid
{
        Fid*    next;
        Fid**   last;
        Chan*   chan;
        long    offset;
        int     fid;
        int     ref;            /* fcalls using the fid; locked by Export.Lock */
        int     attached;       /* fid attached or cloned but not clunked */
};

struct Exq
{
        Lock    lk;
        int     nointr;
        int     noresponse;     /* don't respond to this one */
        Exq*    next;
        int     shut;           /* has been noted for shutdown */
        Export* export;
        void*   slave;
        Fcall   rpc;
        char    buf[MAXRPC];
};

struct
{
        Lock    l;
        Qlock   qwait;
        Rendez  rwait;
        Exq     *head;          /* work waiting for a slave */
        Exq     *tail;
}exq;

static void     exshutdown(Export*);
static void     exflush(Export*, int, int);
static void     exslave(void*);
static void     exfree(Export*);
static void     exportproc(Export*);

static char*    Exauth(Export*, Fcall*);
static char*    Exattach(Export*, Fcall*);
static char*    Exclunk(Export*, Fcall*);
static char*    Excreate(Export*, Fcall*);
static char*    Exopen(Export*, Fcall*);
static char*    Exread(Export*, Fcall*);
static char*    Exremove(Export*, Fcall*);
static char*    Exstat(Export*, Fcall*);
static char*    Exwalk(Export*, Fcall*);
static char*    Exwrite(Export*, Fcall*);
static char*    Exwstat(Export*, Fcall*);
static char*    Exversion(Export*, Fcall*);

static char     *(*fcalls[Tmax])(Export*, Fcall*);

static char     Enofid[]   = "no such fid";
static char     Eseekdir[] = "can't seek on a directory";
static char     Ereaddir[] = "unaligned read of a directory";
static int      exdebug = 0;

int
sysexport(int fd)
{
        Chan *c;
        Export *fs;

        if(waserror())
                return -1;

        c = fdtochan(fd, ORDWR, 1, 1);
        poperror();
        c->flag |= CMSG;

        fs = mallocz(sizeof(Export));
        fs->r.ref = 1;
        fs->pgrp = up->pgrp;
        refinc(&fs->pgrp->r);
        refinc(&up->slash->r);
        fs->root = up->slash;
        refinc(&fs->root->r);
        fs->root = domount(fs->root);
        fs->io = c;

        exportproc(fs);

        return 0;
}

static void
exportinit(void)
{
        lock(&exq.l);
        if(fcalls[Tversion] != nil) {
                unlock(&exq.l);
                return;
        }

        fmtinstall('F', fcallfmt);
        fmtinstall('D', dirfmt);
        fmtinstall('M', dirmodefmt);
        fcalls[Tversion] = Exversion;
        fcalls[Tauth] = Exauth;
        fcalls[Tattach] = Exattach;
        fcalls[Twalk] = Exwalk;
        fcalls[Topen] = Exopen;
        fcalls[Tcreate] = Excreate;
        fcalls[Tread] = Exread;
        fcalls[Twrite] = Exwrite;
        fcalls[Tclunk] = Exclunk;
        fcalls[Tremove] = Exremove;
        fcalls[Tstat] = Exstat;
        fcalls[Twstat] = Exwstat;
        unlock(&exq.l);
}

void
exportproc(Export *fs)
{
        Exq *q;
        char *buf;
        int n, cn, len;

        exportinit();

        for(;;){
                q = mallocz(sizeof(Exq));
                if(q == 0)
                        panic("no memory");

                q->rpc.data = q->buf + MAXMSG;

                buf = q->buf;
                len = MAXRPC;
                if(fs->npart) {
                        memmove(buf, fs->part, fs->npart);
                        buf += fs->npart;
                        len -= fs->npart;
                        goto chk;
                }
                for(;;) {
                        if(waserror())
                                goto bad;

                        n = (*devtab[fs->io->type].read)(fs->io, buf, len, 0);
                        poperror();

                        if(n <= 0)
                                goto bad;

                        buf += n;
                        len -= n;
        chk:
                        n = buf - q->buf;

                        /* convM2S returns size of correctly decoded message */
                        cn = convM2S(q->buf, &q->rpc, n);
                        if(cn < 0){
                                iprint("bad message type in devmnt\n");
                                goto bad;
                        }
                        if(cn > 0) {
                                n -= cn;
                                if(n < 0){
                                        iprint("negative size in devmnt");
                                        goto bad;
                                }
                                fs->npart = n;
                                if(n != 0)
                                        memmove(fs->part, q->buf+cn, n);
                                break;
                        }
                }
                if(exdebug)
                        iprint("export %d <- %F\n", getpid(), &q->rpc);

                if(q->rpc.type == Tflush){
                        exflush(fs, q->rpc.tag, q->rpc.oldtag);
                        free(q);
                        continue;
                }

                q->export = fs;
                refinc(&fs->r);

                lock(&exq.l);
                if(exq.head == nil)
                        exq.head = q;
                else
                        exq.tail->next = q;
                q->next = nil;
                exq.tail = q;
                unlock(&exq.l);
                if(exq.qwait.first == nil) {
                        n = thread("exportfs", exslave, nil);
/* iprint("launch export (pid=%ux)\n", n); */
                }
                rendwakeup(&exq.rwait);
        }
bad:
        free(q);
        exshutdown(fs);
        exfree(fs);
}

void
exflush(Export *fs, int flushtag, int tag)
{
        Exq *q, **last;
        int n;
        Fcall fc;
        char buf[MAXMSG];

        /* hasn't been started? */
        lock(&exq.l);
        last = &exq.head;
        for(q = exq.head; q != nil; q = q->next){
                if(q->export == fs && q->rpc.tag == tag){
                        *last = q->next;
                        unlock(&exq.l);
                        exfree(fs);
                        free(q);
                        goto Respond;
                }
                last = &q->next;
        }
        unlock(&exq.l);

        /* in progress? */
        lock(&fs->r.l);
        for(q = fs->work; q != nil; q = q->next){
                if(q->rpc.tag == tag && !q->noresponse){
                        lock(&q->lk);
                        q->noresponse = 1;
                        if(!q->nointr)
                                intr(q->slave);
                        unlock(&q->lk);
                        unlock(&fs->r.l);
                        goto Respond;
                        return;
                }
        }
        unlock(&fs->r.l);

if(exdebug) iprint("exflush: did not find rpc: %d\n", tag);

Respond:
        fc.type = Rflush;
        fc.tag = flushtag;
        n = convS2M(&fc, buf);
if(exdebug) iprint("exflush -> %F\n", &fc);
        if(!waserror()){
                (*devtab[fs->io->type].write)(fs->io, buf, n, 0);
                poperror();
        }
}

void
exshutdown(Export *fs)
{
        Exq *q, **last;

        lock(&exq.l);
        last = &exq.head;
        for(q = exq.head; q != nil; q = *last){
                if(q->export == fs){
                        *last = q->next;
                        exfree(fs);
                        free(q);
                        continue;
                }
                last = &q->next;
        }
        unlock(&exq.l);

        lock(&fs->r.l);
        q = fs->work;
        while(q != nil){
                if(q->shut){
                        q = q->next;
                        continue;
                }
                q->shut = 1;
                unlock(&fs->r.l);
        /*      postnote(q->slave, 1, "interrupted", NUser);    */
                iprint("postnote 2!\n");
                lock(&fs->r.l);
                q = fs->work;
        }
        unlock(&fs->r.l);
}

void
exfree(Export *fs)
{
        Fid *f, *n;
        int i;

        if(refdec(&fs->r) != 0)
                return;
        closepgrp(fs->pgrp);
        cclose(fs->root);
        cclose(fs->io);
        for(i = 0; i < Nfidhash; i++){
                for(f = fs->fid[i]; f != nil; f = n){
                        if(f->chan != nil)
                                cclose(f->chan);
                        n = f->next;
                        free(f);
                }
        }
        free(fs);
}

int
exwork(void *a)
{
        return exq.head != nil;
}

void
exslave(void *a)
{
        Export *fs;
        Exq *q, *t, **last;
        char *err;
        int n;
/*
        closepgrp(up->pgrp);
        up->pgrp = nil;
*/
        for(;;){
                qlock(&exq.qwait);
                rendsleep(&exq.rwait, exwork, nil);

                lock(&exq.l);
                q = exq.head;
                if(q == nil) {
                        unlock(&exq.l);
                        qunlock(&exq.qwait);
                        continue;
                }
                exq.head = q->next;
                q->slave = curthread();
                unlock(&exq.l);

                qunlock(&exq.qwait);

                q->noresponse = 0;
                q->nointr = 0;
                fs = q->export;
                lock(&fs->r.l);
                q->next = fs->work;
                fs->work = q;
                unlock(&fs->r.l);

                up->pgrp = q->export->pgrp;

                if(exdebug > 1)
                        iprint("exslave dispatch %d %F\n", getpid(), &q->rpc);

                if(waserror()){
                        iprint("exslave err %r\n");
                        err = up->errstr;
                        goto Err;
                }
                if(q->rpc.type >= Tmax || !fcalls[q->rpc.type])
                        err = "bad fcall type";
                else
                        err = (*fcalls[q->rpc.type])(fs, &q->rpc);

                poperror();
                Err:;
                q->rpc.type++;
                if(err){
                        q->rpc.type = Rerror;
                        strncpy(q->rpc.ename, err, ERRLEN);
                }
                n = convS2M(&q->rpc, q->buf);

                if(exdebug)
                        iprint("exslve %d -> %F\n", getpid(), &q->rpc);

                lock(&q->lk);
                if(q->noresponse == 0){
                        q->nointr = 1;
                        clearintr();
                        if(!waserror()){
                                (*devtab[fs->io->type].write)(fs->io, q->buf, n, 0);
                                poperror();
                        }
                }
                unlock(&q->lk);

                /*
                 * exflush might set noresponse at this point, but
                 * setting noresponse means don't send a response now;
                 * it's okay that we sent a response already.
                 */
                if(exdebug > 1)
                        iprint("exslave %d written %d\n", getpid(), q->rpc.tag);

                lock(&fs->r.l);
                last = &fs->work;
                for(t = fs->work; t != nil; t = t->next){
                        if(t == q){
                                *last = q->next;
                                break;
                        }
                        last = &t->next;
                }
                unlock(&fs->r.l);

                exfree(q->export);
                free(q);
        }
        iprint("exslave shut down");
        threadexit();
}

Fid*
Exmkfid(Export *fs, int fid)
{
        ulong h;
        Fid *f, *nf;

        nf = mallocz(sizeof(Fid));
        if(nf == nil)
                return nil;
        lock(&fs->fidlock);
        h = fid % Nfidhash;
        for(f = fs->fid[h]; f != nil; f = f->next){
                if(f->fid == fid){
                        unlock(&fs->fidlock);
                        free(nf);
                        return nil;
                }
        }

        nf->next = fs->fid[h];
        if(nf->next != nil)
                nf->next->last = &nf->next;
        nf->last = &fs->fid[h];
        fs->fid[h] = nf;

        nf->fid = fid;
        nf->ref = 1;
        nf->attached = 1;
        nf->offset = 0;
        nf->chan = nil;
        unlock(&fs->fidlock);
        return nf;
}

Fid*
Exgetfid(Export *fs, int fid)
{
        Fid *f;
        ulong h;

        lock(&fs->fidlock);
        h = fid % Nfidhash;
        for(f = fs->fid[h]; f; f = f->next) {
                if(f->fid == fid){
                        if(f->attached == 0)
                                break;
                        f->ref++;
                        unlock(&fs->fidlock);
                        return f;
                }
        }
        unlock(&fs->fidlock);
        return nil;
}

void
Exputfid(Export *fs, Fid *f)
{
        lock(&fs->fidlock);
        f->ref--;
        if(f->ref == 0 && f->attached == 0){
                if(f->chan != nil)
                        cclose(f->chan);
                f->chan = nil;
                *f->last = f->next;
                if(f->next != nil)
                        f->next->last = f->last;
                unlock(&fs->fidlock);
                free(f);
                return;
        }
        unlock(&fs->fidlock);
}

char*
Exsession(Export *e, Fcall *rpc)
{
        memset(rpc->authid, 0, sizeof(rpc->authid));
        memset(rpc->authdom, 0, sizeof(rpc->authdom));
        memset(rpc->chal, 0, sizeof(rpc->chal));
        return nil;
}

char*
Exauth(Export *e, Fcall *f)
{
        return "authentication not required";
}

char*
Exattach(Export *fs, Fcall *rpc)
{
        Fid *f;

        f = Exmkfid(fs, rpc->fid);
        if(f == nil)
                return Einuse;
        if(waserror()){
                f->attached = 0;
                Exputfid(fs, f);
                return up->errstr;
        }
        f->chan = clone(fs->root, nil);
        poperror();
        rpc->qid = f->chan->qid;
        Exputfid(fs, f);
        return nil;
}

char*
Exclone(Export *fs, Fcall *rpc)
{
        Fid *f, *nf;

        if(rpc->fid == rpc->newfid)
                return Einuse;
        f = Exgetfid(fs, rpc->fid);
        if(f == nil)
                return Enofid;
        nf = Exmkfid(fs, rpc->newfid);
        if(nf == nil){
                Exputfid(fs, f);
                return Einuse;
        }
        if(waserror()){
                Exputfid(fs, f);
                Exputfid(fs, nf);
                return up->errstr;
        }
        nf->chan = clone(f->chan, nil);
        poperror();
        Exputfid(fs, f);
        Exputfid(fs, nf);
        return nil;
}

char*
Exclunk(Export *fs, Fcall *rpc)
{
        Fid *f;

        f = Exgetfid(fs, rpc->fid);
        if(f != nil){
                f->attached = 0;
                Exputfid(fs, f);
        }
        return nil;
}

char*
Exwalk(Export *fs, Fcall *rpc)
{
        Fid *f;
        Chan *c;

        f = Exgetfid(fs, rpc->fid);
        if(f == nil)
                return Enofid;
        if(waserror()){
                Exputfid(fs, f);
                return up->errstr;
        }
        c = walk(f->chan, rpc->name, 1);
        if(c == nil)
                error(Enonexist);
        poperror();

        f->chan = c;
        rpc->qid = c->qid;
        Exputfid(fs, f);
        return nil;
}

char*
Exopen(Export *fs, Fcall *rpc)
{
        Fid *f;
        Chan *c;

        f = Exgetfid(fs, rpc->fid);
        if(f == nil)
                return Enofid;
        if(waserror()){
                Exputfid(fs, f);
                return up->errstr;
        }
        c = f->chan;
        c = (*devtab[c->type].open)(c, rpc->mode);
        poperror();

        f->chan = c;
        f->offset = 0;
        rpc->qid = f->chan->qid;
        Exputfid(fs, f);
        return nil;
}

char*
Excreate(Export *fs, Fcall *rpc)
{
        Fid *f;
        Chan *c;

        f = Exgetfid(fs, rpc->fid);
        if(f == nil)
                return Enofid;
        if(waserror()){
                Exputfid(fs, f);
                return up->errstr;
        }
        c = f->chan;
        if(c->mnt && !(c->flag&CCREATE))
                c = createdir(c);
        (*devtab[c->type].create)(c, rpc->name, rpc->mode, rpc->perm);
        poperror();

        f->chan = c;
        rpc->qid = f->chan->qid;
        Exputfid(fs, f);
        return nil;
}

char*
Exread(Export *fs, Fcall *rpc)
{
        Fid *f;
        Chan *c;
        long off;
        int dir, n, seek;

        f = Exgetfid(fs, rpc->fid);
        if(f == nil)
                return Enofid;

        c = f->chan;
        dir = c->qid.path & CHDIR;
        if(dir){
                rpc->count -= rpc->count%DIRLEN;
                if(rpc->offset%DIRLEN || rpc->count==0){
                        Exputfid(fs, f);
                        return Ereaddir;
                }
                if(f->offset > rpc->offset){
                        Exputfid(fs, f);
                        return Eseekdir;
                }
        }

        if(waserror()) {
                Exputfid(fs, f);
                return up->errstr;
        }

        for(;;){
                n = rpc->count;
                seek = 0;
                off = rpc->offset;
                if(dir && f->offset != off){
                        off = f->offset;
                        n = rpc->offset - off;
                        if(n > MAXDIRREAD)
                                n = MAXDIRREAD;
                        seek = 1;
                }
                if(dir && c->mnt != nil)
                        n = unionread(c, rpc->data, n);
                else{
                        c->offset = off;
                        n = (*devtab[c->type].read)(c, rpc->data, n, off);
                }
                if(n == 0 || !seek)
                        break;
                f->offset = off + n;
                c->offset += n;
        }
        rpc->count = n;
        poperror();
        Exputfid(fs, f);
        return nil;
}

char*
Exwrite(Export *fs, Fcall *rpc)
{
        Fid *f;
        Chan *c;

        f = Exgetfid(fs, rpc->fid);
        if(f == nil)
                return Enofid;
        if(waserror()){
                Exputfid(fs, f);
                return up->errstr;
        }
        c = f->chan;
        if(c->qid.path & CHDIR)
                error(Eisdir);
        rpc->count = (*devtab[c->type].write)(c, rpc->data, rpc->count, rpc->offset);
        poperror();
        Exputfid(fs, f);
        return nil;
}

char*
Exstat(Export *fs, Fcall *rpc)
{
        Fid *f;
        Chan *c;

        f = Exgetfid(fs, rpc->fid);
        if(f == nil)
                return Enofid;
        if(waserror()){
                Exputfid(fs, f);
                return up->errstr;
        }
        c = f->chan;
        (*devtab[c->type].stat)(c, rpc->stat);
        poperror();
        Exputfid(fs, f);
        return nil;
}

char*
Exwstat(Export *fs, Fcall *rpc)
{
        Fid *f;
        Chan *c;

        f = Exgetfid(fs, rpc->fid);
        if(f == nil)
                return Enofid;
        if(waserror()){
                Exputfid(fs, f);
                return up->errstr;
        }
        c = f->chan;
        (*devtab[c->type].wstat)(c, rpc->stat);
        poperror();
        Exputfid(fs, f);
        return nil;
}

char*
Exremove(Export *fs, Fcall *rpc)
{
        Fid *f;
        Chan *c;

        f = Exgetfid(fs, rpc->fid);
        if(f == nil)
                return Enofid;
        if(waserror()){
                Exputfid(fs, f);
                return up->errstr;
        }
        c = f->chan;
        (*devtab[c->type].remove)(c);
        poperror();

        /*
         * chan is already clunked by remove.
         * however, we need to recover the chan,
         * and follow sysremove's lead in making to point to root.
         */
        c->type = 0;

        f->attached = 0;
        Exputfid(fs, f);
        return nil;
}