Subversion Repositories planix.SVN

#include        <u.h>
#include        <libc.h>
#include        <fcall.h>
#include        "compat.h"
#include        "error.h"

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

enum
{
        Nfidhash        = 32,
        Maxfdata        = 8192,
        Maxrpc          = IOHDRSZ + Maxfdata,
};

struct Export
{
        Ref     r;
        Exq*    work;
        Lock    fidlock;
        Fid*    fid[Nfidhash];
        int     io;             /* fd to read/write */
        int     iounit;
        int     nroots;
        Chan    **roots;
};

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     responding;     /* writing out reply message */
        int     noresponse;     /* don't respond to this one */
        Exq*    next;
        int     shut;           /* has been noted for shutdown */
        Export* export;
        void*   slave;
        Fcall   rpc;
        uchar   buf[Maxrpc];
};

struct Exwork
{
        Lock    l;

        int     ref;

        int     nwaiters;       /* queue of slaves waiting for work */
        QLock   qwait;
        Rendez  rwait;

        Exq     *head;          /* work waiting for a slave */
        Exq     *tail;
};

Exwork 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*    Exattach(Export*, Fcall*, uchar*);
static char*    Exauth(Export*, Fcall*, uchar*);
static char*    Exclunk(Export*, Fcall*, uchar*);
static char*    Excreate(Export*, Fcall*, uchar*);
static char*    Exversion(Export*, Fcall*, uchar*);
static char*    Exopen(Export*, Fcall*, uchar*);
static char*    Exread(Export*, Fcall*, uchar*);
static char*    Exremove(Export*, Fcall*, uchar*);
static char*    Exsession(Export*, Fcall*, uchar*);
static char*    Exstat(Export*, Fcall*, uchar*);
static char*    Exwalk(Export*, Fcall*, uchar*);
static char*    Exwrite(Export*, Fcall*, uchar*);
static char*    Exwstat(Export*, Fcall*, uchar*);

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

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 **roots, int nroots)
{
        Export *fs;

        fs = smalloc(sizeof(Export));
        fs->r.ref = 1;
        fs->io = fd;
        fs->roots = roots;
        fs->nroots = nroots;

        exportproc(fs);

        return 0;
}

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

        fmtinstall('F', fcallfmt);
        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);
}

static void
exportproc(Export *fs)
{
        Exq *q;
        int n, ed;

        exportinit();
        ed = errdepth(-1);
        for(;;){
                errdepth(ed);
                q = smalloc(sizeof(Exq));

                n = read9pmsg(fs->io, q->buf, Maxrpc);
                if(n <= 0 || convM2S(q->buf, n, &q->rpc) != n)
                        goto bad;

                if(exdebug)
                        print("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;
                incref(&fs->r);

                lock(&exq.l);
                if(exq.head == nil)
                        exq.head = q;
                else
                        exq.tail->next = q;
                q->next = nil;
                exq.tail = q;
                n = exq.nwaiters;
                if(n)
                        exq.nwaiters = n - 1;
                unlock(&exq.l);
                if(!n)
                        kproc("exportfs", exslave, nil);
                rendwakeup(&exq.rwait);
        }
bad:
        free(q);
        if(exdebug)
                fprint(2, "export proc shutting down: %r\n");
        exshutdown(fs);
        exfree(fs);
}

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

        /* 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);
        for(q = fs->work; q != nil; q = q->next){
                if(q->rpc.tag == tag){
                        lock(&q->lk);
                        q->noresponse = 1;
                        if(!q->responding)
                                rendintr(q->slave);
                        unlock(&q->lk);
                        break;
                }
        }
        unlock(&fs->r);

Respond:
        fc.type = Rflush;
        fc.tag = flushtag;

        n = convS2M(&fc, buf, Maxrpc);
        if(n == 0)
                panic("convS2M error on write");
        if(write(fs->io, buf, n) != n)
                panic("mount write");
}

static 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;
        }

        /*
         * cleanly shut down the slaves if this is the last fs around
         */
        exq.ref--;
        if(!exq.ref)
                rendwakeup(&exq.rwait);
        unlock(&exq.l);

        /*
         * kick any sleepers
         */
        lock(&fs->r);
        for(q = fs->work; q != nil; q = q->next){
                lock(&q->lk);
                q->noresponse = 1;
                if(!q->responding)
                        rendintr(q->slave);
                unlock(&q->lk);
        }
        unlock(&fs->r);
}

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

        if(decref(&fs->r) != 0)
                return;
        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);
}

static int
exwork(void *)
{
        int work;

        lock(&exq.l);
        work = exq.head != nil || !exq.ref;
        unlock(&exq.l);
        return work;
}

