 @@ -1,376 +1,389 @@
-/*	$NetBSD: nfs_node.c,v 1.107 2008/11/19 18:36:09 ad Exp $	*/
+/*	$NetBSD: nfs_node.c,v 1.108 2009/01/02 12:57:29 ad 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. 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_node.c	8.6 (Berkeley) 5/22/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: nfs_node.c,v 1.107 2008/11/19 18:36:09 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: nfs_node.c,v 1.108 2009/01/02 12:57:29 ad Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_nfs.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/mount.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
 #include <sys/kernel.h>
 #include <sys/pool.h>
 #include <sys/lock.h>
 #include <sys/hash.h>
 #include <sys/kauth.h>
 #include <nfs/rpcv2.h>
 #include <nfs/nfsproto.h>
 #include <nfs/nfs.h>
 #include <nfs/nfsnode.h>
 #include <nfs/nfsmount.h>
 #include <nfs/nfs_var.h>
 struct pool nfs_node_pool;
 struct pool nfs_vattr_pool;
 static struct workqueue *nfs_sillyworkq;
 MALLOC_JUSTDEFINE(M_NFSNODE, "NFS node", "NFS vnode private part");
 extern int prtactive;
-void nfs_gop_size(struct vnode *, off_t, off_t *, int);
+static void nfs_gop_size(struct vnode *, off_t, off_t *, int);
-int nfs_gop_alloc(struct vnode *, off_t, off_t, int, kauth_cred_t);
+static int nfs_gop_alloc(struct vnode *, off_t, off_t, int, kauth_cred_t);
-int nfs_gop_write(struct vnode *, struct vm_page **, int, int);
+static int nfs_gop_write(struct vnode *, struct vm_page **, int, int);
 static void nfs_sillyworker(struct work *, void *);
 static const struct genfs_ops nfs_genfsops = {
 	.gop_size = nfs_gop_size,
 	.gop_alloc = nfs_gop_alloc,
 	.gop_write = nfs_gop_write,
 };
 /*
  * Reinitialize inode hash table.
  */
 void
 nfs_node_init()
+{
 	malloc_type_attach(M_NFSNODE);
 	pool_init(&nfs_node_pool, sizeof(struct nfsnode), 0, 0, 0, "nfsnodepl",
 	    &pool_allocator_nointr, IPL_NONE);
 	pool_init(&nfs_vattr_pool, sizeof(struct vattr), 0, 0, 0, "nfsvapl",
 	    &pool_allocator_nointr, IPL_NONE);
 	if (workqueue_create(&nfs_sillyworkq, "nfssilly", nfs_sillyworker,
 	    NULL, PRI_NONE, IPL_NONE, 0) != 0) {
 	    	panic("nfs_node_init");
+	}
+}
 /*
  * Free resources previously allocated in nfs_node_reinit().
  */
 void
 nfs_node_done()
+{
 	pool_destroy(&nfs_node_pool);
 	pool_destroy(&nfs_vattr_pool);
-	malloc_type_detach(M_NFSNODE);
+	workqueue_destroy(nfs_sillyworkq);
+}
 #define	RBTONFSNODE(node) \
 	(void *)((uintptr_t)(node) - offsetof(struct nfsnode, n_rbnode))
 struct fh_match {
 	nfsfh_t *fhm_fhp;
 	size_t fhm_fhsize;
 	size_t fhm_fhoffset;
 };
 static int
 nfs_compare_nodes(const struct rb_node *parent, const struct rb_node *node)
+{
 	const struct nfsnode * const pnp = RBTONFSNODE(parent);
 	const struct nfsnode * const np = RBTONFSNODE(node);
 	if (pnp->n_fhsize != np->n_fhsize)
 		return np->n_fhsize - pnp->n_fhsize;
 	return memcmp(np->n_fhp, pnp->n_fhp, np->n_fhsize);
+}
 static int
 nfs_compare_node_fh(const struct rb_node *b, const void *key)
