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