mm: huge_memory: refactor anon_enabled_store() with set_anon_enabled_mode()

Consolidate the repeated spin_lock/set_bit/clear_bit pattern in
anon_enabled_store() into a new set_anon_enabled_mode() helper that loops
over an orders[] array, setting the bit for the selected mode and clearing
the others.

Introduce enum anon_enabled_mode and anon_enabled_mode_strings[] for the
per-order anon THP setting.

Use sysfs_match_string() with the anon_enabled_mode_strings[] table to
replace the if/else chain of sysfs_streq() calls.

The helper uses __test_and_set_bit()/__test_and_clear_bit() to track
whether the state actually changed, so start_stop_khugepaged() is only
called when needed.  When the mode is unchanged,
set_recommended_min_free_kbytes() is called directly to preserve the
watermark recalculation behavior of the original code.

Link: https://lkml.kernel.org/r/20260317-thp_logs-v7-2-31eb98fa5a8b@debian.org
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Lorenzo Stoakes (Oracle) <ljs@kernel.org>
Acked-by: David Hildenbrand (Arm) <david@kernel.org>
Cc: Baolin Wang <baolin.wang@linux.alibaba.com>
Cc: Barry Song <baohua@kernel.org>
Cc: Brendan Jackman <jackmanb@google.com>
Cc: Dev Jain <dev.jain@arm.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Lance Yang <lance.yang@linux.dev>
Cc: Liam Howlett <liam.howlett@oracle.com>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Nico Pache <npache@redhat.com>
Cc: Ryan Roberts <ryan.roberts@arm.com>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Usama Arif <usamaarif642@gmail.com>
Cc: Vlastimil Babka <vbabka@kernel.org>
Cc: Wei Yang <richard.weiyang@gmail.com>
Cc: Zi Yan <ziy@nvidia.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/mm/huge_memory.c b/mm/huge_memory.c
index a132fb98ed5df8f039cf56f1124af33134181ef1..211d8c8923188344103d4c93da8025558f6a8209 100644 (file)
--- a/mm/huge_memory.c
+++ b/mm/huge_memory.c
@@ -316,6 +316,20 @@ static ssize_t enabled_show(struct kobject *kobj,
        return sysfs_emit(buf, "%s\n", output);
 }
 
+enum anon_enabled_mode {
+       ANON_ENABLED_ALWAYS     = 0,
+       ANON_ENABLED_INHERIT    = 1,
+       ANON_ENABLED_MADVISE    = 2,
+       ANON_ENABLED_NEVER      = 3,
+};
+
+static const char * const anon_enabled_mode_strings[] = {
+       [ANON_ENABLED_ALWAYS]   = "always",
+       [ANON_ENABLED_INHERIT]  = "inherit",
+       [ANON_ENABLED_MADVISE]  = "madvise",
+       [ANON_ENABLED_NEVER]    = "never",
+};
+
 static ssize_t enabled_store(struct kobject *kobj,
                             struct kobj_attribute *attr,
                             const char *buf, size_t count)
@@ -515,48 +529,54 @@ static ssize_t anon_enabled_show(struct kobject *kobj,
        return sysfs_emit(buf, "%s\n", output);
 }
 
+static bool set_anon_enabled_mode(int order, enum anon_enabled_mode mode)
+{
+       static unsigned long *enabled_orders[] = {
+               &huge_anon_orders_always,
+               &huge_anon_orders_inherit,
+               &huge_anon_orders_madvise,
+       };
+       enum anon_enabled_mode m;
+       bool changed = false;
+
+       spin_lock(&huge_anon_orders_lock);
+       for (m = 0; m < ARRAY_SIZE(enabled_orders); m++) {
+               if (m == mode)
+                       changed |= !__test_and_set_bit(order, enabled_orders[m]);
+               else
+                       changed |= __test_and_clear_bit(order, enabled_orders[m]);
+       }
+       spin_unlock(&huge_anon_orders_lock);
+
+       return changed;
+}
+
 static ssize_t anon_enabled_store(struct kobject *kobj,
                                  struct kobj_attribute *attr,
                                  const char *buf, size_t count)
 {
        int order = to_thpsize(kobj)->order;
-       ssize_t ret = count;
+       int mode;
 
-       if (sysfs_streq(buf, "always")) {
-               spin_lock(&huge_anon_orders_lock);
-               clear_bit(order, &huge_anon_orders_inherit);
-               clear_bit(order, &huge_anon_orders_madvise);
-               set_bit(order, &huge_anon_orders_always);
-               spin_unlock(&huge_anon_orders_lock);
-       } else if (sysfs_streq(buf, "inherit")) {
-               spin_lock(&huge_anon_orders_lock);
-               clear_bit(order, &huge_anon_orders_always);
-               clear_bit(order, &huge_anon_orders_madvise);
-               set_bit(order, &huge_anon_orders_inherit);
-               spin_unlock(&huge_anon_orders_lock);
-       } else if (sysfs_streq(buf, "madvise")) {
-               spin_lock(&huge_anon_orders_lock);
-               clear_bit(order, &huge_anon_orders_always);
-               clear_bit(order, &huge_anon_orders_inherit);
-               set_bit(order, &huge_anon_orders_madvise);
-               spin_unlock(&huge_anon_orders_lock);
-       } else if (sysfs_streq(buf, "never")) {
-               spin_lock(&huge_anon_orders_lock);
-               clear_bit(order, &huge_anon_orders_always);
-               clear_bit(order, &huge_anon_orders_inherit);
-               clear_bit(order, &huge_anon_orders_madvise);
-               spin_unlock(&huge_anon_orders_lock);
-       } else
-               ret = -EINVAL;
+       mode = sysfs_match_string(anon_enabled_mode_strings, buf);
+       if (mode < 0)
+               return -EINVAL;
 
-       if (ret > 0) {
-               int err;
+       if (set_anon_enabled_mode(order, mode)) {
+               int err = start_stop_khugepaged();
 
-               err = start_stop_khugepaged();
                if (err)
-                       ret = err;
+                       return err;
+       } else {
+               /*
+                * Recalculate watermarks even when the mode didn't
+                * change, as the previous code always called
+                * start_stop_khugepaged() which does this internally.
+                */
+               set_recommended_min_free_kbytes();
        }
-       return ret;
+
+       return count;
 }
 
 static struct kobj_attribute anon_enabled_attr =