mm: vmscan: refactor updating reclaimed pages in reclaim_state

During reclaim, we keep track of pages reclaimed from other means than
LRU-based reclaim through scan_control->reclaim_state->reclaimed_slab,
which we stash a pointer to in current task_struct.

However, we keep track of more than just reclaimed slab pages through
this.  We also use it for clean file pages dropped through pruned inodes,
and xfs buffer pages freed.  Rename reclaimed_slab to reclaimed, and add a
helper function that wraps updating it through current, so that future
changes to this logic are contained within mm/vmscan.c.

Link: https://lkml.kernel.org/r/20230404001353.468224-3-yosryahmed@google.com
Signed-off-by: Yosry Ahmed <yosryahmed@google.com>
Cc: Christoph Lameter <cl@linux.com>
Cc: Darrick J. Wong <djwong@kernel.org>
Cc: Dave Chinner <david@fromorbit.com>
Cc: David Hildenbrand <david@redhat.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Hyeonggon Yoo <42.hyeyoo@gmail.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Joonsoo Kim <iamjoonsoo.kim@lge.com>
Cc: Matthew Wilcox (Oracle) <willy@infradead.org>
Cc: Miaohe Lin <linmiaohe@huawei.com>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: NeilBrown <neilb@suse.de>
Cc: Peter Xu <peterx@redhat.com>
Cc: Roman Gushchin <roman.gushchin@linux.dev>
Cc: Shakeel Butt <shakeelb@google.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Yu Zhao <yuzhao@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/fs/inode.c b/fs/inode.c
index 4558dc2f13557368fb0200d826fe2edba5de3f1e..e60fcc41faf177c86150e0d121c2e69518e014f9 100644 (file)
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -864,8 +864,7 @@ static enum lru_status inode_lru_isolate(struct list_head *item,
                                __count_vm_events(KSWAPD_INODESTEAL, reap);
                        else
                                __count_vm_events(PGINODESTEAL, reap);
-                       if (current->reclaim_state)
-                               current->reclaim_state->reclaimed_slab += reap;
+                       mm_account_reclaimed_pages(reap);
                }
                iput(inode);
                spin_lock(lru_lock);

diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 54c774af6e1c625abf96d5177fa11814952da1fb..15d1e5a7c2d3407c39846d9f7950af546f749f27 100644 (file)
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -286,8 +286,7 @@ xfs_buf_free_pages(
                if (bp->b_pages[i])
                        __free_page(bp->b_pages[i]);
        }
-       if (current->reclaim_state)
-               current->reclaim_state->reclaimed_slab += bp->b_page_count;
+       mm_account_reclaimed_pages(bp->b_page_count);
 
        if (bp->b_pages != bp->b_page_array)
                kmem_free(bp->b_pages);

diff --git a/include/linux/swap.h b/include/linux/swap.h
index bfc3b06b5f8fa0a0c11d053a71d6ee8e38937053..7f7d5b9ddf7ef961cc673252fe269cdaf63b9da3 100644 (file)
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -153,13 +153,28 @@ union swap_header {
  * memory reclaim
  */
 struct reclaim_state {
-       unsigned long reclaimed_slab;
+       /* pages reclaimed outside of LRU-based reclaim */
+       unsigned long reclaimed;
 #ifdef CONFIG_LRU_GEN
        /* per-thread mm walk data */
        struct lru_gen_mm_walk *mm_walk;
 #endif
 };
 
+/*
+ * mm_account_reclaimed_pages(): account reclaimed pages outside of LRU-based
+ * reclaim
+ * @pages: number of pages reclaimed
+ *
+ * If the current process is undergoing a reclaim operation, increment the
+ * number of reclaimed pages by @pages.
+ */
+static inline void mm_account_reclaimed_pages(unsigned long pages)
+{
+       if (current->reclaim_state)
+               current->reclaim_state->reclaimed += pages;
+}
+
 #ifdef __KERNEL__
 
 struct address_space;

diff --git a/mm/slab.c b/mm/slab.c
index 6b7c172158e5b0cf96dbf2824c427c873f12384c..bb57f7fdbae14e3f50bfe155a7606555eb56a442 100644 (file)
--- a/mm/slab.c
+++ b/mm/slab.c
@@ -1392,8 +1392,7 @@ static void kmem_freepages(struct kmem_cache *cachep, struct slab *slab)
        smp_wmb();
        __folio_clear_slab(folio);
 
-       if (current->reclaim_state)
-               current->reclaim_state->reclaimed_slab += 1 << order;
+       mm_account_reclaimed_pages(1 << order);
        unaccount_slab(slab, order, cachep);
        __free_pages(&folio->page, order);
 }

