[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.175 and 1.190.2.1

version 1.175, 2009/10/08 21:54:45 version 1.190.2.1, 2012/04/17 00:08:28
Line 1 
Line 1 
 /*      $NetBSD$        */  /*      $NetBSD$        */
   
 /*-  /*-
  * Copyright (c) 1997, 1999, 2000, 2002, 2007, 2008 The NetBSD Foundation, Inc.   * Copyright (c) 1997, 1999, 2000, 2002, 2007, 2008, 2010
    *     The NetBSD Foundation, Inc.
  * All rights reserved.   * All rights reserved.
  *   *
  * This code is derived from software contributed to The NetBSD Foundation   * This code is derived from software contributed to The NetBSD Foundation
Line 45  __KERNEL_RCSID(0, "$NetBSD$");
Line 46  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/errno.h>  #include <sys/errno.h>
 #include <sys/kernel.h>  #include <sys/kernel.h>
 #include <sys/malloc.h>  #include <sys/malloc.h>
   #include <sys/vmem.h>
 #include <sys/pool.h>  #include <sys/pool.h>
 #include <sys/syslog.h>  #include <sys/syslog.h>
 #include <sys/debug.h>  #include <sys/debug.h>
Line 53  __KERNEL_RCSID(0, "$NetBSD$");
Line 55  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/cpu.h>  #include <sys/cpu.h>
 #include <sys/atomic.h>  #include <sys/atomic.h>
   
 #include <uvm/uvm.h>  #include <uvm/uvm_extern.h>
   
 /*  /*
  * Pool resource management utility.   * Pool resource management utility.
Line 82  static struct pool phpool[PHPOOL_MAX];
Line 84  static struct pool phpool[PHPOOL_MAX];
 static struct pool psppool;  static struct pool psppool;
 #endif  #endif
   
 static SLIST_HEAD(, pool_allocator) pa_deferinitq =  
     SLIST_HEAD_INITIALIZER(pa_deferinitq);  
   
 static void *pool_page_alloc_meta(struct pool *, int);  static void *pool_page_alloc_meta(struct pool *, int);
 static void pool_page_free_meta(struct pool *, void *);  static void pool_page_free_meta(struct pool *, void *);
   
 /* allocator for pool metadata */  /* allocator for pool metadata */
 struct pool_allocator pool_allocator_meta = {  struct pool_allocator pool_allocator_meta = {
         pool_page_alloc_meta, pool_page_free_meta,          .pa_alloc = pool_page_alloc_meta,
         .pa_backingmapptr = &kmem_map,          .pa_free = pool_page_free_meta,
           .pa_pagesz = 0
 };  };
   
 /* # of seconds to retain page after last use */  /* # of seconds to retain page after last use */
Line 104  static struct pool *drainpp;
Line 104  static struct pool *drainpp;
 static kmutex_t pool_head_lock;  static kmutex_t pool_head_lock;
 static kcondvar_t pool_busy;  static kcondvar_t pool_busy;
   
   /* This lock protects initialization of a potentially shared pool allocator */
   static kmutex_t pool_allocator_lock;
   
 typedef uint32_t pool_item_bitmap_t;  typedef uint32_t pool_item_bitmap_t;
 #define BITMAP_SIZE     (CHAR_BIT * sizeof(pool_item_bitmap_t))  #define BITMAP_SIZE     (CHAR_BIT * sizeof(pool_item_bitmap_t))
 #define BITMAP_MASK     (BITMAP_SIZE - 1)  #define BITMAP_MASK     (BITMAP_SIZE - 1)
Line 175  static struct pool pcg_large_pool;
Line 178  static struct pool pcg_large_pool;
 static struct pool cache_pool;  static struct pool cache_pool;
 static struct pool cache_cpu_pool;  static struct pool cache_cpu_pool;
   
   pool_cache_t pnbuf_cache;       /* pathname buffer cache */
   
 /* List of all caches. */  /* List of all caches. */
 TAILQ_HEAD(,pool_cache) pool_cache_head =  TAILQ_HEAD(,pool_cache) pool_cache_head =
     TAILQ_HEAD_INITIALIZER(pool_cache_head);      TAILQ_HEAD_INITIALIZER(pool_cache_head);
Line 231  int pool_logsize = POOL_LOGSIZE;
Line 236  int pool_logsize = POOL_LOGSIZE;
 static inline void  static inline void
 pr_log(struct pool *pp, void *v, int action, const char *file, long line)  pr_log(struct pool *pp, void *v, int action, const char *file, long line)
 {  {
         int n = pp->pr_curlogentry;          int n;
         struct pool_log *pl;          struct pool_log *pl;
   
         if ((pp->pr_roflags & PR_LOGGING) == 0)          if ((pp->pr_roflags & PR_LOGGING) == 0)
                 return;                  return;
   
           if (pp->pr_log == NULL) {
                   if (kmem_map != NULL)
                           pp->pr_log = malloc(
                                   pool_logsize * sizeof(struct pool_log),
                                   M_TEMP, M_NOWAIT | M_ZERO);
                   if (pp->pr_log == NULL)
                           return;
                   pp->pr_curlogentry = 0;
                   pp->pr_logsize = pool_logsize;
           }
   
         /*          /*
          * Fill in the current entry. Wrap around and overwrite           * Fill in the current entry. Wrap around and overwrite
          * the oldest entry if necessary.           * the oldest entry if necessary.
          */           */
           n = pp->pr_curlogentry;
         pl = &pp->pr_log[n];          pl = &pp->pr_log[n];
         pl->pl_file = file;          pl->pl_file = file;
         pl->pl_line = line;          pl->pl_line = line;
Line 258  pr_printlog(struct pool *pp, struct pool
Line 275  pr_printlog(struct pool *pp, struct pool
         int i = pp->pr_logsize;          int i = pp->pr_logsize;
         int n = pp->pr_curlogentry;          int n = pp->pr_curlogentry;
   
         if ((pp->pr_roflags & PR_LOGGING) == 0)          if (pp->pr_log == NULL)
                 return;                  return;
   
         /*          /*
Line 508  pr_rmpage(struct pool *pp, struct pool_i
Line 525  pr_rmpage(struct pool *pp, struct pool_i
         pool_update_curpage(pp);          pool_update_curpage(pp);
 }  }
   
 static bool  
 pa_starved_p(struct pool_allocator *pa)  
 {  
   
         if (pa->pa_backingmap != NULL) {  
                 return vm_map_starved_p(pa->pa_backingmap);  
         }  
         return false;  
 }  
   
 static int  
 pool_reclaim_callback(struct callback_entry *ce, void *obj, void *arg)  
 {  
         struct pool *pp = obj;  
         struct pool_allocator *pa = pp->pr_alloc;  
   
         KASSERT(&pp->pr_reclaimerentry == ce);  
         pool_reclaim(pp);  
         if (!pa_starved_p(pa)) {  
                 return CALLBACK_CHAIN_ABORT;  
         }  
         return CALLBACK_CHAIN_CONTINUE;  
 }  
   
 static void  
 pool_reclaim_register(struct pool *pp)  
 {  
         struct vm_map *map = pp->pr_alloc->pa_backingmap;  
         int s;  
   
         if (map == NULL) {  
                 return;  
         }  
   
         s = splvm(); /* not necessary for INTRSAFE maps, but don't care. */  
         callback_register(&vm_map_to_kernel(map)->vmk_reclaim_callback,  
             &pp->pr_reclaimerentry, pp, pool_reclaim_callback);  
         splx(s);  
 }  
   
 static void  
 pool_reclaim_unregister(struct pool *pp)  
 {  
         struct vm_map *map = pp->pr_alloc->pa_backingmap;  
         int s;  
   
         if (map == NULL) {  
                 return;  
         }  
   
         s = splvm(); /* not necessary for INTRSAFE maps, but don't care. */  
         callback_unregister(&vm_map_to_kernel(map)->vmk_reclaim_callback,  
             &pp->pr_reclaimerentry);  
         splx(s);  
 }  
   
 static void  
 pa_reclaim_register(struct pool_allocator *pa)  
 {  
         struct vm_map *map = *pa->pa_backingmapptr;  
         struct pool *pp;  
   
         KASSERT(pa->pa_backingmap == NULL);  
         if (map == NULL) {  
                 SLIST_INSERT_HEAD(&pa_deferinitq, pa, pa_q);  
                 return;  
         }  
         pa->pa_backingmap = map;  
         TAILQ_FOREACH(pp, &pa->pa_list, pr_alloc_list) {  
                 pool_reclaim_register(pp);  
         }  
 }  
   
 /*  /*
  * Initialize all the pools listed in the "pools" link set.   * Initialize all the pools listed in the "pools" link set.
  */   */
 void  void
 pool_subsystem_init(void)  pool_subsystem_init(void)
 {  {
         struct pool_allocator *pa;          size_t size;
           int idx;
   
         mutex_init(&pool_head_lock, MUTEX_DEFAULT, IPL_NONE);          mutex_init(&pool_head_lock, MUTEX_DEFAULT, IPL_NONE);
           mutex_init(&pool_allocator_lock, MUTEX_DEFAULT, IPL_NONE);
         cv_init(&pool_busy, "poolbusy");          cv_init(&pool_busy, "poolbusy");
   
         while ((pa = SLIST_FIRST(&pa_deferinitq)) != NULL) {          /*
                 KASSERT(pa->pa_backingmapptr != NULL);           * Initialize private page header pool and cache magazine pool if we
                 KASSERT(*pa->pa_backingmapptr != NULL);           * haven't done so yet.
                 SLIST_REMOVE_HEAD(&pa_deferinitq, pa_q);           */
                 pa_reclaim_register(pa);          for (idx = 0; idx < PHPOOL_MAX; idx++) {
                   static char phpool_names[PHPOOL_MAX][6+1+6+1];
                   int nelem;
                   size_t sz;
   
                   nelem = PHPOOL_FREELIST_NELEM(idx);
                   snprintf(phpool_names[idx], sizeof(phpool_names[idx]),
                       "phpool-%d", nelem);
                   sz = sizeof(struct pool_item_header);
                   if (nelem) {
                           sz = offsetof(struct pool_item_header,
                               ph_bitmap[howmany(nelem, BITMAP_SIZE)]);
                   }
                   pool_init(&phpool[idx], sz, 0, 0, 0,
                       phpool_names[idx], &pool_allocator_meta, IPL_VM);
         }          }
   #ifdef POOL_SUBPAGE
           pool_init(&psppool, POOL_SUBPAGE, POOL_SUBPAGE, 0,
               PR_RECURSIVE, "psppool", &pool_allocator_meta, IPL_VM);
   #endif
   
           size = sizeof(pcg_t) +
               (PCG_NOBJECTS_NORMAL - 1) * sizeof(pcgpair_t);
           pool_init(&pcg_normal_pool, size, coherency_unit, 0, 0,
               "pcgnormal", &pool_allocator_meta, IPL_VM);
   
           size = sizeof(pcg_t) +
               (PCG_NOBJECTS_LARGE - 1) * sizeof(pcgpair_t);
           pool_init(&pcg_large_pool, size, coherency_unit, 0, 0,
               "pcglarge", &pool_allocator_meta, IPL_VM);
   
         pool_init(&cache_pool, sizeof(struct pool_cache), coherency_unit,          pool_init(&cache_pool, sizeof(struct pool_cache), coherency_unit,
             0, 0, "pcache", &pool_allocator_nointr, IPL_NONE);              0, 0, "pcache", &pool_allocator_meta, IPL_NONE);
   
         pool_init(&cache_cpu_pool, sizeof(pool_cache_cpu_t), coherency_unit,          pool_init(&cache_cpu_pool, sizeof(pool_cache_cpu_t), coherency_unit,
             0, 0, "pcachecpu", &pool_allocator_nointr, IPL_NONE);              0, 0, "pcachecpu", &pool_allocator_meta, IPL_NONE);
 }  }
   
 /*  /*
Line 650  pool_init(struct pool *pp, size_t size, 
Line 624  pool_init(struct pool *pp, size_t size, 
                         palloc = &pool_allocator_nointr_fullpage;                          palloc = &pool_allocator_nointr_fullpage;
         }          }
 #endif /* POOL_SUBPAGE */  #endif /* POOL_SUBPAGE */
         if ((palloc->pa_flags & PA_INITIALIZED) == 0) {          if (!cold)
                   mutex_enter(&pool_allocator_lock);
           if (palloc->pa_refcnt++ == 0) {
                 if (palloc->pa_pagesz == 0)                  if (palloc->pa_pagesz == 0)
                         palloc->pa_pagesz = PAGE_SIZE;                          palloc->pa_pagesz = PAGE_SIZE;
   
Line 659  pool_init(struct pool *pp, size_t size, 
Line 635  pool_init(struct pool *pp, size_t size, 
                 mutex_init(&palloc->pa_lock, MUTEX_DEFAULT, IPL_VM);                  mutex_init(&palloc->pa_lock, MUTEX_DEFAULT, IPL_VM);
                 palloc->pa_pagemask = ~(palloc->pa_pagesz - 1);                  palloc->pa_pagemask = ~(palloc->pa_pagesz - 1);
                 palloc->pa_pageshift = ffs(palloc->pa_pagesz) - 1;                  palloc->pa_pageshift = ffs(palloc->pa_pagesz) - 1;
   
                 if (palloc->pa_backingmapptr != NULL) {  
                         pa_reclaim_register(palloc);  
                 }  
                 palloc->pa_flags |= PA_INITIALIZED;  
         }          }
           if (!cold)
                   mutex_exit(&pool_allocator_lock);
   
         if (align == 0)          if (align == 0)
                 align = ALIGN(1);                  align = ALIGN(1);
Line 787  pool_init(struct pool *pp, size_t size, 
Line 760  pool_init(struct pool *pp, size_t size, 
         pp->pr_nidle = 0;          pp->pr_nidle = 0;
         pp->pr_refcnt = 0;          pp->pr_refcnt = 0;
   
 #ifdef POOL_DIAGNOSTIC          pp->pr_log = NULL;
         if (flags & PR_LOGGING) {  
                 if (kmem_map == NULL ||  
                     (pp->pr_log = malloc(pool_logsize * sizeof(struct pool_log),  
                      M_TEMP, M_NOWAIT)) == NULL)  
                         pp->pr_roflags &= ~PR_LOGGING;  
                 pp->pr_curlogentry = 0;  
                 pp->pr_logsize = pool_logsize;  
         }  
 #endif  
   
         pp->pr_entered_file = NULL;          pp->pr_entered_file = NULL;
         pp->pr_entered_line = 0;          pp->pr_entered_line = 0;
Line 805  pool_init(struct pool *pp, size_t size, 
Line 769  pool_init(struct pool *pp, size_t size, 
         cv_init(&pp->pr_cv, wchan);          cv_init(&pp->pr_cv, wchan);
         pp->pr_ipl = ipl;          pp->pr_ipl = ipl;
   
         /*  
          * Initialize private page header pool and cache magazine pool if we  
          * haven't done so yet.  
          * XXX LOCKING.  
          */  
         if (phpool[0].pr_size == 0) {  
                 int idx;  
                 for (idx = 0; idx < PHPOOL_MAX; idx++) {  
                         static char phpool_names[PHPOOL_MAX][6+1+6+1];  
                         int nelem;  
                         size_t sz;  
   
                         nelem = PHPOOL_FREELIST_NELEM(idx);  
                         snprintf(phpool_names[idx], sizeof(phpool_names[idx]),  
                             "phpool-%d", nelem);  
                         sz = sizeof(struct pool_item_header);  
                         if (nelem) {  
                                 sz = offsetof(struct pool_item_header,  
                                     ph_bitmap[howmany(nelem, BITMAP_SIZE)]);  
                         }  
                         pool_init(&phpool[idx], sz, 0, 0, 0,  
                             phpool_names[idx], &pool_allocator_meta, IPL_VM);  
                 }  
 #ifdef POOL_SUBPAGE  
                 pool_init(&psppool, POOL_SUBPAGE, POOL_SUBPAGE, 0,  
                     PR_RECURSIVE, "psppool", &pool_allocator_meta, IPL_VM);  
 #endif  
   
                 size = sizeof(pcg_t) +  
                     (PCG_NOBJECTS_NORMAL - 1) * sizeof(pcgpair_t);  
                 pool_init(&pcg_normal_pool, size, coherency_unit, 0, 0,  
                     "pcgnormal", &pool_allocator_meta, IPL_VM);  
   
                 size = sizeof(pcg_t) +  
                     (PCG_NOBJECTS_LARGE - 1) * sizeof(pcgpair_t);  
                 pool_init(&pcg_large_pool, size, coherency_unit, 0, 0,  
                     "pcglarge", &pool_allocator_meta, IPL_VM);  
         }  
   
         /* Insert into the list of all pools. */          /* Insert into the list of all pools. */
         if (__predict_true(!cold))          if (!cold)
                 mutex_enter(&pool_head_lock);                  mutex_enter(&pool_head_lock);
         TAILQ_FOREACH(pp1, &pool_head, pr_poollist) {          TAILQ_FOREACH(pp1, &pool_head, pr_poollist) {
                 if (strcmp(pp1->pr_wchan, pp->pr_wchan) > 0)                  if (strcmp(pp1->pr_wchan, pp->pr_wchan) > 0)
Line 855  pool_init(struct pool *pp, size_t size, 
Line 780  pool_init(struct pool *pp, size_t size, 
                 TAILQ_INSERT_TAIL(&pool_head, pp, pr_poollist);                  TAILQ_INSERT_TAIL(&pool_head, pp, pr_poollist);
         else          else
                 TAILQ_INSERT_BEFORE(pp1, pp, pr_poollist);                  TAILQ_INSERT_BEFORE(pp1, pp, pr_poollist);
         if (__predict_true(!cold))          if (!cold)
                 mutex_exit(&pool_head_lock);                  mutex_exit(&pool_head_lock);
   
         /* Insert this into the list of pools using this allocator. */          /* Insert this into the list of pools using this allocator. */
         if (__predict_true(!cold))          if (!cold)
                 mutex_enter(&palloc->pa_lock);                  mutex_enter(&palloc->pa_lock);
         TAILQ_INSERT_TAIL(&palloc->pa_list, pp, pr_alloc_list);          TAILQ_INSERT_TAIL(&palloc->pa_list, pp, pr_alloc_list);
         if (__predict_true(!cold))          if (!cold)
                 mutex_exit(&palloc->pa_lock);                  mutex_exit(&palloc->pa_lock);
   
         pool_reclaim_register(pp);  
 }  }
   
 /*  /*
Line 887  pool_destroy(struct pool *pp)
Line 810  pool_destroy(struct pool *pp)
         mutex_exit(&pool_head_lock);          mutex_exit(&pool_head_lock);
   
         /* Remove this pool from its allocator's list of pools. */          /* Remove this pool from its allocator's list of pools. */
         pool_reclaim_unregister(pp);  
         mutex_enter(&pp->pr_alloc->pa_lock);          mutex_enter(&pp->pr_alloc->pa_lock);
         TAILQ_REMOVE(&pp->pr_alloc->pa_list, pp, pr_alloc_list);          TAILQ_REMOVE(&pp->pr_alloc->pa_list, pp, pr_alloc_list);
         mutex_exit(&pp->pr_alloc->pa_lock);          mutex_exit(&pp->pr_alloc->pa_lock);
   
           mutex_enter(&pool_allocator_lock);
           if (--pp->pr_alloc->pa_refcnt == 0)
                   mutex_destroy(&pp->pr_alloc->pa_lock);
           mutex_exit(&pool_allocator_lock);
   
         mutex_enter(&pp->pr_lock);          mutex_enter(&pp->pr_lock);
   
         KASSERT(pp->pr_cache == NULL);          KASSERT(pp->pr_cache == NULL);
Line 917  pool_destroy(struct pool *pp)
Line 844  pool_destroy(struct pool *pp)
         pr_pagelist_free(pp, &pq);          pr_pagelist_free(pp, &pq);
   
 #ifdef POOL_DIAGNOSTIC  #ifdef POOL_DIAGNOSTIC
         if ((pp->pr_roflags & PR_LOGGING) != 0)          if (pp->pr_log != NULL) {
                 free(pp->pr_log, M_TEMP);                  free(pp->pr_log, M_TEMP);
                   pp->pr_log = NULL;
           }
 #endif  #endif
   
         cv_destroy(&pp->pr_cv);          cv_destroy(&pp->pr_cv);
Line 966  pool_get(struct pool *pp, int flags)
Line 895  pool_get(struct pool *pp, int flags)
         void *v;          void *v;
   
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         if (__predict_false(pp->pr_itemsperpage == 0))          if (pp->pr_itemsperpage == 0)
                 panic("pool_get: pool %p: pr_itemsperpage is zero, "                  panic("pool_get: pool '%s': pr_itemsperpage is zero, "
                     "pool not initialized?", pp);                      "pool not initialized?", pp->pr_wchan);
         if (__predict_false(curlwp == NULL && doing_shutdown == 0 &&          if ((cpu_intr_p() || cpu_softintr_p()) && pp->pr_ipl == IPL_NONE &&
                             (flags & PR_WAITOK) != 0))              !cold && panicstr == NULL)
                 panic("pool_get: %s: must have NOWAIT", pp->pr_wchan);                  panic("pool '%s' is IPL_NONE, but called from "
                       "interrupt context\n", pp->pr_wchan);
 #endif /* DIAGNOSTIC */  #endif
 #ifdef LOCKDEBUG  
         if (flags & PR_WAITOK) {          if (flags & PR_WAITOK) {
                 ASSERT_SLEEPABLE();                  ASSERT_SLEEPABLE();
         }          }
 #endif  
   
         mutex_enter(&pp->pr_lock);          mutex_enter(&pp->pr_lock);
         pr_enter(pp, file, line);          pr_enter(pp, file, line);
Line 1586  pool_sethardlimit(struct pool *pp, int n
Line 1513  pool_sethardlimit(struct pool *pp, int n
   
 /*  /*
  * Release all complete pages that have not been used recently.   * Release all complete pages that have not been used recently.
    *
    * Might be called from interrupt context.
  */   */
 int  int
 #ifdef POOL_DIAGNOSTIC  #ifdef POOL_DIAGNOSTIC
Line 1600  pool_reclaim(struct pool *pp)
Line 1529  pool_reclaim(struct pool *pp)
         bool klock;          bool klock;
         int rv;          int rv;
   
           if (cpu_intr_p() || cpu_softintr_p()) {
                   KASSERT(pp->pr_ipl != IPL_NONE);
           }
   
         if (pp->pr_drain_hook != NULL) {          if (pp->pr_drain_hook != NULL) {
                 /*                  /*
                  * The drain hook must be called with the pool unlocked.                   * The drain hook must be called with the pool unlocked.
Line 1642  pool_reclaim(struct pool *pp)
Line 1575  pool_reclaim(struct pool *pp)
                         break;                          break;
   
                 KASSERT(ph->ph_nmissing == 0);                  KASSERT(ph->ph_nmissing == 0);
                 if (curtime - ph->ph_time < pool_inactive_time                  if (curtime - ph->ph_time < pool_inactive_time)
                     && !pa_starved_p(pp->pr_alloc))  
                         continue;                          continue;
   
                 /*                  /*
Line 1718  pool_drain_start(struct pool **ppp, uint
Line 1650  pool_drain_start(struct pool **ppp, uint
         }          }
 }  }
   
 void  bool
 pool_drain_end(struct pool *pp, uint64_t where)  pool_drain_end(struct pool *pp, uint64_t where)
 {  {
           bool reclaimed;
   
         if (pp == NULL)          if (pp == NULL)
                 return;                  return false;
   
         KASSERT(pp->pr_refcnt > 0);          KASSERT(pp->pr_refcnt > 0);
   
Line 1732  pool_drain_end(struct pool *pp, uint64_t
Line 1665  pool_drain_end(struct pool *pp, uint64_t
                 xc_wait(where);                  xc_wait(where);
   
         /* Drain the cache (if any) and pool.. */          /* Drain the cache (if any) and pool.. */
         pool_reclaim(pp);          reclaimed = pool_reclaim(pp);
   
         /* Finally, unlock the pool. */          /* Finally, unlock the pool. */
         mutex_enter(&pool_head_lock);          mutex_enter(&pool_head_lock);
         pp->pr_refcnt--;          pp->pr_refcnt--;
         cv_broadcast(&pool_busy);          cv_broadcast(&pool_busy);
         mutex_exit(&pool_head_lock);          mutex_exit(&pool_head_lock);
   
           return reclaimed;
 }  }
   
 /*  /*
Line 1887  pool_print1(struct pool *pp, const char 
Line 1822  pool_print1(struct pool *pp, const char 
         if (pc != NULL) {          if (pc != NULL) {
                 cpuhit = 0;                  cpuhit = 0;
                 cpumiss = 0;                  cpumiss = 0;
                 for (i = 0; i < MAXCPUS; i++) {                  for (i = 0; i < __arraycount(pc->pc_cpus); i++) {
                         if ((cc = pc->pc_cpus[i]) == NULL)                          if ((cc = pc->pc_cpus[i]) == NULL)
                                 continue;                                  continue;
                         cpuhit += cc->cc_hits;                          cpuhit += cc->cc_hits;
Line 2122  pool_cache_bootstrap(pool_cache_t pc, si
Line 2057  pool_cache_bootstrap(pool_cache_t pc, si
 void  void
 pool_cache_destroy(pool_cache_t pc)  pool_cache_destroy(pool_cache_t pc)
 {  {
   
           pool_cache_bootstrap_destroy(pc);
           pool_put(&cache_pool, pc);
   }
   
   /*
    * pool_cache_bootstrap_destroy:
    *
    *      Destroy a pool cache.
    */
   void
   pool_cache_bootstrap_destroy(pool_cache_t pc)
   {
         struct pool *pp = &pc->pc_pool;          struct pool *pp = &pc->pc_pool;
         u_int i;          u_int i;
   
Line 2141  pool_cache_destroy(pool_cache_t pc)
Line 2089  pool_cache_destroy(pool_cache_t pc)
         mutex_exit(&pp->pr_lock);          mutex_exit(&pp->pr_lock);
   
         /* Destroy per-CPU data */          /* Destroy per-CPU data */
         for (i = 0; i < MAXCPUS; i++)          for (i = 0; i < __arraycount(pc->pc_cpus); i++)
                 pool_cache_invalidate_cpu(pc, i);                  pool_cache_invalidate_cpu(pc, i);
   
         /* Finally, destroy it. */          /* Finally, destroy it. */
         mutex_destroy(&pc->pc_lock);          mutex_destroy(&pc->pc_lock);
         pool_destroy(pp);          pool_destroy(pp);
         pool_put(&cache_pool, pc);  
 }  }
   
 /*  /*
Line 2163  pool_cache_cpu_init1(struct cpu_info *ci
Line 2110  pool_cache_cpu_init1(struct cpu_info *ci
   
         index = ci->ci_index;          index = ci->ci_index;
   
         KASSERT(index < MAXCPUS);          KASSERT(index < __arraycount(pc->pc_cpus));
   
         if ((cc = pc->pc_cpus[index]) != NULL) {          if ((cc = pc->pc_cpus[index]) != NULL) {
                 KASSERT(cc->cc_cpuindex == index);                  KASSERT(cc->cc_cpuindex == index);
Line 2289  pool_cache_invalidate_groups(pool_cache_
Line 2236  pool_cache_invalidate_groups(pool_cache_
  *   *
  *      Invalidate a pool cache (destruct and release all of the   *      Invalidate a pool cache (destruct and release all of the
  *      cached objects).  Does not reclaim objects from the pool.   *      cached objects).  Does not reclaim objects from the pool.
    *
    *      Note: For pool caches that provide constructed objects, there
    *      is an assumption that another level of synchronization is occurring
    *      between the input to the constructor and the cache invalidation.
  */   */
 void  void
 pool_cache_invalidate(pool_cache_t pc)  pool_cache_invalidate(pool_cache_t pc)
 {  {
         pcg_t *full, *empty, *part;          pcg_t *full, *empty, *part;
   #if 0
           uint64_t where;
   
           if (ncpu < 2 || !mp_online) {
                   /*
                    * We might be called early enough in the boot process
                    * for the CPU data structures to not be fully initialized.
                    * In this case, simply gather the local CPU's cache now
                    * since it will be the only one running.
                    */
                   pool_cache_xcall(pc);
           } else {
                   /*
                    * Gather all of the CPU-specific caches into the
                    * global cache.
                    */
                   where = xc_broadcast(0, (xcfunc_t)pool_cache_xcall, pc, NULL);
                   xc_wait(where);
           }
   #endif
         mutex_enter(&pc->pc_lock);          mutex_enter(&pc->pc_lock);
         full = pc->pc_fullgroups;          full = pc->pc_fullgroups;
         empty = pc->pc_emptygroups;          empty = pc->pc_emptygroups;
Line 2313  pool_cache_invalidate(pool_cache_t pc)
Line 2283  pool_cache_invalidate(pool_cache_t pc)
 }  }
   
 /*  /*
  * pool_cache_invalidate_local:  
  *  
  *      Invalidate all local ('current CPU') cached objects in  
  *      pool cache.  
  *      It is caller's responsibility to ensure that no operation is  
  *      taking place on this pool cache while doing the local invalidation.  
  */  
 void  
 pool_cache_invalidate_local(pool_cache_t pc)  
 {  
         pool_cache_invalidate_cpu(pc, curcpu()->ci_index);  
 }  
   
 /*  
  * pool_cache_invalidate_cpu:   * pool_cache_invalidate_cpu:
  *   *
  *      Invalidate all CPU-bound cached objects in pool cache, the CPU being   *      Invalidate all CPU-bound cached objects in pool cache, the CPU being
Line 2493  pool_cache_get_paddr(pool_cache_t pc, in
Line 2449  pool_cache_get_paddr(pool_cache_t pc, in
         void *object;          void *object;
         int s;          int s;
   
 #ifdef LOCKDEBUG          KASSERTMSG((!cpu_intr_p() && !cpu_softintr_p()) ||
               (pc->pc_pool.pr_ipl != IPL_NONE || cold || panicstr != NULL),
               "pool '%s' is IPL_NONE, but called from interrupt context\n",
               pc->pc_pool.pr_wchan);
   
         if (flags & PR_WAITOK) {          if (flags & PR_WAITOK) {
                 ASSERT_SLEEPABLE();                  ASSERT_SLEEPABLE();
         }          }
 #endif  
   
         /* Lock out interrupts and disable preemption. */          /* Lock out interrupts and disable preemption. */
         s = splvm();          s = splvm();
Line 2759  void pool_page_free(struct pool *, void 
Line 2718  void pool_page_free(struct pool *, void 
   
 #ifdef POOL_SUBPAGE  #ifdef POOL_SUBPAGE
 struct pool_allocator pool_allocator_kmem_fullpage = {  struct pool_allocator pool_allocator_kmem_fullpage = {
         pool_page_alloc, pool_page_free, 0,          .pa_alloc = pool_page_alloc,
         .pa_backingmapptr = &kmem_map,          .pa_free = pool_page_free,
           .pa_pagesz = 0
 };  };
 #else  #else
 struct pool_allocator pool_allocator_kmem = {  struct pool_allocator pool_allocator_kmem = {
         pool_page_alloc, pool_page_free, 0,          .pa_alloc = pool_page_alloc,
         .pa_backingmapptr = &kmem_map,          .pa_free = pool_page_free,
           .pa_pagesz = 0
 };  };
 #endif  #endif
   
 void    *pool_page_alloc_nointr(struct pool *, int);  
 void    pool_page_free_nointr(struct pool *, void *);  
   
 #ifdef POOL_SUBPAGE  #ifdef POOL_SUBPAGE
 struct pool_allocator pool_allocator_nointr_fullpage = {  struct pool_allocator pool_allocator_nointr_fullpage = {
         pool_page_alloc_nointr, pool_page_free_nointr, 0,          .pa_alloc = pool_page_alloc,
         .pa_backingmapptr = &kernel_map,          .pa_free = pool_page_free,
           .pa_pagesz = 0
 };  };
 #else  #else
 struct pool_allocator pool_allocator_nointr = {  struct pool_allocator pool_allocator_nointr = {
         pool_page_alloc_nointr, pool_page_free_nointr, 0,          .pa_alloc = pool_page_alloc,
         .pa_backingmapptr = &kernel_map,          .pa_free = pool_page_free,
           .pa_pagesz = 0
 };  };
 #endif  #endif
   
Line 2789  void *pool_subpage_alloc(struct pool *, 
Line 2749  void *pool_subpage_alloc(struct pool *, 
 void    pool_subpage_free(struct pool *, void *);  void    pool_subpage_free(struct pool *, void *);
   
 struct pool_allocator pool_allocator_kmem = {  struct pool_allocator pool_allocator_kmem = {
         pool_subpage_alloc, pool_subpage_free, POOL_SUBPAGE,          .pa_alloc = pool_subpage_alloc,
         .pa_backingmapptr = &kmem_map,          .pa_free = pool_subpage_free,
           .pa_pagesz = POOL_SUBPAGE
 };  };
   
 void    *pool_subpage_alloc_nointr(struct pool *, int);  
 void    pool_subpage_free_nointr(struct pool *, void *);  
   
 struct pool_allocator pool_allocator_nointr = {  struct pool_allocator pool_allocator_nointr = {
         pool_subpage_alloc, pool_subpage_free, POOL_SUBPAGE,          .pa_alloc = pool_subpage_alloc,
         .pa_backingmapptr = &kmem_map,          .pa_free = pool_subpage_free,
           .pa_pagesz = POOL_SUBPAGE
 };  };
 #endif /* POOL_SUBPAGE */  #endif /* POOL_SUBPAGE */
   
Line 2834  pool_allocator_free(struct pool *pp, voi
Line 2793  pool_allocator_free(struct pool *pp, voi
 void *  void *
 pool_page_alloc(struct pool *pp, int flags)  pool_page_alloc(struct pool *pp, int flags)
 {  {
         bool waitok = (flags & PR_WAITOK) ? true : false;          const vm_flag_t vflags = (flags & PR_WAITOK) ? VM_SLEEP: VM_NOSLEEP;
           vmem_addr_t va;
           int ret;
   
         return ((void *) uvm_km_alloc_poolpage_cache(kmem_map, waitok));          ret = uvm_km_kmem_alloc(kmem_va_arena, pp->pr_alloc->pa_pagesz,
               vflags | VM_INSTANTFIT, &va);
   
           return ret ? NULL : (void *)va;
 }  }
   
 void  void
 pool_page_free(struct pool *pp, void *v)  pool_page_free(struct pool *pp, void *v)
 {  {
   
         uvm_km_free_poolpage_cache(kmem_map, (vaddr_t) v);          uvm_km_kmem_free(kmem_va_arena, (vaddr_t)v, pp->pr_alloc->pa_pagesz);
 }  }
   
 static void *  static void *
 pool_page_alloc_meta(struct pool *pp, int flags)  pool_page_alloc_meta(struct pool *pp, int flags)
 {  {
         bool waitok = (flags & PR_WAITOK) ? true : false;          const vm_flag_t vflags = (flags & PR_WAITOK) ? VM_SLEEP: VM_NOSLEEP;
           vmem_addr_t va;
           int ret;
   
           ret = vmem_alloc(kmem_meta_arena, pp->pr_alloc->pa_pagesz,
               vflags | VM_INSTANTFIT, &va);
   
         return ((void *) uvm_km_alloc_poolpage(kmem_map, waitok));          return ret ? NULL : (void *)va;
 }  }
   
 static void  static void
 pool_page_free_meta(struct pool *pp, void *v)  pool_page_free_meta(struct pool *pp, void *v)
 {  {
   
         uvm_km_free_poolpage(kmem_map, (vaddr_t) v);          vmem_free(kmem_meta_arena, (vmem_addr_t)v, pp->pr_alloc->pa_pagesz);
 }  }
   
 #ifdef POOL_SUBPAGE  #ifdef POOL_SUBPAGE
Line 2875  pool_subpage_free(struct pool *pp, void 
Line 2844  pool_subpage_free(struct pool *pp, void 
         pool_put(&psppool, v);          pool_put(&psppool, v);
 }  }
   
 /* We don't provide a real nointr allocator.  Maybe later. */  
 void *  
 pool_subpage_alloc_nointr(struct pool *pp, int flags)  
 {  
   
         return (pool_subpage_alloc(pp, flags));  
 }  
   
 void  
 pool_subpage_free_nointr(struct pool *pp, void *v)  
 {  
   
         pool_subpage_free(pp, v);  
 }  
 #endif /* POOL_SUBPAGE */  #endif /* POOL_SUBPAGE */
 void *  
 pool_page_alloc_nointr(struct pool *pp, int flags)  
 {  
         bool waitok = (flags & PR_WAITOK) ? true : false;  
   
         return ((void *) uvm_km_alloc_poolpage_cache(kernel_map, waitok));  
 }  
   
 void  
 pool_page_free_nointr(struct pool *pp, void *v)  
 {  
   
         uvm_km_free_poolpage_cache(kernel_map, (vaddr_t) v);  
 }  
   
 #if defined(DDB)  #if defined(DDB)
 static bool  static bool
Line 3013  found:
Line 2954  found:
                                         goto print;                                          goto print;
                                 }                                  }
                         }                          }
                         for (i = 0; i < MAXCPUS; i++) {                          for (i = 0; i < __arraycount(pc->pc_cpus); i++) {
                                 pool_cache_cpu_t *cc;                                  pool_cache_cpu_t *cc;
   
                                 if ((cc = pc->pc_cpus[i]) == NULL) {                                  if ((cc = pc->pc_cpus[i]) == NULL) {

Legend:
Removed from v.1.175  
changed lines
  Added in v.1.190.2.1

CVSweb <webmaster@jp.NetBSD.org>