Re: [PATCH v2 2/4] mm: shmem: control THP support through the kernel command line

[Baolin Wang <baolin.wang@linux.alibaba.com>]

On 2024/10/29 08:13, Maíra Canal wrote:
> Add a new kernel command line to control the hugepage allocation policy
> for the internal shmem mount, ``transparent_hugepage_shmem``. The
> parameter is similar to ``transparent_hugepage`` and has the following
> format:
> 
> transparent_hugepage_shmem=<policy>
> 
> where ``<policy>`` is one of the seven valid policies available for
> shmem.
> 
> By configuring the default hugepage allocation policy for the internal
> shmem mount, applications that use shmem, such as the DRM GEM objects,
> can take advantage of mTHP before it's been configured through sysfs.

Just out of curiosity, do you have any performance benefit data when 
using mTHP for DRM GEM objects?

> Signed-off-by: Maíra Canal <mcanal@igalia.com>
> ---
>   .../admin-guide/kernel-parameters.txt         |  7 +++
>   Documentation/admin-guide/mm/transhuge.rst    |  6 +++
>   mm/shmem.c                                    | 53 +++++++++++++++----
>   3 files changed, 57 insertions(+), 9 deletions(-)
> 
> diff --git a/Documentation/admin-guide/kernel-parameters.txt b/Documentation/admin-guide/kernel-parameters.txt
> index 1666576acc0e..acabb04d0dd4 100644
> --- a/Documentation/admin-guide/kernel-parameters.txt
> +++ b/Documentation/admin-guide/kernel-parameters.txt
> @@ -6926,6 +6926,13 @@
>   			See Documentation/admin-guide/mm/transhuge.rst
>   			for more details.
>   
> +	transparent_hugepage_shmem= [KNL]
> +			Format: [always|within_size|advise|never|deny|force]
> +			Can be used to control the hugepage allocation policy for
> +			the internal shmem mount.
> +			See Documentation/admin-guide/mm/transhuge.rst
> +			for more details.
> +
>   	trusted.source=	[KEYS]
>   			Format: <string>
>   			This parameter identifies the trust source as a backend
> diff --git a/Documentation/admin-guide/mm/transhuge.rst b/Documentation/admin-guide/mm/transhuge.rst
> index 745055c3dc09..9b5b02c4d1ab 100644
> --- a/Documentation/admin-guide/mm/transhuge.rst
> +++ b/Documentation/admin-guide/mm/transhuge.rst
> @@ -326,6 +326,12 @@ PMD_ORDER THP policy will be overridden. If the policy for PMD_ORDER
>   is not defined within a valid ``thp_anon``, its policy will default to
>   ``never``.
>   
> +Similarly to ``transparent_hugepage``, you can control the hugepage
> +allocation policy for the internal shmem mount by using the kernel parameter
> +``transparent_hugepage_shmem=<policy>``, where ``<policy>`` is one of the
> +seven valid policies for shmem (``always``, ``within_size``, ``advise``,
> +``never``, ``deny``, and ``force``).
> +
>   Hugepages in tmpfs/shmem
>   ========================
>   
> diff --git a/mm/shmem.c b/mm/shmem.c
> index 44282a296c33..26c1eb1b4b1d 100644
> --- a/mm/shmem.c
> +++ b/mm/shmem.c
> @@ -582,7 +582,6 @@ static bool shmem_huge_global_enabled(struct inode *inode, pgoff_t index,
>   	}
>   }
>   
> -#if defined(CONFIG_SYSFS)
>   static int shmem_parse_huge(const char *str)
>   {
>   	if (!strcmp(str, "never"))
> @@ -599,7 +598,6 @@ static int shmem_parse_huge(const char *str)
>   		return SHMEM_HUGE_FORCE;
>   	return -EINVAL;
>   }
> -#endif
>   
>   #if defined(CONFIG_SYSFS) || defined(CONFIG_TMPFS)
>   static const char *shmem_format_huge(int huge)
> @@ -624,6 +622,20 @@ static const char *shmem_format_huge(int huge)
>   }
>   #endif
>   
> +static int shmem_valid_huge(int huge)
> +{
> +	if (!has_transparent_hugepage() &&
> +			huge != SHMEM_HUGE_NEVER && huge != SHMEM_HUGE_DENY)
> +		return -EINVAL;
> +
> +	/* Do not override huge allocation policy with non-PMD sized mTHP */
> +	if (huge == SHMEM_HUGE_FORCE &&
> +	    huge_shmem_orders_inherit != BIT(HPAGE_PMD_ORDER))
> +		return -EINVAL;
> +
> +	return 0;
> +}
> +
>   static unsigned long shmem_unused_huge_shrink(struct shmem_sb_info *sbinfo,
>   		struct shrink_control *sc, unsigned long nr_to_free)
>   {
> @@ -5070,14 +5082,10 @@ static ssize_t shmem_enabled_store(struct kobject *kobj,
>   	huge = shmem_parse_huge(tmp);
>   	if (huge == -EINVAL)
>   		return -EINVAL;
> -	if (!has_transparent_hugepage() &&
> -			huge != SHMEM_HUGE_NEVER && huge != SHMEM_HUGE_DENY)
> -		return -EINVAL;
>   
> -	/* Do not override huge allocation policy with non-PMD sized mTHP */
> -	if (huge == SHMEM_HUGE_FORCE &&
> -	    huge_shmem_orders_inherit != BIT(HPAGE_PMD_ORDER))
> -		return -EINVAL;
> +	err = shmem_valid_huge(huge);
> +	if (err)
> +		return err;
>   
>   	shmem_huge = huge;
>   	if (shmem_huge > SHMEM_HUGE_DENY)
> @@ -5174,6 +5182,33 @@ struct kobj_attribute thpsize_shmem_enabled_attr =
>   	__ATTR(shmem_enabled, 0644, thpsize_shmem_enabled_show, thpsize_shmem_enabled_store);
>   #endif /* CONFIG_TRANSPARENT_HUGEPAGE && CONFIG_SYSFS */
>   
> +#if defined(CONFIG_TRANSPARENT_HUGEPAGE)
> +
> +static int __init setup_transparent_hugepage_shmem(char *str)
> +{
> +	int huge, ret = 0;
> +
> +	if (!str)
> +		goto out;
> +
> +	huge = shmem_parse_huge(str);
> +	if (huge == -EINVAL)
> +		goto out;

Looks better. But shmem_parse_huge() is also a common part, and what I 
am thinking is below:

diff --git a/mm/shmem.c b/mm/shmem.c
index f8b8b1ad2631..646d8943950a 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -629,24 +629,39 @@ static unsigned int 
shmem_huge_global_enabled(struct inode *inode, pgoff_t index
         }
  }

-#if defined(CONFIG_SYSFS)
  static int shmem_parse_huge(const char *str)
  {
+       int huge;
+
+       if (!str)
+               return -EINVAL;
+
         if (!strcmp(str, "never"))
-               return SHMEM_HUGE_NEVER;
-       if (!strcmp(str, "always"))
-               return SHMEM_HUGE_ALWAYS;
-       if (!strcmp(str, "within_size"))
-               return SHMEM_HUGE_WITHIN_SIZE;
-       if (!strcmp(str, "advise"))
-               return SHMEM_HUGE_ADVISE;
-       if (!strcmp(str, "deny"))
-               return SHMEM_HUGE_DENY;
-       if (!strcmp(str, "force"))
-               return SHMEM_HUGE_FORCE;
-       return -EINVAL;
+               huge = SHMEM_HUGE_NEVER;
+       else if (!strcmp(str, "always"))
+               huge = SHMEM_HUGE_ALWAYS;
+       else if (!strcmp(str, "within_size"))
+               huge = SHMEM_HUGE_WITHIN_SIZE;
+       else if (!strcmp(str, "advise"))
+               huge = SHMEM_HUGE_ADVISE;
+       else if (!strcmp(str, "deny"))
+               huge = SHMEM_HUGE_DENY;
+       else if (!strcmp(str, "force"))
+               huge = SHMEM_HUGE_FORCE;
+       else
+               return -EINVAL;
+
+       if (!has_transparent_hugepage() &&
+           huge != SHMEM_HUGE_NEVER && huge != SHMEM_HUGE_DENY)
+               return -EINVAL;
+
+       /* Do not override huge allocation policy with non-PMD sized mTHP */
+       if (huge == SHMEM_HUGE_FORCE &&
+           huge_shmem_orders_inherit != BIT(HPAGE_PMD_ORDER))
+               return -EINVAL;
+
+       return huge;
  }
-#endif

  #if defined(CONFIG_SYSFS) || defined(CONFIG_TMPFS)
  static const char *shmem_format_huge(int huge)
@@ -5104,16 +5119,8 @@ static ssize_t shmem_enabled_store(struct kobject 
*kobj,
                 tmp[count - 1] = '\0';

         huge = shmem_parse_huge(tmp);
-       if (huge == -EINVAL)
-               return -EINVAL;
-       if (!has_transparent_hugepage() &&
-                       huge != SHMEM_HUGE_NEVER && huge != SHMEM_HUGE_DENY)
-               return -EINVAL;
-
-       /* Do not override huge allocation policy with non-PMD sized mTHP */
-       if (huge == SHMEM_HUGE_FORCE &&
-           huge_shmem_orders_inherit != BIT(HPAGE_PMD_ORDER))
-               return -EINVAL;
+       if (huge < 0)
+               return huge;

         shmem_huge = huge;
         if (shmem_huge > SHMEM_HUGE_DENY)
@@ -5210,6 +5217,25 @@ struct kobj_attribute thpsize_shmem_enabled_attr =
         __ATTR(shmem_enabled, 0644, thpsize_shmem_enabled_show, 
thpsize_shmem_enabled_store);
  #endif /* CONFIG_TRANSPARENT_HUGEPAGE && CONFIG_SYSFS */

+#if defined(CONFIG_TRANSPARENT_HUGEPAGE)
+
+static int __init setup_transparent_hugepage_shmem(char *str)
+{
+       int huge;
+
+       huge = shmem_parse_huge(str);
+       if (huge < 0) {
+               pr_warn("transparent_hugepage_shmem= cannot parse, 
ignored\n");
+               return 0;
+       }
+
+       shmem_huge = huge;
+       return 1;
+}
+__setup("transparent_hugepage_shmem=", setup_transparent_hugepage_shmem);
+
+#endif /* CONFIG_TRANSPARENT_HUGEPAGE */
+
  #else /* !CONFIG_SHMEM */

  /*