static void
exslave(void *)
{
        Export *fs;
        Exq *q, *t, **last;
        char *volatile err;
        int n, ed;

        while(waserror())
                fprint(2, "exslave %d errored out of loop -- heading back in!\n", getpid());
        ed = errdepth(-1);
        for(;;){
                errdepth(ed);
                qlock(&exq.qwait);
                if(waserror()){
                        qunlock(&exq.qwait);
                        nexterror();
                }
                rendsleep(&exq.rwait, exwork, nil);

                lock(&exq.l);
                if(!exq.ref){
                        unlock(&exq.l);
                        poperror();
                        qunlock(&exq.qwait);
                        break;
                }
                q = exq.head;
                if(q == nil){
                        unlock(&exq.l);
                        poperror();
                        qunlock(&exq.qwait);
                        continue;
                }
                exq.head = q->next;
                if(exq.head == nil)
                        exq.tail = nil;
                poperror();
                qunlock(&exq.qwait);

                /*
                 * put the job on the work queue before it's
                 * visible as off of the head queue, so it's always
                 * findable for flushes and shutdown
                 */
                q->slave = up;
                q->noresponse = 0;
                q->responding = 0;
                rendclearintr();
                fs = q->export;
                lock(&fs->r);
                q->next = fs->work;
                fs->work = q;
                unlock(&fs->r);

                unlock(&exq.l);

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

                if(waserror()){
                        print("exslave err %r\n");
                        err = up->error;
                }else{
                        if(q->rpc.type >= Tmax || !fcalls[q->rpc.type])
                                err = "bad fcall type";
                        else
                                err = (*fcalls[q->rpc.type])(fs, &q->rpc, &q->buf[IOHDRSZ]);
                        poperror();
                }

                q->rpc.type++;
                if(err){
                        q->rpc.type = Rerror;
                        q->rpc.ename = err;
                }
                n = convS2M(&q->rpc, q->buf, Maxrpc);

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

                lock(&q->lk);
                if(!q->noresponse){
                        q->responding = 1;
                        unlock(&q->lk);
                        write(fs->io, q->buf, n);
                }else
                        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)
                        print("exslave %d written %d\n", getpid(), q->rpc.tag);

                lock(&fs->r);
                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);

                exfree(q->export);
                free(q);

                rendclearintr();
                lock(&exq.l);
                exq.nwaiters++;
                unlock(&exq.l);
        }
        if(exdebug)
                fprint(2, "export slaveshutting down\n");
        kexit();
}

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

        nf = mallocz(sizeof(Fid), 1);
        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);
}

static char*
Exversion(Export *fs, Fcall *rpc, uchar *)
{
        if(rpc->msize > Maxrpc)
                rpc->msize = Maxrpc;
        if(strncmp(rpc->version, "9P", 2) != 0){
                rpc->version = "unknown";
                return nil;
        }

        fs->iounit = rpc->msize - IOHDRSZ;
        rpc->version = "9P2000";
        return nil;
}

static char*
Exauth(Export *, Fcall *, uchar *)
{
        return "vnc: authentication not required";
}

static char*
Exattach(Export *fs, Fcall *rpc, uchar *)
{
        Fid *f;
        int w;

        w = 0;
        if(rpc->aname != nil)
                w = strtol(rpc->aname, nil, 10);
        if(w < 0 || w > fs->nroots)
                error(Ebadspec);
        f = Exmkfid(fs, rpc->fid);
        if(f == nil)
                return Einuse;
        if(waserror()){
                f->attached = 0;
                Exputfid(fs, f);
                return up->error;
        }
        f->chan = cclone(fs->roots[w]);
        poperror();
        rpc->qid = f->chan->qid;
        Exputfid(fs, f);
        return nil;
}

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

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

static char*
Exwalk(Export *fs, Fcall *rpc, uchar *)
{
        Fid *volatile f, *volatile nf;
        Walkqid *wq;
        Chan *c;
        int i, nwname;
        int volatile isnew;

        f = Exgetfid(fs, rpc->fid);
        if(f == nil)
                return Enofid;
        nf = nil;
        if(waserror()){
                Exputfid(fs, f);
                if(nf != nil)
                        Exputfid(fs, nf);
                return up->error;
        }

        /*
         * optional clone, but don't attach it until the walk succeeds.
         */
        if(rpc->fid != rpc->newfid){
                nf = Exmkfid(fs, rpc->newfid);
                if(nf == nil)
                        error(Einuse);
                nf->attached = 0;
                isnew = 1;
        }else{
                nf = Exgetfid(fs, rpc->fid);
                isnew = 0;
        }

        /*
         * let the device do the work
         */
        c = f->chan;
        nwname = rpc->nwname;
        wq = (*devtab[c->type]->walk)(c, nf->chan, rpc->wname, nwname);
        if(wq == nil)
                error(Enonexist);

        poperror();

        /*
         * copy qid array
         */
        for(i = 0; i < wq->nqid; i++)
                rpc->wqid[i] = wq->qid[i];
        rpc->nwqid = wq->nqid;

        /*
         * update the channel if everything walked correctly.
         */
        if(isnew && wq->nqid == nwname){
                nf->chan = wq->clone;
                nf->attached = 1;
        }

        free(wq);
        Exputfid(fs, f);
        Exputfid(fs, nf);
        return nil;
}

static char*
Exopen(Export *fs, Fcall *rpc, uchar *)
{
        Fid *volatile f;
        Chan *c;
        int iou;

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

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

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

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

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

static char*
Exread(Export *fs, Fcall *rpc, uchar *buf)
{
        Fid *f;
        Chan *c;
        long off;

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

        c = f->chan;

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

        rpc->data = (char*)buf;
        off = rpc->offset;
        c->offset = off;
        rpc->count = (*devtab[c->type]->read)(c, rpc->data, rpc->count, off);
        poperror();
        Exputfid(fs, f);
        return nil;
}

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

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

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

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

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

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

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

        f = Exgetfid(fs, rpc->fid);
        if(f == nil)
                return Enofid;
        if(waserror()){
                Exputfid(fs, f);
                return up->error;
        }
        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;
}