rename vcache_node

- Rename struct vcache_node to vnode_impl, start its fields with vi_.
- Rename enum vcache_state to vnode_state, start its elements with VS_.
- Rename macros VN_TO_VP and VP_TO_VN to VIMPL_TO_VNODE and VNODE_TO_VIMPL.
- Add typedef struct vnode_impl vnode_impl_t.

diff -r 5357560b10e8 -r a383ca0b02f4 sys/kern/vfs_vnode.c
--- a/sys/kern/vfs_vnode.c	Sat Oct 22 13:39:01 2016 +0200
+++ b/sys/kern/vfs_vnode.c	Sat Oct 22 13:39:05 2016 +0200
@@ -187,28 +187,29 @@
 /* Flags to vrelel. */
 #define	VRELEL_ASYNC_RELE	0x0001	/* Always defer to vrele thread. */
 
-enum vcache_state {
-	VN_MARKER,	/* Stable, used as marker. Will not change. */
-	VN_LOADING,	/* Intermediate, initialising the fs node. */
-	VN_ACTIVE,	/* Stable, valid fs node attached. */
-	VN_BLOCKED,	/* Intermediate, active, no new references allowed. */
-	VN_RECLAIMING,	/* Intermediate, detaching the fs node. */
-	VN_RECLAIMED	/* Stable, no fs node attached. */
+enum vnode_state {
+	VS_MARKER,	/* Stable, used as marker. Will not change. */
+	VS_LOADING,	/* Intermediate, initialising the fs node. */
+	VS_ACTIVE,	/* Stable, valid fs node attached. */
+	VS_BLOCKED,	/* Intermediate, active, no new references allowed. */
+	VS_RECLAIMING,	/* Intermediate, detaching the fs node. */
+	VS_RECLAIMED	/* Stable, no fs node attached. */
 };
 struct vcache_key {
 	struct mount *vk_mount;
 	const void *vk_key;
 	size_t vk_key_len;
 };
-struct vcache_node {
-	struct vnode vn_vnode;
-	enum vcache_state vn_state;
-	SLIST_ENTRY(vcache_node) vn_hash;
-	struct vcache_key vn_key;
+struct vnode_impl {
+	struct vnode vi_vnode;
+	enum vnode_state vi_state;
+	SLIST_ENTRY(vnode_impl) vi_hash;
+	struct vcache_key vi_key;
 };
+typedef struct vnode_impl vnode_impl_t;
 
-#define VN_TO_VP(node)	((vnode_t *)(node))
-#define VP_TO_VN(vp)	((struct vcache_node *)(vp))
+#define VIMPL_TO_VNODE(node)	((vnode_t *)(node))
+#define VNODE_TO_VIMPL(vp)	((vnode_impl_t *)(vp))
 
 u_int			numvnodes		__cacheline_aligned;
 
@@ -229,7 +230,7 @@
 static int		vrele_pending		__cacheline_aligned;
 static int		vrele_gen		__cacheline_aligned;
 
-SLIST_HEAD(hashhead, vcache_node);
+SLIST_HEAD(hashhead, vnode_impl);
 static struct {
 	kmutex_t	lock;
 	kcondvar_t	cv;
@@ -239,8 +240,8 @@
 }			vcache			__cacheline_aligned;
 
 static int		cleanvnode(void);
-static struct vcache_node *vcache_alloc(void);
-static void		vcache_free(struct vcache_node *);
+static vnode_impl_t *vcache_alloc(void);
+static void		vcache_free(vnode_impl_t *);
 static void		vcache_init(void);
 static void		vcache_reinit(void);
 static void		vcache_reclaim(vnode_t *);
@@ -258,21 +259,21 @@
 /* Vnode state operations and diagnostics. */
 
 static const char *
-vstate_name(enum vcache_state state)
+vstate_name(enum vnode_state state)
 {
 
 	switch (state) {
-	case VN_MARKER:
+	case VS_MARKER:
 		return "MARKER";
-	case VN_LOADING:
+	case VS_LOADING:
 		return "LOADING";
-	case VN_ACTIVE:
+	case VS_ACTIVE:
 		return "ACTIVE";
-	case VN_BLOCKED:
+	case VS_BLOCKED:
 		return "BLOCKED";
-	case VN_RECLAIMING:
+	case VS_RECLAIMING:
 		return "RECLAIMING";
-	case VN_RECLAIMED:
+	case VS_RECLAIMED:
 		return "RECLAIMED";
 	default:
 		return "ILLEGAL";
@@ -291,80 +292,80 @@
 	vstate_assert((vp), (state), __func__, __LINE__)
 
 static void
-vstate_assert(vnode_t *vp, enum vcache_state state, const char *func, int line)
+vstate_assert(vnode_t *vp, enum vnode_state state, const char *func, int line)
 {
-	struct vcache_node *node = VP_TO_VN(vp);
+	vnode_impl_t *node = VNODE_TO_VIMPL(vp);
 
 	KASSERTMSG(mutex_owned(vp->v_interlock), "at %s:%d", func, line);
 
-	if (__predict_true(node->vn_state == state))
+	if (__predict_true(node->vi_state == state))
 		return;
 	vnpanic(vp, "state is %s, expected %s at %s:%d",
-	    vstate_name(node->vn_state), vstate_name(state), func, line);
+	    vstate_name(node->vi_state), vstate_name(state), func, line);
 }
 
-static enum vcache_state
+static enum vnode_state
 vstate_assert_get(vnode_t *vp, const char *func, int line)
 {
-	struct vcache_node *node = VP_TO_VN(vp);
+	vnode_impl_t *node = VNODE_TO_VIMPL(vp);
 
 	KASSERTMSG(mutex_owned(vp->v_interlock), "at %s:%d", func, line);
-	if (node->vn_state == VN_MARKER)
+	if (node->vi_state == VS_MARKER)
 		vnpanic(vp, "state is %s at %s:%d",
-		    vstate_name(node->vn_state), func, line);
+		    vstate_name(node->vi_state), func, line);
 
-	return node->vn_state;
+	return node->vi_state;
 }
 
 static void
 vstate_assert_wait_stable(vnode_t *vp, const char *func, int line)
 {
-	struct vcache_node *node = VP_TO_VN(vp);
+	vnode_impl_t *node = VNODE_TO_VIMPL(vp);
 
 	KASSERTMSG(mutex_owned(vp->v_interlock), "at %s:%d", func, line);
-	if (node->vn_state == VN_MARKER)
+	if (node->vi_state == VS_MARKER)
 		vnpanic(vp, "state is %s at %s:%d",
-		    vstate_name(node->vn_state), func, line);
+		    vstate_name(node->vi_state), func, line);
 
-	while (node->vn_state != VN_ACTIVE && node->vn_state != VN_RECLAIMED)
+	while (node->vi_state != VS_ACTIVE && node->vi_state != VS_RECLAIMED)
 		cv_wait(&vp->v_cv, vp->v_interlock);
 
-	if (node->vn_state == VN_MARKER)
+	if (node->vi_state == VS_MARKER)
 		vnpanic(vp, "state is %s at %s:%d",
-		    vstate_name(node->vn_state), func, line);
+		    vstate_name(node->vi_state), func, line);
 }
 
 static void
