8367997598cb972d03c420c12b2bf84dc0db57cd
[dragonfly.git] / sys / kern / vfs_cache.c
1 /*
2  * Copyright (c) 2003,2004 The DragonFly Project.  All rights reserved.
3  * 
4  * This code is derived from software contributed to The DragonFly Project
5  * by Matthew Dillon <dillon@backplane.com>
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  * 
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
16  *    distribution.
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.
20  * 
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
32  * SUCH DAMAGE.
33  * 
34  * Copyright (c) 1989, 1993, 1995
35  *      The Regents of the University of California.  All rights reserved.
36  *
37  * This code is derived from software contributed to Berkeley by
38  * Poul-Henning Kamp of the FreeBSD Project.
39  *
40  * Redistribution and use in source and binary forms, with or without
41  * modification, are permitted provided that the following conditions
42  * are met:
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.
55  *
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
66  * SUCH DAMAGE.
67  *
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 $
71  */
72
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>
81 #include <sys/proc.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>
89 #include <ddb/ddb.h>
90
91 #include <sys/sysref2.h>
92 #include <sys/mplock2.h>
93
94 #define MAX_RECURSION_DEPTH     64
95
96 /*
97  * Random lookups in the cache are accomplished with a hash table using
98  * a hash key of (nc_src_vp, name).
99  *
100  * Negative entries may exist and correspond to structures where nc_vp
101  * is NULL.  In a negative entry, NCF_WHITEOUT will be set if the entry
102  * corresponds to a whited-out directory entry (verses simply not finding the
103  * entry at all).
104  *
105  * Upon reaching the last segment of a path, if the reference is for DELETE,
106  * or NOCACHE is set (rewrite), and the name is located in the cache, it
107  * will be dropped.
108  */
109
110 /*
111  * Structures associated with name cacheing.
112  */
113 #define NCHHASH(hash)   (&nchashtbl[(hash) & nchash])
114 #define MINNEG          1024
115
116 MALLOC_DEFINE(M_VFSCACHE, "vfscache", "VFS name cache entries");
117
118 static LIST_HEAD(nchashhead, namecache) *nchashtbl;     /* Hash Table */
119 static struct namecache_list    ncneglist;              /* instead of vnode */
120
121 /*
122  * ncvp_debug - debug cache_fromvp().  This is used by the NFS server
123  * to create the namecache infrastructure leading to a dangling vnode.
124  *
125  * 0    Only errors are reported
126  * 1    Successes are reported
127  * 2    Successes + the whole directory scan is reported
128  * 3    Force the directory scan code run as if the parent vnode did not
129  *      have a namecache record, even if it does have one.
130  */
131 static int      ncvp_debug;
132 SYSCTL_INT(_debug, OID_AUTO, ncvp_debug, CTLFLAG_RW, &ncvp_debug, 0, "");
133
134 static u_long   nchash;                 /* size of hash table */
135 SYSCTL_ULONG(_debug, OID_AUTO, nchash, CTLFLAG_RD, &nchash, 0, "");
136
137 static u_long   ncnegfactor = 16;       /* ratio of negative entries */
138 SYSCTL_ULONG(_debug, OID_AUTO, ncnegfactor, CTLFLAG_RW, &ncnegfactor, 0, "");
139
140 static int      nclockwarn;             /* warn on locked entries in ticks */
141 SYSCTL_INT(_debug, OID_AUTO, nclockwarn, CTLFLAG_RW, &nclockwarn, 0, "");
142
143 static u_long   numneg;         /* number of cache entries allocated */
144 SYSCTL_ULONG(_debug, OID_AUTO, numneg, CTLFLAG_RD, &numneg, 0, "");
145
146 static u_long   numcache;               /* number of cache entries allocated */
147 SYSCTL_ULONG(_debug, OID_AUTO, numcache, CTLFLAG_RD, &numcache, 0, "");
148
149 static u_long   numunres;               /* number of unresolved entries */
150 SYSCTL_ULONG(_debug, OID_AUTO, numunres, CTLFLAG_RD, &numunres, 0, "");
151
152 SYSCTL_INT(_debug, OID_AUTO, vnsize, CTLFLAG_RD, 0, sizeof(struct vnode), "");
153 SYSCTL_INT(_debug, OID_AUTO, ncsize, CTLFLAG_RD, 0, sizeof(struct namecache), "");
154
155 static int cache_resolve_mp(struct mount *mp);
156 static struct vnode *cache_dvpref(struct namecache *ncp);
157 static void _cache_rehash(struct namecache *ncp);
158 static void _cache_lock(struct namecache *ncp);
159 static void _cache_setunresolved(struct namecache *ncp);
160
161 /*
162  * The new name cache statistics
163  */
164 SYSCTL_NODE(_vfs, OID_AUTO, cache, CTLFLAG_RW, 0, "Name cache statistics");
165 #define STATNODE(mode, name, var) \
166         SYSCTL_ULONG(_vfs_cache, OID_AUTO, name, mode, var, 0, "");
167 STATNODE(CTLFLAG_RD, numneg, &numneg);
168 STATNODE(CTLFLAG_RD, numcache, &numcache);
169 static u_long numcalls; STATNODE(CTLFLAG_RD, numcalls, &numcalls);
170 static u_long dothits; STATNODE(CTLFLAG_RD, dothits, &dothits);
171 static u_long dotdothits; STATNODE(CTLFLAG_RD, dotdothits, &dotdothits);
172 static u_long numchecks; STATNODE(CTLFLAG_RD, numchecks, &numchecks);
173 static u_long nummiss; STATNODE(CTLFLAG_RD, nummiss, &nummiss);
174 static u_long nummisszap; STATNODE(CTLFLAG_RD, nummisszap, &nummisszap);
175 static u_long numposzaps; STATNODE(CTLFLAG_RD, numposzaps, &numposzaps);
176 static u_long numposhits; STATNODE(CTLFLAG_RD, numposhits, &numposhits);
177 static u_long numnegzaps; STATNODE(CTLFLAG_RD, numnegzaps, &numnegzaps);
178 static u_long numneghits; STATNODE(CTLFLAG_RD, numneghits, &numneghits);
179
180 struct nchstats nchstats[SMP_MAXCPU];
181 /*
182  * Export VFS cache effectiveness statistics to user-land.
183  *
184  * The statistics are left for aggregation to user-land so
185  * neat things can be achieved, like observing per-CPU cache
186  * distribution.
187  */
188 static int
189 sysctl_nchstats(SYSCTL_HANDLER_ARGS)
190 {
191         struct globaldata *gd;
192         int i, error;
193
194         error = 0;
195         for (i = 0; i < ncpus; ++i) {
196                 gd = globaldata_find(i);
197                 if ((error = SYSCTL_OUT(req, (void *)&(*gd->gd_nchstats),
198                         sizeof(struct nchstats))))
199                         break;
200         }
201
202         return (error);
203 }
204 SYSCTL_PROC(_vfs_cache, OID_AUTO, nchstats, CTLTYPE_OPAQUE|CTLFLAG_RD,
205   0, 0, sysctl_nchstats, "S,nchstats", "VFS cache effectiveness statistics");
206
207 static void cache_zap(struct namecache *ncp);
208
209 /*
210  * cache_hold() and cache_drop() prevent the premature deletion of a
211  * namecache entry but do not prevent operations (such as zapping) on
212  * that namecache entry.
213  *
214  * This routine may only be called from outside this source module if
215  * nc_refs is already at least 1.
216  *
217  * This is a rare case where callers are allowed to hold a spinlock,
218  * so we can't ourselves.
219  */
220 static __inline
221 struct namecache *
222 _cache_hold(struct namecache *ncp)
223 {
224         atomic_add_int(&ncp->nc_refs, 1);
225         return(ncp);
226 }
227
228 /*
229  * When dropping an entry, if only one ref remains and the entry has not
230  * been resolved, zap it.  Since the one reference is being dropped the
231  * entry had better not be locked.
232  */
233 static __inline
234 void
235 _cache_drop(struct namecache *ncp)
236 {
237         KKASSERT(ncp->nc_refs > 0);
238         if (ncp->nc_refs == 1 && 
239             (ncp->nc_flag & NCF_UNRESOLVED) && 
240             TAILQ_EMPTY(&ncp->nc_list)
241         ) {
242                 KKASSERT(ncp->nc_exlocks == 0);
243                 _cache_lock(ncp);
244                 cache_zap(ncp);
245         } else {
246                 atomic_subtract_int(&ncp->nc_refs, 1);
247         }
248 }
249
250 /*
251  * Link a new namecache entry to its parent.  Be careful to avoid races
252  * if vhold() blocks in the future.
253  */
254 static void
255 cache_link_parent(struct namecache *ncp, struct namecache *par)
256 {
257         KKASSERT(ncp->nc_parent == NULL);
258         ncp->nc_parent = par;
259         if (TAILQ_EMPTY(&par->nc_list)) {
260                 TAILQ_INSERT_HEAD(&par->nc_list, ncp, nc_entry);
261                 /*
262                  * Any vp associated with an ncp which has children must
263                  * be held to prevent it from being recycled.
264                  */
265                 if (par->nc_vp)
266                         vhold(par->nc_vp);
267         } else {
268                 TAILQ_INSERT_HEAD(&par->nc_list, ncp, nc_entry);
269         }
270 }
271
272 /*
273  * Remove the parent association from a namecache structure.  If this is
274  * the last child of the parent the cache_drop(par) will attempt to
275  * recursively zap the parent.
276  */
277 static void
278 cache_unlink_parent(struct namecache *ncp)
279 {
280         struct namecache *par;
281
282         if ((par = ncp->nc_parent) != NULL) {
283                 ncp->nc_parent = NULL;
284                 par = _cache_hold(par);
285                 TAILQ_REMOVE(&par->nc_list, ncp, nc_entry);
286                 if (par->nc_vp && TAILQ_EMPTY(&par->nc_list))
287                         vdrop(par->nc_vp);
288                 _cache_drop(par);
289         }
290 }
291
292 /*
293  * Allocate a new namecache structure.  Most of the code does not require
294  * zero-termination of the string but it makes vop_compat_ncreate() easier.
295  */
296 static struct namecache *
297 cache_alloc(int nlen)
298 {
299         struct namecache *ncp;
300
301         ncp = kmalloc(sizeof(*ncp), M_VFSCACHE, M_WAITOK|M_ZERO);
302         if (nlen)
303                 ncp->nc_name = kmalloc(nlen + 1, M_VFSCACHE, M_WAITOK);
304         ncp->nc_nlen = nlen;
305         ncp->nc_flag = NCF_UNRESOLVED;
306         ncp->nc_error = ENOTCONN;       /* needs to be resolved */
307         ncp->nc_refs = 1;
308
309         /*
310          * Construct a fake FSMID based on the time of day and a 32 bit
311          * roller for uniqueness.  This is used to generate a useful
312          * FSMID for filesystems which do not support it.
313          */
314         ncp->nc_fsmid = cache_getnewfsmid();
315         TAILQ_INIT(&ncp->nc_list);
316         _cache_lock(ncp);
317         return(ncp);
318 }
319
320 static void
321 _cache_free(struct namecache *ncp)
322 {
323         KKASSERT(ncp->nc_refs == 1 && ncp->nc_exlocks == 1);
324         if (ncp->nc_name)
325                 kfree(ncp->nc_name, M_VFSCACHE);
326         kfree(ncp, M_VFSCACHE);
327 }
328
329 void
330 cache_zero(struct nchandle *nch)
331 {
332         nch->ncp = NULL;
333         nch->mount = NULL;
334 }
335
336 /*
337  * Ref and deref a namecache structure.
338  *
339  * Warning: caller may hold an unrelated read spinlock, which means we can't
340  * use read spinlocks here.
341  */
342 struct nchandle *
343 cache_hold(struct nchandle *nch)
344 {
345         _cache_hold(nch->ncp);
346         ++nch->mount->mnt_refs;
347         return(nch);
348 }
349
350 void
351 cache_copy(struct nchandle *nch, struct nchandle *target)
352 {
353         *target = *nch;
354         _cache_hold(target->ncp);
355         ++nch->mount->mnt_refs;
356 }
357
358 void
359 cache_changemount(struct nchandle *nch, struct mount *mp)
360 {
361         --nch->mount->mnt_refs;
362         nch->mount = mp;
363         ++nch->mount->mnt_refs;
364 }
365
366 void
367 cache_drop(struct nchandle *nch)
368 {
369         --nch->mount->mnt_refs;
370         _cache_drop(nch->ncp);
371         nch->ncp = NULL;
372         nch->mount = NULL;
373 }
374
375 /*
376  * Namespace locking.  The caller must already hold a reference to the
377  * namecache structure in order to lock/unlock it.  This function prevents
378  * the namespace from being created or destroyed by accessors other then
379  * the lock holder.
380  *
381  * Note that holding a locked namecache structure prevents other threads
382  * from making namespace changes (e.g. deleting or creating), prevents
383  * vnode association state changes by other threads, and prevents the
384  * namecache entry from being resolved or unresolved by other threads.
385  *
386  * The lock owner has full authority to associate/disassociate vnodes
387  * and resolve/unresolve the locked ncp.
388  *
389  * WARNING!  Holding a locked ncp will prevent a vnode from being destroyed
390  * or recycled, but it does NOT help you if the vnode had already initiated
391  * a recyclement.  If this is important, use cache_get() rather then 
392  * cache_lock() (and deal with the differences in the way the refs counter
393  * is handled).  Or, alternatively, make an unconditional call to 
394  * cache_validate() or cache_resolve() after cache_lock() returns.
395  */
396 static
397 void
398 _cache_lock(struct namecache *ncp)
399 {
400         thread_t td;
401         int didwarn;
402
403         KKASSERT(ncp->nc_refs != 0);
404         didwarn = 0;
405         td = curthread;
406
407         for (;;) {
408                 if (ncp->nc_exlocks == 0) {
409                         ncp->nc_exlocks = 1;
410                         ncp->nc_locktd = td;
411                         /* 
412                          * The vp associated with a locked ncp must be held
413                          * to prevent it from being recycled (which would
414                          * cause the ncp to become unresolved).
415                          *
416                          * WARNING!  If VRECLAIMED is set the vnode could
417                          * already be in the middle of a recycle.  Callers
418                          * should not assume that nc_vp is usable when
419                          * not NULL.  cache_vref() or cache_vget() must be
420                          * called.
421                          *
422                          * XXX loop on race for later MPSAFE work.
423                          */
424                         if (ncp->nc_vp)
425                                 vhold(ncp->nc_vp);
426                         break;
427                 }
428                 if (ncp->nc_locktd == td) {
429                         ++ncp->nc_exlocks;
430                         break;
431                 }
432                 ncp->nc_flag |= NCF_LOCKREQ;
433                 if (tsleep(ncp, 0, "clock", nclockwarn) == EWOULDBLOCK) {
434                         if (didwarn)
435                                 continue;
436                         didwarn = 1;
437                         kprintf("[diagnostic] cache_lock: blocked on %p", ncp);
438                         kprintf(" \"%*.*s\"\n",
439                                 ncp->nc_nlen, ncp->nc_nlen, ncp->nc_name);
440                 }
441         }
442
443         if (didwarn == 1) {
444                 kprintf("[diagnostic] cache_lock: unblocked %*.*s\n",
445                         ncp->nc_nlen, ncp->nc_nlen, ncp->nc_name);
446         }
447 }
448
449 void
450 cache_lock(struct nchandle *nch)
451 {
452         _cache_lock(nch->ncp);
453 }
454
455 static
456 int
457 _cache_lock_nonblock(struct namecache *ncp)
458 {
459         thread_t td;
460
461         KKASSERT(ncp->nc_refs != 0);
462         td = curthread;
463         if (ncp->nc_exlocks == 0) {
464                 ncp->nc_exlocks = 1;
465                 ncp->nc_locktd = td;
466                 /* 
467                  * The vp associated with a locked ncp must be held
468                  * to prevent it from being recycled (which would
469                  * cause the ncp to become unresolved).
470                  *
471                  * WARNING!  If VRECLAIMED is set the vnode could
472                  * already be in the middle of a recycle.  Callers
473                  * should not assume that nc_vp is usable when
474                  * not NULL.  cache_vref() or cache_vget() must be
475                  * called.
476                  *
477                  * XXX loop on race for later MPSAFE work.
478                  */
479                 if (ncp->nc_vp)
480                         vhold(ncp->nc_vp);
481                 return(0);
482         } else {
483                 return(EWOULDBLOCK);
484         }
485 }
486
487 int
488 cache_lock_nonblock(struct nchandle *nch)
489 {
490         return(_cache_lock_nonblock(nch->ncp));
491 }
492
493 static
494 void
495 _cache_unlock(struct namecache *ncp)
496 {
497         thread_t td __debugvar = curthread;
498
499         KKASSERT(ncp->nc_refs > 0);
500         KKASSERT(ncp->nc_exlocks > 0);
501         KKASSERT(ncp->nc_locktd == td);
502         if (--ncp->nc_exlocks == 0) {
503                 if (ncp->nc_vp)
504                         vdrop(ncp->nc_vp);
505                 ncp->nc_locktd = NULL;
506                 if (ncp->nc_flag & NCF_LOCKREQ) {
507                         ncp->nc_flag &= ~NCF_LOCKREQ;
508                         wakeup(ncp);
509                 }
510         }
511 }
512
513 void
514 cache_unlock(struct nchandle *nch)
515 {
516         _cache_unlock(nch->ncp);
517 }
518
519 /*
520  * ref-and-lock, unlock-and-deref functions.
521  *
522  * This function is primarily used by nlookup.  Even though cache_lock
523  * holds the vnode, it is possible that the vnode may have already
524  * initiated a recyclement.  We want cache_get() to return a definitively
525  * usable vnode or a definitively unresolved ncp.
526  */
527 static
528 struct namecache *
529 _cache_get(struct namecache *ncp)
530 {
531         _cache_hold(ncp);
532         _cache_lock(ncp);
533         if (ncp->nc_vp && (ncp->nc_vp->v_flag & VRECLAIMED))
534                 _cache_setunresolved(ncp);
535         return(ncp);
536 }
537
538 /*
539  * note: the same nchandle can be passed for both arguments.
540  */
541 void
542 cache_get(struct nchandle *nch, struct nchandle *target)
543 {
544         target->mount = nch->mount;
545         target->ncp = _cache_get(nch->ncp);
546         ++target->mount->mnt_refs;
547 }
548
549 static int
550 _cache_get_nonblock(struct namecache *ncp)
551 {
552         /* XXX MP */
553         if (ncp->nc_exlocks == 0 || ncp->nc_locktd == curthread) {
554                 _cache_hold(ncp);
555                 _cache_lock(ncp);
556                 if (ncp->nc_vp && (ncp->nc_vp->v_flag & VRECLAIMED))
557                         _cache_setunresolved(ncp);
558                 return(0);
559         }
560         return(EWOULDBLOCK);
561 }
562
563 int
564 cache_get_nonblock(struct nchandle *nch)
565 {
566         int error;
567
568         if ((error = _cache_get_nonblock(nch->ncp)) == 0)
569                 ++nch->mount->mnt_refs;
570         return (error);
571 }
572
573 static __inline
574 void
575 _cache_put(struct namecache *ncp)
576 {
577         _cache_unlock(ncp);
578         _cache_drop(ncp);
579 }
580
581 void
582 cache_put(struct nchandle *nch)
583 {
584         --nch->mount->mnt_refs;
585         _cache_put(nch->ncp);
586         nch->ncp = NULL;
587         nch->mount = NULL;
588 }
589
590 /*
591  * Resolve an unresolved ncp by associating a vnode with it.  If the
592  * vnode is NULL, a negative cache entry is created.
593  *
594  * The ncp should be locked on entry and will remain locked on return.
595  */
596 static
597 void
598 _cache_setvp(struct mount *mp, struct namecache *ncp, struct vnode *vp)
599 {
600         KKASSERT(ncp->nc_flag & NCF_UNRESOLVED);
601         ncp->nc_vp = vp;
602         if (vp != NULL) {
603                 /*
604                  * Any vp associated with an ncp which has children must
605                  * be held.  Any vp associated with a locked ncp must be held.
606                  */
607                 if (!TAILQ_EMPTY(&ncp->nc_list))
608                         vhold(vp);
609                 TAILQ_INSERT_HEAD(&vp->v_namecache, ncp, nc_vnode);
610                 if (ncp->nc_exlocks)
611                         vhold(vp);
612
613                 /*
614                  * Set auxiliary flags
615                  */
616                 switch(vp->v_type) {
617                 case VDIR:
618                         ncp->nc_flag |= NCF_ISDIR;
619                         break;
620                 case VLNK:
621                         ncp->nc_flag |= NCF_ISSYMLINK;
622                         /* XXX cache the contents of the symlink */
623                         break;
624                 default:
625                         break;
626                 }
627                 ++numcache;
628                 ncp->nc_error = 0;
629         } else {
630                 /*
631                  * When creating a negative cache hit we set the
632                  * namecache_gen.  A later resolve will clean out the
633                  * negative cache hit if the mount point's namecache_gen
634                  * has changed.  Used by devfs, could also be used by
635                  * other remote FSs.
636                  */
637                 TAILQ_INSERT_TAIL(&ncneglist, ncp, nc_vnode);
638                 ++numneg;
639                 ncp->nc_error = ENOENT;
640                 if (mp)
641                         ncp->nc_namecache_gen = mp->mnt_namecache_gen;
642         }
643         ncp->nc_flag &= ~NCF_UNRESOLVED;
644 }
645
646 void
647 cache_setvp(struct nchandle *nch, struct vnode *vp)
648 {
649         _cache_setvp(nch->mount, nch->ncp, vp);
650 }
651
652 void
653 cache_settimeout(struct nchandle *nch, int nticks)
654 {
655         struct namecache *ncp = nch->ncp;
656
657         if ((ncp->nc_timeout = ticks + nticks) == 0)
658                 ncp->nc_timeout = 1;
659 }
660
661 /*
662  * Disassociate the vnode or negative-cache association and mark a
663  * namecache entry as unresolved again.  Note that the ncp is still
664  * left in the hash table and still linked to its parent.
665  *
666  * The ncp should be locked and refd on entry and will remain locked and refd
667  * on return.
668  *
669  * This routine is normally never called on a directory containing children.
670  * However, NFS often does just that in its rename() code as a cop-out to
671  * avoid complex namespace operations.  This disconnects a directory vnode
672  * from its namecache and can cause the OLDAPI and NEWAPI to get out of
673  * sync.
674  *
675  * NOTE: NCF_FSMID must be cleared so a refurbishment of the ncp, such as
676  * in a create, properly propogates flag up the chain.
677  */
678 static
679 void
680 _cache_setunresolved(struct namecache *ncp)
681 {
682         struct vnode *vp;
683
684         if ((ncp->nc_flag & NCF_UNRESOLVED) == 0) {
685                 ncp->nc_flag |= NCF_UNRESOLVED;
686                 ncp->nc_timeout = 0;
687                 ncp->nc_error = ENOTCONN;
688                 ++numunres;
689                 if ((vp = ncp->nc_vp) != NULL) {
690                         --numcache;
691                         ncp->nc_vp = NULL;
692                         TAILQ_REMOVE(&vp->v_namecache, ncp, nc_vnode);
693
694                         /*
695                          * Any vp associated with an ncp with children is
696                          * held by that ncp.  Any vp associated with a locked
697                          * ncp is held by that ncp.  These conditions must be
698                          * undone when the vp is cleared out from the ncp.
699                          */
700                         if (ncp->nc_flag & NCF_FSMID)
701                                 vupdatefsmid(vp);
702                         if (!TAILQ_EMPTY(&ncp->nc_list))
703                                 vdrop(vp);
704                         if (ncp->nc_exlocks)
705                                 vdrop(vp);
706                 } else {
707                         TAILQ_REMOVE(&ncneglist, ncp, nc_vnode);
708                         --numneg;
709                 }
710                 ncp->nc_flag &= ~(NCF_WHITEOUT|NCF_ISDIR|NCF_ISSYMLINK|
711                                   NCF_FSMID);
712         }
713 }
714
715 /*
716  * The cache_nresolve() code calls this function to automatically
717  * set a resolved cache element to unresolved if it has timed out
718  * or if it is a negative cache hit and the mount point namecache_gen
719  * has changed.
720  */
721 static __inline void
722 _cache_auto_unresolve(struct mount *mp, struct namecache *ncp)
723 {
724         /*
725          * Already in an unresolved state, nothing to do.
726          */
727         if (ncp->nc_flag & NCF_UNRESOLVED)
728                 return;
729
730         /*
731          * Try to zap entries that have timed out.  We have
732          * to be careful here because locked leafs may depend
733          * on the vnode remaining intact in a parent, so only
734          * do this under very specific conditions.
735          */
736         if (ncp->nc_timeout && (int)(ncp->nc_timeout - ticks) < 0 &&
737             TAILQ_EMPTY(&ncp->nc_list)) {
738                 _cache_setunresolved(ncp);
739                 return;
740         }
741
742         /*
743          * If a resolved negative cache hit is invalid due to
744          * the mount's namecache generation being bumped, zap it.
745          */
746         if (ncp->nc_vp == NULL &&
747             ncp->nc_namecache_gen != mp->mnt_namecache_gen) {
748                 _cache_setunresolved(ncp);
749                 return;
750         }
751 }
752
753 void
754 cache_setunresolved(struct nchandle *nch)
755 {
756         _cache_setunresolved(nch->ncp);
757 }
758
759 /*
760  * Determine if we can clear NCF_ISMOUNTPT by scanning the mountlist
761  * looking for matches.  This flag tells the lookup code when it must
762  * check for a mount linkage and also prevents the directories in question
763  * from being deleted or renamed.
764  */
765 static
766 int
767 cache_clrmountpt_callback(struct mount *mp, void *data)
768 {
769         struct nchandle *nch = data;
770
771         if (mp->mnt_ncmounton.ncp == nch->ncp)
772                 return(1);
773         if (mp->mnt_ncmountpt.ncp == nch->ncp)
774                 return(1);
775         return(0);
776 }
777
778 void
779 cache_clrmountpt(struct nchandle *nch)
780 {
781         int count;
782
783         count = mountlist_scan(cache_clrmountpt_callback, nch,
784                                MNTSCAN_FORWARD|MNTSCAN_NOBUSY);
785         if (count == 0)
786                 nch->ncp->nc_flag &= ~NCF_ISMOUNTPT;
787 }
788
789 /*
790  * Invalidate portions of the namecache topology given a starting entry.
791  * The passed ncp is set to an unresolved state and:
792  *
793  * The passed ncp must be locked.
794  *
795  * CINV_DESTROY         - Set a flag in the passed ncp entry indicating
796  *                        that the physical underlying nodes have been 
797  *                        destroyed... as in deleted.  For example, when
798  *                        a directory is removed.  This will cause record
799  *                        lookups on the name to no longer be able to find
800  *                        the record and tells the resolver to return failure
801  *                        rather then trying to resolve through the parent.
802  *
803  *                        The topology itself, including ncp->nc_name,
804  *                        remains intact.
805  *
806  *                        This only applies to the passed ncp, if CINV_CHILDREN
807  *                        is specified the children are not flagged.
808  *
809  * CINV_CHILDREN        - Set all children (recursively) to an unresolved
810  *                        state as well.
811  *
812  *                        Note that this will also have the side effect of
813  *                        cleaning out any unreferenced nodes in the topology
814  *                        from the leaves up as the recursion backs out.
815  *
816  * Note that the topology for any referenced nodes remains intact.
817  *
818  * It is possible for cache_inval() to race a cache_resolve(), meaning that
819  * the namecache entry may not actually be invalidated on return if it was
820  * revalidated while recursing down into its children.  This code guarentees
821  * that the node(s) will go through an invalidation cycle, but does not 
822  * guarentee that they will remain in an invalidated state. 
823  *
824  * Returns non-zero if a revalidation was detected during the invalidation
825  * recursion, zero otherwise.  Note that since only the original ncp is
826  * locked the revalidation ultimately can only indicate that the original ncp
827  * *MIGHT* no have been reresolved.
828  *
829  * DEEP RECURSION HANDLING - If a recursive invalidation recurses deeply we
830  * have to avoid blowing out the kernel stack.  We do this by saving the
831  * deep namecache node and aborting the recursion, then re-recursing at that
832  * node using a depth-first algorithm in order to allow multiple deep
833  * recursions to chain through each other, then we restart the invalidation
834  * from scratch.
835  */
836
837 struct cinvtrack {
838         struct namecache *resume_ncp;
839         int depth;
840 };
841
842 static int _cache_inval_internal(struct namecache *, int, struct cinvtrack *);
843
844 static
845 int
846 _cache_inval(struct namecache *ncp, int flags)
847 {
848         struct cinvtrack track;
849         struct namecache *ncp2;
850         int r;
851
852         track.depth = 0;
853         track.resume_ncp = NULL;
854
855         for (;;) {
856                 r = _cache_inval_internal(ncp, flags, &track);
857                 if (track.resume_ncp == NULL)
858                         break;
859                 kprintf("Warning: deep namecache recursion at %s\n",
860                         ncp->nc_name);
861                 _cache_unlock(ncp);
862                 while ((ncp2 = track.resume_ncp) != NULL) {
863                         track.resume_ncp = NULL;
864                         _cache_lock(ncp2);
865                         _cache_inval_internal(ncp2, flags & ~CINV_DESTROY,
866                                              &track);
867                         _cache_put(ncp2);
868                 }
869                 _cache_lock(ncp);
870         }
871         return(r);
872 }
873
874 int
875 cache_inval(struct nchandle *nch, int flags)
876 {
877         return(_cache_inval(nch->ncp, flags));
878 }
879
880 static int
881 _cache_inval_internal(struct namecache *ncp, int flags, struct cinvtrack *track)
882 {
883         struct namecache *kid;
884         struct namecache *nextkid;
885         int rcnt = 0;
886
887         KKASSERT(ncp->nc_exlocks);
888
889         _cache_setunresolved(ncp);
890         if (flags & CINV_DESTROY)
891                 ncp->nc_flag |= NCF_DESTROYED;
892
893         if ((flags & CINV_CHILDREN) && 
894             (kid = TAILQ_FIRST(&ncp->nc_list)) != NULL
895         ) {
896                 if (++track->depth > MAX_RECURSION_DEPTH) {
897                         track->resume_ncp = ncp;
898                         _cache_hold(ncp);
899                         ++rcnt;
900                 }
901                 _cache_hold(kid);
902                 _cache_unlock(ncp);
903                 while (kid) {
904                         if (track->resume_ncp) {
905                                 _cache_drop(kid);
906                                 break;
907                         }
908                         if ((nextkid = TAILQ_NEXT(kid, nc_entry)) != NULL)
909                                 _cache_hold(nextkid);
910                         if ((kid->nc_flag & NCF_UNRESOLVED) == 0 ||
911                             TAILQ_FIRST(&kid->nc_list)
912                         ) {
913                                 _cache_lock(kid);
914                                 rcnt += _cache_inval_internal(kid, flags & ~CINV_DESTROY, track);
915                                 _cache_unlock(kid);
916                         }
917                         _cache_drop(kid);
918                         kid = nextkid;
919                 }
920                 --track->depth;
921                 _cache_lock(ncp);
922         }
923
924         /*
925          * Someone could have gotten in there while ncp was unlocked,
926          * retry if so.
927          */
928         if ((ncp->nc_flag & NCF_UNRESOLVED) == 0)
929                 ++rcnt;
930         return (rcnt);
931 }
932
933 /*
934  * Invalidate a vnode's namecache associations.  To avoid races against
935  * the resolver we do not invalidate a node which we previously invalidated
936  * but which was then re-resolved while we were in the invalidation loop.
937  *
938  * Returns non-zero if any namecache entries remain after the invalidation
939  * loop completed.
940  *
941  * NOTE: unlike the namecache topology which guarentees that ncp's will not
942  * be ripped out of the topology while held, the vnode's v_namecache list
943  * has no such restriction.  NCP's can be ripped out of the list at virtually
944  * any time if not locked, even if held.
945  */
946 int
947 cache_inval_vp(struct vnode *vp, int flags)
948 {
949         struct namecache *ncp;
950         struct namecache *next;
951
952 restart:
953         ncp = TAILQ_FIRST(&vp->v_namecache);
954         if (ncp)
955                 _cache_hold(ncp);
956         while (ncp) {
957                 /* loop entered with ncp held */
958                 if ((next = TAILQ_NEXT(ncp, nc_vnode)) != NULL)
959                         _cache_hold(next);
960                 _cache_lock(ncp);
961                 if (ncp->nc_vp != vp) {
962                         kprintf("Warning: cache_inval_vp: race-A detected on "
963                                 "%s\n", ncp->nc_name);
964                         _cache_put(ncp);
965                         if (next)
966                                 _cache_drop(next);
967                         goto restart;
968                 }
969                 _cache_inval(ncp, flags);
970                 _cache_put(ncp);                /* also releases reference */
971                 ncp = next;
972                 if (ncp && ncp->nc_vp != vp) {
973                         kprintf("Warning: cache_inval_vp: race-B detected on "
974                                 "%s\n", ncp->nc_name);
975                         _cache_drop(ncp);
976                         goto restart;
977                 }
978         }
979         return(TAILQ_FIRST(&vp->v_namecache) != NULL);
980 }
981
982 /*
983  * This routine is used instead of the normal cache_inval_vp() when we
984  * are trying to recycle otherwise good vnodes.
985  *
986  * Return 0 on success, non-zero if not all namecache records could be
987  * disassociated from the vnode (for various reasons).
988  */
989 int
990 cache_inval_vp_nonblock(struct vnode *vp)
991 {
992         struct namecache *ncp;
993         struct namecache *next;
994
995         ncp = TAILQ_FIRST(&vp->v_namecache);
996         if (ncp)
997                 _cache_hold(ncp);
998         while (ncp) {
999                 /* loop entered with ncp held */
1000                 if ((next = TAILQ_NEXT(ncp, nc_vnode)) != NULL)
1001                         _cache_hold(next);
1002                 if (_cache_lock_nonblock(ncp)) {
1003                         _cache_drop(ncp);
1004                         if (next)
1005                                 _cache_drop(next);
1006                         break;
1007                 }
1008                 if (ncp->nc_vp != vp) {
1009                         kprintf("Warning: cache_inval_vp: race-A detected on "
1010                                 "%s\n", ncp->nc_name);
1011                         _cache_put(ncp);
1012                         if (next)
1013                                 _cache_drop(next);
1014                         break;
1015                 }
1016                 _cache_inval(ncp, 0);
1017                 _cache_put(ncp);                /* also releases reference */
1018                 ncp = next;
1019                 if (ncp && ncp->nc_vp != vp) {
1020                         kprintf("Warning: cache_inval_vp: race-B detected on "
1021                                 "%s\n", ncp->nc_name);
1022                         _cache_drop(ncp);
1023                         break;
1024                 }
1025         }
1026         return(TAILQ_FIRST(&vp->v_namecache) != NULL);
1027 }
1028
1029 /*
1030  * The source ncp has been renamed to the target ncp.  Both fncp and tncp
1031  * must be locked.  The target ncp is destroyed (as a normal rename-over
1032  * would destroy the target file or directory).
1033  *
1034  * Because there may be references to the source ncp we cannot copy its
1035  * contents to the target.  Instead the source ncp is relinked as the target
1036  * and the target ncp is removed from the namecache topology.
1037  */
1038 void
1039 cache_rename(struct nchandle *fnch, struct nchandle *tnch)
1040 {
1041         struct namecache *fncp = fnch->ncp;
1042         struct namecache *tncp = tnch->ncp;
1043         char *oname;
1044
1045         _cache_setunresolved(tncp);
1046         cache_unlink_parent(fncp);
1047         cache_link_parent(fncp, tncp->nc_parent);
1048         cache_unlink_parent(tncp);
1049         oname = fncp->nc_name;
1050         fncp->nc_name = tncp->nc_name;
1051         fncp->nc_nlen = tncp->nc_nlen;
1052         tncp->nc_name = NULL;
1053         tncp->nc_nlen = 0;
1054         if (fncp->nc_flag & NCF_HASHED)
1055                 _cache_rehash(fncp);
1056         if (tncp->nc_flag & NCF_HASHED)
1057                 _cache_rehash(tncp);
1058         if (oname)
1059                 kfree(oname, M_VFSCACHE);
1060 }
1061
1062 /*
1063  * vget the vnode associated with the namecache entry.  Resolve the namecache
1064  * entry if necessary and deal with namecache/vp races.  The passed ncp must
1065  * be referenced and may be locked.  The ncp's ref/locking state is not 
1066  * effected by this call.
1067  *
1068  * lk_type may be LK_SHARED, LK_EXCLUSIVE.  A ref'd, possibly locked
1069  * (depending on the passed lk_type) will be returned in *vpp with an error
1070  * of 0, or NULL will be returned in *vpp with a non-0 error code.  The
1071  * most typical error is ENOENT, meaning that the ncp represents a negative
1072  * cache hit and there is no vnode to retrieve, but other errors can occur
1073  * too.
1074  *
1075  * The main race we have to deal with are namecache zaps.  The ncp itself
1076  * will not disappear since it is referenced, and it turns out that the
1077  * validity of the vp pointer can be checked simply by rechecking the
1078  * contents of ncp->nc_vp.
1079  */
1080 int
1081 cache_vget(struct nchandle *nch, struct ucred *cred,
1082            int lk_type, struct vnode **vpp)
1083 {
1084         struct namecache *ncp;
1085         struct vnode *vp;
1086         int error;
1087
1088         ncp = nch->ncp;
1089 again:
1090         vp = NULL;
1091         if (ncp->nc_flag & NCF_UNRESOLVED) {
1092                 _cache_lock(ncp);
1093                 error = cache_resolve(nch, cred);
1094                 _cache_unlock(ncp);
1095         } else {
1096                 error = 0;
1097         }
1098         if (error == 0 && (vp = ncp->nc_vp) != NULL) {
1099                 /*
1100                  * Accessing the vnode from the namecache is a bit 
1101                  * dangerous.  Because there are no refs on the vnode, it
1102                  * could be in the middle of a reclaim.
1103                  */
1104                 if (vp->v_flag & VRECLAIMED) {
1105                         kprintf("Warning: vnode reclaim race detected in cache_vget on %p (%s)\n", vp, ncp->nc_name);
1106                         _cache_lock(ncp);
1107                         _cache_setunresolved(ncp);
1108                         _cache_unlock(ncp);
1109                         goto again;
1110                 }
1111                 error = vget(vp, lk_type);
1112                 if (error) {
1113                         if (vp != ncp->nc_vp)
1114                                 goto again;
1115                         vp = NULL;
1116                 } else if (vp != ncp->nc_vp) {
1117                         vput(vp);
1118                         goto again;
1119                 } else if (vp->v_flag & VRECLAIMED) {
1120                         panic("vget succeeded on a VRECLAIMED node! vp %p", vp);
1121                 }
1122         }
1123         if (error == 0 && vp == NULL)
1124                 error = ENOENT;
1125         *vpp = vp;
1126         return(error);
1127 }
1128
1129 int
1130 cache_vref(struct nchandle *nch, struct ucred *cred, struct vnode **vpp)
1131 {
1132         struct namecache *ncp;
1133         struct vnode *vp;
1134         int error;
1135
1136         ncp = nch->ncp;
1137
1138 again:
1139         vp = NULL;
1140         if (ncp->nc_flag & NCF_UNRESOLVED) {
1141                 _cache_lock(ncp);
1142                 error = cache_resolve(nch, cred);
1143                 _cache_unlock(ncp);
1144         } else {
1145                 error = 0;
1146         }
1147         if (error == 0 && (vp = ncp->nc_vp) != NULL) {
1148                 /*
1149                  * Since we did not obtain any locks, a cache zap 
1150                  * race can occur here if the vnode is in the middle
1151                  * of being reclaimed and has not yet been able to
1152                  * clean out its cache node.  If that case occurs,
1153                  * we must lock and unresolve the cache, then loop
1154                  * to retry.
1155                  */
1156                 if ((error = vget(vp, LK_SHARED)) != 0) {
1157                         if (error == ENOENT) {
1158                                 kprintf("Warning: vnode reclaim race detected on cache_vref %p (%s)\n", vp, ncp->nc_name);
1159                                 _cache_lock(ncp);
1160                                 _cache_setunresolved(ncp);
1161                                 _cache_unlock(ncp);
1162                                 goto again;
1163                         }
1164                         /* fatal error */
1165                 } else {
1166                         /* caller does not want a lock */
1167                         vn_unlock(vp);
1168                 }
1169         }
1170         if (error == 0 && vp == NULL)
1171                 error = ENOENT;
1172         *vpp = vp;
1173         return(error);
1174 }
1175
1176 /*
1177  * Return a referenced vnode representing the parent directory of
1178  * ncp.  Because the caller has locked the ncp it should not be possible for
1179  * the parent ncp to go away.
1180  *
1181  * However, we might race against the parent dvp and not be able to
1182  * reference it.  If we race, return NULL.
1183  */
1184 static struct vnode *
1185 cache_dvpref(struct namecache *ncp)
1186 {
1187         struct namecache *par;
1188         struct vnode *dvp;
1189
1190         dvp = NULL;
1191         if ((par = ncp->nc_parent) != NULL) {
1192                 if ((par->nc_flag & NCF_UNRESOLVED) == 0) {
1193                         if ((dvp = par->nc_vp) != NULL) {
1194                                 if (vget(dvp, LK_SHARED) == 0) {
1195                                         vn_unlock(dvp);
1196                                         /* return referenced, unlocked dvp */
1197                                 } else {
1198                                         dvp = NULL;
1199                                 }
1200                         }
1201                 }
1202         }
1203         return(dvp);
1204 }
1205
1206 /*
1207  * Recursively set the FSMID update flag for namecache nodes leading
1208  * to root.  This will cause the next getattr or reclaim to increment the
1209  * fsmid and mark the inode for lazy updating.
1210  *
1211  * Stop recursing when we hit a node whos NCF_FSMID flag is already set.
1212  * This makes FSMIDs work in an Einsteinian fashion - where the observation
1213  * effects the result.  In this case a program monitoring a higher level
1214  * node will have detected some prior change and started its scan (clearing
1215  * NCF_FSMID in higher level nodes), but since it has not yet observed the
1216  * node where we find NCF_FSMID still set, we can safely make the related
1217  * modification without interfering with the theorized program.
1218  *
1219  * This also means that FSMIDs cannot represent time-domain quantities
1220  * in a hierarchical sense.  But the main reason for doing it this way
1221  * is to reduce the amount of recursion that occurs in the critical path
1222  * when e.g. a program is writing to a file that sits deep in a directory
1223  * hierarchy.
1224  */
1225 void
1226 cache_update_fsmid(struct nchandle *nch)
1227 {
1228         struct namecache *ncp;
1229         struct namecache *scan;
1230         struct vnode *vp;
1231
1232         ncp = nch->ncp;
1233
1234         /*
1235          * Warning: even if we get a non-NULL vp it could still be in the
1236          * middle of a recyclement.  Don't do anything fancy, just set
1237          * NCF_FSMID.
1238          */
1239         if ((vp = ncp->nc_vp) != NULL) {
1240                 TAILQ_FOREACH(ncp, &vp->v_namecache, nc_vnode) {
1241                         for (scan = ncp; scan; scan = scan->nc_parent) {
1242                                 if (scan->nc_flag & NCF_FSMID)
1243                                         break;
1244                                 scan->nc_flag |= NCF_FSMID;
1245                         }
1246                 }
1247         } else {
1248                 while (ncp && (ncp->nc_flag & NCF_FSMID) == 0) {
1249                         ncp->nc_flag |= NCF_FSMID;
1250                         ncp = ncp->nc_parent;
1251                 }
1252         }
1253 }
1254
1255 void
1256 cache_update_fsmid_vp(struct vnode *vp)
1257 {
1258         struct namecache *ncp;
1259         struct namecache *scan;
1260
1261         TAILQ_FOREACH(ncp, &vp->v_namecache, nc_vnode) {
1262                 for (scan = ncp; scan; scan = scan->nc_parent) {
1263                         if (scan->nc_flag & NCF_FSMID)
1264                                 break;
1265                         scan->nc_flag |= NCF_FSMID;
1266                 }
1267         }
1268 }
1269
1270 /*
1271  * If getattr is called on a vnode (e.g. a stat call), the filesystem
1272  * may call this routine to determine if the namecache has the hierarchical
1273  * change flag set, requiring the fsmid to be updated.
1274  *
1275  * Since 0 indicates no support, make sure the filesystem fsmid is at least
1276  * 1.
1277  */
1278 int
1279 cache_check_fsmid_vp(struct vnode *vp, int64_t *fsmid)
1280 {
1281         struct namecache *ncp;
1282         int changed = 0;
1283
1284         TAILQ_FOREACH(ncp, &vp->v_namecache, nc_vnode) {
1285                 if (ncp->nc_flag & NCF_FSMID) {
1286                         ncp->nc_flag &= ~NCF_FSMID;
1287                         changed = 1;
1288                 }
1289         }
1290         if (*fsmid == 0)
1291                 ++*fsmid;
1292         if (changed)
1293                 ++*fsmid;
1294         return(changed);
1295 }
1296
1297 /*
1298  * Obtain the FSMID for a vnode for filesystems which do not support
1299  * a built-in FSMID.
1300  */
1301 int64_t
1302 cache_sync_fsmid_vp(struct vnode *vp)
1303 {
1304         struct namecache *ncp;
1305
1306         if ((ncp = TAILQ_FIRST(&vp->v_namecache)) != NULL) {
1307                 if (ncp->nc_flag & NCF_FSMID) {
1308                         ncp->nc_flag &= ~NCF_FSMID;
1309                         ++ncp->nc_fsmid;
1310                 }
1311                 return(ncp->nc_fsmid);
1312         }
1313         return(VNOVAL);
1314 }
1315
1316 /*
1317  * Convert a directory vnode to a namecache record without any other 
1318  * knowledge of the topology.  This ONLY works with directory vnodes and
1319  * is ONLY used by the NFS server.  dvp must be refd but unlocked, and the
1320  * returned ncp (if not NULL) will be held and unlocked.
1321  *
1322  * If 'makeit' is 0 and dvp has no existing namecache record, NULL is returned.
1323  * If 'makeit' is 1 we attempt to track-down and create the namecache topology
1324  * for dvp.  This will fail only if the directory has been deleted out from
1325  * under the caller.  
1326  *
1327  * Callers must always check for a NULL return no matter the value of 'makeit'.
1328  *
1329  * To avoid underflowing the kernel stack each recursive call increments
1330  * the makeit variable.
1331  */
1332
1333 static int cache_inefficient_scan(struct nchandle *nch, struct ucred *cred,
1334                                   struct vnode *dvp, char *fakename);
1335 static int cache_fromdvp_try(struct vnode *dvp, struct ucred *cred, 
1336                                   struct vnode **saved_dvp);
1337
1338 int
1339 cache_fromdvp(struct vnode *dvp, struct ucred *cred, int makeit,
1340               struct nchandle *nch)
1341 {
1342         struct vnode *saved_dvp;
1343         struct vnode *pvp;
1344         char *fakename;
1345         int error;
1346
1347         nch->ncp = NULL;
1348         nch->mount = dvp->v_mount;
1349         saved_dvp = NULL;
1350         fakename = NULL;
1351
1352         /*
1353          * Temporary debugging code to force the directory scanning code
1354          * to be exercised.
1355          */
1356         if (ncvp_debug >= 3 && makeit && TAILQ_FIRST(&dvp->v_namecache)) {
1357                 nch->ncp = TAILQ_FIRST(&dvp->v_namecache);
1358                 kprintf("cache_fromdvp: forcing %s\n", nch->ncp->nc_name);
1359                 goto force;
1360         }
1361
1362         /*
1363          * Loop until resolution, inside code will break out on error.
1364          */
1365         while ((nch->ncp = TAILQ_FIRST(&dvp->v_namecache)) == NULL && makeit) {
1366 force:
1367                 /*
1368                  * If dvp is the root of its filesystem it should already
1369                  * have a namecache pointer associated with it as a side 
1370                  * effect of the mount, but it may have been disassociated.
1371                  */
1372                 if (dvp->v_flag & VROOT) {
1373                         nch->ncp = _cache_get(nch->mount->mnt_ncmountpt.ncp);
1374                         error = cache_resolve_mp(nch->mount);
1375                         _cache_put(nch->ncp);
1376                         if (ncvp_debug) {
1377                                 kprintf("cache_fromdvp: resolve root of mount %p error %d", 
1378                                         dvp->v_mount, error);
1379                         }
1380                         if (error) {
1381                                 if (ncvp_debug)
1382                                         kprintf(" failed\n");
1383                                 nch->ncp = NULL;
1384                                 break;
1385                         }
1386                         if (ncvp_debug)
1387                                 kprintf(" succeeded\n");
1388                         continue;
1389                 }
1390
1391                 /*
1392                  * If we are recursed too deeply resort to an O(n^2)
1393                  * algorithm to resolve the namecache topology.  The
1394                  * resolved pvp is left referenced in saved_dvp to
1395                  * prevent the tree from being destroyed while we loop.
1396                  */
1397                 if (makeit > 20) {
1398                         error = cache_fromdvp_try(dvp, cred, &saved_dvp);
1399                         if (error) {
1400                                 kprintf("lookupdotdot(longpath) failed %d "
1401                                        "dvp %p\n", error, dvp);
1402                                 nch->ncp = NULL;
1403                                 break;
1404                         }
1405                         continue;
1406                 }
1407
1408                 /*
1409                  * Get the parent directory and resolve its ncp.
1410                  */
1411                 if (fakename) {
1412                         kfree(fakename, M_TEMP);
1413                         fakename = NULL;
1414                 }
1415                 error = vop_nlookupdotdot(*dvp->v_ops, dvp, &pvp, cred,
1416                                           &fakename);
1417                 if (error) {
1418                         kprintf("lookupdotdot failed %d dvp %p\n", error, dvp);
1419                         break;
1420                 }
1421                 vn_unlock(pvp);
1422
1423                 /*
1424                  * Reuse makeit as a recursion depth counter.  On success
1425                  * nch will be fully referenced.
1426                  */
1427                 cache_fromdvp(pvp, cred, makeit + 1, nch);
1428                 vrele(pvp);
1429                 if (nch->ncp == NULL)
1430                         break;
1431
1432                 /*
1433                  * Do an inefficient scan of pvp (embodied by ncp) to look
1434                  * for dvp.  This will create a namecache record for dvp on
1435                  * success.  We loop up to recheck on success.
1436                  *
1437                  * ncp and dvp are both held but not locked.
1438                  */
1439                 error = cache_inefficient_scan(nch, cred, dvp, fakename);
1440                 if (error) {
1441                         kprintf("cache_fromdvp: scan %p (%s) failed on dvp=%p\n",
1442                                 pvp, nch->ncp->nc_name, dvp);
1443                         cache_drop(nch);
1444                         /* nch was NULLed out, reload mount */
1445                         nch->mount = dvp->v_mount;
1446                         break;
1447                 }
1448                 if (ncvp_debug) {
1449                         kprintf("cache_fromdvp: scan %p (%s) succeeded\n",
1450                                 pvp, nch->ncp->nc_name);
1451                 }
1452                 cache_drop(nch);
1453                 /* nch was NULLed out, reload mount */
1454                 nch->mount = dvp->v_mount;
1455         }
1456
1457         if (fakename)
1458                 kfree(fakename, M_TEMP);
1459
1460         /*
1461          * hold it for real so the mount gets a ref
1462          */
1463         if (nch->ncp)
1464                 cache_hold(nch);
1465         if (saved_dvp)
1466                 vrele(saved_dvp);
1467         if (nch->ncp)
1468                 return (0);
1469         return (EINVAL);
1470 }
1471
1472 /*
1473  * Go up the chain of parent directories until we find something
1474  * we can resolve into the namecache.  This is very inefficient.
1475  */
1476 static
1477 int
1478 cache_fromdvp_try(struct vnode *dvp, struct ucred *cred,
1479                   struct vnode **saved_dvp)
1480 {
1481         struct nchandle nch;
1482         struct vnode *pvp;
1483         int error;
1484         static time_t last_fromdvp_report;
1485         char *fakename;
1486
1487         /*
1488          * Loop getting the parent directory vnode until we get something we
1489          * can resolve in the namecache.
1490          */
1491         vref(dvp);
1492         nch.mount = dvp->v_mount;
1493         nch.ncp = NULL;
1494         fakename = NULL;
1495
1496         for (;;) {
1497                 if (fakename) {
1498                         kfree(fakename, M_TEMP);
1499                         fakename = NULL;
1500                 }
1501                 error = vop_nlookupdotdot(*dvp->v_ops, dvp, &pvp, cred,
1502                                           &fakename);
1503                 if (error) {
1504                         vrele(dvp);
1505                         break;
1506                 }
1507                 vn_unlock(pvp);
1508                 if ((nch.ncp = TAILQ_FIRST(&pvp->v_namecache)) != NULL) {
1509                         _cache_hold(nch.ncp);
1510                         vrele(pvp);
1511                         break;
1512                 }
1513                 if (pvp->v_flag & VROOT) {
1514                         nch.ncp = _cache_get(pvp->v_mount->mnt_ncmountpt.ncp);
1515                         error = cache_resolve_mp(nch.mount);
1516                         _cache_unlock(nch.ncp);
1517                         vrele(pvp);
1518                         if (error) {
1519                                 _cache_drop(nch.ncp);
1520                                 nch.ncp = NULL;
1521                                 vrele(dvp);
1522                         }
1523                         break;
1524                 }
1525                 vrele(dvp);
1526                 dvp = pvp;
1527         }
1528         if (error == 0) {
1529                 if (last_fromdvp_report != time_second) {
1530                         last_fromdvp_report = time_second;
1531                         kprintf("Warning: extremely inefficient path "
1532                                 "resolution on %s\n",
1533                                 nch.ncp->nc_name);
1534                 }
1535                 error = cache_inefficient_scan(&nch, cred, dvp, fakename);
1536
1537                 /*
1538                  * Hopefully dvp now has a namecache record associated with
1539                  * it.  Leave it referenced to prevent the kernel from
1540                  * recycling the vnode.  Otherwise extremely long directory
1541                  * paths could result in endless recycling.
1542                  */
1543                 if (*saved_dvp)
1544                     vrele(*saved_dvp);
1545                 *saved_dvp = dvp;
1546                 _cache_drop(nch.ncp);
1547         }
1548         if (fakename)
1549                 kfree(fakename, M_TEMP);
1550         return (error);
1551 }
1552
1553 /*
1554  * Do an inefficient scan of the directory represented by ncp looking for
1555  * the directory vnode dvp.  ncp must be held but not locked on entry and
1556  * will be held on return.  dvp must be refd but not locked on entry and
1557  * will remain refd on return.
1558  *
1559  * Why do this at all?  Well, due to its stateless nature the NFS server
1560  * converts file handles directly to vnodes without necessarily going through
1561  * the namecache ops that would otherwise create the namecache topology
1562  * leading to the vnode.  We could either (1) Change the namecache algorithms
1563  * to allow disconnect namecache records that are re-merged opportunistically,
1564  * or (2) Make the NFS server backtrack and scan to recover a connected
1565  * namecache topology in order to then be able to issue new API lookups.
1566  *
1567  * It turns out that (1) is a huge mess.  It takes a nice clean set of 
1568  * namecache algorithms and introduces a lot of complication in every subsystem
1569  * that calls into the namecache to deal with the re-merge case, especially
1570  * since we are using the namecache to placehold negative lookups and the
1571  * vnode might not be immediately assigned. (2) is certainly far less
1572  * efficient then (1), but since we are only talking about directories here
1573  * (which are likely to remain cached), the case does not actually run all
1574  * that often and has the supreme advantage of not polluting the namecache
1575  * algorithms.
1576  *
1577  * If a fakename is supplied just construct a namecache entry using the
1578  * fake name.
1579  */
1580 static int
1581 cache_inefficient_scan(struct nchandle *nch, struct ucred *cred, 
1582                        struct vnode *dvp, char *fakename)
1583 {
1584         struct nlcomponent nlc;
1585         struct nchandle rncp;
1586         struct dirent *den;
1587         struct vnode *pvp;
1588         struct vattr vat;
1589         struct iovec iov;
1590         struct uio uio;
1591         int blksize;
1592         int eofflag;
1593         int bytes;
1594         char *rbuf;
1595         int error;
1596
1597         vat.va_blocksize = 0;
1598         if ((error = VOP_GETATTR(dvp, &vat)) != 0)
1599                 return (error);
1600         if ((error = cache_vref(nch, cred, &pvp)) != 0)
1601                 return (error);
1602         if (ncvp_debug) {
1603                 kprintf("inefficient_scan: directory iosize %ld "
1604                         "vattr fileid = %lld\n",
1605                         vat.va_blocksize,
1606                         (long long)vat.va_fileid);
1607         }
1608
1609         /*
1610          * Use the supplied fakename if not NULL.  Fake names are typically
1611          * not in the actual filesystem hierarchy.  This is used by HAMMER
1612          * to glue @@timestamp recursions together.
1613          */
1614         if (fakename) {
1615                 nlc.nlc_nameptr = fakename;
1616                 nlc.nlc_namelen = strlen(fakename);
1617                 rncp = cache_nlookup(nch, &nlc);
1618                 goto done;
1619         }
1620
1621         if ((blksize = vat.va_blocksize) == 0)
1622                 blksize = DEV_BSIZE;
1623         rbuf = kmalloc(blksize, M_TEMP, M_WAITOK);
1624         rncp.ncp = NULL;
1625
1626         eofflag = 0;
1627         uio.uio_offset = 0;
1628 again:
1629         iov.iov_base = rbuf;
1630         iov.iov_len = blksize;
1631         uio.uio_iov = &iov;
1632         uio.uio_iovcnt = 1;
1633         uio.uio_resid = blksize;
1634         uio.uio_segflg = UIO_SYSSPACE;
1635         uio.uio_rw = UIO_READ;
1636         uio.uio_td = curthread;
1637
1638         if (ncvp_debug >= 2)
1639                 kprintf("cache_inefficient_scan: readdir @ %08x\n", (int)uio.uio_offset);
1640         error = VOP_READDIR(pvp, &uio, cred, &eofflag, NULL, NULL);
1641         if (error == 0) {
1642                 den = (struct dirent *)rbuf;
1643                 bytes = blksize - uio.uio_resid;
1644
1645                 while (bytes > 0) {
1646                         if (ncvp_debug >= 2) {
1647                                 kprintf("cache_inefficient_scan: %*.*s\n",
1648                                         den->d_namlen, den->d_namlen, 
1649                                         den->d_name);
1650                         }
1651                         if (den->d_type != DT_WHT &&
1652                             den->d_ino == vat.va_fileid) {
1653                                 if (ncvp_debug) {
1654                                         kprintf("cache_inefficient_scan: "
1655                                                "MATCHED inode %lld path %s/%*.*s\n",
1656                                                (long long)vat.va_fileid,
1657                                                nch->ncp->nc_name,
1658                                                den->d_namlen, den->d_namlen,
1659                                                den->d_name);
1660                                 }
1661                                 nlc.nlc_nameptr = den->d_name;
1662                                 nlc.nlc_namelen = den->d_namlen;
1663                                 rncp = cache_nlookup(nch, &nlc);
1664                                 KKASSERT(rncp.ncp != NULL);
1665                                 break;
1666                         }
1667                         bytes -= _DIRENT_DIRSIZ(den);
1668                         den = _DIRENT_NEXT(den);
1669                 }
1670                 if (rncp.ncp == NULL && eofflag == 0 && uio.uio_resid != blksize)
1671                         goto again;
1672         }
1673         kfree(rbuf, M_TEMP);
1674 done:
1675         vrele(pvp);
1676         if (rncp.ncp) {
1677                 if (rncp.ncp->nc_flag & NCF_UNRESOLVED) {
1678                         _cache_setvp(rncp.mount, rncp.ncp, dvp);
1679                         if (ncvp_debug >= 2) {
1680                                 kprintf("cache_inefficient_scan: setvp %s/%s = %p\n",
1681                                         nch->ncp->nc_name, rncp.ncp->nc_name, dvp);
1682                         }
1683                 } else {
1684                         if (ncvp_debug >= 2) {
1685                                 kprintf("cache_inefficient_scan: setvp %s/%s already set %p/%p\n", 
1686                                         nch->ncp->nc_name, rncp.ncp->nc_name, dvp,
1687                                         rncp.ncp->nc_vp);
1688                         }
1689                 }
1690                 if (rncp.ncp->nc_vp == NULL)
1691                         error = rncp.ncp->nc_error;
1692                 /* 
1693                  * Release rncp after a successful nlookup.  rncp was fully
1694                  * referenced.
1695                  */
1696                 cache_put(&rncp);
1697         } else {
1698                 kprintf("cache_inefficient_scan: dvp %p NOT FOUND in %s\n",
1699                         dvp, nch->ncp->nc_name);
1700                 error = ENOENT;
1701         }
1702         return (error);
1703 }
1704
1705 /*
1706  * Zap a namecache entry.  The ncp is unconditionally set to an unresolved
1707  * state, which disassociates it from its vnode or ncneglist.
1708  *
1709  * Then, if there are no additional references to the ncp and no children,
1710  * the ncp is removed from the topology and destroyed.  This function will
1711  * also run through the nc_parent chain and destroy parent ncps if possible.
1712  * As a side benefit, it turns out the only conditions that allow running
1713  * up the chain are also the conditions to ensure no deadlock will occur.
1714  *
1715  * References and/or children may exist if the ncp is in the middle of the
1716  * topology, preventing the ncp from being destroyed.
1717  *
1718  * This function must be called with the ncp held and locked and will unlock
1719  * and drop it during zapping.
1720  */
1721 static void
1722 cache_zap(struct namecache *ncp)
1723 {
1724         struct namecache *par;
1725
1726         /*
1727          * Disassociate the vnode or negative cache ref and set NCF_UNRESOLVED.
1728          */
1729         _cache_setunresolved(ncp);
1730
1731         /*
1732          * Try to scrap the entry and possibly tail-recurse on its parent.
1733          * We only scrap unref'd (other then our ref) unresolved entries,
1734          * we do not scrap 'live' entries.
1735          */
1736         while (ncp->nc_flag & NCF_UNRESOLVED) {
1737                 /*
1738                  * Someone other then us has a ref, stop.
1739                  */
1740                 if (ncp->nc_refs > 1)
1741                         goto done;
1742
1743                 /*
1744                  * We have children, stop.
1745                  */
1746                 if (!TAILQ_EMPTY(&ncp->nc_list))
1747                         goto done;
1748
1749                 /*
1750                  * Remove ncp from the topology: hash table and parent linkage.
1751                  */
1752                 if (ncp->nc_flag & NCF_HASHED) {
1753                         ncp->nc_flag &= ~NCF_HASHED;
1754                         LIST_REMOVE(ncp, nc_hash);
1755                 }
1756                 if ((par = ncp->nc_parent) != NULL) {
1757                         par = _cache_hold(par);
1758                         TAILQ_REMOVE(&par->nc_list, ncp, nc_entry);
1759                         ncp->nc_parent = NULL;
1760                         if (par->nc_vp && TAILQ_EMPTY(&par->nc_list))
1761                                 vdrop(par->nc_vp);
1762                 }
1763
1764                 /*
1765                  * ncp should not have picked up any refs.  Physically
1766                  * destroy the ncp.
1767                  */
1768                 KKASSERT(ncp->nc_refs == 1);
1769                 --numunres;
1770                 /* _cache_unlock(ncp) not required */
1771                 ncp->nc_refs = -1;      /* safety */
1772                 if (ncp->nc_name)
1773                         kfree(ncp->nc_name, M_VFSCACHE);
1774                 kfree(ncp, M_VFSCACHE);
1775
1776                 /*
1777                  * Loop on the parent (it may be NULL).  Only bother looping
1778                  * if the parent has a single ref (ours), which also means
1779                  * we can lock it trivially.
1780                  */
1781                 ncp = par;
1782                 if (ncp == NULL)
1783                         return;
1784                 if (ncp->nc_refs != 1) {
1785                         _cache_drop(ncp);
1786                         return;
1787                 }
1788                 KKASSERT(par->nc_exlocks == 0);
1789                 _cache_lock(ncp);
1790         }
1791 done:
1792         _cache_unlock(ncp);
1793         atomic_subtract_int(&ncp->nc_refs, 1);
1794 }
1795
1796 static enum { CHI_LOW, CHI_HIGH } cache_hysteresis_state = CHI_LOW;
1797
1798 static __inline
1799 void
1800 cache_hysteresis(void)
1801 {
1802         /*
1803          * Don't cache too many negative hits.  We use hysteresis to reduce
1804          * the impact on the critical path.
1805          */
1806         switch(cache_hysteresis_state) {
1807         case CHI_LOW:
1808                 if (numneg > MINNEG && numneg * ncnegfactor > numcache) {
1809                         cache_cleanneg(10);
1810                         cache_hysteresis_state = CHI_HIGH;
1811                 }
1812                 break;
1813         case CHI_HIGH:
1814                 if (numneg > MINNEG * 9 / 10 && 
1815                     numneg * ncnegfactor * 9 / 10 > numcache
1816                 ) {
1817                         cache_cleanneg(10);
1818                 } else {
1819                         cache_hysteresis_state = CHI_LOW;
1820                 }
1821                 break;
1822         }
1823 }
1824
1825 /*
1826  * NEW NAMECACHE LOOKUP API
1827  *
1828  * Lookup an entry in the cache.  A locked, referenced, non-NULL 
1829  * entry is *always* returned, even if the supplied component is illegal.
1830  * The resulting namecache entry should be returned to the system with
1831  * cache_put() or _cache_unlock() + cache_drop().
1832  *
1833  * namecache locks are recursive but care must be taken to avoid lock order
1834  * reversals.
1835  *
1836  * Nobody else will be able to manipulate the associated namespace (e.g.
1837  * create, delete, rename, rename-target) until the caller unlocks the
1838  * entry.
1839  *
1840  * The returned entry will be in one of three states:  positive hit (non-null
1841  * vnode), negative hit (null vnode), or unresolved (NCF_UNRESOLVED is set).
1842  * Unresolved entries must be resolved through the filesystem to associate the
1843  * vnode and/or determine whether a positive or negative hit has occured.
1844  *
1845  * It is not necessary to lock a directory in order to lock namespace under
1846  * that directory.  In fact, it is explicitly not allowed to do that.  A
1847  * directory is typically only locked when being created, renamed, or
1848  * destroyed.
1849  *
1850  * The directory (par) may be unresolved, in which case any returned child
1851  * will likely also be marked unresolved.  Likely but not guarenteed.  Since
1852  * the filesystem lookup requires a resolved directory vnode the caller is
1853  * responsible for resolving the namecache chain top-down.  This API 
1854  * specifically allows whole chains to be created in an unresolved state.
1855  */
1856 struct nchandle
1857 cache_nlookup(struct nchandle *par_nch, struct nlcomponent *nlc)
1858 {
1859         struct nchandle nch;
1860         struct namecache *ncp;
1861         struct namecache *new_ncp;
1862         struct nchashhead *nchpp;
1863         struct mount *mp;
1864         u_int32_t hash;
1865         globaldata_t gd;
1866
1867         numcalls++;
1868         gd = mycpu;
1869         mp = par_nch->mount;
1870
1871         /*
1872          * Try to locate an existing entry
1873          */
1874         hash = fnv_32_buf(nlc->nlc_nameptr, nlc->nlc_namelen, FNV1_32_INIT);
1875         hash = fnv_32_buf(&par_nch->ncp, sizeof(par_nch->ncp), hash);
1876         new_ncp = NULL;
1877 restart:
1878         LIST_FOREACH(ncp, (NCHHASH(hash)), nc_hash) {
1879                 numchecks++;
1880
1881                 /*
1882                  * Break out if we find a matching entry.  Note that
1883                  * UNRESOLVED entries may match, but DESTROYED entries
1884                  * do not.
1885                  */
1886                 if (ncp->nc_parent == par_nch->ncp &&
1887                     ncp->nc_nlen == nlc->nlc_namelen &&
1888                     bcmp(ncp->nc_name, nlc->nlc_nameptr, ncp->nc_nlen) == 0 &&
1889                     (ncp->nc_flag & NCF_DESTROYED) == 0
1890                 ) {
1891                         if (_cache_get_nonblock(ncp) == 0) {
1892                                 _cache_auto_unresolve(mp, ncp);
1893                                 if (new_ncp)
1894                                         _cache_free(new_ncp);
1895                                 goto found;
1896                         }
1897                         _cache_get(ncp);
1898                         _cache_put(ncp);
1899                         goto restart;
1900                 }
1901         }
1902
1903         /*
1904          * We failed to locate an entry, create a new entry and add it to
1905          * the cache.  We have to relookup after possibly blocking in
1906          * malloc.
1907          */
1908         if (new_ncp == NULL) {
1909                 new_ncp = cache_alloc(nlc->nlc_namelen);
1910                 goto restart;
1911         }
1912
1913         ncp = new_ncp;
1914
1915         /*
1916          * Initialize as a new UNRESOLVED entry, lock (non-blocking),
1917          * and link to the parent.  The mount point is usually inherited
1918          * from the parent unless this is a special case such as a mount
1919          * point where nlc_namelen is 0.   If nlc_namelen is 0 nc_name will
1920          * be NULL.
1921          */
1922         if (nlc->nlc_namelen) {
1923                 bcopy(nlc->nlc_nameptr, ncp->nc_name, nlc->nlc_namelen);
1924                 ncp->nc_name[nlc->nlc_namelen] = 0;
1925         }
1926         nchpp = NCHHASH(hash);
1927         LIST_INSERT_HEAD(nchpp, ncp, nc_hash);
1928         ncp->nc_flag |= NCF_HASHED;
1929         cache_link_parent(ncp, par_nch->ncp);
1930 found:
1931         /*
1932          * stats and namecache size management
1933          */
1934         if (ncp->nc_flag & NCF_UNRESOLVED)
1935                 ++gd->gd_nchstats->ncs_miss;
1936         else if (ncp->nc_vp)
1937                 ++gd->gd_nchstats->ncs_goodhits;
1938         else
1939                 ++gd->gd_nchstats->ncs_neghits;
1940         cache_hysteresis();
1941         nch.mount = mp;
1942         nch.ncp = ncp;
1943         ++nch.mount->mnt_refs;
1944         return(nch);
1945 }
1946
1947 /*
1948  * The namecache entry is marked as being used as a mount point. 
1949  * Locate the mount if it is visible to the caller.
1950  */
1951 struct findmount_info {
1952         struct mount *result;
1953         struct mount *nch_mount;
1954         struct namecache *nch_ncp;
1955 };
1956
1957 static
1958 int
1959 cache_findmount_callback(struct mount *mp, void *data)
1960 {
1961         struct findmount_info *info = data;
1962
1963         /*
1964          * Check the mount's mounted-on point against the passed nch.
1965          */
1966         if (mp->mnt_ncmounton.mount == info->nch_mount &&
1967             mp->mnt_ncmounton.ncp == info->nch_ncp
1968         ) {
1969             info->result = mp;
1970             return(-1);
1971         }
1972         return(0);
1973 }
1974
1975 struct mount *
1976 cache_findmount(struct nchandle *nch)
1977 {
1978         struct findmount_info info;
1979
1980         info.result = NULL;
1981         info.nch_mount = nch->mount;
1982         info.nch_ncp = nch->ncp;
1983         mountlist_scan(cache_findmount_callback, &info,
1984                                MNTSCAN_FORWARD|MNTSCAN_NOBUSY);
1985         return(info.result);
1986 }
1987
1988 /*
1989  * Resolve an unresolved namecache entry, generally by looking it up.
1990  * The passed ncp must be locked and refd. 
1991  *
1992  * Theoretically since a vnode cannot be recycled while held, and since
1993  * the nc_parent chain holds its vnode as long as children exist, the
1994  * direct parent of the cache entry we are trying to resolve should
1995  * have a valid vnode.  If not then generate an error that we can 
1996  * determine is related to a resolver bug.
1997  *
1998  * However, if a vnode was in the middle of a recyclement when the NCP
1999  * got locked, ncp->nc_vp might point to a vnode that is about to become
2000  * invalid.  cache_resolve() handles this case by unresolving the entry
2001  * and then re-resolving it.
2002  *
2003  * Note that successful resolution does not necessarily return an error
2004  * code of 0.  If the ncp resolves to a negative cache hit then ENOENT
2005  * will be returned.
2006  */
2007 int
2008 cache_resolve(struct nchandle *nch, struct ucred *cred)
2009 {
2010         struct namecache *par;
2011         struct namecache *ncp;
2012         struct nchandle nctmp;
2013         struct mount *mp;
2014         struct vnode *dvp;
2015         int error;
2016
2017         ncp = nch->ncp;
2018         mp = nch->mount;
2019 restart:
2020         /*
2021          * If the ncp is already resolved we have nothing to do.  However,
2022          * we do want to guarentee that a usable vnode is returned when
2023          * a vnode is present, so make sure it hasn't been reclaimed.
2024          */
2025         if ((ncp->nc_flag & NCF_UNRESOLVED) == 0) {
2026                 if (ncp->nc_vp && (ncp->nc_vp->v_flag & VRECLAIMED))
2027                         _cache_setunresolved(ncp);
2028                 if ((ncp->nc_flag & NCF_UNRESOLVED) == 0)
2029                         return (ncp->nc_error);
2030         }
2031
2032         /*
2033          * Mount points need special handling because the parent does not
2034          * belong to the same filesystem as the ncp.
2035          */
2036         if (ncp == mp->mnt_ncmountpt.ncp)
2037                 return (cache_resolve_mp(mp));
2038
2039         /*
2040          * We expect an unbroken chain of ncps to at least the mount point,
2041          * and even all the way to root (but this code doesn't have to go
2042          * past the mount point).
2043          */
2044         if (ncp->nc_parent == NULL) {
2045                 kprintf("EXDEV case 1 %p %*.*s\n", ncp,
2046                         ncp->nc_nlen, ncp->nc_nlen, ncp->nc_name);
2047                 ncp->nc_error = EXDEV;
2048                 return(ncp->nc_error);
2049         }
2050
2051         /*
2052          * The vp's of the parent directories in the chain are held via vhold()
2053          * due to the existance of the child, and should not disappear. 
2054          * However, there are cases where they can disappear:
2055          *
2056          *      - due to filesystem I/O errors.
2057          *      - due to NFS being stupid about tracking the namespace and
2058          *        destroys the namespace for entire directories quite often.
2059          *      - due to forced unmounts.
2060          *      - due to an rmdir (parent will be marked DESTROYED)
2061          *
2062          * When this occurs we have to track the chain backwards and resolve
2063          * it, looping until the resolver catches up to the current node.  We
2064          * could recurse here but we might run ourselves out of kernel stack
2065          * so we do it in a more painful manner.  This situation really should
2066          * not occur all that often, or if it does not have to go back too
2067          * many nodes to resolve the ncp.
2068          */
2069         while ((dvp = cache_dvpref(ncp)) == NULL) {
2070                 /*
2071                  * This case can occur if a process is CD'd into a
2072                  * directory which is then rmdir'd.  If the parent is marked
2073                  * destroyed there is no point trying to resolve it.
2074                  */
2075                 if (ncp->nc_parent->nc_flag & NCF_DESTROYED)
2076                         return(ENOENT);
2077
2078                 par = ncp->nc_parent;
2079                 while (par->nc_parent && par->nc_parent->nc_vp == NULL)
2080                         par = par->nc_parent;
2081                 if (par->nc_parent == NULL) {
2082                         kprintf("EXDEV case 2 %*.*s\n",
2083                                 par->nc_nlen, par->nc_nlen, par->nc_name);
2084                         return (EXDEV);
2085                 }
2086                 kprintf("[diagnostic] cache_resolve: had to recurse on %*.*s\n",
2087                         par->nc_nlen, par->nc_nlen, par->nc_name);
2088                 /*
2089                  * The parent is not set in stone, ref and lock it to prevent
2090                  * it from disappearing.  Also note that due to renames it
2091                  * is possible for our ncp to move and for par to no longer
2092                  * be one of its parents.  We resolve it anyway, the loop 
2093                  * will handle any moves.
2094                  */
2095                 _cache_get(par);
2096                 if (par == nch->mount->mnt_ncmountpt.ncp) {
2097                         cache_resolve_mp(nch->mount);
2098                 } else if ((dvp = cache_dvpref(par)) == NULL) {
2099                         kprintf("[diagnostic] cache_resolve: raced on %*.*s\n", par->nc_nlen, par->nc_nlen, par->nc_name);
2100                         _cache_put(par);
2101                         continue;
2102                 } else {
2103                         if (par->nc_flag & NCF_UNRESOLVED) {
2104                                 nctmp.mount = mp;
2105                                 nctmp.ncp = par;
2106                                 par->nc_error = VOP_NRESOLVE(&nctmp, dvp, cred);
2107                         }
2108                         vrele(dvp);
2109                 }
2110                 if ((error = par->nc_error) != 0) {
2111                         if (par->nc_error != EAGAIN) {
2112                                 kprintf("EXDEV case 3 %*.*s error %d\n",
2113                                     par->nc_nlen, par->nc_nlen, par->nc_name,
2114                                     par->nc_error);
2115                                 _cache_put(par);
2116                                 return(error);
2117                         }
2118                         kprintf("[diagnostic] cache_resolve: EAGAIN par %p %*.*s\n",
2119                                 par, par->nc_nlen, par->nc_nlen, par->nc_name);
2120                 }
2121                 _cache_put(par);
2122                 /* loop */
2123         }
2124
2125         /*
2126          * Call VOP_NRESOLVE() to get the vp, then scan for any disconnected
2127          * ncp's and reattach them.  If this occurs the original ncp is marked
2128          * EAGAIN to force a relookup.
2129          *
2130          * NOTE: in order to call VOP_NRESOLVE(), the parent of the passed
2131          * ncp must already be resolved.
2132          */
2133         if (dvp) {
2134                 nctmp.mount = mp;
2135                 nctmp.ncp = ncp;
2136                 ncp->nc_error = VOP_NRESOLVE(&nctmp, dvp, cred);
2137                 vrele(dvp);
2138         } else {
2139                 ncp->nc_error = EPERM;
2140         }
2141         if (ncp->nc_error == EAGAIN) {
2142                 kprintf("[diagnostic] cache_resolve: EAGAIN ncp %p %*.*s\n",
2143                         ncp, ncp->nc_nlen, ncp->nc_nlen, ncp->nc_name);
2144                 goto restart;
2145         }
2146         return(ncp->nc_error);
2147 }
2148
2149 /*
2150  * Resolve the ncp associated with a mount point.  Such ncp's almost always
2151  * remain resolved and this routine is rarely called.  NFS MPs tends to force
2152  * re-resolution more often due to its mac-truck-smash-the-namecache
2153  * method of tracking namespace changes.
2154  *
2155  * The semantics for this call is that the passed ncp must be locked on
2156  * entry and will be locked on return.  However, if we actually have to
2157  * resolve the mount point we temporarily unlock the entry in order to
2158  * avoid race-to-root deadlocks due to e.g. dead NFS mounts.  Because of
2159  * the unlock we have to recheck the flags after we relock.
2160  */
2161 static int
2162 cache_resolve_mp(struct mount *mp)
2163 {
2164         struct namecache *ncp = mp->mnt_ncmountpt.ncp;
2165         struct vnode *vp;
2166         int error;
2167
2168         KKASSERT(mp != NULL);
2169
2170         /*
2171          * If the ncp is already resolved we have nothing to do.  However,
2172          * we do want to guarentee that a usable vnode is returned when
2173          * a vnode is present, so make sure it hasn't been reclaimed.
2174          */
2175         if ((ncp->nc_flag & NCF_UNRESOLVED) == 0) {
2176                 if (ncp->nc_vp && (ncp->nc_vp->v_flag & VRECLAIMED))
2177                         _cache_setunresolved(ncp);
2178         }
2179
2180         if (ncp->nc_flag & NCF_UNRESOLVED) {
2181                 _cache_unlock(ncp);
2182                 while (vfs_busy(mp, 0))
2183                         ;
2184                 error = VFS_ROOT(mp, &vp);
2185                 _cache_lock(ncp);
2186
2187                 /*
2188                  * recheck the ncp state after relocking.
2189                  */
2190                 if (ncp->nc_flag & NCF_UNRESOLVED) {
2191                         ncp->nc_error = error;
2192                         if (error == 0) {
2193                                 _cache_setvp(mp, ncp, vp);
2194                                 vput(vp);
2195                         } else {
2196                                 kprintf("[diagnostic] cache_resolve_mp: failed"
2197                                         " to resolve mount %p err=%d ncp=%p\n",
2198                                         mp, error, ncp);
2199                                 _cache_setvp(mp, ncp, NULL);
2200                         }
2201                 } else if (error == 0) {
2202                         vput(vp);
2203                 }
2204                 vfs_unbusy(mp);
2205         }
2206         return(ncp->nc_error);
2207 }
2208
2209 void
2210 cache_cleanneg(int count)
2211 {
2212         struct namecache *ncp;
2213
2214         /*
2215          * Automode from the vnlru proc - clean out 10% of the negative cache
2216          * entries.
2217          */
2218         if (count == 0)
2219                 count = numneg / 10 + 1;
2220
2221         /*
2222          * Attempt to clean out the specified number of negative cache
2223          * entries.
2224          */
2225         while (count) {
2226                 ncp = TAILQ_FIRST(&ncneglist);
2227                 if (ncp == NULL) {
2228                         KKASSERT(numneg == 0);
2229                         break;
2230                 }
2231                 TAILQ_REMOVE(&ncneglist, ncp, nc_vnode);
2232                 TAILQ_INSERT_TAIL(&ncneglist, ncp, nc_vnode);
2233                 if (_cache_get_nonblock(ncp) == 0)
2234                         cache_zap(ncp);
2235                 --count;
2236         }
2237 }
2238
2239 /*
2240  * Rehash a ncp.  Rehashing is typically required if the name changes (should
2241  * not generally occur) or the parent link changes.  This function will
2242  * unhash the ncp if the ncp is no longer hashable.
2243  */
2244 static void
2245 _cache_rehash(struct namecache *ncp)
2246 {
2247         struct nchashhead *nchpp;
2248         u_int32_t hash;
2249
2250         if (ncp->nc_flag & NCF_HASHED) {
2251                 ncp->nc_flag &= ~NCF_HASHED;
2252                 LIST_REMOVE(ncp, nc_hash);
2253         }
2254         if (ncp->nc_nlen && ncp->nc_parent) {
2255                 hash = fnv_32_buf(ncp->nc_name, ncp->nc_nlen, FNV1_32_INIT);
2256                 hash = fnv_32_buf(&ncp->nc_parent, 
2257                                         sizeof(ncp->nc_parent), hash);
2258                 nchpp = NCHHASH(hash);
2259                 LIST_INSERT_HEAD(nchpp, ncp, nc_hash);
2260                 ncp->nc_flag |= NCF_HASHED;
2261         }
2262 }
2263
2264 /*
2265  * Name cache initialization, from vfsinit() when we are booting
2266  */
2267 void
2268 nchinit(void)
2269 {
2270         int i;
2271         globaldata_t gd;
2272
2273         /* initialise per-cpu namecache effectiveness statistics. */
2274         for (i = 0; i < ncpus; ++i) {
2275                 gd = globaldata_find(i);
2276                 gd->gd_nchstats = &nchstats[i];
2277         }
2278         TAILQ_INIT(&ncneglist);
2279         nchashtbl = hashinit(desiredvnodes*2, M_VFSCACHE, &nchash);
2280         nclockwarn = 5 * hz;
2281 }
2282
2283 /*
2284  * Called from start_init() to bootstrap the root filesystem.  Returns
2285  * a referenced, unlocked namecache record.
2286  */
2287 void
2288 cache_allocroot(struct nchandle *nch, struct mount *mp, struct vnode *vp)
2289 {
2290         nch->ncp = cache_alloc(0);
2291         nch->mount = mp;
2292         ++mp->mnt_refs;
2293         if (vp)
2294                 _cache_setvp(nch->mount, nch->ncp, vp);
2295 }
2296
2297 /*
2298  * vfs_cache_setroot()
2299  *
2300  *      Create an association between the root of our namecache and
2301  *      the root vnode.  This routine may be called several times during
2302  *      booting.
2303  *
2304  *      If the caller intends to save the returned namecache pointer somewhere
2305  *      it must cache_hold() it.
2306  */
2307 void
2308 vfs_cache_setroot(struct vnode *nvp, struct nchandle *nch)
2309 {
2310         struct vnode *ovp;
2311         struct nchandle onch;
2312
2313         ovp = rootvnode;
2314         onch = rootnch;
2315         rootvnode = nvp;
2316         if (nch)
2317                 rootnch = *nch;
2318         else
2319                 cache_zero(&rootnch);
2320         if (ovp)
2321                 vrele(ovp);
2322         if (onch.ncp)
2323                 cache_drop(&onch);
2324 }
2325
2326 /*
2327  * XXX OLD API COMPAT FUNCTION.  This really messes up the new namecache
2328  * topology and is being removed as quickly as possible.  The new VOP_N*()
2329  * API calls are required to make specific adjustments using the supplied
2330  * ncp pointers rather then just bogusly purging random vnodes.
2331  *
2332  * Invalidate all namecache entries to a particular vnode as well as 
2333  * any direct children of that vnode in the namecache.  This is a 
2334  * 'catch all' purge used by filesystems that do not know any better.
2335  *
2336  * Note that the linkage between the vnode and its namecache entries will
2337  * be removed, but the namecache entries themselves might stay put due to
2338  * active references from elsewhere in the system or due to the existance of
2339  * the children.   The namecache topology is left intact even if we do not
2340  * know what the vnode association is.  Such entries will be marked
2341  * NCF_UNRESOLVED.
2342  */
2343 void
2344 cache_purge(struct vnode *vp)
2345 {
2346         cache_inval_vp(vp, CINV_DESTROY | CINV_CHILDREN);
2347 }
2348
2349 /*
2350  * Flush all entries referencing a particular filesystem.
2351  *
2352  * Since we need to check it anyway, we will flush all the invalid
2353  * entries at the same time.
2354  */
2355 #if 0
2356
2357 void
2358 cache_purgevfs(struct mount *mp)
2359 {
2360         struct nchashhead *nchpp;
2361         struct namecache *ncp, *nnp;
2362
2363         /*
2364          * Scan hash tables for applicable entries.
2365          */
2366         for (nchpp = &nchashtbl[nchash]; nchpp >= nchashtbl; nchpp--) {
2367                 ncp = LIST_FIRST(nchpp);
2368                 if (ncp)
2369                         _cache_hold(ncp);
2370                 while (ncp) {
2371                         nnp = LIST_NEXT(ncp, nc_hash);
2372                         if (nnp)
2373                                 _cache_hold(nnp);
2374                         if (ncp->nc_mount == mp) {
2375                                 _cache_lock(ncp);
2376                                 cache_zap(ncp);
2377                         } else {
2378                                 _cache_drop(ncp);
2379                         }
2380                         ncp = nnp;
2381                 }
2382         }
2383 }
2384
2385 #endif
2386
2387 /*
2388  * Create a new (theoretically) unique fsmid
2389  */
2390 int64_t
2391 cache_getnewfsmid(void)
2392 {
2393         static int fsmid_roller;
2394         int64_t fsmid;
2395
2396         ++fsmid_roller;
2397         fsmid = ((int64_t)time_second << 32) |
2398                         (fsmid_roller & 0x7FFFFFFF);
2399         return (fsmid);
2400 }
2401
2402
2403 static int disablecwd;
2404 SYSCTL_INT(_debug, OID_AUTO, disablecwd, CTLFLAG_RW, &disablecwd, 0, "");
2405
2406 static u_long numcwdcalls; STATNODE(CTLFLAG_RD, numcwdcalls, &numcwdcalls);
2407 static u_long numcwdfail1; STATNODE(CTLFLAG_RD, numcwdfail1, &numcwdfail1);
2408 static u_long numcwdfail2; STATNODE(CTLFLAG_RD, numcwdfail2, &numcwdfail2);
2409 static u_long numcwdfail3; STATNODE(CTLFLAG_RD, numcwdfail3, &numcwdfail3);
2410 static u_long numcwdfail4; STATNODE(CTLFLAG_RD, numcwdfail4, &numcwdfail4);
2411 static u_long numcwdfound; STATNODE(CTLFLAG_RD, numcwdfound, &numcwdfound);
2412
2413 /*
2414  * MPALMOSTSAFE
2415  */
2416 int
2417 sys___getcwd(struct __getcwd_args *uap)
2418 {
2419         int buflen;
2420         int error;
2421         char *buf;
2422         char *bp;
2423
2424         if (disablecwd)
2425                 return (ENODEV);
2426
2427         buflen = uap->buflen;
2428         if (buflen == 0)
2429                 return (EINVAL);
2430         if (buflen > MAXPATHLEN)
2431                 buflen = MAXPATHLEN;
2432
2433         buf = kmalloc(buflen, M_TEMP, M_WAITOK);
2434         get_mplock();
2435         bp = kern_getcwd(buf, buflen, &error);
2436         rel_mplock();
2437         if (error == 0)
2438                 error = copyout(bp, uap->buf, strlen(bp) + 1);
2439         kfree(buf, M_TEMP);
2440         return (error);
2441 }
2442
2443 char *
2444 kern_getcwd(char *buf, size_t buflen, int *error)
2445 {
2446         struct proc *p = curproc;
2447         char *bp;
2448         int i, slash_prefixed;
2449         struct filedesc *fdp;
2450         struct nchandle nch;
2451
2452         numcwdcalls++;
2453         bp = buf;
2454         bp += buflen - 1;
2455         *bp = '\0';
2456         fdp = p->p_fd;
2457         slash_prefixed = 0;
2458
2459         nch = fdp->fd_ncdir;
2460         while (nch.ncp && (nch.ncp != fdp->fd_nrdir.ncp || 
2461                nch.mount != fdp->fd_nrdir.mount)
2462         ) {
2463                 /*
2464                  * While traversing upwards if we encounter the root
2465                  * of the current mount we have to skip to the mount point
2466                  * in the underlying filesystem.
2467                  */
2468                 if (nch.ncp == nch.mount->mnt_ncmountpt.ncp) {
2469                         nch = nch.mount->mnt_ncmounton;
2470                         continue;
2471                 }
2472
2473                 /*
2474                  * Prepend the path segment
2475                  */
2476                 for (i = nch.ncp->nc_nlen - 1; i >= 0; i--) {
2477                         if (bp == buf) {
2478                                 numcwdfail4++;
2479                                 *error = ERANGE;
2480                                 return(NULL);
2481                         }
2482                         *--bp = nch.ncp->nc_name[i];
2483                 }
2484                 if (bp == buf) {
2485                         numcwdfail4++;
2486                         *error = ERANGE;
2487                         return(NULL);
2488                 }
2489                 *--bp = '/';
2490                 slash_prefixed = 1;
2491
2492                 /*
2493                  * Go up a directory.  This isn't a mount point so we don't
2494                  * have to check again.
2495                  */
2496                 nch.ncp = nch.ncp->nc_parent;
2497         }
2498         if (nch.ncp == NULL) {
2499                 numcwdfail2++;
2500                 *error = ENOENT;
2501                 return(NULL);
2502         }
2503         if (!slash_prefixed) {
2504                 if (bp == buf) {
2505                         numcwdfail4++;
2506                         *error = ERANGE;
2507                         return(NULL);
2508                 }
2509                 *--bp = '/';
2510         }
2511         numcwdfound++;
2512         *error = 0;
2513         return (bp);
2514 }
2515
2516 /*
2517  * Thus begins the fullpath magic.
2518  */
2519
2520 #undef STATNODE
2521 #define STATNODE(name)                                                  \
2522         static u_int name;                                              \
2523         SYSCTL_UINT(_vfs_cache, OID_AUTO, name, CTLFLAG_RD, &name, 0, "")
2524
2525 static int disablefullpath;
2526 SYSCTL_INT(_debug, OID_AUTO, disablefullpath, CTLFLAG_RW,
2527     &disablefullpath, 0, "");
2528
2529 STATNODE(numfullpathcalls);
2530 STATNODE(numfullpathfail1);
2531 STATNODE(numfullpathfail2);
2532 STATNODE(numfullpathfail3);
2533 STATNODE(numfullpathfail4);
2534 STATNODE(numfullpathfound);
2535
2536 int
2537 cache_fullpath(struct proc *p, struct nchandle *nchp, char **retbuf, char **freebuf)
2538 {
2539         char *bp, *buf;
2540         int i, slash_prefixed;
2541         struct nchandle fd_nrdir;
2542         struct nchandle nch;
2543
2544         numfullpathcalls--;
2545
2546         *retbuf = NULL; 
2547         *freebuf = NULL;
2548
2549         buf = kmalloc(MAXPATHLEN, M_TEMP, M_WAITOK);
2550         bp = buf + MAXPATHLEN - 1;
2551         *bp = '\0';
2552         if (p != NULL)
2553                 fd_nrdir = p->p_fd->fd_nrdir;
2554         else
2555                 fd_nrdir = rootnch;
2556         slash_prefixed = 0;
2557         nch = *nchp;
2558
2559         while (nch.ncp && 
2560                (nch.ncp != fd_nrdir.ncp || nch.mount != fd_nrdir.mount)
2561         ) {
2562                 /*
2563                  * While traversing upwards if we encounter the root
2564                  * of the current mount we have to skip to the mount point.
2565                  */
2566                 if (nch.ncp == nch.mount->mnt_ncmountpt.ncp) {
2567                         nch = nch.mount->mnt_ncmounton;
2568                         continue;
2569                 }
2570
2571                 /*
2572                  * Prepend the path segment
2573                  */
2574                 for (i = nch.ncp->nc_nlen - 1; i >= 0; i--) {
2575                         if (bp == buf) {
2576                                 numfullpathfail4++;
2577                                 kfree(buf, M_TEMP);
2578                                 return(ENOMEM);
2579                         }
2580                         *--bp = nch.ncp->nc_name[i];
2581                 }
2582                 if (bp == buf) {
2583                         numfullpathfail4++;
2584                         kfree(buf, M_TEMP);
2585                         return(ENOMEM);
2586                 }
2587                 *--bp = '/';
2588                 slash_prefixed = 1;
2589
2590                 /*
2591                  * Go up a directory.  This isn't a mount point so we don't
2592                  * have to check again.
2593                  */
2594                 nch.ncp = nch.ncp->nc_parent;
2595         }
2596         if (nch.ncp == NULL) {
2597                 numfullpathfail2++;
2598                 kfree(buf, M_TEMP);
2599                 return(ENOENT);
2600         }
2601
2602         if (!slash_prefixed) {
2603                 if (bp == buf) {
2604                         numfullpathfail4++;
2605                         kfree(buf, M_TEMP);
2606                         return(ENOMEM);
2607                 }
2608                 *--bp = '/';
2609         }
2610         numfullpathfound++;
2611         *retbuf = bp; 
2612         *freebuf = buf;
2613
2614         return(0);
2615 }
2616
2617 int
2618 vn_fullpath(struct proc *p, struct vnode *vn, char **retbuf, char **freebuf) 
2619 {
2620         struct namecache *ncp;
2621         struct nchandle nch;
2622
2623         numfullpathcalls++;
2624         if (disablefullpath)
2625                 return (ENODEV);
2626
2627         if (p == NULL)
2628                 return (EINVAL);
2629
2630         /* vn is NULL, client wants us to use p->p_textvp */
2631         if (vn == NULL) {
2632                 if ((vn = p->p_textvp) == NULL)
2633                         return (EINVAL);
2634         }
2635         TAILQ_FOREACH(ncp, &vn->v_namecache, nc_vnode) {
2636                 if (ncp->nc_nlen)
2637                         break;
2638         }
2639         if (ncp == NULL)
2640                 return (EINVAL);
2641
2642         numfullpathcalls--;
2643         nch.ncp = ncp;;
2644         nch.mount = vn->v_mount;
2645         return(cache_fullpath(p, &nch, retbuf, freebuf));
2646 }