~kris/9p

9hist

c036890165fa1be9f90dd3f6a33b68a71d887ce1 — David du Colombier 26 years ago 1070549
Plan 9 from Bell Labs 1999-11-05
M pc/vgat2r4.c => pc/vgat2r4.c +8 -0
@@ 328,6 328,13 @@ t2r4curenable(VGAscr* scr)
	t2r4xo(scr, CursorCtl, CursorMode);
}

static void
t2r4drawinit(VGAscr *scr)
{
	scr->fill = nil;
	scr->scroll = nil;
}

VGAdev vgat2r4dev = {
	"t2r4",



@@ 335,6 342,7 @@ VGAdev vgat2r4dev = {
	nil,
	nil,
	t2r4linear,
	t2r4drawinit,
};

VGAcur vgat2r4cur = {

M port/chan.c => port/chan.c +0 -12
@@ 47,18 47,6 @@ decref(Ref *r)
}

void
chanrec(Mnt *m)
{
	Chan *c;

	lock(&chanalloc);
	for(c = chanalloc.list; c; c = c->link)
		if(c->mntptr == m)
			c->flag |= CRECOV;
	unlock(&chanalloc);
}

void
chandevreset(void)
{
	int i;

M port/devmnt.c => port/devmnt.c +0 -179
@@ 55,7 55,6 @@ void	mountmux(Mnt*, Mntrpc*);
void	mountrpc(Mnt*, Mntrpc*);
int	rpcattn(void*);
void	mclose(Mnt*, Chan*);
void	mntrecover(Mnt*, Mntrpc*);
Chan*	mntchan(void);

int defmaxmsg = MAXFDATA;


@@ 621,13 620,7 @@ mountrpc(Mnt *m, Mntrpc *r)
	r->reply.tag = 0;
	r->reply.type = 4;

	while(waserror()) {
		if((m->flags&MRECOV) == 0)
			nexterror();
		mntrecover(m, r);
	}
	mountio(m, r);
	poperror();

	t = r->reply.type;
	switch(t) {


@@ 898,62 891,6 @@ mntqrm(Mnt *m, Mntrpc *r)
	unlock(m);
}

void
recoverchan(Mnt*, Chan*)
{
panic("recoverchan");
#ifdef asdf
BUG: WON'T WORK WITH PATHS GONE?
	int i, n, flg;
	Path *safe, *p, **pav;

	if(m->c == 0)
		error(Eshutdown);

	flg = c->flag;
	/* Don't recursively recover */
	c->flag &= ~(COPEN|CRECOV);

	n = 0;
	for(p = c->path; p; p = p->parent)
		n++;
	pav = smalloc(sizeof(Path*)*n);
	i = n;
	for(p = c->path; p; p = p->parent)
		pav[--i] = p;

	safe = c->path;

	if(waserror()) {
		c->flag = flg;
		free(pav);
		nexterror();
	}

	/* Attach the fid onto the file server (sets c->path to #Mxxx) */
	mattach(m, c, c->xmh->mount->spec);
	poperror();

	/*
	 * c is now at the root so we free where
	 * the chan was before the server connection was lost
	 */
	decref(safe);

	for(i = 1; i < n; i++) {
		if(mntwalk(c, pav[i]->elem) == 0) {
			free(pav);
			/* Shut down the channel */
			c->dev = m->id-1;
			error(Erecover);
		}
	}
	free(pav);
	if(flg&COPEN)
		mntopen(c, c->mode);
#endif
}

Mnt*
mntchk(Chan *c)
{


@@ 967,12 904,6 @@ mntchk(Chan *c)
	if(m->id == 0 || m->id >= c->dev)
		error(Eshutdown);

	/*
	 * Try and get the channel back after a crash
	 */
	if((c->flag&CRECOV) && m->recprog == 0)
		recoverchan(m, c);

	return m;
}



@@ 997,116 928,6 @@ rpcattn(void *v)
	return r->done || r->m->rip == 0;
}

int
recdone(void *v)
{
	Mnt *m;

	m = v;
	return m->recprog == 0;
}

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

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

void
mntrecover(Mnt *m, Mntrpc *r)
{
	char *ps;

	lock(m);
	if(m->recprog == 0) {
		m->recprog = 1;
		unlock(m);
		chanrec(m);
		/*
		 * Send a message to boot via #/recover
		 */
panic("mntrecover\n");
//		rootrecover(m->c->path, m->tree.root->elem);
		lock(m);
	}
	r->list = m->recwait;
	m->recwait = r;
	unlock(m);

	pprint("lost server connection, wait...\n");

	ps = up->psstate;
	up->psstate = "Recover";

	if(waserror()) {
		up->psstate = ps;
		mntrecdel(m, r);
		nexterror();
	}
	sleep(&r->r, recdone, m);
	poperror();

	r->done = 0;
	mntrecdel(m, r);
	if(r->c != 0)
		recoverchan(m, r->c);

	up->psstate = ps;
}

void
mntrepl(char*)
{
panic("mntrepl");
#ifdef asdf
	int fd;
	Mnt *m;
	char *p;
	Chan *c1, *c2;
	Mntrpc *r;

	/* reply from boot is 'fd #M23' */
	fd = strtoul(buf, &p, 0);

	p++;
	lock(&mntalloc);
	for(m = mntalloc.list; m; m = m->list) {
		if(strcmp(p, m->tree.root->elem) == 0)
			break;
	}
	unlock(&mntalloc);
	if(m == 0)
		error(Eunmount);

	c1 = fdtochan(fd, ORDWR, 0, 1);	/* error check and inc ref */

	/* If the channel was posted fix it up */
	srvrecover(m->c, c1);

	lock(m);
	c2 = m->c;
	m->c = c1;
	m->recprog = 0;

	/* Wakeup partially complete rpc */
	for(r = m->recwait; r; r = r->list)
		wakeup(&r->r);

	unlock(m);
	cclose(c2);
#endif
}

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

M port/devproc.c => port/devproc.c +0 -2
@@ 341,8 341,6 @@ int2flag(int flag, char *s)
		*s++ = 'c';
	if(flag & MCACHE)
		*s++ = 'C';
	if(flag & MRECOV)
		*s++ = 'r';
	*s = '\0';
}