-vstate_assert_change(vnode_t *vp, enum vcache_state from, enum vcache_state to,
+vstate_assert_change(vnode_t *vp, enum vnode_state from, enum vnode_state to,
     const char *func, int line)
 {
-	struct vcache_node *node = VP_TO_VN(vp);
+	vnode_impl_t *node = VNODE_TO_VIMPL(vp);
 
 	KASSERTMSG(mutex_owned(vp->v_interlock), "at %s:%d", func, line);
-	if (from == VN_LOADING)
+	if (from == VS_LOADING)
 		KASSERTMSG(mutex_owned(&vcache.lock), "at %s:%d", func, line);
 
-	if (from == VN_MARKER)
+	if (from == VS_MARKER)
 		vnpanic(vp, "from is %s at %s:%d",
 		    vstate_name(from), func, line);
-	if (to == VN_MARKER)
+	if (to == VS_MARKER)
 		vnpanic(vp, "to is %s at %s:%d",
 		    vstate_name(to), func, line);
-	if (node->vn_state != from)
+	if (node->vi_state != from)
 		vnpanic(vp, "from is %s, expected %s at %s:%d\n",
-		    vstate_name(node->vn_state), vstate_name(from), func, line);
+		    vstate_name(node->vi_state), vstate_name(from), func, line);
 
-	node->vn_state = to;
-	if (from == VN_LOADING)
+	node->vi_state = to;
+	if (from == VS_LOADING)
 		cv_broadcast(&vcache.cv);
-	if (to == VN_ACTIVE || to == VN_RECLAIMED)
+	if (to == VS_ACTIVE || to == VS_RECLAIMED)
 		cv_broadcast(&vp->v_cv);
 }
 
 #else /* defined(DIAGNOSTIC) */
 
 #define VSTATE_GET(vp) \
-	(VP_TO_VN((vp))->vn_state)
+	(VNODE_TO_VIMPL((vp))->vi_state)
 #define VSTATE_CHANGE(vp, from, to) \
 	vstate_change((vp), (from), (to))
 #define VSTATE_WAIT_STABLE(vp) \
@@ -374,21 +375,21 @@
 static void
 vstate_wait_stable(vnode_t *vp)
 {
-	struct vcache_node *node = VP_TO_VN(vp);
+	vnode_impl_t *node = VNODE_TO_VIMPL(vp);
 
-	while (node->vn_state != VN_ACTIVE && node->vn_state != VN_RECLAIMED)
+	while (node->vi_state != VS_ACTIVE && node->vi_state != VS_RECLAIMED)
 		cv_wait(&vp->v_cv, vp->v_interlock);
 }
 
 static void
