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 <pfarrell@whamcloud.com>
Change-Id: If347ff39776f9a75c0f7d9d9981d01e19bc2cbc9
Reviewed-on: https://review.whamcloud.com/c/ex/lustre-release/+/52453
Tested-by: jenkins <devops@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>

diff --git a/lustre/ptlrpc/sec_bulk.c b/lustre/ptlrpc/sec_bulk.c
index f8c1f94..0d29821 100644 (file)
--- 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);