<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv=Content-Type content="text/html; charset=utf8">
<title>/usr/web/sources/contrib/quanstro/vx32devmnt.c - Plan 9 from Bell Labs</title>


</meta>
</head>
<body>


<a href="/plan9/">Plan 9 from Bell Labs</a>’s /usr/web/sources/contrib/quanstro/vx32devmnt.c


<center>
Copyright © 2009 Alcatel-Lucent. 
Distributed under the
<a href="/plan9/license.html">Lucent Public License version 1.02</a>.
 
<a href="/plan9/download.html">Download the Plan 9 distribution.</a>

</center>

<table width="100%" cellspacing=0 border=0><tr><td align="center">
<table cellspacing=0 cellpadding=5 bgcolor="#eeeeff"><tr><td align="left">
<pre>

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

/*
* References are managed as follows:
* The channel to the server - a network connection or pipe - has one
* reference for every Chan open on the server. The server channel has
* c->mux set to the Mnt used for muxing control to that server. Mnts
* have no reference count; they go away when c goes away.
* Each channel derived from the mount point has mchan set to c,
* and increfs/decrefs mchan to manage references on the server
* connection.
*/

#define MAXRPC (IOHDRSZ+8192)

struct Mntrpc
{
Chan* c; /* Channel for whom we are working */
Mntrpc* list; /* Free/pending list */
Fcall request; /* Outgoing file system protocol message */
Fcall reply; /* Incoming reply */
Mnt* m; /* Mount device during rpc */
Rendez r; /* Place to hang out */
uchar* rpc; /* I/O Data buffer */
uint rpclen; /* len of buffer */
Block *b; /* reply blocks */
char done; /* Rpc completed */
uvlong stime; /* start time for mnt statistics */
ulong reqlen; /* request length for mnt statistics */
ulong replen; /* reply length for mnt statistics */
Mntrpc* flushed; /* message this one flushes */
};

enum
{
TAGSHIFT = 5, /* ulong has to be 32 bits */
TAGMASK = (1<<TAGSHIFT)-1,
NMASK = (64*1024)>>TAGSHIFT,
};

struct Mntalloc
{
Lock lk;
Mnt* list; /* Mount devices in use */
Mnt* mntfree; /* Free list */
Mntrpc* rpcfree;
int nrpcfree;
int nrpcused;
ulong id;
ulong tagmask[NMASK];
}mntalloc;

Mnt* mntchk(Chan*);
void mntdirfix(uchar*, Chan*);
Mntrpc* mntflushalloc(Mntrpc*, ulong);
void mntflushfree(Mnt*, Mntrpc*);
void mntfree(Mntrpc*);
void mntgate(Mnt*);
void mntpntfree(Mnt*);
void mntqrm(Mnt*, Mntrpc*);
Mntrpc* mntralloc(Chan*, ulong);
long mntrdwr(int, Chan*, void*, long, vlong);
int mntrpcread(Mnt*, Mntrpc*);
void mountio(Mnt*, Mntrpc*);
void mountmux(Mnt*, Mntrpc*);
void mountrpc(Mnt*, Mntrpc*);
int rpcattn(void*);
Chan* mntchan(void);

char Esbadstat[] = "invalid directory entry received from server";
char Enoversion[] = "version not established for mount channel";

void (*mntstats)(int, Chan*, uvlong, ulong);

static void
mntreset(void)
{
mntalloc.id = 10; /* 1-9 are reserved for devfs */
mntalloc.tagmask[0] = 1; /* don't allow 0 as a tag */
mntalloc.tagmask[NMASK-1] = 0x80000000UL; /* don't allow NOTAG */
fmtinstall('F', fcallfmt);
fmtinstall('D', dirfmt);
/* We can't install %M since eipfmt does and is used in the kernel [sape] */

cinit();
}

