Commit cdcb53e1 authored by Hui Zhu's avatar Hui Zhu Committed by Andrew Morton
Browse files

mm/hugetlb: extract sysctl into hugetlb_sysctl.c 

Following the extraction of sysfs code, this patch moves the sysctl
interface implementation into a dedicated file to further improve code
organization and maintainability of the hugetlb subsystem.

The following components are moved to mm/hugetlb_sysctl.c:
- proc_hugetlb_doulongvec_minmax()
- hugetlb_sysctl_handler_common()
- hugetlb_sysctl_handler()
- hugetlb_mempolicy_sysctl_handler() (CONFIG_NUMA)
- hugetlb_overcommit_handler()
- hugetlb_table[] sysctl table definition
- hugetlb_sysctl_init()

The hugetlb_internal.h header file is updated to declare the sysctl
initialization function with proper #ifdef guards for configurations
without CONFIG_SYSCTL support.

The Makefile is updated to compile hugetlb_sysctl.o when CONFIG_HUGETLBFS
is enabled.  This refactoring reduces the size of hugetlb.c and logically
separates the sysctl interface from core hugetlb management code.

MAINTAINERS is updated to add new file hugetlb_sysctl.c.

No functional changes are introduced; all code is moved as-is from
hugetlb.c with consistent formatting.

Link: https://lkml.kernel.org/r/5bbee7ab5be71d0bb1aebec38642d7e83526bb7a.1762398359.git.zhuhui@kylinos.cn


Signed-off-by: default avatarGeliang Tang <geliang@kernel.org>
Signed-off-by: default avatarHui Zhu <zhuhui@kylinos.cn>
Cc: David Hildenbrand <david@redhat.com>
Cc: Muchun Song <muchun.song@linux.dev>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: SeongJae Park <sj@kernel.org>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
parent ecd6703f

MAINTAINERS

+1 −0
Original line number Diff line number Diff line
@@ -11540,6 +11540,7 @@ F: mm/hugetlb.c 
F:	mm/hugetlb_cgroup.c

F:	mm/hugetlb_cma.c

F:	mm/hugetlb_cma.h

F:	mm/hugetlb_sysctl.c

F:	mm/hugetlb_sysfs.c

F:	mm/hugetlb_vmemmap.c

F:	mm/hugetlb_vmemmap.h

mm/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -78,7 +78,7 @@ endif 
obj-$(CONFIG_SWAP)	+= page_io.o swap_state.o swapfile.o

obj-$(CONFIG_ZSWAP)	+= zswap.o

obj-$(CONFIG_HAS_DMA)	+= dmapool.o

obj-$(CONFIG_HUGETLBFS)	+= hugetlb.o hugetlb_sysfs.o

obj-$(CONFIG_HUGETLBFS)	+= hugetlb.o hugetlb_sysfs.o hugetlb_sysctl.o

ifdef CONFIG_CMA

obj-$(CONFIG_HUGETLBFS)	+= hugetlb_cma.o

endif

mm/hugetlb.c

+0 −132
Original line number Diff line number Diff line
@@ -7,7 +7,6 @@ 
#include <linux/init.h>

#include <linux/mm.h>

#include <linux/seq_file.h>

#include <linux/sysctl.h>

#include <linux/highmem.h>

#include <linux/mmu_notifier.h>

#include <linux/nodemask.h>
@@ -4111,12 +4110,6 @@ ssize_t __nr_hugepages_store_common(bool obey_mempolicy, 
	return err ? err : len;

}



#ifdef CONFIG_SYSCTL

static void hugetlb_sysctl_init(void);

#else

static inline void hugetlb_sysctl_init(void) { }

#endif



static int __init hugetlb_init(void)

{

	int i;
@@ -4549,131 +4542,6 @@ static unsigned int allowed_mems_nr(struct hstate *h) 
	return nr;

}



#ifdef CONFIG_SYSCTL

static int proc_hugetlb_doulongvec_minmax(const struct ctl_table *table, int write,

					  void *buffer, size_t *length,

					  loff_t *ppos, unsigned long *out)

