 @@ -1,1456 +1,1463 @@
-/*	$NetBSD: vfs_cache.c,v 1.139 2020/04/13 19:23:18 ad Exp $	*/
+/*	$NetBSD: vfs_cache.c,v 1.140 2020/04/22 21:35:52 ad Exp $	*/
 /*-
  * Copyright (c) 2008, 2019, 2020 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Andrew Doran.
+ *
  * 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.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
  */
 /*
  * Copyright (c) 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * 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.
+ *
  *	@(#)vfs_cache.c	8.3 (Berkeley) 8/22/94
  */
 /*
  * Name caching:
+ *
  *	Names found by directory scans are retained in a cache for future
  *	reference.  It is managed LRU, so frequently used names will hang
  *	around.  The cache is indexed by hash value obtained from the name.
+ *
  *	The name cache is the brainchild of Robert Elz and was introduced in
  *	4.3BSD.  See "Using gprof to Tune the 4.2BSD Kernel", Marshall Kirk
  *	McKusick, May 21 1984.
+ *
  * Data structures:
+ *
  *	Most Unix namecaches very sensibly use a global hash table to index
  *	names.  The global hash table works well, but can cause concurrency
  *	headaches for the kernel hacker.  In the NetBSD 10.0 implementation
  *	we are not sensible, and use a per-directory data structure to index
  *	names, but the cache otherwise functions the same.
+ *
  *	The index is a red-black tree.  There are no special concurrency
  *	requirements placed on it, because it's per-directory and protected
  *	by the namecache's per-directory locks.  It should therefore not be
  *	difficult to experiment with other types of index.
+ *
  *	Each cached name is stored in a struct namecache, along with a
  *	pointer to the associated vnode (nc_vp).  Names longer than a
  *	maximum length of NCHNAMLEN are allocated with kmem_alloc(); they
  *	occur infrequently, and names shorter than this are stored directly
  *	in struct namecache.  If it is a "negative" entry, (i.e. for a name
  *	that is known NOT to exist) the vnode pointer will be NULL.
+ *
  *	For a directory with 3 cached names for 3 distinct vnodes, the
  *	various vnodes and namecache structs would be connected like this
  *	(the root is at the bottom of the diagram):
+ *
  *          ...
  *           ^
  *           |- vi_nc_tree
  *           |
  *      +----o----+               +---------+               +---------+
  *      |  VDIR   |               |  VCHR   |               |  VREG   |
  *      |  vnode  o-----+         |  vnode  o-----+         |  vnode  o------+
  *      +---------+     |         +---------+     |         +---------+      |
  *           ^          |              ^          |              ^           |
  *           |- nc_vp   |- vi_nc_list  |- nc_vp   |- vi_nc_list  |- nc_vp    |
  *           |          |              |          |              |           |
  *      +----o----+     |         +----o----+     |         +----o----+      |
  *  +---onamecache|<----+     +---onamecache|<----+     +---onamecache|<-----+
  *  |   +---------+           |   +---------+           |   +---------+
  *  |        ^                |        ^                |        ^
  *  |        |                |        |                |        |
  *  |        |  +----------------------+                |        |
  *  |-nc_dvp | +-------------------------------------------------+
  *  |        |/- vi_nc_tree   |                         |
  *  |        |                |- nc_dvp                 |- nc_dvp
  *  |   +----o----+           |                         |
  *  +-->|  VDIR   |<----------+                         |
  *      |  vnode  |<------------------------------------+
  *      +---------+
+ *
  *      START HERE
+ *
  * Replacement:
+ *
  *	As the cache becomes full, old and unused entries are purged as new
  *	entries are added.  The synchronization overhead in maintaining a
  *	strict ordering would be prohibitive, so the VM system's "clock" or
  *	"second chance" page replacement algorithm is aped here.  New
  *	entries go to the tail of the active list.  After they age out and
  *	reach the head of the list, they are moved to the tail of the
  *	inactive list.  Any use of the deactivated cache entry reactivates
  *	it, saving it from impending doom; if not reactivated, the entry
  *	eventually reaches the head of the inactive list and is purged.
+ *
  * Concurrency:
+ *
  *	From a performance perspective, cache_lookup(nameiop == LOOKUP) is
  *	what really matters; insertion of new entries with cache_enter() is
  *	comparatively infrequent, and overshadowed by the cost of expensive
  *	file system metadata operations (which may involve disk I/O).  We
  *	therefore want to make everything simplest in the lookup path.
+ *
  *	struct namecache is mostly stable except for list and tree related
  *	entries, changes to which don't affect the cached name or vnode.
  *	For changes to name+vnode, entries are purged in preference to
  *	modifying them.
+ *
  *	Read access to namecache entries is made via tree, list, or LRU
  *	list.  A lock corresponding to the direction of access should be
  *	held.  See definition of "struct namecache" in src/sys/namei.src,
  *	and the definition of "struct vnode" for the particulars.
+ *
  *	Per-CPU statistics, and LRU list totals are read unlocked, since
  *	an approximate value is OK.  We maintain 32-bit sized per-CPU
  *	counters and 64-bit global counters under the theory that 32-bit
  *	sized counters are less likely to be hosed by nonatomic increment
  *	(on 32-bit platforms).
+ *
  *	The lock order is:
+ *
  *	1) vi->vi_nc_lock	(tree or parent -> child direction,
  *				 used during forward lookup)
+ *
  *	2) vi->vi_nc_listlock	(list or child -> parent direction,
  *				 used during reverse lookup)
+ *
  *	3) cache_lru_lock	(LRU list direction, used during reclaim)
+ *
  *	4) vp->v_interlock	(what the cache entry points to)
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_cache.c,v 1.139 2020/04/13 19:23:18 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_cache.c,v 1.140 2020/04/22 21:35:52 ad Exp $");
 #define __NAMECACHE_PRIVATE
 #ifdef _KERNEL_OPT
 #include "opt_ddb.h"
 #include "opt_dtrace.h"
 #endif
 #include <sys/types.h>
 #include <sys/atomic.h>
 #include <sys/callout.h>
 #include <sys/cpu.h>
 #include <sys/errno.h>
 #include <sys/evcnt.h>
 #include <sys/hash.h>
 #include <sys/kernel.h>
 #include <sys/mount.h>
 #include <sys/mutex.h>
 #include <sys/namei.h>
 #include <sys/param.h>
 #include <sys/pool.h>
 #include <sys/sdt.h>
 #include <sys/sysctl.h>
 #include <sys/systm.h>
 #include <sys/time.h>
 #include <sys/vnode_impl.h>
 #include <miscfs/genfs/genfs.h>
 static void	cache_activate(struct namecache *);
 static void	cache_update_stats(void *);
 static int	cache_compare_nodes(void *, const void *, const void *);
 static void	cache_deactivate(void);
 static void	cache_reclaim(void);
 static int	cache_stat_sysctl(SYSCTLFN_ARGS);
 /*
  * Global pool cache.
  */
 static pool_cache_t cache_pool __read_mostly;
 /*
  * LRU replacement.
  */
 enum cache_lru_id {
 	LRU_ACTIVE,
 	LRU_INACTIVE,
 	LRU_COUNT
 };
 static struct {
 	TAILQ_HEAD(, namecache)	list[LRU_COUNT];
 	u_int			count[LRU_COUNT];
 } cache_lru __cacheline_aligned;
 static kmutex_t cache_lru_lock __cacheline_aligned;
 /*
  * Cache effectiveness statistics.  nchstats holds system-wide total.
  */
 struct nchstats	nchstats;
 struct nchstats_percpu _NAMEI_CACHE_STATS(uint32_t);
 struct nchcpu {
 	struct nchstats_percpu cur;
 	struct nchstats_percpu last;
 };
 static callout_t cache_stat_callout;
 static kmutex_t cache_stat_lock __cacheline_aligned;
 #define	COUNT(f) do { \
 	lwp_t *l = curlwp; \
 	KPREEMPT_DISABLE(l); \
 	((struct nchstats_percpu *)curcpu()->ci_data.cpu_nch)->f++; \
 	KPREEMPT_ENABLE(l); \
 } while (/* CONSTCOND */ 0);
 #define	UPDATE(nchcpu, f) do { \
 	uint32_t cur = atomic_load_relaxed(&nchcpu->cur.f); \
 	nchstats.f += (uint32_t)(cur - nchcpu->last.f); \
 	nchcpu->last.f = cur; \
 } while (/* CONSTCOND */ 0)
 /*
  * Tunables.  cache_maxlen replaces the historical doingcache:
  * set it zero to disable caching for debugging purposes.
  */
 int cache_lru_maxdeact __read_mostly = 2;	/* max # to deactivate */
 int cache_lru_maxscan __read_mostly = 64;	/* max # to scan/reclaim */
 int cache_maxlen __read_mostly = USHRT_MAX;	/* max name length to cache */
 int cache_stat_interval __read_mostly = 300;	/* in seconds */
 /*
  * sysctl stuff.
  */
 static struct	sysctllog *cache_sysctllog;
 /*
  * Red-black tree stuff.
  */
 static const rb_tree_ops_t cache_rbtree_ops = {
 	.rbto_compare_nodes = cache_compare_nodes,
 	.rbto_compare_key = cache_compare_nodes,
 	.rbto_node_offset = offsetof(struct namecache, nc_tree),
 	.rbto_context = NULL
 };
 /*
  * dtrace probes.
  */
 SDT_PROVIDER_DEFINE(vfs);
 SDT_PROBE_DEFINE1(vfs, namecache, invalidate, done, "struct vnode *");
 SDT_PROBE_DEFINE1(vfs, namecache, purge, parents, "struct vnode *");
 SDT_PROBE_DEFINE1(vfs, namecache, purge, children, "struct vnode *");
 SDT_PROBE_DEFINE2(vfs, namecache, purge, name, "char *", "size_t");
 SDT_PROBE_DEFINE1(vfs, namecache, purge, vfs, "struct mount *");
 SDT_PROBE_DEFINE3(vfs, namecache, lookup, hit, "struct vnode *",
     "char *", "size_t");
 SDT_PROBE_DEFINE3(vfs, namecache, lookup, miss, "struct vnode *",
     "char *", "size_t");
 SDT_PROBE_DEFINE3(vfs, namecache, lookup, toolong, "struct vnode *",
     "char *", "size_t");
 SDT_PROBE_DEFINE2(vfs, namecache, revlookup, success, "struct vnode *",
      "struct vnode *");
 SDT_PROBE_DEFINE2(vfs, namecache, revlookup, fail, "struct vnode *",
      "int");
 SDT_PROBE_DEFINE2(vfs, namecache, prune, done, "int", "int");
 SDT_PROBE_DEFINE3(vfs, namecache, enter, toolong, "struct vnode *",
     "char *", "size_t");
 SDT_PROBE_DEFINE3(vfs, namecache, enter, done, "struct vnode *",
     "char *", "size_t");
 /*
  * rbtree: compare two nodes.
  */
 static int
 cache_compare_nodes(void *context, const void *n1, const void *n2)
+{
 	const struct namecache *nc1 = n1;
 	const struct namecache *nc2 = n2;
 	if (nc1->nc_key < nc2->nc_key) {
 		return -1;
+	}
 	if (nc1->nc_key > nc2->nc_key) {
 		return 1;
+	}
 	KASSERT(nc1->nc_nlen == nc2->nc_nlen);
 	return memcmp(nc1->nc_name, nc2->nc_name, nc1->nc_nlen);
+}
 /*
  * Compute a key value for the given name.  The name length is encoded in
  * the key value to try and improve uniqueness, and so that length doesn't
  * need to be compared separately for string comparisons.
  */
 static inline uint64_t
 cache_key(const char *name, size_t nlen)
+{
 	uint64_t key;
 	KASSERT(nlen <= USHRT_MAX);
 	key = hash32_buf(name, nlen, HASH32_STR_INIT);
 	return (key << 32) | nlen;
+}
 /*
  * Remove an entry from the cache.  vi_nc_lock must be held, and if dir2node
  * is true, then we're locking in the conventional direction and the list
  * lock will be acquired when removing the entry from the vnode list.
  */
 static void
 cache_remove(struct namecache *ncp, const bool dir2node)
+{
 	struct vnode *vp, *dvp = ncp->nc_dvp;
 	vnode_impl_t *dvi = VNODE_TO_VIMPL(dvp);
 	KASSERT(rw_write_held(&dvi->vi_nc_lock));
 	KASSERT(cache_key(ncp->nc_name, ncp->nc_nlen) == ncp->nc_key);
 	KASSERT(rb_tree_find_node(&dvi->vi_nc_tree, ncp) == ncp);
 	SDT_PROBE(vfs, namecache, invalidate, done, ncp,
 , 0, 0, 0);
 	/*
 	 * Remove from the vnode's list.  This excludes cache_revlookup(),
 	 * and then it's safe to remove from the LRU lists.
 	 */
 	if ((vp = ncp->nc_vp) != NULL) {
 		vnode_impl_t *vi = VNODE_TO_VIMPL(vp);
 		if (__predict_true(dir2node)) {
 			rw_enter(&vi->vi_nc_listlock, RW_WRITER);
 			TAILQ_REMOVE(&vi->vi_nc_list, ncp, nc_list);
 			rw_exit(&vi->vi_nc_listlock);
 		} else {
 			TAILQ_REMOVE(&vi->vi_nc_list, ncp, nc_list);
+		}
+	}
 	/* Remove from the directory's rbtree. */
 	rb_tree_remove_node(&dvi->vi_nc_tree, ncp);
 	/* Remove from the LRU lists. */
 	mutex_enter(&cache_lru_lock);
 	TAILQ_REMOVE(&cache_lru.list[ncp->nc_lrulist], ncp, nc_lru);
 	cache_lru.count[ncp->nc_lrulist]--;
 	mutex_exit(&cache_lru_lock);
 	/* Finally, free it. */
 	if (ncp->nc_nlen > NCHNAMLEN) {
 		size_t sz = offsetof(struct namecache, nc_name[ncp->nc_nlen]);
 		kmem_free(ncp, sz);
 	} else {
 		pool_cache_put(cache_pool, ncp);
+	}
+}
 /*
  * Find a single cache entry and return it.  vi_nc_lock must be held.
  */
 static struct namecache * __noinline
 cache_lookup_entry(struct vnode *dvp, const char *name, size_t namelen,
     uint64_t key)