/*
* Version is not multiplexed: message sent only once per connection.
*/
long
mntversion(Chan *c, char *version, int msize, int returnlen)
{
Fcall f;
uchar *msg;
Mnt *m;
char *v;
long k, l;
uvlong oo;
char buf[128];

qlock(&c->umqlock); /* make sure no one else does this until we've established ourselves */
if(waserror()){
qunlock(&c->umqlock);
nexterror();
}

/* defaults */
if(msize == 0)
msize = MAXRPC;
if(msize > c->iounit && c->iounit != 0)
msize = c->iounit;
v = version;
if(v == nil || v[0] == '\0')
v = VERSION9P;

/* validity */
if(msize < 0)
error("bad iounit in version call");
if(strncmp(v, VERSION9P, strlen(VERSION9P)) != 0)
error("bad 9P version specification");

m = c->mux;

if(m != nil){
qunlock(&c->umqlock);
poperror();

strecpy(buf, buf+sizeof buf, m->version);
k = strlen(buf);
if(strncmp(buf, v, k) != 0){
snprint(buf, sizeof buf, "incompatible 9P versions %s %s", m->version, v);
error(buf);
}
if(returnlen > 0){
if(returnlen < k)
error(Eshort);
memmove(version, buf, k);
}
return k;
}

f.type = Tversion;
f.tag = NOTAG;
f.msize = msize;
f.version = v;
msg = malloc(8192+IOHDRSZ);
if(msg == nil)
exhausted("version memory");
if(waserror()){
free(msg);
nexterror();
}
k = convS2M(&f, msg, 8192+IOHDRSZ);
if(k == 0)
error("bad fversion conversion on send");

lock(&c->ref.lk);
oo = c->offset;
c->offset += k;
unlock(&c->ref.lk);

l = devtab[c->type]->write(c, msg, k, oo);

if(l < k){
lock(&c->ref.lk);
c->offset -= k - l;
unlock(&c->ref.lk);
error("short write in fversion");
}

/* message sent; receive and decode reply */
k = devtab[c->type]->read(c, msg, 8192+IOHDRSZ, c->offset);
if(k <= 0)
error("EOF receiving fversion reply");

lock(&c->ref.lk);
c->offset += k;
unlock(&c->ref.lk);

l = convM2S(msg, k, &f);
if(l != k)
error("bad fversion conversion on reply");
if(f.type != Rversion){
if(f.type == Rerror)
error(f.ename);
error("unexpected reply type in fversion");
}
if(f.msize > msize)
error("server tries to increase msize in fversion");
if(f.msize<256 || f.msize>1024*1024)
error("nonsense value of msize in fversion");
k = strlen(f.version);
if(strncmp(f.version, v, k) != 0)
error("bad 9P version returned from server");

/* now build Mnt associated with this connection */
lock(&mntalloc.lk);
m = mntalloc.mntfree;
if(m != 0)
mntalloc.mntfree = m->list;
else {
m = malloc(sizeof(Mnt));
if(m == 0) {
unlock(&mntalloc.lk);
exhausted("mount devices");
}
}
m->list = mntalloc.list;
mntalloc.list = m;
m->version = nil;
kstrdup(&m->version, f.version);
m->id = mntalloc.id++;
m->q = qopen(10*MAXRPC, 0, nil, nil);
m->msize = f.msize;
unlock(&mntalloc.lk);

if(returnlen > 0){
if(returnlen < k)
error(Eshort);
memmove(version, f.version, k);
}

poperror(); /* msg */
free(msg);

lock(&m->lk);
m->queue = 0;
m->rip = 0;

c->flag |= CMSG;
c->mux = m;
m->c = c;
unlock(&m->lk);

poperror(); /* c */
qunlock(&c->umqlock);

return k;
}

Chan*
mntauth(Chan *c, char *spec)
{
Mnt *m;
Mntrpc *r;

m = c->mux;

if(m == nil){
mntversion(c, VERSION9P, MAXRPC, 0);
m = c->mux;
if(m == nil)
error(Enoversion);
}

c = mntchan();
if(waserror()) {
/* Close must not be called since it will
* call mnt recursively
*/
chanfree(c);
nexterror();
}

r = mntralloc(0, m->msize);

if(waserror()) {
mntfree(r);
nexterror();
}

r->request.type = Tauth;
r->request.afid = c->fid;
r->request.uname = up->user;
r->request.aname = spec;
mountrpc(m, r);

c->qid = r->reply.aqid;
c->mchan = m->c;
incref(&m->c->ref);
c->mqid = c->qid;
c->mode = ORDWR;

poperror(); /* r */
mntfree(r);

poperror(); /* c */

return c;

}

