From 1006abcbd125953336b645e8112ea8055c647cd5 Mon Sep 17 00:00:00 2001 From: Patrick Farrell Date: Thu, 21 Sep 2023 11:06:06 -0400 Subject: [PATCH] EX-8270 ptlrpc: begin renaming pool_index to order Replace local variables for pool_index with pool_order. Other renames will be in a subsequent patch, to keep these as simple as possible. Test-Parameters: trivial Signed-off-by: Patrick Farrell Change-Id: If347ff39776f9a75c0f7d9d9981d01e19bc2cbc9 Reviewed-on: https://review.whamcloud.com/c/ex/lustre-release/+/52453 Tested-by: jenkins Tested-by: Maloo Reviewed-by: Andreas Dilger --- lustre/ptlrpc/sec_bulk.c | 49 ++++++++++++++++++++++++------------------------ 1 file changed, 25 insertions(+), 24 deletions(-) diff --git a/lustre/ptlrpc/sec_bulk.c b/lustre/ptlrpc/sec_bulk.c index f8c1f94..0d29821 100644 --- a/lustre/ptlrpc/sec_bulk.c +++ b/lustre/ptlrpc/sec_bulk.c @@ -195,7 +195,7 @@ int encrypt_page_pools_seq_show(struct seq_file *m, void *v) */ int page_pools_seq_show(struct seq_file *m, void *v) { - int pool_index; + int pool_order; struct ptlrpc_page_pool *pool; seq_printf(m, "physical_pages: %lu\n" @@ -203,8 +203,8 @@ int page_pools_seq_show(struct seq_file *m, void *v) "pools:\n", cfs_totalram_pages(), PAGES_PER_POOL); - for (pool_index = 0; pool_index < POOLS_COUNT; pool_index++) { - pool = page_pools[pool_index]; + for (pool_order = 0; pool_order < POOLS_COUNT; pool_order++) { + pool = page_pools[pool_order]; if (!pool->ppp_st_access) continue; spin_lock(&pool->ppp_lock); @@ -309,8 +309,8 @@ static void pool_release_free_pages(long npages, struct ptlrpc_page_pool *pool) 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]; + unsigned int pool_order = SEEKS_TO_INDEX(s); + struct ptlrpc_page_pool *pool = page_pools[pool_order]; /* * if no pool access for a long time, we consider it's fully * idle. A little race here is fine. @@ -336,8 +336,8 @@ static unsigned long pool_shrink_scan(struct shrinker *s, struct shrink_control *sc) { /* 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]; + unsigned int pool_order = SEEKS_TO_INDEX(s); + struct ptlrpc_page_pool *pool = page_pools[pool_order]; spin_lock(&pool->ppp_lock); if (pool->ppp_free_pages <= PTLRPC_MAX_BRW_PAGES) @@ -528,7 +528,7 @@ static int pool_add_pages(int npages, struct ptlrpc_page_pool *page_pool) void ***pools; int npools, alloced = 0; int i, j, rc = -ENOMEM; - unsigned int pool_index = page_pool->ppp_index; + unsigned int pool_order = page_pool->ppp_index; if (npages < POOL_INIT_SIZE / element_size(page_pool)) npages = POOL_INIT_SIZE / element_size(page_pool); @@ -552,7 +552,7 @@ static int pool_add_pages(int npages, struct ptlrpc_page_pool *page_pool) goto out_pools; for (j = 0; j < PAGES_PER_POOL && alloced < npages; j++) { - if (pool_index == PAGES_POOL) + if (pool_order == PAGES_POOL) pools[i][j] = alloc_page(GFP_NOFS | __GFP_HIGHMEM); else { @@ -1019,10 +1019,11 @@ static inline void pool_free(struct ptlrpc_page_pool *pool) int sptlrpc_pool_init(void) { - int pool_index = 0, to_revert; - int rc = 0; struct ptlrpc_page_pool *pool; int pool_max_pages = cfs_totalram_pages() / POOLS_COUNT; + int pool_order = 0; + int to_revert; + int rc = 0; ENTRY; @@ -1035,12 +1036,12 @@ int sptlrpc_pool_init(void) OBD_ALLOC(page_pools, POOLS_COUNT * sizeof(*page_pools)); if (page_pools == NULL) RETURN(-ENOMEM); - for (pool_index = 0; pool_index < POOLS_COUNT; pool_index++) { - OBD_ALLOC(page_pools[pool_index], sizeof(**page_pools)); - if (page_pools[pool_index] == NULL) + for (pool_order = 0; pool_order < POOLS_COUNT; pool_order++) { + OBD_ALLOC(page_pools[pool_order], sizeof(**page_pools)); + if (page_pools[pool_order] == NULL) GOTO(fail, rc = -ENOMEM); - pool = page_pools[pool_index]; + pool = page_pools[pool_order]; pool->ppp_max_pages = pool_max_pages; pool->ppp_max_pools = @@ -1054,8 +1055,8 @@ int sptlrpc_pool_init(void) pool->ppp_st_max_wait = ktime_set(0, 0); pool_alloc(pool); - pool->ppp_index = pool_index; - CDEBUG(D_SEC, "Allocated pool %i\n", pool_index); + pool->ppp_index = pool_order; + CDEBUG(D_SEC, "Allocated pool %i\n", pool_order); if (pool->ppp_pools == NULL) GOTO(fail, rc = -ENOMEM); #ifdef HAVE_SHRINKER_COUNT @@ -1064,7 +1065,7 @@ int sptlrpc_pool_init(void) #else pool->pool_shrinker.shrink = pool_shrink; #endif - pool->pool_shrinker.seeks = INDEX_TO_SEEKS(pool_index); + pool->pool_shrinker.seeks = INDEX_TO_SEEKS(pool_order); /* Pass pool number as part of pool_shrinker_seeks value */ rc = register_shrinker(&pool->pool_shrinker); if (rc) @@ -1074,9 +1075,9 @@ int sptlrpc_pool_init(void) RETURN(0); fail: - to_revert = pool_index; - for (pool_index = 0; pool_index <= to_revert; pool_index++) { - pool = page_pools[pool_index]; + to_revert = pool_order; + for (pool_order = 0; pool_order <= to_revert; pool_order++) { + pool = page_pools[pool_order]; if (pool) { unregister_shrinker(&pool->pool_shrinker); if (pool->ppp_pools) @@ -1092,11 +1093,11 @@ fail: void sptlrpc_pool_fini(void) { unsigned long cleaned, npools; - int pool_index; + int pool_order; struct ptlrpc_page_pool *pool; - for (pool_index = 0; pool_index < POOLS_COUNT; pool_index++) { - pool = page_pools[pool_index]; + for (pool_order = 0; pool_order < POOLS_COUNT; pool_order++) { + pool = page_pools[pool_order]; unregister_shrinker(&pool->pool_shrinker); LASSERT(pool->ppp_pools); LASSERT(pool->ppp_total_pages == pool->ppp_free_pages); -- 1.8.3.1