+{
 	vnode_impl_t *dvi = VNODE_TO_VIMPL(dvp);
 	struct rb_node *node = dvi->vi_nc_tree.rbt_root;
 	struct namecache *ncp;
 	int lrulist, diff;
 	KASSERT(rw_lock_held(&dvi->vi_nc_lock));
 	/*
 	 * Search the RB tree for the key.  This is an inlined lookup
 	 * tailored for exactly what's needed here (64-bit key and so on)
 	 * that is quite a bit faster than using rb_tree_find_node().
+	 *
 	 * For a matching key memcmp() needs to be called once to confirm
 	 * that the correct name has been found.  Very rarely there will be
 	 * a key value collision and the search will continue.
 	 */
 	for (;;) {
 		if (__predict_false(RB_SENTINEL_P(node))) {
 			return NULL;
+		}
 		ncp = (struct namecache *)node;
 		KASSERT((void *)&ncp->nc_tree == (void *)ncp);
 		KASSERT(ncp->nc_dvp == dvp);
 		if (ncp->nc_key == key) {
 			KASSERT(ncp->nc_nlen == namelen);
 			diff = memcmp(ncp->nc_name, name, namelen);
 			if (__predict_true(diff == 0)) {
 				break;
+			}
 			node = node->rb_nodes[diff < 0];
 		} else {
 			node = node->rb_nodes[ncp->nc_key < key];
+		}
+	}
 	/*
 	 * If the entry is on the wrong LRU list, requeue it.  This is an
 	 * unlocked check, but it will rarely be wrong and even then there
 	 * will be no harm caused.
 	 */
 	lrulist = atomic_load_relaxed(&ncp->nc_lrulist);
 	if (__predict_false(lrulist != LRU_ACTIVE)) {
 		cache_activate(ncp);
+	}
 	return ncp;
+}
 /*
  * Look for a the name in the cache. We don't do this
  * if the segment name is long, simply so the cache can avoid
  * holding long names (which would either waste space, or
  * add greatly to the complexity).
+ *
  * Lookup is called with DVP pointing to the directory to search,
  * and CNP providing the name of the entry being sought: cn_nameptr
  * is the name, cn_namelen is its length, and cn_flags is the flags
  * word from the namei operation.
+ *
  * DVP must be locked.
+ *
  * There are three possible non-error return states:
  *    1. Nothing was found in the cache. Nothing is known about
  *       the requested name.
  *    2. A negative entry was found in the cache, meaning that the
  *       requested name definitely does not exist.
  *    3. A positive entry was found in the cache, meaning that the
  *       requested name does exist and that we are providing the
  *       vnode.
  * In these cases the results are:
  *    1. 0 returned; VN is set to NULL.
  *    2. 1 returned; VN is set to NULL.
  *    3. 1 returned; VN is set to the vnode found.
+ *
  * The additional result argument ISWHT is set to zero, unless a
  * negative entry is found that was entered as a whiteout, in which
  * case ISWHT is set to one.
+ *
  * The ISWHT_RET argument pointer may be null. In this case an
  * assertion is made that the whiteout flag is not set. File systems
  * that do not support whiteouts can/should do this.
+ *
  * Filesystems that do support whiteouts should add ISWHITEOUT to
  * cnp->cn_flags if ISWHT comes back nonzero.
+ *
  * When a vnode is returned, it is locked, as per the vnode lookup
  * locking protocol.
+ *
  * There is no way for this function to fail, in the sense of
  * generating an error that requires aborting the namei operation.
+ *
  * (Prior to October 2012, this function returned an integer status,
  * and a vnode, and mucked with the flags word in CNP for whiteouts.
  * The integer status was -1 for "nothing found", ENOENT for "a
  * negative entry found", 0 for "a positive entry found", and possibly
  * other errors, and the value of VN might or might not have been set
  * depending on what error occurred.)
  */
 bool
 cache_lookup(struct vnode *dvp, const char *name, size_t namelen,
 	     uint32_t nameiop, uint32_t cnflags,
 	     int *iswht_ret, struct vnode **vn_ret)
+{
 	vnode_impl_t *dvi = VNODE_TO_VIMPL(dvp);
 	struct namecache *ncp;
 	struct vnode *vp;
 	uint64_t key;
 	int error;
 	bool hit;
 	krw_t op;
 	/* Establish default result values */
 	if (iswht_ret != NULL) {
 		*iswht_ret = 0;
+	}
 	*vn_ret = NULL;
 	if (__predict_false(namelen > cache_maxlen)) {
 		SDT_PROBE(vfs, namecache, lookup, toolong, dvp,
 		    name, namelen, 0, 0);
 		COUNT(ncs_long);
 		return false;
+	}
 	/* Compute the key up front - don't need the lock. */
 	key = cache_key(name, namelen);
 	/* Could the entry be purged below? */
 	if ((cnflags & ISLASTCN) != 0 &&
 	    ((cnflags & MAKEENTRY) == 0 || nameiop == CREATE)) {
 	    	op = RW_WRITER;
 	} else {
 		op = RW_READER;
+	}
 	/* Now look for the name. */
 	rw_enter(&dvi->vi_nc_lock, op);
 	ncp = cache_lookup_entry(dvp, name, namelen, key);
 	if (__predict_false(ncp == NULL)) {
 		rw_exit(&dvi->vi_nc_lock);
 		COUNT(ncs_miss);
 		SDT_PROBE(vfs, namecache, lookup, miss, dvp,
 		    name, namelen, 0, 0);
 		return false;
+	}
 	if (__predict_false((cnflags & MAKEENTRY) == 0)) {
 		/*
 		 * Last component and we are renaming or deleting,
 		 * the cache entry is invalid, or otherwise don't
 		 * want cache entry to exist.
 		 */
 		KASSERT((cnflags & ISLASTCN) != 0);
 		cache_remove(ncp, true);
 		rw_exit(&dvi->vi_nc_lock);
 		COUNT(ncs_badhits);
 		return false;
+	}
 	if (ncp->nc_vp == NULL) {
 		if (iswht_ret != NULL) {
 			/*
 			 * Restore the ISWHITEOUT flag saved earlier.
 			 */
 			*iswht_ret = ncp->nc_whiteout;
 		} else {
 			KASSERT(!ncp->nc_whiteout);
+		}
 		if (nameiop == CREATE && (cnflags & ISLASTCN) != 0) {
 			/*
 			 * Last component and we are preparing to create
 			 * the named object, so flush the negative cache
 			 * entry.
 			 */
 			COUNT(ncs_badhits);
 			cache_remove(ncp, true);
 			hit = false;
 		} else {
 			COUNT(ncs_neghits);
 			SDT_PROBE(vfs, namecache, lookup, hit, dvp, name,
 			    namelen, 0, 0);
 			/* found neg entry; vn is already null from above */
 			hit = true;
+		}
 		rw_exit(&dvi->vi_nc_lock);
 		return hit;
+	}
 	vp = ncp->nc_vp;
 	mutex_enter(vp->v_interlock);
 	rw_exit(&dvi->vi_nc_lock);
 	/*
 	 * Unlocked except for the vnode interlock.  Call vcache_tryvget().
 	 */
 	error = vcache_tryvget(vp);
 	if (error) {
 		KASSERT(error == EBUSY);
 		/*
 		 * This vnode is being cleaned out.
 		 * XXX badhits?
 		 */
 		COUNT(ncs_falsehits);
 		return false;
+	}
 	COUNT(ncs_goodhits);
 	SDT_PROBE(vfs, namecache, lookup, hit, dvp, name, namelen, 0, 0);
 	/* found it */
 	*vn_ret = vp;
 	return true;
+}
 /*
  * Version of the above without the nameiop argument, for NFS.
  */
 bool
 cache_lookup_raw(struct vnode *dvp, const char *name, size_t namelen,
 		 uint32_t cnflags,
 		 int *iswht_ret, struct vnode **vn_ret)
+{
 	return cache_lookup(dvp, name, namelen, LOOKUP, cnflags | MAKEENTRY,
 	    iswht_ret, vn_ret);
+}
 /*
  * Used by namei() to walk down a path, component by component by looking up
  * names in the cache.  The node locks are chained along the way: a parent's
  * lock is not dropped until the child's is acquired.
  */
 bool
 cache_lookup_linked(struct vnode *dvp, const char *name, size_t namelen,
 		    struct vnode **vn_ret, krwlock_t **plock,
 		    kauth_cred_t cred)
+{
 	vnode_impl_t *dvi = VNODE_TO_VIMPL(dvp);
 	struct namecache *ncp;
 	uint64_t key;
 	int error;
 	/* Establish default results. */
 	*vn_ret = NULL;
 	/* If disabled, or file system doesn't support this, bail out. */
 	if (__predict_false((dvp->v_mount->mnt_iflag & IMNT_NCLOOKUP) == 0)) {
 		return false;
+	}
 	if (__predict_false(namelen > cache_maxlen)) {
 		COUNT(ncs_long);
 		return false;
+	}
 	/* Compute the key up front - don't need the lock. */
 	key = cache_key(name, namelen);
 	/*
 	 * Acquire the directory lock.  Once we have that, we can drop the
 	 * previous one (if any).
+	 *
 	 * The two lock holds mean that the directory can't go away while
 	 * here: the directory must be purged with cache_purge() before
 	 * being freed, and both parent & child's vi_nc_lock must be taken
 	 * before that point is passed.
+	 *
 	 * However if there's no previous lock, like at the root of the
 	 * chain, then "dvp" must be referenced to prevent dvp going away
 	 * before we get its lock.
+	 *
 	 * Note that the two locks can be the same if looking up a dot, for
-	 * example: /usr/bin/.
+	 * example: /usr/bin/.  If looking up the parent (..) we can't wait
 	 * on the lock as child -> parent is the wrong direction.
 	 */
 	if (*plock != &dvi->vi_nc_lock) {
-		rw_enter(&dvi->vi_nc_lock, RW_READER);
+		if (namelen == 2 && name[0] == '.' && name[1] == '.') {
 			if (!rw_tryenter(&dvi->vi_nc_lock, RW_READER)) {
 				return false;
+			}
 		} else {
 			rw_enter(&dvi->vi_nc_lock, RW_READER);
+		}
 		if (*plock != NULL) {
 			rw_exit(*plock);
+		}
 		*plock = &dvi->vi_nc_lock;
 	} else if (*plock == NULL) {
 		KASSERT(vrefcnt(dvp) > 0);
+	}
 	/*
 	 * First up check if the user is allowed to look up files in this
 	 * directory.
 	 */
 	KASSERT(dvi->vi_nc_mode != VNOVAL && dvi->vi_nc_uid != VNOVAL &&
 	    dvi->vi_nc_gid != VNOVAL);
 	error = kauth_authorize_vnode(cred, KAUTH_ACCESS_ACTION(VEXEC,
 	    dvp->v_type, dvi->vi_nc_mode & ALLPERMS), dvp, NULL,
 	    genfs_can_access(dvp->v_type, dvi->vi_nc_mode & ALLPERMS,
 	    dvi->vi_nc_uid, dvi->vi_nc_gid, VEXEC, cred));
 	if (error != 0) {
 		COUNT(ncs_denied);
 		return false;
+	}
 	/*
 	 * Now look for a matching cache entry.
 	 */
 	ncp = cache_lookup_entry(dvp, name, namelen, key);
 	if (__predict_false(ncp == NULL)) {
 		COUNT(ncs_miss);
 		SDT_PROBE(vfs, namecache, lookup, miss, dvp,
 		    name, namelen, 0, 0);
 		return false;
+	}
 	if (ncp->nc_vp == NULL) {
 		/* found negative entry; vn is already null from above */
 		COUNT(ncs_neghits);
 		SDT_PROBE(vfs, namecache, lookup, hit, dvp, name, namelen, 0, 0);
 		return true;
+	}
 	COUNT(ncs_goodhits); /* XXX can be "badhits" */
 	SDT_PROBE(vfs, namecache, lookup, hit, dvp, name, namelen, 0, 0);
 	/*
 	 * Return with the directory lock still held.  It will either be
 	 * returned to us with another call to cache_lookup_linked() when
 	 * looking up the next component, or the caller will release it
 	 * manually when finished.
 	 */
 	*vn_ret = ncp->nc_vp;
 	return true;
+}
 /*
  * Scan cache looking for name of directory entry pointing at vp.
  * Will not search for "." or "..".
+ *
  * If the lookup succeeds the vnode is referenced and stored in dvpp.
+ *
  * If bufp is non-NULL, also place the name in the buffer which starts
  * at bufp, immediately before *bpp, and move bpp backwards to point
  * at the start of it.  (Yes, this is a little baroque, but it's done
  * this way to cater to the whims of getcwd).
+ *
  * Returns 0 on success, -1 on cache miss, positive errno on failure.
  */
 int
 cache_revlookup(struct vnode *vp, struct vnode **dvpp, char **bpp, char *bufp,
     bool checkaccess, int perms)
+{
 	vnode_impl_t *vi = VNODE_TO_VIMPL(vp);
 	struct namecache *ncp;
 	struct vnode *dvp;
 	int error, nlen, lrulist;
 	char *bp;
 	KASSERT(vp != NULL);
 	if (cache_maxlen == 0)
 		goto out;
 	rw_enter(&vi->vi_nc_listlock, RW_READER);
 	if (checkaccess) {
 		/*
 		 * Check if the user is allowed to see.  NOTE: this is
 		 * checking for access on the "wrong" directory.  getcwd()
 		 * wants to see that there is access on every component
 		 * along the way, not that there is access to any individual
 		 * component.  Don't use this to check you can look in vp.
+		 *
 		 * I don't like it, I didn't come up with it, don't blame me!
 		 */
 		KASSERT(vi->vi_nc_mode != VNOVAL && vi->vi_nc_uid != VNOVAL &&
 		    vi->vi_nc_gid != VNOVAL);
 		error = kauth_authorize_vnode(curlwp->l_cred,
 		    KAUTH_ACCESS_ACTION(VEXEC, vp->v_type, vi->vi_nc_mode &
 		    ALLPERMS), vp, NULL, genfs_can_access(vp->v_type,
 		    vi->vi_nc_mode & ALLPERMS, vi->vi_nc_uid, vi->vi_nc_gid,
 		    perms, curlwp->l_cred));
 		    if (error != 0) {
 		    	rw_exit(&vi->vi_nc_listlock);
 			COUNT(ncs_denied);
 			return EACCES;
+		}
+	}
 	TAILQ_FOREACH(ncp, &vi->vi_nc_list, nc_list) {
 		KASSERT(ncp->nc_vp == vp);
 		KASSERT(ncp->nc_dvp != NULL);
 		nlen = ncp->nc_nlen;
 		/*
 		 * The queue is partially sorted.  Once we hit dots, nothing
 		 * else remains but dots and dotdots, so bail out.
 		 */
 		if (ncp->nc_name[0] == '.') {
 			if (nlen == 1 ||
 			    (nlen == 2 && ncp->nc_name[1] == '.')) {
 			    	break;
+			}
+		}
 		/*
 		 * Record a hit on the entry.  This is an unlocked read but
 		 * even if wrong it doesn't matter too much.
 		 */
 		lrulist = atomic_load_relaxed(&ncp->nc_lrulist);
 		if (lrulist != LRU_ACTIVE) {
 			cache_activate(ncp);
+		}
 		if (bufp) {
 			bp = *bpp;
 			bp -= nlen;
 			if (bp <= bufp) {
 				*dvpp = NULL;
 				rw_exit(&vi->vi_nc_listlock);
 				SDT_PROBE(vfs, namecache, revlookup,
 				    fail, vp, ERANGE, 0, 0, 0);
 				return (ERANGE);
+			}
 			memcpy(bp, ncp->nc_name, nlen);
 			*bpp = bp;
+		}
 		dvp = ncp->nc_dvp;
 		mutex_enter(dvp->v_interlock);
 		rw_exit(&vi->vi_nc_listlock);
 		error = vcache_tryvget(dvp);
 		if (error) {
 			KASSERT(error == EBUSY);
 			if (bufp)
 				(*bpp) += nlen;
 			*dvpp = NULL;
 			SDT_PROBE(vfs, namecache, revlookup, fail, vp,
 			    error, 0, 0, 0);
 			return -1;
+		}
 		*dvpp = dvp;
 		SDT_PROBE(vfs, namecache, revlookup, success, vp, dvp,
 , 0, 0);
 		COUNT(ncs_revhits);
 		return (0);
+	}
 	rw_exit(&vi->vi_nc_listlock);
 	COUNT(ncs_revmiss);
  out:
 	*dvpp = NULL;
 	return (-1);
+}
 /*
  * Add an entry to the cache.
  */
 void
 cache_enter(struct vnode *dvp, struct vnode *vp,
 	    const char *name, size_t namelen, uint32_t cnflags)