+{
 	const struct nfsnode * const pnp = RBTONFSNODE(b);
 	const struct fh_match * const fhm = key;
 	if (pnp->n_fhsize != fhm->fhm_fhsize)
 		return fhm->fhm_fhsize - pnp->n_fhsize;
 	return memcmp(fhm->fhm_fhp, pnp->n_fhp, pnp->n_fhsize);
+}
 static const struct rb_tree_ops nfs_node_rbtree_ops = {
 	.rbto_compare_nodes = nfs_compare_nodes,
 	.rbto_compare_key = nfs_compare_node_fh,
 };
 void
 nfs_rbtinit(struct nfsmount *nmp)
+{
 	rb_tree_init(&nmp->nm_rbtree, &nfs_node_rbtree_ops);
+}
 /*
  * Look up a vnode/nfsnode by file handle.
  * Callers must check for mount points!!
  * In all cases, a pointer to a
  * nfsnode structure is returned.
  */
 int
 nfs_nget1(mntp, fhp, fhsize, npp, lkflags)
 	struct mount *mntp;
 	nfsfh_t *fhp;
 	int fhsize;
 	struct nfsnode **npp;
 	int lkflags;
+{
 	struct nfsnode *np;
 	struct vnode *vp;
 	struct nfsmount *nmp = VFSTONFS(mntp);
 	int error;
 	struct fh_match fhm;
 	struct rb_node *node;
 	fhm.fhm_fhp = fhp;
 	fhm.fhm_fhsize = fhsize;
 loop:
 	rw_enter(&nmp->nm_rbtlock, RW_READER);
 	node = rb_tree_find_node(&nmp->nm_rbtree, &fhm);
 	if (node != NULL) {
 		np = RBTONFSNODE(node);
 		vp = NFSTOV(np);
 		mutex_enter(&vp->v_interlock);
 		rw_exit(&nmp->nm_rbtlock);
 		error = vget(vp, LK_EXCLUSIVE | LK_INTERLOCK | lkflags);
 		if (error == EBUSY)
 			return error;
 		if (error)
 			goto loop;
 		*npp = np;
 		return(0);
+	}
 	rw_exit(&nmp->nm_rbtlock);
 	error = getnewvnode(VT_NFS, mntp, nfsv2_vnodeop_p, &vp);
 	if (error) {
 		*npp = 0;
 		return (error);
+	}
 	np = pool_get(&nfs_node_pool, PR_WAITOK);
 	memset(np, 0, sizeof *np);
 	np->n_vnode = vp;
 	/*
 	 * Insert the nfsnode in the hash queue for its new file handle
 	 */
 	if (fhsize > NFS_SMALLFH) {
 		np->n_fhp = kmem_alloc(fhsize, KM_SLEEP);
 	} else
 		np->n_fhp = &np->n_fh;
 	memcpy(np->n_fhp, fhp, fhsize);
 	np->n_fhsize = fhsize;
 	np->n_accstamp = -1;
 	np->n_vattr = pool_get(&nfs_vattr_pool, PR_WAITOK);
 	rw_enter(&nmp->nm_rbtlock, RW_WRITER);
 	if (NULL != rb_tree_find_node(&nmp->nm_rbtree, &fhm)) {
 		rw_exit(&nmp->nm_rbtlock);
 		if (fhsize > NFS_SMALLFH) {
 			kmem_free(np->n_fhp, fhsize);
+		}
 		pool_put(&nfs_vattr_pool, np->n_vattr);
 		pool_put(&nfs_node_pool, np);
 		ungetnewvnode(vp);
 		goto loop;
+	}
 	vp->v_data = np;
 	genfs_node_init(vp, &nfs_genfsops);
 	/*
 	 * Initalize read/write creds to useful values. VOP_OPEN will
 	 * overwrite these.
 	 */
 	np->n_rcred = curlwp->l_cred;
 	kauth_cred_hold(np->n_rcred);
 	np->n_wcred = curlwp->l_cred;
 	kauth_cred_hold(np->n_wcred);
 	vlockmgr(&vp->v_lock, LK_EXCLUSIVE);
 	NFS_INVALIDATE_ATTRCACHE(np);
 	uvm_vnp_setsize(vp, 0);
 	rb_tree_insert_node(&nmp->nm_rbtree, &np->n_rbnode);
 	rw_exit(&nmp->nm_rbtlock);
 	*npp = np;
 	return (0);
+}
 int
 nfs_inactive(v)
 	void *v;
