From 2b128fafba7043caaf9bf10dafd3e111abbe02cf Mon Sep 17 00:00:00 2001 From: Patrick Farrell Date: Wed, 20 Sep 2023 14:17:01 -0400 Subject: [PATCH] EX-8270 ptlrpc: reduce usage of pool_index The pool index is used over and over a lot of places where we should just use it once. Note the printing functions are deliberately not combined to maximum length lines for ease of reading. Test-Parameters: trivial Signed-off-by: Patrick Farrell Change-Id: I7efbf491cf28f6fd16d06f5bbc42d714c908f34c Reviewed-on: https://review.whamcloud.com/c/ex/lustre-release/+/52436 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Andreas Dilger --- lustre/ptlrpc/sec_bulk.c | 72 +++++++++++++++++++++++++----------------------- 1 file changed, 38 insertions(+), 34 deletions(-) diff --git a/lustre/ptlrpc/sec_bulk.c b/lustre/ptlrpc/sec_bulk.c index b954812..e664ff6 100644 --- a/lustre/ptlrpc/sec_bulk.c +++ b/lustre/ptlrpc/sec_bulk.c @@ -139,7 +139,9 @@ static struct ptlrpc_page_pool { */ int encrypt_page_pools_seq_show(struct seq_file *m, void *v) { - spin_lock(&page_pools[PAGES_POOL]->ppp_lock); + struct ptlrpc_page_pool *pool = page_pools[PAGES_POOL]; + + spin_lock(&pool->ppp_lock); seq_printf(m, "physical pages: %lu\n" "pages per pool: %lu\n" "max pages: %lu\n" @@ -160,24 +162,24 @@ int encrypt_page_pools_seq_show(struct seq_file *m, void *v) "max wait time ms: %lld\n" "out of mem: %lu\n", cfs_totalram_pages(), PAGES_PER_POOL, - page_pools[PAGES_POOL]->ppp_max_pages, - page_pools[PAGES_POOL]->ppp_max_pools, - page_pools[PAGES_POOL]->ppp_total_pages, - page_pools[PAGES_POOL]->ppp_free_pages, - page_pools[PAGES_POOL]->ppp_idle_idx, - ktime_get_seconds() - page_pools[PAGES_POOL]->ppp_last_shrink, - ktime_get_seconds() - page_pools[PAGES_POOL]->ppp_last_access, - page_pools[PAGES_POOL]->ppp_st_max_pages, - page_pools[PAGES_POOL]->ppp_st_grows, - page_pools[PAGES_POOL]->ppp_st_grow_fails, - page_pools[PAGES_POOL]->ppp_st_shrinks, - page_pools[PAGES_POOL]->ppp_st_access, - page_pools[PAGES_POOL]->ppp_st_missings, - page_pools[PAGES_POOL]->ppp_st_lowfree, - page_pools[PAGES_POOL]->ppp_st_max_wqlen, - ktime_to_ms(page_pools[PAGES_POOL]->ppp_st_max_wait), - page_pools[PAGES_POOL]->ppp_st_outofmem); - spin_unlock(&page_pools[PAGES_POOL]->ppp_lock); + pool->ppp_max_pages, + pool->ppp_max_pools, + pool->ppp_total_pages, + pool->ppp_free_pages, + pool->ppp_idle_idx, + ktime_get_seconds() - pool->ppp_last_shrink, + ktime_get_seconds() - pool->ppp_last_access, + pool->ppp_st_max_pages, + pool->ppp_st_grows, + pool->ppp_st_grow_fails, + pool->ppp_st_shrinks, + pool->ppp_st_access, + pool->ppp_st_missings, + pool->ppp_st_lowfree, + pool->ppp_st_max_wqlen, + ktime_to_ms(pool->ppp_st_max_wait), + pool->ppp_st_outofmem); + spin_unlock(&pool->ppp_lock); return 0; } @@ -596,17 +598,17 @@ static inline void pool_wakeup(unsigned int pool) static int pool_should_grow(int needed, unsigned int pool_index) { + struct ptlrpc_page_pool *pool = page_pools[pool_index]; + /* * don't grow if someone else is growing the pools right now, * or the pools has reached its full capacity */ - if (page_pools[pool_index]->ppp_growing || - page_pools[pool_index]->ppp_total_pages == - page_pools[pool_index]->ppp_max_pages) + if (pool->ppp_growing || pool->ppp_total_pages == pool->ppp_max_pages) return 0; /* if total pages is not enough, we need to grow */ - if (page_pools[pool_index]->ppp_total_pages < needed) + if (pool->ppp_total_pages < needed) return 1; /* @@ -941,22 +943,23 @@ EXPORT_SYMBOL(sptlrpc_pool_put_pages); */ int sptlrpc_pool_add_user(void) { + struct ptlrpc_page_pool *pool = page_pools[PAGES_POOL]; - spin_lock(&page_pools[PAGES_POOL]->ppp_lock); + spin_lock(&pool->ppp_lock); /* 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 (pool_should_grow(1, PAGES_POOL)) { - page_pools[PAGES_POOL]->ppp_growing = 1; - spin_unlock(&page_pools[PAGES_POOL]->ppp_lock); + pool->ppp_growing = 1; + spin_unlock(&pool->ppp_lock); pool_add_pages(PTLRPC_MAX_BRW_PAGES * 2, PAGES_POOL); - spin_lock(&page_pools[PAGES_POOL]->ppp_lock); - page_pools[PAGES_POOL]->ppp_growing = 0; + spin_lock(&pool->ppp_lock); + pool->ppp_growing = 0; pool_wakeup(PAGES_POOL); } - spin_unlock(&page_pools[PAGES_POOL]->ppp_lock); + spin_unlock(&pool->ppp_lock); return 0; } EXPORT_SYMBOL(sptlrpc_pool_add_user); @@ -977,12 +980,13 @@ static inline void pool_alloc(struct ptlrpc_page_pool *pool) static inline void pool_free(unsigned int pool_index) { - LASSERT(page_pools[pool_index]->ppp_max_pools); - LASSERT(page_pools[pool_index]->ppp_pools); + struct ptlrpc_page_pool *pool = page_pools[pool_index]; + + LASSERT(pool->ppp_max_pools); + LASSERT(pool->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)); + OBD_FREE_LARGE(pool->ppp_pools, + pool->ppp_max_pools * sizeof(*pool->ppp_pools)); } int sptlrpc_pool_init(void) -- 1.8.3.1