static Chan*
mntattach(char *muxattach)
{
Mnt *m;
Chan *c;
Mntrpc *r;
struct bogus{
Chan *chan;
Chan *authchan;
char *spec;
int flags;
}bogus;

bogus = *((struct bogus *)muxattach);
c = bogus.chan;

{ // Plan 9 VX addition
extern Dev mntloopdevtab;
Chan *mc;
if(devtab[c->type] == &mntloopdevtab){
if(bogus.authchan || (bogus.spec && bogus.spec[0]))
error(Ebadarg);
mc = c->aux;
incref(&mc->ref);
return mc;
}
}

m = c->mux;

if(m == nil){
mntversion(c, nil, 0, 0);
m = c->mux;
if(m == nil)
error(Enoversion);
}

c = mntchan();
if(waserror()) {
/* Close must not be called since it will
* call mnt recursively
*/
chanfree(c);
nexterror();
}

r = mntralloc(0, m->msize);

if(waserror()) {
mntfree(r);
nexterror();
}

r->request.type = Tattach;
r->request.fid = c->fid;
if(bogus.authchan == nil)
r->request.afid = NOFID;
else
r->request.afid = bogus.authchan->fid;
r->request.uname = up->user;
r->request.aname = bogus.spec;
mountrpc(m, r);

c->qid = r->reply.qid;
c->mchan = m->c;
incref(&m->c->ref);
c->mqid = c->qid;

poperror(); /* r */
mntfree(r);

poperror(); /* c */

if(bogus.flags&MCACHE)
c->flag |= CCACHE;
return c;
}

Chan*
mntchan(void)
{
Chan *c;

c = devattach('M', 0);
lock(&mntalloc.lk);
c->dev = mntalloc.id++;
unlock(&mntalloc.lk);

if(c->mchan)
panic("mntchan non-zero %p", c->mchan);
return c;
}

static Walkqid*
mntwalk(Chan *c, Chan *nc, char **name, int nname)
{
int i, alloc;
Mnt *m;
Mntrpc *r;
Walkqid *wq;

if(nc != nil)
print("mntwalk: nc != nil\n");
if(nname > MAXWELEM)
error("devmnt: too many name elements");
alloc = 0;
wq = smalloc(sizeof(Walkqid)+(nname-1)*sizeof(Qid));
if(waserror()){
if(alloc && wq->clone!=nil)
cclose(wq->clone);
free(wq);
return nil;
}

alloc = 0;
m = mntchk(c);
r = mntralloc(c, m->msize);
if(nc == nil){
nc = devclone(c);
/*
* Until the other side accepts this fid, we can't mntclose it.
* Therefore set type to 0 for now; rootclose is known to be safe.
*/
nc->type = 0;
alloc = 1;
}
wq->clone = nc;

if(waserror()) {
mntfree(r);
nexterror();
}
r->request.type = Twalk;
r->request.fid = c->fid;
r->request.newfid = nc->fid;
r->request.nwname = nname;
memmove(r->request.wname, name, nname*sizeof(char*));

mountrpc(m, r);

if(r->reply.nwqid > nname)
error("too many QIDs returned by walk");
if(r->reply.nwqid < nname){
if(alloc)
cclose(nc);
wq->clone = nil;
if(r->reply.nwqid == 0){
free(wq);
wq = nil;
goto Return;
}
}

/* move new fid onto mnt device and update its qid */
if(wq->clone != nil){
if(wq->clone != c){
wq->clone->type = c->type;
wq->clone->mchan = c->mchan;
incref(&c->mchan->ref);
}
if(r->reply.nwqid > 0)
wq->clone->qid = r->reply.wqid[r->reply.nwqid-1];
}
wq->nqid = r->reply.nwqid;
for(i=0; i<wq->nqid; i++)
wq->qid[i] = r->reply.wqid[i];

Return:
poperror();
mntfree(r);
poperror();
return wq;
}

static int
mntstat(Chan *c, uchar *dp, int n)
{
Mnt *m;
Mntrpc *r;

if(n < BIT16SZ)
error(Eshortstat);
m = mntchk(c);
r = mntralloc(c, m->msize);
if(waserror()) {
mntfree(r);
nexterror();
}
r->request.type = Tstat;
r->request.fid = c->fid;
mountrpc(m, r);

if(r->reply.nstat > n){
n = BIT16SZ;
PBIT16((uchar*)dp, r->reply.nstat-2);
}else{
n = r->reply.nstat;
memmove(dp, r->reply.stat, n);
validstat(dp, n);
mntdirfix(dp, c);
}
poperror();
mntfree(r);
return n;
}