{

	struct ctl_table dup_table;



	/*

	 * In order to avoid races with __do_proc_doulongvec_minmax(), we

	 * can duplicate the @table and alter the duplicate of it.

	 */

	dup_table = *table;

	dup_table.data = out;



	return proc_doulongvec_minmax(&dup_table, write, buffer, length, ppos);

}



static int hugetlb_sysctl_handler_common(bool obey_mempolicy,

			 const struct ctl_table *table, int write,

			 void *buffer, size_t *length, loff_t *ppos)

{

	struct hstate *h = &default_hstate;

	unsigned long tmp = h->max_huge_pages;

	int ret;



	if (!hugepages_supported())

		return -EOPNOTSUPP;



	ret = proc_hugetlb_doulongvec_minmax(table, write, buffer, length, ppos,

					     &tmp);

	if (ret)

		goto out;



	if (write)

		ret = __nr_hugepages_store_common(obey_mempolicy, h,

						  NUMA_NO_NODE, tmp, *length);

out:

	return ret;

}



static int hugetlb_sysctl_handler(const struct ctl_table *table, int write,

			  void *buffer, size_t *length, loff_t *ppos)

{



	return hugetlb_sysctl_handler_common(false, table, write,

							buffer, length, ppos);

}



#ifdef CONFIG_NUMA

static int hugetlb_mempolicy_sysctl_handler(const struct ctl_table *table, int write,

			  void *buffer, size_t *length, loff_t *ppos)

{

	return hugetlb_sysctl_handler_common(true, table, write,

							buffer, length, ppos);

}

#endif /* CONFIG_NUMA */



static int hugetlb_overcommit_handler(const struct ctl_table *table, int write,

		void *buffer, size_t *length, loff_t *ppos)

{

	struct hstate *h = &default_hstate;

	unsigned long tmp;

	int ret;



	if (!hugepages_supported())

		return -EOPNOTSUPP;



	tmp = h->nr_overcommit_huge_pages;



	if (write && hstate_is_gigantic_no_runtime(h))

		return -EINVAL;



	ret = proc_hugetlb_doulongvec_minmax(table, write, buffer, length, ppos,

					     &tmp);

	if (ret)

		goto out;



	if (write) {

		spin_lock_irq(&hugetlb_lock);

		h->nr_overcommit_huge_pages = tmp;

		spin_unlock_irq(&hugetlb_lock);

	}

out:

	return ret;

}



static const struct ctl_table hugetlb_table[] = {

	{

		.procname	= "nr_hugepages",

		.data		= NULL,

		.maxlen		= sizeof(unsigned long),

		.mode		= 0644,

		.proc_handler	= hugetlb_sysctl_handler,

	},

#ifdef CONFIG_NUMA

	{

		.procname       = "nr_hugepages_mempolicy",

		.data           = NULL,

		.maxlen         = sizeof(unsigned long),

		.mode           = 0644,

		.proc_handler   = &hugetlb_mempolicy_sysctl_handler,

	},

#endif

	{

		.procname	= "hugetlb_shm_group",

		.data		= &sysctl_hugetlb_shm_group,

		.maxlen		= sizeof(gid_t),

		.mode		= 0644,

		.proc_handler	= proc_dointvec,

	},

	{

		.procname	= "nr_overcommit_hugepages",

		.data		= NULL,

		.maxlen		= sizeof(unsigned long),

		.mode		= 0644,

		.proc_handler	= hugetlb_overcommit_handler,

	},

};



static void __init hugetlb_sysctl_init(void)

{

	register_sysctl_init("vm", hugetlb_table);

}

#endif /* CONFIG_SYSCTL */



void hugetlb_report_meminfo(struct seq_file *m)

