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@xxxxxxx wrote:
> > From: Ran Xiaokai <ran.xiaokai@xxxxxxxxxx>
> >
> > 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@xxxxxxxxxx>
>
> 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
> >
> >