version 1.112.2.5, 2006/08/11 15:45:46 |
version 1.128.2.5, 2007/07/29 11:34:47 |
|
|
/* $NetBSD$ */ |
/* $NetBSD$ */ |
|
|
/*- |
/*- |
* Copyright (c) 1997, 1999, 2000 The NetBSD Foundation, Inc. |
* Copyright (c) 1997, 1999, 2000, 2002, 2007 The NetBSD Foundation, Inc. |
* All rights reserved. |
* All rights reserved. |
* |
* |
* This code is derived from software contributed to The NetBSD Foundation |
* This code is derived from software contributed to The NetBSD Foundation |
Line 53 __KERNEL_RCSID(0, "$NetBSD$"); |
|
Line 53 __KERNEL_RCSID(0, "$NetBSD$"); |
|
#include <sys/lock.h> |
#include <sys/lock.h> |
#include <sys/pool.h> |
#include <sys/pool.h> |
#include <sys/syslog.h> |
#include <sys/syslog.h> |
|
#include <sys/debug.h> |
|
#include <sys/lockdebug.h> |
|
|
#include <uvm/uvm.h> |
#include <uvm/uvm.h> |
|
|
Line 100 int pool_inactive_time = 10; |
|
Line 102 int pool_inactive_time = 10; |
|
/* Next candidate for drainage (see pool_drain()) */ |
/* Next candidate for drainage (see pool_drain()) */ |
static struct pool *drainpp; |
static struct pool *drainpp; |
|
|
/* This spin lock protects both pool_head and drainpp. */ |
/* This lock protects both pool_head and drainpp. */ |
struct simplelock pool_head_slock = SIMPLELOCK_INITIALIZER; |
static kmutex_t pool_head_lock; |
|
|
typedef uint8_t pool_item_freelist_t; |
typedef uint8_t pool_item_freelist_t; |
|
|
Line 111 struct pool_item_header { |
|
Line 113 struct pool_item_header { |
|
ph_pagelist; /* pool page list */ |
ph_pagelist; /* pool page list */ |
SPLAY_ENTRY(pool_item_header) |
SPLAY_ENTRY(pool_item_header) |
ph_node; /* Off-page page headers */ |
ph_node; /* Off-page page headers */ |
caddr_t ph_page; /* this page's address */ |
void * ph_page; /* this page's address */ |
struct timeval ph_time; /* last referenced */ |
struct timeval ph_time; /* last referenced */ |
union { |
union { |
/* !PR_NOTOUCH */ |
/* !PR_NOTOUCH */ |
Line 183 static void pool_cache_reclaim(struct po |
|
Line 185 static void pool_cache_reclaim(struct po |
|
static void pcg_grouplist_free(struct pool_cache_grouplist *); |
static void pcg_grouplist_free(struct pool_cache_grouplist *); |
|
|
static int pool_catchup(struct pool *); |
static int pool_catchup(struct pool *); |
static void pool_prime_page(struct pool *, caddr_t, |
static void pool_prime_page(struct pool *, void *, |
struct pool_item_header *); |
struct pool_item_header *); |
static void pool_update_curpage(struct pool *); |
static void pool_update_curpage(struct pool *); |
|
|
Line 325 pr_item_notouch_index(const struct pool |
|
Line 327 pr_item_notouch_index(const struct pool |
|
int idx; |
int idx; |
|
|
KASSERT(pp->pr_roflags & PR_NOTOUCH); |
KASSERT(pp->pr_roflags & PR_NOTOUCH); |
idx = (cp - ph->ph_page - ph->ph_off) / pp->pr_size; |
idx = (cp - (char *)ph->ph_page - ph->ph_off) / pp->pr_size; |
KASSERT(idx < pp->pr_itemsperpage); |
KASSERT(idx < pp->pr_itemsperpage); |
return idx; |
return idx; |
} |
} |
Line 358 pr_item_notouch_get(const struct pool *p |
|
Line 360 pr_item_notouch_get(const struct pool *p |
|
ph->ph_firstfree = freelist[idx]; |
ph->ph_firstfree = freelist[idx]; |
freelist[idx] = PR_INDEX_USED; |
freelist[idx] = PR_INDEX_USED; |
|
|
return ph->ph_page + ph->ph_off + idx * pp->pr_size; |
return (char *)ph->ph_page + ph->ph_off + idx * pp->pr_size; |
} |
} |
|
|
static inline int |
static inline int |
phtree_compare(struct pool_item_header *a, struct pool_item_header *b) |
phtree_compare(struct pool_item_header *a, struct pool_item_header *b) |
{ |
{ |
|
|
|
/* |
|
* we consider pool_item_header with smaller ph_page bigger. |
|
* (this unnatural ordering is for the benefit of pr_find_pagehead.) |
|
*/ |
|
|
if (a->ph_page < b->ph_page) |
if (a->ph_page < b->ph_page) |
return (-1); |
|
else if (a->ph_page > b->ph_page) |
|
return (1); |
return (1); |
|
else if (a->ph_page > b->ph_page) |
|
return (-1); |
else |
else |
return (0); |
return (0); |
} |
} |
Line 376 SPLAY_PROTOTYPE(phtree, pool_item_header |
|
Line 384 SPLAY_PROTOTYPE(phtree, pool_item_header |
|
SPLAY_GENERATE(phtree, pool_item_header, ph_node, phtree_compare); |
SPLAY_GENERATE(phtree, pool_item_header, ph_node, phtree_compare); |
|
|
/* |
/* |
* Return the pool page header based on page address. |
* Return the pool page header based on item address. |
*/ |
*/ |
static inline struct pool_item_header * |
static inline struct pool_item_header * |
pr_find_pagehead(struct pool *pp, caddr_t page) |
pr_find_pagehead(struct pool *pp, void *v) |
{ |
{ |
struct pool_item_header *ph, tmp; |
struct pool_item_header *ph, tmp; |
|
|
if ((pp->pr_roflags & PR_PHINPAGE) != 0) |
if ((pp->pr_roflags & PR_NOALIGN) != 0) { |
return ((struct pool_item_header *)(page + pp->pr_phoffset)); |
tmp.ph_page = (void *)(uintptr_t)v; |
|
ph = SPLAY_FIND(phtree, &pp->pr_phtree, &tmp); |
|
if (ph == NULL) { |
|
ph = SPLAY_ROOT(&pp->pr_phtree); |
|
if (ph != NULL && phtree_compare(&tmp, ph) >= 0) { |
|
ph = SPLAY_NEXT(phtree, &pp->pr_phtree, ph); |
|
} |
|
KASSERT(ph == NULL || phtree_compare(&tmp, ph) < 0); |
|
} |
|
} else { |
|
void *page = |
|
(void *)((uintptr_t)v & pp->pr_alloc->pa_pagemask); |
|
|
|
if ((pp->pr_roflags & PR_PHINPAGE) != 0) { |
|
ph = (struct pool_item_header *)((char *)page + pp->pr_phoffset); |
|
} else { |
|
tmp.ph_page = page; |
|
ph = SPLAY_FIND(phtree, &pp->pr_phtree, &tmp); |
|
} |
|
} |
|
|
tmp.ph_page = page; |
KASSERT(ph == NULL || ((pp->pr_roflags & PR_PHINPAGE) != 0) || |
ph = SPLAY_FIND(phtree, &pp->pr_phtree, &tmp); |
((char *)ph->ph_page <= (char *)v && |
|
(char *)v < (char *)ph->ph_page + pp->pr_alloc->pa_pagesz)); |
return ph; |
return ph; |
} |
} |
|
|
|
|
pr_pagelist_free(struct pool *pp, struct pool_pagelist *pq) |
pr_pagelist_free(struct pool *pp, struct pool_pagelist *pq) |
{ |
{ |
struct pool_item_header *ph; |
struct pool_item_header *ph; |
int s; |
|
|
|
while ((ph = LIST_FIRST(pq)) != NULL) { |
while ((ph = LIST_FIRST(pq)) != NULL) { |
LIST_REMOVE(ph, ph_pagelist); |
LIST_REMOVE(ph, ph_pagelist); |
pool_allocator_free(pp, ph->ph_page); |
pool_allocator_free(pp, ph->ph_page); |
if ((pp->pr_roflags & PR_PHINPAGE) == 0) { |
if ((pp->pr_roflags & PR_PHINPAGE) == 0) |
s = splvm(); |
|
pool_put(pp->pr_phpool, ph); |
pool_put(pp->pr_phpool, ph); |
splx(s); |
|
} |
|
} |
} |
} |
} |
|
|
Line 416 pr_rmpage(struct pool *pp, struct pool_i |
|
Line 440 pr_rmpage(struct pool *pp, struct pool_i |
|
struct pool_pagelist *pq) |
struct pool_pagelist *pq) |
{ |
{ |
|
|
LOCK_ASSERT(simple_lock_held(&pp->pr_slock)); |
KASSERT(mutex_owned(&pp->pr_lock)); |
|
|
/* |
/* |
* If the page was idle, decrement the idle page count. |
* If the page was idle, decrement the idle page count. |
Line 447 pr_rmpage(struct pool *pp, struct pool_i |
|
Line 471 pr_rmpage(struct pool *pp, struct pool_i |
|
pool_update_curpage(pp); |
pool_update_curpage(pp); |
} |
} |
|
|
static boolean_t |
static bool |
pa_starved_p(struct pool_allocator *pa) |
pa_starved_p(struct pool_allocator *pa) |
{ |
{ |
|
|
if (pa->pa_backingmap != NULL) { |
if (pa->pa_backingmap != NULL) { |
return vm_map_starved_p(pa->pa_backingmap); |
return vm_map_starved_p(pa->pa_backingmap); |
} |
} |
return FALSE; |
return false; |
} |
} |
|
|
static int |
static int |
Line 530 pool_subsystem_init(void) |
|
Line 554 pool_subsystem_init(void) |
|
__link_set_decl(pools, struct link_pool_init); |
__link_set_decl(pools, struct link_pool_init); |
struct link_pool_init * const *pi; |
struct link_pool_init * const *pi; |
|
|
|
mutex_init(&pool_head_lock, MUTEX_DEFAULT, IPL_NONE); |
|
|
__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 551 pool_subsystem_init(void) |
|
Line 577 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; |
#endif |
#endif |
size_t trysize, phsize; |
size_t trysize, phsize; |
int off, slack, s; |
int off, slack; |
|
|
KASSERT((1UL << (CHAR_BIT * sizeof(pool_item_freelist_t))) - 2 >= |
KASSERT((1UL << (CHAR_BIT * sizeof(pool_item_freelist_t))) - 2 >= |
PHPOOL_FREELIST_NELEM(PHPOOL_MAX - 1)); |
PHPOOL_FREELIST_NELEM(PHPOOL_MAX - 1)); |
Line 598 pool_init(struct pool *pp, size_t size, |
|
Line 624 pool_init(struct pool *pp, size_t size, |
|
|
|
TAILQ_INIT(&palloc->pa_list); |
TAILQ_INIT(&palloc->pa_list); |
|
|
simple_lock_init(&palloc->pa_slock); |
mutex_init(&palloc->pa_lock, MUTEX_DRIVER, IPL_VM); |
palloc->pa_pagemask = ~(palloc->pa_pagesz - 1); |
palloc->pa_pagemask = ~(palloc->pa_pagesz - 1); |
palloc->pa_pageshift = ffs(palloc->pa_pagesz) - 1; |
palloc->pa_pageshift = ffs(palloc->pa_pagesz) - 1; |
|
|
Line 611 pool_init(struct pool *pp, size_t size, |
|
Line 637 pool_init(struct pool *pp, size_t size, |
|
if (align == 0) |
if (align == 0) |
align = ALIGN(1); |
align = ALIGN(1); |
|
|
if (size < sizeof(struct pool_item)) |
if ((flags & PR_NOTOUCH) == 0 && size < sizeof(struct pool_item)) |
size = sizeof(struct pool_item); |
size = sizeof(struct pool_item); |
|
|
size = roundup(size, align); |
size = roundup(size, align); |
#ifdef DIAGNOSTIC |
#ifdef DIAGNOSTIC |
if (size > palloc->pa_pagesz) |
if (size > palloc->pa_pagesz) |
panic("pool_init: pool item size (%lu) too large", |
panic("pool_init: pool item size (%zu) too large", size); |
(u_long)size); |
|
#endif |
#endif |
|
|
/* |
/* |
Line 649 pool_init(struct pool *pp, size_t size, |
|
Line 674 pool_init(struct pool *pp, size_t size, |
|
pp->pr_hardlimit_warning_last.tv_usec = 0; |
pp->pr_hardlimit_warning_last.tv_usec = 0; |
pp->pr_drain_hook = NULL; |
pp->pr_drain_hook = NULL; |
pp->pr_drain_hook_arg = NULL; |
pp->pr_drain_hook_arg = NULL; |
|
pp->pr_freecheck = NULL; |
|
|
/* |
/* |
* Decide whether to put the page header off page to avoid |
* Decide whether to put the page header off page to avoid |
Line 667 pool_init(struct pool *pp, size_t size, |
|
Line 693 pool_init(struct pool *pp, size_t size, |
|
/* See the comment below about reserved bytes. */ |
/* See the comment below about reserved bytes. */ |
trysize = palloc->pa_pagesz - ((align - ioff) % align); |
trysize = palloc->pa_pagesz - ((align - ioff) % align); |
phsize = ALIGN(sizeof(struct pool_item_header)); |
phsize = ALIGN(sizeof(struct pool_item_header)); |
if ((pp->pr_roflags & PR_NOTOUCH) == 0 && |
if ((pp->pr_roflags & (PR_NOTOUCH | PR_NOALIGN)) == 0 && |
(pp->pr_size < MIN(palloc->pa_pagesz / 16, phsize << 3) || |
(pp->pr_size < MIN(palloc->pa_pagesz / 16, phsize << 3) || |
trysize / pp->pr_size == (trysize - phsize) / pp->pr_size)) { |
trysize / pp->pr_size == (trysize - phsize) / pp->pr_size)) { |
/* Use the end of the page for the page header */ |
/* Use the end of the page for the page header */ |
Line 742 pool_init(struct pool *pp, size_t size, |
|
Line 768 pool_init(struct pool *pp, size_t size, |
|
pp->pr_entered_file = NULL; |
pp->pr_entered_file = NULL; |
pp->pr_entered_line = 0; |
pp->pr_entered_line = 0; |
|
|
simple_lock_init(&pp->pr_slock); |
mutex_init(&pp->pr_lock, MUTEX_DRIVER, ipl); |
|
cv_init(&pp->pr_cv, wchan); |
|
pp->pr_ipl = ipl; |
|
|
/* |
/* |
* Initialize private page header pool and cache magazine pool if we |
* Initialize private page header pool and cache magazine pool if we |
Line 765 pool_init(struct pool *pp, size_t size, |
|
Line 793 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); |
|
} |
|
|
|
if (__predict_true(!cold)) { |
|
/* Insert into the list of all pools. */ |
|
mutex_enter(&pool_head_lock); |
|
LIST_INSERT_HEAD(&pool_head, pp, pr_poollist); |
|
mutex_exit(&pool_head_lock); |
|
|
|
/* Insert this into the list of pools using this allocator. */ |
|
mutex_enter(&palloc->pa_lock); |
|
TAILQ_INSERT_TAIL(&palloc->pa_list, pp, pr_alloc_list); |
|
mutex_exit(&palloc->pa_lock); |
|
} else { |
|
LIST_INSERT_HEAD(&pool_head, pp, pr_poollist); |
|
TAILQ_INSERT_TAIL(&palloc->pa_list, pp, pr_alloc_list); |
} |
} |
|
|
/* Insert into the list of all pools. */ |
|
simple_lock(&pool_head_slock); |
|
LIST_INSERT_HEAD(&pool_head, pp, pr_poollist); |
|
simple_unlock(&pool_head_slock); |
|
|
|
/* Insert this into the list of pools using this allocator. */ |
|
s = splvm(); |
|
simple_lock(&palloc->pa_slock); |
|
TAILQ_INSERT_TAIL(&palloc->pa_list, pp, pr_alloc_list); |
|
simple_unlock(&palloc->pa_slock); |
|
splx(s); |
|
pool_reclaim_register(pp); |
pool_reclaim_register(pp); |
} |
} |
|
|
Line 797 pool_destroy(struct pool *pp) |
|
Line 829 pool_destroy(struct pool *pp) |
|
{ |
{ |
struct pool_pagelist pq; |
struct pool_pagelist pq; |
struct pool_item_header *ph; |
struct pool_item_header *ph; |
int s; |
|
|
|
/* Remove from global pool list */ |
/* Remove from global pool list */ |
simple_lock(&pool_head_slock); |
mutex_enter(&pool_head_lock); |
LIST_REMOVE(pp, pr_poollist); |
LIST_REMOVE(pp, pr_poollist); |
if (drainpp == pp) |
if (drainpp == pp) |
drainpp = NULL; |
drainpp = NULL; |
simple_unlock(&pool_head_slock); |
mutex_exit(&pool_head_lock); |
|
|
/* Remove this pool from its allocator's list of pools. */ |
/* Remove this pool from its allocator's list of pools. */ |
pool_reclaim_unregister(pp); |
pool_reclaim_unregister(pp); |
s = splvm(); |
mutex_enter(&pp->pr_alloc->pa_lock); |
simple_lock(&pp->pr_alloc->pa_slock); |
|
TAILQ_REMOVE(&pp->pr_alloc->pa_list, pp, pr_alloc_list); |
TAILQ_REMOVE(&pp->pr_alloc->pa_list, pp, pr_alloc_list); |
simple_unlock(&pp->pr_alloc->pa_slock); |
mutex_exit(&pp->pr_alloc->pa_lock); |
splx(s); |
|
|
|
s = splvm(); |
mutex_enter(&pp->pr_lock); |
simple_lock(&pp->pr_slock); |
|
|
|
KASSERT(LIST_EMPTY(&pp->pr_cachelist)); |
KASSERT(LIST_EMPTY(&pp->pr_cachelist)); |
|
|
Line 835 pool_destroy(struct pool *pp) |
|
Line 863 pool_destroy(struct pool *pp) |
|
while ((ph = LIST_FIRST(&pp->pr_emptypages)) != NULL) |
while ((ph = LIST_FIRST(&pp->pr_emptypages)) != NULL) |
pr_rmpage(pp, ph, &pq); |
pr_rmpage(pp, ph, &pq); |
|
|
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
splx(s); |
|
|
|
pr_pagelist_free(pp, &pq); |
pr_pagelist_free(pp, &pq); |
|
|
Line 844 pool_destroy(struct pool *pp) |
|
Line 871 pool_destroy(struct pool *pp) |
|
if ((pp->pr_roflags & PR_LOGGING) != 0) |
if ((pp->pr_roflags & PR_LOGGING) != 0) |
free(pp->pr_log, M_TEMP); |
free(pp->pr_log, M_TEMP); |
#endif |
#endif |
|
|
|
cv_destroy(&pp->pr_cv); |
|
mutex_destroy(&pp->pr_lock); |
} |
} |
|
|
void |
void |
Line 860 pool_set_drain_hook(struct pool *pp, voi |
|
Line 890 pool_set_drain_hook(struct pool *pp, voi |
|
} |
} |
|
|
static struct pool_item_header * |
static struct pool_item_header * |
pool_alloc_item_header(struct pool *pp, caddr_t storage, int flags) |
pool_alloc_item_header(struct pool *pp, void *storage, int flags) |
{ |
{ |
struct pool_item_header *ph; |
struct pool_item_header *ph; |
int s; |
|
|
|
LOCK_ASSERT(simple_lock_held(&pp->pr_slock) == 0); |
|
|
|
if ((pp->pr_roflags & PR_PHINPAGE) != 0) |
if ((pp->pr_roflags & PR_PHINPAGE) != 0) |
ph = (struct pool_item_header *) (storage + pp->pr_phoffset); |
ph = (struct pool_item_header *) ((char *)storage + pp->pr_phoffset); |
else { |
else |
s = splvm(); |
|
ph = pool_get(pp->pr_phpool, flags); |
ph = pool_get(pp->pr_phpool, flags); |
splx(s); |
|
} |
|
|
|
return (ph); |
return (ph); |
} |
} |
Line 904 pool_get(struct pool *pp, int flags) |
|
Line 928 pool_get(struct pool *pp, int flags) |
|
#ifdef LOCKDEBUG |
#ifdef LOCKDEBUG |
if (flags & PR_WAITOK) |
if (flags & PR_WAITOK) |
ASSERT_SLEEPABLE(NULL, "pool_get(PR_WAITOK)"); |
ASSERT_SLEEPABLE(NULL, "pool_get(PR_WAITOK)"); |
SCHED_ASSERT_UNLOCKED(); |
|
#endif |
#endif |
|
|
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
pr_enter(pp, file, line); |
pr_enter(pp, file, line); |
|
|
startover: |
startover: |
Line 919 pool_get(struct pool *pp, int flags) |
|
Line 942 pool_get(struct pool *pp, int flags) |
|
#ifdef DIAGNOSTIC |
#ifdef DIAGNOSTIC |
if (__predict_false(pp->pr_nout > pp->pr_hardlimit)) { |
if (__predict_false(pp->pr_nout > pp->pr_hardlimit)) { |
pr_leave(pp); |
pr_leave(pp); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
panic("pool_get: %s: crossed hard limit", pp->pr_wchan); |
panic("pool_get: %s: crossed hard limit", pp->pr_wchan); |
} |
} |
#endif |
#endif |
Line 931 pool_get(struct pool *pp, int flags) |
|
Line 954 pool_get(struct pool *pp, int flags) |
|
* and check the hardlimit condition again. |
* and check the hardlimit condition again. |
*/ |
*/ |
pr_leave(pp); |
pr_leave(pp); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
(*pp->pr_drain_hook)(pp->pr_drain_hook_arg, flags); |
(*pp->pr_drain_hook)(pp->pr_drain_hook_arg, flags); |
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
pr_enter(pp, file, line); |
pr_enter(pp, file, line); |
if (pp->pr_nout < pp->pr_hardlimit) |
if (pp->pr_nout < pp->pr_hardlimit) |
goto startover; |
goto startover; |
Line 946 pool_get(struct pool *pp, int flags) |
|
Line 969 pool_get(struct pool *pp, int flags) |
|
*/ |
*/ |
pp->pr_flags |= PR_WANTED; |
pp->pr_flags |= PR_WANTED; |
pr_leave(pp); |
pr_leave(pp); |
ltsleep(pp, PSWP, pp->pr_wchan, 0, &pp->pr_slock); |
cv_wait(&pp->pr_cv, &pp->pr_lock); |
pr_enter(pp, file, line); |
pr_enter(pp, file, line); |
goto startover; |
goto startover; |
} |
} |
Line 962 pool_get(struct pool *pp, int flags) |
|
Line 985 pool_get(struct pool *pp, int flags) |
|
pp->pr_nfail++; |
pp->pr_nfail++; |
|
|
pr_leave(pp); |
pr_leave(pp); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
return (NULL); |
return (NULL); |
} |
} |
|
|
Line 977 pool_get(struct pool *pp, int flags) |
|
Line 1000 pool_get(struct pool *pp, int flags) |
|
|
|
#ifdef DIAGNOSTIC |
#ifdef DIAGNOSTIC |
if (pp->pr_nitems != 0) { |
if (pp->pr_nitems != 0) { |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
printf("pool_get: %s: curpage NULL, nitems %u\n", |
printf("pool_get: %s: curpage NULL, nitems %u\n", |
pp->pr_wchan, pp->pr_nitems); |
pp->pr_wchan, pp->pr_nitems); |
panic("pool_get: nitems inconsistent"); |
panic("pool_get: nitems inconsistent"); |
Line 1004 pool_get(struct pool *pp, int flags) |
|
Line 1027 pool_get(struct pool *pp, int flags) |
|
|
|
pp->pr_nfail++; |
pp->pr_nfail++; |
pr_leave(pp); |
pr_leave(pp); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
return (NULL); |
return (NULL); |
} |
} |
|
|
Line 1015 pool_get(struct pool *pp, int flags) |
|
Line 1038 pool_get(struct pool *pp, int flags) |
|
#ifdef DIAGNOSTIC |
#ifdef DIAGNOSTIC |
if (__predict_false(ph->ph_nmissing == pp->pr_itemsperpage)) { |
if (__predict_false(ph->ph_nmissing == pp->pr_itemsperpage)) { |
pr_leave(pp); |
pr_leave(pp); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
panic("pool_get: %s: page empty", pp->pr_wchan); |
panic("pool_get: %s: page empty", pp->pr_wchan); |
} |
} |
#endif |
#endif |
Line 1027 pool_get(struct pool *pp, int flags) |
|
Line 1050 pool_get(struct pool *pp, int flags) |
|
v = pi = LIST_FIRST(&ph->ph_itemlist); |
v = pi = LIST_FIRST(&ph->ph_itemlist); |
if (__predict_false(v == NULL)) { |
if (__predict_false(v == NULL)) { |
pr_leave(pp); |
pr_leave(pp); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
panic("pool_get: %s: page empty", pp->pr_wchan); |
panic("pool_get: %s: page empty", pp->pr_wchan); |
} |
} |
#ifdef DIAGNOSTIC |
#ifdef DIAGNOSTIC |
if (__predict_false(pp->pr_nitems == 0)) { |
if (__predict_false(pp->pr_nitems == 0)) { |
pr_leave(pp); |
pr_leave(pp); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
printf("pool_get: %s: items on itemlist, nitems %u\n", |
printf("pool_get: %s: items on itemlist, nitems %u\n", |
pp->pr_wchan, pp->pr_nitems); |
pp->pr_wchan, pp->pr_nitems); |
panic("pool_get: nitems inconsistent"); |
panic("pool_get: nitems inconsistent"); |
Line 1080 pool_get(struct pool *pp, int flags) |
|
Line 1103 pool_get(struct pool *pp, int flags) |
|
if (__predict_false((pp->pr_roflags & PR_NOTOUCH) == 0 && |
if (__predict_false((pp->pr_roflags & PR_NOTOUCH) == 0 && |
!LIST_EMPTY(&ph->ph_itemlist))) { |
!LIST_EMPTY(&ph->ph_itemlist))) { |
pr_leave(pp); |
pr_leave(pp); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
panic("pool_get: %s: nmissing inconsistent", |
panic("pool_get: %s: nmissing inconsistent", |
pp->pr_wchan); |
pp->pr_wchan); |
} |
} |
Line 1109 pool_get(struct pool *pp, int flags) |
|
Line 1132 pool_get(struct pool *pp, int flags) |
|
*/ |
*/ |
} |
} |
|
|
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
|
KASSERT((((vaddr_t)v + pp->pr_itemoffset) & (pp->pr_align - 1)) == 0); |
|
FREECHECK_OUT(&pp->pr_freecheck, v); |
return (v); |
return (v); |
} |
} |
|
|
Line 1121 pool_do_put(struct pool *pp, void *v, st |
|
Line 1146 pool_do_put(struct pool *pp, void *v, st |
|
{ |
{ |
struct pool_item *pi = v; |
struct pool_item *pi = v; |
struct pool_item_header *ph; |
struct pool_item_header *ph; |
caddr_t page; |
|
|
|
LOCK_ASSERT(simple_lock_held(&pp->pr_slock)); |
KASSERT(mutex_owned(&pp->pr_lock)); |
SCHED_ASSERT_UNLOCKED(); |
FREECHECK_IN(&pp->pr_freecheck, v); |
|
LOCKDEBUG_MEM_CHECK(v, pp->pr_size); |
page = (caddr_t)((u_long)v & pp->pr_alloc->pa_pagemask); |
|
|
|
#ifdef DIAGNOSTIC |
#ifdef DIAGNOSTIC |
if (__predict_false(pp->pr_nout == 0)) { |
if (__predict_false(pp->pr_nout == 0)) { |
Line 1136 pool_do_put(struct pool *pp, void *v, st |
|
Line 1159 pool_do_put(struct pool *pp, void *v, st |
|
} |
} |
#endif |
#endif |
|
|
if (__predict_false((ph = pr_find_pagehead(pp, page)) == NULL)) { |
if (__predict_false((ph = pr_find_pagehead(pp, v)) == NULL)) { |
pr_printlog(pp, NULL, printf); |
pr_printlog(pp, NULL, printf); |
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((caddr_t)pi, ((caddr_t)pi) + pp->pr_size); |
|
#endif |
|
|
|
/* |
/* |
* Return to item list. |
* Return to item list. |
*/ |
*/ |
Line 1183 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((caddr_t)pp); |
cv_broadcast(&pp->pr_cv); |
return; |
return; |
} |
} |
|
|
Line 1245 _pool_put(struct pool *pp, void *v, cons |
|
Line 1261 _pool_put(struct pool *pp, void *v, cons |
|
|
|
LIST_INIT(&pq); |
LIST_INIT(&pq); |
|
|
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
pr_enter(pp, file, line); |
pr_enter(pp, file, line); |
|
|
pr_log(pp, v, PRLOG_PUT, file, line); |
pr_log(pp, v, PRLOG_PUT, file, line); |
Line 1253 _pool_put(struct pool *pp, void *v, cons |
|
Line 1269 _pool_put(struct pool *pp, void *v, cons |
|
pool_do_put(pp, v, &pq); |
pool_do_put(pp, v, &pq); |
|
|
pr_leave(pp); |
pr_leave(pp); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
|
|
pr_pagelist_free(pp, &pq); |
pr_pagelist_free(pp, &pq); |
} |
} |
Line 1267 pool_put(struct pool *pp, void *v) |
|
Line 1283 pool_put(struct pool *pp, void *v) |
|
|
|
LIST_INIT(&pq); |
LIST_INIT(&pq); |
|
|
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
pool_do_put(pp, v, &pq); |
pool_do_put(pp, v, &pq); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
|
|
pr_pagelist_free(pp, &pq); |
pr_pagelist_free(pp, &pq); |
} |
} |
Line 1292 pool_grow(struct pool *pp, int flags) |
|
Line 1308 pool_grow(struct pool *pp, int flags) |
|
struct pool_item_header *ph = NULL; |
struct pool_item_header *ph = NULL; |
char *cp; |
char *cp; |
|
|
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
cp = pool_allocator_alloc(pp, flags); |
cp = pool_allocator_alloc(pp, flags); |
if (__predict_true(cp != NULL)) { |
if (__predict_true(cp != NULL)) { |
ph = pool_alloc_item_header(pp, cp, flags); |
ph = pool_alloc_item_header(pp, cp, flags); |
Line 1301 pool_grow(struct pool *pp, int flags) |
|
Line 1317 pool_grow(struct pool *pp, int flags) |
|
if (cp != NULL) { |
if (cp != NULL) { |
pool_allocator_free(pp, cp); |
pool_allocator_free(pp, cp); |
} |
} |
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
return ENOMEM; |
return ENOMEM; |
} |
} |
|
|
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
pool_prime_page(pp, cp, ph); |
pool_prime_page(pp, cp, ph); |
pp->pr_npagealloc++; |
pp->pr_npagealloc++; |
return 0; |
return 0; |
Line 1320 pool_prime(struct pool *pp, int n) |
|
Line 1336 pool_prime(struct pool *pp, int n) |
|
int newpages; |
int newpages; |
int error = 0; |
int error = 0; |
|
|
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
|
|
newpages = roundup(n, pp->pr_itemsperpage) / pp->pr_itemsperpage; |
newpages = roundup(n, pp->pr_itemsperpage) / pp->pr_itemsperpage; |
|
|
Line 1335 pool_prime(struct pool *pp, int n) |
|
Line 1351 pool_prime(struct pool *pp, int n) |
|
if (pp->pr_minpages >= pp->pr_maxpages) |
if (pp->pr_minpages >= pp->pr_maxpages) |
pp->pr_maxpages = pp->pr_minpages + 1; /* XXX */ |
pp->pr_maxpages = pp->pr_minpages + 1; /* XXX */ |
|
|
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
return error; |
return error; |
} |
} |
|
|
Line 1345 pool_prime(struct pool *pp, int n) |
|
Line 1361 pool_prime(struct pool *pp, int n) |
|
* Note, we must be called with the pool descriptor LOCKED. |
* Note, we must be called with the pool descriptor LOCKED. |
*/ |
*/ |
static void |
static void |
pool_prime_page(struct pool *pp, caddr_t storage, struct pool_item_header *ph) |
pool_prime_page(struct pool *pp, void *storage, struct pool_item_header *ph) |
{ |
{ |
struct pool_item *pi; |
struct pool_item *pi; |
caddr_t cp = storage; |
void *cp = storage; |
unsigned int align = pp->pr_align; |
const unsigned int align = pp->pr_align; |
unsigned int ioff = pp->pr_itemoffset; |
const unsigned int ioff = pp->pr_itemoffset; |
int n; |
int n; |
|
|
LOCK_ASSERT(simple_lock_held(&pp->pr_slock)); |
KASSERT(mutex_owned(&pp->pr_lock)); |
|
|
#ifdef DIAGNOSTIC |
#ifdef DIAGNOSTIC |
if (((u_long)cp & (pp->pr_alloc->pa_pagesz - 1)) != 0) |
if ((pp->pr_roflags & PR_NOALIGN) == 0 && |
|
((uintptr_t)cp & (pp->pr_alloc->pa_pagesz - 1)) != 0) |
panic("pool_prime_page: %s: unaligned page", pp->pr_wchan); |
panic("pool_prime_page: %s: unaligned page", pp->pr_wchan); |
#endif |
#endif |
|
|
Line 1376 pool_prime_page(struct pool *pp, caddr_t |
|
Line 1393 pool_prime_page(struct pool *pp, caddr_t |
|
/* |
/* |
* Color this page. |
* Color this page. |
*/ |
*/ |
cp = (caddr_t)(cp + pp->pr_curcolor); |
cp = (char *)cp + pp->pr_curcolor; |
if ((pp->pr_curcolor += align) > pp->pr_maxcolor) |
if ((pp->pr_curcolor += align) > pp->pr_maxcolor) |
pp->pr_curcolor = 0; |
pp->pr_curcolor = 0; |
|
|
Line 1384 pool_prime_page(struct pool *pp, caddr_t |
|
Line 1401 pool_prime_page(struct pool *pp, caddr_t |
|
* Adjust storage to apply aligment to `pr_itemoffset' in each item. |
* Adjust storage to apply aligment to `pr_itemoffset' in each item. |
*/ |
*/ |
if (ioff != 0) |
if (ioff != 0) |
cp = (caddr_t)(cp + (align - ioff)); |
cp = (char *)cp + align - ioff; |
|
|
|
KASSERT((((vaddr_t)cp + ioff) & (align - 1)) == 0); |
|
|
/* |
/* |
* Insert remaining chunks on the bucket list. |
* Insert remaining chunks on the bucket list. |
Line 1396 pool_prime_page(struct pool *pp, caddr_t |
|
Line 1415 pool_prime_page(struct pool *pp, caddr_t |
|
pool_item_freelist_t *freelist = PR_FREELIST(ph); |
pool_item_freelist_t *freelist = PR_FREELIST(ph); |
int i; |
int i; |
|
|
ph->ph_off = cp - storage; |
ph->ph_off = (char *)cp - (char *)storage; |
ph->ph_firstfree = 0; |
ph->ph_firstfree = 0; |
for (i = 0; i < n - 1; i++) |
for (i = 0; i < n - 1; i++) |
freelist[i] = i + 1; |
freelist[i] = i + 1; |
Line 1412 pool_prime_page(struct pool *pp, caddr_t |
|
Line 1431 pool_prime_page(struct pool *pp, caddr_t |
|
#ifdef DIAGNOSTIC |
#ifdef DIAGNOSTIC |
pi->pi_magic = PI_MAGIC; |
pi->pi_magic = PI_MAGIC; |
#endif |
#endif |
cp = (caddr_t)(cp + pp->pr_size); |
cp = (char *)cp + pp->pr_size; |
|
|
|
KASSERT((((vaddr_t)cp + ioff) & (align - 1)) == 0); |
} |
} |
} |
} |
|
|
|
|
pool_setlowat(struct pool *pp, int n) |
pool_setlowat(struct pool *pp, int n) |
{ |
{ |
|
|
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
|
|
pp->pr_minitems = n; |
pp->pr_minitems = n; |
pp->pr_minpages = (n == 0) |
pp->pr_minpages = (n == 0) |
Line 1479 pool_setlowat(struct pool *pp, int n) |
|
Line 1500 pool_setlowat(struct pool *pp, int n) |
|
*/ |
*/ |
} |
} |
|
|
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
} |
} |
|
|
void |
void |
pool_sethiwat(struct pool *pp, int n) |
pool_sethiwat(struct pool *pp, int n) |
{ |
{ |
|
|
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
|
|
pp->pr_maxpages = (n == 0) |
pp->pr_maxpages = (n == 0) |
? 0 |
? 0 |
: roundup(n, pp->pr_itemsperpage) / pp->pr_itemsperpage; |
: roundup(n, pp->pr_itemsperpage) / pp->pr_itemsperpage; |
|
|
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
} |
} |
|
|
void |
void |
pool_sethardlimit(struct pool *pp, int n, const char *warnmess, int ratecap) |
pool_sethardlimit(struct pool *pp, int n, const char *warnmess, int ratecap) |
{ |
{ |
|
|
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
|
|
pp->pr_hardlimit = n; |
pp->pr_hardlimit = n; |
pp->pr_hardlimit_warning = warnmess; |
pp->pr_hardlimit_warning = warnmess; |
Line 1515 pool_sethardlimit(struct pool *pp, int n |
|
Line 1536 pool_sethardlimit(struct pool *pp, int n |
|
? 0 |
? 0 |
: roundup(n, pp->pr_itemsperpage) / pp->pr_itemsperpage; |
: roundup(n, pp->pr_itemsperpage) / pp->pr_itemsperpage; |
|
|
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
} |
} |
|
|
/* |
/* |
Line 1541 pool_reclaim(struct pool *pp) |
|
Line 1562 pool_reclaim(struct pool *pp) |
|
(*pp->pr_drain_hook)(pp->pr_drain_hook_arg, PR_NOWAIT); |
(*pp->pr_drain_hook)(pp->pr_drain_hook_arg, PR_NOWAIT); |
} |
} |
|
|
if (simple_lock_try(&pp->pr_slock) == 0) |
if (mutex_tryenter(&pp->pr_lock) == 0) |
return (0); |
return (0); |
pr_enter(pp, file, line); |
pr_enter(pp, file, line); |
|
|
Line 1581 pool_reclaim(struct pool *pp) |
|
Line 1602 pool_reclaim(struct pool *pp) |
|
} |
} |
|
|
pr_leave(pp); |
pr_leave(pp); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
if (LIST_EMPTY(&pq) && LIST_EMPTY(&pcgl)) |
if (LIST_EMPTY(&pq) && LIST_EMPTY(&pcgl)) |
return 0; |
return 0; |
|
|
Line 1602 pool_drain(void *arg) |
|
Line 1623 pool_drain(void *arg) |
|
int s; |
int s; |
|
|
pp = NULL; |
pp = NULL; |
s = splvm(); |
s = splvm(); /* XXX why? */ |
simple_lock(&pool_head_slock); |
mutex_enter(&pool_head_lock); |
if (drainpp == NULL) { |
if (drainpp == NULL) { |
drainpp = LIST_FIRST(&pool_head); |
drainpp = LIST_FIRST(&pool_head); |
} |
} |
Line 1611 pool_drain(void *arg) |
|
Line 1632 pool_drain(void *arg) |
|
pp = drainpp; |
pp = drainpp; |
drainpp = LIST_NEXT(pp, pr_poollist); |
drainpp = LIST_NEXT(pp, pr_poollist); |
} |
} |
simple_unlock(&pool_head_slock); |
mutex_exit(&pool_head_lock); |
if (pp) |
if (pp) |
pool_reclaim(pp); |
pool_reclaim(pp); |
splx(s); |
splx(s); |
Line 1623 pool_drain(void *arg) |
|
Line 1644 pool_drain(void *arg) |
|
void |
void |
pool_print(struct pool *pp, const char *modif) |
pool_print(struct pool *pp, const char *modif) |
{ |
{ |
int s; |
|
|
|
s = splvm(); |
if (mutex_tryenter(&pp->pr_lock) == 0) { |
if (simple_lock_try(&pp->pr_slock) == 0) { |
|
printf("pool %s is locked; try again later\n", |
printf("pool %s is locked; try again later\n", |
pp->pr_wchan); |
pp->pr_wchan); |
splx(s); |
|
return; |
return; |
} |
} |
pool_print1(pp, modif, printf); |
pool_print1(pp, modif, printf); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
splx(s); |
|
} |
} |
|
|
void |
void |
Line 1642 pool_printall(const char *modif, void (* |
|
Line 1659 pool_printall(const char *modif, void (* |
|
{ |
{ |
struct pool *pp; |
struct pool *pp; |
|
|
if (simple_lock_try(&pool_head_slock) == 0) { |
if (mutex_tryenter(&pool_head_lock) == 0) { |
(*pr)("WARNING: pool_head_slock is locked\n"); |
(*pr)("WARNING: pool_head_slock is locked\n"); |
} else { |
} else { |
simple_unlock(&pool_head_slock); |
mutex_exit(&pool_head_lock); |
} |
} |
|
|
LIST_FOREACH(pp, &pool_head, pr_poollist) { |
LIST_FOREACH(pp, &pool_head, pr_poollist) { |
Line 1667 pool_printit(struct pool *pp, const char |
|
Line 1684 pool_printit(struct pool *pp, const char |
|
* other processors should be paused. We can skip locking |
* other processors should be paused. We can skip locking |
* the pool in this case. |
* the pool in this case. |
* |
* |
* We do a simple_lock_try() just to print the lock |
* We do a mutex_tryenter() just to print the lock |
* status, however. |
* status, however. |
*/ |
*/ |
|
|
if (simple_lock_try(&pp->pr_slock) == 0) |
if (mutex_tryenter(&pp->pr_lock) == 0) |
(*pr)("WARNING: pool %s is locked\n", pp->pr_wchan); |
(*pr)("WARNING: pool %s is locked\n", pp->pr_wchan); |
else |
else |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
|
|
pool_print1(pp, modif, pr); |
pool_print1(pp, modif, pr); |
} |
} |
Line 1763 pool_print1(struct pool *pp, const char |
|
Line 1780 pool_print1(struct pool *pp, const char |
|
(*pr)("\n"); |
(*pr)("\n"); |
if ((pp->pr_roflags & PR_LOGGING) == 0) |
if ((pp->pr_roflags & PR_LOGGING) == 0) |
(*pr)("\tno log\n"); |
(*pr)("\tno log\n"); |
else |
else { |
pr_printlog(pp, NULL, pr); |
pr_printlog(pp, NULL, pr); |
|
} |
|
|
skip_log: |
skip_log: |
if (print_cache == 0) |
if (print_cache == 0) |
|
|
pool_chk_page(struct pool *pp, const char *label, struct pool_item_header *ph) |
pool_chk_page(struct pool *pp, const char *label, struct pool_item_header *ph) |
{ |
{ |
struct pool_item *pi; |
struct pool_item *pi; |
caddr_t page; |
void *page; |
int n; |
int n; |
|
|
page = (caddr_t)((u_long)ph & pp->pr_alloc->pa_pagemask); |
if ((pp->pr_roflags & PR_NOALIGN) == 0) { |
if (page != ph->ph_page && |
page = (void *)((uintptr_t)ph & pp->pr_alloc->pa_pagemask); |
(pp->pr_roflags & PR_PHINPAGE) != 0) { |
if (page != ph->ph_page && |
if (label != NULL) |
(pp->pr_roflags & PR_PHINPAGE) != 0) { |
printf("%s: ", label); |
if (label != NULL) |
printf("pool(%p:%s): page inconsistency: page %p;" |
printf("%s: ", label); |
" at page head addr %p (p %p)\n", pp, |
printf("pool(%p:%s): page inconsistency: page %p;" |
pp->pr_wchan, ph->ph_page, |
" at page head addr %p (p %p)\n", pp, |
ph, page); |
pp->pr_wchan, ph->ph_page, |
return 1; |
ph, page); |
|
return 1; |
|
} |
} |
} |
|
|
if ((pp->pr_roflags & PR_NOTOUCH) != 0) |
if ((pp->pr_roflags & PR_NOTOUCH) != 0) |
Line 1839 pool_chk_page(struct pool *pp, const cha |
|
Line 1859 pool_chk_page(struct pool *pp, const cha |
|
if (label != NULL) |
if (label != NULL) |
printf("%s: ", label); |
printf("%s: ", label); |
printf("pool(%s): free list modified: magic=%x;" |
printf("pool(%s): free list modified: magic=%x;" |
" page %p; item ordinal %d;" |
" page %p; item ordinal %d; addr %p\n", |
" addr %p (p %p)\n", |
|
pp->pr_wchan, pi->pi_magic, ph->ph_page, |
pp->pr_wchan, pi->pi_magic, ph->ph_page, |
n, pi, page); |
n, pi); |
panic("pool"); |
panic("pool"); |
} |
} |
#endif |
#endif |
page = |
if ((pp->pr_roflags & PR_NOALIGN) != 0) { |
(caddr_t)((u_long)pi & pp->pr_alloc->pa_pagemask); |
continue; |
|
} |
|
page = (void *)((uintptr_t)pi & pp->pr_alloc->pa_pagemask); |
if (page == ph->ph_page) |
if (page == ph->ph_page) |
continue; |
continue; |
|
|
Line 1869 pool_chk(struct pool *pp, const char *la |
|
Line 1890 pool_chk(struct pool *pp, const char *la |
|
struct pool_item_header *ph; |
struct pool_item_header *ph; |
int r = 0; |
int r = 0; |
|
|
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
LIST_FOREACH(ph, &pp->pr_emptypages, ph_pagelist) { |
LIST_FOREACH(ph, &pp->pr_emptypages, ph_pagelist) { |
r = pool_chk_page(pp, label, ph); |
r = pool_chk_page(pp, label, ph); |
if (r) { |
if (r) { |
Line 1890 pool_chk(struct pool *pp, const char *la |
|
Line 1911 pool_chk(struct pool *pp, const char *la |
|
} |
} |
|
|
out: |
out: |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
return (r); |
return (r); |
} |
} |
|
|
Line 1912 pool_cache_init(struct pool_cache *pc, s |
|
Line 1933 pool_cache_init(struct pool_cache *pc, s |
|
LIST_INIT(&pc->pc_emptygroups); |
LIST_INIT(&pc->pc_emptygroups); |
LIST_INIT(&pc->pc_fullgroups); |
LIST_INIT(&pc->pc_fullgroups); |
LIST_INIT(&pc->pc_partgroups); |
LIST_INIT(&pc->pc_partgroups); |
simple_lock_init(&pc->pc_slock); |
mutex_init(&pc->pc_lock, MUTEX_DRIVER, pp->pr_ipl); |
|
|
pc->pc_pool = pp; |
pc->pc_pool = pp; |
|
|
Line 1927 pool_cache_init(struct pool_cache *pc, s |
|
Line 1948 pool_cache_init(struct pool_cache *pc, s |
|
|
|
pc->pc_nitems = 0; |
pc->pc_nitems = 0; |
|
|
simple_lock(&pp->pr_slock); |
if (__predict_true(!cold)) { |
LIST_INSERT_HEAD(&pp->pr_cachelist, pc, pc_poollist); |
mutex_enter(&pp->pr_lock); |
simple_unlock(&pp->pr_slock); |
LIST_INSERT_HEAD(&pp->pr_cachelist, pc, pc_poollist); |
|
mutex_exit(&pp->pr_lock); |
|
} else |
|
LIST_INSERT_HEAD(&pp->pr_cachelist, pc, pc_poollist); |
} |
} |
|
|
/* |
/* |
Line 1946 pool_cache_destroy(struct pool_cache *pc |
|
Line 1970 pool_cache_destroy(struct pool_cache *pc |
|
pool_cache_invalidate(pc); |
pool_cache_invalidate(pc); |
|
|
/* ...and remove it from the pool's cache list. */ |
/* ...and remove it from the pool's cache list. */ |
simple_lock(&pp->pr_slock); |
mutex_enter(&pp->pr_lock); |
LIST_REMOVE(pc, pc_poollist); |
LIST_REMOVE(pc, pc_poollist); |
simple_unlock(&pp->pr_slock); |
mutex_exit(&pp->pr_lock); |
|
|
|
mutex_destroy(&pc->pc_lock); |
} |
} |
|
|
static inline void * |
static inline void * |
|
|
pcg_grouplist_free(struct pool_cache_grouplist *pcgl) |
pcg_grouplist_free(struct pool_cache_grouplist *pcgl) |
{ |
{ |
struct pool_cache_group *pcg; |
struct pool_cache_group *pcg; |
int s; |
|
|
|
s = splvm(); |
|
while ((pcg = LIST_FIRST(pcgl)) != NULL) { |
while ((pcg = LIST_FIRST(pcgl)) != NULL) { |
LIST_REMOVE(pcg, pcg_list); |
LIST_REMOVE(pcg, pcg_list); |
pool_put(&pcgpool, pcg); |
pool_put(&pcgpool, pcg); |
} |
} |
splx(s); |
|
} |
} |
|
|
/* |
/* |
Line 2014 pool_cache_get_paddr(struct pool_cache * |
|
Line 2037 pool_cache_get_paddr(struct pool_cache * |
|
ASSERT_SLEEPABLE(NULL, "pool_cache_get(PR_WAITOK)"); |
ASSERT_SLEEPABLE(NULL, "pool_cache_get(PR_WAITOK)"); |
#endif |
#endif |
|
|
simple_lock(&pc->pc_slock); |
mutex_enter(&pc->pc_lock); |
|
|
pcg = LIST_FIRST(&pc->pc_partgroups); |
pcg = LIST_FIRST(&pc->pc_partgroups); |
if (pcg == NULL) { |
if (pcg == NULL) { |
Line 2033 pool_cache_get_paddr(struct pool_cache * |
|
Line 2056 pool_cache_get_paddr(struct pool_cache * |
|
* when the object is freed back to the cache. |
* when the object is freed back to the cache. |
*/ |
*/ |
pc->pc_misses++; |
pc->pc_misses++; |
simple_unlock(&pc->pc_slock); |
mutex_exit(&pc->pc_lock); |
object = pool_get(pc->pc_pool, flags); |
object = pool_get(pc->pc_pool, flags); |
if (object != NULL && pc->pc_ctor != NULL) { |
if (object != NULL && pc->pc_ctor != NULL) { |
if ((*pc->pc_ctor)(pc->pc_arg, object, flags) != 0) { |
if ((*pc->pc_ctor)(pc->pc_arg, object, flags) != 0) { |
Line 2041 pool_cache_get_paddr(struct pool_cache * |
|
Line 2064 pool_cache_get_paddr(struct pool_cache * |
|
return (NULL); |
return (NULL); |
} |
} |
} |
} |
|
KASSERT((((vaddr_t)object + pc->pc_pool->pr_itemoffset) & |
|
(pc->pc_pool->pr_align - 1)) == 0); |
if (object != NULL && pap != NULL) { |
if (object != NULL && pap != NULL) { |
#ifdef POOL_VTOPHYS |
#ifdef POOL_VTOPHYS |
*pap = POOL_VTOPHYS(object); |
*pap = POOL_VTOPHYS(object); |
Line 2048 pool_cache_get_paddr(struct pool_cache * |
|
Line 2073 pool_cache_get_paddr(struct pool_cache * |
|
*pap = POOL_PADDR_INVALID; |
*pap = POOL_PADDR_INVALID; |
#endif |
#endif |
} |
} |
|
|
|
FREECHECK_OUT(&pc->pc_freecheck, object); |
return (object); |
return (object); |
} |
} |
|
|
Line 2059 pool_cache_get_paddr(struct pool_cache * |
|
Line 2086 pool_cache_get_paddr(struct pool_cache * |
|
LIST_REMOVE(pcg, pcg_list); |
LIST_REMOVE(pcg, pcg_list); |
LIST_INSERT_HEAD(&pc->pc_emptygroups, pcg, pcg_list); |
LIST_INSERT_HEAD(&pc->pc_emptygroups, pcg, pcg_list); |
} |
} |
simple_unlock(&pc->pc_slock); |
mutex_exit(&pc->pc_lock); |
|
|
|
KASSERT((((vaddr_t)object + pc->pc_pool->pr_itemoffset) & |
|
(pc->pc_pool->pr_align - 1)) == 0); |
|
FREECHECK_OUT(&pc->pc_freecheck, object); |
return (object); |
return (object); |
} |
} |
|
|
|
|
pool_cache_put_paddr(struct pool_cache *pc, void *object, paddr_t pa) |
pool_cache_put_paddr(struct pool_cache *pc, void *object, paddr_t pa) |
{ |
{ |
struct pool_cache_group *pcg; |
struct pool_cache_group *pcg; |
int s; |
|
|
FREECHECK_IN(&pc->pc_freecheck, object); |
|
|
if (__predict_false((pc->pc_pool->pr_flags & PR_WANTED) != 0)) { |
if (__predict_false((pc->pc_pool->pr_flags & PR_WANTED) != 0)) { |
goto destruct; |
goto destruct; |
} |
} |
|
|
simple_lock(&pc->pc_slock); |
mutex_enter(&pc->pc_lock); |
|
|
pcg = LIST_FIRST(&pc->pc_partgroups); |
pcg = LIST_FIRST(&pc->pc_partgroups); |
if (pcg == NULL) { |
if (pcg == NULL) { |
Line 2096 pool_cache_put_paddr(struct pool_cache * |
|
Line 2127 pool_cache_put_paddr(struct pool_cache * |
|
* No empty groups to free the object to. Attempt to |
* No empty groups to free the object to. Attempt to |
* allocate one. |
* allocate one. |
*/ |
*/ |
simple_unlock(&pc->pc_slock); |
mutex_exit(&pc->pc_lock); |
s = splvm(); |
|
pcg = pool_get(&pcgpool, PR_NOWAIT); |
pcg = pool_get(&pcgpool, PR_NOWAIT); |
splx(s); |
|
if (pcg == NULL) { |
if (pcg == NULL) { |
destruct: |
destruct: |
|
|
|
|
return; |
return; |
} |
} |
memset(pcg, 0, sizeof(*pcg)); |
memset(pcg, 0, sizeof(*pcg)); |
simple_lock(&pc->pc_slock); |
mutex_enter(&pc->pc_lock); |
pc->pc_ngroups++; |
pc->pc_ngroups++; |
LIST_INSERT_HEAD(&pc->pc_partgroups, pcg, pcg_list); |
LIST_INSERT_HEAD(&pc->pc_partgroups, pcg, pcg_list); |
} |
} |
|
|
LIST_REMOVE(pcg, pcg_list); |
LIST_REMOVE(pcg, pcg_list); |
LIST_INSERT_HEAD(&pc->pc_fullgroups, pcg, pcg_list); |
LIST_INSERT_HEAD(&pc->pc_fullgroups, pcg, pcg_list); |
} |
} |
simple_unlock(&pc->pc_slock); |
mutex_exit(&pc->pc_lock); |
} |
} |
|
|
/* |
/* |
Line 2169 pool_do_cache_invalidate(struct pool_cac |
|
Line 2198 pool_do_cache_invalidate(struct pool_cac |
|
struct pool_cache_grouplist *pcgl) |
struct pool_cache_grouplist *pcgl) |
{ |
{ |
|
|
LOCK_ASSERT(simple_lock_held(&pc->pc_slock)); |
KASSERT(mutex_owned(&pc->pc_lock)); |
LOCK_ASSERT(simple_lock_held(&pc->pc_pool->pr_slock)); |
KASSERT(mutex_owned(&pc->pc_pool->pr_lock)); |
|
|
pool_do_cache_invalidate_grouplist(&pc->pc_fullgroups, pc, pq, pcgl); |
pool_do_cache_invalidate_grouplist(&pc->pc_fullgroups, pc, pq, pcgl); |
pool_do_cache_invalidate_grouplist(&pc->pc_partgroups, pc, pq, pcgl); |
pool_do_cache_invalidate_grouplist(&pc->pc_partgroups, pc, pq, pcgl); |
Line 2195 pool_cache_invalidate(struct pool_cache |
|
Line 2224 pool_cache_invalidate(struct pool_cache |
|
LIST_INIT(&pq); |
LIST_INIT(&pq); |
LIST_INIT(&pcgl); |
LIST_INIT(&pcgl); |
|
|
simple_lock(&pc->pc_slock); |
mutex_enter(&pc->pc_lock); |
simple_lock(&pc->pc_pool->pr_slock); |
mutex_enter(&pc->pc_pool->pr_lock); |
|
|
pool_do_cache_invalidate(pc, &pq, &pcgl); |
pool_do_cache_invalidate(pc, &pq, &pcgl); |
|
|
simple_unlock(&pc->pc_pool->pr_slock); |
mutex_exit(&pc->pc_pool->pr_lock); |
simple_unlock(&pc->pc_slock); |
mutex_exit(&pc->pc_lock); |
|
|
pr_pagelist_free(pc->pc_pool, &pq); |
pr_pagelist_free(pc->pc_pool, &pq); |
pcg_grouplist_free(&pcgl); |
pcg_grouplist_free(&pcgl); |
Line 2223 pool_cache_reclaim(struct pool_cache *pc |
|
Line 2252 pool_cache_reclaim(struct pool_cache *pc |
|
* to use trylock. If we can't lock the pool_cache, it's not really |
* to use trylock. If we can't lock the pool_cache, it's not really |
* a big deal here. |
* a big deal here. |
*/ |
*/ |
if (simple_lock_try(&pc->pc_slock) == 0) |
if (mutex_tryenter(&pc->pc_lock) == 0) |
return; |
return; |
|
|
pool_do_cache_invalidate(pc, pq, pcgl); |
pool_do_cache_invalidate(pc, pq, pcgl); |
|
|
simple_unlock(&pc->pc_slock); |
mutex_exit(&pc->pc_lock); |
} |
} |
|
|
/* |
/* |
Line 2298 pool_allocator_alloc(struct pool *pp, in |
|
Line 2327 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 2320 pool_allocator_free(struct pool *pp, voi |
|
Line 2347 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); |
} |
} |
|
|
void * |
void * |
pool_page_alloc(struct pool *pp, int flags) |
pool_page_alloc(struct pool *pp, int flags) |
{ |
{ |
boolean_t waitok = (flags & PR_WAITOK) ? TRUE : FALSE; |
bool waitok = (flags & PR_WAITOK) ? true : false; |
|
|
return ((void *) uvm_km_alloc_poolpage_cache(kmem_map, waitok)); |
return ((void *) uvm_km_alloc_poolpage_cache(kmem_map, waitok)); |
} |
} |
Line 2343 pool_page_free(struct pool *pp, void *v) |
|
Line 2368 pool_page_free(struct pool *pp, void *v) |
|
static void * |
static void * |
pool_page_alloc_meta(struct pool *pp, int flags) |
pool_page_alloc_meta(struct pool *pp, int flags) |
{ |
{ |
boolean_t waitok = (flags & PR_WAITOK) ? TRUE : FALSE; |
bool waitok = (flags & PR_WAITOK) ? true : false; |
|
|
return ((void *) uvm_km_alloc_poolpage(kmem_map, waitok)); |
return ((void *) uvm_km_alloc_poolpage(kmem_map, waitok)); |
} |
} |
Line 2360 pool_page_free_meta(struct pool *pp, voi |
|
Line 2385 pool_page_free_meta(struct pool *pp, voi |
|
void * |
void * |
pool_subpage_alloc(struct pool *pp, int flags) |
pool_subpage_alloc(struct pool *pp, int flags) |
{ |
{ |
void *v; |
return pool_get(&psppool, flags); |
int s; |
|
s = splvm(); |
|
v = pool_get(&psppool, flags); |
|
splx(s); |
|
return v; |
|
} |
} |
|
|
void |
void |
pool_subpage_free(struct pool *pp, void *v) |
pool_subpage_free(struct pool *pp, void *v) |
{ |
{ |
int s; |
|
s = splvm(); |
|
pool_put(&psppool, v); |
pool_put(&psppool, v); |
splx(s); |
|
} |
} |
|
|
/* We don't provide a real nointr allocator. Maybe later. */ |
/* We don't provide a real nointr allocator. Maybe later. */ |
Line 2395 pool_subpage_free_nointr(struct pool *pp |
|
Line 2412 pool_subpage_free_nointr(struct pool *pp |
|
void * |
void * |
pool_page_alloc_nointr(struct pool *pp, int flags) |
pool_page_alloc_nointr(struct pool *pp, int flags) |
{ |
{ |
boolean_t waitok = (flags & PR_WAITOK) ? TRUE : FALSE; |
bool waitok = (flags & PR_WAITOK) ? true : false; |
|
|
return ((void *) uvm_km_alloc_poolpage_cache(kernel_map, waitok)); |
return ((void *) uvm_km_alloc_poolpage_cache(kernel_map, waitok)); |
} |
} |