+{
 	vnode_impl_t *dvi = VNODE_TO_VIMPL(dvp);
 	struct namecache *ncp, *oncp;
 	int total;
 	/* First, check whether we can/should add a cache entry. */
 	if ((cnflags & MAKEENTRY) == 0 ||
 	    __predict_false(namelen > cache_maxlen)) {
 		SDT_PROBE(vfs, namecache, enter, toolong, vp, name, namelen,
 , 0);
 		return;
+	}
 	SDT_PROBE(vfs, namecache, enter, done, vp, name, namelen, 0, 0);
 	/*
 	 * Reclaim some entries if over budget.  This is an unlocked check,
 	 * but it doesn't matter.  Just need to catch up with things
 	 * eventually: it doesn't matter if we go over temporarily.
 	 */
 	total = atomic_load_relaxed(&cache_lru.count[LRU_ACTIVE]);
 	total += atomic_load_relaxed(&cache_lru.count[LRU_INACTIVE]);
 	if (__predict_false(total > desiredvnodes)) {
 		cache_reclaim();
+	}
 	/* Now allocate a fresh entry. */
 	if (__predict_true(namelen <= NCHNAMLEN)) {
 		ncp = pool_cache_get(cache_pool, PR_WAITOK);
 	} else {
 		size_t sz = offsetof(struct namecache, nc_name[namelen]);
 		ncp = kmem_alloc(sz, KM_SLEEP);
+	}
 	/*
 	 * Fill in cache info.  For negative hits, save the ISWHITEOUT flag
 	 * so we can restore it later when the cache entry is used again.
 	 */
 	ncp->nc_vp = vp;
 	ncp->nc_dvp = dvp;
 	ncp->nc_key = cache_key(name, namelen);
 	ncp->nc_nlen = namelen;
 	ncp->nc_whiteout = ((cnflags & ISWHITEOUT) != 0);
 	memcpy(ncp->nc_name, name, namelen);
 	/*
 	 * Insert to the directory.  Concurrent lookups may race for a cache
 	 * entry.  If there's a entry there already, purge it.
 	 */
 	rw_enter(&dvi->vi_nc_lock, RW_WRITER);
 	oncp = rb_tree_insert_node(&dvi->vi_nc_tree, ncp);
 	if (oncp != ncp) {
 		KASSERT(oncp->nc_key == ncp->nc_key);
 		KASSERT(oncp->nc_nlen == ncp->nc_nlen);
 		KASSERT(memcmp(oncp->nc_name, name, namelen) == 0);
 		cache_remove(oncp, true);
 		oncp = rb_tree_insert_node(&dvi->vi_nc_tree, ncp);
 		KASSERT(oncp == ncp);
+	}
 	/*
 	 * With the directory lock still held, insert to the tail of the
 	 * ACTIVE LRU list (new) and take the opportunity to incrementally
 	 * balance the lists.
 	 */
 	mutex_enter(&cache_lru_lock);
 	ncp->nc_lrulist = LRU_ACTIVE;
 	cache_lru.count[LRU_ACTIVE]++;
 	TAILQ_INSERT_TAIL(&cache_lru.list[LRU_ACTIVE], ncp, nc_lru);
 	cache_deactivate();
 	mutex_exit(&cache_lru_lock);
 	/*
 	 * Finally, insert to the vnode and unlock.  With everything set up
 	 * it's safe to let cache_revlookup() see the entry.  Partially sort
 	 * the per-vnode list: dots go to back so cache_revlookup() doesn't
 	 * have to consider them.
 	 */
 	if (vp != NULL) {
 		vnode_impl_t *vi = VNODE_TO_VIMPL(vp);
 		rw_enter(&vi->vi_nc_listlock, RW_WRITER);
 		if ((namelen == 1 && name[0] == '.') ||
 		    (namelen == 2 && name[0] == '.' && name[1] == '.')) {
 			TAILQ_INSERT_TAIL(&vi->vi_nc_list, ncp, nc_list);
 		} else {
 			TAILQ_INSERT_HEAD(&vi->vi_nc_list, ncp, nc_list);
+		}
 		rw_exit(&vi->vi_nc_listlock);
+	}
 	rw_exit(&dvi->vi_nc_lock);
+}
 /*
  * Set identity info in cache for a vnode.  We only care about directories
  * so ignore other updates.
  */
 void
 cache_enter_id(struct vnode *vp, mode_t mode, uid_t uid, gid_t gid)
+{
 	vnode_impl_t *vi = VNODE_TO_VIMPL(vp);
 	if (vp->v_type == VDIR) {
 		/* Grab both locks, for forward & reverse lookup. */
 		rw_enter(&vi->vi_nc_lock, RW_WRITER);
 		rw_enter(&vi->vi_nc_listlock, RW_WRITER);
 		vi->vi_nc_mode = mode;
 		vi->vi_nc_uid = uid;
 		vi->vi_nc_gid = gid;
 		rw_exit(&vi->vi_nc_listlock);
 		rw_exit(&vi->vi_nc_lock);
+	}
+}
 /*
  * Return true if we have identity for the given vnode, and use as an
  * opportunity to confirm that everything squares up.
+ *
  * Because of shared code, some file systems could provide partial
  * information, missing some updates, so always check the mount flag
  * instead of looking for !VNOVAL.
  */
 bool
 cache_have_id(struct vnode *vp)
+{
 	if (vp->v_type == VDIR &&
 	    (vp->v_mount->mnt_iflag & IMNT_NCLOOKUP) != 0) {
 		KASSERT(VNODE_TO_VIMPL(vp)->vi_nc_mode != VNOVAL);
 		KASSERT(VNODE_TO_VIMPL(vp)->vi_nc_uid != VNOVAL);
 		KASSERT(VNODE_TO_VIMPL(vp)->vi_nc_gid != VNOVAL);
 		return true;
 	} else {
 		return false;
+	}
+}
 /*
  * Name cache initialization, from vfs_init() when the system is booting.
  */
 void
 nchinit(void)
+{
 	cache_pool = pool_cache_init(sizeof(struct namecache),
 	    coherency_unit, 0, 0, "namecache", NULL, IPL_NONE, NULL,
 	    NULL, NULL);
 	KASSERT(cache_pool != NULL);
 	mutex_init(&cache_lru_lock, MUTEX_DEFAULT, IPL_NONE);
 	TAILQ_INIT(&cache_lru.list[LRU_ACTIVE]);
 	TAILQ_INIT(&cache_lru.list[LRU_INACTIVE]);
 	mutex_init(&cache_stat_lock, MUTEX_DEFAULT, IPL_NONE);
 	callout_init(&cache_stat_callout, CALLOUT_MPSAFE);
 	callout_setfunc(&cache_stat_callout, cache_update_stats, NULL);
 	callout_schedule(&cache_stat_callout, cache_stat_interval * hz);
 	KASSERT(cache_sysctllog == NULL);
 	sysctl_createv(&cache_sysctllog, 0, NULL, NULL,
 		       CTLFLAG_PERMANENT,
 		       CTLTYPE_STRUCT, "namecache_stats",
 		       SYSCTL_DESCR("namecache statistics"),
 		       cache_stat_sysctl, 0, NULL, 0,
 		       CTL_VFS, CTL_CREATE, CTL_EOL);
+}
 /*
  * Called once for each CPU in the system as attached.
  */
 void
 cache_cpu_init(struct cpu_info *ci)
+{
 	void *p;
 	size_t sz;
 	sz = roundup2(sizeof(struct nchstats_percpu), coherency_unit) +
 	    coherency_unit;
 	p = kmem_zalloc(sz, KM_SLEEP);
 	ci->ci_data.cpu_nch = (void *)roundup2((uintptr_t)p, coherency_unit);
+}
 /*
  * A vnode is being allocated: set up cache structures.
  */
 void
 cache_vnode_init(struct vnode *vp)
+{
 	vnode_impl_t *vi = VNODE_TO_VIMPL(vp);
 	rw_init(&vi->vi_nc_lock);
 	rw_init(&vi->vi_nc_listlock);
 	rb_tree_init(&vi->vi_nc_tree, &cache_rbtree_ops);
 	TAILQ_INIT(&vi->vi_nc_list);
 	vi->vi_nc_mode = VNOVAL;
 	vi->vi_nc_uid = VNOVAL;
 	vi->vi_nc_gid = VNOVAL;
+}
 /*
  * A vnode is being freed: finish cache structures.
  */
 void
 cache_vnode_fini(struct vnode *vp)
+{
 	vnode_impl_t *vi = VNODE_TO_VIMPL(vp);
 	KASSERT(RB_TREE_MIN(&vi->vi_nc_tree) == NULL);
 	KASSERT(TAILQ_EMPTY(&vi->vi_nc_list));
 	rw_destroy(&vi->vi_nc_lock);
 	rw_destroy(&vi->vi_nc_listlock);
+}
 /*
  * Helper for cache_purge1(): purge cache entries for the given vnode from
  * all directories that the vnode is cached in.
  */
 static void
 cache_purge_parents(struct vnode *vp)
+{
 	vnode_impl_t *dvi, *vi = VNODE_TO_VIMPL(vp);
 	struct vnode *dvp, *blocked;
 	struct namecache *ncp;
 	SDT_PROBE(vfs, namecache, purge, parents, vp, 0, 0, 0, 0);
 	blocked = NULL;
 	rw_enter(&vi->vi_nc_listlock, RW_WRITER);
 	while ((ncp = TAILQ_FIRST(&vi->vi_nc_list)) != NULL) {
 		/*
 		 * Locking in the wrong direction.  Try for a hold on the
 		 * directory node's lock, and if we get it then all good,
 		 * nuke the entry and move on to the next.
 		 */
 		dvp = ncp->nc_dvp;
 		dvi = VNODE_TO_VIMPL(dvp);
 		if (rw_tryenter(&dvi->vi_nc_lock, RW_WRITER)) {
 			cache_remove(ncp, false);
 			rw_exit(&dvi->vi_nc_lock);
 			blocked = NULL;
 			continue;
+		}
 		/*
 		 * We can't wait on the directory node's lock with our list
 		 * lock held or the system could deadlock.
+		 *
 		 * Take a hold on the directory vnode to prevent it from
 		 * being freed (taking the vnode & lock with it).  Then
 		 * wait for the lock to become available with no other locks
 		 * held, and retry.
+		 *
 		 * If this happens twice in a row, give the other side a
 		 * breather; we can do nothing until it lets go.
 		 */
 		vhold(dvp);
 		rw_exit(&vi->vi_nc_listlock);
 		rw_enter(&dvi->vi_nc_lock, RW_WRITER);
 		/* Do nothing. */
 		rw_exit(&dvi->vi_nc_lock);
 		holdrele(dvp);
 		if (blocked == dvp) {
 			kpause("ncpurge", false, 1, NULL);
+		}
 		rw_enter(&vi->vi_nc_listlock, RW_WRITER);
 		blocked = dvp;
+	}
 	rw_exit(&vi->vi_nc_listlock);
+}
 /*
  * Helper for cache_purge1(): purge all cache entries hanging off the given
  * directory vnode.
  */
 static void
 cache_purge_children(struct vnode *dvp)
+{
 	vnode_impl_t *dvi = VNODE_TO_VIMPL(dvp);
 	struct namecache *ncp;
 	SDT_PROBE(vfs, namecache, purge, children, dvp, 0, 0, 0, 0);
 	rw_enter(&dvi->vi_nc_lock, RW_WRITER);
 	while ((ncp = RB_TREE_MIN(&dvi->vi_nc_tree)) != NULL) {
 		cache_remove(ncp, true);
+	}
 	rw_exit(&dvi->vi_nc_lock);
+}
 /*
  * Helper for cache_purge1(): purge cache entry from the given vnode,
  * finding it by name.
  */
 static void
 cache_purge_name(struct vnode *dvp, const char *name, size_t namelen)
+{
 	vnode_impl_t *dvi = VNODE_TO_VIMPL(dvp);
 	struct namecache *ncp;
 	uint64_t key;
 	SDT_PROBE(vfs, namecache, purge, name, name, namelen, 0, 0, 0);
 	key = cache_key(name, namelen);
 	rw_enter(&dvi->vi_nc_lock, RW_WRITER);
 	ncp = cache_lookup_entry(dvp, name, namelen, key);
 	if (ncp) {
 		cache_remove(ncp, true);
+	}
 	rw_exit(&dvi->vi_nc_lock);
+}
 /*
  * Cache flush, a particular vnode; called when a vnode is renamed to
  * hide entries that would now be invalid.
  */
 void
 cache_purge1(struct vnode *vp, const char *name, size_t namelen, int flags)
+{
 	if (flags & PURGE_PARENTS) {
 		cache_purge_parents(vp);
+	}
 	if (flags & PURGE_CHILDREN) {
 		cache_purge_children(vp);
+	}
 	if (name != NULL) {
 		cache_purge_name(vp, name, namelen);
+	}
+}
 /*
  * vnode filter for cache_purgevfs().
  */
 static bool
 cache_vdir_filter(void *cookie, vnode_t *vp)
+{
 	return vp->v_type == VDIR;
+}
 /*
  * Cache flush, a whole filesystem; called when filesys is umounted to
  * remove entries that would now be invalid.
  */
 void
 cache_purgevfs(struct mount *mp)
+{
 	struct vnode_iterator *iter;
 	vnode_t *dvp;
 	vfs_vnode_iterator_init(mp, &iter);
 	for (;;) {
 		dvp = vfs_vnode_iterator_next(iter, cache_vdir_filter, NULL);
 		if (dvp == NULL) {
 			break;
+		}
 		cache_purge_children(dvp);
 		vrele(dvp);
+	}
 	vfs_vnode_iterator_destroy(iter);
+}
 /*
  * Re-queue an entry onto the tail of the active LRU list, after it has
  * scored a hit.
  */
 static void
 cache_activate(struct namecache *ncp)
+{
 	mutex_enter(&cache_lru_lock);
 	TAILQ_REMOVE(&cache_lru.list[ncp->nc_lrulist], ncp, nc_lru);
 	TAILQ_INSERT_TAIL(&cache_lru.list[LRU_ACTIVE], ncp, nc_lru);
 	cache_lru.count[ncp->nc_lrulist]--;
 	cache_lru.count[LRU_ACTIVE]++;
 	ncp->nc_lrulist = LRU_ACTIVE;
 	mutex_exit(&cache_lru_lock);
+}
 /*
  * Try to balance the LRU lists.  Pick some victim entries, and re-queue
  * them from the head of the active list to the tail of the inactive list.
  */
 static void
 cache_deactivate(void)
+{
 	struct namecache *ncp;
 	int total, i;
 	KASSERT(mutex_owned(&cache_lru_lock));
 	/* If we're nowhere near budget yet, don't bother. */
 	total = cache_lru.count[LRU_ACTIVE] + cache_lru.count[LRU_INACTIVE];
 	if (total < (desiredvnodes >> 1)) {
 	    	return;
+	}
 	/*
 	 * Aim for a 1:1 ratio of active to inactive.  This is to allow each
 	 * potential victim a reasonable amount of time to cycle through the
 	 * inactive list in order to score a hit and be reactivated, while
 	 * trying not to cause reactivations too frequently.
 	 */
 	if (cache_lru.count[LRU_ACTIVE] < cache_lru.count[LRU_INACTIVE]) {
 		return;
+	}
 	/* Move only a few at a time; will catch up eventually. */
 	for (i = 0; i < cache_lru_maxdeact; i++) {
 		ncp = TAILQ_FIRST(&cache_lru.list[LRU_ACTIVE]);
 		if (ncp == NULL) {
 			break;
+		}
 		KASSERT(ncp->nc_lrulist == LRU_ACTIVE);
 		ncp->nc_lrulist = LRU_INACTIVE;
 		TAILQ_REMOVE(&cache_lru.list[LRU_ACTIVE], ncp, nc_lru);
 		TAILQ_INSERT_TAIL(&cache_lru.list[LRU_INACTIVE], ncp, nc_lru);
 		cache_lru.count[LRU_ACTIVE]--;
 		cache_lru.count[LRU_INACTIVE]++;
+	}
+}
 /*
  * Free some entries from the cache, when we have gone over budget.
+ *
  * We don't want to cause too much work for any individual caller, and it
  * doesn't matter if we temporarily go over budget.  This is also "just a
  * cache" so it's not a big deal if we screw up and throw out something we
  * shouldn't.  So we take a relaxed attitude to this process to reduce its
  * impact.
  */
 static void
 cache_reclaim(void)