-vstate_change(vnode_t *vp, enum vcache_state from, enum vcache_state to)
+vstate_change(vnode_t *vp, enum vnode_state from, enum vnode_state to)
 {
-	struct vcache_node *node = VP_TO_VN(vp);
+	vnode_impl_t *node = VNODE_TO_VIMPL(vp);
 
-	node->vn_state = to;
-	if (from == VN_LOADING)
+	node->vi_state = to;
+	if (from == VS_LOADING)
 		cv_broadcast(&vcache.cv);
-	if (to == VN_ACTIVE || to == VN_RECLAIMED)
+	if (to == VS_ACTIVE || to == VS_RECLAIMED)
 		cv_broadcast(&vp->v_cv);
 }
 
@@ -427,16 +428,16 @@
 vnode_t *
 vnalloc_marker(struct mount *mp)
 {
-	struct vcache_node *node;
+	vnode_impl_t *node;
 	vnode_t *vp;
 
 	node = pool_cache_get(vcache.pool, PR_WAITOK);
 	memset(node, 0, sizeof(*node));
-	vp = VN_TO_VP(node);
+	vp = VIMPL_TO_VNODE(node);
 	uvm_obj_init(&vp->v_uobj, &uvm_vnodeops, true, 0);
 	vp->v_mount = mp;
 	vp->v_type = VBAD;
-	node->vn_state = VN_MARKER;
+	node->vi_state = VS_MARKER;
 
 	return vp;
 }
@@ -447,10 +448,10 @@
 void
 vnfree_marker(vnode_t *vp)
 {
-	struct vcache_node *node;
+	vnode_impl_t *node;
 
-	node = VP_TO_VN(vp);
-	KASSERT(node->vn_state == VN_MARKER);
+	node = VNODE_TO_VIMPL(vp);
+	KASSERT(node->vi_state == VS_MARKER);
 	uvm_obj_destroy(&vp->v_uobj, true);
 	pool_cache_put(vcache.pool, node);
 }
@@ -462,7 +463,7 @@
 vnis_marker(vnode_t *vp)
 {
 
-	return (VP_TO_VN(vp)->vn_state == VN_MARKER);
+	return (VNODE_TO_VIMPL(vp)->vi_state == VS_MARKER);
 }
 
 /*
@@ -589,13 +590,13 @@
  *
  * => Must be called with v_interlock held.
  *
- * If state is VN_RECLAIMING, the vnode may be eliminated in vcache_reclaim().
+ * If state is VS_RECLAIMING, the vnode may be eliminated in vcache_reclaim().
  * In that case, we cannot grab the vnode, so the process is awakened when
  * the transition is completed, and an error returned to indicate that the
  * vnode is no longer usable.
  *
- * If state is VN_LOADING or VN_BLOCKED, wait until the vnode enters a
- * stable state (VN_ACTIVE or VN_RECLAIMED).
+ * If state is VS_LOADING or VS_BLOCKED, wait until the vnode enters a
+ * stable state (VS_ACTIVE or VS_RECLAIMED).
  */
 int
 vget(vnode_t *vp, int flags, bool waitok)
@@ -623,10 +624,10 @@
 	 */
 	if (! ISSET(flags, LK_NOWAIT))
 		VSTATE_WAIT_STABLE(vp);
