version 1.128.2.1, 2007/03/13 16:51:56 |
version 1.131.4.1, 2007/10/14 11:48:46 |
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); |
} |
} |
|
|