[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.203.4.3 and 1.204

version 1.203.4.3, 2017/08/28 17:53:07 version 1.204, 2015/07/28 12:32:44
Line 35 
Line 35 
 #include <sys/cdefs.h>  #include <sys/cdefs.h>
 __KERNEL_RCSID(0, "$NetBSD$");  __KERNEL_RCSID(0, "$NetBSD$");
   
 #ifdef _KERNEL_OPT  
 #include "opt_ddb.h"  #include "opt_ddb.h"
 #include "opt_lockdebug.h"  #include "opt_lockdebug.h"
 #endif  
   
 #include <sys/param.h>  #include <sys/param.h>
 #include <sys/systm.h>  #include <sys/systm.h>
Line 106  struct pool_allocator pool_allocator_met
Line 104  struct pool_allocator pool_allocator_met
         .pa_pagesz = 0          .pa_pagesz = 0
 };  };
   
 #define POOL_ALLOCATOR_BIG_BASE 13  
 extern struct pool_allocator pool_allocator_big[];  
 static int pool_bigidx(size_t);  
   
 /* # of seconds to retain page after last use */  /* # of seconds to retain page after last use */
 int pool_inactive_time = 10;  int pool_inactive_time = 10;
   
Line 386  pr_rmpage(struct pool *pp, struct pool_i
Line 380  pr_rmpage(struct pool *pp, struct pool_i
          * If the page was idle, decrement the idle page count.           * If the page was idle, decrement the idle page count.
          */           */
         if (ph->ph_nmissing == 0) {          if (ph->ph_nmissing == 0) {
                 KASSERT(pp->pr_nidle != 0);  #ifdef DIAGNOSTIC
                 KASSERTMSG((pp->pr_nitems >= pp->pr_itemsperpage),                  if (pp->pr_nidle == 0)
                     "nitems=%u < itemsperpage=%u",                          panic("pr_rmpage: nidle inconsistent");
                     pp->pr_nitems, pp->pr_itemsperpage);                  if (pp->pr_nitems < pp->pr_itemsperpage)
                           panic("pr_rmpage: nitems inconsistent");
   #endif
                 pp->pr_nidle--;                  pp->pr_nidle--;
         }          }
   
Line 527  pool_init(struct pool *pp, size_t size, 
Line 523  pool_init(struct pool *pp, size_t size, 
                 prsize = sizeof(struct pool_item);                  prsize = sizeof(struct pool_item);
   
         prsize = roundup(prsize, align);          prsize = roundup(prsize, align);
         KASSERTMSG((prsize <= palloc->pa_pagesz),  #ifdef DIAGNOSTIC
             "pool_init: pool item size (%zu) larger than page size (%u)",          if (prsize > palloc->pa_pagesz)
             prsize, palloc->pa_pagesz);                  panic("pool_init: pool item size (%zu) too large", prsize);
   #endif
   
         /*          /*
          * Initialize the pool structure.           * Initialize the pool structure.
Line 699  pool_destroy(struct pool *pp)
Line 696  pool_destroy(struct pool *pp)
         mutex_enter(&pp->pr_lock);          mutex_enter(&pp->pr_lock);
   
         KASSERT(pp->pr_cache == NULL);          KASSERT(pp->pr_cache == NULL);
         KASSERTMSG((pp->pr_nout == 0),  
             "pool_destroy: pool busy: still out: %u", pp->pr_nout);  #ifdef DIAGNOSTIC
           if (pp->pr_nout != 0) {
                   panic("pool_destroy: pool busy: still out: %u",
                       pp->pr_nout);
           }
   #endif
   
         KASSERT(LIST_EMPTY(&pp->pr_fullpages));          KASSERT(LIST_EMPTY(&pp->pr_fullpages));
         KASSERT(LIST_EMPTY(&pp->pr_partpages));          KASSERT(LIST_EMPTY(&pp->pr_partpages));
   
Line 721  pool_set_drain_hook(struct pool *pp, voi
Line 724  pool_set_drain_hook(struct pool *pp, voi
 {  {
   
         /* XXX no locking -- must be used just after pool_init() */          /* XXX no locking -- must be used just after pool_init() */
         KASSERTMSG((pp->pr_drain_hook == NULL),  #ifdef DIAGNOSTIC
             "pool_set_drain_hook(%s): already set", pp->pr_wchan);          if (pp->pr_drain_hook != NULL)
                   panic("pool_set_drain_hook(%s): already set", pp->pr_wchan);
   #endif
         pp->pr_drain_hook = fn;          pp->pr_drain_hook = fn;
         pp->pr_drain_hook_arg = arg;          pp->pr_drain_hook_arg = arg;
 }  }
Line 750  pool_get(struct pool *pp, int flags)
Line 755  pool_get(struct pool *pp, int flags)
         struct pool_item_header *ph;          struct pool_item_header *ph;
         void *v;          void *v;
   
         KASSERTMSG((pp->pr_itemsperpage != 0),  #ifdef DIAGNOSTIC
             "pool_get: pool '%s': pr_itemsperpage is zero, "          if (pp->pr_itemsperpage == 0)
             "pool not initialized?", pp->pr_wchan);                  panic("pool_get: pool '%s': pr_itemsperpage is zero, "
         KASSERTMSG((!(cpu_intr_p() || cpu_softintr_p())                      "pool not initialized?", pp->pr_wchan);
                 || pp->pr_ipl != IPL_NONE || cold || panicstr != NULL),          if ((cpu_intr_p() || cpu_softintr_p()) && pp->pr_ipl == IPL_NONE &&
             "pool '%s' is IPL_NONE, but called from interrupt context",              !cold && panicstr == NULL)
             pp->pr_wchan);                  panic("pool '%s' is IPL_NONE, but called from "
                       "interrupt context\n", pp->pr_wchan);
   #endif
         if (flags & PR_WAITOK) {          if (flags & PR_WAITOK) {
                 ASSERT_SLEEPABLE();                  ASSERT_SLEEPABLE();
         }          }
Line 768  pool_get(struct pool *pp, int flags)
Line 775  pool_get(struct pool *pp, int flags)
          * and we can wait, then wait until an item has been returned to           * and we can wait, then wait until an item has been returned to
          * the pool.           * the pool.
          */           */
         KASSERTMSG((pp->pr_nout <= pp->pr_hardlimit),  #ifdef DIAGNOSTIC
             "pool_get: %s: crossed hard limit", pp->pr_wchan);          if (__predict_false(pp->pr_nout > pp->pr_hardlimit)) {
                   mutex_exit(&pp->pr_lock);
                   panic("pool_get: %s: crossed hard limit", pp->pr_wchan);
           }
   #endif
         if (__predict_false(pp->pr_nout == pp->pr_hardlimit)) {          if (__predict_false(pp->pr_nout == pp->pr_hardlimit)) {
                 if (pp->pr_drain_hook != NULL) {                  if (pp->pr_drain_hook != NULL) {
                         /*                          /*
Line 817  pool_get(struct pool *pp, int flags)
Line 828  pool_get(struct pool *pp, int flags)
         if ((ph = pp->pr_curpage) == NULL) {          if ((ph = pp->pr_curpage) == NULL) {
                 int error;                  int error;
   
                 KASSERTMSG((pp->pr_nitems == 0),  #ifdef DIAGNOSTIC
                     "pool_get: nitems inconsistent"                  if (pp->pr_nitems != 0) {
                     ": %s: curpage NULL, nitems %u",                          mutex_exit(&pp->pr_lock);
                     pp->pr_wchan, pp->pr_nitems);                          printf("pool_get: %s: curpage NULL, nitems %u\n",
                               pp->pr_wchan, pp->pr_nitems);
                           panic("pool_get: nitems inconsistent");
                   }
   #endif
   
                 /*                  /*
                  * Call the back-end page allocator for more memory.                   * Call the back-end page allocator for more memory.
Line 847  pool_get(struct pool *pp, int flags)
Line 862  pool_get(struct pool *pp, int flags)
                 goto startover;                  goto startover;
         }          }
         if (pp->pr_roflags & PR_NOTOUCH) {          if (pp->pr_roflags & PR_NOTOUCH) {
                 KASSERTMSG((ph->ph_nmissing < pp->pr_itemsperpage),  #ifdef DIAGNOSTIC
                     "pool_get: %s: page empty", pp->pr_wchan);                  if (__predict_false(ph->ph_nmissing == pp->pr_itemsperpage)) {
                           mutex_exit(&pp->pr_lock);
                           panic("pool_get: %s: page empty", pp->pr_wchan);
                   }
   #endif
                 v = pr_item_notouch_get(pp, ph);                  v = pr_item_notouch_get(pp, ph);
         } else {          } else {
                 v = pi = LIST_FIRST(&ph->ph_itemlist);                  v = pi = LIST_FIRST(&ph->ph_itemlist);
Line 856  pool_get(struct pool *pp, int flags)
Line 875  pool_get(struct pool *pp, int flags)
                         mutex_exit(&pp->pr_lock);                          mutex_exit(&pp->pr_lock);
                         panic("pool_get: %s: page empty", pp->pr_wchan);                          panic("pool_get: %s: page empty", pp->pr_wchan);
                 }                  }
                 KASSERTMSG((pp->pr_nitems > 0),  #ifdef DIAGNOSTIC
                     "pool_get: nitems inconsistent"                  if (__predict_false(pp->pr_nitems == 0)) {
                     ": %s: items on itemlist, nitems %u",                          mutex_exit(&pp->pr_lock);
                     pp->pr_wchan, pp->pr_nitems);                          printf("pool_get: %s: items on itemlist, nitems %u\n",
                 KASSERTMSG((pi->pi_magic == PI_MAGIC),                              pp->pr_wchan, pp->pr_nitems);
                     "pool_get(%s): free list modified: "                          panic("pool_get: nitems inconsistent");
                     "magic=%x; page %p; item addr %p",                  }
                     pp->pr_wchan, pi->pi_magic, ph->ph_page, pi);  #endif
   
   #ifdef DIAGNOSTIC
                   if (__predict_false(pi->pi_magic != PI_MAGIC)) {
                           panic("pool_get(%s): free list modified: "
                               "magic=%x; page %p; item addr %p\n",
                               pp->pr_wchan, pi->pi_magic, ph->ph_page, pi);
                   }
   #endif
   
                 /*                  /*
                  * Remove from item list.                   * Remove from item list.
Line 873  pool_get(struct pool *pp, int flags)
Line 900  pool_get(struct pool *pp, int flags)
         pp->pr_nitems--;          pp->pr_nitems--;
         pp->pr_nout++;          pp->pr_nout++;
         if (ph->ph_nmissing == 0) {          if (ph->ph_nmissing == 0) {
                 KASSERT(pp->pr_nidle > 0);  #ifdef DIAGNOSTIC
                   if (__predict_false(pp->pr_nidle == 0))
                           panic("pool_get: nidle inconsistent");
   #endif
                 pp->pr_nidle--;                  pp->pr_nidle--;
   
                 /*                  /*
Line 885  pool_get(struct pool *pp, int flags)
Line 915  pool_get(struct pool *pp, int flags)
         }          }
         ph->ph_nmissing++;          ph->ph_nmissing++;
         if (ph->ph_nmissing == pp->pr_itemsperpage) {          if (ph->ph_nmissing == pp->pr_itemsperpage) {
                 KASSERTMSG(((pp->pr_roflags & PR_NOTOUCH) ||  #ifdef DIAGNOSTIC
                         LIST_EMPTY(&ph->ph_itemlist)),                  if (__predict_false((pp->pr_roflags & PR_NOTOUCH) == 0 &&
                     "pool_get: %s: nmissing inconsistent", pp->pr_wchan);                      !LIST_EMPTY(&ph->ph_itemlist))) {
                           mutex_exit(&pp->pr_lock);
                           panic("pool_get: %s: nmissing inconsistent",
                               pp->pr_wchan);
                   }
   #endif
                 /*                  /*
                  * This page is now full.  Move it to the full list                   * This page is now full.  Move it to the full list
                  * and select a new current page.                   * and select a new current page.
Line 932  pool_do_put(struct pool *pp, void *v, st
Line 967  pool_do_put(struct pool *pp, void *v, st
         FREECHECK_IN(&pp->pr_freecheck, v);          FREECHECK_IN(&pp->pr_freecheck, v);
         LOCKDEBUG_MEM_CHECK(v, pp->pr_size);          LOCKDEBUG_MEM_CHECK(v, pp->pr_size);
   
         KASSERTMSG((pp->pr_nout > 0),  #ifdef DIAGNOSTIC
             "pool_put: pool %s: putting with none out", pp->pr_wchan);          if (__predict_false(pp->pr_nout == 0)) {
                   printf("pool %s: putting with none out\n",
                       pp->pr_wchan);
                   panic("pool_put");
           }
   #endif
   
         if (__predict_false((ph = pr_find_pagehead(pp, v)) == NULL)) {          if (__predict_false((ph = pr_find_pagehead(pp, v)) == NULL)) {
                 panic("pool_put: %s: page header missing", pp->pr_wchan);                  panic("pool_put: %s: page header missing", pp->pr_wchan);
Line 1114  pool_prime_page(struct pool *pp, void *s
Line 1154  pool_prime_page(struct pool *pp, void *s
         int n;          int n;
   
         KASSERT(mutex_owned(&pp->pr_lock));          KASSERT(mutex_owned(&pp->pr_lock));
         KASSERTMSG(((pp->pr_roflags & PR_NOALIGN) ||  
                 (((uintptr_t)cp & (pp->pr_alloc->pa_pagesz - 1)) == 0)),  #ifdef DIAGNOSTIC
             "pool_prime_page: %s: unaligned page: %p", pp->pr_wchan, cp);          if ((pp->pr_roflags & PR_NOALIGN) == 0 &&
               ((uintptr_t)cp & (pp->pr_alloc->pa_pagesz - 1)) != 0)
                   panic("pool_prime_page: %s: unaligned page", pp->pr_wchan);
   #endif
   
         /*          /*
          * Insert page header.           * Insert page header.
Line 1442  pool_print_pagelist(struct pool *pp, str
Line 1485  pool_print_pagelist(struct pool *pp, str
     void (*pr)(const char *, ...))      void (*pr)(const char *, ...))
 {  {
         struct pool_item_header *ph;          struct pool_item_header *ph;
         struct pool_item *pi __diagused;  #ifdef DIAGNOSTIC
           struct pool_item *pi;
   #endif
   
         LIST_FOREACH(ph, pl, ph_pagelist) {          LIST_FOREACH(ph, pl, ph_pagelist) {
                 (*pr)("\t\tpage %p, nmissing %d, time %" PRIu32 "\n",                  (*pr)("\t\tpage %p, nmissing %d, time %" PRIu32 "\n",
Line 1704  pool_cache_bootstrap(pool_cache_t pc, si
Line 1749  pool_cache_bootstrap(pool_cache_t pc, si
         struct pool *pp;          struct pool *pp;
   
         pp = &pc->pc_pool;          pp = &pc->pc_pool;
         if (palloc == NULL && ipl == IPL_NONE) {          if (palloc == NULL && ipl == IPL_NONE)
                 if (size > PAGE_SIZE) {                  palloc = &pool_allocator_nointr;
                         int bigidx = pool_bigidx(size);  
   
                         palloc = &pool_allocator_big[bigidx];  
                 } else  
                         palloc = &pool_allocator_nointr;  
         }  
         pool_init(pp, size, align, align_offset, flags, wchan, palloc, ipl);          pool_init(pp, size, align, align_offset, flags, wchan, palloc, ipl);
         mutex_init(&pc->pc_lock, MUTEX_DEFAULT, ipl);          mutex_init(&pc->pc_lock, MUTEX_DEFAULT, ipl);
   
Line 2508  struct pool_allocator pool_allocator_noi
Line 2547  struct pool_allocator pool_allocator_noi
 };  };
 #endif /* POOL_SUBPAGE */  #endif /* POOL_SUBPAGE */
   
 struct pool_allocator pool_allocator_big[] = {  
         {  
                 .pa_alloc = pool_page_alloc,  
                 .pa_free = pool_page_free,  
                 .pa_pagesz = 1 << (POOL_ALLOCATOR_BIG_BASE + 0),  
         },  
         {  
                 .pa_alloc = pool_page_alloc,  
                 .pa_free = pool_page_free,  
                 .pa_pagesz = 1 << (POOL_ALLOCATOR_BIG_BASE + 1),  
         },  
         {  
                 .pa_alloc = pool_page_alloc,  
                 .pa_free = pool_page_free,  
                 .pa_pagesz = 1 << (POOL_ALLOCATOR_BIG_BASE + 2),  
         },  
         {  
                 .pa_alloc = pool_page_alloc,  
                 .pa_free = pool_page_free,  
                 .pa_pagesz = 1 << (POOL_ALLOCATOR_BIG_BASE + 3),  
         },  
         {  
                 .pa_alloc = pool_page_alloc,  
                 .pa_free = pool_page_free,  
                 .pa_pagesz = 1 << (POOL_ALLOCATOR_BIG_BASE + 4),  
         },  
         {  
                 .pa_alloc = pool_page_alloc,  
                 .pa_free = pool_page_free,  
                 .pa_pagesz = 1 << (POOL_ALLOCATOR_BIG_BASE + 5),  
         },  
         {  
                 .pa_alloc = pool_page_alloc,  
                 .pa_free = pool_page_free,  
                 .pa_pagesz = 1 << (POOL_ALLOCATOR_BIG_BASE + 6),  
         },  
         {  
                 .pa_alloc = pool_page_alloc,  
                 .pa_free = pool_page_free,  
                 .pa_pagesz = 1 << (POOL_ALLOCATOR_BIG_BASE + 7),  
         }  
 };  
   
 static int  
 pool_bigidx(size_t size)  
 {  
         int i;  
   
         for (i = 0; i < __arraycount(pool_allocator_big); i++) {  
                 if (1 << (i + POOL_ALLOCATOR_BIG_BASE) >= size)  
                         return i;  
         }  
         panic("pool item size %zu too large, use a custom allocator", size);  
 }  
   
 static void *  static void *
 pool_allocator_alloc(struct pool *pp, int flags)  pool_allocator_alloc(struct pool *pp, int flags)
 {  {
Line 2963  pool_sysctl(SYSCTLFN_ARGS)
Line 2947  pool_sysctl(SYSCTLFN_ARGS)
                                 cc = pc->pc_cpus[i];                                  cc = pc->pc_cpus[i];
                                 if (cc == NULL)                                  if (cc == NULL)
                                         continue;                                          continue;
                                 data.pr_cache_nmiss_pcpu += cc->cc_misses;                                  data.pr_cache_nmiss_pcpu = cc->cc_misses;
                                 data.pr_cache_nhit_pcpu += cc->cc_hits;                                  data.pr_cache_nhit_pcpu = cc->cc_hits;
                         }                          }
                 } else {                  } else {
                         data.pr_cache_meta_size = 0;                          data.pr_cache_meta_size = 0;

Legend:
Removed from v.1.203.4.3  
changed lines
  Added in v.1.204

CVSweb <webmaster@jp.NetBSD.org>