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 <pfarrell@whamcloud.com>
Change-Id: I9eabcfe77a57a82c87b36e3b3e040be91671fbfb
Reviewed-on: https://review.whamcloud.com/c/ex/lustre-release/+/52435
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 b017125..b954812 100644 (file)
--- 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,