Skip to contentSkip to conversation

Allocate memmap from hotadded memory (per device)

PATCH Superseded Oscar Salvador 3 participants 14 messages Mar 4, 2021 – Mar 8, 2021

Subsystems (10)

v3 of 10 Superseded Latest is v10 →

lore
Share & tools
lore

Oscar Salvador

author maintainer
#0 lore raw

v3 cover Allocate memmap from hotadded memory (per device)

Hi,

here is v3.

Changes from v2 -> v3:
- Addressed feedback from David
- Squash former patch#4 and and patch#5 into patch#1
- Fix config dependency CONFIR_SPARSE_VMEMMAP vs CONFIG_SPARSE_VMEMMAP_ENABLE
- Simplify module parameter functions

Changes from v1 -> v2
- Addressed feedback from David
- Fence off the feature in case struct page size is not multiple of PMD size or pageblock alignment cannot be guaranted
- Tested on x86_64 small and large memory_blocks
- Tested on arm64 4KB and 64KB page sizes (for some reason I cannot boot my VM with 16KB page size).

Arm64 with 4KB page size behaves like x86_64 after [1], which made section size smaller.
With 64KB, the feature gets fenced off due to pageblock alignment.

Changes from RFCv3 -> v1:
- Addressed feedback from David
- Re-order patches

Changes from v2 -> v3 (RFC):
- Re-order patches (Michal)
- Fold "mm,memory_hotplug: Introduce MHP_MEMMAP_ON_MEMORY" in patch#1
- Add kernel boot option to enable this feature (Michal)

Changes from v1 -> v2 (RFC):
- Addressed feedback provided by David
- Add a arch_support_memmap_on_memory to be called from mhp_supports_memmap_on_memory, as atm, only ARM, powerpc and x86_64 have altmat support.

[1] https://lore.kernel.org/lkml/[email protected]/

Original cover letter:

----

The primary goal of this patchset is to reduce memory overhead of the hot-added memory (at least for SPARSEMEM_VMEMMAP memory model).
The current way we use to populate memmap (struct page array) has two main drawbacks:

a) it consumes an additional memory until the hotadded memory itself is onlined and
b) memmap might end up on a different numa node which is especially true for movable_node configuration.
c) due to fragmentation we might end up populating memmap with base pages

One way to mitigate all these issues is to simply allocate memmap array (which is the largest memory footprint of the physical memory hotplug) from the hot-added memory itself. SPARSEMEM_VMEMMAP memory model allows us to map any pfn range so the memory doesn't need to be online to be usable for the array. See patch 3 for more details.
This feature is only usable when CONFIG_SPARSEMEM_VMEMMAP is set.

[Overall design]:

Implementation wise we reuse vmem_altmap infrastructure to override the default allocator used by vmemap_populate. memory_block structure gained a new field called nr_vmemmap_pages. This plays well for two reasons:

1) {offline/online}_pages know the difference between start_pfn and buddy_start_pfn, which is start_pfn + nr_vmemmap_pages. In this way all isolation/migration operations are done to within the right range of memory without vmemmap pages. This allows us for a much cleaner handling.

2) In try_remove_memory, we construct a new vmemap_altmap struct with the right information based on memory_block->nr_vmemap_pages, so we end up calling vmem_altmap_free instead of free_pagetable when removing the memory.

Oscar Salvador (5):
mm,memory_hotplug: Allocate memmap from the added memory range acpi,memhotplug: Enable MHP_MEMMAP_ON_MEMORY when supported mm,memory_hotplug: Add kernel boot option to enable memmap_on_memory x86/Kconfig: Introduce ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE arm64/Kconfig: Introduce ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE

 Documentation/admin-guide/kernel-parameters.txt |  14 +++
 arch/arm64/Kconfig                              |   4 +
 arch/x86/Kconfig                                |   4 +
 drivers/acpi/acpi_memhotplug.c                  |   5 +-
 drivers/base/memory.c                           |  20 +--
 include/linux/memory.h                          |   8 +-
 include/linux/memory_hotplug.h                  |  21 +++-
 include/linux/memremap.h                        |   2 +-
 include/linux/mmzone.h                          |   5 +
 mm/Kconfig                                      |   4 +
 mm/Makefile                                     |   5 +-
 mm/memory_hotplug.c                             | 155 ++++++++++++++++++++----
 mm/page_alloc.c                                 |   4 +-
 13 files changed, 213 insertions(+), 38 deletions(-)
Signature · 1 line
2.16.3
author maintainer
#1 lore raw

PATCH v3 1/5 mm,memory_hotplug: Allocate memmap from the added memory range

Physical memory hotadd has to allocate a memmap (struct page array) for the newly added memory section. Currently, alloc_pages_node() is used for those allocations.

This has some disadvantages:
a) an existing memory is consumed for that purpose

    (eg: ~2MB per 128MB memory section on x86_64)

b) if the whole node is movable then we have off-node struct pages which has performance drawbacks.
c) It might be there are no PMD_ALIGNED chunks so memmap array gets populated with base pages.

This can be improved when CONFIG_SPARSEMEM_VMEMMAP is enabled.