+{
 	struct namecache *ncp;
 	vnode_impl_t *dvi;
 	int toscan;
 	/*
 	 * Scan up to a preset maxium number of entries, but no more than
 	 * 0.8% of the total at once (to allow for very small systems).
+	 *
 	 * On bigger systems, do a larger chunk of work to reduce the number
 	 * of times that cache_lru_lock is held for any length of time.
 	 */
 	mutex_enter(&cache_lru_lock);
 	toscan = MIN(cache_lru_maxscan, desiredvnodes >> 7);
 	toscan = MAX(toscan, 1);
 	SDT_PROBE(vfs, namecache, prune, done, cache_lru.count[LRU_ACTIVE] +
 	    cache_lru.count[LRU_INACTIVE], toscan, 0, 0, 0);
 	while (toscan-- != 0) {
 		/* First try to balance the lists. */
 		cache_deactivate();
 		/* Now look for a victim on head of inactive list (old). */
 		ncp = TAILQ_FIRST(&cache_lru.list[LRU_INACTIVE]);
 		if (ncp == NULL) {
 			break;
+		}
 		dvi = VNODE_TO_VIMPL(ncp->nc_dvp);
 		KASSERT(ncp->nc_lrulist == LRU_INACTIVE);
 		KASSERT(dvi != NULL);
 		/*
 		 * Locking in the wrong direction.  If we can't get the
 		 * lock, the directory is actively busy, and it could also
 		 * cause problems for the next guy in here, so send the
 		 * entry to the back of the list.
 		 */
 		if (!rw_tryenter(&dvi->vi_nc_lock, RW_WRITER)) {
 			TAILQ_REMOVE(&cache_lru.list[LRU_INACTIVE],
 			    ncp, nc_lru);
 			TAILQ_INSERT_TAIL(&cache_lru.list[LRU_INACTIVE],
 			    ncp, nc_lru);
 			continue;
+		}
 		/*
 		 * Now have the victim entry locked.  Drop the LRU list
 		 * lock, purge the entry, and start over.  The hold on
 		 * vi_nc_lock will prevent the vnode from vanishing until
 		 * finished (cache_purge() will be called on dvp before it
 		 * disappears, and that will wait on vi_nc_lock).
 		 */
 		mutex_exit(&cache_lru_lock);
 		cache_remove(ncp, true);
 		rw_exit(&dvi->vi_nc_lock);
 		mutex_enter(&cache_lru_lock);
+	}
 	mutex_exit(&cache_lru_lock);
+}
 /*
  * For file system code: count a lookup that required a full re-scan of
  * directory metadata.
  */
 void
 namecache_count_pass2(void)
+{
 	COUNT(ncs_pass2);
+}
 /*
  * For file system code: count a lookup that scored a hit in the directory
  * metadata near the location of the last lookup.
  */
 void
 namecache_count_2passes(void)
+{
 	COUNT(ncs_2passes);
+}
 /*
  * Sum the stats from all CPUs into nchstats.  This needs to run at least
  * once within every window where a 32-bit counter could roll over.  It's
  * called regularly by timer to ensure this.
  */
 static void
 cache_update_stats(void *cookie)
+{
 	CPU_INFO_ITERATOR cii;
 	struct cpu_info *ci;
 	mutex_enter(&cache_stat_lock);
 	for (CPU_INFO_FOREACH(cii, ci)) {
 		struct nchcpu *nchcpu = ci->ci_data.cpu_nch;
 		UPDATE(nchcpu, ncs_goodhits);
 		UPDATE(nchcpu, ncs_neghits);
 		UPDATE(nchcpu, ncs_badhits);
 		UPDATE(nchcpu, ncs_falsehits);
 		UPDATE(nchcpu, ncs_miss);
 		UPDATE(nchcpu, ncs_long);
 		UPDATE(nchcpu, ncs_pass2);
 		UPDATE(nchcpu, ncs_2passes);
 		UPDATE(nchcpu, ncs_revhits);
 		UPDATE(nchcpu, ncs_revmiss);
 		UPDATE(nchcpu, ncs_denied);
+	}
 	if (cookie != NULL) {
 		memcpy(cookie, &nchstats, sizeof(nchstats));
+	}
 	/* Reset the timer; arrive back here in N minutes at latest. */
 	callout_schedule(&cache_stat_callout, cache_stat_interval * hz);
 	mutex_exit(&cache_stat_lock);
+}
 /*
  * Fetch the current values of the stats for sysctl.
  */
 static int
 cache_stat_sysctl(SYSCTLFN_ARGS)
+{
 	struct nchstats stats;
 	if (oldp == NULL) {
 		*oldlenp = sizeof(nchstats);
 		return 0;
+	}
 	if (*oldlenp <= 0) {
 		*oldlenp = 0;
 		return 0;
+	}
 	/* Refresh the global stats. */
 	sysctl_unlock();
 	cache_update_stats(&stats);
 	sysctl_relock();
 	*oldlenp = MIN(sizeof(stats), *oldlenp);
 	return sysctl_copyout(l, &stats, oldp, *oldlenp);
+}
 /*
  * For the debugger, given the address of a vnode, print all associated
  * names in the cache.
  */
 #ifdef DDB
 void
 namecache_print(struct vnode *vp, void (*pr)(const char *, ...))
+{
 	struct vnode *dvp = NULL;
 	struct namecache *ncp;
 	enum cache_lru_id id;
 	for (id = 0; id < LRU_COUNT; id++) {
 		TAILQ_FOREACH(ncp, &cache_lru.list[id], nc_lru) {
 			if (ncp->nc_vp == vp) {
 				(*pr)("name %.*s\n", ncp->nc_nlen,
 				    ncp->nc_name);
 				dvp = ncp->nc_dvp;
+			}
+		}
+	}
 	if (dvp == NULL) {
 		(*pr)("name not found\n");
 		return;
+	}
 	for (id = 0; id < LRU_COUNT; id++) {
 		TAILQ_FOREACH(ncp, &cache_lru.list[id], nc_lru) {
 			if (ncp->nc_vp == dvp) {
 				(*pr)("parent %.*s\n", ncp->nc_nlen,
 				    ncp->nc_name);
+			}
+		}
+	}
+}
 #endif

 @@ -1,2244 +1,2251 @@
-/*	$NetBSD: vfs_lookup.c,v 1.218 2020/04/21 21:42:47 ad Exp $	*/
+/*	$NetBSD: vfs_lookup.c,v 1.219 2020/04/22 21:35:52 ad Exp $	*/
 /*
  * Copyright (c) 1982, 1986, 1989, 1993
  *	The Regents of the University of California.  All rights reserved.
  * (c) UNIX System Laboratories, Inc.
  * All or some portions of this file are derived from material licensed
  * to the University of California by American Telephone and Telegraph
  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
  * the permission of UNIX System Laboratories, Inc.
+ *
  * 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.
+ *
  *	@(#)vfs_lookup.c	8.10 (Berkeley) 5/27/95
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: vfs_lookup.c,v 1.218 2020/04/21 21:42:47 ad Exp $");
+__KERNEL_RCSID(0, "$NetBSD: vfs_lookup.c,v 1.219 2020/04/22 21:35:52 ad Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_magiclinks.h"
 #endif
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kernel.h>
 #include <sys/syslimits.h>
 #include <sys/time.h>
 #include <sys/namei.h>
 #include <sys/vnode.h>
 #include <sys/vnode_impl.h>
 #include <sys/mount.h>
 #include <sys/errno.h>
 #include <sys/filedesc.h>
 #include <sys/hash.h>
 #include <sys/proc.h>
 #include <sys/syslog.h>
 #include <sys/kauth.h>
 #include <sys/ktrace.h>
 #include <sys/dirent.h>
 #ifndef MAGICLINKS
 #define MAGICLINKS 0
 #endif
 int vfs_magiclinks = MAGICLINKS;
 __CTASSERT(MAXNAMLEN == NAME_MAX);
 /*
  * Substitute replacement text for 'magic' strings in symlinks.
  * Returns 0 if successful, and returns non-zero if an error
  * occurs.  (Currently, the only possible error is running out
  * of temporary pathname space.)
+ *
  * Looks for "@<string>" and "@<string>/", where <string> is a
  * recognized 'magic' string.  Replaces the "@<string>" with the
  * appropriate replacement text.  (Note that in some cases the
  * replacement text may have zero length.)
+ *
  * This would have been table driven, but the variance in
  * replacement strings (and replacement string lengths) made
  * that impractical.
  */
 #define	VNL(x)							\
 	(sizeof(x) - 1)
 #define	VO	'{'
 #define	VC	'}'
 #define	MATCH(str)						\
 	((termchar == '/' && i + VNL(str) == *len) ||		\
 	 (i + VNL(str) < *len &&				\
 	  cp[i + VNL(str)] == termchar)) &&			\
 	!strncmp((str), &cp[i], VNL(str))
 #define	SUBSTITUTE(m, s, sl)					\
 	if ((newlen + (sl)) >= MAXPATHLEN)			\
 		return 1;					\
 	i += VNL(m);						\
 	if (termchar != '/')					\
 		i++;						\
 	(void)memcpy(&tmp[newlen], (s), (sl));			\
 	newlen += (sl);						\
 	change = 1;						\
 	termchar = '/';
 static int
 symlink_magic(struct proc *p, char *cp, size_t *len)
+{
 	char *tmp;
 	size_t change, i, newlen, slen;
 	char termchar = '/';
 	char idtmp[11]; /* enough for 32 bit *unsigned* integer */
 	tmp = PNBUF_GET();
 	for (change = i = newlen = 0; i < *len; ) {
 		if (cp[i] != '@') {
 			tmp[newlen++] = cp[i++];
 			continue;
+		}
 		i++;
 		/* Check for @{var} syntax. */
 		if (cp[i] == VO) {
 			termchar = VC;
 			i++;
+		}
 		/*
 		 * The following checks should be ordered according
 		 * to frequency of use.
 		 */
 		if (MATCH("machine_arch")) {
 			slen = VNL(MACHINE_ARCH);
 			SUBSTITUTE("machine_arch", MACHINE_ARCH, slen);
 		} else if (MATCH("machine")) {
 			slen = VNL(MACHINE);
 			SUBSTITUTE("machine", MACHINE, slen);
 		} else if (MATCH("hostname")) {
 			SUBSTITUTE("hostname", hostname, hostnamelen);
 		} else if (MATCH("osrelease")) {
 			slen = strlen(osrelease);
 			SUBSTITUTE("osrelease", osrelease, slen);
 		} else if (MATCH("emul")) {
 			slen = strlen(p->p_emul->e_name);
 			SUBSTITUTE("emul", p->p_emul->e_name, slen);
 		} else if (MATCH("kernel_ident")) {
 			slen = strlen(kernel_ident);
 			SUBSTITUTE("kernel_ident", kernel_ident, slen);
 		} else if (MATCH("domainname")) {
 			SUBSTITUTE("domainname", domainname, domainnamelen);
 		} else if (MATCH("ostype")) {
 			slen = strlen(ostype);
 			SUBSTITUTE("ostype", ostype, slen);
 		} else if (MATCH("uid")) {
 			slen = snprintf(idtmp, sizeof(idtmp), "%u",
 			    kauth_cred_geteuid(kauth_cred_get()));
 			SUBSTITUTE("uid", idtmp, slen);
 		} else if (MATCH("ruid")) {
 			slen = snprintf(idtmp, sizeof(idtmp), "%u",
 			    kauth_cred_getuid(kauth_cred_get()));
 			SUBSTITUTE("ruid", idtmp, slen);
 		} else if (MATCH("gid")) {
 			slen = snprintf(idtmp, sizeof(idtmp), "%u",
 			    kauth_cred_getegid(kauth_cred_get()));
 			SUBSTITUTE("gid", idtmp, slen);
 		} else if (MATCH("rgid")) {
 			slen = snprintf(idtmp, sizeof(idtmp), "%u",
 			    kauth_cred_getgid(kauth_cred_get()));
 			SUBSTITUTE("rgid", idtmp, slen);
 		} else {
 			tmp[newlen++] = '@';
 			if (termchar == VC)
 				tmp[newlen++] = VO;
+		}
+	}
 	if (change) {
 		(void)memcpy(cp, tmp, newlen);
 		*len = newlen;
+	}
 	PNBUF_PUT(tmp);
 	return 0;
+}
 #undef VNL
 #undef VO
 #undef VC
 #undef MATCH
 #undef SUBSTITUTE
 ////////////////////////////////////////////////////////////
 /*
  * Determine the namei hash (for the namecache) for name.
  * If *ep != NULL, hash from name to ep-1.
  * If *ep == NULL, hash from name until the first NUL or '/', and
  * return the location of this termination character in *ep.
+ *
  * This function returns an equivalent hash to the MI hash32_strn().
  * The latter isn't used because in the *ep == NULL case, determining
  * the length of the string to the first NUL or `/' and then calling
  * hash32_strn() involves unnecessary double-handling of the data.
  */
 uint32_t
 namei_hash(const char *name, const char **ep)
+{
 	uint32_t	hash;
 	hash = HASH32_STR_INIT;
 	if (*ep != NULL) {
 		for (; name < *ep; name++)
 			hash = hash * 33 + *(const uint8_t *)name;
 	} else {
 		for (; *name != '\0' && *name != '/'; name++)
 			hash = hash * 33 + *(const uint8_t *)name;
 		*ep = name;
+	}
 	return (hash + (hash >> 5));
+}
 /*
  * Find the end of the first path component in NAME and return its
  * length.
  */
 static size_t
 namei_getcomponent(const char *name)
+{
 	size_t pos;
 	pos = 0;
 	while (name[pos] != '\0' && name[pos] != '/') {
 		pos++;
+	}
 	return pos;
+}
 ////////////////////////////////////////////////////////////
 /*
  * Sealed abstraction for pathnames.
+ *
  * System-call-layer level code that is going to call namei should
  * first create a pathbuf and adjust all the bells and whistles on it
  * as needed by context.
  */
 struct pathbuf {
 	char *pb_path;
 	char *pb_pathcopy;
 	unsigned pb_pathcopyuses;
 };
 static struct pathbuf *
 pathbuf_create_raw(void)
+{
 	struct pathbuf *pb;
 	pb = kmem_alloc(sizeof(*pb), KM_SLEEP);
 	pb->pb_path = PNBUF_GET();
 	if (pb->pb_path == NULL) {
 		kmem_free(pb, sizeof(*pb));
 		return NULL;
+	}
 	pb->pb_pathcopy = NULL;
 	pb->pb_pathcopyuses = 0;
 	return pb;
+}
 void
 pathbuf_destroy(struct pathbuf *pb)
+{
 	KASSERT(pb->pb_pathcopyuses == 0);
 	KASSERT(pb->pb_pathcopy == NULL);
 	PNBUF_PUT(pb->pb_path);
 	kmem_free(pb, sizeof(*pb));
+}
 struct pathbuf *
 pathbuf_assimilate(char *pnbuf)
+{
 	struct pathbuf *pb;
 	pb = kmem_alloc(sizeof(*pb), KM_SLEEP);
 	pb->pb_path = pnbuf;
 	pb->pb_pathcopy = NULL;
 	pb->pb_pathcopyuses = 0;
 	return pb;
+}
 struct pathbuf *
 pathbuf_create(const char *path)
+{
 	struct pathbuf *pb;
 	int error;
 	pb = pathbuf_create_raw();
 	if (pb == NULL) {
 		return NULL;
+	}
 	error = copystr(path, pb->pb_path, PATH_MAX, NULL);
 	if (error != 0) {
 		KASSERT(!"kernel path too long in pathbuf_create");
 		/* make sure it's null-terminated, just in case */
 		pb->pb_path[PATH_MAX-1] = '\0';
+	}
 	return pb;
+}
 int
 pathbuf_copyin(const char *userpath, struct pathbuf **ret)
+{
 	struct pathbuf *pb;
 	int error;
 	pb = pathbuf_create_raw();
 	if (pb == NULL) {
 		return ENOMEM;
+	}
 	error = copyinstr(userpath, pb->pb_path, PATH_MAX, NULL);
 	if (error) {
 		pathbuf_destroy(pb);
 		return error;
+	}
 	*ret = pb;
 	return 0;
+}
 /*
  * XXX should not exist:
  *   1. whether a pointer is kernel or user should be statically checkable.
  *   2. copyin should be handled by the upper part of the syscall layer,
  *      not in here.
  */
 int
 pathbuf_maybe_copyin(const char *path, enum uio_seg seg, struct pathbuf **ret)
