1990/0629/port/devmnt.c (diff list | history)

port/devmnt.c on 1990/0227
1990/0227		#include "u.h" #include "lib.h" #include "mem.h" #include "dat.h" #include "fns.h" #include "errno.h" #include "devtab.h" #include "fcall.h" typedef struct Mnt Mnt;
1990/0604		typedef struct Mnthdr Mnthdr; typedef struct MntQ MntQ;
1990/0227		struct Mnt { Ref; /* for number of chans, incl. mntpt but not msg */
1990/0303		ulong mntid; /* serial # */
1990/0227		Chan *mntpt; /* channel in user's name space */
1990/0604		MntQ *q;
1990/0227		};
1990/0604		struct MntQ { Ref; QLock; /* for access */ MntQ *next; /* for allocation */ Chan *msg; /* for reading and writing messages */ Proc *reader; /* process reading response */ Mnthdr *writer; /* queue of headers of written messages */ };
1990/0227		#define BUFSIZE (MAXFDATA+500) /* BUG */ typedef struct Mntbuf Mntbuf; struct Mntbuf { Mntbuf *next; char buf[BUFSIZE]; }; struct { Lock; Mntbuf *free; }mntbufalloc;
1990/0604		struct Mnthdr
1990/0227		{
1990/0604		Mnthdr *next; /* in free list or writers list */
1990/0227		Fcall thdr; Fcall rhdr;
1990/0604		Rendez r; Proc *p; Mntbuf *mbr;
1990/0227		}; struct { Lock; Mnthdr *free; }mnthdralloc;
1990/0303		struct { Lock;
1990/0619		QLock;
1990/0604		MntQ *arena; MntQ *free; }mntqalloc; struct { Lock;
1990/0303		long id; }mntid;
1990/0227		Mnt *mnt; void mntxmit(Mnt*, Mnthdr*); Mntbuf* mballoc(void) { Mntbuf *mb; loop: lock(&mntbufalloc); if(mb = mntbufalloc.free){ /* assign = */ mntbufalloc.free = mb->next; unlock(&mntbufalloc); return mb; } unlock(&mntbufalloc); print("no mntbufs\n"); if(u == 0) panic("mballoc"); u->p->state = Wakeme; alarm(1000, wakeme, u->p); sched(); goto loop; } void mbfree(Mntbuf *mb) { lock(&mntbufalloc); mb->next = mntbufalloc.free; mntbufalloc.free = mb; unlock(&mntbufalloc); } Mnthdr* mhalloc(void) { Mnthdr *mh; loop: lock(&mnthdralloc); if(mh = mnthdralloc.free){ /* assign = */ mnthdralloc.free = mh->next; unlock(&mnthdralloc); return mh; } unlock(&mnthdralloc); print("no mnthdrs\n"); if(u == 0)
1990/0604		panic("mhalloc");
1990/0227		u->p->state = Wakeme; alarm(1000, wakeme, u->p); sched(); goto loop; } void mhfree(Mnthdr *mh) { lock(&mnthdralloc); mh->next = mnthdralloc.free; mnthdralloc.free = mh; unlock(&mnthdralloc); }
1990/0604		MntQ*
1990/0619		mqalloc(Chan *msg) /* mntqalloc is qlocked */
1990/0604		{ MntQ *q; if(q = mntqalloc.free){ /* assign = */ mntqalloc.free = q->next; lock(q); q->ref = 1;
1990/0617		q->msg = msg; unlock(q); incref(msg);
1990/0604		q->writer = 0; q->reader = 0; return q; } panic("no mntqs\n"); /* there MUST be enough */ } void mqfree(MntQ *mq) { Chan *msg = 0; lock(mq); if(--mq->ref == 0){ msg = mq->msg; mq->msg = 0; lock(&mntqalloc); mq->next = mntqalloc.free; mntqalloc.free = mq; unlock(&mntqalloc); } unlock(mq); if(msg) /* after locks are down */ close(msg); }
1990/0227		Mnt* mntdev(int dev, int noerr) { Mnt *m;
1990/0303		int i;
1990/0227
1990/0303		for(m=mnt,i=0; i<conf.nmntdev; i++,m++) /* use a hash table some day */ if(m->mntid == dev){
1990/0604		if(m->q == 0)
1990/0303		break; return m; } if(noerr) return 0; error(0, Eshutdown);
1990/0227		} void mntreset(void) { int i; Mntbuf *mb; Mnthdr *mh;
1990/0604		MntQ *mq;
1990/0227		mnt = ialloc(conf.nmntdev*sizeof(Mnt), 0); mb = ialloc(conf.nmntbuf*sizeof(Mntbuf), 0); for(i=0; i<conf.nmntbuf-1; i++) mb[i].next = &mb[i+1]; mb[i].next = 0; mntbufalloc.free = mb; mh = ialloc(conf.nmnthdr*sizeof(Mnthdr), 0); for(i=0; i<conf.nmnthdr-1; i++) mh[i].next = &mh[i+1]; mh[i].next = 0; mnthdralloc.free = mh;
1990/0604		mq = ialloc(conf.nmntdev*sizeof(MntQ), 0); for(i=0; i<conf.nmntdev-1; i++) mq[i].next = &mq[i+1]; mq[i].next = 0; mntqalloc.arena = mq; mntqalloc.free = mq;
1990/0227		} void mntinit(void) { } Chan* mntattach(char *spec) { int i;
1990/0604		Mnt *m, *mm;
1990/0227		Mnthdr *mh;
1990/0604		MntQ *q;
1990/0227		Chan *c, *cm; struct bogus{ Chan *chan; char *spec; }bogus; bogus = *((struct bogus *)spec); spec = bogus.spec; m = mnt; for(i=0; i<conf.nmntdev; i++,m++){ lock(m); if(m->ref == 0) goto Found; unlock(m); } error(0, Enomntdev);
1990/0604
1990/0227		Found: m->ref = 1; unlock(m);
1990/0303		lock(&mntid); m->mntid = ++mntid.id; unlock(&mntid);
1990/0227		c = devattach('M', spec);
1990/0303		c->dev = m->mntid;
1990/0227		m->mntpt = c; cm = bogus.chan;
1990/0604		/* * Look for queue to same msg channel */ q = mntqalloc.arena;
1990/0619		qlock(&mntqalloc);
1990/0604		for(i=0; i<conf.nmntdev; i++,q++) if(q->msg==cm){ lock(q); if(q->ref && q->msg==cm){ m->q = q; q->ref++; unlock(q); goto out; } unlock(q); }
1990/0617		m->q = mqalloc(cm);
1990/0604		out:
1990/0619		qunlock(&mntqalloc);
1990/0227		mh = mhalloc(); if(waserror()){ mhfree(mh);
1990/0604		mqfree(q);
1990/0227		close(c); nexterror(); } mh->thdr.type = Tattach; mh->thdr.fid = c->fid; memcpy(mh->thdr.uname, u->p->pgrp->user, NAMELEN); strcpy(mh->thdr.aname, spec); mntxmit(m, mh); c->qid = mh->rhdr.qid;
1990/0604		c->mchan = m->q->msg;
1990/0303		c->mqid = c->qid;
1990/0227		mhfree(mh); poperror(); return c; } Chan* mntclone(Chan *c, Chan *nc) { Mnt *m; Mnthdr *mh; int new; new = 0; if(nc == 0){ nc = newchan(); new = 1; if(waserror()){ close(nc); nexterror(); } } m = mntdev(c->dev, 0); mh = mhalloc(); if(waserror()){ mhfree(mh); nexterror(); } mh->thdr.type = Tclone; mh->thdr.fid = c->fid; mh->thdr.newfid = nc->fid; mntxmit(m, mh); nc->type = c->type; nc->dev = c->dev; nc->qid = c->qid; nc->mode = c->mode; nc->flag = c->flag; nc->offset = c->offset; nc->mnt = c->mnt;
1990/0303		nc->mchan = c->mchan; nc->mqid = c->qid;
1990/0227		mhfree(mh); poperror();
1990/0513		if(new) poperror();
1990/0227		incref(m); return nc; } int mntwalk(Chan *c, char *name) { Mnt *m; Mnthdr *mh; int found; found = 1; m = mntdev(c->dev, 0); mh = mhalloc(); mh->thdr.type = Twalk; mh->thdr.fid = c->fid; strcpy(mh->thdr.name, name); if(waserror()){ /* BUG: can check type of error? */ found = 0; goto Out; } mntxmit(m, mh); c->qid = mh->rhdr.qid; poperror(); Out: mhfree(mh); return found; } void mntstat(Chan *c, char *dp) { Mnt *m; Mnthdr *mh; m = mntdev(c->dev, 0); mh = mhalloc(); if(waserror()){ mhfree(mh); nexterror(); } mh->thdr.type = Tstat; mh->thdr.fid = c->fid; mntxmit(m, mh); memcpy(dp, mh->rhdr.stat, DIRLEN); dp[DIRLEN-4] = devchar[c->type]; dp[DIRLEN-3] = 0; dp[DIRLEN-2] = c->dev; dp[DIRLEN-1] = c->dev>>8; mhfree(mh); poperror(); } Chan* mntopen(Chan *c, int omode) { Mnt *m; Mnthdr *mh; m = mntdev(c->dev, 0); mh = mhalloc(); if(waserror()){ mhfree(mh); nexterror(); } mh->thdr.type = Topen; mh->thdr.fid = c->fid; mh->thdr.mode = omode; mntxmit(m, mh); c->qid = mh->rhdr.qid; mhfree(mh); poperror(); c->offset = 0; c->mode = openmode(omode); c->flag |= COPEN; return c; } void mntcreate(Chan *c, char *name, int omode, ulong perm) { Mnt *m; Mnthdr *mh; m = mntdev(c->dev, 0); mh = mhalloc(); if(waserror()){ mhfree(mh); nexterror(); } mh->thdr.type = Tcreate; mh->thdr.fid = c->fid; strcpy(mh->thdr.name, name); mh->thdr.mode = omode; mh->thdr.perm = perm; mntxmit(m, mh); c->qid = mh->rhdr.qid; mhfree(mh); poperror(); c->flag |= COPEN; c->mode = openmode(omode); c->qid = mh->rhdr.qid; } void
1990/0604		mntclunk(Chan *c, int t)
1990/0227		{ Mnt *m; Mnthdr *mh;
1990/0604		MntQ *q; int waserr; int ne = u->nerrlab;
1990/0227		m = mntdev(c->dev, 0); mh = mhalloc();
1990/0604		mh->thdr.type = t;
1990/0227		mh->thdr.fid = c->fid;
1990/0604		waserr = 0; if(waserror()) /* gotta clean up as if there wasn't */ waserr = 1; else mntxmit(m, mh);
1990/0227		mhfree(mh); if(c == m->mntpt) m->mntpt = 0;
1990/0604		lock(m); if(--m->ref == 0){ /* BUG: need to hang up all pending i/o */ q = m->q; m->q = 0; m->mntid = 0; unlock(m); /* mqfree can take time */ mqfree(q); }else unlock(m); if(waserr) nexterror();
1990/0227		poperror(); }
1990/0604		void mntclose(Chan *c) { mntclunk(c, Tclunk); }
1990/0227		long mntreadwrite(Chan *c, void *vbuf, long n, int type) { Mnt *m; Mnthdr *mh; long nt, nr, count, offset; char *buf; buf = vbuf; count = 0; offset = c->offset; m = mntdev(c->dev, 0); mh = mhalloc(); if(waserror()){ mhfree(mh); nexterror(); } mh->thdr.type = type; mh->thdr.fid = c->fid; Loop: nt = n; if(nt > MAXFDATA) nt = MAXFDATA; mh->thdr.offset = offset; mh->thdr.count = nt; mh->thdr.data = buf; mntxmit(m, mh); nr = mh->rhdr.count; offset += nr; count += nr; buf += nr; n -= nr; if(n && nr==nt) goto Loop; mhfree(mh); poperror(); return count; } long mntread(Chan *c, void *buf, long n) { long i; uchar *b; n = mntreadwrite(c, buf, n, Tread); if(c->qid & CHDIR){ b = (uchar*)buf; for(i=n-DIRLEN; i>=0; i-=DIRLEN){ b[DIRLEN-4] = devchar[c->type]; b[DIRLEN-3] = 0; b[DIRLEN-2] = c->dev; b[DIRLEN-1] = c->dev>>8; b += DIRLEN; } } return n; } long mntwrite(Chan *c, void *buf, long n) { return mntreadwrite(c, buf, n, Twrite); } void mntremove(Chan *c) {
1990/0604		mntclunk(c, Tremove);
1990/0227		} void mntwstat(Chan *c, char *dp) { Mnt *m; Mnthdr *mh; m = mntdev(c->dev, 0); mh = mhalloc(); if(waserror()){ mhfree(mh); nexterror(); } mh->thdr.type = Twstat; mh->thdr.fid = c->fid; memcpy(mh->thdr.stat, dp, DIRLEN); mntxmit(m, mh); mhfree(mh); poperror(); } void mnterrstr(Error *e, char *buf) { Mnt *m; Mnthdr *mh; char *def="mounted device shut down"; m = mntdev(e->dev, 1); if(m == 0){ strcpy(buf, def); return; } mh = mhalloc(); if(waserror()){ strcpy(buf, def); mhfree(mh); nexterror(); } mh->thdr.type = Terrstr; mh->thdr.fid = 0; mh->thdr.err = e->code; mntxmit(m, mh); strcpy(buf, (char*)mh->rhdr.ename); mhfree(mh); poperror(); } void mntuserstr(Error *e, char *buf) { Mnt *m; Mnthdr *mh; char *def="mounted device shut down"; m = mntdev(e->dev, 1); if(m == 0){ strcpy(buf, def); return; } mh = mhalloc(); if(waserror()){ strcpy(buf, def); mhfree(mh); nexterror(); } mh->thdr.type = Tuserstr; mh->thdr.fid = 0; mh->thdr.uid = e->code; mntxmit(m, mh); strcpy(buf, (char*)mh->rhdr.uname); mhfree(mh); poperror(); } void
1990/0604		mnterrdequeue(MntQ *q, Mnthdr *mh) /* queue is unlocked */ { Mnthdr *w; qlock(q); /* take self from queue if necessary */ if(q->reader == u->p){ /* advance a writer to reader */ w = q->writer; if(w){ q->reader = w->p; q->writer = w->next; wakeup(&w->r); }else{ q->reader = 0; q->writer = 0; } }else{ w = q->writer; if(w == mh) q->writer = w->next; else{ while(w){ if(w->next == mh){ w->next = mh->next; break; } w = w->next; } } } qunlock(q); } void
1990/0227		mntxmit(Mnt *m, Mnthdr *mh) { ulong n;
1990/0619		Mntbuf *mbw;
1990/0604		Mnthdr *w, *ow; Chan *mntpt; MntQ *q; int qlocked;
1990/0227
1990/0619		mh->mbr = mballoc();
1990/0227		mbw = mballoc(); if(waserror()){
1990/0619		mbfree(mh->mbr);
1990/0227		mbfree(mbw); nexterror(); } n = convS2M(&mh->thdr, mbw->buf);
1990/0604		q = m->q; if(q == 0) error(0, Eshutdown); #ifdef BIT3
1990/03081		/*
1990/0511		* Bit3 does its own multiplexing. (Well, the file server does.) * The code is different enough that it's broken out separately here.
1990/03081		*/
1990/0604		if(devchar[q->msg->type] != '3')
1990/0511		goto Normal;
1990/0604		incref(q);
1990/0227		if(waserror()){
1990/0604		mqfree(q);
1990/0227		nexterror(); }
1990/0604		if((*devtab[q->msg->type].write)(q->msg, mbw->buf, n) != n){ print("short write in mntxmit\n"); error(0, Eshortmsg);
1990/0227		} /* * Read response */
1990/0619		n = (*devtab[q->msg->type].read)(q->msg, mh->mbr->buf, BUFSIZE);
1990/0604		mqfree(q);
1990/0511		poperror();
1990/0619		if(convM2S(mh->mbr->buf, &mh->rhdr, n) == 0){
1990/0604		print("format error in mntxmit\n"); error(0, Ebadmsg);
1990/0511		} /* * Various checks */ if(mh->rhdr.type != mh->thdr.type+1){
1990/0604		print("type mismatch %d %d\n", mh->rhdr.type, mh->thdr.type+1); error(0, Ebadmsg);
1990/0511		} if(mh->rhdr.fid != mh->thdr.fid){
1990/0604		print("fid mismatch %d %d type %d\n", mh->rhdr.fid, mh->thdr.fid, mh->rhdr.type); error(0, Ebadmsg);
1990/0511		} if(mh->rhdr.err){ mntpt = m->mntpt; /* unsafe, but Errors are unsafe anyway */ if(mntpt) error(mntpt, mh->rhdr.err); error(0, Eshutdown); } /* * Copy out on read */ if(mh->thdr.type == Tread) memcpy(mh->thdr.data, mh->rhdr.data, mh->rhdr.count);
1990/0619		mbfree(mh->mbr);
1990/0511		mbfree(mbw); poperror(); return; Normal:
1990/0604		#endif incref(q); qlock(q); qlocked = 1;
1990/0511		if(waserror()){
1990/0604		if(qlocked) qunlock(q); mqfree(q);
1990/0511		nexterror();
1990/03081		}
1990/0604		if((*devtab[q->msg->type].write)(q->msg, mbw->buf, n) != n){ print("short write in mntxmit\n"); error(0, Eshortmsg);
1990/0511		}
1990/0604		if(q->reader == 0){ /* i will read */ q->reader = u->p; Read: qunlock(q); qlocked = 0;
1990/0619		n = (*devtab[q->msg->type].read)(q->msg, mh->mbr->buf, BUFSIZE); if(convM2S(mh->mbr->buf, &mh->rhdr, n) == 0){
1990/0604		mnterrdequeue(q, mh); error(0, Ebadmsg); } /* * Response might not be mine */ qlock(q); qlocked = 1; if(mh->rhdr.fid == mh->thdr.fid && mh->rhdr.type == mh->thdr.type+1){ /* it's mine */ q->reader = 0; if(w = q->writer){ /* advance a writer to reader */ q->reader = w->p; q->writer = w->next; wakeup(&w->r); } qunlock(q); qlocked = 0; goto Respond; } /* * Hand response to correct recipient */ for(ow=0,w=q->writer; w; ow=w,w=w->next) if(mh->rhdr.fid == w->thdr.fid && mh->rhdr.type == w->thdr.type+1){ Mntbuf *t;
1990/0619		t = mh->mbr; mh->mbr = w->mbr;
1990/0604		w->mbr = t; memcpy(&w->rhdr, &mh->rhdr, sizeof mh->rhdr); /* take recipient from queue */ if(ow == 0) q->writer = w->next; else ow->next = w->next; wakeup(&w->r); goto Read; }
1990/0629		print("devmnt: undelivered response fid %d type %d\n", mh->rhdr.fid, mh->rhdr.type); print("reader pid %d fid %d type %d\n", u->p->pid, mh->thdr.fid, mh->thdr.type); for(w=q->writer; w; w=w->next)print("writer pid %d fid %d type %d\n",w->p->pid,w->thdr.fid,w->thdr.type);
1990/0604		goto Read; }else{ mh->p = u->p; /* put self in queue */ mh->next = q->writer; q->writer = mh; qunlock(q); qlocked = 0; if(waserror()){ /* interrupted sleep */ mnterrdequeue(q, mh); nexterror(); } sleep(&mh->r, return0, 0); poperror(); qlock(q); qlocked = 1; if(q->reader == u->p) /* i got promoted */ goto Read; qunlock(q); qlocked = 0; goto Respond;
1990/0227		}
1990/0604		Respond: mqfree(q); poperror();
1990/0227		if(mh->rhdr.err){ mntpt = m->mntpt; /* unsafe, but Errors are unsafe anyway */ if(mntpt) error(mntpt, mh->rhdr.err); error(0, Eshutdown); } /* * Copy out on read */ if(mh->thdr.type == Tread) memcpy(mh->thdr.data, mh->rhdr.data, mh->rhdr.count);
1990/0619		mbfree(mh->mbr);
1990/0227		mbfree(mbw); poperror(); }