void
respond(Req *r, char *error)
{
int i, m, n;
char errbuf[ERRMAX];
Srv *srv;
srv = r->srv;
assert(srv != nil);
assert(r->responded == 0);
r->error = error;
switch(r->ifcall.type){
default:
assert(0);
/*
* Flush is special. If the handler says so, we return
* without further processing. Respond will be called
* again once it is safe.
*/
case Tflush:
if(rflush(r, error)<0)
return;
break;
case Tversion: rversion(r, error); break;
case Tauth: rauth(r, error); break;
case Tattach: rattach(r, error); break;
case Twalk: rwalk(r, error); break;
case Topen: ropen(r, error); break;
case Tcreate: rcreate(r, error); break;
case Tread: rread(r, error); break;
case Twrite: rwrite(r, error); break;
case Tclunk: rclunk(r, error); break;
case Tremove: rremove(r, error, errbuf); break;
case Tstat: rstat(r, error); break;
case Twstat: rwstat(r, error); break;
}
r->ofcall.tag = r->ifcall.tag;
r->ofcall.type = r->ifcall.type+1;
if(r->error)
setfcallerror(&r->ofcall, r->error);
if(chatty9p)
fprint(2, "-%d-> %F\n", srv->outfd, &r->ofcall);
qlock(&srv->wlock);
n = convS2M(&r->ofcall, srv->wbuf, srv->msize);
if(n <= 0){
fprint(2, "n = %d %F\n", n, &r->ofcall);
abort();
}
assert(n > 2);
if(r->pool) /* not a fake */
closereq(removereq(r->pool, r->ifcall.tag));
m = write(srv->outfd, srv->wbuf, n);
if(m != n)
sysfatal("lib9p srv: write %d returned %d on fd %d: %r", n, m, srv->outfd);
qunlock(&srv->wlock);
qlock(&r->lk); /* no one will add flushes now */
r->responded = 1;
qunlock(&r->lk);
for(i=0; i<r->nflush; i++)
respond(r->flush[i], nil);
free(r->flush);
r->flush = nil;
r->nflush = 0;
if(r->pool)
closereq(r);
else
free(r);
}
void
ioproc0(void *v)
{
long n;
Mfile *mf;
uchar mdata[IOHDRSZ + Maxfdata];
Request req;
Job *job;
USED(v);
for(;;){
n = read9pmsg(mfd[0], mdata, sizeof mdata);
if(n <= 0){
syslog(0, logfile, "error reading mntpt: %r");
break;
}
job = newjob();
if(convM2S(mdata, n, &job->request) != n){
freejob(job);
continue;
}
if(debug)
syslog(0, logfile, "%F", &job->request);
getactivity(&req);
req.aborttime = now + 60; /* don't spend more than 60 seconds */
mf = nil;
switch(job->request.type){
case Tversion:
case Tauth:
case Tflush:
break;
case Tattach:
mf = newfid(job->request.fid, 1);
if(mf == nil){
sendmsg(job, "fid in use");
goto skip;
}
break;
default:
mf = newfid(job->request.fid, 0);
if(mf == nil){
sendmsg(job, "unknown fid");
goto skip;
}
break;
}
switch(job->request.type){
default:
syslog(1, logfile, "unknown request type %d", job->request.type);
break;
case Tversion:
rversion(job);
break;
case Tauth:
rauth(job);
break;
case Tflush:
rflush(job);
break;
case Tattach:
rattach(job, mf);
break;
case Twalk:
rwalk(job, mf);
break;
case Topen:
ropen(job, mf);
break;
case Tcreate:
rcreate(job, mf);
break;
case Tread:
rread(job, mf);
break;
case Twrite:
rwrite(job, mf, &req);
break;
case Tclunk:
rclunk(job, mf);
break;
case Tremove:
rremove(job, mf);
break;
case Tstat:
rstat(job, mf);
break;
case Twstat:
rwstat(job, mf);
break;
}
skip:
freejob(job);
putactivity();
}
}
void
io(void)
{
volatile long n;
volatile uchar mdata[IOHDRSZ + Maxfdata];
Job *volatile job;
Mfile *volatile mf;
volatile Request req;
memset(&req, 0, sizeof req);
/*
* a slave process is sometimes forked to wait for replies from other
* servers. The master process returns immediately via a longjmp
* through 'mret'.
*/
if(setjmp(req.mret))
putactivity(0);
req.isslave = 0;
stop = 0;
while(!stop){
procsetname("%d %s/dns Twrites of %d 9p rpcs read; %d alarms",
stats.qrecvd9p, mntpt, stats.qrecvd9prpc, stats.alarms);
n = read9pmsg(mfd[0], mdata, sizeof mdata);
if(n<=0){
dnslog("error reading 9P from %s: %r", mntpt);
sleep(2000); /* don't thrash after read error */
return;
}
stats.qrecvd9prpc++;
job = newjob();
if(convM2S(mdata, n, &job->request) != n){
freejob(job);
continue;
}
mf = newfid(job->request.fid, 0);
if(debug)
dnslog("%F", &job->request);
getactivity(&req, 0);
req.aborttime = timems() + Maxreqtm;
req.from = "9p";
switch(job->request.type){
default:
warning("unknown request type %d", job->request.type);
break;
case Tversion:
rversion(job);
break;
case Tauth:
rauth(job);
break;
case Tflush:
rflush(job);
break;
case Tattach:
rattach(job, mf);
break;
case Twalk:
rwalk(job, mf);
break;
case Topen:
ropen(job, mf);
break;
case Tcreate:
rcreate(job, mf);
break;
case Tread:
rread(job, mf);
break;
case Twrite:
/* &req is handed to dnresolve() */
rwrite(job, mf, &req);
break;
case Tclunk:
rclunk(job, mf);
break;
case Tremove:
rremove(job, mf);
break;
case Tstat:
rstat(job, mf);
break;
case Twstat:
rwstat(job, mf);
break;
}
freejob(job);
/*
* slave processes die after replying
*/
if(req.isslave){
putactivity(0);
_exits(0);
}
putactivity(0);
}
/* kill any udp server, notifier, etc. processes */
postnote(PNGROUP, getpid(), "die");
sleep(1000);
}
char*
rwalk(Fid *f)
{
VacFile *file, *nfile;
Fid *nf;
int nqid, nwname;
Qid qid;
char *err = nil;
if(f->busy == 0)
return Enotexist;
nf = nil;
if(rhdr.fid != rhdr.newfid){
if(f->open)
return vtstrdup(Eisopen);
if(f->busy == 0)
return vtstrdup(Enotexist);
nf = newfid(rhdr.newfid);
if(nf->busy)
return vtstrdup(Eisopen);
nf->busy = 1;
nf->open = 0;
nf->qid = f->qid;
nf->file = vacfileincref(f->file);
nf->user = vtstrdup(f->user);
f = nf;
}
nwname = rhdr.nwname;
/* easy case */
if(nwname == 0) {
thdr.nwqid = 0;
return 0;
}
file = f->file;
vacfileincref(file);
qid = f->qid;
for(nqid = 0; nqid < nwname; nqid++){
if((qid.type & QTDIR) == 0){
err = Enotdir;
break;
}
if(!permf(file, f->user, Pexec)) {
err = Eperm;
break;
}
nfile = vacfilewalk(file, rhdr.wname[nqid]);
if(nfile == nil)
break;
vacfiledecref(file);
file = nfile;
qid.type = QTFILE;
if(vacfileisdir(file))
qid.type = QTDIR;
#ifdef PLAN9PORT
if(vacfilegetmode(file)&ModeLink)
qid.type = QTSYMLINK;
#endif
qid.vers = vacfilegetmcount(file);
qid.path = vacfilegetid(file);
thdr.wqid[nqid] = qid;
}
thdr.nwqid = nqid;
if(nqid == nwname){
/* success */
f->qid = thdr.wqid[nqid-1];
vacfiledecref(f->file);
f->file = file;
return 0;
}
vacfiledecref(file);
if(nf != nil)
rclunk(nf);
/* only error on the first element */
if(nqid == 0)
return vtstrdup(err);
return 0;
}