M port/devroot.c => port/devroot.c +2 -66
@@ 7,7 7,6 @@

enum{
	Qdir=	0,
	Qrecover,

	Nfiles=32,	/* max root files */
};


@@ 15,14 14,10 @@ enum{
extern ulong	bootlen;
extern uchar	bootcode[];

Dirtab rootdir[Nfiles]=
{
	"recover",	{Qrecover},	0,	0777,
};
Dirtab rootdir[Nfiles];

static uchar	*rootdata[Nfiles];
static int	nroot = 1;
static int	recovbusy;
static int	nroot = 0;

typedef struct Recover Recover;
struct Recover


@@ 125,13 120,6 @@ rootopen(Chan *c, int omode)
	switch(c->qid.path & ~CHDIR) {
	default:
		break;
	case Qrecover:
		if(recovbusy)
			error(Einuse);
		if(strcmp(up->user, eve) != 0)
			error(Eperm);
		recovbusy = 1;
		break;
	}

	return devopen(c, omode, rootdir, nroot, devgen);


@@ 146,10 134,6 @@ rootclose(Chan *c)
	switch(c->qid.path) {
	default:
		break;
	case Qrecover:
		if(c->flag&COPEN)
			recovbusy = 0;
		break;
	}
}



@@ 172,29 156,6 @@ rootread(Chan *c, void *buf, long n, vlong off)
	switch(t){
	case Qdir:
		return devdirread(c, buf, n, rootdir, nroot, devgen);
	case Qrecover:
		qlock(&reclist);
		if(waserror()) {
			qunlock(&reclist);
			nexterror();
		}

		sleep(&reclist, rdrdy, 0);

		lock(&reclist);
		r = reclist.q;
		reclist.q = r->next;
		unlock(&reclist);

		qunlock(&reclist);

		poperror();
		if(n < r->len)
			n = r->len;
		memmove(buf, r->req, n);
		free(r->req);
		free(r);
		return n;
	}

	d = &rootdir[t-1];


@@ 210,19 171,9 @@ rootread(Chan *c, void *buf, long n, vlong off)
static long
rootwrite(Chan *c, void *buf, long n, vlong)
{
	char tmp[256];

	switch(c->qid.path & ~CHDIR){
	default:
		error(Egreg);
	case Qrecover:
		if(n > sizeof(tmp)-1)
			error(Etoosmall);
		/* Nul terminate */
		memmove(tmp, buf, n);
		tmp[n] = '\0';
		mntrepl(tmp);
		return n;
	}
	return 0;
}


@@ 258,18 209,3 @@ Dev rootdevtab = {
	devremove,
	devwstat,
};