Vmemap page tables can map arbitrary memory.
That means that we can simply use the beginning of each memory section and map struct pages there.
struct pages which back the allocated space then just need to be treated carefully.

Implementation wise we will reuse vmem_altmap infrastructure to override the default allocator used by __populate_section_memmap.
Part of the implementation also relies on memory_block structure gaining a new field which specifies the number of vmemmap_pages at the beginning. This comes in handy as in {online,offline}_pages, all the isolation and migration is being done on (buddy_start_pfn, end_pfn] range, being buddy_start_pfn = start_pfn + nr_vmemmap_pages.

In this way, we have:

[start_pfn, buddy_start_pfn - 1] = Initialized and PageReserved
[buddy_start_pfn, end_pfn - 1] = Initialized and sent to buddy

Hot-remove:

We need to be careful when removing memory, as adding and removing memory needs to be done with the same granularity. To check that this assumption is not violated, we check the memory range we want to remove and if a) any memory block has vmemmap pages and b) the range spans more than a single memory block, we scream out loud and refuse to proceed.

If all is good and the range was using memmap on memory (aka vmemmap pages), we construct an altmap structure so free_hugepage_table does the right thing and calls vmem_altmap_free instead of free_pagetable.

---
 drivers/base/memory.c          |  20 +++---
 include/linux/memory.h         |   8 ++-
 include/linux/memory_hotplug.h |  21 ++++--
 include/linux/memremap.h       |   2 +-
 include/linux/mmzone.h         |   5 ++
 mm/Kconfig                     |   4 ++
 mm/memory_hotplug.c            | 149 +++++++++++++++++++++++++++++++++++------
 mm/page_alloc.c                |   4 +-
 8 files changed, 177 insertions(+), 36 deletions(-)
