sys/kern/vfs_cache.c

   1 /*-
   2  * Copyright (c) 1989, 1993, 1995
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Poul-Henning Kamp of the FreeBSD Project.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  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 the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. Neither the name of the University nor the names of its contributors
  17  *    may be used to endorse or promote products derived from this software
  18  *    without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  30  * SUCH DAMAGE.
  31  *
  32  *      @(#)vfs_cache.c 8.5 (Berkeley) 3/22/95
  33  */
  34
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 #include "opt_ktrace.h"
  39
  40 #include <sys/param.h>
  41 #include <sys/systm.h>
  42 #include <sys/counter.h>
  43 #include <sys/filedesc.h>
  44 #include <sys/fnv_hash.h>
  45 #include <sys/kernel.h>
  46 #include <sys/lock.h>
  47 #include <sys/malloc.h>
  48 #include <sys/fcntl.h>
  49 #include <sys/mount.h>
  50 #include <sys/namei.h>
  51 #include <sys/proc.h>
  52 #include <sys/rwlock.h>
  53 #include <sys/sdt.h>
  54 #include <sys/smp.h>
  55 #include <sys/syscallsubr.h>
  56 #include <sys/sysctl.h>
  57 #include <sys/sysproto.h>
  58 #include <sys/vnode.h>
  59 #ifdef KTRACE
  60 #include <sys/ktrace.h>
  61 #endif
  62
  63 #include <vm/uma.h>
  64
  65 SDT_PROVIDER_DECLARE(vfs);
  66 SDT_PROBE_DEFINE3(vfs, namecache, enter, done, "struct vnode *", "char *",
  67     "struct vnode *");
  68 SDT_PROBE_DEFINE2(vfs, namecache, enter_negative, done, "struct vnode *",
  69     "char *");
  70 SDT_PROBE_DEFINE1(vfs, namecache, fullpath, entry, "struct vnode *");
  71 SDT_PROBE_DEFINE3(vfs, namecache, fullpath, hit, "struct vnode *",
  72     "char *", "struct vnode *");
  73 SDT_PROBE_DEFINE1(vfs, namecache, fullpath, miss, "struct vnode *");
  74 SDT_PROBE_DEFINE3(vfs, namecache, fullpath, return, "int",
  75     "struct vnode *", "char *");
  76 SDT_PROBE_DEFINE3(vfs, namecache, lookup, hit, "struct vnode *", "char *",
  77     "struct vnode *");
  78 SDT_PROBE_DEFINE2(vfs, namecache, lookup, hit__negative,
  79     "struct vnode *", "char *");
  80 SDT_PROBE_DEFINE2(vfs, namecache, lookup, miss, "struct vnode *",
  81     "char *");
  82 SDT_PROBE_DEFINE1(vfs, namecache, purge, done, "struct vnode *");
  83 SDT_PROBE_DEFINE1(vfs, namecache, purge_negative, done, "struct vnode *");
  84 SDT_PROBE_DEFINE1(vfs, namecache, purgevfs, done, "struct mount *");
  85 SDT_PROBE_DEFINE3(vfs, namecache, zap, done, "struct vnode *", "char *",
  86     "struct vnode *");
  87 SDT_PROBE_DEFINE3(vfs, namecache, zap_negative, done, "struct vnode *",
  88     "char *", "int");
  89 SDT_PROBE_DEFINE3(vfs, namecache, shrink_negative, done, "struct vnode *",
  90     "char *", "int");
  91
  92 /*
  93  * This structure describes the elements in the cache of recent
  94  * names looked up by namei.
  95  */
  96
  97 struct  namecache {
  98         LIST_ENTRY(namecache) nc_hash;  /* hash chain */
  99         LIST_ENTRY(namecache) nc_src;   /* source vnode list */
 100         TAILQ_ENTRY(namecache) nc_dst;  /* destination vnode list */
 101         struct  vnode *nc_dvp;          /* vnode of parent of name */
 102         union {
 103                 struct  vnode *nu_vp;   /* vnode the name refers to */
 104                 u_int   nu_neghits;     /* negative entry hits */
 105         } n_un;
 106         u_char  nc_flag;                /* flag bits */
 107         u_char  nc_nlen;                /* length of name */
 108         char    nc_name[0];             /* segment name + nul */
 109 };
 110
 111 /*
 112  * struct namecache_ts repeats struct namecache layout up to the
 113  * nc_nlen member.
 114  * struct namecache_ts is used in place of struct namecache when time(s) need
 115  * to be stored.  The nc_dotdottime field is used when a cache entry is mapping
 116  * both a non-dotdot directory name plus dotdot for the directory's
 117  * parent.
 118  */
 119 struct  namecache_ts {
 120         LIST_ENTRY(namecache) nc_hash;  /* hash chain */
 121         LIST_ENTRY(namecache) nc_src;   /* source vnode list */
 122         TAILQ_ENTRY(namecache) nc_dst;  /* destination vnode list */
 123         struct  vnode *nc_dvp;          /* vnode of parent of name */
 124         union {
 125                 struct  vnode *nu_vp;   /* vnode the name refers to */
 126                 u_int   nu_neghits;     /* negative entry hits */
 127         } n_un;
 128         u_char  nc_flag;                /* flag bits */
 129         u_char  nc_nlen;                /* length of name */
 130         struct  timespec nc_time;       /* timespec provided by fs */
 131         struct  timespec nc_dotdottime; /* dotdot timespec provided by fs */
 132         int     nc_ticks;               /* ticks value when entry was added */
 133         char    nc_name[0];             /* segment name + nul */
 134 };
 135
 136 #define nc_vp           n_un.nu_vp
 137 #define nc_neghits      n_un.nu_neghits
 138
 139 /*
 140  * Flags in namecache.nc_flag
 141  */
 142 #define NCF_WHITE       0x01
 143 #define NCF_ISDOTDOT    0x02
 144 #define NCF_TS          0x04
 145 #define NCF_DTS         0x08
 146 #define NCF_DVDROP      0x10
 147 #define NCF_NEGATIVE    0x20
 148 #define NCF_HOTNEGATIVE 0x40
 149
 150 /*
 151  * Name caching works as follows:
 152  *
 153  * Names found by directory scans are retained in a cache
 154  * for future reference.  It is managed LRU, so frequently
 155  * used names will hang around.  Cache is indexed by hash value
 156  * obtained from (vp, name) where vp refers to the directory
 157  * containing name.
 158  *
 159  * If it is a "negative" entry, (i.e. for a name that is known NOT to
 160  * exist) the vnode pointer will be NULL.
 161  *
 162  * Upon reaching the last segment of a path, if the reference
 163  * is for DELETE, or NOCACHE is set (rewrite), and the
 164  * name is located in the cache, it will be dropped.
 165  *
 166  * These locks are used (in the order in which they can be taken):
 167  * NAME         TYPE    ROLE
 168  * vnodelock    mtx     vnode lists and v_cache_dd field protection
 169  * bucketlock   rwlock  for access to given set of hash buckets
 170  * neglist      mtx     negative entry LRU management
 171  *
 172  * Additionally, ncneg_shrink_lock mtx is used to have at most one thread
 173  * shrinking the LRU list.
 174  *
 175  * It is legal to take multiple vnodelock and bucketlock locks. The locking
 176  * order is lower address first. Both are recursive.
 177  *
 178  * "." lookups are lockless.
 179  *
 180  * ".." and vnode -> name lookups require vnodelock.
 181  *
 182  * name -> vnode lookup requires the relevant bucketlock to be held for reading.
 183  *
 184  * Insertions and removals of entries require involved vnodes and bucketlocks
 185  * to be write-locked to prevent other threads from seeing the entry.
 186  *
 187  * Some lookups result in removal of the found entry (e.g. getting rid of a
 188  * negative entry with the intent to create a positive one), which poses a
 189  * problem when multiple threads reach the state. Similarly, two different
 190  * threads can purge two different vnodes and try to remove the same name.
 191  *
 192  * If the already held vnode lock is lower than the second required lock, we
 193  * can just take the other lock. However, in the opposite case, this could
 194  * deadlock. As such, this is resolved by trylocking and if that fails unlocking
 195  * the first node, locking everything in order and revalidating the state.
 196  */
 197
 198 /*
 199  * Structures associated with name caching.
 200  */
 201 #define NCHHASH(hash) \
 202         (&nchashtbl[(hash) & nchash])
 203 static __read_mostly LIST_HEAD(nchashhead, namecache) *nchashtbl;/* Hash Table */
 204 static u_long __read_mostly     nchash;                 /* size of hash table */
 205 SYSCTL_ULONG(_debug, OID_AUTO, nchash, CTLFLAG_RD, &nchash, 0,
 206     "Size of namecache hash table");
 207 static u_long __read_mostly     ncnegfactor = 16; /* ratio of negative entries */
 208 SYSCTL_ULONG(_vfs, OID_AUTO, ncnegfactor, CTLFLAG_RW, &ncnegfactor, 0,
 209     "Ratio of negative namecache entries");
 210 static u_long __exclusive_cache_line    numneg; /* number of negative entries allocated */
 211 SYSCTL_ULONG(_debug, OID_AUTO, numneg, CTLFLAG_RD, &numneg, 0,
 212     "Number of negative entries in namecache");
 213 static u_long __exclusive_cache_line    numcache;/* number of cache entries allocated */
 214 SYSCTL_ULONG(_debug, OID_AUTO, numcache, CTLFLAG_RD, &numcache, 0,
 215     "Number of namecache entries");
 216 static u_long __exclusive_cache_line    numcachehv;/* number of cache entries with vnodes held */
 217 SYSCTL_ULONG(_debug, OID_AUTO, numcachehv, CTLFLAG_RD, &numcachehv, 0,
 218     "Number of namecache entries with vnodes held");
 219 u_int __read_mostly     ncsizefactor = 2;
 220 SYSCTL_UINT(_vfs, OID_AUTO, ncsizefactor, CTLFLAG_RW, &ncsizefactor, 0,
 221     "Size factor for namecache");
 222 static u_int __read_mostly      ncpurgeminvnodes;
 223 SYSCTL_UINT(_vfs, OID_AUTO, ncpurgeminvnodes, CTLFLAG_RW, &ncpurgeminvnodes, 0,
 224     "Number of vnodes below which purgevfs ignores the request");
 225 static u_int __read_mostly      ncneghitsrequeue = 8;
 226 SYSCTL_UINT(_vfs, OID_AUTO, ncneghitsrequeue, CTLFLAG_RW, &ncneghitsrequeue, 0,
 227     "Number of hits to requeue a negative entry in the LRU list");
 228
 229 struct nchstats nchstats;               /* cache effectiveness statistics */
 230
 231 static struct mtx       ncneg_shrink_lock;
 232 static int      shrink_list_turn;
 233
 234 struct neglist {
 235         struct mtx              nl_lock;
 236         TAILQ_HEAD(, namecache) nl_list;
 237 } __aligned(CACHE_LINE_SIZE);
 238
 239 static struct neglist __read_mostly     *neglists;
 240 static struct neglist ncneg_hot;
 241
 242 #define numneglists (ncneghash + 1)
 243 static u_int __read_mostly      ncneghash;
 244 static inline struct neglist *
 245 NCP2NEGLIST(struct namecache *ncp)
 246 {
 247
 248         return (&neglists[(((uintptr_t)(ncp) >> 8) & ncneghash)]);
 249 }
 250
 251 #define numbucketlocks (ncbuckethash + 1)
 252 static u_int __read_mostly  ncbuckethash;
 253 static struct rwlock_padalign __read_mostly  *bucketlocks;
 254 #define HASH2BUCKETLOCK(hash) \
 255         ((struct rwlock *)(&bucketlocks[((hash) & ncbuckethash)]))
 256
 257 #define numvnodelocks (ncvnodehash + 1)
 258 static u_int __read_mostly  ncvnodehash;
 259 static struct mtx __read_mostly *vnodelocks;
 260 static inline struct mtx *
 261 VP2VNODELOCK(struct vnode *vp)
 262 {
 263
 264         return (&vnodelocks[(((uintptr_t)(vp) >> 8) & ncvnodehash)]);
 265 }
 266
 267 /*
 268  * UMA zones for the VFS cache.
 269  *
 270  * The small cache is used for entries with short names, which are the
 271  * most common.  The large cache is used for entries which are too big to
 272  * fit in the small cache.
 273  */
 274 static uma_zone_t __read_mostly cache_zone_small;
 275 static uma_zone_t __read_mostly cache_zone_small_ts;
 276 static uma_zone_t __read_mostly cache_zone_large;
 277 static uma_zone_t __read_mostly cache_zone_large_ts;
 278
 279 #define CACHE_PATH_CUTOFF       35
 280
 281 static struct namecache *
 282 cache_alloc(int len, int ts)
 283 {
 284
 285         if (len > CACHE_PATH_CUTOFF) {
 286                 if (ts)
 287                         return (uma_zalloc(cache_zone_large_ts, M_WAITOK));
 288                 else
 289                         return (uma_zalloc(cache_zone_large, M_WAITOK));
 290         }
 291         if (ts)
 292                 return (uma_zalloc(cache_zone_small_ts, M_WAITOK));
 293         else
 294                 return (uma_zalloc(cache_zone_small, M_WAITOK));
 295 }
 296
 297 static void
 298 cache_free(struct namecache *ncp)
 299 {
 300         int ts;
 301
 302         if (ncp == NULL)
 303                 return;
 304         ts = ncp->nc_flag & NCF_TS;
 305         if ((ncp->nc_flag & NCF_DVDROP) != 0)
 306                 vdrop(ncp->nc_dvp);
 307         if (ncp->nc_nlen <= CACHE_PATH_CUTOFF) {
 308                 if (ts)
 309                         uma_zfree(cache_zone_small_ts, ncp);
 310                 else
 311                         uma_zfree(cache_zone_small, ncp);
 312         } else if (ts)
 313                 uma_zfree(cache_zone_large_ts, ncp);
 314         else
 315                 uma_zfree(cache_zone_large, ncp);
 316 }
 317
 318 static char *
 319 nc_get_name(struct namecache *ncp)
 320 {
 321         struct namecache_ts *ncp_ts;
 322
 323         if ((ncp->nc_flag & NCF_TS) == 0)
 324                 return (ncp->nc_name);
 325         ncp_ts = (struct namecache_ts *)ncp;
 326         return (ncp_ts->nc_name);
 327 }
 328
 329 static void
 330 cache_out_ts(struct namecache *ncp, struct timespec *tsp, int *ticksp)
 331 {
 332
 333         KASSERT((ncp->nc_flag & NCF_TS) != 0 ||
 334             (tsp == NULL && ticksp == NULL),
 335             ("No NCF_TS"));
 336
 337         if (tsp != NULL)
 338                 *tsp = ((struct namecache_ts *)ncp)->nc_time;
 339         if (ticksp != NULL)
 340                 *ticksp = ((struct namecache_ts *)ncp)->nc_ticks;
 341 }
 342
 343 static int __read_mostly        doingcache = 1; /* 1 => enable the cache */
 344 SYSCTL_INT(_debug, OID_AUTO, vfscache, CTLFLAG_RW, &doingcache, 0,
 345     "VFS namecache enabled");
 346
 347 /* Export size information to userland */
 348 SYSCTL_INT(_debug_sizeof, OID_AUTO, namecache, CTLFLAG_RD, SYSCTL_NULL_INT_PTR,
 349     sizeof(struct namecache), "sizeof(struct namecache)");
 350
 351 /*
 352  * The new name cache statistics
 353  */
 354 static SYSCTL_NODE(_vfs, OID_AUTO, cache, CTLFLAG_RW, 0,
 355     "Name cache statistics");
 356 #define STATNODE_ULONG(name, descr)     \
 357         SYSCTL_ULONG(_vfs_cache, OID_AUTO, name, CTLFLAG_RD, &name, 0, descr);
 358 #define STATNODE_COUNTER(name, descr)   \
 359         static counter_u64_t __read_mostly name; \
 360         SYSCTL_COUNTER_U64(_vfs_cache, OID_AUTO, name, CTLFLAG_RD, &name, descr);
 361 STATNODE_ULONG(numneg, "Number of negative cache entries");
 362 STATNODE_ULONG(numcache, "Number of cache entries");
 363 STATNODE_COUNTER(numcalls, "Number of cache lookups");
 364 STATNODE_COUNTER(dothits, "Number of '.' hits");
 365 STATNODE_COUNTER(dotdothits, "Number of '..' hits");
 366 STATNODE_COUNTER(numchecks, "Number of checks in lookup");
 367 STATNODE_COUNTER(nummiss, "Number of cache misses");
 368 STATNODE_COUNTER(nummisszap, "Number of cache misses we do not want to cache");
 369 STATNODE_COUNTER(numposzaps,
 370     "Number of cache hits (positive) we do not want to cache");
 371 STATNODE_COUNTER(numposhits, "Number of cache hits (positive)");
 372 STATNODE_COUNTER(numnegzaps,
 373     "Number of cache hits (negative) we do not want to cache");
 374 STATNODE_COUNTER(numneghits, "Number of cache hits (negative)");
 375 /* These count for kern___getcwd(), too. */
 376 STATNODE_COUNTER(numfullpathcalls, "Number of fullpath search calls");
 377 STATNODE_COUNTER(numfullpathfail1, "Number of fullpath search errors (ENOTDIR)");
 378 STATNODE_COUNTER(numfullpathfail2,
 379     "Number of fullpath search errors (VOP_VPTOCNP failures)");
 380 STATNODE_COUNTER(numfullpathfail4, "Number of fullpath search errors (ENOMEM)");
 381 STATNODE_COUNTER(numfullpathfound, "Number of successful fullpath calls");
 382 static long zap_and_exit_bucket_fail; STATNODE_ULONG(zap_and_exit_bucket_fail,
 383     "Number of times zap_and_exit failed to lock");
 384 static long cache_lock_vnodes_cel_3_failures;
 385 STATNODE_ULONG(cache_lock_vnodes_cel_3_failures,
 386     "Number of times 3-way vnode locking failed");
 387
 388 static void cache_zap_locked(struct namecache *ncp, bool neg_locked);
 389 static int vn_fullpath1(struct thread *td, struct vnode *vp, struct vnode *rdir,
 390     char *buf, char **retbuf, u_int buflen);
 391
 392 static MALLOC_DEFINE(M_VFSCACHE, "vfscache", "VFS name cache entries");
 393
 394 static int cache_yield;
 395 SYSCTL_INT(_vfs_cache, OID_AUTO, yield, CTLFLAG_RD, &cache_yield, 0,
 396     "Number of times cache called yield");
 397
 398 static void
 399 cache_maybe_yield(void)
 400 {
 401
 402         if (should_yield()) {
 403                 cache_yield++;
 404                 kern_yield(PRI_USER);
 405         }
 406 }
 407
 408 static inline void
 409 cache_assert_vlp_locked(struct mtx *vlp)
 410 {
 411
 412         if (vlp != NULL)
 413                 mtx_assert(vlp, MA_OWNED);
 414 }
 415
 416 static inline void
 417 cache_assert_vnode_locked(struct vnode *vp)
 418 {
 419         struct mtx *vlp;
 420
 421         vlp = VP2VNODELOCK(vp);
 422         cache_assert_vlp_locked(vlp);
 423 }
 424
 425 static uint32_t
 426 cache_get_hash(char *name, u_char len, struct vnode *dvp)
 427 {
 428         uint32_t hash;
 429
 430         hash = fnv_32_buf(name, len, FNV1_32_INIT);
 431         hash = fnv_32_buf(&dvp, sizeof(dvp), hash);
 432         return (hash);
 433 }
 434
 435 static inline struct rwlock *
 436 NCP2BUCKETLOCK(struct namecache *ncp)
 437 {
 438         uint32_t hash;
 439
 440         hash = cache_get_hash(nc_get_name(ncp), ncp->nc_nlen, ncp->nc_dvp);
 441         return (HASH2BUCKETLOCK(hash));
 442 }
 443
 444 #ifdef INVARIANTS
 445 static void
 446 cache_assert_bucket_locked(struct namecache *ncp, int mode)
 447 {
 448         struct rwlock *blp;
 449
 450         blp = NCP2BUCKETLOCK(ncp);
 451         rw_assert(blp, mode);
 452 }
 453 #else
 454 #define cache_assert_bucket_locked(x, y) do { } while (0)
 455 #endif
 456
 457 #define cache_sort(x, y)        _cache_sort((void **)(x), (void **)(y))
 458 static void
 459 _cache_sort(void **p1, void **p2)
 460 {
 461         void *tmp;
 462
 463         if (*p1 > *p2) {
 464                 tmp = *p2;
 465                 *p2 = *p1;
 466                 *p1 = tmp;
 467         }
 468 }
 469
 470 static void
 471 cache_lock_all_buckets(void)
 472 {
 473         u_int i;
 474
 475         for (i = 0; i < numbucketlocks; i++)
 476                 rw_wlock(&bucketlocks[i]);
 477 }
 478
 479 static void
 480 cache_unlock_all_buckets(void)
 481 {
 482         u_int i;
 483
 484         for (i = 0; i < numbucketlocks; i++)
 485                 rw_wunlock(&bucketlocks[i]);
 486 }
 487
 488 static void
 489 cache_lock_all_vnodes(void)
 490 {
 491         u_int i;
 492
 493         for (i = 0; i < numvnodelocks; i++)
 494                 mtx_lock(&vnodelocks[i]);
 495 }
 496
 497 static void
 498 cache_unlock_all_vnodes(void)
 499 {
 500         u_int i;
 501
 502         for (i = 0; i < numvnodelocks; i++)
 503                 mtx_unlock(&vnodelocks[i]);
 504 }
 505
 506 static int
 507 cache_trylock_vnodes(struct mtx *vlp1, struct mtx *vlp2)
 508 {
 509
 510         cache_sort(&vlp1, &vlp2);
 511         MPASS(vlp2 != NULL);
 512
 513         if (vlp1 != NULL) {
 514                 if (!mtx_trylock(vlp1))
 515                         return (EAGAIN);
 516         }
 517         if (!mtx_trylock(vlp2)) {
 518                 if (vlp1 != NULL)
 519                         mtx_unlock(vlp1);
 520                 return (EAGAIN);
 521         }
 522
 523         return (0);
 524 }
 525
 526 static void
 527 cache_unlock_vnodes(struct mtx *vlp1, struct mtx *vlp2)
 528 {
 529
 530         MPASS(vlp1 != NULL || vlp2 != NULL);
 531
 532         if (vlp1 != NULL)
 533                 mtx_unlock(vlp1);
 534         if (vlp2 != NULL)
 535                 mtx_unlock(vlp2);
 536 }
 537
 538 static int
 539 sysctl_nchstats(SYSCTL_HANDLER_ARGS)
 540 {
 541         struct nchstats snap;
 542
 543         if (req->oldptr == NULL)
 544                 return (SYSCTL_OUT(req, 0, sizeof(snap)));
 545
 546         snap = nchstats;
 547         snap.ncs_goodhits = counter_u64_fetch(numposhits);
 548         snap.ncs_neghits = counter_u64_fetch(numneghits);
 549         snap.ncs_badhits = counter_u64_fetch(numposzaps) +
 550             counter_u64_fetch(numnegzaps);
 551         snap.ncs_miss = counter_u64_fetch(nummisszap) +
 552             counter_u64_fetch(nummiss);
 553
 554         return (SYSCTL_OUT(req, &snap, sizeof(snap)));
 555 }
 556 SYSCTL_PROC(_vfs_cache, OID_AUTO, nchstats, CTLTYPE_OPAQUE | CTLFLAG_RD |
 557     CTLFLAG_MPSAFE, 0, 0, sysctl_nchstats, "LU",
 558     "VFS cache effectiveness statistics");
 559
 560 #ifdef DIAGNOSTIC
 561 /*
 562  * Grab an atomic snapshot of the name cache hash chain lengths
 563  */
 564 static SYSCTL_NODE(_debug, OID_AUTO, hashstat, CTLFLAG_RW, NULL,
 565     "hash table stats");
 566
 567 static int
 568 sysctl_debug_hashstat_rawnchash(SYSCTL_HANDLER_ARGS)
 569 {
 570         struct nchashhead *ncpp;
 571         struct namecache *ncp;
 572         int i, error, n_nchash, *cntbuf;
 573
 574 retry:
 575         n_nchash = nchash + 1;  /* nchash is max index, not count */
 576         if (req->oldptr == NULL)
 577                 return SYSCTL_OUT(req, 0, n_nchash * sizeof(int));
 578         cntbuf = malloc(n_nchash * sizeof(int), M_TEMP, M_ZERO | M_WAITOK);
 579         cache_lock_all_buckets();
 580         if (n_nchash != nchash + 1) {
 581                 cache_unlock_all_buckets();
 582                 free(cntbuf, M_TEMP);
 583                 goto retry;
 584         }
 585         /* Scan hash tables counting entries */
 586         for (ncpp = nchashtbl, i = 0; i < n_nchash; ncpp++, i++)
 587                 LIST_FOREACH(ncp, ncpp, nc_hash)
 588                         cntbuf[i]++;
 589         cache_unlock_all_buckets();
 590         for (error = 0, i = 0; i < n_nchash; i++)
 591                 if ((error = SYSCTL_OUT(req, &cntbuf[i], sizeof(int))) != 0)
 592                         break;
 593         free(cntbuf, M_TEMP);
 594         return (error);
 595 }
 596 SYSCTL_PROC(_debug_hashstat, OID_AUTO, rawnchash, CTLTYPE_INT|CTLFLAG_RD|
 597     CTLFLAG_MPSAFE, 0, 0, sysctl_debug_hashstat_rawnchash, "S,int",
 598     "nchash chain lengths");
 599
 600 static int
 601 sysctl_debug_hashstat_nchash(SYSCTL_HANDLER_ARGS)
 602 {
 603         int error;
 604         struct nchashhead *ncpp;
 605         struct namecache *ncp;
 606         int n_nchash;
 607         int count, maxlength, used, pct;
 608
 609         if (!req->oldptr)
 610                 return SYSCTL_OUT(req, 0, 4 * sizeof(int));
 611
 612         cache_lock_all_buckets();
 613         n_nchash = nchash + 1;  /* nchash is max index, not count */
 614         used = 0;
 615         maxlength = 0;
 616
 617         /* Scan hash tables for applicable entries */
 618         for (ncpp = nchashtbl; n_nchash > 0; n_nchash--, ncpp++) {
 619                 count = 0;
 620                 LIST_FOREACH(ncp, ncpp, nc_hash) {
 621                         count++;
 622                 }
 623                 if (count)
 624                         used++;
 625                 if (maxlength < count)
 626                         maxlength = count;
 627         }
 628         n_nchash = nchash + 1;
 629         cache_unlock_all_buckets();
 630         pct = (used * 100) / (n_nchash / 100);
 631         error = SYSCTL_OUT(req, &n_nchash, sizeof(n_nchash));
 632         if (error)
 633                 return (error);
 634         error = SYSCTL_OUT(req, &used, sizeof(used));
 635         if (error)
 636                 return (error);
 637         error = SYSCTL_OUT(req, &maxlength, sizeof(maxlength));
 638         if (error)
 639                 return (error);
 640         error = SYSCTL_OUT(req, &pct, sizeof(pct));
 641         if (error)
 642                 return (error);
 643         return (0);
 644 }
 645 SYSCTL_PROC(_debug_hashstat, OID_AUTO, nchash, CTLTYPE_INT|CTLFLAG_RD|
 646     CTLFLAG_MPSAFE, 0, 0, sysctl_debug_hashstat_nchash, "I",
 647     "nchash statistics (number of total/used buckets, maximum chain length, usage percentage)");
 648 #endif
 649
 650 /*
 651  * Negative entries management
 652  *
 653  * A variation of LRU scheme is used. New entries are hashed into one of
 654  * numneglists cold lists. Entries get promoted to the hot list on first hit.
 655  * Partial LRU for the hot list is maintained by requeueing them every
 656  * ncneghitsrequeue hits.
 657  *
 658  * The shrinker will demote hot list head and evict from the cold list in a
 659  * round-robin manner.
 660  */
 661 static void
 662 cache_negative_hit(struct namecache *ncp)
 663 {
 664         struct neglist *neglist;
 665         u_int hits;
 666
 667         MPASS(ncp->nc_flag & NCF_NEGATIVE);
 668         hits = atomic_fetchadd_int(&ncp->nc_neghits, 1);
 669         if (ncp->nc_flag & NCF_HOTNEGATIVE) {
 670                 if ((hits % ncneghitsrequeue) != 0)
 671                         return;
 672                 mtx_lock(&ncneg_hot.nl_lock);
 673                 if (ncp->nc_flag & NCF_HOTNEGATIVE) {
 674                         TAILQ_REMOVE(&ncneg_hot.nl_list, ncp, nc_dst);
 675                         TAILQ_INSERT_TAIL(&ncneg_hot.nl_list, ncp, nc_dst);
 676                         mtx_unlock(&ncneg_hot.nl_lock);
 677                         return;
 678                 }
 679                 /*
 680                  * The shrinker cleared the flag and removed the entry from
 681                  * the hot list. Put it back.
 682                  */
 683         } else {
 684                 mtx_lock(&ncneg_hot.nl_lock);
 685         }
 686         neglist = NCP2NEGLIST(ncp);
 687         mtx_lock(&neglist->nl_lock);
 688         if (!(ncp->nc_flag & NCF_HOTNEGATIVE)) {
 689                 TAILQ_REMOVE(&neglist->nl_list, ncp, nc_dst);
 690                 TAILQ_INSERT_TAIL(&ncneg_hot.nl_list, ncp, nc_dst);
 691                 ncp->nc_flag |= NCF_HOTNEGATIVE;
 692         }
 693         mtx_unlock(&neglist->nl_lock);
 694         mtx_unlock(&ncneg_hot.nl_lock);
 695 }
 696
 697 static void
 698 cache_negative_insert(struct namecache *ncp, bool neg_locked)
 699 {
 700         struct neglist *neglist;
 701
 702         MPASS(ncp->nc_flag & NCF_NEGATIVE);
 703         cache_assert_bucket_locked(ncp, RA_WLOCKED);
 704         neglist = NCP2NEGLIST(ncp);
 705         if (!neg_locked) {
 706                 mtx_lock(&neglist->nl_lock);
 707         } else {
 708                 mtx_assert(&neglist->nl_lock, MA_OWNED);
 709         }
 710         TAILQ_INSERT_TAIL(&neglist->nl_list, ncp, nc_dst);
 711         if (!neg_locked)
 712                 mtx_unlock(&neglist->nl_lock);
 713         atomic_add_rel_long(&numneg, 1);
 714 }
 715
 716 static void
 717 cache_negative_remove(struct namecache *ncp, bool neg_locked)
 718 {
 719         struct neglist *neglist;
 720         bool hot_locked = false;
 721         bool list_locked = false;
 722
 723         MPASS(ncp->nc_flag & NCF_NEGATIVE);
 724         cache_assert_bucket_locked(ncp, RA_WLOCKED);
 725         neglist = NCP2NEGLIST(ncp);
 726         if (!neg_locked) {
 727                 if (ncp->nc_flag & NCF_HOTNEGATIVE) {
 728                         hot_locked = true;
 729                         mtx_lock(&ncneg_hot.nl_lock);
 730                         if (!(ncp->nc_flag & NCF_HOTNEGATIVE)) {
 731                                 list_locked = true;
 732                                 mtx_lock(&neglist->nl_lock);
 733                         }
 734                 } else {
 735                         list_locked = true;
 736                         mtx_lock(&neglist->nl_lock);
 737                 }
 738         }
 739         if (ncp->nc_flag & NCF_HOTNEGATIVE) {
 740                 mtx_assert(&ncneg_hot.nl_lock, MA_OWNED);
 741                 TAILQ_REMOVE(&ncneg_hot.nl_list, ncp, nc_dst);
 742         } else {
 743                 mtx_assert(&neglist->nl_lock, MA_OWNED);
 744                 TAILQ_REMOVE(&neglist->nl_list, ncp, nc_dst);
 745         }
 746         if (list_locked)
 747                 mtx_unlock(&neglist->nl_lock);
 748         if (hot_locked)
 749                 mtx_unlock(&ncneg_hot.nl_lock);
 750         atomic_subtract_rel_long(&numneg, 1);
 751 }
 752
 753 static void
 754 cache_negative_shrink_select(int start, struct namecache **ncpp,
 755     struct neglist **neglistpp)
 756 {
 757         struct neglist *neglist;
 758         struct namecache *ncp;
 759         int i;
 760
 761         *ncpp = ncp = NULL;
 762
 763         for (i = start; i < numneglists; i++) {
 764                 neglist = &neglists[i];
 765                 if (TAILQ_FIRST(&neglist->nl_list) == NULL)
 766                         continue;
 767                 mtx_lock(&neglist->nl_lock);
 768                 ncp = TAILQ_FIRST(&neglist->nl_list);
 769                 if (ncp != NULL)
 770                         break;
 771                 mtx_unlock(&neglist->nl_lock);
 772         }
 773
 774         *neglistpp = neglist;
 775         *ncpp = ncp;
 776 }
 777
 778 static void
 779 cache_negative_zap_one(void)
 780 {
 781         struct namecache *ncp, *ncp2;
 782         struct neglist *neglist;
 783         struct mtx *dvlp;
 784         struct rwlock *blp;
 785
 786         if (!mtx_trylock(&ncneg_shrink_lock))
 787                 return;
 788
 789         mtx_lock(&ncneg_hot.nl_lock);
 790         ncp = TAILQ_FIRST(&ncneg_hot.nl_list);
 791         if (ncp != NULL) {
 792                 neglist = NCP2NEGLIST(ncp);
 793                 mtx_lock(&neglist->nl_lock);
 794                 TAILQ_REMOVE(&ncneg_hot.nl_list, ncp, nc_dst);
 795                 TAILQ_INSERT_TAIL(&neglist->nl_list, ncp, nc_dst);
 796                 ncp->nc_flag &= ~NCF_HOTNEGATIVE;
 797                 mtx_unlock(&neglist->nl_lock);
 798         }
 799
 800         cache_negative_shrink_select(shrink_list_turn, &ncp, &neglist);
 801         shrink_list_turn++;
 802         if (shrink_list_turn == numneglists)
 803                 shrink_list_turn = 0;
 804         if (ncp == NULL && shrink_list_turn == 0)
 805                 cache_negative_shrink_select(shrink_list_turn, &ncp, &neglist);
 806         if (ncp == NULL) {
 807                 mtx_unlock(&ncneg_hot.nl_lock);
 808                 goto out;
 809         }
 810
 811         MPASS(ncp->nc_flag & NCF_NEGATIVE);
 812         dvlp = VP2VNODELOCK(ncp->nc_dvp);
 813         blp = NCP2BUCKETLOCK(ncp);
 814         mtx_unlock(&neglist->nl_lock);
 815         mtx_unlock(&ncneg_hot.nl_lock);
 816         mtx_lock(dvlp);
 817         rw_wlock(blp);
 818         mtx_lock(&neglist->nl_lock);
 819         ncp2 = TAILQ_FIRST(&neglist->nl_list);
 820         if (ncp != ncp2 || dvlp != VP2VNODELOCK(ncp2->nc_dvp) ||
 821             blp != NCP2BUCKETLOCK(ncp2) || !(ncp2->nc_flag & NCF_NEGATIVE)) {
 822                 ncp = NULL;
 823                 goto out_unlock_all;
 824         }
 825         SDT_PROBE3(vfs, namecache, shrink_negative, done, ncp->nc_dvp,
 826             nc_get_name(ncp), ncp->nc_neghits);
 827
 828         cache_zap_locked(ncp, true);
 829 out_unlock_all:
 830         mtx_unlock(&neglist->nl_lock);
 831         rw_wunlock(blp);
 832         mtx_unlock(dvlp);
 833 out:
 834         mtx_unlock(&ncneg_shrink_lock);
 835         cache_free(ncp);
 836 }
 837
 838 /*
 839  * cache_zap_locked():
 840  *
 841  *   Removes a namecache entry from cache, whether it contains an actual
 842  *   pointer to a vnode or if it is just a negative cache entry.
 843  */
 844 static void
 845 cache_zap_locked(struct namecache *ncp, bool neg_locked)
 846 {
 847
 848         if (!(ncp->nc_flag & NCF_NEGATIVE))
 849                 cache_assert_vnode_locked(ncp->nc_vp);
 850         cache_assert_vnode_locked(ncp->nc_dvp);
 851         cache_assert_bucket_locked(ncp, RA_WLOCKED);
 852
 853         CTR2(KTR_VFS, "cache_zap(%p) vp %p", ncp,
 854             (ncp->nc_flag & NCF_NEGATIVE) ? NULL : ncp->nc_vp);
 855         if (!(ncp->nc_flag & NCF_NEGATIVE)) {
 856                 SDT_PROBE3(vfs, namecache, zap, done, ncp->nc_dvp,
 857                     nc_get_name(ncp), ncp->nc_vp);
 858         } else {
 859                 SDT_PROBE3(vfs, namecache, zap_negative, done, ncp->nc_dvp,
 860                     nc_get_name(ncp), ncp->nc_neghits);
 861         }
 862         LIST_REMOVE(ncp, nc_hash);
 863         if (!(ncp->nc_flag & NCF_NEGATIVE)) {
 864                 TAILQ_REMOVE(&ncp->nc_vp->v_cache_dst, ncp, nc_dst);
 865                 if (ncp == ncp->nc_vp->v_cache_dd)
 866                         ncp->nc_vp->v_cache_dd = NULL;
 867         } else {
 868                 cache_negative_remove(ncp, neg_locked);
 869         }
 870         if (ncp->nc_flag & NCF_ISDOTDOT) {
 871                 if (ncp == ncp->nc_dvp->v_cache_dd)
 872                         ncp->nc_dvp->v_cache_dd = NULL;
 873         } else {
 874                 LIST_REMOVE(ncp, nc_src);
 875                 if (LIST_EMPTY(&ncp->nc_dvp->v_cache_src)) {
 876                         ncp->nc_flag |= NCF_DVDROP;
 877                         atomic_subtract_rel_long(&numcachehv, 1);
 878                 }
 879         }
 880         atomic_subtract_rel_long(&numcache, 1);
 881 }
 882
 883 static void
 884 cache_zap_negative_locked_vnode_kl(struct namecache *ncp, struct vnode *vp)
 885 {
 886         struct rwlock *blp;
 887
 888         MPASS(ncp->nc_dvp == vp);
 889         MPASS(ncp->nc_flag & NCF_NEGATIVE);
 890         cache_assert_vnode_locked(vp);
 891
 892         blp = NCP2BUCKETLOCK(ncp);
 893         rw_wlock(blp);
 894         cache_zap_locked(ncp, false);
 895         rw_wunlock(blp);
 896 }
 897
 898 static bool
 899 cache_zap_locked_vnode_kl2(struct namecache *ncp, struct vnode *vp,
 900     struct mtx **vlpp)
 901 {
 902         struct mtx *pvlp, *vlp1, *vlp2, *to_unlock;
 903         struct rwlock *blp;
 904
 905         MPASS(vp == ncp->nc_dvp || vp == ncp->nc_vp);
 906         cache_assert_vnode_locked(vp);
 907
 908         if (ncp->nc_flag & NCF_NEGATIVE) {
 909                 if (*vlpp != NULL) {
 910                         mtx_unlock(*vlpp);
 911                         *vlpp = NULL;
 912                 }
 913                 cache_zap_negative_locked_vnode_kl(ncp, vp);
 914                 return (true);
 915         }
 916
 917         pvlp = VP2VNODELOCK(vp);
 918         blp = NCP2BUCKETLOCK(ncp);
 919         vlp1 = VP2VNODELOCK(ncp->nc_dvp);
 920         vlp2 = VP2VNODELOCK(ncp->nc_vp);
 921
 922         if (*vlpp == vlp1 || *vlpp == vlp2) {
 923                 to_unlock = *vlpp;
 924                 *vlpp = NULL;
 925         } else {
 926                 if (*vlpp != NULL) {
 927                         mtx_unlock(*vlpp);
 928                         *vlpp = NULL;
 929                 }
 930                 cache_sort(&vlp1, &vlp2);
 931                 if (vlp1 == pvlp) {
 932                         mtx_lock(vlp2);
 933                         to_unlock = vlp2;
 934                 } else {
 935                         if (!mtx_trylock(vlp1))
 936                                 goto out_relock;
 937                         to_unlock = vlp1;
 938                 }
 939         }
 940         rw_wlock(blp);
 941         cache_zap_locked(ncp, false);
 942         rw_wunlock(blp);
 943         if (to_unlock != NULL)
 944                 mtx_unlock(to_unlock);
 945         return (true);
 946
 947 out_relock:
 948         mtx_unlock(vlp2);
 949         mtx_lock(vlp1);
 950         mtx_lock(vlp2);
 951         MPASS(*vlpp == NULL);
 952         *vlpp = vlp1;
 953         return (false);
 954 }
 955
 956 static int
 957 cache_zap_locked_vnode(struct namecache *ncp, struct vnode *vp)
 958 {
 959         struct mtx *pvlp, *vlp1, *vlp2, *to_unlock;
 960         struct rwlock *blp;
 961         int error = 0;
 962
 963         MPASS(vp == ncp->nc_dvp || vp == ncp->nc_vp);
 964         cache_assert_vnode_locked(vp);
 965
 966         pvlp = VP2VNODELOCK(vp);
 967         if (ncp->nc_flag & NCF_NEGATIVE) {
 968                 cache_zap_negative_locked_vnode_kl(ncp, vp);
 969                 goto out;
 970         }
 971
 972         blp = NCP2BUCKETLOCK(ncp);
 973         vlp1 = VP2VNODELOCK(ncp->nc_dvp);
 974         vlp2 = VP2VNODELOCK(ncp->nc_vp);
 975         cache_sort(&vlp1, &vlp2);
 976         if (vlp1 == pvlp) {
 977                 mtx_lock(vlp2);
 978                 to_unlock = vlp2;
 979         } else {
 980                 if (!mtx_trylock(vlp1)) {
 981                         error = EAGAIN;
 982                         goto out;
 983                 }
 984                 to_unlock = vlp1;
 985         }
 986         rw_wlock(blp);
 987         cache_zap_locked(ncp, false);
 988         rw_wunlock(blp);
 989         mtx_unlock(to_unlock);
 990 out:
 991         mtx_unlock(pvlp);
 992         return (error);
 993 }
 994
 995 static int
 996 cache_zap_rlocked_bucket(struct namecache *ncp, struct rwlock *blp)
 997 {
 998         struct mtx *dvlp, *vlp;
 999
1000         cache_assert_bucket_locked(ncp, RA_RLOCKED);
1001
1002         dvlp = VP2VNODELOCK(ncp->nc_dvp);
1003         vlp = NULL;
1004         if (!(ncp->nc_flag & NCF_NEGATIVE))
1005                 vlp = VP2VNODELOCK(ncp->nc_vp);
1006         if (cache_trylock_vnodes(dvlp, vlp) == 0) {
1007                 rw_runlock(blp);
1008                 rw_wlock(blp);
1009                 cache_zap_locked(ncp, false);
1010                 rw_wunlock(blp);
1011                 cache_unlock_vnodes(dvlp, vlp);
1012                 return (0);
1013         }
1014
1015         rw_runlock(blp);
1016         return (EAGAIN);
1017 }
1018
1019 static int
1020 cache_zap_wlocked_bucket_kl(struct namecache *ncp, struct rwlock *blp,
1021     struct mtx **vlpp1, struct mtx **vlpp2)
1022 {
1023         struct mtx *dvlp, *vlp;
1024
1025         cache_assert_bucket_locked(ncp, RA_WLOCKED);
1026
1027         dvlp = VP2VNODELOCK(ncp->nc_dvp);
1028         vlp = NULL;
1029         if (!(ncp->nc_flag & NCF_NEGATIVE))
1030                 vlp = VP2VNODELOCK(ncp->nc_vp);
1031         cache_sort(&dvlp, &vlp);
1032
1033         if (*vlpp1 == dvlp && *vlpp2 == vlp) {
1034                 cache_zap_locked(ncp, false);
1035                 cache_unlock_vnodes(dvlp, vlp);
1036                 *vlpp1 = NULL;
1037                 *vlpp2 = NULL;
1038                 return (0);
1039         }
1040
1041         if (*vlpp1 != NULL)
1042                 mtx_unlock(*vlpp1);
1043         if (*vlpp2 != NULL)
1044                 mtx_unlock(*vlpp2);
1045         *vlpp1 = NULL;
1046         *vlpp2 = NULL;
1047
1048         if (cache_trylock_vnodes(dvlp, vlp) == 0) {
1049                 cache_zap_locked(ncp, false);
1050                 cache_unlock_vnodes(dvlp, vlp);
1051                 return (0);
1052         }
1053
1054         rw_wunlock(blp);
1055         *vlpp1 = dvlp;
1056         *vlpp2 = vlp;
1057         if (*vlpp1 != NULL)
1058                 mtx_lock(*vlpp1);
1059         mtx_lock(*vlpp2);
1060         rw_wlock(blp);
1061         return (EAGAIN);
1062 }
1063
1064 static void
1065 cache_lookup_unlock(struct rwlock *blp, struct mtx *vlp)
1066 {
1067
1068         if (blp != NULL) {
1069                 rw_runlock(blp);
1070                 mtx_assert(vlp, MA_NOTOWNED);
1071         } else {
1072                 mtx_unlock(vlp);
1073         }
1074 }
1075
1076 static int __noinline
1077 cache_lookup_dot(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
1078     struct timespec *tsp, int *ticksp)
1079 {
1080         int ltype;
1081
1082         *vpp = dvp;
1083         CTR2(KTR_VFS, "cache_lookup(%p, %s) found via .",
1084                         dvp, cnp->cn_nameptr);
1085         counter_u64_add(dothits, 1);
1086         SDT_PROBE3(vfs, namecache, lookup, hit, dvp, ".", *vpp);
1087         if (tsp != NULL)
1088                 timespecclear(tsp);
1089         if (ticksp != NULL)
1090                 *ticksp = ticks;
1091         vrefact(*vpp);
1092         /*
1093          * When we lookup "." we still can be asked to lock it
1094          * differently...
1095          */
1096         ltype = cnp->cn_lkflags & LK_TYPE_MASK;
1097         if (ltype != VOP_ISLOCKED(*vpp)) {
1098                 if (ltype == LK_EXCLUSIVE) {
1099                         vn_lock(*vpp, LK_UPGRADE | LK_RETRY);
1100                         if ((*vpp)->v_iflag & VI_DOOMED) {
1101                                 /* forced unmount */
1102                                 vrele(*vpp);
1103                                 *vpp = NULL;
1104                                 return (ENOENT);
1105                         }
1106                 } else
1107                         vn_lock(*vpp, LK_DOWNGRADE | LK_RETRY);
1108         }
1109         return (-1);
1110 }
1111
1112 /*
1113  * Lookup an entry in the cache
1114  *
1115  * Lookup is called with dvp pointing to the directory to search,
1116  * cnp pointing to the name of the entry being sought. If the lookup
1117  * succeeds, the vnode is returned in *vpp, and a status of -1 is
1118  * returned. If the lookup determines that the name does not exist
1119  * (negative caching), a status of ENOENT is returned. If the lookup
1120  * fails, a status of zero is returned.  If the directory vnode is
1121  * recycled out from under us due to a forced unmount, a status of
1122  * ENOENT is returned.
1123  *
1124  * vpp is locked and ref'd on return.  If we're looking up DOTDOT, dvp is
1125  * unlocked.  If we're looking up . an extra ref is taken, but the lock is
1126  * not recursively acquired.
1127  */
1128
1129 int
1130 cache_lookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp,
1131     struct timespec *tsp, int *ticksp)
1132 {
1133         struct namecache *ncp;
1134         struct rwlock *blp;
1135         struct mtx *dvlp, *dvlp2;
1136         uint32_t hash;
1137         int error, ltype;
1138
1139         if (__predict_false(!doingcache)) {
1140                 cnp->cn_flags &= ~MAKEENTRY;
1141                 return (0);
1142         }
1143 retry:
1144         blp = NULL;
1145         dvlp = VP2VNODELOCK(dvp);
1146         error = 0;
1147         counter_u64_add(numcalls, 1);
1148
1149         if (cnp->cn_nameptr[0] == '.') {
1150                 if (cnp->cn_namelen == 1)
1151                         return (cache_lookup_dot(dvp, vpp, cnp, tsp, ticksp));
1152                 if (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.') {
1153                         counter_u64_add(dotdothits, 1);
1154                         dvlp2 = NULL;
1155                         mtx_lock(dvlp);
1156 retry_dotdot:
1157                         ncp = dvp->v_cache_dd;
1158                         if (ncp == NULL) {
1159                                 SDT_PROBE3(vfs, namecache, lookup, miss, dvp,
1160                                     "..", NULL);
1161                                 mtx_unlock(dvlp);
1162                                 return (0);
1163                         }
1164                         if ((cnp->cn_flags & MAKEENTRY) == 0) {
1165                                 if ((ncp->nc_flag & NCF_ISDOTDOT) != 0) {
1166                                         if (ncp->nc_dvp != dvp)
1167                                                 panic("dvp %p v_cache_dd %p\n", dvp, ncp);
1168                                         if (!cache_zap_locked_vnode_kl2(ncp,
1169                                             dvp, &dvlp2))
1170                                                 goto retry_dotdot;
1171                                         MPASS(dvp->v_cache_dd == NULL);
1172                                         mtx_unlock(dvlp);
1173                                         if (dvlp2 != NULL)
1174                                                 mtx_unlock(dvlp2);
1175                                         cache_free(ncp);
1176                                 } else {
1177                                         dvp->v_cache_dd = NULL;
1178                                         mtx_unlock(dvlp);
1179                                         if (dvlp2 != NULL)
1180                                                 mtx_unlock(dvlp2);
1181                                 }
1182                                 return (0);
1183                         }
1184                         if ((ncp->nc_flag & NCF_ISDOTDOT) != 0) {
1185                                 if (ncp->nc_flag & NCF_NEGATIVE)
1186                                         *vpp = NULL;
1187                                 else
1188                                         *vpp = ncp->nc_vp;
1189                         } else
1190                                 *vpp = ncp->nc_dvp;
1191                         /* Return failure if negative entry was found. */
1192                         if (*vpp == NULL)
1193                                 goto negative_success;
1194                         CTR3(KTR_VFS, "cache_lookup(%p, %s) found %p via ..",
1195                             dvp, cnp->cn_nameptr, *vpp);
1196                         SDT_PROBE3(vfs, namecache, lookup, hit, dvp, "..",
1197                             *vpp);
1198                         cache_out_ts(ncp, tsp, ticksp);
1199                         if ((ncp->nc_flag & (NCF_ISDOTDOT | NCF_DTS)) ==
1200                             NCF_DTS && tsp != NULL)
1201                                 *tsp = ((struct namecache_ts *)ncp)->
1202                                     nc_dotdottime;
1203                         goto success;
1204                 }
1205         }
1206
1207         hash = cache_get_hash(cnp->cn_nameptr, cnp->cn_namelen, dvp);
1208         blp = HASH2BUCKETLOCK(hash);
1209         rw_rlock(blp);
1210
1211         LIST_FOREACH(ncp, (NCHHASH(hash)), nc_hash) {
1212                 counter_u64_add(numchecks, 1);
1213                 if (ncp->nc_dvp == dvp && ncp->nc_nlen == cnp->cn_namelen &&
1214                     !bcmp(nc_get_name(ncp), cnp->cn_nameptr, ncp->nc_nlen))
1215                         break;
1216         }
1217
1218         /* We failed to find an entry */
1219         if (ncp == NULL) {
1220                 SDT_PROBE3(vfs, namecache, lookup, miss, dvp, cnp->cn_nameptr,
1221                     NULL);
1222                 if ((cnp->cn_flags & MAKEENTRY) == 0) {
1223                         counter_u64_add(nummisszap, 1);
1224                 } else {
1225                         counter_u64_add(nummiss, 1);
1226                 }
1227                 goto unlock;
1228         }
1229
1230         /* We don't want to have an entry, so dump it */
1231         if ((cnp->cn_flags & MAKEENTRY) == 0) {
1232                 counter_u64_add(numposzaps, 1);
1233                 goto zap_and_exit;
1234         }
1235
1236         /* We found a "positive" match, return the vnode */
1237         if (!(ncp->nc_flag & NCF_NEGATIVE)) {
1238                 counter_u64_add(numposhits, 1);
1239                 *vpp = ncp->nc_vp;
1240                 CTR4(KTR_VFS, "cache_lookup(%p, %s) found %p via ncp %p",
1241                     dvp, cnp->cn_nameptr, *vpp, ncp);
1242                 SDT_PROBE3(vfs, namecache, lookup, hit, dvp, nc_get_name(ncp),
1243                     *vpp);
1244                 cache_out_ts(ncp, tsp, ticksp);
1245                 goto success;
1246         }
1247
1248 negative_success:
1249         /* We found a negative match, and want to create it, so purge */
1250         if (cnp->cn_nameiop == CREATE) {
1251                 counter_u64_add(numnegzaps, 1);
1252                 goto zap_and_exit;
1253         }
1254
1255         counter_u64_add(numneghits, 1);
1256         cache_negative_hit(ncp);
1257         if (ncp->nc_flag & NCF_WHITE)
1258                 cnp->cn_flags |= ISWHITEOUT;
1259         SDT_PROBE2(vfs, namecache, lookup, hit__negative, dvp,
1260             nc_get_name(ncp));
1261         cache_out_ts(ncp, tsp, ticksp);
1262         cache_lookup_unlock(blp, dvlp);
1263         return (ENOENT);
1264
1265 success:
1266         /*
1267          * On success we return a locked and ref'd vnode as per the lookup
1268          * protocol.
1269          */
1270         MPASS(dvp != *vpp);
1271         ltype = 0;      /* silence gcc warning */
1272         if (cnp->cn_flags & ISDOTDOT) {
1273                 ltype = VOP_ISLOCKED(dvp);
1274                 VOP_UNLOCK(dvp, 0);
1275         }
1276         vhold(*vpp);
1277         cache_lookup_unlock(blp, dvlp);
1278         error = vget(*vpp, cnp->cn_lkflags | LK_VNHELD, cnp->cn_thread);
1279         if (cnp->cn_flags & ISDOTDOT) {
1280                 vn_lock(dvp, ltype | LK_RETRY);
1281                 if (dvp->v_iflag & VI_DOOMED) {
1282                         if (error == 0)
1283                                 vput(*vpp);
1284                         *vpp = NULL;
1285                         return (ENOENT);
1286                 }
1287         }
1288         if (error) {
1289                 *vpp = NULL;
1290                 goto retry;
1291         }
1292         if ((cnp->cn_flags & ISLASTCN) &&
1293             (cnp->cn_lkflags & LK_TYPE_MASK) == LK_EXCLUSIVE) {
1294                 ASSERT_VOP_ELOCKED(*vpp, "cache_lookup");
1295         }
1296         return (-1);
1297
1298 unlock:
1299         cache_lookup_unlock(blp, dvlp);
1300         return (0);
1301
1302 zap_and_exit:
1303         if (blp != NULL)
1304                 error = cache_zap_rlocked_bucket(ncp, blp);
1305         else
1306                 error = cache_zap_locked_vnode(ncp, dvp);
1307         if (error != 0) {
1308                 zap_and_exit_bucket_fail++;
1309                 cache_maybe_yield();
1310                 goto retry;
1311         }
1312         cache_free(ncp);
1313         return (0);
1314 }
1315
1316 struct celockstate {
1317         struct mtx *vlp[3];
1318         struct rwlock *blp[2];
1319 };
1320 CTASSERT((nitems(((struct celockstate *)0)->vlp) == 3));
1321 CTASSERT((nitems(((struct celockstate *)0)->blp) == 2));
1322
1323 static inline void
1324 cache_celockstate_init(struct celockstate *cel)
1325 {
1326
1327         bzero(cel, sizeof(*cel));
1328 }
1329
1330 static void
1331 cache_lock_vnodes_cel(struct celockstate *cel, struct vnode *vp,
1332     struct vnode *dvp)
1333 {
1334         struct mtx *vlp1, *vlp2;
1335
1336         MPASS(cel->vlp[0] == NULL);
1337         MPASS(cel->vlp[1] == NULL);
1338         MPASS(cel->vlp[2] == NULL);
1339
1340         MPASS(vp != NULL || dvp != NULL);
1341
1342         vlp1 = VP2VNODELOCK(vp);
1343         vlp2 = VP2VNODELOCK(dvp);
1344         cache_sort(&vlp1, &vlp2);
1345
1346         if (vlp1 != NULL) {
1347                 mtx_lock(vlp1);
1348                 cel->vlp[0] = vlp1;
1349         }
1350         mtx_lock(vlp2);
1351         cel->vlp[1] = vlp2;
1352 }
1353
1354 static void
1355 cache_unlock_vnodes_cel(struct celockstate *cel)
1356 {
1357
1358         MPASS(cel->vlp[0] != NULL || cel->vlp[1] != NULL);
1359
1360         if (cel->vlp[0] != NULL)
1361                 mtx_unlock(cel->vlp[0]);
1362         if (cel->vlp[1] != NULL)
1363                 mtx_unlock(cel->vlp[1]);
1364         if (cel->vlp[2] != NULL)
1365                 mtx_unlock(cel->vlp[2]);
1366 }
1367
1368 static bool
1369 cache_lock_vnodes_cel_3(struct celockstate *cel, struct vnode *vp)
1370 {
1371         struct mtx *vlp;
1372         bool ret;
1373
1374         cache_assert_vlp_locked(cel->vlp[0]);
1375         cache_assert_vlp_locked(cel->vlp[1]);
1376         MPASS(cel->vlp[2] == NULL);
1377
1378         MPASS(vp != NULL);
1379         vlp = VP2VNODELOCK(vp);
1380
1381         ret = true;
1382         if (vlp >= cel->vlp[1]) {
1383                 mtx_lock(vlp);
1384         } else {
1385                 if (mtx_trylock(vlp))
1386                         goto out;
1387                 cache_lock_vnodes_cel_3_failures++;
1388                 cache_unlock_vnodes_cel(cel);
1389                 if (vlp < cel->vlp[0]) {
1390                         mtx_lock(vlp);
1391                         mtx_lock(cel->vlp[0]);
1392                         mtx_lock(cel->vlp[1]);
1393                 } else {
1394                         if (cel->vlp[0] != NULL)
1395                                 mtx_lock(cel->vlp[0]);
1396                         mtx_lock(vlp);
1397                         mtx_lock(cel->vlp[1]);
1398                 }
1399                 ret = false;
1400         }
1401 out:
1402         cel->vlp[2] = vlp;
1403         return (ret);
1404 }
1405
1406 static void
1407 cache_lock_buckets_cel(struct celockstate *cel, struct rwlock *blp1,
1408     struct rwlock *blp2)
1409 {
1410
1411         MPASS(cel->blp[0] == NULL);
1412         MPASS(cel->blp[1] == NULL);
1413
1414         cache_sort(&blp1, &blp2);
1415
1416         if (blp1 != NULL) {
1417                 rw_wlock(blp1);
1418                 cel->blp[0] = blp1;
1419         }
1420         rw_wlock(blp2);
1421         cel->blp[1] = blp2;
1422 }
1423
1424 static void
1425 cache_unlock_buckets_cel(struct celockstate *cel)
1426 {
1427
1428         if (cel->blp[0] != NULL)
1429                 rw_wunlock(cel->blp[0]);
1430         rw_wunlock(cel->blp[1]);
1431 }
1432
1433 /*
1434  * Lock part of the cache affected by the insertion.
1435  *
1436  * This means vnodelocks for dvp, vp and the relevant bucketlock.
1437  * However, insertion can result in removal of an old entry. In this
1438  * case we have an additional vnode and bucketlock pair to lock. If the
1439  * entry is negative, ncelock is locked instead of the vnode.
1440  *
1441  * That is, in the worst case we have to lock 3 vnodes and 2 bucketlocks, while
1442  * preserving the locking order (smaller address first).
1443  */
1444 static void
1445 cache_enter_lock(struct celockstate *cel, struct vnode *dvp, struct vnode *vp,
1446     uint32_t hash)
1447 {
1448         struct namecache *ncp;
1449         struct rwlock *blps[2];
1450
1451         blps[0] = HASH2BUCKETLOCK(hash);
1452         for (;;) {
1453                 blps[1] = NULL;
1454                 cache_lock_vnodes_cel(cel, dvp, vp);
1455                 if (vp == NULL || vp->v_type != VDIR)
1456                         break;
1457                 ncp = vp->v_cache_dd;
1458                 if (ncp == NULL)
1459                         break;
1460                 if ((ncp->nc_flag & NCF_ISDOTDOT) == 0)
1461                         break;
1462                 MPASS(ncp->nc_dvp == vp);
1463                 blps[1] = NCP2BUCKETLOCK(ncp);
1464                 if (ncp->nc_flag & NCF_NEGATIVE)
1465                         break;
1466                 if (cache_lock_vnodes_cel_3(cel, ncp->nc_vp))
1467                         break;
1468                 /*
1469                  * All vnodes got re-locked. Re-validate the state and if
1470                  * nothing changed we are done. Otherwise restart.
1471                  */
1472                 if (ncp == vp->v_cache_dd &&
1473                     (ncp->nc_flag & NCF_ISDOTDOT) != 0 &&
1474                     blps[1] == NCP2BUCKETLOCK(ncp) &&
1475                     VP2VNODELOCK(ncp->nc_vp) == cel->vlp[2])
1476                         break;
1477                 cache_unlock_vnodes_cel(cel);
1478                 cel->vlp[0] = NULL;
1479                 cel->vlp[1] = NULL;
1480                 cel->vlp[2] = NULL;
1481         }
1482         cache_lock_buckets_cel(cel, blps[0], blps[1]);
1483 }
1484
1485 static void
1486 cache_enter_lock_dd(struct celockstate *cel, struct vnode *dvp, struct vnode *vp,
1487     uint32_t hash)
1488 {
1489         struct namecache *ncp;
1490         struct rwlock *blps[2];
1491
1492         blps[0] = HASH2BUCKETLOCK(hash);
1493         for (;;) {
1494                 blps[1] = NULL;
1495                 cache_lock_vnodes_cel(cel, dvp, vp);
1496                 ncp = dvp->v_cache_dd;
1497                 if (ncp == NULL)
1498                         break;
1499                 if ((ncp->nc_flag & NCF_ISDOTDOT) == 0)
1500                         break;
1501                 MPASS(ncp->nc_dvp == dvp);
1502                 blps[1] = NCP2BUCKETLOCK(ncp);
1503                 if (ncp->nc_flag & NCF_NEGATIVE)
1504                         break;
1505                 if (cache_lock_vnodes_cel_3(cel, ncp->nc_vp))
1506                         break;
1507                 if (ncp == dvp->v_cache_dd &&
1508                     (ncp->nc_flag & NCF_ISDOTDOT) != 0 &&
1509                     blps[1] == NCP2BUCKETLOCK(ncp) &&
1510                     VP2VNODELOCK(ncp->nc_vp) == cel->vlp[2])
1511                         break;
1512                 cache_unlock_vnodes_cel(cel);
1513                 cel->vlp[0] = NULL;
1514                 cel->vlp[1] = NULL;
1515                 cel->vlp[2] = NULL;
1516         }
1517         cache_lock_buckets_cel(cel, blps[0], blps[1]);
1518 }
1519
1520 static void
1521 cache_enter_unlock(struct celockstate *cel)
1522 {
1523
1524         cache_unlock_buckets_cel(cel);
1525         cache_unlock_vnodes_cel(cel);
1526 }
1527
1528 /*
1529  * Add an entry to the cache.
1530  */
1531 void
1532 cache_enter_time(struct vnode *dvp, struct vnode *vp, struct componentname *cnp,
1533     struct timespec *tsp, struct timespec *dtsp)
1534 {
1535         struct celockstate cel;
1536         struct namecache *ncp, *n2, *ndd;
1537         struct namecache_ts *n3;
1538         struct nchashhead *ncpp;
1539         struct neglist *neglist;
1540         uint32_t hash;
1541         int flag;
1542         int len;
1543         bool neg_locked;
1544
1545         CTR3(KTR_VFS, "cache_enter(%p, %p, %s)", dvp, vp, cnp->cn_nameptr);
1546         VNASSERT(vp == NULL || (vp->v_iflag & VI_DOOMED) == 0, vp,
1547             ("cache_enter: Adding a doomed vnode"));
1548         VNASSERT(dvp == NULL || (dvp->v_iflag & VI_DOOMED) == 0, dvp,
1549             ("cache_enter: Doomed vnode used as src"));
1550
1551         if (__predict_false(!doingcache))
1552                 return;
1553
1554         /*
1555          * Avoid blowout in namecache entries.
1556          */
1557         if (__predict_false(numcache >= desiredvnodes * ncsizefactor))
1558                 return;
1559
1560         cache_celockstate_init(&cel);
1561         ndd = NULL;
1562         flag = 0;
1563         if (cnp->cn_nameptr[0] == '.') {
1564                 if (cnp->cn_namelen == 1)
1565                         return;
1566                 if (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.') {
1567                         len = cnp->cn_namelen;
1568                         hash = cache_get_hash(cnp->cn_nameptr, len, dvp);
1569                         cache_enter_lock_dd(&cel, dvp, vp, hash);
1570                         /*
1571                          * If dotdot entry already exists, just retarget it
1572                          * to new parent vnode, otherwise continue with new
1573                          * namecache entry allocation.
1574                          */
1575                         if ((ncp = dvp->v_cache_dd) != NULL &&
1576                             ncp->nc_flag & NCF_ISDOTDOT) {
1577                                 KASSERT(ncp->nc_dvp == dvp,
1578                                     ("wrong isdotdot parent"));
1579                                 neg_locked = false;
1580                                 if (ncp->nc_flag & NCF_NEGATIVE || vp == NULL) {
1581                                         neglist = NCP2NEGLIST(ncp);
1582                                         mtx_lock(&ncneg_hot.nl_lock);
1583                                         mtx_lock(&neglist->nl_lock);
1584                                         neg_locked = true;
1585                                 }
1586                                 if (!(ncp->nc_flag & NCF_NEGATIVE)) {
1587                                         TAILQ_REMOVE(&ncp->nc_vp->v_cache_dst,
1588                                             ncp, nc_dst);
1589                                 } else {
1590                                         cache_negative_remove(ncp, true);
1591                                 }
1592                                 if (vp != NULL) {
1593                                         TAILQ_INSERT_HEAD(&vp->v_cache_dst,
1594                                             ncp, nc_dst);
1595                                         ncp->nc_flag &= ~(NCF_NEGATIVE|NCF_HOTNEGATIVE);
1596                                 } else {
1597                                         ncp->nc_flag &= ~(NCF_HOTNEGATIVE);
1598                                         ncp->nc_flag |= NCF_NEGATIVE;
1599                                         cache_negative_insert(ncp, true);
1600                                 }
1601                                 if (neg_locked) {
1602                                         mtx_unlock(&neglist->nl_lock);
1603                                         mtx_unlock(&ncneg_hot.nl_lock);
1604                                 }
1605                                 ncp->nc_vp = vp;
1606                                 cache_enter_unlock(&cel);
1607                                 return;
1608                         }
1609                         dvp->v_cache_dd = NULL;
1610                         cache_enter_unlock(&cel);
1611                         cache_celockstate_init(&cel);
1612                         SDT_PROBE3(vfs, namecache, enter, done, dvp, "..", vp);
1613                         flag = NCF_ISDOTDOT;
1614                 }
1615         }
1616
1617         /*
1618          * Calculate the hash key and setup as much of the new
1619          * namecache entry as possible before acquiring the lock.
1620          */
1621         ncp = cache_alloc(cnp->cn_namelen, tsp != NULL);
1622         ncp->nc_flag = flag;
1623         ncp->nc_vp = vp;
1624         if (vp == NULL)
1625                 ncp->nc_flag |= NCF_NEGATIVE;
1626         ncp->nc_dvp = dvp;
1627         if (tsp != NULL) {
1628                 n3 = (struct namecache_ts *)ncp;
1629                 n3->nc_time = *tsp;
1630                 n3->nc_ticks = ticks;
1631                 n3->nc_flag |= NCF_TS;
1632                 if (dtsp != NULL) {
1633                         n3->nc_dotdottime = *dtsp;
1634                         n3->nc_flag |= NCF_DTS;
1635                 }
1636         }
1637         len = ncp->nc_nlen = cnp->cn_namelen;
1638         hash = cache_get_hash(cnp->cn_nameptr, len, dvp);
1639         strlcpy(nc_get_name(ncp), cnp->cn_nameptr, len + 1);
1640         cache_enter_lock(&cel, dvp, vp, hash);
1641
1642         /*
1643          * See if this vnode or negative entry is already in the cache
1644          * with this name.  This can happen with concurrent lookups of
1645          * the same path name.
1646          */
1647         ncpp = NCHHASH(hash);
1648         LIST_FOREACH(n2, ncpp, nc_hash) {
1649                 if (n2->nc_dvp == dvp &&
1650                     n2->nc_nlen == cnp->cn_namelen &&
1651                     !bcmp(nc_get_name(n2), cnp->cn_nameptr, n2->nc_nlen)) {
1652                         if (tsp != NULL) {
1653                                 KASSERT((n2->nc_flag & NCF_TS) != 0,
1654                                     ("no NCF_TS"));
1655                                 n3 = (struct namecache_ts *)n2;
1656                                 n3->nc_time =
1657                                     ((struct namecache_ts *)ncp)->nc_time;
1658                                 n3->nc_ticks =
1659                                     ((struct namecache_ts *)ncp)->nc_ticks;
1660                                 if (dtsp != NULL) {
1661                                         n3->nc_dotdottime =
1662                                             ((struct namecache_ts *)ncp)->
1663                                             nc_dotdottime;
1664                                         if (ncp->nc_flag & NCF_NEGATIVE)
1665                                                 mtx_lock(&ncneg_hot.nl_lock);
1666                                         n3->nc_flag |= NCF_DTS;
1667                                         if (ncp->nc_flag & NCF_NEGATIVE)
1668                                                 mtx_unlock(&ncneg_hot.nl_lock);
1669                                 }
1670                         }
1671                         goto out_unlock_free;
1672                 }
1673         }
1674
1675         if (flag == NCF_ISDOTDOT) {
1676                 /*
1677                  * See if we are trying to add .. entry, but some other lookup
1678                  * has populated v_cache_dd pointer already.
1679                  */
1680                 if (dvp->v_cache_dd != NULL)
1681                         goto out_unlock_free;
1682                 KASSERT(vp == NULL || vp->v_type == VDIR,
1683                     ("wrong vnode type %p", vp));
1684                 dvp->v_cache_dd = ncp;
1685         }
1686
1687         atomic_add_rel_long(&numcache, 1);
1688         if (vp != NULL) {
1689                 if (vp->v_type == VDIR) {
1690                         if (flag != NCF_ISDOTDOT) {
1691                                 /*
1692                                  * For this case, the cache entry maps both the
1693                                  * directory name in it and the name ".." for the
1694                                  * directory's parent.
1695                                  */
1696                                 if ((ndd = vp->v_cache_dd) != NULL) {
1697                                         if ((ndd->nc_flag & NCF_ISDOTDOT) != 0)
1698                                                 cache_zap_locked(ndd, false);
1699                                         else
1700                                                 ndd = NULL;
1701                                 }
1702                                 vp->v_cache_dd = ncp;
1703                         }
1704                 } else {
1705                         vp->v_cache_dd = NULL;
1706                 }
1707         }
1708
1709         if (flag != NCF_ISDOTDOT) {
1710                 if (LIST_EMPTY(&dvp->v_cache_src)) {
1711                         vhold(dvp);
1712                         atomic_add_rel_long(&numcachehv, 1);
1713                 }
1714                 LIST_INSERT_HEAD(&dvp->v_cache_src, ncp, nc_src);
1715         }
1716
1717         /*
1718          * Insert the new namecache entry into the appropriate chain
1719          * within the cache entries table.
1720          */
1721         LIST_INSERT_HEAD(ncpp, ncp, nc_hash);
1722
1723         /*
1724          * If the entry is "negative", we place it into the
1725          * "negative" cache queue, otherwise, we place it into the
1726          * destination vnode's cache entries queue.
1727          */
1728         if (vp != NULL) {
1729                 TAILQ_INSERT_HEAD(&vp->v_cache_dst, ncp, nc_dst);
1730                 SDT_PROBE3(vfs, namecache, enter, done, dvp, nc_get_name(ncp),
1731                     vp);
1732         } else {
1733                 if (cnp->cn_flags & ISWHITEOUT)
1734                         ncp->nc_flag |= NCF_WHITE;
1735                 cache_negative_insert(ncp, false);
1736                 SDT_PROBE2(vfs, namecache, enter_negative, done, dvp,
1737                     nc_get_name(ncp));
1738         }
1739         cache_enter_unlock(&cel);
1740         if (numneg * ncnegfactor > numcache)
1741                 cache_negative_zap_one();
1742         cache_free(ndd);
1743         return;
1744 out_unlock_free:
1745         cache_enter_unlock(&cel);
1746         cache_free(ncp);
1747         return;
1748 }
1749
1750 static u_int
1751 cache_roundup_2(u_int val)
1752 {
1753         u_int res;
1754
1755         for (res = 1; res <= val; res <<= 1)
1756                 continue;
1757
1758         return (res);
1759 }
1760
1761 /*
1762  * Name cache initialization, from vfs_init() when we are booting
1763  */
1764 static void
1765 nchinit(void *dummy __unused)
1766 {
1767         u_int i;
1768
1769         cache_zone_small = uma_zcreate("S VFS Cache",
1770             sizeof(struct namecache) + CACHE_PATH_CUTOFF + 1,
1771             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_ZINIT);
1772         cache_zone_small_ts = uma_zcreate("STS VFS Cache",
1773             sizeof(struct namecache_ts) + CACHE_PATH_CUTOFF + 1,
1774             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_ZINIT);
1775         cache_zone_large = uma_zcreate("L VFS Cache",
1776             sizeof(struct namecache) + NAME_MAX + 1,
1777             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_ZINIT);
1778         cache_zone_large_ts = uma_zcreate("LTS VFS Cache",
1779             sizeof(struct namecache_ts) + NAME_MAX + 1,
1780             NULL, NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_ZINIT);
1781
1782         nchashtbl = hashinit(desiredvnodes * 2, M_VFSCACHE, &nchash);
1783         ncbuckethash = cache_roundup_2(mp_ncpus * 64) - 1;
1784         if (ncbuckethash > nchash)
1785                 ncbuckethash = nchash;
1786         bucketlocks = malloc(sizeof(*bucketlocks) * numbucketlocks, M_VFSCACHE,
1787             M_WAITOK | M_ZERO);
1788         for (i = 0; i < numbucketlocks; i++)
1789                 rw_init_flags(&bucketlocks[i], "ncbuc", RW_DUPOK | RW_RECURSE);
1790         ncvnodehash = cache_roundup_2(mp_ncpus * 64) - 1;
1791         vnodelocks = malloc(sizeof(*vnodelocks) * numvnodelocks, M_VFSCACHE,
1792             M_WAITOK | M_ZERO);
1793         for (i = 0; i < numvnodelocks; i++)
1794                 mtx_init(&vnodelocks[i], "ncvn", NULL, MTX_DUPOK | MTX_RECURSE);
1795         ncpurgeminvnodes = numbucketlocks;
1796
1797         ncneghash = 3;
1798         neglists = malloc(sizeof(*neglists) * numneglists, M_VFSCACHE,
1799             M_WAITOK | M_ZERO);
1800         for (i = 0; i < numneglists; i++) {
1801                 mtx_init(&neglists[i].nl_lock, "ncnegl", NULL, MTX_DEF);
1802                 TAILQ_INIT(&neglists[i].nl_list);
1803         }
1804         mtx_init(&ncneg_hot.nl_lock, "ncneglh", NULL, MTX_DEF);
1805         TAILQ_INIT(&ncneg_hot.nl_list);
1806
1807         mtx_init(&ncneg_shrink_lock, "ncnegs", NULL, MTX_DEF);
1808
1809         numcalls = counter_u64_alloc(M_WAITOK);
1810         dothits = counter_u64_alloc(M_WAITOK);
1811         dotdothits = counter_u64_alloc(M_WAITOK);
1812         numchecks = counter_u64_alloc(M_WAITOK);
1813         nummiss = counter_u64_alloc(M_WAITOK);
1814         nummisszap = counter_u64_alloc(M_WAITOK);
1815         numposzaps = counter_u64_alloc(M_WAITOK);
1816         numposhits = counter_u64_alloc(M_WAITOK);
1817         numnegzaps = counter_u64_alloc(M_WAITOK);
1818         numneghits = counter_u64_alloc(M_WAITOK);
1819         numfullpathcalls = counter_u64_alloc(M_WAITOK);
1820         numfullpathfail1 = counter_u64_alloc(M_WAITOK);
1821         numfullpathfail2 = counter_u64_alloc(M_WAITOK);
1822         numfullpathfail4 = counter_u64_alloc(M_WAITOK);
1823         numfullpathfound = counter_u64_alloc(M_WAITOK);
1824 }
1825 SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_SECOND, nchinit, NULL);
1826
1827 void
1828 cache_changesize(int newmaxvnodes)
1829 {
1830         struct nchashhead *new_nchashtbl, *old_nchashtbl;
1831         u_long new_nchash, old_nchash;
1832         struct namecache *ncp;
1833         uint32_t hash;
1834         int i;
1835
1836         newmaxvnodes = cache_roundup_2(newmaxvnodes * 2);
1837         if (newmaxvnodes < numbucketlocks)
1838                 newmaxvnodes = numbucketlocks;
1839
1840         new_nchashtbl = hashinit(newmaxvnodes, M_VFSCACHE, &new_nchash);
1841         /* If same hash table size, nothing to do */
1842         if (nchash == new_nchash) {
1843                 free(new_nchashtbl, M_VFSCACHE);
1844                 return;
1845         }
1846         /*
1847          * Move everything from the old hash table to the new table.
1848          * None of the namecache entries in the table can be removed
1849          * because to do so, they have to be removed from the hash table.
1850          */
1851         cache_lock_all_vnodes();
1852         cache_lock_all_buckets();
1853         old_nchashtbl = nchashtbl;
1854         old_nchash = nchash;
1855         nchashtbl = new_nchashtbl;
1856         nchash = new_nchash;
1857         for (i = 0; i <= old_nchash; i++) {
1858                 while ((ncp = LIST_FIRST(&old_nchashtbl[i])) != NULL) {
1859                         hash = cache_get_hash(nc_get_name(ncp), ncp->nc_nlen,
1860                             ncp->nc_dvp);
1861                         LIST_REMOVE(ncp, nc_hash);
1862                         LIST_INSERT_HEAD(NCHHASH(hash), ncp, nc_hash);
1863                 }
1864         }
1865         cache_unlock_all_buckets();
1866         cache_unlock_all_vnodes();
1867         free(old_nchashtbl, M_VFSCACHE);
1868 }
1869
1870 /*
1871  * Invalidate all entries to a particular vnode.
1872  */
1873 void
1874 cache_purge(struct vnode *vp)
1875 {
1876         TAILQ_HEAD(, namecache) ncps;
1877         struct namecache *ncp, *nnp;
1878         struct mtx *vlp, *vlp2;
1879
1880         CTR1(KTR_VFS, "cache_purge(%p)", vp);
1881         SDT_PROBE1(vfs, namecache, purge, done, vp);
1882         if (LIST_EMPTY(&vp->v_cache_src) && TAILQ_EMPTY(&vp->v_cache_dst) &&
1883             vp->v_cache_dd == NULL)
1884                 return;
1885         TAILQ_INIT(&ncps);
1886         vlp = VP2VNODELOCK(vp);
1887         vlp2 = NULL;
1888         mtx_lock(vlp);
1889 retry:
1890         while (!LIST_EMPTY(&vp->v_cache_src)) {
1891                 ncp = LIST_FIRST(&vp->v_cache_src);
1892                 if (!cache_zap_locked_vnode_kl2(ncp, vp, &vlp2))
1893                         goto retry;
1894                 TAILQ_INSERT_TAIL(&ncps, ncp, nc_dst);
1895         }
1896         while (!TAILQ_EMPTY(&vp->v_cache_dst)) {
1897                 ncp = TAILQ_FIRST(&vp->v_cache_dst);
1898                 if (!cache_zap_locked_vnode_kl2(ncp, vp, &vlp2))
1899                         goto retry;
1900                 TAILQ_INSERT_TAIL(&ncps, ncp, nc_dst);
1901         }
1902         ncp = vp->v_cache_dd;
1903         if (ncp != NULL) {
1904                 KASSERT(ncp->nc_flag & NCF_ISDOTDOT,
1905                    ("lost dotdot link"));
1906                 if (!cache_zap_locked_vnode_kl2(ncp, vp, &vlp2))
1907                         goto retry;
1908                 TAILQ_INSERT_TAIL(&ncps, ncp, nc_dst);
1909         }
1910         KASSERT(vp->v_cache_dd == NULL, ("incomplete purge"));
1911         mtx_unlock(vlp);
1912         if (vlp2 != NULL)
1913                 mtx_unlock(vlp2);
1914         TAILQ_FOREACH_SAFE(ncp, &ncps, nc_dst, nnp) {
1915                 cache_free(ncp);
1916         }
1917 }
1918
1919 /*
1920  * Invalidate all negative entries for a particular directory vnode.
1921  */
1922 void
1923 cache_purge_negative(struct vnode *vp)
1924 {
1925         TAILQ_HEAD(, namecache) ncps;
1926         struct namecache *ncp, *nnp;
1927         struct mtx *vlp;
1928
1929         CTR1(KTR_VFS, "cache_purge_negative(%p)", vp);
1930         SDT_PROBE1(vfs, namecache, purge_negative, done, vp);
1931         TAILQ_INIT(&ncps);
1932         vlp = VP2VNODELOCK(vp);
1933         mtx_lock(vlp);
1934         LIST_FOREACH_SAFE(ncp, &vp->v_cache_src, nc_src, nnp) {
1935                 if (!(ncp->nc_flag & NCF_NEGATIVE))
1936                         continue;
1937                 cache_zap_negative_locked_vnode_kl(ncp, vp);
1938                 TAILQ_INSERT_TAIL(&ncps, ncp, nc_dst);
1939         }
1940         mtx_unlock(vlp);
1941         TAILQ_FOREACH_SAFE(ncp, &ncps, nc_dst, nnp) {
1942                 cache_free(ncp);
1943         }
1944 }
1945
1946 /*
1947  * Flush all entries referencing a particular filesystem.
1948  */
1949 void
1950 cache_purgevfs(struct mount *mp, bool force)
1951 {
1952         TAILQ_HEAD(, namecache) ncps;
1953         struct mtx *vlp1, *vlp2;
1954         struct rwlock *blp;
1955         struct nchashhead *bucket;
1956         struct namecache *ncp, *nnp;
1957         u_long i, j, n_nchash;
1958         int error;
1959
1960         /* Scan hash tables for applicable entries */
1961         SDT_PROBE1(vfs, namecache, purgevfs, done, mp);
1962         if (!force && mp->mnt_nvnodelistsize <= ncpurgeminvnodes)
1963                 return;
1964         TAILQ_INIT(&ncps);
1965         n_nchash = nchash + 1;
1966         vlp1 = vlp2 = NULL;
1967         for (i = 0; i < numbucketlocks; i++) {
1968                 blp = (struct rwlock *)&bucketlocks[i];
1969                 rw_wlock(blp);
1970                 for (j = i; j < n_nchash; j += numbucketlocks) {
1971 retry:
1972                         bucket = &nchashtbl[j];
1973                         LIST_FOREACH_SAFE(ncp, bucket, nc_hash, nnp) {
1974                                 cache_assert_bucket_locked(ncp, RA_WLOCKED);
1975                                 if (ncp->nc_dvp->v_mount != mp)
1976                                         continue;
1977                                 error = cache_zap_wlocked_bucket_kl(ncp, blp,
1978                                     &vlp1, &vlp2);
1979                                 if (error != 0)
1980                                         goto retry;
1981                                 TAILQ_INSERT_HEAD(&ncps, ncp, nc_dst);
1982                         }
1983                 }
1984                 rw_wunlock(blp);
1985                 if (vlp1 == NULL && vlp2 == NULL)
1986                         cache_maybe_yield();
1987         }
1988         if (vlp1 != NULL)
1989                 mtx_unlock(vlp1);
1990         if (vlp2 != NULL)
1991                 mtx_unlock(vlp2);
1992
1993         TAILQ_FOREACH_SAFE(ncp, &ncps, nc_dst, nnp) {
1994                 cache_free(ncp);
1995         }
1996 }
1997
1998 /*
1999  * Perform canonical checks and cache lookup and pass on to filesystem
2000  * through the vop_cachedlookup only if needed.
2001  */
2002
2003 int
2004 vfs_cache_lookup(struct vop_lookup_args *ap)
2005 {
2006         struct vnode *dvp;
2007         int error;
2008         struct vnode **vpp = ap->a_vpp;
2009         struct componentname *cnp = ap->a_cnp;
2010         struct ucred *cred = cnp->cn_cred;
2011         int flags = cnp->cn_flags;
2012         struct thread *td = cnp->cn_thread;
2013
2014         *vpp = NULL;
2015         dvp = ap->a_dvp;
2016
2017         if (dvp->v_type != VDIR)
2018                 return (ENOTDIR);
2019
2020         if ((flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
2021             (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
2022                 return (EROFS);
2023
2024         error = VOP_ACCESS(dvp, VEXEC, cred, td);
2025         if (error)
2026                 return (error);
2027
2028         error = cache_lookup(dvp, vpp, cnp, NULL, NULL);
2029         if (error == 0)
2030                 return (VOP_CACHEDLOOKUP(dvp, vpp, cnp));
2031         if (error == -1)
2032                 return (0);
2033         return (error);
2034 }
2035
2036 /*
2037  * XXX All of these sysctls would probably be more productive dead.
2038  */
2039 static int __read_mostly disablecwd;
2040 SYSCTL_INT(_debug, OID_AUTO, disablecwd, CTLFLAG_RW, &disablecwd, 0,
2041    "Disable the getcwd syscall");
2042
2043 /* Implementation of the getcwd syscall. */
2044 int
2045 sys___getcwd(struct thread *td, struct __getcwd_args *uap)
2046 {
2047
2048         return (kern___getcwd(td, uap->buf, UIO_USERSPACE, uap->buflen,
2049             MAXPATHLEN));
2050 }
2051
2052 int
2053 kern___getcwd(struct thread *td, char *buf, enum uio_seg bufseg, size_t buflen,
2054     size_t path_max)
2055 {
2056         char *bp, *tmpbuf;
2057         struct filedesc *fdp;
2058         struct vnode *cdir, *rdir;
2059         int error;
2060
2061         if (__predict_false(disablecwd))
2062                 return (ENODEV);
2063         if (__predict_false(buflen < 2))
2064                 return (EINVAL);
2065         if (buflen > path_max)
2066                 buflen = path_max;
2067
2068         tmpbuf = malloc(buflen, M_TEMP, M_WAITOK);
2069         fdp = td->td_proc->p_fd;
2070         FILEDESC_SLOCK(fdp);
2071         cdir = fdp->fd_cdir;
2072         vrefact(cdir);
2073         rdir = fdp->fd_rdir;
2074         vrefact(rdir);
2075         FILEDESC_SUNLOCK(fdp);
2076         error = vn_fullpath1(td, cdir, rdir, tmpbuf, &bp, buflen);
2077         vrele(rdir);
2078         vrele(cdir);
2079
2080         if (!error) {
2081                 if (bufseg == UIO_SYSSPACE)
2082                         bcopy(bp, buf, strlen(bp) + 1);
2083                 else
2084                         error = copyout(bp, buf, strlen(bp) + 1);
2085 #ifdef KTRACE
2086         if (KTRPOINT(curthread, KTR_NAMEI))
2087                 ktrnamei(bp);
2088 #endif
2089         }
2090         free(tmpbuf, M_TEMP);
2091         return (error);
2092 }
2093
2094 /*
2095  * Thus begins the fullpath magic.
2096  */
2097
2098 static int __read_mostly disablefullpath;
2099 SYSCTL_INT(_debug, OID_AUTO, disablefullpath, CTLFLAG_RW, &disablefullpath, 0,
2100     "Disable the vn_fullpath function");
2101
2102 /*
2103  * Retrieve the full filesystem path that correspond to a vnode from the name
2104  * cache (if available)
2105  */
2106 int
2107 vn_fullpath(struct thread *td, struct vnode *vn, char **retbuf, char **freebuf)
2108 {
2109         char *buf;
2110         struct filedesc *fdp;
2111         struct vnode *rdir;
2112         int error;
2113
2114         if (__predict_false(disablefullpath))
2115                 return (ENODEV);
2116         if (__predict_false(vn == NULL))
2117                 return (EINVAL);
2118
2119         buf = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
2120         fdp = td->td_proc->p_fd;
2121         FILEDESC_SLOCK(fdp);
2122         rdir = fdp->fd_rdir;
2123         vrefact(rdir);
2124         FILEDESC_SUNLOCK(fdp);
2125         error = vn_fullpath1(td, vn, rdir, buf, retbuf, MAXPATHLEN);
2126         vrele(rdir);
2127
2128         if (!error)
2129                 *freebuf = buf;
2130         else
2131                 free(buf, M_TEMP);
2132         return (error);
2133 }
2134
2135 /*
2136  * This function is similar to vn_fullpath, but it attempts to lookup the
2137  * pathname relative to the global root mount point.  This is required for the
2138  * auditing sub-system, as audited pathnames must be absolute, relative to the
2139  * global root mount point.
2140  */
2141 int
2142 vn_fullpath_global(struct thread *td, struct vnode *vn,
2143     char **retbuf, char **freebuf)
2144 {
2145         char *buf;
2146         int error;
2147
2148         if (__predict_false(disablefullpath))
2149                 return (ENODEV);
2150         if (__predict_false(vn == NULL))
2151                 return (EINVAL);
2152         buf = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
2153         error = vn_fullpath1(td, vn, rootvnode, buf, retbuf, MAXPATHLEN);
2154         if (!error)
2155                 *freebuf = buf;
2156         else
2157                 free(buf, M_TEMP);
2158         return (error);
2159 }
2160
2161 int
2162 vn_vptocnp(struct vnode **vp, struct ucred *cred, char *buf, u_int *buflen)
2163 {
2164         struct vnode *dvp;
2165         struct namecache *ncp;
2166         struct mtx *vlp;
2167         int error;
2168
2169         vlp = VP2VNODELOCK(*vp);
2170         mtx_lock(vlp);
2171         TAILQ_FOREACH(ncp, &((*vp)->v_cache_dst), nc_dst) {
2172                 if ((ncp->nc_flag & NCF_ISDOTDOT) == 0)
2173                         break;
2174         }
2175         if (ncp != NULL) {
2176                 if (*buflen < ncp->nc_nlen) {
2177                         mtx_unlock(vlp);
2178                         vrele(*vp);
2179                         counter_u64_add(numfullpathfail4, 1);
2180                         error = ENOMEM;
2181                         SDT_PROBE3(vfs, namecache, fullpath, return, error,
2182                             vp, NULL);
2183                         return (error);
2184                 }
2185                 *buflen -= ncp->nc_nlen;
2186                 memcpy(buf + *buflen, nc_get_name(ncp), ncp->nc_nlen);
2187                 SDT_PROBE3(vfs, namecache, fullpath, hit, ncp->nc_dvp,
2188                     nc_get_name(ncp), vp);
2189                 dvp = *vp;
2190                 *vp = ncp->nc_dvp;
2191                 vref(*vp);
2192                 mtx_unlock(vlp);
2193                 vrele(dvp);
2194                 return (0);
2195         }
2196         SDT_PROBE1(vfs, namecache, fullpath, miss, vp);
2197
2198         mtx_unlock(vlp);
2199         vn_lock(*vp, LK_SHARED | LK_RETRY);
2200         error = VOP_VPTOCNP(*vp, &dvp, cred, buf, buflen);
2201         vput(*vp);
2202         if (error) {
2203                 counter_u64_add(numfullpathfail2, 1);
2204                 SDT_PROBE3(vfs, namecache, fullpath, return,  error, vp, NULL);
2205                 return (error);
2206         }
2207
2208         *vp = dvp;
2209         if (dvp->v_iflag & VI_DOOMED) {
2210                 /* forced unmount */
2211                 vrele(dvp);
2212                 error = ENOENT;
2213                 SDT_PROBE3(vfs, namecache, fullpath, return, error, vp, NULL);
2214                 return (error);
2215         }
2216         /*
2217          * *vp has its use count incremented still.
2218          */
2219
2220         return (0);
2221 }
2222
2223 /*
2224  * The magic behind kern___getcwd() and vn_fullpath().
2225  */
2226 static int
2227 vn_fullpath1(struct thread *td, struct vnode *vp, struct vnode *rdir,
2228     char *buf, char **retbuf, u_int buflen)
2229 {
2230         int error, slash_prefixed;
2231 #ifdef KDTRACE_HOOKS
2232         struct vnode *startvp = vp;
2233 #endif
2234         struct vnode *vp1;
2235
2236         buflen--;
2237         buf[buflen] = '\0';
2238         error = 0;
2239         slash_prefixed = 0;
2240
2241         SDT_PROBE1(vfs, namecache, fullpath, entry, vp);
2242         counter_u64_add(numfullpathcalls, 1);
2243         vref(vp);
2244         if (vp->v_type != VDIR) {
2245                 error = vn_vptocnp(&vp, td->td_ucred, buf, &buflen);
2246                 if (error)
2247                         return (error);
2248                 if (buflen == 0) {
2249                         vrele(vp);
2250                         return (ENOMEM);
2251                 }
2252                 buf[--buflen] = '/';
2253                 slash_prefixed = 1;
2254         }
2255         while (vp != rdir && vp != rootvnode) {
2256                 /*
2257                  * The vp vnode must be already fully constructed,
2258                  * since it is either found in namecache or obtained
2259                  * from VOP_VPTOCNP().  We may test for VV_ROOT safely
2260                  * without obtaining the vnode lock.
2261                  */
2262                 if ((vp->v_vflag & VV_ROOT) != 0) {
2263                         vn_lock(vp, LK_RETRY | LK_SHARED);
2264
2265                         /*
2266                          * With the vnode locked, check for races with
2267                          * unmount, forced or not.  Note that we
2268                          * already verified that vp is not equal to
2269                          * the root vnode, which means that
2270                          * mnt_vnodecovered can be NULL only for the
2271                          * case of unmount.
2272                          */
2273                         if ((vp->v_iflag & VI_DOOMED) != 0 ||
2274                             (vp1 = vp->v_mount->mnt_vnodecovered) == NULL ||
2275                             vp1->v_mountedhere != vp->v_mount) {
2276                                 vput(vp);
2277                                 error = ENOENT;
2278                                 SDT_PROBE3(vfs, namecache, fullpath, return,
2279                                     error, vp, NULL);
2280                                 break;
2281                         }
2282
2283                         vref(vp1);
2284                         vput(vp);
2285                         vp = vp1;
2286                         continue;
2287                 }
2288                 if (vp->v_type != VDIR) {
2289                         vrele(vp);
2290                         counter_u64_add(numfullpathfail1, 1);
2291                         error = ENOTDIR;
2292                         SDT_PROBE3(vfs, namecache, fullpath, return,
2293                             error, vp, NULL);
2294                         break;
2295                 }
2296                 error = vn_vptocnp(&vp, td->td_ucred, buf, &buflen);
2297                 if (error)
2298                         break;
2299                 if (buflen == 0) {
2300                         vrele(vp);
2301                         error = ENOMEM;
2302                         SDT_PROBE3(vfs, namecache, fullpath, return, error,
2303                             startvp, NULL);
2304                         break;
2305                 }
2306                 buf[--buflen] = '/';
2307                 slash_prefixed = 1;
2308         }
2309         if (error)
2310                 return (error);
2311         if (!slash_prefixed) {
2312                 if (buflen == 0) {
2313                         vrele(vp);
2314                         counter_u64_add(numfullpathfail4, 1);
2315                         SDT_PROBE3(vfs, namecache, fullpath, return, ENOMEM,
2316                             startvp, NULL);
2317                         return (ENOMEM);
2318                 }
2319                 buf[--buflen] = '/';
2320         }
2321         counter_u64_add(numfullpathfound, 1);
2322         vrele(vp);
2323
2324         SDT_PROBE3(vfs, namecache, fullpath, return, 0, startvp, buf + buflen);
2325         *retbuf = buf + buflen;
2326         return (0);
2327 }
2328
2329 struct vnode *
2330 vn_dir_dd_ino(struct vnode *vp)
2331 {
2332         struct namecache *ncp;
2333         struct vnode *ddvp;
2334         struct mtx *vlp;
2335
2336         ASSERT_VOP_LOCKED(vp, "vn_dir_dd_ino");
2337         vlp = VP2VNODELOCK(vp);
2338         mtx_lock(vlp);
2339         TAILQ_FOREACH(ncp, &(vp->v_cache_dst), nc_dst) {
2340                 if ((ncp->nc_flag & NCF_ISDOTDOT) != 0)
2341                         continue;
2342                 ddvp = ncp->nc_dvp;
2343                 vhold(ddvp);
2344                 mtx_unlock(vlp);
2345                 if (vget(ddvp, LK_SHARED | LK_NOWAIT | LK_VNHELD, curthread))
2346                         return (NULL);
2347                 return (ddvp);
2348         }
2349         mtx_unlock(vlp);
2350         return (NULL);
2351 }
2352
2353 int
2354 vn_commname(struct vnode *vp, char *buf, u_int buflen)
2355 {
2356         struct namecache *ncp;
2357         struct mtx *vlp;
2358         int l;
2359
2360         vlp = VP2VNODELOCK(vp);
2361         mtx_lock(vlp);
2362         TAILQ_FOREACH(ncp, &vp->v_cache_dst, nc_dst)
2363                 if ((ncp->nc_flag & NCF_ISDOTDOT) == 0)
2364                         break;
2365         if (ncp == NULL) {
2366                 mtx_unlock(vlp);
2367                 return (ENOENT);
2368         }
2369         l = min(ncp->nc_nlen, buflen - 1);
2370         memcpy(buf, nc_get_name(ncp), l);
2371         mtx_unlock(vlp);
2372         buf[l] = '\0';
2373         return (0);
2374 }
2375
2376 /* ABI compat shims for old kernel modules. */
2377 #undef cache_enter
2378
2379 void    cache_enter(struct vnode *dvp, struct vnode *vp,
2380             struct componentname *cnp);
2381
2382 void
2383 cache_enter(struct vnode *dvp, struct vnode *vp, struct componentname *cnp)
2384 {
2385
2386         cache_enter_time(dvp, vp, cnp, NULL, NULL);
2387 }
2388
2389 /*
2390  * This function updates path string to vnode's full global path
2391  * and checks the size of the new path string against the pathlen argument.
2392  *
2393  * Requires a locked, referenced vnode.
2394  * Vnode is re-locked on success or ENODEV, otherwise unlocked.
2395  *
2396  * If sysctl debug.disablefullpath is set, ENODEV is returned,
2397  * vnode is left locked and path remain untouched.
2398  *
2399  * If vp is a directory, the call to vn_fullpath_global() always succeeds
2400  * because it falls back to the ".." lookup if the namecache lookup fails.
2401  */
2402 int
2403 vn_path_to_global_path(struct thread *td, struct vnode *vp, char *path,
2404     u_int pathlen)
2405 {
2406         struct nameidata nd;
2407         struct vnode *vp1;
2408         char *rpath, *fbuf;
2409         int error;
2410
2411         ASSERT_VOP_ELOCKED(vp, __func__);
2412
2413         /* Return ENODEV if sysctl debug.disablefullpath==1 */
2414         if (__predict_false(disablefullpath))
2415                 return (ENODEV);
2416
2417         /* Construct global filesystem path from vp. */
2418         VOP_UNLOCK(vp, 0);
2419         error = vn_fullpath_global(td, vp, &rpath, &fbuf);
2420
2421         if (error != 0) {
2422                 vrele(vp);
2423                 return (error);
2424         }
2425
2426         if (strlen(rpath) >= pathlen) {
2427                 vrele(vp);
2428                 error = ENAMETOOLONG;
2429                 goto out;
2430         }
2431
2432         /*
2433          * Re-lookup the vnode by path to detect a possible rename.
2434          * As a side effect, the vnode is relocked.
2435          * If vnode was renamed, return ENOENT.
2436          */
2437         NDINIT(&nd, LOOKUP, FOLLOW | LOCKLEAF | AUDITVNODE1,
2438             UIO_SYSSPACE, path, td);
2439         error = namei(&nd);
2440         if (error != 0) {
2441                 vrele(vp);
2442                 goto out;
2443         }
2444         NDFREE(&nd, NDF_ONLY_PNBUF);
2445         vp1 = nd.ni_vp;
2446         vrele(vp);
2447         if (vp1 == vp)
2448                 strcpy(path, rpath);
2449         else {
2450                 vput(vp1);
2451                 error = ENOENT;
2452         }
2453
2454 out:
2455         free(fbuf, M_TEMP);
2456         return (error);
2457 }