[PATCH v3 0/2] refactors thpsize_shmem_enabled_store() and thpsize_shmem_enabled_show()

[PATCH v3 0/2] refactors thpsize_shmem_enabled_store() and thpsize_shmem_enabled_show()

[ranxiaokai627]

From: Ran Xiaokai <ran.xiaokai@zte.com.cn>

This is v3 of the refactor of thpsize_shmem_enabled_store() and
thpsize_shmem_enabled_show() series.

Changes since v2:
 - Fix subject prefix to "mm: shmem:" as suggested by Baolin.
 - Some changes according to Lorenzo's comments:
   - Add cover letter and fix threading.
   - Add THP maintainers to the cc list.
   - Document the behavioral change regarding start_stop_khugepaged() in commit message.
   - Improve single letter variable names.
   - Simplify error handling and return values.

Ran Xiaokai (2):
  mm: shmem: refactor thpsize_shmem_enabled_store() with
    sysfs_match_string()
  mm: shmem: refactor thpsize_shmem_enabled_show() with helper arrays

 mm/shmem.c | 143 +++++++++++++++++++++++++++++++----------------------
 1 file changed, 83 insertions(+), 60 deletions(-)

-- 
2.25.1

[PATCH v3 1/2] mm: shmem: refactor thpsize_shmem_enabled_store() with sysfs_match_string()

[ranxiaokai627]

From: Ran Xiaokai <ran.xiaokai@zte.com.cn>