drivers/base/memory.c +12 -8
index f35298425575..5ea2b3fbce02 100644
@@ -175,7 +175,7 @@ int memory_notify(unsigned long val, void *v)
  */
 static int
 memory_block_action(unsigned long start_section_nr, unsigned long action,
-		    int online_type, int nid)
+		    int online_type, int nid, unsigned long nr_vmemmap_pages)
 {
 	unsigned long start_pfn;
 	unsigned long nr_pages = PAGES_PER_SECTION * sections_per_block;
@@ -185,10 +185,11 @@ memory_block_action(unsigned long start_section_nr, unsigned long action,
 
 	switch (action) {
 	case MEM_ONLINE:
-		ret = online_pages(start_pfn, nr_pages, online_type, nid);
+		ret = online_pages(start_pfn, nr_pages, nr_vmemmap_pages,
+				   online_type, nid);
 		break;
 	case MEM_OFFLINE:
-		ret = offline_pages(start_pfn, nr_pages);
+		ret = offline_pages(start_pfn, nr_pages, nr_vmemmap_pages);
 		break;
 	default:
 		WARN(1, KERN_WARNING "%s(%ld, %ld) unknown action: "
@@ -211,7 +212,7 @@ static int memory_block_change_state(struct memory_block *mem,
 		mem->state = MEM_GOING_OFFLINE;
 
 	ret = memory_block_action(mem->start_section_nr, to_state,
-				  mem->online_type, mem->nid);
+				  mem->online_type, mem->nid, mem->nr_vmemmap_pages);
 
 	mem->state = ret ? from_state_req : to_state;
 
@@ -567,7 +568,8 @@ int register_memory(struct memory_block *memory)
 	return ret;
 }
 
-static int init_memory_block(unsigned long block_id, unsigned long state)
+static int init_memory_block(unsigned long block_id, unsigned long state,
+			     unsigned long nr_vmemmap_pages)
 {
 	struct memory_block *mem;
 	int ret = 0;
@@ -584,6 +586,7 @@ static int init_memory_block(unsigned long block_id, unsigned long state)
 	mem->start_section_nr = block_id * sections_per_block;
 	mem->state = state;
 	mem->nid = NUMA_NO_NODE;
+	mem->nr_vmemmap_pages = nr_vmemmap_pages;
 
 	ret = register_memory(mem);
 
@@ -603,7 +606,7 @@ static int add_memory_block(unsigned long base_section_nr)
 	if (section_count == 0)
 		return 0;
 	return init_memory_block(memory_block_id(base_section_nr),
-				 MEM_ONLINE);
+				 MEM_ONLINE, 0);
 }
 
 static void unregister_memory(struct memory_block *memory)
@@ -625,7 +628,8 @@ static void unregister_memory(struct memory_block *memory)
  *
  * Called under device_hotplug_lock.
  */
-int create_memory_block_devices(unsigned long start, unsigned long size)
+int create_memory_block_devices(unsigned long start, unsigned long size,
+				unsigned long vmemmap_pages)
 {
 	const unsigned long start_block_id = pfn_to_block_id(PFN_DOWN(start));
 	unsigned long end_block_id = pfn_to_block_id(PFN_DOWN(start + size));
@@ -638,7 +642,7 @@ int create_memory_block_devices(unsigned long start, unsigned long size)
 		return -EINVAL;
 
 	for (block_id = start_block_id; block_id != end_block_id; block_id++) {
-		ret = init_memory_block(block_id, MEM_OFFLINE);
+		ret = init_memory_block(block_id, MEM_OFFLINE, vmemmap_pages);
 		if (ret)
 			break;
 	}
include/linux/memory.h +7 -1
index 4da95e684e20..97e92e8b556a 100644
@@ -29,6 +29,11 @@ struct memory_block {
 	int online_type;		/* for passing data to online routine */
 	int nid;			/* NID for this memory block */
 	struct device dev;
+	/*
+	 * Number of vmemmap pages. These pages
+	 * lay at the beginning of the memory block.
+	 */
+	unsigned long nr_vmemmap_pages;
 };
 
 int arch_get_memory_phys_device(unsigned long start_pfn);
@@ -80,7 +85,8 @@ static inline int memory_notify(unsigned long val, void *v)
 #else
 extern int register_memory_notifier(struct notifier_block *nb);
 extern void unregister_memory_notifier(struct notifier_block *nb);
-int create_memory_block_devices(unsigned long start, unsigned long size);
+int create_memory_block_devices(unsigned long start, unsigned long size,
+				unsigned long vmemmap_pages);
 void remove_memory_block_devices(unsigned long start, unsigned long size);
 extern void memory_dev_init(void);
 extern int memory_notify(unsigned long val, void *v);
include/linux/memory_hotplug.h +17 -4
index 7288aa5ef73b..a85d4b7d15c2 100644
@@ -55,6 +55,14 @@ typedef int __bitwise mhp_t;
  */
 #define MHP_MERGE_RESOURCE	((__force mhp_t)BIT(0))
 
+/*
+ * We want memmap (struct page array) to be self contained.
+ * To do so, we will use the beginning of the hot-added range to build
+ * the page tables for the memmap array that describes the entire range.
+ * Only selected architectures support it with SPARSE_VMEMMAP.
+ */
+#define MHP_MEMMAP_ON_MEMORY   ((__force mhp_t)BIT(1))
+
 /*
  * Extended parameters for memory hotplug:
  * altmap: alternative allocator for memmap array (optional)
@@ -101,11 +109,13 @@ extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages);
 extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);
 /* VM interface that may be used by firmware interface */
 extern int online_pages(unsigned long pfn, unsigned long nr_pages,
-			int online_type, int nid);
+			unsigned long nr_vmemmap_pages, int online_type,
+			int nid);
 extern struct zone *test_pages_in_a_zone(unsigned long start_pfn,
 					 unsigned long end_pfn);
 extern void __offline_isolated_pages(unsigned long start_pfn,
-				     unsigned long end_pfn);
+				     unsigned long end_pfn,
+				     unsigned long buddy_start_pfn);
 
 typedef void (*online_page_callback_t)(struct page *page, unsigned int order);
 
@@ -307,7 +317,8 @@ static inline void pgdat_resize_init(struct pglist_data *pgdat) {}
 #ifdef CONFIG_MEMORY_HOTREMOVE
 
 extern void try_offline_node(int nid);
-extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
+extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages,
+			 unsigned long nr_vmemmap_pages);
 extern int remove_memory(int nid, u64 start, u64 size);
 extern void __remove_memory(int nid, u64 start, u64 size);
 extern int offline_and_remove_memory(int nid, u64 start, u64 size);
@@ -315,7 +326,8 @@ extern int offline_and_remove_memory(int nid, u64 start, u64 size);
 #else
 static inline void try_offline_node(int nid) {}
 
-static inline int offline_pages(unsigned long start_pfn, unsigned long nr_pages)
+static inline int offline_pages(unsigned long start_pfn, unsigned long nr_pages,
+				unsigned long nr_vmemmap_pages)
 {
 	return -EINVAL;
 }