{

	struct hstate *h;

mm/hugetlb_internal.h

+6 −0
Original line number Diff line number Diff line
@@ -108,4 +108,10 @@ extern ssize_t __nr_hugepages_store_common(bool obey_mempolicy, 


extern void hugetlb_sysfs_init(void) __init;



#ifdef CONFIG_SYSCTL

extern void hugetlb_sysctl_init(void);

#else

static inline void hugetlb_sysctl_init(void) { }

#endif



#endif /* _LINUX_HUGETLB_INTERNAL_H */

mm/hugetlb_sysctl.c

0 → 100644
+134 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/*

 * HugeTLB sysfs interfaces.

 * (C) Nadia Yvette Chambers, April 2004

 */



#include <linux/sysctl.h>



#include "hugetlb_internal.h"



#ifdef CONFIG_SYSCTL

static int proc_hugetlb_doulongvec_minmax(const struct ctl_table *table, int write,

					  void *buffer, size_t *length,

					  loff_t *ppos, unsigned long *out)

{

	struct ctl_table dup_table;



	/*

	 * In order to avoid races with __do_proc_doulongvec_minmax(), we

	 * can duplicate the @table and alter the duplicate of it.

	 */

	dup_table = *table;

	dup_table.data = out;



	return proc_doulongvec_minmax(&dup_table, write, buffer, length, ppos);

}



static int hugetlb_sysctl_handler_common(bool obey_mempolicy,

			 const struct ctl_table *table, int write,

			 void *buffer, size_t *length, loff_t *ppos)

{

	struct hstate *h = &default_hstate;

	unsigned long tmp = h->max_huge_pages;

	int ret;



	if (!hugepages_supported())

		return -EOPNOTSUPP;



	ret = proc_hugetlb_doulongvec_minmax(table, write, buffer, length, ppos,

					     &tmp);

	if (ret)

		goto out;



	if (write)

		ret = __nr_hugepages_store_common(obey_mempolicy, h,

						  NUMA_NO_NODE, tmp, *length);

out:

	return ret;

}



static int hugetlb_sysctl_handler(const struct ctl_table *table, int write,

			  void *buffer, size_t *length, loff_t *ppos)

{



	return hugetlb_sysctl_handler_common(false, table, write,

							buffer, length, ppos);

}



#ifdef CONFIG_NUMA

static int hugetlb_mempolicy_sysctl_handler(const struct ctl_table *table, int write,

			  void *buffer, size_t *length, loff_t *ppos)

{

	return hugetlb_sysctl_handler_common(true, table, write,

							buffer, length, ppos);

}

#endif /* CONFIG_NUMA */



static int hugetlb_overcommit_handler(const struct ctl_table *table, int write,

		void *buffer, size_t *length, loff_t *ppos)

{

	struct hstate *h = &default_hstate;

	unsigned long tmp;

	int ret;



	if (!hugepages_supported())

		return -EOPNOTSUPP;



	tmp = h->nr_overcommit_huge_pages;



	if (write && hstate_is_gigantic_no_runtime(h))

		return -EINVAL;



	ret = proc_hugetlb_doulongvec_minmax(table, write, buffer, length, ppos,

					     &tmp);

	if (ret)

		goto out;



	if (write) {

		spin_lock_irq(&hugetlb_lock);

		h->nr_overcommit_huge_pages = tmp;

		spin_unlock_irq(&hugetlb_lock);

	}

out:

	return ret;

}



static const struct ctl_table hugetlb_table[] = {

	{

		.procname	= "nr_hugepages",

		.data		= NULL,

		.maxlen		= sizeof(unsigned long),

		.mode		= 0644,

		.proc_handler	= hugetlb_sysctl_handler,

	},

#ifdef CONFIG_NUMA

	{

		.procname       = "nr_hugepages_mempolicy",

		.data           = NULL,

		.maxlen         = sizeof(unsigned long),

		.mode           = 0644,

		.proc_handler   = &hugetlb_mempolicy_sysctl_handler,

	},

#endif

	{

		.procname	= "hugetlb_shm_group",

		.data		= &sysctl_hugetlb_shm_group,

		.maxlen		= sizeof(gid_t),

		.mode		= 0644,

		.proc_handler	= proc_dointvec,

	},

	{

		.procname	= "nr_overcommit_hugepages",

		.data		= NULL,

		.maxlen		= sizeof(unsigned long),

		.mode		= 0644,

		.proc_handler	= hugetlb_overcommit_handler,

	},

};



void __init hugetlb_sysctl_init(void)

{

	register_sysctl_init("vm", hugetlb_table);

}

#endif /* CONFIG_SYSCTL */