-	if (VSTATE_GET(vp) == VN_RECLAIMED) {
+	if (VSTATE_GET(vp) == VS_RECLAIMED) {
 		vrelel(vp, 0);
 		return ENOENT;
-	} else if (VSTATE_GET(vp) != VN_ACTIVE) {
+	} else if (VSTATE_GET(vp) != VS_ACTIVE) {
 		KASSERT(ISSET(flags, LK_NOWAIT));
 		vrelel(vp, 0);
 		return EBUSY;
@@ -635,7 +636,7 @@
 	/*
 	 * Ok, we got it in good shape.
 	 */
-	VSTATE_ASSERT(vp, VN_ACTIVE);
+	VSTATE_ASSERT(vp, VS_ACTIVE);
 	mutex_exit(vp->v_interlock);
 
 	return 0;
@@ -687,7 +688,7 @@
 	KASSERT(vp->v_freelisthd == NULL);
 
 	if (__predict_false(vp->v_op == dead_vnodeop_p &&
-	    VSTATE_GET(vp) != VN_RECLAIMED)) {
+	    VSTATE_GET(vp) != VS_RECLAIMED)) {
 		vnpanic(vp, "dead but not clean");
 	}
 
@@ -714,7 +715,7 @@
 	 * If not clean, deactivate the vnode, but preserve
 	 * our reference across the call to VOP_INACTIVE().
 	 */
-	if (VSTATE_GET(vp) != VN_RECLAIMED) {
+	if (VSTATE_GET(vp) != VS_RECLAIMED) {
 		recycle = false;
 
 		/*
@@ -771,7 +772,7 @@
 			mutex_exit(vp->v_interlock);
 			return;
 		}
-		VSTATE_CHANGE(vp, VN_ACTIVE, VN_BLOCKED);
+		VSTATE_CHANGE(vp, VS_ACTIVE, VS_BLOCKED);
 		mutex_exit(vp->v_interlock);
 
 		/*
@@ -789,7 +790,7 @@
 				recycle = false;
 		}
 		mutex_enter(vp->v_interlock);
-		VSTATE_CHANGE(vp, VN_BLOCKED, VN_ACTIVE);
+		VSTATE_CHANGE(vp, VS_BLOCKED, VS_ACTIVE);
 		if (!recycle) {
 			if (vtryrele(vp)) {
 				mutex_exit(vp->v_interlock);
@@ -812,7 +813,7 @@
 		 * otherwise just free it.
 		 */
 		if (recycle) {
-			VSTATE_ASSERT(vp, VN_ACTIVE);
+			VSTATE_ASSERT(vp, VS_ACTIVE);
 			vcache_reclaim(vp);
 		}
 		KASSERT(vp->v_usecount > 0);
@@ -824,7 +825,7 @@
 		return;
 	}
 
-	if (VSTATE_GET(vp) == VN_RECLAIMED) {
+	if (VSTATE_GET(vp) == VS_RECLAIMED) {
 		/*
 		 * It's clean so destroy it.  It isn't referenced
 		 * anywhere since it has been reclaimed.
@@ -836,7 +837,7 @@
 		if (vp->v_type == VBLK || vp->v_type == VCHR) {
 			spec_node_destroy(vp);
 		}
-		vcache_free(VP_TO_VN(vp));
+		vcache_free(VNODE_TO_VIMPL(vp));
 	} else {
 		/*
 		 * Otherwise, put it back onto the freelist.  It
@@ -1027,7 +1028,7 @@
 
 	mutex_enter(vp->v_interlock);
 	VSTATE_WAIT_STABLE(vp);
-	if (VSTATE_GET(vp) == VN_RECLAIMED) {
+	if (VSTATE_GET(vp) == VS_RECLAIMED) {
 		mutex_exit(vp->v_interlock);
 		return;
 	} else if (vp->v_type != VBLK && vp->v_type != VCHR) {
@@ -1055,7 +1056,7 @@
 {
 
 	if (vn_lock(vp, LK_EXCLUSIVE) != 0) {
-		VSTATE_ASSERT(vp, VN_RECLAIMED);
+		VSTATE_ASSERT(vp, VS_RECLAIMED);
 		vrele(vp);
 	}
 
@@ -1078,7 +1079,7 @@
 vcache_init(void)
 {
 
-	vcache.pool = pool_cache_init(sizeof(struct vcache_node), 0, 0, 0,
+	vcache.pool = pool_cache_init(sizeof(vnode_impl_t), 0, 0, 0,
 	    "vcachepl", NULL, IPL_NONE, NULL, NULL, NULL);
 	KASSERT(vcache.pool != NULL);
 	mutex_init(&vcache.lock, MUTEX_DEFAULT, IPL_NONE);
@@ -1094,7 +1095,7 @@
 	uint32_t hash;
 	u_long oldmask, newmask;
 	struct hashhead *oldtab, *newtab;
-	struct vcache_node *node;
+	vnode_impl_t *node;
 
 	newtab = hashinit(desiredvnodes, HASH_SLIST, true, &newmask);
 	mutex_enter(&vcache.lock);
@@ -1104,31 +1105,31 @@
 	vcache.hashmask = newmask;
 	for (i = 0; i <= oldmask; i++) {
 		while ((node = SLIST_FIRST(&oldtab[i])) != NULL) {
-			SLIST_REMOVE(&oldtab[i], node, vcache_node, vn_hash);
-			hash = vcache_hash(&node->vn_key);
+			SLIST_REMOVE(&oldtab[i], node, vnode_impl, vi_hash);
+			hash = vcache_hash(&node->vi_key);
 			SLIST_INSERT_HEAD(&newtab[hash & vcache.hashmask],
-			    node, vn_hash);
+			    node, vi_hash);
 		}
 	}
 	mutex_exit(&vcache.lock);
 	hashdone(oldtab, HASH_SLIST, oldmask);
 }
 
-static inline struct vcache_node *
+static inline vnode_impl_t *
 vcache_hash_lookup(const struct vcache_key *key, uint32_t hash)
 {
 	struct hashhead *hashp;
-	struct vcache_node *node;
+	vnode_impl_t *node;
 
 	KASSERT(mutex_owned(&vcache.lock));
 
 	hashp = &vcache.hashtab[hash & vcache.hashmask];
-	SLIST_FOREACH(node, hashp, vn_hash) {
-		if (key->vk_mount != node->vn_key.vk_mount)
+	SLIST_FOREACH(node, hashp, vi_hash) {
+		if (key->vk_mount != node->vi_key.vk_mount)
 			continue;
-		if (key->vk_key_len != node->vn_key.vk_key_len)
+		if (key->vk_key_len != node->vi_key.vk_key_len)
 			continue;
-		if (memcmp(key->vk_key, node->vn_key.vk_key, key->vk_key_len))
+		if (memcmp(key->vk_key, node->vi_key.vk_key, key->vk_key_len))
 			continue;
 		return node;
 	}
@@ -1138,18 +1139,18 @@
 /*
  * Allocate a new, uninitialized vcache node.
  */
-static struct vcache_node *
+static vnode_impl_t *
 vcache_alloc(void)
 {
-	struct vcache_node *node;
+	vnode_impl_t *node;
 	vnode_t *vp;
 
 	node = pool_cache_get(vcache.pool, PR_WAITOK);
 	memset(node, 0, sizeof(*node));
 
-	/* SLIST_INIT(&node->vn_hash); */
+	/* SLIST_INIT(&node->vi_hash); */
 
-	vp = VN_TO_VP(node);
+	vp = VIMPL_TO_VNODE(node);
 	uvm_obj_init(&vp->v_uobj, &uvm_vnodeops, true, 0);
 	cv_init(&vp->v_cv, "vnode");
 	/* LIST_INIT(&vp->v_nclist); */
@@ -1166,7 +1167,7 @@
 	vp->v_type = VNON;
 	vp->v_size = vp->v_writesize = VSIZENOTSET;
 
-	node->vn_state = VN_LOADING;
+	node->vi_state = VS_LOADING;
 
 	return node;
 }
@@ -1175,11 +1176,11 @@
  * Free an unused, unreferenced vcache node.
  */
 static void
-vcache_free(struct vcache_node *node)
+vcache_free(vnode_impl_t *node)
 {
 	vnode_t *vp;
 
-	vp = VN_TO_VP(node);
+	vp = VIMPL_TO_VNODE(node);
 
 	KASSERT(vp->v_usecount == 0);
 
@@ -1205,7 +1206,7 @@
 	const void *new_key;
 	struct vnode *vp;
 	struct vcache_key vcache_key;
-	struct vcache_node *node, *new_node;
+	vnode_impl_t *node, *new_node;
 
 	new_key = NULL;
 	*vpp = NULL;
@@ -1224,17 +1225,17 @@
 		/*
 		 * If the vnode is loading we cannot take the v_interlock
 		 * here as it might change during load (see uvm_obj_setlock()).
-		 * As changing state from VN_LOADING requires both vcache.lock
+		 * As changing state from VS_LOADING requires both vcache.lock
 		 * and v_interlock it is safe to test with vcache.lock held.
 		 *
-		 * Wait for vnodes changing state from VN_LOADING and retry.
+		 * Wait for vnodes changing state from VS_LOADING and retry.
 		 */
-		if (__predict_false(node->vn_state == VN_LOADING)) {
+		if (__predict_false(node->vi_state == VS_LOADING)) {
 			cv_wait(&vcache.cv, &vcache.lock);
 			mutex_exit(&vcache.lock);
 			goto again;
 		}
-		vp = VN_TO_VP(node);
+		vp = VIMPL_TO_VNODE(node);
 		mutex_enter(vp->v_interlock);
 		mutex_exit(&vcache.lock);
 		error = vget(vp, 0, true /* wait */);
@@ -1252,20 +1253,20 @@
 	if (error)
 		return error;
 	new_node = vcache_alloc();
-	new_node->vn_key = vcache_key;
-	vp = VN_TO_VP(new_node);
+	new_node->vi_key = vcache_key;
+	vp = VIMPL_TO_VNODE(new_node);
 	mutex_enter(&vcache.lock);
 	node = vcache_hash_lookup(&vcache_key, hash);
 	if (node == NULL) {
 		SLIST_INSERT_HEAD(&vcache.hashtab[hash & vcache.hashmask],
-		    new_node, vn_hash);
+		    new_node, vi_hash);
 		node = new_node;
 	}
 
 	/* If another thread beat us inserting this node, retry. */
 	if (node != new_node) {
 		mutex_enter(vp->v_interlock);
-		VSTATE_CHANGE(vp, VN_LOADING, VN_RECLAIMED);
+		VSTATE_CHANGE(vp, VS_LOADING, VS_RECLAIMED);
 		mutex_exit(&vcache.lock);
 		vrelel(vp, 0);
 		vfs_unbusy(mp, false, NULL);
@@ -1273,14 +1274,14 @@
 	}
 	mutex_exit(&vcache.lock);
 
-	/* Load the fs node.  Exclusive as new_node is VN_LOADING. */
+	/* Load the fs node.  Exclusive as new_node is VS_LOADING. */
 	error = VFS_LOADVNODE(mp, vp, key, key_len, &new_key);
 	if (error) {
 		mutex_enter(&vcache.lock);
 		SLIST_REMOVE(&vcache.hashtab[hash & vcache.hashmask],
-		    new_node, vcache_node, vn_hash);
+		    new_node, vnode_impl, vi_hash);
 		mutex_enter(vp->v_interlock);
-		VSTATE_CHANGE(vp, VN_LOADING, VN_RECLAIMED);
+		VSTATE_CHANGE(vp, VS_LOADING, VS_RECLAIMED);
 		mutex_exit(&vcache.lock);
 		vrelel(vp, 0);
 		vfs_unbusy(mp, false, NULL);
@@ -1297,9 +1298,9 @@
 
 	/* Finished loading, finalize node. */
 	mutex_enter(&vcache.lock);
-	new_node->vn_key.vk_key = new_key;
+	new_node->vi_key.vk_key = new_key;
 	mutex_enter(vp->v_interlock);
-	VSTATE_CHANGE(vp, VN_LOADING, VN_ACTIVE);
+	VSTATE_CHANGE(vp, VS_LOADING, VS_ACTIVE);
 	mutex_exit(vp->v_interlock);
 	mutex_exit(&vcache.lock);
 	*vpp = vp;
@@ -1316,8 +1317,8 @@
 	int error;
 	uint32_t hash;
 	struct vnode *ovp, *vp;
-	struct vcache_node *new_node;
-	struct vcache_node *old_node __diagused;
+	vnode_impl_t *new_node;
+	vnode_impl_t *old_node __diagused;
 
 	*vpp = NULL;
 
@@ -1326,30 +1327,30 @@
 	if (error)
 		return error;
 	new_node = vcache_alloc();
-	new_node->vn_key.vk_mount = mp;
-	vp = VN_TO_VP(new_node);
+	new_node->vi_key.vk_mount = mp;
+	vp = VIMPL_TO_VNODE(new_node);
 
 	/* Create and load the fs node. */
 	error = VFS_NEWVNODE(mp, dvp, vp, vap, cred,
-	    &new_node->vn_key.vk_key_len, &new_node->vn_key.vk_key);
+	    &new_node->vi_key.vk_key_len, &new_node->vi_key.vk_key);
 	if (error) {
 		mutex_enter(&vcache.lock);
 		mutex_enter(vp->v_interlock);
-		VSTATE_CHANGE(vp, VN_LOADING, VN_RECLAIMED);
+		VSTATE_CHANGE(vp, VS_LOADING, VS_RECLAIMED);
 		mutex_exit(&vcache.lock);
 		vrelel(vp, 0);
 		vfs_unbusy(mp, false, NULL);
 		KASSERT(*vpp == NULL);
 		return error;
 	}
-	KASSERT(new_node->vn_key.vk_key != NULL);
+	KASSERT(new_node->vi_key.vk_key != NULL);
 	KASSERT(vp->v_op != NULL);
-	hash = vcache_hash(&new_node->vn_key);
+	hash = vcache_hash(&new_node->vi_key);
 
 	/* Wait for previous instance to be reclaimed, then insert new node. */
 	mutex_enter(&vcache.lock);
-	while ((old_node = vcache_hash_lookup(&new_node->vn_key, hash))) {
-		ovp = VN_TO_VP(old_node);
+	while ((old_node = vcache_hash_lookup(&new_node->vi_key, hash))) {
+		ovp = VIMPL_TO_VNODE(old_node);
 		mutex_enter(ovp->v_interlock);
 		mutex_exit(&vcache.lock);
 		error = vget(ovp, 0, true /* wait */);
@@ -1357,7 +1358,7 @@
 		mutex_enter(&vcache.lock);
 	}
 	SLIST_INSERT_HEAD(&vcache.hashtab[hash & vcache.hashmask],
-	    new_node, vn_hash);
+	    new_node, vi_hash);
 	mutex_exit(&vcache.lock);
 	vfs_insmntque(vp, mp);
 	if ((mp->mnt_iflag & IMNT_MPSAFE) != 0)
@@ -1367,7 +1368,7 @@
 	/* Finished loading, finalize node. */
 	mutex_enter(&vcache.lock);
 	mutex_enter(vp->v_interlock);
-	VSTATE_CHANGE(vp, VN_LOADING, VN_ACTIVE);
+	VSTATE_CHANGE(vp, VS_LOADING, VS_ACTIVE);
 	mutex_exit(&vcache.lock);
 	mutex_exit(vp->v_interlock);
 	*vpp = vp;
@@ -1385,7 +1386,7 @@
 {
 	uint32_t old_hash, new_hash;
 	struct vcache_key old_vcache_key, new_vcache_key;
-	struct vcache_node *node, *new_node;
+	vnode_impl_t *node, *new_node;
 	struct vnode *tvp;
 
 	old_vcache_key.vk_mount = mp;
@@ -1399,29 +1400,29 @@
 	new_hash = vcache_hash(&new_vcache_key);
 
 	new_node = vcache_alloc();
-	new_node->vn_key = new_vcache_key;
-	tvp = VN_TO_VP(new_node);
+	new_node->vi_key = new_vcache_key;
+	tvp = VIMPL_TO_VNODE(new_node);
 
 	/* Insert locked new node used as placeholder. */
 	mutex_enter(&vcache.lock);
 	node = vcache_hash_lookup(&new_vcache_key, new_hash);
 	if (node != NULL) {
 		mutex_enter(tvp->v_interlock);
-		VSTATE_CHANGE(tvp, VN_LOADING, VN_RECLAIMED);
+		VSTATE_CHANGE(tvp, VS_LOADING, VS_RECLAIMED);
 		mutex_exit(&vcache.lock);
 		vrelel(tvp, 0);
 		return EEXIST;
 	}
 	SLIST_INSERT_HEAD(&vcache.hashtab[new_hash & vcache.hashmask],
-	    new_node, vn_hash);
+	    new_node, vi_hash);
 
 	/* Lock old node. */
 	node = vcache_hash_lookup(&old_vcache_key, old_hash);
 	KASSERT(node != NULL);
-	KASSERT(VN_TO_VP(node) == vp);
+	KASSERT(VIMPL_TO_VNODE(node) == vp);
 	mutex_enter(vp->v_interlock);
-	VSTATE_CHANGE(vp, VN_ACTIVE, VN_BLOCKED);
-	node->vn_key = old_vcache_key;
+	VSTATE_CHANGE(vp, VS_ACTIVE, VS_BLOCKED);
+	node->vi_key = old_vcache_key;
 	mutex_exit(vp->v_interlock);
 	mutex_exit(&vcache.lock);
 	return 0;
@@ -1437,7 +1438,7 @@
 {
 	uint32_t old_hash, new_hash;
 	struct vcache_key old_vcache_key, new_vcache_key;
-	struct vcache_node *old_node, *new_node;
+	vnode_impl_t *old_node, *new_node;
 	struct vnode *tvp;
 
 	old_vcache_key.vk_mount = mp;
@@ -1455,32 +1456,32 @@
 	/* Lookup old and new node. */
 	old_node = vcache_hash_lookup(&old_vcache_key, old_hash);
 	KASSERT(old_node != NULL);
-	KASSERT(VN_TO_VP(old_node) == vp);
+	KASSERT(VIMPL_TO_VNODE(old_node) == vp);
 	mutex_enter(vp->v_interlock);
-	VSTATE_ASSERT(vp, VN_BLOCKED);
+	VSTATE_ASSERT(vp, VS_BLOCKED);
 
 	new_node = vcache_hash_lookup(&new_vcache_key, new_hash);
 	KASSERT(new_node != NULL);
-	KASSERT(new_node->vn_key.vk_key_len == new_key_len);
-	tvp = VN_TO_VP(new_node);
+	KASSERT(new_node->vi_key.vk_key_len == new_key_len);
+	tvp = VIMPL_TO_VNODE(new_node);
 	mutex_enter(tvp->v_interlock);
-	VSTATE_ASSERT(VN_TO_VP(new_node), VN_LOADING);
+	VSTATE_ASSERT(VIMPL_TO_VNODE(new_node), VS_LOADING);
 
 	/* Rekey old node and put it onto its new hashlist. */
-	old_node->vn_key = new_vcache_key;
+	old_node->vi_key = new_vcache_key;
 	if (old_hash != new_hash) {
 		SLIST_REMOVE(&vcache.hashtab[old_hash & vcache.hashmask],
-		    old_node, vcache_node, vn_hash);
+		    old_node, vnode_impl, vi_hash);
 		SLIST_INSERT_HEAD(&vcache.hashtab[new_hash & vcache.hashmask],
-		    old_node, vn_hash);
+		    old_node, vi_hash);
 	}
-	VSTATE_CHANGE(vp, VN_BLOCKED, VN_ACTIVE);
+	VSTATE_CHANGE(vp, VS_BLOCKED, VS_ACTIVE);
 	mutex_exit(vp->v_interlock);
 
 	/* Remove new node used as placeholder. */
 	SLIST_REMOVE(&vcache.hashtab[new_hash & vcache.hashmask],
-	    new_node, vcache_node, vn_hash);
-	VSTATE_CHANGE(tvp, VN_LOADING, VN_RECLAIMED);
+	    new_node, vnode_impl, vi_hash);
+	VSTATE_CHANGE(tvp, VS_LOADING, VS_RECLAIMED);
 	mutex_exit(&vcache.lock);
 	vrelel(tvp, 0);
 }
@@ -1495,7 +1496,7 @@
 vcache_reclaim(vnode_t *vp)
 {
 	lwp_t *l = curlwp;
-	struct vcache_node *node = VP_TO_VN(vp);
+	vnode_impl_t *node = VNODE_TO_VIMPL(vp);
 	uint32_t hash;
 	uint8_t temp_buf[64], *temp_key;
 	size_t temp_key_len;
@@ -1508,12 +1509,12 @@
 	KASSERT(vp->v_usecount != 0);
 
 	active = (vp->v_usecount > 1);
-	temp_key_len = node->vn_key.vk_key_len;
+	temp_key_len = node->vi_key.vk_key_len;
 	/*
 	 * Prevent the vnode from being recycled or brought into use
 	 * while we clean it out.
 	 */
-	VSTATE_CHANGE(vp, VN_ACTIVE, VN_RECLAIMING);
+	VSTATE_CHANGE(vp, VS_ACTIVE, VS_RECLAIMING);
 	if (vp->v_iflag & VI_EXECMAP) {
 		atomic_add_int(&uvmexp.execpages, -vp->v_uobj.uo_npages);
 		atomic_add_int(&uvmexp.filepages, vp->v_uobj.uo_npages);
@@ -1522,14 +1523,14 @@
 	mutex_exit(vp->v_interlock);
 
 	/* Replace the vnode key with a temporary copy. */
-	if (node->vn_key.vk_key_len > sizeof(temp_buf)) {
+	if (node->vi_key.vk_key_len > sizeof(temp_buf)) {
 		temp_key = kmem_alloc(temp_key_len, KM_SLEEP);
 	} else {
 		temp_key = temp_buf;
 	}
 	mutex_enter(&vcache.lock);
-	memcpy(temp_key, node->vn_key.vk_key, temp_key_len);
-	node->vn_key.vk_key = temp_key;
+	memcpy(temp_key, node->vi_key.vk_key, temp_key_len);
+	node->vi_key.vk_key = temp_key;
 	mutex_exit(&vcache.lock);
 
 	/*
@@ -1554,7 +1555,7 @@
 	} else {
 		/*
 		 * Any other processes trying to obtain this lock must first
-		 * wait for VN_RECLAIMED, then call the new lock operation.
+		 * wait for VS_RECLAIMED, then call the new lock operation.
 		 */
 		VOP_UNLOCK(vp);
 	}
@@ -1581,11 +1582,11 @@
 	vfs_insmntque(vp, dead_rootmount);
 
 	/* Remove from vnode cache. */
-	hash = vcache_hash(&node->vn_key);
+	hash = vcache_hash(&node->vi_key);
 	mutex_enter(&vcache.lock);
-	KASSERT(node == vcache_hash_lookup(&node->vn_key, hash));
+	KASSERT(node == vcache_hash_lookup(&node->vi_key, hash));
 	SLIST_REMOVE(&vcache.hashtab[hash & vcache.hashmask],
-	    node, vcache_node, vn_hash);
+	    node, vnode_impl, vi_hash);
 	mutex_exit(&vcache.lock);
 	if (temp_key != temp_buf)
 		kmem_free(temp_key, temp_key_len);
@@ -1594,7 +1595,7 @@
 	mutex_enter(vp->v_interlock);
 	vp->v_op = dead_vnodeop_p;
 	vp->v_vflag |= VV_LOCKSWORK;
-	VSTATE_CHANGE(vp, VN_RECLAIMING, VN_RECLAIMED);
+	VSTATE_CHANGE(vp, VS_RECLAIMING, VS_RECLAIMED);
 	vp->v_tag = VT_NON;
 	KNOTE(&vp->v_klist, NOTE_REVOKE);
 
@@ -1609,13 +1610,13 @@
 {
 	int n;
 	const uint8_t *cp;
-	struct vcache_node *node;
+	vnode_impl_t *node;
 
-	node = VP_TO_VN(vp);
-	n = node->vn_key.vk_key_len;
-	cp = node->vn_key.vk_key;
+	node = VNODE_TO_VIMPL(vp);
+	n = node->vi_key.vk_key_len;
+	cp = node->vi_key.vk_key;
 
-	(*pr)("%sstate %s, key(%d)", prefix, vstate_name(node->vn_state), n);
+	(*pr)("%sstate %s, key(%d)", prefix, vstate_name(node->vi_state), n);
 
 	while (n-- > 0)
 		(*pr)(" %02x", *cp++);
@@ -1660,10 +1661,10 @@
 	if (! ISSET(flags, VDEAD_NOWAIT))
 		VSTATE_WAIT_STABLE(vp);
 
-	if (VSTATE_GET(vp) == VN_RECLAIMING) {
+	if (VSTATE_GET(vp) == VS_RECLAIMING) {
 		KASSERT(ISSET(flags, VDEAD_NOWAIT));
 		return EBUSY;
-	} else if (VSTATE_GET(vp) == VN_RECLAIMED) {
+	} else if (VSTATE_GET(vp) == VS_RECLAIMED) {
 		return ENOENT;
 	}