/*
* Implements the RPCs for a Plan B volume
* relying on fs.c, ctlfs.c, or nilfs.c.
*
* Locking order:
* 1st. fids are locked by the RPCs using them.
* 2nd. volslck.
* 3rd. mvol locks or vol mntlck
* In general:
* do not lock fids while holding a vol/mvol lock.
* do not lock volslck while holding a mvol/vol lock.
*/
#include <u.h>
#include <libc.h>
#include <auth.h>
#include <ip.h>
#include <fcall.h>
#include <thread.h>
#include "names.h"
#include "vols.h"
/* We use our own fids for servers, because we may
* have to (re)attach to them and we don't know which fids
* the client will use in the future.
* All fids owned by us have 0 as their client nr.
* The alloc routine returns a new fid each time we alloc 0.
*
* Regarding Rpcs used for our own bookkeeping, we try to
* use the client supplied rpc. See the comment near the top
* of main.c
*/
static QLock fidlck;
static int fidgen;
static Fid* fidhash[Fhashsz];
static Fid* freefids;
static ulong nfids;
static ulong nafids;
int msglen;
#define FIDHASH(s) fidhash[(s)%Fhashsz]
int hdebug;
void
dbgprint(Fid* fid, char* msg, ...)
{
va_list arg;
if (!debug && (!fid || !fid->debug))
return;
va_start(arg, msg);
vfprint(2, msg, arg);
va_end(arg);
}
void
Dbgprint(Fid* fid, char* msg, ...)
{
va_list arg;
if (debug < 2 && (!fid || fid->debug < 2))
return;
va_start(arg, msg);
vfprint(2, msg, arg);
va_end(arg);
}
int
fidfmt(Fmt* fmt)
{
Fid* f;
f = va_arg(fmt->args, Fid*);
if (!f)
return fmtprint(fmt, "nil fid");
return fmtprint(fmt, "0x%p: fid=%d sfid=%d %N"
" mv=%p fs=%p e=%d Q=%llx %c %c",
f, f->nr, f->snr, f->sname,
f->mvol, f->fs, f->epoch, f->qid.path,
((f->qid.type&QTDIR) ? 'd' : ' '),
(f->notimeout ? 'n' : 't'));
}
static Fid *
getfid(int nr)
{
Fid *f;
qlock(&fidlck);
for(f = FIDHASH(nr); f; f = f->hnext)
if(f->nr == nr)
break;
qunlock(&fidlck);
return f;
}
int
getfidnr(void)
{
int nr;
qlock(&fidlck);
nr = ++fidgen;
qunlock(&fidlck);
return nr;
}
void
closefid(Fid* f, Frpc* fop)
{
/* We keep f->isopen as it was.
* This is only to close the fid in the server.
*/
if (f->fs && f->fs != &ctlfs && f->fs->fd >= 0){
fop->f.type = Tclunk;
fop->f.fid = f->snr;
fsop(f->fs, fop);
}
putfs(f->fs);
f->fs = nil;
f->epoch = 0;
}
static int
openfid(Fid* fid, Frpc* fop)
{
if (fid->fs && fid->fs != &ctlfs && fid->fs->fd >= 0){
fop->f.type = Topen;
fop->f.fid = fid->snr;
fop->f.mode = fid->omode;
return fsop(fid->fs, fop);
} else
return -1;
}
int
fidfree(Fid* fid, Frpc* fop)
{
Fid *f, **l;
int nr;
if (fid == nil)
return 1;
qlock(&fidlck);
nfids--;
l = &FIDHASH(fid->nr);
for(f = *l; f; f = f->hnext) {
if(fid == f) {
*l = f->hnext;
qunlock(&fidlck);
closefid(f, fop);
f->isopen = 0;
if (f->mvol)
mvoldelfid(f->mvol, f);
putmvol(f->mvol, fop);
putfs(f->fs);
n_reset(f->sname);
free(f->d);
free(f->ureadbuf);
qlock(&fidlck);
f->hnext = freefids;
freefids = f;
nr = f->nr;
Dbgprint(f, "fidfree: released fid=%d\n", nr);
f->debug = 0;
for(f = *l; f != nil; f = f->hnext)
if (nr && f->nr == nr)fprint(2, "\n****\n**** BUG: dup fid in hash: %d\n****\n\n", nr);
qunlock(&fidlck);
return 1;
}
l = &f->hnext;
}
qunlock(&fidlck);
fprint(2, "\n\nXXX fidfree: not found? %X\n\n", fid);
return 0;
}
Fid *
fidalloc(int nr)
{
Fid *new, **l;
Name* sn;
int snr;
qlock(&fidlck);
l = &FIDHASH(nr);
for(new = *l; new; new = new->hnext){
// if nr is 0 it's a local fid used by this program
// to issue requests to servers. We may have several
// ones, and it's ok if they are dup.
if(nr && new->nr == nr){
qunlock(&fidlck);
return 0;
}
}
nfids++;
if(freefids == 0) {
nafids++;
freefids = emalloc(sizeof(Fid));
freefids->sname = n_new();
freefids->hnext = nil;
freefids->snr = ++fidgen;
}
new = freefids;
freefids = new->hnext;
sn = new->sname;
snr= new->snr;
memset(new, 0, sizeof(Fid));
new->sname= sn;
new->snr = snr;
new->nr = nr;
new->hnext = *l;
*l = new;
qunlock(&fidlck);
return new;
}
void
dumpfids(void)
{
int i;
Fid* f;
int nh;
fprint(2, "fids: %ld used %ld allocated\n", nfids, nafids);
qlock(&fidlck);
for (i = 0; i < nelem(fidhash); i++){
nh = 0;
for (f = fidhash[i]; f; f = f->hnext){
nh++;
fprint(2, " %X\n", f);
fprint(2, " %W\n", f->mvol);
}
if (nh > 5)
fprint(2, "\t[%d fids in bucket]\n", nh);
}
qunlock(&fidlck);
}
/*
* Version, Auth, and Attach are handled by us.
* To the user, it seems that a volume is being mounted.
* All auth is done by the factotum underlying this program, not by clients.
*/
static void
fsversion(Frpc* fop)
{
if(strncmp(fop->f.version, "9P", 2) != 0){
fop->f.version = "unknown";
}
fop->r.tag = fop->f.tag;
fop->r.type = Rversion;
fop->r.version = "9P2000";
/*
* BUG: We don't know what the real file server msize will
* be, we tried using iounit in open, but the kernel seems
* to ignore that.
*/
if (fop->f.msize > 8*1024)
fop->f.msize = 8*1024;
msglen = fop->r.msize = fop->f.msize;
}
static void
fserror(Frpc* fop, char* e)
{
fop->r.tag = fop->f.tag;
fop->r.type = Rerror;
fop->r.ename= e;
}
static void
fsauth(Frpc* fop)
{
fserror(fop, Eauth);
}
static int
fidbound(Fid* fid, Vol* v)
{
return !fid->stale && fid->fs &&
v && v->fs == fid->fs && fid->epoch == fid->fs->epoch;
}
/* Fid may be a brand new one, or an already bound one.
* If bindfid succeeds, fid will be a valid fid in v
* for its sname in v->fs.
* This does not reopen the fid if it was open.
*/
static int
bindfid(Fid* fid, Mvol* mv, Vol* v, Frpc* fop)
{
int unbound;
if (fidbound(fid, v))
return 1;
closefid(fid, fop);
if (mv == nil){ // fid into our ctl fs. We're done.
incref(&ctlfs);
putfs(fid->fs);
fid->fs = &ctlfs;
fid->epoch = ctlfs.epoch;
fid->stale = 0;
return 1;
}
if (fid->mvol == nil){
assert(!fid->linked);
unbound = 1;
fid->mvol = mv;
if (mv) {
incref(mv);
fid->notimeout = mv->notimeout;
fid->debug = mv->debug;
}
} else {
unbound = 0;
assert(fid->mvol == mv);
}
if(v && v->fs)
incref(v->fs);
putfs(fid->fs);
fid->fs = (v ? v->fs : nil);
if (fid->fs != nil && fid->mvol != nil && fid->mvol->musthave)
fid->fs->musthave = 1;
fid->stale = 0;
if (v && v->slash && v->fs){
if (walkfid(v->slash, fid, nil, 0, fop) <= 0){
if (unbound){
decref(fid->mvol);
fid->mvol = nil;
}
return 0;
}
} else {
fid->qid.type = QTDIR;
fid->qid.path = 0;
fid->qid.vers = 0;
}
if (unbound && mv)
mvoladdfid(mv, fid);
return 1;
}
static void
fsattach(Frpc* fop)
{
Vol* v;
Mvol* mv;
Fid* fid;
int nr;
int tag;
nr = fop->f.fid;
tag= fop->f.tag;
if (strcmp(getuser(), fop->f.uname)){
fserror(fop, Euser);
return;
}
mv = newmvol(fop->f.aname);
if (mv == nil && fop->f.aname[0] != 0){
fserror(fop, Espec);
return;
}
updatemvol(mv, fop);
fid = fidalloc(nr);
if (fid == nil){
putmvol(mv, fop);
fop->r.tag = tag;
fserror(fop, Ebadfid);
return;
}
if (!mv){
fid->qid.path = Ctldirqid;
fid->qid.vers = 0;
fid->qid.type = QTDIR;
}
for(;;){
// If all vols fail, mv ends up empty.
// the rpc is guaranteed to work there.
v = getmvolvol(mv, 0);
if (bindfid(fid, mv, v, fop))
break;
vdprint(2, "attach: deadvol: %s %s\n", v->addr, v->name);
qlock(&volslck);
deadvol(v, fop);
qlock(mv);
mvolunmount(mv, v, fop);
qunlock(mv);
qunlock(&volslck);
}
if (fid->fs == nil)
newfsqid(&fid->qid); // unique qid for fake fs /
fop->r.type = Rattach;
fop->r.qid = fid->qid;
fop->r.tag = tag;
}
/* We must ensure the system always gets the same qid for
* a file we serve:
* - The kernel can be using only those files that
* have fids on us. Usually Chans for a name space.
* - User programs may remember qids for closed files,
* that do not have fids on us (e.g., acme for its files).
*
* The qids we use are the first ones seen, decorated
* in the high long in path with nfid->fs->qid. To make them unique.
* The decoration ensures that fids forgotten get the same qid if
* their file stays the same.
* We leave Qid.vers as the real qid.vers+qid.path, to report changes
* for files whose path/vers changes.
*/
static void
fixseenqid(Fid* nfid, Fs* fs, Qid* wqid, int i)
{
Fid* old;
ulong vers;
vers = wqid[i].vers + (ulong)wqid[i].path;
old = mvolgetfid(nfid->mvol, nfid->sname, nfid);
if (old){
nfid->qid = old->qid;
} else {
nfid->qid = wqid[i];
if (fs)
nfid->qid.path |= fs->qid.path;
}
nfid->qid.vers = vers;
wqid[i] = nfid->qid;
wqid[i].vers = vers;
}
/* Walks (the unbound) nfid through elems in nfid->sname.
* The start for the walk is fid.
* The sname in nfid is updated to reflect the walk.
* Qids in nfid is updated to: <fsqid>|<realqid>
* Qids in fop->r.wqid[] are updated as well.
*
* When elems is nil, we walk nfid->sname, and leave the sname
* as it was. This is used while rebinding a fid into a new volume.
*
* Return 1 if could walk elems; 0 if couldn't; -1 if got an IO error.
*/
int
walkfid(Fid* fid, Fid* nfid, char** elems, int nelems, Frpc* fop)
{
int i;
int rebind;
int ndotdot;
int a,b;
int r;
rebind = ndotdot = 0;
if (elems == nil){
rebind = 1;
elems = nfid->sname->elems;
nelems= nfid->sname->nelems;
} else {
/* Drop the part of "../../..." that might
* go past the root in the volume. We assume
* that we won't get "a/../../..."
*/
for (i = 0; i < nelems; i++)
if (strcmp(elems[i], ".."))
break;
else
ndotdot++;
while(ndotdot > fid->sname->nelems){
elems++;
nelems--;
ndotdot--;
}
}
fop->f.type = Twalk;
fop->f.fid = fid->snr;
fop->f.newfid = nfid->snr;
fop->f.nwname = nelems;
for (i = 0; i < nelems; i++)
fop->f.wname[i] = elems[i];
r = fsop(fid->fs, fop);
if (r < 0 && !strncmp(fop->r.ename, "io ", 3)){
dbgprint(fid, "walkfid: io err: %X\n", fid);
return r;
}
if (nfid != fid && fid->fs)
nfid->epoch = fid->fs->epoch;
if (!rebind && fop->r.type == Rwalk && nelems == 0 && fid != nfid){
n_reset(nfid->sname);
n_cat(nfid->sname, fid->sname);
}
if (fop->r.type == Rwalk && fop->r.nwqid > 0){
if (!rebind){
/* This is in the inner loop.
* If this is improved, the user will notice.
*/
if (fid != nfid){
n_reset(nfid->sname);
n_cat(nfid->sname, fid->sname);
}
if (fop->r.nwqid < nelems)
n_getpos(nfid->sname, &a, &b);
for (i = 0; i < nelems; i++){
if (!strcmp(elems[i], ".."))
n_dotdot(nfid->sname);
else
n_append(nfid->sname, elems[i]);
fixseenqid(nfid, fid->fs, fop->r.wqid, i);
}
Dbgprint(fid, "\tfixed fid: %X\n", nfid);
if (fop->r.nwqid < nelems)
n_setpos(nfid->sname, a, b);
}
}
if (nelems == 0 && nfid != fid && fop->r.nwqid == nelems){
// nfid->qid = fid->qid;
fixseenqid(nfid, fid->fs, &fid->qid, 0);
}
return fop->r.nwqid == nelems;
}
static Ref once;
static void
fswalk(Frpc* fop)
{
Fid* fid;
Fid* nfid;
Vol* v;
Frpc* fwop; // Auxiliary used to keep fop untouched.
int r, nvol;
int isunion;
int musthave;
int d, vd;
fid = fop->fid = getfid(fop->f.fid);
if (fid == nil || fid->isopen){
fserror(fop, Ebadfid);
return;
}
incref(&once);
if (once.ref == 1 && hdebug){
d = debug;
vd= vdebug;
} else
d = vd = -1;
dbgprint(fid, "<- %F\n", &fop->f);
Dbgprint(fid, "Walk %X\n", fid);
qlock(fid);
if(fop->f.newfid != fop->f.fid){
nfid = fidalloc(fop->f.newfid);
if(!nfid) {
fprint(2, "BUG: dup fid\n");
/* Try to recover.
* The user already knows this happens.
*/
nfid = getfid(fop->f.newfid);
assert(nfid);
nfid->nr = 0; // forget it.
nfid = fidalloc(fop->f.newfid);
if (!nfid){
fprint(2, "BUG at BUG\n");
fserror(fop, Edupfid);
qunlock(fid);
decref(&once);
return;
}
}
assert(!nfid->linked);
assert(nfid->mvol == nil);
if (nfid->mvol = fid->mvol){
incref(fid->mvol);
mvoladdfid(nfid->mvol, nfid);
nfid->notimeout = fid->mvol->notimeout;
nfid->debug = fid->mvol->debug;
}
} else
nfid = fid;
fserror(fop, Ebadfid); // by default
fwop = rpcalloc();
fwop->f.tag = fop->f.tag;
nvol = 0;
isunion = (fid->mvol ? fid->mvol->isunion : 0);
musthave= (fid->mvol ? fid->mvol->musthave : 0);
do {
/* Try the walk in the volume used.
* When all volumes in the mvol fail,
* an empty fs is used intead of the real thing.
* For musthave mvols, we don't accept the empty one.
*/
r = -1;
updatemvol(fid->mvol, fwop);
v = getmvolvol(fid->mvol, nvol++);
if (!bindfid(fid, fid->mvol, v, fwop))
continue;
if (musthave && (v == nil || fid->fs == nil)){
fprint(2, "wait for %s\n", fid->mvol->name);
if (d != -1 && vd != -1)
debug = vdebug = 2;
sleep(Tmout*1000);
checkvols(fwop);
nvol = 0;
continue;
}
r = walkfid(fid, nfid, fop->f.wname, fop->f.nwname, fop);
if (r > 0){
if (nfid != fid && nfid->fs != fid->fs){
putfs(nfid->fs);
if (nfid->fs = fid->fs)
incref(nfid->fs);
}
}
} while ((r <= 0 && v && isunion) || (r < 0 && musthave));
if (d != -1 && vd != -1){
debug = d;
vdebug = vd;
}
decref(&once);
rpcfree(fwop);
if (r <= 0 && nfid != fid) // couln't walk. Get rid of it.
fop->freefid = nfid;
free(nfid->d);
nfid->d = nil;
Dbgprint(fid, "Walked fid %X\nWalked nfid %X\n", fid, nfid);
qunlock(fid);
}
/* To read all entries of a union at once.
* We know that fid points to the root of a union.
*/
static void
fidreadall(Fid *fid, Frpc* fop)
{
char* buf;
long bufsz;
long buflen, off;
long nr;
Vol* v;
int nvol;
buf = emalloc(16*1024);
bufsz = 16*1024;
buflen = 0;
updatemvol(fid->mvol, fop);
nvol = 0;
do {
v = getmvolvol(fid->mvol, nvol++);
if (v == nil && buflen > 0)
break;
closefid(fid, fop);
if (!bindfid(fid, fid->mvol, v, fop)) // ignore
continue;
nr = openfid(fid, fop);
off = 0;
if (nr >= 0){
for(;;){
if (buflen == bufsz){
buf = erealloc(buf, bufsz + 16*1024);
bufsz += 16*1024;
}
fop->f.type = Tread;
fop->f.count= bufsz - buflen;
if (fid->iounit && fop->f.count>fid->iounit)
fop->f.count = fid->iounit;
fop->f.offset = off;
nr = fsop(fid->fs, fop);
if (nr < 0 || fop->r.count <= 0)
break; // next volume
memmove(buf+buflen, fop->r.data, fop->r.count);
buflen += fop->r.count;
off += fop->r.count;
}
//closefid(fid, fop);
}
} while (v);
fid->ureadbuf = buf;
fid->ureadlen = buflen;
}
static int
mayretry(Frpc* fop)
{
if (fop->f.type == Tstat || fop->f.type == Tread)
return 1;
if (fop->f.type == Topen && fop->f.mode == OREAD)
return 1;
return 0;
}
/* Similar to fsop(fid, fop), but retries on other
* volumes available for the fid's mvol on io errors.
* Note that this always retries in the first vol.
*/
static void
mvolop(Fid* fid, Frpc* fop)
{
Frpc* fwop;
Vol* v;
int r;
int ntries;
fwop = nil;
ntries = 0;
again:
if (fid->stale || (fid->fs && fid->fs->fd < 0)){
if (fwop == nil)
fwop = rpcalloc();
fwop->f.tag = fop->f.tag;
closefid(fid, fwop);
}
/* Recover fids for volumes that were gone.
* On unions we don't recover. The particular vol was gone.
*/
if (fid->fs == nil && !fid->mvol->isunion && mayretry(fop)){
dbgprint(fid, "rebind for RPC %d: %X\n", fop->f.type, fid);
if (fwop == nil)
fwop = rpcalloc();
fwop->f.tag = fop->f.tag;
for(;;){
fwop->fid = fid;
updatemvol(fid->mvol, fwop);
v = getmvolvol(fid->mvol, 0);
if(v || !fid->mvol || !fid->mvol->musthave)
break;
sleep(Tmout*1000);
checkvols(fwop);
dprint(2, "waiting for %s\n", fid->mvol->name);
}
bindfid(fid, fid->mvol, v, fwop);
if (fid->isopen)
openfid(fid, fwop);
}
r = fsop(fid->fs, fop);
/* Retry if necessary.
*/
if (r < 0){
fserror(fop, fop->err);
if (!fid->mvol->isunion)
if (!strncmp(fop->r.ename, "io ", 3) && mayretry(fop)){
if (fwop == nil)
fwop = rpcalloc();
fwop->f.tag = fop->f.tag;
checkvols(fwop);
ntries++;
if (ntries > 2)
fprint(2, "%d tries for fid %X\n", ntries, fid);
goto again;
}
}
rpcfree(fwop);
}
// Does not fix qids for dir reads.
// Not needed to preserve client's binds.
static void
fsread(Frpc* fop)
{
long off, len, n, count;
Dir d;
Fid* fid;
fid = fop->fid = getfid(fop->f.fid);
if (fid == nil){
fserror(fop, Ebadfid);
return;
}
dbgprint(fid, "<- %F\n", &fop->f);
if (!fid->isopen){
fserror(fop, Enotopen);
return;
}
qlock(fid);
fop->f.fid = fid->snr;
if (fop->f.count > fid->iounit && fid->iounit)
fop->f.count = fid->iounit;
off = fop->f.offset;
count = fop->f.count;
if (fid->sname->nelems > 0 || !fid->mvol || !fid->mvol->isunion){
mvolop(fid, fop);
qunlock(fid);
return;
}
/* Volume union reads
*/
if (fid->ureadbuf == nil){
fidreadall(fid, fop);
fop->f.type = Tread;
}
fop->r.tag = fop->f.tag;
fop->r.type= Rread;
fop->r.count = 0;
fop->r.data = (char*)fop->buf;
len = fid->ureadlen;
while(count > 0 && off < len){
n = convM2D((uchar*)fid->ureadbuf + off, len - off, &d, nil);
if (n <= 0 || n > count)
break;
memmove(fop->r.data + fop->r.count, fid->ureadbuf + off, n);
off += n;
count -= n;
fop->r.count += n;
}
qunlock(fid);
}
static void
fsfwd(Frpc* fop)
{
Fid* fid;
int op;
fid = fop->fid = getfid(fop->f.fid);
if (fid == nil){
fserror(fop, Ebadfid);
return;
}
dbgprint(fid, "<- %F\n", &fop->f);
op = fop->f.type;
qlock(fid);
fop->f.fid = fid->snr;
if (fop->f.type == Twrite && fid->iounit && fid->iounit < fop->f.count)
fop->f.count = fid->iounit;
mvolop(fid, fop);
switch(fop->r.type){
case Ropen:
fop->r.qid = fid->qid; // comes from walkfid
open:
fid->isopen = 1;
fid->omode = fop->f.mode;
if (fop->r.iounit > msglen)
fop->r.iounit = msglen;
fid->iounit = fop->r.iounit;
break;
case Rremove:
mvoldelotherfids(fid->mvol, fid);
break;
case Rcreate:
n_append(fid->sname, fop->f.name);
mvoldelotherfids(fid->mvol, fid);
fixseenqid(fid, fid->fs, &fop->r.qid, 0);
goto open;
case Rstat:
if (fop->d && fid->fs)
fixseenqid(fid, fid->fs, &(fop->d->qid), 0);
break;
}
qunlock(fid);
if (op == Tremove || op == Tclunk){
putfs(fid->fs);
fid->fs = nil;
fop->freefid = fid;
}
}
static void
fsflush(Frpc* fop)
{
Fid* fid;
fop->r.tag = fop->f.tag;
fop->r.type= Rflush;
fid = fop->fid = getfid(fop->f.fid);
if (fid == nil)
return;
dbgprint(fid, "<- %F\m", &fop->f);
/* RACE: We don't lock the fid.
* The flushed request is probably holding the fid
* lock, and that would block the flush.
*/
fop->f.fid = fid->snr;
if (!fid->stale && fid->fs && fid->fs->fd >= 0)
fsop(fid->fs, fop);
}
void (*fscalls[Tmax])(Frpc*) =
{
[Tversion] fsversion,
[Tauth] fsauth,
[Tattach] fsattach,
[Tflush] fsflush,
[Twalk] fswalk,
[Tread] fsread,
[Topen] fsfwd,
[Tcreate] fsfwd,
[Tclunk] fsfwd,
[Twrite] fsfwd,
[Tremove] fsfwd,
[Tstat] fsfwd,
[Twstat] fsfwd,
};
|