+{
 	if (seg == UIO_USERSPACE) {
 		return pathbuf_copyin(path, ret);
 	} else {
 		*ret = pathbuf_create(path);
 		if (*ret == NULL) {
 			return ENOMEM;
+		}
 		return 0;
+	}
+}
 /*
  * Get a copy of the path buffer as it currently exists. If this is
  * called after namei starts the results may be arbitrary.
  */
 void
 pathbuf_copystring(const struct pathbuf *pb, char *buf, size_t maxlen)
+{
 	strlcpy(buf, pb->pb_path, maxlen);
+}
 /*
  * These two functions allow access to a saved copy of the original
  * path string. The first copy should be gotten before namei is
  * called. Each copy that is gotten should be put back.
  */
 const char *
 pathbuf_stringcopy_get(struct pathbuf *pb)
+{
 	if (pb->pb_pathcopyuses == 0) {
 		pb->pb_pathcopy = PNBUF_GET();
 		strcpy(pb->pb_pathcopy, pb->pb_path);
+	}
 	pb->pb_pathcopyuses++;
 	return pb->pb_pathcopy;
+}
 void
 pathbuf_stringcopy_put(struct pathbuf *pb, const char *str)
+{
 	KASSERT(str == pb->pb_pathcopy);
 	KASSERT(pb->pb_pathcopyuses > 0);
 	pb->pb_pathcopyuses--;
 	if (pb->pb_pathcopyuses == 0) {
 		PNBUF_PUT(pb->pb_pathcopy);
 		pb->pb_pathcopy = NULL;
+	}
+}
 ////////////////////////////////////////////////////////////
 /*
  * namei: convert a pathname into a pointer to a (maybe-locked) vnode,
  * and maybe also its parent directory vnode, and assorted other guff.
  * See namei(9) for the interface documentation.
+ *
+ *
  * The FOLLOW flag is set when symbolic links are to be followed
  * when they occur at the end of the name translation process.
  * Symbolic links are always followed for all other pathname
  * components other than the last.
+ *
  * The segflg defines whether the name is to be copied from user
  * space or kernel space.
+ *
  * Overall outline of namei:
+ *
  *	copy in name
  *	get starting directory
  *	while (!done && !error) {
  *		call lookup to search path.
  *		if symbolic link, massage name in buffer and continue
  *	}
  */
 /*
  * Search a pathname.
  * This is a very central and rather complicated routine.
+ *
  * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
  * The starting directory is passed in. The pathname is descended
  * until done, or a symbolic link is encountered. The variable ni_more
  * is clear if the path is completed; it is set to one if a symbolic
  * link needing interpretation is encountered.
+ *
  * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
  * whether the name is to be looked up, created, renamed, or deleted.
  * When CREATE, RENAME, or DELETE is specified, information usable in
  * creating, renaming, or deleting a directory entry may be calculated.
  * If flag has LOCKPARENT or'ed into it, the parent directory is returned
  * locked.  Otherwise the parent directory is not returned. If the target
  * of the pathname exists and LOCKLEAF is or'ed into the flag the target
  * is returned locked, otherwise it is returned unlocked.  When creating
  * or renaming and LOCKPARENT is specified, the target may not be ".".
  * When deleting and LOCKPARENT is specified, the target may be ".".
+ *
  * Overall outline of lookup:
+ *
  * dirloop:
  *	identify next component of name at ndp->ni_ptr
  *	handle degenerate case where name is null string
  *	if .. and crossing mount points and on mounted filesys, find parent
  *	call VOP_LOOKUP routine for next component name
  *	    directory vnode returned in ni_dvp, locked.
  *	    component vnode returned in ni_vp (if it exists), locked.
  *	if result vnode is mounted on and crossing mount points,
  *	    find mounted on vnode
  *	if more components of name, do next level at dirloop
  *	return the answer in ni_vp, locked if LOCKLEAF set
  *	    if LOCKPARENT set, return locked parent in ni_dvp
  */
 /*
  * Internal state for a namei operation.
+ *
  * cnp is always equal to &ndp->ni_cnp.
  */
 struct namei_state {
 	struct nameidata *ndp;
 	struct componentname *cnp;
 	int docache;			/* == 0 do not cache last component */
 	int rdonly;			/* lookup read-only flag bit */
 	int slashes;
 	unsigned attempt_retry:1;	/* true if error allows emul retry */
 	unsigned root_referenced:1;	/* true if ndp->ni_rootdir and
 					     ndp->ni_erootdir were referenced */
 };
 /*
  * Initialize the namei working state.
  */
 static void
 namei_init(struct namei_state *state, struct nameidata *ndp)
+{
 	state->ndp = ndp;
 	state->cnp = &ndp->ni_cnd;
 	state->docache = 0;
 	state->rdonly = 0;
 	state->slashes = 0;
 	state->root_referenced = 0;
 	KASSERTMSG((state->cnp->cn_cred != NULL), "namei: bad cred/proc");
 	KASSERTMSG(((state->cnp->cn_nameiop & (~OPMASK)) == 0),
 	    "namei: nameiop contaminated with flags: %08"PRIx32,
 	    state->cnp->cn_nameiop);
 	KASSERTMSG(((state->cnp->cn_flags & OPMASK) == 0),
 	    "name: flags contaminated with nameiops: %08"PRIx32,
 	    state->cnp->cn_flags);
 	/*
 	 * The buffer for name translation shall be the one inside the
 	 * pathbuf.
 	 */
 	state->ndp->ni_pnbuf = state->ndp->ni_pathbuf->pb_path;
+}
 /*
  * Clean up the working namei state, leaving things ready for return
  * from namei.
  */
 static void
 namei_cleanup(struct namei_state *state)
+{
 	KASSERT(state->cnp == &state->ndp->ni_cnd);
 	if (state->root_referenced) {
 		if (state->ndp->ni_rootdir != NULL)
 			vrele(state->ndp->ni_rootdir);
 		if (state->ndp->ni_erootdir != NULL)
 			vrele(state->ndp->ni_erootdir);
+	}
+}
 //////////////////////////////
 /*
  * Get the directory context.
  * Initializes the rootdir and erootdir state and returns a reference
  * to the starting dir.
  */
 static struct vnode *
 namei_getstartdir(struct namei_state *state)
+{
 	struct nameidata *ndp = state->ndp;
 	struct componentname *cnp = state->cnp;
 	struct cwdinfo *cwdi;		/* pointer to cwd state */
 	struct lwp *self = curlwp;	/* thread doing namei() */
 	struct vnode *rootdir, *erootdir, *curdir, *startdir;
 	if (state->root_referenced) {
 		if (state->ndp->ni_rootdir != NULL)
 			vrele(state->ndp->ni_rootdir);
 		if (state->ndp->ni_erootdir != NULL)
 			vrele(state->ndp->ni_erootdir);
 		state->root_referenced = 0;
+	}
 	cwdi = self->l_proc->p_cwdi;
 	rw_enter(&cwdi->cwdi_lock, RW_READER);
 	/* root dir */
 	if (cwdi->cwdi_rdir == NULL || (cnp->cn_flags & NOCHROOT)) {
 		rootdir = rootvnode;
 	} else {
 		rootdir = cwdi->cwdi_rdir;
+	}
 	/* emulation root dir, if any */
 	if ((cnp->cn_flags & TRYEMULROOT) == 0) {
 		/* if we don't want it, don't fetch it */
 		erootdir = NULL;
 	} else if (cnp->cn_flags & EMULROOTSET) {
 		/* explicitly set emulroot; "/../" doesn't override this */
 		erootdir = ndp->ni_erootdir;
 	} else if (!strncmp(ndp->ni_pnbuf, "/../", 4)) {
 		/* explicit reference to real rootdir */
 		erootdir = NULL;
 	} else {
 		/* may be null */
 		erootdir = cwdi->cwdi_edir;
+	}
 	/* current dir */
 	curdir = cwdi->cwdi_cdir;
 	if (ndp->ni_pnbuf[0] != '/') {
 		if (ndp->ni_atdir != NULL) {
 			startdir = ndp->ni_atdir;
 		} else {
 			startdir = curdir;
+		}
 		erootdir = NULL;
 	} else if (cnp->cn_flags & TRYEMULROOT && erootdir != NULL) {
 		startdir = erootdir;
 	} else {
 		startdir = rootdir;
 		erootdir = NULL;
+	}
 	state->ndp->ni_rootdir = rootdir;
 	state->ndp->ni_erootdir = erootdir;
 	/*
 	 * Get a reference to the start dir so we can safely unlock cwdi.
+	 *
 	 * Must hold references to rootdir and erootdir while we're running.
 	 * A multithreaded process may chroot during namei.
 	 */
 	if (startdir != NULL)
 		vref(startdir);
 	if (state->ndp->ni_rootdir != NULL)
 		vref(state->ndp->ni_rootdir);
 	if (state->ndp->ni_erootdir != NULL)
 		vref(state->ndp->ni_erootdir);
 	state->root_referenced = 1;
 	rw_exit(&cwdi->cwdi_lock);
 	return startdir;
+}
 /*
  * Get the directory context for the nfsd case, in parallel to
  * getstartdir. Initializes the rootdir and erootdir state and
  * returns a reference to the passed-in starting dir.
  */
 static struct vnode *
 namei_getstartdir_for_nfsd(struct namei_state *state)
+{
 	KASSERT(state->ndp->ni_atdir != NULL);
 	/* always use the real root, and never set an emulation root */
 	if (rootvnode == NULL) {
 		return NULL;
+	}
 	state->ndp->ni_rootdir = rootvnode;
 	state->ndp->ni_erootdir = NULL;
 	vref(state->ndp->ni_atdir);
 	KASSERT(! state->root_referenced);
 	vref(state->ndp->ni_rootdir);
 	state->root_referenced = 1;
 	return state->ndp->ni_atdir;
+}
 /*
  * Ktrace the namei operation.
  */
 static void
 namei_ktrace(struct namei_state *state)
+{
 	struct nameidata *ndp = state->ndp;
 	struct componentname *cnp = state->cnp;
 	struct lwp *self = curlwp;	/* thread doing namei() */
 	const char *emul_path;
 	if (ktrpoint(KTR_NAMEI)) {
 		if (ndp->ni_erootdir != NULL) {
 			/*
 			 * To make any sense, the trace entry need to have the
 			 * text of the emulation path prepended.
 			 * Usually we can get this from the current process,
 			 * but when called from emul_find_interp() it is only
 			 * in the exec_package - so we get it passed in ni_next
 			 * (this is a hack).
 			 */
 			if (cnp->cn_flags & EMULROOTSET)
 				emul_path = ndp->ni_next;
 			else
 				emul_path = self->l_proc->p_emul->e_path;
 			ktrnamei2(emul_path, strlen(emul_path),
 			    ndp->ni_pnbuf, ndp->ni_pathlen);
 		} else
 			ktrnamei(ndp->ni_pnbuf, ndp->ni_pathlen);
+	}
+}
 /*
  * Start up namei. Find the root dir and cwd, establish the starting
  * directory for lookup, and lock it. Also calls ktrace when
  * appropriate.
  */
 static int
 namei_start(struct namei_state *state, int isnfsd,
 	    struct vnode **startdir_ret)
+{
 	struct nameidata *ndp = state->ndp;
 	struct vnode *startdir;
 	/* length includes null terminator (was originally from copyinstr) */
 	ndp->ni_pathlen = strlen(ndp->ni_pnbuf) + 1;
 	/*
 	 * POSIX.1 requirement: "" is not a valid file name.
 	 */
 	if (ndp->ni_pathlen == 1) {
 		ndp->ni_erootdir = NULL;
 		return ENOENT;
+	}
 	ndp->ni_loopcnt = 0;
 	/* Get starting directory, set up root, and ktrace. */
 	if (isnfsd) {
 		startdir = namei_getstartdir_for_nfsd(state);
 		/* no ktrace */
 	} else {
 		startdir = namei_getstartdir(state);
 		namei_ktrace(state);
+	}
 	if (startdir == NULL) {
 		return ENOENT;
+	}
 	/* NDAT may feed us with a non directory namei_getstartdir */
 	if (startdir->v_type != VDIR) {
 		vrele(startdir);
 		return ENOTDIR;
+	}
 	*startdir_ret = startdir;
 	return 0;
+}
 /*
  * Check for being at a symlink that we're going to follow.
  */
 static inline int
 namei_atsymlink(struct namei_state *state, struct vnode *foundobj)
+{
 	return (foundobj->v_type == VLNK) &&
 		(state->cnp->cn_flags & (FOLLOW|REQUIREDIR));
+}
 /*
  * Follow a symlink.
+ *
  * Updates searchdir. inhibitmagic causes magic symlinks to not be
  * interpreted; this is used by nfsd.
+ *
  * Unlocks foundobj on success (ugh)
  */
 static inline int
 namei_follow(struct namei_state *state, int inhibitmagic,
 	     struct vnode *searchdir, struct vnode *foundobj,
 	     struct vnode **newsearchdir_ret)
+{
 	struct nameidata *ndp = state->ndp;
 	struct componentname *cnp = state->cnp;
 	struct lwp *self = curlwp;	/* thread doing namei() */
 	struct iovec aiov;		/* uio for reading symbolic links */
 	struct uio auio;
 	char *cp;			/* pointer into pathname argument */
 	size_t linklen;
 	int error;
 	if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
 		return ELOOP;
+	}
 	vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
 	if (foundobj->v_mount->mnt_flag & MNT_SYMPERM) {
 		error = VOP_ACCESS(foundobj, VEXEC, cnp->cn_cred);
 		if (error != 0) {
 			VOP_UNLOCK(foundobj);
 			return error;
+		}
+	}
 	/* FUTURE: fix this to not use a second buffer */
 	cp = PNBUF_GET();
 	aiov.iov_base = cp;
 	aiov.iov_len = MAXPATHLEN;
 	auio.uio_iov = &aiov;
 	auio.uio_iovcnt = 1;
 	auio.uio_offset = 0;
 	auio.uio_rw = UIO_READ;
 	auio.uio_resid = MAXPATHLEN;
 	UIO_SETUP_SYSSPACE(&auio);
 	error = VOP_READLINK(foundobj, &auio, cnp->cn_cred);
 	VOP_UNLOCK(foundobj);
 	if (error) {
 		PNBUF_PUT(cp);
 		return error;
+	}
 	linklen = MAXPATHLEN - auio.uio_resid;
 	if (linklen == 0) {
 		PNBUF_PUT(cp);
 		return ENOENT;
+	}
 	/*
 	 * Do symlink substitution, if appropriate, and
 	 * check length for potential overflow.
+	 *
 	 * Inhibit symlink substitution for nfsd.
 	 * XXX: This is how it was before; is that a bug or a feature?
 	 */
 	if ((!inhibitmagic && vfs_magiclinks &&
 	     symlink_magic(self->l_proc, cp, &linklen)) ||
 	    (linklen + ndp->ni_pathlen >= MAXPATHLEN)) {
 		PNBUF_PUT(cp);
 		return ENAMETOOLONG;
+	}
 	if (ndp->ni_pathlen > 1) {
 		/* includes a null-terminator */
 		memcpy(cp + linklen, ndp->ni_next, ndp->ni_pathlen);
 	} else {
 		cp[linklen] = '\0';
+	}
 	ndp->ni_pathlen += linklen;
 	memcpy(ndp->ni_pnbuf, cp, ndp->ni_pathlen);
 	PNBUF_PUT(cp);
 	/* we're now starting from the beginning of the buffer again */
 	cnp->cn_nameptr = ndp->ni_pnbuf;
 	/*
 	 * Check if root directory should replace current directory.
 	 */
 	if (ndp->ni_pnbuf[0] == '/') {
 		vrele(searchdir);
 		/* Keep absolute symbolic links inside emulation root */
 		searchdir = ndp->ni_erootdir;
 		if (searchdir == NULL ||
 		    (ndp->ni_pnbuf[1] == '.'
 		     && ndp->ni_pnbuf[2] == '.'
 		     && ndp->ni_pnbuf[3] == '/')) {
 			ndp->ni_erootdir = NULL;
 			searchdir = ndp->ni_rootdir;
+		}
 		vref(searchdir);
 		while (cnp->cn_nameptr[0] == '/') {
 			cnp->cn_nameptr++;
 			ndp->ni_pathlen--;
+		}
+	}
 	*newsearchdir_ret = searchdir;
 	return 0;