void
rootrecover(Chan *c, char *mntname)
{
	Recover *r;

	r = malloc(sizeof(Recover));
	r->req = smalloc(c->name->len+strlen(mntname)+2);
	sprint(r->req, "%s %s", c->name->s, mntname);
	lock(&reclist);
	r->next = reclist.q;
	reclist.q = r;
	unlock(&reclist);
	wakeup(&reclist);
}

M port/devsrv.c => port/devsrv.c +0 -18
@@ 305,21 305,3 @@ Dev srvdevtab = {
	srvremove,
	srvwstat,
};

void
srvrecover(Chan *old, Chan *new)
{
	Srv *sp;

	qlock(&srvlk);
	for(sp = srv; sp; sp = sp->link) {
		if(sp->chan == old) {
			sp->chan = new;
			incref(new);
			qunlock(&srvlk);
			cclose(old);
			return;
		}
	}
	qunlock(&srvlk);
}

M port/error.h => port/error.h +0 -1
@@ 51,7 51,6 @@ extern char Enoswap[];		/* swap space full */
extern char Esfnotcached[];	/* subfont not cached */
extern char Esoverlap[];	/* segments overlap */
extern char Emouseset[];	/* mouse type already set */
extern char Erecover[];		/* failed to recover fd */
extern char Eshort[];		/* i/o count too small */
extern char Egreg[];		/* xterm: Error 50, errno 1: Too big */
extern char Ebadspec[];		/* bad attach specifier */

M port/lib.h => port/lib.h +0 -1
@@ 86,7 86,6 @@ extern	char	end[];
#define	MBEFORE	0x0001	/* mount goes before others in union directory */
#define	MAFTER	0x0002	/* mount goes after others in union directory */
#define	MCREATE	0x0004	/* permit creation in mounted directory */
#define	MRECOV	0x0008	/* perform recovery if mount channel is lost */
#define	MCACHE	0x0010	/* cache some data */
#define	MMASK	0x001F	/* all bits on */


M port/portdat.h => port/portdat.h +2 -5
@@ 109,7 109,6 @@ enum
	CCEXEC	= 0x0008,		/* close on exec */
	CFREE	= 0x0010,		/* not in use */
	CRCLOSE	= 0x0020,		/* remove on close */
	CRECOV	= 0x0040,		/* requires recovery */
	CCACHE	= 0x0080,		/* client cache */
};



@@ 243,11 242,9 @@ struct Mnt
	Chan	*c;		/* Channel to file service */
	Proc	*rip;		/* Reader in progress */
	Mntrpc	*queue;		/* Queue of pending requests on this channel */
	Mntrpc	*recwait;	/* List of rpc's with recovery pending */
	ulong	id;		/* Multiplexor id for channel check */
	ulong	id;		/* Multiplexer id for channel check */
	Mnt	*list;		/* Free list */
	int	flags;		/* recover/cache */
	char	recprog;	/* Recovery in progress */
	int	flags;		/* cache */
	int	blocksize;	/* read/write block size */
	ushort	flushtag;	/* Tag to send flush on */
	ushort	flushbase;	/* Base tag of flush window for this buffer */

M port/portfns.h => port/portfns.h +0 -3
@@ 166,7 166,6 @@ void		mmurelease(Proc*);
void		mmuswitch(Proc*);
void		mntdump(void);
long		mntread9p(Chan*, void*, long, vlong);
void		mntrepl(char*);
long		mntwrite9p(Chan*, void*, long, vlong);
void		mountfree(Mount*);
ulong		msize(void*);


@@ 265,7 264,6 @@ void		resetscsi(void);
void		resrcwait(char*);
int		return0(void*);
void		rlock(RWlock*);
void		rootrecover(Chan*, char*);
void		rootreq(Chan*, Mnt*);
long		rtctime(void);
void		runlock(RWlock*);


@@ 308,7 306,6 @@ int		splhi(void);
int		spllo(void);
void		splx(int);
void		splxpc(int);
void		srvrecover(Chan*, Chan*);
char*	srvname(Chan*);
int		swapcount(ulong);
int		swapfull(void);

M port/sysfile.c => port/sysfile.c +1 -1
@@ 607,7 607,7 @@ bindmount(ulong *arg, int ismount)
	if(flag>MMASK || (flag&MORDER)==(MBEFORE|MAFTER))
		error(Ebadarg);

	bogus.flags = flag & (MRECOV|MCACHE);
	bogus.flags = flag & MCACHE;

	if(ismount){
		bc = fdtochan(fd, ORDWR, 0, 1);