The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/vfs_cache.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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  * 4. 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: releng/8.1/sys/kern/vfs_cache.c 207598 2010-05-04 05:25:48Z kib $");
   37 
   38 #include "opt_kdtrace.h"
   39 #include "opt_ktrace.h"
   40 
   41 #include <sys/param.h>
   42 #include <sys/filedesc.h>
   43 #include <sys/fnv_hash.h>
   44 #include <sys/kernel.h>
   45 #include <sys/lock.h>
   46 #include <sys/malloc.h>
   47 #include <sys/mount.h>
   48 #include <sys/namei.h>
   49 #include <sys/proc.h>
   50 #include <sys/rwlock.h>
   51 #include <sys/sdt.h>
   52 #include <sys/syscallsubr.h>
   53 #include <sys/sysctl.h>
   54 #include <sys/sysproto.h>
   55 #include <sys/systm.h>
   56 #include <sys/vnode.h>
   57 #ifdef KTRACE
   58 #include <sys/ktrace.h>
   59 #endif
   60 
   61 #include <vm/uma.h>
   62 
   63 SDT_PROVIDER_DECLARE(vfs);
   64 SDT_PROBE_DEFINE3(vfs, namecache, enter, done, "struct vnode *", "char *",
   65     "struct vnode *");
   66 SDT_PROBE_DEFINE2(vfs, namecache, enter_negative, done, "struct vnode *",
   67     "char *");
   68 SDT_PROBE_DEFINE1(vfs, namecache, fullpath, entry, "struct vnode *");
   69 SDT_PROBE_DEFINE3(vfs, namecache, fullpath, hit, "struct vnode *",
   70     "struct char *", "struct vnode *");
   71 SDT_PROBE_DEFINE1(vfs, namecache, fullpath, miss, "struct vnode *");
   72 SDT_PROBE_DEFINE3(vfs, namecache, fullpath, return, "int", "struct vnode *",
   73     "struct char *");
   74 SDT_PROBE_DEFINE3(vfs, namecache, lookup, hit, "struct vnode *", "char *",
   75     "struct vnode *");
   76 SDT_PROBE_DEFINE2(vfs, namecache, lookup, hit_negative, "struct vnode *",
   77     "char *");
   78 SDT_PROBE_DEFINE2(vfs, namecache, lookup, miss, "struct vnode *",
   79     "char *");
   80 SDT_PROBE_DEFINE1(vfs, namecache, purge, done, "struct vnode *");
   81 SDT_PROBE_DEFINE1(vfs, namecache, purge_negative, done, "struct vnode *");
   82 SDT_PROBE_DEFINE1(vfs, namecache, purgevfs, done, "struct mount *");
   83 SDT_PROBE_DEFINE3(vfs, namecache, zap, done, "struct vnode *", "char *",
   84     "struct vnode *");
   85 SDT_PROBE_DEFINE2(vfs, namecache, zap_negative, done, "struct vnode *",
   86     "char *");
   87 
   88 /*
   89  * This structure describes the elements in the cache of recent
   90  * names looked up by namei.
   91  */
   92 
   93 struct  namecache {
   94         LIST_ENTRY(namecache) nc_hash;  /* hash chain */
   95         LIST_ENTRY(namecache) nc_src;   /* source vnode list */
   96         TAILQ_ENTRY(namecache) nc_dst;  /* destination vnode list */
   97         struct  vnode *nc_dvp;          /* vnode of parent of name */
   98         struct  vnode *nc_vp;           /* vnode the name refers to */
   99         u_char  nc_flag;                /* flag bits */
  100         u_char  nc_nlen;                /* length of name */
  101         char    nc_name[0];             /* segment name + nul */
  102 };
  103 
  104 /*
  105  * Name caching works as follows:
  106  *
  107  * Names found by directory scans are retained in a cache
  108  * for future reference.  It is managed LRU, so frequently
  109  * used names will hang around.  Cache is indexed by hash value
  110  * obtained from (vp, name) where vp refers to the directory
  111  * containing name.
  112  *
  113  * If it is a "negative" entry, (i.e. for a name that is known NOT to
  114  * exist) the vnode pointer will be NULL.
  115  *
  116  * Upon reaching the last segment of a path, if the reference
  117  * is for DELETE, or NOCACHE is set (rewrite), and the
  118  * name is located in the cache, it will be dropped.
  119  */
  120 
  121 /*
  122  * Structures associated with name cacheing.
  123  */
  124 #define NCHHASH(hash) \
  125         (&nchashtbl[(hash) & nchash])
  126 static LIST_HEAD(nchashhead, namecache) *nchashtbl;     /* Hash Table */
  127 static TAILQ_HEAD(, namecache) ncneg;   /* Hash Table */
  128 static u_long   nchash;                 /* size of hash table */
  129 SYSCTL_ULONG(_debug, OID_AUTO, nchash, CTLFLAG_RD, &nchash, 0, "");
  130 static u_long   ncnegfactor = 16;       /* ratio of negative entries */
  131 SYSCTL_ULONG(_debug, OID_AUTO, ncnegfactor, CTLFLAG_RW, &ncnegfactor, 0, "");
  132 static u_long   numneg;                 /* number of cache entries allocated */
  133 SYSCTL_ULONG(_debug, OID_AUTO, numneg, CTLFLAG_RD, &numneg, 0, "");
  134 static u_long   numcache;               /* number of cache entries allocated */
  135 SYSCTL_ULONG(_debug, OID_AUTO, numcache, CTLFLAG_RD, &numcache, 0, "");
  136 static u_long   numcachehv;             /* number of cache entries with vnodes held */
  137 SYSCTL_ULONG(_debug, OID_AUTO, numcachehv, CTLFLAG_RD, &numcachehv, 0, "");
  138 #if 0
  139 static u_long   numcachepl;             /* number of cache purge for leaf entries */
  140 SYSCTL_ULONG(_debug, OID_AUTO, numcachepl, CTLFLAG_RD, &numcachepl, 0, "");
  141 #endif
  142 struct  nchstats nchstats;              /* cache effectiveness statistics */
  143 
  144 static struct rwlock cache_lock;
  145 RW_SYSINIT(vfscache, &cache_lock, "Name Cache");
  146 
  147 #define CACHE_UPGRADE_LOCK()    rw_try_upgrade(&cache_lock)
  148 #define CACHE_RLOCK()           rw_rlock(&cache_lock)
  149 #define CACHE_RUNLOCK()         rw_runlock(&cache_lock)
  150 #define CACHE_WLOCK()           rw_wlock(&cache_lock)
  151 #define CACHE_WUNLOCK()         rw_wunlock(&cache_lock)
  152 
  153 /*
  154  * UMA zones for the VFS cache.
  155  *
  156  * The small cache is used for entries with short names, which are the
  157  * most common.  The large cache is used for entries which are too big to
  158  * fit in the small cache.
  159  */
  160 static uma_zone_t cache_zone_small;
  161 static uma_zone_t cache_zone_large;
  162 
  163 #define CACHE_PATH_CUTOFF       35
  164 #define CACHE_ZONE_SMALL        (sizeof(struct namecache) + CACHE_PATH_CUTOFF \
  165                                     + 1)
  166 #define CACHE_ZONE_LARGE        (sizeof(struct namecache) + NAME_MAX + 1)
  167 
  168 #define cache_alloc(len)        uma_zalloc(((len) <= CACHE_PATH_CUTOFF) ? \
  169         cache_zone_small : cache_zone_large, M_WAITOK)
  170 #define cache_free(ncp)         do { \
  171         if (ncp != NULL) \
  172                 uma_zfree(((ncp)->nc_nlen <= CACHE_PATH_CUTOFF) ? \
  173                     cache_zone_small : cache_zone_large, (ncp)); \
  174 } while (0)
  175 
  176 static int      doingcache = 1;         /* 1 => enable the cache */
  177 SYSCTL_INT(_debug, OID_AUTO, vfscache, CTLFLAG_RW, &doingcache, 0, "");
  178 
  179 /* Export size information to userland */
  180 SYSCTL_INT(_debug_sizeof, OID_AUTO, namecache, CTLFLAG_RD, 0,
  181         sizeof(struct namecache), "");
  182 
  183 /*
  184  * The new name cache statistics
  185  */
  186 static SYSCTL_NODE(_vfs, OID_AUTO, cache, CTLFLAG_RW, 0, "Name cache statistics");
  187 #define STATNODE(mode, name, var) \
  188         SYSCTL_ULONG(_vfs_cache, OID_AUTO, name, mode, var, 0, "");
  189 STATNODE(CTLFLAG_RD, numneg, &numneg);
  190 STATNODE(CTLFLAG_RD, numcache, &numcache);
  191 static u_long numcalls; STATNODE(CTLFLAG_RD, numcalls, &numcalls);
  192 static u_long dothits; STATNODE(CTLFLAG_RD, dothits, &dothits);
  193 static u_long dotdothits; STATNODE(CTLFLAG_RD, dotdothits, &dotdothits);
  194 static u_long numchecks; STATNODE(CTLFLAG_RD, numchecks, &numchecks);
  195 static u_long nummiss; STATNODE(CTLFLAG_RD, nummiss, &nummiss);
  196 static u_long nummisszap; STATNODE(CTLFLAG_RD, nummisszap, &nummisszap);
  197 static u_long numposzaps; STATNODE(CTLFLAG_RD, numposzaps, &numposzaps);
  198 static u_long numposhits; STATNODE(CTLFLAG_RD, numposhits, &numposhits);
  199 static u_long numnegzaps; STATNODE(CTLFLAG_RD, numnegzaps, &numnegzaps);
  200 static u_long numneghits; STATNODE(CTLFLAG_RD, numneghits, &numneghits);
  201 static u_long numupgrades; STATNODE(CTLFLAG_RD, numupgrades, &numupgrades);
  202 
  203 SYSCTL_OPAQUE(_vfs_cache, OID_AUTO, nchstats, CTLFLAG_RD | CTLFLAG_MPSAFE,
  204         &nchstats, sizeof(nchstats), "LU", "VFS cache effectiveness statistics");
  205 
  206 
  207 
  208 static void cache_zap(struct namecache *ncp);
  209 static int vn_vptocnp_locked(struct vnode **vp, struct ucred *cred, char *buf,
  210     u_int *buflen);
  211 static int vn_fullpath1(struct thread *td, struct vnode *vp, struct vnode *rdir,
  212     char *buf, char **retbuf, u_int buflen);
  213 
  214 static MALLOC_DEFINE(M_VFSCACHE, "vfscache", "VFS name cache entries");
  215 
  216 /*
  217  * Flags in namecache.nc_flag
  218  */
  219 #define NCF_WHITE       0x01
  220 #define NCF_ISDOTDOT    0x02
  221 
  222 #ifdef DIAGNOSTIC
  223 /*
  224  * Grab an atomic snapshot of the name cache hash chain lengths
  225  */
  226 SYSCTL_NODE(_debug, OID_AUTO, hashstat, CTLFLAG_RW, NULL, "hash table stats");
  227 
  228 static int
  229 sysctl_debug_hashstat_rawnchash(SYSCTL_HANDLER_ARGS)
  230 {
  231         int error;
  232         struct nchashhead *ncpp;
  233         struct namecache *ncp;
  234         int n_nchash;
  235         int count;
  236 
  237         n_nchash = nchash + 1;  /* nchash is max index, not count */
  238         if (!req->oldptr)
  239                 return SYSCTL_OUT(req, 0, n_nchash * sizeof(int));
  240 
  241         /* Scan hash tables for applicable entries */
  242         for (ncpp = nchashtbl; n_nchash > 0; n_nchash--, ncpp++) {
  243                 CACHE_RLOCK();
  244                 count = 0;
  245                 LIST_FOREACH(ncp, ncpp, nc_hash) {
  246                         count++;
  247                 }
  248                 CACHE_RUNLOCK();
  249                 error = SYSCTL_OUT(req, &count, sizeof(count));
  250                 if (error)
  251                         return (error);
  252         }
  253         return (0);
  254 }
  255 SYSCTL_PROC(_debug_hashstat, OID_AUTO, rawnchash, CTLTYPE_INT|CTLFLAG_RD|
  256         CTLFLAG_MPSAFE, 0, 0, sysctl_debug_hashstat_rawnchash, "S,int",
  257         "nchash chain lengths");
  258 
  259 static int
  260 sysctl_debug_hashstat_nchash(SYSCTL_HANDLER_ARGS)
  261 {
  262         int error;
  263         struct nchashhead *ncpp;
  264         struct namecache *ncp;
  265         int n_nchash;
  266         int count, maxlength, used, pct;
  267 
  268         if (!req->oldptr)
  269                 return SYSCTL_OUT(req, 0, 4 * sizeof(int));
  270 
  271         n_nchash = nchash + 1;  /* nchash is max index, not count */
  272         used = 0;
  273         maxlength = 0;
  274 
  275         /* Scan hash tables for applicable entries */
  276         for (ncpp = nchashtbl; n_nchash > 0; n_nchash--, ncpp++) {
  277                 count = 0;
  278                 CACHE_RLOCK();
  279                 LIST_FOREACH(ncp, ncpp, nc_hash) {
  280                         count++;
  281                 }
  282                 CACHE_RUNLOCK();
  283                 if (count)
  284                         used++;
  285                 if (maxlength < count)
  286                         maxlength = count;
  287         }
  288         n_nchash = nchash + 1;
  289         pct = (used * 100 * 100) / n_nchash;
  290         error = SYSCTL_OUT(req, &n_nchash, sizeof(n_nchash));
  291         if (error)
  292                 return (error);
  293         error = SYSCTL_OUT(req, &used, sizeof(used));
  294         if (error)
  295                 return (error);
  296         error = SYSCTL_OUT(req, &maxlength, sizeof(maxlength));
  297         if (error)
  298                 return (error);
  299         error = SYSCTL_OUT(req, &pct, sizeof(pct));
  300         if (error)
  301                 return (error);
  302         return (0);
  303 }
  304 SYSCTL_PROC(_debug_hashstat, OID_AUTO, nchash, CTLTYPE_INT|CTLFLAG_RD|
  305         CTLFLAG_MPSAFE, 0, 0, sysctl_debug_hashstat_nchash, "I",
  306         "nchash chain lengths");
  307 #endif
  308 
  309 /*
  310  * cache_zap():
  311  *
  312  *   Removes a namecache entry from cache, whether it contains an actual
  313  *   pointer to a vnode or if it is just a negative cache entry.
  314  */
  315 static void
  316 cache_zap(ncp)
  317         struct namecache *ncp;
  318 {
  319         struct vnode *vp;
  320 
  321         rw_assert(&cache_lock, RA_WLOCKED);
  322         CTR2(KTR_VFS, "cache_zap(%p) vp %p", ncp, ncp->nc_vp);
  323 #ifdef KDTRACE_HOOKS
  324         if (ncp->nc_vp != NULL) {
  325                 SDT_PROBE(vfs, namecache, zap, done, ncp->nc_dvp,
  326                     ncp->nc_name, ncp->nc_vp, 0, 0);
  327         } else {
  328                 SDT_PROBE(vfs, namecache, zap_negative, done, ncp->nc_dvp,
  329                     ncp->nc_name, 0, 0, 0);
  330         }
  331 #endif
  332         vp = NULL;
  333         LIST_REMOVE(ncp, nc_hash);
  334         if (ncp->nc_flag & NCF_ISDOTDOT) {
  335                 if (ncp == ncp->nc_dvp->v_cache_dd)
  336                         ncp->nc_dvp->v_cache_dd = NULL;
  337         } else {
  338                 LIST_REMOVE(ncp, nc_src);
  339                 if (LIST_EMPTY(&ncp->nc_dvp->v_cache_src)) {
  340                         vp = ncp->nc_dvp;
  341                         numcachehv--;
  342                 }
  343         }
  344         if (ncp->nc_vp) {
  345                 TAILQ_REMOVE(&ncp->nc_vp->v_cache_dst, ncp, nc_dst);
  346                 if (ncp == ncp->nc_vp->v_cache_dd)
  347                         ncp->nc_vp->v_cache_dd = NULL;
  348         } else {
  349                 TAILQ_REMOVE(&ncneg, ncp, nc_dst);
  350                 numneg--;
  351         }
  352         numcache--;
  353         cache_free(ncp);
  354         if (vp)
  355                 vdrop(vp);
  356 }
  357 
  358 /*
  359  * Lookup an entry in the cache
  360  *
  361  * Lookup is called with dvp pointing to the directory to search,
  362  * cnp pointing to the name of the entry being sought. If the lookup
  363  * succeeds, the vnode is returned in *vpp, and a status of -1 is
  364  * returned. If the lookup determines that the name does not exist
  365  * (negative cacheing), a status of ENOENT is returned. If the lookup
  366  * fails, a status of zero is returned.  If the directory vnode is
  367  * recycled out from under us due to a forced unmount, a status of
  368  * ENOENT is returned.
  369  *
  370  * vpp is locked and ref'd on return.  If we're looking up DOTDOT, dvp is
  371  * unlocked.  If we're looking up . an extra ref is taken, but the lock is
  372  * not recursively acquired.
  373  */
  374 
  375 int
  376 cache_lookup(dvp, vpp, cnp)
  377         struct vnode *dvp;
  378         struct vnode **vpp;
  379         struct componentname *cnp;
  380 {
  381         struct namecache *ncp;
  382         u_int32_t hash;
  383         int error, ltype, wlocked;
  384 
  385         if (!doingcache) {
  386                 cnp->cn_flags &= ~MAKEENTRY;
  387                 return (0);
  388         }
  389 retry:
  390         CACHE_RLOCK();
  391         wlocked = 0;
  392         numcalls++;
  393         error = 0;
  394 
  395 retry_wlocked:
  396         if (cnp->cn_nameptr[0] == '.') {
  397                 if (cnp->cn_namelen == 1) {
  398                         *vpp = dvp;
  399                         CTR2(KTR_VFS, "cache_lookup(%p, %s) found via .",
  400                             dvp, cnp->cn_nameptr);
  401                         dothits++;
  402                         SDT_PROBE(vfs, namecache, lookup, hit, dvp, ".",
  403                             *vpp, 0, 0);
  404                         goto success;
  405                 }
  406                 if (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.') {
  407                         dotdothits++;
  408                         if (dvp->v_cache_dd == NULL) {
  409                                 SDT_PROBE(vfs, namecache, lookup, miss, dvp,
  410                                     "..", NULL, 0, 0);
  411                                 goto unlock;
  412                         }
  413                         if ((cnp->cn_flags & MAKEENTRY) == 0) {
  414                                 if (!wlocked && !CACHE_UPGRADE_LOCK())
  415                                         goto wlock;
  416                                 if (dvp->v_cache_dd->nc_flag & NCF_ISDOTDOT)
  417                                         cache_zap(dvp->v_cache_dd);
  418                                 dvp->v_cache_dd = NULL;
  419                                 CACHE_WUNLOCK();
  420                                 return (0);
  421                         }
  422                         if (dvp->v_cache_dd->nc_flag & NCF_ISDOTDOT)
  423                                 *vpp = dvp->v_cache_dd->nc_vp;
  424                         else
  425                                 *vpp = dvp->v_cache_dd->nc_dvp;
  426                         /* Return failure if negative entry was found. */
  427                         if (*vpp == NULL) {
  428                                 ncp = dvp->v_cache_dd;
  429                                 goto negative_success;
  430                         }
  431                         CTR3(KTR_VFS, "cache_lookup(%p, %s) found %p via ..",
  432                             dvp, cnp->cn_nameptr, *vpp);
  433                         SDT_PROBE(vfs, namecache, lookup, hit, dvp, "..",
  434                             *vpp, 0, 0);
  435                         goto success;
  436                 }
  437         }
  438 
  439         hash = fnv_32_buf(cnp->cn_nameptr, cnp->cn_namelen, FNV1_32_INIT);
  440         hash = fnv_32_buf(&dvp, sizeof(dvp), hash);
  441         LIST_FOREACH(ncp, (NCHHASH(hash)), nc_hash) {
  442                 numchecks++;
  443                 if (ncp->nc_dvp == dvp && ncp->nc_nlen == cnp->cn_namelen &&
  444                     !bcmp(ncp->nc_name, cnp->cn_nameptr, ncp->nc_nlen))
  445                         break;
  446         }
  447 
  448         /* We failed to find an entry */
  449         if (ncp == NULL) {
  450                 SDT_PROBE(vfs, namecache, lookup, miss, dvp, cnp->cn_nameptr,
  451                     NULL, 0, 0);
  452                 if ((cnp->cn_flags & MAKEENTRY) == 0) {
  453                         nummisszap++;
  454                 } else {
  455                         nummiss++;
  456                 }
  457                 nchstats.ncs_miss++;
  458                 goto unlock;
  459         }
  460 
  461         /* We don't want to have an entry, so dump it */
  462         if ((cnp->cn_flags & MAKEENTRY) == 0) {
  463                 numposzaps++;
  464                 nchstats.ncs_badhits++;
  465                 if (!wlocked && !CACHE_UPGRADE_LOCK())
  466                         goto wlock;
  467                 cache_zap(ncp);
  468                 CACHE_WUNLOCK();
  469                 return (0);
  470         }
  471 
  472         /* We found a "positive" match, return the vnode */
  473         if (ncp->nc_vp) {
  474                 numposhits++;
  475                 nchstats.ncs_goodhits++;
  476                 *vpp = ncp->nc_vp;
  477                 CTR4(KTR_VFS, "cache_lookup(%p, %s) found %p via ncp %p",
  478                     dvp, cnp->cn_nameptr, *vpp, ncp);
  479                 SDT_PROBE(vfs, namecache, lookup, hit, dvp, ncp->nc_name,
  480                     *vpp, 0, 0);
  481                 goto success;
  482         }
  483 
  484 negative_success:
  485         /* We found a negative match, and want to create it, so purge */
  486         if (cnp->cn_nameiop == CREATE) {
  487                 numnegzaps++;
  488                 nchstats.ncs_badhits++;
  489                 if (!wlocked && !CACHE_UPGRADE_LOCK())
  490                         goto wlock;
  491                 cache_zap(ncp);
  492                 CACHE_WUNLOCK();
  493                 return (0);
  494         }
  495 
  496         if (!wlocked && !CACHE_UPGRADE_LOCK())
  497                 goto wlock;
  498         numneghits++;
  499         /*
  500          * We found a "negative" match, so we shift it to the end of
  501          * the "negative" cache entries queue to satisfy LRU.  Also,
  502          * check to see if the entry is a whiteout; indicate this to
  503          * the componentname, if so.
  504          */
  505         TAILQ_REMOVE(&ncneg, ncp, nc_dst);
  506         TAILQ_INSERT_TAIL(&ncneg, ncp, nc_dst);
  507         nchstats.ncs_neghits++;
  508         if (ncp->nc_flag & NCF_WHITE)
  509                 cnp->cn_flags |= ISWHITEOUT;
  510         SDT_PROBE(vfs, namecache, lookup, hit_negative, dvp, ncp->nc_name,
  511             0, 0, 0);
  512         CACHE_WUNLOCK();
  513         return (ENOENT);
  514 
  515 wlock:
  516         /*
  517          * We need to update the cache after our lookup, so upgrade to
  518          * a write lock and retry the operation.
  519          */
  520         CACHE_RUNLOCK();
  521         CACHE_WLOCK();
  522         numupgrades++;
  523         wlocked = 1;
  524         goto retry_wlocked;
  525 
  526 success:
  527         /*
  528          * On success we return a locked and ref'd vnode as per the lookup
  529          * protocol.
  530          */
  531         if (dvp == *vpp) {   /* lookup on "." */
  532                 VREF(*vpp);
  533                 if (wlocked)
  534                         CACHE_WUNLOCK();
  535                 else
  536                         CACHE_RUNLOCK();
  537                 /*
  538                  * When we lookup "." we still can be asked to lock it
  539                  * differently...
  540                  */
  541                 ltype = cnp->cn_lkflags & LK_TYPE_MASK;
  542                 if (ltype != VOP_ISLOCKED(*vpp)) {
  543                         if (ltype == LK_EXCLUSIVE) {
  544                                 vn_lock(*vpp, LK_UPGRADE | LK_RETRY);
  545                                 if ((*vpp)->v_iflag & VI_DOOMED) {
  546                                         /* forced unmount */
  547                                         vrele(*vpp);
  548                                         *vpp = NULL;
  549                                         return (ENOENT);
  550                                 }
  551                         } else
  552                                 vn_lock(*vpp, LK_DOWNGRADE | LK_RETRY);
  553                 }
  554                 return (-1);
  555         }
  556         ltype = 0;      /* silence gcc warning */
  557         if (cnp->cn_flags & ISDOTDOT) {
  558                 ltype = VOP_ISLOCKED(dvp);
  559                 VOP_UNLOCK(dvp, 0);
  560         }
  561         VI_LOCK(*vpp);
  562         if (wlocked)
  563                 CACHE_WUNLOCK();
  564         else
  565                 CACHE_RUNLOCK();
  566         error = vget(*vpp, cnp->cn_lkflags | LK_INTERLOCK, cnp->cn_thread);
  567         if (cnp->cn_flags & ISDOTDOT) {
  568                 vn_lock(dvp, ltype | LK_RETRY);
  569                 if (dvp->v_iflag & VI_DOOMED) {
  570                         if (error == 0)
  571                                 vput(*vpp);
  572                         *vpp = NULL;
  573                         return (ENOENT);
  574                 }
  575         }
  576         if (error) {
  577                 *vpp = NULL;
  578                 goto retry;
  579         }
  580         if ((cnp->cn_flags & ISLASTCN) &&
  581             (cnp->cn_lkflags & LK_TYPE_MASK) == LK_EXCLUSIVE) {
  582                 ASSERT_VOP_ELOCKED(*vpp, "cache_lookup");
  583         }
  584         return (-1);
  585 
  586 unlock:
  587         if (wlocked)
  588                 CACHE_WUNLOCK();
  589         else
  590                 CACHE_RUNLOCK();
  591         return (0);
  592 }
  593 
  594 /*
  595  * Add an entry to the cache.
  596  */
  597 void
  598 cache_enter(dvp, vp, cnp)
  599         struct vnode *dvp;
  600         struct vnode *vp;
  601         struct componentname *cnp;
  602 {
  603         struct namecache *ncp, *n2;
  604         struct nchashhead *ncpp;
  605         u_int32_t hash;
  606         int flag;
  607         int hold;
  608         int zap;
  609         int len;
  610 
  611         CTR3(KTR_VFS, "cache_enter(%p, %p, %s)", dvp, vp, cnp->cn_nameptr);
  612         VNASSERT(vp == NULL || (vp->v_iflag & VI_DOOMED) == 0, vp,
  613             ("cache_enter: Adding a doomed vnode"));
  614         VNASSERT(dvp == NULL || (dvp->v_iflag & VI_DOOMED) == 0, dvp,
  615             ("cache_enter: Doomed vnode used as src"));
  616 
  617         if (!doingcache)
  618                 return;
  619 
  620         /*
  621          * Avoid blowout in namecache entries.
  622          */
  623         if (numcache >= desiredvnodes * 2)
  624                 return;
  625 
  626         flag = 0;
  627         if (cnp->cn_nameptr[0] == '.') {
  628                 if (cnp->cn_namelen == 1)
  629                         return;
  630                 if (cnp->cn_namelen == 2 && cnp->cn_nameptr[1] == '.') {
  631                         CACHE_WLOCK();
  632                         /*
  633                          * If dotdot entry already exists, just retarget it
  634                          * to new parent vnode, otherwise continue with new
  635                          * namecache entry allocation.
  636                          */
  637                         if ((ncp = dvp->v_cache_dd) != NULL &&
  638                             ncp->nc_flag & NCF_ISDOTDOT) {
  639                                 KASSERT(ncp->nc_dvp == dvp,
  640                                     ("wrong isdotdot parent"));
  641                                 if (ncp->nc_vp != NULL)
  642                                         TAILQ_REMOVE(&ncp->nc_vp->v_cache_dst,
  643                                             ncp, nc_dst);
  644                                 else
  645                                         TAILQ_REMOVE(&ncneg, ncp, nc_dst);
  646                                 if (vp != NULL)
  647                                         TAILQ_INSERT_HEAD(&vp->v_cache_dst,
  648                                             ncp, nc_dst);
  649                                 else
  650                                         TAILQ_INSERT_TAIL(&ncneg, ncp, nc_dst);
  651                                 ncp->nc_vp = vp;
  652                                 CACHE_WUNLOCK();
  653                                 return;
  654                         }
  655                         dvp->v_cache_dd = NULL;
  656                         SDT_PROBE(vfs, namecache, enter, done, dvp, "..", vp,
  657                             0, 0);
  658                         CACHE_WUNLOCK();
  659                         flag = NCF_ISDOTDOT;
  660                 }
  661         }
  662 
  663         hold = 0;
  664         zap = 0;
  665 
  666         /*
  667          * Calculate the hash key and setup as much of the new
  668          * namecache entry as possible before acquiring the lock.
  669          */
  670         ncp = cache_alloc(cnp->cn_namelen);
  671         ncp->nc_vp = vp;
  672         ncp->nc_dvp = dvp;
  673         ncp->nc_flag = flag;
  674         len = ncp->nc_nlen = cnp->cn_namelen;
  675         hash = fnv_32_buf(cnp->cn_nameptr, len, FNV1_32_INIT);
  676         strlcpy(ncp->nc_name, cnp->cn_nameptr, len + 1);
  677         hash = fnv_32_buf(&dvp, sizeof(dvp), hash);
  678         CACHE_WLOCK();
  679 
  680         /*
  681          * See if this vnode or negative entry is already in the cache
  682          * with this name.  This can happen with concurrent lookups of
  683          * the same path name.
  684          */
  685         ncpp = NCHHASH(hash);
  686         LIST_FOREACH(n2, ncpp, nc_hash) {
  687                 if (n2->nc_dvp == dvp &&
  688                     n2->nc_nlen == cnp->cn_namelen &&
  689                     !bcmp(n2->nc_name, cnp->cn_nameptr, n2->nc_nlen)) {
  690                         CACHE_WUNLOCK();
  691                         cache_free(ncp);
  692                         return;
  693                 }
  694         }
  695 
  696         if (flag == NCF_ISDOTDOT) {
  697                 /*
  698                  * See if we are trying to add .. entry, but some other lookup
  699                  * has populated v_cache_dd pointer already.
  700                  */
  701                 if (dvp->v_cache_dd != NULL) {
  702                     CACHE_WUNLOCK();
  703                     cache_free(ncp);
  704                     return;
  705                 }
  706                 KASSERT(vp == NULL || vp->v_type == VDIR,
  707                     ("wrong vnode type %p", vp));
  708                 dvp->v_cache_dd = ncp;
  709         }
  710 
  711         numcache++;
  712         if (!vp) {
  713                 numneg++;
  714                 if (cnp->cn_flags & ISWHITEOUT)
  715                         ncp->nc_flag |= NCF_WHITE;
  716         } else if (vp->v_type == VDIR) {
  717                 if (flag != NCF_ISDOTDOT) {
  718                         if ((n2 = vp->v_cache_dd) != NULL &&
  719                             (n2->nc_flag & NCF_ISDOTDOT) != 0)
  720                                 cache_zap(n2);
  721                         vp->v_cache_dd = ncp;
  722                 }
  723         } else {
  724                 vp->v_cache_dd = NULL;
  725         }
  726 
  727         /*
  728          * Insert the new namecache entry into the appropriate chain
  729          * within the cache entries table.
  730          */
  731         LIST_INSERT_HEAD(ncpp, ncp, nc_hash);
  732         if (flag != NCF_ISDOTDOT) {
  733                 if (LIST_EMPTY(&dvp->v_cache_src)) {
  734                         hold = 1;
  735                         numcachehv++;
  736                 }
  737                 LIST_INSERT_HEAD(&dvp->v_cache_src, ncp, nc_src);
  738         }
  739 
  740         /*
  741          * If the entry is "negative", we place it into the
  742          * "negative" cache queue, otherwise, we place it into the
  743          * destination vnode's cache entries queue.
  744          */
  745         if (vp) {
  746                 TAILQ_INSERT_HEAD(&vp->v_cache_dst, ncp, nc_dst);
  747                 SDT_PROBE(vfs, namecache, enter, done, dvp, ncp->nc_name, vp,
  748                     0, 0);
  749         } else {
  750                 TAILQ_INSERT_TAIL(&ncneg, ncp, nc_dst);
  751                 SDT_PROBE(vfs, namecache, enter_negative, done, dvp,
  752                     ncp->nc_name, 0, 0, 0);
  753         }
  754         if (numneg * ncnegfactor > numcache) {
  755                 ncp = TAILQ_FIRST(&ncneg);
  756                 zap = 1;
  757         }
  758         if (hold)
  759                 vhold(dvp);
  760         if (zap)
  761                 cache_zap(ncp);
  762         CACHE_WUNLOCK();
  763 }
  764 
  765 /*
  766  * Name cache initialization, from vfs_init() when we are booting
  767  */
  768 static void
  769 nchinit(void *dummy __unused)
  770 {
  771 
  772         TAILQ_INIT(&ncneg);
  773 
  774         cache_zone_small = uma_zcreate("S VFS Cache", CACHE_ZONE_SMALL, NULL,
  775             NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_ZINIT);
  776         cache_zone_large = uma_zcreate("L VFS Cache", CACHE_ZONE_LARGE, NULL,
  777             NULL, NULL, NULL, UMA_ALIGN_PTR, UMA_ZONE_ZINIT);
  778 
  779         nchashtbl = hashinit(desiredvnodes * 2, M_VFSCACHE, &nchash);
  780 }
  781 SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_SECOND, nchinit, NULL);
  782 
  783 
  784 /*
  785  * Invalidate all entries to a particular vnode.
  786  */
  787 void
  788 cache_purge(vp)
  789         struct vnode *vp;
  790 {
  791 
  792         CTR1(KTR_VFS, "cache_purge(%p)", vp);
  793         SDT_PROBE(vfs, namecache, purge, done, vp, 0, 0, 0, 0);
  794         CACHE_WLOCK();
  795         while (!LIST_EMPTY(&vp->v_cache_src))
  796                 cache_zap(LIST_FIRST(&vp->v_cache_src));
  797         while (!TAILQ_EMPTY(&vp->v_cache_dst))
  798                 cache_zap(TAILQ_FIRST(&vp->v_cache_dst));
  799         if (vp->v_cache_dd != NULL) {
  800                 KASSERT(vp->v_cache_dd->nc_flag & NCF_ISDOTDOT,
  801                    ("lost dotdot link"));
  802                 cache_zap(vp->v_cache_dd);
  803         }
  804         KASSERT(vp->v_cache_dd == NULL, ("incomplete purge"));
  805         CACHE_WUNLOCK();
  806 }
  807 
  808 /*
  809  * Invalidate all negative entries for a particular directory vnode.
  810  */
  811 void
  812 cache_purge_negative(vp)
  813         struct vnode *vp;
  814 {
  815         struct namecache *cp, *ncp;
  816 
  817         CTR1(KTR_VFS, "cache_purge_negative(%p)", vp);
  818         SDT_PROBE(vfs, namecache, purge_negative, done, vp, 0, 0, 0, 0);
  819         CACHE_WLOCK();
  820         LIST_FOREACH_SAFE(cp, &vp->v_cache_src, nc_src, ncp) {
  821                 if (cp->nc_vp == NULL)
  822                         cache_zap(cp);
  823         }
  824         CACHE_WUNLOCK();
  825 }
  826 
  827 /*
  828  * Flush all entries referencing a particular filesystem.
  829  */
  830 void
  831 cache_purgevfs(mp)
  832         struct mount *mp;
  833 {
  834         struct nchashhead *ncpp;
  835         struct namecache *ncp, *nnp;
  836 
  837         /* Scan hash tables for applicable entries */
  838         SDT_PROBE(vfs, namecache, purgevfs, done, mp, 0, 0, 0, 0);
  839         CACHE_WLOCK();
  840         for (ncpp = &nchashtbl[nchash]; ncpp >= nchashtbl; ncpp--) {
  841                 LIST_FOREACH_SAFE(ncp, ncpp, nc_hash, nnp) {
  842                         if (ncp->nc_dvp->v_mount == mp)
  843                                 cache_zap(ncp);
  844                 }
  845         }
  846         CACHE_WUNLOCK();
  847 }
  848 
  849 /*
  850  * Perform canonical checks and cache lookup and pass on to filesystem
  851  * through the vop_cachedlookup only if needed.
  852  */
  853 
  854 int
  855 vfs_cache_lookup(ap)
  856         struct vop_lookup_args /* {
  857                 struct vnode *a_dvp;
  858                 struct vnode **a_vpp;
  859                 struct componentname *a_cnp;
  860         } */ *ap;
  861 {
  862         struct vnode *dvp;
  863         int error;
  864         struct vnode **vpp = ap->a_vpp;
  865         struct componentname *cnp = ap->a_cnp;
  866         struct ucred *cred = cnp->cn_cred;
  867         int flags = cnp->cn_flags;
  868         struct thread *td = cnp->cn_thread;
  869 
  870         *vpp = NULL;
  871         dvp = ap->a_dvp;
  872 
  873         if (dvp->v_type != VDIR)
  874                 return (ENOTDIR);
  875 
  876         if ((flags & ISLASTCN) && (dvp->v_mount->mnt_flag & MNT_RDONLY) &&
  877             (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME))
  878                 return (EROFS);
  879 
  880         error = VOP_ACCESS(dvp, VEXEC, cred, td);
  881         if (error)
  882                 return (error);
  883 
  884         error = cache_lookup(dvp, vpp, cnp);
  885         if (error == 0)
  886                 return (VOP_CACHEDLOOKUP(dvp, vpp, cnp));
  887         if (error == -1)
  888                 return (0);
  889         return (error);
  890 }
  891 
  892 
  893 #ifndef _SYS_SYSPROTO_H_
  894 struct  __getcwd_args {
  895         u_char  *buf;
  896         u_int   buflen;
  897 };
  898 #endif
  899 
  900 /*
  901  * XXX All of these sysctls would probably be more productive dead.
  902  */
  903 static int disablecwd;
  904 SYSCTL_INT(_debug, OID_AUTO, disablecwd, CTLFLAG_RW, &disablecwd, 0,
  905    "Disable the getcwd syscall");
  906 
  907 /* Implementation of the getcwd syscall. */
  908 int
  909 __getcwd(td, uap)
  910         struct thread *td;
  911         struct __getcwd_args *uap;
  912 {
  913 
  914         return (kern___getcwd(td, uap->buf, UIO_USERSPACE, uap->buflen));
  915 }
  916 
  917 int
  918 kern___getcwd(struct thread *td, u_char *buf, enum uio_seg bufseg, u_int buflen)
  919 {
  920         char *bp, *tmpbuf;
  921         struct filedesc *fdp;
  922         struct vnode *cdir, *rdir;
  923         int error, vfslocked;
  924 
  925         if (disablecwd)
  926                 return (ENODEV);
  927         if (buflen < 2)
  928                 return (EINVAL);
  929         if (buflen > MAXPATHLEN)
  930                 buflen = MAXPATHLEN;
  931 
  932         tmpbuf = malloc(buflen, M_TEMP, M_WAITOK);
  933         fdp = td->td_proc->p_fd;
  934         FILEDESC_SLOCK(fdp);
  935         cdir = fdp->fd_cdir;
  936         VREF(cdir);
  937         rdir = fdp->fd_rdir;
  938         VREF(rdir);
  939         FILEDESC_SUNLOCK(fdp);
  940         error = vn_fullpath1(td, cdir, rdir, tmpbuf, &bp, buflen);
  941         vfslocked = VFS_LOCK_GIANT(rdir->v_mount);
  942         vrele(rdir);
  943         VFS_UNLOCK_GIANT(vfslocked);
  944         vfslocked = VFS_LOCK_GIANT(cdir->v_mount);
  945         vrele(cdir);
  946         VFS_UNLOCK_GIANT(vfslocked);
  947 
  948         if (!error) {
  949                 if (bufseg == UIO_SYSSPACE)
  950                         bcopy(bp, buf, strlen(bp) + 1);
  951                 else
  952                         error = copyout(bp, buf, strlen(bp) + 1);
  953 #ifdef KTRACE
  954         if (KTRPOINT(curthread, KTR_NAMEI))
  955                 ktrnamei(bp);
  956 #endif
  957         }
  958         free(tmpbuf, M_TEMP);
  959         return (error);
  960 }
  961 
  962 /*
  963  * Thus begins the fullpath magic.
  964  */
  965 
  966 #undef STATNODE
  967 #define STATNODE(name)                                                  \
  968         static u_int name;                                              \
  969         SYSCTL_UINT(_vfs_cache, OID_AUTO, name, CTLFLAG_RD, &name, 0, "")
  970 
  971 static int disablefullpath;
  972 SYSCTL_INT(_debug, OID_AUTO, disablefullpath, CTLFLAG_RW, &disablefullpath, 0,
  973         "Disable the vn_fullpath function");
  974 
  975 /* These count for kern___getcwd(), too. */
  976 STATNODE(numfullpathcalls);
  977 STATNODE(numfullpathfail1);
  978 STATNODE(numfullpathfail2);
  979 STATNODE(numfullpathfail4);
  980 STATNODE(numfullpathfound);
  981 
  982 /*
  983  * Retrieve the full filesystem path that correspond to a vnode from the name
  984  * cache (if available)
  985  */
  986 int
  987 vn_fullpath(struct thread *td, struct vnode *vn, char **retbuf, char **freebuf)
  988 {
  989         char *buf;
  990         struct filedesc *fdp;
  991         struct vnode *rdir;
  992         int error, vfslocked;
  993 
  994         if (disablefullpath)
  995                 return (ENODEV);
  996         if (vn == NULL)
  997                 return (EINVAL);
  998 
  999         buf = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 1000         fdp = td->td_proc->p_fd;
 1001         FILEDESC_SLOCK(fdp);
 1002         rdir = fdp->fd_rdir;
 1003         VREF(rdir);
 1004         FILEDESC_SUNLOCK(fdp);
 1005         error = vn_fullpath1(td, vn, rdir, buf, retbuf, MAXPATHLEN);
 1006         vfslocked = VFS_LOCK_GIANT(rdir->v_mount);
 1007         vrele(rdir);
 1008         VFS_UNLOCK_GIANT(vfslocked);
 1009 
 1010         if (!error)
 1011                 *freebuf = buf;
 1012         else
 1013                 free(buf, M_TEMP);
 1014         return (error);
 1015 }
 1016 
 1017 /*
 1018  * This function is similar to vn_fullpath, but it attempts to lookup the
 1019  * pathname relative to the global root mount point.  This is required for the
 1020  * auditing sub-system, as audited pathnames must be absolute, relative to the
 1021  * global root mount point.
 1022  */
 1023 int
 1024 vn_fullpath_global(struct thread *td, struct vnode *vn,
 1025     char **retbuf, char **freebuf)
 1026 {
 1027         char *buf;
 1028         int error;
 1029 
 1030         if (disablefullpath)
 1031                 return (ENODEV);
 1032         if (vn == NULL)
 1033                 return (EINVAL);
 1034         buf = malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 1035         error = vn_fullpath1(td, vn, rootvnode, buf, retbuf, MAXPATHLEN);
 1036         if (!error)
 1037                 *freebuf = buf;
 1038         else
 1039                 free(buf, M_TEMP);
 1040         return (error);
 1041 }
 1042 
 1043 int
 1044 vn_vptocnp(struct vnode **vp, struct ucred *cred, char *buf, u_int *buflen)
 1045 {
 1046         int error;
 1047 
 1048         CACHE_RLOCK();
 1049         error = vn_vptocnp_locked(vp, cred, buf, buflen);
 1050         if (error == 0) {
 1051                 /*
 1052                  * vn_vptocnp_locked() dropped hold acquired by
 1053                  * VOP_VPTOCNP immediately after locking the
 1054                  * cache. Since we are going to drop the cache rlock,
 1055                  * re-hold the result.
 1056                  */
 1057                 vhold(*vp);
 1058                 CACHE_RUNLOCK();
 1059         }
 1060         return (error);
 1061 }
 1062 
 1063 static int
 1064 vn_vptocnp_locked(struct vnode **vp, struct ucred *cred, char *buf,
 1065     u_int *buflen)
 1066 {
 1067         struct vnode *dvp;
 1068         struct namecache *ncp;
 1069         int error, vfslocked;
 1070 
 1071         TAILQ_FOREACH(ncp, &((*vp)->v_cache_dst), nc_dst) {
 1072                 if ((ncp->nc_flag & NCF_ISDOTDOT) == 0)
 1073                         break;
 1074         }
 1075         if (ncp != NULL) {
 1076                 if (*buflen < ncp->nc_nlen) {
 1077                         CACHE_RUNLOCK();
 1078                         numfullpathfail4++;
 1079                         error = ENOMEM;
 1080                         SDT_PROBE(vfs, namecache, fullpath, return, error,
 1081                             vp, NULL, 0, 0);
 1082                         return (error);
 1083                 }
 1084                 *buflen -= ncp->nc_nlen;
 1085                 memcpy(buf + *buflen, ncp->nc_name, ncp->nc_nlen);
 1086                 SDT_PROBE(vfs, namecache, fullpath, hit, ncp->nc_dvp,
 1087                     ncp->nc_name, vp, 0, 0);
 1088                 *vp = ncp->nc_dvp;
 1089                 return (0);
 1090         }
 1091         SDT_PROBE(vfs, namecache, fullpath, miss, vp, 0, 0, 0, 0);
 1092 
 1093         vhold(*vp);
 1094         CACHE_RUNLOCK();
 1095         vfslocked = VFS_LOCK_GIANT((*vp)->v_mount);
 1096         vn_lock(*vp, LK_SHARED | LK_RETRY);
 1097         error = VOP_VPTOCNP(*vp, &dvp, cred, buf, buflen);
 1098         VOP_UNLOCK(*vp, 0);
 1099         vdrop(*vp);
 1100         VFS_UNLOCK_GIANT(vfslocked);
 1101         if (error) {
 1102                 numfullpathfail2++;
 1103                 SDT_PROBE(vfs, namecache, fullpath, return,  error, vp,
 1104                     NULL, 0, 0);
 1105                 return (error);
 1106         }
 1107 
 1108         *vp = dvp;
 1109         CACHE_RLOCK();
 1110         if ((*vp)->v_iflag & VI_DOOMED) {
 1111                 /* forced unmount */
 1112                 CACHE_RUNLOCK();
 1113                 vdrop(*vp);
 1114                 error = ENOENT;
 1115                 SDT_PROBE(vfs, namecache, fullpath, return, error, vp,
 1116                     NULL, 0, 0);
 1117                 return (error);
 1118         }
 1119         vdrop(*vp);
 1120 
 1121         return (0);
 1122 }
 1123 
 1124 /*
 1125  * The magic behind kern___getcwd() and vn_fullpath().
 1126  */
 1127 static int
 1128 vn_fullpath1(struct thread *td, struct vnode *vp, struct vnode *rdir,
 1129     char *buf, char **retbuf, u_int buflen)
 1130 {
 1131         int error, slash_prefixed;
 1132 #ifdef KDTRACE_HOOKS
 1133         struct vnode *startvp = vp;
 1134 #endif
 1135 
 1136         buflen--;
 1137         buf[buflen] = '\0';
 1138         error = 0;
 1139         slash_prefixed = 0;
 1140 
 1141         SDT_PROBE(vfs, namecache, fullpath, entry, vp, 0, 0, 0, 0);
 1142         numfullpathcalls++;
 1143         CACHE_RLOCK();
 1144         if (vp->v_type != VDIR) {
 1145                 error = vn_vptocnp_locked(&vp, td->td_ucred, buf, &buflen);
 1146                 if (error)
 1147                         return (error);
 1148                 if (buflen == 0) {
 1149                         CACHE_RUNLOCK();
 1150                         return (ENOMEM);
 1151                 }
 1152                 buf[--buflen] = '/';
 1153                 slash_prefixed = 1;
 1154         }
 1155         while (vp != rdir && vp != rootvnode) {
 1156                 if (vp->v_vflag & VV_ROOT) {
 1157                         if (vp->v_iflag & VI_DOOMED) {  /* forced unmount */
 1158                                 CACHE_RUNLOCK();
 1159                                 error = ENOENT;
 1160                                 SDT_PROBE(vfs, namecache, fullpath, return,
 1161                                     error, vp, NULL, 0, 0);
 1162                                 break;
 1163                         }
 1164                         vp = vp->v_mount->mnt_vnodecovered;
 1165                         continue;
 1166                 }
 1167                 if (vp->v_type != VDIR) {
 1168                         CACHE_RUNLOCK();
 1169                         numfullpathfail1++;
 1170                         error = ENOTDIR;
 1171                         SDT_PROBE(vfs, namecache, fullpath, return,
 1172                             error, vp, NULL, 0, 0);
 1173                         break;
 1174                 }
 1175                 error = vn_vptocnp_locked(&vp, td->td_ucred, buf, &buflen);
 1176                 if (error)
 1177                         break;
 1178                 if (buflen == 0) {
 1179                         CACHE_RUNLOCK();
 1180                         error = ENOMEM;
 1181                         SDT_PROBE(vfs, namecache, fullpath, return, error,
 1182                             startvp, NULL, 0, 0);
 1183                         break;
 1184                 }
 1185                 buf[--buflen] = '/';
 1186                 slash_prefixed = 1;
 1187         }
 1188         if (error)
 1189                 return (error);
 1190         if (!slash_prefixed) {
 1191                 if (buflen == 0) {
 1192                         CACHE_RUNLOCK();
 1193                         numfullpathfail4++;
 1194                         SDT_PROBE(vfs, namecache, fullpath, return, ENOMEM,
 1195                             startvp, NULL, 0, 0);
 1196                         return (ENOMEM);
 1197                 }
 1198                 buf[--buflen] = '/';
 1199         }
 1200         numfullpathfound++;
 1201         CACHE_RUNLOCK();
 1202 
 1203         SDT_PROBE(vfs, namecache, fullpath, return, 0, startvp, buf + buflen,
 1204             0, 0);
 1205         *retbuf = buf + buflen;
 1206         return (0);
 1207 }
 1208 
 1209 int
 1210 vn_commname(struct vnode *vp, char *buf, u_int buflen)
 1211 {
 1212         struct namecache *ncp;
 1213         int l;
 1214 
 1215         CACHE_RLOCK();
 1216         TAILQ_FOREACH(ncp, &vp->v_cache_dst, nc_dst)
 1217                 if ((ncp->nc_flag & NCF_ISDOTDOT) == 0)
 1218                         break;
 1219         if (ncp == NULL) {
 1220                 CACHE_RUNLOCK();
 1221                 return (ENOENT);
 1222         }
 1223         l = min(ncp->nc_nlen, buflen - 1);
 1224         memcpy(buf, ncp->nc_name, l);
 1225         CACHE_RUNLOCK();
 1226         buf[l] = '\0';
 1227         return (0);
 1228 }

Cache object: 89d28796c1350236d4c3f101627bc99a


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.