xref: /plan9/sys/src/cmd/unix/9pfreebsd/freebsd-3.2.il-kernel.patch (revision 144145943e440fe30c4e4512a0856f5e3d5ca4be)

diff -N -c -r /usr/src/sys/9fs/9auth.c ./9fs/9auth.c
*** /usr/src/sys/9fs/9auth.c	Wed Dec 31 19:00:00 1969
--- ./9fs/9auth.c	Mon May 22 17:11:29 2000
***************
*** 0 ****
--- 1,238 ----
+ #include <sys/param.h>
+ #include <sys/systm.h>
+ #include <sys/socket.h>
+ #include <sys/socketvar.h>
+ #include <sys/protosw.h>
+ #include <sys/malloc.h>
+ #include <sys/mbuf.h>
+ #include <sys/uio.h>
+
+ #include <9fs/9p.h>
+ #include <9fs/9auth.h>
+
+ #define	N2HCHAR(x)		x = *p++
+ #define	N2HSHORT(x)	x = (p[0] | (p[1]<<8)); p += 2
+ #define	N2HLONG(x)		x = (p[0] | (p[1]<<8) |\
+ 				(p[2]<<16) | (p[3]<<24)); p += 4
+ #define	N2HQUAD(x)	x = (u_int64_t)(p[0] | (p[1]<<8) |\
+ 					(p[2]<<16) | (p[3]<<24)) |\
+ 				((u_int64_t)(p[4] | (p[5]<<8) |\
+ 					(p[6]<<16) | (p[7]<<24)) << 32); p += 8
+ #define	N2HSTRING(x,n)	bcopy(p, x, n); p += n
+
+ #define	H2NCHAR(x)	*p++ = x
+ #define	H2NSHORT(x)	p[0]=x; p[1]=x>>8; p += 2
+ #define	H2NLONG(x)		p[0]=x; p[1]=x>>8; p[2]=x>>16; p[3]=x>>24; p += 4
+ #define	H2NQUAD(x)	p[0]=x;	p[1]=x>>8;\
+ 			p[2]=x>>16;	p[3]=x>>24;\
+ 			p[4]=x>>32;	p[5]=x>>40;\
+ 			p[6]=x>>48;	p[7]=x>>56;\
+ 			p += 8
+ #define	H2NSTRING(x,n)	bcopy(x, p, n); p += n
+
+ static int u9auth_send __P((struct socket *so, struct mbuf *top, struct proc *p));
+ static int u9auth_recv __P((struct socket *so, struct mbuf **mp, struct proc *p));
+
+ static int u9auth_count = 0;
+
+ static int u9auth_tr2m(struct u9auth_ticketreq *f, char *ap)
+ {
+ 	int n;
+ 	u_char *p;
+
+ 	p = (u_char*)ap;
+         H2NCHAR(f->type);
+ 	H2NSTRING(f->authid, U9FS_NAMELEN);
+ 	H2NSTRING(f->authdom, U9FS_DOMLEN);
+ 	H2NSTRING(f->chal, U9FS_CHALLEN);
+ 	H2NSTRING(f->hostid, U9FS_NAMELEN);
+ 	H2NSTRING(f->uid, U9FS_NAMELEN);
+ 	n = p - (u_char*)ap;
+ 	return n;
+ }
+
+ static struct mbuf * u9auth_m_tr2m(struct u9auth_ticketreq * tktq)
+ {
+   register struct mbuf *m;
+   char * ap;
+   int sz = 141;
+
+   MGETHDR(m, M_WAIT, MT_DATA);
+   if( sz > MHLEN )
+     MCLGET(m, M_WAIT);
+   m->m_len = 0;
+
+   if ( M_TRAILINGSPACE(m) < sz )
+     panic("u9auth_m_tr2m");
+
+   ap = mtod(m, char *);
+   m->m_len = u9auth_tr2m(tktq, ap);
+   m->m_pkthdr.len = m->m_len;
+
+   return (m);
+ }
+
+ static int
+ u9auth_send(so, top, p)
+ 	register struct socket *so;
+ 	register struct mbuf *top;
+ 	register struct proc *p;
+
+ {
+   int error, soflags, flags;
+
+   soflags = so->so_proto->pr_flags;
+   if (so->so_type == SOCK_SEQPACKET)
+     flags = MSG_EOR;
+   else
+     flags = 0;
+
+   error = so->so_proto->pr_usrreqs->pru_sosend(so, 0, 0, top, 0, flags, p);
+
+   return (error);
+ }
+
+ static int
+ u9auth_recv(so, mp, p)
+      register struct socket * so;
+      register struct mbuf **mp;
+      struct proc *p;
+ {
+   struct uio auio;
+   u_int32_t len;
+   int error = 0, sotype, rcvflg;
+
+   *mp = 0;
+   sotype = so->so_type;
+
+   /*
+    * For reliable protocols, lock against other senders/receivers
+    * in case a reconnect is necessary.
+    * For SOCK_STREAM, first get the Record Mark to find out how much
+    * more there is to get.
+    * We must lock the socket against other receivers
+    * until we have an entire rpc request/reply.
+    */
+   if (sotype == SOCK_SEQPACKET ) {
+     if( (so->so_state & SS_ISCONNECTED) == 0 )
+       return (EACCES);
+ 		auio.uio_resid = len = 1000000;
+ 		auio.uio_procp = p;
+ 		do {
+ 			rcvflg = 0;
+ 			error =  so->so_proto->pr_usrreqs->pru_soreceive
+ 				(so, 0, &auio, mp,
+ 				(struct mbuf **)0, &rcvflg);
+ 		} while (error == EWOULDBLOCK);
+ 		len -= auio.uio_resid;
+   }
+   if (error) {
+     m_freem(*mp);
+     *mp = 0;
+   }
+   return (error);
+ }
+
+ static void
+ u9auth_m2t(char *ap, struct u9auth_ticket *f, char *key)
+ {
+ 	u_char *p;
+
+ 	if(key)
+ 		decrypt9(key, ap, U9AUTH_TICKETLEN);
+ 	p = (u_char*)ap;
+ 	N2HCHAR(f->num);
+ 	N2HSTRING(f->chal, U9FS_CHALLEN);
+ 	N2HSTRING(f->cuid, U9FS_NAMELEN);
+ 	f->cuid[U9FS_NAMELEN-1] = 0;
+ 	N2HSTRING(f->suid, U9FS_NAMELEN);
+ 	f->suid[U9FS_NAMELEN-1] = 0;
+ 	N2HSTRING(f->key, U9AUTH_DESKEYLEN);
+ };
+
+ static int
+ u9auth_a2m(struct u9auth_authenticator *f, char *ap, char *key)
+ {
+ 	int n;
+ 	u_char *p;
+
+ 	p = (u_char*)ap;
+ 	H2NCHAR(f->num);
+ 	H2NSTRING(f->chal, U9FS_CHALLEN);
+ 	H2NLONG(f->id);
+ 	n = p - (u_char*)ap;
+ 	if(key)
+ 		encrypt9(key, ap, n);
+ 	return n;
+ }
+
+ void u9auth_genchal (char * chal)
+ {
+   u_long * lp = (u_long *)chal;
+
+   *lp++ = random();
+   *lp = random();
+ }
+
+ int u9auth_gettickets (struct socket * so, struct u9fsreq * rep,
+ 			   char * user, char * ckey, char * ts, char * authc,
+ 		       struct proc *p)
+ {
+   char * cp;
+   struct u9auth_ticketreq tktq;
+   struct u9auth_ticket tc;
+   struct u9auth_authenticator auth;
+   struct mbuf * m;
+   int error, len;
+
+   bzero(&tktq, sizeof(tktq));
+   tktq.type = AuthTreq;
+   bcopy(rep->r_authid, tktq.authid, U9FS_NAMELEN);
+   bcopy(rep->r_authdom, tktq.authdom, U9FS_DOMLEN);
+   bcopy(rep->r_chal, tktq.chal, U9FS_CHALLEN);
+   strncpy(tktq.hostid, user, U9FS_NAMELEN);
+   strncpy(tktq.uid, user, U9FS_NAMELEN);
+
+   m = u9auth_m_tr2m(&tktq);
+   error = u9auth_send(so, m, p);
+   if( error )
+     goto bad;
+   error = u9auth_recv(so, &m, p);
+   if( error )
+     goto bad;
+
+   len = U9AUTH_TICKETLEN+1;
+   if( m->m_len < len && (m = m_pullup(m, len)) == 0 )
+     goto bad;
+
+   cp = mtod(m, char *);
+   switch( cp[0] ) {
+   case AuthOK:
+     u9auth_m2t(&cp[1], & tc, ckey);
+     bzero(&auth, sizeof(auth));
+     auth.num = AuthAc;
+     bcopy(tc.chal, auth.chal, sizeof(auth.chal));
+     auth.id = u9auth_count++;
+
+     m->m_len -= len;
+     m->m_data += len;
+
+     len = U9AUTH_TICKETLEN;
+     if( m->m_len < len && (m = m_pullup(m, len)) == 0 )
+       goto bad;
+     cp = mtod(m, char *);
+     bcopy(cp, ts, len);
+     break;
+   case AuthErr:
+   case AuthOKvar:
+     m_freem(m);
+     goto bad;
+     break;
+   }
+
+   u9auth_a2m(&auth, authc, tc.key);
+   return 0;
+  bad:
+   return error;
+ }
+
diff -N -c -r /usr/src/sys/9fs/9auth.h ./9fs/9auth.h
*** /usr/src/sys/9fs/9auth.h	Wed Dec 31 19:00:00 1969
--- ./9fs/9auth.h	Thu Nov 11 15:00:29 1999
***************
*** 0 ****
--- 1,129 ----
+ #ifndef P9AUTH_H
+ #define P9AUTH_H
+
+ #define U9AUTH_DOMLEN		48		/* length of an authentication domain name */
+ #define U9AUTH_DESKEYLEN	7		/* length of a des key for encrypt/decrypt */
+ #define U9AUTH_CHALLEN	8		/* length of a challenge */
+ #define U9AUTH_NETCHLEN	16		/* max network challenge length	*/
+ #define U9AUTH_CONFIGLEN	14
+ #define U9AUTH_SECRETLEN	32		/* max length of a secret */
+ #define U9AUTH_APOPCHLEN	256
+ #define U9AUTH_MD5LEN		16
+ #define U9AUTH_KEYDBOFF	8		/* length of random data at the start of key file */
+ #define U9AUTH_OKEYDBLEN	U9FSNAMELEN+U9AUTH_DESKEYLEN+4+2,	/* length of an entry in old key file */
+ #define U9AUTH_KEYDBLEN	OKEYDBLENSECRETLEN,	/* length of an entry in key file */
+
+ /* encryption numberings (anti-replay) */
+ enum
+ {
+ 	AuthTreq=1,	/* ticket request */
+ 	AuthChal=2,	/* challenge box request */
+ 	AuthPass=3,	/* change password */
+ 	AuthOK=4,	/* fixed length reply follows */
+ 	AuthErr=5,	/* error follows */
+ 	AuthMod=6,	/* modify user */
+ 	AuthApop=7,	/* apop authentication for pop3 */
+ 	AuthOKvar=9,	/* variable length reply follows */
+ 	AuthChap=10,	/* chap authentication for ppp */
+ 	AuthMSchap=11,	/* MS chap authentication for ppp */
+
+
+ 	AuthTs=64,	/* ticket encrypted with server's key */
+ 	AuthTc,		/* ticket encrypted with client's key */
+ 	AuthAs,		/* server generated authenticator */
+ 	AuthAc,		/* client generated authenticator */
+ 	AuthTp,		/* ticket encrypted with clien's key for password change */
+ };
+
+ struct u9auth_ticketreq
+ {
+ 	char	type;
+ 	char	authid[U9FS_NAMELEN];	/* server's encryption id */
+ 	char	authdom[U9AUTH_DOMLEN];	/* server's authentication domain */
+ 	char	chal[U9AUTH_CHALLEN];		/* challenge from server */
+ 	char	hostid[U9FS_NAMELEN];	/* host's encryption id */
+ 	char	uid[U9FS_NAMELEN];		/* uid of requesting user on host */
+ };
+ #define	U9AUTH_TICKREQLEN	(3*U9FS_NAMELEN+U9AUTH_CHALLEN+U9AUTH_DOMLEN+1)
+
+ struct u9auth_ticket
+ {
+ 	char	num;			/* replay protection */
+ 	char	chal[U9AUTH_CHALLEN];		/* server challenge */
+ 	char	cuid[U9FS_NAMELEN];		/* uid on client */
+ 	char	suid[U9FS_NAMELEN];		/* uid on server */
+ 	char	key[U9AUTH_DESKEYLEN];		/* nonce DES key */
+ };
+ #define	U9AUTH_TICKETLEN	(U9AUTH_CHALLEN+2*U9FS_NAMELEN+U9AUTH_DESKEYLEN+1)
+
+ struct u9auth_authenticator
+ {
+ 	char	num;			/* replay protection */
+ 	char	chal[U9AUTH_CHALLEN];
+ 	u_long	id;			/* authenticator id, ++'d with each auth */
+ };
+ #define	U9AUTH_AUTHENTLEN	(U9AUTH_CHALLEN+4+1)
+
+ struct u9auth_passwordreq
+ {
+ 	char	num;
+ 	char	old[U9FS_NAMELEN];
+ 	char	new[U9FS_NAMELEN];
+ 	char	changesecret;
+ 	char	secret[U9AUTH_SECRETLEN];	/* new secret */
+ };
+ #define	U9AUTH_PASSREQLEN	(2*U9FS_NAMELEN+1+1+U9AUTH_SECRETLEN)
+
+ struct u9auth_nvrsafe
+ {
+ 	char	machkey[U9AUTH_DESKEYLEN];
+ 	u_char	machsum;
+ 	char	authkey[U9AUTH_DESKEYLEN];
+ 	u_char	authsum;
+ 	char	config[U9AUTH_CONFIGLEN];
+ 	u_char	configsum;
+ 	char	authid[U9FS_NAMELEN];
+ 	u_char	authidsum;
+ 	char	authdom[U9AUTH_DOMLEN];
+ 	u_char	authdomsum;
+ };
+
+ struct u9auth_chalstate
+ {
+ 	int	afd;			/* /dev/authenticate */
+ 	int	asfd;			/* authdial() */
+ 	char	chal[U9AUTH_NETCHLEN];		/* challenge/response */
+ };
+
+ struct u9auth_apopchalstate
+ {
+ 	int	afd;			/* /dev/authenticate */
+ 	int	asfd;			/* authdial() */
+ 	char	chal[U9AUTH_APOPCHLEN];	/* challenge/response */
+ };
+
+ struct	u9auth_chapreply
+ {
+ 	u_char	id;
+ 	char	uid[U9FS_NAMELEN];
+ 	char	resp[U9AUTH_MD5LEN];
+ };
+
+ struct	u9auth_mSchapreply
+ {
+ 	char	uid[U9FS_NAMELEN];
+ 	char	LMresp[24];		/* Lan Manager response */
+ 	char	NTresp[24];		/* NT response */
+ };
+
+ #ifdef KERNEL
+ void u9auth_genchal __P((char *));
+ int  u9auth_gettickets __P((struct socket * so, struct u9fsreq * rep,
+ 			   char * user, char * ckey, char * ts, char * authc,
+ 			    struct proc * p));
+ int encrypt9 __P((void *key, void * vbuf, int n));
+ int decrypt9 __P((void *key, void * vbuf, int n));
+
+ #endif
+
+ #endif
diff -N -c -r /usr/src/sys/9fs/9crypt.c ./9fs/9crypt.c
*** /usr/src/sys/9fs/9crypt.c	Wed Dec 31 19:00:00 1969
--- ./9fs/9crypt.c	Thu Nov 11 12:23:02 1999
***************
*** 0 ****
--- 1,416 ----
+ /*
+  *	Data Encryption Standard
+  *	D.P.Mitchell  83/06/08.
+  *
+  *	block_cipher(key, block, decrypting)
+  */
+ #include <sys/param.h>
+ #include <sys/systm.h>
+ #include <sys/socket.h>
+ #include <sys/socketvar.h>
+
+ typedef unsigned char uchar;
+ typedef unsigned long ulong;
+ #define NAMELEN 28      /* length of path element, including '\0' */
+ #include <9fs/9p.h>
+ #include <9fs/9auth.h>
+
+ static	long	ip_low(char [8]);
+ static	long	ip_high(char [8]);
+ static	void	fp(long, long, char[8]);
+ static	void	key_setup(char[U9AUTH_DESKEYLEN], char[128]);
+ static	void	block_cipher(char[128], char[8], int);
+
+ /*
+  * destructively encrypt the buffer, which
+  * must be at least 8 characters long.
+  */
+ int
+ encrypt9(void *key, void *vbuf, int n)
+ {
+ 	char ekey[128], *buf;
+ 	int i, r;
+
+ 	if(n < 8)
+ 		return 0;
+ 	key_setup(key, ekey);
+ 	buf = vbuf;
+ 	n--;
+ 	r = n % 7;
+ 	n /= 7;
+ 	for(i = 0; i < n; i++){
+ 		block_cipher(ekey, buf, 0);
+ 		buf += 7;
+ 	}
+ 	if(r)
+ 		block_cipher(ekey, buf - 7 + r, 0);
+ 	return 1;
+ }
+
+ /*
+  * destructively decrypt the buffer, which
+  * must be at least 8 characters long.
+  */
+ int
+ decrypt9(void *key, void *vbuf, int n)
+ {
+ 	char ekey[128], *buf;
+ 	int i, r;
+
+ 	if(n < 8)
+ 		return 0;
+ 	key_setup(key, ekey);
+ 	buf = vbuf;
+ 	n--;
+ 	r = n % 7;
+ 	n /= 7;
+ 	buf += n * 7;
+ 	if(r)
+ 		block_cipher(ekey, buf - 7 + r, 1);
+ 	for(i = 0; i < n; i++){
+ 		buf -= 7;
+ 		block_cipher(ekey, buf, 1);
+ 	}
+ 	return 1;
+ }
+
+ /*
+  *	Tables for Combined S and P Boxes
+  */
+
+ static long  s0p[] = {
+ 0x00410100,0x00010000,0x40400000,0x40410100,0x00400000,0x40010100,0x40010000,0x40400000,
+ 0x40010100,0x00410100,0x00410000,0x40000100,0x40400100,0x00400000,0x00000000,0x40010000,
+ 0x00010000,0x40000000,0x00400100,0x00010100,0x40410100,0x00410000,0x40000100,0x00400100,
+ 0x40000000,0x00000100,0x00010100,0x40410000,0x00000100,0x40400100,0x40410000,0x00000000,
+ 0x00000000,0x40410100,0x00400100,0x40010000,0x00410100,0x00010000,0x40000100,0x00400100,
+ 0x40410000,0x00000100,0x00010100,0x40400000,0x40010100,0x40000000,0x40400000,0x00410000,
+ 0x40410100,0x00010100,0x00410000,0x40400100,0x00400000,0x40000100,0x40010000,0x00000000,
+ 0x00010000,0x00400000,0x40400100,0x00410100,0x40000000,0x40410000,0x00000100,0x40010100,
+ };
+
+ static long  s1p[] = {
+ 0x08021002,0x00000000,0x00021000,0x08020000,0x08000002,0x00001002,0x08001000,0x00021000,
+ 0x00001000,0x08020002,0x00000002,0x08001000,0x00020002,0x08021000,0x08020000,0x00000002,
+ 0x00020000,0x08001002,0x08020002,0x00001000,0x00021002,0x08000000,0x00000000,0x00020002,
+ 0x08001002,0x00021002,0x08021000,0x08000002,0x08000000,0x00020000,0x00001002,0x08021002,
+ 0x00020002,0x08021000,0x08001000,0x00021002,0x08021002,0x00020002,0x08000002,0x00000000,
+ 0x08000000,0x00001002,0x00020000,0x08020002,0x00001000,0x08000000,0x00021002,0x08001002,
+ 0x08021000,0x00001000,0x00000000,0x08000002,0x00000002,0x08021002,0x00021000,0x08020000,
+ 0x08020002,0x00020000,0x00001002,0x08001000,0x08001002,0x00000002,0x08020000,0x00021000,
+ };
+
+ static long  s2p[] = {
+ 0x20800000,0x00808020,0x00000020,0x20800020,0x20008000,0x00800000,0x20800020,0x00008020,
+ 0x00800020,0x00008000,0x00808000,0x20000000,0x20808020,0x20000020,0x20000000,0x20808000,
+ 0x00000000,0x20008000,0x00808020,0x00000020,0x20000020,0x20808020,0x00008000,0x20800000,
+ 0x20808000,0x00800020,0x20008020,0x00808000,0x00008020,0x00000000,0x00800000,0x20008020,
+ 0x00808020,0x00000020,0x20000000,0x00008000,0x20000020,0x20008000,0x00808000,0x20800020,
+ 0x00000000,0x00808020,0x00008020,0x20808000,0x20008000,0x00800000,0x20808020,0x20000000,
+ 0x20008020,0x20800000,0x00800000,0x20808020,0x00008000,0x00800020,0x20800020,0x00008020,
+ 0x00800020,0x00000000,0x20808000,0x20000020,0x20800000,0x20008020,0x00000020,0x00808000,
+ };
+
+ static long  s3p[] = {
+ 0x00080201,0x02000200,0x00000001,0x02080201,0x00000000,0x02080000,0x02000201,0x00080001,
+ 0x02080200,0x02000001,0x02000000,0x00000201,0x02000001,0x00080201,0x00080000,0x02000000,
+ 0x02080001,0x00080200,0x00000200,0x00000001,0x00080200,0x02000201,0x02080000,0x00000200,
+ 0x00000201,0x00000000,0x00080001,0x02080200,0x02000200,0x02080001,0x02080201,0x00080000,
+ 0x02080001,0x00000201,0x00080000,0x02000001,0x00080200,0x02000200,0x00000001,0x02080000,
+ 0x02000201,0x00000000,0x00000200,0x00080001,0x00000000,0x02080001,0x02080200,0x00000200,
+ 0x02000000,0x02080201,0x00080201,0x00080000,0x02080201,0x00000001,0x02000200,0x00080201,
+ 0x00080001,0x00080200,0x02080000,0x02000201,0x00000201,0x02000000,0x02000001,0x02080200,
+ };
+
+ static long  s4p[] = {
+ 0x01000000,0x00002000,0x00000080,0x01002084,0x01002004,0x01000080,0x00002084,0x01002000,
+ 0x00002000,0x00000004,0x01000004,0x00002080,0x01000084,0x01002004,0x01002080,0x00000000,
+ 0x00002080,0x01000000,0x00002004,0x00000084,0x01000080,0x00002084,0x00000000,0x01000004,
+ 0x00000004,0x01000084,0x01002084,0x00002004,0x01002000,0x00000080,0x00000084,0x01002080,
+ 0x01002080,0x01000084,0x00002004,0x01002000,0x00002000,0x00000004,0x01000004,0x01000080,
+ 0x01000000,0x00002080,0x01002084,0x00000000,0x00002084,0x01000000,0x00000080,0x00002004,
+ 0x01000084,0x00000080,0x00000000,0x01002084,0x01002004,0x01002080,0x00000084,0x00002000,
+ 0x00002080,0x01002004,0x01000080,0x00000084,0x00000004,0x00002084,0x01002000,0x01000004,
+ };
+
+ static long  s5p[] = {
+ 0x10000008,0x00040008,0x00000000,0x10040400,0x00040008,0x00000400,0x10000408,0x00040000,
+ 0x00000408,0x10040408,0x00040400,0x10000000,0x10000400,0x10000008,0x10040000,0x00040408,
+ 0x00040000,0x10000408,0x10040008,0x00000000,0x00000400,0x00000008,0x10040400,0x10040008,
+ 0x10040408,0x10040000,0x10000000,0x00000408,0x00000008,0x00040400,0x00040408,0x10000400,
+ 0x00000408,0x10000000,0x10000400,0x00040408,0x10040400,0x00040008,0x00000000,0x10000400,
+ 0x10000000,0x00000400,0x10040008,0x00040000,0x00040008,0x10040408,0x00040400,0x00000008,
+ 0x10040408,0x00040400,0x00040000,0x10000408,0x10000008,0x10040000,0x00040408,0x00000000,
+ 0x00000400,0x10000008,0x10000408,0x10040400,0x10040000,0x00000408,0x00000008,0x10040008,
+ };
+
+ static long  s6p[] = {
+ 0x00000800,0x00000040,0x00200040,0x80200000,0x80200840,0x80000800,0x00000840,0x00000000,
+ 0x00200000,0x80200040,0x80000040,0x00200800,0x80000000,0x00200840,0x00200800,0x80000040,
+ 0x80200040,0x00000800,0x80000800,0x80200840,0x00000000,0x00200040,0x80200000,0x00000840,
+ 0x80200800,0x80000840,0x00200840,0x80000000,0x80000840,0x80200800,0x00000040,0x00200000,
+ 0x80000840,0x00200800,0x80200800,0x80000040,0x00000800,0x00000040,0x00200000,0x80200800,
+ 0x80200040,0x80000840,0x00000840,0x00000000,0x00000040,0x80200000,0x80000000,0x00200040,
+ 0x00000000,0x80200040,0x00200040,0x00000840,0x80000040,0x00000800,0x80200840,0x00200000,
+ 0x00200840,0x80000000,0x80000800,0x80200840,0x80200000,0x00200840,0x00200800,0x80000800,
+ };
+
+ static long  s7p[] = {
+ 0x04100010,0x04104000,0x00004010,0x00000000,0x04004000,0x00100010,0x04100000,0x04104010,
+ 0x00000010,0x04000000,0x00104000,0x00004010,0x00104010,0x04004010,0x04000010,0x04100000,
+ 0x00004000,0x00104010,0x00100010,0x04004000,0x04104010,0x04000010,0x00000000,0x00104000,
+ 0x04000000,0x00100000,0x04004010,0x04100010,0x00100000,0x00004000,0x04104000,0x00000010,
+ 0x00100000,0x00004000,0x04000010,0x04104010,0x00004010,0x04000000,0x00000000,0x00104000,
+ 0x04100010,0x04004010,0x04004000,0x00100010,0x04104000,0x00000010,0x00100010,0x04004000,
+ 0x04104010,0x00100000,0x04100000,0x04000010,0x00104000,0x00004010,0x04004010,0x04100000,
+ 0x00000010,0x04104000,0x00104010,0x00000000,0x04000000,0x04100010,0x00004000,0x00104010,
+ };
+
+ /*
+  *	DES electronic codebook encryption of one block
+  */
+ static void
+ block_cipher(char expanded_key[128], char text[8], int decrypting)
+ {
+ 	char *key;
+ 	long crypto, temp, right, left;
+ 	int i, key_offset;
+
+ 	key = expanded_key;
+ 	left = ip_low(text);
+ 	right = ip_high(text);
+ 	if (decrypting) {
+ 		key_offset = 16;
+ 		key = key + 128 - 8;
+ 	} else
+ 		key_offset = 0;
+ 	for (i = 0; i < 16; i++) {
+ 		temp = (right << 1) | ((right >> 31) & 1);
+ 		crypto  = s0p[(temp         & 0x3f) ^ *key++];
+ 		crypto |= s1p[((temp >>  4) & 0x3f) ^ *key++];
+ 		crypto |= s2p[((temp >>  8) & 0x3f) ^ *key++];
+ 		crypto |= s3p[((temp >> 12) & 0x3f) ^ *key++];
+ 		crypto |= s4p[((temp >> 16) & 0x3f) ^ *key++];
+ 		crypto |= s5p[((temp >> 20) & 0x3f) ^ *key++];
+ 		crypto |= s6p[((temp >> 24) & 0x3f) ^ *key++];
+ 		temp = ((right & 1) << 5) | ((right >> 27) & 0x1f);
+ 		crypto |= s7p[temp ^ *key++];
+ 		temp = left;
+ 		left = right;
+ 		right = temp ^ crypto;
+ 		key -= key_offset;
+ 	}
+ 	/*
+ 	 *	standard final permutation (IPI)
+ 	 *	left and right are reversed here
+ 	 */
+ 	fp(right, left, text);
+ }
+
+ /*
+  *	Initial Permutation
+  */
+ static long iptab[] = {
+ 	0x00000000, 0x00008000, 0x00000000, 0x00008000,
+ 	0x00000080, 0x00008080, 0x00000080, 0x00008080
+ };
+
+ static long
+ ip_low(char block[8])
+ {
+ 	int i;
+ 	long l;
+
+ 	l = 0;
+ 	for(i = 0; i < 8; i++){
+ 		l |= iptab[(block[i] >> 4) & 7] >> i;
+ 		l |= iptab[block[i] & 7] << (16 - i);
+ 	}
+ 	return l;
+ }
+
+ static long
+ ip_high(char block[8])
+ {
+ 	int i;
+ 	long l;
+
+ 	l = 0;
+ 	for(i = 0; i < 8; i++){
+ 		l |= iptab[(block[i] >> 5) & 7] >> i;
+ 		l |= iptab[(block[i] >> 1) & 7] << (16 - i);
+ 	}
+ 	return l;
+ }
+
+ /*
+  *	Final Permutation
+  */
+ static unsigned long	fptab[] = {
+ 0x00000000,0x80000000,0x00800000,0x80800000,0x00008000,0x80008000,0x00808000,0x80808000,
+ 0x00000080,0x80000080,0x00800080,0x80800080,0x00008080,0x80008080,0x00808080,0x80808080,
+ };
+
+ static void
+ fp(long left, long right, char text[8])
+ {
+ 	unsigned long ta[2], t, v[2];
+ 	int i, j, sh;
+
+ 	ta[0] = right;
+ 	ta[1] = left;
+ 	v[0] = v[1] = 0;
+ 	for(i = 0; i < 2; i++){
+ 		t = ta[i];
+ 		sh = i;
+ 		for(j = 0; j < 4; j++){
+ 			v[1] |= fptab[t & 0xf] >> sh;
+ 			t >>= 4;
+ 			v[0] |= fptab[t & 0xf] >> sh;
+ 			t >>= 4;
+ 			sh += 2;
+ 		}
+ 	}
+ 	for(i = 0; i < 2; i++)
+ 		for(j = 0; j < 4; j++){
+ 			*text++ = v[i];
+ 			v[i] >>= 8;
+ 		}
+ }
+
+ /*
+  *	Key set-up
+  */
+ static uchar keyexpand[][15][2] = {
+ 	{   3,  2,   9,  8,  18,  8,  27, 32,  33,  2,  42, 16,  48,  8,  65, 16,
+ 	   74,  2,  80,  2,  89,  4,  99, 16, 104,  4, 122, 32,   0,  0, },
+ 	{   1,  4,   8,  1,  18,  4,  25, 32,  34, 32,  41,  8,  50,  8,  59, 32,
+ 	   64, 16,  75,  4,  90,  1,  97, 16, 106,  2, 112,  2, 123,  1, },
+ 	{   2,  1,  19,  8,  35,  1,  40,  1,  50,  4,  57, 32,  75,  2,  80, 32,
+ 	   89,  1,  96, 16, 107,  4, 120,  8,   0,  0,   0,  0,   0,  0, },
+ 	{   4, 32,  20,  2,  31,  4,  37, 32,  47,  1,  54,  1,  63,  2,  68,  1,
+ 	   78,  4,  84,  8, 101, 16, 108,  4, 119, 16, 126,  8,   0,  0, },
+ 	{   5,  4,  15,  4,  21, 32,  31,  1,  38,  1,  47,  2,  53,  2,  68,  8,
+ 	   85, 16,  92,  4, 103, 16, 108, 32, 118, 32, 124,  2,   0,  0, },
+ 	{  15,  2,  21,  2,  39,  8,  46, 16,  55, 32,  61,  1,  71, 16,  76, 32,
+ 	   86, 32,  93,  4, 102,  2, 108, 16, 117,  8, 126,  1,   0,  0, },
+ 	{  14, 16,  23, 32,  29,  1,  38,  8,  52,  2,  63,  4,  70,  2,  76, 16,
+ 	   85,  8, 100,  1, 110,  4, 116,  8, 127,  8,   0,  0,   0,  0, },
+ 	{   1,  8,   8, 32,  17,  1,  24, 16,  35,  4,  50,  1,  57, 16,  67,  8,
+ 	   83,  1,  88,  1,  98,  4, 105, 32, 114, 32, 123,  2,   0,  0, },
+ 	{   0,  1,  11, 16,  16,  4,  35,  2,  40, 32,  49,  1,  56, 16,  65,  2,
+ 	   74, 16,  80,  8,  99,  8, 115,  1, 121,  4,   0,  0,   0,  0, },
+ 	{   9, 16,  18,  2,  24,  2,  33,  4,  43, 16,  48,  4,  66, 32,  73,  8,
+ 	   82,  8,  91, 32,  97,  2, 106, 16, 112,  8, 122,  1,   0,  0, },
+ 	{  14, 32,  21,  4,  30,  2,  36, 16,  45,  8,  60,  1,  69,  2,  87,  8,
+ 	   94, 16, 103, 32, 109,  1, 118,  8, 124, 32,   0,  0,   0,  0, },
+ 	{   7,  4,  14,  2,  20, 16,  29,  8,  44,  1,  54,  4,  60,  8,  71,  8,
+ 	   78, 16,  87, 32,  93,  1, 102,  8, 116,  2, 125,  4,   0,  0, },
+ 	{   7,  2,  12,  1,  22,  4,  28,  8,  45, 16,  52,  4,  63, 16,  70,  8,
+ 	   84,  2,  95,  4, 101, 32, 111,  1, 118,  1,   0,  0,   0,  0, },
+ 	{   6, 16,  13, 16,  20,  4,  31, 16,  36, 32,  46, 32,  53,  4,  62,  2,
+ 	   69, 32,  79,  1,  86,  1,  95,  2, 101,  2, 119,  8,   0,  0, },
+ 	{   0, 32,  10,  8,  19, 32,  25,  2,  34, 16,  40,  8,  59,  8,  66,  2,
+ 	   72,  2,  81,  4,  91, 16,  96,  4, 115,  2, 121,  8,   0,  0, },
+ 	{   3, 16,  10,  4,  17, 32,  26, 32,  33,  8,  42,  8,  51, 32,  57,  2,
+ 	   67,  4,  82,  1,  89, 16,  98,  2, 104,  2, 113,  4, 120,  1, },
+ 	{   1, 16,  11,  8,  27,  1,  32,  1,  42,  4,  49, 32,  58, 32,  67,  2,
+ 	   72, 32,  81,  1,  88, 16,  99,  4, 114,  1,   0,  0,   0,  0, },
+ 	{   6, 32,  12,  2,  23,  4,  29, 32,  39,  1,  46,  1,  55,  2,  61,  2,
+ 	   70,  4,  76,  8,  93, 16, 100,  4, 111, 16, 116, 32,   0,  0, },
+ 	{   6,  2,  13, 32,  23,  1,  30,  1,  39,  2,  45,  2,  63,  8,  77, 16,
+ 	   84,  4,  95, 16, 100, 32, 110, 32, 117,  4, 127,  4,   0,  0, },
+ 	{   4,  1,  13,  2,  31,  8,  38, 16,  47, 32,  53,  1,  62,  8,  68, 32,
+ 	   78, 32,  85,  4,  94,  2, 100, 16, 109,  8, 127,  2,   0,  0, },
+ 	{   5, 16,  15, 32,  21,  1,  30,  8,  44,  2,  55,  4,  61, 32,  68, 16,
+ 	   77,  8,  92,  1, 102,  4, 108,  8, 126, 16,   0,  0,   0,  0, },
+ 	{   2,  8,   9,  1,  16, 16,  27,  4,  42,  1,  49, 16,  58,  2,  75,  1,
+ 	   80,  1,  90,  4,  97, 32, 106, 32, 113,  8, 120, 32,   0,  0, },
+ 	{   2,  4,   8,  4,  27,  2,  32, 32,  41,  1,  48, 16,  59,  4,  66, 16,
+ 	   72,  8,  91,  8, 107,  1, 112,  1, 123, 16,   0,  0,   0,  0, },
+ 	{   3,  8,  10,  2,  16,  2,  25,  4,  35, 16,  40,  4,  59,  2,  65,  8,
+ 	   74,  8,  83, 32,  89,  2,  98, 16, 104,  8, 121, 16,   0,  0, },
+ 	{   4,  2,  13,  4,  22,  2,  28, 16,  37,  8,  52,  1,  62,  4,  79,  8,
+ 	   86, 16,  95, 32, 101,  1, 110,  8, 126, 32,   0,  0,   0,  0, },
+ 	{   5, 32,  12, 16,  21,  8,  36,  1,  46,  4,  52,  8,  70, 16,  79, 32,
+ 	   85,  1,  94,  8, 108,  2, 119,  4, 126,  2,   0,  0,   0,  0, },
+ 	{   5,  2,  14,  4,  20,  8,  37, 16,  44,  4,  55, 16,  60, 32,  76,  2,
+ 	   87,  4,  93, 32, 103,  1, 110,  1, 119,  2, 124,  1,   0,  0, },
+ 	{   7, 32,  12,  4,  23, 16,  28, 32,  38, 32,  45,  4,  54,  2,  60, 16,
+ 	   71,  1,  78,  1,  87,  2,  93,  2, 111,  8, 118, 16, 125, 16, },
+ 	{   1,  1,  11, 32,  17,  2,  26, 16,  32,  8,  51,  8,  64,  2,  73,  4,
+ 	   83, 16,  88,  4, 107,  2, 112, 32, 122,  8,   0,  0,   0,  0, },
+ 	{   0,  4,   9, 32,  18, 32,  25,  8,  34,  8,  43, 32,  49,  2,  58, 16,
+ 	   74,  1,  81, 16,  90,  2,  96,  2, 105,  4, 115, 16, 122,  4, },
+ 	{   2,  2,  19,  1,  24,  1,  34,  4,  41, 32,  50, 32,  57,  8,  64, 32,
+ 	   73,  1,  80, 16,  91,  4, 106,  1, 113, 16, 123,  8,   0,  0, },
+ 	{   3,  4,  10, 16,  16,  8,  35,  8,  51,  1,  56,  1,  67, 16,  72,  4,
+ 	   91,  2,  96, 32, 105,  1, 112, 16, 121,  2,   0,  0,   0,  0, },
+ 	{   4, 16,  15,  1,  22,  1,  31,  2,  37,  2,  55,  8,  62, 16,  69, 16,
+ 	   76,  4,  87, 16,  92, 32, 102, 32, 109,  4, 118,  2, 125, 32, },
+ 	{   6,  4,  23,  8,  30, 16,  39, 32,  45,  1,  54,  8,  70, 32,  77,  4,
+ 	   86,  2,  92, 16, 101,  8, 116,  1, 125,  2,   0,  0,   0,  0, },
+ 	{   4,  4,  13,  1,  22,  8,  36,  2,  47,  4,  53, 32,  63,  1,  69,  8,
+ 	   84,  1,  94,  4, 100,  8, 117, 16, 127, 32,   0,  0,   0,  0, },
+ 	{   3, 32,   8, 16,  19,  4,  34,  1,  41, 16,  50,  2,  56,  2,  67,  1,
+ 	   72,  1,  82,  4,  89, 32,  98, 32, 105,  8, 114,  8, 121,  1, },
+ 	{   1, 32,  19,  2,  24, 32,  33,  1,  40, 16,  51,  4,  64,  8,  83,  8,
+ 	   99,  1, 104,  1, 114,  4, 120,  4,   0,  0,   0,  0,   0,  0, },
+ 	{   8,  2,  17,  4,  27, 16,  32,  4,  51,  2,  56, 32,  66,  8,  75, 32,
+ 	   81,  2,  90, 16,  96,  8, 115,  8, 122,  2,   0,  0,   0,  0, },
+ 	{   2, 16,  18,  1,  25, 16,  34,  2,  40,  2,  49,  4,  59, 16,  66,  4,
+ 	   73, 32,  82, 32,  89,  8,  98,  8, 107, 32, 113,  2, 123,  4, },
+ 	{   7,  1,  13,  8,  28,  1,  38,  4,  44,  8,  61, 16,  71, 32,  77,  1,
+ 	   86,  8, 100,  2, 111,  4, 117, 32, 124, 16,   0,  0,   0,  0, },
+ 	{  12,  8,  29, 16,  36,  4,  47, 16,  52, 32,  62, 32,  68,  2,  79,  4,
+ 	   85, 32,  95,  1, 102,  1, 111,  2, 117,  2, 126,  4,   0,  0, },
+ 	{   5,  1,  15, 16,  20, 32,  30, 32,  37,  4,  46,  2,  52, 16,  61,  8,
+ 	   70,  1,  79,  2,  85,  2, 103,  8, 110, 16, 119, 32, 124,  4, },
+ 	{   0, 16,   9,  2,  18, 16,  24,  8,  43,  8,  59,  1,  65,  4,  75, 16,
+ 	   80,  4,  99,  2, 104, 32, 113,  1, 123, 32,   0,  0,   0,  0, },
+ 	{  10, 32,  17,  8,  26,  8,  35, 32,  41,  2,  50, 16,  56,  8,  66,  1,
+ 	   73, 16,  82,  2,  88,  2,  97,  4, 107, 16, 112,  4, 121, 32, },
+ 	{   0,  2,  11,  1,  16,  1,  26,  4,  33, 32,  42, 32,  49,  8,  58,  8,
+ 	   65,  1,  72, 16,  83,  4,  98,  1, 105, 16, 114,  2,   0,  0, },
+ 	{   8,  8,  27,  8,  43,  1,  48,  1,  58,  4,  64,  4,  83,  2,  88, 32,
+ 	   97,  1, 104, 16, 115,  4, 122, 16,   0,  0,   0,  0,   0,  0, },
+ 	{   5,  8,  14,  1,  23,  2,  29,  2,  47,  8,  54, 16,  63, 32,  68,  4,
+ 	   79, 16,  84, 32,  94, 32, 101,  4, 110,  2, 116, 16, 127,  1, },
+ 	{   4,  8,  15,  8,  22, 16,  31, 32,  37,  1,  46,  8,  60,  2,  69,  4,
+ 	   78,  2,  84, 16,  93,  8, 108,  1, 118,  4,   0,  0,   0,  0, },
+ 	{   7, 16,  14,  8,  28,  2,  39,  4,  45, 32,  55,  1,  62,  1,  76,  1,
+ 	   86,  4,  92,  8, 109, 16, 116,  4, 125,  1,   0,  0,   0,  0, },
+ 	{   1,  2,  11,  4,  26,  1,  33, 16,  42,  2,  48,  2,  57,  4,  64,  1,
+ 	   74,  4,  81, 32,  90, 32,  97,  8, 106,  8, 115, 32, 120, 16, },
+ 	{   2, 32,  11,  2,  16, 32,  25,  1,  32, 16,  43,  4,  58,  1,  75,  8,
+ 	   91,  1,  96,  1, 106,  4, 113, 32,   0,  0,   0,  0,   0,  0, },
+ 	{   3,  1,   9,  4,  19, 16,  24,  4,  43,  2,  48, 32,  57,  1,  67, 32,
+ 	   73,  2,  82, 16,  88,  8, 107,  8, 120,  2,   0,  0,   0,  0, },
+ 	{   0,  8,  10,  1,  17, 16,  26,  2,  32,  2,  41,  4,  51, 16,  56,  4,
+ 	   65, 32,  74, 32,  81,  8,  90,  8,  99, 32, 105,  2, 114, 16, },
+ 	{   6,  1,  20,  1,  30,  4,  36,  8,  53, 16,  60,  4,  69,  1,  78,  8,
+ 	   92,  2, 103,  4, 109, 32, 119,  1, 125,  8,   0,  0,   0,  0, },
+ 	{   7,  8,  21, 16,  28,  4,  39, 16,  44, 32,  54, 32,  61,  4,  71,  4,
+ 	   77, 32,  87,  1,  94,  1, 103,  2, 109,  2, 124,  8,   0,  0, },
+ 	{   6,  8,  12, 32,  22, 32,  29,  4,  38,  2,  44, 16,  53,  8,  71,  2,
+ 	   77,  2,  95,  8, 102, 16, 111, 32, 117,  1, 127, 16,   0,  0, }
+ };
+
+ static void
+ key_setup(char key[U9AUTH_DESKEYLEN], char *ek)
+ {
+ 	int i, j, k, mask;
+ 	uchar (*x)[2];
+
+ 	bzero(ek, 128);
+ 	x = keyexpand[0];
+ 	for(i = 0; i < 7; i++){
+ 		k = key[i];
+ 		for(mask = 0x80; mask; mask >>= 1){
+ 			if(k & mask)
+ 				for(j = 0; j < 15; j++)
+ 					ek[x[j][0]] |= x[j][1];
+ 			x += 15;
+ 		}
+ 	}
+ }
diff -N -c -r /usr/src/sys/9fs/9fs.h ./9fs/9fs.h
*** /usr/src/sys/9fs/9fs.h	Wed Dec 31 19:00:00 1969
--- ./9fs/9fs.h	Mon May 22 11:31:29 2000
***************
*** 0 ****
--- 1,294 ----
+ /*
+  * Copyright (c) 1989, 1993, 1995
+  *	The Regents of the University of California.  All rights reserved.
+  *
+  * This code is derived from software contributed to Berkeley by
+  * Rick Macklem at The University of Guelph.
+  *
+  * Redistribution and use in source and binary forms, with or without
+  * modification, are permitted provided that the following conditions
+  * are met:
+  * 1. Redistributions of source code must retain the above copyright
+  *    notice, this list of conditions and the following disclaimer.
+  * 2. Redistributions in binary form must reproduce the above copyright
+  *    notice, this list of conditions and the following disclaimer in the
+  *    documentation and/or other materials provided with the distribution.
+  * 3. All advertising materials mentioning features or use of this software
+  *    must display the following acknowledgement:
+  *	This product includes software developed by the University of
+  *	California, Berkeley and its contributors.
+  * 4. Neither the name of the University nor the names of its contributors
+  *    may be used to endorse or promote products derived from this software
+  *    without specific prior written permission.
+  *
+  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+  * SUCH DAMAGE.
+  *
+  *	@(#)nfs.h	8.4 (Berkeley) 5/1/95
+  * $Id: nfs.h,v 1.44 1998/09/07 05:42:15 bde Exp $
+  */
+
+ #ifndef _9FS_H_
+ #define _9FS_H_
+
+ #ifdef KERNEL
+ #include "opt_u9fs.h"
+ #endif
+
+ #define U9FS_FABLKSIZE   512
+ #define U9FS_PORT        17008
+
+ /*
+  * The set of signals the interrupt an I/O in progress for U9FSMNT_INT mounts.
+  * What should be in this set is open to debate, but I believe that since
+  * I/O system calls on ufs are never interrupted by signals the set should
+  * be minimal. My reasoning is that many current programs that use signals
+  * such as SIGALRM will not expect file I/O system calls to be interrupted
+  * by them and break.
+  */
+ #define	U9FSINT_SIGMASK	(sigmask(SIGINT)|sigmask(SIGTERM)|sigmask(SIGKILL)| \
+ 			 sigmask(SIGHUP)|sigmask(SIGQUIT))
+
+ /*
+  * U9FS mount option flags
+  */
+ #define	U9FSMNT_SOFT		0x00000001  /* soft mount (hard is default) */
+ #define	U9FSMNT_MAXGRPS		0x00000020  /* set maximum grouplist size */
+ #define	U9FSMNT_INT		0x00000040  /* allow interrupts on hard mount */
+ #define	U9FSMNT_KERB		0x00000400  /* Use Kerberos authentication */
+ #define	U9FSMNT_READAHEAD	0x00002000  /* set read ahead */
+
+ #define U9FSSTA_HASWRITEVERF	0x00040000  /* Has write verifier for V3 */
+ #define U9FSSTA_GOTPATHCONF	0x00080000  /* Got the V3 pathconf info */
+ #define U9FSSTA_GOTFSINFO	0x00100000  /* Got the V3 fsinfo */
+ #define	U9FSSTA_MNTD		0x00200000  /* Mnt server for mnt point */
+ #define	U9FSSTA_DISMINPROG	0x00400000  /* Dismount in progress */
+ #define	U9FSSTA_DISMNT		0x00800000  /* Dismounted */
+ #define	U9FSSTA_SNDLOCK		0x01000000  /* Send socket lock */
+ #define	U9FSSTA_WANTSND		0x02000000  /* Want above */
+ #define	U9FSSTA_RCVLOCK		0x04000000  /* Rcv socket lock */
+ #define	U9FSSTA_WANTRCV		0x08000000  /* Want above */
+ #define	U9FSSTA_WAITAUTH		0x10000000  /* Wait for authentication */
+ #define	U9FSSTA_HASAUTH		0x20000000  /* Has authenticator */
+ #define	U9FSSTA_WANTAUTH		0x40000000  /* Wants an authenticator */
+ #define	U9FSSTA_AUTHERR		0x80000000  /* Authentication error */
+
+ #define	U9FSNOHASH(fhsum) (&u9fsnodehashtbl[(fhsum) % u9fsnodehash])
+
+ /*
+  * Arguments to mount 9FS
+  */
+ #define U9FS_ARGSVERSION	1	/* change when nfs_args changes */
+ struct u9fs_args {
+ 	int		version;	/* args structure version number */
+ 	struct sockaddr	*addr;		/* file server address */
+ 	int		addrlen;	/* length of address */
+ 	int		sotype;		/* Socket type */
+ 	int		proto;		/* and Protocol */
+ 	int		fhsize;		/* Size, in bytes, of fh */
+ 	int		flags;		/* flags */
+ 	int		wsize;		/* write size in bytes */
+ 	int		rsize;		/* read size in bytes */
+ 	int		readdirsize;	/* readdir size in bytes */
+ 	char		*hostname;	/* server's name */
+
+         struct sockaddr * authaddr;
+         int             authaddrlen;
+         int             authsotype;
+         int             authsoproto;
+
+         int             nusers;
+         char            user[U9FS_NAMELEN];
+         char            key[U9AUTH_DESKEYLEN];
+         struct p9user {
+ 	  uid_t p9_uid;
+ 	  char p9_name[U9FS_NAMELEN];
+ 	} * users;
+ };
+
+ #define U9FS_USER_HASHSIZE 512
+
+ struct u9fsuser {
+   LIST_ENTRY(u9fsuser) u_hash;
+   uid_t                u_uid;
+   char                 u_name[U9FS_NAMELEN];
+   char                 u_ckey[U9AUTH_DESKEYLEN];  /* user key */
+   char                 u_skey[U9AUTH_DESKEYLEN];  /* session key */
+ };
+
+ /*
+  * The u9fsnode is the u9fs equivalent to ufs's inode. Any similarity
+  * is purely coincidental.
+  * There is a unique u9fsnode allocated for each active file,
+  * each current directory, each mounted-on file, text file, and the root.
+  * An u9fsnode is 'named' by its file handle. (nget/u9fs_node.c)
+  * If this structure exceeds 256 bytes (it is currently 256 using 4.4BSD-Lite
+  * type definitions), file handles of > 32 bytes should probably be split out
+  * into a separate MALLOC()'d data structure. (Reduce the size of u9fsfh_t by
+  * changing the definition in u9fsproto.h of U9FS_SMALLFH.)
+  * NB: Hopefully the current order of the fields is such that everything will
+  *     be well aligned and, therefore, tightly packed.
+  */
+ struct u9fsnode {
+ 	LIST_ENTRY(u9fsnode)	n_hash;		/* Hash chain */
+ 	u_quad_t		n_size;		/* Current size of file */
+ 	struct vattr		n_vattr;	/* Vnode attribute cache */
+ 	time_t			n_attrstamp;	/* Attr. cache timestamp */
+ 	u_int32_t		n_mode;		/* ACCESS mode cache */
+ 	uid_t			n_modeuid;	/* credentials having mode */
+ 	time_t			n_modestamp;	/* mode cache timestamp */
+ 	time_t			n_mtime;	/* Prev modify time. */
+ 	time_t			n_ctime;	/* Prev create time. */
+         struct u9fs_qid         n_qid;
+ 	u_short			n_fid;		/* U9FS FID */
+         u_short                 n_rdfid;
+         u_short                 n_wrfid;
+ 	struct vnode		*n_vnode;	/* associated vnode */
+ 	struct lockf		*n_lockf;	/* Locking record of file */
+ 	int			n_error;	/* Save write error value */
+         struct u9fsdir          n_dir;
+ 	short			n_flag;		/* Flag for locking.. */
+         int                     n_opens;        /* number of opens */
+ };
+
+ #define n_atim		n_un1.nf_atim
+ #define n_mtim		n_un2.nf_mtim
+ #define n_sillyrename	n_un3.nf_silly
+ #define n_cookieverf	n_un1.nd_cookieverf
+ #define n_direofoffset	n_un2.nd_direof
+ #define n_cookies	n_un3.nd_cook
+
+ /*
+  * Flags for n_flag
+  */
+ #define	NFLUSHWANT	0x0001	/* Want wakeup from a flush in prog. */
+ #define	NFLUSHINPROG	0x0002	/* Avoid multiple calls to vinvalbuf() */
+ #define	NMODIFIED	0x0004	/* Might have a modified buffer in bio */
+ #define	NWRITEERR	0x0008	/* Flag write errors so close will know */
+ #define	NQU9FSNONCACHE	0x0020	/* Non-cachable lease */
+ #define	NQU9FSWRITE	0x0040	/* Write lease */
+ #define	NQU9FSEVICTED	0x0080	/* Has been evicted */
+ #define	NACC		0x0100	/* Special file accessed */
+ #define	NUPD		0x0200	/* Special file updated */
+ #define	NCHG		0x0400	/* Special file times changed */
+ #define NLOCKED		0x0800  /* node is locked */
+ #define NWANTED		0x0100  /* someone wants to lock */
+
+ /*
+  * Convert between u9fsnode pointers and vnode pointers
+  */
+ #define VTOU9FS(vp)	((struct u9fsnode *)(vp)->v_data)
+ #define U9FSTOV(np)	((struct vnode *)(np)->n_vnode)
+
+ /*
+  * Mount structure.
+  * One allocated on every U9FS mount.
+  * Holds U9FS specific information for mount.
+  */
+ struct	u9fsmount {
+ 	int	nm_flag;		/* Flags for soft/hard... */
+ 	int	nm_state;		/* Internal state flags */
+ 	struct	mount *nm_mountp;	/* Vfs structure for this filesystem */
+ 	int	nm_numgrps;		/* Max. size of groupslist */
+         u9fsfh_t nm_fh;                /* qid.path */
+ 	u_short	nm_fid;	                /* fid of root dir */
+ 	struct	socket *nm_so;		/* Rpc socket */
+ 	int	nm_sotype;		/* Type of socket */
+ 	int	nm_soproto;		/* and protocol */
+ 	int	nm_soflags;		/* pr_flags for socket protocol */
+ 	struct	sockaddr *nm_nam;	/* Addr of server */
+ 	int	nm_sent;		/* Request send count */
+ 	int	nm_cwnd;		/* Request send window */
+ 	int	nm_rsize;		/* Max size of read rpc */
+ 	int	nm_wsize;		/* Max size of write rpc */
+ 	int	nm_readdirsize;		/* Size of a readdir rpc */
+
+   struct lock   nm_lock;                /* lock for tag/fid freelist */
+   bitstr_t * nm_tags;
+   bitstr_t * nm_fids;
+   TAILQ_HEAD(u9fs_reqq, u9fsreq) nm_reqq;
+
+         uid_t   nm_authuid;             /* Uid for authenticator */
+ #if 0
+ 	struct vnode *nm_inprog;	/* Vnode in prog by nqu9fs_clientd() */
+ 	uid_t	nm_authuid;		/* Uid for authenticator */
+ 	int	nm_authtype;		/* Authenticator type */
+ 	int	nm_authlen;		/* and length */
+ 	char	*nm_authstr;		/* Authenticator string */
+ 	char	*nm_verfstr;		/* and the verifier */
+ 	int	nm_verflen;
+ 	u_char	nm_verf[U9FSX_V3WRITEVERF]; /* V3 write verifier */
+ 	U9FSKERBKEY_T nm_key;		/* and the session key */
+ 	int	nm_numuids;		/* Number of u9fsuid mappings */
+ 	TAILQ_HEAD(, u9fsuid) nm_uidlruhead; /* Lists of u9fsuid mappings */
+ 	LIST_HEAD(, u9fsuid) nm_uidhashtbl[U9FS_MUIDHASHSIZ];
+ 	TAILQ_HEAD(, buf) nm_bufq;	/* async io buffer queue */
+ 	short	nm_bufqlen;		/* number of buffers in queue */
+ 	short	nm_bufqwant;		/* process wants to add to the queue */
+ 	int	nm_bufqiods;		/* number of iods processing queue */
+ #endif
+ 	u_int64_t nm_maxfilesize;	/* maximum file size */
+ };
+
+ #ifdef KERNEL
+
+ #ifdef MALLOC_DECLARE
+ MALLOC_DECLARE(M_U9FSHASH);
+ MALLOC_DECLARE(M_U9FSBITS);
+
+ extern        vop_t   **u9fs_vnodeop_p;
+
+ /* u9fs_node.c */
+ void     u9fs_nhinit __P((void));
+ int u9fs_nget __P((struct mount *mntp, u9fsfh_t fh, struct u9fsnode **npp, struct proc * p));
+
+ /* u9fs_subr.c */
+ void u9fs_id_init __P((bitstr_t ** bits));
+ u_short u9fs_id_new __P((bitstr_t * bits));
+ void u9fs_id_free __P((bitstr_t * bits, u_short v));
+ void u9fs_uhinit __P((void));
+ uid_t u9fs_name2uid __P((char * name));
+ struct u9fsuser *  u9fs_finduser __P((uid_t uid));
+ void  u9fs_hashuser __P((uid_t uid, char *name));
+ int u9fs_mbuftouio __P((struct mbuf *m, struct uio *uiop, int siz));
+ int u9fs_uiotombuf __P((struct uio *uiop, struct mbuf **mq, int siz));
+
+ /* u9fs_vnopes.c */
+ int u9fs_readdirrpc __P((struct vnode *, struct uio *, struct ucred *));
+ int u9fs_readrpc __P((struct vnode *vp, struct uio *uiop, struct ucred *cred));
+ int u9fs_writerpc __P((struct vnode *vp, struct uio *uiop, struct ucred *cred));
+
+ /* u9fs_bio.c */
+ int u9fs_bioread __P((struct vnode *, struct uio *, int, struct ucred *,int));
+ int u9fs_biowrite __P((struct vnode *, struct uio *, int ioflag, struct ucred *));
+ int u9fs_doio __P((struct buf *, struct ucred *, struct proc *));
+ int	u9fs_vinvalbuf __P((struct vnode *, int, struct ucred *, struct proc *, int));
+
+
+ /* u9fs_socket.c */
+ int u9fs_sigintr __P((struct u9fsmount *nmp, struct proc *p));
+ void     u9fs_disconnect __P((struct socket *));
+ int      u9fs_connect __P((struct socket ** sop, struct sockaddr * saddr, int sotype, int soproto, struct proc * p));
+ int      u9fs_connect_9fs __P((struct u9fsmount *));
+ int      u9fs_connect_9auth __P((struct u9fsmount *, struct u9fs_args *, struct socket **));
+ int u9fs_request __P((struct u9fsreq * req, struct u9fsreq * rep, int relm));
+
+ #endif
+
+ /*
+  * Convert mount ptr to u9fsmount ptr.
+  */
+ #define VFSTOU9FS(mp)	((struct u9fsmount *)((mp)->mnt_data))
+
+ #endif	/* KERNEL */
+
+ #endif
diff -N -c -r /usr/src/sys/9fs/9fs_bio.c ./9fs/9fs_bio.c
*** /usr/src/sys/9fs/9fs_bio.c	Wed Dec 31 19:00:00 1969
--- ./9fs/9fs_bio.c	Fri Nov 26 12:28:50 1999
***************
*** 0 ****
--- 1,550 ----
+ #include <sys/param.h>
+ #include <sys/sockio.h>
+ #include <sys/proc.h>
+ #include <sys/vnode.h>
+ #include <sys/kernel.h>
+ #include <sys/sysctl.h>
+ #include <sys/malloc.h>
+ #include <sys/mount.h>
+ #include <sys/mbuf.h>
+ #include <sys/socket.h>
+ #include <sys/socketvar.h>
+ #include <sys/systm.h>
+ #include <sys/protosw.h>
+ #include <sys/syslog.h>
+
+ #include <netinet/in.h>
+ #include <netinet/tcp.h>
+
+ #include <vm/vm.h>
+ #include <vm/vm_extern.h>
+ #include <vm/vm_zone.h>
+ #include <vm/vm_prot.h>
+ #include <vm/vm_page.h>
+ #include <vm/vm_object.h>
+ #include <vm/vm_pager.h>
+ #include <vm/vnode_pager.h>
+
+ #include <net/if.h>
+ #include <net/route.h>
+ #include <netinet/in.h>
+
+ #include <9fs/bitstring.h>
+ #include <9fs/9p.h>
+ #include <9fs/9auth.h>
+ #include <9fs/9fs.h>
+
+ static struct buf *u9fs_getcacheblk __P((struct vnode *vp, daddr_t bn, int size, struct proc *p));
+ static void u9fs_prot_buf __P((struct buf *bp, int off, int n));
+
+ /*
+  * Vnode op for read using bio
+  */
+ int
+ u9fs_bioread(vp, uio, ioflag, cred, getpages)
+ 	register struct vnode *vp;
+ 	register struct uio *uio;
+ 	int ioflag;
+ 	struct ucred *cred;
+ 	int getpages;
+ {
+ 	register struct u9fsnode *np = VTOU9FS(vp);
+ 	register int biosize;
+ 	off_t diff;
+ 	struct buf *bp = 0;
+ 	struct proc *p;
+ 	struct u9fsmount *nmp = VFSTOU9FS(vp->v_mount);
+ 	daddr_t lbn;
+ 	int error = 0, n = 0, on = 0, bufsize, not_readin;
+
+ 	if (uio->uio_resid == 0)
+ 		return (0);
+ 	if (uio->uio_offset < 0)
+ 		return (EINVAL);
+ 	p = uio->uio_procp;
+ 	if (vp->v_type != VDIR &&
+ 	    (uio->uio_offset + uio->uio_resid) > nmp->nm_maxfilesize)
+ 		return (EFBIG);
+ 	biosize = vp->v_mount->mnt_stat.f_iosize;
+ #if 0
+ 	if( np->n_qid.vers ) { /* in cache, check revision */
+ 	  error = VOP_GETATTR(vp, &vattr, cred, p);
+ 	  if( error )
+ 	    return error;
+ 	  if( np->n_qid.vers != np->n_dir.dir_qid.vers ) {
+ 	    /* content changed */
+ 	    u9fs_vinvalbuf(vp, V_SAVE, cred, p, 1);
+ 	  }
+ 	}
+ #endif
+ 	do {
+ 	    switch (vp->v_type) {
+ 	    case VREG:
+ 		lbn = uio->uio_offset / biosize;
+ 		on = uio->uio_offset & (biosize - 1);
+ 		not_readin = 1;
+
+ #if 0
+ 		/*
+ 		 * Start the read ahead(s), as required.
+ 		 */
+ 		if (u9fs_numasync > 0 && nmp->nm_readahead > 0) {
+ 		    for (nra = 0; nra < nmp->nm_readahead &&
+ 			(off_t)(lbn + 1 + nra) * biosize < np->n_size; nra++) {
+ 			rabn = lbn + 1 + nra;
+ 			if (!incore(vp, rabn)) {
+ 			    rabp = u9fs_getcacheblk(vp, rabn, biosize, p);
+ 			    if (!rabp)
+ 				return (EINTR);
+ 			    if ((rabp->b_flags & (B_CACHE|B_DELWRI)) == 0) {
+ 				rabp->b_flags |= (B_READ | B_ASYNC);
+ 				vfs_busy_pages(rabp, 0);
+ 				if (u9fs_asyncio(rabp, cred)) {
+ 				    rabp->b_flags |= B_INVAL|B_ERROR;
+ 				    vfs_unbusy_pages(rabp);
+ 				    brelse(rabp);
+ 				}
+ 			    } else
+ 				brelse(rabp);
+ 			}
+ 		    }
+ 		}
+ #endif
+
+ 		/*
+ 		 * If the block is in the cache and has the required data
+ 		 * in a valid region, just copy it out.
+ 		 * Otherwise, get the block and write back/read in,
+ 		 * as required.
+ 		 */
+ again:
+ 		bufsize = biosize;
+ 		if ((off_t)(lbn + 1) * biosize > np->n_size &&
+ 		    (off_t)(lbn + 1) * biosize - np->n_size < biosize) {
+ 			bufsize = np->n_size - (off_t)lbn * biosize;
+ 			bufsize = (bufsize + DEV_BSIZE - 1) & ~(DEV_BSIZE - 1);
+ 		}
+ 		bp = u9fs_getcacheblk(vp, lbn, bufsize, p);
+ 		if (!bp)
+ 			return (EINTR);
+ 		/*
+ 		 * If we are being called from u9fs_getpages, we must
+ 		 * make sure the buffer is a vmio buffer.  The vp will
+ 		 * already be setup for vmio but there may be some old
+ 		 * non-vmio buffers attached to it.
+ 		 */
+ 		if (getpages && !(bp->b_flags & B_VMIO)) {
+ #ifdef DIAGNOSTIC
+ 			printf("u9fs_bioread: non vmio buf found, discarding\n");
+ #endif
+ 			bp->b_flags |= B_NOCACHE;
+ 			if (bp->b_dirtyend > 0) {
+ 				if ((bp->b_flags & B_DELWRI) == 0)
+ 					panic("u9fsbioread");
+ 				if (VOP_BWRITE(bp) == EINTR)
+ 					return (EINTR);
+ 			} else
+ 				brelse(bp);
+ 			goto again;
+ 		}
+ 		if ((bp->b_flags & B_CACHE) == 0) {
+ 		    bp->b_flags |= B_READ;
+ 		    bp->b_flags &= ~(B_DONE | B_ERROR | B_INVAL);
+ 		    not_readin = 0;
+ 		    vfs_busy_pages(bp, 0);
+ 		    error = u9fs_doio(bp, cred, p);
+ 		    if (error) {
+ 			brelse(bp);
+ 			return (error);
+ 		    }
+ 		    np->n_qid.vers = np->n_dir.dir_qid.vers;
+ 		}
+ 		if (bufsize > on) {
+ 			n = min((unsigned)(bufsize - on), uio->uio_resid);
+ 		} else {
+ 			n = 0;
+ 		}
+ 		diff = np->n_size - uio->uio_offset;
+ 		if (diff < n)
+ 			n = diff;
+ 		if (not_readin && n > 0) {
+ 			if (on < bp->b_validoff || (on + n) > bp->b_validend) {
+ 				bp->b_flags |= B_NOCACHE;
+ 				if (bp->b_dirtyend > 0) {
+ 				    if ((bp->b_flags & B_DELWRI) == 0)
+ 					panic("u9fsbioread");
+ 				    if (VOP_BWRITE(bp) == EINTR)
+ 					return (EINTR);
+ 				} else
+ 				    brelse(bp);
+ 				goto again;
+ 			}
+ 		}
+ 		vp->v_lastr = lbn;
+ 		diff = (on >= bp->b_validend) ? 0 : (bp->b_validend - on);
+ 		if (diff < n)
+ 			n = diff;
+ 		break;
+ 	    case VDIR:
+ 	        biosize = nmp->nm_readdirsize;
+ 		lbn = (uoff_t)uio->uio_offset / biosize;
+ 		on = uio->uio_offset % biosize;
+ 		bp = u9fs_getcacheblk(vp, lbn, biosize, p);
+ 		if (!bp)
+ 		    return (EINTR);
+ 		if ((bp->b_flags & B_CACHE) == 0) {
+ 		    bp->b_flags |= B_READ;
+ 		    vfs_busy_pages(bp, 0);
+ 		    error = u9fs_doio(bp, cred, p);
+ 		    if (error) {
+ 			    brelse(bp);
+ 		    }
+ 		    if (error)
+ 			    return (error);
+ 		    np->n_qid.vers = np->n_dir.dir_qid.vers;
+ 		}
+
+ 		/*
+ 		 * Make sure we use a signed variant of min() since
+ 		 * the second term may be negative.
+ 		 */
+ 		n = lmin(uio->uio_resid, biosize - bp->b_resid - on);
+ 		break;
+ 	    default:
+ 		printf(" u9fs_bioread: type %x unexpected\n",vp->v_type);
+ 		break;
+ 	    };
+
+ 	    if (n > 0) {
+ 		    error = uiomove(bp->b_data + on, (int)n, uio);
+ 	    }
+ 	    brelse(bp);
+ 	} while (error == 0 && uio->uio_resid > 0 && n > 0);
+ 	return (error);
+ }
+
+ /*
+  * Vnode op for write using bio
+  */
+ int
+ u9fs_biowrite(vp, uio, ioflag, cred)
+      register struct vnode *vp;
+      register struct uio *uio;
+      register int  ioflag;
+      register struct ucred *cred;
+ {
+   register int biosize;
+   struct proc *p = uio->uio_procp;
+   struct u9fsnode *np = VTOU9FS(vp);
+   struct buf *bp;
+   struct vattr vattr;
+   struct u9fsmount *nmp = VFSTOU9FS(vp->v_mount);
+   daddr_t lbn;
+   int bufsize;
+   int n, on, error = 0;
+
+   if (ioflag & (IO_APPEND | IO_SYNC)) {
+     if (ioflag & IO_APPEND) {
+       error = VOP_GETATTR(vp, &vattr, cred, p);
+       if (error)
+ 	return (error);
+       uio->uio_offset = np->n_size;
+     }
+   }
+   if (uio->uio_offset < 0)
+     return (EINVAL);
+   if ((uio->uio_offset + uio->uio_resid) > nmp->nm_maxfilesize)
+     return (EFBIG);
+   if (uio->uio_resid == 0)
+     return (0);
+
+ 	/*
+ 	 * I use nm_rsize, not nm_wsize so that all buffer cache blocks
+ 	 * will be the same size within a filesystem. nfs_writerpc will
+ 	 * still use nm_wsize when sizing the rpc's.
+ 	 */
+ 	biosize = vp->v_mount->mnt_stat.f_iosize;
+ 	do {
+ 		lbn = uio->uio_offset / biosize;
+ 		on = uio->uio_offset & (biosize-1);
+ 		n = min((unsigned)(biosize - on), uio->uio_resid);
+ 		if (uio->uio_offset + n > np->n_size) {
+ 			np->n_size = uio->uio_offset + n;
+ 			vnode_pager_setsize(vp, np->n_size);
+ 		}
+ 		bufsize = biosize;
+ 		if ((off_t)(lbn + 1) * biosize > np->n_size) {
+ 			bufsize = np->n_size - (off_t)lbn * biosize;
+ 			bufsize = (bufsize + DEV_BSIZE - 1) & ~(DEV_BSIZE - 1);
+ 		}
+ 		bp = u9fs_getcacheblk(vp, lbn, bufsize, p);
+ 		if (!bp)
+ 			return (EINTR);
+ 		if (bp->b_wcred == NOCRED) {
+ 			crhold(cred);
+ 			bp->b_wcred = cred;
+ 		}
+
+ 		error = uiomove((char *)bp->b_data + on, n, uio);
+ 		if (error) {
+ 			bp->b_flags |= B_ERROR;
+ 			brelse(bp);
+ 			return (error);
+ 		}
+
+ 		/*
+ 		 * This will keep the buffer and mmaped regions more coherent.
+ 		 */
+ 		u9fs_prot_buf(bp, on, n);
+ 		bp->b_dirtyoff = on;
+ 		bp->b_dirtyend = on + n;
+
+ 		if (bp->b_validend == 0 || bp->b_validend < bp->b_dirtyoff ||
+ 		    bp->b_validoff > bp->b_dirtyend) {
+ 		  /* XXX: destroys our read cache if not overlapping */
+ 		  /* two choice: none implemented
+ 		     1> keep the bigger(smaller) piece
+ 		     2> read the missing segment
+ 		  */
+ 			bp->b_validoff = bp->b_dirtyoff;
+ 			bp->b_validend = bp->b_dirtyend;
+ 		} else {
+ 			bp->b_validoff = min(bp->b_validoff, bp->b_dirtyoff);
+ 			bp->b_validend = max(bp->b_validend, bp->b_dirtyend);
+ 		}
+
+ 		error = bwrite(bp);
+ 		if( error ) {
+ 		  bp->b_flags |= B_ERROR;
+ 		  /* brelse(bp); */
+ 		  return error;
+ 		}
+ 	} while (uio->uio_resid > 0 && n > 0);
+ 	return 0;
+ }
+
+ /*
+  * Do an I/O operation to/from a cache block. This may be called
+  * synchronously or from an u9fsiod.
+  */
+ int
+ u9fs_doio(bp, cr, p)
+ 	register struct buf *bp;
+ 	struct ucred *cr;
+ 	struct proc *p;
+ {
+ 	register struct uio *uiop;
+ 	register struct vnode *vp;
+ 	struct u9fsnode *np;
+ 	struct u9fsmount *nmp;
+ 	int error = 0, diff, len;
+ 	struct uio uio;
+ 	struct iovec io;
+
+ 	vp = bp->b_vp;
+ 	np = VTOU9FS(vp);
+ 	nmp = VFSTOU9FS(vp->v_mount);
+ 	uiop = &uio;
+ 	uiop->uio_iov = &io;
+ 	uiop->uio_iovcnt = 1;
+ 	uiop->uio_segflg = UIO_SYSSPACE;
+ 	uiop->uio_procp = p;
+
+ 	if (bp->b_flags & B_READ ) {
+ 	    io.iov_len = uiop->uio_resid = bp->b_bcount;
+ 	    io.iov_base = bp->b_data;
+ 	    uiop->uio_rw = UIO_READ;
+ 	    switch (vp->v_type) {
+ 	    case VREG:
+ 		uiop->uio_offset = ((off_t)bp->b_blkno) * DEV_BSIZE;
+ 		error = u9fs_readrpc(vp, uiop, cr);
+ 		if (!error) {
+ 		    bp->b_validoff = 0;
+ 		    if (uiop->uio_resid) {
+ 			/*
+ 			 * If len > 0, there is a hole in the file and
+ 			 * no writes after the hole have been pushed to
+ 			 * the server yet.
+ 			 * Just zero fill the rest of the valid area.
+ 			 */
+ 			diff = bp->b_bcount - uiop->uio_resid;
+ 			len = np->n_size - (((u_quad_t)bp->b_blkno) * DEV_BSIZE
+ 				+ diff);
+ 			if (len > 0) {
+ 			    len = min(len, uiop->uio_resid);
+ 			    bzero((char *)bp->b_data + diff, len);
+ 			    bp->b_validend = diff + len;
+ 			} else
+ 			    bp->b_validend = diff;
+ 		    } else
+ 			bp->b_validend = bp->b_bcount;
+ 		}
+ 		break;
+ 	    case VDIR:
+ 		uiop->uio_offset = ((u_quad_t)bp->b_lblkno) * nmp->nm_readdirsize;
+ 		error = u9fs_readdirrpc(vp, uiop, cr);
+ 		if (error == 0 && uiop->uio_resid == bp->b_bcount)
+ 		  bp->b_flags |= B_INVAL;
+ 		break;
+ 	    default:
+ 		printf("u9fs_doio:  type %x unexpected\n",vp->v_type);
+ 		break;
+ 	    };
+ 	    if (error) {
+ 		bp->b_flags |= B_ERROR;
+ 		bp->b_error = error;
+ 	    }
+ 	} else {
+ 	    if ((off_t)bp->b_blkno * DEV_BSIZE + bp->b_dirtyend > np->n_size)
+ 		bp->b_dirtyend = np->n_size - (off_t)bp->b_blkno * DEV_BSIZE;
+
+ 	    if (bp->b_dirtyend > bp->b_dirtyoff) {
+ 		io.iov_len = uiop->uio_resid = bp->b_dirtyend
+ 		    - bp->b_dirtyoff;
+ 		uiop->uio_offset = (off_t)bp->b_blkno * DEV_BSIZE
+ 		    + bp->b_dirtyoff;
+ 		io.iov_base = (char *)bp->b_data + bp->b_dirtyoff;
+ 		uiop->uio_rw = UIO_WRITE;
+ 		bp->b_flags |= B_WRITEINPROG;
+ 		error = u9fs_writerpc(vp, uiop, cr);
+ 		bp->b_flags &= ~B_WRITEINPROG;
+
+ 		if (error) {
+ 		  bp->b_flags |= B_ERROR;
+ 		  bp->b_error = np->n_error = error;
+ 		  np->n_flag |= NWRITEERR;
+ 		}
+ 		bp->b_dirtyoff = bp->b_dirtyend = 0;
+ 	    } else {
+ 		bp->b_resid = 0;
+ 		biodone(bp);
+ 		return (0);
+ 	    }
+ 	}
+ 	bp->b_resid = uiop->uio_resid;
+ 	biodone(bp);
+ 	return error;
+ }
+
+ /*
+  * Get an u9fs cache block.
+  * Allocate a new one if the block isn't currently in the cache
+  * and return the block marked busy. If the calling process is
+  * interrupted by a signal for an interruptible mount point, return
+  * NULL.
+  */
+ static struct buf *
+ u9fs_getcacheblk(vp, bn, size, p)
+ 	struct vnode *vp;
+ 	daddr_t bn;
+ 	int size;
+ 	struct proc *p;
+ {
+ 	register struct buf *bp;
+ 	struct mount *mp;
+ 	struct u9fsmount *nmp;
+
+ 	mp = vp->v_mount;
+ 	nmp = VFSTOU9FS(mp);
+
+ 	if (nmp->nm_flag & U9FSMNT_INT) {
+ 		bp = getblk(vp, bn, size, PCATCH, 0);
+ 		while (bp == (struct buf *)0) {
+ 			if (u9fs_sigintr(nmp, p))
+ 				return ((struct buf *)0);
+ 			bp = getblk(vp, bn, size, 0, 2 * hz);
+ 		}
+ 	} else
+ 		bp = getblk(vp, bn, size, 0, 0);
+
+ 	if (vp->v_type == VREG) {
+ 		int biosize;
+ 		biosize = mp->mnt_stat.f_iosize;
+ 		bp->b_blkno = bn * (biosize / DEV_BSIZE);
+ 	}
+
+ 	return (bp);
+ }
+
+ static void
+ u9fs_prot_buf(bp, off, n)
+ 	struct buf *bp;
+ 	int off;
+ 	int n;
+ {
+ 	int pindex, boff, end;
+
+ 	if ((bp->b_flags & B_VMIO) == 0)
+ 		return;
+
+ 	end = round_page(off + n);
+ 	for (boff = trunc_page(off); boff < end; boff += PAGE_SIZE) {
+ 		pindex = boff >> PAGE_SHIFT;
+ 		vm_page_protect(bp->b_pages[pindex], VM_PROT_NONE);
+ 	}
+ }
+
+ /*
+  * Flush and invalidate all dirty buffers. If another process is already
+  * doing the flush, just wait for completion.
+  */
+ int
+ u9fs_vinvalbuf(vp, flags, cred, p, intrflg)
+ 	struct vnode *vp;
+ 	int flags;
+ 	struct ucred *cred;
+ 	struct proc *p;
+ 	int intrflg;
+ {
+ 	register struct u9fsnode *np = VTOU9FS(vp);
+ 	struct u9fsmount *nmp = VFSTOU9FS(vp->v_mount);
+ 	int error = 0, slpflag, slptimeo;
+
+ 	if (vp->v_flag & VXLOCK) {
+ 		return (0);
+ 	}
+
+ 	if ((nmp->nm_flag & U9FSMNT_INT) == 0)
+ 		intrflg = 0;
+ 	if (intrflg) {
+ 		slpflag = PCATCH;
+ 		slptimeo = 2 * hz;
+ 	} else {
+ 		slpflag = 0;
+ 		slptimeo = 0;
+ 	}
+ 	/*
+ 	 * First wait for any other process doing a flush to complete.
+ 	 */
+ 	while (np->n_flag & NFLUSHINPROG) {
+ 		np->n_flag |= NFLUSHWANT;
+ 		error = tsleep((caddr_t)&np->n_flag, PRIBIO + 2, "u9fsvinval",
+ 			slptimeo);
+ 		if (error && intrflg && u9fs_sigintr(nmp, p))
+ 			return (EINTR);
+ 	}
+
+ 	/*
+ 	 * Now, flush as required.
+ 	 */
+ 	np->n_flag |= NFLUSHINPROG;
+ 	error = vinvalbuf(vp, flags, cred, p, slpflag, 0);
+ 	while (error) {
+ 		if (intrflg && u9fs_sigintr(nmp, p)) {
+ 			np->n_flag &= ~NFLUSHINPROG;
+ 			if (np->n_flag & NFLUSHWANT) {
+ 				np->n_flag &= ~NFLUSHWANT;
+ 				wakeup((caddr_t)&np->n_flag);
+ 			}
+ 			return (EINTR);
+ 		}
+ 		error = vinvalbuf(vp, flags, cred, p, 0, slptimeo);
+ 	}
+ 	np->n_flag &= ~(NMODIFIED | NFLUSHINPROG);
+ 	if (np->n_flag & NFLUSHWANT) {
+ 		np->n_flag &= ~NFLUSHWANT;
+ 		wakeup((caddr_t)&np->n_flag);
+ 	}
+ 	return (0);
+ }
+
diff -N -c -r /usr/src/sys/9fs/9fs_node.c ./9fs/9fs_node.c
*** /usr/src/sys/9fs/9fs_node.c	Wed Dec 31 19:00:00 1969
--- ./9fs/9fs_node.c	Thu Nov 25 15:36:49 1999
***************
*** 0 ****
--- 1,132 ----
+ #include <sys/param.h>
+ #include <sys/sockio.h>
+ #include <sys/proc.h>
+ #include <sys/vnode.h>
+ #include <sys/kernel.h>
+ #include <sys/sysctl.h>
+ #include <sys/malloc.h>
+ #include <sys/mount.h>
+ #include <sys/mbuf.h>
+ #include <sys/socket.h>
+ #include <sys/socketvar.h>
+ #include <sys/systm.h>
+ #include <sys/protosw.h>
+ #include <sys/syslog.h>
+
+ #include <netinet/in.h>
+ #include <netinet/tcp.h>
+
+ #include <vm/vm.h>
+ #include <vm/vm_extern.h>
+ #include <vm/vm_zone.h>
+
+ #include <net/if.h>
+ #include <net/route.h>
+ #include <netinet/in.h>
+
+ #include <9fs/bitstring.h>
+ #include <9fs/9p.h>
+ #include <9fs/9auth.h>
+ #include <9fs/9fs.h>
+
+ vm_zone_t u9fsnode_zone;
+ static LIST_HEAD(u9fsnodehashhead, u9fsnode) *u9fsnodehashtbl;
+ static u_long u9fsnodehash;
+ MALLOC_DEFINE(M_U9FSHASH, "U9FS hash", "U9FS hash tables");
+
+ /*
+  * Initialize hash links for u9fsnodes
+  * and build u9fsnode free list.
+  */
+ void
+ u9fs_nhinit()
+ {
+   u9fsnode_zone = zinit("U9FSNODE", sizeof(struct u9fsnode), 0, 0, 1);
+   u9fsnodehashtbl = phashinit(desiredvnodes, M_U9FSHASH, &u9fsnodehash);
+ }
+
+ /*
+  * Look up a vnode/u9fsnode by file handle.
+  * Callers must check for mount points!!
+  * In all cases, a pointer to a
+  * u9fsnode structure is returned.
+  */
+ static int u9fs_node_hash_lock;
+
+ int
+ u9fs_nget(mntp, fh, npp, p)
+      struct mount *mntp;
+      register u9fsfh_t fh;
+      struct u9fsnode **npp;
+      struct proc * p;
+ {
+   struct u9fsnode *np;
+   struct u9fsnodehashhead *nhpp;
+   register struct vnode *vp;
+   struct vnode *nvp;
+   int error;
+
+   nhpp = U9FSNOHASH(fh);
+ loop:
+   for (np = nhpp->lh_first; np != 0; np = np->n_hash.le_next) {
+     if (mntp != U9FSTOV(np)->v_mount || fh != np->n_qid.path )
+       continue;
+     vp = U9FSTOV(np);
+     if (vget(vp, LK_EXCLUSIVE, p))
+       goto loop;
+     *npp = np;
+     return(0);
+   }
+   /*
+    * Obtain a lock to prevent a race condition if the getnewvnode()
+    * or MALLOC() below happens to block.
+    */
+   if (u9fs_node_hash_lock) {
+     while (u9fs_node_hash_lock) {
+       u9fs_node_hash_lock = -1;
+       tsleep(&u9fs_node_hash_lock, PVM, "u9fsngt", 0);
+     }
+     goto loop;
+   }
+   u9fs_node_hash_lock = 1;
+
+   /*
+    * allocate before getnewvnode since doing so afterward
+    * might cause a bogus v_data pointer to get dereferenced
+    * elsewhere if zalloc should block.
+    */
+   np = zalloc(u9fsnode_zone);
+
+   error = getnewvnode(VT_U9FS, mntp, u9fs_vnodeop_p, &nvp);
+   if (error) {
+     if (u9fs_node_hash_lock < 0)
+       wakeup(&u9fs_node_hash_lock);
+     u9fs_node_hash_lock = 0;
+     *npp = 0;
+     zfree(u9fsnode_zone, np);
+     return (error);
+   }
+   vp = nvp;
+   bzero((caddr_t)np, sizeof *np);
+   vp->v_data = np;
+   np->n_vnode = vp;
+   /*
+    * Insert the u9fsnode in the hash queue for its new file handle
+    */
+   LIST_INSERT_HEAD(nhpp, np, n_hash);
+   np->n_qid.path = fh;
+   np->n_qid.vers = 0; /* not in cache yet */
+   np->n_fid = 0; /* should be set by the caller */
+   *npp = np;
+
+   if (u9fs_node_hash_lock < 0)
+     wakeup(&u9fs_node_hash_lock);
+   u9fs_node_hash_lock = 0;
+
+   /*
+    * Lock the new u9fsnode.
+    */
+   vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, p);
+
+   return (0);
+ }
diff -N -c -r /usr/src/sys/9fs/9fs_socket.c ./9fs/9fs_socket.c
*** /usr/src/sys/9fs/9fs_socket.c	Wed Dec 31 19:00:00 1969
--- ./9fs/9fs_socket.c	Thu Nov 25 15:48:46 1999
***************
*** 0 ****
--- 1,503 ----
+ #include <sys/param.h>
+ #include <sys/sockio.h>
+ #include <sys/proc.h>
+ #include <sys/vnode.h>
+ #include <sys/kernel.h>
+ #include <sys/sysctl.h>
+ #include <sys/malloc.h>
+ #include <sys/mount.h>
+ #include <sys/mbuf.h>
+ #include <sys/socket.h>
+ #include <sys/socketvar.h>
+ #include <sys/systm.h>
+ #include <sys/protosw.h>
+ #include <sys/syslog.h>
+
+ #include <netinet/in.h>
+ #include <netinet/tcp.h>
+
+ #include <vm/vm.h>
+ #include <vm/vm_extern.h>
+ #include <vm/vm_zone.h>
+
+ #include <net/if.h>
+ #include <net/route.h>
+ #include <netinet/in.h>
+
+ #include <9fs/bitstring.h>
+ #include <9fs/9p.h>
+ #include <9fs/9auth.h>
+ #include <9fs/9fs.h>
+
+ static int u9fs_reply __P((struct u9fsreq * req));
+ static int u9fs_send __P((struct socket * so, struct mbuf * mreq, struct u9fsreq * req));
+ static int u9fs_receive __P((struct socket * so, struct mbuf **mrep, struct u9fsreq * req));
+
+ static int u9fs_sndlock __P((int *flagp, int *statep, struct u9fsreq *rep));
+ static void u9fs_sndunlock __P((int *flagp, int *statep));
+ static int u9fs_rcvlock __P((struct u9fsreq *req));
+ static void u9fs_rcvunlock __P((int *flagp, int *statep));
+
+ int
+ u9fs_connect(struct socket ** sop, struct sockaddr * saddr, int sotype, int soproto, struct proc * p)
+ {
+   register struct socket * so;
+   int error, s;
+
+   *sop = 0;
+   error = socreate(saddr->sa_family, sop, sotype, soproto, p);
+   if( error )
+     return error;
+   so = *sop;
+   error = soconnect(so, saddr, p);
+   if( error )
+     return error;
+
+   /*
+    * Wait for the connection to complete. Cribbed from the
+    * connect system call but with the wait timing out so
+    * that interruptible mounts don't hang here for a long time.
+    */
+   s = splnet();
+   while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0)
+     (void) tsleep((caddr_t)&so->so_timeo, PSOCK,
+ 		  "u9fscon", 2 * hz);
+
+   if (so->so_error) {
+     error = so->so_error;
+     so->so_error = 0;
+     splx(s);
+     return error;
+   }
+   splx(s);
+
+   return (0);
+ }
+
+ int u9fs_connect_9auth(struct u9fsmount * nmp, struct u9fs_args * argp, struct socket ** sop)
+ {
+   int error;
+   struct proc * p = & proc0;
+   struct sockaddr *nam;
+
+   error = getsockaddr(&nam, (caddr_t)argp->authaddr, argp->authaddrlen);
+   if( error )
+     return error;
+   error = u9fs_connect(sop, nam, argp->authsotype,
+ 		       argp->authsoproto, p);
+   if( error == 0 )
+     return 0;
+
+   u9fs_disconnect(*sop);
+   *sop = 0;
+   return error;
+ }
+
+ /*
+  * Initialize sockets and congestion for a new U9FS connection.
+  * We do not free the sockaddr if error.
+  */
+ int
+ u9fs_connect_9fs(nmp)
+      register struct u9fsmount *nmp;
+ {
+   register struct socket *so;
+   int error, rcvreserve, sndreserve;
+   struct proc *p = &proc0; /* only used for socreate and sobind */
+
+   error = u9fs_connect(&nmp->nm_so, nmp->nm_nam, nmp->nm_sotype,
+ 		       nmp->nm_soproto, p);
+   if (error)
+     goto bad;
+   so = nmp->nm_so;
+   nmp->nm_soflags = so->so_proto->pr_flags;
+
+   if (nmp->nm_flag & (U9FSMNT_SOFT | U9FSMNT_INT)) {
+     so->so_rcv.sb_timeo = (5 * hz);
+     so->so_snd.sb_timeo = (5 * hz);
+   } else {
+     so->so_rcv.sb_timeo = 0;
+     so->so_snd.sb_timeo = 0;
+   }
+
+   /* XXX: i dont understand this, only one outstanding request? */
+   if (nmp->nm_sotype == SOCK_SEQPACKET) {
+     sndreserve = (nmp->nm_wsize) * 2;
+     rcvreserve = (max(nmp->nm_rsize, nmp->nm_readdirsize)) * 2;
+   } else {
+     if (nmp->nm_sotype != SOCK_STREAM)
+       panic("u9fscon sotype");
+     if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
+       struct sockopt sopt;
+       int val;
+
+       bzero(&sopt, sizeof sopt);
+       sopt.sopt_level = SOL_SOCKET;
+       sopt.sopt_name = SO_KEEPALIVE;
+       sopt.sopt_val = &val;
+       sopt.sopt_valsize = sizeof val;
+       val = 1;
+       sosetopt(so, &sopt);
+     }
+     if (so->so_proto->pr_protocol == IPPROTO_TCP) {
+       struct sockopt sopt;
+       int val;
+
+       bzero(&sopt, sizeof sopt);
+       sopt.sopt_level = IPPROTO_TCP;
+       sopt.sopt_name = TCP_NODELAY;
+       sopt.sopt_val = &val;
+       sopt.sopt_valsize = sizeof val;
+       val = 1;
+       sosetopt(so, &sopt);
+     }
+     sndreserve = (nmp->nm_wsize) * 2;
+     rcvreserve = (nmp->nm_rsize) * 2;
+   }
+   error = soreserve(so, sndreserve, rcvreserve);
+   if (error)
+     goto bad;
+   so->so_rcv.sb_flags |= SB_NOINTR;
+   so->so_snd.sb_flags |= SB_NOINTR;
+
+   /* Initialize other non-zero congestion variables */
+   nmp->nm_sent = 0;
+   return (0);
+
+ bad:
+   u9fs_disconnect(nmp->nm_so);
+   nmp->nm_so = 0;
+   return (error);
+ }
+
+ /*
+  * U9FS disconnect. Clean up and unlink.
+  */
+ void
+ u9fs_disconnect(struct socket * so)
+ {
+     soshutdown(so, 2);
+     soclose(so);
+ }
+
+ /*
+  * Lock a socket against others.
+  * Necessary for STREAM sockets to ensure you get an entire rpc request/reply
+  * and also to avoid race conditions between the processes with u9fs requests
+  * in progress when a reconnect is necessary.
+  */
+ static int
+ u9fs_sndlock(flagp, statep, rep)
+ 	register int *flagp;
+ 	register int *statep;
+ 	struct u9fsreq *rep;
+ {
+ 	struct proc *p;
+ 	int slpflag = 0, slptimeo = 0;
+
+ 	if (rep) {
+ 		p = rep->r_procp;
+ 		if (rep->r_nmp->nm_flag & U9FSMNT_INT)
+ 			slpflag = PCATCH;
+ 	} else
+ 		p = (struct proc *)0;
+ 	while (*statep & U9FSSTA_SNDLOCK) {
+ 		if (u9fs_sigintr(rep->r_nmp, p))
+ 			return (EINTR);
+ 		*statep |= U9FSSTA_WANTSND;
+ 		(void) tsleep((caddr_t)flagp, slpflag | (PZERO - 1),
+ 			"u9fsndlck", slptimeo);
+ 		if (slpflag == PCATCH) {
+ 			slpflag = 0;
+ 			slptimeo = 2 * hz;
+ 		}
+ 	}
+ 	*statep |= U9FSSTA_SNDLOCK;
+ 	return (0);
+ }
+
+
+ /*
+  * Unlock the stream socket for others.
+  */
+ static void
+ u9fs_sndunlock(flagp, statep)
+ 	register int *flagp;
+ 	register int *statep;
+ {
+
+ 	if ((*statep & U9FSSTA_SNDLOCK) == 0)
+ 		panic("u9fs sndunlock");
+ 	*statep &= ~U9FSSTA_SNDLOCK;
+ 	if (*statep & U9FSSTA_WANTSND) {
+ 		*statep &= ~U9FSSTA_WANTSND;
+ 		wakeup((caddr_t)flagp);
+ 	}
+ }
+
+ /*
+  * Test for a termination condition pending on the process.
+  * This is used for U9FSMNT_INT mounts.
+  */
+ int
+ u9fs_sigintr(nmp, p)
+ 	struct u9fsmount *nmp;
+ 	struct proc * p;
+ {
+ 	if (!(nmp->nm_flag & U9FSMNT_INT))
+ 		return (0);
+ 	if (p && p->p_siglist &&
+ 	    (((p->p_siglist & ~p->p_sigmask) & ~p->p_sigignore) &
+ 	    U9FSINT_SIGMASK))
+ 		return (EINTR);
+ 	return (0);
+ }
+
+ /*
+  * This is the u9fs send routine. For connection based socket types, it
+  * must be called with an u9fs_sndlock() on the socket.
+  * "rep == NULL" indicates that it has been called from a server.
+  * For the client side:
+  * - return EINTR if the RPC is terminated, 0 otherwise
+  * - set R_MUSTRESEND if the send fails for any reason
+  * - do any cleanup required by recoverable socket errors (?)
+  * For the server side:
+  * - return EINTR or ERESTART if interrupted by a signal
+  * - return EPIPE if a connection is lost for connection based sockets (TCP...)
+  * - do any cleanup required by recoverable socket errors (?)
+  */
+ static int
+ u9fs_send(so, top, req)
+ 	register struct socket *so;
+ 	register struct mbuf *top;
+ 	struct u9fsreq *req;
+ {
+   int error, soflags, flags;
+
+   soflags = so->so_proto->pr_flags;
+   if (so->so_type == SOCK_SEQPACKET)
+     flags = MSG_EOR;
+   else
+     flags = 0;
+
+   error = so->so_proto->pr_usrreqs->pru_sosend(so, 0, 0, top, 0,
+ 					       flags, req->r_procp);
+   if (error)
+     log(LOG_INFO, "u9fs send error %d for server %s\n",error,
+ 	  req->r_nmp->nm_mountp->mnt_stat.f_mntfromname);
+
+   return (error);
+ }
+
+ static int
+ u9fs_receive(so, mrep, req)
+      register struct socket * so;
+      struct mbuf **mrep;
+      struct u9fsreq * req;
+ {
+   struct uio auio;
+   u_int32_t len;
+   int error = 0, sotype, rcvflg;
+
+   /*
+    * Set up arguments for soreceive()
+    */
+   *mrep = (struct mbuf *)0;
+   sotype = req->r_nmp->nm_sotype;
+
+   /*
+    * For reliable protocols, lock against other senders/receivers
+    * in case a reconnect is necessary.
+    * For SOCK_STREAM, first get the Record Mark to find out how much
+    * more there is to get.
+    * We must lock the socket against other receivers
+    * until we have an entire rpc request/reply.
+    */
+   if (sotype == SOCK_SEQPACKET ) {
+     if( (so->so_state & SS_ISCONNECTED) == 0 )
+       return (EACCES);
+ 		auio.uio_resid = len = 1000000;
+ 		auio.uio_procp = req->r_procp;
+ 		do {
+ 			rcvflg = 0;
+ 			error =  so->so_proto->pr_usrreqs->pru_soreceive
+ 				(so, 0, &auio, mrep,
+ 				(struct mbuf **)0, &rcvflg);
+ 		} while (error == EWOULDBLOCK);
+ 		len -= auio.uio_resid;
+   }
+   if (error) {
+     m_freem(*mrep);
+     *mrep = (struct mbuf *)0;
+   }
+   return (error);
+ }
+
+ static int
+ u9fs_rcvlock(req)
+ 	register struct u9fsreq *req;
+ {
+ 	register int *flagp = &req->r_nmp->nm_flag;
+ 	register int *statep = &req->r_nmp->nm_state;
+ 	int slpflag, slptimeo = 0;
+
+ 	if (*flagp & U9FSMNT_INT)
+ 		slpflag = PCATCH;
+ 	else
+ 		slpflag = 0;
+ 	while (*statep & U9FSSTA_RCVLOCK) {
+ 		if (u9fs_sigintr(req->r_nmp, req->r_procp))
+ 			return (EINTR);
+ 		*statep |= U9FSSTA_WANTRCV;
+ 		(void) tsleep((caddr_t)flagp, slpflag | (PZERO - 1), "u9fsrcvlk",
+ 			slptimeo);
+ 		/*
+ 		 * If our reply was recieved while we were sleeping,
+ 		 * then just return without taking the lock to avoid a
+ 		 * situation where a single iod could 'capture' the
+ 		 * recieve lock.
+ 		 */
+ 		if (req->r_mrep != NULL)
+ 			return (EALREADY);
+ 		if (slpflag == PCATCH) {
+ 			slpflag = 0;
+ 			slptimeo = 2 * hz;
+ 		}
+ 	}
+ 	*statep |= U9FSSTA_RCVLOCK;
+ 	return (0);
+ }
+
+ /*
+  * Unlock the stream socket for others.
+  */
+ static void
+ u9fs_rcvunlock(flagp, statep)
+ 	register int *flagp;
+ 	register int *statep;
+ {
+
+ 	if ((*statep & U9FSSTA_RCVLOCK) == 0)
+ 		panic("u9fs rcvunlock");
+ 	*statep &= ~U9FSSTA_RCVLOCK;
+ 	if (*statep & U9FSSTA_WANTRCV) {
+ 		*statep &= ~U9FSSTA_WANTRCV;
+ 		wakeup((caddr_t)flagp);
+ 	}
+ }
+
+ /*
+  * Implement receipt of reply on a socket.
+  * We must search through the list of received datagrams matching them
+  * with outstanding requests using the xid, until ours is found.
+  */
+ /* ARGSUSED */
+ static
+ int u9fs_reply(struct u9fsreq * req)
+ {
+   int error;
+   struct mbuf * mrep;
+   register struct u9fsmount *nmp = req->r_nmp;
+   u_short tag;
+   struct u9fsreq * qp;
+
+   /*
+    * Loop around until we get our own reply
+    */
+   for (;;) {
+     /*
+      * Lock against other receivers so that I don't get stuck in
+      * sbwait() after someone else has received my reply for me.
+      * Also necessary for connection based protocols to avoid
+      * race conditions during a reconnect.
+      * If u9fs_rcvlock() returns EALREADY, that means that
+      * the reply has already been recieved by another
+      * process and we can return immediately.  In this
+      * case, the lock is not taken to avoid races with
+      * other processes.
+      */
+     error = u9fs_rcvlock(req);
+     if (error == EALREADY)
+       return (0);
+     if (error)
+       return (error);
+     /*
+      * Get the next Rpc reply off the socket
+      */
+     error = u9fs_receive(nmp->nm_so, &mrep, req);
+     u9fs_rcvunlock(&nmp->nm_flag, &nmp->nm_state);
+     if (error)
+       return (error);
+
+     /* extract the tag */
+     tag = u9p_m_tag(&mrep);
+
+     /*
+      * Loop through the request list to match up the reply
+      * Iff no match, just drop the datagram
+      */
+     for (qp = nmp->nm_reqq.tqh_first; qp != 0; qp = qp->r_chain.tqe_next) {
+       if ( qp->r_mrep == 0 && qp->r_tag == tag )
+ 	break;
+     }
+     if( qp == 0 ) {
+       m_freem(mrep);
+       continue;
+     }
+
+     if( u9p_m_m2s(&mrep, qp->r_rep) ) { /* freed by m2s */
+       continue;
+     }
+
+     qp->r_mrep = mrep;  /* should not be freed until the reply is read */
+
+     if( qp == req )
+       return 0;
+   }
+ }
+
+ int u9fs_request(struct u9fsreq * req, struct u9fsreq * rep, int relm)
+ {
+   struct mbuf * mreq;
+   int error,s;
+   struct u9fsmount * nmp;
+
+   req->r_rep = rep;
+   req->r_mrep = 0;
+   nmp = req->r_nmp;
+   req->r_tag = u9fs_id_new(nmp->nm_tags);
+
+   mreq = u9p_m_s2m(req);
+
+   /*
+    * Chain request into list of outstanding requests. Be sure
+    * to put it LAST so timer finds oldest requests first.
+    */
+   s = splsoftclock();
+   TAILQ_INSERT_TAIL(&nmp->nm_reqq, req, r_chain);
+   splx(s);
+
+   error = u9fs_send(nmp->nm_so, mreq, req);
+
+   if( !error )
+     error = u9fs_reply(req);
+
+   /*
+    * RPC done, unlink the request.
+    */
+   s = splsoftclock();
+   TAILQ_REMOVE(&nmp->nm_reqq, req, r_chain);
+   splx(s);
+
+   u9fs_id_free(nmp->nm_tags, req->r_tag);
+
+   if( !error && relm ) {
+ 	m_freem(req->r_mrep);
+ 	req->r_mrep = 0;
+   }
+   if( rep->r_type == Rerror )
+       error = EACCES;
+
+   return error;
+ }
+
diff -N -c -r /usr/src/sys/9fs/9fs_subr.c ./9fs/9fs_subr.c
*** /usr/src/sys/9fs/9fs_subr.c	Wed Dec 31 19:00:00 1969
--- ./9fs/9fs_subr.c	Fri Nov 26 12:28:17 1999
***************
*** 0 ****
--- 1,240 ----
+ #include <sys/param.h>
+ #include <sys/sockio.h>
+ #include <sys/proc.h>
+ #include <sys/vnode.h>
+ #include <sys/kernel.h>
+ #include <sys/sysctl.h>
+ #include <sys/malloc.h>
+ #include <sys/mount.h>
+ #include <sys/mbuf.h>
+ #include <sys/socket.h>
+ #include <sys/socketvar.h>
+ #include <sys/systm.h>
+ #include <sys/protosw.h>
+ #include <sys/syslog.h>
+
+ #include <netinet/in.h>
+ #include <netinet/tcp.h>
+
+ #include <vm/vm.h>
+ #include <vm/vm_extern.h>
+ #include <vm/vm_zone.h>
+
+ #include <net/if.h>
+ #include <net/route.h>
+ #include <netinet/in.h>
+
+ #include <9fs/bitstring.h>
+ #include <9fs/9p.h>
+ #include <9fs/9auth.h>
+ #include <9fs/9fs.h>
+
+ vm_zone_t u9fsuser_zone;
+ LIST_HEAD(u9fsuserhashhead, u9fsuser) * u9fsuidhashtbl, * u9fsunamehashtbl;
+ u_long u9fsuidhash;
+ u_long u9fsunamehash;
+ MALLOC_DEFINE(M_U9FSBITS, "U9FS bits", "U9FS tag/fid maps");
+
+ static int   u9fs_hashname __P((char * name));
+
+ void u9fs_uhinit()
+ {
+   u9fsuser_zone = zinit("U9FSUSER", sizeof(struct u9fsuser), 0, 0, 1);
+   u9fsuidhashtbl   = phashinit(U9FS_USER_HASHSIZE, M_U9FSHASH, &u9fsuidhash);
+   u9fsunamehashtbl = phashinit(U9FS_USER_HASHSIZE, M_U9FSHASH, &u9fsunamehash);
+ }
+
+ void
+ u9fs_id_init(bits)
+      bitstr_t ** bits;
+ {
+   bit_alloc(*bits, 0x10000, M_U9FSBITS, M_WAITOK);
+   bit_nset(*bits, 1, 0xffff);  /* we dont use zero */
+ }
+
+ u_short
+ u9fs_id_new(bits)
+      bitstr_t * bits;
+ {
+   int v;
+
+   bit_ffs(bits, 0x10000, &v);
+   if( v < 0 )
+     panic("no more u9fs bits!");
+
+   bit_clear(bits, v);
+   return ((u_short)v);
+ }
+
+ void
+ u9fs_id_free(bits, v)
+      bitstr_t * bits;
+      u_short v;
+ {
+   bit_set(bits, v);
+ }
+
+
+ static int u9fs_hashname(char * cp)
+ {
+   int h = 0;
+
+   cp[U9FS_NAMELEN-1] = 0;
+   do
+     h += *cp;
+   while ( *cp++ );
+
+   return h;
+ }
+
+ void u9fs_hashuser(uid_t uid, char * name)
+ {
+   int h;
+   struct u9fsuser * u9p, *u9p2;
+   struct u9fsuserhashhead * u9hp;
+
+   if( u9fs_name2uid(name) != 65534 ) /* already hashed by previous mount */
+     return;
+
+   u9p = zalloc(u9fsuser_zone);
+   bzero(u9p, sizeof(*u9p));
+   u9p->u_uid = uid;
+   strncpy(u9p->u_name, name, U9FS_NAMELEN);
+   u9hp = & u9fsuidhashtbl[uid % u9fsuidhash];
+   LIST_INSERT_HEAD(u9hp, u9p, u_hash);
+
+   u9p2 = zalloc(u9fsuser_zone);
+   bcopy(u9p, u9p2, sizeof(*u9p));
+   h = u9fs_hashname(name);
+   u9hp = & u9fsunamehashtbl[h%u9fsunamehash];
+   LIST_INSERT_HEAD(u9hp, u9p2, u_hash);
+ }
+
+ /* name must be at least U9FS_NAMELEN long! */
+ struct u9fsuser * u9fs_finduser(uid_t uid)
+ {
+   struct u9fsuser * u9p;
+   struct u9fsuserhashhead * u9hp;
+
+   u9hp = & u9fsuidhashtbl[uid % u9fsuidhash];
+   LIST_FOREACH(u9p, u9hp, u_hash)
+     if( u9p->u_uid == uid )
+       break;
+
+   return u9p;
+ }
+
+ uid_t u9fs_name2uid(char *name)
+ {
+   struct u9fsuser * u9p;
+   struct u9fsuserhashhead * u9hp;
+   int h;
+
+   h = u9fs_hashname(name);
+   u9hp = & u9fsunamehashtbl[h%u9fsunamehash];
+   LIST_FOREACH(u9p, u9hp, u_hash)
+     if( strcmp(u9p->u_name, name) == 0 )
+       break;
+
+   if( u9p )
+     return u9p->u_uid;
+   else
+     return 65534; /* nobody */
+ }
+
+ /*
+  * copies a uio scatter/gather list to an mbuf chain.
+  */
+ int
+ u9fs_uiotombuf(uiop, mq, siz)
+ 	register struct uio *uiop;
+ 	struct mbuf **mq;
+ 	int siz;
+ {
+   register struct mbuf *m;
+   struct mbuf * top, **mp;
+   int mlen, len, error = 0;
+
+   mp = & top;
+   while(siz) {
+     MGET(m, M_WAIT, MT_DATA);
+     mlen = MLEN;
+     if (siz >= MINCLSIZE) {
+       MCLGET(m, M_WAIT);
+       if ((m->m_flags & M_EXT))
+ 	mlen = MCLBYTES;
+     }
+     len = min(mlen, siz);
+     error = uiomove(mtod(m, caddr_t), (int)len, uiop);
+     siz -= len;
+     m->m_len = len;
+     *mp = m;
+     if (error)
+       goto release;
+     mp = &m->m_next;
+   }
+   *mq = top;
+   return 0;
+
+  release:
+   if( top )
+     m_freem(top);
+
+   return error;
+ }
+
+ /*
+  * copies mbuf chain to the uio scatter/gather list
+  */
+ int
+ u9fs_mbuftouio(m, uiop, siz)
+      struct mbuf *m;
+      register struct uio *uiop;
+      int siz;
+ {
+   register char *mbufcp, *uiocp;
+   register int xfer, left, len;
+   long uiosiz;
+
+   mbufcp = mtod(m, char *);
+   len = m->m_len;
+   while (siz > 0) {
+     if (uiop->uio_iovcnt <= 0 || uiop->uio_iov == NULL)
+       return (EFBIG);
+     left = uiop->uio_iov->iov_len;
+     uiocp = uiop->uio_iov->iov_base;
+     if (left > siz)
+       left = siz;
+     uiosiz = left;
+     while (left > 0) {
+       while (len == 0) {
+ 	m = m->m_next;
+ 	if (m == NULL)
+ 	  return (EBADRPC);
+ 	mbufcp = mtod(m, caddr_t);
+ 	len = m->m_len;
+       }
+       xfer = (left > len) ? len : left;
+       if (uiop->uio_segflg == UIO_SYSSPACE)
+ 	bcopy(mbufcp, uiocp, xfer);
+       else
+ 	copyout(mbufcp, uiocp, xfer);
+       left -= xfer;
+       len -= xfer;
+       mbufcp += xfer;
+       uiocp += xfer;
+       uiop->uio_offset += xfer;
+       uiop->uio_resid -= xfer;
+     }
+     if (uiop->uio_iov->iov_len <= siz) {
+       uiop->uio_iovcnt--;
+       uiop->uio_iov++;
+     } else {
+       uiop->uio_iov->iov_base += uiosiz;
+       uiop->uio_iov->iov_len -= uiosiz;
+     }
+     siz -= uiosiz;
+   }
+   return (0);
+ }
+
diff -N -c -r /usr/src/sys/9fs/9fs_vfsops.c ./9fs/9fs_vfsops.c
*** /usr/src/sys/9fs/9fs_vfsops.c	Wed Dec 31 19:00:00 1969
--- ./9fs/9fs_vfsops.c	Mon May 22 16:33:47 2000
***************
*** 0 ****
--- 1,639 ----
+ /*
+  * Copyright (c) 1989, 1993, 1995
+  *	The Regents of the University of California.  All rights reserved.
+  *
+  * This code is derived from software contributed to Berkeley by
+  * Rick Macklem at The University of Guelph.
+  *
+  * Redistribution and use in source and binary forms, with or without
+  * modification, are permitted provided that the following conditions
+  * are met:
+  * 1. Redistributions of source code must retain the above copyright
+  *    notice, this list of conditions and the following disclaimer.
+  * 2. Redistributions in binary form must reproduce the above copyright
+  *    notice, this list of conditions and the following disclaimer in the
+  *    documentation and/or other materials provided with the distribution.
+  * 3. All advertising materials mentioning features or use of this software
+  *    must display the following acknowledgement:
+  *	This product includes software developed by the University of
+  *	California, Berkeley and its contributors.
+  * 4. Neither the name of the University nor the names of its contributors
+  *    may be used to endorse or promote products derived from this software
+  *    without specific prior written permission.
+  *
+  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+  * SUCH DAMAGE.
+  *
+  *	@(#)u9fs_vfsops.c	8.12 (Berkeley) 5/20/95
+  * $Id: u9fs_vfsops.c,v 1.79 1998/12/04 22:54:54 archie Exp $
+  */
+
+ #include <sys/param.h>
+ #include <sys/sockio.h>
+ #include <sys/proc.h>
+ #include <sys/vnode.h>
+ #include <sys/kernel.h>
+ #include <sys/sysctl.h>
+ #include <sys/malloc.h>
+ #include <sys/mount.h>
+ #include <sys/mbuf.h>
+ #include <sys/socket.h>
+ #include <sys/socketvar.h>
+ #include <sys/systm.h>
+ #include <sys/protosw.h>
+ #include <sys/syslog.h>
+
+ #include <netinet/in.h>
+ #include <netinet/tcp.h>
+
+ #include <vm/vm.h>
+ #include <vm/vm_extern.h>
+ #include <vm/vm_zone.h>
+
+ #include <net/if.h>
+ #include <net/route.h>
+ #include <netinet/in.h>
+
+ #include <9fs/bitstring.h>
+ #include <9fs/9p.h>
+ #include <9fs/9auth.h>
+ #include <9fs/9fs.h>
+
+ vm_zone_t u9fsmount_zone;
+
+ static int	u9fs_mount __P(( struct mount *mp, char *path, caddr_t data,
+ 			struct nameidata *ndp, struct proc *p));
+ static int	u9fs_start __P(( struct mount *mp, int flags,
+ 			struct proc *p));
+ static int	u9fs_unmount __P(( struct mount *mp, int mntflags,
+ 			struct proc *p));
+ static int	u9fs_root __P(( struct mount *mp, struct vnode **vpp));
+ static int	u9fs_quotactl __P(( struct mount *mp, int cmds, uid_t uid,
+ 			caddr_t arg, struct proc *p));
+ static int	u9fs_statfs __P(( struct mount *mp, struct statfs *sbp,
+ 			struct proc *p));
+ static int	u9fs_sync __P(( struct mount *mp, int waitfor,
+ 			struct ucred *cred, struct proc *p));
+ static int	u9fs_vptofh __P(( struct vnode *vp, struct fid *fhp));
+ static int	u9fs_fhtovp __P((struct mount *mp, struct fid *fhp,
+ 			struct sockaddr *nam, struct vnode **vpp,
+ 			int *exflagsp, struct ucred **credanonp));
+ static int	u9fs_vget __P((struct mount *, ino_t, struct vnode **));
+ static int      u9fs_init __P((struct vfsconf *vfsp));
+ int             u9fs_uninit __P((struct vfsconf *vfsp));
+
+ /* */
+ static int	mountu9fs __P((struct u9fs_args *,struct mount *,
+ 			struct sockaddr *,char *,char *,struct vnode **, struct proc *p));
+ static int	u9fs_iosize __P((struct u9fsmount *nmp));
+ static void	u9fs_decode_args __P((struct u9fsmount *nmp, struct u9fs_args *argp, struct proc *p));
+
+ /*
+  * u9fs vfs operations.
+  */
+ static struct vfsops u9fs_vfsops = {
+ 	u9fs_mount,
+ 	u9fs_start,
+ 	u9fs_unmount,
+ 	u9fs_root,
+ 	u9fs_quotactl,
+ 	u9fs_statfs,
+ 	u9fs_sync,
+ 	u9fs_vget,
+ 	u9fs_fhtovp,
+ 	u9fs_vptofh,
+ 	u9fs_init,
+ 	u9fs_uninit,
+ 	0
+ };
+ VFS_SET(u9fs_vfsops, u9fs, VFCF_NETWORK);
+
+ /*
+  * u9fs statfs call
+  */
+ static int
+ u9fs_statfs(mp, sbp, p)
+ 	struct mount *mp;
+ 	register struct statfs *sbp;
+ 	struct proc *p;
+ {
+   /* we have a worm with infinite storage,
+      stat not supported by 9fs */
+   return 0;
+ }
+
+ /*
+  * Common code for mount and mountroot
+  */
+ static int
+ mountu9fs(argp, mp, nam, pth, hst, vpp, p)
+ 	register struct u9fs_args *argp;
+ 	register struct mount *mp;
+ 	struct sockaddr *nam;
+ 	char *pth, *hst;
+ 	struct vnode **vpp;
+ 	struct proc *p;
+ {
+   register struct u9fsmount *nmp;
+   struct u9fsnode *np;
+   int error;
+   struct vattr attrs;
+   struct u9fsreq req, rep;
+   char * mntpoint;
+   struct u9fsuser * u9p;
+   struct socket * so;
+
+   if (mp->mnt_flag & MNT_UPDATE) {
+ #if 0
+     nmp = VFSTONFS(mp);
+ <    /* update paths, file handles, etc, here	XXX */
+     FREE(nam, M_SONAME);
+ #endif
+     return (0);
+   } else {
+     nmp = zalloc(u9fsmount_zone);
+     bzero((caddr_t)nmp, sizeof (struct u9fsmount));
+ #if 0
+     TAILQ_INIT(&nmp->nm_uidlruhead);
+     TAILQ_INIT(&nmp->nm_bufq);
+ #endif
+     mp->mnt_data = (qaddr_t)nmp;
+   }
+   vfs_getnewfsid(mp);
+   nmp->nm_mountp = mp;
+
+   nmp->nm_maxfilesize = (u_int64_t)0xffffffffffffffffLL;
+
+   nmp->nm_wsize = U9FS_MAXFDATA;
+   nmp->nm_rsize = U9FS_MAXFDATA;
+   nmp->nm_readdirsize = U9FS_MAXDDATA;
+   bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN);
+   bcopy(pth, mp->mnt_stat.f_mntonname, MNAMELEN);
+   nmp->nm_nam = nam;
+
+   mntpoint = index(hst, '/');
+   if( mntpoint )
+     mntpoint++;
+
+   /* Set up the sockets and per-host congestion */
+   nmp->nm_sotype = argp->sotype;
+   nmp->nm_soproto = argp->proto;
+
+   u9fs_decode_args(nmp, argp, p);
+
+   lockinit(& nmp->nm_lock, PVFS, "u9fsmount", 0, 0);
+   u9fs_id_init(&nmp->nm_tags);
+   u9fs_id_init(&nmp->nm_fids);
+   TAILQ_INIT(&nmp->nm_reqq);
+
+   if ((error = u9fs_connect_9fs(nmp)))
+     goto bad;
+
+   /* "Tnop 1", "Tsession 1 0", "Tattach 1 1 none main 0 0", */
+   bzero(&req, sizeof(req));
+   req.r_nmp = nmp;
+   req.r_procp = p;
+
+   req.r_type = Tnop;
+   error = u9fs_request(& req, & rep, 1);
+   if( error )
+     return error;
+
+   req.r_type = Tsession;
+   /* bzero(req.r_chal, sizeof(req.r_chal)); */
+   u9auth_genchal(req.r_chal);
+   error = u9fs_request(& req, & rep, 1);
+   if( error )
+     return error;
+
+   if( argp->authaddr ) {
+     /* get tickets from the auth server */
+     error = u9fs_connect_9auth(nmp, argp, & so);
+     if( error )
+       goto bad;
+     u9p = u9fs_finduser(u9fs_name2uid(argp->user));
+     error = u9auth_gettickets(so, & rep, argp->user, u9p->u_ckey,
+ 			      req.r_ticket, req.r_auth, p);
+     u9fs_disconnect(so);
+     if( error )
+       goto bad;
+   }
+
+   req.r_type = Tattach;
+   req.r_fid = u9fs_id_new(nmp->nm_fids);
+   strcpy(req.r_uname, argp->user);
+   strcpy(req.r_aname, mntpoint);
+   error = u9fs_request(& req, & rep, 1);
+   if( error )
+     return error;
+   nmp->nm_fh = rep.r_qid.path;
+   nmp->nm_fid = req.r_fid;
+   /* XXX: we should have checked our challenge to the server! */
+
+   /*
+    * This is silly, but it has to be set so that vinifod() works.
+    * We do not want to do an u9fs_statfs() here since we can get
+    * stuck on a dead server and we are holding a lock on the mount
+    * point.
+    */
+   mp->mnt_stat.f_iosize = u9fs_iosize(nmp);
+
+   /*
+    * A reference count is needed on the u9fsnode representing the
+    * remote root.  If this object is not persistent, then backward
+    * traversals of the mount point (i.e. "..") will not work if
+    * the u9fsnode gets flushed out of the cache. Ufs does not have
+    * this problem, because one can identify root inodes by their
+    * number == ROOTINO (2).
+    */
+   error = u9fs_nget(mp, nmp->nm_fh, &np, p);
+   np->n_fid = nmp->nm_fid;
+
+   nmp->nm_authuid = p->p_ucred->cr_uid;
+
+   if (error)
+     goto bad;
+   *vpp = U9FSTOV(np);
+
+   /*
+    * Get file attributes for the mountpoint.  This has the side
+    * effect of filling in (*vpp)->v_type with the correct value.
+    */
+   VOP_GETATTR(*vpp, &attrs, p->p_ucred, p);
+
+   /*
+    * Lose the lock but keep the ref.
+    */
+   VOP_UNLOCK(*vpp, 0, p);
+
+   return (0);
+ bad:
+   u9fs_disconnect(nmp->nm_so);
+   zfree(u9fsmount_zone, nmp);
+   FREE(nam, M_SONAME);
+   return (error);
+ }
+
+ /*
+  * VFS Operations.
+  *
+  * mount system call
+  * It seems a bit dumb to copyinstr() the host and path here and then
+  * bcopy() them in mountu9fs(), but I wanted to detect errors before
+  * doing the sockargs() call because sockargs() allocates an mbuf and
+  * an error after that means that I have to release the mbuf.
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_mount(mp, path, data, ndp, p)
+ 	struct mount *mp;
+ 	char *path;
+ 	caddr_t data;
+ 	struct nameidata *ndp;
+ 	struct proc *p;
+ {
+   int error;
+   struct u9fs_args args;
+   struct sockaddr *nam;
+   struct vnode *vp;
+   char pth[MNAMELEN], hst[MNAMELEN];
+   size_t len;
+
+   if( path == NULL )
+     return (EOPNOTSUPP);
+
+   error = copyin(data, (caddr_t)&args, sizeof (struct u9fs_args));
+   if (error)
+     return (error);
+
+   if (args.version != U9FS_ARGSVERSION)
+     return (EPROGMISMATCH);
+
+   if (mp->mnt_flag & MNT_UPDATE) {
+ #if 0
+     register struct u9fsmount *nmp = VFSTONFS(mp);
+
+     if (nmp == NULL)
+       return (EIO);
+     /*
+      * When doing an update, we can't change from or to
+      * v3 and/or nqu9fs, or change cookie translation
+      */
+     args.flags = (args.flags &
+ 		  ~(NFSMNT_NFSV3|NFSMNT_NQNFS /*|NFSMNT_XLATECOOKIE*/)) |
+       (nmp->nm_flag &
+        (NFSMNT_NFSV3|NFSMNT_NQNFS /*|NFSMNT_XLATECOOKIE*/));
+     u9fs_decode_args(nmp, &args, p);
+ #endif
+     return (0);
+   }
+
+   error = copyinstr(path, pth, MNAMELEN-1, &len);
+   if (error)
+     return (error);
+   bzero(&pth[len], MNAMELEN - len);
+   error = copyinstr(args.hostname, hst, MNAMELEN-1, &len);
+   if (error)
+     return (error);
+   bzero(&hst[len], MNAMELEN - len);
+   /* sockargs() call must be after above copyin() calls */
+   error = getsockaddr(&nam, (caddr_t)args.addr, args.addrlen);
+   if (error)
+     return (error);
+   error = mountu9fs(&args, mp, nam, pth, hst, &vp, p);
+   return (error);
+ }
+
+ /*
+  * unmount system call
+  */
+ static int
+ u9fs_unmount(mp, mntflags, p)
+      struct mount *mp;
+      int mntflags;
+      struct proc *p;
+ {
+   register struct u9fsmount *nmp;
+   struct u9fsnode *np;
+   struct vnode *vp;
+   int error, flags = 0;
+
+   if (mntflags & MNT_FORCE)
+     flags |= FORCECLOSE;
+   nmp = VFSTOU9FS(mp);
+
+   if( p->p_ucred->cr_uid != nmp->nm_authuid )
+     return (EPERM);
+
+   /*
+    * Goes something like this..
+    * - Check for activity on the root vnode (other than ourselves).
+    * - Call vflush() to clear out vnodes for this file system,
+    *   except for the root vnode.
+    * - Decrement reference on the vnode representing remote root.
+    * - Close the socket
+    * - Free up the data structures
+    */
+   /*
+    * We need to decrement the ref. count on the u9fsnode representing
+    * the remote root.  See comment in mountu9fs().  The VFS unmount()
+    * has done vput on this vnode, otherwise we would get deadlock!
+    */
+   error = u9fs_nget(mp, nmp->nm_fh, &np, p);
+   if (error)
+     return(error);
+   vp = U9FSTOV(np);
+   if (vp->v_usecount > 2) {
+     vput(vp);
+     return (EBUSY);
+   }
+
+   error = vflush(mp, vp, flags);
+   if (error) {
+     vput(vp);
+     return (error);
+   }
+
+   /*
+    * We are now committed to the unmount.
+    */
+   /*
+    * There are two reference counts and one lock to get rid of here.
+    */
+   vput(vp);
+   vrele(vp);
+   vgone(vp);
+   u9fs_disconnect(nmp->nm_so);
+   FREE(nmp->nm_nam, M_SONAME);
+
+   zfree(u9fsmount_zone, nmp);
+   return (0);
+ }
+
+ /*
+  * Return root of a filesystem
+  */
+ static int
+ u9fs_root(mp, vpp)
+ 	struct mount *mp;
+ 	struct vnode **vpp;
+ {
+         register struct vnode *vp;
+         struct u9fsmount *nmp;
+         struct u9fsnode *np;
+         int error;
+
+         nmp = VFSTOU9FS(mp);
+         error = u9fs_nget(mp, nmp->nm_fh, &np, curproc); /* XXX */
+         if (error)
+                 return (error);
+         vp = U9FSTOV(np);
+         if (vp->v_type == VNON)
+             vp->v_type = VDIR;
+         vp->v_flag = VROOT;
+         *vpp = vp;
+         return (0);
+ }
+
+ extern int syncprt;
+
+ /*
+  * Flush out the buffer cache
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_sync(mp, waitfor, cred, p)
+ 	struct mount *mp;
+ 	int waitfor;
+ 	struct ucred *cred;
+ 	struct proc *p;
+ {
+   /* no cache yet */
+   return 0;
+ }
+
+ /*
+  * U9FS flat namespace lookup.
+  * Currently unsupported.
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_vget(mp, ino, vpp)
+ 	struct mount *mp;
+ 	ino_t ino;
+ 	struct vnode **vpp;
+ {
+
+ 	return (EOPNOTSUPP);
+ }
+
+ /*
+  * At this point, this should never happen
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_fhtovp(mp, fhp, nam, vpp, exflagsp, credanonp)
+ 	register struct mount *mp;
+ 	struct fid *fhp;
+ 	struct sockaddr *nam;
+ 	struct vnode **vpp;
+ 	int *exflagsp;
+ 	struct ucred **credanonp;
+ {
+
+ 	return (EINVAL);
+ }
+
+ /*
+  * Vnode pointer to File handle, should never happen either
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_vptofh(vp, fhp)
+ 	struct vnode *vp;
+ 	struct fid *fhp;
+ {
+
+ 	return (EINVAL);
+ }
+
+ /*
+  * Vfs start routine, a no-op.
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_start(mp, flags, p)
+ 	struct mount *mp;
+ 	int flags;
+ 	struct proc *p;
+ {
+
+ 	return (0);
+ }
+
+ /*
+  * Do operations associated with quotas, not supported
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_quotactl(mp, cmd, uid, arg, p)
+ 	struct mount *mp;
+ 	int cmd;
+ 	uid_t uid;
+ 	caddr_t arg;
+ 	struct proc *p;
+ {
+
+ 	return (EOPNOTSUPP);
+ }
+
+ /*
+  * Called once to initialize data structures...
+  */
+ int
+ u9fs_init(vfsp)
+ 	struct vfsconf *vfsp;
+ {
+   u9fsmount_zone = zinit("U9FSMOUNT", sizeof(struct u9fsmount), 0, 0, 1);
+   u9fs_nhinit();			/* Init the u9fsnode table */
+   u9fs_uhinit();
+   return 0;
+ }
+
+ int
+ u9fs_uninit(vfsp)
+ 	struct vfsconf *vfsp;
+ {
+   return 0;
+ }
+
+ static int
+ u9fs_iosize(nmp)
+      struct u9fsmount* nmp;
+ {
+   int iosize;
+
+   /*
+    * Calculate the size used for io buffers.  Use the larger
+    * of the two sizes to minimise u9fs requests but make sure
+    * that it is at least one VM page to avoid wasting buffer
+    * space.
+    */
+   iosize = max(nmp->nm_rsize, nmp->nm_wsize);
+   if (iosize < PAGE_SIZE) iosize = PAGE_SIZE;
+   return iosize;
+ }
+
+ static void
+ u9fs_decode_args(nmp, argp, p)
+      struct u9fsmount *nmp;
+      struct u9fs_args *argp;
+      struct proc * p;
+ {
+   int s, i;
+   int maxio;
+   struct p9user * p9p, p9u;
+   struct u9fsuser * u9p;
+
+   s = splnet();
+   /* Update flags atomically.  Don't change the lock bits. */
+   nmp->nm_flag = argp->flags | nmp->nm_flag;
+   splx(s);
+
+   maxio = U9FS_MAXFDATA;
+
+   if (argp->wsize > 0) {
+     nmp->nm_wsize = argp->wsize;
+     /* Round down to multiple of blocksize */
+     nmp->nm_wsize &= ~(U9FS_FABLKSIZE - 1);
+     if (nmp->nm_wsize <= 0)
+       nmp->nm_wsize = U9FS_FABLKSIZE;
+   }
+   if (nmp->nm_wsize > maxio)
+     nmp->nm_wsize = maxio;
+   if (nmp->nm_wsize > MAXBSIZE)
+     nmp->nm_wsize = MAXBSIZE;
+
+   if (argp->rsize > 0) {
+     nmp->nm_rsize = argp->rsize;
+     /* Round down to multiple of blocksize */
+     nmp->nm_rsize &= ~(U9FS_FABLKSIZE - 1);
+     if (nmp->nm_rsize <= 0)
+       nmp->nm_rsize = U9FS_FABLKSIZE;
+   }
+   if (nmp->nm_rsize > maxio)
+     nmp->nm_rsize = maxio;
+   if (nmp->nm_rsize > MAXBSIZE)
+     nmp->nm_rsize = MAXBSIZE;
+
+   if (argp->readdirsize > 0) {
+     nmp->nm_readdirsize = argp->readdirsize;
+   }
+   if (nmp->nm_readdirsize > maxio)
+     nmp->nm_readdirsize = maxio;
+   if (nmp->nm_readdirsize > nmp->nm_rsize)
+     nmp->nm_readdirsize = nmp->nm_rsize;
+
+   if( argp->nusers ) {
+     p9p = argp->users;
+     for(i = 0; i < argp->nusers; i++) {
+       copyin(p9p, &p9u, sizeof(p9u));
+       u9fs_hashuser(p9u.p9_uid, p9u.p9_name);
+       p9p ++;
+     }
+     printf("%d p9users loaded\n", argp->nusers);
+   }
+
+   if( (u9p = u9fs_finduser(u9fs_name2uid(argp->user))) ) {
+     bcopy(argp->key, u9p->u_ckey, U9AUTH_DESKEYLEN);
+   }
+ }
diff -N -c -r /usr/src/sys/9fs/9fs_vnops.c ./9fs/9fs_vnops.c
*** /usr/src/sys/9fs/9fs_vnops.c	Wed Dec 31 19:00:00 1969
--- ./9fs/9fs_vnops.c	Mon May 22 11:40:00 2000
***************
*** 0 ****
--- 1,1794 ----
+ /*
+  * Copyright (c) 1989, 1993
+  *	The Regents of the University of California.  All rights reserved.
+  *
+  * This code is derived from software contributed to Berkeley by
+  * Rick Macklem at The University of Guelph.
+  *
+  * Redistribution and use in source and binary forms, with or without
+  * modification, are permitted provided that the following conditions
+  * are met:
+  * 1. Redistributions of source code must retain the above copyright
+  *    notice, this list of conditions and the following disclaimer.
+  * 2. Redistributions in binary form must reproduce the above copyright
+  *    notice, this list of conditions and the following disclaimer in the
+  *    documentation and/or other materials provided with the distribution.
+  * 3. All advertising materials mentioning features or use of this software
+  *    must display the following acknowledgement:
+  *	This product includes software developed by the University of
+  *	California, Berkeley and its contributors.
+  * 4. Neither the name of the University nor the names of its contributors
+  *    may be used to endorse or promote products derived from this software
+  *    without specific prior written permission.
+  *
+  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+  * SUCH DAMAGE.
+  *
+  *	@(#)u9fs_vnops.c	8.16 (Berkeley) 5/27/95
+  * $Id: u9fs_vnops.c,v 1.116.2.3 1999/02/13 08:03:47 dillon Exp $
+  */
+
+
+ /*
+  * vnode op calls for 9FS
+  */
+
+ #include "opt_inet.h"
+
+ #include <sys/param.h>
+ #include <sys/kernel.h>
+ #include <sys/systm.h>
+ #include <sys/resourcevar.h>
+ #include <sys/proc.h>
+ #include <sys/mount.h>
+ #include <sys/buf.h>
+ #include <sys/malloc.h>
+ #include <sys/mbuf.h>
+ #include <sys/namei.h>
+ #include <sys/socket.h>
+ #include <sys/vnode.h>
+ #include <sys/dirent.h>
+ #include <sys/fcntl.h>
+ #include <sys/lockf.h>
+ #include <sys/stat.h>
+ #include <sys/sysctl.h>
+
+ #include <vm/vm.h>
+ #include <vm/vm_extern.h>
+ #include <vm/vm_zone.h>
+ #include <vm/vm_prot.h>
+ #include <vm/vm_page.h>
+ #include <vm/vm_object.h>
+ #include <vm/vm_pager.h>
+ #include <vm/vnode_pager.h>
+
+ #include <net/if.h>
+ #include <netinet/in.h>
+ #include <netinet/in_var.h>
+
+ #include <9fs/bitstring.h>
+ #include <9fs/9p.h>
+ #include <9fs/9auth.h>
+ #include <9fs/9fs.h>
+
+ #define u9fs_poll vop_nopoll
+ static	int	u9fs_lookup __P((struct vop_lookup_args *));
+ static	int	u9fs_create __P((struct vop_create_args *));
+ static	int	u9fs_mknod __P((struct vop_mknod_args *));
+ static	int	u9fs_open __P((struct vop_open_args *));
+ static	int	u9fs_close __P((struct vop_close_args *));
+ static	int	u9fs_access __P((struct vop_access_args *));
+ static	int	u9fs_getattr __P((struct vop_getattr_args *));
+ static	int	u9fs_setattr __P((struct vop_setattr_args *));
+ static	int	u9fs_read __P((struct vop_read_args *));
+ static	int	u9fs_mmap __P((struct vop_mmap_args *));
+ static	int	u9fs_fsync __P((struct vop_fsync_args *));
+ static	int	u9fs_remove __P((struct vop_remove_args *));
+ static	int	u9fs_link __P((struct vop_link_args *));
+ static	int	u9fs_rename __P((struct vop_rename_args *));
+ static	int	u9fs_mkdir __P((struct vop_mkdir_args *));
+ static	int	u9fs_rmdir __P((struct vop_rmdir_args *));
+ static	int	u9fs_symlink __P((struct vop_symlink_args *));
+ static	int	u9fs_readdir __P((struct vop_readdir_args *));
+ static	int	u9fs_bmap __P((struct vop_bmap_args *));
+ static	int	u9fs_strategy __P((struct vop_strategy_args *));
+ static int	u9fs_readlink __P((struct vop_readlink_args *));
+ static int	u9fs_print __P((struct vop_print_args *));
+ static int	u9fs_advlock __P((struct vop_advlock_args *));
+ static int	u9fs_bwrite __P((struct vop_bwrite_args *));
+ static int   u9fs_abortop __P((struct vop_abortop_args *));
+ static int   u9fs_getpages __P((struct vop_getpages_args *));
+ static int   u9fs_putpages __P((struct vop_putpages_args *));
+ static int   u9fs_inactive __P((struct vop_inactive_args *));
+ static int   u9fs_reclaim __P((struct vop_reclaim_args *));
+ static int   u9fs_write __P((struct vop_write_args *));
+
+ /*
+  * Global vfs data structures for u9fs
+  */
+ vop_t **u9fs_vnodeop_p;
+ static struct vnodeopv_entry_desc u9fs_vnodeop_entries[] = {
+ 	{ &vop_default_desc,		(vop_t *) vop_defaultop },
+ 	{ &vop_abortop_desc,		(vop_t *) u9fs_abortop },
+ 	{ &vop_access_desc,		(vop_t *) u9fs_access },
+ 	{ &vop_advlock_desc,		(vop_t *) u9fs_advlock },
+ 	{ &vop_bmap_desc,		(vop_t *) u9fs_bmap },
+ 	{ &vop_bwrite_desc,		(vop_t *) u9fs_bwrite },
+ 	{ &vop_close_desc,		(vop_t *) u9fs_close },
+ 	{ &vop_create_desc,		(vop_t *) u9fs_create },
+ 	{ &vop_fsync_desc,		(vop_t *) u9fs_fsync },
+ 	{ &vop_getattr_desc,		(vop_t *) u9fs_getattr },
+ 	{ &vop_getpages_desc,		(vop_t *) u9fs_getpages },
+ 	{ &vop_putpages_desc,		(vop_t *) u9fs_putpages },
+ 	{ &vop_inactive_desc,		(vop_t *) u9fs_inactive },
+ 	{ &vop_lease_desc,		(vop_t *) vop_null },
+ 	{ &vop_link_desc,		(vop_t *) u9fs_link },
+ 	{ &vop_lock_desc,		(vop_t *) vop_sharedlock },
+ 	{ &vop_lookup_desc,		(vop_t *) u9fs_lookup },
+ 	{ &vop_mkdir_desc,		(vop_t *) u9fs_mkdir },
+ 	{ &vop_mknod_desc,		(vop_t *) u9fs_mknod },
+ 	{ &vop_mmap_desc,		(vop_t *) u9fs_mmap },
+ 	{ &vop_open_desc,		(vop_t *) u9fs_open },
+ 	{ &vop_poll_desc,		(vop_t *) vop_nopoll },
+ 	{ &vop_print_desc,		(vop_t *) u9fs_print },
+ 	{ &vop_read_desc,		(vop_t *) u9fs_read },
+ 	{ &vop_readdir_desc,		(vop_t *) u9fs_readdir },
+ 	{ &vop_readlink_desc,		(vop_t *) u9fs_readlink },
+ 	{ &vop_reclaim_desc,		(vop_t *) u9fs_reclaim },
+ 	{ &vop_remove_desc,		(vop_t *) u9fs_remove },
+ 	{ &vop_rename_desc,		(vop_t *) u9fs_rename },
+ 	{ &vop_rmdir_desc,		(vop_t *) u9fs_rmdir },
+ 	{ &vop_setattr_desc,		(vop_t *) u9fs_setattr },
+ 	{ &vop_strategy_desc,		(vop_t *) u9fs_strategy },
+ 	{ &vop_symlink_desc,		(vop_t *) u9fs_symlink },
+ 	{ &vop_write_desc,		(vop_t *) u9fs_write },
+ 	{ NULL, NULL }
+ };
+ static struct vnodeopv_desc u9fs_vnodeop_opv_desc =
+ 	{ &u9fs_vnodeop_p, u9fs_vnodeop_entries };
+ VNODEOP_SET(u9fs_vnodeop_opv_desc);
+
+ extern vm_zone_t u9fsnode_zone;
+
+ static int u9fs_trunc(struct vnode * vp, struct ucred * cred, struct proc * p);
+ static void u9fs_free_fid __P((u_short fid, struct u9fsmount * nmp, struct proc * p));
+ static void u9fs_updtcache __P((struct u9fsnode *, struct u9fsreq *));
+
+ #define     DIRHDSIZ        (sizeof (struct dirent) - (MAXNAMLEN + 1))
+
+ /* open returns a qid for cache consistent check */
+ static void
+ u9fs_updtcache(struct u9fsnode * np, struct u9fsreq * rep)
+ {
+   if( rep->r_type != Rerror )
+     np->n_dir.dir_qid = rep->r_qid;
+ }
+
+ static int
+ u9fs_trunc(vp, cred, p)
+      register struct vnode * vp;
+      struct ucred * cred;
+      struct proc * p;
+ {
+   struct u9fsnode *np = VTOU9FS(vp);
+   struct u9fsmount * nmp = VFSTOU9FS(vp->v_mount);
+   int error;
+   u_short newfid;
+   struct u9fsreq req, rep;
+   u_char mode;
+
+   /*
+    * Disallow write attempts on filesystems mounted read-only;
+    * unless the file is a socket, fifo, or a block or character
+    * device resident on the filesystem.
+    */
+   if ( (vp->v_mount->mnt_flag & MNT_RDONLY)) {
+     switch (vp->v_type) {
+     case VREG:
+     case VDIR:
+     case VLNK:
+       return (EROFS);
+     default:
+       break;
+     }
+   }
+   mode = U9P_MODE_WR | U9P_MODE_TRUNC;
+   bzero(&req, sizeof(req));
+   req.r_nmp = nmp;
+   req.r_procp = p;
+   newfid = u9fs_id_new(nmp->nm_fids);
+   req.r_type = Tclone;
+   req.r_fid  = np->n_fid;
+   req.r_newfid = newfid;
+   error = u9fs_request(&req, &rep, 1);
+   if( error )
+     return error;
+   req.r_type = Topen;
+   req.r_fid = newfid;
+   req.r_mode = mode;
+   error = u9fs_request(&req, &rep, 1);
+   if( !error )
+     u9fs_vinvalbuf(vp, 0, cred, p, 0);
+   if( error || np->n_wrfid ) {
+     u9fs_free_fid(newfid, nmp, p);
+     return error;
+   }
+
+   if( !U9P_PERM_EXCL(np->n_dir.dir_mode))
+     np->n_wrfid = newfid;
+   else
+     u9fs_free_fid(newfid, nmp, p);
+
+   return (0);
+ }
+
+ /*
+  * u9fs access vnode op.
+  */
+ static int
+ u9fs_access(ap)
+ 	struct vop_access_args /* {
+ 		struct vnode *a_vp;
+ 		int  a_mode;
+ 		struct ucred *a_cred;
+ 		struct proc *a_p;
+ 	} */ *ap;
+ {
+   register struct vnode *vp = ap->a_vp;
+   struct u9fsnode *np = VTOU9FS(vp);
+   struct u9fsmount * nmp = VFSTOU9FS(vp->v_mount);
+   struct proc * p = ap->a_p;
+   int error, a_mode = ap->a_mode;
+   u_short * fidp = 0, *fidp2 = 0, newfid;
+   struct u9fsreq req, rep;
+   u_char mode;
+   struct ucred * cred = ap->a_cred;
+
+   /* XXX: for the moment, only the authenticator has access */
+   if( cred->cr_uid != nmp->nm_authuid )
+     return (EPERM);
+
+   /*
+    * Disallow write attempts on filesystems mounted read-only;
+    * unless the file is a socket, fifo, or a block or character
+    * device resident on the filesystem.
+    */
+   if ((a_mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
+     switch (vp->v_type) {
+     case VREG:
+     case VDIR:
+     case VLNK:
+       return (EROFS);
+     default:
+       break;
+     }
+   }
+
+   /* we cant open an exclusive open file here */
+   if( U9P_PERM_EXCL(np->n_dir.dir_mode) )
+     return 0;
+
+   /* check permission by actually opening it */
+   /* translate mode */
+   mode = 0;
+   if( a_mode & VREAD ) {
+     fidp = &np->n_rdfid;
+     mode = U9P_MODE_RD;
+   }
+   if( a_mode & VWRITE ) {
+     fidp = &np->n_wrfid;
+     mode = U9P_MODE_WR;
+   }
+   if( (a_mode & (VREAD|VWRITE)) == (VREAD|VWRITE) ) {
+     fidp2 = &np->n_rdfid;
+     mode = U9P_MODE_RDWR;
+   }
+
+   if( a_mode & VEXEC ) {
+     fidp = &np->n_rdfid;
+     if( vp->v_type == VREG )
+       mode = U9P_MODE_EX;
+   }
+
+   if( fidp2 == 0 )
+     fidp2 = fidp;
+
+   /* open fid mode */
+   bzero(&req, sizeof(req));
+   req.r_nmp = nmp;
+   req.r_procp = p;
+   newfid = u9fs_id_new(nmp->nm_fids);
+   req.r_type = Tclone;
+   req.r_fid  = np->n_fid;
+   req.r_newfid = newfid;
+   error = u9fs_request(&req, &rep, 1);
+   if( error )
+     return error;
+   req.r_type = Topen;
+   req.r_fid = newfid;
+   req.r_mode = mode;
+   error = u9fs_request(&req, &rep, 1);
+   u9fs_updtcache(np, &rep);
+   if( error || (*fidp && *fidp2 ) ) {
+     u9fs_free_fid(newfid, nmp, p);
+     return error;
+   }
+
+   *fidp = *fidp2 = newfid;
+
+   return (0);
+ }
+
+ /*
+  * u9fs open vnode op
+  * Check to see if the type is ok
+  * and that deletion is not in progress.
+  * For paged in text files, you will need to flush the page cache
+  * if consistency is lost.
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_open(ap)
+ 	struct vop_open_args /* {
+ 		struct vnode *a_vp;
+ 		int  a_mode;
+ 		struct ucred *a_cred;
+ 		struct proc *a_p;
+ 	} */ *ap;
+ {
+   register struct vnode *vp = ap->a_vp;
+   struct u9fsnode *np = VTOU9FS(vp);
+   int error=0, a_mode = ap->a_mode;
+   u_short * fidp = 0, *fidp2 = 0, newfid;
+   struct u9fsmount * nmp = VFSTOU9FS(vp->v_mount);
+   struct proc * p = ap->a_p;
+   struct u9fsreq req, rep;
+   u_char mode;
+   struct ucred * cred = ap->a_cred;
+
+   /* assume access permissions have been checked via VOP_ACCESS */
+   /* the file is actually opened except the rdwr case */
+
+   if( a_mode & (O_EXCL|O_SHLOCK|O_EXLOCK) ) {
+ #if 0  /* XXX: what can we do here? */
+     return (EOPNOTSUPP);
+ #endif
+   }
+
+   /* translate mode */
+   mode = 0;
+   if( a_mode & FREAD ) {
+     fidp = &np->n_rdfid;
+     mode = U9P_MODE_RD;
+   }
+   if( a_mode & FWRITE ) {
+     fidp = &np->n_wrfid;
+     mode = U9P_MODE_WR;
+   }
+   if( (a_mode & (FREAD|FWRITE)) == (FREAD|FWRITE) ) {
+     fidp2 = & np->n_rdfid;
+     mode = U9P_MODE_RDWR;
+   }
+   if( fidp2 == 0)
+     fidp2 = fidp;
+
+   if( U9P_PERM_EXCL(np->n_dir.dir_mode) ) {
+     if( *fidp || *fidp2 )
+       return ENOLCK;
+
+     /* open fid mode */
+     bzero(&req, sizeof(req));
+     req.r_nmp = nmp;
+     req.r_procp = p;
+     newfid = u9fs_id_new(nmp->nm_fids);
+     req.r_type = Tclone;
+     req.r_fid  = np->n_fid;
+     req.r_newfid = newfid;
+     error = u9fs_request(&req, &rep, 1);
+     if( error )
+       return error;
+     req.r_type = Topen;
+     req.r_fid = newfid;
+     req.r_mode = mode;
+     error = u9fs_request(&req, &rep, 1);
+     if( error ) {
+       u9fs_free_fid(newfid, nmp, p);
+       return error;
+     }
+     u9fs_updtcache(np, &rep);
+
+     *fidp = *fidp2 = newfid;
+   }
+
+   if( *fidp == 0 )
+     panic("open");
+
+   if( *fidp2 == 0 ) {
+     /* open fid mode */
+     bzero(&req, sizeof(req));
+     req.r_nmp = nmp;
+     req.r_procp = p;
+     newfid = u9fs_id_new(nmp->nm_fids);
+     req.r_type = Tclone;
+     req.r_fid  = np->n_fid;
+     req.r_newfid = newfid;
+     error = u9fs_request(&req, &rep, 1);
+     if( error )
+       return error;
+     req.r_type = Topen;
+     req.r_fid = newfid;
+     req.r_mode = mode;
+     error = u9fs_request(&req, &rep, 1);
+     if( error ) {
+       u9fs_free_fid(newfid, nmp, p);
+       return error;
+     }
+     u9fs_updtcache(np, &rep);
+     *fidp2 = newfid;
+   }
+
+   if( np->n_qid.vers != np->n_dir.dir_qid.vers ) /* content changed */
+     u9fs_vinvalbuf(vp, 0, cred, p, 0);
+
+   return 0;
+ }
+
+ /*
+  * u9fs close vnode op
+  * What an U9FS client should do upon close after writing is a debatable issue.
+  * Most U9FS clients push delayed writes to the server upon close, basically for
+  * two reasons:
+  * 1 - So that any write errors may be reported back to the client process
+  *     doing the close system call. By far the two most likely errors are
+  *     U9FSERR_NOSPC and U9FSERR_DQUOT to indicate space allocation failure.
+  * 2 - To put a worst case upper bound on cache inconsistency between
+  *     multiple clients for the file.
+  * There is also a consistency problem for Version 2 of the protocol w.r.t.
+  * not being able to tell if other clients are writing a file concurrently,
+  * since there is no way of knowing if the changed modify time in the reply
+  * is only due to the write for this client.
+  * (U9FS Version 3 provides weak cache consistency data in the reply that
+  *  should be sufficient to detect and handle this case.)
+  *
+  * The current code does the following:
+  * for U9FS Version 2 - play it safe and flush/invalidate all dirty buffers
+  * for U9FS Version 3 - flush dirty buffers to the server but don't invalidate
+  *                     or commit them (this satisfies 1 and 2 except for the
+  *                     case where the server crashes after this close but
+  *                     before the commit RPC, which is felt to be "good
+  *                     enough". Changing the last argument to u9fs_flush() to
+  *                     a 1 would force a commit operation, if it is felt a
+  *                     commit is necessary now.
+  * for NQU9FS         - do nothing now, since 2 is dealt with via leases and
+  *                     1 should be dealt with via an fsync() system call for
+  *                     cases where write errors are important.
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_close(ap)
+ 	struct vop_close_args /* {
+ 		struct vnodeop_desc *a_desc;
+ 		struct vnode *a_vp;
+ 		int  a_fflag;
+ 		struct ucred *a_cred;
+ 		struct proc *a_p;
+ 	} */ *ap;
+ {
+   int fflag = ap->a_fflag;
+   struct vnode * vp = ap->a_vp;
+   struct u9fsnode * np = VTOU9FS(vp);
+   struct u9fsmount * nmp = VFSTOU9FS(vp->v_mount);
+   struct proc * p = ap->a_p;
+
+   if( U9P_PERM_EXCL(np->n_dir.dir_mode) ) {
+     if( (fflag & FREAD) ) {
+       u9fs_free_fid(np->n_rdfid, nmp, p);
+       np->n_rdfid = 0;
+     }
+
+     if( (fflag & FWRITE) == FWRITE ) {
+       u9fs_free_fid(np->n_wrfid, nmp, p);
+       np->n_wrfid = 0;
+     }
+
+     if( (fflag & (FREAD|FWRITE)) == (FREAD|FWRITE) )
+       np->n_wrfid = 0;
+   }
+
+   return 0;
+ }
+
+ /*
+  * u9fs getattr call from vfs.
+  */
+ static int
+ u9fs_getattr(ap)
+ 	struct vop_getattr_args /* {
+ 		struct vnode *a_vp;
+ 		struct vattr *a_vap;
+ 		struct ucred *a_cred;
+ 		struct proc *a_p;
+ 	} */ *ap;
+ {
+   register struct vnode *vp = ap->a_vp;
+   register struct u9fsnode *np = VTOU9FS(vp);
+   int error = 0;
+   struct u9fsreq req, rep;
+   struct u9fsmount * nmp = VFSTOU9FS(vp->v_mount);
+   struct u9fsdir * dir;
+   struct vattr * vap = ap->a_vap;
+
+   /*
+    * Update local times for special files.
+    */
+   if (np->n_flag & (NACC | NUPD))
+     np->n_flag |= NCHG;
+ #if 0
+   /*
+    * First look in the cache.
+    */
+   if (u9fs_getattrcache(vp, ap->a_vap) == 0)
+     return (0);
+ #endif
+   if( np->n_fid == 0 )
+     panic("u9fs_getattr");
+
+   /* stat fid */
+   bzero(&req, sizeof(req));
+   req.r_nmp = nmp;
+   req.r_procp = ap->a_p;
+   req.r_type = Tstat;
+   req.r_fid = np->n_fid;
+   error = u9fs_request(& req, & rep, 1);
+   if( error )
+     return error;
+
+   /* fill in vattr */
+   dir = & np->n_dir;
+   u9p_m2d(rep.r_stat, dir);
+
+   bzero(vap, sizeof(*vap));
+   /* the plan9 file system has no other types. */
+   /* XXX: we have not delt with devices yet */
+   if( U9P_PERM_CHDIR(dir->dir_mode) )
+     vap->va_type = VDIR;
+   else
+     vap->va_type = VREG;
+
+   vap->va_mode  = U9P_PERM_ALL(dir->dir_mode);
+   vap->va_nlink = 1;
+   vap->va_uid = u9fs_name2uid(dir->dir_uid);
+   vap->va_gid = u9fs_name2uid(dir->dir_gid);
+   vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
+   vap->va_fileid = dir->dir_qid.path;
+   vap->va_size = np->n_size = dir->dir_length;
+   vap->va_blocksize = PAGE_SIZE;
+   vap->va_atime.tv_sec = dir->dir_atime;
+   vap->va_atime.tv_nsec = 0;
+   vap->va_mtime.tv_sec = dir->dir_mtime;
+   vap->va_mtime.tv_nsec = 0;
+   vap->va_ctime.tv_sec = dir->dir_mtime;
+   vap->va_ctime.tv_nsec = dir->dir_mtime;
+   vap->va_gen = VNOVAL;
+   vap->va_flags = 0;
+   vap->va_bytes = vap->va_size;
+   vap->va_filerev = dir->dir_qid.vers;
+
+   vp->v_type = vap->va_type;
+   vp->v_tag = VT_U9FS;
+
+   return (error);
+ }
+
+ /*
+  * u9fs setattr call.
+  */
+ static int
+ u9fs_setattr(ap)
+ 	struct vop_setattr_args /* {
+ 		struct vnodeop_desc *a_desc;
+ 		struct vnode *a_vp;
+ 		struct vattr *a_vap;
+ 		struct ucred *a_cred;
+ 		struct proc *a_p;
+ 	} */ *ap;
+ {
+   register struct vnode *vp = ap->a_vp;
+   register struct u9fsnode *np = VTOU9FS(vp);
+   register struct vattr *vap = ap->a_vap;
+   int error = 0;
+   struct u9fsmount * nmp = VFSTOU9FS(vp->v_mount);
+   struct u9fsdir dir;
+   struct u9fsuser * u9p;
+   struct vattr attr;
+   struct u9fsreq req, rep;
+
+   if( vp->v_mount->mnt_flag & MNT_RDONLY )
+     return (EROFS);
+
+   if( vap->va_nlink != VNOVAL || vap->va_uid != VNOVAL ||
+       vap->va_fsid != VNOVAL || vap->va_fileid != VNOVAL ||
+ #if 0
+       vap->va_size != VNOVAL || vap->va_blocksize != VNOVAL ||
+ #endif
+       vap->va_atime.tv_sec != VNOVAL || vap->va_ctime.tv_sec != VNOVAL ||
+       vap->va_gen != VNOVAL ||
+       vap->va_flags != VNOVAL || vap->va_bytes != VNOVAL ) {
+ #if 0
+     printf("%d %d %d %d %d %d %d %d %d %d %d\n", vap->va_nlink, vap->va_uid, vap->va_fsid,
+ 	       vap->va_fileid, vap->va_size, vap->va_blocksize,
+ 	       vap->va_atime.tv_sec, vap->va_ctime.tv_sec, vap->va_gen,
+ 	       vap->va_flags, vap->va_bytes);
+     printf("unsupported setattr\n");
+     /* touch tries to change ctime first.
+      * if fails, it touches the first byte
+     */
+ #endif
+     return (EOPNOTSUPP);
+   }
+
+   if( vap->va_size == 0 )
+     u9fs_trunc(vp, ap->a_cred, ap->a_p);
+
+   bcopy(&np->n_dir, &dir, sizeof(dir));
+   if( vap->va_mode  != (mode_t)VNOVAL ) {
+     dir.dir_mode = U9P_PERM_NONPERM(dir.dir_mode)|U9P_PERM_ALL(vap->va_mode);
+   }
+   if( vap->va_gid != VNOVAL ) {
+     if( (u9p = u9fs_finduser(vap->va_gid)) == 0 )
+       return (EINVAL);
+     strncpy(u9p->u_name, dir.dir_gid, U9FS_NAMELEN);
+   }
+   if( vap->va_mtime.tv_sec != VNOVAL ) {
+     dir.dir_mtime = vap->va_mtime.tv_sec;
+   }
+
+   /* stat fid */
+   bzero(&req, sizeof(req));
+   req.r_nmp = nmp;
+   req.r_procp = ap->a_p;
+   req.r_type = Twstat;
+   req.r_fid = np->n_fid;
+   u9p_d2m(&dir, req.r_stat);
+   error = u9fs_request(& req, & rep, 1);
+   if( error )
+     return error;
+   VOP_GETATTR(vp, &attr, ap->a_cred, ap->a_p);
+
+   return 0;
+ }
+
+ /*
+  * u9fs lookup call, one step at a time...
+  * First look in cache
+  * If not found, unlock the directory u9fsnode and do the rpc
+  */
+ static int
+ u9fs_lookup(ap)
+ 	struct vop_lookup_args /* {
+ 		struct vnodeop_desc *a_desc;
+ 		struct vnode *a_dvp;
+ 		struct vnode **a_vpp;
+ 		struct componentname *a_cnp;
+ 	} */ *ap;
+ {
+ 	struct componentname *cnp = ap->a_cnp;
+ 	struct vnode *dvp = ap->a_dvp;
+ 	struct vnode **vpp = ap->a_vpp;
+ 	int flags = cnp->cn_flags;
+ 	struct vnode *newvp;
+ 	struct u9fsmount *nmp;
+ 	long len;
+ 	u9fsfh_t fh;
+ 	struct u9fsnode *np;
+ 	int lockparent, wantparent, error = 0;
+ 	struct proc *p = cnp->cn_proc;
+ 	struct u9fsreq req, rep;
+ 	u_short newfid;
+ 	struct vattr attrs;
+
+ 	*vpp = NULLVP;
+ 	if ((flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
+ 	    (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
+ 		return (EROFS);
+ 	if (dvp->v_type != VDIR)
+ 		return (ENOTDIR);
+ 	lockparent = flags & LOCKPARENT;
+ 	wantparent = flags & (LOCKPARENT|WANTPARENT);
+ 	nmp = VFSTOU9FS(dvp->v_mount);
+ 	np = VTOU9FS(dvp);
+ #if 0
+ 	if ((error = cache_lookup(dvp, vpp, cnp)) && error != ENOENT) {
+ 		struct vattr vattr;
+ 		int vpid;
+
+ 		if (error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, p)) {
+ 			*vpp = NULLVP;
+ 			return (error);
+ 		}
+
+ 		newvp = *vpp;
+ 		vpid = newvp->v_id;
+ 		/*
+ 		 * See the comment starting `Step through' in ufs/ufs_lookup.c
+ 		 * for an explanation of the locking protocol
+ 		 */
+ 		if (dvp == newvp) {
+ 			VREF(newvp);
+ 			error = 0;
+ 		} else if (flags & ISDOTDOT) {
+ 			VOP_UNLOCK(dvp, 0, p);
+ 			error = vget(newvp, LK_EXCLUSIVE, p);
+ 			if (!error && lockparent && (flags & ISLASTCN))
+ 				error = vn_lock(dvp, LK_EXCLUSIVE, p);
+ 		} else {
+ 			error = vget(newvp, LK_EXCLUSIVE, p);
+ 			if (!lockparent || error || !(flags & ISLASTCN))
+ 				VOP_UNLOCK(dvp, 0, p);
+ 		}
+ 		if (!error) {
+ 			if (vpid == newvp->v_id) {
+ 			   if (!VOP_GETATTR(newvp, &vattr, cnp->cn_cred, p)
+ 			    && vattr.va_ctime.tv_sec == VTOU9FS(newvp)->n_ctime) {
+ 				u9fsstats.lookupcache_hits++;
+ 				if (cnp->cn_nameiop != LOOKUP &&
+ 				    (flags & ISLASTCN))
+ 					cnp->cn_flags |= SAVENAME;
+ 				return (0);
+ 			   }
+ 			   cache_purge(newvp);
+ 			}
+ 			vput(newvp);
+ 			if (lockparent && dvp != newvp && (flags & ISLASTCN))
+ 				VOP_UNLOCK(dvp, 0, p);
+ 		}
+ 		error = vn_lock(dvp, LK_EXCLUSIVE, p);
+ 		*vpp = NULLVP;
+ 		if (error)
+ 			return (error);
+ 	}
+ #endif
+ 	error = 0;
+ 	newvp = NULLVP;
+ 	len = cnp->cn_namelen;
+
+ 	/* Tclwalk tag fid newfid name */
+ 	bzero(&req, sizeof(req));
+ 	req.r_procp = p;
+ 	req.r_nmp = nmp;
+ 	req.r_type = Tclwalk;
+ 	req.r_fid = np->n_fid;
+ 	newfid = req.r_newfid = u9fs_id_new(nmp->nm_fids);
+ 	bcopy(cnp->cn_nameptr, req.r_name, len);
+ 	if( (error = u9fs_request(&req, &rep, 1)) ) {
+ 	  u9fs_id_free(nmp->nm_fids, newfid);
+ 	  return error;
+ 	}
+
+ 	fh = rep.r_qid.path;
+ 	if( fh == 0 ) {
+ 	  u9fs_id_free(nmp->nm_fids, newfid);
+ 	  error = ENOENT;
+ 	  goto lastcheck;
+ 	}
+
+ 	/*
+ 	 * Handle RENAME case...
+ 	 */
+ 	if (cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN)) {
+ #if 0
+ 	  /* XXX: I dont understand this. rename foo foo? */
+ 		if (U9FS_CMPFH(np, fhp, fhsize)) {
+ 			m_freem(mrep);
+ 			return (EISDIR);
+ 		}
+ #endif
+ 		error = u9fs_nget(dvp->v_mount, fh, &np, p);
+ 		if (error)
+ 		  goto fail;
+
+ 		if ( np->n_fid )
+ 		  u9fs_free_fid(newfid, nmp, p);
+ 		else
+ 		  np->n_fid = newfid;
+
+ 		newvp = U9FSTOV(np);
+ 		*vpp = newvp;
+ 		cnp->cn_flags |= SAVENAME;
+ 		if (!lockparent)
+ 			VOP_UNLOCK(dvp, 0, p);
+ 		return (0);
+ 	}
+
+ 	if (flags & ISDOTDOT) {
+ 		VOP_UNLOCK(dvp, 0, p);
+ 		error = u9fs_nget(dvp->v_mount, fh, &np, p);
+ 		if (error) {
+ 			vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, p);
+ 			goto fail;
+ 		}
+ 		if( np->n_fid )
+ 		  u9fs_free_fid(newfid, nmp, p);
+ 		else
+ 		  np->n_fid = req.r_newfid;
+
+ 		newvp = U9FSTOV(np);
+ 		if (lockparent && (flags & ISLASTCN) &&
+ 		    (error = vn_lock(dvp, LK_EXCLUSIVE, p))) {
+ 		    	vput(newvp);
+ 			return (error);
+ 		}
+ 	} else if (np->n_qid.path == fh) {
+ 	        u9fs_free_fid(newfid, nmp, p);
+ 		VREF(dvp);
+ 		newvp = dvp;
+ 	} else {
+ 		error = u9fs_nget(dvp->v_mount, fh, &np, p);
+ 		if (error)
+ 		  goto fail;
+
+ 		if( np->n_fid )
+ 		  u9fs_free_fid(newfid, nmp, p);
+ 		else
+ 		  np->n_fid = req.r_newfid;
+
+ 		if (!lockparent || !(flags & ISLASTCN))
+ 			VOP_UNLOCK(dvp, 0, p);
+ 		newvp = U9FSTOV(np);
+
+ 		VOP_GETATTR(newvp, & attrs, p->p_ucred, p);
+ 	}
+
+ 	if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
+ 		cnp->cn_flags |= SAVENAME;
+ #if 0
+ 	if ((cnp->cn_flags & MAKEENTRY) &&
+ 	    (cnp->cn_nameiop != DELETE || !(flags & ISLASTCN))) {
+ 		np->n_ctime = np->n_vattr.va_ctime.tv_sec;
+ 		cache_enter(dvp, newvp, cnp);
+ 	}
+ #endif
+ 	*vpp = newvp;
+  lastcheck:
+ 	if (error) {
+ 		if (newvp != NULLVP) {
+ 			vrele(newvp);
+ 			*vpp = NULLVP;
+ 		}
+ 		if ((cnp->cn_nameiop == CREATE || cnp->cn_nameiop == RENAME) &&
+ 		    (flags & ISLASTCN) && error == ENOENT) {
+ 			if (!lockparent)
+ 				VOP_UNLOCK(dvp, 0, p);
+ 			if (dvp->v_mount->mnt_flag & MNT_RDONLY)
+ 				error = EROFS;
+ 			else
+ 				error = EJUSTRETURN;
+ 		}
+ 		if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
+ 			cnp->cn_flags |= SAVENAME;
+ 	}
+ 	return (error);
+
+  fail:
+ 	u9fs_free_fid(newfid, nmp, p);
+ 	return (error);
+ }
+
+ /*
+  * u9fs read call.
+  * Just call u9fs_bioread() to do the work.
+  */
+ static int
+ u9fs_read(ap)
+ 	struct vop_read_args /* {
+ 		struct vnode *a_vp;
+ 		struct uio *a_uio;
+ 		int  a_ioflag;
+ 		struct ucred *a_cred;
+ 	} */ *ap;
+ {
+   register struct vnode *vp = ap->a_vp;
+
+   if (vp->v_type != VREG)
+     return (EPERM);
+   return (u9fs_bioread(vp, ap->a_uio, ap->a_ioflag, ap->a_cred, 0));
+ }
+
+ /*
+  * u9fs readlink call
+  */
+ static int
+ u9fs_readlink(ap)
+ 	struct vop_readlink_args /* {
+ 		struct vnode *a_vp;
+ 		struct uio *a_uio;
+ 		struct ucred *a_cred;
+ 	} */ *ap;
+ {
+   return (EOPNOTSUPP);
+ }
+
+ /*
+  * u9fs mknod vop
+  * just call u9fs_mknodrpc() to do the work.
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_mknod(ap)
+ 	struct vop_mknod_args /* {
+ 		struct vnode *a_dvp;
+ 		struct vnode **a_vpp;
+ 		struct componentname *a_cnp;
+ 		struct vattr *a_vap;
+ 	} */ *ap;
+ {
+   return (EOPNOTSUPP);
+ }
+
+ /*
+  * u9fs file create call
+  */
+ static int
+ u9fs_create(ap)
+ 	struct vop_create_args /* {
+ 		struct vnode *a_dvp;
+ 		struct vnode **a_vpp;
+ 		struct componentname *a_cnp;
+ 		struct vattr *a_vap;
+ 	} */ *ap;
+ {
+ 	register struct vnode *dvp = ap->a_dvp;
+ 	register struct vattr *vap = ap->a_vap;
+ 	register struct componentname *cnp = ap->a_cnp;
+ 	struct u9fsnode *np = (struct u9fsnode *)0;
+ 	struct vnode *newvp = (struct vnode *)0;
+ 	int error = 0, len;
+ 	struct vattr vattr;
+ 	struct u9fsreq req, rep;
+ 	struct u9fsmount *nmp;
+ 	u9fsfh_t fh;
+ 	struct proc * p;
+ 	int pfid;
+
+ #if 0
+ 	/*
+ 	 * Oops, not for me..
+ 	 */
+ 	if (vap->va_type == VSOCK)
+ 		return (u9fs_mknodrpc(dvp, ap->a_vpp, cnp, vap));
+ #endif
+
+ 	if (error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_proc)) {
+ 		VOP_ABORTOP(dvp, cnp);
+ 		return (error);
+ 	}
+
+ 	nmp = VFSTOU9FS(dvp->v_mount);
+ 	np = VTOU9FS(dvp);
+ 	p = cnp->cn_proc;
+
+ 	bzero(&req, sizeof(req));
+ 	req.r_nmp = nmp;
+ 	req.r_procp = p;
+
+ 	req.r_type = Tclone;
+ 	pfid = req.r_fid  = np->n_fid;
+ 	req.r_newfid = u9fs_id_new(nmp->nm_fids);
+ 	error = u9fs_request(&req, &rep, 1);
+ 	if( error )
+ 	  return error;
+
+ 	req.r_type = Tcreate;
+ 	req.r_fid = req.r_newfid;
+ 	len = cnp->cn_namelen;
+ 	if( len > U9FS_NAMELEN )
+ 	  len = U9FS_NAMELEN;
+ 	strncpy(req.r_name, cnp->cn_nameptr, len);
+ 	req.r_name[U9FS_NAMELEN] = 0;
+ 	req.r_perm = U9P_PERM_ALL(vap->va_mode);
+ 	if( vap->va_type == VDIR ) {
+ 	  req.r_perm |= 0x80000000;
+ 	  req.r_mode = U9P_MODE_RD;
+ 	} else
+ 	  req.r_mode = U9P_MODE_WR | U9P_MODE_TRUNC;
+ 	if(vap->va_vaflags & VA_EXCLUSIVE)
+ 	  req.r_mode = U9P_MODE_EX;
+
+ 	error = u9fs_request(&req, &rep, 1);
+ 	if( error )
+ 	  return error;
+
+ 	fh = rep.r_qid.path;
+ 	u9fs_nget(dvp->v_mount, fh, &np, p);
+ 	newvp = U9FSTOV(np);
+ 	if( vap->va_type == VDIR )
+ 	  np->n_rdfid = req.r_fid;
+ 	else
+ 	  np->n_wrfid = req.r_fid;
+
+ 	req.r_type = Tclwalk;
+ 	req.r_fid  = pfid;
+ 	req.r_newfid = u9fs_id_new(nmp->nm_fids);
+ 	/* r_name is already filled */
+ 	error = u9fs_request(&req, &rep, 1);
+ 	if( error )
+ 	  return error;
+ 	np->n_fid = req.r_newfid;
+ 	VOP_GETATTR(newvp, & vattr, p->p_ucred, p);
+
+ 	*ap->a_vpp = newvp;
+ 	zfree(namei_zone, cnp->cn_pnbuf);
+
+ 	return 0;
+ }
+
+ /*
+  * u9fs file remove call
+  * To try and make u9fs semantics closer to ufs semantics, a file that has
+  * other processes using the vnode is renamed instead of removed and then
+  * removed later on the last close.
+  * - If v_usecount > 1
+  *	  If a rename is not already in the works
+  *	     call u9fs_sillyrename() to set it up
+  *     else
+  *	  do the remove rpc
+  */
+ static int
+ u9fs_remove(ap)
+ 	struct vop_remove_args /* {
+ 		struct vnodeop_desc *a_desc;
+ 		struct vnode * a_dvp;
+ 		struct vnode * a_vp;
+ 		struct componentname * a_cnp;
+ 	} */ *ap;
+ {
+ 	register struct vnode *vp = ap->a_vp;
+ 	register struct componentname *cnp = ap->a_cnp;
+ 	struct u9fsnode *np;
+ 	struct u9fsreq req, rep;
+ 	struct u9fsmount *nmp;
+ 	struct proc * p;
+ 	int error;
+
+ 	nmp = VFSTOU9FS(vp->v_mount);
+ 	np = VTOU9FS(vp);
+ 	p = cnp->cn_proc;
+ 	bzero(&req, sizeof(req));
+ 	req.r_nmp = nmp;
+ 	req.r_procp = p;
+ 	req.r_type = Tremove;
+ 	req.r_fid = np->n_fid;
+ 	error = u9fs_request(&req, &rep, 1);
+ 	if( error )
+ 	  return error;
+ 	zfree(namei_zone, cnp->cn_pnbuf);
+ 	return 0;
+ }
+
+ /*
+  * u9fs file rename call
+  */
+ static int
+ u9fs_rename(ap)
+ 	struct vop_rename_args  /* {
+ 		struct vnode *a_fdvp;
+ 		struct vnode *a_fvp;
+ 		struct componentname *a_fcnp;
+ 		struct vnode *a_tdvp;
+ 		struct vnode *a_tvp;
+ 		struct componentname *a_tcnp;
+ 	} */ *ap;
+ {
+ 	register struct vnode *fvp = ap->a_fvp;
+ 	register struct vnode *tvp = ap->a_tvp;
+ 	register struct vnode *fdvp = ap->a_fdvp;
+ 	register struct vnode *tdvp = ap->a_tdvp;
+ 	register struct componentname *tcnp = ap->a_tcnp;
+ 	register struct componentname *fcnp = ap->a_fcnp;
+ 	int error, len;
+ 	struct u9fsmount * nmp;
+ 	struct u9fsreq req, rep;
+ 	struct u9fsdir dir;
+ 	struct u9fsnode * np;
+
+ 	/* we cant do cross-directory renaming or move to an existing file */
+ 	if( fdvp != tdvp || tvp != 0 || fvp->v_mount->mnt_flag & MNT_RDONLY ){
+ 	  printf("rename to existing file not supported\n");
+ 	  error = EOPNOTSUPP;
+ 	  goto out;
+ 	}
+
+ 	nmp = VFSTOU9FS(fvp->v_mount);
+ 	np = VTOU9FS(fvp);
+
+ 	bcopy(&np->n_dir, &dir, sizeof(dir));
+ 	len = tcnp->cn_namelen;
+ 	if( len > U9FS_NAMELEN )
+ 	  len = U9FS_NAMELEN;
+ 	strncpy(dir.dir_name, tcnp->cn_nameptr, len);
+ 	dir.dir_name[U9FS_NAMELEN-1] = 0;
+
+ 	/* stat fid */
+ 	bzero(&req, sizeof(req));
+ 	req.r_nmp = nmp;
+ 	req.r_procp = fcnp->cn_proc;
+ 	req.r_type = Twstat;
+ 	req.r_fid = np->n_fid;
+ 	u9p_d2m(&dir, req.r_stat);
+ 	error = u9fs_request(& req, & rep, 1);
+
+  out:
+ 	if (tdvp == tvp)
+ 		vrele(tdvp);
+ 	else
+ 		vput(tdvp);
+ 	if (tvp)
+ 		vput(tvp);
+ 	vrele(fdvp);
+ 	vrele(fvp);
+
+ 	return error;
+ }
+
+ /*
+  * u9fs hard link create call
+  */
+ static int
+ u9fs_link(ap)
+ 	struct vop_link_args /* {
+ 		struct vnode *a_tdvp;
+ 		struct vnode *a_vp;
+ 		struct componentname *a_cnp;
+ 	} */ *ap;
+ {
+   return (EOPNOTSUPP);
+ }
+
+ /*
+  * u9fs symbolic link create call
+  */
+ static int
+ u9fs_symlink(ap)
+ 	struct vop_symlink_args /* {
+ 		struct vnode *a_dvp;
+ 		struct vnode **a_vpp;
+ 		struct componentname *a_cnp;
+ 		struct vattr *a_vap;
+ 		char *a_target;
+ 	} */ *ap;
+ {
+   return (EOPNOTSUPP);
+ }
+
+ /*
+  * u9fs make dir call
+  */
+ static int
+ u9fs_mkdir(ap)
+ 	struct vop_mkdir_args /* {
+ 		struct vnode *a_dvp;
+ 		struct vnode **a_vpp;
+ 		struct componentname *a_cnp;
+ 		struct vattr *a_vap;
+ 	} */ *ap;
+ {
+   struct vop_create_args cap;
+
+   cap.a_dvp = ap->a_dvp;
+   cap.a_vpp = ap->a_vpp;
+   cap.a_cnp = ap->a_cnp;
+   cap.a_vap = ap->a_vap;
+   return u9fs_create(&cap);
+ }
+
+ /*
+  * u9fs remove directory call
+  */
+ static int
+ u9fs_rmdir(ap)
+ 	struct vop_rmdir_args /* {
+ 		struct vnode *a_dvp;
+ 		struct vnode *a_vp;
+ 		struct componentname *a_cnp;
+ 	} */ *ap;
+ {
+ 	register struct vnode *vp = ap->a_vp;
+ 	register struct componentname *cnp = ap->a_cnp;
+ 	struct u9fsnode *np;
+ 	struct u9fsreq req, rep;
+ 	struct u9fsmount *nmp;
+ 	struct proc * p;
+ 	int error;
+
+ 	nmp = VFSTOU9FS(vp->v_mount);
+ 	np = VTOU9FS(vp);
+ 	p = cnp->cn_proc;
+ 	bzero(&req, sizeof(req));
+ 	req.r_nmp = nmp;
+ 	req.r_procp = p;
+ 	req.r_type = Tremove;
+ 	req.r_fid = np->n_fid;
+ 	error = u9fs_request(&req, &rep, 1);
+ 	if( error )
+ 	  return error;
+ 	u9fs_id_free(nmp->nm_fids, np->n_fid);
+ 	np->n_fid = 0;
+ 	zfree(namei_zone, cnp->cn_pnbuf);
+ 	return 0;
+ }
+
+ /*
+  * u9fs readdir call
+  */
+ static int
+ u9fs_readdir(ap)
+ 	struct vop_readdir_args /* {
+ 		struct vnode *a_vp;
+ 		struct uio *a_uio;
+ 		struct ucred *a_cred;
+ 	} */ *ap;
+ {
+   register struct vnode *vp = ap->a_vp;
+   register struct uio *uio = ap->a_uio;
+   int error;
+
+   if (vp->v_type != VDIR)
+     return (EPERM);
+
+   /*
+    * Call u9fs_bioread() to do the real work.
+    */
+   error = u9fs_bioread(vp, uio, 0, ap->a_cred, 0);
+
+   return (error);
+ }
+
+ /*
+  * Kludge City..
+  * - make u9fs_bmap() essentially a no-op that does no translation
+  * - do u9fs_strategy() by doing I/O with u9fs_readrpc/u9fs_writerpc
+  *   (Maybe I could use the process's page mapping, but I was concerned that
+  *    Kernel Write might not be enabled and also figured copyout() would do
+  *    a lot more work than bcopy() and also it currently happens in the
+  *    context of the swapper process (2).
+  */
+ static int
+ u9fs_bmap(ap)
+ 	struct vop_bmap_args /* {
+ 		struct vnode *a_vp;
+ 		daddr_t  a_bn;
+ 		struct vnode **a_vpp;
+ 		daddr_t *a_bnp;
+ 		int *a_runp;
+ 		int *a_runb;
+ 	} */ *ap;
+ {
+   register struct vnode *vp = ap->a_vp;
+
+   if (ap->a_vpp != NULL)
+     *ap->a_vpp = vp;
+   if (ap->a_bnp != NULL)
+     *ap->a_bnp = ap->a_bn * btodb(vp->v_mount->mnt_stat.f_iosize);
+   if (ap->a_runp != NULL)
+     *ap->a_runp = 0;
+   if (ap->a_runb != NULL)
+     *ap->a_runb = 0;
+   return (0);
+
+   return 0;
+ }
+
+ /*
+  * Strategy routine.
+  * For async requests when u9fsiod(s) are running, queue the request by
+  * calling u9fs_asyncio(), otherwise just all u9fs_doio() to do the
+  * request.
+  */
+ static int
+ u9fs_strategy(ap)
+ 	struct vop_strategy_args *ap;
+ {
+ 	register struct buf *bp = ap->a_bp;
+ 	struct ucred *cr;
+ 	struct proc *p;
+ 	int error = 0;
+
+ 	if (bp->b_flags & B_PHYS)
+ 		panic("nfs physio");
+ 	if (bp->b_flags & B_ASYNC)
+ 	        panic("u9fs async");
+
+ 	p = curproc;	/* XXX */
+ 	if (bp->b_flags & B_READ)
+ 		cr = bp->b_rcred;
+ 	else
+ 		cr = bp->b_wcred;
+ 	error = u9fs_doio(bp, cr, p);
+ 	return (error);
+ }
+
+ /*
+  * Mmap a file
+  *
+  * NB Currently unsupported.
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_mmap(ap)
+ 	struct vop_mmap_args /* {
+ 		struct vnode *a_vp;
+ 		int  a_fflags;
+ 		struct ucred *a_cred;
+ 		struct proc *a_p;
+ 	} */ *ap;
+ {
+ 	return (EINVAL);
+ }
+
+ /*
+  * fsync vnode op. Just call u9fs_flush() with commit == 1.
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_fsync(ap)
+ 	struct vop_fsync_args /* {
+ 		struct vnodeop_desc *a_desc;
+ 		struct vnode * a_vp;
+ 		struct ucred * a_cred;
+ 		int  a_waitfor;
+ 		struct proc * a_p;
+ 	} */ *ap;
+ {
+   /* we have a blocking writeback cache */
+   return 0;
+ }
+
+ /*
+  * U9FS advisory byte-level locks.
+  * Currently unsupported.
+  */
+ static int
+ u9fs_advlock(ap)
+ 	struct vop_advlock_args /* {
+ 		struct vnode *a_vp;
+ 		caddr_t  a_id;
+ 		int  a_op;
+ 		struct flock *a_fl;
+ 		int  a_flags;
+ 	} */ *ap;
+ {
+ 	register struct u9fsnode *np = VTOU9FS(ap->a_vp);
+
+ 	/*
+ 	 * The following kludge is to allow diskless support to work
+ 	 * until a real NFS lockd is implemented. Basically, just pretend
+ 	 * that this is a local lock.
+ 	 */
+ 	return (lf_advlock(ap, &(np->n_lockf), np->n_size));
+ }
+
+ /*
+  * Print out the contents of an u9fsnode.
+  */
+ static int
+ u9fs_print(ap)
+ 	struct vop_print_args /* {
+ 		struct vnode *a_vp;
+ 	} */ *ap;
+ {
+   panic("u9fs_print");
+   return 0;
+ }
+
+ /*
+  * Just call u9fs_writebp() with the force argument set to 1.
+  */
+ static int
+ u9fs_bwrite(ap)
+ 	struct vop_bwrite_args /* {
+ 		struct vnode *a_bp;
+ 	} */ *ap;
+ {
+   panic("u9fs_bwrite");
+   return 0;
+ }
+
+ /*
+  * Vnode op for VM getpages.
+  */
+ static int
+ u9fs_getpages(ap)
+ 	struct vop_getpages_args /* {
+ 		struct vnode *a_vp;
+ 		vm_page_t *a_m;
+ 		int a_count;
+ 		int a_reqpage;
+ 		vm_ooffset_t a_offset;
+ 	} */ *ap;
+ {
+ 	int i, error, nextoff, size, toff, npages, count;
+ 	struct uio uio;
+ 	struct iovec iov;
+ 	vm_offset_t kva;
+ 	struct buf *bp;
+ 	struct vnode *vp;
+ 	struct proc *p;
+ 	struct ucred *cred;
+ 	struct u9fsmount *nmp;
+ 	vm_page_t *pages;
+
+ 	vp = ap->a_vp;
+ 	p = curproc;				/* XXX */
+ 	cred = curproc->p_ucred;		/* XXX */
+ 	nmp = VFSTOU9FS(vp->v_mount);
+ 	pages = ap->a_m;
+ 	count = ap->a_count;
+
+ 	if (vp->v_object == NULL) {
+ 		printf("u9fs_getpages: called with non-merged cache vnode??\n");
+ 		return VM_PAGER_ERROR;
+ 	}
+
+ 	/*
+ 	 * We use only the kva address for the buffer, but this is extremely
+ 	 * convienient and fast.
+ 	 */
+ 	bp = getpbuf();
+
+ 	npages = btoc(count);
+ 	kva = (vm_offset_t) bp->b_data;
+ 	pmap_qenter(kva, pages, npages);
+
+ 	iov.iov_base = (caddr_t) kva;
+ 	iov.iov_len = count;
+ 	uio.uio_iov = &iov;
+ 	uio.uio_iovcnt = 1;
+ 	uio.uio_offset = IDX_TO_OFF(pages[0]->pindex);
+ 	uio.uio_resid = count;
+ 	uio.uio_segflg = UIO_SYSSPACE;
+ 	uio.uio_rw = UIO_READ;
+ 	uio.uio_procp = p;
+
+ 	error = u9fs_readrpc(vp, &uio, cred);
+ 	pmap_qremove(kva, npages);
+
+ 	relpbuf(bp);
+
+ 	if (error && (uio.uio_resid == count))
+ 		return VM_PAGER_ERROR;
+
+ 	size = count - uio.uio_resid;
+
+ 	for (i = 0, toff = 0; i < npages; i++, toff = nextoff) {
+ 		vm_page_t m;
+ 		nextoff = toff + PAGE_SIZE;
+ 		m = pages[i];
+
+ 		m->flags &= ~PG_ZERO;
+
+ 		if (nextoff <= size) {
+ 			m->valid = VM_PAGE_BITS_ALL;
+ 			m->dirty = 0;
+ 		} else {
+ 			int nvalid = ((size + DEV_BSIZE - 1) - toff) & ~(DEV_BSIZE - 1);
+ 			vm_page_set_validclean(m, 0, nvalid);
+ 		}
+
+ 		if (i != ap->a_reqpage) {
+ 			/*
+ 			 * Whether or not to leave the page activated is up in
+ 			 * the air, but we should put the page on a page queue
+ 			 * somewhere (it already is in the object).  Result:
+ 			 * It appears that emperical results show that
+ 			 * deactivating pages is best.
+ 			 */
+
+ 			/*
+ 			 * Just in case someone was asking for this page we
+ 			 * now tell them that it is ok to use.
+ 			 */
+ 			if (!error) {
+ 				if (m->flags & PG_WANTED)
+ 					vm_page_activate(m);
+ 				else
+ 					vm_page_deactivate(m);
+ 				vm_page_wakeup(m);
+ 			} else {
+ 				vnode_pager_freepage(m);
+ 			}
+ 		}
+ 	}
+ 	return 0;
+ }
+
+ /*
+  * Vnode op for VM putpages.
+  */
+ static int
+ u9fs_putpages(ap)
+ 	struct vop_putpages_args /* {
+ 		struct vnode *a_vp;
+ 		vm_page_t *a_m;
+ 		int a_count;
+ 		int a_sync;
+ 		int *a_rtvals;
+ 		vm_ooffset_t a_offset;
+ 	} */ *ap;
+ {
+   panic("u9fs_putpages");
+   return 0;
+ }
+
+ static int
+ u9fs_inactive(ap)
+ 	struct vop_inactive_args /* {
+ 		struct vnode *a_vp;
+ 		struct proc *a_p;
+ 	} */ *ap;
+ {
+   VOP_UNLOCK(ap->a_vp, 0, ap->a_p);
+   return 0;
+ }
+
+ /*
+  * Reclaim an u9fsnode so that it can be used for other purposes.
+  */
+ static int
+ u9fs_reclaim(ap)
+ 	struct vop_reclaim_args /* {
+ 		struct vnode *a_vp;
+ 	} */ *ap;
+ {
+ 	register struct vnode *vp = ap->a_vp;
+ 	register struct u9fsnode *np = VTOU9FS(vp);
+ 	register struct u9fsmount *nmp = VFSTOU9FS(vp->v_mount);
+ 	struct proc * p = curproc;
+
+ 	/* some vnodes do not have fids due to previous access failure */
+ 	if( np->n_fid ) {
+ 	  /* clunk fids */
+ 	  u9fs_free_fid(np->n_fid, nmp, p);
+ 	  if( np->n_rdfid )
+ 	    u9fs_free_fid(np->n_rdfid, nmp, p);
+ 	  if( np->n_wrfid )
+ 	    u9fs_free_fid(np->n_wrfid, nmp, p);
+ 	}
+
+ 	LIST_REMOVE(np, n_hash);
+ 	cache_purge(vp);
+ 	zfree(u9fsnode_zone, vp->v_data);
+ 	vp->v_data = (void *)0;
+
+ 	return (0);
+ }
+
+ /*
+  * Vnode op for write using bio
+  */
+ static int
+ u9fs_write(ap)
+ 	struct vop_write_args /* {
+ 		struct vnode *a_vp;
+ 		struct uio *a_uio;
+ 		int  a_ioflag;
+ 		struct ucred *a_cred;
+ 	} */ *ap;
+ {
+   if (ap->a_vp->v_type != VREG)
+     return (EIO);
+
+   return u9fs_biowrite(ap->a_vp, ap->a_uio, ap->a_ioflag, ap->a_cred);
+ }
+
+ /*
+  * Nfs abort op, called after namei() when a CREATE/DELETE isn't actually
+  * done. Currently nothing to do.
+  */
+ /* ARGSUSED */
+ static int
+ u9fs_abortop(ap)
+ 	struct vop_abortop_args /* {
+ 		struct vnode *a_dvp;
+ 		struct componentname *a_cnp;
+ 	} */ *ap;
+ {
+ 	return (0);
+ }
+
+ /*
+  * u9fs write call
+  */
+ int
+ u9fs_writerpc(vp, uiop, cred)
+ 	register struct vnode *vp;
+ 	register struct uio *uiop;
+ 	struct ucred *cred;
+ {
+   struct u9fsmount *nmp = VFSTOU9FS(vp->v_mount);
+   int error = 0, len, tsiz, rlen;
+   struct u9fsreq req, rep;
+   struct u9fsnode * np = VTOU9FS(vp);
+   struct proc * p = uiop->uio_procp;
+   struct mbuf * top;
+
+   tsiz = uiop->uio_resid;
+   if (uiop->uio_offset + tsiz > nmp->nm_maxfilesize)
+     return (EFBIG);
+   bzero(&req, sizeof(req));
+   req.r_nmp = nmp;
+   req.r_procp = p;
+   req.r_type = Twrite;
+   req.r_fid = np->n_wrfid;
+   while (tsiz > 0) {
+     len = (tsiz > nmp->nm_wsize) ? nmp->nm_wsize : tsiz;
+     req.r_offset = uiop->uio_offset;
+     req.r_count = len;
+     error = u9fs_uiotombuf(uiop, &top, len);
+     if( error )
+       break;
+     req.r_data = (char *)top;
+     error = u9fs_request(&req, &rep, 1);
+     if( error )
+       break;
+     rlen = rep.r_count;
+     if( rlen < len ) {
+       error = EIO;
+       break;
+     }
+     tsiz -= len;
+
+     /* each write message increments version number by one.
+        to avoid flushing our write cache, update the version */
+     if( np->n_qid.vers )
+       np->n_qid.vers++;
+     else
+       np->n_qid.vers = np->n_dir.dir_qid.vers + 1;
+   }
+   if (error)
+     uiop->uio_resid = tsiz;
+   return (error);
+ }
+
+ /*
+  * Readdir rpc call.
+  * Called from below the buffer cache by u9fs_doio().
+  */
+ int
+ u9fs_readdirrpc(vp, uiop, cred)
+ 	struct vnode *vp;
+ 	register struct uio *uiop;
+ 	struct ucred *cred;
+
+ {
+ 	register int len, left;
+ 	register struct dirent *dp;
+ 	struct u9fsmount *nmp = VFSTOU9FS(vp->v_mount);
+ 	struct u9fsnode *np = VTOU9FS(vp);
+ 	int error = 0, tlen, more_dirs = 1, bigenough;
+ 	struct u9fsreq req, rep;
+ 	int count;
+ 	struct u9fsdir u9dir;
+
+ 	bigenough = uiop->uio_resid >= sizeof(struct dirent);
+ 	bzero(&req, sizeof(req));
+ 	req.r_nmp = nmp;
+ 	req.r_type = Tread;
+ 	req.r_fid = np->n_rdfid;
+ 	req.r_count = nmp->nm_readdirsize;
+ 	while ( more_dirs && bigenough ) {
+ 	  req.r_offset = uiop->uio_offset;
+ 	  error = u9fs_request(&req, &rep, 0);
+ 	  if( error )
+ 	    return error;
+
+ 	  count = rep.r_count;
+ 	  more_dirs = (count == req.r_count);
+ 	  len = 0;
+ 	  dp = (struct dirent *)uiop->uio_iov->iov_base;
+ 	  left = uiop->uio_resid;
+ 	  while( len < count ) {
+ 	    /* XXX: too conservative, but OK */
+ 	    if( left < sizeof(*dp) ) {
+ 	      bigenough = 0;
+ 	      break;
+ 	    }
+ 	    if( u9p_m_m2d(&req.r_mrep, & u9dir) ) {
+ 	      printf("u9p_m_m2d failed!\n");
+ 	      return (EIO);
+ 	    }
+
+ 	    dp->d_fileno = u9dir.dir_qid.path;
+ 	    if( U9P_PERM_CHDIR(u9dir.dir_mode) )
+ 	      dp->d_type = DT_DIR;
+ 	    else
+ 	      dp->d_type = DT_REG;
+ 	    u9dir.dir_name[U9FS_NAMELEN-1] = 0; /* just to be sure */
+ 	    dp->d_namlen = strlen(u9dir.dir_name);
+ 	    memcpy(dp->d_name, u9dir.dir_name, dp->d_namlen+1);
+ 	    tlen = DIRHDSIZ + dp->d_namlen + 4;
+ 	    tlen = tlen - (tlen & 0x3);
+ 	    dp->d_reclen = tlen;
+ 	    dp = (struct dirent *)(((char *)dp) + tlen);
+ 	    left -= tlen;
+ 	    len += sizeof(u9dir);
+ 	  }
+ 	  tlen = uiop->uio_resid - left;
+ 	  uiop->uio_resid = left;
+ 	  uiop->uio_iov->iov_base += tlen;
+ 	  uiop->uio_iov->iov_len -= tlen;
+ 	  uiop->uio_offset += len;
+ 	  m_freem(req.r_mrep);
+ 	}
+ 	return 0;
+ }
+
+ /*
+  * u9fs read rpc call
+  * Ditto above
+  */
+ int
+ u9fs_readrpc(vp, uiop, cred)
+ 	register struct vnode *vp;
+ 	struct uio *uiop;
+ 	struct ucred *cred;
+ {
+   struct u9fsmount *nmp;
+   struct u9fsnode *np = VTOU9FS(vp);
+   int error = 0, len, retlen, tsiz;
+   struct u9fsreq req, rep;
+
+   nmp = VFSTOU9FS(vp->v_mount);
+   tsiz = uiop->uio_resid;
+   if (uiop->uio_offset + tsiz > nmp->nm_maxfilesize)
+     return (EFBIG);
+   bzero(&req, sizeof(req));
+   req.r_nmp = nmp;
+   req.r_type = Tread;
+   req.r_fid = np->n_rdfid;
+   while (tsiz > 0) {
+     len = (tsiz > nmp->nm_rsize) ? nmp->nm_rsize : tsiz;
+     req.r_count = len;
+     req.r_offset = uiop->uio_offset;
+     error = u9fs_request(&req, &rep, 0);
+     if( error )
+       return error;
+     retlen = rep.r_count;
+     if( retlen && (error = u9fs_mbuftouio(req.r_mrep, uiop, retlen)) ) {
+       m_freem(req.r_mrep);
+       return error;
+     }
+
+     m_freem(req.r_mrep);
+     req.r_mrep = 0;
+     tsiz -= retlen;
+     if (retlen < len)
+       tsiz = 0;
+   }
+   return (0);
+ }
+
+ static void u9fs_free_fid(fid, nmp, p)
+      u_short fid;
+      struct u9fsmount * nmp;
+      struct proc * p;
+ {
+   struct u9fsreq req, rep;
+
+   /* clunk fid */
+   bzero(&req, sizeof(req));
+   req.r_nmp = nmp;
+   req.r_procp = p;
+   req.r_type = Tclunk;
+   req.r_fid = fid;
+   u9fs_request(&req, &rep, 1);
+   u9fs_id_free(nmp->nm_fids, fid);
+ }
diff -N -c -r /usr/src/sys/9fs/9p.c ./9fs/9p.c
*** /usr/src/sys/9fs/9p.c	Wed Dec 31 19:00:00 1969
--- ./9fs/9p.c	Thu Nov 25 15:04:16 1999
***************
*** 0 ****
--- 1,974 ----
+ #include <sys/param.h>
+ #include <sys/systm.h>
+ #include <sys/socket.h>
+ #include <sys/socketvar.h>
+ #include <netinet/in.h>
+ #include <sys/mbuf.h>
+ #include <sys/malloc.h>
+ #include <sys/vnode.h>
+ #include <sys/mount.h>
+
+ #include <9fs/bitstring.h>
+ #include <9fs/9p.h>
+ #include <9fs/9auth.h>
+ #include <9fs/9fs.h>
+
+ int u9p_usetcp = 0;
+ struct u9fs_reqq u9fs_reqq;
+
+ #define	N2HCHAR(x)		x = *p++
+ #define	N2HSHORT(x)	x = (p[0] | (p[1]<<8)); p += 2
+ #define	N2HLONG(x)		x = (p[0] | (p[1]<<8) |\
+ 				(p[2]<<16) | (p[3]<<24)); p += 4
+ #define	N2HQUAD(x)	x = (u_int64_t)(p[0] | (p[1]<<8) |\
+ 					(p[2]<<16) | (p[3]<<24)) |\
+ 				((u_int64_t)(p[4] | (p[5]<<8) |\
+ 					(p[6]<<16) | (p[7]<<24)) << 32); p += 8
+ #define	N2HSTRING(x,n)	bcopy(p, x, n); p += n
+
+ #define	H2NCHAR(x)	*p++ = x
+ #define	H2NSHORT(x)	p[0]=x; p[1]=x>>8; p += 2
+ #define	H2NLONG(x)		p[0]=x; p[1]=x>>8; p[2]=x>>16; p[3]=x>>24; p += 4
+ #define	H2NQUAD(x)	p[0]=x;	p[1]=x>>8;\
+ 			p[2]=x>>16;	p[3]=x>>24;\
+ 			p[4]=x>>32;	p[5]=x>>40;\
+ 			p[6]=x>>48;	p[7]=x>>56;\
+ 			p += 8
+ #define	H2NSTRING(x,n)	bcopy(x, p, n); p += n
+
+ static void u9p_print __P((u_char * m, int len, struct u9fsreq * f));
+
+ static char * u9p_types[] = {
+   "Tnop",
+   "Rnop",
+   "Tosession",
+   "Rosession",
+   "Terror",
+   "Rerror",
+   "Tflush",
+   "Rflush",
+   "Toattach",
+   "Roattach",
+   "Tclone",
+   "Rclone",
+   "Twalk",
+   "Rwalk",
+   "Topen",
+   "Ropen",
+   "Tcreate",
+   "Rcreate",
+   "Tread",
+   "Rread",
+   "Twrite",
+   "Rwrite",
+   "Tclunk",
+   "Rclunk",
+   "Tremove",
+   "Rremove",
+   "Tstat",
+   "Rstat",
+   "Twstat",
+   "Rwstat",
+   "Tclwalk",
+   "Rclwalk",
+   "Tauth",
+   "Rauth",
+   "Tsession",
+   "Rsession",
+   "Tattach",
+   "Rattach",
+   "Ttunnel",
+   "Rtunnel",
+   "Tmax"
+ };
+
+ int u9p_m2s(char *ap, int n, struct u9fsreq *f)
+ {
+ 	u_char *p;
+
+ 	p = (u_char*)ap;
+ 	N2HCHAR(f->r_type);
+ 	N2HSHORT(f->r_tag);
+ 	switch(f->r_type)
+ 	{
+ 	default:
+ 		return 0;
+
+ 	case Tnop:
+ 	case Tosession:
+ 		break;
+
+ 	case Tsession:
+ 		N2HSTRING(f->r_chal, sizeof(f->r_chal));
+ 		break;
+
+ 	case Tflush:
+ 		N2HSHORT(f->r_oldtag);
+ 		break;
+
+ 	case Tattach:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSTRING(f->r_uname, sizeof(f->r_uname));
+ 		N2HSTRING(f->r_aname, sizeof(f->r_aname));
+ 		N2HSTRING(f->r_ticket, sizeof(f->r_ticket));
+ 		N2HSTRING(f->r_auth, sizeof(f->r_auth));
+ 		break;
+
+ 	case Toattach:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSTRING(f->r_uname, sizeof(f->r_uname));
+ 		N2HSTRING(f->r_aname, sizeof(f->r_aname));
+ 		N2HSTRING(f->r_ticket, U9FS_NAMELEN);
+ 		break;
+
+ 	case Tauth:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSTRING(f->r_uname, sizeof(f->r_uname));
+ 		N2HSTRING(f->r_ticket, 8+U9FS_NAMELEN);
+ 		break;
+
+ 	case Tclone:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSHORT(f->r_newfid);
+ 		break;
+
+ 	case Twalk:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSTRING(f->r_name, sizeof(f->r_name));
+ 		break;
+
+ 	case Topen:
+ 		N2HSHORT(f->r_fid);
+ 		N2HCHAR(f->r_mode);
+ 		break;
+
+ 	case Tcreate:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSTRING(f->r_name, sizeof(f->r_name));
+ 		N2HLONG(f->r_perm);
+ 		N2HCHAR(f->r_mode);
+ 		break;
+
+ 	case Tread:
+ 		N2HSHORT(f->r_fid);
+ 		N2HQUAD(f->r_offset);
+ 		N2HSHORT(f->r_count);
+ 		break;
+
+ 	case Twrite:
+ 		N2HSHORT(f->r_fid);
+ 		N2HQUAD(f->r_offset);
+ 		N2HSHORT(f->r_count);
+ 		p++;	/* pad(1) */
+ 		f->r_data = (char*)p; p += f->r_count;
+ 		break;
+
+ 	case Ttunnel:
+ 		N2HSHORT(f->r_fid);
+ 		break;
+
+ 	case Tclunk:
+ 		N2HSHORT(f->r_fid);
+ 		break;
+
+ 	case Tremove:
+ 		N2HSHORT(f->r_fid);
+ 		break;
+
+ 	case Tstat:
+ 		N2HSHORT(f->r_fid);
+ 		break;
+
+ 	case Twstat:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSTRING(f->r_stat, sizeof(f->r_stat));
+ 		break;
+
+ 	case Tclwalk:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSHORT(f->r_newfid);
+ 		N2HSTRING(f->r_name, sizeof(f->r_name));
+ 		break;
+ /*
+  */
+ 	case Rnop:
+ 	case Rosession:
+ 		break;
+
+ 	case Rsession:
+ 		N2HSTRING(f->r_chal, sizeof(f->r_chal));
+ 		N2HSTRING(f->r_authid, sizeof(f->r_authid));
+ 		N2HSTRING(f->r_authdom, sizeof(f->r_authdom));
+ 		break;
+
+ 	case Rerror:
+ 		N2HSTRING(f->r_ename, sizeof(f->r_ename));
+ 		break;
+
+ 	case Rflush:
+ 		break;
+
+ 	case Rattach:
+ 		N2HSHORT(f->r_fid);
+ 		N2HLONG(f->r_qid.path);
+ 		N2HLONG(f->r_qid.vers);
+ 		N2HSTRING(f->r_rauth, sizeof(f->r_rauth));
+ 		break;
+
+ 	case Roattach:
+ 		N2HSHORT(f->r_fid);
+ 		N2HLONG(f->r_qid.path);
+ 		N2HLONG(f->r_qid.vers);
+ 		break;
+
+ 	case Rauth:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSTRING(f->r_ticket, 8+8+7+7);
+ 		break;
+
+ 	case Rclone:
+ 		N2HSHORT(f->r_fid);
+ 		break;
+
+ 	case Rwalk:
+ 	case Rclwalk:
+ 		N2HSHORT(f->r_fid);
+ 		N2HLONG(f->r_qid.path);
+ 		N2HLONG(f->r_qid.vers);
+ 		break;
+
+ 	case Ropen:
+ 		N2HSHORT(f->r_fid);
+ 		N2HLONG(f->r_qid.path);
+ 		N2HLONG(f->r_qid.vers);
+ 		break;
+
+ 	case Rcreate:
+ 		N2HSHORT(f->r_fid);
+ 		N2HLONG(f->r_qid.path);
+ 		N2HLONG(f->r_qid.vers);
+ 		break;
+
+ 	case Rread:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSHORT(f->r_count);
+ 		p++;	/* pad(1) */
+ 		f->r_data = (char*)p; p += f->r_count;
+ 		break;
+
+ 	case Rwrite:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSHORT(f->r_count);
+ 		break;
+
+ 	case Rtunnel:
+ 		N2HSHORT(f->r_fid);
+ 		break;
+
+ 	case Rclunk:
+ 		N2HSHORT(f->r_fid);
+ 		break;
+
+ 	case Rremove:
+ 		N2HSHORT(f->r_fid);
+ 		break;
+
+ 	case Rstat:
+ 		N2HSHORT(f->r_fid);
+ 		N2HSTRING(f->r_stat, sizeof(f->r_stat));
+ 		break;
+
+ 	case Rwstat:
+ 		N2HSHORT(f->r_fid);
+ 		break;
+ 	}
+ 	if((u_char*)ap+n == p)
+ 		return n;
+ 	return 0;
+ }
+
+ void u9p_print(u_char * m, int len, struct u9fsreq * f)
+ {
+   struct u9fsreq u9fsreq;
+
+   if( f == 0 )
+     f = & u9fsreq;
+
+   if( len < 3 ) {
+     printf("truncated-9p %d", len);
+     return;
+   }
+
+   if( u9p_m2s((char *)m, len, f) == 0 )
+     return;
+
+   printf("%s tag %d ", u9p_types[f->r_type-Tnop], f->r_tag);
+
+   switch( f->r_type ) {
+ 	default:
+ 	  return;
+
+ 	case Tnop:
+ 	case Tosession:
+ 	case Toattach:
+ 	case Tauth:
+ 		break;
+
+ 	case Tsession:
+ 	case Rsession:
+ 	  printf("chal 0x%x 0x%x", *(u_int *)&f->r_chal[0], *(u_int *)&f->r_chal[4]);
+ 		break;
+
+ 	case Tflush:
+ 	  printf("oldtag %d", f->r_oldtag);
+ 		break;
+
+ 	case Tclone:
+ 	  printf("fid %d newfid %d", f->r_fid, f->r_newfid);
+ 		break;
+
+ 	case Twalk:
+ 	  printf("fid %d name %s", f->r_fid, f->r_name);
+ 		break;
+
+ 	case Topen:
+ 	  printf("fid %d %c", f->r_fid, f->r_mode);
+ 		break;
+
+ 	case Tcreate:
+ 	  printf("fid %d name %s perm 0x%x mode %c", f->r_fid,
+ 		 f->r_name, f->r_perm, f->r_mode);
+ 		break;
+
+ 	case Tread:
+ 	case Twrite:
+ 	  printf("fid %d offset 0x%llx count %d", f->r_fid,
+ 		 f->r_offset, f->r_count);
+ 		break;
+
+ 	case Tattach:
+ 	case Ttunnel:
+ 	case Tclunk:
+ 	case Tremove:
+ 	case Tstat:
+ 	case Twstat:
+ 	case Rclone:
+ 	case Rtunnel:
+ 	case Rclunk:
+ 	case Rremove:
+ 	case Rstat:
+ 	case Rwstat:
+ 	  printf("fid %d", f->r_fid);
+ 		break;
+
+ 	case Tclwalk:
+ 	  printf("fid %d ", f->r_fid);
+ 	  printf("newfid  %d ", f->r_newfid);
+ 	  printf("name %s", f->r_name);
+ 		break;
+ /*
+  */
+ 	case Rnop:
+ 	case Rosession:
+ 	case Rflush:
+ 	case Roattach:
+ 	case Rauth:
+ 		break;
+
+ 	case Rerror:
+ 	  printf("ename %s", f->r_ename);
+ 		break;
+
+ 	case Rattach:
+ 	case Rwalk:
+ 	case Rclwalk:
+ 	case Ropen:
+ 	case Rcreate:
+ 	  printf("fid %d ", f->r_fid);
+ 	  printf("qid 0x%x 0x%x", f->r_qid.path, f->r_qid.vers);
+ 		break;
+
+ 	case Rread:
+ 	  printf("fid %d count %d ", f->r_fid, f->r_count);
+ 	  break;
+
+ 	case Rwrite:
+ 	  printf("fid %d count %d", f->r_fid, f->r_count);
+ 		break;
+   }
+ }
+
+ int
+ u9p_s2m(struct u9fsreq *f, char *ap, int copydata)
+ {
+ 	u_char *p;
+
+ 	p = (u_char*)ap;
+ 	H2NCHAR(f->r_type);
+ 	H2NSHORT(f->r_tag);
+ 	switch(f->r_type)
+ 	{
+ 	default:
+ 		return 0;
+
+ 	case Tosession:
+ 	case Tnop:
+ 		break;
+
+ 	case Tsession:
+ 		H2NSTRING(f->r_chal, sizeof(f->r_chal));
+ 		break;
+
+ 	case Tflush:
+ 		H2NSHORT(f->r_oldtag);
+ 		break;
+
+ 	case Tattach:
+ 		H2NSHORT(f->r_fid);
+ 		H2NSTRING(f->r_uname, sizeof(f->r_uname));
+ 		H2NSTRING(f->r_aname, sizeof(f->r_aname));
+ 		H2NSTRING(f->r_ticket, sizeof(f->r_ticket));
+ 		H2NSTRING(f->r_auth, sizeof(f->r_auth));
+ 		break;
+
+ 	case Toattach:
+ 		H2NSHORT(f->r_fid);
+ 		H2NSTRING(f->r_uname, sizeof(f->r_uname));
+ 		H2NSTRING(f->r_aname, sizeof(f->r_aname));
+ 		H2NSTRING(f->r_ticket, U9FS_NAMELEN);
+ 		break;
+
+ 	case Tauth:
+ 		H2NSHORT(f->r_fid);
+ 		H2NSTRING(f->r_uname, sizeof(f->r_uname));
+ 		H2NSTRING(f->r_ticket, 8+U9FS_NAMELEN);
+ 		break;
+
+ 	case Tclone:
+ 		H2NSHORT(f->r_fid);
+ 		H2NSHORT(f->r_newfid);
+ 		break;
+
+ 	case Twalk:
+ 		H2NSHORT(f->r_fid);
+ 		H2NSTRING(f->r_name, sizeof(f->r_name));
+ 		break;
+
+ 	case Topen:
+ 		H2NSHORT(f->r_fid);
+ 		H2NCHAR(f->r_mode);
+ 		break;
+
+ 	case Tcreate:
+ 		H2NSHORT(f->r_fid);
+ 		H2NSTRING(f->r_name, sizeof(f->r_name));
+ 		H2NLONG(f->r_perm);
+ 		H2NCHAR(f->r_mode);
+ 		break;
+
+ 	case Tread:
+ 		H2NSHORT(f->r_fid);
+ 		H2NQUAD(f->r_offset);
+ 		H2NSHORT(f->r_count);
+ 		break;
+
+ 	case Twrite:
+ 		H2NSHORT(f->r_fid);
+ 		H2NQUAD(f->r_offset);
+ 		H2NSHORT(f->r_count);
+ 		p++;	/* pad(1) */
+ 		if( copydata ) {
+ 		  H2NSTRING(f->r_data, f->r_count);
+ 		}
+ 		break;
+
+ 	case Ttunnel:
+ 		H2NSHORT(f->r_fid);
+ 		break;
+
+ 	case Tclunk:
+ 		H2NSHORT(f->r_fid);
+ 		break;
+
+ 	case Tremove:
+ 		H2NSHORT(f->r_fid);
+ 		break;
+
+ 	case Tstat:
+ 		H2NSHORT(f->r_fid);
+ 		break;
+
+ 	case Twstat:
+ 		H2NSHORT(f->r_fid);
+ 		H2NSTRING(f->r_stat, sizeof(f->r_stat));
+ 		break;
+
+ 	case Tclwalk:
+ 		H2NSHORT(f->r_fid);
+ 		H2NSHORT(f->r_newfid);
+ 		H2NSTRING(f->r_name, sizeof(f->r_name));
+ 		break;
+ /*
+  */
+ 	case Rosession:
+ 	case Rnop:
+ 		break;
+
+ 	case Rsession:
+ 		H2NSTRING(f->r_chal, sizeof(f->r_chal));
+ 		H2NSTRING(f->r_authid, sizeof(f->r_authid));
+ 		H2NSTRING(f->r_authdom, sizeof(f->r_authdom));
+ 		break;
+
+ 	case Rerror:
+ 		H2NSTRING(f->r_ename, sizeof(f->r_ename));
+ 		break;
+
+ 	case Rflush:
+ 		break;
+
+ 	case Rattach:
+ 		H2NSHORT(f->r_fid);
+ 		H2NLONG(f->r_qid.path);
+ 		H2NLONG(f->r_qid.vers);
+ 		H2NSTRING(f->r_rauth, sizeof(f->r_rauth));
+ 		break;
+
+ 	case Roattach:
+ 		H2NSHORT(f->r_fid);
+ 		H2NLONG(f->r_qid.path);
+ 		H2NLONG(f->r_qid.vers);
+ 		break;
+
+ 	case Rauth:
+ 		H2NSHORT(f->r_fid);
+ 		H2NSTRING(f->r_ticket, 8+8+7+7);
+ 		break;
+
+ 	case Rclone:
+ 		H2NSHORT(f->r_fid);
+ 		break;
+
+ 	case Rwalk:
+ 	case Rclwalk:
+ 		H2NSHORT(f->r_fid);
+ 		H2NLONG(f->r_qid.path);
+ 		H2NLONG(f->r_qid.vers);
+ 		break;
+
+ 	case Ropen:
+ 		H2NSHORT(f->r_fid);
+ 		H2NLONG(f->r_qid.path);
+ 		H2NLONG(f->r_qid.vers);
+ 		break;
+
+ 	case Rcreate:
+ 		H2NSHORT(f->r_fid);
+ 		H2NLONG(f->r_qid.path);
+ 		H2NLONG(f->r_qid.vers);
+ 		break;
+
+ 	case Rread:
+ 		H2NSHORT(f->r_fid);
+ 		H2NSHORT(f->r_count);
+ 		p++;	/* pad(1) */
+ 		if( copydata ) {
+ 		  H2NSTRING(f->r_data, f->r_count);
+ 		}
+ 		break;
+
+ 	case Rwrite:
+ 		H2NSHORT(f->r_fid);
+ 		H2NSHORT(f->r_count);
+ 		break;
+
+ 	case Rtunnel:
+ 		H2NSHORT(f->r_fid);
+ 		break;
+
+ 	case Rclunk:
+ 		H2NSHORT(f->r_fid);
+ 		break;
+
+ 	case Rremove:
+ 		H2NSHORT(f->r_fid);
+ 		break;
+
+ 	case Rstat:
+ 		H2NSHORT(f->r_fid);
+ 		if( copydata )
+ 		  H2NSTRING(f->r_stat, sizeof(f->r_stat));
+ 		break;
+
+ 	case Rwstat:
+ 		H2NSHORT(f->r_fid);
+ 		break;
+ 	}
+ 	return p - (u_char*)ap;
+ }
+
+ int
+ u9p_m2d(char *ap, struct u9fsdir *f)
+ {
+ 	u_char *p;
+
+ 	p = (u_char*)ap;
+ 	N2HSTRING(f->dir_name, sizeof(f->dir_name));
+ 	N2HSTRING(f->dir_uid, sizeof(f->dir_uid));
+ 	N2HSTRING(f->dir_gid, sizeof(f->dir_gid));
+ 	N2HLONG(f->dir_qid.path);
+ 	N2HLONG(f->dir_qid.vers);
+ 	N2HLONG(f->dir_mode);
+ 	N2HLONG(f->dir_atime);
+ 	N2HLONG(f->dir_mtime);
+ 	N2HQUAD(f->dir_length);
+ 	N2HSHORT(f->dir_type);
+ 	N2HSHORT(f->dir_dev);
+ 	return p - (u_char*)ap;
+ }
+
+ int
+ u9p_d2m(struct u9fsdir *f, char *ap)
+ {
+ 	u_char *p;
+
+ 	p = (u_char*)ap;
+ 	H2NSTRING(f->dir_name, sizeof(f->dir_name));
+ 	H2NSTRING(f->dir_uid, sizeof(f->dir_uid));
+ 	H2NSTRING(f->dir_gid, sizeof(f->dir_gid));
+ 	H2NLONG(f->dir_qid.path);
+ 	H2NLONG(f->dir_qid.vers);
+ 	H2NLONG(f->dir_mode);
+ 	H2NLONG(f->dir_atime);
+ 	H2NLONG(f->dir_mtime);
+ 	H2NQUAD(f->dir_length);
+ 	H2NSHORT(f->dir_type);
+ 	H2NSHORT(f->dir_dev);
+ 	return p - (u_char*)ap;
+ }
+
+ /* parse 9P types */
+ int u9p_type(char * t)
+ {
+   int i;
+
+   for(i = 0; i < sizeof(u9p_types)/sizeof(u9p_types[0]); i++) {
+     if( strcmp(u9p_types[i], t) == 0 )
+       return (i+Tnop);
+   }
+   return 0;
+ }
+
+ /* m is freed if shorter than s */
+ #if 1
+ #define U9P_PULLUP(m,s)  if( (*(m))->m_len < (s) && ((*(m)) = m_pullup((*(m)),(s))) == 0 ) return 1; p = mtod((*(m)), u_char *)
+ #else
+ #define U9P_PULLUP(m,s)  if( (*(m))->m_len < (s) && ((*(m)) = m_pullup((*(m)),(s))) == 0 ) panic("PULLUP"); p = mtod((*(m)), u_char *)
+ #endif
+
+ #define U9P_ADJ(m,s) (*(m))->m_len -= (s); (*(m))->m_data += (s)
+
+ u_short u9p_m_tag(struct mbuf ** m)
+ {
+   char * p;
+   u_short t;
+
+   U9P_PULLUP(m,3);
+   p = mtod(*m, char *);
+   p++;
+   N2HSHORT(t);
+
+   return t;
+ }
+
+ int
+ u9p_m_m2s(struct mbuf **m, struct u9fsreq *f)
+ {
+   u_char *p;
+
+   U9P_PULLUP(m,3);
+   N2HCHAR(f->r_type);
+   N2HSHORT(f->r_tag);
+   U9P_ADJ(m, sizeof(f->r_type)+sizeof(f->r_tag));
+
+   switch(f->r_type) {
+   default:
+     goto drop;
+
+   case Tnop:
+     break;
+
+   case Tsession:
+     U9P_PULLUP(m,sizeof(f->r_chal));
+     N2HSTRING(f->r_chal, sizeof(f->r_chal));
+     U9P_ADJ(m, sizeof(f->r_chal));
+     break;
+
+   case Tflush:
+     U9P_PULLUP(m,sizeof(f->r_oldtag));
+     N2HSHORT(f->r_oldtag);
+     U9P_ADJ(m, f->r_oldtag);
+     break;
+
+   case Tattach:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_uname)+sizeof(f->r_aname));
+     N2HSHORT(f->r_fid);
+     N2HSTRING(f->r_uname, sizeof(f->r_uname));
+     N2HSTRING(f->r_aname, sizeof(f->r_aname));
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_uname)+sizeof(f->r_aname));
+
+     U9P_PULLUP(m, sizeof(f->r_ticket)+sizeof(f->r_auth));
+     N2HSTRING(f->r_ticket, sizeof(f->r_ticket));
+     N2HSTRING(f->r_auth, sizeof(f->r_auth));
+     U9P_ADJ(m, sizeof(f->r_ticket)+sizeof(f->r_auth));
+     break;
+
+   case Tclone:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_newfid));
+     N2HSHORT(f->r_fid);
+     N2HSHORT(f->r_newfid);
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_newfid));
+     break;
+
+   case Twalk:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_name));
+     N2HSHORT(f->r_fid);
+     N2HSTRING(f->r_name, sizeof(f->r_name));
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_name));
+     break;
+
+   case Topen:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_mode));
+     N2HSHORT(f->r_fid);
+     N2HCHAR(f->r_mode);
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_mode));
+     break;
+
+   case Tcreate:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_name)
+ 	       +sizeof(f->r_perm)+sizeof(f->r_mode));
+     N2HSHORT(f->r_fid);
+     N2HSTRING(f->r_name, sizeof(f->r_name));
+     N2HLONG(f->r_perm);
+     N2HCHAR(f->r_mode);
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_name)
+ 	    +sizeof(f->r_perm)+sizeof(f->r_mode));
+     break;
+
+   case Tread:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_offset)+sizeof(f->r_count));
+     N2HSHORT(f->r_fid);
+     N2HQUAD(f->r_offset);
+     N2HSHORT(f->r_count);
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_offset)+sizeof(f->r_count));
+     break;
+
+   case Twrite:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_offset)+sizeof(f->r_count));
+     N2HSHORT(f->r_fid);
+     N2HQUAD(f->r_offset);
+     N2HSHORT(f->r_count);
+     p++;	/* pad(1) */
+     f->r_data = (char*)p; p += f->r_count;
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_offset)+sizeof(f->r_count)+1);
+     break;
+
+   case Tclunk:
+   case Tremove:
+   case Tstat:
+    U9P_PULLUP(m, sizeof(f->r_fid));
+     N2HSHORT(f->r_fid);
+     U9P_ADJ(m, sizeof(f->r_fid));
+     break;
+
+   case Twstat:
+     U9P_PULLUP(m, sizeof(f->r_fid));
+     N2HSHORT(f->r_fid);
+     m_copydata(*m, sizeof(f->r_fid), sizeof(f->r_stat), f->r_stat);
+     m_adj(*m, sizeof(f->r_fid)+sizeof(f->r_stat));
+     break;
+
+   case Tclwalk:
+      U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_newfid)+sizeof(f->r_name));
+      N2HSHORT(f->r_fid);
+      N2HSHORT(f->r_newfid);
+      N2HSTRING(f->r_name, sizeof(f->r_name));
+      U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_newfid)+sizeof(f->r_name));
+      break;
+ /*
+  */
+   case Rnop:
+     break;
+
+   case Rsession:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_authid)+sizeof(f->r_authdom));
+     N2HSTRING(f->r_chal, sizeof(f->r_chal));
+     N2HSTRING(f->r_authid, sizeof(f->r_authid));
+     N2HSTRING(f->r_authdom, sizeof(f->r_authdom));
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_authid)+sizeof(f->r_authdom));
+     break;
+
+   case Rerror:
+     U9P_PULLUP(m, sizeof(f->r_ename));
+     N2HSTRING(f->r_ename, sizeof(f->r_ename));
+     U9P_ADJ(m, sizeof(f->r_ename));
+     break;
+
+   case Rflush:
+     break;
+
+   case Rattach:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_qid.path)
+ 	       +sizeof(f->r_qid.vers)+sizeof(f->r_rauth));
+     N2HSHORT(f->r_fid);
+     N2HLONG(f->r_qid.path);
+     N2HLONG(f->r_qid.vers);
+     N2HSTRING(f->r_rauth, sizeof(f->r_rauth));
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_qid.path)
+ 	    +sizeof(f->r_qid.vers)+sizeof(f->r_rauth));
+     break;
+
+   case Rclone:
+     U9P_PULLUP(m, sizeof(f->r_fid));
+     N2HSHORT(f->r_fid);
+     U9P_ADJ(m, sizeof(f->r_fid));
+     break;
+
+   case Rwalk:
+   case Rclwalk:
+   case Ropen:
+   case Rcreate:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_qid.path)
+                +sizeof(f->r_qid.vers));
+     N2HSHORT(f->r_fid);
+     N2HLONG(f->r_qid.path);
+     N2HLONG(f->r_qid.vers);
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_qid.path)
+             +sizeof(f->r_qid.vers));
+     break;
+
+   case Rread:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_count));
+     N2HSHORT(f->r_fid);
+     N2HSHORT(f->r_count);
+     p++;	/* pad(1) */
+     f->r_data = (char*)p; p += f->r_count;
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_count)+1);
+     break;
+
+   case Rwrite:
+     U9P_PULLUP(m, sizeof(f->r_fid)+sizeof(f->r_count));
+     N2HSHORT(f->r_fid);
+     N2HSHORT(f->r_count);
+     U9P_ADJ(m, sizeof(f->r_fid)+sizeof(f->r_count));
+     break;
+
+   case Rclunk:
+   case Rremove:
+   case Rwstat:
+     U9P_PULLUP(m, sizeof(f->r_fid));
+     N2HSHORT(f->r_fid);
+     U9P_ADJ(m, sizeof(f->r_fid));
+     break;
+
+   case Rstat:
+     U9P_PULLUP(m, sizeof(f->r_fid));
+     N2HSHORT(f->r_fid);
+     m_copydata(*m, sizeof(f->r_fid), sizeof(f->r_stat), f->r_stat);
+     m_adj(*m, sizeof(f->r_fid)+sizeof(f->r_stat));
+     break;
+
+   }
+   return 0;
+
+  drop:
+   m_freem(*m);
+   return 1;
+ }
+
+ struct mbuf *
+ u9p_m_s2m (struct u9fsreq *f)
+ {
+   register struct mbuf * m;
+   struct mbuf * m0;
+   char * ap;
+   int sz;
+
+   /* we want one contiguous piece */
+   if( f->r_type == Tattach || f->r_type == Rstat || f->r_type == Twstat )
+     sz = 146; /* sizeof a Tattach */
+   else
+     sz = 87; /* sizeof a Tsession */
+
+   MGETHDR(m, M_WAIT, MT_DATA);
+   if( sz > MHLEN )
+     MCLGET(m, M_WAIT);
+   m->m_len = 0;
+
+   if ( M_TRAILINGSPACE(m) < sz )
+     panic("u9p_m_s2m");
+
+   ap = mtod(m, char *);
+   m->m_len = u9p_s2m(f, ap, 0);
+   m->m_pkthdr.len = m->m_len;
+
+   /* append data mbufs  */
+   switch ( f->r_type ) {
+   default:
+     break;
+   case Twrite:
+   case Rread:
+     m0 = (struct mbuf *)f->r_data;
+     m->m_next = m0;
+     m->m_pkthdr.len += f->r_count;
+     break;
+   }
+
+   return m;
+ }
+
+ int
+ u9p_m_m2d (struct mbuf **m, struct u9fsdir *f)
+ {
+   u_char *p;
+
+   U9P_PULLUP(m, sizeof(f->dir_name)+sizeof(f->dir_uid)+sizeof(f->dir_gid));
+   N2HSTRING(f->dir_name, sizeof(f->dir_name));
+   N2HSTRING(f->dir_uid, sizeof(f->dir_uid));
+   N2HSTRING(f->dir_gid, sizeof(f->dir_gid));
+   U9P_ADJ(m, sizeof(f->dir_name)+sizeof(f->dir_uid)+sizeof(f->dir_gid));
+
+   U9P_PULLUP(m, sizeof(f->dir_qid)+sizeof(f->dir_mode)
+ 	     +sizeof(f->dir_atime)+sizeof(f->dir_mtime)
+ 	     +sizeof(f->dir_length)+sizeof(f->dir_type)+sizeof(f->dir_dev));
+   N2HLONG(f->dir_qid.path);
+   N2HLONG(f->dir_qid.vers);
+   N2HLONG(f->dir_mode);
+   N2HLONG(f->dir_atime);
+   N2HLONG(f->dir_mtime);
+   N2HQUAD(f->dir_length);
+   N2HSHORT(f->dir_type);
+   N2HSHORT(f->dir_dev);
+   U9P_ADJ(m, sizeof(f->dir_qid)+sizeof(f->dir_mode)
+ 	     +sizeof(f->dir_atime)+sizeof(f->dir_mtime)
+ 	     +sizeof(f->dir_length)+sizeof(f->dir_type)+sizeof(f->dir_dev));
+
+   return 0;
+ }
+
+ struct mbuf * u9p_m_d2m (struct u9fsdir *f)
+ {
+   char * ap;
+   struct mbuf * m;
+   MGET(m, M_WAIT, MT_DATA);
+   MCLGET(m, M_WAIT);
+   m->m_len = 0;
+
+   if ( M_TRAILINGSPACE(m) < sizeof(struct u9fsdir) )
+     panic("u9p_m_d2m");
+
+   ap = mtod(m, char *);
+   m->m_len = u9p_d2m(f, ap);
+
+   return m;
+ }
diff -N -c -r /usr/src/sys/9fs/9p.h ./9fs/9p.h
*** /usr/src/sys/9fs/9p.h	Wed Dec 31 19:00:00 1969
--- ./9fs/9p.h	Thu Nov 25 15:45:46 1999
***************
*** 0 ****
--- 1,183 ----
+ #ifndef _9FS_9P_H_
+ #define _9FS_9P_H_
+
+
+ #define U9FS_AUTHLEN 13
+ #define U9FS_NAMELEN    28
+ #define U9FS_TICKETLEN  72
+ #define U9FS_ERRLEN     64
+ #define U9FS_DOMLEN     48
+ #define U9FS_CHALLEN    8
+ #define U9FS_DIRLEN     116
+ #define U9FS_MAXFDATA  8192
+ #define U9FS_MAXDDATA  (((int)U9FS_MAXFDATA/U9FS_DIRLEN)*U9FS_DIRLEN)
+
+ #define U9P_MODE_RD    0x0
+ #define U9P_MODE_WR    0x1
+ #define U9P_MODE_RDWR  0x2
+ #define U9P_MODE_EX    0x3
+ #define U9P_MODE_TRUNC 0x10
+ #define U9P_MODE_CLOSE 0x40
+
+ #define U9P_PERM_CHDIR(m) (0x80000000&(m))
+ #define U9P_PERM_OWNER(m) ((m)&0x7)
+ #define U9P_PERM_GROUP(m) (((m)>>3)&0x7)
+ #define U9P_PERM_OTHER(m) (((m)>>6)&0x7)
+ #define U9P_PERM_ALL(m)   ((m)&0777)
+ #define U9P_PERM_EXCL(m)    ((m)&0x20000000)
+ #define U9P_PERM_APPEND(m)  ((m)&0x40000000)
+ #define U9P_PERM_NONPERM(m) ((m)&0xfffffe00)
+
+ /* this is too small */
+ typedef u_int32_t u9fsfh_t;
+
+ struct u9fs_qid {
+ 	u9fsfh_t	path;
+ 	u_int32_t	vers;
+ };
+
+ struct	u9fsreq {
+   TAILQ_ENTRY(u9fsreq) r_chain;
+   struct u9fsreq * r_rep;
+   struct mbuf * r_mrep;
+   struct proc	*r_procp;	/* Proc that did I/O system call */
+   struct u9fsmount *r_nmp;
+
+   /* actual content of the 9P message */
+ 	char	r_type;
+ 	short	r_fid;
+ 	u_short	r_tag;
+ 	union {
+ 		struct {
+ 			u_short	oldtag;		/* Tflush */
+ 			struct u9fs_qid qid;		/* Rattach, Rwalk, Ropen, Rcreate */
+ 			char	rauth[U9FS_AUTHLEN];	/* Rattach */
+ 		} u1;
+ 		struct {
+ 			char	uname[U9FS_NAMELEN];		/* Tattach */
+ 			char	aname[U9FS_NAMELEN];		/* Tattach */
+ 			char	ticket[U9FS_TICKETLEN];	/* Tattach */
+ 			char	auth[U9FS_AUTHLEN];	/* Tattach */
+ 		} u2;
+ 		struct {
+ 			char	ename[U9FS_ERRLEN];		/* Rerror */
+ 			char	authid[U9FS_NAMELEN];	/* Rsession */
+ 			char	authdom[U9FS_DOMLEN];	/* Rsession */
+ 			char	chal[U9FS_CHALLEN];		/* Tsession/Rsession */
+ 		} u3;
+ 		struct {
+ 			u_int32_t	perm;		/* Tcreate */
+ 			short	newfid;		/* Tclone, Tclwalk */
+ 			char	name[U9FS_NAMELEN];	/* Twalk, Tclwalk, Tcreate */
+ 			char	mode;		/* Tcreate, Topen */
+ 		} u4;
+ 		struct {
+ 			u_int64_t	offset;		/* Tread, Twrite */
+ 			u_short	        count;		/* Tread, Twrite, Rread */
+ 			char	*data;		/* Twrite, Rread */
+ 		} u5;
+ 			char	stat[U9FS_DIRLEN];	/* Twstat, Rstat */
+ 	} u;
+ };
+
+ #define r_oldtag u.u1.oldtag
+ #define r_qid u.u1.qid
+ #define r_rauth u.u1.rauth
+ #define r_uname u.u2.uname
+ #define r_aname u.u2.aname
+ #define r_ticket  u.u2.ticket
+ #define r_auth  u.u2.auth
+ #define r_ename  u.u3.ename
+ #define r_authid  u.u3.authid
+ #define r_authdom  u.u3.authdom
+ #define r_chal  u.u3.chal
+ #define r_perm  u.u4.perm
+ #define r_newfid  u.u4.newfid
+ #define r_name  u.u4.name
+ #define r_mode  u.u4.mode
+ #define r_offset  u.u5.offset
+ #define r_count  u.u5.count
+ #define r_data  u.u5.data
+ #define r_stat  u.stat
+
+ struct u9fsdir {
+   char	dir_name[U9FS_NAMELEN];
+   char	dir_uid[U9FS_NAMELEN];
+   char	dir_gid[U9FS_NAMELEN];
+   struct u9fs_qid	dir_qid;
+   u_int32_t	dir_mode;
+   u_int32_t	dir_atime;
+   u_int32_t	dir_mtime;
+   union {
+     u_int64_t	length;
+     struct {	/* little endian */
+       u_int32_t	llength;
+       u_int32_t	hlength;
+     } l;
+   } u;
+   u_short	dir_type;
+   u_short	dir_dev;
+ };
+
+ #define dir_length u.length
+ #define dir_llength u.l.llength
+ #define dir_hlength u.l.hlength
+
+ enum
+ {
+ 	Tnop =		50,
+ 	Rnop,
+ 	Tosession =	52,	/* illegal */
+ 	Rosession,		/* illegal */
+ 	Terror =	54,	/* illegal */
+ 	Rerror,
+ 	Tflush =	56,
+ 	Rflush,
+ 	Toattach =	58,	/* illegal */
+ 	Roattach,		/* illegal */
+ 	Tclone =	60,
+ 	Rclone,
+ 	Twalk =		62,
+ 	Rwalk,
+ 	Topen =		64,
+ 	Ropen,
+ 	Tcreate =	66,
+ 	Rcreate,
+ 	Tread =		68,
+ 	Rread,
+ 	Twrite =	70,
+ 	Rwrite,
+ 	Tclunk =	72,
+ 	Rclunk,
+ 	Tremove =	74,
+ 	Rremove,
+ 	Tstat =		76,
+ 	Rstat,
+ 	Twstat =	78,
+ 	Rwstat,
+ 	Tclwalk =	80,
+ 	Rclwalk,
+ 	Tauth =		82,	/* illegal */
+ 	Rauth,			/* illegal */
+ 	Tsession =	84,
+ 	Rsession,
+ 	Tattach =	86,
+ 	Rattach,
+ 	Ttunnel =	88,
+ 	Rtunnel,
+ 	Tmax
+ };
+
+ int u9p_m2s __P((char *ap, int n, struct u9fsreq *f));
+ int u9p_s2m __P((struct u9fsreq *f, char *ap, int copydata));
+ int u9p_m2d __P((char *ap, struct u9fsdir *f));
+ int u9p_d2m __P((struct u9fsdir *f, char *ap));
+ int u9p_type __P((char * t));
+
+ int u9p_m_m2s __P((struct mbuf **m, struct u9fsreq *f));
+ struct mbuf * u9p_m_s2m __P((struct u9fsreq *f));
+ int u9p_m_m2d __P((struct mbuf **m, struct u9fsdir *f));
+ struct mbuf * u9p_m_d2m __P((struct u9fsdir *f));
+ u_short u9p_m_tag __P((struct mbuf **m));
+
+ #endif
diff -N -c -r /usr/src/sys/9fs/bitstring.h ./9fs/bitstring.h
*** /usr/src/sys/9fs/bitstring.h	Wed Dec 31 19:00:00 1969
--- ./9fs/bitstring.h	Thu Oct 21 12:34:50 1999
***************
*** 0 ****
--- 1,143 ----
+ /*
+  * Copyright (c) 1989, 1993
+  *	The Regents of the University of California.  All rights reserved.
+  *
+  * This code is derived from software contributed to Berkeley by
+  * Paul Vixie.
+  *
+  * Redistribution and use in source and binary forms, with or without
+  * modification, are permitted provided that the following conditions
+  * are met:
+  * 1. Redistributions of source code must retain the above copyright
+  *    notice, this list of conditions and the following disclaimer.
+  * 2. Redistributions in binary form must reproduce the above copyright
+  *    notice, this list of conditions and the following disclaimer in the
+  *    documentation and/or other materials provided with the distribution.
+  * 3. All advertising materials mentioning features or use of this software
+  *    must display the following acknowledgement:
+  *	This product includes software developed by the University of
+  *	California, Berkeley and its contributors.
+  * 4. Neither the name of the University nor the names of its contributors
+  *    may be used to endorse or promote products derived from this software
+  *    without specific prior written permission.
+  *
+  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+  * SUCH DAMAGE.
+  *
+  *	@(#)bitstring.h	8.1 (Berkeley) 7/19/93
+  */
+
+ #ifndef _BITSTRING_H_
+ #define	_BITSTRING_H_
+
+ typedef	unsigned char bitstr_t;
+
+ /* internal macros */
+ 				/* byte of the bitstring bit is in */
+ #define	_bit_byte(bit) \
+ 	((bit) >> 3)
+
+ 				/* mask for the bit within its byte */
+ #define	_bit_mask(bit) \
+ 	(1 << ((bit)&0x7))
+
+ /* external macros */
+ 				/* bytes in a bitstring of nbits bits */
+ #define	bitstr_size(nbits) \
+ 	((((nbits) - 1) >> 3) + 1)
+
+ 				/* allocate a bitstring */
+ #define	bit_alloc(space, nbits, type, flags) \
+ 	MALLOC((space), bitstr_t *, \
+         (u_int)bitstr_size(nbits)*sizeof(bitstr_t), (type), (flags))
+
+ 				/* allocate a bitstring on the stack */
+ #define	bit_decl(name, nbits) \
+ 	(name)[bitstr_size(nbits)]
+
+ 				/* is bit N of bitstring name set? */
+ #define	bit_test(name, bit) \
+ 	((name)[_bit_byte(bit)] & _bit_mask(bit))
+
+ 				/* set bit N of bitstring name */
+ #define	bit_set(name, bit) \
+ 	(name)[_bit_byte(bit)] |= _bit_mask(bit)
+
+ 				/* clear bit N of bitstring name */
+ #define	bit_clear(name, bit) \
+ 	(name)[_bit_byte(bit)] &= ~_bit_mask(bit)
+
+ 				/* clear bits start ... stop in bitstring */
+ #define	bit_nclear(name, start, stop) { \
+ 	register bitstr_t *_name = name; \
+ 	register int _start = start, _stop = stop; \
+ 	register int _startbyte = _bit_byte(_start); \
+ 	register int _stopbyte = _bit_byte(_stop); \
+ 	if (_startbyte == _stopbyte) { \
+ 		_name[_startbyte] &= ((0xff >> (8 - (_start&0x7))) | \
+ 				      (0xff << ((_stop&0x7) + 1))); \
+ 	} else { \
+ 		_name[_startbyte] &= 0xff >> (8 - (_start&0x7)); \
+ 		while (++_startbyte < _stopbyte) \
+ 			_name[_startbyte] = 0; \
+ 		_name[_stopbyte] &= 0xff << ((_stop&0x7) + 1); \
+ 	} \
+ }
+
+ 				/* set bits start ... stop in bitstring */
+ #define	bit_nset(name, start, stop) { \
+ 	register bitstr_t *_name = name; \
+ 	register int _start = start, _stop = stop; \
+ 	register int _startbyte = _bit_byte(_start); \
+ 	register int _stopbyte = _bit_byte(_stop); \
+ 	if (_startbyte == _stopbyte) { \
+ 		_name[_startbyte] |= ((0xff << (_start&0x7)) & \
+ 				    (0xff >> (7 - (_stop&0x7)))); \
+ 	} else { \
+ 		_name[_startbyte] |= 0xff << ((_start)&0x7); \
+ 		while (++_startbyte < _stopbyte) \
+ 	    		_name[_startbyte] = 0xff; \
+ 		_name[_stopbyte] |= 0xff >> (7 - (_stop&0x7)); \
+ 	} \
+ }
+
+ 				/* find first bit clear in name */
+ #define	bit_ffc(name, nbits, value) { \
+ 	register bitstr_t *_name = name; \
+ 	register int _byte, _nbits = nbits; \
+ 	register int _stopbyte = _bit_byte(_nbits), _value = -1; \
+ 	for (_byte = 0; _byte <= _stopbyte; ++_byte) \
+ 		if (_name[_byte] != 0xff) { \
+ 			_value = _byte << 3; \
+ 			for (_stopbyte = _name[_byte]; (_stopbyte&0x1); \
+ 			    ++_value, _stopbyte >>= 1); \
+ 			break; \
+ 		} \
+ 	*(value) = _value; \
+ }
+
+ 				/* find first bit set in name */
+ #define	bit_ffs(name, nbits, value) { \
+ 	register bitstr_t *_name = name; \
+ 	register int _byte, _nbits = nbits; \
+ 	register int _stopbyte = _bit_byte(_nbits), _value = -1; \
+ 	for (_byte = 0; _byte <= _stopbyte; ++_byte) \
+ 		if (_name[_byte]) { \
+ 			_value = _byte << 3; \
+ 			for (_stopbyte = _name[_byte]; !(_stopbyte&0x1); \
+ 			    ++_value, _stopbyte >>= 1); \
+ 			break; \
+ 		} \
+ 	*(value) = _value; \
+ }
+
+ #endif /* !_BITSTRING_H_ */
diff -N -c -r /usr/src/sys/conf/files ./conf/files
*** /usr/src/sys/conf/files	Fri Apr 30 15:32:40 1999
--- ./conf/files	Thu Nov 25 15:34:34 1999
***************
*** 535,540 ****
--- 535,541 ----
  netinet/tcp_timer.c	optional inet
  netinet/tcp_usrreq.c	optional inet
  netinet/udp_usrreq.c	optional inet