static Chan*
mntopencreate(int type, Chan *c, char *name, int omode, ulong perm)
{
Mnt *m;
Mntrpc *r;

m = mntchk(c);
r = mntralloc(c, m->msize);
if(waserror()) {
mntfree(r);
nexterror();
}
r->request.type = type;
r->request.fid = c->fid;
r->request.mode = omode;
if(type == Tcreate){
r->request.perm = perm;
r->request.name = name;
}
mountrpc(m, r);

c->qid = r->reply.qid;
c->offset = 0;
c->mode = openmode(omode);
c->iounit = r->reply.iounit;
if(c->iounit == 0 || c->iounit > m->msize-IOHDRSZ)
c->iounit = m->msize-IOHDRSZ;
c->flag |= COPEN;
poperror();
mntfree(r);

if(c->flag & CCACHE)
copen(c);

return c;
}

static Chan*
mntopen(Chan *c, int omode)
{
return mntopencreate(Topen, c, nil, omode, 0);
}

static void
mntcreate(Chan *c, char *name, int omode, ulong perm)
{
mntopencreate(Tcreate, c, name, omode, perm);
}

static void
mntclunk(Chan *c, int t)
{
Mnt *m;
Mntrpc *r;

m = mntchk(c);
r = mntralloc(c, m->msize);
if(waserror()){
mntfree(r);
nexterror();
}

r->request.type = t;
r->request.fid = c->fid;
mountrpc(m, r);
mntfree(r);
poperror();
}

void
muxclose(Mnt *m)
{
Mntrpc *q, *r;

for(q = m->queue; q; q = r) {
r = q->list;
mntfree(q);
}
m->id = 0;
free(m->version);
m->version = nil;
mntpntfree(m);
}

void
mntpntfree(Mnt *m)
{
Mnt *f, **l;
Queue *q;

lock(&mntalloc.lk);
l = &mntalloc.list;
for(f = *l; f; f = f->list) {
if(f == m) {
*l = m->list;
break;
}
l = &f->list;
}
m->list = mntalloc.mntfree;
mntalloc.mntfree = m;
q = m->q;
unlock(&mntalloc.lk);

qfree(q);
}

static void
mntclose(Chan *c)
{
mntclunk(c, Tclunk);
}

static void
mntremove(Chan *c)
{
mntclunk(c, Tremove);
}

static int
mntwstat(Chan *c, uchar *dp, int n)
{
Mnt *m;
Mntrpc *r;

m = mntchk(c);
r = mntralloc(c, m->msize);
if(waserror()) {
mntfree(r);
nexterror();
}
r->request.type = Twstat;
r->request.fid = c->fid;
r->request.nstat = n;
r->request.stat = dp;
mountrpc(m, r);
poperror();
mntfree(r);
return n;
}

static long
mntread(Chan *c, void *buf, long n, vlong off)
{
uchar *p, *e;
int nc, cache, isdir, dirlen;

isdir = 0;
cache = c->flag & CCACHE;
if(c->qid.type & QTDIR) {
cache = 0;
isdir = 1;
}

p = buf;
if(cache) {
nc = cread(c, buf, n, off);
if(nc > 0) {
n -= nc;
if(n == 0)
return nc;
p += nc;
off += nc;
}
n = mntrdwr(Tread, c, p, n, off);
cupdate(c, p, n, off);
return n + nc;
}

n = mntrdwr(Tread, c, buf, n, off);
if(isdir) {
for(e = &p[n]; p+BIT16SZ < e; p += dirlen){
dirlen = BIT16SZ+GBIT16(p);
if(p+dirlen > e)
break;
validstat(p, dirlen);
mntdirfix(p, c);
}
if(p != e)
error(Esbadstat);
}
return n;
}

static long
mntwrite(Chan *c, void *buf, long n, vlong off)
{
return mntrdwr(Twrite, c, buf, n, off);
}

