Home | History | Annotate | Line # | Download | only in kern
vfs_cache.c revision 1.54
      1 /*	$NetBSD: vfs_cache.c,v 1.54 2003/09/01 12:13:55 yamt Exp $	*/
      2 
      3 /*
      4  * Copyright (c) 1989, 1993
      5  *	The Regents of the University of California.  All rights reserved.
      6  *
      7  * Redistribution and use in source and binary forms, with or without
      8  * modification, are permitted provided that the following conditions
      9  * are met:
     10  * 1. Redistributions of source code must retain the above copyright
     11  *    notice, this list of conditions and the following disclaimer.
     12  * 2. Redistributions in binary form must reproduce the above copyright
     13  *    notice, this list of conditions and the following disclaimer in the
     14  *    documentation and/or other materials provided with the distribution.
     15  * 3. Neither the name of the University nor the names of its contributors
     16  *    may be used to endorse or promote products derived from this software
     17  *    without specific prior written permission.
     18  *
     19  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
     20  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     21  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     22  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
     23  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     24  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     25  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     26  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     27  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     28  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     29  * SUCH DAMAGE.
     30  *
     31  *	@(#)vfs_cache.c	8.3 (Berkeley) 8/22/94
     32  */
     33 
     34 #include <sys/cdefs.h>
     35 __KERNEL_RCSID(0, "$NetBSD: vfs_cache.c,v 1.54 2003/09/01 12:13:55 yamt Exp $");
     36 
     37 #include "opt_ddb.h"
     38 #include "opt_revcache.h"
     39 
     40 #include <sys/param.h>
     41 #include <sys/systm.h>
     42 #include <sys/time.h>
     43 #include <sys/mount.h>
     44 #include <sys/vnode.h>
     45 #include <sys/namei.h>
     46 #include <sys/errno.h>
     47 #include <sys/malloc.h>
     48 #include <sys/pool.h>
     49 #include <sys/lock.h>
     50 
     51 /*
     52  * Name caching works as follows:
     53  *
     54  * Names found by directory scans are retained in a cache
     55  * for future reference.  It is managed LRU, so frequently
     56  * used names will hang around.  Cache is indexed by hash value
     57  * obtained from (dvp, name) where dvp refers to the directory
     58  * containing name.
     59  *
     60  * For simplicity (and economy of storage), names longer than
     61  * a maximum length of NCHNAMLEN are not cached; they occur
     62  * infrequently in any case, and are almost never of interest.
     63  *
     64  * Upon reaching the last segment of a path, if the reference
     65  * is for DELETE, or NOCACHE is set (rewrite), and the
     66  * name is located in the cache, it will be dropped.
     67  * The entry is dropped also when it was not possible to lock
     68  * the cached vnode, either because vget() failed or the generation
     69  * number has changed while waiting for the lock.
     70  */
     71 
     72 /*
     73  * Structures associated with name cacheing.
     74  */
     75 LIST_HEAD(nchashhead, namecache) *nchashtbl;
     76 u_long	nchash;				/* size of hash table - 1 */
     77 long	numcache;			/* number of cache entries allocated */
     78 #define	NCHASH(cnp, dvp)	\
     79 	(((cnp)->cn_hash ^ ((uintptr_t)(dvp) >> 3)) & nchash)
     80 
     81 LIST_HEAD(ncvhashhead, namecache) *ncvhashtbl;
     82 u_long	ncvhash;			/* size of hash table - 1 */
     83 #define	NCVHASH(vp)		(((uintptr_t)(vp) >> 3) & ncvhash)
     84 
     85 TAILQ_HEAD(, namecache) nclruhead;		/* LRU chain */
     86 struct	nchstats nchstats;		/* cache effectiveness statistics */
     87 
     88 struct pool namecache_pool;
     89 
     90 MALLOC_DEFINE(M_CACHE, "namecache", "Dynamically allocated cache entries");
     91 
     92 int doingcache = 1;			/* 1 => enable the cache */
     93 
     94 /* A single lock to protect cache insertion, removal and lookup */
     95 static struct simplelock namecache_slock = SIMPLELOCK_INITIALIZER;
     96 
     97 static void cache_remove(struct namecache *);
     98 static void cache_free(struct namecache *);
     99 
    100 static void
    101 cache_remove(struct namecache *ncp)
    102 {
    103 
    104 	LOCK_ASSERT(simple_lock_held(&namecache_slock));
    105 
    106 	ncp->nc_dvp = NULL;
    107 	ncp->nc_vp = NULL;
    108 
    109 	TAILQ_REMOVE(&nclruhead, ncp, nc_lru);
    110 	if (ncp->nc_hash.le_prev != NULL) {
    111 		LIST_REMOVE(ncp, nc_hash);
    112 		ncp->nc_hash.le_prev = NULL;
    113 	}
    114 	if (ncp->nc_vhash.le_prev != NULL) {
    115 		LIST_REMOVE(ncp, nc_vhash);
    116 		ncp->nc_vhash.le_prev = NULL;
    117 	}
    118 	if (ncp->nc_vlist.le_prev != NULL) {
    119 		LIST_REMOVE(ncp, nc_vlist);
    120 		ncp->nc_vlist.le_prev = NULL;
    121 	}
    122 	if (ncp->nc_dvlist.le_prev != NULL) {
    123 		LIST_REMOVE(ncp, nc_dvlist);
    124 		ncp->nc_dvlist.le_prev = NULL;
    125 	}
    126 }
    127 
    128 static void
    129 cache_free(struct namecache *ncp)
    130 {
    131 
    132 	pool_put(&namecache_pool, ncp);
    133 	numcache--; /* XXX MP */
    134 }
    135 
    136 /*
    137  * Look for a the name in the cache. We don't do this
    138  * if the segment name is long, simply so the cache can avoid
    139  * holding long names (which would either waste space, or
    140  * add greatly to the complexity).
    141  *
    142  * Lookup is called with ni_dvp pointing to the directory to search,
    143  * ni_ptr pointing to the name of the entry being sought, ni_namelen
    144  * tells the length of the name, and ni_hash contains a hash of
    145  * the name. If the lookup succeeds, the vnode is locked, stored in ni_vp
    146  * and a status of zero is returned. If the locking fails for whatever
    147  * reason, the vnode is unlocked and the error is returned to caller.
    148  * If the lookup determines that the name does not exist (negative cacheing),
    149  * a status of ENOENT is returned. If the lookup fails, a status of -1
    150  * is returned.
    151  */
    152 int
    153 cache_lookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp)
    154 {
    155 	struct namecache *ncp;
    156 	struct nchashhead *ncpp;
    157 	struct vnode *vp;
    158 	int error;
    159 
    160 	if (!doingcache) {
    161 		cnp->cn_flags &= ~MAKEENTRY;
    162 		*vpp = NULL;
    163 		return (-1);
    164 	}
    165 
    166 	if (cnp->cn_namelen > NCHNAMLEN) {
    167 		/* XXXSMP - updating stats without lock; do we care? */
    168 		nchstats.ncs_long++;
    169 		cnp->cn_flags &= ~MAKEENTRY;
    170 		goto fail;
    171 	}
    172 	ncpp = &nchashtbl[NCHASH(cnp, dvp)];
    173 	simple_lock(&namecache_slock);
    174 	LIST_FOREACH(ncp, ncpp, nc_hash) {
    175 		if (ncp->nc_dvp == dvp &&
    176 		    ncp->nc_nlen == cnp->cn_namelen &&
    177 		    !memcmp(ncp->nc_name, cnp->cn_nameptr, (u_int)ncp->nc_nlen))
    178 			break;
    179 	}
    180 	if (ncp == 0) {
    181 		nchstats.ncs_miss++;
    182 		goto fail_wlock;
    183 	}
    184 	if ((cnp->cn_flags & MAKEENTRY) == 0) {
    185 		nchstats.ncs_badhits++;
    186 		goto remove;
    187 	} else if (ncp->nc_vp == NULL) {
    188 		/*
    189 		 * Restore the ISWHITEOUT flag saved earlier.
    190 		 */
    191 		cnp->cn_flags |= ncp->nc_flags;
    192 		if (cnp->cn_nameiop != CREATE ||
    193 		    (cnp->cn_flags & ISLASTCN) == 0) {
    194 			nchstats.ncs_neghits++;
    195 			/*
    196 			 * Move this slot to end of LRU chain,
    197 			 * if not already there.
    198 			 */
    199 			if (TAILQ_NEXT(ncp, nc_lru) != 0) {
    200 				TAILQ_REMOVE(&nclruhead, ncp, nc_lru);
    201 				TAILQ_INSERT_TAIL(&nclruhead, ncp, nc_lru);
    202 			}
    203 			simple_unlock(&namecache_slock);
    204 			return (ENOENT);
    205 		} else {
    206 			nchstats.ncs_badhits++;
    207 			goto remove;
    208 		}
    209 	}
    210 
    211 	vp = ncp->nc_vp;
    212 
    213 	/*
    214 	 * Move this slot to end of LRU chain, if not already there.
    215 	 */
    216 	if (TAILQ_NEXT(ncp, nc_lru) != 0) {
    217 		TAILQ_REMOVE(&nclruhead, ncp, nc_lru);
    218 		TAILQ_INSERT_TAIL(&nclruhead, ncp, nc_lru);
    219 	}
    220 
    221 	if (vp != dvp)
    222 		simple_lock(&vp->v_interlock);
    223 
    224 	/* Release the name cache mutex while we acquire vnode locks */
    225 	simple_unlock(&namecache_slock);
    226 
    227 #ifdef DEBUG
    228 	/*
    229 	 * since we released namecache_slock,
    230 	 * we can't use this pointer any more.
    231 	 */
    232 	ncp = NULL;
    233 #endif /* DEBUG */
    234 
    235 	if (vp != dvp && __predict_false(vp->v_flag & VXLOCK)) {
    236 		/*
    237 		 * this vnode is being cleaned out.
    238 		 */
    239 		simple_unlock(&vp->v_interlock);
    240 		nchstats.ncs_falsehits++; /* XXX badhits? */
    241 		goto fail;
    242 	}
    243 
    244 	if (vp == dvp) {	/* lookup on "." */
    245 		VREF(dvp);
    246 		error = 0;
    247 	} else if (cnp->cn_flags & ISDOTDOT) {
    248 		VOP_UNLOCK(dvp, 0);
    249 		cnp->cn_flags |= PDIRUNLOCK;
    250 		error = vget(vp, LK_EXCLUSIVE | LK_INTERLOCK);
    251 		/*
    252 		 * If the above vget() succeeded and both LOCKPARENT and
    253 		 * ISLASTCN is set, lock the directory vnode as well.
    254 		 */
    255 		if (!error && (~cnp->cn_flags & (LOCKPARENT|ISLASTCN)) == 0) {
    256 			if ((error = vn_lock(dvp, LK_EXCLUSIVE)) != 0) {
    257 				vput(vp);
    258 				return (error);
    259 			}
    260 			cnp->cn_flags &= ~PDIRUNLOCK;
    261 		}
    262 	} else {
    263 		error = vget(vp, LK_EXCLUSIVE | LK_INTERLOCK);
    264 		/*
    265 		 * If the above vget() failed or either of LOCKPARENT or
    266 		 * ISLASTCN is set, unlock the directory vnode.
    267 		 */
    268 		if (error || (~cnp->cn_flags & (LOCKPARENT|ISLASTCN)) != 0) {
    269 			VOP_UNLOCK(dvp, 0);
    270 			cnp->cn_flags |= PDIRUNLOCK;
    271 		}
    272 	}
    273 
    274 	/*
    275 	 * Check that the lock succeeded.
    276 	 */
    277 	if (error) {
    278 		/* XXXSMP - updating stats without lock; do we care? */
    279 		nchstats.ncs_badhits++;
    280 
    281 		/*
    282 		 * The parent needs to be locked when we return to VOP_LOOKUP().
    283 		 * The `.' case here should be extremely rare (if it can happen
    284 		 * at all), so we don't bother optimizing out the unlock/relock.
    285 		 */
    286 		if (vp == dvp ||
    287 		    error || (~cnp->cn_flags & (LOCKPARENT|ISLASTCN)) != 0) {
    288 			if ((error = vn_lock(dvp, LK_EXCLUSIVE)) != 0)
    289 				return (error);
    290 			cnp->cn_flags &= ~PDIRUNLOCK;
    291 		}
    292 		*vpp = NULL;
    293 		return (-1);
    294 	}
    295 
    296 	/* XXXSMP - updating stats without lock; do we care? */
    297 	nchstats.ncs_goodhits++;
    298 	*vpp = vp;
    299 	return (0);
    300 
    301 remove:
    302 	/*
    303 	 * Last component and we are renaming or deleting,
    304 	 * the cache entry is invalid, or otherwise don't
    305 	 * want cache entry to exist.
    306 	 */
    307 	TAILQ_REMOVE(&nclruhead, ncp, nc_lru);
    308 	LIST_REMOVE(ncp, nc_hash);
    309 	ncp->nc_hash.le_prev = NULL;
    310 	if (ncp->nc_vhash.le_prev != NULL) {
    311 		LIST_REMOVE(ncp, nc_vhash);
    312 		ncp->nc_vhash.le_prev = NULL;
    313 	}
    314 	TAILQ_INSERT_HEAD(&nclruhead, ncp, nc_lru);
    315 
    316 fail_wlock:
    317 	simple_unlock(&namecache_slock);
    318 fail:
    319 	*vpp = NULL;
    320 	return (-1);
    321 }
    322 
    323 /*
    324  * Scan cache looking for name of directory entry pointing at vp.
    325  *
    326  * Fill in dvpp.
    327  *
    328  * If bufp is non-NULL, also place the name in the buffer which starts
    329  * at bufp, immediately before *bpp, and move bpp backwards to point
    330  * at the start of it.  (Yes, this is a little baroque, but it's done
    331  * this way to cater to the whims of getcwd).
    332  *
    333  * Returns 0 on success, -1 on cache miss, positive errno on failure.
    334  */
    335 int
    336 cache_revlookup(struct vnode *vp, struct vnode **dvpp, char **bpp, char *bufp)
    337 {
    338 	struct namecache *ncp;
    339 	struct vnode *dvp;
    340 	struct ncvhashhead *nvcpp;
    341 	char *bp;
    342 
    343 	if (!doingcache)
    344 		goto out;
    345 
    346 	nvcpp = &ncvhashtbl[NCVHASH(vp)];
    347 
    348 	simple_lock(&namecache_slock);
    349 	LIST_FOREACH(ncp, nvcpp, nc_vhash) {
    350 		if (ncp->nc_vp == vp &&
    351 		    (dvp = ncp->nc_dvp) != NULL &&
    352 		    dvp != vp) { 		/* avoid pesky . entries.. */
    353 
    354 #ifdef DIAGNOSTIC
    355 			if (ncp->nc_nlen == 1 &&
    356 			    ncp->nc_name[0] == '.')
    357 				panic("cache_revlookup: found entry for .");
    358 
    359 			if (ncp->nc_nlen == 2 &&
    360 			    ncp->nc_name[0] == '.' &&
    361 			    ncp->nc_name[1] == '.')
    362 				panic("cache_revlookup: found entry for ..");
    363 #endif
    364 			nchstats.ncs_revhits++;
    365 
    366 			if (bufp) {
    367 				bp = *bpp;
    368 				bp -= ncp->nc_nlen;
    369 				if (bp <= bufp) {
    370 					*dvpp = NULL;
    371 					simple_unlock(&namecache_slock);
    372 					return (ERANGE);
    373 				}
    374 				memcpy(bp, ncp->nc_name, ncp->nc_nlen);
    375 				*bpp = bp;
    376 			}
    377 
    378 			/* XXX MP: how do we know dvp won't evaporate? */
    379 			*dvpp = dvp;
    380 			simple_unlock(&namecache_slock);
    381 			return (0);
    382 		}
    383 	}
    384 	nchstats.ncs_revmiss++;
    385 	simple_unlock(&namecache_slock);
    386  out:
    387 	*dvpp = NULL;
    388 	return (-1);
    389 }
    390 
    391 /*
    392  * Add an entry to the cache
    393  */
    394 void
    395 cache_enter(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
    396 {
    397 	struct namecache *ncp;
    398 	struct nchashhead *ncpp;
    399 	struct ncvhashhead *nvcpp;
    400 
    401 #ifdef DIAGNOSTIC
    402 	if (cnp->cn_namelen > NCHNAMLEN)
    403 		panic("cache_enter: name too long");
    404 #endif
    405 	if (!doingcache)
    406 		return;
    407 	/*
    408 	 * Free the cache slot at head of lru chain.
    409 	 */
    410 	simple_lock(&namecache_slock);
    411 	if (numcache < numvnodes) {
    412 		numcache++;
    413 		simple_unlock(&namecache_slock);
    414 		ncp = pool_get(&namecache_pool, PR_WAITOK);
    415 		memset(ncp, 0, sizeof(*ncp));
    416 		simple_lock(&namecache_slock);
    417 	} else if ((ncp = TAILQ_FIRST(&nclruhead)) != NULL) {
    418 		cache_remove(ncp);
    419 	} else {
    420 		simple_unlock(&namecache_slock);
    421 		return;
    422 	}
    423 	/* Grab the vnode we just found. */
    424 	ncp->nc_vp = vp;
    425 	if (vp == NULL) {
    426 		/*
    427 		 * For negative hits, save the ISWHITEOUT flag so we can
    428 		 * restore it later when the cache entry is used again.
    429 		 */
    430 		ncp->nc_flags = cnp->cn_flags & ISWHITEOUT;
    431 	}
    432 	/* Fill in cache info. */
    433 	ncp->nc_dvp = dvp;
    434 	LIST_INSERT_HEAD(&dvp->v_dnclist, ncp, nc_dvlist);
    435 	if (vp)
    436 		LIST_INSERT_HEAD(&vp->v_nclist, ncp, nc_vlist);
    437 	ncp->nc_nlen = cnp->cn_namelen;
    438 	memcpy(ncp->nc_name, cnp->cn_nameptr, (unsigned)ncp->nc_nlen);
    439 	TAILQ_INSERT_TAIL(&nclruhead, ncp, nc_lru);
    440 	ncpp = &nchashtbl[NCHASH(cnp, dvp)];
    441 	LIST_INSERT_HEAD(ncpp, ncp, nc_hash);
    442 
    443 	ncp->nc_vhash.le_prev = NULL;
    444 	ncp->nc_vhash.le_next = NULL;
    445 
    446 	/*
    447 	 * Create reverse-cache entries (used in getcwd) for directories.
    448 	 */
    449 	if (vp != NULL &&
    450 	    vp != dvp &&
    451 #ifndef NAMECACHE_ENTER_REVERSE
    452 	    vp->v_type == VDIR &&
    453 #endif
    454 	    (ncp->nc_nlen > 2 ||
    455 	    (ncp->nc_nlen > 1 && ncp->nc_name[1] != '.') ||
    456 	    (/* ncp->nc_nlen > 0 && */ ncp->nc_name[0] != '.'))) {
    457 		nvcpp = &ncvhashtbl[NCVHASH(vp)];
    458 		LIST_INSERT_HEAD(nvcpp, ncp, nc_vhash);
    459 	}
    460 	simple_unlock(&namecache_slock);
    461 }
    462 
    463 /*
    464  * Name cache initialization, from vfs_init() when we are booting
    465  */
    466 void
    467 nchinit(void)
    468 {
    469 
    470 	TAILQ_INIT(&nclruhead);
    471 	nchashtbl =
    472 	    hashinit(desiredvnodes, HASH_LIST, M_CACHE, M_WAITOK, &nchash);
    473 	ncvhashtbl =
    474 #ifdef NAMECACHE_ENTER_REVERSE
    475 	    hashinit(desiredvnodes, HASH_LIST, M_CACHE, M_WAITOK, &ncvhash);
    476 #else
    477 	    hashinit(desiredvnodes/8, HASH_LIST, M_CACHE, M_WAITOK, &ncvhash);
    478 #endif
    479 	pool_init(&namecache_pool, sizeof(struct namecache), 0, 0, 0,
    480 	    "ncachepl", &pool_allocator_nointr);
    481 }
    482 
    483 /*
    484  * Name cache reinitialization, for when the maximum number of vnodes increases.
    485  */
    486 void
    487 nchreinit(void)
    488 {
    489 	struct namecache *ncp;
    490 	struct nchashhead *oldhash1, *hash1;
    491 	struct ncvhashhead *oldhash2, *hash2;
    492 	u_long i, oldmask1, oldmask2, mask1, mask2;
    493 
    494 	hash1 = hashinit(desiredvnodes, HASH_LIST, M_CACHE, M_WAITOK, &mask1);
    495 	hash2 =
    496 #ifdef NAMECACHE_ENTER_REVERSE
    497 	    hashinit(desiredvnodes, HASH_LIST, M_CACHE, M_WAITOK, &mask2);
    498 #else
    499 	    hashinit(desiredvnodes/8, HASH_LIST, M_CACHE, M_WAITOK, &mask2);
    500 #endif
    501 	simple_lock(&namecache_slock);
    502 	oldhash1 = nchashtbl;
    503 	oldmask1 = nchash;
    504 	nchashtbl = hash1;
    505 	nchash = mask1;
    506 	oldhash2 = ncvhashtbl;
    507 	oldmask2 = ncvhash;
    508 	ncvhashtbl = hash2;
    509 	ncvhash = mask2;
    510 	for (i = 0; i <= oldmask1; i++) {
    511 		while ((ncp = LIST_FIRST(&oldhash1[i])) != NULL) {
    512 			LIST_REMOVE(ncp, nc_hash);
    513 			ncp->nc_hash.le_prev = NULL;
    514 		}
    515 	}
    516 	for (i = 0; i <= oldmask2; i++) {
    517 		while ((ncp = LIST_FIRST(&oldhash2[i])) != NULL) {
    518 			LIST_REMOVE(ncp, nc_vhash);
    519 			ncp->nc_vhash.le_prev = NULL;
    520 		}
    521 	}
    522 	simple_unlock(&namecache_slock);
    523 	hashdone(oldhash1, M_CACHE);
    524 	hashdone(oldhash2, M_CACHE);
    525 }
    526 
    527 /*
    528  * Cache flush, a particular vnode; called when a vnode is renamed to
    529  * hide entries that would now be invalid
    530  */
    531 void
    532 cache_purge(struct vnode *vp)
    533 {
    534 	struct namecache *ncp, *ncnext;
    535 
    536 	simple_lock(&namecache_slock);
    537 	for (ncp = LIST_FIRST(&vp->v_nclist); ncp != NULL; ncp = ncnext) {
    538 		ncnext = LIST_NEXT(ncp, nc_vlist);
    539 		cache_remove(ncp);
    540 		cache_free(ncp);
    541 	}
    542 	for (ncp = LIST_FIRST(&vp->v_dnclist); ncp != NULL; ncp = ncnext) {
    543 		ncnext = LIST_NEXT(ncp, nc_dvlist);
    544 		cache_remove(ncp);
    545 		cache_free(ncp);
    546 	}
    547 	simple_unlock(&namecache_slock);
    548 }
    549 
    550 /*
    551  * Cache flush, a whole filesystem; called when filesys is umounted to
    552  * remove entries that would now be invalid.
    553  */
    554 void
    555 cache_purgevfs(struct mount *mp)
    556 {
    557 	struct namecache *ncp, *nxtcp;
    558 
    559 	simple_lock(&namecache_slock);
    560 	for (ncp = TAILQ_FIRST(&nclruhead); ncp != NULL; ncp = nxtcp) {
    561 		nxtcp = TAILQ_NEXT(ncp, nc_lru);
    562 		if (ncp->nc_dvp == NULL || ncp->nc_dvp->v_mount != mp) {
    563 			continue;
    564 		}
    565 		/* Free the resources we had. */
    566 		cache_remove(ncp);
    567 		cache_free(ncp);
    568 	}
    569 	simple_unlock(&namecache_slock);
    570 }
    571 
    572 #ifdef DDB
    573 void
    574 namecache_print(struct vnode *vp, void (*pr)(const char *, ...))
    575 {
    576 	struct vnode *dvp = NULL;
    577 	struct namecache *ncp;
    578 
    579 	TAILQ_FOREACH(ncp, &nclruhead, nc_lru) {
    580 		if (ncp->nc_vp == vp) {
    581 			(*pr)("name %.*s\n", ncp->nc_nlen, ncp->nc_name);
    582 			dvp = ncp->nc_dvp;
    583 		}
    584 	}
    585 	if (dvp == NULL) {
    586 		(*pr)("name not found\n");
    587 		return;
    588 	}
    589 	vp = dvp;
    590 	TAILQ_FOREACH(ncp, &nclruhead, nc_lru) {
    591 		if (ncp->nc_vp == vp) {
    592 			(*pr)("parent %.*s\n", ncp->nc_nlen, ncp->nc_name);
    593 		}
    594 	}
    595 }
    596 #endif
    597