University of Michigan's Citi NFSv4 kernel client code.

Submitted by: Jim Rees <rees@umich.edu>

37 files changed, 11249 insertions, 22 deletions

diff --git a/sys/conf/files b/sys/conf/files
index 2482345..08dfcab 100644
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -1562,6 +1562,15 @@ nfsclient/nfs_nfsiod.c		optional nfsclient
 nfsclient/nfs_vfsops.c		optional nfsclient
 nfsclient/nfs_vnops.c		optional nfsclient
 nfsclient/nfs_lock.c		optional nfsclient
+nfs4client/nfs4_socket.c	optional nfsclient
+nfs4client/nfs4_vfsops.c	optional nfsclient
+nfs4client/nfs4_vnops.c		optional nfsclient
+nfs4client/nfs4_subs.c		optional nfsclient
+nfs4client/nfs4_vfs_subs.c	optional nfsclient
+nfs4client/nfs4_vn_subs.c	optional nfsclient
+nfs4client/nfs4_dev.c		optional nfsclient
+nfs4client/nfs4_idmap.c		optional nfsclient
+rpc/rpcclnt.c			optional nfsclient
 nfsserver/nfs_serv.c		optional nfsserver
 nfsserver/nfs_srvsock.c		optional nfsserver
 nfsserver/nfs_srvcache.c	optional nfsserver
diff --git a/sys/nfs/nfsproto.h b/sys/nfs/nfsproto.h
index 8f62ab1..4c8a090 100644
--- a/sys/nfs/nfsproto.h
+++ b/sys/nfs/nfsproto.h
@@ -55,17 +55,19 @@
 #define	NFS_PROG	100003
 #define NFS_VER2	2
 #define	NFS_VER3	3
+#define NFS_VER4	4
+
 #define NFS_V2MAXDATA	8192
 #define	NFS_MAXDGRAMDATA 16384
 #define	NFS_MAXDATA	32768
 #define	NFS_MAXPATHLEN	1024
 #define	NFS_MAXNAMLEN	255
-#define	NFS_MAXPKTHDR	404
+#define	NFS_MAXPKTHDR	404	/* XXXv4 this needs to be adjust for v4 */
 #define NFS_MAXPACKET	(NFS_MAXPKTHDR + NFS_MAXDATA)
 #define	NFS_MINPACKET	20
 #define	NFS_FABLKSIZE	512	/* Size in bytes of a block wrt fa_blocks */
 
-/* Stat numbers for rpc returns (version 2 and 3) */
+/* Stat numbers for rpc returns (version 2, 3 and 4) */
 #define	NFS_OK			0
 #define	NFSERR_PERM		1
 #define	NFSERR_NOENT		2
@@ -88,7 +90,7 @@
 #define	NFSERR_STALE		70
 #define	NFSERR_REMOTE		71	/* Version 3 only */
 #define	NFSERR_WFLUSH		99	/* Version 2 only */
-#define	NFSERR_BADHANDLE	10001	/* The rest Version 3 only */
+#define	NFSERR_BADHANDLE	10001	/* The rest Version 3, 4 only */
 #define	NFSERR_NOT_SYNC		10002
 #define	NFSERR_BAD_COOKIE	10003
 #define	NFSERR_NOTSUPP		10004
@@ -97,8 +99,48 @@
 #define	NFSERR_BADTYPE		10007
 #define	NFSERR_JUKEBOX		10008
 #define NFSERR_TRYLATER		NFSERR_JUKEBOX
+#define	NFSERR_SAME		10009   /* The rest Version 4 only */
+#define	NFSERR_DENIED		10010
+#define	NFSERR_EXPIRED		10011
+#define	NFSERR_LOCKED		10012
+#define	NFSERR_GRACE		10013
+#define	NFSERR_FHEXPIRED	10014
+#define	NFSERR_SHARDE_DENIED	10015
+#define	NFSERR_WRONGSEC		10016
+#define	NFSERR_CLID_INUSE	10017
+#define	NFSERR_RESOURCE		10018
+#define	NFSERR_MOVED		10019
+#define	NFSERR_NOFILEHANDLE	10020
+#define	NFSERR_MINOR_VERS_MISMATCH 10021
+#define	NFSERR_STALE_CLIENTID	10022
+#define	NFSERR_STALE_STATEID	10023
+#define	NFSERR_OLD_STATEID	10024
+#define	NFSERR_BAD_STATEID	10025
+#define	NFSERR_BAD_SEQID	10026
+#define	NFSERR_NOT_SAME		10027
+#define	NFSERR_LOCK_RANGE	10028
+#define	NFSERR_SYMLINK		10029
+#define	NFSERR_READDIR_NOSPC	10030
+#define	NFSERR_LEASE_MOVED	10031
+#define	NFSERR_ATTRNOTSUPP	10032
+#define	NFSERR_NO_GRACE		10033
+#define	NFSERR_RECLAIM_BAD	10034
+#define	NFSERR_RECLAIM_CONFLICT	10035
+#define	NFSERR_BADXDR		10036
+#define	NFSERR_LOCKS_HELD	10037
+#define	NFSERR_OPENMODE		10038
+#define	NFSERR_BADOWNER		10039
+#define	NFSERR_BADCHAR		10040
+#define	NFSERR_BADNAME		10041
+#define	NFSERR_BAD_RANGE	10042
+#define	NFSERR_LOCK_NOTSUPP	10043
+#define	NFSERR_OP_ILLEGAL	10044
+#define	NFSERR_DEADLOCK		10045
+#define	NFSERR_FILE_OPEN	10046
 #define	NFSERR_STALEWRITEVERF	30001	/* Fake return for nfs_commit() */
 
+
+
 #define NFSERR_RETVOID		0x20000000 /* Return void, not error */
 #define NFSERR_AUTHERR		0x40000000 /* Mark an authentication error */
 #define NFSERR_RETERR		0x80000000 /* Mark an error return for V3 */
@@ -128,6 +170,11 @@
 #define NFSX_V3FSINFO		48
 #define NFSX_V3PATHCONF		24
 
+/* specific to NFS Version 4 */
+#define NFSX_V4VERF		8
+#define NFSX_V4FH		128
+#define NFSX_V4STATEID		16
+
 /* variants for both versions */
 #define NFSX_FH(v3)		((v3) ? (NFSX_V3FHMAX + NFSX_UNSIGNED) : \
 					NFSX_V2FH)
@@ -193,6 +240,48 @@
 #define	NFSV2PROC_READDIR	16
 #define	NFSV2PROC_STATFS	17
 
+/* Version 4 procedure numbers */
+#define NFSV4PROC_NULL         0
+#define NFSV4PROC_COMPOUND     1
+
+/* Version 4 operation numbers */
+#define NFSV4OP_ACCESS		3
+#define NFSV4OP_CLOSE		4
+#define NFSV4OP_COMMIT		5
+#define NFSV4OP_CREATE		6
+#define NFSV4OP_DELEGPURGE	7
+#define NFSV4OP_DELEGRETURN	8
+#define NFSV4OP_GETATTR		9
+#define NFSV4OP_GETFH		10
+#define NFSV4OP_LINK		11
+#define NFSV4OP_LOCK		12
+#define NFSV4OP_LOCKT		13
+#define NFSV4OP_LOCKU		14
+#define NFSV4OP_LOOKUP		15
+#define NFSV4OP_LOOKUPP		16
+#define NFSV4OP_NVERIFY		17
+#define NFSV4OP_OPEN		18
+#define NFSV4OP_OPENATTR	19
+#define NFSV4OP_OPEN_CONFIRM	20
+#define NFSV4OP_OPEN_DOWNGRADE	21
+#define NFSV4OP_PUTFH		22
+#define NFSV4OP_PUTPUBFH	23
+#define NFSV4OP_PUTROOTFH	24
+#define NFSV4OP_READ		25
+#define NFSV4OP_READDIR		26
+#define NFSV4OP_READLINK	27
+#define NFSV4OP_REMOVE		28
+#define NFSV4OP_RENAME		29
+#define NFSV4OP_RENEW		30
+#define NFSV4OP_RESTOREFH	31
+#define NFSV4OP_SAVEFH		32
+#define NFSV4OP_SECINFO		33
+#define NFSV4OP_SETATTR		34
+#define NFSV4OP_SETCLIENTID	35
+#define NFSV4OP_SETCLIENTID_CONFIRM 36
+#define NFSV4OP_VERIFY		37
+#define NFSV4OP_WRITE		38
+
 /*
  * Constants used by the Version 3 protocol for various RPCs
  */
@@ -220,11 +309,65 @@
 #define NFSV3FSINFO_HOMOGENEOUS		0x08
 #define NFSV3FSINFO_CANSETTIME		0x10
 
+/*
+ * Constants used by the Version 4 protocol for various RPCs
+ */
+
+#define NFSV4ACCESS_READ		0x01
+#define NFSV4ACCESS_LOOKUP		0x02
+#define NFSV4ACCESS_MODIFY		0x04
+#define NFSV4ACCESS_EXTEND		0x08
+#define NFSV4ACCESS_DELETE		0x10
+#define NFSV4ACCESS_EXECUTE		0x20
+
+#define NFSV4OPENRES_MLOCK		0x01
+#define NFSV4OPENRES_CONFIRM		0x02
+
+#define NFSV4OPENSHARE_ACCESS_READ	0x01
+#define NFSV4OPENSHARE_ACCESS_WRITE	0x02
+#define NFSV4OPENSHARE_ACCESS_BOTH	0x03
+#define NFSV4OPENSHARE_DENY_NONE	0x00
+#define NFSV4OPENSHARE_DENY_READ	0x01
+#define NFSV4OPENSHARE_DENY_WRITE	0x02
+#define NFSV4OPENSHARE_DENY_BOTH	0x03
+
 /* File types */
-typedef enum { NFNON=0, NFREG=1, NFDIR=2, NFBLK=3, NFCHR=4, NFLNK=5,
-	NFSOCK=6, NFFIFO=7 } nfstype;
+typedef enum {
+	NFNON=0,
+	NFREG=1,
+	NFDIR=2,
+	NFBLK=3,
+	NFCHR=4,
+	NFLNK=5,
+	NFSOCK=6,
+	NFFIFO=7,
+	NFATTRDIR = 8,
+	NFNAMEDATTR = 9,
+	NFBAD = 10,
+} nfstype;	
+
+/* NFSv4 claim type */
+typedef enum {
+	NCLNULL = 0,
+	NCLPREV = 1,
+	NCLDELEGCUR = 2,
+	NCLDELEGPREV = 3,
+} nfsv4cltype;
+
+/* Other NFSv4 types */
+typedef enum {
+	NSHUNSTABLE = 0,
+	NSHDATASYNC = 1,
+	NSHFILESYNC = 2,
+} nfsv4stablehow;
+
+typedef enum { OTNOCREATE = 0, OTCREATE = 1 } nfsv4opentype;
+typedef enum { CMUNCHECKED = 0, CMGUARDED = 1, CMEXCLUSIVE = 2 } nfsv4createmode;
+typedef enum { THSERVERTIME = 0, THCLIENTTIME = 1 } nfsv4timehow;
+typedef enum { ODNONE = 0, ODREAD = 1, ODWRITE = 2 } nfsv4opendelegtype;
 
 /* Structs for common parts of the rpc's */
+
 /*
  * File Handle (32 bytes for version 2), variable up to 64 for version 3.
  * File Handles of up to NFS_SMALLFH in size are stored directly in the
@@ -233,7 +376,7 @@ typedef enum { NFNON=0, NFREG=1, NFDIR=2, NFBLK=3, NFCHR=4, NFLNK=5,
  * NFS_SMALLFH should be in the range of 32 to 64 and be divisible by 4.
  */
 #ifndef NFS_SMALLFH
-#define NFS_SMALLFH	64
+#define NFS_SMALLFH	128
 #endif
 union nfsfh {
 	fhandle_t	fh_generic;
@@ -281,6 +424,22 @@ struct nfsv3_spec {
 typedef	struct nfsv3_spec	nfsv3spec;
 
 /*
+ * NFS Version 4 bitmap.
+ */
+struct nfsv4_bitmap {
+	uint32_t	bmlen;
+	uint32_t	*bmval;
+};
+typedef struct nfsv4_bitmap nfsv4bitmap;
+
+struct nfsv4_changeinfo {
+	u_int		ciatomic;
+	uint64_t	cibefore;
+	uint64_t	ciafter;
+};
+typedef struct nfsv4_changeinfo nfsv4changeinfo;
+
+/*
  * File attributes and setable attributes. These structures cover both
  * NFS version 2 and the version 3 protocol. Note that the union is only
  * used so that one pointer can refer to both variants. These structures
@@ -339,6 +498,126 @@ struct nfs_fattr {
 #define	fa3_mtime		fa_un.fa_nfsv3.nfsv3fa_mtime
 #define	fa3_ctime		fa_un.fa_nfsv3.nfsv3fa_ctime
 
+struct nfsv4_fattr {
+	u_int		fa4_valid;
+	nfstype		fa4_type;
+	off_t		fa4_size;
+	uint64_t	fa4_fsid_major;
+	uint64_t	fa4_fsid_minor;
+	uint64_t	fa4_fileid;
+	mode_t		fa4_mode;
+	nlink_t		fa4_nlink;
+	uid_t		fa4_uid;
+	gid_t		fa4_gid;
+	uint32_t	fa4_rdev_major;
+	uint32_t	fa4_rdev_minor;
+	struct timespec	fa4_atime;
+	struct timespec	fa4_ctime;
+	struct timespec	fa4_mtime;
+	uint64_t	fa4_maxread;
+	uint64_t	fa4_maxwrite;
+	uint64_t	fa4_ffree;
+	uint64_t	fa4_ftotal;
+	uint32_t	fa4_maxname;
+	uint64_t	fa4_savail;
+	uint64_t	fa4_sfree;
+	uint64_t	fa4_stotal;
+	uint64_t	fa4_changeid;
+	uint32_t	fa4_lease_time;
+	uint64_t	fa4_maxfilesize;
+};
+
+/* Flags for fa4_valid */
+#define FA4V_SIZE	0x00000001
+#define FA4V_FSID	0x00000002
+#define FA4V_FILEID	0x00000004
+#define FA4V_MODE	0x00000008
+#define FA4V_NLINK	0x00000010
+#define FA4V_UID	0x00000020
+#define FA4V_GID	0x00000040
+#define FA4V_RDEV	0x00000080
+#define FA4V_ATIME	0x00000100
+#define FA4V_CTIME	0x00000200
+#define FA4V_MTIME	0x00000400
+#define FA4V_MAXREAD	0x00000800
+#define FA4V_MAXWRITE	0x00001000
+#define FA4V_TYPE	0x00002000
+#define FA4V_FFREE	0x00004000
+#define FA4V_FTOTAL	0x00008000
+#define FA4V_MAXNAME	0x00010000
+#define FA4V_SAVAIL	0x00020000
+#define FA4V_SFREE	0x00040000
+#define FA4V_STOTAL	0x00080000
+#define FA4V_CHANGEID	0x00100000
+#define FA4V_LEASE_TIME	0x00200000
+#define FA4V_MAXFILESIZE 0x00400000
+#define FA4V_ACL	0x00800000
+
+/* Offsets into bitmask */
+#define FA4_SUPPORTED_ATTRS	0
+#define FA4_TYPE		1
+#define FA4_FH_EXPIRE_TYPE	2
+#define FA4_CHANGE		3
+#define FA4_SIZE		4
+#define FA4_LINK_SUPPORT	5
+#define FA4_SYMLINK_SUPPORT	6
+#define FA4_NAMED_ATTR		7
+#define FA4_FSID		8
+#define FA4_UNIQUE_HANDLES	9
+#define FA4_LEASE_TIME		10
+#define FA4_RDATTR_ERROR	11
+#define FA4_ACL			12
+#define FA4_ACLSUPPORT		13
+#define FA4_ARCHIVE		14
+#define FA4_CANSETTIME		15
+#define FA4_CASE_INSENSITIVE	16
+#define FA4_CASE_PRESERVING	17 
+#define FA4_CHOWN_RESTRICTED	18
+#define FA4_FILEHANDLE		19
+#define FA4_FILEID		20
+#define FA4_FILES_AVAIL		21
+#define FA4_FILES_FREE		22
+#define FA4_FILES_TOTAL		23
+#define FA4_FS_LOCATIONS	24
+#define FA4_HIDDEN		25
+#define FA4_HOMOGENEOUS		26
+#define FA4_MAXFILESIZE		27
+#define FA4_MAXLINK		28
+#define FA4_MAXNAME		29
+#define FA4_MAXREAD		30
+#define FA4_MAXWRITE		31
+#define FA4_MIMETYPE		32
+#define FA4_MODE		33
+#define FA4_NO_TRUNC		34
+#define FA4_NUMLINKS		35
+#define FA4_OWNER		36
+#define FA4_OWNER_GROUP		37
+#define FA4_QUOTA_HARD		38
+#define FA4_QUOTA_SOFT		39
+#define FA4_QUOTA_USED		40
+#define FA4_RAWDEV		41
+#define FA4_SPACE_AVAIL		42
+#define FA4_SPACE_FREE		43
+#define FA4_SPACE_TOTAL		44
+#define FA4_SPACE_USED		45
+#define FA4_SYSTEM		46
+#define FA4_TIME_ACCESS		47
+#define FA4_TIME_ACCESS_SET	48
+#define FA4_TIME_BACKUP		49
+#define FA4_TIME_CREATE		50
+#define FA4_TIME_DELTA		51
+#define FA4_TIME_METADATA	52
+#define FA4_TIME_MODIFY		53
+#define FA4_TIME_MODIFY_SET	54
+#define FA4_ATTR_MAX		55
+
+/* Macros for v4 fattr manipulation */
+#define FA4_SET(n, p)	((p)[(n)/32] |= (1 << ((n) % 32)))
+#define FA4_CLR(n, p)	((p)[(n)/32] &= ~(1 << ((n) % 32)))
+#define FA4_ISSET(n, p)	((p)[(n)/32] & (1 << ((n) % 32)))
+#define FA4_ZERO(p)	bzero((p), 8)
+#define FA4_SKIP(p)	((p) += 2)
+
 struct nfsv2_sattr {
 	u_int32_t	sa_mode;
 	u_int32_t	sa_uid;
diff --git a/sys/nfs/rpcv2.h b/sys/nfs/rpcv2.h
index 977a8d3..e65d87b 100644
--- a/sys/nfs/rpcv2.h
+++ b/sys/nfs/rpcv2.h
@@ -53,6 +53,7 @@
 #define	RPCAUTH_NULL	0
 #define	RPCAUTH_UNIX	1
 #define	RPCAUTH_SHORT	2
+#define	RPCAUTH_KERB4	4
 #define	RPCAUTH_MAXSIZ	400
 #define	RPCVERF_MAXSIZ	12	/* For Kerb, can actually be 400 */
 #define	RPCAUTH_UNIXGIDS 16
@@ -63,19 +64,28 @@
 #define RPCAKN_FULLNAME	0
 #define RPCAKN_NICKNAME	1
 
-/* Rpc Constants */
+/* msg type */
 #define	RPC_CALL	0
 #define	RPC_REPLY	1
+
+/* reply status */
 #define	RPC_MSGACCEPTED	0
 #define	RPC_MSGDENIED	1
+
+/* accepted status */
+#define	RPC_SUCCESS	0
 #define	RPC_PROGUNAVAIL	1
 #define	RPC_PROGMISMATCH	2
 #define	RPC_PROCUNAVAIL	3
 #define	RPC_GARBAGE	4		/* I like this one */
+#define	RPC_SYSTEMERR	5
+
+/* rejected status */
 #define	RPC_MISMATCH	0
 #define	RPC_AUTHERR	1
 
 /* Authentication failures */
+#define	AUTH_OK		0
 #define	AUTH_BADCRED	1
 #define	AUTH_REJECTCRED	2
 #define	AUTH_BADVERF	3
diff --git a/sys/nfs4client/nfs4.h b/sys/nfs4client/nfs4.h
new file mode 100644
index 0000000..148c224
--- /dev/null
+++ b/sys/nfs4client/nfs4.h
@@ -0,0 +1,260 @@
+/* $FreeBSD$ */
+/* $Id: nfs4.h,v 1.25 2003/11/05 14:58:58 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+#ifndef _NFS4CLIENT_NFS4_H
+#define _NFS4CLIENT_NFS4_H
+
+#define NFS4_USE_RPCCLNT
+
+#define NFS4_MINOR_VERSION		0
+#define NFS_PORT			2049
+#define NFS4_DEF_FILE_IO_BUFFER_SIZE	4096
+#define NFS4_MAX_FILE_IO_BUFFER_SIZE	32768
+#define NFS4_DEF_MAXFILESIZE		0xffffffff
+#define NFS4_SUPER_MAGIC		0xF00BA4
+
+#define NFS4FS_SILLY_RENAME		1
+#define NFS4FS_STRICT_LOCKING		1
+#define NFS4FS_RETRY_OLD_STATEID	1
+#define NFS4FS_MIN_LEASE		(1 * hz)
+#define NFS4FS_DEFAULT_LEASE		(30 * hz)
+#define NFS4FS_MAX_LEASE		(120 * hz)
+#define NFS4FS_RETRY_MIN_DELAY		(hz >> 4)
+#define NFS4FS_RETRY_MAX_DELAY		(hz << 3)
+#define NFS4FS_SEMAPHORE_DELAY		(hz >> 4)
+#define NFS4FS_GRACE_DELAY		(hz * 5)
+#define NFS4FS_OLD_STATEID_DELAY	(hz >> 3)
+#define NFS4FS_OP_MAX			10
+
+
+#define NFS4_BUFSIZE			8192
+#define NFS4FS_MAX_IOV			10
+#define NFS4_SETCLIENTID_MAXTRIES	5
+#define NFS4_READDIR_MAXTRIES		5
+#define NFS4_MAXIO			4
+#define NFS4_MAX_REQUEST_SOFT		192
+#define NFS4_MAX_REQUEST_HARD		256
+#define NFS4_MAXCOMMIT			64
+#define NFS4_READ_DELAY			(2 * HZ)
+#define NFS4_WRITEBACK_DELAY		(5 * HZ)
+#define NFS4_WRITEBACK_LOCKDELAY	(60 * HZ)
+#define NFS4_COMMIT_DELAY		(5 * HZ)
+#define RPC_SLACK_SPACE			512
+
+
+struct nfs4_compound {
+	char	       *tag;
+
+	int		req_nops;
+	uint32_t       *req_nopsp;
+	uint32_t       *req_seqidp;
+	uint32_t       *req_stateidp[NFS4_MAXIO];
+	uint32_t	req_nstateid;
+
+	u_int		seqidused;
+
+	int		rep_status;
+	int		rep_nops;
+
+	struct nfs4_fctx *fcp;
+
+	struct vnode   *curvp;
+	struct vnode   *savevp;
+
+	struct nfsmount *nmp;
+};
+
+struct nfs4_fdata {
+	struct nfsnode *fd_n;
+	pid_t		fd_pid;
+};
+
+struct nfs4_oparg_putfh {
+	/* filled in by caller */
+/*	  struct dentry *dentry;*/
+
+	/* filled in by setup routine */
+/*	  nfs_opnum4 op;*/
+	uint32_t	fh_len;
+	nfsfh_t		fh_val;
+	int		nlookups;
+};
+
+struct nfs4_oparg_getattr {
+	struct vnode   *vp;
+	nfsv4bitmap    *bm;
+	struct nfsv4_fattr fa;
+};
+
+struct nfs4_oparg_getfh {
+	uint32_t	fh_len;
+	nfsfh_t		fh_val;
+	struct vnode   *vp;
+};
+
+struct nfs4_oparg_lookup {
+	const char     *name;
+	uint32_t	namelen;
+	struct vnode   *vp;
+};
+
+struct nfs4_oparg_setclientid {
+	struct nfsmount *np;
+	uint32_t	namelen;
+	char	       *name;
+	char	       *cb_netid;
+	uint32_t	cb_netidlen;
+	char	       *cb_univaddr;
+	uint32_t	cb_univaddrlen;
+	uint32_t	cb_prog;
+
+	uint64_t	clientid;
+	u_char		verf[NFSX_V4VERF];
+};
+
+struct nfs4_oparg_access {
+	uint32_t	mode;
+	uint32_t	rmode;
+	uint32_t	supported;
+};
+
+struct nfs4_oparg_open {
+	uint32_t	flags;
+	uint32_t	rflags;
+
+	nfsv4cltype	ctype;
+	struct vattr   *vap;
+	struct componentname *cnp;
+
+	struct nfs4_fctx *fcp;
+
+	char		stateid[NFSX_V4STATEID];
+};
+
+struct nfs4_oparg_read {
+	uint64_t	off;
+	uint32_t	maxcnt;
+	uint32_t	eof;
+	uint32_t	retlen;
+	struct uio     *uiop;
+	struct nfs4_fctx *fcp;
+};
+
+struct nfs4_oparg_write {
+	uint64_t	off;
+	uint32_t	stable;
+	uint32_t	cnt;
+	uint32_t	retlen;
+	uint32_t	committed;
+	struct uio     *uiop;
+	u_char		wverf[NFSX_V4VERF];
+	struct nfs4_fctx *fcp;
+};
+
+struct nfs4_oparg_commit {
+	uint32_t	len;
+	off_t		start;
+
+	u_char		verf[NFSX_V4VERF];
+};
+
+struct nfs4_oparg_readdir {
+	uint32_t	cnt;
+	nfsv4bitmap    *bm;
+	uint64_t	cookie;
+	u_char		verf[NFSX_V4VERF];
+};
+
+struct nfs4_oparg_create {
+	nfstype		type;
+	char	       *linktext;
+	char	       *name;
+	uint32_t	namelen;
+	struct vattr   *vap;
+};
+
+struct nfs4_oparg_rename {
+	const char     *fname;
+	uint32_t	fnamelen;
+	const char     *tname;
+	uint32_t	tnamelen;
+};
+
+struct nfs4_oparg_link {
+	const char     *name;
+	uint32_t	namelen;
+};
+
+/*
+ * Lockowner
+ */
+struct nfs4_lowner {
+	uint32_t	lo_cnt;
+	uint32_t	lo_seqid;
+	uint32_t	lo_id;
+};
+
+#define NFS4_SEQIDMUTATINGERROR(err)		\
+(((err) != NFSERR_STALE_CLIENTID) &&		\
+ ((err) != NFSERR_BAD_SEQID) &&			\
+ ((err) != NFSERR_STALE_STATEID) &&		\
+ ((err) != NFSERR_BAD_STATEID))
+
+/* Standard bitmasks */
+extern nfsv4bitmap nfsv4_fsinfobm;
+extern nfsv4bitmap nfsv4_fsattrbm;
+extern nfsv4bitmap nfsv4_getattrbm;
+extern nfsv4bitmap nfsv4_readdirbm;
+
+vfs_init_t nfs4_init;
+vfs_uninit_t nfs4_uninit;
+
+uint32_t nfs_v4fileid4_to_fileid(uint64_t);
+
+int	nfs4_readrpc(struct vnode *, struct uio *, struct ucred *);
+int	nfs4_writerpc(struct vnode *, struct uio *, struct ucred *, int *,
+	    int *);
+int	nfs4_commit(struct vnode *vp, u_quad_t offset, int cnt,
+	    struct ucred *cred, struct thread *td);
+int	nfs4_readdirrpc(struct vnode *, struct uio *, struct ucred *);
+int	nfs4_readlinkrpc(struct vnode *, struct uio *, struct ucred *);
+int	nfs4_sigintr(struct nfsmount *, struct nfsreq *, struct thread *);
+int	nfs4_writebp(struct buf *, int, struct thread *);
+int	nfs4_request(struct vnode *, struct mbuf *, int, struct thread *,
+	    struct ucred *, struct mbuf **, struct mbuf **, caddr_t *);
+int	nfs4_request_mnt(struct nfsmount *, struct mbuf *, int, struct thread *,
+	    struct ucred *, struct mbuf **, struct mbuf **, caddr_t *);
+int	nfs4_connect(struct nfsmount *);
+void	nfs4_disconnect(struct nfsmount *);
+void	nfs4_safedisconnect(struct nfsmount *);
+int	nfs4_nmcancelreqs(struct nfsmount *);
+
+void	nfs_v4initcompound(struct nfs4_compound *);
+int	nfs_v4postop(struct nfs4_compound *, int);
+int	nfs_v4handlestatus(int, struct nfs4_compound *);
+
+#endif /* _NFS4CLIENT_NFS4_H */
diff --git a/sys/nfs4client/nfs4_dev.c b/sys/nfs4client/nfs4_dev.c
new file mode 100644
index 0000000..09c9d57
--- /dev/null
+++ b/sys/nfs4client/nfs4_dev.c
@@ -0,0 +1,451 @@
+/* $FreeBSD$ */
+/* $Id: nfs4_dev.c,v 1.10 2003/11/05 14:58:59 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+#include <sys/param.h>
+#include <sys/conf.h>
+#include <sys/queue.h>
+#include <sys/malloc.h>
+#include <sys/kernel.h>
+#include <sys/poll.h>
+#include <sys/mutex.h>
+#include <sys/stat.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/wait.h>
+#include <sys/signalvar.h>
+
+#include <nfs4client/nfs4_dev.h>
+
+#ifdef NFS4DEVVERBOSE
+#define NFS4DEV_DEBUG(X...) printf(X)
+#else
+#define NFS4DEV_DEBUG(X...)
+#endif
+
+#define NFS4DEV_NAME "nfs4"
+#define CDEV_MAJOR 29 /* XXX where are these numbers assigned!?!?  */
+#define CDEV_MINOR 1
+
+MALLOC_DEFINE(M_NFS4DEV, "NFS4 dev", "NFS4 device");
+
+struct nfs4dev_upcall {
+  	/* request msg */
+	struct nfs4dev_msg up_reqmsg;
+  	size_t up_reqmsglen;
+
+	/* reply (payload only) */
+	caddr_t up_rep;
+	size_t * up_replen;	
+
+	int up_copied;		/* non-zero when reply has been copied to 
+				   '*up_rep' */
+				   
+	int up_error;		/* non-zero if an error occured */
+
+	TAILQ_ENTRY(nfs4dev_upcall) up_entry;
+};
+
+
+#define nfs4dev_upcall_get(MP) MALLOC((MP), struct nfs4dev_upcall *, sizeof(struct nfs4dev_upcall), M_NFS4DEV, M_WAITOK | M_ZERO)
+
+#define nfs4dev_upcall_put(MP) FREE((MP), M_NFS4DEV)
+
+static int nfs4dev_nopen = 0;
+static struct thread * nfs4dev_reader = NULL;
+static dev_t nfs4device = 0;
+static struct mtx nfs4dev_daemon_mtx;
+
+static int nfs4dev_xid = 0;
+/* queue of pending upcalls */
+TAILQ_HEAD(, nfs4dev_upcall) nfs4dev_newq;
+static struct mtx nfs4dev_newq_mtx;
+
+/* queue of upcalls waiting for replys */
+TAILQ_HEAD(, nfs4dev_upcall) nfs4dev_waitq;
+static struct mtx nfs4dev_waitq_mtx;
+
+/* dev hooks */
+static d_open_t  nfs4dev_open;
+static d_close_t nfs4dev_close;
+static d_ioctl_t nfs4dev_ioctl;
+static d_poll_t  nfs4dev_poll;
+
+static struct cdevsw nfs4dev_cdevsw = {
+	.d_open =   nfs4dev_open,
+	.d_close =  nfs4dev_close,
+	.d_ioctl =  nfs4dev_ioctl,
+	.d_poll =   nfs4dev_poll,
+	.d_name =   NFS4DEV_NAME,
+	.d_maj =    CDEV_MAJOR
+};
+
+static int nfs4dev_reply(caddr_t);
+static int nfs4dev_request(caddr_t);
+
+/* Userland requests a new operation to service */
+static int 
+nfs4dev_request(caddr_t addr)
+{
+	struct nfs4dev_upcall * u;
+	struct nfs4dev_msg * m = (struct nfs4dev_msg *) addr;
+
+	mtx_lock(&nfs4dev_newq_mtx);
+
+	if (TAILQ_EMPTY(&nfs4dev_newq)) {
+  		mtx_unlock(&nfs4dev_newq_mtx);
+		return EAGAIN;	
+	}
+
+	u = TAILQ_FIRST(&nfs4dev_newq);
+	TAILQ_REMOVE(&nfs4dev_newq, u, up_entry);
+	mtx_unlock(&nfs4dev_newq_mtx);
+
+	bcopy(&u->up_reqmsg, m, sizeof(struct nfs4dev_msg));
+
+	mtx_lock(&nfs4dev_waitq_mtx);
+	TAILQ_INSERT_TAIL(&nfs4dev_waitq, u, up_entry);
+	mtx_unlock(&nfs4dev_waitq_mtx);
+
+	return 0;
+}
+
+static int
+nfs4dev_reply(caddr_t addr)
+{
+	struct nfs4dev_upcall * u;
+	struct nfs4dev_msg * m = (struct nfs4dev_msg *) addr;
+	int error;
+
+	if (m->msg_vers != NFS4DEV_VERSION) {
+	  	printf("nfs4dev version mismatch\n");
+		return EINVAL;
+	}
+
+	if (m->msg_type > NFS4DEV_MAX_TYPE) {
+		NFS4DEV_DEBUG("nfs4dev: unsupported message type\n");
+		return EINVAL;
+	}
+
+	if (m->msg_len == 0 || m->msg_len > NFS4DEV_MSG_MAX_DATALEN) {
+	  	NFS4DEV_DEBUG("bad message length\n");
+		return EINVAL;
+	}
+	  	
+	/* match the reply with a request */
+	mtx_lock(&nfs4dev_waitq_mtx);
+	TAILQ_FOREACH(u, &nfs4dev_waitq, up_entry) {
+		if (m->msg_xid == u->up_reqmsg.msg_xid) {
+			if (m->msg_type == u->up_reqmsg.msg_type)
+		  		goto found;
+			NFS4DEV_DEBUG("nfs4dev: op type mismatch!\n");
+			break;
+		}
+	}
+	mtx_unlock(&nfs4dev_waitq_mtx);
+
+	NFS4DEV_DEBUG("nfs4dev msg op: %d xid: %x not found.\n",
+	    m->msg_type, m->msg_xid);
+
+	error = EIO;
+	goto bad;
+
+found:
+	TAILQ_REMOVE(&nfs4dev_waitq, u, up_entry);
+	mtx_unlock(&nfs4dev_waitq_mtx);
+
+	if (m->msg_error) {
+		error = m->msg_error;
+		goto bad;
+	}
+
+	if (m->msg_len > *u->up_replen) {
+		error = EFAULT;
+		goto bad;
+	}
+
+	bcopy(m->msg_data, u->up_rep, m->msg_len);
+	*u->up_replen = m->msg_len;
+
+	u->up_copied = m->msg_len;
+	wakeup(u);
+
+	return 0;
+bad:
+	u->up_error = error;
+	wakeup(u);
+	return error;
+}
+
+void
+nfs4dev_init(void)
+{
+  	nfs4dev_xid = arc4random();
+	TAILQ_INIT(&nfs4dev_newq);	
+	TAILQ_INIT(&nfs4dev_waitq);	
+	mtx_init(&nfs4dev_newq_mtx, "nfs4dev newq", NULL, MTX_DEF);
+	mtx_init(&nfs4dev_waitq_mtx, "nfs4dev waitq", NULL, MTX_DEF);
+
+	mtx_init(&nfs4dev_daemon_mtx, "nfs4dev state", NULL, MTX_DEF);
+
+	nfs4device = make_dev(&nfs4dev_cdevsw, CDEV_MINOR, (uid_t)0, (gid_t)0,
+	    S_IRUSR | S_IWUSR, "nfs4");
+}
+
+void
+nfs4dev_uninit(void)
+{
+  	struct proc * dead = NULL;
+
+  	mtx_lock(&nfs4dev_daemon_mtx);
+  	if (nfs4dev_nopen) {
+		if (nfs4dev_reader == NULL) {
+			NFS4DEV_DEBUG("nfs4dev uninit(): unregistered reader\n");
+		} else {
+			dead = nfs4dev_reader->td_proc;
+		}
+	}
+  	mtx_unlock(&nfs4dev_daemon_mtx);
+
+	if (dead != NULL) {
+		NFS4DEV_DEBUG("nfs4dev_uninit(): you forgot to kill attached daemon (pid: %u)\n",
+		    dead->p_pid);
+		PROC_LOCK(dead);
+		psignal(dead, SIGTERM);
+		PROC_UNLOCK(dead);
+	}
+
+	/* XXX moot? */
+	nfs4dev_purge();
+
+  	mtx_destroy(&nfs4dev_newq_mtx);
+  	mtx_destroy(&nfs4dev_waitq_mtx);
+  	mtx_destroy(&nfs4dev_daemon_mtx);
+
+	destroy_dev(nfs4device);
+}
+
+/* device interface functions */
+static int
+nfs4dev_open(dev_t dev, int flags, int fmt, d_thread_t *td)
+{
+	if (dev != nfs4device) 
+		return ENODEV;
+
+  	mtx_lock(&nfs4dev_daemon_mtx);
+	if (nfs4dev_nopen) {
+  		mtx_unlock(&nfs4dev_daemon_mtx);
+	  	return EBUSY;
+	}
+
+	nfs4dev_nopen++;
+	nfs4dev_reader = curthread;
+  	mtx_unlock(&nfs4dev_daemon_mtx);
+
+	return (0);
+}
+
+static int
+nfs4dev_close(dev_t dev, int flags, int fmt, d_thread_t *td)
+{
+	struct nfs4dev_upcall * u;
+
+	if (dev != nfs4device) 
+		return ENODEV;
+
+  	mtx_lock(&nfs4dev_daemon_mtx);
+	if (!nfs4dev_nopen) {
+  		mtx_unlock(&nfs4dev_daemon_mtx);
+	  	return ENOENT;
+	}
+
+	nfs4dev_nopen--; 
+	nfs4dev_reader = NULL;
+  	mtx_unlock(&nfs4dev_daemon_mtx);
+
+	mtx_lock(&nfs4dev_waitq_mtx);
+
+	while (!TAILQ_EMPTY(&nfs4dev_waitq)) {
+		u = TAILQ_FIRST(&nfs4dev_waitq);
+		TAILQ_REMOVE(&nfs4dev_waitq, u, up_entry);
+		u->up_error = EINTR;
+		wakeup(u);
+	}
+
+	mtx_unlock(&nfs4dev_waitq_mtx);
+
+	return 0;
+}
+
+static int 
+nfs4dev_ioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, struct thread *td)
+{
+  	int error;
+
+	if (dev != nfs4device)
+	 	return ENODEV; 
+
+	if (data == NULL) 
+	  	return EFAULT;
+
+	if (nfs4dev_reader != curthread)
+		nfs4dev_reader = curthread;
+
+	switch (cmd) {
+	case NFS4DEVIOCGET:
+		error = nfs4dev_request(data);
+	break;
+	case NFS4DEVIOCPUT:
+		error = nfs4dev_reply(data);
+	break;
+	default:
+		NFS4DEV_DEBUG("nfs4dev_ioctl: unkown ioctl cmd %d\n", (int)cmd);
+		error = EOPNOTSUPP;
+	break;
+	}
+
+	return error;
+}
+
+static int 
+nfs4dev_poll(dev_t dev, int events, struct thread *td)
+{
+  	int revents;
+
+	if (dev != nfs4device) 
+	  return EINVAL;
+
+	mtx_lock(&nfs4dev_daemon_mtx);
+	if (nfs4dev_nopen == 0) {
+		mtx_unlock(&nfs4dev_daemon_mtx);
+		return 0;
+	}
+	mtx_unlock(&nfs4dev_daemon_mtx);
+
+	revents = 0;
+
+	/* check readable data */
+	mtx_lock(&nfs4dev_newq_mtx);
+	  if (!TAILQ_EMPTY(&nfs4dev_newq))
+	    revents |= POLLIN;
+	mtx_unlock(&nfs4dev_newq_mtx);
+
+	mtx_lock(&nfs4dev_waitq_mtx);
+	  if (!TAILQ_EMPTY(&nfs4dev_waitq))
+	    revents |= POLLOUT;
+	mtx_unlock(&nfs4dev_waitq_mtx);
+
+	return revents;
+}
+
+int 
+nfs4dev_call(uint32_t type, caddr_t req_data, size_t req_len, caddr_t rep_data, size_t * rep_lenp)
+{
+  	struct nfs4dev_upcall * u;
+	int error = 0; 
+	unsigned int xtmp;
+
+	mtx_lock(&nfs4dev_daemon_mtx);
+	if (nfs4dev_nopen == 0) {
+		mtx_unlock(&nfs4dev_daemon_mtx);
+		return EINVAL;
+	}
+	mtx_unlock(&nfs4dev_daemon_mtx);
+
+	if (type > NFS4DEV_MAX_TYPE)
+	  return EOPNOTSUPP;
+
+	NFS4DEV_DEBUG("upcall %d/%d:%d\n", type, req_len, *rep_lenp);
+
+	nfs4dev_upcall_get(u);
+
+	u->up_error = 0;
+	u->up_rep = rep_data;
+	u->up_replen = rep_lenp;
+	u->up_copied = 0;
+
+	u->up_reqmsg.msg_vers = NFS4DEV_VERSION;
+	/* XXX efficient copying */
+	bcopy(req_data, u->up_reqmsg.msg_data, req_len);
+	u->up_reqmsg.msg_len  = req_len;
+
+	mtx_lock(&nfs4dev_newq_mtx);
+
+	/* get new XID */
+	while ((xtmp = arc4random() % 256) == 0);
+	nfs4dev_xid += xtmp;
+	u->up_reqmsg.msg_xid = nfs4dev_xid;
+
+	TAILQ_INSERT_TAIL(&nfs4dev_newq, u, up_entry);
+	mtx_unlock(&nfs4dev_newq_mtx);
+
+
+	NFS4DEV_DEBUG("nfs4dev op: %d xid: %x sleeping\n", u->up_reqmsg.msg_type, u->up_reqmsg.msg_xid);
+
+	do {
+		tsleep(u, PLOCK, "nfs4dev", 0);
+	} while (u->up_copied == 0 && u->up_error == 0);
+
+	/* upcall now removed from the queue */
+
+	NFS4DEV_DEBUG("nfs4dev prog: %d xid: %x continues...\n", 
+	    u->up_reqmsg.msg_type, u->up_reqmsg.msg_xid);
+
+	if (u->up_error) {
+		error = u->up_error; 
+		NFS4DEV_DEBUG("nfs4dev prog: %d xid: %x error: %d\n", 
+	    	    u->up_reqmsg.msg_type, u->up_reqmsg.msg_xid, u->up_error);
+		goto out;
+	}
+
+out:
+	nfs4dev_upcall_put(u);
+	return error;
+}
+
+void
+nfs4dev_purge(void)
+{
+  	struct nfs4dev_upcall * u;
+
+	mtx_lock(&nfs4dev_newq_mtx);
+	while (!TAILQ_EMPTY(&nfs4dev_newq)) {
+		u = TAILQ_FIRST(&nfs4dev_newq);
+		TAILQ_REMOVE(&nfs4dev_newq, u, up_entry);
+		u->up_error = EINTR;
+		wakeup(u);
+	}
+	mtx_unlock(&nfs4dev_newq_mtx);
+
+	mtx_lock(&nfs4dev_waitq_mtx);
+	while (!TAILQ_EMPTY(&nfs4dev_waitq)) {
+		u = TAILQ_FIRST(&nfs4dev_waitq);
+		TAILQ_REMOVE(&nfs4dev_waitq, u, up_entry);
+		u->up_error = EINTR;
+		wakeup(u);
+	}
+	mtx_unlock(&nfs4dev_waitq_mtx);
+}
diff --git a/sys/nfs4client/nfs4_dev.h b/sys/nfs4client/nfs4_dev.h
new file mode 100644
index 0000000..218f1de
--- /dev/null
+++ b/sys/nfs4client/nfs4_dev.h
@@ -0,0 +1,65 @@
+/* $FreeBSD$ */
+/* $Id: nfs4_dev.h,v 1.3 2003/11/05 14:58:59 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+#ifndef _NFS3_DEV_H_
+#define _NFS4_DEV_H_
+
+#include <sys/ioccom.h>
+
+
+/* type of upcall */
+#define NFS4DEV_TYPE_IDMAP 0
+#define NFS4DEV_TYPE_GSS   1
+#define NFS4DEV_MAX_TYPE   1
+
+struct nfs4dev_msg {
+	unsigned int msg_vers;
+	unsigned int msg_type;
+	unsigned int msg_xid;
+	unsigned int msg_error;
+
+	#define NFS4DEV_MSG_MAX_DATALEN 350 
+	size_t msg_len;
+	uint8_t msg_data[NFS4DEV_MSG_MAX_DATALEN];
+};
+
+#define NFS4DEV_VERSION  (0x3 << 16 | sizeof(struct nfs4dev_msg))
+
+/* ioctl commands */
+#define NFS4DEVIOCGET _IOR('A', 0x200, struct nfs4dev_msg)
+#define NFS4DEVIOCPUT _IOW('A', 0x201, struct nfs4dev_msg)
+
+#ifdef _KERNEL
+int nfs4dev_call(uint32_t type, caddr_t req_data, size_t req_len, caddr_t rep_datap, size_t * rep_lenp);
+
+void nfs4dev_purge(void);
+
+void nfs4dev_init(void);
+void nfs4dev_uninit(void);
+#endif
+
+#endif /* _NFS4_DEV_H_ */
diff --git a/sys/nfs4client/nfs4_idmap.c b/sys/nfs4client/nfs4_idmap.c
new file mode 100644
index 0000000..1b932e6
--- /dev/null
+++ b/sys/nfs4client/nfs4_idmap.c
@@ -0,0 +1,513 @@
+/* $FreeBSD$ */
+/* $Id: nfs4_idmap.c,v 1.4 2003/11/05 14:58:59 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+/* TODO: 
+ *  o validate ascii 
+ * */
+
+#include <sys/param.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/lockmgr.h>
+#include <sys/fnv_hash.h>
+#include <sys/proc.h>
+#include <sys/syscall.h>
+#include <sys/sysent.h>
+#include <sys/libkern.h>
+
+#include <rpc/rpcclnt.h>
+
+#include <nfs4client/nfs4_dev.h>
+#include <nfs4client/nfs4_idmap.h>
+
+
+#ifdef IDMAPVERBOSE
+#define IDMAP_DEBUG(X...) printf(X);
+#else
+#define IDMAP_DEBUG(X...)
+#endif
+
+#define IDMAP_HASH_SIZE 37
+
+MALLOC_DEFINE(M_IDMAP, "idmap", "idmap");
+
+#define idmap_entry_get(ID) MALLOC((ID), struct idmap_entry, sizeof(struct idmap_entry), M_IDMAP, M_WAITOK | M_ZERO)
+#define idmap_entry_put(ID) FREE((ID), M_IDMAP)
+
+
+
+struct idmap_entry {
+	struct idmap_msg id_info;
+
+	TAILQ_ENTRY(idmap_entry) id_entry_id;
+	TAILQ_ENTRY(idmap_entry) id_entry_name;
+};
+
+struct idmap_hash {
+	TAILQ_HEAD(, idmap_entry) hash_name[IDMAP_HASH_SIZE];
+	TAILQ_HEAD(, idmap_entry) hash_id[IDMAP_HASH_SIZE];
+
+	struct lock hash_lock;
+};
+
+#define IDMAP_RLOCK(lock) lockmgr(lock, LK_SHARED, NULL, curthread)
+#define IDMAP_WLOCK(lock) lockmgr(lock, LK_EXCLUSIVE, NULL, curthread)
+#define IDMAP_UNLOCK(lock) lockmgr(lock, LK_RELEASE, NULL, curthread)
+
+
+static struct idmap_hash idmap_uid_hash;
+static struct idmap_hash idmap_gid_hash;
+
+static struct idmap_entry * idmap_name_lookup(uint32_t, char *);
+static struct idmap_entry * idmap_id_lookup(uint32_t, ident_t);
+static int idmap_upcall_name(uint32_t, char *, struct idmap_entry **);
+static int idmap_upcall_id(uint32_t , ident_t, struct idmap_entry ** );
+static int idmap_add(struct idmap_entry *);
+
+static int
+idmap_upcall_name(uint32_t type, char * name, struct idmap_entry ** found)
+{
+	int error;
+	struct idmap_entry * e;
+	size_t len, siz;
+
+	if (type > IDMAP_MAX_TYPE || type == 0) {
+		IDMAP_DEBUG("bad type %d\n", type);
+	 	return EINVAL; /* XXX */ 
+	}
+
+	if (name == NULL || (len = strlen(name)) == 0 || len > IDMAP_MAXNAMELEN) {
+		IDMAP_DEBUG("idmap_upcall_name: bad name\n");
+		return EFAULT;	/* XXX */
+	}
+
+	MALLOC(e, struct idmap_entry *, sizeof(struct idmap_entry), M_IDMAP,
+	    M_WAITOK | M_ZERO);
+
+	e->id_info.id_type = type;
+	bcopy(name, e->id_info.id_name, len); 
+	e->id_info.id_namelen = len;
+
+
+	siz = sizeof(struct idmap_msg);
+	error = nfs4dev_call(NFS4DEV_TYPE_IDMAP, (caddr_t)&e->id_info, siz, 
+	    (caddr_t)&e->id_info, &siz);
+
+	if (error) {
+		IDMAP_DEBUG("error %d in nfs4dev_upcall()\n", error);
+		*found = NULL;
+		return error;
+	}
+
+	if (siz != sizeof(struct idmap_msg)) {
+	  	IDMAP_DEBUG("bad size of returned message\n");
+		*found = NULL;
+		return EFAULT;
+	}
+
+		
+	*found = e;
+	return 0;
+}
+
+static int
+idmap_upcall_id(uint32_t type, ident_t id, struct idmap_entry ** found)
+{
+	int error;
+	struct idmap_entry * e;
+	size_t siz;
+
+	if (type > IDMAP_MAX_TYPE)
+	 	panic("bad type"); /* XXX */ 
+
+	MALLOC(e, struct idmap_entry *, sizeof(struct idmap_entry), M_IDMAP,
+	    M_WAITOK | M_ZERO);
+
+	e->id_info.id_type = type;
+	e->id_info.id_namelen = 0;	/* should already */
+	e->id_info.id_id = id;
+
+	siz = sizeof(struct idmap_msg);
+	error = nfs4dev_call(NFS4DEV_TYPE_IDMAP, (caddr_t)&e->id_info, siz, 
+	    (caddr_t)&e->id_info, &siz);
+
+	if (error) {
+		IDMAP_DEBUG("error %d in nfs4dev_upcall()\n", error);
+		*found = NULL;
+		return error;
+	}
+
+	if (siz != sizeof(struct idmap_msg)) {
+	  	IDMAP_DEBUG("bad size of returned message\n");
+		*found = NULL;
+		return EFAULT;
+	}
+
+	*found = e;
+	return 0;
+}
+
+static int 
+idmap_hashf(struct idmap_entry *e, uint32_t * hval_id, uint32_t * hval_name) 
+{
+	switch (e->id_info.id_type) {
+                case IDMAP_TYPE_UID:
+                        *hval_id = e->id_info.id_id.uid % IDMAP_HASH_SIZE;
+                break;
+                case IDMAP_TYPE_GID:
+                        *hval_id = e->id_info.id_id.gid % IDMAP_HASH_SIZE;
+                break;
+                default:
+                        /* XXX yikes! */
+                        panic("hashf: bad type!");
+                break;
+        }
+
+	if (e->id_info.id_namelen == 0) 
+		/* XXX */ panic("hashf: bad name");
+
+	*hval_name = fnv_32_str(e->id_info.id_name, FNV1_32_INIT) % IDMAP_HASH_SIZE;
+	return 0;
+}
+
+static int
+idmap_add(struct idmap_entry * e)
+{
+	struct idmap_hash * hash;
+        uint32_t hval_id, hval_name;
+
+	if (e == NULL)
+	  panic("idmap_add null");
+
+	if (e->id_info.id_namelen == 0)
+	  panic("idmap_add name of len 0");
+
+        switch (e->id_info.id_type) {
+                case IDMAP_TYPE_UID:
+                        hash = &idmap_uid_hash;
+                break;
+                case IDMAP_TYPE_GID:
+                        hash = &idmap_gid_hash;
+                break;
+                default:
+                        /* XXX yikes */
+                        panic("idmap add: bad type!");
+                break;
+        }
+
+	if (idmap_hashf(e, &hval_id, &hval_name) != 0) {
+		IDMAP_DEBUG("idmap_hashf fails!\n");
+		return -1;
+	}
+
+	IDMAP_WLOCK(&hash->hash_lock);
+
+	TAILQ_INSERT_TAIL(&hash->hash_id[hval_id], e, id_entry_id);
+	TAILQ_INSERT_TAIL(&hash->hash_name[hval_name], e, id_entry_name);
+
+	IDMAP_UNLOCK(&hash->hash_lock);
+
+	return 0;
+}
+
+static struct idmap_entry * 
+idmap_id_lookup(uint32_t type, ident_t id)
+{
+	struct idmap_hash * hash;
+	uint32_t hval;
+	struct idmap_entry * e;
+
+	switch (type) {
+		case IDMAP_TYPE_UID:
+	 		hash = &idmap_uid_hash; 
+			hval = id.uid % IDMAP_HASH_SIZE;
+		break;
+		case IDMAP_TYPE_GID:
+	 		hash = &idmap_gid_hash; 
+			hval = id.gid % IDMAP_HASH_SIZE;
+		break;
+		default:
+			/* XXX yikes */
+			panic("lookup: bad type!");	
+		break;
+	}
+	
+
+	IDMAP_RLOCK(&hash->hash_lock);
+
+	TAILQ_FOREACH(e, &hash->hash_id[hval], id_entry_name) {
+	  	if ((type == IDMAP_TYPE_UID && e->id_info.id_id.uid == id.uid)||
+		    (type == IDMAP_TYPE_GID  && e->id_info.id_id.gid == id.gid)) {
+			IDMAP_UNLOCK(&hash->hash_lock);
+			return e;
+		}
+	}
+
+	IDMAP_UNLOCK(&hash->hash_lock);
+	return NULL;
+}
+
+static struct idmap_entry * 
+idmap_name_lookup(uint32_t type, char * name)
+{
+	struct idmap_hash * hash;
+	uint32_t hval;
+	struct idmap_entry * e;
+	size_t len;
+
+	switch (type) {
+	case IDMAP_TYPE_UID:
+	 	hash = &idmap_uid_hash; 
+	break;
+	case IDMAP_TYPE_GID:
+	 	hash = &idmap_gid_hash; 
+	break;
+	default:
+		/* XXX yikes */
+		panic("lookup: bad type!");	
+	break;
+	}
+	
+	len = strlen(name);
+
+	if (len == 0 || len > IDMAP_MAXNAMELEN) {
+		IDMAP_DEBUG("bad name length %d\n", len);
+		return NULL;
+	}
+
+	hval = fnv_32_str(name, FNV1_32_INIT) % IDMAP_HASH_SIZE;
+
+	IDMAP_RLOCK(&hash->hash_lock);
+
+	TAILQ_FOREACH(e, &hash->hash_name[hval], id_entry_name) {
+		if ((strlen(e->id_info.id_name) == strlen(name)) && strncmp(e->id_info.id_name, name, strlen(name)) == 0) {
+			IDMAP_UNLOCK(&hash->hash_lock);
+			return e;
+		}
+	}
+
+	IDMAP_UNLOCK(&hash->hash_lock);
+	return NULL;
+}
+
+void 
+idmap_init(void)
+{
+	unsigned int i;
+
+	for (i=0; i<IDMAP_HASH_SIZE; i++) {
+		TAILQ_INIT(&idmap_uid_hash.hash_name[i]);
+		TAILQ_INIT(&idmap_uid_hash.hash_id[i]);
+
+		TAILQ_INIT(&idmap_gid_hash.hash_name[i]);
+		TAILQ_INIT(&idmap_gid_hash.hash_id[i]);
+	}
+
+	lockinit(&idmap_uid_hash.hash_lock, PLOCK, "idmap uid hash table", 0,0);
+	lockinit(&idmap_gid_hash.hash_lock, PLOCK, "idmap gid hash table", 0,0);
+
+}
+
+void idmap_uninit(void)
+{
+  	struct idmap_entry * e;
+	int i;
+
+	lockdestroy(&idmap_uid_hash.hash_lock);
+	lockdestroy(&idmap_gid_hash.hash_lock);
+
+	for (i=0; i<IDMAP_HASH_SIZE; i++) {
+		while(!TAILQ_EMPTY(&idmap_uid_hash.hash_name[i])) {
+			e = TAILQ_FIRST(&idmap_uid_hash.hash_name[i]);
+			TAILQ_REMOVE(&idmap_uid_hash.hash_name[i], e, id_entry_name);
+			TAILQ_REMOVE(&idmap_uid_hash.hash_id[i], e, id_entry_id);
+			FREE(e, M_IDMAP);
+		}
+
+		while(!TAILQ_EMPTY(&idmap_gid_hash.hash_name[i])) {
+			e = TAILQ_FIRST(&idmap_gid_hash.hash_name[i]);
+			TAILQ_REMOVE(&idmap_gid_hash.hash_name[i], e, id_entry_name);
+			TAILQ_REMOVE(&idmap_gid_hash.hash_id[i], e, id_entry_id);
+			FREE(e, M_IDMAP);
+		}
+
+	}
+}
+
+int 
+idmap_uid_to_name(uid_t uid, char ** name, size_t * len)
+{
+  	struct idmap_entry * e;
+	int error = 0;
+	ident_t id;
+
+	id.uid = uid;
+
+
+	if ((e = idmap_id_lookup(IDMAP_TYPE_UID, id)) == NULL) {
+	  	if ((error = idmap_upcall_id(IDMAP_TYPE_UID, id, &e)) != 0) {
+			IDMAP_DEBUG("error in upcall\n");
+			return error;
+		}
+
+		if (e == NULL) {
+			IDMAP_DEBUG("no error from upcall, but no data returned\n");
+			return EFAULT;
+		}
+
+		if (idmap_add(e) != 0) {
+			IDMAP_DEBUG("idmap_add failed\n");
+			FREE(e, M_IDMAP);
+		}
+	}
+
+	*name = e->id_info.id_name;
+	*len = e->id_info.id_namelen;
+	return 0;
+}
+
+int 
+idmap_gid_to_name(gid_t gid, char ** name, size_t * len)
+{
+  	struct idmap_entry * e;
+	int error = 0;
+	ident_t id;
+	
+	id.gid = gid;
+
+
+	if ((e = idmap_id_lookup(IDMAP_TYPE_GID, id)) == NULL) {
+	  	if ((error = idmap_upcall_id(IDMAP_TYPE_GID, (ident_t)id, &e))) {
+			IDMAP_DEBUG("error in upcall\n");
+			return error;
+		}
+
+		if (e == NULL) {
+			IDMAP_DEBUG("no error from upcall, but no data returned\n");
+			return EFAULT;
+		}
+
+		if (idmap_add(e) != 0) {
+			IDMAP_DEBUG("idmap_add failed\n");
+			FREE(e, M_IDMAP);
+		}
+	}
+
+	*name = e->id_info.id_name;
+	*len  = e->id_info.id_namelen;
+	return 0;
+}
+
+int 
+idmap_name_to_uid(char * name, size_t len, uid_t * id)
+{
+  	struct idmap_entry * e;
+	int error = 0;
+	char * namestr;
+
+	if (name == NULL )
+		return EFAULT;
+
+	if (len == 0 || len > IDMAP_MAXNAMELEN) {
+	  	IDMAP_DEBUG("idmap_name_to_uid: bad len\n");
+	  	return EINVAL;
+	}
+
+	/* XXX hack */
+	MALLOC(namestr, char *, len + 1, M_TEMP, M_WAITOK);
+	bcopy(name, namestr, len);
+	namestr[len] = '\0';
+
+
+	if ((e = idmap_name_lookup(IDMAP_TYPE_UID, namestr)) == NULL) {
+	  	if ((error = idmap_upcall_name(IDMAP_TYPE_UID, namestr, &e))) {
+			FREE(namestr, M_TEMP);
+			return error;
+		}
+
+		if (e == NULL) {
+			IDMAP_DEBUG("no error from upcall, but no data returned\n");
+			FREE(namestr, M_TEMP);
+			return EFAULT;
+		}
+
+		if (idmap_add(e) != 0) {
+			IDMAP_DEBUG("idmap_add failed\n");
+			FREE(e, M_IDMAP);
+		}
+	}
+
+	*id = e->id_info.id_id.uid;
+	FREE(namestr, M_TEMP);
+	return 0;
+}
+
+int 
+idmap_name_to_gid(char * name, size_t len, gid_t * id)
+{
+  	struct idmap_entry * e;
+	int error = 0;
+
+	char * namestr;
+
+	if (name == NULL )
+		return EFAULT;
+
+	if (len == 0 || len > IDMAP_MAXNAMELEN) {
+	  	IDMAP_DEBUG("idmap_name_to_uid: bad len\n");
+	  	return EINVAL;
+	}
+
+	/* XXX hack */
+	MALLOC(namestr, char *, len + 1, M_TEMP, M_WAITOK);
+	bcopy(name, namestr, len);
+	namestr[len] = '\0';
+
+
+	if ((e = idmap_name_lookup(IDMAP_TYPE_GID, namestr)) == NULL) {
+	  	if ((error = idmap_upcall_name(IDMAP_TYPE_GID, namestr, &e)) != 0) {
+			IDMAP_DEBUG("error in upcall\n");
+			FREE(namestr, M_TEMP);
+			return error;
+		}
+
+		if (e == NULL) {
+			IDMAP_DEBUG("no error from upcall, but no data returned\n");
+			FREE(namestr, M_TEMP);
+			return EFAULT;
+		}
+
+		if (idmap_add(e) != 0) {
+			IDMAP_DEBUG("idmap_add failed\n");
+			FREE(e, M_IDMAP);
+		}
+	}
+
+	*id = e->id_info.id_id.gid;
+	FREE(namestr, M_TEMP);
+	return 0;
+}
diff --git a/sys/nfs4client/nfs4_idmap.h b/sys/nfs4client/nfs4_idmap.h
new file mode 100644
index 0000000..86cd01b
--- /dev/null
+++ b/sys/nfs4client/nfs4_idmap.h
@@ -0,0 +1,64 @@
+/* $FreeBSD$ */
+/* $Id: nfs4_idmap.h,v 1.2 2003/11/05 14:58:59 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+#ifndef __NFS4_IDMAP_H__
+#define __NFS4_IDMAP_H__
+
+#define IDMAP_TYPE_GID 1
+#define IDMAP_TYPE_UID 2
+#define IDMAP_MAX_TYPE 2
+
+typedef union {
+  uid_t uid;
+  gid_t gid;
+} ident_t;
+
+#define IDMAP_MAXNAMELEN 249
+struct idmap_msg {
+	uint32_t id_type;
+	ident_t id_id;
+	size_t id_namelen; 
+	char id_name[IDMAP_MAXNAMELEN + 1];
+};
+
+
+#ifdef _KERNEL
+MALLOC_DECLARE(M_IDMAP);
+
+void idmap_init(void);
+void idmap_uninit(void);
+
+int idmap_gid_to_name(gid_t id, char ** name, size_t * len);
+int idmap_uid_to_name(uid_t id, char ** name, size_t * len);
+
+int idmap_name_to_gid(char *, size_t len, gid_t *);
+int idmap_name_to_uid(char *, size_t len, uid_t *);
+
+#endif /* _KERNEL */
+
+
+#endif /* __NFS4_GSS_H__ */
diff --git a/sys/nfs4client/nfs4_socket.c b/sys/nfs4client/nfs4_socket.c
new file mode 100644
index 0000000..f997d52
--- /dev/null
+++ b/sys/nfs4client/nfs4_socket.c
@@ -0,0 +1,340 @@
+/* $FreeBSD$ */
+/* $Id: nfs_socket.c,v 1.12 2003/11/05 14:59:01 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+/*
+ * Copyright (c) 1989, 1991, 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_socket.c	8.5 (Berkeley) 3/30/95
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * Socket operations for use by nfs
+ */
+
+#include "opt_inet6.h"
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/mount.h>
+#include <sys/mutex.h>
+#include <sys/proc.h>
+#include <sys/protosw.h>
+#include <sys/signalvar.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/syslog.h>
+#include <sys/vnode.h>
+
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+
+#include <rpc/rpcclnt.h>
+
+#include <nfs/rpcv2.h>
+#include <nfs/nfsproto.h>
+#include <nfsclient/nfs.h>
+#include <nfs4client/nfs4.h>
+#include <nfs/xdr_subs.h>
+#include <nfsclient/nfsm_subs.h>
+#include <nfsclient/nfsmount.h>
+
+#ifdef NFS4_USE_RPCCLNT
+#include <rpc/rpcclnt.h>
+#include <rpc/rpcm_subs.h>
+#endif
+
+#ifdef NFS4_USE_RPCCLNT
+static struct rpc_program nfs_program = {
+  NFS_PROG, NFS_VER4, "NFSv4"
+};
+#endif
+
+
+int
+nfs4_connect(struct nfsmount *nmp)
+{
+	struct rpcclnt * rpc = &nmp->nm_rpcclnt;
+	struct rpc_auth * auth;
+	int flag = 0;
+	int error;
+
+	/* XXX hack! */
+#ifdef __OpenBSD__
+	struct proc * td = curproc;
+#else
+	struct thread * td = curthread;
+#endif
+
+	MALLOC(auth, struct rpc_auth *, sizeof(struct rpc_auth), M_TEMP, M_WAITOK);
+	auth->auth_type  = RPCAUTH_UNIX;
+
+	/* translate nfs flags -> rpcclnt flags */
+	if (nmp->nm_flag & NFSMNT_SOFT)
+		flag |= RPCCLNT_SOFT;
+
+	if (nmp->nm_flag & NFSMNT_INT)
+		flag |= RPCCLNT_INT;
+
+	if (nmp->nm_flag & NFSMNT_NOCONN)
+		flag |= RPCCLNT_NOCONN;
+
+	if (nmp->nm_flag & NFSMNT_DUMBTIMR)
+		flag |= RPCCLNT_DUMBTIMR;
+
+	/* rpc->rc_servername = nmp->nm_mountp->mnt_stat.f_mntfromname; */
+				  
+	error = rpcclnt_setup(rpc, &nfs_program, nmp->nm_nam, nmp->nm_sotype,
+			      nmp->nm_soproto, auth, 
+			      /* XXX: check nmp->nm_flag to make sure these are set */
+			      (nmp->nm_rsize > nmp->nm_readdirsize) ? nmp->nm_rsize : nmp->nm_readdirsize,
+			      nmp->nm_wsize, flag);
+
+	/* set deadthresh, timeo, retry */
+	rpc->rc_deadthresh = nmp->nm_deadthresh;
+	rpc->rc_timeo = nmp->nm_timeo;
+	rpc->rc_retry = nmp->nm_retry;
+
+
+	if (error)
+		return error;
+
+	return rpcclnt_connect(rpc, td);
+}
+
+/*
+ * NFS disconnect. Clean up and unlink.
+ */
+void
+nfs4_disconnect(struct nfsmount *nmp)
+{
+	rpcclnt_disconnect(&nmp->nm_rpcclnt);
+}
+
+void
+nfs4_safedisconnect(struct nfsmount *nmp)
+{
+	rpcclnt_safedisconnect(&nmp->nm_rpcclnt);
+}
+
+/*
+ * nfs_request - goes something like this
+ *	- fill in request struct
+ *	- links it into list
+ *	- calls nfs_send() for first transmit
+ *	- calls nfs_receive() to get reply
+ *	- break down rpc header and return with nfs reply pointed to
+ *	  by mrep or error
+ * nb: always frees up mreq mbuf list
+ */
+/* XXX overloaded before */
+#define	NQ_TRYLATERDEL	15	/* Initial try later delay (sec) */
+
+int
+nfs4_request(struct vnode *vp, struct mbuf *mrest, int procnum,
+    struct thread *td, struct ucred *cred, struct mbuf **mrp,
+    struct mbuf **mdp, caddr_t *dposp)
+{
+	int error;
+	u_int32_t *tl;
+	struct nfsmount * nmp = VFSTONFS(vp->v_mount);
+	struct rpcclnt * clnt = &nmp->nm_rpcclnt;
+	struct mbuf *md, *mrep;
+	caddr_t dpos;
+	struct rpc_reply reply;
+
+	if ((error = rpcclnt_request(clnt, mrest, procnum, td, cred,
+	    &reply)) != 0) {
+		goto out;
+	}
+
+	/* XXX: don't free mrest if an error occured, to allow caller to retry*/
+	m_freem(mrest);
+	mrep = reply.mrep;
+	md = reply.result_md;
+	dpos = reply.result_dpos;
+
+	tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
+	if (*tl != 0) {
+		error = fxdr_unsigned(int, *tl);
+
+		#if 0
+		if ((nmp->nm_flag & NFSMNT_NFSV3) &&
+		    error == NFSERR_TRYLATER) {
+			m_freem(mrep);
+			error = 0;
+			waituntil = time_second + trylater_delay;
+			while (time_second < waituntil)
+				(void) tsleep(&lbolt, PSOCK, "nqnfstry", 0);
+			trylater_delay *= nfs_backoff[trylater_cnt];
+			if (trylater_cnt < NFS_NBACKOFF - 1)
+				trylater_cnt++;
+			goto tryagain;
+		}
+		#endif
+
+		/*
+ 		** If the File Handle was stale, invalidate the
+ 		** lookup cache, just in case.
+ 		**/
+		if (error == ESTALE)
+			cache_purge(vp);
+		goto out;
+	}
+
+	*mrp = mrep;
+	*mdp = md;
+	*dposp = dpos;
+	return (0);
+nfsmout:
+out:
+	m_freem(reply.mrep);
+	*mrp = NULL;
+	*mdp = NULL;
+	return (error);
+}
+
+
+int
+nfs4_request_mnt(struct nfsmount *nmp, struct mbuf *mrest, int procnum,
+    struct thread *td, struct ucred *cred, struct mbuf **mrp,
+    struct mbuf **mdp, caddr_t *dposp)
+{
+	int error;
+	u_int32_t *tl;
+	struct rpcclnt * clnt = &nmp->nm_rpcclnt;
+	struct mbuf *md, *mrep;
+	caddr_t dpos;
+	struct rpc_reply reply;
+
+	if ((error = rpcclnt_request(clnt, mrest, procnum, td, cred,
+	    &reply)) != 0) {
+		goto out;
+	}
+
+	/* XXX: don't free mrest if an error occured, to allow caller to retry*/
+	m_freem(mrest);
+	mrep = reply.mrep;
+	md = reply.result_md;
+	dpos = reply.result_dpos;
+
+	tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
+	if (*tl != 0) {
+		error = fxdr_unsigned(int, *tl);
+#if 0
+		if ((nmp->nm_flag & NFSMNT_NFSV3) &&
+		    error == NFSERR_TRYLATER) {
+			m_freem(mrep);
+			error = 0;
+			waituntil = time_second + trylater_delay;
+			while (time_second < waituntil)
+				(void) tsleep(&lbolt, PSOCK, "nqnfstry", 0);
+			trylater_delay *= nfs_backoff[trylater_cnt];
+			if (trylater_cnt < NFS_NBACKOFF - 1)
+				trylater_cnt++;
+			goto tryagain;
+		}
+#endif
+		goto out;
+	}
+
+	*mrp = mrep;
+	*mdp = md;
+	*dposp = dpos;
+	return (0);
+nfsmout:
+out:
+	m_freem(reply.mrep);
+	*mrp = NULL;
+	*mdp = NULL;
+	return (error);
+}
+
+
+/*
+ * Mark all of an nfs mount's outstanding requests with R_SOFTTERM and
+ * wait for all requests to complete. This is used by forced unmounts
+ * to terminate any outstanding RPCs.
+ */
+int
+nfs4_nmcancelreqs(nmp)
+	struct nfsmount *nmp;
+{
+	return rpcclnt_cancelreqs(&nmp->nm_rpcclnt);
+}
+
+/*
+ * Test for a termination condition pending on the process.
+ * This is used for NFSMNT_INT mounts.
+ */
+int
+nfs4_sigintr(struct nfsmount *nmp, struct nfsreq *rep, struct thread *td)
+{
+	if (rep != NULL) {
+		printf("nfs_sigintr: attempting to use nfsreq != NULL\n");
+		return EINTR;
+	}
+	return rpcclnt_sigintr(&nmp->nm_rpcclnt, NULL, td);
+}
diff --git a/sys/nfs4client/nfs4_subs.c b/sys/nfs4client/nfs4_subs.c
new file mode 100644
index 0000000..22ccfa8
--- /dev/null
+++ b/sys/nfs4client/nfs4_subs.c
@@ -0,0 +1,1352 @@
+/* $FreeBSD$ */
+/* $Id: nfs4_subs.c,v 1.52 2003/11/05 14:58:59 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+#include <sys/cdefs.h>
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bio.h>
+#include <sys/buf.h>
+#include <sys/proc.h>
+#include <sys/mount.h>
+#include <sys/vnode.h>
+#include <sys/namei.h>
+#include <sys/mbuf.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/malloc.h>
+#include <sys/sysent.h>
+#include <sys/syscall.h>
+#include <sys/sysproto.h>
+#include <sys/fcntl.h>
+
+#include <machine/stdarg.h>
+
+#include <vm/vm.h>
+#include <vm/vm_object.h>
+#include <vm/vm_extern.h>
+#include <vm/uma.h>
+
+#include <rpc/rpcclnt.h>
+
+#include <nfs/rpcv2.h>
+#include <nfs/nfsproto.h>
+#include <nfsclient/nfs.h>
+#include <nfs4client/nfs4.h>
+#include <nfsclient/nfsnode.h>
+#include <nfsclient/nfsmount.h>
+#include <nfs/xdr_subs.h>
+#include <nfsclient/nfsm_subs.h>
+
+#include <nfs4client/nfs4_dev.h>
+#include <nfs4client/nfs4_idmap.h>
+#include <nfs4client/nfs4m_subs.h>
+
+#include <netinet/in.h>
+
+#define NFSM_DISSECT(s) do {							\
+	tl = nfsm_dissect_xx((s), md, dpos);					\
+	if (tl == NULL) {							\
+		printf("NFSM_DISSECT error; allocation (%s/%d) (%s:%d)\n", #s, s, __FILE__, __LINE__);	\
+		return (EBADRPC);						\
+	}									\
+} while (0)
+
+#define NFSM_ADV(s) do {						\
+	t1 = nfsm_adv_xx((s), md, dpos);				\
+	if (t1 != 0) {							\
+		printf("NFSM_ADV error; allocation (%s/%d) (%s:%d)\n", #s, s, __FILE__, __LINE__);	\
+		return (EBADRPC);					\
+	}								\
+} while (0)
+
+#define NFSM_MTOTIME(t) do {				\
+	NFSM_DISSECT(3 * NFSX_UNSIGNED);		\
+	(t).tv_sec = fxdr_hyper(tl);			\
+	tl += 2;					\
+	(t).tv_nsec = fxdr_unsigned(long, *tl++);	\
+} while (0)
+
+static uint32_t __fsinfo_bm[2], __fsattr_bm[2], __getattr_bm[2], __readdir_bm[2];
+
+nfsv4bitmap nfsv4_fsinfobm = { 2, __fsinfo_bm };
+nfsv4bitmap nfsv4_fsattrbm = { 2, __fsattr_bm };
+nfsv4bitmap nfsv4_getattrbm = { 2, __getattr_bm };
+nfsv4bitmap nfsv4_readdirbm = { 2, __readdir_bm };
+
+/* Helper routines */
+int nfsm_v4build_attrs_xx(struct vattr *, struct mbuf **, caddr_t *);
+int nfsm_v4dissect_changeinfo_xx(nfsv4changeinfo *,  struct mbuf **, caddr_t *);
+
+void
+nfsm_v4init(void)
+{
+
+	/* Set up bitmasks */
+        FA4_SET(FA4_FSID, __fsinfo_bm);
+        FA4_SET(FA4_MAXREAD, __fsinfo_bm);
+        FA4_SET(FA4_MAXWRITE, __fsinfo_bm);
+        FA4_SET(FA4_LEASE_TIME, __fsinfo_bm);
+
+	FA4_SET(FA4_FSID, __fsattr_bm);
+        FA4_SET(FA4_FILES_FREE, __fsattr_bm);
+        FA4_SET(FA4_FILES_TOTAL, __fsattr_bm);
+        FA4_SET(FA4_SPACE_AVAIL, __fsattr_bm);
+        FA4_SET(FA4_SPACE_FREE, __fsattr_bm);
+        FA4_SET(FA4_SPACE_TOTAL, __fsattr_bm);
+
+	FA4_SET(FA4_TYPE, __getattr_bm);
+        FA4_SET(FA4_FSID, __getattr_bm);
+        FA4_SET(FA4_SIZE, __getattr_bm);
+        FA4_SET(FA4_MODE, __getattr_bm);
+        FA4_SET(FA4_RAWDEV, __getattr_bm);
+        FA4_SET(FA4_NUMLINKS, __getattr_bm);
+        FA4_SET(FA4_OWNER, __getattr_bm);
+        FA4_SET(FA4_OWNER_GROUP, __getattr_bm);
+        FA4_SET(FA4_FILEID, __getattr_bm);
+        FA4_SET(FA4_TIME_MODIFY, __getattr_bm);
+        FA4_SET(FA4_TIME_ACCESS, __getattr_bm);
+/*        FA4_SET(FA4_TIME_CREATE, __getattr_bm);*/
+
+	FA4_SET(FA4_TYPE, __readdir_bm);
+	FA4_SET(FA4_FSID, __readdir_bm);
+        FA4_SET(FA4_FILEID, __readdir_bm);
+}
+
+/*
+ * Util
+ */
+
+uint32_t
+nfs_v4fileid4_to_fileid(uint64_t fid)
+{
+        return ((uint32_t)((fid >> 32) | fid));
+}
+
+void
+nfs_v4initcompound(struct nfs4_compound *cp)
+{
+	bzero(cp, sizeof(*cp));
+}
+
+/*
+ * Build/dissect XDR buffer with a format string.
+ *
+ *    u - unsigned
+ *    h - hyper
+ *    s - stringlength, string
+ *    k - skip length (bytes)
+ *    a - arraylength, componentlenght, array
+ *    o - opaque fix length
+ *    O - opaque var length in bytes
+ */
+
+void
+nfsm_buildf_xx(struct mbuf **mb, caddr_t *bpos, char *fmt, ...)
+{
+	uint32_t *tl, t1, len, uval;
+	uint64_t hval;
+	va_list args;
+	char *p, *which;
+
+	va_start(args, fmt);
+	for (which = fmt; *which != '\0'; which++)
+		switch (*which) {
+		case 'u':	/* Unsigned */
+			tl = nfsm_build_xx(NFSX_UNSIGNED, mb, bpos);
+			uval = va_arg(args, uint32_t);
+			*tl++ = txdr_unsigned(uval);
+			break;
+		case 'h':	/* Hyper */
+			tl = nfsm_build_xx(2 * NFSX_UNSIGNED, mb, bpos);
+			hval = va_arg(args, uint64_t);
+			txdr_hyper(hval, tl);
+			break;
+		case 'o':	/* Fixed-length opaque */
+			len = va_arg(args, uint32_t);
+			p = va_arg(args, char *);
+			tl = nfsm_build_xx(nfsm_rndup(len), mb, bpos);
+			bcopy(p, tl, len);
+			break;
+		case 'O':	/* Variable-length opaque */
+		case 's':	/* String */
+			len = va_arg(args, uint32_t);
+			p = va_arg(args, char *);
+			t1 = nfsm_strtom_xx(p, len, len, mb, bpos);
+			break;
+		case 'k':	/* Skip */
+			len = va_arg(args, uint32_t);
+			nfsm_build_xx(nfsm_rndup(len), mb, bpos);
+			break;
+		default:
+			panic("Invalid buildf string %s[%c]", fmt, *which);
+			break;
+		}
+	va_end(args);
+}
+
+int
+nfsm_dissectf_xx(struct mbuf **md, caddr_t *dpos, char *fmt, ...)
+{
+	uint32_t *tl, t1, len, *uval;
+	uint64_t *hval;
+	va_list args;
+	char *p, *which;
+
+	va_start(args, fmt);
+	for (which = fmt; *which != '\0'; which++)
+		switch (*which) {
+		case 'u':	/* Unsigned */
+			tl = nfsm_dissect_xx(NFSX_UNSIGNED, md, dpos);
+			if (tl == NULL)
+				return (EBADRPC);
+			uval = va_arg(args, uint32_t *);
+			*uval = fxdr_unsigned(uint32_t, *tl++);
+			break;
+		case 'h':	/* Hyper */
+			tl = nfsm_dissect_xx(2 * NFSX_UNSIGNED, md, dpos);
+			if (tl == NULL)
+				return (EBADRPC);
+			hval = va_arg(args, uint64_t *);
+			*hval = fxdr_hyper(tl);
+			break;
+		case 'o':	/* Fixed-length opaque */
+			len = va_arg(args, uint32_t);
+			p = va_arg(args, void *);
+			tl = nfsm_dissect_xx(nfsm_rndup(len), md, dpos);
+			if (tl == NULL)
+				return (EBADRPC);
+			bcopy(tl, p, len);
+			break;
+		case 'O':	/* Variable-length opaque */
+		case 's':	/* String */
+			len = va_arg(args, uint32_t);
+			p = va_arg(args, char *);
+			tl = nfsm_dissect_xx(nfsm_rndup(len), md, dpos);
+			if (tl == NULL)
+				return (EBADRPC);
+			bcopy(tl, p, len);
+			break;
+		case 'k':	/* Skip bytes */
+			len = va_arg(args, uint32_t);
+			t1 = nfsm_adv_xx(nfsm_rndup(len), md, dpos);
+			break;
+		default:
+			panic("Invalid dissectf string %s[%c]", fmt, *which);
+			break;
+		}
+	va_end(args);
+
+	return (0);
+}
+
+/*
+ * XXX - There are a few problems with the way the postops are places
+ * in the code.  Ideally, they should be taken care of immediately, as
+ * to avoid uneceesary waits for mutexes, but then we would be
+ * introducing even more complexity by having to handle two separate
+ * cases.  Also, since they are placed at the end of the vnops', there
+ * may be operations which sleep in between, further extending this
+ * wait.  It is conceivable that there is a deadlock condition there,
+ * too.
+ *
+ * Also, for vnops that do multiple operations, it's inconvenient
+ * since on error, individual decoding will got nfsmout.
+ */
+
+int
+nfs_v4postop(struct nfs4_compound *cp, int status)
+{
+	struct nfs4_fctx *fcp = cp->fcp;
+
+	/*
+	 * XXX does the previous result need to be stores with the
+	 * lockowner?  ack, spec is unclear ..
+	 */
+
+	if (fcp != NULL)
+		if (cp->seqidused < cp->rep_nops ||
+		    (cp->seqidused + 1 == cp->rep_nops &&
+			NFS4_SEQIDMUTATINGERROR(status)))
+			fcp->lop->lo_seqid++;
+
+	return (status);
+}
+
+int
+nfs_v4handlestatus(int status, struct nfs4_compound *cp)
+{
+	return (status);
+}
+
+/*
+ * Initial setup of compound.
+ */
+
+int
+nfsm_v4build_compound_xx(struct nfs4_compound *cp, char *tag,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	uint32_t t1, *tl, siz;
+
+	/* Tag */
+	siz = strlen(tag);
+	t1 = nfsm_rndup(siz) + NFSX_UNSIGNED;
+	if (t1 <= M_TRAILINGSPACE(*mb)) {
+		tl = nfsm_build_xx(t1, mb, bpos);
+		*tl++ = txdr_unsigned(siz);
+		*(tl + ((t1 >> 2) - 2)) = 0;
+		bcopy(tag, tl, siz);
+	} else {
+		t1 = nfsm_strtmbuf(mb, bpos, (const char *)tag, siz);
+		if (t1 != 0)
+			return (t1);
+	}
+
+	/* Minor version and argarray*/
+	tl = nfsm_build_xx(2 * NFSX_UNSIGNED, mb, bpos);
+	*tl++ = txdr_unsigned(NFS4_MINOR_VERSION);
+	/* Save for backfill */
+	cp->req_nopsp = tl;
+	*tl = txdr_unsigned(0);
+
+	cp->curvp = NULL;
+	cp->savevp = NULL;
+
+	return (0);
+}
+
+/*
+ * XXX
+ * - backfill for stateid, and such
+ */
+int
+nfsm_v4build_finalize_xx(struct nfs4_compound *cp, struct mbuf **mb, caddr_t *bpos)
+{
+	*cp->req_nopsp = txdr_unsigned(cp->req_nops);
+
+	return (0);
+}
+
+int
+nfsm_v4build_putfh_xx(struct nfs4_compound *cp, struct vnode *vp,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	uint32_t t1;
+
+	/* Op */
+	nfsm_buildf_xx(mb, bpos, "u", NFSV4OP_PUTFH);
+
+	/* FH */
+	t1 = nfsm_fhtom_xx(vp, 1, mb, bpos);
+	if (t1 != 0)
+		return (t1);
+
+	cp->req_nops++;
+	cp->curvp = vp;
+
+	return (0);
+}
+
+int
+nfsm_v4build_putfh_nv_xx(struct nfs4_compound *cp, struct nfs4_oparg_getfh *gfh,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "uuo",
+	    NFSV4OP_PUTFH,
+	    gfh->fh_len,
+	    gfh->fh_len,
+	    &gfh->fh_val);
+
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_simple_xx(struct nfs4_compound *cp, uint32_t op,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "u", op);
+
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_getattr_xx(struct nfs4_compound *cp, struct nfs4_oparg_getattr *ga,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	int i;
+
+	/* Op + bitmap length + bitmap */
+	nfsm_buildf_xx(mb, bpos, "uu", NFSV4OP_GETATTR, ga->bm->bmlen);
+	for (i = 0; i < ga->bm->bmlen; i++)
+		nfsm_buildf_xx(mb, bpos, "u", ga->bm->bmval[i]);
+
+	ga->vp = cp->curvp;
+	cp->req_nops++;		 
+
+	return (0);
+}
+
+int
+nfsm_v4build_setattr_xx(struct nfs4_compound *cp, struct vattr *vap,
+    struct nfs4_fctx *fcp, struct mbuf **mb, caddr_t *bpos)
+{
+	int error;
+
+	nfsm_buildf_xx(mb, bpos, "uo",
+	    NFSV4OP_SETATTR,
+	    NFSX_V4STATEID, fcp->stateid);
+	error = nfsm_v4build_attrs_xx(vap, mb, bpos);
+	if (error == 0)
+		cp->req_nops++;
+
+	return (error);
+}
+
+int
+nfsm_v4build_getfh_xx(struct nfs4_compound *cp, struct nfs4_oparg_getfh *gfh,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "u", NFSV4OP_GETFH);
+
+	gfh->vp = cp->curvp;
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_lookup_xx(struct nfs4_compound *cp, struct nfs4_oparg_lookup *l,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "us", NFSV4OP_LOOKUP, l->namelen, l->name);
+
+	cp->curvp = l->vp;
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_setclientid_xx(struct nfs4_compound *cp,
+    struct nfs4_oparg_setclientid *sci, struct mbuf **mb, caddr_t *bpos)
+{
+	struct timeval tv;
+
+	microtime(&tv);
+
+	nfsm_buildf_xx(mb, bpos, "uuusussu",
+	    NFSV4OP_SETCLIENTID,
+	    tv.tv_sec, tv.tv_usec,
+	    sci->namelen, sci->name,
+	    sci->cb_prog,
+	    sci->cb_netidlen, sci->cb_netid,
+	    sci->cb_univaddrlen, sci->cb_univaddr,
+	    0xCA11BACC);
+
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_setclientid_confirm_xx(struct nfs4_compound *cp,
+    struct nfs4_oparg_setclientid *sci, struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "uho",
+	    NFSV4OP_SETCLIENTID_CONFIRM,
+	    sci->clientid,
+	    sizeof(sci->verf), sci->verf);
+
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_open_xx(struct nfs4_compound *cp, struct nfs4_oparg_open *op,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	int error = 0;
+	struct nfs4_lowner *lop = op->fcp->lop;
+
+	nfsm_buildf_xx(mb, bpos, "uuuuhuu",
+	    NFSV4OP_OPEN,
+	    lop->lo_seqid,
+	    op->flags & O_ACCMODE,
+	    NFSV4OPENSHARE_DENY_NONE,
+	    cp->nmp->nm_clientid,
+	    4, lop->lo_id);
+
+	if (op->flags & O_CREAT) {
+		nfsm_buildf_xx(mb, bpos, "u", OTCREATE);
+		/* openflag4: mode */
+		nfsm_buildf_xx(mb, bpos, "u", CMUNCHECKED);
+		/* openflag4: createattrs... */
+		if (op->vap != NULL) {
+			if (op->flags & O_TRUNC)
+				op->vap->va_size = 0;
+			error = nfsm_v4build_attrs_xx(op->vap, mb, bpos);
+			if (error != 0)
+				return (error);
+		} else
+			nfsm_buildf_xx(mb, bpos, "uu", 0, 0);
+	} else
+		nfsm_buildf_xx(mb, bpos, "u", OTNOCREATE);
+
+	nfsm_buildf_xx(mb, bpos, "us", op->ctype,
+	    op->cnp->cn_namelen, op->cnp->cn_nameptr);
+
+	cp->seqidused = cp->req_nops++;
+	cp->fcp = op->fcp;
+
+	return (error);
+}
+
+/*
+ * XXX
+ * - Wait on recovery
+ */
+int
+nfsm_v4build_open_confirm_xx(struct nfs4_compound *cp, struct nfs4_oparg_open *op,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "uou",
+	    NFSV4OP_OPEN_CONFIRM,
+	    NFSX_V4STATEID, op->fcp->stateid,
+	    op->fcp->lop->lo_seqid);
+
+	cp->seqidused = cp->req_nops++;
+	cp->fcp = op->fcp;
+
+	return (0);
+}
+
+/*
+ * XXX
+ * - Wait on recovery
+ */
+int
+nfsm_v4build_close_xx(struct nfs4_compound *cp, struct nfs4_fctx *fcp,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	struct nfs4_lowner *lop = fcp->lop;
+
+	nfsm_buildf_xx(mb, bpos, "uuo",
+	    NFSV4OP_CLOSE,
+	    lop->lo_seqid,
+	    NFSX_V4STATEID, fcp->stateid);
+
+	cp->seqidused = cp->req_nops++;
+	cp->fcp = fcp;
+
+	return (0);
+}
+
+int
+nfsm_v4build_access_xx(struct nfs4_compound *cp, struct nfs4_oparg_access *acc,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "uu", NFSV4OP_ACCESS, acc->mode);
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_read_xx(struct nfs4_compound *cp, struct nfs4_oparg_read *r,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "uohu",
+	    NFSV4OP_READ,
+	    NFSX_V4STATEID, r->fcp->stateid,
+	    r->off,
+	    r->maxcnt);
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_write_xx(struct nfs4_compound *cp, struct nfs4_oparg_write *w,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "uohuu",
+	    NFSV4OP_WRITE,
+	    NFSX_V4STATEID, w->fcp->stateid,
+	    w->off,
+	    w->stable,
+	    w->cnt);
+	cp->req_nops++;
+	return (nfsm_uiotombuf(w->uiop, mb, w->cnt, bpos));
+}
+
+int
+nfsm_v4build_commit_xx(struct nfs4_compound *cp, struct nfs4_oparg_commit *c,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "uhu", NFSV4OP_COMMIT, c->start, c->len);
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_readdir_xx(struct nfs4_compound *cp, struct nfs4_oparg_readdir *r,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	int i;
+
+	nfsm_buildf_xx(mb, bpos, "uhouuu",
+	    NFSV4OP_READDIR,
+	    r->cookie,
+	    sizeof(r->verf), r->verf,
+	    r->cnt >> 4,	/* meaningless "dircount" field */
+	    r->cnt,
+	    r->bm->bmlen);
+
+	for (i = 0; i < r->bm->bmlen; i++)
+		nfsm_buildf_xx(mb, bpos, "u", r->bm->bmval[i]);
+
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_renew_xx(struct nfs4_compound *cp, uint64_t cid,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "uh", NFSV4OP_RENEW, cid);
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_create_xx(struct nfs4_compound *cp, struct nfs4_oparg_create *c,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	uint32_t t1;
+
+	nfsm_buildf_xx(mb, bpos, "uu", NFSV4OP_CREATE, c->type);
+
+	if (c->type == NFLNK)
+		/* XXX strlen */
+		nfsm_buildf_xx(mb, bpos, "s", strlen(c->linktext), c->linktext);
+	else if (c->type == NFCHR || c->type == NFBLK)
+		nfsm_buildf_xx(mb, bpos, "uu",
+		    umajor(c->vap->va_rdev), uminor(c->vap->va_rdev));
+
+	/* Name */
+	nfsm_buildf_xx(mb, bpos, "s", c->namelen, c->name);	
+
+	/* Attributes */
+	t1 = nfsm_v4build_attrs_xx(c->vap, mb, bpos);
+	if (t1 != 0)
+		return (t1);
+
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_rename_xx(struct nfs4_compound *cp, struct nfs4_oparg_rename *r,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "uss", NFSV4OP_RENAME, r->fnamelen, r->fname,
+	    r->tnamelen, r->tname);
+
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_link_xx(struct nfs4_compound *cp, struct nfs4_oparg_link *l,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "us", NFSV4OP_LINK, l->namelen, l->name);
+
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_remove_xx(struct nfs4_compound *cp, const char *name, u_int namelen,
+    struct mbuf **mb, caddr_t *bpos)
+{
+	nfsm_buildf_xx(mb, bpos, "us", NFSV4OP_REMOVE, namelen, name);
+
+	cp->req_nops++;
+
+	return (0);
+}
+
+int
+nfsm_v4build_attrs_xx(struct vattr *vap, struct mbuf **mb, caddr_t *bpos)
+{
+	uint32_t *tl, *attrlenp, *bmvalp, siz, len;
+
+	tl = nfsm_build_xx(4 * NFSX_UNSIGNED, mb, bpos);
+
+	*tl++ = txdr_unsigned(2);    /* bitmap length */
+	bmvalp = tl;
+	bzero(bmvalp, 8);
+	tl += 2;
+	attrlenp = tl;
+
+	len = 0;
+	if (vap->va_size != VNOVAL) {
+		tl = nfsm_build_xx(2 * NFSX_UNSIGNED, mb, bpos);
+		FA4_SET(FA4_SIZE, bmvalp);
+		txdr_hyper(vap->va_size, tl); tl += 2;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (vap->va_mode != (u_short)VNOVAL) {
+		tl = nfsm_build_xx(NFSX_UNSIGNED, mb, bpos);
+		FA4_SET(FA4_MODE, bmvalp);
+		*tl++ = txdr_unsigned(vap->va_mode);
+		len += NFSX_UNSIGNED;
+	}
+	if (vap->va_uid != VNOVAL) {
+		int error;
+		char *name;
+		error = idmap_uid_to_name(vap->va_uid, &name, &siz);
+		if (error || name == NULL || siz == 0) {
+		  	/* XXX */
+			siz = sizeof("nobody") - 1;
+			tl = nfsm_build_xx(NFSX_UNSIGNED + nfsm_rndup(siz), mb, 
+			    bpos);
+			*tl++ = txdr_unsigned(siz);
+			bcopy("nobody", tl, siz);
+			len += NFSX_UNSIGNED + nfsm_rndup(siz);
+		} else {
+			tl = nfsm_build_xx(NFSX_UNSIGNED + nfsm_rndup(siz), mb,
+			    bpos);
+			*tl++ = txdr_unsigned(siz);
+			bcopy(name, tl, siz);
+			len += NFSX_UNSIGNED + nfsm_rndup(siz);
+		}
+		FA4_SET(FA4_OWNER, bmvalp);
+	}
+	if (vap->va_gid != VNOVAL) {
+		int error;
+		char *name;
+		error = idmap_gid_to_name(vap->va_gid, &name, &siz);
+		if (error || name == NULL || siz == 0) {
+		  	/* XXX */
+			siz = sizeof("nogroup") - 1;
+			tl = nfsm_build_xx(NFSX_UNSIGNED + nfsm_rndup(siz), mb, 
+			    bpos);
+			*tl++ = txdr_unsigned(siz);
+			bcopy("nogroup", tl, siz);
+			len += NFSX_UNSIGNED + nfsm_rndup(siz);
+		} else {
+			tl = nfsm_build_xx(NFSX_UNSIGNED + nfsm_rndup(siz), mb,
+			    bpos);
+			*tl++ = txdr_unsigned(siz);
+			bcopy(name, tl, siz);
+			len += NFSX_UNSIGNED + nfsm_rndup(siz);
+		}
+		FA4_SET(FA4_OWNER_GROUP, bmvalp);
+	}
+	if (vap->va_atime.tv_sec != VNOVAL) {
+		uint64_t val = vap->va_atime.tv_sec;
+		tl = nfsm_build_xx(4 * NFSX_UNSIGNED, mb, bpos);
+		FA4_SET(FA4_TIME_ACCESS_SET, bmvalp);
+		*tl++ = txdr_unsigned(THCLIENTTIME);
+		txdr_hyper(val, tl); tl += 2;
+		*tl++ = txdr_unsigned(vap->va_atime.tv_nsec);
+		len += 4 * NFSX_UNSIGNED;
+	}
+	if (vap->va_mtime.tv_sec != VNOVAL) {
+		uint64_t val = vap->va_mtime.tv_sec;
+		tl = nfsm_build_xx(4 * NFSX_UNSIGNED, mb, bpos);
+		FA4_SET(FA4_TIME_MODIFY_SET, bmvalp);
+		*tl++ = txdr_unsigned(THCLIENTTIME);
+		txdr_hyper(val, tl); tl += 2;
+		*tl++ = txdr_unsigned(vap->va_mtime.tv_nsec);
+		len += 4 * NFSX_UNSIGNED;
+	}
+
+	bmvalp[0] = txdr_unsigned(bmvalp[0]);
+	bmvalp[1] = txdr_unsigned(bmvalp[1]);
+
+	*attrlenp = txdr_unsigned(len);
+
+	return (0);
+}
+
+int
+nfsm_v4dissect_compound_xx(struct nfs4_compound *cp, struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t taglen, t1, *tl;
+
+	tl = nfsm_dissect_xx(NFSX_UNSIGNED, md, dpos);
+	if (tl == NULL)
+		return (EBADRPC);
+
+	/* Reply status is handled by the RPC code */
+
+	taglen = fxdr_unsigned(uint32_t, *tl++);
+	t1 = nfsm_adv_xx(nfsm_rndup(taglen), md, dpos);
+	if (t1 != 0)
+		return (EBADRPC);
+
+	tl = nfsm_dissect_xx(NFSX_UNSIGNED, md, dpos);
+	if (tl == NULL)
+		return (EBADRPC);
+
+	cp->rep_nops = fxdr_unsigned(uint32_t, *tl++);
+
+	return (0);
+}
+
+int
+nfsm_v4dissect_simple_xx(struct nfs4_compound *cp, uint32_t op,
+    uint32_t skipbytes, struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t t1, dop, status;
+
+	t1 = nfsm_dissectf_xx(md, dpos, "uu", &dop, &status);
+	if (t1 != 0)
+		return (t1);
+
+	if (dop != op || status != 0)
+		return (EBADRPC);
+
+	if (skipbytes > 0)
+		NFSM_ADV(nfsm_rndup(skipbytes));
+
+	return (0);
+}
+
+int
+nfsm_v4dissect_getattr_xx(struct nfs4_compound *cp, struct nfs4_oparg_getattr *ga,
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t *tl;
+
+	tl = nfsm_dissect_xx(2 * NFSX_UNSIGNED, md, dpos);
+	if (tl == NULL || fxdr_unsigned(uint32_t, *tl++) != NFSV4OP_GETATTR ||
+	    *tl++ != 0)
+		return (EBADRPC);
+
+	return (nfsm_v4dissect_attrs_xx(&ga->fa, md, dpos));
+}
+
+int
+nfsm_v4dissect_setattr_xx(struct nfs4_compound *cp, struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t t1, op, bmlen, status;
+
+	t1 = nfsm_dissectf_xx(md, dpos, "uu", &op, &status);
+	if (t1 != 0)
+		return (t1);
+
+	if (op != NFSV4OP_SETATTR || status != 0)
+		return (EBADRPC);
+
+	t1 = nfsm_dissectf_xx(md, dpos, "u", &bmlen);
+	if (t1 != 0)
+		return (t1);
+
+	return (nfsm_dissectf_xx(md, dpos, "k", bmlen << 2));
+}
+
+int
+nfsm_v4dissect_getfh_xx(struct nfs4_compound *cp, struct nfs4_oparg_getfh *gfh,
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t *tl, len, xdrlen;
+
+	tl = nfsm_dissect_xx(2 * NFSX_UNSIGNED, md, dpos);
+	if (tl == NULL || fxdr_unsigned(uint32_t, *tl++) != NFSV4OP_GETFH)
+		return (EBADRPC);
+
+	if (*tl++ != 0)
+		return (EBADRPC);
+
+	NFSM_DISSECT(NFSX_UNSIGNED);
+	len = fxdr_unsigned(uint32_t, *tl++);
+	if (len > NFSX_V4FH)
+		return (EBADRPC);
+
+	/* XXX integrate this into nfs_mtofh()? */
+
+	gfh->fh_len = len;
+	xdrlen = nfsm_rndup(len);
+
+	NFSM_DISSECT(xdrlen);
+	bcopy(tl, &gfh->fh_val, xdrlen);
+
+	return (0);
+}
+
+int
+nfsm_v4dissect_setclientid_xx(struct nfs4_compound *cp,
+    struct nfs4_oparg_setclientid *sci, struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t *tl;
+
+	tl = nfsm_dissect_xx(2 * NFSX_UNSIGNED, md, dpos);
+	if (tl == NULL || fxdr_unsigned(uint32_t, *tl++) != NFSV4OP_SETCLIENTID)
+		return (EBADRPC);
+
+	/* Handle NFS4ERR_CLID_INUSE specially */
+	if (*tl++ != 0)
+		return (EBADRPC);
+
+	NFSM_DISSECT(2 * NFSX_UNSIGNED);
+	sci->clientid = fxdr_hyper(tl);
+
+	NFSM_DISSECT(nfsm_rndup(NFSX_V4VERF));
+	bcopy(tl, sci->verf, NFSX_V4VERF);
+
+	return (0);
+}
+
+int
+nfsm_v4dissect_close_xx(struct nfs4_compound *cp, struct nfs4_fctx *fcp,
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t *tl, t1;
+
+	tl = nfsm_dissect_xx(2 * NFSX_UNSIGNED, md, dpos);
+	if (tl == NULL || fxdr_unsigned(uint32_t, *tl++) != NFSV4OP_CLOSE ||
+	    *tl++ != 0)
+		return (EBADRPC);
+
+	/* Copy stateid */
+	t1 = nfsm_dissectf_xx(md, dpos, "o", NFSX_V4STATEID, fcp->stateid);
+	if (t1 != 0)
+		return (t1);
+
+	return (0);
+}
+
+int
+nfsm_v4dissect_access_xx(struct nfs4_compound *cp, struct nfs4_oparg_access *acc,
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t *tl;
+
+	tl = nfsm_dissect_xx(4 * NFSX_UNSIGNED, md, dpos);
+	if (tl == NULL || fxdr_unsigned(uint32_t, *tl++) != NFSV4OP_ACCESS ||
+	    *tl++ != 0)
+		return (EBADRPC);
+
+	acc->supported = fxdr_unsigned(uint32_t, *tl++);
+	acc->rmode = fxdr_unsigned(uint32_t, *tl++);
+
+	return (0);
+}
+
+int
+nfsm_v4dissect_open_xx(struct nfs4_compound *cp, struct nfs4_oparg_open *op,
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t *tl, t1, bmlen, delegtype = ODNONE;
+	int error = 0;
+	nfsv4changeinfo cinfo;
+	struct nfs4_fctx *fcp = op->fcp;
+
+	tl = nfsm_dissect_xx(2 * NFSX_UNSIGNED, md, dpos);
+	if (tl == NULL || fxdr_unsigned(uint32_t, *tl++) != NFSV4OP_OPEN ||
+	    *tl++ != 0)
+		return (EBADRPC);
+
+	t1 = nfsm_dissectf_xx(md, dpos, "o", NFSX_V4STATEID, fcp->stateid);
+	if (t1 != 0)
+		return (t1);
+
+	error = nfsm_v4dissect_changeinfo_xx(&cinfo, md, dpos);
+	if (error != 0)
+		goto nfsmout;
+
+	NFSM_DISSECT(2 * NFSX_UNSIGNED);
+
+	op->rflags = fxdr_unsigned(uint32_t, *tl++);
+	bmlen = fxdr_unsigned(uint32_t, *tl++);
+	if (bmlen > 2) {
+		error = EBADRPC;
+		goto nfsmout;
+	}
+
+	/* Skip */
+	NFSM_ADV(nfsm_rndup(bmlen << 2));
+
+	NFSM_DISSECT(NFSX_UNSIGNED);
+	delegtype = fxdr_unsigned(uint32_t, *tl++);
+	switch (delegtype) {
+	case ODREAD:
+	case ODWRITE:
+		printf("nfs4: client delegation not yet supported\n");
+		error = EOPNOTSUPP;
+		goto nfsmout;
+		break;
+	case ODNONE:
+	default:
+		break;
+	}
+
+ nfsmout:
+	return (error);
+}
+
+int
+nfsm_v4dissect_open_confirm_xx(struct nfs4_compound *cp, struct nfs4_oparg_open *op,
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t *tl;
+
+	tl = nfsm_dissect_xx(2 * NFSX_UNSIGNED, md, dpos);
+	if (tl == NULL || fxdr_unsigned(uint32_t, *tl++) != NFSV4OP_OPEN_CONFIRM ||
+	    *tl++ != 0)
+		return (EBADRPC);
+
+	return nfsm_dissectf_xx(md, dpos, "o", NFSX_V4STATEID, op->fcp->stateid);
+}
+
+int
+nfsm_v4dissect_read_xx(struct nfs4_compound *cp, struct nfs4_oparg_read *r,
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t op, status, t1;
+
+	t1 = nfsm_dissectf_xx(md, dpos, "uu", &op, &status);
+	if (t1 != 0)
+		return (t1);
+
+	if (op != NFSV4OP_READ || status != 0)
+		return (EBADRPC);
+
+	t1 = nfsm_dissectf_xx(md, dpos, "uu", &r->eof, &r->retlen);
+	if (t1 != 0)
+		return (t1);
+
+	return (nfsm_mbuftouio(md, r->uiop, r->retlen, dpos));
+}
+
+int
+nfsm_v4dissect_write_xx(struct nfs4_compound *cp, struct nfs4_oparg_write *w,
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t op, status, t1;
+
+	t1 = nfsm_dissectf_xx(md, dpos, "uu", &op, &status);
+	if (t1 != 0)
+		return (t1);
+
+	if (op != NFSV4OP_WRITE || status != 0)
+		return (EBADRPC);
+
+	return (nfsm_dissectf_xx(md, dpos, "uuo", &w->retlen, &w->committed,
+		    NFSX_V4VERF, w->wverf));
+}
+
+int
+nfsm_v4dissect_commit_xx(struct nfs4_compound *cp, struct nfs4_oparg_commit *c,
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t t1, op, status;
+
+	t1 = nfsm_dissectf_xx(md, dpos, "uu", &op, &status);
+	if (t1 != 0)
+		return (t1);
+
+	if (op != NFSV4OP_COMMIT || status != 0)
+		return (EBADRPC);
+
+	return (nfsm_dissectf_xx(md, dpos, "o", NFSX_V4VERF, c->verf));
+}
+
+int
+nfsm_v4dissect_create_xx(struct nfs4_compound *cp, struct nfs4_oparg_create *c,
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t t1, *tl, op, status, bmlen;
+	nfsv4changeinfo ci;
+
+	t1 = nfsm_dissectf_xx(md, dpos, "uu", &op, &status);
+	if (t1 != 0)
+		return (t1);
+
+	if (op != NFSV4OP_CREATE || status != 0)
+		return (EBADRPC);
+
+	/* Just throw this away for now */
+	t1 = nfsm_v4dissect_changeinfo_xx(&ci, md, dpos);
+	if (t1 != 0)
+		return (t1);
+
+	/* Throw this away too */
+	NFSM_DISSECT(NFSX_UNSIGNED);
+	bmlen = fxdr_unsigned(uint32_t, *tl++);
+	NFSM_DISSECT(bmlen * NFSX_UNSIGNED);
+	tl += bmlen;
+
+	return 0;
+}
+
+int
+nfsm_v4dissect_readlink_xx(struct nfs4_compound *cp, struct uio *uiop, 
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t t1, *tl, op, status, linklen;
+
+	t1 = nfsm_dissectf_xx(md, dpos, "uu", &op, &status);
+	if (t1 != 0)
+		return (t1);
+
+	if (op != NFSV4OP_READLINK || status != 0)
+		return (EBADRPC);
+
+	/* Do this one manually for careful checking of sizes. */
+	NFSM_DISSECT(NFSX_UNSIGNED);
+	linklen = fxdr_unsigned(uint32_t, *tl++);
+	if (linklen <= 0)
+		return (EBADRPC);
+
+	return (nfsm_mbuftouio(md, uiop, MIN(linklen, uiop->uio_resid), dpos));
+}
+
+int
+nfsm_v4dissect_changeinfo_xx(nfsv4changeinfo *ci,
+    struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t *tl;
+
+	NFSM_DISSECT(5 * NFSX_UNSIGNED);
+
+	ci->ciatomic = fxdr_unsigned(uint32_t, *tl++);
+	ci->cibefore = fxdr_hyper(tl); tl += 2;
+	ci->ciafter = fxdr_hyper(tl); tl += 2;
+
+	return (0);
+}
+
+int
+nfsm_v4dissect_attrs_xx(struct nfsv4_fattr *fa, struct mbuf **md, caddr_t *dpos)
+{
+	uint32_t t1, *tl, bmlen, bmval[2], attrlen, len = 0;
+
+	/* Bitmap length + value */
+	NFSM_DISSECT(NFSX_UNSIGNED);
+
+	bmlen = fxdr_unsigned(uint32_t, *tl++);
+	if (bmlen > 2)
+		return (EBADRPC);
+
+	if (bmlen == 0)
+		return (0);
+
+	NFSM_DISSECT(nfsm_rndup(bmlen << 2) + NFSX_UNSIGNED);
+
+	bmval[0] = bmlen > 0 ? fxdr_unsigned(uint32_t, *tl++) : 0;
+	bmval[1] = bmlen > 1 ? fxdr_unsigned(uint32_t, *tl++) : 0;
+
+	/* Attribute length */
+	attrlen = fxdr_unsigned(uint32_t, *tl++);
+
+	/*
+	 * XXX check for correct (<=) attributes mask return from
+	 * server.  need to pass this in.
+	 */
+
+	if (FA4_ISSET(FA4_TYPE, bmval)) {
+		/* overflow check */
+		NFSM_DISSECT(NFSX_UNSIGNED);
+		fa->fa4_type = fxdr_unsigned(uint32_t, *tl++);
+		fa->fa4_valid |= FA4V_TYPE;
+		len += NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_CHANGE, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_changeid = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_CHANGEID;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_SIZE, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_size = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_SIZE;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_FSID, bmval)) {
+		NFSM_DISSECT(4 * NFSX_UNSIGNED);
+		fa->fa4_fsid_major = fxdr_hyper(tl); tl += 2;
+		fa->fa4_fsid_minor = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_SIZE;
+		len += 4 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_LEASE_TIME, bmval)) {
+		NFSM_DISSECT(NFSX_UNSIGNED);
+		fa->fa4_lease_time = fxdr_unsigned(uint32_t, *tl++);
+		fa->fa4_valid |= FA4V_LEASE_TIME;
+		len += NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_FILEID, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_fileid = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_FILEID;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_FILES_FREE, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_ffree = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_FFREE;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_FILES_TOTAL, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_ftotal = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_FTOTAL;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_MAXFILESIZE, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_maxfilesize = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_MAXFILESIZE;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_MAXNAME, bmval)) {
+		NFSM_DISSECT(NFSX_UNSIGNED);
+		fa->fa4_maxname = fxdr_unsigned(uint32_t, *tl++);
+		fa->fa4_valid |= FA4V_MAXNAME;
+		len += NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_MAXREAD, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_maxread = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_MAXREAD;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_MAXWRITE, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_maxwrite = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_MAXWRITE;
+		len += 2 * NFSX_UNSIGNED;
+	}
+
+	if (FA4_ISSET(FA4_MODE, bmval)) {
+		NFSM_DISSECT(NFSX_UNSIGNED);
+		fa->fa4_mode = fxdr_unsigned(mode_t, *tl++);
+		fa->fa4_valid |= FA4V_MODE;
+		len += NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_NUMLINKS, bmval)) {
+		NFSM_DISSECT(NFSX_UNSIGNED);
+		fa->fa4_nlink = fxdr_unsigned(nlink_t, *tl++);
+		fa->fa4_valid |= FA4V_NLINK;
+		len += NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_OWNER, bmval)) {
+		uint32_t ownerlen;
+		int error;
+
+		NFSM_DISSECT(NFSX_UNSIGNED);
+
+		ownerlen = fxdr_unsigned(uint32_t, *tl++);
+		NFSM_DISSECT(nfsm_rndup(ownerlen));
+		error = idmap_name_to_uid((char *)tl, ownerlen, &fa->fa4_uid);
+		if (error) 
+			fa->fa4_uid = -2;
+		fa->fa4_valid |= FA4V_UID;
+		len += NFSX_UNSIGNED + nfsm_rndup(ownerlen);
+	}
+	if (FA4_ISSET(FA4_OWNER_GROUP, bmval)) {
+		uint32_t ownergrouplen;
+		int error;
+
+		NFSM_DISSECT(NFSX_UNSIGNED);
+		ownergrouplen = fxdr_unsigned(uint32_t, *tl++);
+		NFSM_DISSECT(nfsm_rndup(ownergrouplen));
+		error = idmap_name_to_gid((char *)tl, ownergrouplen, &fa->fa4_gid);
+		if (error) 
+			fa->fa4_gid = -2;
+		fa->fa4_valid |= FA4V_GID;
+		len += NFSX_UNSIGNED + nfsm_rndup(ownergrouplen);
+	}
+	if (FA4_ISSET(FA4_RAWDEV, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_rdev_major = fxdr_unsigned(uint32_t, *tl++);
+		fa->fa4_rdev_minor = fxdr_unsigned(uint32_t, *tl++);
+		fa->fa4_valid |= FA4V_RDEV;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_SPACE_AVAIL, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_savail = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_SAVAIL;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_SPACE_FREE, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_sfree = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_SFREE;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_SPACE_TOTAL, bmval)) {
+		NFSM_DISSECT(2 * NFSX_UNSIGNED);
+		fa->fa4_stotal = fxdr_hyper(tl);
+		fa->fa4_valid |= FA4V_STOTAL;
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_SPACE_USED, bmval)) {
+		NFSM_ADV(2 * NFSX_UNSIGNED);
+		len += 2 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_TIME_ACCESS, bmval)) {
+		NFSM_MTOTIME(fa->fa4_atime);
+		fa->fa4_valid |= FA4V_ATIME;
+		len += 3 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_TIME_CREATE, bmval)) {
+		NFSM_MTOTIME(fa->fa4_ctime);
+		fa->fa4_valid |= FA4V_CTIME;
+		len += 3 * NFSX_UNSIGNED;
+	}
+	if (FA4_ISSET(FA4_TIME_MODIFY, bmval)) {
+		NFSM_MTOTIME(fa->fa4_mtime);
+		fa->fa4_valid |= FA4V_MTIME;
+		len += 3 * NFSX_UNSIGNED;
+	}
+
+	if (len != attrlen)
+		return (EBADRPC);
+
+	return (0);
+}
diff --git a/sys/nfs4client/nfs4_vfs.h b/sys/nfs4client/nfs4_vfs.h
new file mode 100644
index 0000000..18772be3
--- /dev/null
+++ b/sys/nfs4client/nfs4_vfs.h
@@ -0,0 +1,34 @@
+/* $FreeBSD$ */
+/* $Id: nfs4_vfs.h,v 1.4 2003/11/05 14:59:00 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+#ifndef _NFS4CLIENT_NFS4_VFS_H
+#define _NFS4CLIENT_NFS4_VFS_H
+
+void nfs4_vfsop_fsinfo(struct nfsv4_fattr *, struct nfsmount *);
+void nfs4_vfsop_statfs(struct nfsv4_fattr *, struct statfs *, struct mount *);
+
+#endif /* _NFS4CLIENT_NFS4_VFS_H */
diff --git a/sys/nfs4client/nfs4_vfs_subs.c b/sys/nfs4client/nfs4_vfs_subs.c
new file mode 100644
index 0000000..ecd8b1d
--- /dev/null
+++ b/sys/nfs4client/nfs4_vfs_subs.c
@@ -0,0 +1,150 @@
+/* $FreeBSD$ */
+/* $Id: nfs4_vfs_subs.c,v 1.5 2003/11/05 14:59:00 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/limits.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/module.h>
+#include <sys/mount.h>
+#include <sys/proc.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/sockio.h>
+#include <sys/vnode.h>
+
+#include <vm/vm.h>
+#include <vm/vm_extern.h>
+#include <vm/uma.h>
+
+#include <net/if.h>
+#include <net/route.h>
+#include <netinet/in.h>
+
+#include <rpc/rpcclnt.h>
+
+#include <nfs/rpcv2.h>
+#include <nfs/nfsproto.h>
+#include <nfsclient/nfs.h>
+#include <nfsclient/nfsmount.h>
+#include <nfs/xdr_subs.h>
+#include <nfsclient/nfsm_subs.h>
+#include <nfsclient/nfsdiskless.h>
+
+/* NFSv4 */
+#include <nfs4client/nfs4.h>
+#include <nfs4client/nfs4m_subs.h>
+#include <nfs4client/nfs4_vfs.h>
+
+#include <nfsclient/nfsnode.h>
+
+static int	nfs_iosize(struct nfsmount *nmp);
+
+static int
+nfs_iosize(struct nfsmount *nmp)
+{
+	int iosize;
+
+	/*
+	 * Calculate the size used for io buffers.  Use the larger
+	 * of the two sizes to minimise nfs 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;
+}
+
+void
+nfs4_vfsop_fsinfo(struct nfsv4_fattr *fap, struct nfsmount *nmp)
+{
+	uint32_t max;
+
+	if (fap->fa4_valid & FA4V_FSID) {
+		nmp->nm_fsid.val[0] = fap->fa4_fsid_major;
+		nmp->nm_fsid.val[1] = fap->fa4_fsid_minor;
+	}
+	if (fap->fa4_valid & FA4V_MAXREAD) {
+                max = fap->fa4_maxread;
+                if (max < nmp->nm_rsize) {
+                        nmp->nm_rsize = max & ~(NFS_FABLKSIZE - 1);
+                        if (nmp->nm_rsize == 0)
+                                nmp->nm_rsize = max;
+                }
+                if (max < nmp->nm_readdirsize) {
+                        nmp->nm_readdirsize = max & ~(NFS_DIRBLKSIZ - 1);
+                        if (nmp->nm_readdirsize == 0)
+                                nmp->nm_readdirsize = max;
+                }
+	}
+	if (fap->fa4_valid & FA4V_MAXWRITE) {
+                max = fap->fa4_maxwrite;
+                if (max < nmp->nm_wsize) {
+                        nmp->nm_wsize = max & ~(NFS_FABLKSIZE - 1);
+                        if (nmp->nm_wsize == 0)
+                                nmp->nm_wsize = max;
+                }
+	}
+	if (fap->fa4_valid & FA4V_LEASE_TIME)
+		nmp->nm_lease_time = fap->fa4_lease_time;
+
+	/* nmp->nm_flag |= NFSMNT_GOTFSINFO; */
+}
+
+void
+nfs4_vfsop_statfs(struct nfsv4_fattr *fap, struct statfs *sbp, struct mount *mp)
+{
+	struct nfsmount *nmp = VFSTONFS(mp);
+
+	sbp->f_flags = nmp->nm_flag;
+	sbp->f_iosize = nfs_iosize(nmp);
+	sbp->f_bsize = NFS_FABLKSIZE;
+
+	if (fap->fa4_valid & FA4V_FSID) {
+		sbp->f_fsid.val[0] = fap->fa4_fsid_major;
+		sbp->f_fsid.val[1] = fap->fa4_fsid_minor;
+	}
+
+	sbp->f_ffree = fap->fa4_valid & FA4V_FFREE ? fap->fa4_ffree : 0;
+	/* sbp->f_ftotal = fa->fa4_valid & FA4_FTOTAL ? fa->fa4_ftotal : 0; */
+	sbp->f_bavail = fap->fa4_valid & FA4V_SAVAIL ?
+	    fap->fa4_savail / NFS_FABLKSIZE : 500000;
+	sbp->f_bfree = fap->fa4_valid & FA4V_SFREE ?
+	    fap->fa4_sfree / NFS_FABLKSIZE : 500000;
+	sbp->f_blocks = fap->fa4_valid & FA4V_STOTAL ?
+	    fap->fa4_stotal / NFS_FABLKSIZE : 1000000;
+
+	if (sbp != &mp->mnt_stat) {
+		sbp->f_type = mp->mnt_vfc->vfc_typenum;
+		bcopy(mp->mnt_stat.f_mntonname, sbp->f_mntonname, MNAMELEN);
+		bcopy(mp->mnt_stat.f_mntfromname, sbp->f_mntfromname, MNAMELEN);
+	}
+}
diff --git a/sys/nfs4client/nfs4_vfsops.c b/sys/nfs4client/nfs4_vfsops.c
new file mode 100644
index 0000000..fe168f8
--- /dev/null
+++ b/sys/nfs4client/nfs4_vfsops.c
@@ -0,0 +1,938 @@
+/* $FreeBSD$ */
+/* $Id: nfs_vfsops.c,v 1.38 2003/11/05 14:59:01 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+/*
+ * 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_vfsops.c	8.12 (Berkeley) 5/20/95
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include "opt_bootp.h"
+#include "opt_nfsroot.h"
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/kthread.h>
+#include <sys/limits.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/module.h>
+#include <sys/mount.h>
+#include <sys/proc.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/sockio.h>
+#include <sys/sysctl.h>
+#include <sys/unistd.h>
+#include <sys/vnode.h>
+
+#include <vm/vm.h>
+#include <vm/vm_extern.h>
+#include <vm/uma.h>
+
+#include <net/if.h>
+#include <net/route.h>
+#include <netinet/in.h>
+#include <netinet/in_var.h>
+
+#include <rpc/rpcclnt.h>
+
+#include <nfs/rpcv2.h>
+#include <nfs/nfsproto.h>
+#include <nfsclient/nfs.h>
+#include <nfs4client/nfs4.h>
+#include <nfsclient/nfsnode.h>
+#include <nfsclient/nfsmount.h>
+#include <nfs/xdr_subs.h>
+#include <nfsclient/nfsm_subs.h>
+#include <nfsclient/nfsdiskless.h>
+
+#include <nfs4client/nfs4m_subs.h>
+#include <nfs4client/nfs4_vfs.h>
+
+#include <nfs4client/nfs4_dev.h>
+#include <nfs4client/nfs4_idmap.h>
+
+SYSCTL_NODE(_vfs, OID_AUTO, nfs4, CTLFLAG_RW, 0, "NFS4 filesystem");
+SYSCTL_STRUCT(_vfs_nfs4, NFS_NFSSTATS, nfsstats, CTLFLAG_RD,
+	&nfsstats, nfsstats, "S,nfsstats");
+#ifdef NFS_DEBUG
+int nfs_debug;
+SYSCTL_INT(_vfs_nfs4, OID_AUTO, debug, CTLFLAG_RW, &nfs_debug, 0, "");
+#endif
+
+static void	nfs_decode_args(struct nfsmount *nmp, struct nfs_args *argp);
+static void	nfs4_daemon(void *arg);
+static int	mountnfs(struct nfs_args *, struct mount *,
+		    struct sockaddr *, char *, char *, struct vnode **,
+		    struct ucred *cred);
+static int	nfs4_do_setclientid(struct nfsmount *nmp, struct ucred *cred);
+static vfs_mount_t nfs_mount;
+static vfs_unmount_t nfs_unmount;
+static vfs_root_t nfs_root;
+static vfs_statfs_t nfs_statfs;
+static vfs_sync_t nfs_sync;
+
+/*
+ * nfs vfs operations.
+ */
+static struct vfsops nfs_vfsops = {
+	.vfs_init =		nfs4_init,
+	.vfs_mount =		nfs_mount,
+	.vfs_root =		nfs_root,
+	.vfs_statfs =		nfs_statfs,
+	.vfs_sync =		nfs_sync,
+	.vfs_uninit =		nfs4_uninit,
+	.vfs_unmount =		nfs_unmount,
+};
+VFS_SET(nfs_vfsops, nfs4, VFCF_NETWORK);
+
+/* So that loader and kldload(2) can find us, wherever we are.. */
+MODULE_VERSION(nfs4, 1);
+
+void		nfsargs_ntoh(struct nfs_args *);
+
+#ifdef NFS4DISKLESS
+/*
+ * This structure must be filled in by a primary bootstrap or bootstrap
+ * server for a diskless/dataless machine. It is initialized below just
+ * to ensure that it is allocated to initialized data (.data not .bss).
+ */
+struct nfs_diskless nfs_diskless = { { { 0 } } };
+struct nfsv3_diskless nfsv3_diskless = { { { 0 } } };
+int nfs_diskless_valid = 0;
+
+SYSCTL_INT(_vfs_nfs4, OID_AUTO, diskless_valid, CTLFLAG_RD,
+	&nfs_diskless_valid, 0, "");
+
+SYSCTL_STRING(_vfs_nfs4, OID_AUTO, diskless_rootpath, CTLFLAG_RD,
+	nfsv3_diskless.root_hostnam, 0, "");
+
+SYSCTL_OPAQUE(_vfs_nfs4, OID_AUTO, diskless_rootaddr, CTLFLAG_RD,
+	&nfsv3_diskless.root_saddr, sizeof nfsv3_diskless.root_saddr,
+	"%Ssockaddr_in", "");
+
+SYSCTL_STRING(_vfs_nfs4, OID_AUTO, diskless_swappath, CTLFLAG_RD,
+	nfsv3_diskless.swap_hostnam, 0, "");
+
+SYSCTL_OPAQUE(_vfs_nfs4, OID_AUTO, diskless_swapaddr, CTLFLAG_RD,
+	&nfsv3_diskless.swap_saddr, sizeof nfsv3_diskless.swap_saddr,
+	"%Ssockaddr_in","");
+
+static int	nfs_mountdiskless(char *, char *, int,
+		    struct sockaddr_in *, struct nfs_args *,
+		    struct thread *, struct vnode **, struct mount **);
+static void	nfs_convert_diskless(void);
+static void	nfs_convert_oargs(struct nfs_args *args,
+		    struct onfs_args *oargs);
+
+static void
+nfs_convert_oargs(struct nfs_args *args, struct onfs_args *oargs)
+{
+
+	args->version = NFS_ARGSVERSION;
+	args->addr = oargs->addr;
+	args->addrlen = oargs->addrlen;
+	args->sotype = oargs->sotype;
+	args->proto = oargs->proto;
+	args->fh = oargs->fh;
+	args->fhsize = oargs->fhsize;
+	args->flags = oargs->flags;
+	args->wsize = oargs->wsize;
+	args->rsize = oargs->rsize;
+	args->readdirsize = oargs->readdirsize;
+	args->timeo = oargs->timeo;
+	args->retrans = oargs->retrans;
+	args->maxgrouplist = oargs->maxgrouplist;
+	args->readahead = oargs->readahead;
+	args->deadthresh = oargs->deadthresh;
+	args->hostname = oargs->hostname;
+}
+
+static void
+nfs_convert_diskless(void)
+{
+
+	bcopy(&nfs_diskless.myif, &nfsv3_diskless.myif,
+		sizeof(struct ifaliasreq));
+	bcopy(&nfs_diskless.mygateway, &nfsv3_diskless.mygateway,
+		sizeof(struct sockaddr_in));
+	nfs_convert_oargs(&nfsv3_diskless.root_args,&nfs_diskless.root_args);
+	nfsv3_diskless.root_fhsize = NFSX_V2FH;
+	bcopy(nfs_diskless.root_fh, nfsv3_diskless.root_fh, NFSX_V2FH);
+	bcopy(&nfs_diskless.root_saddr,&nfsv3_diskless.root_saddr,
+		sizeof(struct sockaddr_in));
+	bcopy(nfs_diskless.root_hostnam, nfsv3_diskless.root_hostnam, MNAMELEN);
+	nfsv3_diskless.root_time = nfs_diskless.root_time;
+	bcopy(nfs_diskless.my_hostnam, nfsv3_diskless.my_hostnam,
+		MAXHOSTNAMELEN);
+	nfs_diskless_valid = 3;
+}
+#endif
+
+int
+nfs4_init(struct vfsconf *vfsp)
+{
+
+	rpcclnt_init();
+	nfs4dev_init();
+	idmap_init();
+	nfsm_v4init();
+
+	return (0);
+}
+
+int
+nfs4_uninit(struct vfsconf *vfsp)
+{
+
+	rpcclnt_uninit();
+	nfs4dev_uninit();
+	idmap_uninit();
+
+	return (0);
+}
+
+/*
+ * nfs statfs call
+ */
+static int
+nfs_statfs(struct mount *mp, struct statfs *sbp, struct thread *td)
+{
+	struct vnode *vp;
+	struct nfs_statfs *sfp;
+	caddr_t bpos, dpos;
+	struct nfsmount *nmp = VFSTONFS(mp);
+	int error = 0;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfsnode *np;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_getattr ga;
+	struct nfsv4_fattr *fap = &ga.fa;
+
+#ifndef nolint
+	sfp = NULL;
+#endif
+	error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np);
+	if (error)
+		return (error);
+	vp = NFSTOV(np);
+	nfsstats.rpccnt[NFSPROC_FSSTAT]++;
+	mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, NFSX_FH(1));
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	ga.bm = &nfsv4_fsattrbm;
+	nfs_v4initcompound(&cp);
+
+	nfsm_v4build_compound(&cp, "statfs()");
+	nfsm_v4build_putfh(&cp, vp);
+	nfsm_v4build_getattr(&cp, &ga);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(vp, NFSV4PROC_COMPOUND, td, td->td_ucred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_getattr(&cp, &ga);
+
+	nfs4_vfsop_statfs(fap, sbp, mp);
+
+nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	vput(vp);
+	if (mrep != NULL)
+		m_freem(mrep);
+
+	return (error);
+}
+
+static void
+nfs_decode_args(struct nfsmount *nmp, struct nfs_args *argp)
+{
+	int s;
+	int adjsock;
+	int maxio;
+
+	s = splnet();
+	/*
+	 * Silently clear NFSMNT_NOCONN if it's a TCP mount, it makes
+	 * no sense in that context.
+	 */
+	if (argp->sotype == SOCK_STREAM)
+		nmp->nm_flag &= ~NFSMNT_NOCONN;
+
+	nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
+
+	/* Re-bind if rsrvd port requested and wasn't on one */
+	adjsock = !(nmp->nm_flag & NFSMNT_RESVPORT)
+		  && (argp->flags & NFSMNT_RESVPORT);
+	/* Also re-bind if we're switching to/from a connected UDP socket */
+	adjsock |= ((nmp->nm_flag & NFSMNT_NOCONN) !=
+		    (argp->flags & NFSMNT_NOCONN));
+
+	/* Update flags atomically.  Don't change the lock bits. */
+	nmp->nm_flag = argp->flags | nmp->nm_flag;
+	splx(s);
+
+	if ((argp->flags & NFSMNT_TIMEO) && argp->timeo > 0) {
+		nmp->nm_timeo = (argp->timeo * NFS_HZ + 5) / 10;
+		if (nmp->nm_timeo < NFS_MINTIMEO)
+			nmp->nm_timeo = NFS_MINTIMEO;
+		else if (nmp->nm_timeo > NFS_MAXTIMEO)
+			nmp->nm_timeo = NFS_MAXTIMEO;
+	}
+
+	if ((argp->flags & NFSMNT_RETRANS) && argp->retrans > 1) {
+		nmp->nm_retry = argp->retrans;
+		if (nmp->nm_retry > NFS_MAXREXMIT)
+			nmp->nm_retry = NFS_MAXREXMIT;
+	}
+
+	if (argp->flags & NFSMNT_NFSV3) {
+		if (argp->sotype == SOCK_DGRAM)
+			maxio = NFS_MAXDGRAMDATA;
+		else
+			maxio = NFS_MAXDATA;
+	} else
+		maxio = NFS_V2MAXDATA;
+
+	if ((argp->flags & NFSMNT_WSIZE) && argp->wsize > 0) {
+		nmp->nm_wsize = argp->wsize;
+		/* Round down to multiple of blocksize */
+		nmp->nm_wsize &= ~(NFS_FABLKSIZE - 1);
+		if (nmp->nm_wsize <= 0)
+			nmp->nm_wsize = NFS_FABLKSIZE;
+	}
+	if (nmp->nm_wsize > maxio)
+		nmp->nm_wsize = maxio;
+	if (nmp->nm_wsize > MAXBSIZE)
+		nmp->nm_wsize = MAXBSIZE;
+
+	if ((argp->flags & NFSMNT_RSIZE) && argp->rsize > 0) {
+		nmp->nm_rsize = argp->rsize;
+		/* Round down to multiple of blocksize */
+		nmp->nm_rsize &= ~(NFS_FABLKSIZE - 1);
+		if (nmp->nm_rsize <= 0)
+			nmp->nm_rsize = NFS_FABLKSIZE;
+	}
+	if (nmp->nm_rsize > maxio)
+		nmp->nm_rsize = maxio;
+	if (nmp->nm_rsize > MAXBSIZE)
+		nmp->nm_rsize = MAXBSIZE;
+
+	if ((argp->flags & NFSMNT_READDIRSIZE) && 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->flags & NFSMNT_ACREGMIN) && argp->acregmin >= 0)
+		nmp->nm_acregmin = argp->acregmin;
+	else
+		nmp->nm_acregmin = NFS_MINATTRTIMO;
+	if ((argp->flags & NFSMNT_ACREGMAX) && argp->acregmax >= 0)
+		nmp->nm_acregmax = argp->acregmax;
+	else
+		nmp->nm_acregmax = NFS_MAXATTRTIMO;
+	if ((argp->flags & NFSMNT_ACDIRMIN) && argp->acdirmin >= 0)
+		nmp->nm_acdirmin = argp->acdirmin;
+	else
+		nmp->nm_acdirmin = NFS_MINDIRATTRTIMO;
+	if ((argp->flags & NFSMNT_ACDIRMAX) && argp->acdirmax >= 0)
+		nmp->nm_acdirmax = argp->acdirmax;
+	else
+		nmp->nm_acdirmax = NFS_MAXDIRATTRTIMO;
+	if (nmp->nm_acdirmin > nmp->nm_acdirmax)
+		nmp->nm_acdirmin = nmp->nm_acdirmax;
+	if (nmp->nm_acregmin > nmp->nm_acregmax)
+		nmp->nm_acregmin = nmp->nm_acregmax;
+
+	if ((argp->flags & NFSMNT_MAXGRPS) && argp->maxgrouplist >= 0) {
+		if (argp->maxgrouplist <= NFS_MAXGRPS)
+			nmp->nm_numgrps = argp->maxgrouplist;
+		else
+			nmp->nm_numgrps = NFS_MAXGRPS;
+	}
+	if ((argp->flags & NFSMNT_READAHEAD) && argp->readahead >= 0) {
+		if (argp->readahead <= NFS_MAXRAHEAD)
+			nmp->nm_readahead = argp->readahead;
+		else
+			nmp->nm_readahead = NFS_MAXRAHEAD;
+	}
+	if ((argp->flags & NFSMNT_DEADTHRESH) && argp->deadthresh >= 0) {
+		if (argp->deadthresh <= NFS_MAXDEADTHRESH)
+			nmp->nm_deadthresh = argp->deadthresh;
+		else
+			nmp->nm_deadthresh = NFS_MAXDEADTHRESH;
+	}
+
+	adjsock |= ((nmp->nm_sotype != argp->sotype) ||
+		    (nmp->nm_soproto != argp->proto));
+	nmp->nm_sotype = argp->sotype;
+	nmp->nm_soproto = argp->proto;
+
+	if (nmp->nm_rpcclnt.rc_so && adjsock) {
+		nfs_safedisconnect(nmp);
+		if (nmp->nm_sotype == SOCK_DGRAM) {
+			while (nfs4_connect(nmp)) {
+				printf("nfs_args: retrying connect\n");
+				(void) tsleep((caddr_t)&lbolt,
+					      PSOCK, "nfscon", 0);
+			}
+		}
+	}
+}
+
+/*
+ * VFS Operations.
+ *
+ * mount system call
+ * It seems a bit dumb to copyinstr() the host and path here and then
+ * bcopy() them in mountnfs(), 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
+nfs_mount(struct mount *mp, char *path, caddr_t data, struct nameidata *ndp,
+    struct thread *td)
+{
+	int error;
+	struct nfs_args args;
+	struct sockaddr *nam;
+	struct vnode *vp;
+	char hst[MNAMELEN];
+	size_t len;
+
+	if (path == NULL) {
+		printf("NFSv4: nfs_mountroot not supported\n");
+		return EINVAL;
+	}
+	error = copyin(data, (caddr_t)&args, sizeof (struct nfs_args));
+	if (error)
+		return (error);
+	if (args.version != NFS_ARGSVERSION)
+		return (EPROGMISMATCH);
+	if (mp->mnt_flag & MNT_UPDATE) {
+		struct nfsmount *nmp = VFSTONFS(mp);
+
+		if (nmp == NULL)
+			return (EIO);
+		/*
+		 * When doing an update, we can't change from or to
+		 * v3, switch lockd strategies or change cookie translation
+		 */
+		args.flags = (args.flags &
+		    ~(NFSMNT_NFSV3 | NFSMNT_NFSV4 | NFSMNT_NOLOCKD)) |
+		    (nmp->nm_flag &
+			(NFSMNT_NFSV3 | NFSMNT_NFSV4 | NFSMNT_NOLOCKD));
+		nfs_decode_args(nmp, &args);
+		return (0);
+	}
+
+	if (error)
+		return (error);
+	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 = mountnfs(&args, mp, nam, path, hst, &vp, td->td_ucred);
+	return (error);
+}
+
+/*
+ * renew should be done async
+ * should re-scan mount queue each time
+ */
+struct proc *nfs4_daemonproc;
+
+static int
+nfs4_do_renew(struct nfsmount *nmp, struct ucred *cred)
+{
+	struct nfs4_compound cp;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	caddr_t bpos, dpos;	
+	int error;
+
+	mreq = nfsm_reqhead(NULL, NFSV4PROC_COMPOUND, sizeof(uint64_t));
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	nfs_v4initcompound(&cp);
+
+	nfsm_v4build_compound(&cp, "nfs4_do_renew()");
+	nfsm_v4build_renew(&cp, nmp->nm_clientid);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request_mnt(nmp, NFSV4PROC_COMPOUND, curthread, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_renew(&cp);
+	nmp->nm_last_renewal = time_second;
+	return (0);
+
+ nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	/* XXX */
+	if (mrep != NULL)
+		m_freem(mrep);
+	return (error);
+}
+
+static void
+nfs4_daemon(void *arg)
+{
+	struct mount *mp;
+	struct nfsmount *nmp;
+	int nmounts;
+
+	while (1) {
+		nmounts = 0;
+		mtx_lock(&mountlist_mtx);
+		TAILQ_FOREACH(mp, &mountlist, mnt_list) {
+			if (strcmp(mp->mnt_vfc->vfc_name, "nfs4") != 0)
+				continue;
+			nmounts++;
+			nmp = VFSTONFS(mp);
+			if (time_second < nmp->nm_last_renewal + nmp->nm_lease_time - 4)
+				continue;
+			mtx_unlock(&mountlist_mtx);
+			mtx_lock(&Giant);
+			nfs4_do_renew(nmp, (struct ucred *) arg);
+			mtx_unlock(&Giant);
+			mtx_lock(&mountlist_mtx);
+		}
+		mtx_unlock(&mountlist_mtx);
+
+		/* Must kill the daemon here, or module unload will cause a panic */
+		if (nmounts == 0) {
+			mtx_lock(&Giant);
+			nfs4_daemonproc = NULL;
+			printf("nfsv4 renewd exiting\n");
+			kthread_exit(0);
+		}
+		tsleep(&nfs4_daemonproc, PVFS, "nfs4", 2 * hz);
+	}
+}
+
+/*
+ * Common code for mount and mountroot
+ */
+static int
+mountnfs(struct nfs_args *argp, struct mount *mp, struct sockaddr *nam,
+    char *pth, char *hst, struct vnode **vpp, struct ucred *cred)
+{
+	struct nfsmount *nmp;
+	char *rpth, *cp1, *cp2;
+	int nlkup = 0, error;
+	struct nfs4_compound cp;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	caddr_t bpos, dpos;	
+	struct nfs4_oparg_lookup lkup;
+	struct nfs4_oparg_getfh gfh;
+	struct nfs4_oparg_getattr ga;
+	struct thread *td = curthread; /* XXX */
+
+	if (mp->mnt_flag & MNT_UPDATE) {
+		nmp = VFSTONFS(mp);
+		/* update paths, file handles, etc, here	XXX */
+		FREE(nam, M_SONAME);
+		return (0);
+	} else {
+		nmp = uma_zalloc(nfsmount_zone, M_WAITOK);
+		bzero((caddr_t)nmp, sizeof (struct nfsmount));
+		TAILQ_INIT(&nmp->nm_bufq);
+		mp->mnt_data = (qaddr_t)nmp;
+	}
+
+	vfs_getnewfsid(mp);
+	nmp->nm_mountp = mp;
+	nmp->nm_maxfilesize = 0xffffffffLL;
+	nmp->nm_timeo = NFS_TIMEO;
+	nmp->nm_retry = NFS_RETRANS;
+	nmp->nm_wsize = NFS_WSIZE;
+	nmp->nm_rsize = NFS_RSIZE;
+	nmp->nm_readdirsize = NFS_READDIRSIZE;
+	nmp->nm_numgrps = NFS_MAXGRPS;
+	nmp->nm_readahead = NFS_DEFRAHEAD;
+	nmp->nm_deadthresh = NFS_MAXDEADTHRESH;
+	bcopy(hst, mp->mnt_stat.f_mntfromname, MNAMELEN);
+	bcopy(pth, mp->mnt_stat.f_mntonname, MNAMELEN);
+	nmp->nm_nam = nam;
+	/* Set up the sockets and per-host congestion */
+	nmp->nm_sotype = argp->sotype;
+	nmp->nm_soproto = argp->proto;
+	/* XXX */
+        mp->mnt_stat.f_iosize = PAGE_SIZE;
+
+	/* XXX - this is to make some other code work.  Sort of ugly. */
+	argp->flags |= (NFSMNT_NFSV3 | NFSMNT_NFSV4);
+
+	nfs_decode_args(nmp, argp);
+
+	if ((error = nfs4_connect(nmp)))
+		goto bad;
+
+	mreq = nfsm_reqhead(NULL, NFSV4PROC_COMPOUND, NFSX_FH(1));
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	ga.bm = &nfsv4_fsinfobm;
+	nfs_v4initcompound(&cp);
+
+	/* Get remote path */
+	rpth = hst;
+	strsep(&rpth, ":");
+
+	nfsm_v4build_compound(&cp, "mountnfs()");
+	nfsm_v4build_putrootfh(&cp);
+	for (cp1 = rpth; cp1 && *cp1; cp1 = cp2)  {
+		while (*cp1 == '/')
+			cp1++;
+		if (!*cp1)
+			break;
+		for (cp2 = cp1; *cp2 && *cp2 != '/'; cp2++)
+			;
+		lkup.name = cp1;
+		lkup.namelen = cp2 - cp1;
+		nfsm_v4build_lookup(&cp, &lkup);
+		nlkup++;
+	}
+	nfsm_v4build_getfh(&cp, &gfh);
+	nfsm_v4build_getattr(&cp, &ga);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request_mnt(nmp, NFSV4PROC_COMPOUND, td, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putrootfh(&cp);
+	while (nlkup--)
+		nfsm_v4dissect_lookup(&cp);
+	nfsm_v4dissect_getfh(&cp, &gfh);
+	nfsm_v4dissect_getattr(&cp, &ga);
+
+	nfs4_vfsop_fsinfo(&ga.fa, nmp);
+	nmp->nm_state |= NFSSTA_GOTFSINFO;
+
+	/* Copy root fh into nfsmount. */
+	nmp->nm_fhsize = gfh.fh_len;
+	bcopy(&gfh.fh_val, nmp->nm_fh, nmp->nm_fhsize);
+	nmp->nm_last_renewal = time_second;
+
+	if ((error = nfs4_do_setclientid(nmp, cred)) != 0)
+		goto nfsmout;
+
+	/* Start renewd if it isn't already running */
+	if (nfs4_daemonproc == NULL)
+		kthread_create(nfs4_daemon, crdup(cred), &nfs4_daemonproc,
+			       (RFPROC|RFMEM), 0, "nfs4rd");
+
+	return (0);
+ nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	/* XXX */
+	if (mrep != NULL)
+		m_freem(mrep);
+bad:
+	nfs_disconnect(nmp);
+	uma_zfree(nfsmount_zone, nmp);
+	FREE(nam, M_SONAME);
+
+	return (error);
+}
+
+/*
+ * unmount system call
+ */
+static int
+nfs_unmount(struct mount *mp, int mntflags, struct thread *td)
+{
+	struct nfsmount *nmp;
+	int error, flags = 0;
+
+	if (mntflags & MNT_FORCE)
+		flags |= FORCECLOSE;
+	nmp = VFSTONFS(mp);
+	/*
+	 * Goes something like this..
+	 * - Call vflush() to clear out vnodes for this filesystem
+	 * - Close the socket
+	 * - Free up the data structures
+	 */
+	/* In the forced case, cancel any outstanding requests. */
+	if (flags & FORCECLOSE) {
+		error = nfs_nmcancelreqs(nmp);
+		if (error)
+			return (error);
+		nfs4dev_purge();
+	}
+
+	error = vflush(mp, 0, flags);
+	if (error)
+		return (error);
+
+	/*
+	 * We are now committed to the unmount.
+	 */
+	nfs_disconnect(nmp);
+	FREE(nmp->nm_nam, M_SONAME);
+
+	/* XXX there's a race condition here for SMP */
+	wakeup(&nfs4_daemonproc);
+
+	uma_zfree(nfsmount_zone, nmp);
+	return (0);
+}
+
+/*
+ * Return root of a filesystem
+ */
+static int
+nfs_root(struct mount *mp, struct vnode **vpp)
+{
+	struct vnode *vp;
+	struct nfsmount *nmp;
+	struct nfsnode *np;
+	int error;
+
+	nmp = VFSTONFS(mp);
+	error = nfs_nget(mp, (nfsfh_t *)nmp->nm_fh, nmp->nm_fhsize, &np);
+	if (error)
+		return (error);
+	vp = NFSTOV(np);
+	if (vp->v_type == VNON)
+	    vp->v_type = VDIR;
+	vp->v_vflag |= VV_ROOT;
+	*vpp = vp;
+
+	return (0);
+}
+
+/*
+ * Flush out the buffer cache
+ */
+/* ARGSUSED */
+static int
+nfs_sync(struct mount *mp, int waitfor, struct ucred *cred, struct thread *td)
+{
+	struct vnode *vp, *vnp;
+	int error, allerror = 0;
+
+	/*
+	 * Force stale buffer cache information to be flushed.
+	 */
+	MNT_ILOCK(mp);
+loop:
+	for (vp = TAILQ_FIRST(&mp->mnt_nvnodelist);
+	     vp != NULL;
+	     vp = vnp) {
+		/*
+		 * If the vnode that we are about to sync is no longer
+		 * associated with this mount point, start over.
+		 */
+		if (vp->v_mount != mp)
+			goto loop;
+		vnp = TAILQ_NEXT(vp, v_nmntvnodes);
+		VI_LOCK(vp);
+		MNT_IUNLOCK(mp);
+		if (VOP_ISLOCKED(vp, NULL) || TAILQ_EMPTY(&vp->v_dirtyblkhd) ||
+		    waitfor == MNT_LAZY) {
+			VI_UNLOCK(vp);
+			MNT_ILOCK(mp);
+			continue;
+		}
+		if (vget(vp, LK_EXCLUSIVE | LK_INTERLOCK, td)) {
+			goto loop;
+		}
+		error = VOP_FSYNC(vp, cred, waitfor, td);
+		if (error)
+			allerror = error;
+		VOP_UNLOCK(vp, 0, td);
+		vrele(vp);
+
+		MNT_ILOCK(mp);
+	}
+	MNT_IUNLOCK(mp);
+	return (allerror);
+}
+
+static int
+nfs4_do_setclientid(struct nfsmount *nmp, struct ucred *cred)
+{
+	struct nfs4_oparg_setclientid scid;
+	struct nfs4_compound cp;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	caddr_t bpos, dpos;	
+	struct route ro;
+	char *ipsrc = NULL, uaddr[24], name[24];
+	int try = 0;
+	static int seq;
+	int error;
+
+#ifndef NFS4_USE_RPCCLNT
+	return (0);
+#endif
+	if (nmp->nm_clientid) {
+		printf("nfs4_do_setclientid: already have clientid!\n");
+		error = 0;
+		goto nfsmout;
+	}
+
+	/* Try not to re-use clientids */
+	if (seq == 0)
+		seq = time_second & 0xffffff;
+
+#ifdef NFS4_USE_RPCCLNT
+	scid.cb_netid = (nmp->nm_rpcclnt.rc_sotype == SOCK_STREAM) ? "tcp" : "udp";
+#endif
+	scid.cb_netid = "tcp";
+	scid.cb_netidlen = 3;
+	scid.cb_prog = 0x1234; /* XXX */
+
+	/* Do a route lookup to find our source address for talking to this server */
+	bzero(&ro, sizeof ro);
+
+#ifdef NFS4_USE_RPCCLNT
+	ro.ro_dst = *nmp->nm_rpcclnt.rc_name;
+#endif
+	rtalloc(&ro);
+	if (ro.ro_rt == NULL) {
+		error = EHOSTUNREACH;
+		goto nfsmout;
+	}
+	ipsrc = inet_ntoa(IA_SIN(ifatoia(ro.ro_rt->rt_ifa))->sin_addr);
+	sprintf(uaddr, "%s.12.48", ipsrc);
+	scid.cb_univaddr = uaddr;
+	scid.cb_univaddrlen = strlen(uaddr);
+	RTFREE(ro.ro_rt);
+
+ try_again:
+	sprintf(name, "%s-%d", ipsrc, seq++);
+	scid.namelen = strlen(name);
+	scid.name = name;
+	nfs_v4initcompound(&cp);
+
+	mreq = nfsm_reqhead(NULL, NFSV4PROC_COMPOUND, NFSX_FH(1));
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	nfsm_v4build_compound(&cp, "nfs4_do_setclientid()");
+	nfsm_v4build_setclientid(&cp, &scid);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request_mnt(nmp, NFSV4PROC_COMPOUND, curthread, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_setclientid(&cp, &scid);
+	nmp->nm_clientid = scid.clientid;
+
+	error = nfs_v4postop(&cp, error);
+
+	/* Confirm */
+	m_freem(mrep);
+	mreq = nfsm_reqhead(NULL, NFSV4PROC_COMPOUND, NFSX_FH(1));
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	nfs_v4initcompound(&cp);
+
+	nfsm_v4build_compound(&cp, "nfs4_do_setclientid() (confirm)");
+	nfsm_v4build_setclientid_confirm(&cp, &scid);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request_mnt(nmp, NFSV4PROC_COMPOUND, curthread, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_setclientid_confirm(&cp);
+
+ nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (mrep)
+		m_freem(mrep);
+	if (error == NFSERR_CLID_INUSE && (++try < NFS4_SETCLIENTID_MAXTRIES))
+		goto try_again;
+
+	return (error);
+}
diff --git a/sys/nfs4client/nfs4_vn.h b/sys/nfs4client/nfs4_vn.h
new file mode 100644
index 0000000..d984713
--- /dev/null
+++ b/sys/nfs4client/nfs4_vn.h
@@ -0,0 +1,33 @@
+/* $FreeBSD$ */
+/* $Id: nfs4_vn.h,v 1.5 2003/11/05 14:59:00 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+#ifndef _NFS4CLIENT_NFS4_VFS_H
+#define _NFS4CLIENT_NFS4_VFS_H
+
+void nfs4_vnop_loadattrcache(struct vnode *, struct nfsv4_fattr *, struct vattr *);
+
+#endif /* _NFS4CLIENT_NFS4_VFS_H */
diff --git a/sys/nfs4client/nfs4_vn_subs.c b/sys/nfs4client/nfs4_vn_subs.c
new file mode 100644
index 0000000..28eb52d
--- /dev/null
+++ b/sys/nfs4client/nfs4_vn_subs.c
@@ -0,0 +1,223 @@
+/* $FreeBSD$ */
+/* $Id: nfs4_vn_subs.c,v 1.9 2003/11/05 14:59:00 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/limits.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/mbuf.h>
+#include <sys/module.h>
+#include <sys/mount.h>
+#include <sys/proc.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/sockio.h>
+#include <sys/vnode.h>
+#include <sys/types.h>
+
+#include <vm/vm.h>
+#include <vm/vm_extern.h>
+#include <vm/uma.h>
+
+#include <net/if.h>
+#include <net/route.h>
+#include <netinet/in.h>
+
+#include <rpc/rpcclnt.h>
+
+#include <nfs/rpcv2.h>
+#include <nfs/nfsproto.h>
+#include <nfsclient/nfs.h>
+#include <nfsclient/nfsmount.h>
+#include <nfs/xdr_subs.h>
+#include <nfsclient/nfsm_subs.h>
+#include <nfsclient/nfsdiskless.h>
+
+/* NFSv4 */
+#include <nfs4client/nfs4.h>
+#include <nfs4client/nfs4m_subs.h>
+#include <nfs4client/nfs4_vn.h>
+
+#include <nfsclient/nfsnode.h>
+
+void
+nfs4_vnop_loadattrcache(struct vnode *vp, struct nfsv4_fattr *fap,
+    struct vattr *vaper)
+{
+        struct vattr *vap;
+        struct nfsnode *np;
+        int32_t rdev;
+        enum vtype vtyp;
+        u_short vmode;
+        struct timespec mtime;
+	struct timeval tv;
+
+        microtime(&tv);
+
+        vtyp = nv3tov_type[fap->fa4_type & 0x7];
+        vmode = (fap->fa4_valid & FA4V_MODE) ? fap->fa4_mode : 0777;
+        rdev = (fap->fa4_valid & FA4V_RDEV) ?
+	    makeudev(fap->fa4_rdev_major, fap->fa4_rdev_minor) : 0;
+        if (fap->fa4_valid & FA4V_MTIME)
+                mtime = fap->fa4_mtime;
+        else
+                bzero(&mtime, sizeof mtime);
+
+        /*
+         * If v_type == VNON it is a new node, so fill in the v_type,
+         * n_mtime fields. Check to see if it represents a special
+         * device, and if so, check for a possible alias. Once the
+         * correct vnode has been obtained, fill in the rest of the
+         * information.
+         */
+        np = VTONFS(vp);
+        vap = &np->n_vattr;
+        if (vp->v_type != vtyp || np->n_mtime == 0) {
+                bzero(vap, sizeof *vap);
+                vp->v_type = vtyp;
+                np->n_mtime = mtime.tv_sec;
+        }
+        vap->va_type = vtyp;
+        vap->va_mode = (vmode & 07777);
+        vap->va_rdev = rdev;
+        vap->va_mtime = mtime;
+        vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0];
+        if (fap->fa4_valid & FA4V_NLINK)
+                vap->va_nlink = fap->fa4_nlink;
+        if (fap->fa4_valid & FA4V_UID)
+                vap->va_uid = fap->fa4_uid;
+        if (fap->fa4_valid & FA4V_GID)
+                vap->va_gid = fap->fa4_gid;
+        vap->va_size = fap->fa4_size;
+        vap->va_blocksize = NFS_FABLKSIZE;
+        vap->va_bytes = fap->fa4_size;
+        if (fap->fa4_valid & FA4V_FILEID)
+                vap->va_fileid = nfs_v4fileid4_to_fileid(fap->fa4_fileid);
+        if (fap->fa4_valid & FA4V_ATIME)
+                vap->va_atime = fap->fa4_atime;
+        if (fap->fa4_valid & FA4V_CTIME)
+                vap->va_ctime = fap->fa4_ctime;
+        vap->va_flags = 0;
+        vap->va_filerev = 0;
+	/* XXX dontshrink flag? */
+        if (vap->va_size != np->n_size) {
+                if (vap->va_type == VREG) {
+                        if (np->n_flag & NMODIFIED) {
+                                if (vap->va_size < np->n_size)
+                                        vap->va_size = np->n_size;
+                                else
+                                        np->n_size = vap->va_size;
+                        } else
+                                np->n_size = vap->va_size;
+			vnode_pager_setsize(vp, np->n_size);
+                } else
+                        np->n_size = vap->va_size;
+        }
+        np->n_attrstamp = tv.tv_sec;
+        if (vaper != NULL) {
+                bcopy((caddr_t)vap, (caddr_t)vaper, sizeof(*vap));
+                if (np->n_flag & NCHG) {
+                        if (np->n_flag & NACC)
+                                vaper->va_atime = np->n_atim;
+                        if (np->n_flag & NUPD)
+                                vaper->va_mtime = np->n_mtim;
+                }
+        }
+}
+
+static uint64_t nfs_nullcookie = 0;
+/*
+ * This function finds the directory cookie that corresponds to the
+ * logical byte offset given.
+ */
+uint64_t *
+nfs4_getcookie(struct nfsnode *np, off_t off, int add)
+{
+	struct nfsdmap *dp, *dp2;
+	int pos;
+
+	pos = (uoff_t)off / NFS_DIRBLKSIZ;
+	if (pos == 0 || off < 0) {
+#ifdef DIAGNOSTIC
+		if (add)
+			panic("nfs getcookie add at <= 0");
+#endif
+		return (&nfs_nullcookie);
+	}
+	pos--;
+	dp = LIST_FIRST(&np->n_cookies);
+	if (!dp) {
+		if (add) {
+			MALLOC(dp, struct nfsdmap *, sizeof (struct nfsdmap),
+				M_NFSDIROFF, M_WAITOK);
+			dp->ndm_eocookie = 0;
+			LIST_INSERT_HEAD(&np->n_cookies, dp, ndm_list);
+		} else
+			return (NULL);
+	}
+	while (pos >= NFSNUMCOOKIES) {
+		pos -= NFSNUMCOOKIES;
+		if (LIST_NEXT(dp, ndm_list)) {
+			if (!add && dp->ndm_eocookie < NFSNUMCOOKIES &&
+				pos >= dp->ndm_eocookie)
+				return (NULL);
+			dp = LIST_NEXT(dp, ndm_list);
+		} else if (add) {
+			MALLOC(dp2, struct nfsdmap *, sizeof (struct nfsdmap),
+				M_NFSDIROFF, M_WAITOK);
+			dp2->ndm_eocookie = 0;
+			LIST_INSERT_AFTER(dp, dp2, ndm_list);
+			dp = dp2;
+		} else
+			return (NULL);
+	}
+	if (pos >= dp->ndm_eocookie) {
+		if (add)
+			dp->ndm_eocookie = pos + 1;
+		else
+			return (NULL);
+	}
+	return (&dp->ndm4_cookies[pos]);
+}
+
+/*
+ * Invalidate cached directory information, except for the actual directory
+ * blocks (which are invalidated separately).
+ * Done mainly to avoid the use of stale offset cookies.
+ */
+void
+nfs4_invaldir(struct vnode *vp)
+{
+	struct nfsnode *np = VTONFS(vp);
+
+	np->n_direofoffset = 0;
+	bzero(np->n4_cookieverf, NFSX_V4VERF);
+	if (LIST_FIRST(&np->n_cookies))
+		LIST_FIRST(&np->n_cookies)->ndm_eocookie = 0;
+}
diff --git a/sys/nfs4client/nfs4_vnops.c b/sys/nfs4client/nfs4_vnops.c
new file mode 100644
index 0000000..48e4549
--- /dev/null
+++ b/sys/nfs4client/nfs4_vnops.c
@@ -0,0 +1,3200 @@
+/* $FreeBSD$ */
+/* $Id: nfs_vnops.c,v 1.45 2003/11/05 14:59:02 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+/*
+ * 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.
+ *
+ *	@(#)nfs_vnops.c	8.16 (Berkeley) 5/27/95
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * vnode op calls for Sun NFS version 2 and 3
+ */
+
+#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/bio.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 <fs/fifofs/fifo.h>
+
+#include <rpc/rpcclnt.h>
+
+#include <nfs/rpcv2.h>
+#include <nfs/nfsproto.h>
+#include <nfsclient/nfs.h>
+#include <nfs4client/nfs4.h>
+#include <nfsclient/nfsnode.h>
+#include <nfsclient/nfsmount.h>
+#include <nfsclient/nfs_lock.h>
+#include <nfs/xdr_subs.h>
+#include <nfsclient/nfsm_subs.h>
+
+#include <net/if.h>
+#include <netinet/in.h>
+#include <netinet/in_var.h>
+
+/* NFSv4 */
+#include <nfs4client/nfs4m_subs.h>
+#include <nfs4client/nfs4_vn.h>
+
+/* Defs */
+#define	TRUE	1
+#define	FALSE	0
+
+/*
+ * Ifdef for FreeBSD-current merged buffer cache. It is unfortunate that these
+ * calls are not in getblk() and brelse() so that they would not be necessary
+ * here.
+ */
+#ifndef B_VMIO
+#define vfs_busy_pages(bp, f)
+#endif
+
+static int	nfsspec_read(struct vop_read_args *);
+static int	nfsspec_write(struct vop_write_args *);
+static int	nfsfifo_read(struct vop_read_args *);
+static int	nfsfifo_write(struct vop_write_args *);
+static int	nfsspec_close(struct vop_close_args *);
+static int	nfsfifo_close(struct vop_close_args *);
+static int	nfs4_flush(struct vnode *, struct ucred *, int, struct thread *,
+		    int);
+static int	nfs4_setattrrpc(struct vnode *, struct vattr *, struct ucred *,
+		    struct thread *);
+static int      nfs4_closerpc(struct vnode *, struct ucred *, struct thread *, int);
+
+static	int	nfs4_lookup(struct vop_lookup_args *);
+static	int	nfs4_create(struct vop_create_args *);
+static	int	nfs4_mknod(struct vop_mknod_args *);
+static	int	nfs4_open(struct vop_open_args *);
+static	int	nfs4_close(struct vop_close_args *);
+static	int	nfs4_access(struct vop_access_args *);
+static	int	nfs4_getattr(struct vop_getattr_args *);
+static	int	nfs4_setattr(struct vop_setattr_args *);
+static	int	nfs4_read(struct vop_read_args *);
+static	int	nfs4_fsync(struct vop_fsync_args *);
+static	int	nfs4_remove(struct vop_remove_args *);
+static	int	nfs4_link(struct vop_link_args *);
+static	int	nfs4_rename(struct vop_rename_args *);
+static	int	nfs4_mkdir(struct vop_mkdir_args *);
+static	int	nfs4_rmdir(struct vop_rmdir_args *);
+static	int	nfs4_symlink(struct vop_symlink_args *);
+static	int	nfs4_readdir(struct vop_readdir_args *);
+static	int	nfs4_strategy(struct vop_strategy_args *);
+static	int	nfs4_lookitup(struct vnode *, const char *, int,
+		    struct ucred *, struct thread *, struct nfsnode **);
+static	int	nfs4_sillyrename(struct vnode *, struct vnode *,
+		    struct componentname *);
+static int	nfsspec_access(struct vop_access_args *);
+static int	nfs4_readlink(struct vop_readlink_args *);
+static int	nfs4_print(struct vop_print_args *);
+static int	nfs4_advlock(struct vop_advlock_args *);
+
+/*
+ * Global vfs data structures for nfs
+ */
+vop_t **nfs4_vnodeop_p;
+static struct vnodeopv_entry_desc nfs4_vnodeop_entries[] = {
+	{ &vop_default_desc,		(vop_t *) vop_defaultop },
+	{ &vop_access_desc,		(vop_t *) nfs4_access },
+	{ &vop_advlock_desc,		(vop_t *) nfs4_advlock },
+	{ &vop_close_desc,		(vop_t *) nfs4_close },
+	{ &vop_create_desc,		(vop_t *) nfs4_create },
+	{ &vop_fsync_desc,		(vop_t *) nfs4_fsync },
+	{ &vop_getattr_desc,		(vop_t *) nfs4_getattr },
+	{ &vop_getpages_desc,		(vop_t *) nfs_getpages },
+	{ &vop_putpages_desc,		(vop_t *) nfs_putpages },
+	{ &vop_inactive_desc,		(vop_t *) nfs_inactive },
+	{ &vop_lease_desc,		(vop_t *) vop_null },
+	{ &vop_link_desc,		(vop_t *) nfs4_link },
+	{ &vop_lookup_desc,		(vop_t *) nfs4_lookup },
+	{ &vop_mkdir_desc,		(vop_t *) nfs4_mkdir },
+	{ &vop_mknod_desc,		(vop_t *) nfs4_mknod },
+	{ &vop_open_desc,		(vop_t *) nfs4_open },
+	{ &vop_print_desc,		(vop_t *) nfs4_print },
+	{ &vop_read_desc,		(vop_t *) nfs4_read },
+	{ &vop_readdir_desc,		(vop_t *) nfs4_readdir },
+	{ &vop_readlink_desc,		(vop_t *) nfs4_readlink },
+	{ &vop_reclaim_desc,		(vop_t *) nfs_reclaim },
+	{ &vop_remove_desc,		(vop_t *) nfs4_remove },
+	{ &vop_rename_desc,		(vop_t *) nfs4_rename },
+	{ &vop_rmdir_desc,		(vop_t *) nfs4_rmdir },
+	{ &vop_setattr_desc,		(vop_t *) nfs4_setattr },
+	{ &vop_strategy_desc,		(vop_t *) nfs4_strategy },
+	{ &vop_symlink_desc,		(vop_t *) nfs4_symlink },
+	{ &vop_write_desc,		(vop_t *) nfs_write },
+	{ NULL, NULL }
+};
+static struct vnodeopv_desc nfs4_vnodeop_opv_desc =
+	{ &nfs4_vnodeop_p, nfs4_vnodeop_entries };
+VNODEOP_SET(nfs4_vnodeop_opv_desc);
+
+/*
+ * Special device vnode ops
+ */
+vop_t **spec_nfs4nodeop_p;
+static struct vnodeopv_entry_desc nfs4_specop_entries[] = {
+	{ &vop_default_desc,		(vop_t *) spec_vnoperate },
+	{ &vop_access_desc,		(vop_t *) nfsspec_access },
+	{ &vop_close_desc,		(vop_t *) nfsspec_close },
+	{ &vop_fsync_desc,		(vop_t *) nfs4_fsync },
+	{ &vop_getattr_desc,		(vop_t *) nfs4_getattr },
+	{ &vop_inactive_desc,		(vop_t *) nfs_inactive },
+	{ &vop_print_desc,		(vop_t *) nfs4_print },
+	{ &vop_read_desc,		(vop_t *) nfsspec_read },
+	{ &vop_reclaim_desc,		(vop_t *) nfs_reclaim },
+	{ &vop_setattr_desc,		(vop_t *) nfs4_setattr },
+	{ &vop_write_desc,		(vop_t *) nfsspec_write },
+	{ NULL, NULL }
+};
+static struct vnodeopv_desc spec_nfs4nodeop_opv_desc =
+	{ &spec_nfs4nodeop_p, nfs4_specop_entries };
+VNODEOP_SET(spec_nfs4nodeop_opv_desc);
+
+vop_t **fifo_nfs4nodeop_p;
+static struct vnodeopv_entry_desc nfs4_fifoop_entries[] = {
+	{ &vop_default_desc,		(vop_t *) fifo_vnoperate },
+	{ &vop_access_desc,		(vop_t *) nfsspec_access },
+	{ &vop_close_desc,		(vop_t *) nfsfifo_close },
+	{ &vop_fsync_desc,		(vop_t *) nfs4_fsync },
+	{ &vop_getattr_desc,		(vop_t *) nfs4_getattr },
+	{ &vop_inactive_desc,		(vop_t *) nfs_inactive },
+	{ &vop_print_desc,		(vop_t *) nfs4_print },
+	{ &vop_read_desc,		(vop_t *) nfsfifo_read },
+	{ &vop_reclaim_desc,		(vop_t *) nfs_reclaim },
+	{ &vop_setattr_desc,		(vop_t *) nfs4_setattr },
+	{ &vop_write_desc,		(vop_t *) nfsfifo_write },
+	{ NULL, NULL }
+};
+static struct vnodeopv_desc fifo_nfs4nodeop_opv_desc =
+	{ &fifo_nfs4nodeop_p, nfs4_fifoop_entries };
+VNODEOP_SET(fifo_nfs4nodeop_opv_desc);
+
+static int	nfs4_removerpc(struct vnode *dvp, const char *name, int namelen,
+			      struct ucred *cred, struct thread *td);
+static int	nfs4_renamerpc(struct vnode *fdvp, const char *fnameptr,
+			      int fnamelen, struct vnode *tdvp,
+			      const char *tnameptr, int tnamelen,
+			      struct ucred *cred, struct thread *td);
+static int	nfs4_renameit(struct vnode *sdvp, struct componentname *scnp,
+			     struct sillyrename *sp);
+static int      nfs4_openrpc(struct vnode *, struct vnode **,
+                            struct componentname *, int, struct vattr *);
+static int	nfs4_open_confirm(struct vnode *vp, struct nfs4_compound *cpp,
+				 struct nfs4_oparg_open *openap,
+				 struct nfs4_oparg_getfh *gfh,
+				 struct ucred *cred, struct thread *td);
+static int      nfs4_createrpc(struct vnode *, struct vnode **,
+                              struct componentname *, nfstype,
+                              struct vattr *, char *);
+
+/*
+ * Global variables
+ */
+struct nfs4_lowner nfs4_masterlowner;
+
+#define	DIRHDSIZ	(sizeof (struct dirent) - (MAXNAMLEN + 1))
+
+SYSCTL_DECL(_vfs_nfs4);
+
+static int	nfsaccess_cache_timeout = NFS_MAXATTRTIMO;
+SYSCTL_INT(_vfs_nfs4, OID_AUTO, access_cache_timeout, CTLFLAG_RW,
+	   &nfsaccess_cache_timeout, 0, "NFS ACCESS cache timeout");
+
+static int	nfsv3_commit_on_close = 0;
+SYSCTL_INT(_vfs_nfs4, OID_AUTO, nfsv3_commit_on_close, CTLFLAG_RW,
+	   &nfsv3_commit_on_close, 0, "write+commit on close, else only write");
+#if 0
+SYSCTL_INT(_vfs_nfs4, OID_AUTO, access_cache_hits, CTLFLAG_RD,
+	   &nfsstats.accesscache_hits, 0, "NFS ACCESS cache hit count");
+
+SYSCTL_INT(_vfs_nfs4, OID_AUTO, access_cache_misses, CTLFLAG_RD,
+	   &nfsstats.accesscache_misses, 0, "NFS ACCESS cache miss count");
+#endif
+
+#define	NFSV3ACCESS_ALL (NFSV3ACCESS_READ | NFSV3ACCESS_MODIFY		\
+			 | NFSV3ACCESS_EXTEND | NFSV3ACCESS_EXECUTE	\
+			 | NFSV3ACCESS_DELETE | NFSV3ACCESS_LOOKUP)
+static int
+nfs3_access_otw(struct vnode *vp, int wmode, struct thread *td,
+    struct ucred *cred)
+{
+	const int v3 = 1;
+	u_int32_t *tl;
+	int error = 0, attrflag;
+
+	return (0);
+
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	caddr_t bpos, dpos;
+	u_int32_t rmode;
+	struct nfsnode *np = VTONFS(vp);
+
+	nfsstats.rpccnt[NFSPROC_ACCESS]++;
+	mreq = nfsm_reqhead(vp, NFSPROC_ACCESS, NFSX_FH(v3) + NFSX_UNSIGNED);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+	nfsm_fhtom(vp, v3);
+	tl = nfsm_build(u_int32_t *, NFSX_UNSIGNED);
+	*tl = txdr_unsigned(wmode);
+	nfsm_request(vp, NFSPROC_ACCESS, td, cred);
+	nfsm_postop_attr(vp, attrflag);
+	if (!error) {
+		tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
+		rmode = fxdr_unsigned(u_int32_t, *tl);
+		np->n_mode = rmode;
+		np->n_modeuid = cred->cr_uid;
+		np->n_modestamp = time_second;
+	}
+	m_freem(mrep);
+nfsmout:
+	return error;
+}
+
+/*
+ * nfs access vnode op.
+ * For nfs version 2, just return ok. File accesses may fail later.
+ * For nfs version 3, use the access rpc to check accessibility. If file modes
+ * are changed on the server, accesses might still fail later.
+ */
+static int
+nfs4_access(struct vop_access_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	int error = 0;
+	u_int32_t mode, wmode;
+	int v3 = NFS_ISV3(vp);	/* v3 \in v4 */
+	struct nfsnode *np = VTONFS(vp);
+	caddr_t bpos, dpos;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_access acc;
+	struct thread *td = ap->a_td;
+	struct ucred *cred = ap->a_cred;
+
+	/*
+	 * 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 ((ap->a_mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
+		switch (vp->v_type) {
+		case VREG:
+		case VDIR:
+		case VLNK:
+			return (EROFS);
+		default:
+			break;
+		}
+	}
+	/*
+	 * For nfs v3, check to see if we have done this recently, and if
+	 * so return our cached result instead of making an ACCESS call.
+	 * If not, do an access rpc, otherwise you are stuck emulating
+	 * ufs_access() locally using the vattr. This may not be correct,
+	 * since the server may apply other access criteria such as
+	 * client uid-->server uid mapping that we do not know about.
+	 */
+	/* XXX Disable this for now; needs fixing of _access_otw() */
+	if (0 && v3) {
+		if (ap->a_mode & VREAD)
+			mode = NFSV3ACCESS_READ;
+		else
+			mode = 0;
+		if (vp->v_type != VDIR) {
+			if (ap->a_mode & VWRITE)
+				mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND);
+			if (ap->a_mode & VEXEC)
+				mode |= NFSV3ACCESS_EXECUTE;
+		} else {
+			if (ap->a_mode & VWRITE)
+				mode |= (NFSV3ACCESS_MODIFY | NFSV3ACCESS_EXTEND |
+				    NFSV3ACCESS_DELETE);
+			if (ap->a_mode & VEXEC)
+				mode |= NFSV3ACCESS_LOOKUP;
+		}
+		/* XXX safety belt, only make blanket request if caching */
+		if (nfsaccess_cache_timeout > 0) {
+			wmode = NFSV3ACCESS_READ | NFSV3ACCESS_MODIFY |
+			    NFSV3ACCESS_EXTEND | NFSV3ACCESS_EXECUTE |
+			    NFSV3ACCESS_DELETE | NFSV3ACCESS_LOOKUP;
+		} else {
+			wmode = mode;
+		}
+
+		/*
+		 * Does our cached result allow us to give a definite yes to
+		 * this request?
+		 */
+		if ((time_second < (np->n_modestamp + nfsaccess_cache_timeout)) &&
+		    (ap->a_cred->cr_uid == np->n_modeuid) &&
+		    ((np->n_mode & mode) == mode)) {
+			nfsstats.accesscache_hits++;
+		} else {
+			/*
+			 * Either a no, or a don't know.  Go to the wire.
+			 */
+			nfsstats.accesscache_misses++;
+		        error = nfs3_access_otw(vp, wmode, ap->a_td,ap->a_cred);
+			if (!error) {
+				if ((np->n_mode & mode) != mode) {
+					error = EACCES;
+				}
+			}
+		}
+		return (error);
+	}
+
+	/* XXX use generic access code here? */
+	mode = ap->a_mode & VREAD ? NFSV4ACCESS_READ : 0;
+	if (vp->v_type == VDIR) {
+		if (ap->a_mode & VWRITE)
+			mode |= NFSV4ACCESS_MODIFY | NFSV4ACCESS_EXTEND | NFSV4ACCESS_DELETE;
+		if (ap->a_mode & VEXEC)
+			mode |= NFSV4ACCESS_LOOKUP;
+	} else {
+		if (ap->a_mode & VWRITE)
+			mode |= NFSV4ACCESS_MODIFY | NFSV4ACCESS_EXTEND;
+		if (ap->a_mode & VEXEC)
+			mode |= NFSV4ACCESS_EXECUTE;
+	}
+
+	nfs_v4initcompound(&cp);
+	acc.mode = mode;
+
+	mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	nfsm_v4build_compound(&cp, "nfs4_access()");
+	nfsm_v4build_putfh(&cp, vp);
+	nfsm_v4build_access(&cp, &acc);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(vp, NFSV4PROC_COMPOUND, td, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_access(&cp, &acc);
+
+	if ((acc.rmode & mode) != mode)
+		error = EACCES;
+
+ nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (mrep != NULL)
+		m_freem(mrep);
+
+	return (error);
+}
+
+static int
+nfs4_openrpc(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
+    int flags, struct vattr *vap)
+{
+	struct vnode *vp = *vpp;
+	struct nfs4_oparg_getattr getattr;
+	struct nfs4_oparg_getfh getfh;
+	struct nfs4_oparg_open opena;
+	struct nfs4_compound cp;
+	caddr_t bpos, dpos;
+	int error = 0;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct ucred *cred = cnp->cn_cred;
+	struct thread *td = cnp->cn_thread;
+	struct nfs4_fctx xfc, *fcp;
+	struct nfsnode *np;
+
+	if (vp == NULL) {
+		/* Create a new file */
+		np = NULL;
+		fcp = &xfc;
+		bzero(fcp, sizeof(*fcp));
+	} else {
+		np = VTONFS(vp);
+		fcp = flags & FWRITE ? &np->n_wfc : &np->n_rfc;
+	}
+
+	/*
+	 * Since we are currently only one lockowner; we only open the
+	 * file one each for reading and writing.
+	 */
+	if (fcp->refcnt++ != 0) {
+		*vpp = vp;
+		/*printf("not opening %s\n", np->n_name != NULL ? np->n_name : "");*/
+		return (0);
+	}
+
+	fcp->lop = &nfs4_masterlowner;
+	fcp->pid = cnp->cn_thread->td_proc->p_pid;
+	fcp->np = np;
+
+	nfs_v4initcompound(&cp);
+	cp.nmp = VFSTONFS(dvp->v_mount);
+
+	opena.ctype = NCLNULL;
+	opena.flags = flags;
+	opena.vap = vap;
+	opena.fcp = fcp;		/* For lockowner */
+	opena.cnp = cnp;
+
+	getattr.bm = &nfsv4_getattrbm;
+
+	mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	nfsm_v4build_compound(&cp, "nfs4_openrpc()");
+	nfsm_v4build_putfh(&cp, dvp);
+	nfsm_v4build_open(&cp, &opena);
+	nfsm_v4build_getattr(&cp, &getattr);
+	nfsm_v4build_getfh(&cp, &getfh);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(vp != NULL ? vp : dvp, NFSV4PROC_COMPOUND, td, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_open(&cp, &opena);
+	nfsm_v4dissect_getattr(&cp, &getattr);
+	nfsm_v4dissect_getfh(&cp, &getfh);
+
+	error = nfs_v4postop(&cp, error);
+
+	if (opena.rflags & NFSV4OPENRES_CONFIRM) {
+		error = nfs4_open_confirm(vp ? vp : dvp, &cp, &opena, &getfh, cred, td);
+		if (error != 0)
+			goto nfsmout;
+	}
+
+	if (vp == NULL) {
+		/* New file */
+		error = nfs_nget(dvp->v_mount, &getfh.fh_val,
+		    getfh.fh_len, &np);
+		if (error != 0)
+			goto nfsmout;
+
+		vp = NFSTOV(np);
+		np->n_dvp = dvp;
+		np->n_namelen = cnp->cn_namelen; /* XXX memory leaks on these; track! */
+		if (np->n_name != NULL)
+			FREE(np->n_name, M_NFSREQ);
+		MALLOC(np->n_name, u_char *, np->n_namelen + 1, M_NFSREQ, M_WAITOK);
+		bcopy(cnp->cn_nameptr, np->n_name, np->n_namelen);
+		np->n_name[np->n_namelen] = '\0';
+		if (flags & FWRITE)
+			np->n_wfc = *fcp;
+		else
+			np->n_rfc = *fcp;
+
+		/*printf("opened new file %s\n", np->n_name);*/
+
+		nfs4_vnop_loadattrcache(vp, &getattr.fa, NULL);
+		*vpp = vp;
+	} else {
+		/*printf("openend \"old\" %s\n", np->n_name != NULL ? np->n_name : "");*/
+
+		if (flags & O_TRUNC && np->n_size != 0) {
+			struct vattr va;
+
+			VATTR_NULL(&va);
+			va.va_size = 0;
+			error = nfs4_setattrrpc(vp, &va,
+			    cnp->cn_cred, cnp->cn_thread);
+		}
+		np->n_attrstamp = 0;
+	}
+
+ nfsmout:
+	if (mrep != NULL)
+		m_freem(mrep);
+
+	return (error);
+}
+
+static int
+nfs4_open_confirm(struct vnode *vp, struct nfs4_compound *cpp,
+    struct nfs4_oparg_open *openap, struct nfs4_oparg_getfh *gfh,
+    struct ucred *cred, struct thread *td)
+{
+	caddr_t bpos, dpos;
+	int error = 0;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+
+	nfs_v4initcompound(cpp);
+	cpp->nmp = VFSTONFS(vp->v_mount);
+
+	mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	nfsm_v4build_compound(cpp, "nfs4_open_confirm()");
+	nfsm_v4build_putfh_nv(cpp, gfh);
+	nfsm_v4build_open_confirm(cpp, openap);
+	nfsm_v4build_finalize(cpp);
+
+	nfsm_request(vp, NFSV4PROC_COMPOUND, td, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(cpp);
+	nfsm_v4dissect_putfh(cpp);
+	nfsm_v4dissect_open_confirm(cpp, openap);
+
+ nfsmout:
+	error = nfs_v4postop(cpp, error);
+
+	if (mrep != NULL)
+		m_freem(mrep);
+
+	return (error);
+}
+
+
+/*
+ * nfs 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
+nfs4_open(struct vop_open_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	struct nfsnode *np = VTONFS(vp);
+	enum vtype vtype = vp->v_type;
+	int mode = ap->a_mode;
+	struct componentname cn;
+
+	if (vtype != VREG) {
+		if (vtype != VDIR && vtype != VLNK) {
+#ifdef DIAGNOSTIC
+			printf("open eacces vtyp=%d\n", vp->v_type);
+#endif
+			return (EACCES);
+		} else
+			return (0);
+	}
+
+	if (np->n_flag & NCREATED) {
+		np->n_flag &= ~NCREATED;
+		return (0);
+	}
+
+	cn.cn_nameptr = np->n_name;
+	cn.cn_namelen = np->n_namelen;
+	cn.cn_cred = ap->a_cred;
+	cn.cn_thread = ap->a_td;
+
+	return (nfs4_openrpc(np->n_dvp, &vp, &cn, mode, NULL));
+}
+
+static int
+nfs4_closerpc(struct vnode *vp, struct ucred *cred, struct thread *td, int flags)
+{
+	caddr_t bpos, dpos;
+	int error = 0;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfs4_fctx *fcp;
+	struct nfs4_compound cp;
+	struct nfsnode *np = VTONFS(vp);
+
+	fcp = flags & FWRITE ? &np->n_wfc : &np->n_rfc;
+
+	nfs_v4initcompound(&cp);
+
+	if (--fcp->refcnt != 0)
+		return (0);
+
+	/*printf("closing %s\n", np->n_name != NULL ? np->n_name : "");*/
+
+	cp.fcp = fcp;
+
+	mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	nfsm_v4build_compound(&cp, "nfs4_closerpc()");
+	nfsm_v4build_putfh(&cp, vp);
+	nfsm_v4build_close(&cp, fcp);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(vp, NFSV4PROC_COMPOUND, td, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_close(&cp, fcp);
+
+ nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (mrep != NULL)
+		m_freem(mrep);
+
+	return (error);
+}
+
+/*
+ * nfs close vnode op
+ * What an NFS client should do upon close after writing is a debatable issue.
+ * Most NFS 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
+ *     NFSERR_NOSPC and NFSERR_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.
+ * (NFS 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 NFS Version 2 - play it safe and flush/invalidate all dirty buffers
+ * for NFS 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 nfs_flush() to
+ *                     a 1 would force a commit operation, if it is felt a
+ *                     commit is necessary now.
+ */
+/* ARGSUSED */
+static int
+nfs4_close(struct vop_close_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	struct nfsnode *np = VTONFS(vp);
+	int error = 0;
+
+	if (vp->v_type != VREG)
+		return (0);
+
+	if (np->n_flag & NMODIFIED) {
+		if (NFS_ISV3(vp)) {
+			/*
+			 * Under NFSv3 we have dirty buffers to
+			 * dispose of.  We must flush them to the NFS
+			 * server.  We have the option of waiting all
+			 * the way through the commit rpc or just
+			 * waiting for the initial write.  The default
+			 * is to only wait through the initial write
+			 * so the data is in the server's cache, which
+			 * is roughly similar to the state a standard
+			 * disk subsystem leaves the file in on
+			 * close().
+			 *
+			 * We cannot clear the NMODIFIED bit in
+			 * np->n_flag due to potential races with
+			 * other processes, and certainly cannot clear
+			 * it if we don't commit.
+			 */
+			int cm = nfsv3_commit_on_close ? 1 : 0;
+			error = nfs4_flush(vp, ap->a_cred, MNT_WAIT, ap->a_td, cm);
+			/* np->n_flag &= ~NMODIFIED; */
+		} else {
+			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, ap->a_td);
+			error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred, ap->a_td, 1);
+			VOP_UNLOCK(vp, 0, ap->a_td);
+		}
+		np->n_attrstamp = 0;
+	}
+
+	error = nfs4_closerpc(vp, ap->a_cred, ap->a_td, ap->a_fflag);
+
+	if (!error && np->n_flag & NWRITEERR) {
+		np->n_flag &= ~NWRITEERR;
+		error = np->n_error;
+	}
+	return (error);
+}
+
+/*
+ * nfs getattr call from vfs.
+ */
+static int
+nfs4_getattr(struct vop_getattr_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	struct nfsnode *np = VTONFS(vp);
+	caddr_t bpos, dpos;
+	int error = 0;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfs4_oparg_getattr ga;
+	struct nfs4_compound cp;
+
+	/*
+	 * Update local times for special files.
+	 */
+	if (np->n_flag & (NACC | NUPD))
+		np->n_flag |= NCHG;
+	/*
+	 * First look in the cache.
+	 */
+	if (nfs_getattrcache(vp, ap->a_vap) == 0)
+		return (0);
+
+	nfsstats.rpccnt[NFSPROC_GETATTR]++;
+
+	mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, NFSX_FH(1));
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	ga.bm = &nfsv4_getattrbm;
+	nfs_v4initcompound(&cp);
+
+	nfsm_v4build_compound(&cp, "nfs4_getattr()");
+	nfsm_v4build_putfh(&cp, vp);
+	nfsm_v4build_getattr(&cp, &ga);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(vp, NFSV4PROC_COMPOUND, ap->a_td, ap->a_cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_getattr(&cp, &ga);
+
+	nfs4_vnop_loadattrcache(vp, &ga.fa, ap->a_vap);
+
+nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (mrep != NULL)
+		m_freem(mrep);
+	return (error);
+}
+
+/*
+ * nfs setattr call.
+ */
+static int
+nfs4_setattr(struct vop_setattr_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	struct nfsnode *np = VTONFS(vp);
+	struct vattr *vap = ap->a_vap;
+	int error = 0;
+	u_quad_t tsize;
+
+#ifndef nolint
+	tsize = (u_quad_t)0;
+#endif
+
+	/*
+	 * Setting of flags is not supported.
+	 */
+	if (vap->va_flags != VNOVAL)
+		return (EOPNOTSUPP);
+
+	/*
+	 * Disallow write attempts if the filesystem is mounted read-only.
+	 */
+  	if ((vap->va_flags != VNOVAL || vap->va_uid != (uid_t)VNOVAL ||
+	    vap->va_gid != (gid_t)VNOVAL || vap->va_atime.tv_sec != VNOVAL ||
+	    vap->va_mtime.tv_sec != VNOVAL || vap->va_mode != (mode_t)VNOVAL) &&
+	    (vp->v_mount->mnt_flag & MNT_RDONLY))
+		return (EROFS);
+	if (vap->va_size != VNOVAL) {
+ 		switch (vp->v_type) {
+ 		case VDIR:
+ 			return (EISDIR);
+ 		case VCHR:
+ 		case VBLK:
+ 		case VSOCK:
+ 		case VFIFO:
+			if (vap->va_mtime.tv_sec == VNOVAL &&
+			    vap->va_atime.tv_sec == VNOVAL &&
+			    vap->va_mode == (mode_t)VNOVAL &&
+			    vap->va_uid == (uid_t)VNOVAL &&
+			    vap->va_gid == (gid_t)VNOVAL)
+				return (0);
+ 			vap->va_size = VNOVAL;
+ 			break;
+ 		default:
+			/*
+			 * Disallow write attempts if the filesystem is
+			 * mounted read-only.
+			 */
+			if (vp->v_mount->mnt_flag & MNT_RDONLY)
+				return (EROFS);
+
+			/*
+			 *  We run vnode_pager_setsize() early (why?),
+			 * we must set np->n_size now to avoid vinvalbuf
+			 * V_SAVE races that might setsize a lower
+			 * value.
+			 */
+
+			tsize = np->n_size;
+			error = nfs_meta_setsize(vp, ap->a_cred, 
+						ap->a_td, vap->va_size);
+
+ 			if (np->n_flag & NMODIFIED) {
+ 			    if (vap->va_size == 0)
+ 				error = nfs_vinvalbuf(vp, 0,
+ 					ap->a_cred, ap->a_td, 1);
+ 			    else
+ 				error = nfs_vinvalbuf(vp, V_SAVE,
+ 					ap->a_cred, ap->a_td, 1);
+ 			    if (error) {
+				vnode_pager_setsize(vp, np->n_size);
+ 				return (error);
+			    }
+ 			}
+			/*
+			 * np->n_size has already been set to vap->va_size
+			 * in nfs_meta_setsize(). We must set it again since
+			 * nfs_loadattrcache() could be called through
+			 * nfs_meta_setsize() and could modify np->n_size.
+			 */
+ 			np->n_vattr.va_size = np->n_size = vap->va_size;
+  		};
+  	} else if ((vap->va_mtime.tv_sec != VNOVAL ||
+		vap->va_atime.tv_sec != VNOVAL) && (np->n_flag & NMODIFIED) &&
+		vp->v_type == VREG &&
+  		(error = nfs_vinvalbuf(vp, V_SAVE, ap->a_cred,
+		 ap->a_td, 1)) == EINTR)
+		return (error);
+	error = nfs4_setattrrpc(vp, vap, ap->a_cred, ap->a_td);
+	if (error && vap->va_size != VNOVAL) {
+		np->n_size = np->n_vattr.va_size = tsize;
+		vnode_pager_setsize(vp, np->n_size);
+	}
+	return (error);
+}
+
+/*
+ * Do an nfs setattr rpc.
+ */
+static int
+nfs4_setattrrpc(struct vnode *vp, struct vattr *vap, struct ucred *cred,
+    struct thread *td)
+{
+	caddr_t bpos, dpos;
+	int error = 0;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_getattr ga;
+	struct nfsnode *np = VTONFS(vp);
+	struct nfs4_fctx *fcp = &np->n_wfc;
+
+	nfsstats.rpccnt[NFSPROC_SETATTR]++;
+	mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	ga.bm = &nfsv4_getattrbm;
+	nfs_v4initcompound(&cp);
+
+	nfsm_v4build_compound(&cp, "nfs4_setattrrpc");
+	nfsm_v4build_putfh(&cp, vp);
+	nfsm_v4build_setattr(&cp, vap, fcp);
+	nfsm_v4build_getattr(&cp, &ga);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(vp, NFSV4PROC_COMPOUND, td, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_setattr(&cp);
+	nfsm_v4dissect_getattr(&cp, &ga);
+
+	nfs4_vnop_loadattrcache(vp, &ga.fa, NULL);
+
+	/* XXX -- need to implement this in nfs4_setattr*/
+	if (np->n_flag & NTRUNCATE) {
+		error = nfs4_closerpc(vp, cred, td, FWRITE);
+		np->n_flag &= ~NTRUNCATE;
+	}
+
+nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (mrep != NULL)
+		m_freem(mrep);
+	
+	return (error);
+}
+
+/*
+ * nfs lookup call, one step at a time...
+ * First look in cache
+ * If not found, unlock the directory nfsnode and do the rpc
+ */
+static int
+nfs4_lookup(struct vop_lookup_args *ap)
+{
+	struct componentname *cnp = ap->a_cnp;
+	struct vnode *dvp = ap->a_dvp;
+	struct vnode **vpp = ap->a_vpp;
+	int isdot, flags = cnp->cn_flags;
+	struct vnode *newvp;
+	struct nfsmount *nmp;
+	caddr_t bpos, dpos;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	long len;
+	nfsfh_t *fhp;
+	struct nfsnode *np;
+	int lockparent, wantparent, error = 0, fhsize;
+	struct thread *td = cnp->cn_thread;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_getattr ga, dga;
+	struct nfs4_oparg_lookup l;
+	struct nfs4_oparg_getfh gfh;
+
+	*vpp = NULLVP;
+	cnp->cn_flags &= ~PDIRUNLOCK;
+	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 = VFSTONFS(dvp->v_mount);
+	np = VTONFS(dvp);
+
+	isdot = cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.';
+
+	if ((error = cache_lookup(dvp, vpp, cnp)) && error != ENOENT) {
+		struct vattr vattr;
+		int vpid;
+
+		if ((error = VOP_ACCESS(dvp, VEXEC, cnp->cn_cred, td)) != 0) {
+			*vpp = NULLVP;
+			return (error);
+		}
+
+		vhold(*vpp);
+		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, td);
+			cnp->cn_flags |= PDIRUNLOCK;
+			error = vget(newvp, LK_EXCLUSIVE, td);
+			if (!error && lockparent && (flags & ISLASTCN)) {
+				error = vn_lock(dvp, LK_EXCLUSIVE, td);
+				if (error == 0)
+					cnp->cn_flags &= ~PDIRUNLOCK;
+			}
+		} else {
+			error = vget(newvp, LK_EXCLUSIVE, td);
+			if (!lockparent || error || !(flags & ISLASTCN)) {
+				VOP_UNLOCK(dvp, 0, td);
+				cnp->cn_flags |= PDIRUNLOCK;
+			}
+		}
+		if (!error) {
+			if (vpid == newvp->v_id) {
+			   if (!VOP_GETATTR(newvp, &vattr, cnp->cn_cred, td)
+			    && vattr.va_ctime.tv_sec == VTONFS(newvp)->n_ctime) {
+				nfsstats.lookupcache_hits++;
+				if (cnp->cn_nameiop != LOOKUP &&
+				    (flags & ISLASTCN))
+					cnp->cn_flags |= SAVENAME;
+				vdrop(newvp);
+				return (0);
+			   }
+			   cache_purge(newvp);
+			}
+			vput(newvp);
+			if (lockparent && dvp != newvp && (flags & ISLASTCN))
+				VOP_UNLOCK(dvp, 0, td);
+		}
+		vdrop(newvp);
+		error = vn_lock(dvp, LK_EXCLUSIVE, td);
+		*vpp = NULLVP;
+		if (error) {
+			cnp->cn_flags |= PDIRUNLOCK;
+			return (error);
+		}
+		cnp->cn_flags &= ~PDIRUNLOCK;
+	}
+
+	error = 0;
+	newvp = NULLVP;
+	nfsstats.lookupcache_misses++;
+	nfsstats.rpccnt[NFSPROC_LOOKUP]++;
+
+	len = cnp->cn_namelen;
+	mreq = nfsm_reqhead(NULL, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	ga.bm = &nfsv4_getattrbm;
+	dga.bm = &nfsv4_getattrbm;
+	nfs_v4initcompound(&cp);
+
+	nfsm_v4build_compound(&cp, "nfs4_lookup()");
+	nfsm_v4build_putfh(&cp, dvp);
+	nfsm_v4build_getattr(&cp, &dga);
+	if (flags & ISDOTDOT)
+		nfsm_v4build_lookupp(&cp);
+	else if (!isdot) {
+		l.name = cnp->cn_nameptr;
+		l.namelen = len;
+		nfsm_v4build_lookup(&cp, &l);
+	}
+	nfsm_v4build_getattr(&cp, &ga);
+	nfsm_v4build_getfh(&cp, &gfh);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(dvp, NFSV4PROC_COMPOUND, cnp->cn_thread, cnp->cn_cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_getattr(&cp, &dga);
+	if (flags & ISDOTDOT)
+		nfsm_v4dissect_lookupp(&cp);
+	else if (!isdot)
+		nfsm_v4dissect_lookup(&cp);
+	nfsm_v4dissect_getattr(&cp, &ga);
+	nfsm_v4dissect_getfh(&cp, &gfh);
+
+	nfs4_vnop_loadattrcache(dvp, &dga.fa, NULL);
+	fhp = &gfh.fh_val;
+	fhsize = gfh.fh_len;
+
+	/*
+	 * Handle RENAME case...
+	 */
+	if (cnp->cn_nameiop == RENAME && wantparent && (flags & ISLASTCN)) {
+		if (NFS_CMPFH(np, fhp, fhsize))
+			return (EISDIR);
+
+		error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
+		if (error)
+			return (error);
+
+		newvp = NFSTOV(np);
+
+		nfs4_vnop_loadattrcache(newvp, &ga.fa, NULL);
+
+		*vpp = newvp;
+		cnp->cn_flags |= SAVENAME;
+		if (!lockparent) {
+			VOP_UNLOCK(dvp, 0, td);
+			cnp->cn_flags |= PDIRUNLOCK;
+		}
+		return (0);
+	}
+
+	if (flags & ISDOTDOT) {
+		VOP_UNLOCK(dvp, 0, td);
+
+		error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
+		if (error) {
+			vn_lock(dvp, LK_EXCLUSIVE | LK_RETRY, td);
+			return (error);
+		}
+		newvp = NFSTOV(np);
+
+		nfs4_vnop_loadattrcache(newvp, &ga.fa, NULL);
+
+		if (lockparent && (flags & ISLASTCN)) {
+			error = vn_lock(dvp, LK_EXCLUSIVE, td);
+			if (error) {
+				cnp->cn_flags |= PDIRUNLOCK;
+		    		vput(newvp);
+				return (error);
+			}
+		} else
+			cnp->cn_flags |= PDIRUNLOCK;
+	} else if (NFS_CMPFH(np, fhp, fhsize)) {
+		VREF(dvp);
+		newvp = dvp;
+	} else {
+		error = nfs_nget(dvp->v_mount, fhp, fhsize, &np);
+		if (error)
+			return (error);
+
+		if (!lockparent || !(flags & ISLASTCN)) {
+			cnp->cn_flags |= PDIRUNLOCK;
+			VOP_UNLOCK(dvp, 0, td);
+		}
+		newvp = NFSTOV(np);
+
+		/* Fill in np used by open. */
+		np->n_dvp = dvp;
+		np->n_namelen = cnp->cn_namelen;
+		if (np->n_name != NULL)
+			FREE(np->n_name, M_NFSREQ);
+		MALLOC(np->n_name, u_char *, np->n_namelen + 1, M_NFSREQ, M_WAITOK);
+		bcopy(cnp->cn_nameptr, np->n_name, np->n_namelen);
+		np->n_name[np->n_namelen] = '\0';
+
+		nfs4_vnop_loadattrcache(newvp, &ga.fa, NULL);
+	}
+
+	if (cnp->cn_nameiop != LOOKUP && (flags & ISLASTCN))
+		cnp->cn_flags |= SAVENAME;
+	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);
+	}
+	*vpp = newvp;
+	m_freem(mrep);
+nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	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, td);
+				cnp->cn_flags |= PDIRUNLOCK;
+			}
+			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);
+}
+
+/*
+ * nfs read call.
+ * Just call nfs_bioread() to do the work.
+ */
+static int
+nfs4_read(struct vop_read_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+
+	switch (vp->v_type) {
+	case VREG:
+		return (nfs_bioread(vp, ap->a_uio, ap->a_ioflag, ap->a_cred));
+	case VDIR:
+		return (EISDIR);
+	default:
+		return (EOPNOTSUPP);
+	}
+}
+
+/*
+ * nfs readlink call
+ */
+static int
+nfs4_readlink(struct vop_readlink_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+
+	if (vp->v_type != VLNK)
+		return (EINVAL);
+	return (nfs_bioread(vp, ap->a_uio, 0, ap->a_cred));
+}
+
+/*
+ * Do a readlink rpc.
+ * Called by nfs_doio() from below the buffer cache.
+ */
+int
+nfs4_readlinkrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred)
+{
+	caddr_t bpos, dpos;
+	int error = 0;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfs4_compound cp;
+
+	nfsstats.rpccnt[NFSPROC_READLINK]++;
+
+	mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	nfs_v4initcompound(&cp);
+
+	nfsm_v4build_compound(&cp, "nfs4_readlinkrpc()");
+	nfsm_v4build_putfh(&cp, vp);
+	nfsm_v4build_readlink(&cp);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(vp, NFSV4PROC_COMPOUND, uiop->uio_td, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_readlink(&cp, uiop);
+
+nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (m_freem != NULL)
+		m_freem(mrep);
+	return (error);
+}
+
+/*
+ * nfs read rpc call
+ * Ditto above
+ */
+int
+nfs4_readrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred)
+{
+	caddr_t bpos, dpos;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfsmount *nmp;
+	int error = 0, len, tsiz;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_read read;
+	struct nfsnode *np = VTONFS(vp);
+
+	nmp = VFSTONFS(vp->v_mount);
+	tsiz = uiop->uio_resid;
+	if (uiop->uio_offset + tsiz > nmp->nm_maxfilesize)
+		return (EFBIG);
+
+	if (tsiz == 0)
+		return (0);
+
+	read.uiop = uiop;
+	read.fcp = np->n_rfc.refcnt > 0 ? &np->n_rfc : &np->n_wfc;
+
+	while (tsiz > 0) {
+		nfsstats.rpccnt[NFSPROC_READ]++;
+		len = (tsiz > nmp->nm_rsize) ? nmp->nm_rsize : tsiz;
+
+		read.off = uiop->uio_offset;
+		read.maxcnt = len;
+		nfs_v4initcompound(&cp);
+
+		mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, 0);
+		mb = mreq;
+		bpos = mtod(mb, caddr_t);
+
+		nfsm_v4build_compound(&cp, "nfs4_readrpc()");
+		nfsm_v4build_putfh(&cp, vp);
+		nfsm_v4build_read(&cp, &read);
+		nfsm_v4build_finalize(&cp);
+
+		nfsm_request(vp, NFSV4PROC_COMPOUND, uiop->uio_td, cred);
+		if (error != 0) {
+			error = nfs_v4postop(&cp, error);
+			goto nfsmout;
+		}
+
+		nfsm_v4dissect_compound(&cp);
+		nfsm_v4dissect_putfh(&cp);
+		nfsm_v4dissect_read(&cp, &read);
+
+		if (read.eof || read.retlen == 0)
+			tsiz = 0;
+		else
+			tsiz -= read.retlen;
+
+		error = nfs_v4postop(&cp, error);
+
+		m_freem(mrep);
+		mrep = NULL;
+	}
+nfsmout:
+	if (mrep != NULL)
+		m_freem(mrep);
+	
+	return (error);
+}
+
+/*
+ * nfs write call
+ */
+int
+nfs4_writerpc(struct vnode *vp, struct uio *uiop, struct ucred *cred,
+    int *iomode, int *must_commit)
+{
+	int32_t backup;
+	caddr_t bpos, dpos;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
+	int error = 0, len, tsiz, wccflag = 1, rlen;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_write write;
+	nfsv4stablehow commit, committed = NSHFILESYNC;
+	caddr_t verf;
+	struct nfsnode *np = VTONFS(vp);
+
+#ifndef DIAGNOSTIC
+	if (uiop->uio_iovcnt != 1)
+		panic("nfs: writerpc iovcnt > 1");
+#endif
+	*must_commit = 0;
+	tsiz = uiop->uio_resid;
+	if (uiop->uio_offset + tsiz > nmp->nm_maxfilesize)
+		return (EFBIG);
+
+	if (tsiz == 0)
+		return (0);
+
+	write.stable = (nfsv4stablehow)*iomode;
+	write.uiop = uiop;
+	write.fcp = &np->n_wfc;
+
+	while (tsiz > 0) {
+		nfsstats.rpccnt[NFSPROC_WRITE]++;
+		len = (tsiz > nmp->nm_wsize) ? nmp->nm_wsize : tsiz;
+
+		write.off = uiop->uio_offset;
+		write.cnt = len;
+		nfs_v4initcompound(&cp);
+
+		mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, 0);
+		mb = mreq;
+		bpos = mtod(mb, caddr_t);
+
+		nfsm_v4build_compound(&cp, "nfs4_writerpc()");
+		nfsm_v4build_putfh(&cp, vp);
+		nfsm_v4build_write(&cp, &write);
+		nfsm_v4build_finalize(&cp);
+
+		nfsm_request(vp, NFSV4PROC_COMPOUND, uiop->uio_td, cred);
+		if (error != 0) {
+			error = nfs_v4postop(&cp, error);
+			goto nfsmout;
+		}
+
+		nfsm_v4dissect_compound(&cp);
+		nfsm_v4dissect_putfh(&cp);
+		nfsm_v4dissect_write(&cp, &write);
+
+		rlen = write.retlen;
+		if (rlen == 0) {
+			error = NFSERR_IO;
+			break;
+		} else if (rlen < len) {
+			backup = len - rlen;
+			(char *)uiop->uio_iov->iov_base -= backup;
+			uiop->uio_iov->iov_len += backup;
+                        uiop->uio_offset -= backup;
+                        uiop->uio_resid += backup;
+                        len = rlen;
+		}
+
+		commit = write.committed;
+
+		if (committed == NSHFILESYNC ||
+		    (committed = NSHDATASYNC && commit == NSHUNSTABLE))
+			committed = commit;
+
+		verf = (caddr_t)write.wverf;
+
+                if ((nmp->nm_flag & NFSSTA_HASWRITEVERF) == 0) {
+                        bcopy(verf, nmp->nm_verf, NFSX_V4VERF);
+                        nmp->nm_flag |= NFSMNT_HASWRITEVERF;
+                } else if (bcmp(verf, nmp->nm_verf, NFSX_V4VERF)) {
+                        *must_commit = 1;
+                        bcopy(verf, nmp->nm_verf, NFSX_V4VERF);
+                }
+
+		/* XXX wccflag */
+		if (wccflag)
+			VTONFS(vp)->n_mtime = VTONFS(vp)->n_vattr.va_mtime.tv_sec;
+
+		error = nfs_v4postop(&cp, error);
+
+		m_freem(mrep);
+		mrep = NULL;
+		if (error)
+			break;
+		tsiz -= len;
+	}
+nfsmout:
+	if (mrep != NULL)
+		m_freem(mrep);
+	*iomode = committed;
+	if (error)
+		uiop->uio_resid = tsiz;
+	return (error);
+}
+
+/* ARGSUSED */
+static int
+nfs4_mknod(struct vop_mknod_args *ap)
+{
+	struct vattr *vap = ap->a_vap;
+	struct vnode *newvp = NULL;
+	int error;
+
+	error = nfs4_createrpc(ap->a_dvp, &newvp,
+	    ap->a_cnp, (nfstype)vap->va_type, vap, NULL);
+
+	/* XXX - is this actually referenced here? */
+	if (error == 0) {
+		*ap->a_vpp = newvp;
+		vrele(newvp);
+	}
+
+	return (error);
+}
+
+static int
+nfs4_createrpc(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
+    nfstype ftype, struct vattr *vap, char *linktarget)
+{
+	struct nfsnode *dnp = VTONFS(dvp);
+	struct nfsnode *np = NULL;
+	struct vnode *newvp = NULL;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_create c;
+	struct nfs4_oparg_getattr ga;
+	struct nfs4_oparg_getfh gfh;
+	caddr_t bpos, dpos;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	int error = 0;
+
+	nfsstats.rpccnt[NFSPROC_CREATE]++;
+
+	mreq = nfsm_reqhead(dvp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	bzero(&c, sizeof(c));
+	bzero(&ga, sizeof(ga));
+
+	c.type = ftype;
+	c.vap = vap;
+	c.linktext = linktarget;
+	c.name = cnp->cn_nameptr;
+	c.namelen = cnp->cn_namelen;
+
+	ga.bm = &nfsv4_getattrbm;
+	nfs_v4initcompound(&cp);
+
+	nfsm_v4build_compound(&cp, "nfs4_createrpc()");
+	nfsm_v4build_putfh(&cp, dvp);
+	nfsm_v4build_create(&cp, &c);
+	nfsm_v4build_getattr(&cp, &ga);
+	nfsm_v4build_getfh(&cp, &gfh);	
+	nfsm_v4build_finalize(&cp); 
+
+	nfsm_request(dvp, NFSV4PROC_COMPOUND, cnp->cn_thread, cnp->cn_cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_create(&cp, &c);
+	nfsm_v4dissect_getattr(&cp, &ga);
+	nfsm_v4dissect_getfh(&cp, &gfh);	
+	
+	error = nfs_nget(dvp->v_mount, &gfh.fh_val, gfh.fh_len, &np);
+	if (error != 0)
+		goto nfsmout;
+
+	newvp = NFSTOV(np);
+	nfs4_vnop_loadattrcache(newvp, &ga.fa, NULL);
+
+	if (cnp->cn_flags & MAKEENTRY)
+		cache_enter(dvp, newvp, cnp);
+
+	dnp->n_flag |= NMODIFIED;
+	dnp->n_attrstamp = 0;
+
+ nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (mrep != NULL)
+		m_freem(mrep);
+
+	/* XXX */
+	/*FREE(cnp->cn_pnbuf, M_NAMEI);*/
+	if (error != 0 && newvp != NULL)
+		vrele(newvp);
+	else if (error == 0)
+		*vpp = newvp;
+
+	return (error);
+}
+
+static int
+nfs4_renamerpc(struct vnode *fdvp, const char *fnameptr, int fnamelen,
+    struct vnode *tdvp, const char *tnameptr, int tnamelen,
+    struct ucred *cred, struct thread *td)
+{
+
+	struct nfsnode *fnp = VTONFS(fdvp), *tnp = VTONFS(tdvp);
+	caddr_t bpos, dpos;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_rename r;
+	int error = 0;
+
+	nfsstats.rpccnt[NFSPROC_RENAME]++;
+
+	r.fname = fnameptr;
+	r.fnamelen = fnamelen;
+	r.tname = tnameptr;
+	r.tnamelen = tnamelen;
+	nfs_v4initcompound(&cp);
+
+	mreq = nfsm_reqhead(fdvp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	nfsm_v4build_compound(&cp, "nfs4_renamerpc()");
+	nfsm_v4build_putfh(&cp, fdvp);
+	nfsm_v4build_savefh(&cp);
+	nfsm_v4build_putfh(&cp, tdvp);
+	nfsm_v4build_rename(&cp, &r);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(fdvp, NFSV4PROC_COMPOUND, td, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_savefh(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_rename(&cp);
+
+	/* XXX should this always be performed?  */
+	fnp->n_flag |= NMODIFIED;
+	tnp->n_flag |= NMODIFIED;
+	fnp->n_attrstamp = tnp->n_attrstamp = 0;
+
+ nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (mrep != NULL)
+		m_freem(mrep);
+
+	return (error);
+}
+
+/*
+ * nfs file create call
+ */
+static int
+nfs4_create(struct vop_create_args *ap)
+{
+	struct vnode *dvp = ap->a_dvp;
+	struct vattr *vap = ap->a_vap;
+	struct nfsnode *dnp = VTONFS(dvp);
+	struct componentname *cnp = ap->a_cnp;
+	struct vnode *newvp = NULL;
+	int error = 0, fmode = (O_CREAT | FREAD | FWRITE);
+	struct vattr vattr;
+
+	if ((error = VOP_GETATTR(dvp, &vattr, cnp->cn_cred, cnp->cn_thread)) != 0)
+		return (error);
+
+	if (vap->va_vaflags & VA_EXCLUSIVE)
+		fmode |= O_EXCL;
+
+	error = nfs4_openrpc(dvp, &newvp, cnp, fmode, vap);
+	if (error != 0)
+		goto out;
+
+	VTONFS(newvp)->n_flag |= NCREATED;
+
+	if (cnp->cn_flags & MAKEENTRY)
+		cache_enter(dvp, newvp, cnp);
+
+	*ap->a_vpp = newvp;
+
+	dnp->n_flag |= NMODIFIED;
+	dnp->n_attrstamp = 0;	/* XXX; wccflag */
+
+ out:
+	return (error);
+}
+
+/*
+ * nfs file remove call
+ * To try and make nfs 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 nfs4_sillyrename() to set it up
+ *     else
+ *	  do the remove rpc
+ */
+static int
+nfs4_remove(struct vop_remove_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	struct vnode *dvp = ap->a_dvp;
+	struct componentname *cnp = ap->a_cnp;
+	struct nfsnode *np = VTONFS(vp);
+	int error = 0;
+	struct vattr vattr;
+
+#ifndef DIAGNOSTIC
+	if ((cnp->cn_flags & HASBUF) == 0)
+		panic("nfs4_remove: no name");
+	if (vrefcnt(vp) < 1)
+		panic("nfs4_remove: bad v_usecount");
+#endif
+	if (vp->v_type == VDIR)
+		error = EPERM;
+	else if (vrefcnt(vp) == 1 || (np->n_sillyrename &&
+	    VOP_GETATTR(vp, &vattr, cnp->cn_cred, cnp->cn_thread) == 0 &&
+	    vattr.va_nlink > 1)) {
+		/*
+		 * Purge the name cache so that the chance of a lookup for
+		 * the name succeeding while the remove is in progress is
+		 * minimized. Without node locking it can still happen, such
+		 * that an I/O op returns ESTALE, but since you get this if
+		 * another host removes the file..
+		 */
+		cache_purge(vp);
+		/*
+		 * throw away biocache buffers, mainly to avoid
+		 * unnecessary delayed writes later.
+		 */
+		error = nfs_vinvalbuf(vp, 0, cnp->cn_cred, cnp->cn_thread, 1);
+		/* Do the rpc */
+		if (error != EINTR)
+			error = nfs4_removerpc(dvp, cnp->cn_nameptr,
+				cnp->cn_namelen, cnp->cn_cred, cnp->cn_thread);
+		/*
+		 * Kludge City: If the first reply to the remove rpc is lost..
+		 *   the reply to the retransmitted request will be ENOENT
+		 *   since the file was in fact removed
+		 *   Therefore, we cheat and return success.
+		 */
+		if (error == ENOENT)
+			error = 0;
+	} else if (!np->n_sillyrename)
+		error = nfs4_sillyrename(dvp, vp, cnp);
+	np->n_attrstamp = 0;
+	return (error);
+}
+
+/*
+ * nfs file remove rpc called from nfs_inactive
+ */
+int
+nfs4_removeit(struct sillyrename *sp)
+{
+	/*
+	 * Make sure that the directory vnode is still valid.
+	 * XXX we should lock sp->s_dvp here.
+	 */
+	if (sp->s_dvp->v_type == VBAD)
+		return (0);
+	return (nfs4_removerpc(sp->s_dvp, sp->s_name, sp->s_namlen, sp->s_cred,
+		NULL));
+}
+
+/*
+ * Nfs remove rpc, called from nfs4_remove() and nfs4_removeit().
+ */
+static int
+nfs4_removerpc(struct vnode *dvp, const char *name, int namelen,
+    struct ucred *cred, struct thread *td)
+{
+	caddr_t bpos, dpos;
+	int error = 0;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfs4_compound cp;
+
+	nfsstats.rpccnt[NFSPROC_REMOVE]++;
+
+	mreq = nfsm_reqhead(dvp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	nfs_v4initcompound(&cp);
+
+	nfsm_v4build_compound(&cp, "nfs4_removerpc()");
+	nfsm_v4build_putfh(&cp, dvp);
+	nfsm_v4build_remove(&cp, name, namelen);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(dvp, NFSV4PROC_COMPOUND, td, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_remove(&cp);
+
+ nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (mrep != NULL)
+		m_freem(mrep);
+
+	VTONFS(dvp)->n_flag |= NMODIFIED;
+	VTONFS(dvp)->n_attrstamp = 0; /* XXX wccflag */
+
+	return (error);
+}
+
+/*
+ * nfs file rename call
+ */
+static int
+nfs4_rename(struct vop_rename_args *ap)
+{
+	struct vnode *fvp = ap->a_fvp;
+	struct vnode *tvp = ap->a_tvp;
+	struct vnode *fdvp = ap->a_fdvp;
+	struct vnode *tdvp = ap->a_tdvp;
+	struct componentname *tcnp = ap->a_tcnp;
+	struct componentname *fcnp = ap->a_fcnp;
+	int error;
+
+ #ifndef DIAGNOSTIC
+	if ((tcnp->cn_flags & HASBUF) == 0 ||
+	    (fcnp->cn_flags & HASBUF) == 0)
+		panic("nfs4_rename: no name");
+#endif
+	/* Check for cross-device rename */
+	if ((fvp->v_mount != tdvp->v_mount) ||
+	    (tvp && (fvp->v_mount != tvp->v_mount))) {
+		error = EXDEV;
+		goto out;
+	}
+
+	if (fvp == tvp) {
+		printf("nfs4_rename: fvp == tvp (can't happen)\n");
+		error = 0;
+		goto out;
+	}
+	if ((error = vn_lock(fvp, LK_EXCLUSIVE, fcnp->cn_thread)) != 0)
+		goto out;
+
+	/*
+	 * We have to flush B_DELWRI data prior to renaming
+	 * the file.  If we don't, the delayed-write buffers
+	 * can be flushed out later after the file has gone stale
+	 * under NFSV3.  NFSV2 does not have this problem because
+	 * ( as far as I can tell ) it flushes dirty buffers more
+	 * often.
+	 */
+	VOP_FSYNC(fvp, fcnp->cn_cred, MNT_WAIT, fcnp->cn_thread);
+	VOP_UNLOCK(fvp, 0, fcnp->cn_thread);
+	if (tvp)
+	    VOP_FSYNC(tvp, tcnp->cn_cred, MNT_WAIT, tcnp->cn_thread);
+
+	/*
+	 * If the tvp exists and is in use, sillyrename it before doing the
+	 * rename of the new file over it.
+	 * XXX Can't sillyrename a directory.
+	 */
+	if (tvp && vrefcnt(tvp) > 1 && !VTONFS(tvp)->n_sillyrename &&
+		tvp->v_type != VDIR && !nfs4_sillyrename(tdvp, tvp, tcnp)) {
+		vput(tvp);
+		tvp = NULL;
+	}
+
+	error = nfs4_renamerpc(fdvp, fcnp->cn_nameptr, fcnp->cn_namelen,
+		tdvp, tcnp->cn_nameptr, tcnp->cn_namelen, tcnp->cn_cred,
+		tcnp->cn_thread);
+
+	if (fvp->v_type == VDIR) {
+		if (tvp != NULL && tvp->v_type == VDIR)
+			cache_purge(tdvp);
+		cache_purge(fdvp);
+	}
+
+out:
+	if (tdvp == tvp)
+		vrele(tdvp);
+	else
+		vput(tdvp);
+	if (tvp)
+		vput(tvp);
+	vrele(fdvp);
+	vrele(fvp);
+	/*
+	 * Kludge: Map ENOENT => 0 assuming that it is a reply to a retry.
+	 */
+	if (error == ENOENT)
+		error = 0;
+	return (error);
+}
+
+/*
+ * nfs file rename rpc called from nfs4_remove() above
+ */
+static int
+nfs4_renameit(struct vnode *sdvp, struct componentname *scnp,
+    struct sillyrename *sp)
+{
+	return (nfs4_renamerpc(sdvp, scnp->cn_nameptr, scnp->cn_namelen, sdvp,
+	    sp->s_name, sp->s_namlen, scnp->cn_cred, scnp->cn_thread));
+}
+
+/*
+ * nfs hard link create call
+ */
+static int
+nfs4_link(struct vop_link_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	struct vnode *tdvp = ap->a_tdvp;
+	struct componentname *cnp = ap->a_cnp;
+	caddr_t bpos, dpos;
+	int error = 0;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_link l;
+
+	if (vp->v_mount != tdvp->v_mount) {
+		return (EXDEV);
+	}
+
+	/*
+	 * Push all writes to the server, so that the attribute cache
+	 * doesn't get "out of sync" with the server.
+	 * XXX There should be a better way!
+	 */
+	VOP_FSYNC(vp, cnp->cn_cred, MNT_WAIT, cnp->cn_thread);
+
+	nfsstats.rpccnt[NFSPROC_LINK]++;
+
+	l.name = cnp->cn_nameptr;
+	l.namelen = cnp->cn_namelen;
+	nfs_v4initcompound(&cp);
+
+	mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	nfsm_v4build_compound(&cp, "nfs4_link()");
+	nfsm_v4build_putfh(&cp, vp);
+	nfsm_v4build_savefh(&cp);
+	nfsm_v4build_putfh(&cp, tdvp);
+	nfsm_v4build_link(&cp, &l);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(vp, NFSV4PROC_COMPOUND, cnp->cn_thread, cnp->cn_cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_savefh(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_link(&cp);
+
+	VTONFS(tdvp)->n_flag |= NMODIFIED;
+	VTONFS(vp)->n_attrstamp = 0;
+	VTONFS(tdvp)->n_attrstamp = 0;
+
+nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (mrep != NULL)
+		m_freem(mrep);
+
+	return (error);
+}
+
+/*
+ * nfs symbolic link create call
+ */
+static int
+nfs4_symlink(struct vop_symlink_args *ap)
+{
+	struct vnode *dvp = ap->a_dvp;
+	int error = 0;
+	struct vnode *newvp = NULL;
+
+	nfsstats.rpccnt[NFSPROC_SYMLINK]++;
+
+	error = nfs4_createrpc(ap->a_dvp, &newvp, ap->a_cnp, NFLNK,
+	    ap->a_vap, ap->a_target);
+
+	if (error != 0 && newvp != NULL)
+		vput(newvp);
+	else if (error == 0)
+		 *ap->a_vpp = newvp;
+
+	VTONFS(dvp)->n_flag |= NMODIFIED;
+	VTONFS(dvp)->n_attrstamp = 0; /* XXX wccflags */
+
+	return (error);
+}
+
+/*
+ * nfs make dir call
+ */
+static int
+nfs4_mkdir(struct vop_mkdir_args *ap)
+{
+	return (nfs4_createrpc(ap->a_dvp, ap->a_vpp, ap->a_cnp, NFDIR,
+		    ap->a_vap, NULL));
+}
+
+/*
+ * nfs remove directory call
+ */
+static int
+nfs4_rmdir(struct vop_rmdir_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	struct vnode *dvp = ap->a_dvp;
+	struct nfsnode *dnp = VTONFS(dvp);
+	struct componentname *cnp = ap->a_cnp;
+	int error = 0;
+
+	if (dvp == vp)
+		return (EINVAL);
+
+	error = (nfs4_removerpc(dvp, cnp->cn_nameptr, cnp->cn_namelen, cnp->cn_cred,
+			       NULL));
+	if (error)
+		return (error);
+
+	dnp->n_flag |= NMODIFIED;
+	dnp->n_attrstamp = 0;
+	cache_purge(dvp);
+	cache_purge(vp);
+
+	return (error);
+}
+
+/*
+ * nfs readdir call
+ */
+static int
+nfs4_readdir(struct vop_readdir_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	struct nfsnode *np = VTONFS(vp);
+	struct uio *uio = ap->a_uio;
+	int tresid, error;
+	struct vattr vattr;
+
+	if (vp->v_type != VDIR)
+		return (EPERM);
+	/*
+	 * First, check for hit on the EOF offset cache
+	 */
+	if (np->n_direofoffset > 0 && uio->uio_offset >= np->n_direofoffset &&
+	    (np->n_flag & NMODIFIED) == 0) {
+		if (VOP_GETATTR(vp, &vattr, ap->a_cred, uio->uio_td) == 0 &&
+			np->n_mtime == vattr.va_mtime.tv_sec) {
+			nfsstats.direofcache_hits++;
+			return (0);
+		}
+	}
+
+	/*
+	 * Call nfs_bioread() to do the real work.
+	 */
+	tresid = uio->uio_resid;
+	error = nfs_bioread(vp, uio, 0, ap->a_cred);
+
+	if (!error && uio->uio_resid == tresid)
+		nfsstats.direofcache_misses++;
+	return (error);
+}
+
+static u_char fty_to_dty[] = {
+	DT_UNKNOWN,		/* NFNON */
+	DT_REG,			/* NFREG */
+	DT_DIR,			/* NFDIR */
+	DT_BLK,			/* NFBLK */
+	DT_CHR,			/* NFCHR */
+	DT_LNK,			/* NFLNK */
+	DT_SOCK,		/* NFSOCK */
+	DT_FIFO,		/* NFFIFO */
+        DT_UNKNOWN,		/* NFATTRDIT */
+        DT_UNKNOWN,		/* NFNAMEDATTR */
+        DT_UNKNOWN,		/* NFBAD */
+};
+
+/*
+ * Readdir rpc call.
+ * Called from below the buffer cache by nfs_doio().
+ */
+int
+nfs4_readdirrpc(struct vnode *vp, struct uio *uiop, struct ucred *cred)
+{
+	int len, left;
+	struct dirent *dp = NULL;
+	u_int32_t *tl;
+	caddr_t p;
+	uint64_t *cookiep;
+	caddr_t bpos, dpos;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	uint64_t cookie;
+	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
+	struct nfsnode *dnp = VTONFS(vp);
+	int error = 0, tlen, more_dirs = 1, blksiz = 0, bigenough = 1;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_readdir readdir;
+	struct nfsv4_fattr fattr;
+	u_int fty;
+
+#ifndef DIAGNOSTIC
+	if (uiop->uio_iovcnt != 1 || (uiop->uio_offset & (DIRBLKSIZ - 1)) ||
+		(uiop->uio_resid & (DIRBLKSIZ - 1)))
+		panic("nfs readdirrpc bad uio");
+#endif
+
+	/*
+	 * If there is no cookie, assume directory was stale.
+	 */
+	cookiep = nfs4_getcookie(dnp, uiop->uio_offset, 0);
+	if (cookiep)
+		cookie = *cookiep;
+	else
+		return (NFSERR_BAD_COOKIE);
+
+	/* Generate fake entries for "." and ".." */
+	while (cookie < 2 && bigenough) {
+		cookie++;
+		len = 4 + DIRHDSIZ;
+
+		if (len > uiop->uio_resid) {
+			bigenough = 0;
+			break;
+		}
+		dp = (struct dirent *)uiop->uio_iov->iov_base;
+
+		dp->d_namlen = cookie;
+		dp->d_reclen = len;
+		dp->d_type = DT_DIR;
+		if (cookie == 1)
+			dp->d_fileno = dnp->n_vattr.va_fileid; /* XXX has problems with pynfs virtualhandles */
+		else
+			dp->d_fileno = dnp->n_dvp != NULL ?
+			    VTONFS(dnp->n_dvp)->n_vattr.va_fileid : cookie;
+
+		p = dp->d_name;
+		*p++ = '.';
+		if (cookie == 2)
+			*p++ = '.';
+		*p = '\0';
+
+		blksiz += len;
+		if (blksiz == DIRBLKSIZ)
+			blksiz = 0;
+		uiop->uio_offset += len;
+		uiop->uio_resid -= len;
+		(char *)uiop->uio_iov->iov_base += len;
+		uiop->uio_iov->iov_len -= len;
+	}
+
+	if (cookie == 2)
+		cookie = 0;
+
+	/* This is sort of ugly, to prevent v4postop() from acting weird */
+	bzero(&cp, sizeof(cp));
+
+	/*
+	 * Loop around doing readdir rpc's of size nm_readdirsize
+	 * truncated to a multiple of DIRBLKSIZ.
+	 * The stopping criteria is EOF or buffer full.
+	 */
+	/*
+	 * XXX this is sort of ugly for nfsv4; we don't maintain the
+	 * strict abstraction, but do the decoding inline.  that's ok.
+	 */
+	while (more_dirs && bigenough) {
+		nfsstats.rpccnt[NFSPROC_READDIR]++;
+
+		mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, 0);
+		mb = mreq;
+		bpos = mtod(mb, caddr_t);
+
+		readdir.cnt = nmp->nm_readdirsize;
+		readdir.cookie = cookie;
+		readdir.bm = &nfsv4_readdirbm;
+		if (cookie == 0)
+			bzero(&readdir.verf, sizeof(readdir.verf));
+		else
+			bcopy(&dnp->n_cookieverf, &readdir.verf,
+			    sizeof(readdir.verf));
+
+		nfs_v4initcompound(&cp);
+
+		nfsm_v4build_compound(&cp, "nfs4_readdirrpc()");
+		nfsm_v4build_putfh(&cp, vp);
+		nfsm_v4build_readdir(&cp, &readdir);
+		nfsm_v4build_finalize(&cp);
+
+		nfsm_request(vp, NFSV4PROC_COMPOUND, uiop->uio_td, cred);
+		if (error != 0)
+			goto nfsmout;
+
+		nfsm_v4dissect_compound(&cp);
+		nfsm_v4dissect_putfh(&cp);
+
+		/*
+		 * XXX - Readdir gets handled inline like in
+		 * NFSv{2,3}.  This is a nasty inconsistency and
+		 * should be fixed.
+		 */
+
+		tl = nfsm_dissect(uint32_t *, 5 * NFSX_UNSIGNED);
+		if (fxdr_unsigned(uint32_t, *tl++) != NFSV4OP_READDIR) {
+			error = EBADRPC;
+			goto nfsmout;
+		}
+		if (fxdr_unsigned(uint32_t, *tl++) != 0) {
+			error = EBADRPC;
+			goto nfsmout;
+		}
+
+		bcopy(tl, &dnp->n_cookieverf, NFSX_V4VERF);
+		tl += 2;
+		more_dirs = fxdr_unsigned(int, *tl++);
+
+		/* loop thru the dir entries, doctoring them to 4bsd form */
+		while (more_dirs && bigenough) {
+			tl = nfsm_dissect(uint32_t *, 3 * NFSX_UNSIGNED);
+			cookie = fxdr_hyper(tl);
+			tl += 2;
+			/* XXX cookie sanity check */
+			len = fxdr_unsigned(int, *tl++);
+			if (len <= 0 || len > NFS_MAXNAMLEN) {
+				error = EBADRPC;
+				goto nfsmout;
+			}
+			tlen = nfsm_rndup(len);
+			if (tlen == len)
+				tlen += 4;	/* To ensure null termination */
+			left = DIRBLKSIZ - blksiz;
+			if ((tlen + DIRHDSIZ) > left) {
+				dp->d_reclen += left;
+				uiop->uio_iov->iov_base =
+				    (char *)uiop->uio_iov->iov_base + left;
+				uiop->uio_iov->iov_len -= left;
+				uiop->uio_offset += left;
+				uiop->uio_resid -= left;
+				blksiz = 0;
+			}
+			if ((tlen + DIRHDSIZ) > uiop->uio_resid)
+				bigenough = 0;
+			if (bigenough) {
+				dp = (struct dirent *)uiop->uio_iov->iov_base;
+
+				dp->d_namlen = len;
+				dp->d_reclen = tlen + DIRHDSIZ;
+
+				blksiz += dp->d_reclen;
+				if (blksiz == DIRBLKSIZ)
+					blksiz = 0;
+				uiop->uio_offset += DIRHDSIZ;
+				uiop->uio_resid -= DIRHDSIZ;
+				uiop->uio_iov->iov_base =
+				    (char *)uiop->uio_iov->iov_base + DIRHDSIZ;
+				uiop->uio_iov->iov_len -= DIRHDSIZ;
+
+				/* Copy name */
+				nfsm_mtouio(uiop, len);
+				p = uiop->uio_iov->iov_base;
+				tlen -= len;
+				*p = '\0';	/* null terminate */
+				/* printf("nfs4_readdirrpc: name: \"%s\" cookie %d\n",
+				   p - len, (int) cookie);*/
+				uiop->uio_iov->iov_base =
+				    (char *)uiop->uio_iov->iov_base + tlen;
+				uiop->uio_iov->iov_len -= tlen;
+				uiop->uio_offset += tlen;
+				uiop->uio_resid -= tlen;
+
+				/* Copy attributes */
+				nfsm_v4dissect_attrs(&fattr);
+
+				dp->d_fileno = nfs_v4fileid4_to_fileid(
+					fattr.fa4_valid & FA4V_FILEID &&
+					    fattr.fa4_fileid ?
+					    fattr.fa4_fileid : cookie);
+
+				fty = (u_int)fattr.fa4_type;
+				dp->d_type = fattr.fa4_valid & FA4V_TYPE &&
+				    (fty < sizeof(fty_to_dty)) ?
+				    fty_to_dty[fty] : DT_UNKNOWN;
+			} else
+				nfsm_adv(nfsm_rndup(len));
+
+			tl = nfsm_dissect(uint32_t *, NFSX_UNSIGNED);
+			more_dirs = fxdr_unsigned(int, *tl++);
+		}
+		/*
+		 * If at end of rpc data, get the eof boolean
+		 */
+		if (!more_dirs) {
+			tl = nfsm_dissect(u_int32_t *, NFSX_UNSIGNED);
+			more_dirs = (fxdr_unsigned(int, *tl) == 0);
+		}
+
+		error = nfs_v4postop(&cp, error);
+
+		m_freem(mrep);
+		mrep = NULL;
+	}
+	/*
+	 * Fill last record, iff any, out to a multiple of DIRBLKSIZ
+	 * by increasing d_reclen for the last record.
+	 */
+	if (blksiz > 0) {
+		left = DIRBLKSIZ - blksiz;
+		dp->d_reclen += left;
+		uiop->uio_iov->iov_base =
+		    (char *)uiop->uio_iov->iov_base + left;
+		uiop->uio_iov->iov_len -= left;
+		uiop->uio_offset += left;
+		uiop->uio_resid -= left;
+	}
+
+	/*
+	 * We are now either at the end of the directory or have filled the
+	 * block.
+	 */
+	if (bigenough)
+		dnp->n_direofoffset = uiop->uio_offset;
+	else {
+		if (uiop->uio_resid > 0)
+			printf("EEK! readdirrpc resid > 0\n");
+		cookiep = nfs4_getcookie(dnp, uiop->uio_offset, 1);
+		*cookiep = cookie;
+	}
+nfsmout:
+	if (mrep != NULL)
+		m_freem(mrep);
+	return (error);
+}
+
+/*
+ * Silly rename. To make the NFS filesystem that is stateless look a little
+ * more like the "ufs" a remove of an active vnode is translated to a rename
+ * to a funny looking filename that is removed by nfs_inactive on the
+ * nfsnode. There is the potential for another process on a different client
+ * to create the same funny name between the nfs_lookitup() fails and the
+ * nfs_rename() completes, but...
+ */
+static int
+nfs4_sillyrename(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
+{
+	struct sillyrename *sp;
+	struct nfsnode *np;
+	int error;
+	short pid;
+
+	cache_purge(dvp);
+	np = VTONFS(vp);
+#ifndef DIAGNOSTIC
+	if (vp->v_type == VDIR)
+		panic("nfs: sillyrename dir");
+#endif
+	MALLOC(sp, struct sillyrename *, sizeof (struct sillyrename),
+		M_NFSREQ, M_WAITOK);
+	sp->s_cred = crhold(cnp->cn_cred);
+	sp->s_dvp = dvp;
+	sp->s_removeit = nfs4_removeit;
+	VREF(dvp);
+
+	/* Fudge together a funny name */
+	pid = cnp->cn_thread->td_proc->p_pid;
+	sp->s_namlen = sprintf(sp->s_name, ".nfsA%04x4.4", pid);
+
+	/* Try lookitups until we get one that isn't there */
+	while (nfs4_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
+		cnp->cn_thread, NULL) == 0) {
+		sp->s_name[4]++;
+		if (sp->s_name[4] > 'z') {
+			error = EINVAL;
+			goto bad;
+		}
+	}
+	error = nfs4_renameit(dvp, cnp, sp);
+	if (error)
+		goto bad;
+	error = nfs4_lookitup(dvp, sp->s_name, sp->s_namlen, sp->s_cred,
+		cnp->cn_thread, &np);
+	np->n_sillyrename = sp;
+	return (0);
+bad:
+	vrele(sp->s_dvp);
+	crfree(sp->s_cred);
+	free((caddr_t)sp, M_NFSREQ);
+	return (error);
+}
+
+/*
+ * Look up a file name and optionally either update the file handle or
+ * allocate an nfsnode, depending on the value of npp.
+ * npp == NULL	--> just do the lookup
+ * *npp == NULL --> allocate a new nfsnode and make sure attributes are
+ *			handled too
+ * *npp != NULL --> update the file handle in the vnode
+ */
+static int
+nfs4_lookitup(struct vnode *dvp, const char *name, int len, struct ucred *cred,
+    struct thread *td, struct nfsnode **npp)
+{
+	struct vnode *newvp = NULL;
+	struct nfsnode *np, *dnp = VTONFS(dvp);
+	caddr_t bpos, dpos;
+	int error = 0, fhlen;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	nfsfh_t *nfhp;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_lookup l;
+	struct nfs4_oparg_getfh gfh;
+	struct nfs4_oparg_getattr ga;
+
+	nfsstats.rpccnt[NFSPROC_RENAME]++;
+
+	mreq = nfsm_reqhead(dvp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	l.name = name;
+	l.namelen = len;
+
+	nfs_v4initcompound(&cp);
+
+	ga.bm = &nfsv4_getattrbm;
+
+	nfsm_v4build_compound(&cp, "nfs4_renamerpc()");
+	nfsm_v4build_putfh(&cp, dvp);
+	nfsm_v4build_lookup(&cp, &l);
+	nfsm_v4build_getfh(&cp, &gfh);
+	nfsm_v4build_getattr(&cp, &ga);
+
+	nfsm_request(dvp, NFSV4PROC_COMPOUND, td, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_lookup(&cp);
+	nfsm_v4dissect_getfh(&cp, &gfh);
+	nfsm_v4dissect_getattr(&cp, &ga);
+
+	if (npp != NULL && error == 0) {
+		nfhp = &gfh.fh_val;
+		fhlen = gfh.fh_len;
+
+		if (*npp != NULL) {
+			np = *npp;
+			if (np->n_fhsize > NFS_SMALLFH && fhlen <= NFS_SMALLFH) {
+				free((caddr_t)np->n_fhp, M_NFSBIGFH);
+				np->n_fhp = &np->n_fh;
+			} else if (np->n_fhsize <= NFS_SMALLFH && fhlen>NFS_SMALLFH)
+				np->n_fhp =(nfsfh_t *)malloc(fhlen, M_NFSBIGFH, M_WAITOK);
+			bcopy((caddr_t)nfhp, (caddr_t)np->n_fhp, fhlen);
+			np->n_fhsize = fhlen;
+			newvp = NFSTOV(np);
+		} else if (NFS_CMPFH(dnp, nfhp, fhlen)) {
+			VREF(dvp);
+			newvp = dvp;
+		} else {
+			error = nfs_nget(dvp->v_mount, nfhp, fhlen, &np);
+			if (error) {
+				m_freem(mrep);
+				return (error);
+			}
+			newvp = NFSTOV(np);
+		}
+
+		if (newvp != dvp) {
+			np->n_dvp = dvp;
+			np->n_namelen = len;
+			if (np->n_name != NULL)
+				FREE(np->n_name, M_NFSREQ);
+			MALLOC(np->n_name, u_char *,
+			    np->n_namelen + 1, M_NFSREQ, M_WAITOK);
+			memcpy(np->n_name, name, len);
+			np->n_name[len] = '\0';
+		}
+		nfs4_vnop_loadattrcache(newvp, &ga.fa, NULL);
+	}
+
+nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (mrep != NULL)
+		m_freem(mrep);
+	if (npp && *npp == NULL) {
+		if (error) {
+			if (newvp) {
+				if (newvp == dvp)
+					vrele(newvp);
+				else
+					vput(newvp);
+			}
+		} else
+			*npp = np;
+	}
+
+
+	return (error);
+}
+
+/*
+ * Nfs Version 3 commit rpc
+ */
+int
+nfs4_commit(struct vnode *vp, u_quad_t offset, int cnt, struct ucred *cred,
+    struct thread *td)
+{
+	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
+	caddr_t bpos, dpos;
+	int error = 0;
+	struct mbuf *mreq, *mrep = NULL, *md, *mb;
+	struct nfs4_compound cp;
+	struct nfs4_oparg_commit commit;
+
+	if ((nmp->nm_state & NFSSTA_HASWRITEVERF) == 0)
+		return (0);
+	nfsstats.rpccnt[NFSPROC_COMMIT]++;
+
+	mreq = nfsm_reqhead(vp, NFSV4PROC_COMPOUND, 0);
+	mb = mreq;
+	bpos = mtod(mb, caddr_t);
+
+	commit.start = offset;
+	commit.len = cnt;
+
+	nfs_v4initcompound(&cp);
+
+	nfsm_v4build_compound(&cp, "nfs4_commit()");
+	nfsm_v4build_putfh(&cp, vp);
+	nfsm_v4build_commit(&cp, &commit);
+	nfsm_v4build_finalize(&cp);
+
+	nfsm_request(vp, NFSV4PROC_COMPOUND, td, cred);
+	if (error != 0)
+		goto nfsmout;
+
+	nfsm_v4dissect_compound(&cp);
+	nfsm_v4dissect_putfh(&cp);
+	nfsm_v4dissect_commit(&cp, &commit);
+	
+	/* XXX */
+	/* nfsm_wcc_data(vp, wccflag);*/
+	if (bcmp(nmp->nm_verf, commit.verf, NFSX_V4VERF)) {
+		bcopy(commit.verf, nmp->nm_verf, NFSX_V4VERF);
+		error = NFSERR_STALEWRITEVERF;
+	}
+
+nfsmout:
+	error = nfs_v4postop(&cp, error);
+
+	if (mrep == NULL)
+		m_freem(mrep);
+	return (error);
+}
+
+/*
+ * Strategy routine.
+ * For async requests when nfsiod(s) are running, queue the request by
+ * calling nfs_asyncio(), otherwise just all nfs_doio() to do the
+ * request.
+ */
+static int
+nfs4_strategy(struct vop_strategy_args *ap)
+{
+	struct buf *bp = ap->a_bp;
+	struct ucred *cr;
+	struct thread *td;
+	int error = 0;
+
+	KASSERT(ap->a_vp == ap->a_bp->b_vp, ("%s(%p != %p)",
+	    __func__, ap->a_vp, ap->a_bp->b_vp));
+	KASSERT(!(bp->b_flags & B_DONE), ("nfs4_strategy: buffer %p unexpectedly marked B_DONE", bp));
+	KASSERT(BUF_REFCNT(bp) > 0, ("nfs4_strategy: buffer %p not locked", bp));
+
+	if (bp->b_flags & B_ASYNC)
+		td = NULL;
+	else
+		td = curthread;	/* XXX */
+
+	if (bp->b_iocmd == BIO_READ)
+		cr = bp->b_rcred;
+	else
+		cr = bp->b_wcred;
+
+	/*
+	 * If the op is asynchronous and an i/o daemon is waiting
+	 * queue the request, wake it up and wait for completion
+	 * otherwise just do it ourselves.
+	 */
+	if ((bp->b_flags & B_ASYNC) == 0 ||
+		nfs_asyncio(bp, NOCRED, td))
+		error = nfs_doio(bp, cr, td);
+	return (error);
+}
+
+/*
+ * fsync vnode op. Just call nfs4_flush() with commit == 1.
+ */
+/* ARGSUSED */
+static int
+nfs4_fsync(struct vop_fsync_args *ap)
+{
+	return (nfs4_flush(ap->a_vp, ap->a_cred, ap->a_waitfor, ap->a_td, 1));
+}
+
+/*
+ * Flush all the blocks associated with a vnode.
+ * 	Walk through the buffer pool and push any dirty pages
+ *	associated with the vnode.
+ */
+static int
+nfs4_flush(struct vnode *vp, struct ucred *cred, int waitfor, struct thread *td,
+    int commit)
+{
+	struct nfsnode *np = VTONFS(vp);
+	struct buf *bp;
+	int i;
+	struct buf *nbp;
+	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
+	int s, error = 0, slptimeo = 0, slpflag = 0, retv, bvecpos;
+	int passone = 1;
+	u_quad_t off, endoff, toff;
+	struct ucred* wcred = NULL;
+	struct buf **bvec = NULL;
+#ifndef NFS_COMMITBVECSIZ
+#define NFS_COMMITBVECSIZ	20
+#endif
+	struct buf *bvec_on_stack[NFS_COMMITBVECSIZ];
+	int bvecsize = 0, bveccount;
+
+	if (nmp->nm_flag & NFSMNT_INT)
+		slpflag = PCATCH;
+	if (!commit)
+		passone = 0;
+	/*
+	 * A b_flags == (B_DELWRI | B_NEEDCOMMIT) block has been written to the
+	 * server, but nas not been committed to stable storage on the server
+	 * yet. On the first pass, the byte range is worked out and the commit
+	 * rpc is done. On the second pass, nfs_writebp() is called to do the
+	 * job.
+	 */
+again:
+	off = (u_quad_t)-1;
+	endoff = 0;
+	bvecpos = 0;
+	if (NFS_ISV3(vp) && commit) {
+		s = splbio();
+		if (bvec != NULL && bvec != bvec_on_stack)
+			free(bvec, M_TEMP);
+		/*
+		 * Count up how many buffers waiting for a commit.
+		 */
+		bveccount = 0;
+		VI_LOCK(vp);
+		for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
+			nbp = TAILQ_NEXT(bp, b_vnbufs);
+			if (BUF_REFCNT(bp) == 0 &&
+			    (bp->b_flags & (B_DELWRI | B_NEEDCOMMIT))
+				== (B_DELWRI | B_NEEDCOMMIT))
+				bveccount++;
+		}
+		/*
+		 * Allocate space to remember the list of bufs to commit.  It is
+		 * important to use M_NOWAIT here to avoid a race with nfs4_write.
+		 * If we can't get memory (for whatever reason), we will end up
+		 * committing the buffers one-by-one in the loop below.
+		 */
+		if (bveccount > NFS_COMMITBVECSIZ) {
+			/*
+			 * Release the vnode interlock to avoid a lock
+			 * order reversal.
+			 */
+			VI_UNLOCK(vp);
+			bvec = (struct buf **)
+				malloc(bveccount * sizeof(struct buf *),
+				       M_TEMP, M_NOWAIT);
+			VI_LOCK(vp);
+			if (bvec == NULL) {
+				bvec = bvec_on_stack;
+				bvecsize = NFS_COMMITBVECSIZ;
+			} else
+				bvecsize = bveccount;
+		} else {
+			bvec = bvec_on_stack;
+			bvecsize = NFS_COMMITBVECSIZ;
+		}
+		for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
+			if (bvecpos >= bvecsize)
+				break;
+			if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) {
+				nbp = TAILQ_NEXT(bp, b_vnbufs);
+				continue;
+			}
+			if ((bp->b_flags & (B_DELWRI | B_NEEDCOMMIT)) !=
+			    (B_DELWRI | B_NEEDCOMMIT)) {
+				BUF_UNLOCK(bp);
+				nbp = TAILQ_NEXT(bp, b_vnbufs);
+				continue;
+			}
+			VI_UNLOCK(vp);
+			bremfree(bp);
+			/*
+			 * Work out if all buffers are using the same cred
+			 * so we can deal with them all with one commit.
+			 *
+			 * NOTE: we are not clearing B_DONE here, so we have
+			 * to do it later on in this routine if we intend to
+			 * initiate I/O on the bp.
+			 *
+			 * Note: to avoid loopback deadlocks, we do not
+			 * assign b_runningbufspace.
+			 */
+			if (wcred == NULL)
+				wcred = bp->b_wcred;
+			else if (wcred != bp->b_wcred)
+				wcred = NOCRED;
+			bp->b_flags |= B_WRITEINPROG;
+			vfs_busy_pages(bp, 1);
+
+			VI_LOCK(vp);
+			/*
+			 * bp is protected by being locked, but nbp is not
+			 * and vfs_busy_pages() may sleep.  We have to
+			 * recalculate nbp.
+			 */
+			nbp = TAILQ_NEXT(bp, b_vnbufs);
+
+			/*
+			 * A list of these buffers is kept so that the
+			 * second loop knows which buffers have actually
+			 * been committed. This is necessary, since there
+			 * may be a race between the commit rpc and new
+			 * uncommitted writes on the file.
+			 */
+			bvec[bvecpos++] = bp;
+			toff = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +
+				bp->b_dirtyoff;
+			if (toff < off)
+				off = toff;
+			toff += (u_quad_t)(bp->b_dirtyend - bp->b_dirtyoff);
+			if (toff > endoff)
+				endoff = toff;
+		}
+		splx(s);
+		VI_UNLOCK(vp);
+	}
+	if (bvecpos > 0) {
+		/*
+		 * Commit data on the server, as required.
+		 * If all bufs are using the same wcred, then use that with
+		 * one call for all of them, otherwise commit each one
+		 * separately.
+		 */
+		if (wcred != NOCRED)
+			retv = nfs4_commit(vp, off, (int)(endoff - off),
+					  wcred, td);
+		else {
+			retv = 0;
+			for (i = 0; i < bvecpos; i++) {
+				off_t off, size;
+				bp = bvec[i];
+				off = ((u_quad_t)bp->b_blkno) * DEV_BSIZE +
+					bp->b_dirtyoff;
+				size = (u_quad_t)(bp->b_dirtyend
+						  - bp->b_dirtyoff);
+				retv = nfs4_commit(vp, off, (int)size,
+						  bp->b_wcred, td);
+				if (retv) break;
+			}
+		}
+
+		if (retv == NFSERR_STALEWRITEVERF)
+			nfs_clearcommit(vp->v_mount);
+
+		/*
+		 * Now, either mark the blocks I/O done or mark the
+		 * blocks dirty, depending on whether the commit
+		 * succeeded.
+		 */
+		for (i = 0; i < bvecpos; i++) {
+			bp = bvec[i];
+			bp->b_flags &= ~(B_NEEDCOMMIT | B_WRITEINPROG | B_CLUSTEROK);
+			if (retv) {
+				/*
+				 * Error, leave B_DELWRI intact
+				 */
+				vfs_unbusy_pages(bp);
+				brelse(bp);
+			} else {
+				/*
+				 * Success, remove B_DELWRI ( bundirty() ).
+				 *
+				 * b_dirtyoff/b_dirtyend seem to be NFS
+				 * specific.  We should probably move that
+				 * into bundirty(). XXX
+				 */
+				s = splbio();
+				VI_LOCK(vp);
+				vp->v_numoutput++;
+				VI_UNLOCK(vp);
+				bp->b_flags |= B_ASYNC;
+				bundirty(bp);
+				bp->b_flags &= ~B_DONE;
+				bp->b_ioflags &= ~BIO_ERROR;
+				bp->b_dirtyoff = bp->b_dirtyend = 0;
+				splx(s);
+				bufdone(bp);
+			}
+		}
+	}
+
+	/*
+	 * Start/do any write(s) that are required.
+	 */
+loop:
+	s = splbio();
+	VI_LOCK(vp);
+	for (bp = TAILQ_FIRST(&vp->v_dirtyblkhd); bp; bp = nbp) {
+		nbp = TAILQ_NEXT(bp, b_vnbufs);
+		if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL)) {
+			if (waitfor != MNT_WAIT || passone)
+				continue;
+
+			error = BUF_TIMELOCK(bp,
+			    LK_EXCLUSIVE | LK_SLEEPFAIL | LK_INTERLOCK,
+			    VI_MTX(vp), "nfsfsync", slpflag, slptimeo);
+			splx(s);
+			if (error == 0)
+				panic("nfs4_fsync: inconsistent lock");
+			if (error == ENOLCK)
+				goto loop;
+			if (nfs4_sigintr(nmp, NULL, td)) {
+				error = EINTR;
+				goto done;
+			}
+			if (slpflag == PCATCH) {
+				slpflag = 0;
+				slptimeo = 2 * hz;
+			}
+			goto loop;
+		}
+		if ((bp->b_flags & B_DELWRI) == 0)
+			panic("nfs4_fsync: not dirty");
+		if ((passone || !commit) && (bp->b_flags & B_NEEDCOMMIT)) {
+			BUF_UNLOCK(bp);
+			continue;
+		}
+		VI_UNLOCK(vp);
+		bremfree(bp);
+		if (passone || !commit)
+		    bp->b_flags |= B_ASYNC;
+		else
+		    bp->b_flags |= B_ASYNC | B_WRITEINPROG;
+		splx(s);
+		BUF_WRITE(bp);
+		goto loop;
+	}
+	splx(s);
+	if (passone) {
+		passone = 0;
+		VI_UNLOCK(vp);
+		goto again;
+	}
+	if (waitfor == MNT_WAIT) {
+		while (vp->v_numoutput) {
+			vp->v_iflag |= VI_BWAIT;
+			error = msleep((caddr_t)&vp->v_numoutput, VI_MTX(vp),
+				slpflag | (PRIBIO + 1), "nfsfsync", slptimeo);
+			if (error) {
+			    VI_UNLOCK(vp);
+			    if (nfs4_sigintr(nmp, NULL, td)) {
+				error = EINTR;
+				goto done;
+			    }
+			    if (slpflag == PCATCH) {
+				slpflag = 0;
+				slptimeo = 2 * hz;
+			    }
+			    VI_LOCK(vp);
+			}
+		}
+		if (!TAILQ_EMPTY(&vp->v_dirtyblkhd) && commit) {
+			VI_UNLOCK(vp);
+			goto loop;
+		}
+	}
+	VI_UNLOCK(vp);
+	if (np->n_flag & NWRITEERR) {
+		error = np->n_error;
+		np->n_flag &= ~NWRITEERR;
+	}
+done:
+	if (bvec != NULL && bvec != bvec_on_stack)
+		free(bvec, M_TEMP);
+	return (error);
+}
+
+/*
+ * NFS advisory byte-level locks.
+ */
+static int
+nfs4_advlock(struct vop_advlock_args *ap)
+{
+	return (EPERM);
+
+	if ((VFSTONFS(ap->a_vp->v_mount)->nm_flag & NFSMNT_NOLOCKD) != 0) {
+		struct nfsnode *np = VTONFS(ap->a_vp);
+
+		return (lf_advlock(ap, &(np->n_lockf), np->n_size));
+	}
+	return (nfs_dolock(ap));
+}
+
+/*
+ * Print out the contents of an nfsnode.
+ */
+static int
+nfs4_print(struct vop_print_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	struct nfsnode *np = VTONFS(vp);
+
+	printf("\tfileid %ld fsid 0x%x",
+	   np->n_vattr.va_fileid, np->n_vattr.va_fsid);
+	if (vp->v_type == VFIFO)
+		fifo_printinfo(vp);
+	printf("\n");
+	return (0);
+}
+
+/*
+ * This is the "real" nfs::bwrite(struct buf*).
+ * B_WRITEINPROG isn't set unless the force flag is one and it
+ * handles the B_NEEDCOMMIT flag.
+ * We set B_CACHE if this is a VMIO buffer.
+ */
+int
+nfs4_writebp(struct buf *bp, int force, struct thread *td)
+{
+	int s;
+	int oldflags = bp->b_flags;
+#if 0
+	int retv = 1;
+	off_t off;
+#endif
+
+	if (BUF_REFCNT(bp) == 0)
+		panic("bwrite: buffer is not locked???");
+
+	if (bp->b_flags & B_INVAL) {
+		brelse(bp);
+		return(0);
+	}
+
+	bp->b_flags |= B_CACHE;
+
+	/*
+	 * Undirty the bp.  We will redirty it later if the I/O fails.
+	 */
+
+	s = splbio();
+	bundirty(bp);
+	bp->b_flags &= ~B_DONE;
+	bp->b_ioflags &= ~BIO_ERROR;
+	bp->b_iocmd = BIO_WRITE;
+
+	VI_LOCK(bp->b_vp);
+	bp->b_vp->v_numoutput++;
+	VI_UNLOCK(bp->b_vp);
+	curthread->td_proc->p_stats->p_ru.ru_oublock++;
+	splx(s);
+
+	/*
+	 * Note: to avoid loopback deadlocks, we do not
+	 * assign b_runningbufspace.
+	 */
+	vfs_busy_pages(bp, 1);
+
+	if (force)
+		bp->b_flags |= B_WRITEINPROG;
+	BUF_KERNPROC(bp);
+	bp->b_iooffset = dbtob(bp->b_blkno);
+	VOP_STRATEGY(bp->b_vp, bp);
+
+	if( (oldflags & B_ASYNC) == 0) {
+		int rtval = bufwait(bp);
+
+		if (oldflags & B_DELWRI) {
+			s = splbio();
+			reassignbuf(bp, bp->b_vp);
+			splx(s);
+		}
+
+		brelse(bp);
+		return (rtval);
+	}
+
+	return (0);
+}
+
+/*
+ * nfs special file access vnode op.
+ * Essentially just get vattr and then imitate iaccess() since the device is
+ * local to the client.
+ */
+static int
+nfsspec_access(struct vop_access_args *ap)
+{
+	struct vattr *vap;
+	struct ucred *cred = ap->a_cred;
+	struct vnode *vp = ap->a_vp;
+	mode_t mode = ap->a_mode;
+	struct vattr vattr;
+	int error;
+
+	/*
+	 * 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 ((mode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) {
+		switch (vp->v_type) {
+		case VREG:
+		case VDIR:
+		case VLNK:
+			return (EROFS);
+		default:
+			break;
+		}
+	}
+	vap = &vattr;
+	error = VOP_GETATTR(vp, vap, cred, ap->a_td);
+	if (error)
+		return (error);
+	return (vaccess(vp->v_type, vap->va_mode, vap->va_uid, vap->va_gid,
+	    mode, cred, NULL));
+}
+
+/*
+ * Read wrapper for special devices.
+ */
+static int
+nfsspec_read(struct vop_read_args *ap)
+{
+	struct nfsnode *np = VTONFS(ap->a_vp);
+
+	/*
+	 * Set access flag.
+	 */
+	np->n_flag |= NACC;
+	getnanotime(&np->n_atim);
+	return (VOCALL(spec_vnodeop_p, VOFFSET(vop_read), ap));
+}
+
+/*
+ * Write wrapper for special devices.
+ */
+static int
+nfsspec_write(struct vop_write_args *ap)
+{
+	struct nfsnode *np = VTONFS(ap->a_vp);
+
+	/*
+	 * Set update flag.
+	 */
+	np->n_flag |= NUPD;
+	getnanotime(&np->n_mtim);
+	return (VOCALL(spec_vnodeop_p, VOFFSET(vop_write), ap));
+}
+
+/*
+ * Close wrapper for special devices.
+ *
+ * Update the times on the nfsnode then do device close.
+ */
+static int
+nfsspec_close(struct vop_close_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	struct nfsnode *np = VTONFS(vp);
+	struct vattr vattr;
+
+	if (np->n_flag & (NACC | NUPD)) {
+		np->n_flag |= NCHG;
+		if (vrefcnt(vp) == 1 &&
+		    (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
+			VATTR_NULL(&vattr);
+			if (np->n_flag & NACC)
+				vattr.va_atime = np->n_atim;
+			if (np->n_flag & NUPD)
+				vattr.va_mtime = np->n_mtim;
+			(void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_td);
+		}
+	}
+	return (VOCALL(spec_vnodeop_p, VOFFSET(vop_close), ap));
+}
+
+/*
+ * Read wrapper for fifos.
+ */
+static int
+nfsfifo_read(struct vop_read_args *ap)
+{
+	struct nfsnode *np = VTONFS(ap->a_vp);
+
+	/*
+	 * Set access flag.
+	 */
+	np->n_flag |= NACC;
+	getnanotime(&np->n_atim);
+	return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_read), ap));
+}
+
+/*
+ * Write wrapper for fifos.
+ */
+static int
+nfsfifo_write(struct vop_write_args *ap)
+{
+	struct nfsnode *np = VTONFS(ap->a_vp);
+
+	/*
+	 * Set update flag.
+	 */
+	np->n_flag |= NUPD;
+	getnanotime(&np->n_mtim);
+	return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_write), ap));
+}
+
+/*
+ * Close wrapper for fifos.
+ *
+ * Update the times on the nfsnode then do fifo close.
+ */
+static int
+nfsfifo_close(struct vop_close_args *ap)
+{
+	struct vnode *vp = ap->a_vp;
+	struct nfsnode *np = VTONFS(vp);
+	struct vattr vattr;
+	struct timespec ts;
+
+	if (np->n_flag & (NACC | NUPD)) {
+		getnanotime(&ts);
+		if (np->n_flag & NACC)
+			np->n_atim = ts;
+		if (np->n_flag & NUPD)
+			np->n_mtim = ts;
+		np->n_flag |= NCHG;
+		if (vrefcnt(vp) == 1 &&
+		    (vp->v_mount->mnt_flag & MNT_RDONLY) == 0) {
+			VATTR_NULL(&vattr);
+			if (np->n_flag & NACC)
+				vattr.va_atime = np->n_atim;
+			if (np->n_flag & NUPD)
+				vattr.va_mtime = np->n_mtim;
+			vn_lock(vp, LK_EXCLUSIVE | LK_RETRY, ap->a_td);
+			(void)VOP_SETATTR(vp, &vattr, ap->a_cred, ap->a_td);
+			VOP_UNLOCK(vp, 0, ap->a_td);
+		}
+	}
+	return (VOCALL(fifo_vnodeop_p, VOFFSET(vop_close), ap));
+}
+
diff --git a/sys/nfs4client/nfs4m_subs.h b/sys/nfs4client/nfs4m_subs.h
new file mode 100644
index 0000000..534c836
--- /dev/null
+++ b/sys/nfs4client/nfs4m_subs.h
@@ -0,0 +1,498 @@
+/* $FreeBSD$ */
+/* $Id: nfs4m_subs.h,v 1.36 2003/11/05 14:59:01 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+#ifndef _NFS4CLIENT_NFSM4_SUBS_H
+#define _NFS4CLIENT_NFSM4_SUBS_H
+
+void nfsm_v4init(void);
+
+void nfsm_buildf_xx(struct mbuf **mb, caddr_t *bpos, char *fmt, ...);
+int nfsm_dissectf_xx(struct mbuf **md, caddr_t *dpos, char *fmt, ...);
+
+int nfsm_v4build_compound_xx(struct nfs4_compound *, char *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_putfh_xx(struct nfs4_compound *, struct vnode *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_putfh_nv_xx(struct nfs4_compound *, struct nfs4_oparg_getfh *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_getattr_xx(struct nfs4_compound *, struct nfs4_oparg_getattr *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_finalize_xx(struct nfs4_compound *, struct mbuf **, caddr_t *);
+int nfsm_v4build_getfh_xx(struct nfs4_compound *, struct nfs4_oparg_getfh *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_lookup_xx(struct nfs4_compound *, struct nfs4_oparg_lookup *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_setclientid_xx(struct nfs4_compound *,
+        struct nfs4_oparg_setclientid *, struct mbuf **, caddr_t *);
+int nfsm_v4build_setclientid_confirm_xx(struct nfs4_compound *,
+        struct nfs4_oparg_setclientid *, struct mbuf **, caddr_t *);
+int nfsm_v4build_close_xx(struct nfs4_compound *, struct nfs4_fctx *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_access_xx(struct nfs4_compound *, struct nfs4_oparg_access *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_open_xx(struct nfs4_compound *, struct nfs4_oparg_open *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_open_confirm_xx(struct nfs4_compound *, struct nfs4_oparg_open *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_read_xx(struct nfs4_compound *, struct nfs4_oparg_read *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_write_xx(struct nfs4_compound *, struct nfs4_oparg_write *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_commit_xx(struct nfs4_compound *, struct nfs4_oparg_commit *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_readdir_xx(struct nfs4_compound *, struct nfs4_oparg_readdir *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_renew_xx(struct nfs4_compound *, uint64_t,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_setattr_xx(struct nfs4_compound *, struct vattr *,
+        struct nfs4_fctx *, struct mbuf **, caddr_t *);
+int nfsm_v4build_create_xx(struct nfs4_compound *, struct nfs4_oparg_create *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_rename_xx(struct nfs4_compound *, struct nfs4_oparg_rename *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_link_xx(struct nfs4_compound *, struct nfs4_oparg_link *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4build_remove_xx(struct nfs4_compound *, const char *, u_int,
+        struct mbuf **, caddr_t *);
+
+int nfsm_v4dissect_compound_xx(struct nfs4_compound *, struct mbuf **, caddr_t *);
+int nfsm_v4dissect_getattr_xx(struct nfs4_compound *, struct nfs4_oparg_getattr *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4dissect_getfh_xx(struct nfs4_compound *, struct nfs4_oparg_getfh *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4dissect_setclientid_xx(struct nfs4_compound *,
+        struct nfs4_oparg_setclientid *, struct mbuf **, caddr_t *);
+int nfsm_v4dissect_close_xx(struct nfs4_compound *, struct nfs4_fctx *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4dissect_access_xx(struct nfs4_compound *, struct nfs4_oparg_access *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4dissect_open_xx(struct nfs4_compound *, struct nfs4_oparg_open *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4dissect_open_confirm_xx(struct nfs4_compound *, struct nfs4_oparg_open *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4dissect_read_xx(struct nfs4_compound *, struct nfs4_oparg_read *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4dissect_write_xx(struct nfs4_compound *, struct nfs4_oparg_write *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4dissect_commit_xx(struct nfs4_compound *, struct nfs4_oparg_commit *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4dissect_setattr_xx(struct nfs4_compound *, struct mbuf **, caddr_t *);
+int nfsm_v4dissect_create_xx(struct nfs4_compound *, struct nfs4_oparg_create *,
+        struct mbuf **, caddr_t *);
+int nfsm_v4dissect_readlink_xx(struct nfs4_compound *, struct uio *, 
+        struct mbuf **, caddr_t *);
+
+int nfsm_v4dissect_attrs_xx(struct nfsv4_fattr *, struct mbuf **, caddr_t *);
+
+int nfsm_v4build_simple_xx(struct nfs4_compound *, uint32_t,
+        struct mbuf **, caddr_t *);
+int nfsm_v4dissect_simple_xx(struct nfs4_compound *, uint32_t,
+        uint32_t, struct mbuf **, caddr_t *);
+
+#define nfsm_v4build_putrootfh_xx(cp, mb, bpos) \
+	nfsm_v4build_simple_xx((cp), NFSV4OP_PUTROOTFH, (mb), (bpos))
+
+#define nfsm_v4build_lookupp_xx(cp, mb, bpos) \
+	nfsm_v4build_simple_xx((cp), NFSV4OP_LOOKUPP, (mb), (bpos))
+
+#define nfsm_v4build_savefh_xx(cp, mb, bpos)				\
+	nfsm_v4build_simple_xx((cp), NFSV4OP_SAVEFH, (mb), (bpos))
+
+#define nfsm_v4build_readlink_xx(cp, mb, bpos)				\
+	nfsm_v4build_simple_xx((cp), NFSV4OP_READLINK, (mb), (bpos))
+
+
+#define nfsm_v4dissect_putrootfh_xx(cp, mb, bpos)				\
+	nfsm_v4dissect_simple_xx((cp), NFSV4OP_PUTROOTFH, 0, (mb), (bpos))
+
+#define nfsm_v4dissect_lookup_xx(cp, mb, bpos) \
+	nfsm_v4dissect_simple_xx((cp), NFSV4OP_LOOKUP, 0, (mb), (bpos))
+
+#define nfsm_v4dissect_lookupp_xx(cp, mb, bpos) \
+	nfsm_v4dissect_simple_xx((cp), NFSV4OP_LOOKUPP, 0, (mb), (bpos))
+
+#define nfsm_v4dissect_putfh_xx(cp, mb, bpos) \
+	nfsm_v4dissect_simple_xx((cp), NFSV4OP_PUTFH, 0, (mb), (bpos))
+
+#define nfsm_v4dissect_renew_xx(cp, mb, bpos) \
+	nfsm_v4dissect_simple_xx((cp), NFSV4OP_RENEW, 0, (mb), (bpos))
+
+#define nfsm_v4dissect_setclientid_confirm_xx(cp, mb, bpos) \
+	nfsm_v4dissect_simple_xx((cp), NFSV4OP_SETCLIENTID_CONFIRM, 0, (mb), (bpos))
+
+#define nfsm_v4dissect_rename_xx(cp, mb, bpos)				\
+	nfsm_v4dissect_simple_xx((cp), NFSV4OP_RENAME, 0, (mb), (bpos))
+
+#define nfsm_v4dissect_link_xx(cp, mb, bpos)				\
+	nfsm_v4dissect_simple_xx((cp), NFSV4OP_LINK, 0, (mb), (bpos))
+
+#define nfsm_v4dissect_savefh_xx(cp, mb, bpos)				\
+	nfsm_v4dissect_simple_xx((cp), NFSV4OP_SAVEFH, 0, (mb), (bpos))
+
+#define nfsm_v4dissect_remove_xx(cp, mb, bpos)				\
+	nfsm_v4dissect_simple_xx((cp), NFSV4OP_REMOVE, 0, (mb), (bpos))
+
+#define nfsm_v4build_compound(cp, tag) do {			\
+	int32_t t1;						\
+	t1 = nfsm_v4build_compound_xx((cp), (tag), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_finalize(cp) do {			\
+	int32_t t1;					\
+	t1 = nfsm_v4build_finalize_xx((cp), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);				\
+} while (0)
+
+#define nfsm_v4build_putfh(cp, vp) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_putfh_xx((cp), (vp), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_putfh_nv(cp, gfh) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_putfh_nv_xx((cp), (gfh), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_putrootfh(cp) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_putrootfh_xx((cp), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_getattr(cp, ga) do {			\
+	int32_t t1;						\
+	t1 = nfsm_v4build_getattr_xx((cp), (ga), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_setattr(cp, vap, fcp) do {				\
+	int32_t t1;							\
+	t1 = nfsm_v4build_setattr_xx((cp), (vap), (fcp), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);						\
+} while (0)
+
+#define nfsm_v4build_lookup(cp, l) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_lookup_xx((cp), (l), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_lookupp(cp) do {			\
+	int32_t t1;					\
+	t1 = nfsm_v4build_lookupp_xx((cp), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);				\
+} while (0)
+
+#define nfsm_v4build_getfh(cp, gfh) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_getfh_xx((cp), (gfh), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_close(cp, fcp) do {			\
+	int32_t t1;						\
+	t1 = nfsm_v4build_close_xx((cp), (fcp), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_access(cp, acc) do {			\
+	int32_t t1;						\
+	t1 = nfsm_v4build_access_xx((cp), (acc), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_open(cp, o) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_open_xx((cp), (o), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_open_confirm(cp, o) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_open_confirm_xx((cp), (o), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_read(cp, r) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_read_xx((cp), (r), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_write(cp, w) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_write_xx((cp), (w), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_commit(cp, c) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_commit_xx((cp), (c), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_readdir(cp, r) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_readdir_xx((cp), (r), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_renew(cp, cid) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_renew_xx((cp), (cid), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_setclientid(cp, cid) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_setclientid_xx((cp), (cid), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_setclientid_confirm(cp, cid) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_setclientid_confirm_xx((cp), (cid), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_create(cp, c) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_create_xx((cp), (c), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_rename(cp, r) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_rename_xx((cp), (r), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_link(cp, r) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_link_xx((cp), (r), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_savefh(cp) do {			\
+	int32_t t1;					\
+	t1 = nfsm_v4build_savefh_xx((cp), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);				\
+} while (0)
+
+#define nfsm_v4build_readlink(cp) do {				\
+	int32_t t1;						\
+	t1 = nfsm_v4build_readlink_xx((cp), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);					\
+} while (0)
+
+#define nfsm_v4build_remove(cp, name, namelen) do {				\
+	int32_t t1;								\
+	t1 = nfsm_v4build_remove_xx((cp), (name), (namelen), &mb, &bpos);	\
+	nfsm_bcheck(t1, mreq);							\
+} while (0)
+
+/* --- */
+
+#define nfsm_v4dissect_compound(cp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_compound_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_putfh(cp)			\
+do {							\
+        int32_t t1;					\
+        t1 = nfsm_v4dissect_putfh_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);				\
+} while (0)
+
+#define nfsm_v4dissect_putrootfh(cp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_putrootfh_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_getattr(cp, ga)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_getattr_xx((cp), (ga), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_setattr(cp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_setattr_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_lookup(cp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_lookup_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_lookupp(cp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_lookupp_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_getfh(cp, gfh)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_getfh_xx((cp), (gfh), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_setclientid(cp, sci)				\
+do {									\
+        int32_t t1;							\
+        t1 = nfsm_v4dissect_setclientid_xx((cp), (sci), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);						\
+} while (0)
+
+#define nfsm_v4dissect_setclientid_confirm(cp)				\
+do {									\
+        int32_t t1;							\
+        t1 = nfsm_v4dissect_setclientid_confirm_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);						\
+} while (0)
+
+#define nfsm_v4dissect_close(cp, fcp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_close_xx((cp), (fcp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_access(cp, acc)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_access_xx((cp), (acc), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_open(cp, openp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_open_xx((cp), (openp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_open_confirm(cp, openp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_open_confirm_xx((cp), (openp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_read(cp, r)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_read_xx((cp), (r), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_write(cp, w)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_write_xx((cp), (w), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_commit(cp, c)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_commit_xx((cp), (c), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_attrs(fattr)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_attrs_xx((fattr), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_renew(cp)			\
+do {							\
+        int32_t t1;					\
+        t1 = nfsm_v4dissect_renew_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);				\
+} while (0)
+
+#define nfsm_v4dissect_create(cp, c)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_create_xx((cp), (c), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_rename(cp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_rename_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_link(cp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_link_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_savefh(cp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_savefh_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#define nfsm_v4dissect_readlink(cp, uiop)				\
+do {									\
+        int32_t t1;							\
+        t1 = nfsm_v4dissect_readlink_xx((cp), (uiop), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);						\
+} while (0)
+
+#define nfsm_v4dissect_remove(cp)				\
+do {								\
+        int32_t t1;						\
+        t1 = nfsm_v4dissect_remove_xx((cp), &md, &dpos);	\
+        nfsm_dcheck(t1, mrep);					\
+} while (0)
+
+#endif /* _NFS4CLIENT_NFSM4_SUBS_H */
diff --git a/sys/nfsclient/bootp_subr.c b/sys/nfsclient/bootp_subr.c
index 51a618e..c4d9eea 100644
--- a/sys/nfsclient/bootp_subr.c
+++ b/sys/nfsclient/bootp_subr.c
@@ -65,6 +65,8 @@ __FBSDID("$FreeBSD$");
 #include <net/if_types.h>
 #include <net/if_dl.h>
 
+#include <rpc/rpcclnt.h>
+
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
 #include <nfsclient/nfs.h>
diff --git a/sys/nfsclient/krpc_subr.c b/sys/nfsclient/krpc_subr.c
index b12bbc6..9ecee2c 100644
--- a/sys/nfsclient/krpc_subr.c
+++ b/sys/nfsclient/krpc_subr.c
@@ -57,6 +57,8 @@ __FBSDID("$FreeBSD$");
 #include <net/if.h>
 #include <netinet/in.h>
 
+#include <rpc/rpcclnt.h>
+
 #include <nfs/rpcv2.h>
 #include <nfsclient/krpc.h>
 #include <nfs/xdr_subs.h>
diff --git a/sys/nfsclient/nfs.h b/sys/nfsclient/nfs.h
index f231fb9..f09fd65 100644
--- a/sys/nfsclient/nfs.h
+++ b/sys/nfsclient/nfs.h
@@ -242,13 +242,31 @@ extern int nfs_debug;
 
 #endif
 
+/*
+ * File context information for nfsv4.	Currently, there is only one
+ * lockowner for the whole machine "0."
+ */
+struct nfs4_fctx {
+	TAILQ_ENTRY(nfs4_fstate) next;
+
+	pid_t		pid;
+	uint32_t	refcnt;
+	struct nfs4_lowner *lop;
+	struct nfsnode *np;
+	char		stateid[NFSX_V4STATEID];
+};
+
 vfs_init_t nfs_init;
 vfs_uninit_t nfs_uninit;
 int	nfs_mountroot(struct mount *mp, struct thread *td);
+
+#ifndef NFS4_USE_RPCCLNT
 int	nfs_send(struct socket *, struct sockaddr *, struct mbuf *,
 	    struct nfsreq *);
 int	nfs_sndlock(struct nfsreq *);
 void	nfs_sndunlock(struct nfsreq *);
+#endif /* ! NFS4_USE_RPCCLNT */
+
 int	nfs_vinvalbuf(struct vnode *, int, struct ucred *, struct thread *,
 	    int);
 int	nfs_readrpc(struct vnode *, struct uio *, struct ucred *);
@@ -271,6 +289,7 @@ int	nfsm_mbuftouio(struct mbuf **, struct uio *, int, caddr_t *);
 void	nfs_nhinit(void);
 int	nfs_nmcancelreqs(struct nfsmount *);
 void	nfs_timer(void*);
+
 int	nfs_connect(struct nfsmount *, struct nfsreq *);
 void	nfs_disconnect(struct nfsmount *);
 void	nfs_safedisconnect(struct nfsmount *);
diff --git a/sys/nfsclient/nfs_bio.c b/sys/nfsclient/nfs_bio.c
index 442acbc..58ef852 100644
--- a/sys/nfsclient/nfs_bio.c
+++ b/sys/nfsclient/nfs_bio.c
@@ -58,24 +58,40 @@ __FBSDID("$FreeBSD$");
 #include <vm/vm_pager.h>
 #include <vm/vnode_pager.h>
 
+#include <rpc/rpcclnt.h>
+
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
 #include <nfsclient/nfs.h>
 #include <nfsclient/nfsmount.h>
 #include <nfsclient/nfsnode.h>
 
+#include <nfs4client/nfs4.h>
+
 /*
  * Just call nfs_writebp() with the force argument set to 1.
  *
  * NOTE: B_DONE may or may not be set in a_bp on call.
  */
 static int
+nfs4_bwrite(struct buf *bp)
+{
+
+	return (nfs4_writebp(bp, 1, curthread));
+}
+
+static int
 nfs_bwrite(struct buf *bp)
 {
 
 	return (nfs_writebp(bp, 1, curthread));
 }
 
+struct buf_ops buf_ops_nfs4 = {
+	"buf_ops_nfs4",
+	nfs4_bwrite
+};
+
 struct buf_ops buf_ops_nfs = {
 	"buf_ops_nfs",
 	nfs_bwrite
@@ -118,6 +134,7 @@ nfs_getpages(struct vop_getpages_args *ap)
 
 	if ((nmp->nm_flag & NFSMNT_NFSV3) != 0 &&
 	    (nmp->nm_state & NFSSTA_GOTFSINFO) == 0) {
+		/* We'll never get here for v4, because we always have fsinfo */
 		(void)nfs_fsinfo(nmp, vp, cred, td);
 	}
 
@@ -170,7 +187,10 @@ nfs_getpages(struct vop_getpages_args *ap)
 	uio.uio_rw = UIO_READ;
 	uio.uio_td = td;
 
-	error = nfs_readrpc(vp, &uio, cred);
+	if ((nmp->nm_flag & NFSMNT_NFSV4) != 0)
+		error = nfs4_readrpc(vp, &uio, cred);
+	else
+		error = nfs_readrpc(vp, &uio, cred);
 	pmap_qremove(kva, npages);
 
 	relpbuf(bp, &nfs_pbuf_freecnt);
@@ -332,7 +352,10 @@ nfs_putpages(struct vop_putpages_args *ap)
 	else
 	    iomode = NFSV3WRITE_FILESYNC;
 
-	error = nfs_writerpc(vp, &uio, cred, &iomode, &must_commit);
+	if ((nmp->nm_flag & NFSMNT_NFSV4) != 0)
+		error = nfs4_writerpc(vp, &uio, cred, &iomode, &must_commit);
+	else
+		error = nfs_writerpc(vp, &uio, cred, &iomode, &must_commit);
 
 	pmap_qremove(kva, npages);
 	relpbuf(bp, &nfs_pbuf_freecnt);
@@ -837,7 +860,10 @@ again:
 				allocbuf(bp, bcount);
 				bp->b_flags |= save;
 				bp->b_magic = B_MAGIC_NFS;
-				bp->b_op = &buf_ops_nfs;
+				if ((nmp->nm_flag & NFSMNT_NFSV4) != 0)
+					bp->b_op = &buf_ops_nfs4;
+				else
+					bp->b_op = &buf_ops_nfs;
 			}
 		} else {
 			/*
@@ -996,7 +1022,10 @@ again:
 				break;
 		} else if ((n + on) == biosize) {
 			bp->b_flags |= B_ASYNC;
-			(void)nfs_writebp(bp, 0, 0);
+			if ((nmp->nm_flag & NFSMNT_NFSV4) != 0)
+				(void)nfs4_writebp(bp, 0, 0);
+			else
+				(void)nfs_writebp(bp, 0, 0);
 		} else {
 			bdwrite(bp);
 		}
@@ -1339,13 +1368,17 @@ nfs_doio(struct buf *bp, struct ucred *cr, struct thread *td)
 	    case VDIR:
 		nfsstats.readdir_bios++;
 		uiop->uio_offset = ((u_quad_t)bp->b_lblkno) * NFS_DIRBLKSIZ;
-		if (nmp->nm_flag & NFSMNT_RDIRPLUS) {
-			error = nfs_readdirplusrpc(vp, uiop, cr);
-			if (error == NFSERR_NOTSUPP)
-				nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
+		if ((nmp->nm_flag & NFSMNT_NFSV4) != 0)
+			error = nfs4_readdirrpc(vp, uiop, cr);
+		else {
+			if ((nmp->nm_flag & NFSMNT_RDIRPLUS) != 0) {
+				error = nfs_readdirplusrpc(vp, uiop, cr);
+				if (error == NFSERR_NOTSUPP)
+					nmp->nm_flag &= ~NFSMNT_RDIRPLUS;
+			}
+			if ((nmp->nm_flag & NFSMNT_RDIRPLUS) == 0)
+				error = nfs_readdirrpc(vp, uiop, cr);
 		}
-		if ((nmp->nm_flag & NFSMNT_RDIRPLUS) == 0)
-			error = nfs_readdirrpc(vp, uiop, cr);
 		/*
 		 * end-of-directory sets B_INVAL but does not generate an
 		 * error.
diff --git a/sys/nfsclient/nfs_diskless.c b/sys/nfsclient/nfs_diskless.c
index 4e09bde..e2c199a 100644
--- a/sys/nfsclient/nfs_diskless.c
+++ b/sys/nfsclient/nfs_diskless.c
@@ -52,6 +52,7 @@ __FBSDID("$FreeBSD$");
 #include <net/if_var.h>
 #include <net/ethernet.h>
 #include <netinet/in.h>
+#include <rpc/rpcclnt.h>
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
 #include <nfsclient/nfs.h>
diff --git a/sys/nfsclient/nfs_lock.c b/sys/nfsclient/nfs_lock.c
index 374bbf9..88b9609 100644
--- a/sys/nfsclient/nfs_lock.c
+++ b/sys/nfsclient/nfs_lock.c
@@ -51,6 +51,8 @@ __FBSDID("$FreeBSD$");
 
 #include <net/if.h>
 
+#include <rpc/rpcclnt.h>
+
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
 #include <nfsclient/nfs.h>
diff --git a/sys/nfsclient/nfs_nfsiod.c b/sys/nfsclient/nfs_nfsiod.c
index c33b950..6ebd053 100644
--- a/sys/nfsclient/nfs_nfsiod.c
+++ b/sys/nfsclient/nfs_nfsiod.c
@@ -66,6 +66,9 @@ __FBSDID("$FreeBSD$");
 
 #include <netinet/in.h>
 #include <netinet/tcp.h>
+
+#include <rpc/rpcclnt.h>
+
 #include <nfs/xdr_subs.h>
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
diff --git a/sys/nfsclient/nfs_node.c b/sys/nfsclient/nfs_node.c
index fc3520f..3dd3d03 100644
--- a/sys/nfsclient/nfs_node.c
+++ b/sys/nfsclient/nfs_node.c
@@ -53,6 +53,8 @@ __FBSDID("$FreeBSD$");
 
 #include <vm/uma.h>
 
+#include <rpc/rpcclnt.h>
+
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
 #include <nfsclient/nfs.h>
@@ -182,7 +184,7 @@ nfs_nget(struct mount *mntp, nfsfh_t *fhp, int fhsize, struct nfsnode **npp)
 
 	/*
 	 * Calculate nfs mount point and figure out whether the rslock should
-	 * be interruptable or not.
+	 * be interruptible or not.
 	 */
 	nmp = VFSTONFS(mntp);
 	if (nmp->nm_flag & NFSMNT_INT)
@@ -226,7 +228,10 @@ loop:
 	 */
 	np = uma_zalloc(nfsnode_zone, M_WAITOK);
 
-	error = getnewvnode("nfs", mntp, nfs_vnodeop_p, &nvp);
+	if (nmp->nm_flag & NFSMNT_NFSV4)
+		error = getnewvnode("nfs4", mntp, nfs4_vnodeop_p, &nvp);
+	else
+		error = getnewvnode("nfs", mntp, nfs_vnodeop_p, &nvp);
 	if (error) {
 		if (nfs_node_hash_lock < 0)
 			wakeup(&nfs_node_hash_lock);
@@ -295,7 +300,7 @@ nfs_inactive(struct vop_inactive_args *ap)
 		/*
 		 * Remove the silly file that was rename'd earlier
 		 */
-		nfs_removeit(sp);
+		(sp->s_removeit)(sp);
 		crfree(sp->s_cred);
 		vrele(sp->s_dvp);
 		FREE((caddr_t)sp, M_NFSREQ);
diff --git a/sys/nfsclient/nfs_socket.c b/sys/nfsclient/nfs_socket.c
index 9c82759..d74ae8e 100644
--- a/sys/nfsclient/nfs_socket.c
+++ b/sys/nfsclient/nfs_socket.c
@@ -65,6 +65,8 @@ __FBSDID("$FreeBSD$");
 #include <netinet/in.h>
 #include <netinet/tcp.h>
 
+#include <rpc/rpcclnt.h>
+
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
 #include <nfsclient/nfs.h>
@@ -73,6 +75,8 @@ __FBSDID("$FreeBSD$");
 #include <nfsclient/nfsmount.h>
 #include <nfsclient/nfsnode.h>
 
+#include <nfs4client/nfs4.h>
+
 #define	TRUE	1
 #define	FALSE	0
 
@@ -874,6 +878,8 @@ nfs_request(struct vnode *vp, struct mbuf *mrest, int procnum,
 		return (ESTALE);
 	}
 	nmp = VFSTONFS(vp->v_mount);
+	if ((nmp->nm_flag & NFSMNT_NFSV4) != 0)
+		return nfs4_request(vp, mrest, procnum, td, cred, mrp, mdp, dposp);
 	MALLOC(rep, struct nfsreq *, sizeof(struct nfsreq), M_NFSREQ, M_WAITOK);
 	rep->r_nmp = nmp;
 	rep->r_vp = vp;
@@ -1235,6 +1241,8 @@ nfs_sigintr(struct nfsmount *nmp, struct nfsreq *rep, struct thread *td)
 	struct proc *p;
 	sigset_t tmpset;
 
+	if ((nmp->nm_flag & NFSMNT_NFSV4) != 0)
+		return nfs4_sigintr(nmp, rep, td);
 	if (rep && (rep->r_flags & R_SOFTTERM))
 		return (EINTR);
 	/* Terminate all requests while attempting a forced unmount. */
diff --git a/sys/nfsclient/nfs_subs.c b/sys/nfsclient/nfs_subs.c
index 7b8866e..8d4a3df 100644
--- a/sys/nfsclient/nfs_subs.c
+++ b/sys/nfsclient/nfs_subs.c
@@ -67,6 +67,8 @@ __FBSDID("$FreeBSD$");
 #include <vm/vm_extern.h>
 #include <vm/uma.h>
 
+#include <rpc/rpcclnt.h>
+
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
 #include <nfsclient/nfs.h>
@@ -761,6 +763,10 @@ nfs_invaldir(struct vnode *vp)
 	if (vp->v_type != VDIR)
 		panic("nfs: invaldir not dir");
 #endif
+	if ((VFSTONFS(vp->v_mount)->nm_flag & NFSMNT_NFSV4) != 0) {
+		nfs4_invaldir(vp);
+		return;
+	}
 	np->n_direofoffset = 0;
 	np->n_cookieverf.nfsuquad[0] = 0;
 	np->n_cookieverf.nfsuquad[1] = 0;
diff --git a/sys/nfsclient/nfs_vfsops.c b/sys/nfsclient/nfs_vfsops.c
index b53a200..7ee48ab 100644
--- a/sys/nfsclient/nfs_vfsops.c
+++ b/sys/nfsclient/nfs_vfsops.c
@@ -66,6 +66,8 @@ __FBSDID("$FreeBSD$");
 #include <net/route.h>
 #include <netinet/in.h>
 
+#include <rpc/rpcclnt.h>
+
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
 #include <nfsclient/nfs.h>
diff --git a/sys/nfsclient/nfs_vnops.c b/sys/nfsclient/nfs_vnops.c
index 692ab89..60acab0 100644
--- a/sys/nfsclient/nfs_vnops.c
+++ b/sys/nfsclient/nfs_vnops.c
@@ -69,6 +69,8 @@ __FBSDID("$FreeBSD$");
 
 #include <fs/fifofs/fifo.h>
 
+#include <rpc/rpcclnt.h>
+
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
 #include <nfsclient/nfs.h>
@@ -2397,6 +2399,7 @@ nfs_sillyrename(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
 		M_NFSREQ, M_WAITOK);
 	sp->s_cred = crhold(cnp->cn_cred);
 	sp->s_dvp = dvp;
+	sp->s_removeit = nfs_removeit;
 	VREF(dvp);
 
 	/* Fudge together a funny name */
diff --git a/sys/nfsclient/nfsargs.h b/sys/nfsclient/nfsargs.h
index 7f4c636..5cd0e9e 100644
--- a/sys/nfsclient/nfsargs.h
+++ b/sys/nfsclient/nfsargs.h
@@ -95,5 +95,7 @@ struct nfs_args {
 #define	NFSMNT_ACDIRMIN		0x00100000
 #define	NFSMNT_ACDIRMAX		0x00200000
 #define	NFSMNT_NOLOCKD		0x00400000 /* Locks are local */
+#define	NFSMNT_NFSV4		0x00800000 /* Use NFS Version 4 protocol */
+#define	NFSMNT_HASWRITEVERF	0x01000000 /* NFSv4 Write verifier */
 
 #endif
diff --git a/sys/nfsclient/nfsm_subs.h b/sys/nfsclient/nfsm_subs.h
index f626dd4..ee9d215 100644
--- a/sys/nfsclient/nfsm_subs.h
+++ b/sys/nfsclient/nfsm_subs.h
@@ -147,6 +147,17 @@ do { \
 	} \
 } while (0)
 
+#define	nfsm_request_mnt(n, t, p, c) \
+do { \
+	error = nfs4_request_mnt((n), mreq, (t), (p), (c), &mrep, &md, &dpos); \
+	if (error != 0) { \
+		if (error & NFSERR_RETERR) \
+			error &= ~NFSERR_RETERR; \
+		else \
+			goto nfsmout; \
+	} \
+} while (0)
+
 /* *********************************** */
 /* Reply interpretation phase macros */
 
diff --git a/sys/nfsclient/nfsmount.h b/sys/nfsclient/nfsmount.h
index 8c531cb..485885a 100644
--- a/sys/nfsclient/nfsmount.h
+++ b/sys/nfsclient/nfsmount.h
@@ -50,8 +50,9 @@ struct	nfsmount {
 	int	nm_state;		/* Internal state flags */
 	struct	mount *nm_mountp;	/* Vfs structure for this filesystem */
 	int	nm_numgrps;		/* Max. size of groupslist */
-	u_char	nm_fh[NFSX_V3FHMAX];	/* File handle of root dir */
+	u_char	nm_fh[NFSX_V4FH];	/* File handle of root dir */
 	int	nm_fhsize;		/* Size of root file handle */
+	struct	rpcclnt nm_rpcclnt;	/* rpc state */
 	struct	socket *nm_so;		/* Rpc socket */
 	int	nm_sotype;		/* Type of socket */
 	int	nm_soproto;		/* and protocol */
@@ -79,6 +80,12 @@ struct	nfsmount {
 	short	nm_bufqwant;		/* process wants to add to the queue */
 	int	nm_bufqiods;		/* number of iods processing queue */
 	u_int64_t nm_maxfilesize;	/* maximum file size */
+
+	/* NFSv4 */
+	uint64_t nm_clientid;
+	fsid_t	nm_fsid;
+	u_int	nm_lease_time;
+	time_t	nm_last_renewal;
 };
 
 #if defined(_KERNEL)
diff --git a/sys/nfsclient/nfsnode.h b/sys/nfsclient/nfsnode.h
index f74d99f..76019cd 100644
--- a/sys/nfsclient/nfsnode.h
+++ b/sys/nfsclient/nfsnode.h
@@ -51,6 +51,7 @@
 struct sillyrename {
 	struct	ucred *s_cred;
 	struct	vnode *s_dvp;
+	int	(*s_removeit)(struct sillyrename *sp);
 	long	s_namlen;
 	char	s_name[20];
 };
@@ -68,9 +69,15 @@ struct sillyrename {
 struct nfsdmap {
 	LIST_ENTRY(nfsdmap)	ndm_list;
 	int			ndm_eocookie;
-	nfsuint64		ndm_cookies[NFSNUMCOOKIES];
+	union {
+		nfsuint64	ndmu3_cookies[NFSNUMCOOKIES];
+		uint64_t	ndmu4_cookies[NFSNUMCOOKIES];
+	} ndm_un1;
 };
 
+#define ndm_cookies	ndm_un1.ndmu3_cookies
+#define ndm4_cookies	ndm_un1.ndmu4_cookies
+
 /*
  * The nfsnode is the nfs equivalent to ufs's inode. Any similarity
  * is purely coincidental.
@@ -99,11 +106,13 @@ struct nfsnode {
 	time_t			n_expiry;	/* Lease expiry time */
 	nfsfh_t			*n_fhp;		/* NFS File Handle */
 	struct vnode		*n_vnode;	/* associated vnode */
+	struct vnode		*n_dvp;		/* parent vnode */
 	struct lockf		*n_lockf;	/* Locking record of file */
 	int			n_error;	/* Save write error value */
 	union {
 		struct timespec	nf_atim;	/* Special file times */
 		nfsuint64	nd_cookieverf;	/* Cookie verifier (dir only) */
+		u_char		nd4_cookieverf[NFSX_V4VERF];
 	} n_un1;
 	union {
 		struct timespec	nf_mtim;
@@ -117,12 +126,21 @@ struct nfsnode {
 	short			n_flag;		/* Flag for locking.. */
 	nfsfh_t			n_fh;		/* Small File Handle */
 	struct lock		n_rslock;
+	struct nfs4_fctx	n_rfc;
+	struct nfs4_fctx	n_wfc;
+	/*
+	 * The last component name is needed for the NFSv4 OPEN
+	 * operation.
+	 */
+	u_char			*n_name;
+	uint32_t		n_namelen;
 };
 
 #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 n4_cookieverf	n_un1.nd4_cookieverf
 #define n_direofoffset	n_un2.nd_direof
 #define n_cookies	n_un3.nd_cook
 
@@ -137,6 +155,8 @@ struct nfsnode {
 #define	NACC		0x0100	/* Special file accessed */
 #define	NUPD		0x0200	/* Special file updated */
 #define	NCHG		0x0400	/* Special file times changed */
+#define	NCREATED	0x0800	/* Opened by nfs_create() */
+#define	NTRUNCATE	0x1000	/* Opened by nfs_setattr() */
 
 /*
  * Convert between nfsnode pointers and vnode pointers
@@ -182,6 +202,10 @@ extern	vop_t	**fifo_nfsnodeop_p;
 extern	vop_t	**nfs_vnodeop_p;
 extern	vop_t	**spec_nfsnodeop_p;
 
+extern	vop_t	**fifo_nfs4nodeop_p;
+extern	vop_t	**nfs4_vnodeop_p;
+extern	vop_t	**spec_nfs4nodeop_p;
+
 /*
  * Prototypes for NFS vnode operations
  */
@@ -193,9 +217,12 @@ int	nfs_reclaim(struct vop_reclaim_args *);
 
 /* other stuff */
 int	nfs_removeit(struct sillyrename *);
+int	nfs4_removeit(struct sillyrename *);
 int	nfs_nget(struct mount *, nfsfh_t *, int, struct nfsnode **);
 nfsuint64 *nfs_getcookie(struct nfsnode *, off_t, int);
+uint64_t *nfs4_getcookie(struct nfsnode *, off_t, int);
 void	nfs_invaldir(struct vnode *);
+void	nfs4_invaldir(struct vnode *);
 
 #endif /* _KERNEL */
 
diff --git a/sys/rpc/rpcclnt.c b/sys/rpc/rpcclnt.c
new file mode 100644
index 0000000..4f61f29
--- /dev/null
+++ b/sys/rpc/rpcclnt.c
@@ -0,0 +1,2083 @@
+/* $FreeBSD$ */
+/* $Id: rpcclnt.c,v 1.9 2003/11/05 14:59:03 rees Exp $ */
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+/*
+ * Copyright (c) 1989, 1991, 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_socket.c	8.5 (Berkeley) 3/30/95
+ */
+
+/* XXX: kill ugly debug strings */
+/* XXX: get rid of proct, as it is not even being used... (or keep it so v{2,3}
+ *      can run, but clean it up! */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/proc.h>
+#include <sys/mount.h>
+#include <sys/kernel.h>
+#include <sys/mbuf.h>
+#include <sys/syslog.h>
+#include <sys/malloc.h>
+#include <sys/uio.h>
+#include <sys/lock.h>
+#include <sys/signalvar.h>
+#include <sys/sysent.h>
+#include <sys/syscall.h>
+#include <sys/sysctl.h>
+
+#include <sys/domain.h>
+#include <sys/protosw.h>
+#include <sys/socket.h>
+#include <sys/socketvar.h>
+#include <sys/mutex.h>
+
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+
+#include <nfs/rpcv2.h>
+
+#include <rpc/rpcm_subs.h>
+#include <rpc/rpcclnt.h>
+
+/* memory management */
+#ifdef __OpenBSD__
+struct pool     rpctask_pool;
+struct pool     rpcclnt_pool;
+#define RPCTASKPOOL_LWM 10
+#define RPCTASKPOOL_HWM 40
+#else
+static          MALLOC_DEFINE(M_RPC, "rpcclnt", "rpc state");
+#endif
+
+#define RPC_RETURN(X) do { RPCDEBUG("returning %d", X); return X; }while(0)
+
+/*
+ * Estimate rto for an nfs rpc sent via. an unreliable datagram. Use the mean
+ * and mean deviation of rtt for the appropriate type of rpc for the frequent
+ * rpcs and a default for the others. The justification for doing "other"
+ * this way is that these rpcs happen so infrequently that timer est. would
+ * probably be stale. Also, since many of these rpcs are non-idempotent, a
+ * conservative timeout is desired. getattr, lookup - A+2D read, write     -
+ * A+4D other           - nm_timeo
+ */
+#define	RPC_RTO(n, t) \
+	((t) == 0 ? (n)->rc_timeo : \
+	 ((t) < 3 ? \
+	  (((((n)->rc_srtt[t-1] + 3) >> 2) + (n)->rc_sdrtt[t-1] + 1) >> 1) : \
+	  ((((n)->rc_srtt[t-1] + 7) >> 3) + (n)->rc_sdrtt[t-1] + 1)))
+
+#define	RPC_SRTT(s,r)	(r)->r_rpcclnt->rc_srtt[rpcclnt_proct((s),\
+				(r)->r_procnum) - 1]
+
+#define	RPC_SDRTT(s,r)	(r)->r_rpcclnt->rc_sdrtt[rpcclnt_proct((s),\
+				(r)->r_procnum) - 1]
+
+
+/*
+ * There is a congestion window for outstanding rpcs maintained per mount
+ * point. The cwnd size is adjusted in roughly the way that: Van Jacobson,
+ * Congestion avoidance and Control, In "Proceedings of SIGCOMM '88". ACM,
+ * August 1988. describes for TCP. The cwnd size is chopped in half on a
+ * retransmit timeout and incremented by 1/cwnd when each rpc reply is
+ * received and a full cwnd of rpcs is in progress. (The sent count and cwnd
+ * are scaled for integer arith.) Variants of "slow start" were tried and
+ * were found to be too much of a performance hit (ave. rtt 3 times larger),
+ * I suspect due to the large rtt that nfs rpcs have.
+ */
+#define	RPC_CWNDSCALE	256
+#define	RPC_MAXCWND	(RPC_CWNDSCALE * 32)
+static int      rpcclnt_backoff[8] = {2, 4, 8, 16, 32, 64, 128, 256,};
+
+/* XXX ugly debug strings */
+#define RPC_ERRSTR_ACCEPTED_SIZE 6
+char *rpc_errstr_accepted[RPC_ERRSTR_ACCEPTED_SIZE] = {
+	"",			/* no good message... */
+	"remote server hasn't exported program.",
+	"remote server can't support version number.",
+	"program can't support procedure.",
+	"procedure can't decode params.",
+	"remote error.  remote side memory allocation failure?"
+};
+
+char *rpc_errstr_denied[2] = {
+	"remote server doesnt support rpc version 2!",
+	"remote server authentication error."
+};
+
+#define RPC_ERRSTR_AUTH_SIZE 6
+char *rpc_errstr_auth[RPC_ERRSTR_AUTH_SIZE] = {
+	"",
+	"auth error: bad credential (seal broken).",
+	"auth error: client must begin new session.",
+	"auth error: bad verifier (seal broken).",
+	"auth error: verifier expired or replayed.",
+	"auth error: rejected for security reasons.",
+};
+
+/*
+ * Static data, mostly RPC constants in XDR form
+ */
+static u_int32_t rpc_reply, rpc_call, rpc_vers;
+
+/*
+ * rpc_msgdenied, rpc_mismatch, rpc_auth_unix, rpc_msgaccepted,
+ * rpc_autherr, rpc_auth_kerb;
+ */
+
+static u_int32_t rpcclnt_xid = 0;
+static u_int32_t rpcclnt_xid_touched = 0;
+struct rpcstats rpcstats;
+int      rpcclnt_ticks;
+
+SYSCTL_NODE(_kern, OID_AUTO, rpc, CTLFLAG_RD, 0, "RPC Subsystem");
+
+SYSCTL_UINT(_kern_rpc, OID_AUTO, retries, CTLFLAG_RD, &rpcstats.rpcretries, 0, "retries");
+SYSCTL_UINT(_kern_rpc, OID_AUTO, request, CTLFLAG_RD, &rpcstats.rpcrequests, 0, "request");
+SYSCTL_UINT(_kern_rpc, OID_AUTO, timeouts, CTLFLAG_RD, &rpcstats.rpctimeouts, 0, "timeouts");
+SYSCTL_UINT(_kern_rpc, OID_AUTO, unexpected, CTLFLAG_RD, &rpcstats.rpcunexpected, 0, "unexpected");
+SYSCTL_UINT(_kern_rpc, OID_AUTO, invalid, CTLFLAG_RD, &rpcstats.rpcinvalid, 0, "invalid");
+
+
+#ifdef RPCCLNT_DEBUG
+int             rpcdebugon = 0;
+SYSCTL_UINT(_kern_rpc, OID_AUTO, debug_on, CTLFLAG_RW, &rpcdebugon, 0, "RPC Debug messages");
+#endif
+
+/*
+ * Queue head for rpctask's
+ */
+static 
+TAILQ_HEAD(, rpctask) rpctask_q;
+struct callout_handle rpcclnt_timer_handle;
+
+#ifdef __OpenBSD__
+static int             rpcclnt_send(struct socket *, struct mbuf *, struct mbuf *, struct rpctask *);
+static int             rpcclnt_receive(struct rpctask *, struct mbuf **, struct mbuf **, RPC_EXEC_CTX);
+#else
+static int             rpcclnt_send(struct socket *, struct sockaddr *, struct mbuf *, struct rpctask *);
+static int             rpcclnt_receive(struct rpctask *, struct sockaddr **, struct mbuf **, RPC_EXEC_CTX);
+#endif
+
+static int             rpcclnt_msg(RPC_EXEC_CTX, const char *, char *);
+
+static int             rpcclnt_reply(struct rpctask *, RPC_EXEC_CTX);
+static void            rpcclnt_timer(void *);
+static int             rpcclnt_sndlock(int *, struct rpctask *);
+static void            rpcclnt_sndunlock(int *);
+static int             rpcclnt_rcvlock(struct rpctask *);
+static void            rpcclnt_rcvunlock(int *);
+#if 0
+void            rpcclnt_realign(struct mbuf *, int);
+#else
+static void	rpcclnt_realign(struct mbuf **, int);
+#endif
+
+static struct mbuf    *rpcclnt_buildheader(struct rpcclnt *, int, struct mbuf *, u_int32_t, int *, struct mbuf **, struct ucred *);
+static int             rpcm_disct(struct mbuf **, caddr_t *, int, int, caddr_t *);
+static u_int32_t       rpcclnt_proct(struct rpcclnt *, u_int32_t);
+static int             rpc_adv(struct mbuf **, caddr_t *, int, int);
+static void     rpcclnt_softterm(struct rpctask * task);
+
+static int rpcauth_buildheader(struct rpc_auth * auth, struct ucred *, struct mbuf **, caddr_t *);
+
+void
+rpcclnt_init(void)
+{
+#ifdef __OpenBSD__
+	static struct timeout rpcclnt_timer_to;
+#endif
+
+	rpcclnt_ticks = (hz * RPC_TICKINTVL + 500) / 1000;
+	if (rpcclnt_ticks < 1)
+		rpcclnt_ticks = 1;
+	rpcstats.rpcretries = 0;
+	rpcstats.rpcrequests = 0;
+	rpcstats.rpctimeouts = 0;
+	rpcstats.rpcunexpected = 0;
+	rpcstats.rpcinvalid = 0;
+
+	/*
+	 * rpc constants how about actually using more than one of these!
+	 */
+
+	rpc_reply = txdr_unsigned(RPC_REPLY);
+	rpc_vers = txdr_unsigned(RPC_VER2);
+	rpc_call = txdr_unsigned(RPC_CALL);
+#if 0
+	rpc_msgdenied = txdr_unsigned(RPC_MSGDENIED);
+	rpc_msgaccepted = txdr_unsigned(RPC_MSGACCEPTED);
+	rpc_mismatch = txdr_unsigned(RPC_MISMATCH);
+	rpc_autherr = txdr_unsigned(RPC_AUTHERR);
+	rpc_auth_unix = txdr_unsigned(RPCAUTH_UNIX);
+	rpc_auth_kerb = txdr_unsigned(RPCAUTH_KERB4);
+#endif
+
+	/* initialize rpctask queue */
+	TAILQ_INIT(&rpctask_q);
+
+#ifdef __OpenBSD__
+	/* initialize pools */
+	pool_init(&rpctask_pool, sizeof(struct rpctask), 0, 0, RPCTASKPOOL_LWM,
+		  "rpctask_p", NULL);
+	pool_setlowat(&rpctask_pool, RPCTASKPOOL_LWM);
+	pool_sethiwat(&rpctask_pool, RPCTASKPOOL_HWM);
+
+	pool_init(&rpcclnt_pool, sizeof(struct rpcclnt), 0, 0, 1, "rpcclnt_p", NULL);
+
+	/* initialize timers */
+	timeout_set(&rpcclnt_timer_to, rpcclnt_timer, &rpcclnt_timer_to);
+	rpcclnt_timer(&rpcclnt_timer_to);
+#else /* !__OpenBSD__ */
+	rpcclnt_timer(NULL);
+
+#endif /* !__OpenBSD__ */
+
+	RPCDEBUG("rpc initialed");
+
+	return;
+}
+
+void
+rpcclnt_uninit(void)
+{
+  	RPCDEBUG("uninit");
+	untimeout(rpcclnt_timer, (void *)NULL, rpcclnt_timer_handle);
+
+	/* XXX delete sysctl variables? */
+}
+
+int
+rpcclnt_setup(clnt, program, addr, sotype, soproto, auth, max_read_size, max_write_size, flags)
+    struct rpcclnt * clnt;
+    struct rpc_program * program;
+    struct sockaddr * addr;
+    int sotype;
+    int soproto;
+    struct rpc_auth * auth;
+    int max_read_size;
+    int max_write_size;
+    int flags;
+{
+	if (clnt == NULL || program == NULL || addr == NULL || auth == NULL)
+	  RPC_RETURN (EFAULT);
+
+	if (program->prog_name == NULL)
+	  RPC_RETURN (EFAULT);
+	clnt->rc_prog = program;
+
+	clnt->rc_name = addr;
+	clnt->rc_sotype = sotype;
+	clnt->rc_soproto = soproto;
+	clnt->rc_auth = auth;
+	clnt->rc_rsize = max_read_size;
+	clnt->rc_wsize = max_write_size;
+	clnt->rc_flag = flags;
+
+	clnt->rc_proctlen = 0;
+	clnt->rc_proct = NULL;
+
+	RPC_RETURN (0);
+}
+
+/*
+ * Initialize sockets and congestion for a new RPC connection. We do not free
+ * the sockaddr if error.
+ */
+int
+rpcclnt_connect(rpc, td)
+	struct rpcclnt *rpc;
+	RPC_EXEC_CTX td;
+{
+	struct socket  *so;
+	int             s, error, rcvreserve, sndreserve;
+	struct sockaddr *saddr;
+
+#ifdef __OpenBSD__
+	struct sockaddr_in *sin;
+	struct mbuf    *m;
+#else
+	struct sockaddr_in sin;
+
+	int             soarg;
+	struct sockopt  opt;
+#endif
+
+	if (rpc == NULL) {
+		RPCDEBUG("no rpcclnt struct!\n");
+		RPC_RETURN(EFAULT);
+	}
+
+	GIANT_REQUIRED;		/* XXX until socket locking done */
+
+	/* create the socket */
+	rpc->rc_so = NULL;
+
+	saddr = rpc->rc_name;
+
+	error = socreate(saddr->sa_family, &rpc->rc_so, rpc->rc_sotype,
+			 rpc->rc_soproto, td->td_ucred, td);
+
+	if (error) {
+		RPCDEBUG("error %d in socreate()", error);
+		RPC_RETURN(error);
+	}
+	so = rpc->rc_so;
+	rpc->rc_soflags = so->so_proto->pr_flags;
+
+	/*
+	 * Some servers require that the client port be a reserved port
+	 * number. We always allocate a reserved port, as this prevents
+	 * filehandle disclosure through UDP port capture.
+	 */
+	if (saddr->sa_family == AF_INET) {
+#ifdef __OpenBSD__
+		struct mbuf    *mopt;
+		int            *ip;
+#endif
+
+#ifdef __OpenBSD__
+		MGET(mopt, M_TRYWAIT, MT_SOOPTS);
+		mopt->m_len = sizeof(int);
+		ip = mtod(mopt, int *);
+		*ip = IP_PORTRANGE_LOW;
+
+		error = sosetopt(so, IPPROTO_IP, IP_PORTRANGE, mopt);
+#else
+		soarg = IP_PORTRANGE_LOW;
+		bzero(&opt, sizeof(struct sockopt));
+		opt.sopt_dir = SOPT_SET;
+		opt.sopt_level = IPPROTO_IP;
+		opt.sopt_name = IP_PORTRANGE;
+		opt.sopt_val = &soarg;
+		opt.sopt_valsize = sizeof(soarg);
+
+		error = sosetopt(so, &opt);
+#endif
+		if (error)
+			goto bad;
+
+#if __OpenBSD__
+		MGET(m, M_TRYWAIT, MT_SONAME);
+		sin = mtod(m, struct sockaddr_in *);
+		sin->sin_len = m->m_len = sizeof(struct sockaddr_in);
+		sin->sin_family = AF_INET;
+		sin->sin_addr.s_addr = INADDR_ANY;
+		sin->sin_port = htons(0);
+		error = sobind(so, m);
+		m_freem(m);
+#else
+		sin.sin_len = sizeof(struct sockaddr_in);
+		sin.sin_family = AF_INET;
+		sin.sin_addr.s_addr = INADDR_ANY;
+		sin.sin_port = htons(0);
+		error = sobind(so, (struct sockaddr *) & sin, td);
+#endif
+		if (error)
+			goto bad;
+
+#if __OpenBSD__
+		MGET(mopt, M_TRYWAIT, MT_SOOPTS);
+		mopt->m_len = sizeof(int);
+		ip = mtod(mopt, int *);
+		*ip = IP_PORTRANGE_DEFAULT;
+		error = sosetopt(so, IPPROTO_IP, IP_PORTRANGE, mopt);
+#else
+		soarg = IP_PORTRANGE_DEFAULT;
+		bzero(&opt, sizeof(struct sockopt));
+		opt.sopt_dir = SOPT_SET;
+		opt.sopt_level = IPPROTO_IP;
+		opt.sopt_name = IP_PORTRANGE;
+		opt.sopt_val = &soarg;
+		opt.sopt_valsize = sizeof(soarg);
+		error = sosetopt(so, &opt);
+#endif
+		if (error)
+			goto bad;
+	}
+	/*
+	 * Protocols that do not require connections may be optionally left
+	 * unconnected for servers that reply from a port other than
+	 * NFS_PORT.
+	 */
+	if (rpc->rc_flag & RPCCLNT_NOCONN) {
+		if (rpc->rc_soflags & PR_CONNREQUIRED) {
+			error = ENOTCONN;
+			goto bad;
+		}
+	} else {
+		error = soconnect(so, saddr, td);
+		if (error)
+			goto bad;
+
+		/*
+		 * 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.
+		 */
+#ifdef __OpenBSD__
+		s = splsoftnet();
+#else
+		s = splnet();
+#endif
+		while ((so->so_state & SS_ISCONNECTING) && so->so_error == 0) {
+			(void)tsleep((caddr_t) & so->so_timeo, PSOCK,
+				     "rpc", 2 * hz);
+
+			/*
+			 * XXX needs to catch interrupt signals. something
+			 * like this: if ((so->so_state & SS_ISCONNECTING) &&
+			 * so->so_error == 0 && rep && (error =
+			 * nfs_sigintr(nmp, rep, rep->r_td)) != 0) {
+			 * so->so_state &= ~SS_ISCONNECTING; splx(s); goto
+			 * bad; }
+			 */
+		}
+		if (so->so_error) {
+			error = so->so_error;
+			so->so_error = 0;
+			splx(s);
+			goto bad;
+		}
+		splx(s);
+	}
+	if (rpc->rc_flag & (RPCCLNT_SOFT | RPCCLNT_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;
+	}
+
+
+	if (rpc->rc_sotype == SOCK_DGRAM) {
+		sndreserve = rpc->rc_wsize + RPC_MAXPKTHDR;
+		rcvreserve = rpc->rc_rsize + RPC_MAXPKTHDR;
+	} else if (rpc->rc_sotype == SOCK_SEQPACKET) {
+		sndreserve = (rpc->rc_wsize + RPC_MAXPKTHDR) * 2;
+		rcvreserve = (rpc->rc_rsize + RPC_MAXPKTHDR) * 2;
+	} else {
+		if (rpc->rc_sotype != SOCK_STREAM)
+			panic("rpcclnt_connect() bad sotype");
+		if (so->so_proto->pr_flags & PR_CONNREQUIRED) {
+#ifdef __OpenBSD__
+			MGET(m, M_TRYWAIT, MT_SOOPTS);
+			*mtod(m, int32_t *) = 1;
+			m->m_len = sizeof(int32_t);
+			sosetopt(so, SOL_SOCKET, SO_KEEPALIVE, m);
+#else
+			soarg = 1;
+
+			bzero(&opt, sizeof(struct sockopt));
+			opt.sopt_dir = SOPT_SET;
+			opt.sopt_level = SOL_SOCKET;
+			opt.sopt_name = SO_KEEPALIVE;
+			opt.sopt_val = &soarg;
+			opt.sopt_valsize = sizeof(soarg);
+			sosetopt(so, &opt);
+#endif
+		}
+		if (so->so_proto->pr_protocol == IPPROTO_TCP) {
+#ifdef __OpenBSD__
+			MGET(m, M_TRYWAIT, MT_SOOPTS);
+			*mtod(m, int32_t *) = 1;
+			m->m_len = sizeof(int32_t);
+			sosetopt(so, IPPROTO_TCP, TCP_NODELAY, m);
+#else
+			soarg = 1;
+
+			bzero(&opt, sizeof(struct sockopt));
+			opt.sopt_dir = SOPT_SET;
+			opt.sopt_level = IPPROTO_TCP;
+			opt.sopt_name = TCP_NODELAY;
+			opt.sopt_val = &soarg;
+			opt.sopt_valsize = sizeof(soarg);
+			sosetopt(so, &opt);
+#endif
+		}
+		sndreserve = (rpc->rc_wsize + RPC_MAXPKTHDR +
+			      sizeof(u_int32_t)) * 2;
+		rcvreserve = (rpc->rc_rsize + RPC_MAXPKTHDR +
+			      sizeof(u_int32_t)) * 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 */
+	rpc->rc_srtt[0] = rpc->rc_srtt[1] = rpc->rc_srtt[2] = rpc->rc_srtt[3] =
+		rpc->rc_srtt[4] = (RPC_TIMEO << 3);
+	rpc->rc_sdrtt[0] = rpc->rc_sdrtt[1] = rpc->rc_sdrtt[2] =
+		rpc->rc_sdrtt[3] = rpc->rc_sdrtt[4] = 0;
+	rpc->rc_cwnd = RPC_MAXCWND / 2;	/* Initial send window */
+	rpc->rc_sent = 0;
+	rpc->rc_timeouts = 0;
+	RPC_RETURN(0);
+
+bad:
+	rpcclnt_disconnect(rpc);
+	RPC_RETURN(error);
+}
+
+
+/*
+ * Reconnect routine: Called when a connection is broken on a reliable
+ * protocol. - clean up the old socket - nfs_connect() again - set
+ * R_MUSTRESEND for all outstanding requests on mount point If this fails the
+ * mount point is DEAD! nb: Must be called with the nfs_sndlock() set on the
+ * mount point.
+ */
+int
+rpcclnt_reconnect(rep, td)
+	struct rpctask *rep;
+	RPC_EXEC_CTX td;
+{
+	struct rpctask *rp;
+	struct rpcclnt *rpc = rep->r_rpcclnt;
+	int             error;
+
+	rpcclnt_disconnect(rpc);
+	while ((error = rpcclnt_connect(rpc, td)) != 0) {
+		if (error == EINTR || error == ERESTART)
+			RPC_RETURN(EINTR);
+		tsleep(&lbolt, PSOCK, "rpccon", 0);
+	}
+
+	/*
+	 * Loop through outstanding request list and fix up all requests on
+	 * old socket.
+	 */
+	for (rp = TAILQ_FIRST(&rpctask_q); rp != NULL;
+	     rp = TAILQ_NEXT(rp, r_chain)) {
+		if (rp->r_rpcclnt == rpc)
+			rp->r_flags |= R_MUSTRESEND;
+	}
+	RPC_RETURN(0);
+}
+
+/*
+ * NFS disconnect. Clean up and unlink.
+ */
+void
+rpcclnt_disconnect(rpc)
+	struct rpcclnt *rpc;
+{
+	struct socket  *so;
+
+	GIANT_REQUIRED;		/* XXX until socket locking done */
+
+	if (rpc->rc_so) {
+		so = rpc->rc_so;
+		rpc->rc_so = NULL;
+		soshutdown(so, 2);
+		soclose(so);
+	}
+}
+
+void
+rpcclnt_safedisconnect(struct rpcclnt * rpc)
+{
+	struct rpctask  dummytask;
+
+	bzero(&dummytask, sizeof(dummytask));
+	dummytask.r_rpcclnt = rpc;
+	rpcclnt_rcvlock(&dummytask);
+	rpcclnt_disconnect(rpc);
+	rpcclnt_rcvunlock(&rpc->rc_flag);
+}
+
+/*
+ * This is the nfs send routine. For connection based socket types, it must
+ * be called with an nfs_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
+rpcclnt_send(so, nam, top, rep)
+	struct socket  *so;
+#ifdef __OpenBSD__
+	struct mbuf    *nam;
+#else
+	struct sockaddr *nam;
+#endif
+	struct mbuf    *top;
+	struct rpctask *rep;
+{
+#ifdef __OpenBSD__
+	struct mbuf    *sendnam;
+#else
+	struct sockaddr *sendnam;
+	struct thread  *td = curthread;
+#endif
+	int error, soflags, flags;
+
+	GIANT_REQUIRED;		/* XXX until socket locking done */
+
+	if (rep) {
+		if (rep->r_flags & R_SOFTTERM) {
+			m_freem(top);
+			RPC_RETURN(EINTR);
+		}
+		if ((so = rep->r_rpcclnt->rc_so) == NULL) {
+			rep->r_flags |= R_MUSTRESEND;
+			m_freem(top);
+			RPC_RETURN(0);
+		}
+		rep->r_flags &= ~R_MUSTRESEND;
+		soflags = rep->r_rpcclnt->rc_soflags;
+	} else
+		soflags = so->so_proto->pr_flags;
+
+	if ((soflags & PR_CONNREQUIRED) || (so->so_state & SS_ISCONNECTED))
+		sendnam = NULL;
+	else
+		sendnam = nam;
+
+	if (so->so_type == SOCK_SEQPACKET)
+		flags = MSG_EOR;
+	else
+		flags = 0;
+
+	error = sosend(so, sendnam, NULL, top, NULL, flags, td);
+
+	if (error) {
+		if (rep) {
+			log(LOG_INFO, "rpc send error %d for service %s\n", error,
+			    rep->r_rpcclnt->rc_prog->prog_name);
+			/*
+			 * Deal with errors for the client side.
+			 */
+			if (rep->r_flags & R_SOFTTERM)
+				error = EINTR;
+			else
+				rep->r_flags |= R_MUSTRESEND;
+		} else
+			log(LOG_INFO, "rpc service send error %d\n", error);
+
+		/*
+		 * Handle any recoverable (soft) socket errors here.
+		 */
+		if (error != EINTR && error != ERESTART &&
+		    error != EWOULDBLOCK && error != EPIPE)
+			error = 0;
+	}
+	RPC_RETURN(error);
+}
+
+/*
+ * Receive a Sun RPC Request/Reply. For SOCK_DGRAM, the work is all done by
+ * soreceive(), but for SOCK_STREAM we must deal with the Record Mark and
+ * consolidate the data into a new mbuf list. nb: Sometimes TCP passes the
+ * data up to soreceive() in long lists of small mbufs. For SOCK_STREAM we
+ * must be very careful to read an entire record once we have read any of it,
+ * even if the system call has been interrupted.
+ */
+static int
+rpcclnt_receive(rep, aname, mp, td)
+	struct rpctask *rep;
+#ifdef __OpenBSD__
+	struct mbuf   **aname;
+#else
+	struct sockaddr **aname;
+#endif
+	struct mbuf   **mp;
+	RPC_EXEC_CTX  td;
+{
+	struct socket  *so;
+	struct uio      auio;
+	struct iovec    aio;
+	struct mbuf    *m;
+	struct mbuf    *control;
+	u_int32_t       len;
+#ifdef __OpenBSD__
+	struct mbuf   **getnam;
+#else
+	struct sockaddr **getnam;
+#endif
+	int error, sotype, rcvflg;
+
+	GIANT_REQUIRED;		/* XXX until socket locking done */
+
+	/*
+	 * Set up arguments for soreceive()
+	 */
+	*mp = NULL;
+	*aname = NULL;
+	sotype = rep->r_rpcclnt->rc_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_DGRAM) {
+		error = rpcclnt_sndlock(&rep->r_rpcclnt->rc_flag, rep);
+		if (error)
+			RPC_RETURN(error);
+tryagain:
+		/*
+		 * Check for fatal errors and resending request.
+		 */
+		/*
+		 * Ugh: If a reconnect attempt just happened, rc_so would
+		 * have changed. NULL indicates a failed attempt that has
+		 * essentially shut down this mount point.
+		 */
+		if (rep->r_mrep || (rep->r_flags & R_SOFTTERM)) {
+			rpcclnt_sndunlock(&rep->r_rpcclnt->rc_flag);
+			RPC_RETURN(EINTR);
+		}
+		so = rep->r_rpcclnt->rc_so;
+		if (!so) {
+			error = rpcclnt_reconnect(rep, td);
+			if (error) {
+				rpcclnt_sndunlock(&rep->r_rpcclnt->rc_flag);
+				RPC_RETURN(error);
+			}
+			goto tryagain;
+		}
+		while (rep->r_flags & R_MUSTRESEND) {
+			m = m_copym(rep->r_mreq, 0, M_COPYALL, M_TRYWAIT);
+			rpcstats.rpcretries++;
+			error = rpcclnt_send(so, rep->r_rpcclnt->rc_name, m, rep);
+			if (error) {
+				if (error == EINTR || error == ERESTART ||
+				    (error = rpcclnt_reconnect(rep, td)) != 0) {
+					rpcclnt_sndunlock(&rep->r_rpcclnt->rc_flag);
+					RPC_RETURN(error);
+				}
+				goto tryagain;
+			}
+		}
+		rpcclnt_sndunlock(&rep->r_rpcclnt->rc_flag);
+		if (sotype == SOCK_STREAM) {
+			aio.iov_base = (caddr_t) & len;
+			aio.iov_len = sizeof(u_int32_t);
+			auio.uio_iov = &aio;
+			auio.uio_iovcnt = 1;
+			auio.uio_segflg = UIO_SYSSPACE;
+			auio.uio_rw = UIO_READ;
+			auio.uio_offset = 0;
+			auio.uio_resid = sizeof(u_int32_t);
+#ifdef __OpenBSD__
+			auio.uio_procp = td;
+#else
+			auio.uio_td = td;
+#endif
+			do {
+				rcvflg = MSG_WAITALL;
+				error = soreceive(so, NULL, &auio, NULL, NULL, &rcvflg);
+				if (error == EWOULDBLOCK && rep) {
+					if (rep->r_flags & R_SOFTTERM)
+						RPC_RETURN(EINTR);
+				}
+			} while (error == EWOULDBLOCK);
+			if (!error && auio.uio_resid > 0) {
+				log(LOG_INFO,
+				"short receive (%d/%d) from rpc server %s\n",
+				    sizeof(u_int32_t) - auio.uio_resid,
+				    sizeof(u_int32_t),
+				    rep->r_rpcclnt->rc_prog->prog_name);
+				error = EPIPE;
+			}
+			if (error)
+				goto errout;
+			len = ntohl(len) & ~0x80000000;
+			/*
+			 * This is SERIOUS! We are out of sync with the
+			 * sender and forcing a disconnect/reconnect is all I
+			 * can do.
+			 */
+			if (len > RPC_MAXPACKET) {
+				log(LOG_ERR, "%s (%d) from rpc server %s\n",
+				    "impossible packet length",
+				    len,
+				    rep->r_rpcclnt->rc_prog->prog_name);
+				error = EFBIG;
+				goto errout;
+			}
+			auio.uio_resid = len;
+			do {
+				rcvflg = MSG_WAITALL;
+				error = soreceive(so, NULL, &auio, mp, NULL, &rcvflg);
+			} while (error == EWOULDBLOCK || error == EINTR ||
+				 error == ERESTART);
+			if (!error && auio.uio_resid > 0) {
+				log(LOG_INFO,
+				"short receive (%d/%d) from rpc server %s\n",
+				    len - auio.uio_resid, len,
+				    rep->r_rpcclnt->rc_prog->prog_name);
+				error = EPIPE;
+			}
+		} else {
+			/*
+			 * NB: Since uio_resid is big, MSG_WAITALL is ignored
+			 * and soreceive() will return when it has either a
+			 * control msg or a data msg. We have no use for
+			 * control msg., but must grab them and then throw
+			 * them away so we know what is going on.
+			 */
+			auio.uio_resid = len = 100000000;	/* Anything Big */
+#ifdef __OpenBSD__
+			auio.uio_procp = td;
+#else
+			auio.uio_td = td;
+#endif
+			do {
+				rcvflg = 0;
+				error = soreceive(so, NULL, &auio, mp, &control, &rcvflg);
+				if (control)
+					m_freem(control);
+				if (error == EWOULDBLOCK && rep) {
+					if (rep->r_flags & R_SOFTTERM)
+						RPC_RETURN(EINTR);
+				}
+			} while (error == EWOULDBLOCK ||
+				 (!error && *mp == NULL && control));
+			if ((rcvflg & MSG_EOR) == 0)
+				printf("Egad!!\n");
+			if (!error && *mp == NULL)
+				error = EPIPE;
+			len -= auio.uio_resid;
+		}
+errout:
+		if (error && error != EINTR && error != ERESTART) {
+			m_freem(*mp);
+			*mp = (struct mbuf *) 0;
+			if (error != EPIPE)
+				log(LOG_INFO,
+				    "receive error %d from rpc server %s\n",
+				    error,
+				    rep->r_rpcclnt->rc_prog->prog_name);
+			error = rpcclnt_sndlock(&rep->r_rpcclnt->rc_flag, rep);
+			if (!error)
+				error = rpcclnt_reconnect(rep, td);
+			if (!error)
+				goto tryagain;
+		}
+	} else {
+		if ((so = rep->r_rpcclnt->rc_so) == NULL)
+			RPC_RETURN(EACCES);
+		if (so->so_state & SS_ISCONNECTED)
+			getnam = NULL;
+		else
+			getnam = aname;
+		auio.uio_resid = len = 1000000;
+#ifdef __OpenBSD__
+		auio.uio_procp = td;
+#else
+		auio.uio_td = td;
+#endif
+
+		do {
+			rcvflg = 0;
+			error = soreceive(so, getnam, &auio, mp, NULL, &rcvflg);
+			RPCDEBUG("soreceivce returns %d", error);
+			if (error == EWOULDBLOCK && (rep->r_flags & R_SOFTTERM)) {
+				RPCDEBUG("wouldblock && softerm -> EINTR");
+				RPC_RETURN(EINTR);
+			}
+		} while (error == EWOULDBLOCK);
+		len -= auio.uio_resid;
+	}
+	if (error) {
+		m_freem(*mp);
+		*mp = NULL;
+	} 
+
+	/*
+	 * Search for any mbufs that are not a multiple of 4 bytes
+	 * long or with m_data not longword aligned. These could
+	 * cause pointer alignment problems, so copy them to well
+	 * aligned mbufs.
+	 */
+	rpcclnt_realign(mp, 5 * RPCX_UNSIGNED);
+	RPC_RETURN(error);
+}
+
+
+/*
+ * 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
+rpcclnt_reply(myrep, td)
+	struct rpctask *myrep;
+	RPC_EXEC_CTX td;
+{
+	struct rpctask *rep;
+	struct rpcclnt *rpc = myrep->r_rpcclnt;
+	int32_t         t1;
+	struct mbuf    *mrep, *md;
+#ifdef __OpenBSD__
+	struct mbuf    *nam;
+#else
+	struct sockaddr *nam;
+#endif
+	u_int32_t       rxid, *tl;
+	caddr_t         dpos, cp2;
+	int             error;
+
+	/*
+	 * 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.
+		 */
+		error = rpcclnt_rcvlock(myrep);
+		if (error)
+			RPC_RETURN(error);
+		/* Already received, bye bye */
+		if (myrep->r_mrep != NULL) {
+			rpcclnt_rcvunlock(&rpc->rc_flag);
+			RPC_RETURN(0);
+		}
+		/*
+		 * Get the next Rpc reply off the socket
+		 */
+		error = rpcclnt_receive(myrep, &nam, &mrep, td);
+
+		rpcclnt_rcvunlock(&rpc->rc_flag);
+
+		if (error) {
+			/*
+			 * Ignore routing errors on connectionless
+			 * protocols??
+			 */
+			if (RPCIGNORE_SOERROR(rpc->rc_soflags, error)) {
+				rpc->rc_so->so_error = 0;
+				if (myrep->r_flags & R_GETONEREP)
+					RPC_RETURN(0);
+				RPCDEBUG("ingoring routing error on connectionless protocol.");
+				continue;
+			}
+			RPC_RETURN(error);
+		}
+#ifdef __OpenBSD__
+		if (nam)
+			m_freem(nam);
+#else
+		if (nam)
+			FREE(nam, M_SONAME);
+#endif
+
+		/*
+		 * Get the xid and check that it is an rpc reply
+		 */
+		md = mrep;
+		dpos = mtod(md, caddr_t);
+		rpcm_dissect(tl, u_int32_t *, 2 * RPCX_UNSIGNED);
+		rxid = *tl++;
+		if (*tl != rpc_reply) {
+			rpcstats.rpcinvalid++;
+			m_freem(mrep);
+	rpcmout:
+			if (myrep->r_flags & R_GETONEREP)
+				RPC_RETURN(0);
+			continue;
+		}
+		/*
+		 * Loop through the request list to match up the reply Iff no
+		 * match, just drop the datagram
+		 */
+		TAILQ_FOREACH(rep, &rpctask_q, r_chain) {
+			if (rep->r_mrep == NULL && rxid == rep->r_xid) {
+				/* Found it.. */
+				rep->r_mrep = mrep;
+				rep->r_md = md;
+				rep->r_dpos = dpos;
+
+				/*
+				 * Update congestion window. Do the additive
+				 * increase of one rpc/rtt.
+				 */
+				if (rpc->rc_cwnd <= rpc->rc_sent) {
+					rpc->rc_cwnd +=
+						(RPC_CWNDSCALE * RPC_CWNDSCALE +
+					(rpc->rc_cwnd >> 1)) / rpc->rc_cwnd;
+					if (rpc->rc_cwnd > RPC_MAXCWND)
+						rpc->rc_cwnd = RPC_MAXCWND;
+				}
+				rep->r_flags &= ~R_SENT;
+				rpc->rc_sent -= RPC_CWNDSCALE;
+				/*
+				 * Update rtt using a gain of 0.125 on the
+				 * mean and a gain of 0.25 on the deviation.
+				 */
+				if (rep->r_flags & R_TIMING) {
+					/*
+					 * Since the timer resolution of
+					 * NFS_HZ is so course, it can often
+					 * result in r_rtt == 0. Since r_rtt
+					 * == N means that the actual rtt is
+					 * between N+dt and N+2-dt ticks, add
+					 * 1.
+					 */
+					t1 = rep->r_rtt + 1;
+					t1 -= (RPC_SRTT(rpc, rep) >> 3);
+					RPC_SRTT(rpc, rep) += t1;
+					if (t1 < 0)
+						t1 = -t1;
+					t1 -= (RPC_SDRTT(rpc, rep) >> 2);
+					RPC_SDRTT(rpc, rep) += t1;
+				}
+				rpc->rc_timeouts = 0;
+				break;
+			}
+		}
+		/*
+		 * If not matched to a request, drop it. If it's mine, get
+		 * out.
+		 */
+		if (rep == 0) {
+			rpcstats.rpcunexpected++;
+			RPCDEBUG("rpc reply not matched\n");
+			m_freem(mrep);
+		} else if (rep == myrep) {
+			if (rep->r_mrep == NULL)
+				panic("rpcreply nil");
+			RPC_RETURN(0);
+		}
+		if (myrep->r_flags & R_GETONEREP)
+			RPC_RETURN(0);
+	}
+}
+
+/* XXX: ignores tryagain! */
+/*
+ * code from nfs_request - goes something like this - fill in task struct -
+ * links task into list - calls nfs_send() for first transmit - calls
+ * nfs_receive() to get reply - fills in reply (which should be initialized
+ * prior to calling), which is valid when 0 is returned and is NEVER freed in
+ * this function
+ * 
+ * always frees the request header, but NEVER frees 'mrest'
+ * 
+ */
+/*
+ * ruthtype
+ * pcclnt_setauth() should be used before calling this. EAUTH is returned if
+ * authentication fails.
+ */
+/*
+ * note that reply->result_* are invalid unless reply->type ==
+ * RPC_MSGACCEPTED and reply->status == RPC_SUCCESS and that reply->verf_*
+ * are invalid unless reply->type == RPC_MSGACCEPTED
+ */
+int
+rpcclnt_request(rpc, mrest, procnum, td, cred, reply)
+	struct rpcclnt *rpc;
+	struct mbuf    *mrest;
+	int             procnum;
+	RPC_EXEC_CTX	td;
+	struct ucred   *cred;
+	struct rpc_reply *reply;
+{
+	struct mbuf    *m, *mrep;
+	struct rpctask *task;
+	u_int32_t      *tl;
+	struct mbuf    *md, *mheadend;
+	caddr_t         dpos, cp2;
+	int             t1, s, error = 0, mrest_len;
+	u_int32_t       xid;
+
+#ifdef __OpenBSD__
+	task = pool_get(&rpctask_pool, PR_WAITOK);
+#else
+	MALLOC(task, struct rpctask *, sizeof(struct rpctask), M_RPC, (M_WAITOK | M_ZERO));
+#endif
+
+	task->r_rpcclnt = rpc;
+	task->r_procnum = procnum;
+	task->r_td = td;
+
+	mrest_len = m_length(mrest, NULL);
+
+	m = rpcclnt_buildheader(rpc, procnum, mrest, mrest_len, &xid, &mheadend,
+	    cred);
+
+	/*
+	 * For stream protocols, insert a Sun RPC Record Mark.
+	 */
+	if (rpc->rc_sotype == SOCK_STREAM) {
+		M_PREPEND(m, RPCX_UNSIGNED, M_TRYWAIT);
+		*mtod(m, u_int32_t *) = htonl(0x80000000 |
+					 (m->m_pkthdr.len - RPCX_UNSIGNED));
+	}
+	task->r_mreq = m;
+	task->r_xid = xid;
+
+	if (rpc->rc_flag & RPCCLNT_SOFT)
+		task->r_retry = rpc->rc_retry;
+	else
+		task->r_retry = RPC_MAXREXMIT + 1;	/* past clip limit */
+	task->r_rtt = task->r_rexmit = 0;
+
+	if (rpcclnt_proct(rpc, procnum) > 0)
+		task->r_flags = R_TIMING;
+	else
+		task->r_flags = 0;
+	task->r_mrep = NULL;
+
+	/*
+	 * Do the client side RPC.
+	 */
+	rpcstats.rpcrequests++;
+
+	/*
+	 * Chain request into list of outstanding requests. Be sure to put it
+	 * LAST so timer finds oldest requests first.
+	 */
+	s = splsoftclock();
+	TAILQ_INSERT_TAIL(&rpctask_q, task, r_chain);
+
+	/*
+	 * If backing off another request or avoiding congestion, don't send
+	 * this one now but let timer do it. If not timing a request, do it
+	 * now.
+	 */
+	if (rpc->rc_so && (rpc->rc_sotype != SOCK_DGRAM ||
+			   (rpc->rc_flag & RPCCLNT_DUMBTIMR) ||
+			   rpc->rc_sent < rpc->rc_cwnd)) {
+		splx(s);
+
+		if (rpc->rc_soflags & PR_CONNREQUIRED)
+			error = rpcclnt_sndlock(&rpc->rc_flag, task);
+		if (!error) {
+			error = rpcclnt_send(rpc->rc_so, rpc->rc_name, m_copym(m, 0, M_COPYALL, M_TRYWAIT),
+					     task);
+			if (rpc->rc_soflags & PR_CONNREQUIRED)
+				rpcclnt_sndunlock(&rpc->rc_flag);
+		}
+		if (!error && (task->r_flags & R_MUSTRESEND) == 0) {
+			rpc->rc_sent += RPC_CWNDSCALE;
+			task->r_flags |= R_SENT;
+		}
+	} else {
+		splx(s);
+		task->r_rtt = -1;
+	}
+
+	/*
+	 * Wait for the reply from our send or the timer's.
+	 */
+	if (!error || error == EPIPE)
+		error = rpcclnt_reply(task, td);
+
+	/*
+	 * RPC done, unlink the request.
+	 */
+	s = splsoftclock();
+	TAILQ_REMOVE(&rpctask_q, task, r_chain);
+	splx(s);
+
+	/*
+	 * Decrement the outstanding request count.
+	 */
+	if (task->r_flags & R_SENT) {
+		task->r_flags &= ~R_SENT;	/* paranoia */
+		rpc->rc_sent -= RPC_CWNDSCALE;
+	}
+	/*
+	 * If there was a successful reply and a tprintf msg. tprintf a
+	 * response.
+	 */
+	if (!error && (task->r_flags & R_TPRINTFMSG))
+		rpcclnt_msg(task->r_td, rpc->rc_prog->prog_name,
+			    "is alive again");
+
+	/* free request header (leaving mrest) */
+	mheadend->m_next = NULL;
+	m_freem(task->r_mreq);
+
+	/* initialize reply */
+	reply->mrep = task->r_mrep;
+	reply->verf_md = NULL;
+	reply->result_md = NULL;
+
+	mrep = task->r_mrep;
+	md = task->r_md;
+	dpos = task->r_dpos;
+
+	/* task structure is no longer needed */
+#ifdef __OpenBSD__
+	pool_put(&rpctask_pool, task);
+#else
+	FREE(task, M_RPC);
+#endif
+
+	if (error)
+		goto rpcmout;
+
+	/*
+	 * break down the rpc header and check if ok
+	 */
+
+	rpcm_dissect(tl, u_int32_t *, RPCX_UNSIGNED);
+	reply->stat.type = fxdr_unsigned(u_int32_t, *tl);
+
+	if (reply->stat.type == RPC_MSGDENIED) {
+		rpcm_dissect(tl, u_int32_t *, RPCX_UNSIGNED);
+		reply->stat.status = fxdr_unsigned(u_int32_t, *tl);
+
+		switch (reply->stat.status) {
+		case RPC_MISMATCH:
+			rpcm_dissect(tl, u_int32_t *, 2 * RPCX_UNSIGNED);
+			reply->stat.mismatch_info.low = fxdr_unsigned(u_int32_t, *tl++);
+			reply->stat.mismatch_info.low = fxdr_unsigned(u_int32_t, *tl);
+			break;
+		case RPC_AUTHERR:
+			rpcm_dissect(tl, u_int32_t *, RPCX_UNSIGNED);
+			reply->stat.autherr = fxdr_unsigned(u_int32_t, *tl);
+			break;
+		default:
+			error = EBADRPC;
+			goto rpcmout;
+			break;
+		}
+		RPC_RETURN(0);
+	} else if (reply->stat.type == RPC_MSGACCEPTED) {
+		rpcm_dissect(tl, u_int32_t *, 2 * RPCX_UNSIGNED);
+
+		reply->verf_md = md;
+		reply->verf_dpos = dpos;
+
+		reply->verf_type = fxdr_unsigned(u_int32_t, *tl++);
+		reply->verf_size = fxdr_unsigned(u_int32_t, *tl);
+
+		if (reply->verf_size != 0)
+			rpcm_adv(rpcm_rndup(reply->verf_size));
+
+		rpcm_dissect(tl, u_int32_t *, RPCX_UNSIGNED);
+		reply->stat.status = fxdr_unsigned(u_int32_t, *tl);
+
+		if (reply->stat.status == RPC_SUCCESS) {
+			if ((uint32_t)(dpos - mtod(md, caddr_t)) >= md->m_len) {
+				RPCDEBUG("where is the next mbuf?");
+				RPCDEBUG("%d -> %d", (int)(dpos - mtod(md, caddr_t)), md->m_len);
+				if (md->m_next == NULL) {
+					error = EBADRPC;
+					goto rpcmout;
+				} else {
+					reply->result_md = md->m_next;
+					reply->result_dpos = mtod(reply->result_md, caddr_t);
+				}
+			} else {
+				reply->result_md = md;
+				reply->result_dpos = dpos;
+			}
+		} else if (reply->stat.status == RPC_PROGMISMATCH) {
+			rpcm_dissect(tl, u_int32_t *, 2 * RPCX_UNSIGNED);
+			reply->stat.mismatch_info.low = fxdr_unsigned(u_int32_t, *tl++);
+			reply->stat.mismatch_info.high = fxdr_unsigned(u_int32_t, *tl);
+		} else if (reply->stat.status > 5) {
+			error = EBADRPC;
+			goto rpcmout;
+		}
+		RPC_RETURN(0);
+	} else {
+		error = EBADRPC;
+	}
+
+rpcmout:
+	RPCDEBUG("request returning error %d", error);
+	RPC_RETURN(error);
+}
+
+
+/*
+ * Nfs timer routine Scan the nfsreq list and retranmit any requests that
+ * have timed out To avoid retransmission attempts on STREAM sockets (in the
+ * future) make sure to set the r_retry field to 0 (implies nm_retry == 0).
+ */
+void
+rpcclnt_timer(arg)
+	void           *arg;
+{
+#ifdef __OpenBSD__
+	struct timeout *to = (struct timeout *) arg;
+#endif
+	struct rpctask *rep;
+	struct mbuf    *m;
+	struct socket  *so;
+	struct rpcclnt *rpc;
+	int             timeo;
+	int             s, error;
+
+#ifndef __OpenBSD__
+	struct thread  *td = curthread;
+#endif
+
+#if __OpenBSD__
+	s = splsoftnet();
+#else
+	s = splnet();
+#endif
+	TAILQ_FOREACH(rep, &rpctask_q, r_chain) {
+		rpc = rep->r_rpcclnt;
+		if (rep->r_mrep || (rep->r_flags & R_SOFTTERM))
+			continue;
+		if (rpcclnt_sigintr(rpc, rep, rep->r_td)) {
+			rep->r_flags |= R_SOFTTERM;
+			continue;
+		}
+		if (rep->r_rtt >= 0) {
+			rep->r_rtt++;
+			if (rpc->rc_flag & RPCCLNT_DUMBTIMR)
+				timeo = rpc->rc_timeo;
+			else
+				timeo = RPC_RTO(rpc, rpcclnt_proct(rep->r_rpcclnt,
+							   rep->r_procnum));
+			if (rpc->rc_timeouts > 0)
+				timeo *= rpcclnt_backoff[rpc->rc_timeouts - 1];
+			if (rep->r_rtt <= timeo)
+				continue;
+			if (rpc->rc_timeouts < 8)
+				rpc->rc_timeouts++;
+		}
+		/*
+		 * Check for server not responding
+		 */
+		if ((rep->r_flags & R_TPRINTFMSG) == 0 &&
+		    rep->r_rexmit > rpc->rc_deadthresh) {
+			rpcclnt_msg(rep->r_td, rpc->rc_prog->prog_name,
+				    "not responding");
+			rep->r_flags |= R_TPRINTFMSG;
+		}
+		if (rep->r_rexmit >= rep->r_retry) {	/* too many */
+			rpcstats.rpctimeouts++;
+			rep->r_flags |= R_SOFTTERM;
+			continue;
+		}
+		if (rpc->rc_sotype != SOCK_DGRAM) {
+			if (++rep->r_rexmit > RPC_MAXREXMIT)
+				rep->r_rexmit = RPC_MAXREXMIT;
+			continue;
+		}
+		if ((so = rpc->rc_so) == NULL)
+			continue;
+
+		/*
+		 * If there is enough space and the window allows.. Resend it
+		 * Set r_rtt to -1 in case we fail to send it now.
+		 */
+		rep->r_rtt = -1;
+		if (sbspace(&so->so_snd) >= rep->r_mreq->m_pkthdr.len &&
+		    ((rpc->rc_flag & RPCCLNT_DUMBTIMR) ||
+		     (rep->r_flags & R_SENT) ||
+		     rpc->rc_sent < rpc->rc_cwnd) &&
+		    (m = m_copym(rep->r_mreq, 0, M_COPYALL, M_DONTWAIT))) {
+			if ((rpc->rc_flag & RPCCLNT_NOCONN) == 0)
+				error = (*so->so_proto->pr_usrreqs->pru_send) (so, 0, m,
+							    NULL, NULL, td);
+			else
+				error = (*so->so_proto->pr_usrreqs->pru_send)(so, 0, m, rpc->rc_name, NULL, td);
+			if (error) {
+				if (RPCIGNORE_SOERROR(rpc->rc_soflags, error))
+					so->so_error = 0;
+			} else {
+				/*
+				 * Iff first send, start timing else turn
+				 * timing off, backoff timer and divide
+				 * congestion window by 2.
+				 */
+				if (rep->r_flags & R_SENT) {
+					rep->r_flags &= ~R_TIMING;
+					if (++rep->r_rexmit > RPC_MAXREXMIT)
+						rep->r_rexmit = RPC_MAXREXMIT;
+					rpc->rc_cwnd >>= 1;
+					if (rpc->rc_cwnd < RPC_CWNDSCALE)
+						rpc->rc_cwnd = RPC_CWNDSCALE;
+					rpcstats.rpcretries++;
+				} else {
+					rep->r_flags |= R_SENT;
+					rpc->rc_sent += RPC_CWNDSCALE;
+				}
+				rep->r_rtt = 0;
+			}
+		}
+	}
+	splx(s);
+
+#ifdef __OpenBSD__
+	timeout_add(rpcclnt_timer, to, rpcclnt_ticks);
+#else
+	rpcclnt_timer_handle = timeout(rpcclnt_timer, NULL, rpcclnt_ticks);
+#endif
+}
+
+/*
+ * Test for a termination condition pending on the process. This is used for
+ * RPCCLNT_INT mounts.
+ */
+int
+rpcclnt_sigintr(rpc, task, pr)
+	struct rpcclnt *rpc;
+	struct rpctask *task;
+	RPC_EXEC_CTX pr;
+{
+	struct proc    *p;
+
+	sigset_t        tmpset;
+
+	if (rpc == NULL) 
+		return EFAULT;
+
+	/* XXX deal with forced unmounts */
+
+	if (task && (task->r_flags & R_SOFTTERM))
+		RPC_RETURN(EINTR);
+
+	if (!(rpc->rc_flag & RPCCLNT_INT))
+		RPC_RETURN(0);
+
+	if (pr == NULL)
+		return (0);
+
+#ifdef __OpenBSD__
+	p = pr;
+	if (p && p->p_siglist &&
+	    (((p->p_siglist & ~p->p_sigmask) & ~p->p_sigignore) &
+	     RPCINT_SIGMASK))
+		RPC_RETURN(EINTR);
+#else
+	p = pr->td_proc;
+	PROC_LOCK(p);
+	tmpset = p->p_siglist;
+	SIGSETNAND(tmpset, pr->td_sigmask);
+	mtx_lock(&p->p_sigacts->ps_mtx);
+	SIGSETNAND(tmpset, p->p_sigacts->ps_sigignore);
+	mtx_unlock(&p->p_sigacts->ps_mtx);
+	if (SIGNOTEMPTY(p->p_siglist) && RPCCLNTINT_SIGMASK(tmpset)) {
+		PROC_UNLOCK(p);
+		RPC_RETURN(EINTR);
+	}
+	PROC_UNLOCK(p);
+#endif
+	RPC_RETURN(0);
+}
+
+/*
+ * 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 nfs requests in progress when a reconnect is necessary.
+ */
+static int
+rpcclnt_sndlock(flagp, task)
+	int            *flagp;
+	struct rpctask *task;
+{
+	RPC_EXEC_CTX p;
+	int             slpflag = 0, slptimeo = 0;
+
+	if (task) {
+		p = task->r_td;
+		if (task->r_rpcclnt->rc_flag & RPCCLNT_INT)
+			slpflag = PCATCH;
+	} else
+		p = NULL;
+	while (*flagp & RPCCLNT_SNDLOCK) {
+		if (rpcclnt_sigintr(task->r_rpcclnt, task, p))
+			RPC_RETURN(EINTR);
+		*flagp |= RPCCLNT_WANTSND;
+		(void)tsleep((caddr_t) flagp, slpflag | (PZERO - 1), "rpcsndlck",
+			     slptimeo);
+		if (slpflag == PCATCH) {
+			slpflag = 0;
+			slptimeo = 2 * hz;
+		}
+	}
+	*flagp |= RPCCLNT_SNDLOCK;
+	RPC_RETURN(0);
+}
+
+/*
+ * Unlock the stream socket for others.
+ */
+static void
+rpcclnt_sndunlock(flagp)
+	int            *flagp;
+{
+
+	if ((*flagp & RPCCLNT_SNDLOCK) == 0)
+		panic("rpc sndunlock");
+	*flagp &= ~RPCCLNT_SNDLOCK;
+	if (*flagp & RPCCLNT_WANTSND) {
+		*flagp &= ~RPCCLNT_WANTSND;
+		wakeup((caddr_t) flagp);
+	}
+}
+
+static int
+rpcclnt_rcvlock(task)
+	struct rpctask *task;
+{
+	int            *flagp = &task->r_rpcclnt->rc_flag;
+	int             slpflag, slptimeo = 0;
+
+	if (*flagp & RPCCLNT_INT)
+		slpflag = PCATCH;
+	else
+		slpflag = 0;
+	while (*flagp & RPCCLNT_RCVLOCK) {
+		if (rpcclnt_sigintr(task->r_rpcclnt, task, task->r_td))
+			RPC_RETURN(EINTR);
+		*flagp |= RPCCLNT_WANTRCV;
+		(void)tsleep((caddr_t) flagp, slpflag | (PZERO - 1), "rpcrcvlk",
+			     slptimeo);
+		if (slpflag == PCATCH) {
+			slpflag = 0;
+			slptimeo = 2 * hz;
+		}
+	}
+	*flagp |= RPCCLNT_RCVLOCK;
+	RPC_RETURN(0);
+}
+
+/*
+ * Unlock the stream socket for others.
+ */
+static void
+rpcclnt_rcvunlock(flagp)
+	int            *flagp;
+{
+
+	if ((*flagp & RPCCLNT_RCVLOCK) == 0)
+		panic("nfs rcvunlock");
+	*flagp &= ~RPCCLNT_RCVLOCK;
+	if (*flagp & RPCCLNT_WANTRCV) {
+		*flagp &= ~RPCCLNT_WANTRCV;
+		wakeup((caddr_t) flagp);
+	}
+}
+
+#if 0
+/*
+ * Check for badly aligned mbuf data areas and realign data in an mbuf list
+ * by copying the data areas up, as required.
+ */
+void
+rpcclnt_realign(m, hsiz)
+	struct mbuf    *m;
+	int             hsiz;
+{
+	struct mbuf    *m2;
+	int             siz, mlen, olen;
+	caddr_t         tcp, fcp;
+	struct mbuf    *mnew;
+
+	while (m) {
+		/*
+		 * This never happens for UDP, rarely happens for TCP but
+		 * frequently happens for iso transport.
+		 */
+		if ((m->m_len & 0x3) || (mtod(m, long)&0x3)) {
+			olen = m->m_len;
+			fcp = mtod(m, caddr_t);
+			if ((long)fcp & 0x3) {
+				if (m->m_flags & M_PKTHDR)
+					m_tag_delete_chain(m, NULL);
+				m->m_flags &= ~M_PKTHDR;
+				if (m->m_flags & M_EXT)
+					m->m_data = m->m_ext.ext_buf +
+						((m->m_ext.ext_size - olen) & ~0x3);
+				else
+					m->m_data = m->m_dat;
+			}
+			m->m_len = 0;
+			tcp = mtod(m, caddr_t);
+			mnew = m;
+			m2 = m->m_next;
+
+			/*
+			 * If possible, only put the first invariant part of
+			 * the RPC header in the first mbuf.
+			 */
+			mlen = M_TRAILINGSPACE(m);
+			if (olen <= hsiz && mlen > hsiz)
+				mlen = hsiz;
+
+			/* Loop through the mbuf list consolidating data. */
+			while (m) {
+				while (olen > 0) {
+					if (mlen == 0) {
+						if (m2->m_flags & M_PKTHDR)
+							m_tag_delete_chain(m2, NULL);
+						m2->m_flags &= ~M_PKTHDR;
+						if (m2->m_flags & M_EXT)
+							m2->m_data = m2->m_ext.ext_buf;
+						else
+							m2->m_data = m2->m_dat;
+						m2->m_len = 0;
+						mlen = M_TRAILINGSPACE(m2);
+						tcp = mtod(m2, caddr_t);
+						mnew = m2;
+						m2 = m2->m_next;
+					}
+					siz = min(mlen, olen);
+					if (tcp != fcp)
+						bcopy(fcp, tcp, siz);
+					mnew->m_len += siz;
+					mlen -= siz;
+					olen -= siz;
+					tcp += siz;
+					fcp += siz;
+				}
+				m = m->m_next;
+				if (m) {
+					olen = m->m_len;
+					fcp = mtod(m, caddr_t);
+				}
+			}
+
+			/*
+			 * Finally, set m_len == 0 for any trailing mbufs
+			 * that have been copied out of.
+			 */
+			while (m2) {
+				m2->m_len = 0;
+				m2 = m2->m_next;
+			}
+			return;
+		}
+		m = m->m_next;
+	}
+}
+#else
+static void
+rpcclnt_realign(struct mbuf **pm, int hsiz)
+{
+	struct mbuf *m;
+	struct mbuf *n = NULL;
+	int off = 0;
+
+	RPCDEBUG("in rpcclnt_realign()");
+
+	while ((m = *pm) != NULL) {
+	    if ((m->m_len & 0x3) || (mtod(m, intptr_t) & 0x3)) {
+	        MGET(n, M_TRYWAIT, MT_DATA);
+	        if (m->m_len >= MINCLSIZE) {
+	            MCLGET(n, M_TRYWAIT);
+	        }
+	        n->m_len = 0;
+	        break;
+	    }
+	    pm = &m->m_next;
+	}
+
+	/*
+	* If n is non-NULL, loop on m copying data, then replace the
+	* portion of the chain that had to be realigned.
+	*/
+	if (n != NULL) {
+	    while (m) {
+	        m_copyback(n, off, m->m_len, mtod(m, caddr_t));
+	        off += m->m_len;
+	        m = m->m_next;
+	    }
+	    m_freem(*pm);
+	    *pm = n;
+	}
+
+	RPCDEBUG("leave rpcclnt_realign()");
+}
+#endif
+
+static int
+rpcclnt_msg(p, server, msg)
+	RPC_EXEC_CTX   p;
+	const char     *server;
+	char           *msg;
+{
+#ifdef __OpenBSD__
+	tpr_t           tpr;
+	struct proc    *pr = p;
+
+	if (p)
+		tpr = tprintf_open(p);
+	else
+		tpr = NULL;
+	tprintf(tpr, "rpc server %s: %s\n", server, msg);
+	tprintf_close(tpr);
+	RPC_RETURN(0);
+#else
+	tprintf(p ? p->td_proc : NULL, LOG_INFO,
+		"nfs server %s: %s\n", server, msg);
+	RPC_RETURN(0);
+#endif
+}
+
+/*
+ * Build the RPC header and fill in the authorization info. The authorization
+ * string argument is only used when the credentials come from outside of the
+ * kernel (AUTH_KERB). (likewise, the ucred is only used when inside the
+ * kernel) Returns the head of the mbuf list.
+ */
+static struct mbuf    *
+rpcclnt_buildheader(rc, procid, mrest, mrest_len, xidp, mheadend, cred)
+	struct rpcclnt *rc;
+	int             procid;
+	struct mbuf    *mrest;
+	u_int32_t       mrest_len;
+	int            *xidp;
+	struct mbuf   **mheadend;
+	struct ucred * cred;
+{
+	/* register */ struct mbuf *mb;
+	register u_int32_t *tl;
+	/* register */ caddr_t bpos;
+	struct mbuf *mreq, *mb2;
+	int error;
+
+	MGETHDR(mb, M_TRYWAIT, MT_DATA);
+	if (6 * RPCX_UNSIGNED >= MINCLSIZE) {
+		MCLGET(mb, M_TRYWAIT);
+	} else if (6 * RPCX_UNSIGNED < MHLEN) {
+		MH_ALIGN(mb, 6 * RPCX_UNSIGNED);
+	} else {
+	  	RPCDEBUG("mbuf too small");
+		panic("cheap bailout");
+	}
+	mb->m_len = 0;
+	mreq = mb;
+	bpos = mtod(mb, caddr_t);
+
+	/*
+	 * First the RPC header.
+	 */
+	rpcm_build(tl, u_int32_t *, 6 * RPCX_UNSIGNED);
+
+	/* Get a new (non-zero) xid */
+	if ((rpcclnt_xid == 0) && (rpcclnt_xid_touched == 0)) {
+		rpcclnt_xid = arc4random();
+		rpcclnt_xid_touched = 1;
+	} else {
+		while ((*xidp = arc4random() % 256) == 0);
+		rpcclnt_xid += *xidp;
+	}
+
+	/* XXX: funky... */
+	*tl++ = *xidp = txdr_unsigned(rpcclnt_xid);
+
+	*tl++ = rpc_call;
+	*tl++ = rpc_vers;
+	*tl++ = txdr_unsigned(rc->rc_prog->prog_id);
+	*tl++ = txdr_unsigned(rc->rc_prog->prog_version);
+	*tl++ = txdr_unsigned(procid);
+
+	if ((error = rpcauth_buildheader(rc->rc_auth, cred, &mb, &bpos))) {
+		RPCDEBUG("rpcauth_buildheader failed %d", error);
+		return NULL;
+	}
+
+	mb->m_next = mrest;
+	*mheadend = mb;
+	mreq->m_pkthdr.len = m_length(mreq, NULL);
+	mreq->m_pkthdr.rcvif = NULL;
+	return (mreq);
+}
+
+/*
+ * Help break down an mbuf chain by setting the first siz bytes contiguous
+ * pointed to by returned val. This is used by the macros rpcm_dissect and
+ * rpcm_dissecton for tough cases. (The macros use the vars. dpos and dpos2)
+ */
+static int
+rpcm_disct(mdp, dposp, siz, left, cp2)
+	struct mbuf   **mdp;
+	caddr_t        *dposp;
+	int             siz;
+	int             left;
+	caddr_t        *cp2;
+{
+	struct mbuf    *mp, *mp2;
+	int             siz2, xfer;
+	caddr_t         p;
+
+	mp = *mdp;
+	while (left == 0) {
+		*mdp = mp = mp->m_next;
+		if (mp == NULL)
+			RPC_RETURN(EBADRPC);
+		left = mp->m_len;
+		*dposp = mtod(mp, caddr_t);
+	}
+	if (left >= siz) {
+		*cp2 = *dposp;
+		*dposp += siz;
+	} else if (mp->m_next == NULL) {
+		RPC_RETURN(EBADRPC);
+	} else if (siz > MHLEN) {
+		panic("rpc S too big");
+	} else {
+		MGET(mp2, M_TRYWAIT, MT_DATA);
+		mp2->m_next = mp->m_next;
+		mp->m_next = mp2;
+		mp->m_len -= left;
+		mp = mp2;
+		*cp2 = p = mtod(mp, caddr_t);
+		bcopy(*dposp, p, left);	/* Copy what was left */
+		siz2 = siz - left;
+		p += left;
+		mp2 = mp->m_next;
+		/* Loop around copying up the siz2 bytes */
+		while (siz2 > 0) {
+			if (mp2 == NULL)
+				RPC_RETURN(EBADRPC);
+			xfer = (siz2 > mp2->m_len) ? mp2->m_len : siz2;
+			if (xfer > 0) {
+				bcopy(mtod(mp2, caddr_t), p, xfer);
+				RPCMADV(mp2, xfer);
+				mp2->m_len -= xfer;
+				p += xfer;
+				siz2 -= xfer;
+			}
+			if (siz2 > 0)
+				mp2 = mp2->m_next;
+		}
+		mp->m_len = siz;
+		*mdp = mp2;
+		*dposp = mtod(mp2, caddr_t);
+	}
+	RPC_RETURN(0);
+}
+
+
+
+static u_int32_t
+rpcclnt_proct(rpc, procid)
+	struct rpcclnt *rpc;
+	u_int32_t       procid;
+{
+	if (rpc->rc_proctlen != 0 && rpc->rc_proct != NULL &&
+	    procid < rpc->rc_proctlen) {
+		return rpc->rc_proct[procid];
+	}
+	return (0);
+}
+
+static int
+rpc_adv(mdp, dposp, offs, left)
+	struct mbuf   **mdp;
+	caddr_t        *dposp;
+	int             offs;
+	int             left;
+{
+	struct mbuf    *m;
+	int             s;
+
+	m = *mdp;
+	s = left;
+	while (s < offs) {
+		offs -= s;
+		m = m->m_next;
+		if (m == NULL)
+			RPC_RETURN(EBADRPC);
+		s = m->m_len;
+	}
+	*mdp = m;
+	*dposp = mtod(m, caddr_t) + offs;
+	RPC_RETURN(0);
+}
+
+int
+rpcclnt_cancelreqs(rpc)
+	struct rpcclnt *rpc;
+{
+	struct rpctask *task;
+	int             i, s;
+
+	s = splnet();
+	TAILQ_FOREACH(task, &rpctask_q, r_chain) {
+		if (rpc != task->r_rpcclnt || task->r_mrep != NULL ||
+		    (task->r_flags & R_SOFTTERM))
+			continue;
+		rpcclnt_softterm(task);
+	}
+	splx(s);
+
+	for (i = 0; i < 30; i++) {
+		s = splnet();
+		TAILQ_FOREACH(task, &rpctask_q, r_chain) {
+			if (rpc == task->r_rpcclnt)
+				break;
+		}
+		splx(s);
+		if (task == NULL)
+			return (0);
+		tsleep(&lbolt, PSOCK, "nfscancel", 0);
+	}
+	return (EBUSY);
+}
+
+static void
+rpcclnt_softterm(struct rpctask * task)
+{
+	task->r_flags |= R_SOFTTERM;
+	if (task->r_flags & R_SENT) {
+		task->r_rpcclnt->rc_sent -= RPC_CWNDSCALE;
+		task->r_flags &= ~R_SENT;
+	}
+}
+
+
+#ifndef __OpenBSD__
+/* called by rpcclnt_get() */
+void
+rpcclnt_create(struct rpcclnt ** rpc)
+{
+	MALLOC(*rpc, struct rpcclnt *, sizeof(struct rpcclnt), M_RPC, M_WAITOK | M_ZERO);
+}
+
+/* called by rpcclnt_put() */
+void
+rpcclnt_destroy(struct rpcclnt * rpc)
+{
+	if (rpc != NULL) {
+		FREE(rpc, M_RPC);
+	} else {
+		RPCDEBUG("attempting to free a NULL rpcclnt (not dereferenced)");
+	}
+}
+#endif				/* !__OpenBSD__ */
+
+
+/* XXX: add a lock around the auth structure in struct rpcclnt and make this
+ * call safe for calling durring a connection */
+static int
+rpcauth_buildheader(struct rpc_auth * auth, struct ucred * cred, struct mbuf ** mhdr, caddr_t * bp)
+{
+	size_t authsiz, verfsiz;
+	uint32_t mlen, grpsiz;
+	register struct mbuf *mb, *mb2;
+	caddr_t bpos;
+	register u_int32_t *tl;
+	register int i;
+
+	if (auth == NULL || mhdr == NULL)
+	  return EFAULT;
+
+	switch (auth->auth_type) {
+	case RPCAUTH_NULL:
+	  	authsiz = 0;
+		verfsiz = 0;
+	break;
+	case RPCAUTH_UNIX:
+		authsiz = (5 + cred->cr_ngroups) * RPCX_UNSIGNED;
+		verfsiz = 0;
+	break;
+	default:
+		return EPROTONOSUPPORT;
+	break;
+	};
+
+	mlen = rpcm_rndup(authsiz) + rpcm_rndup(verfsiz) + 4 * RPCX_UNSIGNED;
+
+	mb = *mhdr;
+	bpos = *bp;
+
+	rpcm_build(tl, u_int32_t *, mlen);
+
+	*bp = bpos;
+	*mhdr = mb;
+
+	*tl++ = txdr_unsigned(auth->auth_type);
+	*tl++ = txdr_unsigned(authsiz);
+	switch (auth->auth_type) {
+	case RPCAUTH_UNIX:
+	 	*tl++ = 0;
+	 	*tl++ = 0; 
+
+		*tl++ = txdr_unsigned(cred->cr_uid);
+		*tl++ = txdr_unsigned(cred->cr_groups[0]);
+		grpsiz = cred->cr_ngroups;
+		*tl++ = txdr_unsigned(grpsiz);
+		/* XXX: groups[0] is already sent... */
+		for (i = 0 ; i < grpsiz ; i++) {
+			 *tl++ = txdr_unsigned(cred->cr_groups[i]);
+		}
+
+		/* null verification header */
+		*tl++ = txdr_unsigned(RPCAUTH_NULL);
+		*tl++ = 0;
+	break;
+	case RPCAUTH_NULL:
+		/* just a null verf header */
+		*tl++ = txdr_unsigned(RPCAUTH_NULL);
+		*tl = 0;
+	break;
+	default:
+		panic("inconsistent rpc auth type");
+	break;
+	}
+
+	return 0;
+}
diff --git a/sys/rpc/rpcclnt.h b/sys/rpc/rpcclnt.h
new file mode 100644
index 0000000..48681ab
--- /dev/null
+++ b/sys/rpc/rpcclnt.h
@@ -0,0 +1,358 @@
+/* $FreeBSD$ */
+/*	$OpenBSD: nfsmount.h,v 1.11 2002/03/14 01:27:13 millert Exp $	*/
+/*	$NetBSD: nfsmount.h,v 1.10 1996/02/18 11:54:03 fvdl Exp $	*/
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+/*
+ * 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.
+ *
+ *	@(#)nfsmount.h	8.3 (Berkeley) 3/30/95
+ */
+
+
+#ifndef _RPCCLNT_H_
+#define _RPCCLNT_H_
+
+#include <sys/types.h>
+#include <sys/malloc.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+
+#ifdef __OpenBSD__
+	#define RPC_EXEC_CTX struct proc *
+#else
+	#define RPC_EXEC_CTX struct thread *
+#endif
+
+
+#ifdef RPCCLNT_DEBUG
+#define RPCDEBUG(args...) do{	\
+	if(rpcdebugon != 0){	\
+		printf("%s(): ", __FUNCTION__);\
+		printf(args);	\
+		printf("\n");	\
+	}}while(0)
+#else
+#define RPCDEBUG(args...)
+#endif
+
+/* from nfs/nfs.h */
+#define RPC_TICKINTVL     5
+
+
+/* from nfs/nfsproto.h */
+#define RPC_MAXDATA     32768
+#define RPC_MAXPKTHDR   404
+#define RPC_MAXPACKET   (RPC_MAXPKTHDR + RPC_MAXDATA)
+
+#define RPCX_UNSIGNED   4
+
+/* defines for rpcclnt's rc_flags
+   XXX these flags came from the NFSMNT_* flags in OpenBSD's sys/mount.h */
+#define RPCCLNT_SOFT            0x001 /* soft mount (hard is details) */
+#define RPCCLNT_INT             0x002 /* allow interrupts on hard mounts */
+#define RPCCLNT_NOCONN          0x004 /* dont connect the socket (udp) */
+#define RPCCLNT_DUMBTIMR        0x010
+
+#define RPCCLNT_SNDLOCK         0x100
+#define RPCCLNT_WANTSND         0x200
+#define RPCCLNT_RCVLOCK         0x400
+#define RPCCLNT_WANTRCV         0x800
+
+
+/* Flag values for r_flags */
+#define R_TIMING        0x01            /* timing request (in mntp) */
+#define R_SENT          0x02            /* request has been sent */
+#define R_SOFTTERM      0x04            /* soft mnt, too many retries */
+#define R_INTR          0x08            /* intr mnt, signal pending */
+#define R_SOCKERR       0x10            /* Fatal error on socket */
+#define R_TPRINTFMSG    0x20            /* Did a tprintf msg. */
+#define R_MUSTRESEND    0x40            /* Must resend request */
+#define R_GETONEREP     0x80            /* Probe for one reply only */
+
+
+#define RPC_HZ          (hz / rpcclnt_ticks) /* Ticks/sec */
+#define RPC_TIMEO       (1 * RPC_HZ)    /* Default timeout = 1 second */
+
+#define RPC_MAXREXMIT   100             /* Stop counting after this many */
+
+
+#define RPCIGNORE_SOERROR(s, e) \
+                ((e) != EINTR && (e) != ERESTART && (e) != EWOULDBLOCK && \
+                ((s) & PR_CONNREQUIRED) == 0)
+
+#define RPCINT_SIGMASK  (sigmask(SIGINT)|sigmask(SIGTERM)|sigmask(SIGKILL)| \
+                         sigmask(SIGHUP)|sigmask(SIGQUIT))
+
+#define RPCMADV(m, s)   (m)->m_data += (s)
+
+#define RPCAUTH_ROOTCREDS NULL
+
+#define RPCCLNTINT_SIGMASK(set)             \
+  (SIGISMEMBER(set, SIGINT) || SIGISMEMBER(set, SIGTERM) || \
+	 SIGISMEMBER(set, SIGHUP) || SIGISMEMBER(set, SIGKILL) || \
+	 SIGISMEMBER(set, SIGQUIT))
+
+
+#define fxdr_unsigned(t, v) ((t)ntohl((int32_t)(v)))
+#define txdr_unsigned(v)  (htonl((int32_t)(v)))
+
+
+/* global rpcstats 
+ * XXX should be per rpcclnt */
+struct rpcstats {
+	int	rpcretries;
+	int rpcrequests;
+	int rpctimeouts;
+	int rpcunexpected;
+	int rpcinvalid;
+};
+
+struct rpc_program {
+	u_int32_t prog_id;
+	u_int32_t prog_version;
+	char * prog_name;
+};
+
+struct rpc_auth {
+	unsigned int auth_type;
+};
+
+struct rpctask {
+	TAILQ_ENTRY(rpctask) r_chain;
+	struct mbuf     *r_mreq;
+	struct mbuf     *r_mrep;
+	struct mbuf     *r_md;
+	caddr_t         r_dpos;
+
+	struct rpcclnt  *r_rpcclnt;
+
+	u_int32_t       r_xid;
+	int             r_flags;        /* flags on request, see below */
+	int             r_retry;        /* max retransmission count */
+	int             r_rexmit;       /* current retrans count */
+	int             r_timer;        /* tick counter on reply */
+	int             r_procnum;      /* NFS procedure number */
+	int             r_rtt;          /* RTT for rpc */
+	RPC_EXEC_CTX    r_td;
+};
+
+struct rpc_reply {
+	struct {
+		u_int32_t type;
+		u_int32_t status;
+
+		/* used only when reply == RPC_MSGDENIED and
+		 * status == RPC_AUTHERR */
+		u_int32_t autherr;
+
+		/* rpc mismatch info if reply == RPC_MSGDENIED and
+	 	* status == RPC_MISMATCH */
+		struct {
+			u_int32_t low;
+			u_int32_t high;
+		} mismatch_info;
+	} stat;
+
+	/* head of the mbuf chain */
+	struct mbuf * mrep;
+
+	/* mbuf and position of the verification opaque data
+	 * note that this is only valid when stat.reply == RPC_MSGACCEPTED */
+	u_int32_t verf_type;
+	u_int32_t verf_size;
+	struct mbuf * verf_md;
+	caddr_t verf_dpos;
+
+	/* mbuf and postion of the result of the rpc request */
+	struct mbuf * result_md;
+	caddr_t result_dpos;
+};
+
+
+/*
+ * RPC Client connection context.
+ * One allocated on every NFS mount.
+ * Holds RPC specific information for mount.
+ */
+/* XXX: please note that all pointer type variables are just set (not copied),
+ *      so it is up to the user to free these values */
+struct	rpcclnt {
+	int	rc_flag;		/* For RPCCLNT_* flags  */
+
+	int	rc_wsize;		/* Max size of the request data */
+	int	rc_rsize;		/* Max size of the response data */
+	struct	sockaddr *rc_name;		
+	struct	socket *rc_so;		/* Rpc socket */
+	int	rc_sotype;		/* Type of socket */
+	int	rc_soproto;		/* and protocol */
+	int	rc_soflags;		/* pr_flags for socket protocol */
+
+	int	rc_timeo;		/* Init timer for NFSMNT_DUMBTIMR */
+	int	rc_retry;		/* Max retries */
+	int	rc_srtt[4];		/* Timers for rpcs */
+	int	rc_sdrtt[4];
+	int	rc_sent;		/* Request send count */
+	int	rc_cwnd;		/* Request send window */
+	int	rc_timeouts;		/* Request timeouts */
+
+/* XXX: this is not being set!!!! */
+	int	rc_deadthresh;		/* Threshold of timeouts-->dead server*/
+
+
+	/* authentication: */
+	/* currently can be RPCAUTH_NULL, RPCAUTH_KERBV4, RPCAUTH_UNIX */
+	/* should be kept in XDR form */
+	int	rc_authtype;		/* Authenticator type */
+
+
+#if 0
+	/* RPCAUTH_KERB4 */
+	int	rc_authlen;		/* and length */
+	char	*rc_authstr;		/* Authenticator string */
+	int	rc_verflen;
+	char	*rc_verfstr;		/* and the verifier */
+#endif
+
+	/* RPCAUTH_UNIX*/
+	struct rpc_auth * rc_auth;	/* authentication */
+
+#if 0
+	/* stored in XDR form (network byte order) */
+	unsigned int rc_progid;		/* program id */
+	unsigned int rc_progvers;	/* program version */
+
+	/* name of server for log messages */
+	const char *rc_servername;	/* for printing error messages */
+#else 
+	struct rpc_program * rc_prog;
+#endif
+
+	/* XXX: this should be removed */
+	int rc_proctlen;		/* if == 0 then rc_proct == NULL */
+	int * rc_proct;
+};
+
+#ifdef __OpenBSD__
+extern struct pool rpcreply_pool;
+extern struct pool rpcclnt_pool;
+#else 
+/* MALLOC_DECLARE(M_RPC); */
+#endif
+extern int rpcdebugon;
+
+
+#ifdef __OpenBSD__
+#define rpcclnt_get(X)	\
+	do {	\
+	(X) = pool_get(&rpcclnt_pool, PR_WAITOK);	\
+	bzero((X), sizeof(struct rpcclnt));	\
+	}while(0)
+
+#define rpcclnt_put(X)	\
+	do {	\
+	if ((X) != NULL){	\
+		pool_put(&rpcclnt_pool, (X));	\
+	}}while(0)
+
+#else /* !__OpenBSD__ */
+
+/* usage count for module (un)loading */
+extern unsigned int rpcclnt_usage;
+extern struct mtx rpcclnt_usage_mutex;
+
+void rpcclnt_create(struct rpcclnt ** rpc);
+void rpcclnt_destroy(struct rpcclnt * rpc);
+
+#define rpcclnt_get(X) rpcclnt_create(&(X))
+#define rpcclnt_put(X) rpcclnt_destroy(X)
+
+#ifdef RPCCLNT_TEST
+struct rpcclnt_test_args {
+	int nothing;
+};
+int rpcclnt_test(struct thread *, struct rpcclnt_test_args *);
+
+#define RPC_RETURN(X) do { RPCDEBUG("returning %d", X); return X; }while(0)
+#endif /* RPCCLNT_TEST */
+
+#endif /* !__OpenBSD__ */
+
+void rpcclnt_init(void);
+void rpcclnt_uninit(void);
+#if 0
+int rpcclnt_setup(struct rpcclnt *, int, struct sockaddr *, int, int, int, int, const char *, int, int);
+#endif
+
+int rpcclnt_setup(struct rpcclnt *, struct rpc_program *, struct sockaddr *, int, int, struct rpc_auth *, int, int, int);
+
+
+int rpcclnt_connect(struct rpcclnt *, RPC_EXEC_CTX td);
+int rpcclnt_reconnect(struct rpctask *, RPC_EXEC_CTX td);
+void rpcclnt_disconnect(struct rpcclnt *);
+void rpcclnt_safedisconnect(struct rpcclnt *);
+
+void rpcclnt_setauth(struct rpcclnt *, u_int32_t,  u_int32_t, char *, u_int32_t, char *, struct ucred *);
+int rpcclnt_request(struct rpcclnt *, struct mbuf *, int, RPC_EXEC_CTX, struct ucred *, struct rpc_reply *);
+int rpcclnt_err(struct rpc_reply *);
+
+int rpcclnt_cancelreqs(struct rpcclnt *);
+int rpcclnt_sigintr(struct rpcclnt *, struct rpctask *, RPC_EXEC_CTX);
+
+
+#endif /* _RPCCLNT_H_ */
diff --git a/sys/rpc/rpcm_subs.h b/sys/rpc/rpcm_subs.h
new file mode 100644
index 0000000..09e452a
--- /dev/null
+++ b/sys/rpc/rpcm_subs.h
@@ -0,0 +1,133 @@
+/* $FreeBSD$ */
+/*	$OpenBSD: nfsm_subs.h,v 1.11 2000/01/05 20:50:52 millert Exp $	*/
+/*	$NetBSD: nfsm_subs.h,v 1.10 1996/03/20 21:59:56 fvdl Exp $	*/
+
+/*
+ * copyright (c) 2003
+ * the regents of the university of michigan
+ * all rights reserved
+ * 
+ * permission is granted to use, copy, create derivative works and redistribute
+ * this software and such derivative works for any purpose, so long as the name
+ * of the university of michigan is not used in any advertising or publicity
+ * pertaining to the use or distribution of this software without specific,
+ * written prior authorization.  if the above copyright notice or any other
+ * identification of the university of michigan is included in any copy of any
+ * portion of this software, then the disclaimer below must also be included.
+ * 
+ * this software is provided as is, without representation from the university
+ * of michigan as to its fitness for any purpose, and without warranty by the
+ * university of michigan of any kind, either express or implied, including
+ * without limitation the implied warranties of merchantability and fitness for
+ * a particular purpose. the regents of the university of michigan shall not be
+ * liable for any damages, including special, indirect, incidental, or
+ * consequential damages, with respect to any claim arising out of or in
+ * connection with the use of the software, even if it has been or is hereafter
+ * advised of the possibility of such damages.
+ */
+
+/*
+ * 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.
+ *
+ *	@(#)nfsm_subs.h	8.2 (Berkeley) 3/30/95
+ */
+
+
+#ifndef _RPC_RPCM_SUBS_H_
+#define _RPC_RPCM_SUBS_H_
+
+
+/*
+ * Now for the macros that do the simple stuff and call the functions
+ * for the hard stuff.
+ * These macros use several vars. declared in rpcm_reqhead and these
+ * vars. must not be used elsewhere unless you are careful not to corrupt
+ * them. The vars. starting with pN and tN (N=1,2,3,..) are temporaries
+ * that may be used so long as the value is not expected to retained
+ * after a macro.
+ * I know, this is kind of dorkey, but it makes the actual op functions
+ * fairly clean and deals with the mess caused by the xdr discriminating
+ * unions.
+ */
+
+#define	rpcm_build(a,c,s) \
+		{ if ((s) > M_TRAILINGSPACE(mb)) { \
+			MGET(mb2, M_WAIT, MT_DATA); \
+			if ((s) > MLEN) \
+				panic("build > MLEN"); \
+			mb->m_next = mb2; \
+			mb = mb2; \
+			mb->m_len = 0; \
+			bpos = mtod(mb, caddr_t); \
+		} \
+		(a) = (c)(bpos); \
+		mb->m_len += (s); \
+		bpos += (s); }
+
+#define	rpcm_dissect(a, c, s) \
+		{ t1 = mtod(md, caddr_t)+md->m_len-dpos; \
+		if (t1 >= (s)) { \
+			(a) = (c)(dpos); \
+			dpos += (s); \
+		} else if ((t1 = rpcm_disct(&md, &dpos, (s), t1, &cp2)) != 0){ \
+			error = t1; \
+			goto rpcmout; \
+		} else { \
+			(a) = (c)cp2; \
+		} }
+
+#if 0
+#define rpcm_mtouio(p,s) \
+		if ((s) > 0 && \
+		   (t1 = rpcm_mbuftouio(&md,(p),(s),&dpos)) != 0) { \
+			error = t1; \
+			goto rpcmout; \
+		}
+#endif
+
+#define rpcm_rndup(a)	(((a)+3)&(~0x3))
+
+#define	rpcm_adv(s) \
+		{ t1 = mtod(md, caddr_t)+md->m_len-dpos; \
+		if (t1 >= (s)) { \
+			dpos += (s); \
+		} else if ((t1 = rpc_adv(&md, &dpos, (s), t1)) != 0) { \
+			error = t1; \
+			goto rpcmout; \
+		} }
+
+#define RPCMADV(m, s)   (m)->m_data += (s)
+
+#endif /* _RPC_RPCM_SUBS_H_ */
diff --git a/sys/rpc/rpcv2.h b/sys/rpc/rpcv2.h
new file mode 100644
index 0000000..316ebd2
--- /dev/null
+++ b/sys/rpc/rpcv2.h
@@ -0,0 +1,101 @@
+/* $FreeBSD$ */
+/*	$OpenBSD: rpcv2.h,v 1.5 2002/06/11 15:45:44 hin Exp $	*/
+/*	$NetBSD: rpcv2.h,v 1.8 1996/02/18 11:54:11 fvdl Exp $	*/
+
+/*
+ * 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.
+ *
+ *	@(#)rpcv2.h	8.2 (Berkeley) 3/30/95
+ */
+
+
+#ifndef _NFS_RPCV2_H_
+#define _NFS_RPCV2_H_
+
+/*
+ * Definitions for Sun RPC Version 2, from
+ * "RPC: Remote Procedure Call Protocol Specification" RFC1057
+ */
+
+/* Version # */
+#define	RPC_VER2	2
+
+/* Authentication */
+#define	RPCAUTH_NULL	0
+#define	RPCAUTH_UNIX	1
+#define	RPCAUTH_SHORT	2
+#define RPCAUTH_KERB4	4
+#define	RPCAUTH_MAXSIZ	400
+#define	RPCVERF_MAXSIZ	12	/* For Kerb, can actually be 400 */
+#define	RPCAUTH_UNIXGIDS 16
+
+/* Rpc Constants */
+
+/* msg type */
+#define	RPC_CALL	0
+#define	RPC_REPLY	1
+
+/* reply stat */
+#define	RPC_MSGACCEPTED	0
+#define	RPC_MSGDENIED	1
+
+/* accepted stat: */
+#define RPC_SUCCESS	0
+#define	RPC_PROGUNAVAIL	1
+#define	RPC_PROGMISMATCH	2
+#define	RPC_PROCUNAVAIL	3
+#define	RPC_GARBAGE	4		/* I like this one */
+#define RPC_SYSTEMERR	5
+
+/* reject stat */
+#define	RPC_MISMATCH	0
+#define	RPC_AUTHERR	1
+
+/* Authentication failures */
+#define AUTH_OK		0
+#define	AUTH_BADCRED	1
+#define	AUTH_REJECTCRED	2
+#define	AUTH_BADVERF	3
+#define	AUTH_REJECTVERF	4
+#define	AUTH_TOOWEAK	5		/* Give em wheaties */
+
+
+/* Sizes of rpc header parts */
+#define	RPC_SIZ		24
+#define	RPC_REPLYSIZ	28
+
+typedef u_char			NFSKERBKEY_T[2];
+
+#endif