long
mntrdwr(int type, Chan *c, void *buf, long n, vlong off)
{
Mnt *m;
Mntrpc *r;
char *uba;
int cache;
ulong cnt, nr, nreq;

m = mntchk(c);
uba = buf;
cnt = 0;
cache = c->flag & CCACHE;
if(c->qid.type & QTDIR)
cache = 0;
for(;;) {
r = mntralloc(c, m->msize);
if(waserror()) {
mntfree(r);
nexterror();
}
r->request.type = type;
r->request.fid = c->fid;
r->request.offset = off;
r->request.data = uba;
nr = n;
if(nr > m->msize-IOHDRSZ)
nr = m->msize-IOHDRSZ;
r->request.count = nr;
mountrpc(m, r);
nreq = r->request.count;
nr = r->reply.count;
if(nr > nreq)
nr = nreq;

if(type == Tread)
r->b = bl2mem((uchar*)uba, r->b, nr);
else if(cache)
cwrite(c, (uchar*)uba, nr, off);

poperror();
mntfree(r);
off += nr;
uba += nr;
cnt += nr;
n -= nr;
if(nr != nreq || n == 0 || up->nnote)
break;
}
return cnt;
}

void
mountrpc(Mnt *m, Mntrpc *r)
{
char *sn, *cn;
int t;

r->reply.tag = 0;
r->reply.type = Tmax; /* can't ever be a valid message type */

mountio(m, r);

t = r->reply.type;
switch(t) {
case Rerror:
error(r->reply.ename);
case Rflush:
error(Eintr);
default:
if(t == r->request.type+1)
break;
sn = "?";
if(m->c->path != nil)
sn = m->c->path->s;
cn = "?";
if(r->c != nil && r->c->path != nil)
cn = r->c->path->s;
print("mnt: proc %s %lud: mismatch from %s %s rep 0x%lux tag %d fid %d T%d R%d rp %d\n",
up->text, up->pid, sn, cn,
r, r->request.tag, r->request.fid, r->request.type,
r->reply.type, r->reply.tag);
error(Emountrpc);
}
}

void
mountio(Mnt *m, Mntrpc *r)
{
int n;

while(waserror()) {
if(m->rip == up)
mntgate(m);
if(strcmp(up->errstr, Eintr) != 0){
mntflushfree(m, r);
nexterror();
}
r = mntflushalloc(r, m->msize);
}

lock(&m->lk);
r->m = m;
r->list = m->queue;
m->queue = r;
unlock(&m->lk);

/* Transmit a file system rpc */
if(m->msize == 0)
panic("msize");
n = convS2M(&r->request, r->rpc, m->msize);
if(n < 0)
panic("bad message type in mountio");
if(devtab[m->c->type]->write(m->c, r->rpc, n, 0) != n)
error(Emountrpc);
r->stime = fastticks(nil);
r->reqlen = n;

/* Gate readers onto the mount point one at a time */
for(;;) {
lock(&m->lk);
if(m->rip == 0)
break;
unlock(&m->lk);
sleep(&r->r, rpcattn, r);
if(r->done){
poperror();
mntflushfree(m, r);
return;
}
}
m->rip = up;
unlock(&m->lk);
while(r->done == 0) {
if(mntrpcread(m, r) < 0)
error(Emountrpc);
mountmux(m, r);
}
mntgate(m);
poperror();
mntflushfree(m, r);
}

static int
doread(Mnt *m, int len)
{
Block *b;

while(qlen(m->q) < len){
b = devtab[m->c->type]->bread(m->c, m->msize, 0);
if(b == nil)
return -1;
if(blocklen(b) == 0){
freeblist(b);
return -1;
}
qaddlist(m->q, b);
}
return 0;
}

