ref: 88412aa050adddde5cacf3a45e914bad9a5d3e22
dir: /sys/src/cmd/vnc/exportfs.c/
#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)
break;
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);
}
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 < 256)
return "version: message size too small";
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;
}