EX-8270 ptlrpc: change "pool" to "page_ptrs"

The page pool code *also* likes to refer to each page of
pointers it uses to track items in it as a "POOL", which is
incredibly confusing.

This patch works on renaming that to page_ptrs, but leaves
some steps for a future patch.

Test-Parameters: trivial
Signed-off-by: Patrick Farrell <pfarrell@whamcloud.com>
Change-Id: I56ee54c7f39b52d7cceffec9e3decf71bd313ddc
Reviewed-on: https://review.whamcloud.com/c/ex/lustre-release/+/52458
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 5286193..e15f2ee 100644 (file)
--- a/lustre/ptlrpc/sec_bulk.c
+++ b/lustre/ptlrpc/sec_bulk.c
@@ -121,9 +121,9 @@ static struct ptlrpc_page_pool {
        ktime_t ppp_st_max_wait; /* in nanoseconds */
        unsigned long ppp_st_outofmem; /* # of out of mem requests */
        /*
-        * pointers to pools, may be vmalloc'd
+        * pointers to ptr_pages, may be vmalloc'd
         */
-       void ***ppp_pools;
+       void ***ppp_ptr_pages;
        /*
         * memory shrinker
         */
@@ -272,19 +272,19 @@ static void pool_release_free_pages(long npages, struct ptlrpc_page_pool *pool)
 
        p_idx = pool->ppp_free_pages / PTRS_PER_PAGE;
        g_idx = pool->ppp_free_pages % PTRS_PER_PAGE;
-       LASSERT(pool->ppp_pools[p_idx]);
+       LASSERT(pool->ppp_ptr_pages[p_idx]);
 
        while (npages--) {
-               LASSERT(pool->ppp_pools[p_idx]);
-               LASSERT(pool->ppp_pools[p_idx][g_idx] != NULL);
+               LASSERT(pool->ppp_ptr_pages[p_idx]);
+               LASSERT(pool->ppp_ptr_pages[p_idx][g_idx] != NULL);
 
                if (pool->ppp_order == 0)
-                       __free_page(pool->ppp_pools[p_idx][g_idx]);
+                       __free_page(pool->ppp_ptr_pages[p_idx][g_idx]);
                else
-                       OBD_FREE_LARGE(pool->ppp_pools[p_idx][g_idx],
+                       OBD_FREE_LARGE(pool->ppp_ptr_pages[p_idx][g_idx],
                                       element_size(pool));
 
-               pool->ppp_pools[p_idx][g_idx] = NULL;
+               pool->ppp_ptr_pages[p_idx][g_idx] = NULL;
 
                if (++g_idx == PTRS_PER_PAGE) {
                        p_idx++;
@@ -294,9 +294,9 @@ static void pool_release_free_pages(long npages, struct ptlrpc_page_pool *pool)
 
        /* free unused pools */
        while (p_idx_max1 < p_idx_max2) {
-               LASSERT(pool->ppp_pools[p_idx_max2]);
-               OBD_FREE(pool->ppp_pools[p_idx_max2], PAGE_SIZE);
-               pool->ppp_pools[p_idx_max2] = NULL;
+               LASSERT(pool->ppp_ptr_pages[p_idx_max2]);
+               OBD_FREE(pool->ppp_ptr_pages[p_idx_max2], PAGE_SIZE);
+               pool->ppp_ptr_pages[p_idx_max2] = NULL;
                p_idx_max2--;
        }
 }
@@ -459,10 +459,10 @@ static void pool_insert(void ***pools, int npools, int npages,
        ng_idx = (npages - 1) % PTRS_PER_PAGE;
 
        while (freeslot) {
-               LASSERT(page_pool->ppp_pools[op_idx][og_idx] == NULL);
+               LASSERT(page_pool->ppp_ptr_pages[op_idx][og_idx] == NULL);
                LASSERT(pools[np_idx][ng_idx] != NULL);
 
-               page_pool->ppp_pools[op_idx][og_idx] = pools[np_idx][ng_idx];
+               page_pool->ppp_ptr_pages[op_idx][og_idx] = pools[np_idx][ng_idx];
                pools[np_idx][ng_idx] = NULL;
 
                freeslot--;
@@ -490,11 +490,11 @@ static void pool_insert(void ***pools, int npools, int npages,
 
        np_idx = 0;
        while (cur_npools < end_npools) {
-               LASSERT(page_pool->ppp_pools[cur_npools] == NULL);
+               LASSERT(page_pool->ppp_ptr_pages[cur_npools] == NULL);
                LASSERT(np_idx < npools);
                LASSERT(pools[np_idx] != NULL);
 
-               page_pool->ppp_pools[cur_npools++] = pools[np_idx];
+               page_pool->ppp_ptr_pages[cur_npools++] = pools[np_idx];
                pools[np_idx++] = NULL;
        }
 
@@ -756,10 +756,10 @@ again:
        for (i = 0; i < count; i++) {
                void **pagep = page_from(array, i);
 
-               if (page_pool->ppp_pools[p_idx][g_idx] == NULL)
+               if (page_pool->ppp_ptr_pages[p_idx][g_idx] == NULL)
                        GOTO(out_unlock, rc = -EPROTO);
-               *pagep = page_pool->ppp_pools[p_idx][g_idx];
-               page_pool->ppp_pools[p_idx][g_idx] = NULL;
+               *pagep = page_pool->ppp_ptr_pages[p_idx][g_idx];
+               page_pool->ppp_ptr_pages[p_idx][g_idx] = NULL;
 
                if (++g_idx == PTRS_PER_PAGE) {
                        p_idx++;
@@ -857,17 +857,17 @@ static int __sptlrpc_pool_put_pages(void *array, unsigned int count,
 
        if (page_pool->ppp_free_pages + count > page_pool->ppp_total_pages)
                GOTO(out_unlock, rc = -EPROTO);
-       if (!page_pool->ppp_pools[p_idx])
+       if (!page_pool->ppp_ptr_pages[p_idx])
                GOTO(out_unlock, rc = -EPROTO);
 
        for (i = 0; i < count; i++) {
                void **pagep = page_from(array, i);
 
                if (!*pagep ||
-                   page_pool->ppp_pools[p_idx][g_idx] != NULL)
+                   page_pool->ppp_ptr_pages[p_idx][g_idx] != NULL)
                        GOTO(out_unlock, rc = -EPROTO);
 
-               page_pool->ppp_pools[p_idx][g_idx] = *pagep;
+               page_pool->ppp_ptr_pages[p_idx][g_idx] = *pagep;
                if (++g_idx == PTRS_PER_PAGE) {
                        p_idx++;
                        g_idx = 0;
@@ -992,21 +992,21 @@ void sptlrpc_pool_del_user(void)
 }
 EXPORT_SYMBOL(sptlrpc_pool_del_user);
 
-static inline void pool_alloc(struct ptlrpc_page_pool *pool)
+static inline void pool_ptrs_alloc(struct ptlrpc_page_pool *pool)
 {
        LASSERT(pool->ppp_max_pools);
-       OBD_ALLOC_LARGE(pool->ppp_pools,
+       OBD_ALLOC_LARGE(pool->ppp_ptr_pages,
                        pool->ppp_max_pools *
-                       sizeof(*pool->ppp_pools));
+                       sizeof(*pool->ppp_ptr_pages));
 }
 
-static inline void pool_free(struct ptlrpc_page_pool *pool)
+static inline void pool_ptrs_free(struct ptlrpc_page_pool *pool)
 {
        LASSERT(pool->ppp_max_pools);
-       LASSERT(pool->ppp_pools);
+       LASSERT(pool->ppp_ptr_pages);
 
-       OBD_FREE_LARGE(pool->ppp_pools,
-                      pool->ppp_max_pools * sizeof(*pool->ppp_pools));
+       OBD_FREE_LARGE(pool->ppp_ptr_pages,
+                      pool->ppp_max_pools * sizeof(*pool->ppp_ptr_pages));
 }
 
 int sptlrpc_pool_init(void)
@@ -1046,10 +1046,10 @@ int sptlrpc_pool_init(void)
                spin_lock_init(&pool->ppp_lock);
                pool->ppp_st_max_wait = ktime_set(0, 0);
 
-               pool_alloc(pool);
+               pool_ptrs_alloc(pool);
                pool->ppp_order = pool_order;
                CDEBUG(D_SEC, "Allocated pool %i\n", pool_order);
-               if (pool->ppp_pools == NULL)
+               if (pool->ppp_ptr_pages == NULL)
                        GOTO(fail, rc = -ENOMEM);
 #ifdef HAVE_SHRINKER_COUNT
                pool->pool_shrinker.count_objects = pool_shrink_count;
@@ -1072,8 +1072,8 @@ fail:
                pool = page_pools[pool_order];
                if (pool) {
                        unregister_shrinker(&pool->pool_shrinker);
-                       if (pool->ppp_pools) 
-                               pool_free(pool);
+                       if (pool->ppp_ptr_pages) 
+                               pool_ptrs_free(pool);
                        OBD_FREE(pool, sizeof(**page_pools));
                }
        }
@@ -1091,14 +1091,14 @@ void sptlrpc_pool_fini(void)
        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_ptr_pages);
                LASSERT(pool->ppp_total_pages == pool->ppp_free_pages);
 
                npools = npages_to_npools(pool->ppp_total_pages);
-               cleaned = pool_cleanup(pool->ppp_pools, npools, pool);
+               cleaned = pool_cleanup(pool->ppp_ptr_pages, npools, pool);
                LASSERT(cleaned == pool->ppp_total_pages);
 
-               pool_free(pool);
+               pool_ptrs_free(pool);
 
                if (pool->ppp_st_access > 0) {
                        CDEBUG(D_SEC,