int
mntrpcread(Mnt *m, Mntrpc *r)
{
int i, t, len, hlen;
Block *b, **l, *nb;

r->reply.type = 0;
r->reply.tag = 0;

/* read at least length, type, and tag and pullup to a single block */
if(doread(m, BIT32SZ+BIT8SZ+BIT16SZ) < 0)
return -1;
nb = pullupqueue(m->q, BIT32SZ+BIT8SZ+BIT16SZ);

/* read in the rest of the message, avoid ridiculous (for now) message sizes */
len = GBIT32(nb->rp);
if(len > m->msize){
qdiscard(m->q, qlen(m->q));
return -1;
}
if(doread(m, len) < 0)
return -1;

/* pullup the header (i.e. everything except data) */
t = nb->rp[BIT32SZ];
switch(t){
case Rread:
hlen = BIT32SZ+BIT8SZ+BIT16SZ+BIT32SZ;
break;
default:
hlen = len;
break;
}
nb = pullupqueue(m->q, hlen);

if(convM2S(nb->rp, len, &r->reply) <= 0){
/* bad message, dump it */
print("mntrpcread: convM2S failed\n");
qdiscard(m->q, len);
return -1;
}

/* hang the data off of the fcall struct */
l = &r->b;
*l = nil;
do {
b = qremove(m->q);
if(hlen > 0){
b->rp += hlen;
len -= hlen;
hlen = 0;
}
i = BLEN(b);
if(i <= len){
len -= i;
*l = b;
l = &(b->next);
} else {
/* split block and put unused bit back */
nb = allocb(i-len);
memmove(nb->wp, b->rp+len, i-len);
b->wp = b->rp+len;
nb->wp += i-len;
qputback(m->q, nb);
*l = b;
return 0;
}
}while(len > 0);

return 0;
}

void
mntgate(Mnt *m)
{
Mntrpc *q;

lock(&m->lk);
m->rip = 0;
for(q = m->queue; q; q = q->list) {
if(q->done == 0)
if(wakeup(&q->r))
break;
}
unlock(&m->lk);
}

void
mountmux(Mnt *m, Mntrpc *r)
{
int bad;
Mntrpc **l, *q;
int tagallocd(int);
void freetag(int);

lock(&m->lk);
l = &m->queue;
for(q = *l; q; q = q->list) {
/* look for a reply to a message */
if(q->request.tag == r->reply.tag) {
*l = q->list;
if(q != r) {
/*
* Completed someone else.
* Trade pointers to receive buffer.
*/
q->reply = r->reply;
q->b = r->b;
r->b = nil;
}
q->done = 1;
unlock(&m->lk);
if(mntstats != nil)
(*mntstats)(q->request.type,
m->c, q->stime,
q->reqlen + r->replen);
if(q != r)
wakeup(&q->r);
return;
}
l = &q->list;
}
bad = 1;
if(tagallocd(r->reply.tag)){
freetag(r->reply.tag);
bad = 0;
}
unlock(&m->lk);
if(bad)
print("unexpected reply tag %ud; type %d\n", r->reply.tag, r->reply.type);
else
print("WOOT! caught stale reply %ud; type %d\n", r->reply.tag, r->reply.type);
}

/*
* Create a new flush request and chain the previous
* requests from it
*/
Mntrpc*
mntflushalloc(Mntrpc *r, ulong iounit)
{
Mntrpc *fr;

fr = mntralloc(0, iounit);

fr->request.type = Tflush;
if(r->request.type == Tflush)
fr->request.oldtag = r->request.oldtag;
else
fr->request.oldtag = r->request.tag;
fr->flushed = r;

return fr;
}

/*
* Free a chain of flushes. Remove each unanswered
* flush and the original message from the unanswered
* request queue. Mark the original message as done
* and if it hasn't been answered set the reply to to
* Rflush.
*/
void
mntflushfree(Mnt *m, Mntrpc *r)
{
Mntrpc *fr;

while(r){
fr = r->flushed;
if(!r->done){
r->reply.type = Rflush;
mntqrm(m, r);
}
if(fr)
mntfree(r);
r = fr;
}
}

int
alloctag(void)
{
int i, j;
ulong v;

for(i = 0; i < NMASK; i++){
v = mntalloc.tagmask[i];
if(v == ~0UL)
continue;
for(j = 0; j < 1<<TAGSHIFT; j++)
if((v & (1<<j)) == 0){
mntalloc.tagmask[i] |= 1<<j;
return (i<<TAGSHIFT) + j;
}
}
panic("no friggin tags left");
return NOTAG;
}

int
tagallocd(int t)
{
return mntalloc.tagmask[t>>TAGSHIFT] & 1<<(t&TAGMASK);
}

void
freetag(int t)
{
mntalloc.tagmask[t>>TAGSHIFT] &= ~(1<<(t&TAGMASK));
}