@@ -359,6 +371,7 @@ extern struct zone *zone_for_pfn_range(int online_type, int nid, unsigned start_
 extern int arch_create_linear_mapping(int nid, u64 start, u64 size,
 				      struct mhp_params *params);
 void arch_remove_linear_mapping(u64 start, u64 size);
+extern bool mhp_supports_memmap_on_memory(unsigned long size);
 #endif /* CONFIG_MEMORY_HOTPLUG */
 
 #endif /* __LINUX_MEMORY_HOTPLUG_H */
include/linux/memremap.h +1 -1
index f5b464daeeca..45a79da89c5f 100644
@@ -17,7 +17,7 @@ struct device;
  * @alloc: track pages consumed, private to vmemmap_populate()
  */
 struct vmem_altmap {
-	const unsigned long base_pfn;
+	unsigned long base_pfn;
 	const unsigned long end_pfn;
 	const unsigned long reserve;
 	unsigned long free;
include/linux/mmzone.h +5 -0
index 47946cec7584..747e1c21d8e2 100644
@@ -427,6 +427,11 @@ enum zone_type {
 	 *    techniques might use alloc_contig_range() to hide previously
 	 *    exposed pages from the buddy again (e.g., to implement some sort
 	 *    of memory unplug in virtio-mem).
+	 * 6. Memory-hotplug: when using memmap_on_memory and onlining the memory
+	 *    to the MOVABLE zone, the vmemmap pages are also placed in such
+	 *    zone. Such pages cannot be really moved around as they are
+	 *    self-stored in the range, but they are treated as movable when
+	 *    the range they describe is about to be offlined.
 	 *
 	 * In general, no unmovable allocations that degrade memory offlining
 	 * should end up in ZONE_MOVABLE. Allocators (like alloc_contig_range())
mm/Kconfig +4 -0
index 24c045b24b95..de3a7b5ed216 100644
@@ -183,6 +183,10 @@ config MEMORY_HOTREMOVE
 	depends on MEMORY_HOTPLUG && ARCH_ENABLE_MEMORY_HOTREMOVE
 	depends on MIGRATION
 
+config MHP_MEMMAP_ON_MEMORY
+	def_bool y
+	depends on SPARSEMEM_VMEMMAP && ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
+
 # Heavily threaded applications may benefit from splitting the mm-wide
 # page_table_lock, so that faults on different parts of the user address
 # space can be handled with less contention: split it at this NR_CPUS.
mm/memory_hotplug.c +128 -21

310 lines not on this page · raw message

mm/page_alloc.c +3 -1
index 3e4b29ee2b1e..85c478e374d7 100644
@@ -8830,7 +8830,8 @@ void zone_pcp_reset(struct zone *zone)
  * All pages in the range must be in a single zone, must not contain holes,
  * must span full sections, and must be isolated before calling this function.
  */
-void __offline_isolated_pages(unsigned long start_pfn, unsigned long end_pfn)
+void __offline_isolated_pages(unsigned long start_pfn, unsigned long end_pfn,
+			      unsigned long buddy_start_pfn)
 {
 	unsigned long pfn = start_pfn;
 	struct page *page;
@@ -8841,6 +8842,7 @@ void __offline_isolated_pages(unsigned long start_pfn, unsigned long end_pfn)
 	offline_mem_sections(pfn, end_pfn);
 	zone = page_zone(pfn_to_page(pfn));
 	spin_lock_irqsave(&zone->lock, flags);
+	pfn = buddy_start_pfn;
 	while (pfn < end_pfn) {
 		page = pfn_to_page(pfn);
 		/*
Signature · 1 line
2.16.3
reviewer
#2 lore raw

Re: [PATCH v3 1/5] mm,memory_hotplug: Allocate memmap from the added memory range

Quoted 28 lines · Oscar Salvador

Physical memory hotadd has to allocate a memmap (struct page array) for the newly added memory section. Currently, alloc_pages_node() is used for those allocations.

This has some disadvantages:
a) an existing memory is consumed for that purpose

    (eg: ~2MB per 128MB memory section on x86_64)

b) if the whole node is movable then we have off-node struct pages which has performance drawbacks.
c) It might be there are no PMD_ALIGNED chunks so memmap array gets populated with base pages.

This can be improved when CONFIG_SPARSEMEM_VMEMMAP is enabled.

Vmemap page tables can map arbitrary memory.
That means that we can simply use the beginning of each memory section and map struct pages there.
struct pages which back the allocated space then just need to be treated carefully.

Implementation wise we will reuse vmem_altmap infrastructure to override the default allocator used by __populate_section_memmap.
Part of the implementation also relies on memory_block structure gaining a new field which specifies the number of vmemmap_pages at the beginning. This comes in handy as in {online,offline}_pages, all the isolation and migration is being done on (buddy_start_pfn, end_pfn] range, being buddy_start_pfn = start_pfn + nr_vmemmap_pages.

Quoted 4 lines

In this way, we have:

[start_pfn, buddy_start_pfn - 1] = Initialized and PageReserved
[buddy_start_pfn, end_pfn - 1] = Initialized and sent to buddy

+Mike for hugetlb discussion.

Just thinking about how it might impact gigantic page allocation like hugetlb. When MHP_MEMMAP_ON_MEMORY is on, memmap pages are placed at the beginning of each hot added memory block, so available PFNs from two consecutive hot added memory blocks are not all contiguous, separated by memmap pages. If the memory block size is <= 1GB, there is no way of reserving gigantic pages for hugetlb during runtime using alloc_contig_pages from any hot added memory. Am I getting this right?

I see this implication is documented at the high level in patch 3. Just wonder if we want to be more specific. Or hugetlb is rarely used along with hot-add memory.

Thanks.

—
Best Regards,
Yan Zi

author maintainer
#3 lore raw

Re: [PATCH v3 1/5] mm,memory_hotplug: Allocate memmap from the added memory range

Quoted 9 lines · Zi Yan

+Mike for hugetlb discussion.

Just thinking about how it might impact gigantic page allocation like hugetlb. When MHP_MEMMAP_ON_MEMORY is on, memmap pages are placed at the beginning of each hot added memory block, so available PFNs from two consecutive hot added memory blocks are not all contiguous, separated by memmap pages. If the memory block size is <= 1GB, there is no way of reserving gigantic pages for hugetlb during runtime using alloc_contig_pages from any hot added memory. Am I getting this right?

Yes, that is why it is stated both in boot parameter documentation and patch changelog that this feature does not play well in those setups where your workload is in need of large contiguous chunks of memory, that being gigantic hugetlb or just normal memory.

Quoted 3 lines

I see this implication is documented at the high level in patch 3. Just wonder if we want to be more specific. Or hugetlb is rarely used along with hot-add memory.

I think it is quite normal to see hugetlb and hotplug operations in the same environment.
One thing excludes the other, just need to be careful when it comes to potential pitfalls during offline operations.

I guess we could mention hugetlb pages in the documentation, if it feels it is necesary.

Signature · 2 lines
Oscar Salvador
SUSE L3
#4 lore raw

Re: [PATCH v3 1/5] mm,memory_hotplug: Allocate memmap from the added memory range

Quoted 20 lines · Oscar Salvador
Quoted 9 lines · Zi Yan

+Mike for hugetlb discussion.

Just thinking about how it might impact gigantic page allocation like hugetlb. When MHP_MEMMAP_ON_MEMORY is on, memmap pages are placed at the beginning of each hot added memory block, so available PFNs from two consecutive hot added memory blocks are not all contiguous, separated by memmap pages. If the memory block size is <= 1GB, there is no way of reserving gigantic pages for hugetlb during runtime using alloc_contig_pages from any hot added memory. Am I getting this right?

Yes, that is why it is stated both in boot parameter documentation and patch changelog that this feature does not play well in those setups where your workload is in need of large contiguous chunks of memory, that being gigantic hugetlb or just normal memory.

Quoted 3 lines

I see this implication is documented at the high level in patch 3. Just wonder if we want to be more specific. Or hugetlb is rarely used along with hot-add memory.

Quoted 7 lines

I think it is quite normal to see hugetlb and hotplug operations in the same environment.
One thing excludes the other, just need to be careful when it comes to potential pitfalls during offline operations.

I guess we could mention hugetlb pages in the documentation, if it feels it is necesary.

Runtime allocation of gigantic pages without CMA is absolutely unreliable either way. IMHO, a tunable for the admin is good enough.

Signature · 3 lines
Thanks,

David / dhildenb
author maintainer
#5 lore raw

PATCH v3 2/5 acpi,memhotplug: Enable MHP_MEMMAP_ON_MEMORY when supported

In reply to Oscar Salvador

Let the caller check whether it can pass MHP_MEMMAP_ON_MEMORY by checking mhp_supports_memmap_on_memory(). MHP_MEMMAP_ON_MEMORY can only be set in case ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE is enabled, the architecture supports altmap, and the range to be added spans a single memory block.

---
 drivers/acpi/acpi_memhotplug.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)
drivers/acpi/acpi_memhotplug.c +4 -1
index b02fd51e5589..8cc195c4c861 100644
@@ -171,6 +171,7 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
 	acpi_handle handle = mem_device->device->handle;
 	int result, num_enabled = 0;
 	struct acpi_memory_info *info;
+	mhp_t mhp_flags = MHP_NONE;
 	int node;
 
 	node = acpi_get_node(handle);
@@ -194,8 +195,10 @@ static int acpi_memory_enable_device(struct acpi_memory_device *mem_device)
 		if (node < 0)
 			node = memory_add_physaddr_to_nid(info->start_addr);
 
+		if (mhp_supports_memmap_on_memory(info->length))
+			mhp_flags |= MHP_MEMMAP_ON_MEMORY;
 		result = __add_memory(node, info->start_addr, info->length,
-				      MHP_NONE);
+				      mhp_flags);
 
 		/*
 		 * If the memory block has been used by the kernel, add_memory()
Signature · 1 line
2.16.3
author maintainer
#6 lore raw

PATCH v3 3/5 mm,memory_hotplug: Add kernel boot option to enable memmap_on_memory

In reply to Oscar Salvador

Self stored memmap leads to a sparse memory situation which is unsuitable for workloads that requires large contiguous memory chunks, so make this an opt-in which needs to be explicitly enabled.

To control this, let memory_hotplug have its own memory space, as suggested by David, so we can add memory_hotplug.memmap_on_memory parameter.

---
 Documentation/admin-guide/kernel-parameters.txt | 14 ++++++++++++++
 mm/Makefile                                     |  5 ++++-
 mm/memory_hotplug.c                             |  8 +++++++-
 3 files changed, 25 insertions(+), 2 deletions(-)
Documentation/admin-guide/kernel-parameters.txt +14 -0
index 04545725f187..e626dab39c60 100644
@@ -2794,6 +2794,20 @@
 			seconds.  Use this parameter to check at some
 			other rate.  0 disables periodic checking.
 
+	memory_hotplug.memmap_on_memory
+			[KNL,X86,ARM] Boolean flag to enable this feature.
+			Format: {on | off (default)}
+			When enabled, memory to build the pages tables for the
+			memmap array describing the hot-added range will be taken
+			from the range itself, so the memmap page tables will be
+			self-hosted.
+			Since only single memory device ranges are supported at
+			the moment, this option is disabled by default because
+			it might have an impact on workloads that needs large
+			contiguous memory chunks.
+			The state of the flag can be read in
+			/sys/module/memory_hotplug/parameters/memmap_on_memory.
+
 	memtest=	[KNL,X86,ARM,PPC] Enable memtest
 			Format: <integer>
 			default : 0 <disable>
mm/Makefile +4 -1
index 72227b24a616..82ae9482f5e3 100644
@@ -58,9 +58,13 @@ obj-y			:= filemap.o mempool.o oom_kill.o fadvise.o \
 page-alloc-y := page_alloc.o
 page-alloc-$(CONFIG_SHUFFLE_PAGE_ALLOCATOR) += shuffle.o
 
+# Give 'memory_hotplug' its own module-parameter namespace
+memory-hotplug-$(CONFIG_MEMORY_HOTPLUG) += memory_hotplug.o
+
 obj-y += page-alloc.o
 obj-y += init-mm.o
 obj-y += memblock.o
+obj-y += $(memory-hotplug-y)
 
 ifdef CONFIG_MMU
 	obj-$(CONFIG_ADVISE_SYSCALLS)	+= madvise.o
@@ -83,7 +87,6 @@ obj-$(CONFIG_SLUB) += slub.o
 obj-$(CONFIG_KASAN)	+= kasan/
 obj-$(CONFIG_KFENCE) += kfence/
 obj-$(CONFIG_FAILSLAB) += failslab.o
-obj-$(CONFIG_MEMORY_HOTPLUG) += memory_hotplug.o
 obj-$(CONFIG_MEMTEST)		+= memtest.o
 obj-$(CONFIG_MIGRATION) += migrate.o
 obj-$(CONFIG_TRANSPARENT_HUGEPAGE) += huge_memory.o khugepaged.o
mm/memory_hotplug.c +7 -1
index 63e5a0e9a6f3..94b0ec3d2ff2 100644
@@ -42,7 +42,13 @@
 #include "internal.h"
 #include "shuffle.h"
 
-static bool memmap_on_memory;
+
+/*
+ * memory_hotplug.memmap_on_memory parameter
+ */
+static bool memmap_on_memory __ro_after_init;
+module_param(memmap_on_memory, bool, 0444);
+MODULE_PARM_DESC(memmap_on_memory, "Enable memmap on memory for memory hotplug");
 
 /*
  * online_page_callback contains pointer to current page onlining function.
Signature · 1 line
2.16.3
Reviewed-by on v3 3/5
#7 lore raw

Re: [PATCH v3 3/5] mm,memory_hotplug: Add kernel boot option to enable memmap_on_memory

Quoted 19 lines · Oscar Salvador

Self stored memmap leads to a sparse memory situation which is unsuitable for workloads that requires large contiguous memory chunks, so make this an opt-in which needs to be explicitly enabled.

To control this, let memory_hotplug have its own memory space, as suggested by David, so we can add memory_hotplug.memmap_on_memory parameter.

---
  Documentation/admin-guide/kernel-parameters.txt | 14 ++++++++++++++
  mm/Makefile                                     |  5 ++++-
  mm/memory_hotplug.c                             |  8 +++++++-
  3 files changed, 25 insertions(+), 2 deletions(-)
Documentation/admin-guide/kernel-parameters.txt +0 -0
index 04545725f187..e626dab39c60 100644

Documentation/admin-guide/kernel-parameters.txt line 2798

Quoted 5 lines
Documentation/admin-guide/kernel-parameters.txt +2 -0
@@ -2794,6 +2794,20 @@
  			seconds.  Use this parameter to check at some
  			other rate.  0 disables periodic checking.
 
+	memory_hotplug.memmap_on_memory
+			[KNL,X86,ARM] Boolean flag to enable this feature.

Right now it can be set on any arch with memory hotplug, right? It's simply not effective.

Documentation/admin-guide/kernel-parameters.txt line 2809

Quoted 11 lines
Documentation/admin-guide/kernel-parameters.txt +11 -0
+			Format: {on | off (default)}
+			When enabled, memory to build the pages tables for the
+			memmap array describing the hot-added range will be taken
+			from the range itself, so the memmap page tables will be
+			self-hosted.
+			Since only single memory device ranges are supported at
+			the moment, this option is disabled by default because
+			it might have an impact on workloads that needs large
+			contiguous memory chunks.
+			The state of the flag can be read in
+			/sys/module/memory_hotplug/parameters/memmap_on_memory.

Maybe want to add that even if enabled, there are cases where it is not effective?

Quoted 37 lines
Documentation/admin-guide/kernel-parameters.txt +1 -0
+
  	memtest=	[KNL,X86,ARM,PPC] Enable memtest
  			Format: <integer>
  			default : 0 <disable>
mm/Makefile +4 -1
index 72227b24a616..82ae9482f5e3 100644
@@ -58,9 +58,13 @@ obj-y			:= filemap.o mempool.o oom_kill.o fadvise.o \
  page-alloc-y := page_alloc.o
  page-alloc-$(CONFIG_SHUFFLE_PAGE_ALLOCATOR) += shuffle.o
 
+# Give 'memory_hotplug' its own module-parameter namespace
+memory-hotplug-$(CONFIG_MEMORY_HOTPLUG) += memory_hotplug.o
+
  obj-y += page-alloc.o
  obj-y += init-mm.o
  obj-y += memblock.o
+obj-y += $(memory-hotplug-y)
 
  ifdef CONFIG_MMU
  	obj-$(CONFIG_ADVISE_SYSCALLS)	+= madvise.o
@@ -83,7 +87,6 @@ obj-$(CONFIG_SLUB) += slub.o
  obj-$(CONFIG_KASAN)	+= kasan/
  obj-$(CONFIG_KFENCE) += kfence/
  obj-$(CONFIG_FAILSLAB) += failslab.o
-obj-$(CONFIG_MEMORY_HOTPLUG) += memory_hotplug.o
  obj-$(CONFIG_MEMTEST)		+= memtest.o
  obj-$(CONFIG_MIGRATION) += migrate.o
  obj-$(CONFIG_TRANSPARENT_HUGEPAGE) += huge_memory.o khugepaged.o
mm/memory_hotplug.c +0 -0
index 63e5a0e9a6f3..94b0ec3d2ff2 100644
@@ -42,7 +42,13 @@
  #include "internal.h"
  #include "shuffle.h"

mm/memory_hotplug.c line 52

Quoted 10 lines
mm/memory_hotplug.c +7 -1
 
-static bool memmap_on_memory;
+
+/*
+ * memory_hotplug.memmap_on_memory parameter
+ */
+static bool memmap_on_memory __ro_after_init;
+module_param(memmap_on_memory, bool, 0444);
+MODULE_PARM_DESC(memmap_on_memory, "Enable memmap on memory for memory hotplug");
 

Wondering if this makes sense getting wrapped in

#ifdef CONFIG MHP_MEMMAP_ON_MEMORY

just a thought.

LGTM

Signature · 3 lines
Thanks,

David / dhildenb
author maintainer
#8 lore raw

Re: [PATCH v3 3/5] mm,memory_hotplug: Add kernel boot option to enable memmap_on_memory

Quoted 13 lines · David Hildenbrand

Documentation/admin-guide/kernel-parameters.txt line 2797

Quoted 9 lines · Oscar Salvador
Documentation/admin-guide/kernel-parameters.txt +2 -0
index 04545725f187..e626dab39c60 100644
@@ -2794,6 +2794,20 @@
  			seconds.  Use this parameter to check at some
  			other rate.  0 disables periodic checking.
+	memory_hotplug.memmap_on_memory
+			[KNL,X86,ARM] Boolean flag to enable this feature.

Right now it can be set on any arch with memory hotplug, right? It's simply not effective.

Right.

Quoted 6 lines
Quoted 6 lines
Documentation/admin-guide/kernel-parameters.txt +6 -0
+			Format: {on | off (default)}
+			When enabled, memory to build the pages tables for the
+			memmap array describing the hot-added range will be taken
+			from the range itself, so the memmap page tables will be
+			self-hosted.
+			Since only single memory device ranges are supported at
Quoted 8 lines

Documentation/admin-guide/kernel-parameters.txt line 2809

Quoted 5 lines
Documentation/admin-guide/kernel-parameters.txt +5 -0
+			the moment, this option is disabled by default because
+			it might have an impact on workloads that needs large
+			contiguous memory chunks.
+			The state of the flag can be read in
+			/sys/module/memory_hotplug/parameters/memmap_on_memory.

Maybe want to add that even if enabled, there are cases where it is not effective?

Sure, I already added a hint.

Quoted 9 lines

Documentation/admin-guide/kernel-parameters.txt line 2811

Quoted 3 lines
Documentation/admin-guide/kernel-parameters.txt +3 -0
+static bool memmap_on_memory __ro_after_init;
+module_param(memmap_on_memory, bool, 0444);
+MODULE_PARM_DESC(memmap_on_memory, "Enable memmap on memory for memory hotplug");

Wondering if this makes sense getting wrapped in

#ifdef CONFIG MHP_MEMMAP_ON_MEMORY

just a thought.

Definitely, will wrapp it with MHP_MEMMAP_ON_MEMORY.

Quoted 4 lines

LGTM

Thanks!

Signature · 2 lines
Oscar Salvador
SUSE L3
author maintainer
#9 lore raw

PATCH v3 4/5 x86/Kconfig: Introduce ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE

In reply to Oscar Salvador

Enable x86_64 platform to use the MHP_MEMMAP_ON_MEMORY feature.

---
 arch/x86/Kconfig | 4 ++++
 1 file changed, 4 insertions(+)
arch/x86/Kconfig +4 -0
index 2792879d398e..6d716d8bce1e 100644
@@ -2433,6 +2433,10 @@ config ARCH_ENABLE_MEMORY_HOTREMOVE
 	def_bool y
 	depends on MEMORY_HOTPLUG
 
+config ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
+	def_bool y
+	depends on X86_64 && MEMORY_HOTPLUG
+
 config USE_PERCPU_NUMA_NODE_ID
 	def_bool y
 	depends on NUMA
Signature · 1 line
2.16.3
Reviewed-by on v3 4/5
#10 lore raw

Re: [PATCH v3 4/5] x86/Kconfig: Introduce ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE

Quoted 12 lines · Oscar Salvador

Enable x86_64 platform to use the MHP_MEMMAP_ON_MEMORY feature.

---
  arch/x86/Kconfig | 4 ++++
  1 file changed, 4 insertions(+)
arch/x86/Kconfig +0 -0
index 2792879d398e..6d716d8bce1e 100644

arch/x86/Kconfig config ARCH_ENABLE_MEMORY_HOTREMOVE · line 2438

Quoted 6 lines
arch/x86/Kconfig +3 -0
@@ -2433,6 +2433,10 @@ config ARCH_ENABLE_MEMORY_HOTREMOVE
  	def_bool y
  	depends on MEMORY_HOTPLUG
 
+config ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
+	def_bool y
+	depends on X86_64 && MEMORY_HOTPLUG

Was wondering if the MEMORY_HOTPLUG would also best be part of the generic MHP_MEMMAP_ON_MEMORY.

Apart from that

Signature · 3 lines
Thanks,

David / dhildenb
author maintainer
#11 lore raw

Re: [PATCH v3 4/5] x86/Kconfig: Introduce ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE

Quoted 8 lines · David Hildenbrand
Quoted 7 lines · Oscar Salvador

Enable x86_64 platform to use the MHP_MEMMAP_ON_MEMORY feature.

---
  arch/x86/Kconfig | 4 ++++
  1 file changed, 4 insertions(+)
Quoted 13 lines

arch/x86/Kconfig config ARCH_ENABLE_MEMORY_HOTREMOVE · line 2437

Quoted 10 lines
arch/x86/Kconfig +3 -0
index 2792879d398e..6d716d8bce1e 100644
@@ -2433,6 +2433,10 @@ config ARCH_ENABLE_MEMORY_HOTREMOVE
  	def_bool y
  	depends on MEMORY_HOTPLUG
+config ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
+	def_bool y
+	depends on X86_64 && MEMORY_HOTPLUG

Was wondering if the MEMORY_HOTPLUG would also best be part of the generic MHP_MEMMAP_ON_MEMORY.

Yes, I think it suits best in the generic Kconfig.

Something like this on top of patch#1:

mm/Kconfig +2 -1
index de3a7b5ed216..febf805000f8 100644
@@ -185,7 +185,8 @@ config MEMORY_HOTREMOVE
 
 config MHP_MEMMAP_ON_MEMORY
        def_bool y
-       depends on SPARSEMEM_VMEMMAP && ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
+       depends on MEMORY_HOTPLUG && SPARSEMEM_VMEMMAP
+       depends on ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
 

And then this patch would be:

arch/x86/Kconfig +2 -0
index 2792879d398e..9f0211df1746 100644
@@ -2433,6 +2433,9 @@ config ARCH_ENABLE_MEMORY_HOTREMOVE
        def_bool y
        depends on MEMORY_HOTPLUG
 
+config ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
+       def_bool y
 

because MEMORY_HOTPLUG already depends on 64 bits.

And the same would go for the arm64 one.

Better?

Signature · 2 lines
Oscar Salvador
SUSE L3
author maintainer
#12 lore raw

PATCH v3 5/5 arm64/Kconfig: Introduce ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE

In reply to Oscar Salvador

Enable arm64 platform to use the MHP_MEMMAP_ON_MEMORY feature.

---
 arch/arm64/Kconfig | 4 ++++
 1 file changed, 4 insertions(+)
arch/arm64/Kconfig +4 -0
index 1f212b47a48a..3c5380c626df 100644
@@ -309,6 +309,10 @@ config ARCH_ENABLE_MEMORY_HOTPLUG
 config ARCH_ENABLE_MEMORY_HOTREMOVE
 	def_bool y
 
+config ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
+	def_bool y
+	depends on MEMORY_HOTPLUG
+
 config SMP
 	def_bool y
 
Signature · 1 line
2.16.3
Reviewed-by on v3 5/5
#13 lore raw

Re: [PATCH v3 5/5] arm64/Kconfig: Introduce ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE

Quoted 12 lines · Oscar Salvador

Enable arm64 platform to use the MHP_MEMMAP_ON_MEMORY feature.

---
  arch/arm64/Kconfig | 4 ++++
  1 file changed, 4 insertions(+)
arch/arm64/Kconfig +0 -0
index 1f212b47a48a..3c5380c626df 100644

arch/arm64/Kconfig config ARCH_ENABLE_MEMORY_HOTPLUG · line 315

Quoted 7 lines
arch/arm64/Kconfig +4 -0
@@ -309,6 +309,10 @@ config ARCH_ENABLE_MEMORY_HOTPLUG
  config ARCH_ENABLE_MEMORY_HOTREMOVE
  	def_bool y
 
+config ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE
+	def_bool y
+	depends on MEMORY_HOTPLUG
+

Same thoughts regarding MEMORY_HOTPLUG

Signature · 3 lines
Thanks,

David / dhildenb