2 * Copyright (c) 2003,2004 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@backplane.com>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
34 * Copyright (c) 1989, 1993, 1995
35 * The Regents of the University of California. All rights reserved.
37 * This code is derived from software contributed to Berkeley by
38 * Poul-Henning Kamp of the FreeBSD Project.
40 * Redistribution and use in source and binary forms, with or without
41 * modification, are permitted provided that the following conditions
43 * 1. Redistributions of source code must retain the above copyright
44 * notice, this list of conditions and the following disclaimer.
45 * 2. Redistributions in binary form must reproduce the above copyright
46 * notice, this list of conditions and the following disclaimer in the
47 * documentation and/or other materials provided with the distribution.
48 * 3. All advertising materials mentioning features or use of this software
49 * must display the following acknowledgement:
50 * This product includes software developed by the University of
51 * California, Berkeley and its contributors.
52 * 4. Neither the name of the University nor the names of its contributors
53 * may be used to endorse or promote products derived from this software
54 * without specific prior written permission.
56 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
57 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
58 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
59 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
60 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
61 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
62 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
63 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
64 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
65 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
68 * @(#)vfs_cache.c 8.5 (Berkeley) 3/22/95
69 * $FreeBSD: src/sys/kern/vfs_cache.c,v 1.42.2.6 2001/10/05 20:07:03 dillon Exp $
70 * $DragonFly: src/sys/kern/vfs_cache.c,v 1.91 2008/06/14 05:34:06 dillon Exp $
73 #include <sys/param.h>
74 #include <sys/systm.h>
75 #include <sys/kernel.h>
76 #include <sys/sysctl.h>
77 #include <sys/mount.h>
78 #include <sys/vnode.h>
79 #include <sys/malloc.h>
80 #include <sys/sysproto.h>
82 #include <sys/namei.h>
83 #include <sys/nlookup.h>
84 #include <sys/filedesc.h>
85 #include <sys/fnv_hash.h>
86 #include <sys/globaldata.h>
87 #include <sys/kern_syscall.h>
88 #include <sys/dirent.h>
91 #include <sys/sysref2.h>
93 #define MAX_RECURSION_DEPTH 64
96 * Random lookups in the cache are accomplished with a hash table using
97 * a hash key of (nc_src_vp, name).
99 * Negative entries may exist and correspond to structures where nc_vp
100 * is NULL. In a negative entry, NCF_WHITEOUT will be set if the entry
101 * corresponds to a whited-out directory entry (verses simply not finding the
104 * Upon reaching the last segment of a path, if the reference is for DELETE,
105 * or NOCACHE is set (rewrite), and the name is located in the cache, it
110 * Structures associated with name cacheing.
112 #define NCHHASH(hash) (&nchashtbl[(hash) & nchash])
115 MALLOC_DEFINE(M_VFSCACHE
, "vfscache", "VFS name cache entries");
117 static LIST_HEAD(nchashhead
, namecache
) *nchashtbl
; /* Hash Table */
118 static struct namecache_list ncneglist
; /* instead of vnode */
121 * ncvp_debug - debug cache_fromvp(). This is used by the NFS server
122 * to create the namecache infrastructure leading to a dangling vnode.
124 * 0 Only errors are reported
125 * 1 Successes are reported
126 * 2 Successes + the whole directory scan is reported
127 * 3 Force the directory scan code run as if the parent vnode did not
128 * have a namecache record, even if it does have one.
130 static int ncvp_debug
;
131 SYSCTL_INT(_debug
, OID_AUTO
, ncvp_debug
, CTLFLAG_RW
, &ncvp_debug
, 0, "");
133 static u_long nchash
; /* size of hash table */
134 SYSCTL_ULONG(_debug
, OID_AUTO
, nchash
, CTLFLAG_RD
, &nchash
, 0, "");
136 static u_long ncnegfactor
= 16; /* ratio of negative entries */
137 SYSCTL_ULONG(_debug
, OID_AUTO
, ncnegfactor
, CTLFLAG_RW
, &ncnegfactor
, 0, "");
139 static int nclockwarn
; /* warn on locked entries in ticks */
140 SYSCTL_INT(_debug
, OID_AUTO
, nclockwarn
, CTLFLAG_RW
, &nclockwarn
, 0, "");
142 static u_long numneg
; /* number of cache entries allocated */
143 SYSCTL_ULONG(_debug
, OID_AUTO
, numneg
, CTLFLAG_RD
, &numneg
, 0, "");
145 static u_long numcache
; /* number of cache entries allocated */
146 SYSCTL_ULONG(_debug
, OID_AUTO
, numcache
, CTLFLAG_RD
, &numcache
, 0, "");
148 static u_long numunres
; /* number of unresolved entries */
149 SYSCTL_ULONG(_debug
, OID_AUTO
, numunres
, CTLFLAG_RD
, &numunres
, 0, "");
151 SYSCTL_INT(_debug
, OID_AUTO
, vnsize
, CTLFLAG_RD
, 0, sizeof(struct vnode
), "");
152 SYSCTL_INT(_debug
, OID_AUTO
, ncsize
, CTLFLAG_RD
, 0, sizeof(struct namecache
), "");
154 static int cache_resolve_mp(struct mount
*mp
);
155 static struct vnode
*cache_dvpref(struct namecache
*ncp
);
156 static void _cache_rehash(struct namecache
*ncp
);
157 static void _cache_lock(struct namecache
*ncp
);
158 static void _cache_setunresolved(struct namecache
*ncp
);
161 * The new name cache statistics
163 SYSCTL_NODE(_vfs
, OID_AUTO
, cache
, CTLFLAG_RW
, 0, "Name cache statistics");
164 #define STATNODE(mode, name, var) \
165 SYSCTL_ULONG(_vfs_cache, OID_AUTO, name, mode, var, 0, "");
166 STATNODE(CTLFLAG_RD
, numneg
, &numneg
);
167 STATNODE(CTLFLAG_RD
, numcache
, &numcache
);
168 static u_long numcalls
; STATNODE(CTLFLAG_RD
, numcalls
, &numcalls
);
169 static u_long dothits
; STATNODE(CTLFLAG_RD
, dothits
, &dothits
);
170 static u_long dotdothits
; STATNODE(CTLFLAG_RD
, dotdothits
, &dotdothits
);
171 static u_long numchecks
; STATNODE(CTLFLAG_RD
, numchecks
, &numchecks
);
172 static u_long nummiss
; STATNODE(CTLFLAG_RD
, nummiss
, &nummiss
);
173 static u_long nummisszap
; STATNODE(CTLFLAG_RD
, nummisszap
, &nummisszap
);
174 static u_long numposzaps
; STATNODE(CTLFLAG_RD
, numposzaps
, &numposzaps
);
175 static u_long numposhits
; STATNODE(CTLFLAG_RD
, numposhits
, &numposhits
);
176 static u_long numnegzaps
; STATNODE(CTLFLAG_RD
, numnegzaps
, &numnegzaps
);
177 static u_long numneghits
; STATNODE(CTLFLAG_RD
, numneghits
, &numneghits
);
179 struct nchstats nchstats
[SMP_MAXCPU
];
181 * Export VFS cache effectiveness statistics to user-land.
183 * The statistics are left for aggregation to user-land so
184 * neat things can be achieved, like observing per-CPU cache
188 sysctl_nchstats(SYSCTL_HANDLER_ARGS
)
190 struct globaldata
*gd
;
194 for (i
= 0; i
< ncpus
; ++i
) {
195 gd
= globaldata_find(i
);
196 if ((error
= SYSCTL_OUT(req
, (void *)&(*gd
->gd_nchstats
),
197 sizeof(struct nchstats
))))
203 SYSCTL_PROC(_vfs_cache
, OID_AUTO
, nchstats
, CTLTYPE_OPAQUE
|CTLFLAG_RD
,
204 0, 0, sysctl_nchstats
, "S,nchstats", "VFS cache effectiveness statistics");
206 static void cache_zap(struct namecache
*ncp
);
209 * cache_hold() and cache_drop() prevent the premature deletion of a
210 * namecache entry but do not prevent operations (such as zapping) on
211 * that namecache entry.
213 * This routine may only be called from outside this source module if
214 * nc_refs is already at least 1.
216 * This is a rare case where callers are allowed to hold a spinlock,
217 * so we can't ourselves.
221 _cache_hold(struct namecache
*ncp
)
223 atomic_add_int(&ncp
->nc_refs
, 1);
228 * When dropping an entry, if only one ref remains and the entry has not
229 * been resolved, zap it. Since the one reference is being dropped the
230 * entry had better not be locked.
234 _cache_drop(struct namecache
*ncp
)
236 KKASSERT(ncp
->nc_refs
> 0);
237 if (ncp
->nc_refs
== 1 &&
238 (ncp
->nc_flag
& NCF_UNRESOLVED
) &&
239 TAILQ_EMPTY(&ncp
->nc_list
)
241 KKASSERT(ncp
->nc_exlocks
== 0);
245 atomic_subtract_int(&ncp
->nc_refs
, 1);
250 * Link a new namecache entry to its parent. Be careful to avoid races
251 * if vhold() blocks in the future.
254 cache_link_parent(struct namecache
*ncp
, struct namecache
*par
)
256 KKASSERT(ncp
->nc_parent
== NULL
);
257 ncp
->nc_parent
= par
;
258 if (TAILQ_EMPTY(&par
->nc_list
)) {
259 TAILQ_INSERT_HEAD(&par
->nc_list
, ncp
, nc_entry
);
261 * Any vp associated with an ncp which has children must
262 * be held to prevent it from being recycled.
267 TAILQ_INSERT_HEAD(&par
->nc_list
, ncp
, nc_entry
);
272 * Remove the parent association from a namecache structure. If this is
273 * the last child of the parent the cache_drop(par) will attempt to
274 * recursively zap the parent.
277 cache_unlink_parent(struct namecache
*ncp
)
279 struct namecache
*par
;
281 if ((par
= ncp
->nc_parent
) != NULL
) {
282 ncp
->nc_parent
= NULL
;
283 par
= _cache_hold(par
);
284 TAILQ_REMOVE(&par
->nc_list
, ncp
, nc_entry
);
285 if (par
->nc_vp
&& TAILQ_EMPTY(&par
->nc_list
))
292 * Allocate a new namecache structure. Most of the code does not require
293 * zero-termination of the string but it makes vop_compat_ncreate() easier.
295 static struct namecache
*
296 cache_alloc(int nlen
)
298 struct namecache
*ncp
;
300 ncp
= kmalloc(sizeof(*ncp
), M_VFSCACHE
, M_WAITOK
|M_ZERO
);
302 ncp
->nc_name
= kmalloc(nlen
+ 1, M_VFSCACHE
, M_WAITOK
);
304 ncp
->nc_flag
= NCF_UNRESOLVED
;
305 ncp
->nc_error
= ENOTCONN
; /* needs to be resolved */
309 * Construct a fake FSMID based on the time of day and a 32 bit
310 * roller for uniqueness. This is used to generate a useful
311 * FSMID for filesystems which do not support it.
313 ncp
->nc_fsmid
= cache_getnewfsmid();
314 TAILQ_INIT(&ncp
->nc_list
);
320 _cache_free(struct namecache
*ncp
)
322 KKASSERT(ncp
->nc_refs
== 1 && ncp
->nc_exlocks
== 1);
324 kfree(ncp
->nc_name
, M_VFSCACHE
);
325 kfree(ncp
, M_VFSCACHE
);
329 cache_zero(struct nchandle
*nch
)
336 * Ref and deref a namecache structure.
338 * Warning: caller may hold an unrelated read spinlock, which means we can't
339 * use read spinlocks here.
342 cache_hold(struct nchandle
*nch
)
344 _cache_hold(nch
->ncp
);
345 ++nch
->mount
->mnt_refs
;
350 cache_copy(struct nchandle
*nch
, struct nchandle
*target
)
353 _cache_hold(target
->ncp
);
354 ++nch
->mount
->mnt_refs
;
358 cache_changemount(struct nchandle
*nch
, struct mount
*mp
)
360 --nch
->mount
->mnt_refs
;
362 ++nch
->mount
->mnt_refs
;
366 cache_drop(struct nchandle
*nch
)
368 --nch
->mount
->mnt_refs
;
369 _cache_drop(nch
->ncp
);
375 * Namespace locking. The caller must already hold a reference to the
376 * namecache structure in order to lock/unlock it. This function prevents
377 * the namespace from being created or destroyed by accessors other then
380 * Note that holding a locked namecache structure prevents other threads
381 * from making namespace changes (e.g. deleting or creating), prevents
382 * vnode association state changes by other threads, and prevents the
383 * namecache entry from being resolved or unresolved by other threads.
385 * The lock owner has full authority to associate/disassociate vnodes
386 * and resolve/unresolve the locked ncp.
388 * WARNING! Holding a locked ncp will prevent a vnode from being destroyed
389 * or recycled, but it does NOT help you if the vnode had already initiated
390 * a recyclement. If this is important, use cache_get() rather then
391 * cache_lock() (and deal with the differences in the way the refs counter
392 * is handled). Or, alternatively, make an unconditional call to
393 * cache_validate() or cache_resolve() after cache_lock() returns.
397 _cache_lock(struct namecache
*ncp
)
402 KKASSERT(ncp
->nc_refs
!= 0);
407 if (ncp
->nc_exlocks
== 0) {
411 * The vp associated with a locked ncp must be held
412 * to prevent it from being recycled (which would
413 * cause the ncp to become unresolved).
415 * WARNING! If VRECLAIMED is set the vnode could
416 * already be in the middle of a recycle. Callers
417 * should not assume that nc_vp is usable when
418 * not NULL. cache_vref() or cache_vget() must be
421 * XXX loop on race for later MPSAFE work.
427 if (ncp
->nc_locktd
== td
) {
431 ncp
->nc_flag
|= NCF_LOCKREQ
;
432 if (tsleep(ncp
, 0, "clock", nclockwarn
) == EWOULDBLOCK
) {
436 kprintf("[diagnostic] cache_lock: blocked on %p", ncp
);
437 kprintf(" \"%*.*s\"\n",
438 ncp
->nc_nlen
, ncp
->nc_nlen
, ncp
->nc_name
);
443 kprintf("[diagnostic] cache_lock: unblocked %*.*s\n",
444 ncp
->nc_nlen
, ncp
->nc_nlen
, ncp
->nc_name
);
449 cache_lock(struct nchandle
*nch
)
451 _cache_lock(nch
->ncp
);
456 _cache_lock_nonblock(struct namecache
*ncp
)
460 KKASSERT(ncp
->nc_refs
!= 0);
462 if (ncp
->nc_exlocks
== 0) {
466 * The vp associated with a locked ncp must be held
467 * to prevent it from being recycled (which would
468 * cause the ncp to become unresolved).
470 * WARNING! If VRECLAIMED is set the vnode could
471 * already be in the middle of a recycle. Callers
472 * should not assume that nc_vp is usable when
473 * not NULL. cache_vref() or cache_vget() must be
476 * XXX loop on race for later MPSAFE work.
487 cache_lock_nonblock(struct nchandle
*nch
)
489 return(_cache_lock_nonblock(nch
->ncp
));
494 _cache_unlock(struct namecache
*ncp
)
496 thread_t td
= curthread
;
498 KKASSERT(ncp
->nc_refs
> 0);
499 KKASSERT(ncp
->nc_exlocks
> 0);
500 KKASSERT(ncp
->nc_locktd
== td
);
501 if (--ncp
->nc_exlocks
== 0) {
504 ncp
->nc_locktd
= NULL
;
505 if (ncp
->nc_flag
& NCF_LOCKREQ
) {
506 ncp
->nc_flag
&= ~NCF_LOCKREQ
;
513 cache_unlock(struct nchandle
*nch
)
515 _cache_unlock(nch
->ncp
);
519 * ref-and-lock, unlock-and-deref functions.
521 * This function is primarily used by nlookup. Even though cache_lock
522 * holds the vnode, it is possible that the vnode may have already
523 * initiated a recyclement. We want cache_get() to return a definitively
524 * usable vnode or a definitively unresolved ncp.
528 _cache_get(struct namecache
*ncp
)
532 if (ncp
->nc_vp
&& (ncp
->nc_vp
->v_flag
& VRECLAIMED
))
533 _cache_setunresolved(ncp
);
538 * note: the same nchandle can be passed for both arguments.
541 cache_get(struct nchandle
*nch
, struct nchandle
*target
)
543 target
->mount
= nch
->mount
;
544 target
->ncp
= _cache_get(nch
->ncp
);
545 ++target
->mount
->mnt_refs
;
549 _cache_get_nonblock(struct namecache
*ncp
)
552 if (ncp
->nc_exlocks
== 0 || ncp
->nc_locktd
== curthread
) {
555 if (ncp
->nc_vp
&& (ncp
->nc_vp
->v_flag
& VRECLAIMED
))
556 _cache_setunresolved(ncp
);
563 cache_get_nonblock(struct nchandle
*nch
)
567 if ((error
= _cache_get_nonblock(nch
->ncp
)) == 0)
568 ++nch
->mount
->mnt_refs
;
574 _cache_put(struct namecache
*ncp
)
581 cache_put(struct nchandle
*nch
)
583 --nch
->mount
->mnt_refs
;
584 _cache_put(nch
->ncp
);
590 * Resolve an unresolved ncp by associating a vnode with it. If the
591 * vnode is NULL, a negative cache entry is created.
593 * The ncp should be locked on entry and will remain locked on return.
597 _cache_setvp(struct mount
*mp
, struct namecache
*ncp
, struct vnode
*vp
)
599 KKASSERT(ncp
->nc_flag
& NCF_UNRESOLVED
);
603 * Any vp associated with an ncp which has children must
604 * be held. Any vp associated with a locked ncp must be held.
606 if (!TAILQ_EMPTY(&ncp
->nc_list
))
608 TAILQ_INSERT_HEAD(&vp
->v_namecache
, ncp
, nc_vnode
);
613 * Set auxiliary flags
617 ncp
->nc_flag
|= NCF_ISDIR
;
620 ncp
->nc_flag
|= NCF_ISSYMLINK
;
621 /* XXX cache the contents of the symlink */
630 * When creating a negative cache hit we set the
631 * namecache_gen. A later resolve will clean out the
632 * negative cache hit if the mount point's namecache_gen
633 * has changed. Used by devfs, could also be used by
636 TAILQ_INSERT_TAIL(&ncneglist
, ncp
, nc_vnode
);
638 ncp
->nc_error
= ENOENT
;
640 ncp
->nc_namecache_gen
= mp
->mnt_namecache_gen
;
642 ncp
->nc_flag
&= ~NCF_UNRESOLVED
;
646 cache_setvp(struct nchandle
*nch
, struct vnode
*vp
)
648 _cache_setvp(nch
->mount
, nch
->ncp
, vp
);
652 cache_settimeout(struct nchandle
*nch
, int nticks
)
654 struct namecache
*ncp
= nch
->ncp
;
656 if ((ncp
->nc_timeout
= ticks
+ nticks
) == 0)
661 * Disassociate the vnode or negative-cache association and mark a
662 * namecache entry as unresolved again. Note that the ncp is still
663 * left in the hash table and still linked to its parent.
665 * The ncp should be locked and refd on entry and will remain locked and refd
668 * This routine is normally never called on a directory containing children.
669 * However, NFS often does just that in its rename() code as a cop-out to
670 * avoid complex namespace operations. This disconnects a directory vnode
671 * from its namecache and can cause the OLDAPI and NEWAPI to get out of
674 * NOTE: NCF_FSMID must be cleared so a refurbishment of the ncp, such as
675 * in a create, properly propogates flag up the chain.
679 _cache_setunresolved(struct namecache
*ncp
)
683 if ((ncp
->nc_flag
& NCF_UNRESOLVED
) == 0) {
684 ncp
->nc_flag
|= NCF_UNRESOLVED
;
686 ncp
->nc_error
= ENOTCONN
;
688 if ((vp
= ncp
->nc_vp
) != NULL
) {
691 TAILQ_REMOVE(&vp
->v_namecache
, ncp
, nc_vnode
);
694 * Any vp associated with an ncp with children is
695 * held by that ncp. Any vp associated with a locked
696 * ncp is held by that ncp. These conditions must be
697 * undone when the vp is cleared out from the ncp.
699 if (ncp
->nc_flag
& NCF_FSMID
)
701 if (!TAILQ_EMPTY(&ncp
->nc_list
))
706 TAILQ_REMOVE(&ncneglist
, ncp
, nc_vnode
);
709 ncp
->nc_flag
&= ~(NCF_WHITEOUT
|NCF_ISDIR
|NCF_ISSYMLINK
|
715 * The cache_nresolve() code calls this function to automatically
716 * set a resolved cache element to unresolved if it has timed out
717 * or if it is a negative cache hit and the mount point namecache_gen
721 _cache_auto_unresolve(struct mount
*mp
, struct namecache
*ncp
)
724 * Already in an unresolved state, nothing to do.
726 if (ncp
->nc_flag
& NCF_UNRESOLVED
)
730 * Try to zap entries that have timed out. We have
731 * to be careful here because locked leafs may depend
732 * on the vnode remaining intact in a parent, so only
733 * do this under very specific conditions.
735 if (ncp
->nc_timeout
&& (int)(ncp
->nc_timeout
- ticks
) < 0 &&
736 TAILQ_EMPTY(&ncp
->nc_list
)) {
737 _cache_setunresolved(ncp
);
742 * If a resolved negative cache hit is invalid due to
743 * the mount's namecache generation being bumped, zap it.
745 if (ncp
->nc_vp
== NULL
&&
746 ncp
->nc_namecache_gen
!= mp
->mnt_namecache_gen
) {
747 _cache_setunresolved(ncp
);
753 cache_setunresolved(struct nchandle
*nch
)
755 _cache_setunresolved(nch
->ncp
);
759 * Determine if we can clear NCF_ISMOUNTPT by scanning the mountlist
760 * looking for matches. This flag tells the lookup code when it must
761 * check for a mount linkage and also prevents the directories in question
762 * from being deleted or renamed.
766 cache_clrmountpt_callback(struct mount
*mp
, void *data
)
768 struct nchandle
*nch
= data
;
770 if (mp
->mnt_ncmounton
.ncp
== nch
->ncp
)
772 if (mp
->mnt_ncmountpt
.ncp
== nch
->ncp
)
778 cache_clrmountpt(struct nchandle
*nch
)
782 count
= mountlist_scan(cache_clrmountpt_callback
, nch
,
783 MNTSCAN_FORWARD
|MNTSCAN_NOBUSY
);
785 nch
->ncp
->nc_flag
&= ~NCF_ISMOUNTPT
;
789 * Invalidate portions of the namecache topology given a starting entry.
790 * The passed ncp is set to an unresolved state and:
792 * The passed ncp must be locked.
794 * CINV_DESTROY - Set a flag in the passed ncp entry indicating
795 * that the physical underlying nodes have been
796 * destroyed... as in deleted. For example, when
797 * a directory is removed. This will cause record
798 * lookups on the name to no longer be able to find
799 * the record and tells the resolver to return failure
800 * rather then trying to resolve through the parent.
802 * The topology itself, including ncp->nc_name,
805 * This only applies to the passed ncp, if CINV_CHILDREN
806 * is specified the children are not flagged.
808 * CINV_CHILDREN - Set all children (recursively) to an unresolved
811 * Note that this will also have the side effect of
812 * cleaning out any unreferenced nodes in the topology
813 * from the leaves up as the recursion backs out.
815 * Note that the topology for any referenced nodes remains intact.
817 * It is possible for cache_inval() to race a cache_resolve(), meaning that
818 * the namecache entry may not actually be invalidated on return if it was
819 * revalidated while recursing down into its children. This code guarentees
820 * that the node(s) will go through an invalidation cycle, but does not
821 * guarentee that they will remain in an invalidated state.
823 * Returns non-zero if a revalidation was detected during the invalidation
824 * recursion, zero otherwise. Note that since only the original ncp is
825 * locked the revalidation ultimately can only indicate that the original ncp
826 * *MIGHT* no have been reresolved.
828 * DEEP RECURSION HANDLING - If a recursive invalidation recurses deeply we
829 * have to avoid blowing out the kernel stack. We do this by saving the
830 * deep namecache node and aborting the recursion, then re-recursing at that
831 * node using a depth-first algorithm in order to allow multiple deep
832 * recursions to chain through each other, then we restart the invalidation
837 struct namecache
*resume_ncp
;
841 static int _cache_inval_internal(struct namecache
*, int, struct cinvtrack
*);
845 _cache_inval(struct namecache
*ncp
, int flags
)
847 struct cinvtrack track
;
848 struct namecache
*ncp2
;
852 track
.resume_ncp
= NULL
;
855 r
= _cache_inval_internal(ncp
, flags
, &track
);
856 if (track
.resume_ncp
== NULL
)
858 kprintf("Warning: deep namecache recursion at %s\n",
861 while ((ncp2
= track
.resume_ncp
) != NULL
) {
862 track
.resume_ncp
= NULL
;
864 _cache_inval_internal(ncp2
, flags
& ~CINV_DESTROY
,
874 cache_inval(struct nchandle
*nch
, int flags
)
876 return(_cache_inval(nch
->ncp
, flags
));
880 _cache_inval_internal(struct namecache
*ncp
, int flags
, struct cinvtrack
*track
)
882 struct namecache
*kid
;
883 struct namecache
*nextkid
;
886 KKASSERT(ncp
->nc_exlocks
);
888 _cache_setunresolved(ncp
);
889 if (flags
& CINV_DESTROY
)
890 ncp
->nc_flag
|= NCF_DESTROYED
;
892 if ((flags
& CINV_CHILDREN
) &&
893 (kid
= TAILQ_FIRST(&ncp
->nc_list
)) != NULL
895 if (++track
->depth
> MAX_RECURSION_DEPTH
) {
896 track
->resume_ncp
= ncp
;
903 if (track
->resume_ncp
) {
907 if ((nextkid
= TAILQ_NEXT(kid
, nc_entry
)) != NULL
)
908 _cache_hold(nextkid
);
909 if ((kid
->nc_flag
& NCF_UNRESOLVED
) == 0 ||
910 TAILQ_FIRST(&kid
->nc_list
)
913 rcnt
+= _cache_inval_internal(kid
, flags
& ~CINV_DESTROY
, track
);
924 * Someone could have gotten in there while ncp was unlocked,
927 if ((ncp
->nc_flag
& NCF_UNRESOLVED
) == 0)
933 * Invalidate a vnode's namecache associations. To avoid races against
934 * the resolver we do not invalidate a node which we previously invalidated
935 * but which was then re-resolved while we were in the invalidation loop.
937 * Returns non-zero if any namecache entries remain after the invalidation
940 * NOTE: unlike the namecache topology which guarentees that ncp's will not
941 * be ripped out of the topology while held, the vnode's v_namecache list
942 * has no such restriction. NCP's can be ripped out of the list at virtually
943 * any time if not locked, even if held.
946 cache_inval_vp(struct vnode
*vp
, int flags
)
948 struct namecache
*ncp
;
949 struct namecache
*next
;
952 ncp
= TAILQ_FIRST(&vp
->v_namecache
);
956 /* loop entered with ncp held */
957 if ((next
= TAILQ_NEXT(ncp
, nc_vnode
)) != NULL
)
960 if (ncp
->nc_vp
!= vp
) {
961 kprintf("Warning: cache_inval_vp: race-A detected on "
962 "%s\n", ncp
->nc_name
);
968 _cache_inval(ncp
, flags
);
969 _cache_put(ncp
); /* also releases reference */
971 if (ncp
&& ncp
->nc_vp
!= vp
) {
972 kprintf("Warning: cache_inval_vp: race-B detected on "
973 "%s\n", ncp
->nc_name
);
978 return(TAILQ_FIRST(&vp
->v_namecache
) != NULL
);
982 * This routine is used instead of the normal cache_inval_vp() when we
983 * are trying to recycle otherwise good vnodes.
985 * Return 0 on success, non-zero if not all namecache records could be
986 * disassociated from the vnode (for various reasons).
989 cache_inval_vp_nonblock(struct vnode
*vp
)
991 struct namecache
*ncp
;
992 struct namecache
*next
;
994 ncp
= TAILQ_FIRST(&vp
->v_namecache
);
998 /* loop entered with ncp held */
999 if ((next
= TAILQ_NEXT(ncp
, nc_vnode
)) != NULL
)
1001 if (_cache_lock_nonblock(ncp
)) {
1007 if (ncp
->nc_vp
!= vp
) {
1008 kprintf("Warning: cache_inval_vp: race-A detected on "
1009 "%s\n", ncp
->nc_name
);
1015 _cache_inval(ncp
, 0);
1016 _cache_put(ncp
); /* also releases reference */
1018 if (ncp
&& ncp
->nc_vp
!= vp
) {
1019 kprintf("Warning: cache_inval_vp: race-B detected on "
1020 "%s\n", ncp
->nc_name
);
1025 return(TAILQ_FIRST(&vp
->v_namecache
) != NULL
);
1029 * The source ncp has been renamed to the target ncp. Both fncp and tncp
1030 * must be locked. The target ncp is destroyed (as a normal rename-over
1031 * would destroy the target file or directory).
1033 * Because there may be references to the source ncp we cannot copy its
1034 * contents to the target. Instead the source ncp is relinked as the target
1035 * and the target ncp is removed from the namecache topology.
1038 cache_rename(struct nchandle
*fnch
, struct nchandle
*tnch
)
1040 struct namecache
*fncp
= fnch
->ncp
;
1041 struct namecache
*tncp
= tnch
->ncp
;
1044 _cache_setunresolved(tncp
);
1045 cache_unlink_parent(fncp
);
1046 cache_link_parent(fncp
, tncp
->nc_parent
);
1047 cache_unlink_parent(tncp
);
1048 oname
= fncp
->nc_name
;
1049 fncp
->nc_name
= tncp
->nc_name
;
1050 fncp
->nc_nlen
= tncp
->nc_nlen
;
1051 tncp
->nc_name
= NULL
;
1053 if (fncp
->nc_flag
& NCF_HASHED
)
1054 _cache_rehash(fncp
);
1055 if (tncp
->nc_flag
& NCF_HASHED
)
1056 _cache_rehash(tncp
);
1058 kfree(oname
, M_VFSCACHE
);
1062 * vget the vnode associated with the namecache entry. Resolve the namecache
1063 * entry if necessary and deal with namecache/vp races. The passed ncp must
1064 * be referenced and may be locked. The ncp's ref/locking state is not
1065 * effected by this call.
1067 * lk_type may be LK_SHARED, LK_EXCLUSIVE. A ref'd, possibly locked
1068 * (depending on the passed lk_type) will be returned in *vpp with an error
1069 * of 0, or NULL will be returned in *vpp with a non-0 error code. The
1070 * most typical error is ENOENT, meaning that the ncp represents a negative
1071 * cache hit and there is no vnode to retrieve, but other errors can occur
1074 * The main race we have to deal with are namecache zaps. The ncp itself
1075 * will not disappear since it is referenced, and it turns out that the
1076 * validity of the vp pointer can be checked simply by rechecking the
1077 * contents of ncp->nc_vp.
1080 cache_vget(struct nchandle
*nch
, struct ucred
*cred
,
1081 int lk_type
, struct vnode
**vpp
)
1083 struct namecache
*ncp
;
1090 if (ncp
->nc_flag
& NCF_UNRESOLVED
) {
1092 error
= cache_resolve(nch
, cred
);
1097 if (error
== 0 && (vp
= ncp
->nc_vp
) != NULL
) {
1099 * Accessing the vnode from the namecache is a bit
1100 * dangerous. Because there are no refs on the vnode, it
1101 * could be in the middle of a reclaim.
1103 if (vp
->v_flag
& VRECLAIMED
) {
1104 kprintf("Warning: vnode reclaim race detected in cache_vget on %p (%s)\n", vp
, ncp
->nc_name
);
1106 _cache_setunresolved(ncp
);
1110 error
= vget(vp
, lk_type
);
1112 if (vp
!= ncp
->nc_vp
)
1115 } else if (vp
!= ncp
->nc_vp
) {
1118 } else if (vp
->v_flag
& VRECLAIMED
) {
1119 panic("vget succeeded on a VRECLAIMED node! vp %p", vp
);
1122 if (error
== 0 && vp
== NULL
)
1129 cache_vref(struct nchandle
*nch
, struct ucred
*cred
, struct vnode
**vpp
)
1131 struct namecache
*ncp
;
1139 if (ncp
->nc_flag
& NCF_UNRESOLVED
) {
1141 error
= cache_resolve(nch
, cred
);
1146 if (error
== 0 && (vp
= ncp
->nc_vp
) != NULL
) {
1148 * Since we did not obtain any locks, a cache zap
1149 * race can occur here if the vnode is in the middle
1150 * of being reclaimed and has not yet been able to
1151 * clean out its cache node. If that case occurs,
1152 * we must lock and unresolve the cache, then loop
1155 if ((error
= vget(vp
, LK_SHARED
)) != 0) {
1156 if (error
== ENOENT
) {
1157 kprintf("Warning: vnode reclaim race detected on cache_vref %p (%s)\n", vp
, ncp
->nc_name
);
1159 _cache_setunresolved(ncp
);
1165 /* caller does not want a lock */
1169 if (error
== 0 && vp
== NULL
)
1176 * Return a referenced vnode representing the parent directory of
1177 * ncp. Because the caller has locked the ncp it should not be possible for
1178 * the parent ncp to go away.
1180 * However, we might race against the parent dvp and not be able to
1181 * reference it. If we race, return NULL.
1183 static struct vnode
*
1184 cache_dvpref(struct namecache
*ncp
)
1186 struct namecache
*par
;
1190 if ((par
= ncp
->nc_parent
) != NULL
) {
1191 if ((par
->nc_flag
& NCF_UNRESOLVED
) == 0) {
1192 if ((dvp
= par
->nc_vp
) != NULL
) {
1193 if (vget(dvp
, LK_SHARED
) == 0) {
1195 /* return referenced, unlocked dvp */
1206 * Recursively set the FSMID update flag for namecache nodes leading
1207 * to root. This will cause the next getattr or reclaim to increment the
1208 * fsmid and mark the inode for lazy updating.
1210 * Stop recursing when we hit a node whos NCF_FSMID flag is already set.
1211 * This makes FSMIDs work in an Einsteinian fashion - where the observation
1212 * effects the result. In this case a program monitoring a higher level
1213 * node will have detected some prior change and started its scan (clearing
1214 * NCF_FSMID in higher level nodes), but since it has not yet observed the
1215 * node where we find NCF_FSMID still set, we can safely make the related
1216 * modification without interfering with the theorized program.
1218 * This also means that FSMIDs cannot represent time-domain quantities
1219 * in a hierarchical sense. But the main reason for doing it this way
1220 * is to reduce the amount of recursion that occurs in the critical path
1221 * when e.g. a program is writing to a file that sits deep in a directory
1225 cache_update_fsmid(struct nchandle
*nch
)
1227 struct namecache
*ncp
;
1228 struct namecache
*scan
;
1234 * Warning: even if we get a non-NULL vp it could still be in the
1235 * middle of a recyclement. Don't do anything fancy, just set
1238 if ((vp
= ncp
->nc_vp
) != NULL
) {
1239 TAILQ_FOREACH(ncp
, &vp
->v_namecache
, nc_vnode
) {
1240 for (scan
= ncp
; scan
; scan
= scan
->nc_parent
) {
1241 if (scan
->nc_flag
& NCF_FSMID
)
1243 scan
->nc_flag
|= NCF_FSMID
;
1247 while (ncp
&& (ncp
->nc_flag
& NCF_FSMID
) == 0) {
1248 ncp
->nc_flag
|= NCF_FSMID
;
1249 ncp
= ncp
->nc_parent
;
1255 cache_update_fsmid_vp(struct vnode
*vp
)
1257 struct namecache
*ncp
;
1258 struct namecache
*scan
;
1260 TAILQ_FOREACH(ncp
, &vp
->v_namecache
, nc_vnode
) {
1261 for (scan
= ncp
; scan
; scan
= scan
->nc_parent
) {
1262 if (scan
->nc_flag
& NCF_FSMID
)
1264 scan
->nc_flag
|= NCF_FSMID
;
1270 * If getattr is called on a vnode (e.g. a stat call), the filesystem
1271 * may call this routine to determine if the namecache has the hierarchical
1272 * change flag set, requiring the fsmid to be updated.
1274 * Since 0 indicates no support, make sure the filesystem fsmid is at least
1278 cache_check_fsmid_vp(struct vnode
*vp
, int64_t *fsmid
)
1280 struct namecache
*ncp
;
1283 TAILQ_FOREACH(ncp
, &vp
->v_namecache
, nc_vnode
) {
1284 if (ncp
->nc_flag
& NCF_FSMID
) {
1285 ncp
->nc_flag
&= ~NCF_FSMID
;
1297 * Obtain the FSMID for a vnode for filesystems which do not support
1301 cache_sync_fsmid_vp(struct vnode
*vp
)
1303 struct namecache
*ncp
;
1305 if ((ncp
= TAILQ_FIRST(&vp
->v_namecache
)) != NULL
) {
1306 if (ncp
->nc_flag
& NCF_FSMID
) {
1307 ncp
->nc_flag
&= ~NCF_FSMID
;
1310 return(ncp
->nc_fsmid
);
1316 * Convert a directory vnode to a namecache record without any other
1317 * knowledge of the topology. This ONLY works with directory vnodes and
1318 * is ONLY used by the NFS server. dvp must be refd but unlocked, and the
1319 * returned ncp (if not NULL) will be held and unlocked.
1321 * If 'makeit' is 0 and dvp has no existing namecache record, NULL is returned.
1322 * If 'makeit' is 1 we attempt to track-down and create the namecache topology
1323 * for dvp. This will fail only if the directory has been deleted out from
1326 * Callers must always check for a NULL return no matter the value of 'makeit'.
1328 * To avoid underflowing the kernel stack each recursive call increments
1329 * the makeit variable.
1332 static int cache_inefficient_scan(struct nchandle
*nch
, struct ucred
*cred
,
1333 struct vnode
*dvp
, char *fakename
);
1334 static int cache_fromdvp_try(struct vnode
*dvp
, struct ucred
*cred
,
1335 struct vnode
**saved_dvp
);
1338 cache_fromdvp(struct vnode
*dvp
, struct ucred
*cred
, int makeit
,
1339 struct nchandle
*nch
)
1341 struct vnode
*saved_dvp
;
1347 nch
->mount
= dvp
->v_mount
;
1352 * Temporary debugging code to force the directory scanning code
1355 if (ncvp_debug
>= 3 && makeit
&& TAILQ_FIRST(&dvp
->v_namecache
)) {
1356 nch
->ncp
= TAILQ_FIRST(&dvp
->v_namecache
);
1357 kprintf("cache_fromdvp: forcing %s\n", nch
->ncp
->nc_name
);
1362 * Loop until resolution, inside code will break out on error.
1364 while ((nch
->ncp
= TAILQ_FIRST(&dvp
->v_namecache
)) == NULL
&& makeit
) {
1367 * If dvp is the root of its filesystem it should already
1368 * have a namecache pointer associated with it as a side
1369 * effect of the mount, but it may have been disassociated.
1371 if (dvp
->v_flag
& VROOT
) {
1372 nch
->ncp
= _cache_get(nch
->mount
->mnt_ncmountpt
.ncp
);
1373 error
= cache_resolve_mp(nch
->mount
);
1374 _cache_put(nch
->ncp
);
1376 kprintf("cache_fromdvp: resolve root of mount %p error %d",
1377 dvp
->v_mount
, error
);
1381 kprintf(" failed\n");
1386 kprintf(" succeeded\n");
1391 * If we are recursed too deeply resort to an O(n^2)
1392 * algorithm to resolve the namecache topology. The
1393 * resolved pvp is left referenced in saved_dvp to
1394 * prevent the tree from being destroyed while we loop.
1397 error
= cache_fromdvp_try(dvp
, cred
, &saved_dvp
);
1399 kprintf("lookupdotdot(longpath) failed %d "
1400 "dvp %p\n", error
, dvp
);
1408 * Get the parent directory and resolve its ncp.
1411 kfree(fakename
, M_TEMP
);
1414 error
= vop_nlookupdotdot(*dvp
->v_ops
, dvp
, &pvp
, cred
,
1417 kprintf("lookupdotdot failed %d dvp %p\n", error
, dvp
);
1423 * Reuse makeit as a recursion depth counter. On success
1424 * nch will be fully referenced.
1426 cache_fromdvp(pvp
, cred
, makeit
+ 1, nch
);
1428 if (nch
->ncp
== NULL
)
1432 * Do an inefficient scan of pvp (embodied by ncp) to look
1433 * for dvp. This will create a namecache record for dvp on
1434 * success. We loop up to recheck on success.
1436 * ncp and dvp are both held but not locked.
1438 error
= cache_inefficient_scan(nch
, cred
, dvp
, fakename
);
1440 kprintf("cache_fromdvp: scan %p (%s) failed on dvp=%p\n",
1441 pvp
, nch
->ncp
->nc_name
, dvp
);
1443 /* nch was NULLed out, reload mount */
1444 nch
->mount
= dvp
->v_mount
;
1448 kprintf("cache_fromdvp: scan %p (%s) succeeded\n",
1449 pvp
, nch
->ncp
->nc_name
);
1452 /* nch was NULLed out, reload mount */
1453 nch
->mount
= dvp
->v_mount
;
1457 kfree(fakename
, M_TEMP
);
1460 * hold it for real so the mount gets a ref
1472 * Go up the chain of parent directories until we find something
1473 * we can resolve into the namecache. This is very inefficient.
1477 cache_fromdvp_try(struct vnode
*dvp
, struct ucred
*cred
,
1478 struct vnode
**saved_dvp
)
1480 struct nchandle nch
;
1483 static time_t last_fromdvp_report
;
1487 * Loop getting the parent directory vnode until we get something we
1488 * can resolve in the namecache.
1491 nch
.mount
= dvp
->v_mount
;
1497 kfree(fakename
, M_TEMP
);
1500 error
= vop_nlookupdotdot(*dvp
->v_ops
, dvp
, &pvp
, cred
,
1507 if ((nch
.ncp
= TAILQ_FIRST(&pvp
->v_namecache
)) != NULL
) {
1508 _cache_hold(nch
.ncp
);
1512 if (pvp
->v_flag
& VROOT
) {
1513 nch
.ncp
= _cache_get(pvp
->v_mount
->mnt_ncmountpt
.ncp
);
1514 error
= cache_resolve_mp(nch
.mount
);
1515 _cache_unlock(nch
.ncp
);
1518 _cache_drop(nch
.ncp
);
1528 if (last_fromdvp_report
!= time_second
) {
1529 last_fromdvp_report
= time_second
;
1530 kprintf("Warning: extremely inefficient path "
1531 "resolution on %s\n",
1534 error
= cache_inefficient_scan(&nch
, cred
, dvp
, fakename
);
1537 * Hopefully dvp now has a namecache record associated with
1538 * it. Leave it referenced to prevent the kernel from
1539 * recycling the vnode. Otherwise extremely long directory
1540 * paths could result in endless recycling.
1545 _cache_drop(nch
.ncp
);
1548 kfree(fakename
, M_TEMP
);
1553 * Do an inefficient scan of the directory represented by ncp looking for
1554 * the directory vnode dvp. ncp must be held but not locked on entry and
1555 * will be held on return. dvp must be refd but not locked on entry and
1556 * will remain refd on return.
1558 * Why do this at all? Well, due to its stateless nature the NFS server
1559 * converts file handles directly to vnodes without necessarily going through
1560 * the namecache ops that would otherwise create the namecache topology
1561 * leading to the vnode. We could either (1) Change the namecache algorithms
1562 * to allow disconnect namecache records that are re-merged opportunistically,
1563 * or (2) Make the NFS server backtrack and scan to recover a connected
1564 * namecache topology in order to then be able to issue new API lookups.
1566 * It turns out that (1) is a huge mess. It takes a nice clean set of
1567 * namecache algorithms and introduces a lot of complication in every subsystem
1568 * that calls into the namecache to deal with the re-merge case, especially
1569 * since we are using the namecache to placehold negative lookups and the
1570 * vnode might not be immediately assigned. (2) is certainly far less
1571 * efficient then (1), but since we are only talking about directories here
1572 * (which are likely to remain cached), the case does not actually run all
1573 * that often and has the supreme advantage of not polluting the namecache
1576 * If a fakename is supplied just construct a namecache entry using the
1580 cache_inefficient_scan(struct nchandle
*nch
, struct ucred
*cred
,
1581 struct vnode
*dvp
, char *fakename
)
1583 struct nlcomponent nlc
;
1584 struct nchandle rncp
;
1596 vat
.va_blocksize
= 0;
1597 if ((error
= VOP_GETATTR(dvp
, &vat
)) != 0)
1599 if ((error
= cache_vref(nch
, cred
, &pvp
)) != 0)
1602 kprintf("inefficient_scan: directory iosize %ld "
1603 "vattr fileid = %lld\n",
1605 (long long)vat
.va_fileid
);
1609 * Use the supplied fakename if not NULL. Fake names are typically
1610 * not in the actual filesystem hierarchy. This is used by HAMMER
1611 * to glue @@timestamp recursions together.
1614 nlc
.nlc_nameptr
= fakename
;
1615 nlc
.nlc_namelen
= strlen(fakename
);
1616 rncp
= cache_nlookup(nch
, &nlc
);
1620 if ((blksize
= vat
.va_blocksize
) == 0)
1621 blksize
= DEV_BSIZE
;
1622 rbuf
= kmalloc(blksize
, M_TEMP
, M_WAITOK
);
1628 iov
.iov_base
= rbuf
;
1629 iov
.iov_len
= blksize
;
1632 uio
.uio_resid
= blksize
;
1633 uio
.uio_segflg
= UIO_SYSSPACE
;
1634 uio
.uio_rw
= UIO_READ
;
1635 uio
.uio_td
= curthread
;
1637 if (ncvp_debug
>= 2)
1638 kprintf("cache_inefficient_scan: readdir @ %08x\n", (int)uio
.uio_offset
);
1639 error
= VOP_READDIR(pvp
, &uio
, cred
, &eofflag
, NULL
, NULL
);
1641 den
= (struct dirent
*)rbuf
;
1642 bytes
= blksize
- uio
.uio_resid
;
1645 if (ncvp_debug
>= 2) {
1646 kprintf("cache_inefficient_scan: %*.*s\n",
1647 den
->d_namlen
, den
->d_namlen
,
1650 if (den
->d_type
!= DT_WHT
&&
1651 den
->d_ino
== vat
.va_fileid
) {
1653 kprintf("cache_inefficient_scan: "
1654 "MATCHED inode %lld path %s/%*.*s\n",
1655 (long long)vat
.va_fileid
,
1657 den
->d_namlen
, den
->d_namlen
,
1660 nlc
.nlc_nameptr
= den
->d_name
;
1661 nlc
.nlc_namelen
= den
->d_namlen
;
1662 rncp
= cache_nlookup(nch
, &nlc
);
1663 KKASSERT(rncp
.ncp
!= NULL
);
1666 bytes
-= _DIRENT_DIRSIZ(den
);
1667 den
= _DIRENT_NEXT(den
);
1669 if (rncp
.ncp
== NULL
&& eofflag
== 0 && uio
.uio_resid
!= blksize
)
1672 kfree(rbuf
, M_TEMP
);
1676 if (rncp
.ncp
->nc_flag
& NCF_UNRESOLVED
) {
1677 _cache_setvp(rncp
.mount
, rncp
.ncp
, dvp
);
1678 if (ncvp_debug
>= 2) {
1679 kprintf("cache_inefficient_scan: setvp %s/%s = %p\n",
1680 nch
->ncp
->nc_name
, rncp
.ncp
->nc_name
, dvp
);
1683 if (ncvp_debug
>= 2) {
1684 kprintf("cache_inefficient_scan: setvp %s/%s already set %p/%p\n",
1685 nch
->ncp
->nc_name
, rncp
.ncp
->nc_name
, dvp
,
1689 if (rncp
.ncp
->nc_vp
== NULL
)
1690 error
= rncp
.ncp
->nc_error
;
1692 * Release rncp after a successful nlookup. rncp was fully
1697 kprintf("cache_inefficient_scan: dvp %p NOT FOUND in %s\n",
1698 dvp
, nch
->ncp
->nc_name
);
1705 * Zap a namecache entry. The ncp is unconditionally set to an unresolved
1706 * state, which disassociates it from its vnode or ncneglist.
1708 * Then, if there are no additional references to the ncp and no children,
1709 * the ncp is removed from the topology and destroyed. This function will
1710 * also run through the nc_parent chain and destroy parent ncps if possible.
1711 * As a side benefit, it turns out the only conditions that allow running
1712 * up the chain are also the conditions to ensure no deadlock will occur.
1714 * References and/or children may exist if the ncp is in the middle of the
1715 * topology, preventing the ncp from being destroyed.
1717 * This function must be called with the ncp held and locked and will unlock
1718 * and drop it during zapping.
1721 cache_zap(struct namecache
*ncp
)
1723 struct namecache
*par
;
1726 * Disassociate the vnode or negative cache ref and set NCF_UNRESOLVED.
1728 _cache_setunresolved(ncp
);
1731 * Try to scrap the entry and possibly tail-recurse on its parent.
1732 * We only scrap unref'd (other then our ref) unresolved entries,
1733 * we do not scrap 'live' entries.
1735 while (ncp
->nc_flag
& NCF_UNRESOLVED
) {
1737 * Someone other then us has a ref, stop.
1739 if (ncp
->nc_refs
> 1)
1743 * We have children, stop.
1745 if (!TAILQ_EMPTY(&ncp
->nc_list
))
1749 * Remove ncp from the topology: hash table and parent linkage.
1751 if (ncp
->nc_flag
& NCF_HASHED
) {
1752 ncp
->nc_flag
&= ~NCF_HASHED
;
1753 LIST_REMOVE(ncp
, nc_hash
);
1755 if ((par
= ncp
->nc_parent
) != NULL
) {
1756 par
= _cache_hold(par
);
1757 TAILQ_REMOVE(&par
->nc_list
, ncp
, nc_entry
);
1758 ncp
->nc_parent
= NULL
;
1759 if (par
->nc_vp
&& TAILQ_EMPTY(&par
->nc_list
))
1764 * ncp should not have picked up any refs. Physically
1767 KKASSERT(ncp
->nc_refs
== 1);
1769 /* _cache_unlock(ncp) not required */
1770 ncp
->nc_refs
= -1; /* safety */
1772 kfree(ncp
->nc_name
, M_VFSCACHE
);
1773 kfree(ncp
, M_VFSCACHE
);
1776 * Loop on the parent (it may be NULL). Only bother looping
1777 * if the parent has a single ref (ours), which also means
1778 * we can lock it trivially.
1783 if (ncp
->nc_refs
!= 1) {
1787 KKASSERT(par
->nc_exlocks
== 0);
1792 atomic_subtract_int(&ncp
->nc_refs
, 1);
1795 static enum { CHI_LOW
, CHI_HIGH
} cache_hysteresis_state
= CHI_LOW
;
1799 cache_hysteresis(void)
1802 * Don't cache too many negative hits. We use hysteresis to reduce
1803 * the impact on the critical path.
1805 switch(cache_hysteresis_state
) {
1807 if (numneg
> MINNEG
&& numneg
* ncnegfactor
> numcache
) {
1809 cache_hysteresis_state
= CHI_HIGH
;
1813 if (numneg
> MINNEG
* 9 / 10 &&
1814 numneg
* ncnegfactor
* 9 / 10 > numcache
1818 cache_hysteresis_state
= CHI_LOW
;
1825 * NEW NAMECACHE LOOKUP API
1827 * Lookup an entry in the cache. A locked, referenced, non-NULL
1828 * entry is *always* returned, even if the supplied component is illegal.
1829 * The resulting namecache entry should be returned to the system with
1830 * cache_put() or _cache_unlock() + cache_drop().
1832 * namecache locks are recursive but care must be taken to avoid lock order
1835 * Nobody else will be able to manipulate the associated namespace (e.g.
1836 * create, delete, rename, rename-target) until the caller unlocks the
1839 * The returned entry will be in one of three states: positive hit (non-null
1840 * vnode), negative hit (null vnode), or unresolved (NCF_UNRESOLVED is set).
1841 * Unresolved entries must be resolved through the filesystem to associate the
1842 * vnode and/or determine whether a positive or negative hit has occured.
1844 * It is not necessary to lock a directory in order to lock namespace under
1845 * that directory. In fact, it is explicitly not allowed to do that. A
1846 * directory is typically only locked when being created, renamed, or
1849 * The directory (par) may be unresolved, in which case any returned child
1850 * will likely also be marked unresolved. Likely but not guarenteed. Since
1851 * the filesystem lookup requires a resolved directory vnode the caller is
1852 * responsible for resolving the namecache chain top-down. This API
1853 * specifically allows whole chains to be created in an unresolved state.
1856 cache_nlookup(struct nchandle
*par_nch
, struct nlcomponent
*nlc
)
1858 struct nchandle nch
;
1859 struct namecache
*ncp
;
1860 struct namecache
*new_ncp
;
1861 struct nchashhead
*nchpp
;
1868 mp
= par_nch
->mount
;
1871 * Try to locate an existing entry
1873 hash
= fnv_32_buf(nlc
->nlc_nameptr
, nlc
->nlc_namelen
, FNV1_32_INIT
);
1874 hash
= fnv_32_buf(&par_nch
->ncp
, sizeof(par_nch
->ncp
), hash
);
1877 LIST_FOREACH(ncp
, (NCHHASH(hash
)), nc_hash
) {
1881 * Break out if we find a matching entry. Note that
1882 * UNRESOLVED entries may match, but DESTROYED entries
1885 if (ncp
->nc_parent
== par_nch
->ncp
&&
1886 ncp
->nc_nlen
== nlc
->nlc_namelen
&&
1887 bcmp(ncp
->nc_name
, nlc
->nlc_nameptr
, ncp
->nc_nlen
) == 0 &&
1888 (ncp
->nc_flag
& NCF_DESTROYED
) == 0
1890 if (_cache_get_nonblock(ncp
) == 0) {
1891 _cache_auto_unresolve(mp
, ncp
);
1893 _cache_free(new_ncp
);
1903 * We failed to locate an entry, create a new entry and add it to
1904 * the cache. We have to relookup after possibly blocking in
1907 if (new_ncp
== NULL
) {
1908 new_ncp
= cache_alloc(nlc
->nlc_namelen
);
1915 * Initialize as a new UNRESOLVED entry, lock (non-blocking),
1916 * and link to the parent. The mount point is usually inherited
1917 * from the parent unless this is a special case such as a mount
1918 * point where nlc_namelen is 0. If nlc_namelen is 0 nc_name will
1921 if (nlc
->nlc_namelen
) {
1922 bcopy(nlc
->nlc_nameptr
, ncp
->nc_name
, nlc
->nlc_namelen
);
1923 ncp
->nc_name
[nlc
->nlc_namelen
] = 0;
1925 nchpp
= NCHHASH(hash
);
1926 LIST_INSERT_HEAD(nchpp
, ncp
, nc_hash
);
1927 ncp
->nc_flag
|= NCF_HASHED
;
1928 cache_link_parent(ncp
, par_nch
->ncp
);
1931 * stats and namecache size management
1933 if (ncp
->nc_flag
& NCF_UNRESOLVED
)
1934 ++gd
->gd_nchstats
->ncs_miss
;
1935 else if (ncp
->nc_vp
)
1936 ++gd
->gd_nchstats
->ncs_goodhits
;
1938 ++gd
->gd_nchstats
->ncs_neghits
;
1942 ++nch
.mount
->mnt_refs
;
1947 * The namecache entry is marked as being used as a mount point.
1948 * Locate the mount if it is visible to the caller.
1950 struct findmount_info
{
1951 struct mount
*result
;
1952 struct mount
*nch_mount
;
1953 struct namecache
*nch_ncp
;
1958 cache_findmount_callback(struct mount
*mp
, void *data
)
1960 struct findmount_info
*info
= data
;
1963 * Check the mount's mounted-on point against the passed nch.
1965 if (mp
->mnt_ncmounton
.mount
== info
->nch_mount
&&
1966 mp
->mnt_ncmounton
.ncp
== info
->nch_ncp
1975 cache_findmount(struct nchandle
*nch
)
1977 struct findmount_info info
;
1980 info
.nch_mount
= nch
->mount
;
1981 info
.nch_ncp
= nch
->ncp
;
1982 mountlist_scan(cache_findmount_callback
, &info
,
1983 MNTSCAN_FORWARD
|MNTSCAN_NOBUSY
);
1984 return(info
.result
);
1988 * Resolve an unresolved namecache entry, generally by looking it up.
1989 * The passed ncp must be locked and refd.
1991 * Theoretically since a vnode cannot be recycled while held, and since
1992 * the nc_parent chain holds its vnode as long as children exist, the
1993 * direct parent of the cache entry we are trying to resolve should
1994 * have a valid vnode. If not then generate an error that we can
1995 * determine is related to a resolver bug.
1997 * However, if a vnode was in the middle of a recyclement when the NCP
1998 * got locked, ncp->nc_vp might point to a vnode that is about to become
1999 * invalid. cache_resolve() handles this case by unresolving the entry
2000 * and then re-resolving it.
2002 * Note that successful resolution does not necessarily return an error
2003 * code of 0. If the ncp resolves to a negative cache hit then ENOENT
2007 cache_resolve(struct nchandle
*nch
, struct ucred
*cred
)
2009 struct namecache
*par
;
2010 struct namecache
*ncp
;
2011 struct nchandle nctmp
;
2020 * If the ncp is already resolved we have nothing to do. However,
2021 * we do want to guarentee that a usable vnode is returned when
2022 * a vnode is present, so make sure it hasn't been reclaimed.
2024 if ((ncp
->nc_flag
& NCF_UNRESOLVED
) == 0) {
2025 if (ncp
->nc_vp
&& (ncp
->nc_vp
->v_flag
& VRECLAIMED
))
2026 _cache_setunresolved(ncp
);
2027 if ((ncp
->nc_flag
& NCF_UNRESOLVED
) == 0)
2028 return (ncp
->nc_error
);
2032 * Mount points need special handling because the parent does not
2033 * belong to the same filesystem as the ncp.
2035 if (ncp
== mp
->mnt_ncmountpt
.ncp
)
2036 return (cache_resolve_mp(mp
));
2039 * We expect an unbroken chain of ncps to at least the mount point,
2040 * and even all the way to root (but this code doesn't have to go
2041 * past the mount point).
2043 if (ncp
->nc_parent
== NULL
) {
2044 kprintf("EXDEV case 1 %p %*.*s\n", ncp
,
2045 ncp
->nc_nlen
, ncp
->nc_nlen
, ncp
->nc_name
);
2046 ncp
->nc_error
= EXDEV
;
2047 return(ncp
->nc_error
);
2051 * The vp's of the parent directories in the chain are held via vhold()
2052 * due to the existance of the child, and should not disappear.
2053 * However, there are cases where they can disappear:
2055 * - due to filesystem I/O errors.
2056 * - due to NFS being stupid about tracking the namespace and
2057 * destroys the namespace for entire directories quite often.
2058 * - due to forced unmounts.
2059 * - due to an rmdir (parent will be marked DESTROYED)
2061 * When this occurs we have to track the chain backwards and resolve
2062 * it, looping until the resolver catches up to the current node. We
2063 * could recurse here but we might run ourselves out of kernel stack
2064 * so we do it in a more painful manner. This situation really should
2065 * not occur all that often, or if it does not have to go back too
2066 * many nodes to resolve the ncp.
2068 while ((dvp
= cache_dvpref(ncp
)) == NULL
) {
2070 * This case can occur if a process is CD'd into a
2071 * directory which is then rmdir'd. If the parent is marked
2072 * destroyed there is no point trying to resolve it.
2074 if (ncp
->nc_parent
->nc_flag
& NCF_DESTROYED
)
2077 par
= ncp
->nc_parent
;
2078 while (par
->nc_parent
&& par
->nc_parent
->nc_vp
== NULL
)
2079 par
= par
->nc_parent
;
2080 if (par
->nc_parent
== NULL
) {
2081 kprintf("EXDEV case 2 %*.*s\n",
2082 par
->nc_nlen
, par
->nc_nlen
, par
->nc_name
);
2085 kprintf("[diagnostic] cache_resolve: had to recurse on %*.*s\n",
2086 par
->nc_nlen
, par
->nc_nlen
, par
->nc_name
);
2088 * The parent is not set in stone, ref and lock it to prevent
2089 * it from disappearing. Also note that due to renames it
2090 * is possible for our ncp to move and for par to no longer
2091 * be one of its parents. We resolve it anyway, the loop
2092 * will handle any moves.
2095 if (par
== nch
->mount
->mnt_ncmountpt
.ncp
) {
2096 cache_resolve_mp(nch
->mount
);
2097 } else if ((dvp
= cache_dvpref(par
)) == NULL
) {
2098 kprintf("[diagnostic] cache_resolve: raced on %*.*s\n", par
->nc_nlen
, par
->nc_nlen
, par
->nc_name
);
2102 if (par
->nc_flag
& NCF_UNRESOLVED
) {
2105 par
->nc_error
= VOP_NRESOLVE(&nctmp
, dvp
, cred
);
2109 if ((error
= par
->nc_error
) != 0) {
2110 if (par
->nc_error
!= EAGAIN
) {
2111 kprintf("EXDEV case 3 %*.*s error %d\n",
2112 par
->nc_nlen
, par
->nc_nlen
, par
->nc_name
,
2117 kprintf("[diagnostic] cache_resolve: EAGAIN par %p %*.*s\n",
2118 par
, par
->nc_nlen
, par
->nc_nlen
, par
->nc_name
);
2125 * Call VOP_NRESOLVE() to get the vp, then scan for any disconnected
2126 * ncp's and reattach them. If this occurs the original ncp is marked
2127 * EAGAIN to force a relookup.
2129 * NOTE: in order to call VOP_NRESOLVE(), the parent of the passed
2130 * ncp must already be resolved.
2135 ncp
->nc_error
= VOP_NRESOLVE(&nctmp
, dvp
, cred
);
2138 ncp
->nc_error
= EPERM
;
2140 if (ncp
->nc_error
== EAGAIN
) {
2141 kprintf("[diagnostic] cache_resolve: EAGAIN ncp %p %*.*s\n",
2142 ncp
, ncp
->nc_nlen
, ncp
->nc_nlen
, ncp
->nc_name
);
2145 return(ncp
->nc_error
);
2149 * Resolve the ncp associated with a mount point. Such ncp's almost always
2150 * remain resolved and this routine is rarely called. NFS MPs tends to force
2151 * re-resolution more often due to its mac-truck-smash-the-namecache
2152 * method of tracking namespace changes.
2154 * The semantics for this call is that the passed ncp must be locked on
2155 * entry and will be locked on return. However, if we actually have to
2156 * resolve the mount point we temporarily unlock the entry in order to
2157 * avoid race-to-root deadlocks due to e.g. dead NFS mounts. Because of
2158 * the unlock we have to recheck the flags after we relock.
2161 cache_resolve_mp(struct mount
*mp
)
2163 struct namecache
*ncp
= mp
->mnt_ncmountpt
.ncp
;
2167 KKASSERT(mp
!= NULL
);
2170 * If the ncp is already resolved we have nothing to do. However,
2171 * we do want to guarentee that a usable vnode is returned when
2172 * a vnode is present, so make sure it hasn't been reclaimed.
2174 if ((ncp
->nc_flag
& NCF_UNRESOLVED
) == 0) {
2175 if (ncp
->nc_vp
&& (ncp
->nc_vp
->v_flag
& VRECLAIMED
))
2176 _cache_setunresolved(ncp
);
2179 if (ncp
->nc_flag
& NCF_UNRESOLVED
) {
2181 while (vfs_busy(mp
, 0))
2183 error
= VFS_ROOT(mp
, &vp
);
2187 * recheck the ncp state after relocking.
2189 if (ncp
->nc_flag
& NCF_UNRESOLVED
) {
2190 ncp
->nc_error
= error
;
2192 _cache_setvp(mp
, ncp
, vp
);
2195 kprintf("[diagnostic] cache_resolve_mp: failed"
2196 " to resolve mount %p err=%d ncp=%p\n",
2198 _cache_setvp(mp
, ncp
, NULL
);
2200 } else if (error
== 0) {
2205 return(ncp
->nc_error
);
2209 cache_cleanneg(int count
)
2211 struct namecache
*ncp
;
2214 * Automode from the vnlru proc - clean out 10% of the negative cache
2218 count
= numneg
/ 10 + 1;
2221 * Attempt to clean out the specified number of negative cache
2225 ncp
= TAILQ_FIRST(&ncneglist
);
2227 KKASSERT(numneg
== 0);
2230 TAILQ_REMOVE(&ncneglist
, ncp
, nc_vnode
);
2231 TAILQ_INSERT_TAIL(&ncneglist
, ncp
, nc_vnode
);
2232 if (_cache_get_nonblock(ncp
) == 0)
2239 * Rehash a ncp. Rehashing is typically required if the name changes (should
2240 * not generally occur) or the parent link changes. This function will
2241 * unhash the ncp if the ncp is no longer hashable.
2244 _cache_rehash(struct namecache
*ncp
)
2246 struct nchashhead
*nchpp
;
2249 if (ncp
->nc_flag
& NCF_HASHED
) {
2250 ncp
->nc_flag
&= ~NCF_HASHED
;
2251 LIST_REMOVE(ncp
, nc_hash
);
2253 if (ncp
->nc_nlen
&& ncp
->nc_parent
) {
2254 hash
= fnv_32_buf(ncp
->nc_name
, ncp
->nc_nlen
, FNV1_32_INIT
);
2255 hash
= fnv_32_buf(&ncp
->nc_parent
,
2256 sizeof(ncp
->nc_parent
), hash
);
2257 nchpp
= NCHHASH(hash
);
2258 LIST_INSERT_HEAD(nchpp
, ncp
, nc_hash
);
2259 ncp
->nc_flag
|= NCF_HASHED
;
2264 * Name cache initialization, from vfsinit() when we are booting
2272 /* initialise per-cpu namecache effectiveness statistics. */
2273 for (i
= 0; i
< ncpus
; ++i
) {
2274 gd
= globaldata_find(i
);
2275 gd
->gd_nchstats
= &nchstats
[i
];
2277 TAILQ_INIT(&ncneglist
);
2278 nchashtbl
= hashinit(desiredvnodes
*2, M_VFSCACHE
, &nchash
);
2279 nclockwarn
= 5 * hz
;
2283 * Called from start_init() to bootstrap the root filesystem. Returns
2284 * a referenced, unlocked namecache record.
2287 cache_allocroot(struct nchandle
*nch
, struct mount
*mp
, struct vnode
*vp
)
2289 nch
->ncp
= cache_alloc(0);
2293 _cache_setvp(nch
->mount
, nch
->ncp
, vp
);
2297 * vfs_cache_setroot()
2299 * Create an association between the root of our namecache and
2300 * the root vnode. This routine may be called several times during
2303 * If the caller intends to save the returned namecache pointer somewhere
2304 * it must cache_hold() it.
2307 vfs_cache_setroot(struct vnode
*nvp
, struct nchandle
*nch
)
2310 struct nchandle onch
;
2318 cache_zero(&rootnch
);
2326 * XXX OLD API COMPAT FUNCTION. This really messes up the new namecache
2327 * topology and is being removed as quickly as possible. The new VOP_N*()
2328 * API calls are required to make specific adjustments using the supplied
2329 * ncp pointers rather then just bogusly purging random vnodes.
2331 * Invalidate all namecache entries to a particular vnode as well as
2332 * any direct children of that vnode in the namecache. This is a
2333 * 'catch all' purge used by filesystems that do not know any better.
2335 * Note that the linkage between the vnode and its namecache entries will
2336 * be removed, but the namecache entries themselves might stay put due to
2337 * active references from elsewhere in the system or due to the existance of
2338 * the children. The namecache topology is left intact even if we do not
2339 * know what the vnode association is. Such entries will be marked
2343 cache_purge(struct vnode
*vp
)
2345 cache_inval_vp(vp
, CINV_DESTROY
| CINV_CHILDREN
);
2349 * Flush all entries referencing a particular filesystem.
2351 * Since we need to check it anyway, we will flush all the invalid
2352 * entries at the same time.
2357 cache_purgevfs(struct mount
*mp
)
2359 struct nchashhead
*nchpp
;
2360 struct namecache
*ncp
, *nnp
;
2363 * Scan hash tables for applicable entries.
2365 for (nchpp
= &nchashtbl
[nchash
]; nchpp
>= nchashtbl
; nchpp
--) {
2366 ncp
= LIST_FIRST(nchpp
);
2370 nnp
= LIST_NEXT(ncp
, nc_hash
);
2373 if (ncp
->nc_mount
== mp
) {
2387 * Create a new (theoretically) unique fsmid
2390 cache_getnewfsmid(void)
2392 static int fsmid_roller
;
2396 fsmid
= ((int64_t)time_second
<< 32) |
2397 (fsmid_roller
& 0x7FFFFFFF);
2402 static int disablecwd
;
2403 SYSCTL_INT(_debug
, OID_AUTO
, disablecwd
, CTLFLAG_RW
, &disablecwd
, 0, "");
2405 static u_long numcwdcalls
; STATNODE(CTLFLAG_RD
, numcwdcalls
, &numcwdcalls
);
2406 static u_long numcwdfail1
; STATNODE(CTLFLAG_RD
, numcwdfail1
, &numcwdfail1
);
2407 static u_long numcwdfail2
; STATNODE(CTLFLAG_RD
, numcwdfail2
, &numcwdfail2
);
2408 static u_long numcwdfail3
; STATNODE(CTLFLAG_RD
, numcwdfail3
, &numcwdfail3
);
2409 static u_long numcwdfail4
; STATNODE(CTLFLAG_RD
, numcwdfail4
, &numcwdfail4
);
2410 static u_long numcwdfound
; STATNODE(CTLFLAG_RD
, numcwdfound
, &numcwdfound
);
2413 sys___getcwd(struct __getcwd_args
*uap
)
2423 buflen
= uap
->buflen
;
2426 if (buflen
> MAXPATHLEN
)
2427 buflen
= MAXPATHLEN
;
2429 buf
= kmalloc(buflen
, M_TEMP
, M_WAITOK
);
2430 bp
= kern_getcwd(buf
, buflen
, &error
);
2432 error
= copyout(bp
, uap
->buf
, strlen(bp
) + 1);
2438 kern_getcwd(char *buf
, size_t buflen
, int *error
)
2440 struct proc
*p
= curproc
;
2442 int i
, slash_prefixed
;
2443 struct filedesc
*fdp
;
2444 struct nchandle nch
;
2453 nch
= fdp
->fd_ncdir
;
2454 while (nch
.ncp
&& (nch
.ncp
!= fdp
->fd_nrdir
.ncp
||
2455 nch
.mount
!= fdp
->fd_nrdir
.mount
)
2458 * While traversing upwards if we encounter the root
2459 * of the current mount we have to skip to the mount point
2460 * in the underlying filesystem.
2462 if (nch
.ncp
== nch
.mount
->mnt_ncmountpt
.ncp
) {
2463 nch
= nch
.mount
->mnt_ncmounton
;
2468 * Prepend the path segment
2470 for (i
= nch
.ncp
->nc_nlen
- 1; i
>= 0; i
--) {
2476 *--bp
= nch
.ncp
->nc_name
[i
];
2487 * Go up a directory. This isn't a mount point so we don't
2488 * have to check again.
2490 nch
.ncp
= nch
.ncp
->nc_parent
;
2492 if (nch
.ncp
== NULL
) {
2497 if (!slash_prefixed
) {
2511 * Thus begins the fullpath magic.
2515 #define STATNODE(name) \
2516 static u_int name; \
2517 SYSCTL_UINT(_vfs_cache, OID_AUTO, name, CTLFLAG_RD, &name, 0, "")
2519 static int disablefullpath
;
2520 SYSCTL_INT(_debug
, OID_AUTO
, disablefullpath
, CTLFLAG_RW
,
2521 &disablefullpath
, 0, "");
2523 STATNODE(numfullpathcalls
);
2524 STATNODE(numfullpathfail1
);
2525 STATNODE(numfullpathfail2
);
2526 STATNODE(numfullpathfail3
);
2527 STATNODE(numfullpathfail4
);
2528 STATNODE(numfullpathfound
);
2531 cache_fullpath(struct proc
*p
, struct nchandle
*nchp
, char **retbuf
, char **freebuf
)
2534 int i
, slash_prefixed
;
2535 struct nchandle fd_nrdir
;
2536 struct nchandle nch
;
2543 buf
= kmalloc(MAXPATHLEN
, M_TEMP
, M_WAITOK
);
2544 bp
= buf
+ MAXPATHLEN
- 1;
2547 fd_nrdir
= p
->p_fd
->fd_nrdir
;
2554 (nch
.ncp
!= fd_nrdir
.ncp
|| nch
.mount
!= fd_nrdir
.mount
)
2557 * While traversing upwards if we encounter the root
2558 * of the current mount we have to skip to the mount point.
2560 if (nch
.ncp
== nch
.mount
->mnt_ncmountpt
.ncp
) {
2561 nch
= nch
.mount
->mnt_ncmounton
;
2566 * Prepend the path segment
2568 for (i
= nch
.ncp
->nc_nlen
- 1; i
>= 0; i
--) {
2574 *--bp
= nch
.ncp
->nc_name
[i
];
2585 * Go up a directory. This isn't a mount point so we don't
2586 * have to check again.
2588 nch
.ncp
= nch
.ncp
->nc_parent
;
2590 if (nch
.ncp
== NULL
) {
2596 if (!slash_prefixed
) {
2612 vn_fullpath(struct proc
*p
, struct vnode
*vn
, char **retbuf
, char **freebuf
)
2614 struct namecache
*ncp
;
2615 struct nchandle nch
;
2618 if (disablefullpath
)
2624 /* vn is NULL, client wants us to use p->p_textvp */
2626 if ((vn
= p
->p_textvp
) == NULL
)
2629 TAILQ_FOREACH(ncp
, &vn
->v_namecache
, nc_vnode
) {
2638 nch
.mount
= vn
->v_mount
;
2639 return(cache_fullpath(p
, &nch
, retbuf
, freebuf
));