Diff for /src/sys/kern/vfs_cache.c between versions 1.13 and 1.14

version 1.13, 2004/03/01 06:33:17 version 1.14, 2004/04/02 05:46:02
Line 52 Line 52
 #include <sys/namei.h>  #include <sys/namei.h>
 #include <sys/filedesc.h>  #include <sys/filedesc.h>
 #include <sys/fnv_hash.h>  #include <sys/fnv_hash.h>
   #include <sys/globaldata.h>
   
 /*  /*
  * Random lookups in the cache are accomplished with a hash table using   * Random lookups in the cache are accomplished with a hash table using
Line 73 Line 74
 #define NCHHASH(hash)   (&nchashtbl[(hash) & nchash])  #define NCHHASH(hash)   (&nchashtbl[(hash) & nchash])
 #define MINNEG          1024  #define MINNEG          1024
   
   MALLOC_DEFINE(M_VFSCACHE, "vfscache", "VFS name cache entries");
   
 static LIST_HEAD(nchashhead, namecache) *nchashtbl;     /* Hash Table */  static LIST_HEAD(nchashhead, namecache) *nchashtbl;     /* Hash Table */
 static struct namecache_list    ncneglist;              /* instead of vnode */  static struct namecache_list    ncneglist;              /* instead of vnode */
 static struct namecache         rootnamecache;          /* Dummy node */  static struct namecache         rootnamecache;          /* Dummy node */
