Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files. =================================================================== RCS file: /ftp/cvs/cvsroot/src/sys/kern/subr_pool.c,v rcsdiff: /ftp/cvs/cvsroot/src/sys/kern/subr_pool.c,v: warning: Unknown phrases like `commitid ...;' are present. retrieving revision 1.165.2.3 retrieving revision 1.185 diff -u -p -r1.165.2.3 -r1.185 --- src/sys/kern/subr_pool.c 2008/12/13 01:15:08 1.165.2.3 +++ src/sys/kern/subr_pool.c 2010/05/12 08:11:16 1.185 @@ -1,7 +1,8 @@ -/* $NetBSD: subr_pool.c,v 1.165.2.3 2008/12/13 01:15:08 haad Exp $ */ +/* $NetBSD: subr_pool.c,v 1.185 2010/05/12 08:11:16 rmind Exp $ */ /*- - * Copyright (c) 1997, 1999, 2000, 2002, 2007, 2008 The NetBSD Foundation, Inc. + * Copyright (c) 1997, 1999, 2000, 2002, 2007, 2008, 2010 + * The NetBSD Foundation, Inc. * All rights reserved. * * This code is derived from software contributed to The NetBSD Foundation @@ -31,7 +32,7 @@ */ #include -__KERNEL_RCSID(0, "$NetBSD: subr_pool.c,v 1.165.2.3 2008/12/13 01:15:08 haad Exp $"); +__KERNEL_RCSID(0, "$NetBSD: subr_pool.c,v 1.185 2010/05/12 08:11:16 rmind Exp $"); #include "opt_ddb.h" #include "opt_pool.h" @@ -69,7 +70,7 @@ __KERNEL_RCSID(0, "$NetBSD: subr_pool.c, */ /* List of all pools */ -TAILQ_HEAD(,pool) pool_head = TAILQ_HEAD_INITIALIZER(pool_head); +static TAILQ_HEAD(, pool) pool_head = TAILQ_HEAD_INITIALIZER(pool_head); /* Private pool for page header structures */ #define PHPOOL_MAX 8 @@ -104,6 +105,9 @@ static struct pool *drainpp; static kmutex_t pool_head_lock; static kcondvar_t pool_busy; +/* This lock protects initialization of a potentially shared pool allocator */ +static kmutex_t pool_allocator_lock; + typedef uint32_t pool_item_bitmap_t; #define BITMAP_SIZE (CHAR_BIT * sizeof(pool_item_bitmap_t)) #define BITMAP_MASK (BITMAP_SIZE - 1) @@ -188,6 +192,7 @@ static bool pool_cache_get_slow(pool_cac void **, paddr_t *, int); static void pool_cache_cpu_init1(struct cpu_info *, pool_cache_t); static void pool_cache_invalidate_groups(pool_cache_t, pcg_t *); +static void pool_cache_invalidate_cpu(pool_cache_t, u_int); static void pool_cache_xcall(pool_cache_t); static int pool_catchup(struct pool *); @@ -230,16 +235,28 @@ int pool_logsize = POOL_LOGSIZE; static inline void pr_log(struct pool *pp, void *v, int action, const char *file, long line) { - int n = pp->pr_curlogentry; + int n; struct pool_log *pl; if ((pp->pr_roflags & PR_LOGGING) == 0) return; + if (pp->pr_log == NULL) { + if (kmem_map != NULL) + pp->pr_log = malloc( + pool_logsize * sizeof(struct pool_log), + M_TEMP, M_NOWAIT | M_ZERO); + if (pp->pr_log == NULL) + return; + pp->pr_curlogentry = 0; + pp->pr_logsize = pool_logsize; + } + /* * Fill in the current entry. Wrap around and overwrite * the oldest entry if necessary. */ + n = pp->pr_curlogentry; pl = &pp->pr_log[n]; pl->pl_file = file; pl->pl_line = line; @@ -257,7 +274,7 @@ pr_printlog(struct pool *pp, struct pool int i = pp->pr_logsize; int n = pp->pr_curlogentry; - if ((pp->pr_roflags & PR_LOGGING) == 0) + if (pp->pr_log == NULL) return; /* @@ -545,6 +562,11 @@ pool_reclaim_register(struct pool *pp) callback_register(&vm_map_to_kernel(map)->vmk_reclaim_callback, &pp->pr_reclaimerentry, pp, pool_reclaim_callback); splx(s); + +#ifdef DIAGNOSTIC + /* Diagnostic drain attempt. */ + uvm_km_va_drain(map, 0); +#endif } static void @@ -587,17 +609,11 @@ void pool_subsystem_init(void) { struct pool_allocator *pa; - __link_set_decl(pools, struct link_pool_init); - struct link_pool_init * const *pi; mutex_init(&pool_head_lock, MUTEX_DEFAULT, IPL_NONE); + mutex_init(&pool_allocator_lock, MUTEX_DEFAULT, IPL_NONE); cv_init(&pool_busy, "poolbusy"); - __link_set_foreach(pi, pools) - pool_init((*pi)->pp, (*pi)->size, (*pi)->align, - (*pi)->align_offset, (*pi)->flags, (*pi)->wchan, - (*pi)->palloc, (*pi)->ipl); - while ((pa = SLIST_FIRST(&pa_deferinitq)) != NULL) { KASSERT(pa->pa_backingmapptr != NULL); KASSERT(*pa->pa_backingmapptr != NULL); @@ -656,7 +672,9 @@ pool_init(struct pool *pp, size_t size, palloc = &pool_allocator_nointr_fullpage; } #endif /* POOL_SUBPAGE */ - if ((palloc->pa_flags & PA_INITIALIZED) == 0) { + if (!cold) + mutex_enter(&pool_allocator_lock); + if (palloc->pa_refcnt++ == 0) { if (palloc->pa_pagesz == 0) palloc->pa_pagesz = PAGE_SIZE; @@ -669,8 +687,9 @@ pool_init(struct pool *pp, size_t size, if (palloc->pa_backingmapptr != NULL) { pa_reclaim_register(palloc); } - palloc->pa_flags |= PA_INITIALIZED; } + if (!cold) + mutex_exit(&pool_allocator_lock); if (align == 0) align = ALIGN(1); @@ -793,16 +812,7 @@ pool_init(struct pool *pp, size_t size, pp->pr_nidle = 0; pp->pr_refcnt = 0; -#ifdef POOL_DIAGNOSTIC - if (flags & PR_LOGGING) { - if (kmem_map == NULL || - (pp->pr_log = malloc(pool_logsize * sizeof(struct pool_log), - M_TEMP, M_NOWAIT)) == NULL) - pp->pr_roflags &= ~PR_LOGGING; - pp->pr_curlogentry = 0; - pp->pr_logsize = pool_logsize; - } -#endif + pp->pr_log = NULL; pp->pr_entered_file = NULL; pp->pr_entered_line = 0; @@ -851,7 +861,7 @@ pool_init(struct pool *pp, size_t size, } /* Insert into the list of all pools. */ - if (__predict_true(!cold)) + if (!cold) mutex_enter(&pool_head_lock); TAILQ_FOREACH(pp1, &pool_head, pr_poollist) { if (strcmp(pp1->pr_wchan, pp->pr_wchan) > 0) @@ -861,14 +871,14 @@ pool_init(struct pool *pp, size_t size, TAILQ_INSERT_TAIL(&pool_head, pp, pr_poollist); else TAILQ_INSERT_BEFORE(pp1, pp, pr_poollist); - if (__predict_true(!cold)) + if (!cold) mutex_exit(&pool_head_lock); /* Insert this into the list of pools using this allocator. */ - if (__predict_true(!cold)) + if (!cold) mutex_enter(&palloc->pa_lock); TAILQ_INSERT_TAIL(&palloc->pa_list, pp, pr_alloc_list); - if (__predict_true(!cold)) + if (!cold) mutex_exit(&palloc->pa_lock); pool_reclaim_register(pp); @@ -898,6 +908,11 @@ pool_destroy(struct pool *pp) TAILQ_REMOVE(&pp->pr_alloc->pa_list, pp, pr_alloc_list); mutex_exit(&pp->pr_alloc->pa_lock); + mutex_enter(&pool_allocator_lock); + if (--pp->pr_alloc->pa_refcnt == 0) + mutex_destroy(&pp->pr_alloc->pa_lock); + mutex_exit(&pool_allocator_lock); + mutex_enter(&pp->pr_lock); KASSERT(pp->pr_cache == NULL); @@ -923,8 +938,10 @@ pool_destroy(struct pool *pp) pr_pagelist_free(pp, &pq); #ifdef POOL_DIAGNOSTIC - if ((pp->pr_roflags & PR_LOGGING) != 0) + if (pp->pr_log != NULL) { free(pp->pr_log, M_TEMP); + pp->pr_log = NULL; + } #endif cv_destroy(&pp->pr_cv); @@ -972,19 +989,17 @@ pool_get(struct pool *pp, int flags) void *v; #ifdef DIAGNOSTIC - if (__predict_false(pp->pr_itemsperpage == 0)) - panic("pool_get: pool %p: pr_itemsperpage is zero, " - "pool not initialized?", pp); - if (__predict_false(curlwp == NULL && doing_shutdown == 0 && - (flags & PR_WAITOK) != 0)) - panic("pool_get: %s: must have NOWAIT", pp->pr_wchan); - -#endif /* DIAGNOSTIC */ -#ifdef LOCKDEBUG + if (pp->pr_itemsperpage == 0) + panic("pool_get: pool '%s': pr_itemsperpage is zero, " + "pool not initialized?", pp->pr_wchan); + if ((cpu_intr_p() || cpu_softintr_p()) && pp->pr_ipl == IPL_NONE && + !cold && panicstr == NULL) + panic("pool '%s' is IPL_NONE, but called from " + "interrupt context\n", pp->pr_wchan); +#endif if (flags & PR_WAITOK) { ASSERT_SLEEPABLE(); } -#endif mutex_enter(&pp->pr_lock); pr_enter(pp, file, line); @@ -1592,6 +1607,8 @@ pool_sethardlimit(struct pool *pp, int n /* * Release all complete pages that have not been used recently. + * + * Might be called from interrupt context. */ int #ifdef POOL_DIAGNOSTIC @@ -1606,6 +1623,10 @@ pool_reclaim(struct pool *pp) bool klock; int rv; + if (cpu_intr_p() || cpu_softintr_p()) { + KASSERT(pp->pr_ipl != IPL_NONE); + } + if (pp->pr_drain_hook != NULL) { /* * The drain hook must be called with the pool unlocked. @@ -1893,7 +1914,7 @@ pool_print1(struct pool *pp, const char if (pc != NULL) { cpuhit = 0; cpumiss = 0; - for (i = 0; i < MAXCPUS; i++) { + for (i = 0; i < __arraycount(pc->pc_cpus); i++) { if ((cc = pc->pc_cpus[i]) == NULL) continue; cpuhit += cc->cc_hits; @@ -2129,9 +2150,7 @@ void pool_cache_destroy(pool_cache_t pc) { struct pool *pp = &pc->pc_pool; - pool_cache_cpu_t *cc; - pcg_t *pcg; - int i; + u_int i; /* Remove it from the global list. */ mutex_enter(&pool_head_lock); @@ -2149,20 +2168,8 @@ pool_cache_destroy(pool_cache_t pc) mutex_exit(&pp->pr_lock); /* Destroy per-CPU data */ - for (i = 0; i < MAXCPUS; i++) { - if ((cc = pc->pc_cpus[i]) == NULL) - continue; - if ((pcg = cc->cc_current) != &pcg_dummy) { - pcg->pcg_next = NULL; - pool_cache_invalidate_groups(pc, pcg); - } - if ((pcg = cc->cc_previous) != &pcg_dummy) { - pcg->pcg_next = NULL; - pool_cache_invalidate_groups(pc, pcg); - } - if (cc != &pc->pc_cpu0) - pool_put(&cache_cpu_pool, cc); - } + for (i = 0; i < __arraycount(pc->pc_cpus); i++) + pool_cache_invalidate_cpu(pc, i); /* Finally, destroy it. */ mutex_destroy(&pc->pc_lock); @@ -2183,7 +2190,7 @@ pool_cache_cpu_init1(struct cpu_info *ci index = ci->ci_index; - KASSERT(index < MAXCPUS); + KASSERT(index < __arraycount(pc->pc_cpus)); if ((cc = pc->pc_cpus[index]) != NULL) { KASSERT(cc->cc_cpuindex == index); @@ -2309,12 +2316,35 @@ pool_cache_invalidate_groups(pool_cache_ * * Invalidate a pool cache (destruct and release all of the * cached objects). Does not reclaim objects from the pool. + * + * Note: For pool caches that provide constructed objects, there + * is an assumption that another level of synchronization is occurring + * between the input to the constructor and the cache invalidation. */ void pool_cache_invalidate(pool_cache_t pc) { pcg_t *full, *empty, *part; +#if 0 + uint64_t where; + if (ncpu < 2 || !mp_online) { + /* + * We might be called early enough in the boot process + * for the CPU data structures to not be fully initialized. + * In this case, simply gather the local CPU's cache now + * since it will be the only one running. + */ + pool_cache_xcall(pc); + } else { + /* + * Gather all of the CPU-specific caches into the + * global cache. + */ + where = xc_broadcast(0, (xcfunc_t)pool_cache_xcall, pc, NULL); + xc_wait(where); + } +#endif mutex_enter(&pc->pc_lock); full = pc->pc_fullgroups; empty = pc->pc_emptygroups; @@ -2332,6 +2362,40 @@ pool_cache_invalidate(pool_cache_t pc) pool_cache_invalidate_groups(pc, part); } +/* + * pool_cache_invalidate_cpu: + * + * Invalidate all CPU-bound cached objects in pool cache, the CPU being + * identified by its associated index. + * It is caller's responsibility to ensure that no operation is + * taking place on this pool cache while doing this invalidation. + * WARNING: as no inter-CPU locking is enforced, trying to invalidate + * pool cached objects from a CPU different from the one currently running + * may result in an undefined behaviour. + */ +static void +pool_cache_invalidate_cpu(pool_cache_t pc, u_int index) +{ + + pool_cache_cpu_t *cc; + pcg_t *pcg; + + if ((cc = pc->pc_cpus[index]) == NULL) + return; + + if ((pcg = cc->cc_current) != &pcg_dummy) { + pcg->pcg_next = NULL; + pool_cache_invalidate_groups(pc, pcg); + } + if ((pcg = cc->cc_previous) != &pcg_dummy) { + pcg->pcg_next = NULL; + pool_cache_invalidate_groups(pc, pcg); + } + if (cc != &pc->pc_cpu0) + pool_put(&cache_cpu_pool, cc); + +} + void pool_cache_set_drain_hook(pool_cache_t pc, void (*fn)(void *, int), void *arg) { @@ -2465,11 +2529,14 @@ pool_cache_get_paddr(pool_cache_t pc, in void *object; int s; -#ifdef LOCKDEBUG + KASSERTMSG((!cpu_intr_p() && !cpu_softintr_p()) || + (pc->pc_pool.pr_ipl != IPL_NONE || cold || panicstr != NULL), + ("pool '%s' is IPL_NONE, but called from interrupt context\n", + pc->pc_pool.pr_wchan)); + if (flags & PR_WAITOK) { ASSERT_SLEEPABLE(); } -#endif /* Lock out interrupts and disable preemption. */ s = splvm(); @@ -2621,6 +2688,7 @@ pool_cache_put_paddr(pool_cache_t pc, vo pcg_t *pcg; int s; + KASSERT(object != NULL); FREECHECK_IN(&pc->pc_freecheck, object); /* Lock out interrupts and disable preemption. */ @@ -2984,7 +3052,7 @@ found: goto print; } } - for (i = 0; i < MAXCPUS; i++) { + for (i = 0; i < __arraycount(pc->pc_cpus); i++) { pool_cache_cpu_t *cc; if ((cc = pc->pc_cpus[i]) == NULL) {