+ netinet/il.c		optional  il
  netipx/ipx.c		optional ipx
  netipx/ipx_cksum.c	optional ipx
  netipx/ipx_input.c	optional ipx
***************
*** 571,576 ****
--- 572,586 ----
  nfs/nfs_syscalls.c	optional nfs
  nfs/nfs_vfsops.c	optional nfs
  nfs/nfs_vnops.c		optional nfs
+ 9fs/9fs_vfsops.c	optional u9fs
+ 9fs/9fs_vnops.c		optional u9fs
+ 9fs/9p.c		optional u9fs
+ 9fs/9auth.c		optional u9fs
+ 9fs/9crypt.c		optional u9fs
+ 9fs/9fs_subr.c		optional u9fs
+ 9fs/9fs_socket.c	optional u9fs
+ 9fs/9fs_bio.c		optional u9fs
+ 9fs/9fs_node.c		optional u9fs
  nfs/bootp_subr.c	optional bootp
  nfs/krpc_subr.c		optional bootp
  pccard/pccard.c		optional card
diff -N -c -r /usr/src/sys/conf/options ./conf/options
*** /usr/src/sys/conf/options	Tue May 11 01:35:28 1999
--- ./conf/options	Mon Oct 11 19:59:14 1999
***************
*** 202,207 ****
--- 202,208 ----
  BRIDGE			opt_bdg.h
  MROUTING		opt_mrouting.h
  INET			opt_inet.h
