version 1.128, 2007/03/04 06:03:07 |
version 1.129.12.2, 2007/10/26 15:48:40 |
Line 560 pool_subsystem_init(void) |
|
Line 560 pool_subsystem_init(void) |
|
__link_set_foreach(pi, pools) |
__link_set_foreach(pi, pools) |
pool_init((*pi)->pp, (*pi)->size, (*pi)->align, |
pool_init((*pi)->pp, (*pi)->size, (*pi)->align, |
(*pi)->align_offset, (*pi)->flags, (*pi)->wchan, |
(*pi)->align_offset, (*pi)->flags, (*pi)->wchan, |
(*pi)->palloc); |
(*pi)->palloc, (*pi)->ipl); |
|
|
while ((pa = SLIST_FIRST(&pa_deferinitq)) != NULL) { |
while ((pa = SLIST_FIRST(&pa_deferinitq)) != NULL) { |
KASSERT(pa->pa_backingmapptr != NULL); |
KASSERT(pa->pa_backingmapptr != NULL); |
Line 578 pool_subsystem_init(void) |
|
Line 578 pool_subsystem_init(void) |
|
*/ |
*/ |
void |
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) |
const char *wchan, struct pool_allocator *palloc, int ipl) |
{ |
{ |
#ifdef DEBUG |
#ifdef DEBUG |
struct pool *pp1; |
struct pool *pp1; |
Line 792 pool_init(struct pool *pp, size_t size, |
|
Line 792 pool_init(struct pool *pp, size_t size, |
|
+ nelem * sizeof(pool_item_freelist_t); |
+ nelem * sizeof(pool_item_freelist_t); |
} |
} |
pool_init(&phpool[idx], sz, 0, 0, 0, |
pool_init(&phpool[idx], sz, 0, 0, 0, |
phpool_names[idx], &pool_allocator_meta); |
phpool_names[idx], &pool_allocator_meta, IPL_VM); |
} |
} |
#ifdef POOL_SUBPAGE |
#ifdef POOL_SUBPAGE |
pool_init(&psppool, POOL_SUBPAGE, POOL_SUBPAGE, 0, |
pool_init(&psppool, POOL_SUBPAGE, POOL_SUBPAGE, 0, |
PR_RECURSIVE, "psppool", &pool_allocator_meta); |
PR_RECURSIVE, "psppool", &pool_allocator_meta, IPL_VM); |
#endif |
#endif |
pool_init(&pcgpool, sizeof(struct pool_cache_group), 0, 0, |
pool_init(&pcgpool, sizeof(struct pool_cache_group), 0, 0, |
0, "pcgpool", &pool_allocator_meta); |
0, "pcgpool", &pool_allocator_meta, IPL_VM); |
} |
} |
|
|
/* Insert into the list of all pools. */ |
/* Insert into the list of all pools. */ |
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); |
} |
} |
|
|