[BACK]Return to subr_pool.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / kern

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/kern/subr_pool.c between version 1.198.2.3 and 1.199

version 1.198.2.3, 2014/08/20 00:04:29 version 1.199, 2013/02/09 00:31:21
Line 1 
Line 1 
 /*      $NetBSD$        */  /*      $NetBSD$        */
   
 /*-  /*-
  * Copyright (c) 1997, 1999, 2000, 2002, 2007, 2008, 2010, 2014   * Copyright (c) 1997, 1999, 2000, 2002, 2007, 2008, 2010
  *     The NetBSD Foundation, Inc.   *     The NetBSD Foundation, Inc.
  * All rights reserved.   * All rights reserved.
  *   *
Line 39  __KERNEL_RCSID(0, "$NetBSD$");
Line 39  __KERNEL_RCSID(0, "$NetBSD$");
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/systm.h>  #include <sys/systm.h>
 #include <sys/sysctl.h>  
 #include <sys/bitops.h>  #include <sys/bitops.h>
 #include <sys/proc.h>  #include <sys/proc.h>
 #include <sys/errno.h>  #include <sys/errno.h>
Line 68  __KERNEL_RCSID(0, "$NetBSD$");
Line 67  __KERNEL_RCSID(0, "$NetBSD$");
  * an internal pool of page headers (`phpool').   * an internal pool of page headers (`phpool').
  */   */
   
 /* List of all pools. Non static as needed by 'vmstat -i' */  /* List of all pools */
 TAILQ_HEAD(, pool) pool_head = TAILQ_HEAD_INITIALIZER(pool_head);  static TAILQ_HEAD(, pool) pool_head = TAILQ_HEAD_INITIALIZER(pool_head);
   
 /* Private pool for page header structures */  /* Private pool for page header structures */
 #define PHPOOL_MAX      8  #define PHPOOL_MAX      8