+ IL			opt_inet.h
  IPDIVERT
  DUMMYNET		opt_ipdn.h
  IPFIREWALL		opt_ipfw.h
***************
*** 314,319 ****
--- 315,322 ----
  NFS_MUIDHASHSIZ		opt_nfs.h
  NFS_NOSERVER		opt_nfs.h
  NFS_DEBUG		opt_nfs.h
+
+ U9FS

  # give bktr an opt_bktr.h file
  OVERRIDE_CARD		opt_bktr.h
diff -N -c -r /usr/src/sys/i386/conf/IL ./i386/conf/IL
*** /usr/src/sys/i386/conf/IL	Wed Dec 31 19:00:00 1969
--- ./i386/conf/IL	Sat Oct 23 14:01:36 1999
***************
*** 0 ****
--- 1,234 ----
+ #
+ # GENERIC -- Generic machine with WD/AHx/NCR/BTx family disks
+ #
+ # For more information read the handbook part System Administration ->
+ # Configuring the FreeBSD Kernel -> The Configuration File.
+ # The handbook is available in /usr/share/doc/handbook or online as
+ # latest version from the FreeBSD World Wide Web server
+ # <URL:http://www.FreeBSD.ORG/>
+ #
+ # An exhaustive list of options and more detailed explanations of the
+ # device lines is present in the ./LINT configuration file. If you are
+ # in doubt as to the purpose or necessity of a line, check first in LINT.
+ #
+ #	$Id: GENERIC,v 1.143.2.2 1999/02/15 02:50:07 des Exp $
+
+ machine		"i386"
+ cpu		"I586_CPU"
+ cpu		"I686_CPU"
+ ident		GENERIC
+ maxusers	128
+
+ #options		DDB
+ options		IL			# plan9's IL
+ options		"U9FS"			# plan9's 9fs client
+ options		INET			#InterNETworking
+ options		FFS			#Berkeley Fast Filesystem
+ options		FFS_ROOT		#FFS usable as root device [keep this!]
+ options		MFS			#Memory Filesystem
+ options		MFS_ROOT		#MFS usable as root device, "MFS" req'ed
+ options		NFS			#Network Filesystem
+ options		NFS_ROOT		#NFS usable as root device, "NFS" req'ed
+ options		"CD9660"		#ISO 9660 Filesystem
+ options		"CD9660_ROOT"		#CD-ROM usable as root. "CD9660" req'ed
+ options		PROCFS			#Process filesystem
+ options         FDESC                   #File descriptor filesystem
+ options		"COMPAT_43"		#Compatible with BSD 4.3 [KEEP THIS!]
+ options		SCSI_DELAY=15000	#Be pessimistic about Joe SCSI device
+ options		UCONSOLE		#Allow users to grab the console
+ options		FAILSAFE		#Be conservative
+ options		USERCONFIG		#boot -c editor
+ options		VISUAL_USERCONFIG	#visual boot -c editor
+ options		NMBCLUSTERS=4096
+ options		MAXFILES=10000
+
+ config		kernel	root on wd0
+
+ # To make an SMP kernel, the next two are needed
+ #options	SMP			# Symmetric MultiProcessor Kernel
+ #options	APIC_IO			# Symmetric (APIC) I/O
+ # Optionally these may need tweaked, (defaults shown):
+ #options	NCPU=2			# number of CPUs
+ #options	NBUS=4			# number of busses
+ #options	NAPIC=1			# number of IO APICs
+ #options	NINTR=24		# number of INTs
+
+ controller	isa0
+ controller	eisa0
+ controller	pci0
+
+ controller	fdc0	at isa? port "IO_FD1" bio irq 6 drq 2
+ disk		fd0	at fdc0 drive 0
+ disk		fd1	at fdc0 drive 1
+
+ options		"CMD640"	# work around CMD640 chip deficiency
+ controller	wdc0	at isa? port "IO_WD1" bio irq 14 flags 0xa0ff vector wdintr
+ disk		wd0	at wdc0 drive 0
+ disk		wd1	at wdc0 drive 1
+
+ controller	wdc1	at isa? port "IO_WD2" bio irq 15 flags 0xa0ff vector wdintr
+ disk		wd2	at wdc1 drive 0
+ disk		wd3	at wdc1 drive 1
+
+ options		ATAPI		#Enable ATAPI support for IDE bus
+ options		ATAPI_STATIC	#Don't do it as an LKM
+ #device		acd0		#IDE CD-ROM
+ #device		wfd0		#IDE Floppy (e.g. LS-120)
+
+ # A single entry for any of these controllers (ncr, ahb, ahc) is
+ # sufficient for any number of installed devices.
+ #controller	ncr0
+ #controller	ahb0
+ #controller	ahc0
+ #controller	isp0
+
+ # This controller offers a number of configuration options, too many to
+ # document here  - see the LINT file in this directory and look up the
+ # dpt0 entry there for much fuller documentation on this.
+ controller      dpt0
+
+ #controller	adv0	at isa? port ? cam irq ?
+ #controller	adw0
+ #controller	bt0	at isa? port ? cam irq ?
+ #controller	aha0	at isa? port ? cam irq ?
+ #controller	aic0	at isa? port 0x340 bio irq 11
+
+ controller	scbus0
+
+ device		da0
+
+ device		sa0
+
+ device		pass0
+
+ device		cd0	#Only need one of these, the code dynamically grows
+
+ #device		wt0	at isa? port 0x300 bio irq 5 drq 1
+ #device		mcd0	at isa? port 0x300 bio irq 10
+
+ #controller	matcd0	at isa? port 0x230 bio
+
+ #device		scd0	at isa? port 0x230 bio
+
+ # atkbdc0 controlls both the keyboard and the PS/2 mouse
+ controller	atkbdc0	at isa? port IO_KBD tty
+ device		atkbd0	at isa? tty irq 1
+ device		psm0	at isa? tty irq 12
+
+ device		vga0	at isa? port ? conflicts
+
+ # splash screen/screen saver
+ pseudo-device	splash
+
+ # syscons is the default console driver, resembling an SCO console
+ device		sc0	at isa? tty
+ # Enable this and PCVT_FREEBSD for pcvt vt220 compatible console driver
+ #device		vt0	at isa? tty
+ #options		XSERVER			# support for X server
+ #options		FAT_CURSOR		# start with block cursor
+ # If you have a ThinkPAD, uncomment this along with the rest of the PCVT lines
+ #options		PCVT_SCANSET=2		# IBM keyboards are non-std
+
+ device		npx0	at isa? port IO_NPX irq 13
+
+ #
+ # Laptop support (see LINT for more options)
+ #
+ device		apm0    at isa?	disable	flags 0x31 # Advanced Power Management
+
+ # PCCARD (PCMCIA) support
+ #controller	card0
+ #device		pcic0	at card?
+ #device		pcic1	at card?
+
+ device		sio0	at isa? port "IO_COM1" flags 0x10 tty irq 4
+ device		sio1	at isa? port "IO_COM2" tty irq 3
+ device		sio2	at isa? disable port "IO_COM3" tty irq 5
+ device		sio3	at isa? disable port "IO_COM4" tty irq 9
+
+ # Parallel port
+ device		ppc0	at isa? port? net irq 7
+ controller	ppbus0
+ device		nlpt0	at ppbus?
+ device		plip0	at ppbus?
+ device		ppi0	at ppbus?
+ #controller	vpo0	at ppbus?
+
+ #
+ # The following Ethernet NICs are all PCI devices.
+ #
+ device ax0		# ASIX AX88140A
+ device de0		# DEC/Intel DC21x4x (``Tulip'')
+ device fxp0		# Intel EtherExpress PRO/100B (82557, 82558)
+ device mx0		# Macronix 98713/98715/98725 (``PMAC'')
+ device pn0		# Lite-On 82c168/82c169 (``PNIC'')
+ device rl0		# RealTek 8129/8139
+ device tl0		# Texas Instruments ThunderLAN
+ device tx0		# SMC 9432TX (83c170 ``EPIC'')
+ device vr0		# VIA Rhine, Rhine II
+ device vx0		# 3Com 3c590, 3c595 (``Vortex'')
+ device wb0		# Winbond W89C840F
+ device xl0		# 3Com 3c90x (``Boomerang'', ``Cyclone'')
+
+ # Order is important here due to intrusive probes, do *not* alphabetize
+ # this list of network interfaces until the probes have been fixed.
+ # Right now it appears that the ie0 must be probed before ep0. See
+ # revision 1.20 of this file.
+
+ #device ed0 at isa? port 0x280 net irq 10 iomem 0xd8000
+ #device ie0 at isa? port 0x300 net irq 10 iomem 0xd0000
+ #device ep0 at isa? port 0x300 net irq 10
+ #device ex0 at isa? port? net irq?
+ #device fe0 at isa? port 0x300 net irq ?
+ #device le0 at isa? port 0x300 net irq 5 iomem 0xd0000
+ #device lnc0 at isa? port 0x280 net irq 10 drq 0
+ #device ze0 at isa? port 0x300 net irq 10 iomem 0xd8000
+ #device zp0 at isa? port 0x300 net irq 10 iomem 0xd8000
+ #device cs0 at isa? port 0x300 net irq ?
+
+ pseudo-device	loop
+ pseudo-device	ether
+ pseudo-device	sl	1
+ pseudo-device	ppp	1
+ pseudo-device	tun	1
+ pseudo-device	pty	32
+ pseudo-device	gzip		# Exec gzipped a.out's
+
+ # KTRACE enables the system-call tracing facility ktrace(2).
+ # This adds 4 KB bloat to your kernel, and slightly increases
+ # the costs of each syscall.
+ options		KTRACE		#kernel tracing
+
+ # This provides support for System V shared memory and message queues.
+ #
+ options		SYSVSHM
+ options		SYSVMSG
+
+ #  The `bpfilter' pseudo-device enables the Berkeley Packet Filter.  Be
+ #  aware of the legal and administrative consequences of enabling this
+ #  option.  The number of devices determines the maximum number of
+ #  simultaneous BPF clients programs runnable.
+ pseudo-device	bpfilter 4	#Berkeley packet filter
+
+
+ # USB support
+ #controller    uhci0
+ #controller    ohci0
+ #controller    usb0
+ #
+ # for the moment we have to specify the priorities of the device
+ # drivers explicitly by the ordering in the list below. This will
+ # be changed in the future.
+ #
+ #device        ums0
+ #device        ukbd0
+ #device        ulpt0
+ #device        uhub0
+ #device        ucom0
+ #device        umodem0
+ #device        hid0
+ #device        ugen0
+
+ #
+ #options       USB_DEBUG
+ #options       USBVERBOSE
diff -N -c -r /usr/src/sys/netinet/il.c ./netinet/il.c
*** /usr/src/sys/netinet/il.c	Wed Dec 31 19:00:00 1969
--- ./netinet/il.c	Tue Nov 23 19:16:13 1999
***************
*** 0 ****
--- 1,1147 ----
+ #include <unistd.h>
+ #include <ctype.h>
+ #include <sys/types.h>
+ #include <sys/param.h>
+ #include <sys/time.h>
+ #include <sys/systm.h>
+ #include <vm/vm_zone.h>
+
+ #include <sys/malloc.h>
+ #include <machine/param.h>
+ #include <sys/mbuf.h>
+ #include <sys/protosw.h>
+ #include <sys/socket.h>
+ #include <sys/socketvar.h>
+ #include <sys/proc.h>
+ #include <net/if.h>
+ #include <net/route.h>
+ #include <netinet/in_systm.h>
+ #include <netinet/in.h>
+ #include <netinet/in_var.h>
+ #include <netinet/if_ether.h>
+ #include <netinet/ip.h>
+ #include <netinet/ip_var.h>
+ #include <netinet/in_pcb.h>
+ #include <errno.h>
+
+ #include <netinet/il.h>
+ #include <netinet/il_var.h>
+
+ struct ilpcb * il_drop(struct ilpcb *ilpcb, int errno0);
+ static struct ilpcb * il_close(struct ilpcb *ilpcb);
+
+ /* kernel protocol states needed */
+ static struct inpcbhead ilb;
+ static struct inpcbinfo ilbinfo;
+
+ u_long il_sendspace = 1024*64;
+ u_long il_recvspace = 1024*64;
+
+ /*
+  * Target size of IL PCB hash tables. Must be a power of two.
+  *
+  * Note that this can be overridden by the kernel environment
+  * variable net.inet.tcp.tcbhashsize
+  */
+ #ifndef ILBHASHSIZE
+ #define ILBHASHSIZE	512
+ #endif
+
+ enum				/* Connection state */
+ {
+ 	ILS_CLOSED,
+ 	ILS_SYNCER,
+ 	ILS_SYNCEE,
+ 	ILS_ESTABLISHED,
+ 	ILS_LISTENING,
+ 	ILS_CLOSING,
+ 	ILS_OPENING,		/* only for file server */
+ };
+
+ char	*ilstates[] =
+ {
+ 	"Closed",
+ 	"Syncer",
+ 	"Syncee",
+ 	"Established",
+ 	"Listening",
+ 	"Closing",
+ 	"Opening",		/* only for file server */
+ };
+
+ enum				/* Packet types */
+ {
+ 	ILT_SYNC,
+ 	ILT_DATA,
+ 	ILT_DATAQUERY,
+ 	ILT_ACK,
+ 	ILT_QUERY,
+ 	ILT_STATE,
+ 	ILT_CLOSE
+ };
+
+ char	*iltype[] =
+ {
+ 	"sync",
+ 	"data",
+ 	"dataquery",
+ 	"ack",
+ 	"query",
+ 	"state",
+ 	"close",
+ };
+
+ /*
+  * This is the actual shape of what we allocate using the zone
+  * allocator.  Doing it this way allows us to protect both structures
+  * using the same generation count, and also eliminates the overhead
+  * of allocating tcpcbs separately.  By hiding the structure here,
+  * we avoid changing most of the rest of the code (although it needs
+  * to be changed, eventually, for greater efficiency).
+  */
+ #define	ALIGNMENT	32
+ #define	ALIGNM1		(ALIGNMENT - 1)
+ struct	inp_ilpcb {
+ 	union {
+ 		struct	inpcb inp;
+ 		char	align[(sizeof(struct inpcb) + ALIGNM1) & ~ALIGNM1];
+ 	} inp_tp_u;
+ 	struct	ilpcb ilpcb;
+ };
+ #undef ALIGNMENT
+ #undef ALIGNM1
+
+ static __inline struct mbuf * il_segq_top(struct ilpcb * ilpcb)
+ {
+   return (ilpcb->segq);
+ }
+
+ static __inline void il_segq_dequeue(struct ilpcb * ilpcb)
+ {
+   struct mbuf * m = ilpcb->segq;
+   ilpcb->segq = m->m_nextpkt;
+   m->m_nextpkt = 0;
+ }
+
+ static __inline void il_segq_insert(struct ilpcb * ilpcb, struct mbuf * m, u_long seq, struct ilhdr * il)
+ {
+   u_long pseq;
+   struct mbuf * mp, * mq;
+
+   m->m_pkthdr.header = il;
+
+   mp = 0;
+   mq = ilpcb->segq;
+   while ( mq ) {
+     il = mq->m_pkthdr.header;
+     pseq = ntohl(*(u_long *)il->ilid);
+     if( pseq > seq )
+       break;
+     if( pseq == seq ) { /* we already got this packet */
+       m_freem(m);
+       return;
+     }
+     mp = mq;
+     mq = mq->m_nextpkt;
+   }
+
+   if( mp == 0 ) {
+     m->m_nextpkt = ilpcb->segq;
+     ilpcb->segq = m;
+     return;
+   }
+   mp->m_nextpkt = m;
+   m->m_nextpkt = mq;
+ }
+
+ void il_init()
+ {
+   LIST_INIT(&ilb);
+   ilbinfo.listhead = &ilb;
+   ilbinfo.hashbase = hashinit(ILBHASHSIZE, M_PCB, &ilbinfo.hashmask);
+   ilbinfo.porthashbase = hashinit(ILBHASHSIZE, M_PCB,
+ 				  &ilbinfo.porthashmask);
+   ilbinfo.ipi_zone = zinit("ilpcb", sizeof(struct inp_ilpcb), maxsockets,
+ 			   ZONE_INTERRUPT, 0);
+ }
+
+ /* fill in il header and cksum, ip src/dst addresses */
+ static int il_output(struct ilpcb * ilpcb, struct mbuf *m, int type, u_long seq, u_char spec)
+ {
+   struct ilhdr * il;
+   struct ip * ip;
+   int illen;
+   struct inpcb * inp;
+   struct socket * so;
+
+   /* XXX: check total size is less than IP_MAXPACKET */
+
+   if( m == 0 ) {
+     inp = ilpcb->inpcb;
+     so = inp->inp_socket;
+     m = m_copypacket(so->so_snd.sb_mb, M_DONTWAIT);
+   }
+
+   /*
+    * Calculate data length and get a mbuf
+    * for IL and IP headers.
+    */
+   illen = m->m_pkthdr.len; /* size of il payload */
+   M_PREPEND(m, sizeof(struct ip) + sizeof(struct ilhdr), M_DONTWAIT);
+   if( m == 0 )
+     return ENOBUFS;
+
+   ip = mtod(m, struct ip *);
+   il = (struct ilhdr *) (ip+1);
+   bzero(ip, sizeof(*ip));
+
+   ip->ip_p = IPPROTO_IL;
+   ip->ip_src = ilpcb->inpcb->inp_laddr;
+   ip->ip_dst = ilpcb->inpcb->inp_faddr;
+   ip->ip_len = m->m_pkthdr.len;
+   ip->ip_ttl = ilpcb->inpcb->inp_ip_ttl;	/* XXX */
+   ip->ip_tos = ilpcb->inpcb->inp_ip_tos;	/* XXX */
+
+   *(u_short *)il->illen = htons(illen + sizeof(struct ilhdr));
+   il->iltype = type;
+   il->ilspec = spec;
+   *(u_short *)il->ilsrc = ilpcb->inpcb->inp_lport;
+   *(u_short *)il->ildst = ilpcb->inpcb->inp_fport;
+   if ( type != ILT_SYNC )
+     *(u_long *)il->ilid = htonl(seq);
+   else
+     *(u_long *)il->ilid = htonl(ilpcb->start);
+
+   if( type != ILT_ACK && type != ILT_STATE) {
+     if( ilpcb->rxt_timer == 0 )
+       ilpcb->rxt_timer = ilpcb->rxt_timer_cur;
+     if( ilpcb->death_timer == 0 )
+       ilpcb->death_timer = ilpcb->death_timer_cur;
+   }
+
+   *(u_long *)il->ilack = htonl(ilpcb->recvd);
+   il->ilsum[0] = il->ilsum[1] = 0;
+
+   /* IL checksum does not cover IP header */
+   m->m_data += sizeof(struct ip);
+   m->m_len  -= sizeof(struct ip);
+   *(u_short *)il->ilsum = in_cksum(m, illen + sizeof(struct ilhdr));
+   m->m_data -= sizeof(struct ip);
+   m->m_len  += sizeof(struct ip);
+
+   return ip_output(m, ilpcb->inpcb->inp_options, &ilpcb->inpcb->inp_route,
+ 		   ilpcb->inpcb->inp_socket->so_options & SO_DONTROUTE ,0);
+ }
+
+ static int il_send_empty(struct ilpcb * ilpcb, int type, u_char spec)
+ {
+   struct mbuf * m0;
+
+   MGETHDR(m0, M_DONTWAIT, MT_DATA);
+   m0->m_len = 0;
+   m0->m_pkthdr.len = 0;
+   MH_ALIGN(m0, 0); /* leave space for the packet header */
+
+   return il_output(ilpcb, m0, type, ilpcb->next, spec);
+ }
+
+ static int il_respond(struct ilpcb * ilpcb, struct ip * ip, struct ilhdr *il, int type, u_char spec)
+ {
+   struct mbuf * m;
+   int illen;
+   struct ip * ip0;
+   struct ilhdr *il0;
+   struct route * ro;
+   struct route sro;
+
+   if( ilpcb ) {
+     ro = & ilpcb->inpcb->inp_route;
+   } else {
+     ro = &sro;
+     bzero(ro, sizeof *ro);
+   }
+
+   MGETHDR(m, M_DONTWAIT, MT_DATA);
+   m->m_len = 0;
+   m->m_pkthdr.len = 0;
+   MH_ALIGN(m, 0); /* leave space for the packet header */
+   illen = m->m_pkthdr.len; /* size of il payload */
+   M_PREPEND(m, sizeof(struct ip) + sizeof(struct ilhdr), M_DONTWAIT);
+   if( m == 0 )
+     return ENOBUFS;
+
+   ip0 = mtod(m, struct ip *);
+   il0 = (struct ilhdr *) (ip0+1);
+   bzero(ip0, sizeof(*ip0));
+
+   ip0->ip_p = IPPROTO_IL;
+   ip0->ip_src = ip->ip_dst;
+   ip0->ip_dst = ip->ip_src;
+   ip0->ip_ttl = ip_defttl;
+   ip0->ip_len = sizeof(struct ip) + sizeof(struct ilhdr);
+   *(u_short *)il0->illen = htons(illen + sizeof(struct ilhdr));
+   il0->iltype = type;
+   il0->ilspec = spec;
+   bcopy(il->ilsrc, il0->ildst, 2);
+   bcopy(il->ildst, il0->ilsrc, 2);
+   *(u_long *)il0->ilid = 0;
+   bcopy(il->ilid, il0->ilack, 4);
+   il0->ilsum[0] = il0->ilsum[1] = 0;
+
+   /* IL checksum does not cover IP header */
+   m->m_data += sizeof(struct ip);
+   m->m_len  -= sizeof(struct ip);
+   *(u_short *)il0->ilsum = in_cksum(m, illen + sizeof(struct ilhdr));
+   m->m_data -= sizeof(struct ip);
+   m->m_len  += sizeof(struct ip);
+
+   return ip_output(m, 0, ro, 0 ,0);
+ }
+
+ static struct ilpcb *
+ il_newconn(struct ilpcb * ilpcb, struct in_addr ti_dst, u_short ti_dport,
+ 	   struct in_addr ti_src, u_short ti_sport)
+ {
+   register struct ilpcb * ilpcb0;
+   struct socket *so2, * so;
+   struct inpcb * inp;
+   struct sockaddr_in sin;
+
+   so = ilpcb->inpcb->inp_socket;
+   so2 = sonewconn(so, 0);
+   if (so2 == 0) {
+     so2 = sodropablereq(so);
+     if (so2) {
+       il_drop(sotoilpcb(so2), ETIMEDOUT);
+       so2 = sonewconn(so, 0);
+     }
+     if (!so2)
+       return 0;
+   }
+   so = so2;
+
+   inp = (struct inpcb *)so->so_pcb;
+   inp->inp_laddr = ti_dst;
+   inp->inp_lport = ti_dport;
+   if (in_pcbinshash(inp) != 0) {
+ 				/*
+ 				 * Undo the assignments above if we failed to put
+ 				 * the PCB on the hash lists.
+ 				 */
+     inp->inp_laddr.s_addr = INADDR_ANY;
+     inp->inp_lport = 0;
+
+     soabort(so);
+     return 0;
+   }
+
+   bzero((char *)&sin, sizeof(sin));
+   sin.sin_family = AF_INET;
+   sin.sin_len = sizeof(sin);
+   sin.sin_addr = ti_src;
+   sin.sin_port = ti_sport;
+   if (in_pcbconnect(inp, (struct sockaddr *)&sin, &proc0)) {
+     inp->inp_laddr.s_addr = INADDR_ANY;
+     soabort(so);
+     return 0;
+   }
+
+   ilpcb0 = intoilpcb(inp);
+   ilpcb0->state = ILS_LISTENING;
+
+   return ilpcb0;
+ }
+
+ /* ack processing */
+ static void il_proc_ack(struct ilpcb * ilpcb, struct socket * so, u_long ack)
+ {
+   if( ack >= ilpcb->unacked ) {
+     ilpcb->rxt_timer = 0;
+     ilpcb->death_timer = 0;
+
+     /* the rxt timer is not prop. to RTT */
+     /* reset it so that the first rxt is always 1 second */
+     ilpcb->rxt_timer_cur = 2;
+
+     if( ack >= ilpcb->next )
+       ack = ilpcb->next - 1;
+     while (ilpcb->unacked <= ack ) {
+       sbdroprecord(&so->so_snd);
+       ilpcb->unacked++;
+     }
+     if( ilpcb->unacked != ilpcb->next ) {
+       ilpcb->rxt_timer = ilpcb->rxt_timer_cur;
+       ilpcb->death_timer = ilpcb->death_timer_cur; /* do we need this here? */
+     }
+     sowwakeup(so);
+   }
+ }
+
+ static int il_proc_data(struct ilpcb * ilpcb, struct socket * so, struct mbuf * m, u_long seq, int spec)
+ {
+   struct mbuf * m0;
+   struct ip * ip;
+   int hlen = sizeof(struct ip) + sizeof(struct ilhdr);
+   struct ilhdr * il;
+   int needack = 0;
+
+   ip = mtod(m, struct ip *);
+   il = (struct ilhdr *)(ip+1);
+   if( seq == ilpcb->recvd + 1 ) {
+     needack = 1;
+     while(1) {
+       ilpcb->recvd = seq;
+
+       m->m_len -= hlen;
+       m->m_pkthdr.len -= hlen;
+       m->m_data += hlen;
+       sbappendrecord(&so->so_rcv, m);
+
+       if( (m0 = il_segq_top(ilpcb)) == 0 )
+ 	break;
+       ip = mtod(m0, struct ip *);
+       il = (struct ilhdr *)(ip+1);
+       seq = ntohl(*(u_long *)il->ilid);
+       if( seq != ilpcb->recvd + 1 )
+ 	break;
+       il_segq_dequeue(ilpcb);
+       m = m0;
+     };
+     sorwakeup(so);
+   } else {
+     if( seq > ilpcb->recvd )
+       il_segq_insert(ilpcb, m, seq, il);
+     else
+       m_freem(m);
+   }
+
+   return needack;
+ }
+
+ /* assume we only have one connection */
+ void il_input(struct mbuf * m, int iphlen)
+ {
+   struct ilhdr * il;
+   struct ilpcb * ilpcb = 0;
+   int len, type;
+   u_long seq, ack;
+   struct ip * ip;
+   struct inpcb * inp;
+   u_short sport, dport;
+   struct socket * so;
+   u_char spec;
+
+   /*
+    * Strip IP options, if any; should skip this,
+    * make available to user, and use on returned packets,
+    * but we don't yet have a way to check the checksum
+    * with options still present.
+    */
+   if (iphlen > sizeof (struct ip)) {
+     ip_stripoptions(m, (struct mbuf *)0);
+     iphlen = sizeof(struct ip);
+   }
+
+   /*
+    * Get IP and IL header together in first mbuf.
+    */
+   ip = mtod(m, struct ip *);
+   if (m->m_len < iphlen + sizeof(struct ilhdr)) {
+     if ((m = m_pullup(m, iphlen + sizeof(struct ilhdr))) == 0) {
+       return;
+     }
+     ip = mtod(m, struct ip *);
+   }
+   il = (struct ilhdr *)((caddr_t)ip + iphlen);
+
+   len = ntohs(*(u_short *)il->illen);
+   seq = ntohl(*(u_long *)il->ilid);
+   ack = ntohl(*(u_long *)il->ilack);
+   sport = *(u_short *)il->ilsrc;
+   dport = *(u_short *)il->ildst;
+   type = il->iltype;
+   spec = il->ilspec;
+
+   inp = in_pcblookup_hash(&ilbinfo, ip->ip_src, sport, ip->ip_dst, dport, 1);
+   if ( inp == 0 && type == ILT_SYNC )
+     goto dropwithrest;
+   if( inp == 0 )
+     goto drop;
+
+   ilpcb = intoilpcb(inp);
+   if( ilpcb == 0 )
+     goto drop;
+
+   so = inp->inp_socket;
+   if( type == ILT_QUERY ) { /* XXX: can we use the same mbuf to send? */
+     il_send_empty(ilpcb, ILT_STATE, il->ilspec);
+     goto drop;
+   }
+
+  again:
+   /* FSM transition */
+   switch( ilpcb->state ) {
+   case ILS_SYNCER:
+     if( ack != ilpcb->start )
+       goto drop;
+     switch( type ) {
+     case ILT_SYNC:
+       ilpcb->unacked++;
+       ilpcb->recvd = seq;
+       il_send_empty(ilpcb, ILT_ACK, 0);
+       ilpcb->state = ILS_ESTABLISHED;
+       ilpcb->rxt_timer = 0;
+       ilpcb->death_timer = 0;
+       soisconnected(inp->inp_socket);
+       break;
+     case ILT_CLOSE:
+       il_drop(ilpcb, ECONNREFUSED);
+       break;
+     }
+     break;
+
+   case ILS_LISTENING:
+     if( type == ILT_SYNC && ack == 0 && so->so_options & SO_ACCEPTCONN ) {
+       ilpcb = il_newconn(ilpcb, ip->ip_dst, dport, ip->ip_src, sport);
+
+       ilpcb->next = ilpcb->start = random();
+       ilpcb->unacked = ilpcb->next;
+       ilpcb->rstart = ilpcb->recvd = seq;
+       ilpcb->state = ILS_SYNCEE;
+       il_send_empty(ilpcb, ILT_SYNC, 0);
+       ilpcb->next++;
+     } else
+       il_respond(ilpcb, ip, il, ILT_CLOSE, 0);
+     break;
+
+   case ILS_SYNCEE:
+     if( ack == ilpcb->start ) {
+       ilpcb->rxt_timer = 0;
+       ilpcb->unacked++;
+       ilpcb->state = ILS_ESTABLISHED;
+       soisconnected(so);
+       goto again;
+       break;
+     }
+     if( type == ILT_SYNC && seq == ilpcb->recvd && ack == 0 )
+       il_send_empty(ilpcb, ILT_SYNC, 0);
+     break;
+
+   case ILS_ESTABLISHED:
+     il_proc_ack(ilpcb, so, ack);
+     switch( type ) {
+     case ILT_DATA:
+       if( il_proc_data(ilpcb, so, m, seq, spec) )
+ 	ilpcb->flags |= ILF_NEEDACK;
+       goto done;
+       break;
+     case ILT_DATAQUERY:
+       il_proc_data(ilpcb, so, m, seq, spec);
+       il_send_empty(ilpcb, ILT_STATE, spec);
+       goto done;
+       break;
+     case ILT_CLOSE:
+       if( ack < ilpcb->next && ack >= ilpcb->start ) {
+ 	if( ilpcb->recvd+1 == seq )
+ 	  ilpcb->recvd = seq;
+ 	il_send_empty(ilpcb, ILT_CLOSE, 0);
+ 	ilpcb->state = ILS_CLOSING;
+       }
+       break;
+     case ILT_STATE:
+       if( ack < ilpcb->rxt_max ) {
+ 	ilpcb->rxt_max = ilpcb->next;
+ 	il_output(ilpcb, 0, ILT_DATAQUERY, ilpcb->unacked, 1);
+       }
+       break;
+     case ILT_SYNC:
+       il_send_empty(ilpcb, ILT_ACK, 0);
+       break;
+     }
+     break;
+
+   case	ILS_CLOSED:
+     goto drop;
+     break;
+
+   case ILS_CLOSING:
+     if( type == ILT_CLOSE ) {
+       if( ilpcb->recvd+1 == seq )
+ 	ilpcb->recvd = seq;
+       il_send_empty(ilpcb, ILT_CLOSE, 0);
+       ilpcb->state = ILS_CLOSED;
+       il_close(ilpcb);
+     }
+     break;
+   }
+
+   m_freem(m);
+  done:
+   return;
+
+  dropwithrest:
+   il_respond(ilpcb, ip, il, ILT_CLOSE, 0);
+  drop:
+   m_freem(m);
+ }
+
+ static void il_sendseqinit(struct ilpcb * ilpcb)
+ {
+   ilpcb->start = ilpcb->next = random();
+   ilpcb->unacked = ilpcb->next;
+   ilpcb->state = ILS_SYNCER;
+   ilpcb->next++;
+ }
+
+ static void il_rxt_timeout(struct ilpcb * ilpcb)
+ {
+   switch ( ilpcb->state ) {
+   case ILS_ESTABLISHED:
+     il_output(ilpcb, 0, ILT_DATAQUERY, ilpcb->unacked, 1);
+     ilpcb->rxtot++;
+     break;
+   case ILS_SYNCER:
+   case ILS_SYNCEE:
+     il_send_empty(ilpcb, ILT_SYNC, 0);
+     break;
+   case ILS_CLOSING:
+     il_send_empty(ilpcb, ILT_CLOSE, 0);
+     break;
+   }
+   ilpcb->rxt_timer = ilpcb->rxt_timer_cur;
+ }
+
+ void il_ctlinput(int cmd, struct sockaddr *sa, void *vip)
+ {}
+
+ int  il_ctloutput(struct socket *so, struct sockopt *sopt)
+ { return 0; }
+
+ void il_drain()
+ {}
+
+ void il_slowtimo()
+ {
+   struct ilpcb * ilpcb;
+   struct inpcb * inp;
+   int s;
+
+   s = splnet();
+   for(inp = ilb.lh_first; inp; inp = inp->inp_list.le_next) {
+     ilpcb = intoilpcb(inp);
+     if(ilpcb->death_timer &&  --ilpcb->death_timer == 0 )
+       il_drop(ilpcb, ETIMEDOUT);
+
+     if(ilpcb->rxt_timer &&  --ilpcb->rxt_timer == 0 ) {
+       ilpcb->rxt_timer_cur <<= 1;
+       il_rxt_timeout(ilpcb);
+     }
+   }
+   splx(s);
+ }
+
+ void il_fasttimo()
+ {
+   struct ilpcb * ilpcb;
+   struct inpcb * inp;
+   int s;
+
+   s = splnet();
+   for(inp = ilb.lh_first; inp; inp = inp->inp_list.le_next) {
+     ilpcb = intoilpcb(inp);
+     if(ilpcb->flags & ILF_NEEDACK) {
+       ilpcb->flags &= ~ILF_NEEDACK;
+       il_send_empty(ilpcb, ILT_ACK, 0);
+     }
+   }
+   splx(s);
+ }
+
+ static struct ilpcb * il_newilpcb(struct inpcb * inp)
+ {
+   struct inp_ilpcb *it;
+   register struct ilpcb *ilpcb;
+
+   it = (struct inp_ilpcb *)inp;
+   ilpcb = &it->ilpcb;
+   bzero((char *) ilpcb, sizeof(struct ilpcb));
+
+   ilpcb->state = ILS_CLOSED;
+   ilpcb->inpcb = inp;
+   ilpcb->rxt_timer_cur = 2;
+   ilpcb->death_timer_cur = 20;
+
+   ilpcb->inpcb = inp;	/* XXX */
+   inp->inp_ip_ttl = ip_defttl;
+   inp->inp_ppcb = (caddr_t)ilpcb;
+   return (ilpcb);		/* XXX */
+ }
+
+ /*
+  * Common subroutine to open a TCP connection to remote host specified
+  * by struct sockaddr_in in mbuf *nam.  Call in_pcbbind to assign a local
+  * port number if needed.  Call in_pcbladdr to do the routing and to choose
+  * a local host address (interface).  If there is an existing incarnation
+  * of the same connection in TIME-WAIT state and if the remote host was
+  * sending CC options and if the connection duration was < MSL, then
+  * truncate the previous TIME-WAIT state and proceed.
+  * Initialize connection parameters and enter SYN-SENT state.
+  */
+ static int
+ il_connect(struct ilpcb *ilpcb, struct sockaddr *nam, struct proc *p)
+ {
+ 	struct inpcb *inp = ilpcb->inpcb, *oinp;
+ 	struct socket *so = inp->inp_socket;
+ 	struct sockaddr_in *sin = (struct sockaddr_in *)nam;
+ 	struct sockaddr_in *ifaddr;
+ 	int error;
+
+ 	if (inp->inp_lport == 0) {
+ 		error = in_pcbbind(inp, (struct sockaddr *)0, p);
+ 		if (error)
+ 			return error;
+ 	}
+
+ 	/*
+ 	 * Cannot simply call in_pcbconnect, because there might be an
+ 	 * earlier incarnation of this same connection still in
+ 	 * TIME_WAIT state, creating an ADDRINUSE error.
+ 	 */
+ 	error = in_pcbladdr(inp, nam, &ifaddr);
+ 	if (error)
+ 		return error;
+ 	oinp = in_pcblookup_hash(inp->inp_pcbinfo,
+ 	    sin->sin_addr, sin->sin_port,
+ 	    inp->inp_laddr.s_addr != INADDR_ANY ? inp->inp_laddr
+ 						: ifaddr->sin_addr,
+ 	    inp->inp_lport,  0);
+ 	if (oinp) {
+ 			return EADDRINUSE;
+ 	}
+ 	if (inp->inp_laddr.s_addr == INADDR_ANY)
+ 		inp->inp_laddr = ifaddr->sin_addr;
+ 	inp->inp_faddr = sin->sin_addr;
+ 	inp->inp_fport = sin->sin_port;
+ 	in_pcbrehash(inp);
+
+ #if 0
+ 	ilpcb->t_template = tcp_template(tp);
+ 	if (ilpcb->t_template == 0) {
+ 		in_pcbdisconnect(inp);
+ 		return ENOBUFS;
+ 	}
+ #endif
+
+ 	soisconnecting(so);
+ 	il_sendseqinit(ilpcb);
+
+ 	return 0;
+ }
+
+ static int il_usr_send(struct socket *so, int flags, struct mbuf * m, struct sockaddr *addr, struct mbuf *control, struct proc *p)
+ {
+   struct ilpcb * ilpcb;
+   struct inpcb * inp = sotoinpcb(so);
+   int error;
+   struct mbuf * m0;
+
+   if (inp == 0) {
+     m_freem(m);
+     return EINVAL;
+   }
+   ilpcb = intoilpcb(inp);
+
+   if (sbspace(&so->so_snd) < -512) {
+     m_freem(m);
+     error = ENOBUFS;
+     goto out;
+   }
+
+   sbappendrecord(&so->so_snd, m);
+   m0 = m_copypacket(m, M_DONTWAIT);
+   error = il_output(ilpcb, m0, ILT_DATA, ilpcb->next++, 0);
+
+  out:
+   return error;
+ }
+
+ static int il_usr_attach(struct socket *so, int proto, struct proc *p)
+ {
+   int s = splnet();
+   int error = 0;
+   struct inpcb *inp = sotoinpcb(so);
+   struct ilpcb *ilpcb = 0;
+
+   if (inp) {
+     error = EISCONN;
+     goto out;
+   }
+
+   if (so->so_snd.sb_hiwat == 0 || so->so_rcv.sb_hiwat == 0) {
+     error = soreserve(so, il_sendspace, il_recvspace);
+     if (error)
+       goto out;
+   }
+
+   error = in_pcballoc(so, &ilbinfo, p);
+
+   if (error)
+     goto out;
+
+   inp = sotoinpcb(so);
+   ilpcb = il_newilpcb(inp);
+   if (ilpcb == 0) {
+     int nofd = so->so_state & SS_NOFDREF;	/* XXX */
+
+     so->so_state &= ~SS_NOFDREF;	/* don't free the socket yet */
+     in_pcbdetach(inp);
+     so->so_state |= nofd;
+     error = ENOBUFS;
+     goto out;
+   }
+   ilpcb->state = ILS_CLOSED;
+   ilpcb->segq = 0;
+
+  out:
+   splx(s);
+   return error;
+
+ }
+
+ static int il_usr_bind(struct socket *so, struct sockaddr *nam, struct proc *p)
+ {
+   int s = splnet();
+   int error = 0;
+   struct inpcb *inp = sotoinpcb(so);
+   struct ilpcb *ilpcb;
+   struct sockaddr_in *sinp;
+
+   if (inp == 0) {
+     splx(s);
+     return EINVAL;
+   }
+   ilpcb = intoilpcb(inp);
+
+ 	/*
+ 	 * Must check for multicast addresses and disallow binding
+ 	 * to them.
+ 	 */
+   sinp = (struct sockaddr_in *)nam;
+   if (sinp->sin_family == AF_INET &&
+       IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) {
+     error = EAFNOSUPPORT;
+     goto out;
+   }
+   error = in_pcbbind(inp, nam, p);
+  out: splx(s);
+   return error;
+ }
+
+ /*
+  * Initiate connection to peer.
+  * Create a template for use in transmissions on this connection.
+  * Enter SYN_SENT state, and mark socket as connecting.
+  * Start keep-alive timer, and seed output sequence space.
+  * Send initial segment on connection.
+  */
+ static int
+ il_usr_connect(struct socket *so, struct sockaddr *nam, struct proc *p)
+ {
+   int s = splnet();
+   int error = 0;
+   struct inpcb *inp = sotoinpcb(so);
+   struct ilpcb *ilpcb;
+   struct sockaddr_in *sinp;
+
+   if (inp == 0) {
+     splx(s);
+     return EINVAL;
+   }
+   ilpcb = intoilpcb(inp);
+
+   /*
+    * Must disallow TCP ``connections'' to multicast addresses.
+    */
+   sinp = (struct sockaddr_in *)nam;
+   if (sinp->sin_family == AF_INET
+       && IN_MULTICAST(ntohl(sinp->sin_addr.s_addr))) {
+     error = EAFNOSUPPORT;
+     goto out;
+   }
+
+   if ((error = il_connect(ilpcb, nam, p)) != 0)
+     goto out;
+
+   error = il_send_empty(ilpcb, ILT_SYNC, 0);
+
+  out: splx(s);
+   return error;
+ }
+
+ /*
+  * Close a TCP control block:
+  *	discard all space held by the tcp
+  *	discard internet protocol block
+  *	wake up any sleepers
+  */
+ static struct ilpcb *
+ il_close(struct ilpcb *ilpcb)
+ {
+ 	register struct mbuf *q;
+ 	register struct mbuf *nq;
+ 	struct inpcb *inp = ilpcb->inpcb;
+ 	struct socket *so = inp->inp_socket;
+
+ 	/* free the reassembly queue, if any */
+ 	for (q = ilpcb->segq; q; q = nq) {
+ 		nq = q->m_nextpkt;
+ 		ilpcb->segq = nq;
+ 		m_freem(q);
+ 	}
+ 	inp->inp_ppcb = NULL;
+ 	soisdisconnected(so);
+ 	in_pcbdetach(inp);
+ 	return ((struct ilpcb *)0);
+ }
+
+ /*
+  * User issued close, and wish to trail through shutdown states:
+  * if never received SYN, just forget it.  If got a SYN from peer,
+  * but haven't sent FIN, then go to FIN_WAIT_1 state to send peer a FIN.
+  * If already got a FIN from peer, then almost done; go to LAST_ACK
+  * state.  In all other cases, have already sent FIN to peer (e.g.
+  * after PRU_SHUTDOWN), and just have to play tedious game waiting
+  * for peer to send FIN or not respond to keep-alives, etc.
+  * We can let the user exit from the close as soon as the FIN is acked.
+  */
+ static struct ilpcb *
+ il_usrclosed(struct ilpcb *ilpcb)
+ {
+
+ 	switch (ilpcb->state) {
+ 	case ILS_CLOSED:
+ 	case ILS_LISTENING:
+ 		ilpcb->state = ILS_CLOSED;
+ 		ilpcb = il_close(ilpcb);
+ 		break;
+
+ 	case ILS_SYNCER:
+ 	case ILS_SYNCEE:
+ 	case ILS_ESTABLISHED:
+ 	  il_send_empty(ilpcb, ILT_CLOSE, 0);
+ 	  ilpcb->state = ILS_CLOSING;
+ 	  break;
+
+ 	case ILS_CLOSING:
+ 		break;
+ 	}
+ 	return (ilpcb);
+ }
+
+ /*
+  * Drop a TCP connection, reporting
+  * the specified error.  If connection is synchronized,
+  * then send a RST to peer.
+  */
+ struct ilpcb *
+ il_drop(ilpcb, errno0)
+      register struct ilpcb *ilpcb;
+      int errno0;
+ {
+   struct socket *so = ilpcb->inpcb->inp_socket;
+
+   panic("il_drop");
+
+   switch(ilpcb->state) {
+   case ILS_SYNCEE:
+   case ILS_ESTABLISHED:
+   case ILS_CLOSING:
+     il_send_empty(ilpcb, ILT_CLOSE, 0);
+   default:
+     break;
+   }
+   ilpcb->state = ILS_CLOSED;
+   so->so_error = errno0;
+   return (il_close(ilpcb));
+ }
+
+ /*
+  * Initiate (or continue) disconnect.
+  * If embryonic state, just send reset (once).
+  * If in ``let data drain'' option and linger null, just drop.
+  * Otherwise (hard), mark socket disconnecting and drop
+  * current input data; switch states based on user close, and
+  * send segment to peer (with FIN).
+  */
+ static struct ilpcb *
+ il_disconnect(struct ilpcb *ilpcb)
+ {
+   struct socket *so = ilpcb->inpcb->inp_socket;
+
+   soisdisconnecting(so);
+   sbflush(&so->so_rcv);
+   ilpcb = il_usrclosed(ilpcb);
+
+   return (ilpcb);
+ }
+
+
+ /*
+  * pru_detach() detaches the IL protocol from the socket.
+  * If the protocol state is non-embryonic, then can't
+  * do this directly: have to initiate a pru_disconnect(),
+  * which may finish later; embryonic TCB's can just
+  * be discarded here.
+  */
+ static int
+ il_usr_detach(struct socket *so)
+ {
+ 	int s = splnet();
+ 	int error = 0;
+ 	struct inpcb *inp = sotoinpcb(so);
+ 	struct ilpcb *ilpcb;
+
+ 	if (inp == 0) {
+ 		splx(s);
+ 		return EINVAL;	/* XXX */
+ 	}
+ 	ilpcb = intoilpcb(inp);
+ 	ilpcb = il_disconnect(ilpcb);
+ 	splx(s);
+ 	return error;
+ }
+
+ /*
+  * Mark the connection as being incapable of further output.
+  */
+ static int
+ il_usr_shutdown(struct socket *so)
+ {
+ 	int s = splnet();
+ 	int error = 0;
+ 	struct inpcb *inp = sotoinpcb(so);
+ 	struct ilpcb *ilpcb;
+
+   if (inp == 0) {
+     splx(s);
+     return EINVAL;
+   }
+   ilpcb = intoilpcb(inp);
+
+   socantsendmore(so);
+   ilpcb = il_usrclosed(ilpcb);
+   splx(s);
+   return error;
+ }
+
+ /*
+  * Initiate disconnect from peer.
+  * If connection never passed embryonic stage, just drop;
+  * else if don't need to let data drain, then can just drop anyways,
+  * else have to begin TCP shutdown process: mark socket disconnecting,
+  * drain unread data, state switch to reflect user close, and
+  * send segment (e.g. FIN) to peer.  Socket will be really disconnected
+  * when peer sends FIN and acks ours.
+  *
+  * SHOULD IMPLEMENT LATER PRU_CONNECT VIA REALLOC TCPCB.
+  */
+ static int
+ il_usr_disconnect(struct socket *so)
+ {
+   int s = splnet();
+   int error = 0;
+   struct inpcb *inp = sotoinpcb(so);
+   struct ilpcb * ilpcb;
+
+   if (inp == 0) {
+     splx(s);
+     return EINVAL;
+   }
+   ilpcb = intoilpcb(inp);
+
+   il_disconnect(ilpcb);
+   splx(s);
+   return error;
+ }
+
+ /*
+  * Abort the TCP.
+  */
+ static int
+ il_usr_abort(struct socket *so)
+ {
+ 	int s = splnet();
+ 	int error = 0;
+ 	struct inpcb *inp = sotoinpcb(so);
+ 	struct ilpcb * ilpcb;
+
+   if (inp == 0) {
+     splx(s);
+     return EINVAL;
+   }
+   ilpcb = intoilpcb(inp);
+
+   ilpcb = il_drop(ilpcb, ECONNABORTED);
+   splx(s);
+   return error;
+
+ }
+
+ /*
+  * Prepare to accept connections.
+  */
+ static int
+ il_usr_listen(struct socket *so, struct proc *p)
+ {
+   int s = splnet();
+   int error = 0;
+   struct inpcb *inp = sotoinpcb(so);
+   struct ilpcb *ilpcb;
+
+   if (inp == 0) {
+     splx(s);
+     return EINVAL;
+   }
+   ilpcb = intoilpcb(inp);
+
+   if (inp->inp_lport == 0)
+     error = in_pcbbind(inp, (struct sockaddr *)0, p);
+   if (error == 0)
+     ilpcb->state = ILS_LISTENING;
+
+   splx(s);
+   return error;
+ }
+
+ /*
+  * Accept a connection.  Essentially all the work is
+  * done at higher levels; just return the address
+  * of the peer, storing through addr.
+  */
+ static int
+ il_usr_accept(struct socket *so, struct sockaddr **nam)
+ {
+   int s = splnet();
+   int error = 0;
+   struct inpcb *inp = sotoinpcb(so);
+   struct ilpcb * ilpcb;
+
+   if (inp == 0) {
+     splx(s);
+     return EINVAL;
+   }
+   ilpcb = intoilpcb(inp);
+
+   in_setpeeraddr(so, nam);
+   splx(s);
+   return error;
+ }
+
+ /* xxx - should be const */
+ struct pr_usrreqs il_usrreqs = {
+ 	il_usr_abort, il_usr_accept, il_usr_attach, il_usr_bind,
+ 	il_usr_connect, pru_connect2_notsupp, in_control, il_usr_detach,
+ 	il_usr_disconnect, il_usr_listen, in_setpeeraddr, pru_rcvd_notsupp,
+ 	pru_rcvoob_notsupp, il_usr_send, pru_sense_null, il_usr_shutdown,
+ 	in_setsockaddr, sosend, soreceive, sopoll
+ };
diff -N -c -r /usr/src/sys/netinet/il.h ./netinet/il.h
*** /usr/src/sys/netinet/il.h	Wed Dec 31 19:00:00 1969
--- ./netinet/il.h	Thu Sep 30 11:24:51 1999
***************
*** 0 ****
--- 1,17 ----
+
+ #ifndef NETINET_IL_H_
+ #define NETINET_IL_H_
+
+ struct ilhdr
+ {
+ 	u_char	ilsum[2];	/* Checksum including header */
+ 	u_char	illen[2];	/* Packet length */
+ 	u_char	iltype;		/* Packet type */
+ 	u_char	ilspec;		/* Special */
+ 	u_char	ilsrc[2];	/* Src port */
+ 	u_char	ildst[2];	/* Dst port */
+ 	u_char	ilid[4];	/* Sequence id */
+ 	u_char	ilack[4];	/* Acked sequence */
+ };
+
+ #endif
diff -N -c -r /usr/src/sys/netinet/il_var.h ./netinet/il_var.h
*** /usr/src/sys/netinet/il_var.h	Wed Dec 31 19:00:00 1969
--- ./netinet/il_var.h	Thu Oct  7 10:45:05 1999
***************
*** 0 ****
--- 1,46 ----
+ #ifndef NETINET_IL_VAR_H_
+ #define NETINET_IL_VAR_H_
+
+ struct ilpcb			/* Control block */
+ {
+   int	state;		/* Connection state */
+   struct inpcb * inpcb;  /* back pointer to internet pcb */
+   u_long unacked;
+
+ #define ILF_NEEDACK 1
+   u_long flags;
+
+   u_long rxt_max;
+   int rxt_timer;  /* number of ticks to the next timeout */
+   int rxt_timer_cur;  /* current rxt timer period */
+
+   int death_timer;
+   int death_timer_cur;
+
+   u_long	next;		/* Id of next to send */
+   u_long	recvd;		/* Last packet received */
+
+   u_long	start;		/* Local start id */
+   u_long	rstart;		/* Remote start id */
+   int	rxtot;		/* number of retransmits on this connection */
+
+   struct mbuf * segq;
+ };
+
+ #define	intoilpcb(ip)	((struct ilpcb *)(ip)->inp_ppcb)
+ #define	sotoilpcb(so)	(intoilpcb(sotoinpcb(so)))
+
+ #ifdef KERNEL
+ void il_init __P((void));
+ void il_input __P((struct mbuf * m, int iphlen));
+ void il_slowtimo __P((void));
+ void il_fasttimo __P((void));
+ void il_ctlinput __P((int cmd, struct sockaddr *sa, void *vip));
+ int  il_ctloutput __P((struct socket *so, struct sockopt *sopt));
+ void il_drain __P((void));
+
+ extern struct pr_usrreqs il_usrreqs;
+
+ #endif
+
+ #endif
diff -N -c -r /usr/src/sys/netinet/in_proto.c ./netinet/in_proto.c
*** /usr/src/sys/netinet/in_proto.c	Sat Aug 22 23:07:14 1998
--- ./netinet/in_proto.c	Wed Oct  6 17:55:12 1999
***************
*** 36,41 ****
--- 36,42 ----

  #include "opt_ipdivert.h"
  #include "opt_ipx.h"