Inspired by commit 82d9ff648c6c ("mm: huge_memory: refactor
anon_enabled_store() with set_anon_enabled_mode()"), refactor
thpsize_shmem_enabled_store() using sysfs_match_string().
This eliminates the duplicated spin_lock/unlock(), set/clear_bit(),
calls across all branches, reducing code duplication.

Behavioral change:
Call start_stop_khugepaged() only when the mode actually changes.
If unchanged, call set_recommended_min_free_kbytes() to preserve
legacy watermark behavior. This avoids unnecessary khugepaged restarts.

Tested with selftests ./run_kselftest.sh -t mm:ksft_thp.sh,
all test cases passed.

Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>
---
 mm/shmem.c | 107 ++++++++++++++++++++++++++++++-----------------------
 1 file changed, 60 insertions(+), 47 deletions(-)

diff --git a/mm/shmem.c b/mm/shmem.c
index 3b5dc21b323c..46d2cfc30823 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -5526,6 +5526,29 @@ static ssize_t shmem_enabled_store(struct kobject *kobj,
 struct kobj_attribute shmem_enabled_attr = __ATTR_RW(shmem_enabled);
 static DEFINE_SPINLOCK(huge_shmem_orders_lock);
 
+enum huge_shmem_enabled_mode {
+	HUGE_SHMEM_ENABLED_ALWAYS = 0,
+	HUGE_SHMEM_ENABLED_INHERIT,
+	HUGE_SHMEM_ENABLED_WITHIN_SIZE,
+	HUGE_SHMEM_ENABLED_ADVISE,
+	HUGE_SHMEM_ENABLED_NEVER,
+};
+
+static const char * const huge_shmem_enabled_mode_strings[] = {
+	[HUGE_SHMEM_ENABLED_ALWAYS]      = "always",
+	[HUGE_SHMEM_ENABLED_INHERIT]     = "inherit",
+	[HUGE_SHMEM_ENABLED_WITHIN_SIZE] = "within_size",
+	[HUGE_SHMEM_ENABLED_ADVISE]      = "advise",
+	[HUGE_SHMEM_ENABLED_NEVER]       = "never",
+};
+
+static unsigned long * const huge_shmem_orders_by_mode[] = {
+	[HUGE_SHMEM_ENABLED_ALWAYS]      = &huge_shmem_orders_always,
+	[HUGE_SHMEM_ENABLED_INHERIT]     = &huge_shmem_orders_inherit,
+	[HUGE_SHMEM_ENABLED_WITHIN_SIZE] = &huge_shmem_orders_within_size,
+	[HUGE_SHMEM_ENABLED_ADVISE]      = &huge_shmem_orders_madvise,
+};
+
 static ssize_t thpsize_shmem_enabled_show(struct kobject *kobj,
 					  struct kobj_attribute *attr, char *buf)
 {
@@ -5546,63 +5569,53 @@ static ssize_t thpsize_shmem_enabled_show(struct kobject *kobj,
 	return sysfs_emit(buf, "%s\n", output);
 }
 
+static bool set_shmem_enabled_mode(int order, enum huge_shmem_enabled_mode mode)
+{
+	bool changed = false;
+	enum huge_shmem_enabled_mode idx;
+
+	spin_lock(&huge_shmem_orders_lock);
+	for (idx = 0; idx < ARRAY_SIZE(huge_shmem_orders_by_mode); idx++) {
+		if (idx == mode)
+			changed |= !__test_and_set_bit(order, huge_shmem_orders_by_mode[idx]);
+		else
+			changed |= __test_and_clear_bit(order, huge_shmem_orders_by_mode[idx]);
+	}
+	spin_unlock(&huge_shmem_orders_lock);
+
+	return changed;
+}
+
 static ssize_t thpsize_shmem_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;
-
-	if (sysfs_streq(buf, "always")) {
-		spin_lock(&huge_shmem_orders_lock);
-		clear_bit(order, &huge_shmem_orders_inherit);
-		clear_bit(order, &huge_shmem_orders_madvise);
-		clear_bit(order, &huge_shmem_orders_within_size);
-		set_bit(order, &huge_shmem_orders_always);
-		spin_unlock(&huge_shmem_orders_lock);
-	} else if (sysfs_streq(buf, "inherit")) {
-		/* Do not override huge allocation policy with non-PMD sized mTHP */
-		if (shmem_huge == SHMEM_HUGE_FORCE && !is_pmd_order(order))
-			return -EINVAL;
+	int mode;
 
-		spin_lock(&huge_shmem_orders_lock);
-		clear_bit(order, &huge_shmem_orders_always);
-		clear_bit(order, &huge_shmem_orders_madvise);
-		clear_bit(order, &huge_shmem_orders_within_size);
-		set_bit(order, &huge_shmem_orders_inherit);
-		spin_unlock(&huge_shmem_orders_lock);
-	} else if (sysfs_streq(buf, "within_size")) {
-		spin_lock(&huge_shmem_orders_lock);
-		clear_bit(order, &huge_shmem_orders_always);
-		clear_bit(order, &huge_shmem_orders_inherit);
-		clear_bit(order, &huge_shmem_orders_madvise);
-		set_bit(order, &huge_shmem_orders_within_size);
-		spin_unlock(&huge_shmem_orders_lock);
-	} else if (sysfs_streq(buf, "advise")) {
-		spin_lock(&huge_shmem_orders_lock);
-		clear_bit(order, &huge_shmem_orders_always);
-		clear_bit(order, &huge_shmem_orders_inherit);
-		clear_bit(order, &huge_shmem_orders_within_size);
-		set_bit(order, &huge_shmem_orders_madvise);
-		spin_unlock(&huge_shmem_orders_lock);
-	} else if (sysfs_streq(buf, "never")) {
-		spin_lock(&huge_shmem_orders_lock);
-		clear_bit(order, &huge_shmem_orders_always);
-		clear_bit(order, &huge_shmem_orders_inherit);
-		clear_bit(order, &huge_shmem_orders_within_size);
-		clear_bit(order, &huge_shmem_orders_madvise);
-		spin_unlock(&huge_shmem_orders_lock);
-	} else {
-		ret = -EINVAL;
-	}
+	mode = sysfs_match_string(huge_shmem_enabled_mode_strings, buf);
+	if (mode < 0)
+		return mode;
 
-	if (ret > 0) {
-		int err = start_stop_khugepaged();
+	/* Do not override huge allocation policy with non-PMD sized mTHP */
+	if (mode == HUGE_SHMEM_ENABLED_INHERIT &&
+	    shmem_huge == SHMEM_HUGE_FORCE && !is_pmd_order(order))
+		return -EINVAL;
 
+	if (set_shmem_enabled_mode(order, mode)) {
+		int err = start_stop_khugepaged();
 		if (err)
-			ret = err;
+			return err;
+	} else {
+		/*
+		 * Recalculate watermarks even when the mode hasn't changed
+		 * to preserve the legacy behavior, as this is always called
+		 * inside start_stop_khugepaged().
+		 */
+		set_recommended_min_free_kbytes();
 	}
-	return ret;
+
+	return count;
 }
 
 struct kobj_attribute thpsize_shmem_enabled_attr =
-- 
2.25.1

[PATCH v3 2/2] mm: shmem: refactor thpsize_shmem_enabled_show() with helper arrays

[ranxiaokai627]

From: Ran Xiaokai <ran.xiaokai@zte.com.cn>

Replace the hardcoded if/else chain of test_bit() calls and string
literals in thpsize_shmem_enabled_show() with a loop over
huge_shmem_orders_by_mode[] and huge_shmem_enabled_mode_strings[] arrays.

This makes thpsize_shmem_enabled_show() consistent with
thpsize_shmem_enabled_store() and eliminates duplicated mode name strings.

Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>
Reviewed-by: Baolin Wang <baolin.wang@linux.alibaba.com>
Tested-by: Baolin Wang <baolin.wang@linux.alibaba.com>
Reviewed-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Lorenzo Stoakes <ljs@kernel.org>
---
 mm/shmem.c | 36 +++++++++++++++++++++++-------------
 1 file changed, 23 insertions(+), 13 deletions(-)

diff --git a/mm/shmem.c b/mm/shmem.c
index 46d2cfc30823..197c9cc314c5 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -5553,20 +5553,30 @@ static ssize_t thpsize_shmem_enabled_show(struct kobject *kobj,
 					  struct kobj_attribute *attr, char *buf)
 {
 	int order = to_thpsize(kobj)->order;
-	const char *output;
-
-	if (test_bit(order, &huge_shmem_orders_always))
-		output = "[always] inherit within_size advise never";
-	else if (test_bit(order, &huge_shmem_orders_inherit))
-		output = "always [inherit] within_size advise never";
-	else if (test_bit(order, &huge_shmem_orders_within_size))
-		output = "always inherit [within_size] advise never";
-	else if (test_bit(order, &huge_shmem_orders_madvise))
-		output = "always inherit within_size [advise] never";
-	else
-		output = "always inherit within_size advise [never]";
+	int active = HUGE_SHMEM_ENABLED_NEVER;
+	int len = 0;
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(huge_shmem_orders_by_mode); i++) {
+		if (test_bit(order, huge_shmem_orders_by_mode[i])) {
+			active = i;
+			break;
+		}
+	}
+
+	for (i = 0; i < ARRAY_SIZE(huge_shmem_enabled_mode_strings); i++) {
+		if (i == active)
+			len += sysfs_emit_at(buf, len, "[%s] ",
+					     huge_shmem_enabled_mode_strings[i]);
+		else
+			len += sysfs_emit_at(buf, len, "%s ",
+					     huge_shmem_enabled_mode_strings[i]);
+	}
+
+	/* Replace trailing space with newline */
+	buf[len - 1] = '\n';
 
-	return sysfs_emit(buf, "%s\n", output);
+	return len;
 }
 
 static bool set_shmem_enabled_mode(int order, enum huge_shmem_enabled_mode mode)
-- 
2.25.1

Re: [PATCH v3 1/2] mm: shmem: refactor thpsize_shmem_enabled_store() with sysfs_match_string()

[Baolin Wang]

On 5/18/26 8:32 PM, ranxiaokai627@163.com wrote:
> From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> 
> Inspired by commit 82d9ff648c6c ("mm: huge_memory: refactor
> anon_enabled_store() with set_anon_enabled_mode()"), refactor
> thpsize_shmem_enabled_store() using sysfs_match_string().
> This eliminates the duplicated spin_lock/unlock(), set/clear_bit(),
> calls across all branches, reducing code duplication.
> 
> Behavioral change:
> Call start_stop_khugepaged() only when the mode actually changes.
> If unchanged, call set_recommended_min_free_kbytes() to preserve
> legacy watermark behavior. This avoids unnecessary khugepaged restarts.
> 
> Tested with selftests ./run_kselftest.sh -t mm:ksft_thp.sh,
> all test cases passed.
> 
> Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> ---

Please keep my tags unless there are major logic changes. Thanks.
Reviewed-by: Baolin Wang <baolin.wang@linux.alibaba.com>
Tested-by: Baolin Wang <baolin.wang@linux.alibaba.com>

>   mm/shmem.c | 107 ++++++++++++++++++++++++++++++-----------------------
>   1 file changed, 60 insertions(+), 47 deletions(-)
> 
> diff --git a/mm/shmem.c b/mm/shmem.c
> index 3b5dc21b323c..46d2cfc30823 100644
> --- a/mm/shmem.c
> +++ b/mm/shmem.c
> @@ -5526,6 +5526,29 @@ static ssize_t shmem_enabled_store(struct kobject *kobj,
>   struct kobj_attribute shmem_enabled_attr = __ATTR_RW(shmem_enabled);
>   static DEFINE_SPINLOCK(huge_shmem_orders_lock);
>   
> +enum huge_shmem_enabled_mode {
> +	HUGE_SHMEM_ENABLED_ALWAYS = 0,
> +	HUGE_SHMEM_ENABLED_INHERIT,
> +	HUGE_SHMEM_ENABLED_WITHIN_SIZE,
> +	HUGE_SHMEM_ENABLED_ADVISE,
> +	HUGE_SHMEM_ENABLED_NEVER,
> +};
> +
> +static const char * const huge_shmem_enabled_mode_strings[] = {
> +	[HUGE_SHMEM_ENABLED_ALWAYS]      = "always",
> +	[HUGE_SHMEM_ENABLED_INHERIT]     = "inherit",
> +	[HUGE_SHMEM_ENABLED_WITHIN_SIZE] = "within_size",
> +	[HUGE_SHMEM_ENABLED_ADVISE]      = "advise",
> +	[HUGE_SHMEM_ENABLED_NEVER]       = "never",
> +};
> +
> +static unsigned long * const huge_shmem_orders_by_mode[] = {

Nit: the name feels a bit verbose, how about huge_shmem_enabled_orders? 
(Perhaps David or Lorenzo has a better suggestion:))

Re: [PATCH v3 1/2] mm: shmem: refactor thpsize_shmem_enabled_store() with sysfs_match_string()

[Lance Yang]

On 2026/5/18 20:32, ranxiaokai627@163.com wrote:
> From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> 
> Inspired by commit 82d9ff648c6c ("mm: huge_memory: refactor
> anon_enabled_store() with set_anon_enabled_mode()"), refactor
> thpsize_shmem_enabled_store() using sysfs_match_string().
> This eliminates the duplicated spin_lock/unlock(), set/clear_bit(),
> calls across all branches, reducing code duplication.
> 
> Behavioral change:
> Call start_stop_khugepaged() only when the mode actually changes.
> If unchanged, call set_recommended_min_free_kbytes() to preserve
> legacy watermark behavior. This avoids unnecessary khugepaged restarts.
> 
> Tested with selftests ./run_kselftest.sh -t mm:ksft_thp.sh,
> all test cases passed.
> 
> Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> ---

Thanks.

Tested-by: Lance Yang <lance.yang@linux.dev>

Re: [PATCH v3 2/2] mm: shmem: refactor thpsize_shmem_enabled_show() with helper arrays

[Lance Yang]

On 2026/5/18 20:32, ranxiaokai627@163.com wrote:
> From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> 
> Replace the hardcoded if/else chain of test_bit() calls and string
> literals in thpsize_shmem_enabled_show() with a loop over
> huge_shmem_orders_by_mode[] and huge_shmem_enabled_mode_strings[] arrays.
> 
> This makes thpsize_shmem_enabled_show() consistent with
> thpsize_shmem_enabled_store() and eliminates duplicated mode name strings.
> 
> Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> Reviewed-by: Baolin Wang <baolin.wang@linux.alibaba.com>
> Tested-by: Baolin Wang <baolin.wang@linux.alibaba.com>
> Reviewed-by: Breno Leitao <leitao@debian.org>
> Reviewed-by: Lorenzo Stoakes <ljs@kernel.org>
> ---

Thanks.

Tested-by: Lance Yang <lance.yang@linux.dev>

Re: [PATCH v3 1/2] mm: shmem: refactor thpsize_shmem_enabled_store() with sysfs_match_string()

[Barry Song]

On Mon, May 18, 2026 at 8:33 PM <ranxiaokai627@163.com> wrote:
>
> From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
>
> Inspired by commit 82d9ff648c6c ("mm: huge_memory: refactor
> anon_enabled_store() with set_anon_enabled_mode()"), refactor
> thpsize_shmem_enabled_store() using sysfs_match_string().
> This eliminates the duplicated spin_lock/unlock(), set/clear_bit(),
> calls across all branches, reducing code duplication.
>
> Behavioral change:
> Call start_stop_khugepaged() only when the mode actually changes.
> If unchanged, call set_recommended_min_free_kbytes() to preserve
> legacy watermark behavior. This avoids unnecessary khugepaged restarts.
>
> Tested with selftests ./run_kselftest.sh -t mm:ksft_thp.sh,
> all test cases passed.
>
> Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>

Reviewed-by: Barry Song <baohua@kernel.org>

Re: [PATCH v3 2/2] mm: shmem: refactor thpsize_shmem_enabled_show() with helper arrays

[Lorenzo Stoakes]

On Mon, May 18, 2026 at 12:32:38PM +0000, ranxiaokai627@163.com wrote:
> From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
>
> Replace the hardcoded if/else chain of test_bit() calls and string
> literals in thpsize_shmem_enabled_show() with a loop over
> huge_shmem_orders_by_mode[] and huge_shmem_enabled_mode_strings[] arrays.
>
> This makes thpsize_shmem_enabled_show() consistent with
> thpsize_shmem_enabled_store() and eliminates duplicated mode name strings.
>
> Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>

From: ranxiaokai627@163.com

This does not match the From: field of the email.

This is violating kernel process. See
https://docs.kernel.org/process/submitting-patches.html

Please either update this to your 163 email account or resend from your
zte.com.cn address, otherwise we can't take this.

Cheers, Lorenzo

> Reviewed-by: Baolin Wang <baolin.wang@linux.alibaba.com>
> Tested-by: Baolin Wang <baolin.wang@linux.alibaba.com>
> Reviewed-by: Breno Leitao <leitao@debian.org>
> Reviewed-by: Lorenzo Stoakes <ljs@kernel.org>
> ---
>  mm/shmem.c | 36 +++++++++++++++++++++++-------------
>  1 file changed, 23 insertions(+), 13 deletions(-)
>
> diff --git a/mm/shmem.c b/mm/shmem.c
> index 46d2cfc30823..197c9cc314c5 100644
> --- a/mm/shmem.c
> +++ b/mm/shmem.c
> @@ -5553,20 +5553,30 @@ static ssize_t thpsize_shmem_enabled_show(struct kobject *kobj,
>  					  struct kobj_attribute *attr, char *buf)
>  {
>  	int order = to_thpsize(kobj)->order;
> -	const char *output;
> -
> -	if (test_bit(order, &huge_shmem_orders_always))
> -		output = "[always] inherit within_size advise never";
> -	else if (test_bit(order, &huge_shmem_orders_inherit))
> -		output = "always [inherit] within_size advise never";
> -	else if (test_bit(order, &huge_shmem_orders_within_size))
> -		output = "always inherit [within_size] advise never";
> -	else if (test_bit(order, &huge_shmem_orders_madvise))
> -		output = "always inherit within_size [advise] never";
> -	else
> -		output = "always inherit within_size advise [never]";
> +	int active = HUGE_SHMEM_ENABLED_NEVER;
> +	int len = 0;
> +	int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(huge_shmem_orders_by_mode); i++) {
> +		if (test_bit(order, huge_shmem_orders_by_mode[i])) {
> +			active = i;
> +			break;
> +		}
> +	}
> +
> +	for (i = 0; i < ARRAY_SIZE(huge_shmem_enabled_mode_strings); i++) {
> +		if (i == active)
> +			len += sysfs_emit_at(buf, len, "[%s] ",
> +					     huge_shmem_enabled_mode_strings[i]);
> +		else
> +			len += sysfs_emit_at(buf, len, "%s ",
> +					     huge_shmem_enabled_mode_strings[i]);
> +	}
> +
> +	/* Replace trailing space with newline */
> +	buf[len - 1] = '\n';
>
> -	return sysfs_emit(buf, "%s\n", output);
> +	return len;
>  }
>
>  static bool set_shmem_enabled_mode(int order, enum huge_shmem_enabled_mode mode)
> --
> 2.25.1
>
>

Re: [PATCH v3 1/2] mm: shmem: refactor thpsize_shmem_enabled_store() with sysfs_match_string()

[Lorenzo Stoakes]

On Mon, May 18, 2026 at 12:32:37PM +0000, ranxiaokai627@163.com wrote:
> From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
>
> Inspired by commit 82d9ff648c6c ("mm: huge_memory: refactor
> anon_enabled_store() with set_anon_enabled_mode()"), refactor
> thpsize_shmem_enabled_store() using sysfs_match_string().
> This eliminates the duplicated spin_lock/unlock(), set/clear_bit(),
> calls across all branches, reducing code duplication.
>
> Behavioral change:
> Call start_stop_khugepaged() only when the mode actually changes.
> If unchanged, call set_recommended_min_free_kbytes() to preserve
> legacy watermark behavior. This avoids unnecessary khugepaged restarts.
>
> Tested with selftests ./run_kselftest.sh -t mm:ksft_thp.sh,
> all test cases passed.
>
> Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>

Your From: and Signed-off-by: differs. As per my mail to the 2/2 this violates
kernel process rules. Please either update the signed-off-by to your @163.com
address or resend from your zte.com.cn address.

Logic generally looks good, but you need to fix your From/Signed-off-by and the
rename suggested below would be good.

Thanks, Lorenzo

> ---
>  mm/shmem.c | 107 ++++++++++++++++++++++++++++++-----------------------
>  1 file changed, 60 insertions(+), 47 deletions(-)
>
> diff --git a/mm/shmem.c b/mm/shmem.c
> index 3b5dc21b323c..46d2cfc30823 100644
> --- a/mm/shmem.c
> +++ b/mm/shmem.c
> @@ -5526,6 +5526,29 @@ static ssize_t shmem_enabled_store(struct kobject *kobj,
>  struct kobj_attribute shmem_enabled_attr = __ATTR_RW(shmem_enabled);
>  static DEFINE_SPINLOCK(huge_shmem_orders_lock);
>
> +enum huge_shmem_enabled_mode {
> +	HUGE_SHMEM_ENABLED_ALWAYS = 0,
> +	HUGE_SHMEM_ENABLED_INHERIT,
> +	HUGE_SHMEM_ENABLED_WITHIN_SIZE,
> +	HUGE_SHMEM_ENABLED_ADVISE,
> +	HUGE_SHMEM_ENABLED_NEVER,
> +};
> +
> +static const char * const huge_shmem_enabled_mode_strings[] = {
> +	[HUGE_SHMEM_ENABLED_ALWAYS]      = "always",
> +	[HUGE_SHMEM_ENABLED_INHERIT]     = "inherit",
> +	[HUGE_SHMEM_ENABLED_WITHIN_SIZE] = "within_size",
> +	[HUGE_SHMEM_ENABLED_ADVISE]      = "advise",
> +	[HUGE_SHMEM_ENABLED_NEVER]       = "never",
> +};
> +
> +static unsigned long * const huge_shmem_orders_by_mode[] = {
> +	[HUGE_SHMEM_ENABLED_ALWAYS]      = &huge_shmem_orders_always,
> +	[HUGE_SHMEM_ENABLED_INHERIT]     = &huge_shmem_orders_inherit,
> +	[HUGE_SHMEM_ENABLED_WITHIN_SIZE] = &huge_shmem_orders_within_size,
> +	[HUGE_SHMEM_ENABLED_ADVISE]      = &huge_shmem_orders_madvise,
> +};

As Baolin suggested, we can probably rename these for bervity.

We know it's shmem, as it's in shmem.c :) so drop that.

huge_mode, huge_mode_strings, huge_mode_orders seems good to me?

> +
>  static ssize_t thpsize_shmem_enabled_show(struct kobject *kobj,
>  					  struct kobj_attribute *attr, char *buf)
>  {
> @@ -5546,63 +5569,53 @@ static ssize_t thpsize_shmem_enabled_show(struct kobject *kobj,
>  	return sysfs_emit(buf, "%s\n", output);
>  }
>
> +static bool set_shmem_enabled_mode(int order, enum huge_shmem_enabled_mode mode)
> +{
> +	bool changed = false;
> +	enum huge_shmem_enabled_mode idx;
> +
> +	spin_lock(&huge_shmem_orders_lock);
> +	for (idx = 0; idx < ARRAY_SIZE(huge_shmem_orders_by_mode); idx++) {
> +		if (idx == mode)
> +			changed |= !__test_and_set_bit(order, huge_shmem_orders_by_mode[idx]);
> +		else
> +			changed |= __test_and_clear_bit(order, huge_shmem_orders_by_mode[idx]);
> +	}
> +	spin_unlock(&huge_shmem_orders_lock);
> +
> +	return changed;
> +}
> +

Thanks for separating this out! :)

>  static ssize_t thpsize_shmem_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;
> -
> -	if (sysfs_streq(buf, "always")) {
> -		spin_lock(&huge_shmem_orders_lock);
> -		clear_bit(order, &huge_shmem_orders_inherit);
> -		clear_bit(order, &huge_shmem_orders_madvise);
> -		clear_bit(order, &huge_shmem_orders_within_size);
> -		set_bit(order, &huge_shmem_orders_always);
> -		spin_unlock(&huge_shmem_orders_lock);
> -	} else if (sysfs_streq(buf, "inherit")) {
> -		/* Do not override huge allocation policy with non-PMD sized mTHP */
> -		if (shmem_huge == SHMEM_HUGE_FORCE && !is_pmd_order(order))
> -			return -EINVAL;
> +	int mode;
>
> -		spin_lock(&huge_shmem_orders_lock);
> -		clear_bit(order, &huge_shmem_orders_always);
> -		clear_bit(order, &huge_shmem_orders_madvise);
> -		clear_bit(order, &huge_shmem_orders_within_size);
> -		set_bit(order, &huge_shmem_orders_inherit);
> -		spin_unlock(&huge_shmem_orders_lock);
> -	} else if (sysfs_streq(buf, "within_size")) {
> -		spin_lock(&huge_shmem_orders_lock);
> -		clear_bit(order, &huge_shmem_orders_always);
> -		clear_bit(order, &huge_shmem_orders_inherit);
> -		clear_bit(order, &huge_shmem_orders_madvise);
> -		set_bit(order, &huge_shmem_orders_within_size);
> -		spin_unlock(&huge_shmem_orders_lock);
> -	} else if (sysfs_streq(buf, "advise")) {
> -		spin_lock(&huge_shmem_orders_lock);
> -		clear_bit(order, &huge_shmem_orders_always);
> -		clear_bit(order, &huge_shmem_orders_inherit);
> -		clear_bit(order, &huge_shmem_orders_within_size);
> -		set_bit(order, &huge_shmem_orders_madvise);
> -		spin_unlock(&huge_shmem_orders_lock);
> -	} else if (sysfs_streq(buf, "never")) {
> -		spin_lock(&huge_shmem_orders_lock);
> -		clear_bit(order, &huge_shmem_orders_always);
> -		clear_bit(order, &huge_shmem_orders_inherit);
> -		clear_bit(order, &huge_shmem_orders_within_size);
> -		clear_bit(order, &huge_shmem_orders_madvise);
> -		spin_unlock(&huge_shmem_orders_lock);
> -	} else {
> -		ret = -EINVAL;
> -	}
> +	mode = sysfs_match_string(huge_shmem_enabled_mode_strings, buf);
> +	if (mode < 0)
> +		return mode;
>
> -	if (ret > 0) {
> -		int err = start_stop_khugepaged();
> +	/* Do not override huge allocation policy with non-PMD sized mTHP */
> +	if (mode == HUGE_SHMEM_ENABLED_INHERIT &&
> +	    shmem_huge == SHMEM_HUGE_FORCE && !is_pmd_order(order))
> +		return -EINVAL;
>
> +	if (set_shmem_enabled_mode(order, mode)) {
> +		int err = start_stop_khugepaged();
>  		if (err)
> -			ret = err;
> +			return err;
> +	} else {
> +		/*
> +		 * Recalculate watermarks even when the mode hasn't changed
> +		 * to preserve the legacy behavior, as this is always called
> +		 * inside start_stop_khugepaged().
> +		 */
> +		set_recommended_min_free_kbytes();
>  	}
> -	return ret;
> +
> +	return count;
>  }
>
>  struct kobj_attribute thpsize_shmem_enabled_attr =
> --
> 2.25.1
>
>

Re: [PATCH v3 2/2] mm: shmem: refactor thpsize_shmem_enabled_show() with helper arrays

[Barry Song]

On Fri, May 22, 2026 at 6:35 PM Lorenzo Stoakes <ljs@kernel.org> wrote:
>
> On Mon, May 18, 2026 at 12:32:38PM +0000, ranxiaokai627@163.com wrote:
> > From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> >
> > Replace the hardcoded if/else chain of test_bit() calls and string
> > literals in thpsize_shmem_enabled_show() with a loop over
> > huge_shmem_orders_by_mode[] and huge_shmem_enabled_mode_strings[] arrays.
> >
> > This makes thpsize_shmem_enabled_show() consistent with
> > thpsize_shmem_enabled_store() and eliminates duplicated mode name strings.
> >
> > Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>
>
> From: ranxiaokai627@163.com
>
> This does not match the From: field of the email.
>
> This is violating kernel process. See
> https://docs.kernel.org/process/submitting-patches.html

I’m not aware of this rule, since I usually see From matching
Signed-off-by. Do we really have such a rule? Sorry, I might be a
bit ignorant about this 🙂

>
> Please either update this to your 163 email account or resend from your
> zte.com.cn address, otherwise we can't take this.
>
> Cheers, Lorenzo
>

Re: [PATCH v3 2/2] mm: shmem: refactor thpsize_shmem_enabled_show() with helper arrays

[Lorenzo Stoakes]

On Fri, May 22, 2026 at 11:35:01AM +0100, Lorenzo Stoakes wrote:
> On Mon, May 18, 2026 at 12:32:38PM +0000, ranxiaokai627@163.com wrote:
> > From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> >
> > Replace the hardcoded if/else chain of test_bit() calls and string
> > literals in thpsize_shmem_enabled_show() with a loop over
> > huge_shmem_orders_by_mode[] and huge_shmem_enabled_mode_strings[] arrays.
> >
> > This makes thpsize_shmem_enabled_show() consistent with
> > thpsize_shmem_enabled_store() and eliminates duplicated mode name strings.
> >
> > Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>
>
> From: ranxiaokai627@163.com
>
> This does not match the From: field of the email.
>
> This is violating kernel process. See
> https://docs.kernel.org/process/submitting-patches.html
>
> Please either update this to your 163 email account or resend from your
> zte.com.cn address, otherwise we can't take this.

Apologies - I'm apparently blind :)

You provided this in-body, there's no issue, ignore this!

Thanks, Lorenzo

>
> Cheers, Lorenzo
>
> > Reviewed-by: Baolin Wang <baolin.wang@linux.alibaba.com>
> > Tested-by: Baolin Wang <baolin.wang@linux.alibaba.com>
> > Reviewed-by: Breno Leitao <leitao@debian.org>
> > Reviewed-by: Lorenzo Stoakes <ljs@kernel.org>
> > ---
> >  mm/shmem.c | 36 +++++++++++++++++++++++-------------
> >  1 file changed, 23 insertions(+), 13 deletions(-)
> >
> > diff --git a/mm/shmem.c b/mm/shmem.c
> > index 46d2cfc30823..197c9cc314c5 100644
> > --- a/mm/shmem.c
> > +++ b/mm/shmem.c
> > @@ -5553,20 +5553,30 @@ static ssize_t thpsize_shmem_enabled_show(struct kobject *kobj,
> >  					  struct kobj_attribute *attr, char *buf)
> >  {
> >  	int order = to_thpsize(kobj)->order;
> > -	const char *output;
> > -
> > -	if (test_bit(order, &huge_shmem_orders_always))
> > -		output = "[always] inherit within_size advise never";
> > -	else if (test_bit(order, &huge_shmem_orders_inherit))
> > -		output = "always [inherit] within_size advise never";
> > -	else if (test_bit(order, &huge_shmem_orders_within_size))
> > -		output = "always inherit [within_size] advise never";
> > -	else if (test_bit(order, &huge_shmem_orders_madvise))
> > -		output = "always inherit within_size [advise] never";
> > -	else
> > -		output = "always inherit within_size advise [never]";
> > +	int active = HUGE_SHMEM_ENABLED_NEVER;
> > +	int len = 0;
> > +	int i;
> > +
> > +	for (i = 0; i < ARRAY_SIZE(huge_shmem_orders_by_mode); i++) {
> > +		if (test_bit(order, huge_shmem_orders_by_mode[i])) {
> > +			active = i;
> > +			break;
> > +		}
> > +	}
> > +
> > +	for (i = 0; i < ARRAY_SIZE(huge_shmem_enabled_mode_strings); i++) {
> > +		if (i == active)
> > +			len += sysfs_emit_at(buf, len, "[%s] ",
> > +					     huge_shmem_enabled_mode_strings[i]);
> > +		else
> > +			len += sysfs_emit_at(buf, len, "%s ",
> > +					     huge_shmem_enabled_mode_strings[i]);
> > +	}
> > +
> > +	/* Replace trailing space with newline */
> > +	buf[len - 1] = '\n';
> >
> > -	return sysfs_emit(buf, "%s\n", output);
> > +	return len;
> >  }
> >
> >  static bool set_shmem_enabled_mode(int order, enum huge_shmem_enabled_mode mode)
> > --
> > 2.25.1
> >
> >

Re: [PATCH v3 1/2] mm: shmem: refactor thpsize_shmem_enabled_store() with sysfs_match_string()

[Lorenzo Stoakes]

On Fri, May 22, 2026 at 11:39:45AM +0100, Lorenzo Stoakes wrote:
> On Mon, May 18, 2026 at 12:32:37PM +0000, ranxiaokai627@163.com wrote:
> > From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> >
> > Inspired by commit 82d9ff648c6c ("mm: huge_memory: refactor
> > anon_enabled_store() with set_anon_enabled_mode()"), refactor
> > thpsize_shmem_enabled_store() using sysfs_match_string().
> > This eliminates the duplicated spin_lock/unlock(), set/clear_bit(),
> > calls across all branches, reducing code duplication.
> >
> > Behavioral change:
> > Call start_stop_khugepaged() only when the mode actually changes.
> > If unchanged, call set_recommended_min_free_kbytes() to preserve
> > legacy watermark behavior. This avoids unnecessary khugepaged restarts.
> >
> > Tested with selftests ./run_kselftest.sh -t mm:ksft_thp.sh,
> > all test cases passed.
> >
> > Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>
>
> Your From: and Signed-off-by: differs. As per my mail to the 2/2 this violates
> kernel process rules. Please either update the signed-off-by to your @163.com
> address or resend from your zte.com.cn address.

Apologies, again I (somehow) missed the in-body From: :P

You're good, ignore this. But do please look at the suggest below re: naming!
Thanks :)

>
> Logic generally looks good, but you need to fix your From/Signed-off-by and the
> rename suggested below would be good.
>
> Thanks, Lorenzo
>
> > ---
> >  mm/shmem.c | 107 ++++++++++++++++++++++++++++++-----------------------
> >  1 file changed, 60 insertions(+), 47 deletions(-)
> >
> > diff --git a/mm/shmem.c b/mm/shmem.c
> > index 3b5dc21b323c..46d2cfc30823 100644
> > --- a/mm/shmem.c
> > +++ b/mm/shmem.c
> > @@ -5526,6 +5526,29 @@ static ssize_t shmem_enabled_store(struct kobject *kobj,
> >  struct kobj_attribute shmem_enabled_attr = __ATTR_RW(shmem_enabled);
> >  static DEFINE_SPINLOCK(huge_shmem_orders_lock);
> >
> > +enum huge_shmem_enabled_mode {
> > +	HUGE_SHMEM_ENABLED_ALWAYS = 0,
> > +	HUGE_SHMEM_ENABLED_INHERIT,
> > +	HUGE_SHMEM_ENABLED_WITHIN_SIZE,
> > +	HUGE_SHMEM_ENABLED_ADVISE,
> > +	HUGE_SHMEM_ENABLED_NEVER,
> > +};
> > +
> > +static const char * const huge_shmem_enabled_mode_strings[] = {
> > +	[HUGE_SHMEM_ENABLED_ALWAYS]      = "always",
> > +	[HUGE_SHMEM_ENABLED_INHERIT]     = "inherit",
> > +	[HUGE_SHMEM_ENABLED_WITHIN_SIZE] = "within_size",
> > +	[HUGE_SHMEM_ENABLED_ADVISE]      = "advise",
> > +	[HUGE_SHMEM_ENABLED_NEVER]       = "never",
> > +};
> > +
> > +static unsigned long * const huge_shmem_orders_by_mode[] = {
> > +	[HUGE_SHMEM_ENABLED_ALWAYS]      = &huge_shmem_orders_always,
> > +	[HUGE_SHMEM_ENABLED_INHERIT]     = &huge_shmem_orders_inherit,
> > +	[HUGE_SHMEM_ENABLED_WITHIN_SIZE] = &huge_shmem_orders_within_size,
> > +	[HUGE_SHMEM_ENABLED_ADVISE]      = &huge_shmem_orders_madvise,
> > +};
>
> As Baolin suggested, we can probably rename these for bervity.
>
> We know it's shmem, as it's in shmem.c :) so drop that.
>
> huge_mode, huge_mode_strings, huge_mode_orders seems good to me?
>
> > +
> >  static ssize_t thpsize_shmem_enabled_show(struct kobject *kobj,
> >  					  struct kobj_attribute *attr, char *buf)
> >  {
> > @@ -5546,63 +5569,53 @@ static ssize_t thpsize_shmem_enabled_show(struct kobject *kobj,
> >  	return sysfs_emit(buf, "%s\n", output);
> >  }
> >
> > +static bool set_shmem_enabled_mode(int order, enum huge_shmem_enabled_mode mode)
> > +{
> > +	bool changed = false;
> > +	enum huge_shmem_enabled_mode idx;
> > +
> > +	spin_lock(&huge_shmem_orders_lock);
> > +	for (idx = 0; idx < ARRAY_SIZE(huge_shmem_orders_by_mode); idx++) {
> > +		if (idx == mode)
> > +			changed |= !__test_and_set_bit(order, huge_shmem_orders_by_mode[idx]);
> > +		else
> > +			changed |= __test_and_clear_bit(order, huge_shmem_orders_by_mode[idx]);
> > +	}
> > +	spin_unlock(&huge_shmem_orders_lock);
> > +
> > +	return changed;
> > +}
> > +
>
> Thanks for separating this out! :)
>
> >  static ssize_t thpsize_shmem_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;
> > -
> > -	if (sysfs_streq(buf, "always")) {
> > -		spin_lock(&huge_shmem_orders_lock);
> > -		clear_bit(order, &huge_shmem_orders_inherit);
> > -		clear_bit(order, &huge_shmem_orders_madvise);
> > -		clear_bit(order, &huge_shmem_orders_within_size);
> > -		set_bit(order, &huge_shmem_orders_always);
> > -		spin_unlock(&huge_shmem_orders_lock);
> > -	} else if (sysfs_streq(buf, "inherit")) {
> > -		/* Do not override huge allocation policy with non-PMD sized mTHP */
> > -		if (shmem_huge == SHMEM_HUGE_FORCE && !is_pmd_order(order))
> > -			return -EINVAL;
> > +	int mode;
> >
> > -		spin_lock(&huge_shmem_orders_lock);
> > -		clear_bit(order, &huge_shmem_orders_always);
> > -		clear_bit(order, &huge_shmem_orders_madvise);
> > -		clear_bit(order, &huge_shmem_orders_within_size);
> > -		set_bit(order, &huge_shmem_orders_inherit);
> > -		spin_unlock(&huge_shmem_orders_lock);
> > -	} else if (sysfs_streq(buf, "within_size")) {
> > -		spin_lock(&huge_shmem_orders_lock);
> > -		clear_bit(order, &huge_shmem_orders_always);
> > -		clear_bit(order, &huge_shmem_orders_inherit);
> > -		clear_bit(order, &huge_shmem_orders_madvise);
> > -		set_bit(order, &huge_shmem_orders_within_size);
> > -		spin_unlock(&huge_shmem_orders_lock);
> > -	} else if (sysfs_streq(buf, "advise")) {
> > -		spin_lock(&huge_shmem_orders_lock);
> > -		clear_bit(order, &huge_shmem_orders_always);
> > -		clear_bit(order, &huge_shmem_orders_inherit);
> > -		clear_bit(order, &huge_shmem_orders_within_size);
> > -		set_bit(order, &huge_shmem_orders_madvise);
> > -		spin_unlock(&huge_shmem_orders_lock);
> > -	} else if (sysfs_streq(buf, "never")) {
> > -		spin_lock(&huge_shmem_orders_lock);
> > -		clear_bit(order, &huge_shmem_orders_always);
> > -		clear_bit(order, &huge_shmem_orders_inherit);
> > -		clear_bit(order, &huge_shmem_orders_within_size);
> > -		clear_bit(order, &huge_shmem_orders_madvise);
> > -		spin_unlock(&huge_shmem_orders_lock);
> > -	} else {
> > -		ret = -EINVAL;
> > -	}
> > +	mode = sysfs_match_string(huge_shmem_enabled_mode_strings, buf);
> > +	if (mode < 0)
> > +		return mode;
> >
> > -	if (ret > 0) {
> > -		int err = start_stop_khugepaged();
> > +	/* Do not override huge allocation policy with non-PMD sized mTHP */
> > +	if (mode == HUGE_SHMEM_ENABLED_INHERIT &&
> > +	    shmem_huge == SHMEM_HUGE_FORCE && !is_pmd_order(order))
> > +		return -EINVAL;
> >
> > +	if (set_shmem_enabled_mode(order, mode)) {
> > +		int err = start_stop_khugepaged();
> >  		if (err)
> > -			ret = err;
> > +			return err;
> > +	} else {
> > +		/*
> > +		 * Recalculate watermarks even when the mode hasn't changed
> > +		 * to preserve the legacy behavior, as this is always called
> > +		 * inside start_stop_khugepaged().
> > +		 */
> > +		set_recommended_min_free_kbytes();
> >  	}
> > -	return ret;
> > +
> > +	return count;
> >  }
> >
> >  struct kobj_attribute thpsize_shmem_enabled_attr =
> > --
> > 2.25.1
> >
> >

Re: [PATCH v3 2/2] mm: shmem: refactor thpsize_shmem_enabled_show() with helper arrays

[Lorenzo Stoakes]

On Fri, May 22, 2026 at 06:44:18PM +0800, Barry Song wrote:
> On Fri, May 22, 2026 at 6:35 PM Lorenzo Stoakes <ljs@kernel.org> wrote:
> >
> > On Mon, May 18, 2026 at 12:32:38PM +0000, ranxiaokai627@163.com wrote:
> > > From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> > >
> > > Replace the hardcoded if/else chain of test_bit() calls and string
> > > literals in thpsize_shmem_enabled_show() with a loop over
> > > huge_shmem_orders_by_mode[] and huge_shmem_enabled_mode_strings[] arrays.
> > >
> > > This makes thpsize_shmem_enabled_show() consistent with
> > > thpsize_shmem_enabled_store() and eliminates duplicated mode name strings.
> > >
> > > Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> >
> > From: ranxiaokai627@163.com
> >
> > This does not match the From: field of the email.
> >
> > This is violating kernel process. See
> > https://docs.kernel.org/process/submitting-patches.html
>
> I’m not aware of this rule, since I usually see From matching
> Signed-off-by. Do we really have such a rule? Sorry, I might be a
> bit ignorant about this 🙂

We do yes.

But I was wrong here, as the From: field was provided inline (doing that and
including the From: field in the To/Cc I think suffices).

>
> >
> > Please either update this to your 163 email account or resend from your
> > zte.com.cn address, otherwise we can't take this.
> >
> > Cheers, Lorenzo
> >

Cheers, Lorenzo

Re: [PATCH v3 2/2] mm: shmem: refactor thpsize_shmem_enabled_show() with helper arrays

[Barry Song]

On Mon, May 18, 2026 at 8:33 PM <ranxiaokai627@163.com> wrote:
>
> From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
>
> Replace the hardcoded if/else chain of test_bit() calls and string
> literals in thpsize_shmem_enabled_show() with a loop over
> huge_shmem_orders_by_mode[] and huge_shmem_enabled_mode_strings[] arrays.
>
> This makes thpsize_shmem_enabled_show() consistent with
> thpsize_shmem_enabled_store() and eliminates duplicated mode name strings.
>
> Signed-off-by: Ran Xiaokai <ran.xiaokai@zte.com.cn>
> Reviewed-by: Baolin Wang <baolin.wang@linux.alibaba.com>
> Tested-by: Baolin Wang <baolin.wang@linux.alibaba.com>
> Reviewed-by: Breno Leitao <leitao@debian.org>
> Reviewed-by: Lorenzo Stoakes <ljs@kernel.org>

Reviewed-by: Barry Song <baohua@kernel.org>

Re: [PATCH v3 1/2] mm: shmem: refactor thpsize_shmem_enabled_store() with sysfs_match_string()

[ranxiaokai627]

>On Mon, May 18, 2026 at 12:32:37PM +0000, ranxiaokai627@163.com wrote:
>> From: Ran Xiaokai <ran.xiaokai@zte.com.cn>
>> ---
>>  mm/shmem.c | 107 ++++++++++++++++++++++++++++++-----------------------
>>  1 file changed, 60 insertions(+), 47 deletions(-)
>>
>> diff --git a/mm/shmem.c b/mm/shmem.c
>> index 3b5dc21b323c..46d2cfc30823 100644
>> --- a/mm/shmem.c
>> +++ b/mm/shmem.c
>> @@ -5526,6 +5526,29 @@ static ssize_t shmem_enabled_store(struct kobject *kobj,
>>  struct kobj_attribute shmem_enabled_attr = __ATTR_RW(shmem_enabled);
>>  static DEFINE_SPINLOCK(huge_shmem_orders_lock);
>>
>> +enum huge_shmem_enabled_mode {
>> +	HUGE_SHMEM_ENABLED_ALWAYS = 0,
>> +	HUGE_SHMEM_ENABLED_INHERIT,
>> +	HUGE_SHMEM_ENABLED_WITHIN_SIZE,
>> +	HUGE_SHMEM_ENABLED_ADVISE,
>> +	HUGE_SHMEM_ENABLED_NEVER,
>> +};
>> +
>> +static const char * const huge_shmem_enabled_mode_strings[] = {
>> +	[HUGE_SHMEM_ENABLED_ALWAYS]      = "always",
>> +	[HUGE_SHMEM_ENABLED_INHERIT]     = "inherit",
>> +	[HUGE_SHMEM_ENABLED_WITHIN_SIZE] = "within_size",
>> +	[HUGE_SHMEM_ENABLED_ADVISE]      = "advise",
>> +	[HUGE_SHMEM_ENABLED_NEVER]       = "never",
>> +};
>> +
>> +static unsigned long * const huge_shmem_orders_by_mode[] = {
>> +	[HUGE_SHMEM_ENABLED_ALWAYS]      = &huge_shmem_orders_always,
>> +	[HUGE_SHMEM_ENABLED_INHERIT]     = &huge_shmem_orders_inherit,
>> +	[HUGE_SHMEM_ENABLED_WITHIN_SIZE] = &huge_shmem_orders_within_size,
>> +	[HUGE_SHMEM_ENABLED_ADVISE]      = &huge_shmem_orders_madvise,
>> +};
>
>As Baolin suggested, we can probably rename these for bervity.
>
>We know it's shmem, as it's in shmem.c :) so drop that.
>
>huge_mode, huge_mode_strings, huge_mode_orders seems good to me?

The old naming is indeed a bit verbose.
I will send a new version based on Baolin and your suggestion.

>> +
>>  static ssize_t thpsize_shmem_enabled_show(struct kobject *kobj,
>>  					  struct kobj_attribute *attr, char *buf)
>>  {
>> @@ -5546,63 +5569,53 @@ static ssize_t thpsize_shmem_enabled_show(struct kobject *kobj,
>>  	return sysfs_emit(buf, "%s\n", output);
>>  }
>>
>> +static bool set_shmem_enabled_mode(int order, enum huge_shmem_enabled_mode mode)
>> +{
>> +	bool changed = false;
>> +	enum huge_shmem_enabled_mode idx;
>> +
>> +	spin_lock(&huge_shmem_orders_lock);
>> +	for (idx = 0; idx < ARRAY_SIZE(huge_shmem_orders_by_mode); idx++) {
>> +		if (idx == mode)
>> +			changed |= !__test_and_set_bit(order, huge_shmem_orders_by_mode[idx]);
>> +		else
>> +			changed |= __test_and_clear_bit(order, huge_shmem_orders_by_mode[idx]);
>> +	}
>> +	spin_unlock(&huge_shmem_orders_lock);
>> +
>> +	return changed;
>> +}
>> +
>
>Thanks for separating this out! :)