Line 562  pool_init(struct pool *pp, size_t size, 
Line 561  pool_init(struct pool *pp, size_t size, 
         /* See the comment below about reserved bytes. */          /* See the comment below about reserved bytes. */
         trysize = palloc->pa_pagesz - ((align - ioff) % align);          trysize = palloc->pa_pagesz - ((align - ioff) % align);
         phsize = ALIGN(sizeof(struct pool_item_header));          phsize = ALIGN(sizeof(struct pool_item_header));
         if (pp->pr_roflags & PR_PHINPAGE ||          if ((pp->pr_roflags & (PR_NOTOUCH | PR_NOALIGN)) == 0 &&
             ((pp->pr_roflags & (PR_NOTOUCH | PR_NOALIGN)) == 0 &&  
             (pp->pr_size < MIN(palloc->pa_pagesz / 16, phsize << 3) ||              (pp->pr_size < MIN(palloc->pa_pagesz / 16, phsize << 3) ||
             trysize / pp->pr_size == (trysize - phsize) / pp->pr_size))) {              trysize / pp->pr_size == (trysize - phsize) / pp->pr_size)) {
                 /* Use the end of the page for the page header */                  /* Use the end of the page for the page header */
                 pp->pr_roflags |= PR_PHINPAGE;                  pp->pr_roflags |= PR_PHINPAGE;
                 pp->pr_phoffset = off = palloc->pa_pagesz - phsize;                  pp->pr_phoffset = off = palloc->pa_pagesz - phsize;
Line 2263  pool_cache_get_paddr(pool_cache_t pc, in
Line 2261  pool_cache_get_paddr(pool_cache_t pc, in
 static bool __noinline  static bool __noinline
 pool_cache_put_slow(pool_cache_cpu_t *cc, int s, void *object)  pool_cache_put_slow(pool_cache_cpu_t *cc, int s, void *object)
 {  {
         struct lwp *l = curlwp;  
         pcg_t *pcg, *cur;          pcg_t *pcg, *cur;
         uint64_t ncsw;          uint64_t ncsw;
         pool_cache_t pc;          pool_cache_t pc;
Line 2274  pool_cache_put_slow(pool_cache_cpu_t *cc
Line 2271  pool_cache_put_slow(pool_cache_cpu_t *cc
         pc = cc->cc_cache;          pc = cc->cc_cache;
         pcg = NULL;          pcg = NULL;
         cc->cc_misses++;          cc->cc_misses++;
         ncsw = l->l_ncsw;  
   
         /*          /*
          * If there are no empty groups in the cache then allocate one           * If there are no empty groups in the cache then allocate one
Line 2284  pool_cache_put_slow(pool_cache_cpu_t *cc
Line 2280  pool_cache_put_slow(pool_cache_cpu_t *cc
                 if (__predict_true(!pool_cache_disable)) {                  if (__predict_true(!pool_cache_disable)) {
                         pcg = pool_get(pc->pc_pcgpool, PR_NOWAIT);                          pcg = pool_get(pc->pc_pcgpool, PR_NOWAIT);
                 }                  }
                 /*  
                  * If pool_get() blocked, then our view of  
                  * the per-CPU data is invalid: retry.  
                  */  
                 if (__predict_false(l->l_ncsw != ncsw)) {  
                         if (pcg != NULL) {  
                                 pool_put(pc->pc_pcgpool, pcg);  
                         }  
                         return true;  
                 }  
                 if (__predict_true(pcg != NULL)) {                  if (__predict_true(pcg != NULL)) {
                         pcg->pcg_avail = 0;                          pcg->pcg_avail = 0;
                         pcg->pcg_size = pc->pc_pcgsize;                          pcg->pcg_size = pc->pc_pcgsize;
Line 2302  pool_cache_put_slow(pool_cache_cpu_t *cc
Line 2288  pool_cache_put_slow(pool_cache_cpu_t *cc
   
         /* Lock the cache. */          /* Lock the cache. */
         if (__predict_false(!mutex_tryenter(&pc->pc_lock))) {          if (__predict_false(!mutex_tryenter(&pc->pc_lock))) {
                   ncsw = curlwp->l_ncsw;
                 mutex_enter(&pc->pc_lock);                  mutex_enter(&pc->pc_lock);
                 pc->pc_contended++;                  pc->pc_contended++;
   
Line 2309  pool_cache_put_slow(pool_cache_cpu_t *cc
Line 2296  pool_cache_put_slow(pool_cache_cpu_t *cc
                  * If we context switched while locking, then our view of                   * If we context switched while locking, then our view of
                  * the per-CPU data is invalid: retry.                   * the per-CPU data is invalid: retry.
                  */                   */
                 if (__predict_false(l->l_ncsw != ncsw)) {                  if (__predict_false(curlwp->l_ncsw != ncsw)) {
                         mutex_exit(&pc->pc_lock);                          mutex_exit(&pc->pc_lock);
                         if (pcg != NULL) {                          if (pcg != NULL) {
                                 pool_put(pc->pc_pcgpool, pcg);                                  pool_put(pc->pc_pcgpool, pcg);
Line 2752  print:
Line 2739  print:
         }          }
 }  }
 #endif /* defined(DDB) */  #endif /* defined(DDB) */
   
 static int  
 pool_sysctl(SYSCTLFN_ARGS)  
 {  
         struct pool_sysctl data;  
         struct pool *pp;  
         struct pool_cache *pc;  
         pool_cache_cpu_t *cc;  
         int error;  
         size_t i, written;  
   
         if (oldp == NULL) {  
                 *oldlenp = 0;  
                 TAILQ_FOREACH(pp, &pool_head, pr_poollist)  
                         *oldlenp += sizeof(data);  
                 return 0;  
         }  
   
         memset(&data, 0, sizeof(data));  
         error = 0;  
         written = 0;  
         TAILQ_FOREACH(pp, &pool_head, pr_poollist) {  
                 if (written + sizeof(data) > *oldlenp)  
                         break;  
                 strlcpy(data.pr_wchan, pp->pr_wchan, sizeof(data.pr_wchan));  
                 data.pr_pagesize = pp->pr_alloc->pa_pagesz;  
                 data.pr_flags = pp->pr_roflags | pp->pr_flags;  
 #define COPY(field) data.field = pp->field  
                 COPY(pr_size);  
   
                 COPY(pr_itemsperpage);  
                 COPY(pr_nitems);  
                 COPY(pr_nout);  
                 COPY(pr_hardlimit);  
                 COPY(pr_npages);  
                 COPY(pr_minpages);  
                 COPY(pr_maxpages);  
   
                 COPY(pr_nget);  
                 COPY(pr_nfail);  
                 COPY(pr_nput);  
                 COPY(pr_npagealloc);  
                 COPY(pr_npagefree);  
                 COPY(pr_hiwat);  
                 COPY(pr_nidle);  
 #undef COPY  
   
                 data.pr_cache_nmiss_pcpu = 0;  
                 data.pr_cache_nhit_pcpu = 0;  
                 if (pp->pr_cache) {  
                         pc = pp->pr_cache;  
                         data.pr_cache_meta_size = pc->pc_pcgsize;  
                         data.pr_cache_nfull = pc->pc_nfull;  
                         data.pr_cache_npartial = pc->pc_npart;  
                         data.pr_cache_nempty = pc->pc_nempty;  
                         data.pr_cache_ncontended = pc->pc_contended;  
                         data.pr_cache_nmiss_global = pc->pc_misses;  
                         data.pr_cache_nhit_global = pc->pc_hits;  
                         for (i = 0; i < pc->pc_ncpu; ++i) {  
                                 cc = pc->pc_cpus[i];  
                                 if (cc == NULL)  
                                         continue;  
                                 data.pr_cache_nmiss_pcpu = cc->cc_misses;  
                                 data.pr_cache_nhit_pcpu = cc->cc_hits;  
                         }  
                 } else {  
                         data.pr_cache_meta_size = 0;  
                         data.pr_cache_nfull = 0;  
                         data.pr_cache_npartial = 0;  
                         data.pr_cache_nempty = 0;  
                         data.pr_cache_ncontended = 0;  
                         data.pr_cache_nmiss_global = 0;  
                         data.pr_cache_nhit_global = 0;  
                 }  
   
                 error = sysctl_copyout(l, &data, oldp, sizeof(data));  
                 if (error)  
                         break;  
                 written += sizeof(data);  
                 oldp = (char *)oldp + sizeof(data);  
         }  
   
         *oldlenp = written;  
         return error;  
 }  
   
 SYSCTL_SETUP(sysctl_pool_setup, "sysctl kern.pool setup")  
 {  
         const struct sysctlnode *rnode = NULL;  
   
         sysctl_createv(clog, 0, NULL, &rnode,  
                        CTLFLAG_PERMANENT,  
                        CTLTYPE_STRUCT, "pool",  
                        SYSCTL_DESCR("Get pool statistics"),  
                        pool_sysctl, 0, NULL, 0,  
                        CTL_KERN, CTL_CREATE, CTL_EOL);  
 }  

Legend:
Removed from v.1.198.2.3  
changed lines
  Added in v.1.199

CVSweb <webmaster@jp.NetBSD.org>