+ #include "opt_inet.h"

  #include <sys/param.h>
  #include <sys/kernel.h>
***************
*** 71,76 ****
--- 72,82 ----
  #include <netns/ns_if.h>
  #endif

+ #ifdef IL
+ #include <netinet/il.h>
+ #include <netinet/il_var.h>
+ #endif
+
  extern	struct domain inetdomain;
  static	struct pr_usrreqs nousrreqs;

***************
*** 161,166 ****
--- 167,181 ----
    0,
    0,		0,		0,		0,
    &rip_usrreqs
+ },
+ #endif
+ #ifdef IL
+ { SOCK_SEQPACKET,	&inetdomain,	IPPROTO_IL,
+ 	PR_CONNREQUIRED|PR_IMPLOPCL|PR_WANTRCVD|PR_ATOMIC,
+   il_input,	0,		il_ctlinput,	il_ctloutput,
+   0,
+   il_init,	il_fasttimo,	il_slowtimo,	il_drain,
+   &il_usrreqs
  },
  #endif
  	/* raw wildcard */
diff -N -c -r /usr/src/sys/sys/vnode.h ./sys/vnode.h
*** /usr/src/sys/sys/vnode.h	Sat Mar 20 04:37:49 1999
--- ./sys/vnode.h	Fri Oct 15 17:44:42 1999
***************
*** 62,68 ****
  enum vtagtype	{
  	VT_NON, VT_UFS, VT_NFS, VT_MFS, VT_PC, VT_LFS, VT_LOFS, VT_FDESC,
  	VT_PORTAL, VT_NULL, VT_UMAP, VT_KERNFS, VT_PROCFS, VT_AFS, VT_ISOFS,
! 	VT_UNION, VT_MSDOSFS, VT_DEVFS, VT_TFS, VT_VFS, VT_CODA, VT_NTFS
  };

  /*
--- 62,68 ----
  enum vtagtype	{
  	VT_NON, VT_UFS, VT_NFS, VT_MFS, VT_PC, VT_LFS, VT_LOFS, VT_FDESC,
  	VT_PORTAL, VT_NULL, VT_UMAP, VT_KERNFS, VT_PROCFS, VT_AFS, VT_ISOFS,
! 	VT_UNION, VT_MSDOSFS, VT_DEVFS, VT_TFS, VT_VFS, VT_CODA, VT_NTFS, VT_U9FS
  };

  /*