Mntrpc*
mntralloc(Chan *c, ulong msize)
{
Mntrpc *new;

lock(&mntalloc.lk);
new = mntalloc.rpcfree;
if(new == nil){
new = malloc(sizeof(Mntrpc));
if(new == nil) {
unlock(&mntalloc.lk);
exhausted("mount rpc header");
}
/*
* The header is split from the data buffer as
* mountmux may swap the buffer with another header.
*/
new->rpc = mallocz(msize, 0);
if(new->rpc == nil){
free(new);
unlock(&mntalloc.lk);
exhausted("mount rpc buffer");
}
new->rpclen = msize;
new->request.tag = alloctag();
}
else {
mntalloc.rpcfree = new->list;
mntalloc.nrpcfree--;
if(new->rpclen < msize){
free(new->rpc);
new->rpc = mallocz(msize, 0);
if(new->rpc == nil){
free(new);
mntalloc.nrpcused--;
unlock(&mntalloc.lk);
exhausted("mount rpc buffer");
}
new->rpclen = msize;
}
}
mntalloc.nrpcused++;
unlock(&mntalloc.lk);
new->c = c;
new->done = 0;
new->flushed = nil;
new->b = nil;
return new;
}

void
mntfree(Mntrpc *r)
{
if(r->b != nil)
freeblist(r->b);
lock(&mntalloc.lk);
if(mntalloc.nrpcfree >= 10){
free(r->rpc);
free(r);
if(r->done != 2)
freetag(r->request.tag);
}
else{
if(r->done == 2)
r->request.tag = alloctag();
r->list = mntalloc.rpcfree;
mntalloc.rpcfree = r;
mntalloc.nrpcfree++;
}
mntalloc.nrpcused--;
unlock(&mntalloc.lk);
}

void
mntqrm(Mnt *m, Mntrpc *r)
{
Mntrpc **l, *f;

lock(&m->lk);
r->done = 2;

l = &m->queue;
for(f = *l; f; f = f->list) {
if(f == r) {
*l = r->list;
break;
}
l = &f->list;
}
unlock(&m->lk);
}

Mnt*
mntchk(Chan *c)
{
Mnt *m;

/* This routine is mostly vestiges of prior lives; now it's just sanity checking */

if(c->mchan == nil)
panic("mntchk 1: nil mchan c %s\n", chanpath(c));

m = c->mchan->mux;

if(m == nil)
print("mntchk 2: nil mux c %s c->mchan %s \n", chanpath(c), chanpath(c->mchan));

/*
* Was it closed and reused (was error(Eshutdown); now, it cannot happen)
*/
if(m->id == 0 || m->id >= c->dev)
panic("mntchk 3: can't happen");

return m;
}

/*
* Rewrite channel type and dev for in-flight data to
* reflect local values. These entries are known to be
* the first two in the Dir encoding after the count.
*/
void
mntdirfix(uchar *dirbuf, Chan *c)
{
uint r;

r = devtab[c->type]->dc;
dirbuf += BIT16SZ; /* skip count */
PBIT16(dirbuf, r);
dirbuf += BIT16SZ;
PBIT32(dirbuf, c->dev);
}

int
rpcattn(void *v)
{
Mntrpc *r;

r = v;
return r->done || r->m->rip == 0;
}

Dev mntdevtab = {
'M',
"mnt",

mntreset,
devinit,
devshutdown,
mntattach,
mntwalk,
mntstat,
mntopen,
mntcreate,
mntclose,
mntread,
devbread,
mntwrite,
devbwrite,
mntremove,
mntwstat,
};

</pre>
</td></tr></table>
</td></tr></table>





<center><table border="0"><tr>
<td valign="middle"><a href="http://www.alcatel-lucent.com/"><img border="0" src="/plan9/img/logo_ft.gif" alt="Bell Labs" />
</a></td>
<td valign="middle"><a href="http://www.opensource.org"><img border="0" alt="OSI certified" src="/plan9/img/osi-certified-60x50.gif" />
</a></td>
<td><img style="padding-right: 45px;" alt="Powered by Plan 9" src="/plan9/img/power36.gif" />
</td>
</tr></table></center>

<center>
(<a href="/plan9/">Return to Plan 9 Home Page</a>)
</center>

<center>
<a href="http://www.lucent.com/copyright.html">Copyright</a>
© 2009 Alcatel-Lucent.
All Rights Reserved.
 
Comments to
<a href="mailto:[email protected]">[email protected]</a>.
</center>
</body>
</html>