[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.129 and 1.129.12.2

version 1.129, 2007/03/12 18:18:34 version 1.129.12.2, 2007/10/26 15:48:40
Line 1166  pool_do_put(struct pool *pp, void *v, st
Line 1166  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 1624  pool_reclaim(struct pool *pp)
Line 1617  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 2179  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) {          LOCK_ASSERT(simple_lock_held(&pc->pc_slock));
                 npcg = LIST_NEXT(pcg, pcg_list);          LOCK_ASSERT(simple_lock_held(&pc->pc_pool->pr_slock));
   
           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;
                   simple_unlock(&pc->pc_pool->pr_slock);
                   simple_unlock(&pc->pc_slock);
   
                 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);
                           simple_lock(&pc->pc_pool->pr_slock);
                         pool_do_put(pc->pc_pool, object, pq);                          pool_do_put(pc->pc_pool, object, pq);
                           simple_unlock(&pc->pc_pool->pr_slock);
                 }                  }
                 pc->pc_ngroups--;  
                 LIST_REMOVE(pcg, pcg_list);                  simple_lock(&pc->pc_slock);
                 LIST_INSERT_HEAD(pcgdl, pcg, pcg_list);                  simple_lock(&pc->pc_pool->pr_slock);
         }          }
 }  }
   
Line 2341  pool_allocator_alloc(struct pool *pp, in
Line 2353  pool_allocator_alloc(struct pool *pp, in
         struct pool_allocator *pa = pp->pr_alloc;          struct pool_allocator *pa = pp->pr_alloc;
         void *res;          void *res;
   
         LOCK_ASSERT(!simple_lock_held(&pp->pr_slock));  
   
         res = (*pa->pa_alloc)(pp, flags);          res = (*pa->pa_alloc)(pp, flags);
         if (res == NULL && (flags & PR_WAITOK) == 0) {          if (res == NULL && (flags & PR_WAITOK) == 0) {
                 /*                  /*
Line 2363  pool_allocator_free(struct pool *pp, voi
Line 2373  pool_allocator_free(struct pool *pp, voi
 {  {
         struct pool_allocator *pa = pp->pr_alloc;          struct pool_allocator *pa = pp->pr_alloc;
   
         LOCK_ASSERT(!simple_lock_held(&pp->pr_slock));  
   
         (*pa->pa_free)(pp, v);          (*pa->pa_free)(pp, v);
 }  }
   
Legend:
Removed from v.1.129  
changed lines
  Added in v.1.129.12.2
CVSweb <webmaster@jp.NetBSD.org>