+}
 //////////////////////////////
 /*
  * Inspect the leading path component and update the state accordingly.
  */
 static int
 lookup_parsepath(struct namei_state *state)
+{
 	const char *cp;			/* pointer into pathname argument */
 	struct componentname *cnp = state->cnp;
 	struct nameidata *ndp = state->ndp;
 	KASSERT(cnp == &ndp->ni_cnd);
 	/*
 	 * Search a new directory.
+	 *
 	 * The last component of the filename is left accessible via
 	 * cnp->cn_nameptr for callers that need the name. Callers needing
 	 * the name set the SAVENAME flag. When done, they assume
 	 * responsibility for freeing the pathname buffer.
+	 *
 	 * At this point, our only vnode state is that the search dir
 	 * is held.
 	 */
 	cnp->cn_consume = 0;
 	cnp->cn_namelen = namei_getcomponent(cnp->cn_nameptr);
 	cp = cnp->cn_nameptr + cnp->cn_namelen;
 	if (cnp->cn_namelen > KERNEL_NAME_MAX) {
 		return ENAMETOOLONG;
+	}
 #ifdef NAMEI_DIAGNOSTIC
 	{ char c = *cp;
 	*(char *)cp = '\0';
 	printf("{%s}: ", cnp->cn_nameptr);
 	*(char *)cp = c; }
 #endif /* NAMEI_DIAGNOSTIC */
 	ndp->ni_pathlen -= cnp->cn_namelen;
 	ndp->ni_next = cp;
 	/*
 	 * If this component is followed by a slash, then move the pointer to
 	 * the next component forward, and remember that this component must be
 	 * a directory.
 	 */
 	if (*cp == '/') {
 		do {
 			cp++;
 		} while (*cp == '/');
 		state->slashes = cp - ndp->ni_next;
 		ndp->ni_pathlen -= state->slashes;
 		ndp->ni_next = cp;
 		cnp->cn_flags |= REQUIREDIR;
 	} else {
 		state->slashes = 0;
 		cnp->cn_flags &= ~REQUIREDIR;
+	}
 	/*
 	 * We do special processing on the last component, whether or not it's
 	 * a directory.  Cache all intervening lookups, but not the final one.
 	 */
 	if (*cp == '\0') {
 		if (state->docache)
 			cnp->cn_flags |= MAKEENTRY;
 		else
 			cnp->cn_flags &= ~MAKEENTRY;
 		cnp->cn_flags |= ISLASTCN;
 	} else {
 		cnp->cn_flags |= MAKEENTRY;
 		cnp->cn_flags &= ~ISLASTCN;
+	}
 	if (cnp->cn_namelen == 2 &&
 	    cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
 		cnp->cn_flags |= ISDOTDOT;
 	else
 		cnp->cn_flags &= ~ISDOTDOT;
 	return 0;
+}
 /*
  * Take care of crossing a mounted-on vnode.  On error, foundobj_ret will be
  * vrele'd, but searchdir is left alone.
  */
 static int
 lookup_crossmount(struct namei_state *state,
 		  struct vnode **searchdir_ret,
 		  struct vnode **foundobj_ret,
 		  bool *searchdir_locked)
+{
 	struct componentname *cnp = state->cnp;
 	struct vnode *foundobj;
 	struct vnode *searchdir;
 	struct mount *mp;
 	int error, lktype;
 	searchdir = *searchdir_ret;
 	foundobj = *foundobj_ret;
 	error = 0;
 	KASSERT((cnp->cn_flags & NOCROSSMOUNT) == 0);
 	KASSERT(searchdir != NULL);
 	/* First, unlock searchdir (oof). */
 	if (*searchdir_locked) {
 		lktype = VOP_ISLOCKED(searchdir);
 		VOP_UNLOCK(searchdir);
 		*searchdir_locked = false;
 	} else {
 		lktype = LK_NONE;
+	}
 	/*
 	 * Do an unlocked check to see if the vnode has been mounted on; if
 	 * so find the root of the mounted file system.
 	 */
 	while (foundobj->v_type == VDIR &&
 	    (mp = foundobj->v_mountedhere) != NULL &&
 	    (cnp->cn_flags & NOCROSSMOUNT) == 0) {
 		KASSERTMSG(searchdir != foundobj, "same vn %p", searchdir);
 		/*
 		 * First get the vnode stable.  LK_SHARED works brilliantly
 		 * here because almost nothing else wants to lock the
 		 * covered vnode.
 		 */
 		error = vn_lock(foundobj, LK_SHARED);
 		if (error != 0) {
 			vrele(foundobj);
 			foundobj = NULL;
 			break;
+		}
 		/* Then check to see if something is still mounted on it. */
 		if ((mp = foundobj->v_mountedhere) == NULL) {
 			VOP_UNLOCK(foundobj);
 			break;
+		}
 		/* Get a reference to the mountpoint, and ditch foundobj. */
 		error = vfs_busy(mp);
 		vput(foundobj);
 		if (error != 0) {
 			foundobj = NULL;
 			break;
+		}
 		/* Now get a reference on the root vnode, and drop mount. */
 		error = VFS_ROOT(mp, LK_NONE, &foundobj);
 		vfs_unbusy(mp);
 		if (error) {
 			foundobj = NULL;
 			break;
+		}
 		/*
 		 * Avoid locking vnodes from two filesystems because
 		 * it's prone to deadlock, e.g. when using puffs.
 		 * Also, it isn't a good idea to propagate slowness of
 		 * a filesystem up to the root directory. For now,
 		 * only handle the common case, where foundobj is
 		 * VDIR.
+		 *
 		 * In this case set searchdir to null to avoid using
 		 * it again. It is not correct to set searchdir ==
 		 * foundobj here as that will confuse the caller.
 		 * (See PR 40740.)
 		 */
 		if (searchdir == NULL) {
 			/* already been here once; do nothing further */
 		} else if (foundobj->v_type == VDIR) {
 			vrele(searchdir);
 			*searchdir_ret = searchdir = NULL;
 			lktype = LK_NONE;
+		}
+	}
 	/* If searchdir is still around, re-lock it. */
  	if (error == 0 && lktype != LK_NONE) {
 		vn_lock(searchdir, lktype | LK_RETRY);
 		*searchdir_locked = true;
+	}
 	*foundobj_ret = foundobj;
 	return error;
+}
 /*
  * Call VOP_LOOKUP for a single lookup; return a new search directory
  * (used when crossing mountpoints up or searching union mounts down) and
  * the found object, which for create operations may be NULL on success.
+ *
  * Note that the new search directory may be null, which means the
  * searchdir was unlocked and released. This happens in the common case
  * when crossing a mount point downwards, in order to avoid coupling
  * locks between different file system volumes. Importantly, this can
  * happen even if the call fails. (XXX: this is gross and should be
  * tidied somehow.)
  */
 static int
 lookup_once(struct namei_state *state,
 	    struct vnode *searchdir,
 	    struct vnode **newsearchdir_ret,
 	    struct vnode **foundobj_ret,
 	    bool *newsearchdir_locked_ret)
+{
 	struct vnode *tmpvn;		/* scratch vnode */
 	struct vnode *foundobj;		/* result */
 	struct lwp *l = curlwp;
 	bool searchdir_locked = false;
 	int error, lktype;
 	struct componentname *cnp = state->cnp;
 	struct nameidata *ndp = state->ndp;
 	KASSERT(cnp == &ndp->ni_cnd);
 	*newsearchdir_ret = searchdir;
 	/*
 	 * Handle "..": two special cases.
 	 * 1. If at root directory (e.g. after chroot)
 	 *    or at absolute root directory
 	 *    then ignore it so can't get out.
 	 * 1a. If at the root of the emulation filesystem go to the real
 	 *    root. So "/../<path>" is always absolute.
 	 * 1b. If we have somehow gotten out of a jail, warn
 	 *    and also ignore it so we can't get farther out.
 	 * 2. If this vnode is the root of a mounted
 	 *    filesystem, then replace it with the
 	 *    vnode which was mounted on so we take the
 	 *    .. in the other file system.
 	 */
 	if (cnp->cn_flags & ISDOTDOT) {
 		struct proc *p = l->l_proc;
 		for (;;) {
 			if (searchdir == ndp->ni_rootdir ||
 			    searchdir == rootvnode) {
 				foundobj = searchdir;
 				vref(foundobj);
 				*foundobj_ret = foundobj;
 				error = 0;
 				goto done;
+			}
 			if (ndp->ni_rootdir != rootvnode) {
 				int retval;
 				retval = vn_isunder(searchdir, ndp->ni_rootdir, l);
 				if (!retval) {
 				    /* Oops! We got out of jail! */
 				    log(LOG_WARNING,
 					"chrooted pid %d uid %d (%s) "
 					"detected outside of its chroot\n",
 					p->p_pid, kauth_cred_geteuid(l->l_cred),
 					p->p_comm);
 				    /* Put us at the jail root. */
 				    vrele(searchdir);
 				    searchdir = NULL;
 				    foundobj = ndp->ni_rootdir;
 				    vref(foundobj);
 				    vref(foundobj);
 				    *newsearchdir_ret = foundobj;
 				    *foundobj_ret = foundobj;
 				    error = 0;
 				    goto done;
+				}
+			}
 			if ((searchdir->v_vflag & VV_ROOT) == 0 ||
 			    (cnp->cn_flags & NOCROSSMOUNT))
 				break;
 			tmpvn = searchdir;
 			searchdir = searchdir->v_mount->mnt_vnodecovered;
 			vref(searchdir);
 			vrele(tmpvn);
 			*newsearchdir_ret = searchdir;
+		}
+	}
 	/*
 	 * If the file system supports VOP_LOOKUP() with a shared lock, and
 	 * we are not making any modifications (nameiop LOOKUP) or this is
 	 * not the last component then get a shared lock.  Where we can't do
 	 * fast-forwarded lookups (for example with layered file systems)
 	 * then this is the fallback for reducing lock contention.
 	 */
 	if ((searchdir->v_mount->mnt_iflag & IMNT_SHRLOOKUP) != 0 &&
 	    (cnp->cn_nameiop == LOOKUP || (cnp->cn_flags & ISLASTCN) == 0)) {
 	    	lktype = LK_SHARED;
 	} else {
 		lktype = LK_EXCLUSIVE;
+	}
 	/*
 	 * We now have a segment name to search for, and a directory to search.
 	 * Our vnode state here is that "searchdir" is held.
 	 */
 unionlookup:
 	foundobj = NULL;
 	if (!searchdir_locked) {
 		vn_lock(searchdir, lktype | LK_RETRY);
 		searchdir_locked = true;
+	}
 	error = VOP_LOOKUP(searchdir, &foundobj, cnp);
 	if (error != 0) {
 		KASSERTMSG((foundobj == NULL),
 		    "leaf `%s' should be empty but is %p",
 		    cnp->cn_nameptr, foundobj);
 #ifdef NAMEI_DIAGNOSTIC
 		printf("not found\n");
 #endif /* NAMEI_DIAGNOSTIC */
 		/*
 		 * If ENOLCK, the file system needs us to retry the lookup
 		 * with an exclusive lock.  It's likely nothing was found in
 		 * cache and/or modifications need to be made.
 		 */
 		if (error == ENOLCK) {
 			KASSERT(VOP_ISLOCKED(searchdir) == LK_SHARED);
 			KASSERT(searchdir_locked);
 			if (vn_lock(searchdir, LK_UPGRADE | LK_NOWAIT)) {
 				VOP_UNLOCK(searchdir);
 				searchdir_locked = false;
+			}
 			lktype = LK_EXCLUSIVE;
 			goto unionlookup;
+		}
 		if ((error == ENOENT) &&
 		    (searchdir->v_vflag & VV_ROOT) &&
 		    (searchdir->v_mount->mnt_flag & MNT_UNION)) {
 			tmpvn = searchdir;
 			searchdir = searchdir->v_mount->mnt_vnodecovered;
 			vref(searchdir);
 			vput(tmpvn);
 			searchdir_locked = false;
 			*newsearchdir_ret = searchdir;
 			goto unionlookup;
+		}
 		if (error != EJUSTRETURN)
 			goto done;
 		/*
 		 * If this was not the last component, or there were trailing
 		 * slashes, and we are not going to create a directory,
 		 * then the name must exist.
 		 */
 		if ((cnp->cn_flags & (REQUIREDIR | CREATEDIR)) == REQUIREDIR) {
 			error = ENOENT;
 			goto done;
+		}
 		/*
 		 * If creating and at end of pathname, then can consider
 		 * allowing file to be created.
 		 */
 		if (state->rdonly) {
 			error = EROFS;
 			goto done;
+		}
 		/*
 		 * We return success and a NULL foundobj to indicate
 		 * that the entry doesn't currently exist, leaving a
 		 * pointer to the (normally, locked) directory vnode
 		 * as searchdir.
 		 */
 		*foundobj_ret = NULL;
 		error = 0;
 		goto done;
+	}
 #ifdef NAMEI_DIAGNOSTIC
 	printf("found\n");
 #endif /* NAMEI_DIAGNOSTIC */
 	/*
 	 * Take into account any additional components consumed by the
 	 * underlying filesystem.  This will include any trailing slashes after
 	 * the last component consumed.
 	 */
 	if (cnp->cn_consume > 0) {
 		ndp->ni_pathlen -= cnp->cn_consume - state->slashes;
 		ndp->ni_next += cnp->cn_consume - state->slashes;
 		cnp->cn_consume = 0;
 		if (ndp->ni_next[0] == '\0')
 			cnp->cn_flags |= ISLASTCN;
+	}
 	/* Unlock, unless the caller needs the parent locked. */
 	if (searchdir != NULL) {
 		KASSERT(searchdir_locked);
 		if ((cnp->cn_flags & (ISLASTCN | LOCKPARENT)) !=
 		    (ISLASTCN | LOCKPARENT)) {
 		    	VOP_UNLOCK(searchdir);
 		    	searchdir_locked = false;
+		}
 	} else {
 		KASSERT(!searchdir_locked);
+	}
 	*foundobj_ret = foundobj;
 	error = 0;
 done:
 	*newsearchdir_locked_ret = searchdir_locked;
 	return error;
+}
 /*
  * Parse out the first path name component that we need to to consider.
+ *
  * While doing this, attempt to use the name cache to fast-forward through
  * as many "easy" to find components of the path as possible.
+ *
  * We use the namecache's node locks to form a chain, and avoid as many
  * vnode references and locks as possible.  In the ideal case, only the
  * final vnode will have its reference count adjusted and lock taken.
  */
 static int
 lookup_fastforward(struct namei_state *state, struct vnode **searchdir_ret,
 		   struct vnode **foundobj_ret)
+{
 	struct componentname *cnp = state->cnp;
 	struct nameidata *ndp = state->ndp;
 	krwlock_t *plock;
 	struct vnode *foundobj, *searchdir;
 	int error, error2;
 	size_t oldpathlen;
 	const char *oldnameptr;
 	/*
 	 * Eat as many path name components as possible before giving up and
 	 * letting lookup_once() handle it.  Remember the starting point in
 	 * case we can't get vnode references and need to roll back.
 	 */
 	plock = NULL;
 	searchdir = *searchdir_ret;
 	oldnameptr = cnp->cn_nameptr;
 	oldpathlen = ndp->ni_pathlen;
 	for (;;) {
 		foundobj = NULL;
 		/*
 		 * Get the next component name.  There should be no slashes
 		 * here, and we shouldn't have looped around if we were
 		 * done.
 		 */
 		KASSERT(cnp->cn_nameptr[0] != '/');
 		KASSERT(cnp->cn_nameptr[0] != '\0');
 		if ((error = lookup_parsepath(state)) != 0) {
 			break;
+		}
 		/*
-		 * Can't deal with dotdot lookups, because it means lock
+		 * Can't deal with DOTDOT lookups if NOCROSSMOUNT or the
-		 * order reversal, and there are checks in lookup_once()
+		 * lookup is chrooted.
 		 * that need to be made.  Also check for missing mountpoints.
 		 */
-		if ((cnp->cn_flags & ISDOTDOT) != 0 ||
+		if ((cnp->cn_flags & ISDOTDOT) != 0) {
-		    searchdir->v_mount == NULL) {
+			if ((searchdir->v_vflag & VV_ROOT) != 0 &&
-			error = EOPNOTSUPP;
+			    (cnp->cn_flags & NOCROSSMOUNT)) {
-			break;
+			    	error = EOPNOTSUPP;
 				break;
+			}
 			if (ndp->ni_rootdir != rootvnode) {
 			    	error = EOPNOTSUPP;
 				break;
+			}
+		}
 		/*
 		 * Can't deal with last component when modifying; this needs
 		 * searchdir locked and VOP_LOOKUP() called (which can and
 		 * does modify state, despite the name).
 		 */
 		if ((cnp->cn_flags & ISLASTCN) != 0) {
 			if (cnp->cn_nameiop != LOOKUP ||
 			    (cnp->cn_flags & LOCKPARENT) != 0) {
 				error = EOPNOTSUPP;
 				break;
+			}
+		}
 		/* Can't deal with -o union lookups. */
 		if ((searchdir->v_vflag & VV_ROOT) != 0 &&
 		    (searchdir->v_mount->mnt_flag & MNT_UNION) != 0) {
 		    	error = EOPNOTSUPP;
 		    	break;
 		/*
 		 * Good, now look for it in cache.  cache_lookup_linked()
 		 * will fail if there's nothing there, or if there's no
 		 * ownership info for the directory, or if the user doesn't
 		 * have permission to look up files in this directory.
 		 */
 		if (!cache_lookup_linked(searchdir, cnp->cn_nameptr,
 		    cnp->cn_namelen, &foundobj, &plock, cnp->cn_cred)) {
 			error = EOPNOTSUPP;
 			break;
+		}
 		KASSERT(plock != NULL && rw_lock_held(plock));
-		/* Scored a hit.  Negative is good too (ENOENT). */
+		/*
 		 * Scored a hit.  Negative is good too (ENOENT).  If there's
 		 * a '-o union' mount here, punt and let lookup_once() deal
 		 * with it.
 		 */
 		if (foundobj == NULL) {
-			error = ENOENT;
+			if ((searchdir->v_vflag & VV_ROOT) != 0 &&
 			    (searchdir->v_mount->mnt_flag & MNT_UNION) != 0) {
 			    	error = EOPNOTSUPP;
 			} else {
 				error = ENOENT;
+			}
 			break;
+		}
 		/*
 		 * Stop and get a hold on the vnode if there's something
 		 * that can't be handled here:
+		 *
 		 * - we've reached the last component.
 		 * - or encountered a mount point that needs to be crossed.
 		 * - or encountered something other than a directory.
 		 */
 		if ((cnp->cn_flags & ISLASTCN) != 0 ||
 		    foundobj->v_type != VDIR ||
 		    (foundobj->v_type == VDIR &&
 		    foundobj->v_mountedhere != NULL)) {
 		    	mutex_enter(foundobj->v_interlock);
 			error = vcache_tryvget(foundobj);
 			/* v_interlock now unheld */
 			if (error != 0) {
 				foundobj = NULL;
 				error = EOPNOTSUPP;
+			}
 			break;
+		}
 		/*
 		 * Otherwise, we're still in business.  Set the found VDIR
 		 * vnode as the search dir for the next component and
 		 * continue on to it.
 		 */
 		cnp->cn_nameptr = ndp->ni_next;
 		searchdir = foundobj;
+	}
 	/*
 	 * If we ended up with a new search dir, ref it before dropping the
 	 * namecache's lock.  The lock prevents both searchdir and foundobj
 	 * from disappearing.  If we can't ref the new searchdir, we have a
 	 * bit of a problem.  Roll back the fastforward to the beginning and
 	 * let lookup_once() take care of it.
 	 */
 	if (searchdir != *searchdir_ret) {
 		mutex_enter(searchdir->v_interlock);
 		error2 = vcache_tryvget(searchdir);
 		/* v_interlock now unheld */
 		KASSERT(plock != NULL);
 		rw_exit(plock);
 		if (__predict_true(error2 == 0)) {
 			/* Returning new searchdir, and maybe new foundobj. */
 			vrele(*searchdir_ret);
 			*searchdir_ret = searchdir;
 		} else {
 			/* Returning nothing. */
 			if (foundobj != NULL) {
 				vrele(foundobj);
 				foundobj = NULL;
+			}
 			cnp->cn_nameptr = oldnameptr;
 			ndp->ni_pathlen = oldpathlen;
 			error = lookup_parsepath(state);
 			if (error == 0) {
 				error = EOPNOTSUPP;
+			}
+		}
 	} else if (plock != NULL) {
 		/* Drop any namecache lock still held. */
 		rw_exit(plock);
+	}
 	KASSERT(error == 0 ? foundobj != NULL : foundobj == NULL);
 	*foundobj_ret = foundobj;
 	return error;
+}
 //////////////////////////////
 /*
  * Do a complete path search from a single root directory.
  * (This is called up to twice if TRYEMULROOT is in effect.)
  */
 static int
 namei_oneroot(struct namei_state *state,
 	 int neverfollow, int inhibitmagic, int isnfsd)
+{
 	struct nameidata *ndp = state->ndp;
 	struct componentname *cnp = state->cnp;
 	struct vnode *searchdir, *foundobj;
 	bool searchdir_locked = false;
 	int error;
 	error = namei_start(state, isnfsd, &searchdir);
 	if (error) {
 		ndp->ni_dvp = NULL;
 		ndp->ni_vp = NULL;
 		return error;
+	}
 	KASSERT(searchdir->v_type == VDIR);
 	/*
 	 * Setup: break out flag bits into variables.
 	 */
 	state->docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE;
 	if (cnp->cn_nameiop == DELETE)
 		state->docache = 0;
 	state->rdonly = cnp->cn_flags & RDONLY;
 	/*
 	 * Keep going until we run out of path components.
 	 */
 	cnp->cn_nameptr = ndp->ni_pnbuf;
 	/* drop leading slashes (already used them to choose startdir) */
 	while (cnp->cn_nameptr[0] == '/') {
 		cnp->cn_nameptr++;
 		ndp->ni_pathlen--;
+	}
 	/* was it just "/"? */
 	if (cnp->cn_nameptr[0] == '\0') {
 		foundobj = searchdir;
 		searchdir = NULL;
 		cnp->cn_flags |= ISLASTCN;
 		/* bleh */
 		goto skiploop;
+	}
 	for (;;) {
 		KASSERT(searchdir != NULL);
 		KASSERT(!searchdir_locked);
 		/*
 		 * Parse out the first path name component that we need to
 		 * to consider.  While doing this, attempt to use the name
 		 * cache to fast-forward through as many "easy" to find
 		 * components of the path as possible.
 		 */
 		error = lookup_fastforward(state, &searchdir, &foundobj);
 		/*
 		 * If we didn't get a good answer from the namecache, then
 		 * go directly to the file system.
 		 */
 		if (error == EOPNOTSUPP) {
 			error = lookup_once(state, searchdir, &searchdir,
 			    &foundobj, &searchdir_locked);
+		}
 		/*
 		 * If the vnode we found is mounted on, then cross the mount
 		 * and get the root vnode in foundobj.  If this encounters
 		 * an error, it will dispose of foundobj, but searchdir is
 		 * untouched.
 		 */
 		if (error == 0 && foundobj != NULL &&
 		    foundobj->v_type == VDIR &&
 		    foundobj->v_mountedhere != NULL &&
 		    (cnp->cn_flags & NOCROSSMOUNT) == 0) {
 		    	error = lookup_crossmount(state, &searchdir,
 		    	    &foundobj, &searchdir_locked);
+		}
 		if (error) {
 			if (searchdir != NULL) {
 				if (searchdir_locked) {
 					searchdir_locked = false;
 					vput(searchdir);
 				} else {
 					vrele(searchdir);
+				}
+			}
 			ndp->ni_dvp = NULL;
 			ndp->ni_vp = NULL;
 			/*
 			 * Note that if we're doing TRYEMULROOT we can
 			 * retry with the normal root. Where this is
 			 * currently set matches previous practice,
 			 * but the previous practice didn't make much
 			 * sense and somebody should sit down and
 			 * figure out which cases should cause retry
 			 * and which shouldn't. XXX.
 			 */
 			state->attempt_retry = 1;
 			return (error);
+		}
 		if (foundobj == NULL) {
 			/*
 			 * Success with no object returned means we're
 			 * creating something and it isn't already
 			 * there. Break out of the main loop now so
 			 * the code below doesn't have to test for
 			 * foundobj == NULL.
 			 */
 			/* lookup_once can't have dropped the searchdir */
 			KASSERT(searchdir != NULL);
 			break;
+		}
 		/*
 		 * Check for symbolic link. If we've reached one,
 		 * follow it, unless we aren't supposed to. Back up
 		 * over any slashes that we skipped, as we will need
 		 * them again.
 		 */
 		if (namei_atsymlink(state, foundobj)) {
 			/* Don't need searchdir locked any more. */
 			if (searchdir_locked) {
 				searchdir_locked = false;
 				VOP_UNLOCK(searchdir);
+			}
 			ndp->ni_pathlen += state->slashes;
 			ndp->ni_next -= state->slashes;
 			if (neverfollow) {
 				error = EINVAL;
 			} else if (searchdir == NULL) {
 				/*
 				 * dholland 20160410: lookup_once only
 				 * drops searchdir if it crossed a
 				 * mount point. Therefore, if we get
 				 * here it means we crossed a mount
 				 * point to a mounted filesystem whose
 				 * root vnode is a symlink. In theory
 				 * we could continue at this point by
 				 * using the pre-crossing searchdir
 				 * (e.g. just take out an extra
 				 * reference on it before calling
 				 * lookup_once so we still have it),
 				 * but this will make an ugly mess and
 				 * it should never happen in practice
 				 * as only badly broken filesystems
 				 * have non-directory root vnodes. (I
 				 * have seen this sort of thing with
 				 * NFS occasionally but even then it
 				 * means something's badly wrong.)
 				 */
 				error = ENOTDIR;
 			} else {
 				/*
 				 * dholland 20110410: if we're at a
 				 * union mount it might make sense to
 				 * use the top of the union stack here
 				 * rather than the layer we found the
 				 * symlink in. (FUTURE)
 				 */
 				error = namei_follow(state, inhibitmagic,
 						     searchdir, foundobj,
 						     &searchdir);
+			}
 			if (error) {
 				KASSERT(searchdir != foundobj);
 				if (searchdir != NULL) {
 					vrele(searchdir);
+				}
 				vrele(foundobj);
 				ndp->ni_dvp = NULL;
 				ndp->ni_vp = NULL;
 				return error;
+			}
 			vrele(foundobj);
 			foundobj = NULL;
 			/*
 			 * If we followed a symlink to `/' and there
 			 * are no more components after the symlink,
 			 * we're done with the loop and what we found
 			 * is the searchdir.
 			 */
 			if (cnp->cn_nameptr[0] == '\0') {
 				KASSERT(searchdir != NULL);
 				foundobj = searchdir;
 				searchdir = NULL;
 				cnp->cn_flags |= ISLASTCN;
 				break;
+			}
 			continue;
+		}
 		/*
 		 * Not a symbolic link.
+		 *
 		 * Check for directory, if the component was
 		 * followed by a series of slashes.
 		 */
 		if ((foundobj->v_type != VDIR) &&
 		    (cnp->cn_flags & REQUIREDIR)) {
 			KASSERT(foundobj != searchdir);
 			if (searchdir) {
 				if (searchdir_locked) {
 					searchdir_locked = false;
 					vput(searchdir);
 				} else {
 					vrele(searchdir);
+				}
 			} else {
 				KASSERT(!searchdir_locked);
+			}
 			vrele(foundobj);
 			ndp->ni_dvp = NULL;
 			ndp->ni_vp = NULL;
 			state->attempt_retry = 1;
 			return ENOTDIR;
+		}
 		/*
 		 * Stop if we've reached the last component.
 		 */
 		if (cnp->cn_flags & ISLASTCN) {
 			break;
+		}
 		/*
 		 * Continue with the next component.
 		 */
 		cnp->cn_nameptr = ndp->ni_next;
 		if (searchdir != NULL) {
 			if (searchdir_locked) {
 				searchdir_locked = false;
 				vput(searchdir);
 			} else {
 				vrele(searchdir);
+			}
+		}
 		searchdir = foundobj;
 		foundobj = NULL;
+	}
 	KASSERT((cnp->cn_flags & LOCKPARENT) == 0 || searchdir == NULL ||
 	    VOP_ISLOCKED(searchdir) == LK_EXCLUSIVE);
  skiploop:
 	if (foundobj != NULL) {
 		if (foundobj == ndp->ni_erootdir) {
 			/*
 			 * We are about to return the emulation root.
 			 * This isn't a good idea because code might
 			 * repeatedly lookup ".." until the file
 			 * matches that returned for "/" and loop
 			 * forever.  So convert it to the real root.
 			 */
 			if (searchdir != NULL) {
 				if (searchdir_locked) {
 					vput(searchdir);
 					searchdir_locked = false;
 				} else {
 					vrele(searchdir);
+				}
 				searchdir = NULL;
+			}
 			vrele(foundobj);
 			foundobj = ndp->ni_rootdir;
 			vref(foundobj);
+		}
 		/*
 		 * If the caller requested the parent node (i.e. it's
 		 * a CREATE, DELETE, or RENAME), and we don't have one
 		 * (because this is the root directory, or we crossed
 		 * a mount point), then we must fail.
 		 */
 		if (cnp->cn_nameiop != LOOKUP &&
 		    (searchdir == NULL ||
 		     searchdir->v_mount != foundobj->v_mount)) {
 			if (searchdir) {
 				if (searchdir_locked) {
 					vput(searchdir);
 					searchdir_locked = false;
 				} else {
 					vrele(searchdir);
+				}
 				searchdir = NULL;
+			}
 			vrele(foundobj);
 			foundobj = NULL;
 			ndp->ni_dvp = NULL;
 			ndp->ni_vp = NULL;
 			state->attempt_retry = 1;
 			switch (cnp->cn_nameiop) {
 			    case CREATE:
 				return EEXIST;
 			    case DELETE:
 			    case RENAME:
 				return EBUSY;
 			    default:
 				break;
+			}
 			panic("Invalid nameiop\n");
+		}
 		/*
 		 * Disallow directory write attempts on read-only lookups.
 		 * Prefers EEXIST over EROFS for the CREATE case.
 		 */
 		if (state->rdonly &&
 		    (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
 			if (searchdir) {
 				if (searchdir_locked) {
 					vput(searchdir);
 					searchdir_locked = false;
 				} else {
 					vrele(searchdir);
+				}
 				searchdir = NULL;
+			}
 			vrele(foundobj);
 			foundobj = NULL;
 			ndp->ni_dvp = NULL;
 			ndp->ni_vp = NULL;
 			state->attempt_retry = 1;
 			return EROFS;
+		}
 		/* Lock the leaf node if requested. */
 		if ((cnp->cn_flags & (LOCKLEAF | LOCKPARENT)) == LOCKPARENT &&
 		    searchdir == foundobj) {
 			/*
 			 * Note: if LOCKPARENT but not LOCKLEAF is
 			 * set, and searchdir == foundobj, this code
 			 * necessarily unlocks the parent as well as
 			 * the leaf. That is, just because you specify
 			 * LOCKPARENT doesn't mean you necessarily get
 			 * a locked parent vnode. The code in
 			 * vfs_syscalls.c, and possibly elsewhere,
 			 * that uses this combination "knows" this, so
 			 * it can't be safely changed. Feh. XXX
 			 */
 			KASSERT(searchdir_locked);
 		    	VOP_UNLOCK(searchdir);
 		    	searchdir_locked = false;
 		} else if ((cnp->cn_flags & LOCKLEAF) != 0 &&
 		    (searchdir != foundobj ||
 		    (cnp->cn_flags & LOCKPARENT) == 0)) {
 			const int lktype = (cnp->cn_flags & LOCKSHARED) != 0 ?
 			    LK_SHARED : LK_EXCLUSIVE;
 			vn_lock(foundobj, lktype | LK_RETRY);
+		}
+	}
 	/*
 	 * Done.
 	 */
 	/*
 	 * If LOCKPARENT is not set, the parent directory isn't returned.
 	 */
 	if ((cnp->cn_flags & LOCKPARENT) == 0 && searchdir != NULL) {
 		vrele(searchdir);
 		searchdir = NULL;
+	}
 	ndp->ni_dvp = searchdir;
 	ndp->ni_vp = foundobj;
 	return 0;
+}
 /*
  * Do namei; wrapper layer that handles TRYEMULROOT.
  */
 static int
 namei_tryemulroot(struct namei_state *state,
 	 int neverfollow, int inhibitmagic, int isnfsd)
+{
 	int error;
 	struct nameidata *ndp = state->ndp;
 	struct componentname *cnp = state->cnp;
 	const char *savepath = NULL;
 	KASSERT(cnp == &ndp->ni_cnd);
 	if (cnp->cn_flags & TRYEMULROOT) {
 		savepath = pathbuf_stringcopy_get(ndp->ni_pathbuf);
+	}
     emul_retry:
 	state->attempt_retry = 0;
 	error = namei_oneroot(state, neverfollow, inhibitmagic, isnfsd);
 	if (error) {
 		/*
 		 * Once namei has started up, the existence of ni_erootdir
 		 * tells us whether we're working from an emulation root.
 		 * The TRYEMULROOT flag isn't necessarily authoritative.
 		 */
 		if (ndp->ni_erootdir != NULL && state->attempt_retry) {
 			/* Retry the whole thing using the normal root */
 			cnp->cn_flags &= ~TRYEMULROOT;
 			state->attempt_retry = 0;
 			/* kinda gross */
 			strcpy(ndp->ni_pathbuf->pb_path, savepath);
 			pathbuf_stringcopy_put(ndp->ni_pathbuf, savepath);
 			savepath = NULL;
 			goto emul_retry;
+		}
+	}
 	if (savepath != NULL) {
 		pathbuf_stringcopy_put(ndp->ni_pathbuf, savepath);
+	}
 	return error;
+}
 /*
  * External interface.
  */
 int
 namei(struct nameidata *ndp)
+{
 	struct namei_state state;
 	int error;
 	namei_init(&state, ndp);
 	error = namei_tryemulroot(&state,
 /*!neverfollow*/, 0/*!inhibitmagic*/,
 /*isnfsd*/);
 	namei_cleanup(&state);
 	if (error) {
 		/* make sure no stray refs leak out */
 		KASSERT(ndp->ni_dvp == NULL);
 		KASSERT(ndp->ni_vp == NULL);
+	}
 	return error;
+}
 ////////////////////////////////////////////////////////////
 /*
  * External interface used by nfsd. This is basically different from
  * namei only in that it has the ability to pass in the "current
  * directory", and uses an extra flag "neverfollow" for which there's
  * no physical flag defined in namei.h. (There used to be a cut&paste
  * copy of about half of namei in nfsd to allow these minor
  * adjustments to exist.)
+ *
  * XXX: the namei interface should be adjusted so nfsd can just use
  * ordinary namei().
  */
 int
 lookup_for_nfsd(struct nameidata *ndp, struct vnode *forcecwd, int neverfollow)
+{
 	struct namei_state state;
 	int error;
 	KASSERT(ndp->ni_atdir == NULL);
 	ndp->ni_atdir = forcecwd;
 	namei_init(&state, ndp);
 	error = namei_tryemulroot(&state,
 				  neverfollow, 1/*inhibitmagic*/, 1/*isnfsd*/);
 	namei_cleanup(&state);
 	if (error) {
 		/* make sure no stray refs leak out */
 		KASSERT(ndp->ni_dvp == NULL);
 		KASSERT(ndp->ni_vp == NULL);
+	}
 	return error;
+}
 /*
  * A second external interface used by nfsd. This turns out to be a
  * single lookup used by the WebNFS code (ha!) to get "index.html" or
  * equivalent when asked for a directory. It should eventually evolve
  * into some kind of namei_once() call; for the time being it's kind
  * of a mess. XXX.
+ *
  * dholland 20110109: I don't think it works, and I don't think it
  * worked before I started hacking and slashing either, and I doubt
  * anyone will ever notice.
  */
 /*
  * Internals. This calls lookup_once() after setting up the assorted
  * pieces of state the way they ought to be.
  */
 static int
 do_lookup_for_nfsd_index(struct namei_state *state)
+{
 	int error = 0;
 	struct componentname *cnp = state->cnp;
 	struct nameidata *ndp = state->ndp;
 	struct vnode *startdir;
 	struct vnode *foundobj;
 	bool startdir_locked;
 	const char *cp;			/* pointer into pathname argument */
 	KASSERT(cnp == &ndp->ni_cnd);
 	startdir = state->ndp->ni_atdir;
 	cnp->cn_nameptr = ndp->ni_pnbuf;
 	state->docache = 1;
 	state->rdonly = cnp->cn_flags & RDONLY;
 	ndp->ni_dvp = NULL;
 	cnp->cn_consume = 0;
 	cnp->cn_namelen = namei_getcomponent(cnp->cn_nameptr);
 	cp = cnp->cn_nameptr + cnp->cn_namelen;
 	KASSERT(cnp->cn_namelen <= KERNEL_NAME_MAX);
 	ndp->ni_pathlen -= cnp->cn_namelen;
 	ndp->ni_next = cp;
 	state->slashes = 0;
 	cnp->cn_flags &= ~REQUIREDIR;
 	cnp->cn_flags |= MAKEENTRY|ISLASTCN;
 	if (cnp->cn_namelen == 2 &&
 	    cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
 		cnp->cn_flags |= ISDOTDOT;
 	else
 		cnp->cn_flags &= ~ISDOTDOT;
 	/*
 	 * Because lookup_once can change the startdir, we need our
 	 * own reference to it to avoid consuming the caller's.
 	 */
 	vref(startdir);
 	error = lookup_once(state, startdir, &startdir, &foundobj,
 	    &startdir_locked);
 	KASSERT((cnp->cn_flags & LOCKPARENT) == 0);
 	if (startdir_locked) {
 		VOP_UNLOCK(startdir);
 		startdir_locked = false;
+	}
 	/*
 	 * If the vnode we found is mounted on, then cross the mount and get
 	 * the root vnode in foundobj.  If this encounters an error, it will
 	 * dispose of foundobj, but searchdir is untouched.
 	 */
 	if (error == 0 && foundobj != NULL &&
 	    foundobj->v_type == VDIR &&
 	    foundobj->v_mountedhere != NULL &&
 	    (cnp->cn_flags & NOCROSSMOUNT) == 0) {
 		error = lookup_crossmount(state, &startdir, &foundobj,
 		    &startdir_locked);
+	}
 	/* Now toss startdir and see if we have an error. */
 	if (startdir != NULL)
 		vrele(startdir);
 	if (error)
 		foundobj = NULL;
 	else if (foundobj != NULL && (cnp->cn_flags & LOCKLEAF) != 0)
 		vn_lock(foundobj, LK_EXCLUSIVE | LK_RETRY);
 	ndp->ni_vp = foundobj;
 	return (error);
+}
 /*
  * External interface. The partitioning between this function and the
  * above isn't very clear - the above function exists mostly so code
  * that uses "state->" can be shuffled around without having to change
  * it to "state.".
  */
 int
 lookup_for_nfsd_index(struct nameidata *ndp, struct vnode *startdir)
+{
 	struct namei_state state;
 	int error;
 	KASSERT(ndp->ni_atdir == NULL);
 	ndp->ni_atdir = startdir;
 	/*
 	 * Note: the name sent in here (is not|should not be) allowed
 	 * to contain a slash.
 	 */
 	if (strlen(ndp->ni_pathbuf->pb_path) > KERNEL_NAME_MAX) {
 		return ENAMETOOLONG;
+	}
 	if (strchr(ndp->ni_pathbuf->pb_path, '/')) {
 		return EINVAL;
+	}
 	ndp->ni_pathlen = strlen(ndp->ni_pathbuf->pb_path) + 1;
 	ndp->ni_pnbuf = NULL;
 	ndp->ni_cnd.cn_nameptr = NULL;
 	namei_init(&state, ndp);
 	error = do_lookup_for_nfsd_index(&state);
 	namei_cleanup(&state);
 	return error;
+}
 ////////////////////////////////////////////////////////////
 /*
  * Reacquire a path name component.
  * dvp is locked on entry and exit.
  * *vpp is locked on exit unless it's NULL.
  */
 int
 relookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp, int dummy)
+{
 	int rdonly;			/* lookup read-only flag bit */
 	int error = 0;
 #ifdef DEBUG
 	size_t newlen;			/* DEBUG: check name len */
 	const char *cp;			/* DEBUG: check name ptr */
 #endif /* DEBUG */
 	(void)dummy;
 	/*
 	 * Setup: break out flag bits into variables.
 	 */
 	rdonly = cnp->cn_flags & RDONLY;
 	/*
 	 * Search a new directory.
+	 *
 	 * The cn_hash value is for use by vfs_cache.
 	 * The last component of the filename is left accessible via
 	 * cnp->cn_nameptr for callers that need the name. Callers needing
 	 * the name set the SAVENAME flag. When done, they assume
 	 * responsibility for freeing the pathname buffer.
 	 */
 #ifdef DEBUG
 #if 0
 	cp = NULL;
 	newhash = namei_hash(cnp->cn_nameptr, &cp);
 	if ((uint32_t)newhash != (uint32_t)cnp->cn_hash)
 		panic("relookup: bad hash");
 #endif
 	newlen = namei_getcomponent(cnp->cn_nameptr);
 	if (cnp->cn_namelen != newlen)
 		panic("relookup: bad len");
 	cp = cnp->cn_nameptr + cnp->cn_namelen;
 	while (*cp == '/')
 		cp++;
 	if (*cp != 0)
 		panic("relookup: not last component");
 #endif /* DEBUG */
 	/*
 	 * Check for degenerate name (e.g. / or "")
 	 * which is a way of talking about a directory,
 	 * e.g. like "/." or ".".
 	 */
 	if (cnp->cn_nameptr[0] == '\0')
 		panic("relookup: null name");
 	if (cnp->cn_flags & ISDOTDOT)
 		panic("relookup: lookup on dot-dot");
 	/*
 	 * We now have a segment name to search for, and a directory to search.
 	 */
 	*vpp = NULL;
 	error = VOP_LOOKUP(dvp, vpp, cnp);
 	if ((error) != 0) {
 		KASSERTMSG((*vpp == NULL),
 		    "leaf `%s' should be empty but is %p",
 		    cnp->cn_nameptr, *vpp);
 		if (error != EJUSTRETURN)
 			goto bad;
+	}
 	/*
 	 * Check for symbolic link
 	 */
 	KASSERTMSG((*vpp == NULL || (*vpp)->v_type != VLNK ||
 		(cnp->cn_flags & FOLLOW) == 0),
 	    "relookup: symlink found");
 	/*
 	 * Check for read-only lookups.
 	 */
 	if (rdonly && cnp->cn_nameiop != LOOKUP) {
 		error = EROFS;
 		if (*vpp) {
 			vrele(*vpp);
+		}
 		goto bad;
+	}
 	/*
 	 * Lock result.
 	 */
 	if (*vpp && *vpp != dvp) {
 		error = vn_lock(*vpp, LK_EXCLUSIVE);
 		if (error != 0) {
 			vrele(*vpp);
 			goto bad;
+		}
+	}
 	return (0);
 bad:
 	*vpp = NULL;
 	return (error);
+}
 /*
  * namei_simple - simple forms of namei.
+ *
  * These are wrappers to allow the simple case callers of namei to be
  * left alone while everything else changes under them.
  */
 /* Flags */
 struct namei_simple_flags_type {
 	int dummy;
 };
 static const struct namei_simple_flags_type ns_nn, ns_nt, ns_fn, ns_ft;
 const namei_simple_flags_t NSM_NOFOLLOW_NOEMULROOT = &ns_nn;
 const namei_simple_flags_t NSM_NOFOLLOW_TRYEMULROOT = &ns_nt;
 const namei_simple_flags_t NSM_FOLLOW_NOEMULROOT = &ns_fn;
 const namei_simple_flags_t NSM_FOLLOW_TRYEMULROOT = &ns_ft;
 static
 int
 namei_simple_convert_flags(namei_simple_flags_t sflags)
+{
 	if (sflags == NSM_NOFOLLOW_NOEMULROOT)
 		return NOFOLLOW | 0;
 	if (sflags == NSM_NOFOLLOW_TRYEMULROOT)
 		return NOFOLLOW | TRYEMULROOT;
 	if (sflags == NSM_FOLLOW_NOEMULROOT)
 		return FOLLOW | 0;
 	if (sflags == NSM_FOLLOW_TRYEMULROOT)
 		return FOLLOW | TRYEMULROOT;
 	panic("namei_simple_convert_flags: bogus sflags\n");
 	return 0;
+}
 int
 namei_simple_kernel(const char *path, namei_simple_flags_t sflags,
 	struct vnode **vp_ret)
+{
 	return nameiat_simple_kernel(NULL, path, sflags, vp_ret);
+}
 int
 nameiat_simple_kernel(struct vnode *dvp, const char *path,
 	namei_simple_flags_t sflags, struct vnode **vp_ret)
+{
 	struct nameidata nd;
 	struct pathbuf *pb;
 	int err;
 	pb = pathbuf_create(path);
 	if (pb == NULL) {
 		return ENOMEM;
+	}
 	NDINIT(&nd,
 		LOOKUP,
 		namei_simple_convert_flags(sflags),
 		pb);
 	if (dvp != NULL)
 		NDAT(&nd, dvp);
 	err = namei(&nd);
 	if (err != 0) {
 		pathbuf_destroy(pb);
 		return err;
+	}
 	*vp_ret = nd.ni_vp;
 	pathbuf_destroy(pb);
 	return 0;
+}
 int
 namei_simple_user(const char *path, namei_simple_flags_t sflags,
 	struct vnode **vp_ret)
+{
 	return nameiat_simple_user(NULL, path, sflags, vp_ret);
+}
 int
 nameiat_simple_user(struct vnode *dvp, const char *path,
 	namei_simple_flags_t sflags, struct vnode **vp_ret)
+{
 	struct pathbuf *pb;
 	struct nameidata nd;
 	int err;
 	err = pathbuf_copyin(path, &pb);
 	if (err) {
 		return err;
+	}
 	NDINIT(&nd,
 		LOOKUP,
 		namei_simple_convert_flags(sflags),
 		pb);
 	if (dvp != NULL)
 		NDAT(&nd, dvp);
 	err = namei(&nd);
 	if (err != 0) {
 		pathbuf_destroy(pb);
 		return err;
+	}
 	*vp_ret = nd.ni_vp;
 	pathbuf_destroy(pb);
 	return 0;
+}