+{
 	struct vop_inactive_args /* {
 		struct vnode *a_vp;
 		bool *a_recycle;
 	} */ *ap = v;
 	struct nfsnode *np;
 	struct sillyrename *sp;
 	struct vnode *vp = ap->a_vp;
 	np = VTONFS(vp);
 	if (vp->v_type != VDIR) {
 		sp = np->n_sillyrename;
 		np->n_sillyrename = (struct sillyrename *)0;
 	} else
 		sp = NULL;
 	if (sp != NULL)
 		nfs_vinvalbuf(vp, 0, sp->s_cred, curlwp, 1);
 	*ap->a_recycle = (np->n_flag & NREMOVED) != 0;
 	np->n_flag &=
 	    (NMODIFIED | NFLUSHINPROG | NFLUSHWANT | NEOFVALID | NTRUNCDELAYED);
 	if (vp->v_type == VDIR && np->n_dircache)
 		nfs_invaldircache(vp,
 		    NFS_INVALDIRCACHE_FORCE | NFS_INVALDIRCACHE_KEEPEOF);
 	VOP_UNLOCK(vp, 0);
 	if (sp != NULL) {
-		int error;
+		workqueue_enqueue(nfs_sillyworkq, &sp->s_work, NULL);
 		/*
 		 * Remove the silly file that was rename'd earlier
 		 * Just in case our thread also has the parent node locked,
 		 * we use LK_CANRECURSE.
 		 */
 		error = vn_lock(sp->s_dvp, LK_EXCLUSIVE | LK_CANRECURSE);
 		if (error || sp->s_dvp->v_data == NULL) {
 			/* XXX should recover */
 			printf("%s: vp=%p error=%d\n",
 			    __func__, sp->s_dvp, error);
 		} else {
 			nfs_removeit(sp);
 		kauth_cred_free(sp->s_cred);
 		vput(sp->s_dvp);
 		kmem_free(sp, sizeof(*sp));
+	}
 	return (0);
+}
 /*
  * Reclaim an nfsnode so that it can be used for other purposes.
  */
 int
 nfs_reclaim(v)
 	void *v;
+{
 	struct vop_reclaim_args /* {
 		struct vnode *a_vp;
 	} */ *ap = v;
 	struct vnode *vp = ap->a_vp;
 	struct nfsnode *np = VTONFS(vp);
 	struct nfsmount *nmp = VFSTONFS(vp->v_mount);
 	if (prtactive && vp->v_usecount > 1)
 		vprint("nfs_reclaim: pushing active", vp);
 	rw_enter(&nmp->nm_rbtlock, RW_WRITER);
 	rb_tree_remove_node(&nmp->nm_rbtree, &np->n_rbnode);
 	rw_exit(&nmp->nm_rbtlock);
 	/*
 	 * Free up any directory cookie structures and
 	 * large file handle structures that might be associated with
 	 * this nfs node.
 	 */
 	if (vp->v_type == VDIR && np->n_dircache != NULL) {
 		nfs_invaldircache(vp, NFS_INVALDIRCACHE_FORCE);
 		hashdone(np->n_dircache, HASH_LIST, nfsdirhashmask);
+	}
 	KASSERT(np->n_dirgens == NULL);
 	if (np->n_fhsize > NFS_SMALLFH)
 		kmem_free(np->n_fhp, np->n_fhsize);
 	pool_put(&nfs_vattr_pool, np->n_vattr);
 	if (np->n_rcred)
 		kauth_cred_free(np->n_rcred);
 	if (np->n_wcred)
 		kauth_cred_free(np->n_wcred);
 	cache_purge(vp);
 	if (vp->v_type == VREG) {
 		mutex_destroy(&np->n_commitlock);
+	}
 	genfs_node_destroy(vp);
 	pool_put(&nfs_node_pool, np);
 	vp->v_data = NULL;
 	return (0);
+}
 void
 nfs_gop_size(struct vnode *vp, off_t size, off_t *eobp, int flags)
+{
 	*eobp = MAX(size, vp->v_size);
+}
 int
 nfs_gop_alloc(struct vnode *vp, off_t off, off_t len, int flags,
     kauth_cred_t cred)
+{
 	return 0;
+}
 int
 nfs_gop_write(struct vnode *vp, struct vm_page **pgs, int npages, int flags)
+{
 	int i;
 	for (i = 0; i < npages; i++) {
 		pmap_page_protect(pgs[i], VM_PROT_READ);
+	}
 	return genfs_gop_write(vp, pgs, npages, flags);
+}
 /*
  * Remove a silly file that was rename'd earlier
  */
 static void
 nfs_sillyworker(struct work *work, void *arg)
+{
 	struct sillyrename *sp;
 	int error;
 	sp = (struct sillyrename *)work;
 	error = vn_lock(sp->s_dvp, LK_EXCLUSIVE);
 	if (error || sp->s_dvp->v_data == NULL) {
 		/* XXX should recover */
 		printf("%s: vp=%p error=%d\n", __func__, sp->s_dvp, error);
 		if (error == 0) {
 			vput(sp->s_dvp);
 		} else {
 			vrele(sp->s_dvp);
+		}
 	} else {
 		nfs_removeit(sp);
 		vput(sp->s_dvp);
+	}
 	kauth_cred_free(sp->s_cred);
 	kmem_free(sp, sizeof(*sp));
+}

 @@ -1,293 +1,294 @@
-/*	 $NetBSD: nfsnode.h,v 1.68 2008/10/22 11:36:06 matt Exp $	*/
+/*	 $NetBSD: nfsnode.h,v 1.69 2009/01/02 12:57:29 ad 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. 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.
+ *
  *	@(#)nfsnode.h	8.9 (Berkeley) 5/14/95
  */
 #ifndef _NFS_NFSNODE_H_
 #define _NFS_NFSNODE_H_
 #include <sys/condvar.h>
 #include <sys/mutex.h>
 #include <sys/rb.h>
 #include <sys/workqueue.h>
 #ifndef _NFS_NFS_H_
 #include <nfs/nfs.h>
 #endif
 #include <miscfs/genfs/genfs.h>
 #include <miscfs/genfs/genfs_node.h>
 /*
  * Silly rename structure that hangs off the nfsnode until the name
  * can be removed by nfs_inactive()
  */
 struct sillyrename {
 	struct work	s_work;
 	kauth_cred_t	s_cred;
 	struct	vnode *s_dvp;
 	long	s_namlen;
 	char	s_name[20];
 };
 /*
  * Definitions for the directory cache. Because directory cookies
  * are an opaque 64 bit entity, we need to provide some sort of
  * mapping between cookies and logical blocknumbers. Also,
  * we should store the cookies from the server somewhere,
  * to be able to satisfy VOP_READDIR requests for cookies.
  * We can't store the cookies in the dirent structure, as some
  * other systems.
+ *
  * Each offset is hashed into a per-nfsnode hashtable. An entry
  * found therein contains information about the (faked up)
  * logical blocknumber, and also a pointer to a buffer where
  * the cookies are stored.
  */
 LIST_HEAD(nfsdirhashhead, nfsdircache);
 TAILQ_HEAD(nfsdirchainhead, nfsdircache);
 struct nfsdircache {
 	off_t		dc_cookie;		/* Own offset (key) */
 	off_t		dc_blkcookie;		/* Offset of block we're in */
 	LIST_ENTRY(nfsdircache) dc_hash;	/* Hash chain */
 	TAILQ_ENTRY(nfsdircache) dc_chain;	/* Least recently entered chn */
 	u_int32_t	dc_cookie32;		/* Key for 64<->32 xlate case */
 	int		dc_entry;		/* Entry number within block */
 	int		dc_refcnt;		/* Reference count */
 	int		dc_flags;		/* NFSDC_ flags */
 };
 #define	NFSDC_INVALID	1
 /*
  * NFSDC_BLKNO: get buffer cache index
  */
 #define	NFSDC_BLKNO(ndp)	((daddr_t)(ndp)->dc_blkcookie)
 /*
  * The nfsnode is the nfs equivalent to ufs's inode. Any similarity
  * is purely coincidental.
  * There is a unique nfsnode allocated for each active file,
  * each current directory, each mounted-on file, text file, and the root.
  * An nfsnode is 'named' by its file handle. (nget/nfs_node.c)
  */
 struct nfsnode_spec {
 	struct timespec	nspec_mtim;	/* local mtime */
 	struct timespec	nspec_atim;	/* local atime */
 };
 struct nfsnode_reg {
 	off_t nreg_pushedlo;		/* 1st blk in commited range */
 	off_t nreg_pushedhi;		/* Last block in range */
 	off_t nreg_pushlo;		/* 1st block in commit range */
 	off_t nreg_pushhi;		/* Last block in range */
 	kmutex_t nreg_commitlock;	/* Serialize commits XXX */
 	int nreg_commitflags;
 	int nreg_error;			/* Save write error value */
 };
 struct nfsnode_dir {
 	off_t ndir_direof;		/* EOF offset cache */
 	nfsuint64 ndir_cookieverf;	/* Cookie verifier */
 	struct nfsdirhashhead *ndir_dircache; /* offset -> cache hash heads */
 	struct nfsdirchainhead ndir_dirchain; /* Chain of dir cookies */
 	struct timespec ndir_nctime;	/* Last name cache entry */
 	unsigned ndir_dircachesize;	/* Size of dir cookie cache */
 };
 struct nfsnode {
 	struct genfs_node	n_gnode;
 	u_quad_t		n_size;		/* Current size of file */
 	union {
 		struct nfsnode_spec	nu_spec;
 		struct nfsnode_reg	nu_reg;
 		struct nfsnode_dir	nu_dir;
 	} n_un1;
 #define n_mtim		n_un1.nu_spec.nspec_mtim
 #define n_atim		n_un1.nu_spec.nspec_atim
 #define	n_pushedlo	n_un1.nu_reg.nreg_pushedlo
 #define	n_pushedhi	n_un1.nu_reg.nreg_pushedhi
 #define	n_pushlo	n_un1.nu_reg.nreg_pushlo
 #define	n_pushhi	n_un1.nu_reg.nreg_pushhi
 #define n_commitlock	n_un1.nu_reg.nreg_commitlock
 #define n_commitflags	n_un1.nu_reg.nreg_commitflags
 #define n_error		n_un1.nu_reg.nreg_error
 #define n_direofoffset	n_un1.nu_dir.ndir_direof
 #define n_cookieverf	n_un1.nu_dir.ndir_cookieverf
 #define n_dircache	n_un1.nu_dir.ndir_dircache
 #define	n_dirchain	n_un1.nu_dir.ndir_dirchain
 #define	n_nctime	n_un1.nu_dir.ndir_nctime
 #define	n_dircachesize	n_un1.nu_dir.ndir_dircachesize
 	union {
 		struct sillyrename *nf_silly;	/* !VDIR: silly rename struct */
 		unsigned *ndir_dirgens;		/* 32<->64bit xlate gen. no. */
 	} n_un2;
 #define n_sillyrename	n_un2.nf_silly
 #define n_dirgens	n_un2.ndir_dirgens
 	struct rb_node		n_rbnode;	/* red/black node */
 	nfsfh_t			*n_fhp;		/* NFS File Handle */
 	struct vattr		*n_vattr;	/* Vnode attribute cache */
 	struct vnode		*n_vnode;	/* associated vnode */
 	struct lockf		*n_lockf;	/* Locking record of file */
 	time_t			n_attrstamp;	/* Attr. cache timestamp */
 	struct timespec		n_mtime;	/* Prev modify time. */
 	time_t			n_ctime;	/* Prev create time. */
 	short			n_fhsize;	/* size in bytes, of fh */
 	short			n_flag;		/* Flag for locking.. */
 	nfsfh_t			n_fh;		/* Small File Handle */
 	time_t			n_accstamp;	/* Access cache timestamp */
 	uid_t			n_accuid;	/* Last access requester */
 	int			n_accmode;	/* Mode last requested */
 	int			n_accerror;	/* Error last returned */
 	kauth_cred_t		n_rcred;
 	kauth_cred_t		n_wcred;
 };
 /*
  * Values for n_commitflags
  */
 #define NFS_COMMIT_PUSH_VALID	0x0001		/* push range valid */
 #define NFS_COMMIT_PUSHED_VALID	0x0002		/* pushed range valid */
 /*
  * Flags for n_flag
  */
 #define	NFLUSHWANT	0x0001	/* Want wakeup from a flush in prog. */
 #define	NFLUSHINPROG	0x0002	/* Avoid multiple calls to vinvalbuf() */
 #define	NMODIFIED	0x0004	/* Might have a modified buffer in bio */
 #define	NWRITEERR	0x0008	/* Flag write errors so close will know */
 #define	NACC		0x0100	/* Special file accessed */
 #define	NUPD		0x0200	/* Special file updated */
 #define	NCHG		0x0400	/* Special file times changed */
 #define	NTRUNCDELAYED	0x1000	/* Should be truncated later;
 				   implies stale cache */
 #define	NREMOVED	0x2000	/* Has been removed */
 #define	NUSEOPENCRED	0x4000	/* Try open cred first rather than owner's */
 #define	NEOFVALID	0x8000	/* dir: n_direofoffset is valid */
 #define	NFS_EOFVALID(ndp)	((ndp)->n_flag & NEOFVALID)
 /*
  * Convert between nfsnode pointers and vnode pointers
  */
 #define VTONFS(vp)	((struct nfsnode *)(vp)->v_data)
 #define NFSTOV(np)	((np)->n_vnode)
 #ifdef _KERNEL
 /*
  * Per-nfsiod datas
  */
 struct nfs_iod {
 	kmutex_t nid_lock;
 	kcondvar_t nid_cv;
 	LIST_ENTRY(nfs_iod) nid_idle;
 	struct nfsmount *nid_mount;
 	bool nid_exiting;
 	LIST_ENTRY(nfs_iod) nid_all;
 };
 LIST_HEAD(nfs_iodlist, nfs_iod);
 extern kmutex_t nfs_iodlist_lock;
 extern struct nfs_iodlist nfs_iodlist_idle;
 extern struct nfs_iodlist nfs_iodlist_all;
 extern u_long nfsdirhashmask;
 /*
  * Prototypes for NFS vnode operations
  */
 int	nfs_lookup	__P((void *));
 int	nfs_create	__P((void *));
 int	nfs_mknod	__P((void *));
 int	nfs_open	__P((void *));
 int	nfs_close	__P((void *));
 int	nfsspec_close	__P((void *));
 int	nfsfifo_close	__P((void *));
 int	nfs_access	__P((void *));
 int	nfsspec_access	__P((void *));
 int	nfs_getattr	__P((void *));
 int	nfs_setattr	__P((void *));
 int	nfs_read	__P((void *));
 int	nfs_write	__P((void *));
 int	nfsspec_read	__P((void *));
 int	nfsspec_write	__P((void *));
 int	nfsfifo_read	__P((void *));
 int	nfsfifo_write	__P((void *));
 #define	nfs_ioctl	genfs_enoioctl
 #define	nfs_poll	genfs_poll
 #define nfs_revoke	genfs_revoke
 #define	nfs_mmap	genfs_mmap
 int	nfs_fsync	__P((void *));
 #define nfs_seek	genfs_seek
 int	nfs_remove	__P((void *));
 int	nfs_link	__P((void *));
 int	nfs_rename	__P((void *));
 int	nfs_mkdir	__P((void *));
 int	nfs_rmdir	__P((void *));
 int	nfs_symlink	__P((void *));
 int	nfs_readdir	__P((void *));
 int	nfs_readlink	__P((void *));
 #define	nfs_abortop	genfs_abortop
 int	nfs_inactive	__P((void *));
 int	nfs_reclaim	__P((void *));
 #define nfs_lock	genfs_lock
 int	nfs_unlock	__P((void *));
 #define nfs_islocked	genfs_islocked
 int	nfs_bmap	__P((void *));
 int	nfs_strategy	__P((void *));
 int	nfs_print	__P((void *));
 int	nfs_pathconf	__P((void *));
 int	nfs_advlock	__P((void *));
 int	nfs_getpages	__P((void *));
 int	nfs_putpages	__P((void *));
 int	nfs_gop_write(struct vnode *, struct vm_page **, int, int);
 int	nfs_kqfilter	__P((void *));
 extern int (**nfsv2_vnodeop_p) __P((void *));
 #define	NFS_INVALIDATE_ATTRCACHE(np)	(np)->n_attrstamp = 0
 #endif /* _KERNEL */
 #endif