From c2652213a2519c900bc602763afe0c95b0c2fdc3 Mon Sep 17 00:00:00 2001 From: Patrick Farrell Date: Wed, 20 Sep 2023 13:57:29 -0400 Subject: [PATCH] EX-8270 ptlrpc: correct use of plural 'pools' There are a bunch of spots which refer to a single pool by pool index, but which say 'pools'. This is very confusing, and in fact led to me misunderstanding the code at least once. Clean that up. Test-Parameters: trivial Signed-off-by: Patrick Farrell Change-Id: I9eabcfe77a57a82c87b36e3b3e040be91671fbfb Reviewed-on: https://review.whamcloud.com/c/ex/lustre-release/+/52435 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Andreas Dilger --- lustre/ptlrpc/sec_bulk.c | 76 +++++++++++++++++++++++------------------------- 1 file changed, 37 insertions(+), 39 deletions(-) diff --git a/lustre/ptlrpc/sec_bulk.c b/lustre/ptlrpc/sec_bulk.c index b017125..b954812 100644 --- a/lustre/ptlrpc/sec_bulk.c +++ b/lustre/ptlrpc/sec_bulk.c @@ -244,7 +244,7 @@ int page_pools_seq_show(struct seq_file *m, void *v) return 0; } -static void pools_release_free_pages(long npages, unsigned int pool_idx) +static void pool_release_free_pages(long npages, unsigned int pool_idx) { int p_idx, g_idx; int p_idx_max1, p_idx_max2; @@ -300,8 +300,8 @@ static void pools_release_free_pages(long npages, unsigned int pool_idx) /* * we try to keep at least PTLRPC_MAX_BRW_PAGES pages in the pool. */ -static unsigned long pools_shrink_count(struct shrinker *s, - struct shrink_control *sc) +static unsigned long pool_shrink_count(struct shrinker *s, + struct shrink_control *sc) { unsigned int pool_index = SEEKS_TO_INDEX(s); struct ptlrpc_page_pool *pool = page_pools[pool_index]; @@ -326,10 +326,10 @@ static unsigned long pools_shrink_count(struct shrinker *s, /* * we try to keep at least PTLRPC_MAX_BRW_PAGES pages in the pool. */ -static unsigned long pools_shrink_scan(struct shrinker *s, - struct shrink_control *sc) +static unsigned long pool_shrink_scan(struct shrinker *s, + struct shrink_control *sc) { - /* Get pool number passed as part of pools_shrinker_seeks value */ + /* Get pool number passed as part of pool_shrinker_seeks value */ unsigned int pool_index = SEEKS_TO_INDEX(s); struct ptlrpc_page_pool *pool = page_pools[pool_index]; @@ -340,7 +340,7 @@ static unsigned long pools_shrink_scan(struct shrinker *s, sc->nr_to_scan = min_t(unsigned long, sc->nr_to_scan, pool->ppp_free_pages - PTLRPC_MAX_BRW_PAGES); if (sc->nr_to_scan > 0) { - pools_release_free_pages(sc->nr_to_scan, pool_index); + pool_release_free_pages(sc->nr_to_scan, pool_index); CDEBUG(D_SEC, "released %ld pages, %ld left\n", (long)sc->nr_to_scan, pool->ppp_free_pages); @@ -370,12 +370,11 @@ static unsigned long pools_shrink_scan(struct shrinker *s, * could be called frequently for query (@nr_to_scan == 0). * we try to keep at least PTLRPC_MAX_BRW_PAGES pages in the pool. */ -static int pools_shrink(struct shrinker *shrinker, - struct shrink_control *sc) +static int pool_shrink(struct shrinker *shrinker, struct shrink_control *sc) { - pools_shrink_scan(shrinker, sc); + pool_shrink_scan(shrinker, sc); - return pools_shrink_count(shrinker, sc); + return pool_shrink_count(shrinker, sc); } #endif /* HAVE_SHRINKER_COUNT */ @@ -388,7 +387,7 @@ int npages_to_npools(unsigned long npages) /* * return how many pages cleaned up. */ -static unsigned long pools_cleanup(void ***pools, int npools, int pool_idx) +static unsigned long pool_cleanup(void ***pools, int npools, int pool_idx) { unsigned long cleaned = 0; int i, j; @@ -421,8 +420,8 @@ static unsigned long pools_cleanup(void ***pools, int npools, int pool_idx) * we have options to avoid most memory copy with some tricks. but we choose * the simplest way to avoid complexity. It's not frequently called. */ -static void pools_insert(void ***pools, int npools, int npages, - unsigned int pool_idx) +static void pool_insert(void ***pools, int npools, int npages, + unsigned int pool_idx) { int freeslot; int op_idx, np_idx, og_idx, ng_idx; @@ -567,14 +566,14 @@ static int pool_add_pages(int npages, int pool_index) } LASSERT(alloced == npages); - pools_insert(pools, npools, npages, pool_index); + pool_insert(pools, npools, npages, pool_index); CDEBUG(D_SEC, "added %d pages into pools\n", npages); OBD_FREE_PTR_ARRAY(pools, npools); rc = 0; out_pools: if (rc) { - pools_cleanup(pools, npools, pool_index); + pool_cleanup(pools, npools, pool_index); } out: if (rc) { @@ -586,7 +585,7 @@ out: return rc; } -static inline void pools_wakeup(unsigned int pool) +static inline void pool_wakeup(unsigned int pool) { assert_spin_locked(&page_pools[pool]->ppp_lock); @@ -595,7 +594,7 @@ static inline void pools_wakeup(unsigned int pool) wake_up_all(&page_pools[pool]->ppp_waitq); } -static int pools_should_grow(int needed, unsigned int pool_index) +static int pool_should_grow(int needed, unsigned int pool_index) { /* * don't grow if someone else is growing the pools right now, @@ -699,7 +698,7 @@ again: page_pool->ppp_st_missings++; page_pool->ppp_pages_short += count; - if (pools_should_grow(count, pool_idx)) { + if (pool_should_grow(count, pool_idx)) { page_pool->ppp_growing = 1; spin_unlock(&page_pool->ppp_lock); @@ -710,7 +709,7 @@ again: page_pool->ppp_growing = 0; - pools_wakeup(pool_idx); + pool_wakeup(pool_idx); } else { if (page_pool->ppp_growing) { if (++page_pool->ppp_waitqlen > @@ -886,7 +885,7 @@ static int __sptlrpc_pool_put_pages(void *array, unsigned int count, } page_pool->ppp_free_pages += count; - pools_wakeup(pool_idx); + pool_wakeup(pool_idx); out_unlock: spin_unlock(&page_pool->ppp_lock); @@ -947,7 +946,7 @@ int sptlrpc_pool_add_user(void) /* ask for 1 page - so if the pool is empty, it will grow * (this might also grow an in-use pool if it's full, which is fine) */ - if (pools_should_grow(1, PAGES_POOL)) { + if (pool_should_grow(1, PAGES_POOL)) { page_pools[PAGES_POOL]->ppp_growing = 1; spin_unlock(&page_pools[PAGES_POOL]->ppp_lock); @@ -955,7 +954,7 @@ int sptlrpc_pool_add_user(void) spin_lock(&page_pools[PAGES_POOL]->ppp_lock); page_pools[PAGES_POOL]->ppp_growing = 0; - pools_wakeup(PAGES_POOL); + pool_wakeup(PAGES_POOL); } spin_unlock(&page_pools[PAGES_POOL]->ppp_lock); return 0; @@ -968,7 +967,7 @@ int sptlrpc_pool_del_user(void) } EXPORT_SYMBOL(sptlrpc_pool_del_user); -static inline void pools_alloc(struct ptlrpc_page_pool *pool) +static inline void pool_alloc(struct ptlrpc_page_pool *pool) { LASSERT(pool->ppp_max_pools); OBD_ALLOC_LARGE(pool->ppp_pools, @@ -976,14 +975,14 @@ static inline void pools_alloc(struct ptlrpc_page_pool *pool) sizeof(*pool->ppp_pools)); } -static inline void pools_free(unsigned int i) +static inline void pool_free(unsigned int pool_index) { - LASSERT(page_pools[i]->ppp_max_pools); - LASSERT(page_pools[i]->ppp_pools); + LASSERT(page_pools[pool_index]->ppp_max_pools); + LASSERT(page_pools[pool_index]->ppp_pools); - OBD_FREE_LARGE(page_pools[i]->ppp_pools, - page_pools[i]->ppp_max_pools * - sizeof(*page_pools[i]->ppp_pools)); + OBD_FREE_LARGE(page_pools[pool_index]->ppp_pools, + page_pools[pool_index]->ppp_max_pools * + sizeof(*page_pools[pool_index]->ppp_pools)); } int sptlrpc_pool_init(void) @@ -1022,18 +1021,18 @@ int sptlrpc_pool_init(void) spin_lock_init(&pool->ppp_lock); pool->ppp_st_max_wait = ktime_set(0, 0); - pools_alloc(pool); + pool_alloc(pool); CDEBUG(D_SEC, "Allocated pool %i\n", pool_index); if (pool->ppp_pools == NULL) GOTO(fail, rc = -ENOMEM); #ifdef HAVE_SHRINKER_COUNT - pool->pool_shrinker.count_objects = pools_shrink_count; - pool->pool_shrinker.scan_objects = pools_shrink_scan; + pool->pool_shrinker.count_objects = pool_shrink_count; + pool->pool_shrinker.scan_objects = pool_shrink_scan; #else - pool->pool_shrinker.shrink = pools_shrink; + pool->pool_shrinker.shrink = pool_shrink; #endif pool->pool_shrinker.seeks = INDEX_TO_SEEKS(pool_index); - /* Pass pool number as part of pools_shrinker_seeks value */ + /* Pass pool number as part of pool_shrinker_seeks value */ rc = register_shrinker(&pool->pool_shrinker); if (rc) GOTO(fail, rc); @@ -1048,7 +1047,7 @@ fail: if (pool) { unregister_shrinker(&pool->pool_shrinker); if (pool->ppp_pools) - pools_free(pool_index); + pool_free(pool_index); OBD_FREE(pool, sizeof(**page_pools)); } } @@ -1070,11 +1069,10 @@ void sptlrpc_pool_fini(void) LASSERT(pool->ppp_total_pages == pool->ppp_free_pages); npools = npages_to_npools(pool->ppp_total_pages); - cleaned = pools_cleanup(pool->ppp_pools, - npools, pool_index); + cleaned = pool_cleanup(pool->ppp_pools, npools, pool_index); LASSERT(cleaned == pool->ppp_total_pages); - pools_free(pool_index); + pool_free(pool_index); if (pool->ppp_st_access > 0) { CDEBUG(D_SEC, -- 1.8.3.1