[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.128.2.2 and 1.128.2.6

version 1.128.2.2, 2007/03/13 17:50:58 version 1.128.2.6, 2007/08/20 21:27:37
Line 54  __KERNEL_RCSID(0, "$NetBSD$");
Line 54  __KERNEL_RCSID(0, "$NetBSD$");
 #include <sys/pool.h>  #include <sys/pool.h>
 #include <sys/syslog.h>  #include <sys/syslog.h>
 #include <sys/debug.h>  #include <sys/debug.h>
   #include <sys/lockdebug.h>
   
 #include <uvm/uvm.h>  #include <uvm/uvm.h>
   
Line 771  pool_init(struct pool *pp, size_t size, 
Line 772  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;
   
         if (strcmp(wchan, "kmem-52") == 0) {  
                 printf("kmem-52 initted, mutex @ %p\n", &pp->pr_lock);  
                 printf("=> %x %x %x %x\n",  
                     ((uint32_t *)&pp->pr_lock)[0],  
                     ((uint32_t *)&pp->pr_lock)[1],  
                     ((uint32_t *)&pp->pr_lock)[2],  
                     ((uint32_t *)&pp->pr_lock)[3]);  
         }  
   
         /*          /*
          * Initialize private page header pool and cache magazine pool if we           * Initialize private page header pool and cache magazine pool if we
          * haven't done so yet.           * haven't done so yet.
Line 1157  pool_do_put(struct pool *pp, void *v, st
Line 1149  pool_do_put(struct pool *pp, void *v, st
   
         KASSERT(mutex_owned(&pp->pr_lock));          KASSERT(mutex_owned(&pp->pr_lock));
         FREECHECK_IN(&pp->pr_freecheck, v);          FREECHECK_IN(&pp->pr_freecheck, v);
           LOCKDEBUG_MEM_CHECK(v, pp->pr_size);
   
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         if (__predict_false(pp->pr_nout == 0)) {          if (__predict_false(pp->pr_nout == 0)) {
Line 1171  pool_do_put(struct pool *pp, void *v, st
Line 1164  pool_do_put(struct pool *pp, void *v, st
                 panic("pool_put: %s: page header missing", pp->pr_wchan);                  panic("pool_put: %s: page header missing", pp->pr_wchan);
         }          }
   
 #ifdef LOCKDEBUG  
         /*  
          * Check if we're freeing a locked simple lock.  
          */  
         simple_lock_freecheck(pi, (char *)pi + pp->pr_size);  
 #endif  
   
         /*          /*
          * Return to item list.           * Return to item list.
          */           */
Line 1213  pool_do_put(struct pool *pp, void *v, st
Line 1199  pool_do_put(struct pool *pp, void *v, st
                 pp->pr_flags &= ~PR_WANTED;                  pp->pr_flags &= ~PR_WANTED;
                 if (ph->ph_nmissing == 0)                  if (ph->ph_nmissing == 0)
                         pp->pr_nidle++;                          pp->pr_nidle++;
                 wakeup((void *)pp);                  cv_broadcast(&pp->pr_cv);
                 return;                  return;
         }          }
   
Line 1629  pool_reclaim(struct pool *pp)
Line 1615  pool_reclaim(struct pool *pp)
  * Drain pools, one at a time.   * Drain pools, one at a time.
  *   *
  * Note, we must never be called from an interrupt context.   * Note, we must never be called from an interrupt context.
    *
    * XXX Pool can disappear while draining.
  */   */
 void  void
 pool_drain(void *arg)  pool_drain(void *arg)
Line 2184  pool_cache_destruct_object(struct pool_c
Line 2172  pool_cache_destruct_object(struct pool_c
         pool_put(pc->pc_pool, object);          pool_put(pc->pc_pool, object);
 }  }
   
   /*
    * pool_do_cache_invalidate_grouplist:
    *
    *      Invalidate a single grouplist and destruct all objects.
    *      XXX This is too expensive.  We should swap the list then
    *      unlock.
    */
 static void  static void
 pool_do_cache_invalidate_grouplist(struct pool_cache_grouplist *pcgsl,  pool_do_cache_invalidate_grouplist(struct pool_cache_grouplist *pcgsl,
     struct pool_cache *pc, struct pool_pagelist *pq,      struct pool_cache *pc, struct pool_pagelist *pq,
     struct pool_cache_grouplist *pcgdl)      struct pool_cache_grouplist *pcgdl)
 {  {
         struct pool_cache_group *pcg, *npcg;          struct pool_cache_group *pcg;
         void *object;          void *object;
   
         for (pcg = LIST_FIRST(pcgsl); pcg != NULL; pcg = npcg) {          KASSERT(mutex_owned(&pc->pc_lock));
                 npcg = LIST_NEXT(pcg, pcg_list);          KASSERT(mutex_owned(&pc->pc_pool->pr_lock));
   
           while ((pcg = LIST_FIRST(pcgsl)) != NULL) {
                   pc->pc_ngroups--;
                   LIST_REMOVE(pcg, pcg_list);
                   LIST_INSERT_HEAD(pcgdl, pcg, pcg_list);
                   pc->pc_nitems -= pcg->pcg_avail;
                   mutex_exit(&pc->pc_pool->pr_lock);
                   mutex_exit(&pc->pc_lock);
   
                 while (pcg->pcg_avail != 0) {                  while (pcg->pcg_avail != 0) {
                         pc->pc_nitems--;  
                         object = pcg_get(pcg, NULL);                          object = pcg_get(pcg, NULL);
                         if (pc->pc_dtor != NULL)                          if (pc->pc_dtor != NULL)
                                 (*pc->pc_dtor)(pc->pc_arg, object);                                  (*pc->pc_dtor)(pc->pc_arg, object);
                           mutex_enter(&pc->pc_pool->pr_lock);
                         pool_do_put(pc->pc_pool, object, pq);                          pool_do_put(pc->pc_pool, object, pq);
                           mutex_exit(&pc->pc_pool->pr_lock);
                 }                  }
                 pc->pc_ngroups--;  
                 LIST_REMOVE(pcg, pcg_list);                  mutex_enter(&pc->pc_lock);
                 LIST_INSERT_HEAD(pcgdl, pcg, pcg_list);                  mutex_enter(&pc->pc_pool->pr_lock);
         }          }
 }  }
   
Legend:
Removed from v.1.128.2.2  
changed lines
  Added in v.1.128.2.6
CVSweb <webmaster@jp.NetBSD.org>