page_counter: track failcnt only for legacy cgroups

Currently page_counter tracks failcnt for counters used by v1 and v2
controllers.  However failcnt is only exported for v1 deployment and thus
there is no need to maintain it in v2.  The oom report does expose failcnt
for memory and swap in v2 but v2 already maintains MEMCG_MAX and
MEMCG_SWAP_MAX event counters which can be used.

Link: https://lkml.kernel.org/r/20250228075808.207484-3-shakeel.butt@linux.dev
Signed-off-by: Shakeel Butt <shakeel.butt@linux.dev>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Michal Hocko <mhocko@kernel.org>
Cc: Muchun Song <muchun.song@linux.dev>
Cc: Roman Gushchin (Cruise) <roman.gushchin@linux.dev>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/include/linux/page_counter.h b/include/linux/page_counter.h
index 46406f3fe34d0b0560b3779b3dfeb634bf8e6a9b..e4bd8fd427bedf3f7e68c409cbfc2f0d7c01a4e3 100644 (file)
--- a/include/linux/page_counter.h
+++ b/include/linux/page_counter.h
@@ -28,12 +28,13 @@ struct page_counter {
        unsigned long watermark;
        /* Latest cg2 reset watermark */
        unsigned long local_watermark;
-       unsigned long failcnt;
+       unsigned long failcnt; /* v1-only field */
 
        /* Keep all the read most fields in a separete cacheline. */
        CACHELINE_PADDING(_pad2_);
 
        bool protection_support;
+       bool track_failcnt;
        unsigned long min;
        unsigned long low;
        unsigned long high;
@@ -58,6 +59,7 @@ static inline void page_counter_init(struct page_counter *counter,
        counter->max = PAGE_COUNTER_MAX;
        counter->parent = parent;
        counter->protection_support = protection_support;
+       counter->track_failcnt = false;
 }
 
 static inline unsigned long page_counter_read(struct page_counter *counter)

diff --git a/mm/hugetlb_cgroup.c b/mm/hugetlb_cgroup.c
index bb9578bd99f98e94746f022bd42f38969ec73cbe..58e895f3899a1db365e35f47a1c1739b4a34e0b5 100644 (file)
--- a/mm/hugetlb_cgroup.c
+++ b/mm/hugetlb_cgroup.c
@@ -101,10 +101,9 @@ static void hugetlb_cgroup_init(struct hugetlb_cgroup *h_cgroup,
        int idx;
 
        for (idx = 0; idx < HUGE_MAX_HSTATE; idx++) {
-               struct page_counter *fault_parent = NULL;
-               struct page_counter *rsvd_parent = NULL;
+               struct page_counter *fault, *fault_parent = NULL;
+               struct page_counter *rsvd, *rsvd_parent = NULL;
                unsigned long limit;
-               int ret;
 
                if (parent_h_cgroup) {
                        fault_parent = hugetlb_cgroup_counter_from_cgroup(
@@ -112,24 +111,22 @@ static void hugetlb_cgroup_init(struct hugetlb_cgroup *h_cgroup,
                        rsvd_parent = hugetlb_cgroup_counter_from_cgroup_rsvd(
                                parent_h_cgroup, idx);
                }
-               page_counter_init(hugetlb_cgroup_counter_from_cgroup(h_cgroup,
-                                                                    idx),
-                                 fault_parent, false);
-               page_counter_init(
-                       hugetlb_cgroup_counter_from_cgroup_rsvd(h_cgroup, idx),
-                       rsvd_parent, false);
+               fault = hugetlb_cgroup_counter_from_cgroup(h_cgroup, idx);
+               rsvd = hugetlb_cgroup_counter_from_cgroup_rsvd(h_cgroup, idx);
+
+               page_counter_init(fault, fault_parent, false);
+               page_counter_init(rsvd, rsvd_parent, false);
+
+               if (!cgroup_subsys_on_dfl(hugetlb_cgrp_subsys)) {
+                       fault->track_failcnt = true;
+                       rsvd->track_failcnt = true;
+               }
 
                limit = round_down(PAGE_COUNTER_MAX,
                                   pages_per_huge_page(&hstates[idx]));
 
-               ret = page_counter_set_max(
-                       hugetlb_cgroup_counter_from_cgroup(h_cgroup, idx),
-                       limit);
-               VM_BUG_ON(ret);
-               ret = page_counter_set_max(
-                       hugetlb_cgroup_counter_from_cgroup_rsvd(h_cgroup, idx),
-                       limit);
-               VM_BUG_ON(ret);
+               VM_BUG_ON(page_counter_set_max(fault, limit));
+               VM_BUG_ON(page_counter_set_max(rsvd, limit));
        }
 }
 

diff --git a/mm/memcontrol.c b/mm/memcontrol.c
index cfccb24bc0326dac201d4d550071d4c2c9df5b4e..0f5e55e75dc9490bf682b2bcf6afb4492b36783b 100644 (file)
--- a/mm/memcontrol.c
+++ b/mm/memcontrol.c
@@ -1572,16 +1572,23 @@ void mem_cgroup_print_oom_meminfo(struct mem_cgroup *memcg)
        /* Use static buffer, for the caller is holding oom_lock. */
        static char buf[SEQ_BUF_SIZE];
        struct seq_buf s;
+       unsigned long memory_failcnt;
 
        lockdep_assert_held(&oom_lock);
 
+       if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
+               memory_failcnt = atomic_long_read(&memcg->memory_events[MEMCG_MAX]);
+       else
+               memory_failcnt = memcg->memory.failcnt;
+
        pr_info("memory: usage %llukB, limit %llukB, failcnt %lu\n",
                K((u64)page_counter_read(&memcg->memory)),
-               K((u64)READ_ONCE(memcg->memory.max)), memcg->memory.failcnt);
+               K((u64)READ_ONCE(memcg->memory.max)), memory_failcnt);
        if (cgroup_subsys_on_dfl(memory_cgrp_subsys))
                pr_info("swap: usage %llukB, limit %llukB, failcnt %lu\n",
                        K((u64)page_counter_read(&memcg->swap)),
-                       K((u64)READ_ONCE(memcg->swap.max)), memcg->swap.failcnt);
+                       K((u64)READ_ONCE(memcg->swap.max)),
+                       atomic_long_read(&memcg->memory_events[MEMCG_SWAP_MAX]));
 #ifdef CONFIG_MEMCG_V1
        else {
                pr_info("memory+swap: usage %llukB, limit %llukB, failcnt %lu\n",
@@ -3622,6 +3629,7 @@ mem_cgroup_css_alloc(struct cgroup_subsys_state *parent_css)
                page_counter_init(&memcg->memory, &parent->memory, memcg_on_dfl);
                page_counter_init(&memcg->swap, &parent->swap, false);
 #ifdef CONFIG_MEMCG_V1
+               memcg->memory.track_failcnt = !memcg_on_dfl;
                WRITE_ONCE(memcg->oom_kill_disable, READ_ONCE(parent->oom_kill_disable));
                page_counter_init(&memcg->kmem, &parent->kmem, false);
                page_counter_init(&memcg->tcpmem, &parent->tcpmem, false);

diff --git a/mm/page_counter.c b/mm/page_counter.c
index af23f927611b78cb86d5524610afc0389671817d..661e0f2a5127a53bafb9005b076f40cdf72ad54b 100644 (file)
--- a/mm/page_counter.c
+++ b/mm/page_counter.c
@@ -121,6 +121,7 @@ bool page_counter_try_charge(struct page_counter *counter,
 {
        struct page_counter *c;
        bool protection = track_protection(counter);
+       bool track_failcnt = counter->track_failcnt;
 
        for (c = counter; c; c = c->parent) {
                long new;
@@ -146,7 +147,8 @@ bool page_counter_try_charge(struct page_counter *counter,
                         * inaccuracy in the failcnt which is only used
                         * to report stats.
                         */
-                       data_race(c->failcnt++);
+                       if (track_failcnt)
+                               data_race(c->failcnt++);
                        *fail = c;
                        goto failed;
                }