Line 95  SYSCTL_ULONG(_debug, OID_AUTO, numcache, Line 98  SYSCTL_ULONG(_debug, OID_AUTO, numcache,
 static u_long   numunres;               /* number of unresolved entries */  static u_long   numunres;               /* number of unresolved entries */
 SYSCTL_ULONG(_debug, OID_AUTO, numunres, CTLFLAG_RD, &numunres, 0, "");  SYSCTL_ULONG(_debug, OID_AUTO, numunres, CTLFLAG_RD, &numunres, 0, "");
   
 struct  nchstats nchstats;              /* cache effectiveness statistics */  
   
 SYSCTL_INT(_debug, OID_AUTO, vnsize, CTLFLAG_RD, 0, sizeof(struct vnode), "");  SYSCTL_INT(_debug, OID_AUTO, vnsize, CTLFLAG_RD, 0, sizeof(struct vnode), "");
 SYSCTL_INT(_debug, OID_AUTO, ncsize, CTLFLAG_RD, 0, sizeof(struct namecache), "");  SYSCTL_INT(_debug, OID_AUTO, ncsize, CTLFLAG_RD, 0, sizeof(struct namecache), "");
   
Line 119  static u_long numposhits; STATNODE(CTLFL Line 120  static u_long numposhits; STATNODE(CTLFL
 static u_long numnegzaps; STATNODE(CTLFLAG_RD, numnegzaps, &numnegzaps);  static u_long numnegzaps; STATNODE(CTLFLAG_RD, numnegzaps, &numnegzaps);
 static u_long numneghits; STATNODE(CTLFLAG_RD, numneghits, &numneghits);  static u_long numneghits; STATNODE(CTLFLAG_RD, numneghits, &numneghits);
   
   struct nchstats nchstats[SMP_MAXCPU];
   /*
    * Export VFS cache effectiveness statistics to user-land.
    *
    * The statistics are left for aggregation to user-land so
    * neat things can be achieved, like observing per-CPU cache
    * distribution.
    */
   static int
   nchstats_agg(SYSCTL_HANDLER_ARGS)
   {
           struct globaldata *gd;
           int i, error;
   
static void cache_zap(struct namecache *ncp);        error = 0;
         for (i = 0; i < ncpus; ++i) {
                 gd = globaldata_find(i);
                 if ((error = SYSCTL_OUT(req, (void *)&(*gd->gd_nchstats),
                         sizeof(struct nchstats))))
                         break;
         }
   
MALLOC_DEFINE(M_VFSCACHE, "vfscache", "VFS name cache entries");        return (error);
 }
 SYSCTL_PROC(_vfs_cache, OID_AUTO, nchstats, CTLTYPE_OPAQUE|CTLFLAG_RD,
   0, 0, nchstats_agg, "S,nchstats", "VFS cache effectiveness statistics");
 
 static void cache_zap(struct namecache *ncp);
   
 /*  /*
  * cache_hold() and cache_drop() prevent the premature deletion of a   * cache_hold() and cache_drop() prevent the premature deletion of a
Line 284  cache_lookup(struct vnode *dvp, struct n Line 309  cache_lookup(struct vnode *dvp, struct n
 {  {
         struct namecache *ncp;          struct namecache *ncp;
         u_int32_t hash;          u_int32_t hash;
           globaldata_t gd = mycpu;
   
         numcalls++;          numcalls++;
   
Line 330  cache_lookup(struct vnode *dvp, struct n Line 356  cache_lookup(struct vnode *dvp, struct n
                 } else {                  } else {
                         nummiss++;                          nummiss++;
                 }                  }
                nchstats.ncs_miss++;                gd->gd_nchstats->ncs_miss++;
                 return (0);                  return (0);
         }          }
   
         /* We don't want to have an entry, so dump it */          /* We don't want to have an entry, so dump it */
         if ((cnp->cn_flags & CNP_MAKEENTRY) == 0) {          if ((cnp->cn_flags & CNP_MAKEENTRY) == 0) {
                 numposzaps++;                  numposzaps++;
                nchstats.ncs_badhits++;                gd->gd_nchstats->ncs_badhits++;
                 cache_zap(ncp);                  cache_zap(ncp);
                 return (0);                  return (0);
         }          }
Line 345  cache_lookup(struct vnode *dvp, struct n Line 371  cache_lookup(struct vnode *dvp, struct n
         /* We found a "positive" match, return the vnode */          /* We found a "positive" match, return the vnode */
         if (ncp->nc_vp) {          if (ncp->nc_vp) {
                 numposhits++;                  numposhits++;
                nchstats.ncs_goodhits++;                gd->gd_nchstats->ncs_goodhits++;
                 *vpp = ncp->nc_vp;                  *vpp = ncp->nc_vp;
                 cache_drop(ncp);                  cache_drop(ncp);
                 return (-1);                  return (-1);
Line 354  cache_lookup(struct vnode *dvp, struct n Line 380  cache_lookup(struct vnode *dvp, struct n
         /* We found a negative match, and want to create it, so purge */          /* We found a negative match, and want to create it, so purge */
         if (cnp->cn_nameiop == NAMEI_CREATE) {          if (cnp->cn_nameiop == NAMEI_CREATE) {
                 numnegzaps++;                  numnegzaps++;
                nchstats.ncs_badhits++;                gd->gd_nchstats->ncs_badhits++;
                 cache_zap(ncp);                  cache_zap(ncp);
                 return (0);                  return (0);
         }          }
Line 368  cache_lookup(struct vnode *dvp, struct n Line 394  cache_lookup(struct vnode *dvp, struct n
          */           */
         TAILQ_REMOVE(&ncneglist, ncp, nc_vnode);          TAILQ_REMOVE(&ncneglist, ncp, nc_vnode);
         TAILQ_INSERT_TAIL(&ncneglist, ncp, nc_vnode);          TAILQ_INSERT_TAIL(&ncneglist, ncp, nc_vnode);
        nchstats.ncs_neghits++;        gd->gd_nchstats->ncs_neghits++;
         if (ncp->nc_flag & NCF_WHITEOUT)          if (ncp->nc_flag & NCF_WHITEOUT)
                 cnp->cn_flags |= CNP_ISWHITEOUT;                  cnp->cn_flags |= CNP_ISWHITEOUT;
         cache_drop(ncp);          cache_drop(ncp);
Line 578  again: Line 604  again:
 }  }
   
 /*  /*
 * Name cache initialization, from vfs_init() when we are booting * Name cache initialization, from vfsinit() when we are booting
  *   *
  * rootnamecache is initialized such that it cannot be recursively deleted.   * rootnamecache is initialized such that it cannot be recursively deleted.
  */   */
 void  void
 nchinit(void)  nchinit(void)
 {  {
           int i;
           globaldata_t gd;
   
           /* initialise per-cpu namecache effectiveness statistics. */
           for (i = 0; i < ncpus; ++i) {
                   gd = globaldata_find(i);
                   gd->gd_nchstats = &nchstats[i];
           }
           
         TAILQ_INIT(&ncneglist);          TAILQ_INIT(&ncneglist);
         nchashtbl = hashinit(desiredvnodes*2, M_VFSCACHE, &nchash);          nchashtbl = hashinit(desiredvnodes*2, M_VFSCACHE, &nchash);
         TAILQ_INIT(&rootnamecache.nc_list);          TAILQ_INIT(&rootnamecache.nc_list);

Removed from v.1.13  
changed lines
  Added in v.1.14