diff --git a/mm/slob.c b/mm/slob.c
index fe567fcfa3a39ef41f939f734c2eab41e86de3c2..79cc8680c973cd80322f0d53a8a07765469eab3c 100644 (file)
--- a/mm/slob.c
+++ b/mm/slob.c
@@ -61,7 +61,7 @@
 #include <linux/slab.h>
 
 #include <linux/mm.h>
-#include <linux/swap.h> /* struct reclaim_state */
+#include <linux/swap.h> /* mm_account_reclaimed_pages() */
 #include <linux/cache.h>
 #include <linux/init.h>
 #include <linux/export.h>
@@ -211,9 +211,7 @@ static void slob_free_pages(void *b, int order)
 {
        struct page *sp = virt_to_page(b);
 
-       if (current->reclaim_state)
-               current->reclaim_state->reclaimed_slab += 1 << order;
-
+       mm_account_reclaimed_pages(1 << order);
        mod_node_page_state(page_pgdat(sp), NR_SLAB_UNRECLAIMABLE_B,
                            -(PAGE_SIZE << order));
        __free_pages(sp, order);

diff --git a/mm/slub.c b/mm/slub.c
index f49d669ff604166ea1943e72f31050ba61b950f7..2728d5ae4dc0e42603e5aab177ce16b6eb3f8327 100644 (file)
--- a/mm/slub.c
+++ b/mm/slub.c
@@ -11,7 +11,7 @@
  */
 
 #include <linux/mm.h>
-#include <linux/swap.h> /* struct reclaim_state */
+#include <linux/swap.h> /* mm_account_reclaimed_pages() */
 #include <linux/module.h>
 #include <linux/bit_spinlock.h>
 #include <linux/interrupt.h>
@@ -2063,8 +2063,7 @@ static void __free_slab(struct kmem_cache *s, struct slab *slab)
        /* Make the mapping reset visible before clearing the flag */
        smp_wmb();
        __folio_clear_slab(folio);
-       if (current->reclaim_state)
-               current->reclaim_state->reclaimed_slab += pages;
+       mm_account_reclaimed_pages(pages);
        unaccount_slab(slab, order, s);
        __free_pages(&folio->page, order);
 }

diff --git a/mm/vmscan.c b/mm/vmscan.c
index 83388b22fce9668b9765ee60d6c41bd5079e771c..7437fb63e1accfca415982af8890662519316ddd 100644 (file)
--- a/mm/vmscan.c
+++ b/mm/vmscan.c
@@ -528,6 +528,19 @@ static void set_task_reclaim_state(struct task_struct *task,
        task->reclaim_state = rs;
 }
 
+/*
+ * flush_reclaim_state(): add pages reclaimed outside of LRU-based reclaim to
+ * scan_control->nr_reclaimed.
+ */
+static void flush_reclaim_state(struct scan_control *sc,
+                               struct reclaim_state *rs)
+{
+       if (rs) {
+               sc->nr_reclaimed += rs->reclaimed;
+               rs->reclaimed = 0;
+       }
+}
+
 static long xchg_nr_deferred(struct shrinker *shrinker,
                             struct shrink_control *sc)
 {
@@ -5362,8 +5375,7 @@ static int shrink_one(struct lruvec *lruvec, struct scan_control *sc)
                vmpressure(sc->gfp_mask, memcg, false, sc->nr_scanned - scanned,
                           sc->nr_reclaimed - reclaimed);
 
-       sc->nr_reclaimed += current->reclaim_state->reclaimed_slab;
-       current->reclaim_state->reclaimed_slab = 0;
+       flush_reclaim_state(sc, current->reclaim_state);
 
        return success ? MEMCG_LRU_YOUNG : 0;
 }
@@ -6484,10 +6496,7 @@ again:
 
        shrink_node_memcgs(pgdat, sc);
 
-       if (reclaim_state) {
-               sc->nr_reclaimed += reclaim_state->reclaimed_slab;
-               reclaim_state->reclaimed_slab = 0;
-       }
+       flush_reclaim_state(sc, reclaim_state);
 
        /* Record the subtree's reclaim efficiency */
        if (!sc->proactive)