[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.137.2.4 and 1.138.2.1

version 1.137.2.4, 2007/12/26 17:55:57 version 1.138.2.1, 2007/12/10 08:56:56
Line 58  __KERNEL_RCSID(0, "$NetBSD$");
Line 58  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/lockdebug.h>  #include <sys/lockdebug.h>
 #include <sys/xcall.h>  #include <sys/xcall.h>
 #include <sys/cpu.h>  #include <sys/cpu.h>
 #include <sys/atomic.h>  
   
 #include <uvm/uvm.h>  #include <uvm/uvm.h>
   
Line 76  __KERNEL_RCSID(0, "$NetBSD$");
Line 75  __KERNEL_RCSID(0, "$NetBSD$");
  */   */
   
 /* List of all pools */  /* List of all pools */
 TAILQ_HEAD(,pool) pool_head = TAILQ_HEAD_INITIALIZER(pool_head);  LIST_HEAD(,pool) pool_head = LIST_HEAD_INITIALIZER(pool_head);
   
   /* List of all caches. */
   LIST_HEAD(,pool_cache) pool_cache_head =
       LIST_HEAD_INITIALIZER(pool_cache_head);
   
 /* Private pool for page header structures */  /* Private pool for page header structures */
 #define PHPOOL_MAX      8  #define PHPOOL_MAX      8
Line 182  static struct pool pcgpool;
Line 185  static struct pool pcgpool;
 static struct pool cache_pool;  static struct pool cache_pool;
 static struct pool cache_cpu_pool;  static struct pool cache_cpu_pool;
   
 /* List of all caches. */  
 TAILQ_HEAD(,pool_cache) pool_cache_head =  
     TAILQ_HEAD_INITIALIZER(pool_cache_head);  
   
 int pool_cache_disable;  
   
   
 static pool_cache_cpu_t *pool_cache_put_slow(pool_cache_cpu_t *, int *,  static pool_cache_cpu_t *pool_cache_put_slow(pool_cache_cpu_t *, int *,
                                              void *, paddr_t);                                               void *, paddr_t);
 static pool_cache_cpu_t *pool_cache_get_slow(pool_cache_cpu_t *, int *,  static pool_cache_cpu_t *pool_cache_get_slow(pool_cache_cpu_t *, int *,
Line 619  void
Line 615  void
 pool_init(struct pool *pp, size_t size, u_int align, u_int ioff, int flags,  pool_init(struct pool *pp, size_t size, u_int align, u_int ioff, int flags,
     const char *wchan, struct pool_allocator *palloc, int ipl)      const char *wchan, struct pool_allocator *palloc, int ipl)
 {  {
   #ifdef DEBUG
         struct pool *pp1;          struct pool *pp1;
   #endif
         size_t trysize, phsize;          size_t trysize, phsize;
         int off, slack;          int off, slack;
   
Line 628  pool_init(struct pool *pp, size_t size, 
Line 626  pool_init(struct pool *pp, size_t size, 
          * Check that the pool hasn't already been initialised and           * Check that the pool hasn't already been initialised and
          * added to the list of all pools.           * added to the list of all pools.
          */           */
         TAILQ_FOREACH(pp1, &pool_head, pr_poollist) {          LIST_FOREACH(pp1, &pool_head, pr_poollist) {
                 if (pp == pp1)                  if (pp == pp1)
                         panic("pool_init: pool %s already initialised",                          panic("pool_init: pool %s already initialised",
                             wchan);                              wchan);
Line 846  pool_init(struct pool *pp, size_t size, 
Line 844  pool_init(struct pool *pp, size_t size, 
                     "cachegrp", &pool_allocator_meta, IPL_VM);                      "cachegrp", &pool_allocator_meta, IPL_VM);
         }          }
   
         /* Insert into the list of all pools. */          if (__predict_true(!cold)) {
         if (__predict_true(!cold))                  /* Insert into the list of all pools. */
                 mutex_enter(&pool_head_lock);                  mutex_enter(&pool_head_lock);
         TAILQ_FOREACH(pp1, &pool_head, pr_poollist) {                  LIST_INSERT_HEAD(&pool_head, pp, pr_poollist);
                 if (strcmp(pp1->pr_wchan, pp->pr_wchan) > 0)  
                         break;  
         }  
         if (pp1 == NULL)  
                 TAILQ_INSERT_TAIL(&pool_head, pp, pr_poollist);  
         else  
                 TAILQ_INSERT_BEFORE(pp1, pp, pr_poollist);  
         if (__predict_true(!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))  
                 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))  
                 mutex_exit(&palloc->pa_lock);                  mutex_exit(&palloc->pa_lock);
           } else {
                   LIST_INSERT_HEAD(&pool_head, pp, pr_poollist);
                   TAILQ_INSERT_TAIL(&palloc->pa_list, pp, pr_alloc_list);
           }
   
         pool_reclaim_register(pp);          pool_reclaim_register(pp);
 }  }
Line 883  pool_destroy(struct pool *pp)
Line 875  pool_destroy(struct pool *pp)
         mutex_enter(&pool_head_lock);          mutex_enter(&pool_head_lock);
         while (pp->pr_refcnt != 0)          while (pp->pr_refcnt != 0)
                 cv_wait(&pool_busy, &pool_head_lock);                  cv_wait(&pool_busy, &pool_head_lock);
         TAILQ_REMOVE(&pool_head, pp, pr_poollist);          LIST_REMOVE(pp, pr_poollist);
         if (drainpp == pp)          if (drainpp == pp)
                 drainpp = NULL;                  drainpp = NULL;
         mutex_exit(&pool_head_lock);          mutex_exit(&pool_head_lock);
Line 1689  pool_drain_start(struct pool **ppp, uint
Line 1681  pool_drain_start(struct pool **ppp, uint
 {  {
         struct pool *pp;          struct pool *pp;
   
         KASSERT(!TAILQ_EMPTY(&pool_head));          KASSERT(!LIST_EMPTY(&pool_head));
   
         pp = NULL;          pp = NULL;
   
Line 1697  pool_drain_start(struct pool **ppp, uint
Line 1689  pool_drain_start(struct pool **ppp, uint
         mutex_enter(&pool_head_lock);          mutex_enter(&pool_head_lock);
         do {          do {
                 if (drainpp == NULL) {                  if (drainpp == NULL) {
                         drainpp = TAILQ_FIRST(&pool_head);                          drainpp = LIST_FIRST(&pool_head);
                 }                  }
                 if (drainpp != NULL) {                  if (drainpp != NULL) {
                         pp = drainpp;                          pp = drainpp;
                         drainpp = TAILQ_NEXT(pp, pr_poollist);                          drainpp = LIST_NEXT(pp, pr_poollist);
                 }                  }
                 /*                  /*
                  * Skip completely idle pools.  We depend on at least                   * Skip completely idle pools.  We depend on at least
Line 1757  pool_printall(const char *modif, void (*
Line 1749  pool_printall(const char *modif, void (*
 {  {
         struct pool *pp;          struct pool *pp;
   
         TAILQ_FOREACH(pp, &pool_head, pr_poollist) {          LIST_FOREACH(pp, &pool_head, pr_poollist) {
                 pool_printit(pp, modif, pr);                  pool_printit(pp, modif, pr);
         }          }
 }  }
Line 2047  pool_cache_bootstrap(pool_cache_t pc, si
Line 2039  pool_cache_bootstrap(pool_cache_t pc, si
     void *arg)      void *arg)
 {  {
         CPU_INFO_ITERATOR cii;          CPU_INFO_ITERATOR cii;
         pool_cache_t pc1;  
         struct cpu_info *ci;          struct cpu_info *ci;
         struct pool *pp;          struct pool *pp;
   
Line 2098  pool_cache_bootstrap(pool_cache_t pc, si
Line 2089  pool_cache_bootstrap(pool_cache_t pc, si
                         pool_cache_cpu_init1(ci, pc);                          pool_cache_cpu_init1(ci, pc);
                 }                  }
         }          }
   
         /* Add to list of all pools. */          if (__predict_true(!cold)) {
         if (__predict_true(!cold))                  mutex_enter(&pp->pr_lock);
                   pp->pr_cache = pc;
                   mutex_exit(&pp->pr_lock);
                 mutex_enter(&pool_head_lock);                  mutex_enter(&pool_head_lock);
         TAILQ_FOREACH(pc1, &pool_cache_head, pc_cachelist) {                  LIST_INSERT_HEAD(&pool_cache_head, pc, pc_cachelist);
                 if (strcmp(pc1->pc_pool.pr_wchan, pc->pc_pool.pr_wchan) > 0)  
                         break;  
         }  
         if (pc1 == NULL)  
                 TAILQ_INSERT_TAIL(&pool_cache_head, pc, pc_cachelist);  
         else  
                 TAILQ_INSERT_BEFORE(pc1, pc, pc_cachelist);  
         if (__predict_true(!cold))  
                 mutex_exit(&pool_head_lock);                  mutex_exit(&pool_head_lock);
           } else {
         membar_sync();                  pp->pr_cache = pc;
         pp->pr_cache = pc;                  LIST_INSERT_HEAD(&pool_cache_head, pc, pc_cachelist);
           }
 }  }
   
 /*  /*
Line 2125  pool_cache_bootstrap(pool_cache_t pc, si
Line 2111  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:
    *
    *      Kernel-private version of pool_cache_destroy().
    *      Destroy a pool cache initialized by pool_cache_bootstrap.
    */
   void
   pool_cache_bootstrap_destroy(pool_cache_t pc)
   {
         struct pool *pp = &pc->pc_pool;          struct pool *pp = &pc->pc_pool;
         pool_cache_cpu_t *cc;          pool_cache_cpu_t *cc;
         pcg_t *pcg;          pcg_t *pcg;
Line 2134  pool_cache_destroy(pool_cache_t pc)
Line 2134  pool_cache_destroy(pool_cache_t pc)
         mutex_enter(&pool_head_lock);          mutex_enter(&pool_head_lock);
         while (pc->pc_refcnt != 0)          while (pc->pc_refcnt != 0)
                 cv_wait(&pool_busy, &pool_head_lock);                  cv_wait(&pool_busy, &pool_head_lock);
         TAILQ_REMOVE(&pool_cache_head, pc, pc_cachelist);          LIST_REMOVE(pc, pc_cachelist);
         mutex_exit(&pool_head_lock);          mutex_exit(&pool_head_lock);
   
         /* First, invalidate the entire cache. */          /* First, invalidate the entire cache. */
Line 2164  pool_cache_destroy(pool_cache_t pc)
Line 2164  pool_cache_destroy(pool_cache_t pc)
         /* 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 2225  pool_cache_cpu_init(struct cpu_info *ci)
Line 2224  pool_cache_cpu_init(struct cpu_info *ci)
         pool_cache_t pc;          pool_cache_t pc;
   
         mutex_enter(&pool_head_lock);          mutex_enter(&pool_head_lock);
         TAILQ_FOREACH(pc, &pool_cache_head, pc_cachelist) {          LIST_FOREACH(pc, &pool_cache_head, pc_cachelist) {
                 pc->pc_refcnt++;                  pc->pc_refcnt++;
                 mutex_exit(&pool_head_lock);                  mutex_exit(&pool_head_lock);
   
Line 2604  pool_cache_put_slow(pool_cache_cpu_t *cc
Line 2603  pool_cache_put_slow(pool_cache_cpu_t *cc
          * If we can't allocate a new group, just throw the           * If we can't allocate a new group, just throw the
          * object away.           * object away.
          */           */
         if (pool_cache_disable) {          pcg = pool_get(&pcgpool, PR_NOWAIT);
                 pcg = NULL;  
         } else {  
                 pcg = pool_get(&pcgpool, PR_NOWAIT);  
         }  
         if (pcg == NULL) {          if (pcg == NULL) {
                 pool_cache_destruct_object(pc, object);                  pool_cache_destruct_object(pc, object);
                 return NULL;                  return NULL;

Legend:
Removed from v.1.137.2.4  
changed lines
  Added in v.1.138.2.1

CVSweb <webmaster@jp.NetBSD.org>