implement "memmap on memory" feature on s390
Subsystems (6)
v2 cover implement "memmap on memory" feature on s390
Hi All,
The patch series implements "memmap on memory" feature on s390.
Patch 1 introduces new mhp_flag MHP_OFFLINE_INACCESSIBLE to mark memory as not accessible until memory hotplug online phase begins.
Patch 2 avoids page_init_poison() on memmap during mhp addition phase, when mhp_flag MHP_OFFLINE_INACCESSIBLE is passed over from add_memory()
Patch 3 introduces MEM_PREPARE_ONLINE/MEM_FINISH_OFFLINE memory notifiers to prepare the transition of memory to and from a physically accessible state. This enhancement is crucial for implementing the "memmap on memory" feature for s390 in a subsequent patch.
Patches 4 allocates vmemmap pages from self-contained memory range for s390. It allocates memory map (struct pages array) from the hotplugged memory range, rather than using system memory by passing altmap to vmemmap functions.
Patch 5 removes unhandled memory notifier types on s390.
Patch 6 implements MEM_PREPARE_ONLINE/MEM_FINISH_OFFLINE memory notifiers on s390. MEM_PREPARE_ONLINE memory notifier makes memory block physical accessible via sclp assign command. The notifier ensures self-contained memory maps are accessible and hence enabling the "memmap on memory" on s390. MEM_FINISH_OFFLINE memory notifier shifts the memory block to an inaccessible state via sclp unassign command
Patch 7 finally enables MHP_MEMMAP_ON_MEMORY on s390
These patches are rebased on top of three fixes:
mm: use vmem_altmap code without CONFIG_ZONE_DEVICE mm/memory_hotplug: fix error handling in add_memory_resource() mm/memory_hotplug: add missing mem_hotplug_lock
v2:
* Fixes are integrated and hence removed from this patch series Suggestions from David:
* Add new flag MHP_OFFLINE_INACCESSIBLE to avoid accessing memory during memory hotplug addition phase.
* Avoid page_init_poison() on memmap during mhp addition phase, when MHP_OFFLINE_INACCESSIBLE mhp_flag is passed in add_memory().
* Do not skip add_pages() in arch_add_memory(). Similarly, remove similar hacks in arch_remove_memory().
* Use MHP_PREPARE_ONLINE/MHP_FINISH_OFFLINE naming convention for new memory notifiers.
* Rearrange removal of unused s390 memory notifier.
* Necessary commit messages changes.
Thank you
Sumanth Korikkar (7):
mm/memory_hotplug: introduce mhp_flag MHP_OFFLINE_INACCESSIBLE mm/memory_hotplug: avoid poisoning memmap during mhp addition phase mm/memory_hotplug: introduce MEM_PREPARE_ONLINE/MEM_FINISH_OFFLINE
notifiers
s390/mm: allocate vmemmap pages from self-contained memory range s390/sclp: remove unhandled memory notifier type s390/mm: implement MEM_PREPARE_ONLINE/MEM_FINISH_OFFLINE notifiers
s390: enable MHP_MEMMAP_ON_MEMORY
arch/s390/Kconfig | 1 + arch/s390/mm/init.c | 3 -- arch/s390/mm/vmem.c | 62 +++++++++++++++++++--------------- drivers/base/memory.c | 23 +++++++++++-- drivers/s390/char/sclp_cmd.c | 31 ++++++++++++----- include/linux/memory.h | 3 ++ include/linux/memory_hotplug.h | 12 ++++++- include/linux/memremap.h | 1 + mm/memory_hotplug.c | 30 ++++++++++++++-- mm/sparse.c | 3 +- 10 files changed, 124 insertions(+), 45 deletions(-)
Signature · 1 line
2.39.2
PATCH v2 1/7 mm/memory_hotplug: introduce mhp_flag MHP_OFFLINE_INACCESSIBLE
Introduce MHP_OFFLINE_INACCESSIBLE mhp_flag to mark the hotplugged memory block as inaccessible during the memory hotplug addition phase. With support for "memmap on memory", the altmap is prepared at this stage. Architectures like s390 anticipate that memmap should not be accessed until memory is physically accessible and is accessible only when it enters the memory hotplug onlining phase using the memory notifier. Introduce the flag to inform the memory hotplug infrastructure that the memory remains inaccessible until the memory hotplug onlining phase begins.
Implementation considerations:
mhp inaccessible flag is initially set in altmap. This is useful in arch_add_memory(). When the memory block device is added, the mhp inaccessible information is passed to memory_block. The flag is used in subsequent patch to avoid accessing memmap during memory hotplug addition phase.
--- drivers/base/memory.c | 2 ++ include/linux/memory.h | 1 + include/linux/memory_hotplug.h | 10 ++++++++++ include/linux/memremap.h | 1 + mm/memory_hotplug.c | 3 ++- 5 files changed, 16 insertions(+), 1 deletion(-)
drivers/base/memory.c +2 -0
@@ -774,6 +774,8 @@ static int add_memory_block(unsigned long block_id, unsigned long state, mem->state = state; mem->nid =NUMA_NO_NODE ; mem->altmap = altmap; +if (altmap) + mem->inaccessible = altmap->inaccessible;INIT_LIST_HEAD (&mem->group_next);#ifndef CONFIG_NUMA
include/linux/memory.h +1 -0
@@ -67,6 +67,7 @@ struct memory_group {struct memory_block {unsigned long start_section_nr;unsigned long state;/* serialized by the dev->lock */ +bool inaccessible;/* during memory addition phase */ int online_type;/* for passing data to online routine */ int nid;/* NID for this memory block */ /*
include/linux/memory_hotplug.h +10 -0
@@ -106,6 +106,16 @@ typedef int __bitwise mhp_t;* implies the node id (nid). */ #define MHP_NID_IS_MGID ((__force mhp_t)BIT(2)) +/* +* Mark the hotplugged memory block as inaccessible during the memory hotplug +* addition phase. With support for "memmap on memory," the altmap is prepared +* at this stage. Architectures like s390 anticipate that memmap should not be +* accessed until memory is physically accessible and is accessible only when +* it enters the memory hotplug onlining phase using the memory notifier. +* Utilize this flag to inform the memory hotplug infrastructure that the +* memory remains inaccessible until the memory hotplug onlining phase begins. +*/ +#define MHP_OFFLINE_INACCESSIBLE ((__force mhp_t)BIT(3))/* * Extended parameters for memory hotplug:
include/linux/memremap.h +1 -0
@@ -25,6 +25,7 @@ struct vmem_altmap {unsigned long free;unsigned long align;unsigned long alloc; +bool inaccessible; };/*
mm/memory_hotplug.c +2 -1
@@ -1092,7 +1092,6 @@ int mhp_init_memmap_on_memory(unsigned long pfn, unsigned long nr_pages, ret =kasan_add_zero_shadow (__va (PFN_PHYS (pfn)),PFN_PHYS (nr_pages));if (ret)return ret; -move_pfn_range_to_zone (zone, pfn, nr_pages,NULL ,MIGRATE_UNMOVABLE );for (i =0 ; i < nr_pages; i++)
@@ -1439,6 +1438,8 @@ int __ref add_memory_resource(int nid, struct resource *res, mhp_t mhp_flags)if (mhp_flags &MHP_MEMMAP_ON_MEMORY ) {if (mhp_supports_memmap_on_memory (size)) { mhp_altmap.free =memory_block_memmap_on_memory_pages (); +if (mhp_flags &MHP_OFFLINE_INACCESSIBLE ) + mhp_altmap.inaccessible = true; params.altmap =kmalloc (sizeof (struct vmem_altmap ),GFP_KERNEL );if (!params.altmap) { ret = -ENOMEM ;
Signature · 1 line
2.39.2
Re: [PATCH v2 1/7] mm/memory_hotplug: introduce mhp_flag MHP_OFFLINE_INACCESSIBLE
Quoted 44 lines · Sumanth Korikkar
Introduce
MHP_OFFLINE_INACCESSIBLEmhp_flagto mark the hotplugged memory block as inaccessible during the memory hotplug addition phase. With support for "memmap on memory", the altmap is prepared at this stage. Architectures like s390 anticipate that memmap should not be accessed until memory is physically accessible and is accessible only when it enters the memory hotplug onlining phase using the memory notifier. Introduce the flag to inform the memory hotplug infrastructure that the memory remains inaccessible until the memory hotplug onlining phase begins.Implementation considerations:
mhp inaccessible flag is initially set in altmap. This is useful inarch_add_memory(). When the memory block device is added, the mhp inaccessible information is passed tomemory_block. The flag is used in subsequent patch to avoid accessing memmap during memory hotplug addition phase.Signed-off-by Sumanth Korikkar <[email protected]>--- drivers/base/memory.c | 2 ++ include/linux/memory.h | 1 + include/linux/memory_hotplug.h | 10 ++++++++++ include/linux/memremap.h | 1 + mm/memory_hotplug.c | 3 ++- 5 files changed, 16 insertions(+), 1 deletion(-)drivers/base/memory.c +2
-0@@ -774,6 +774,8 @@ static int add_memory_block(unsigned long block_id, unsigned long state, mem->state = state; mem->nid =NUMA_NO_NODE ; mem->altmap = altmap; +if (altmap) + mem->inaccessible = altmap->inaccessible;INIT_LIST_HEAD (&mem->group_next);#ifndef CONFIG_NUMA include/linux/memory.h +0
-0
include/linux/memory.h struct memory_group { · line 70
Quoted 4 lines
include/linux/memory.h +1
-0@@ -67,6 +67,7 @@ struct memory_group {struct memory_block {unsigned long start_section_nr;unsigned long state;/* serialized by the dev->lock */ +bool inaccessible;/* during memory addition phase */
Is that really required? After all, the altmap is stored in the memory block and accessible there.
Quoted 11 lines
include/linux/memory.h +0
-0int online_type;/* for passing data to online routine */ int nid;/* NID for this memory block */ /* include/linux/memory_hotplug.h +0
-0@@ -106,6 +106,16 @@ typedef int __bitwise mhp_t;* implies the node id (nid). */ #define MHP_NID_IS_MGID ((__force mhp_t)BIT(2))
include/linux/memory_hotplug.h typedef int __bitwise mhp_t; · line 118
Quoted 10 lines
include/linux/memory_hotplug.h +10
-0+/* +* Mark the hotplugged memory block as inaccessible during the memory hotplug +* addition phase. With support for "memmap on memory," the altmap is prepared +* at this stage. Architectures like s390 anticipate that memmap should not be +* accessed until memory is physically accessible and is accessible only when +* it enters the memory hotplug onlining phase using the memory notifier. +* Utilize this flag to inform the memory hotplug infrastructure that the +* memory remains inaccessible until the memory hotplug onlining phase begins. +*/ +#define MHP_OFFLINE_INACCESSIBLE ((__force mhp_t)BIT(3))
I'd suggest to squash all 3 patches. Then we can properly document here:
/*
* The hotplugged memory is completely inaccessible while the memory is
* offline. The memory provider will handle MEM_PREPARE_ONLINE /
* MEM_FINISH_OFFLINE notifications and make the memory accessible. *
* This flag is only relevant when used along with MHP_MEMMAP_ON_MEMORY,
* because the altmap cannot be written (e.g., poisoned) when adding
* memory -- before it is set online.
*
* This allows for adding memory with an altmap that is not currently
* made available by a hypervisor. When onlining that memory, the
* hypervisor can be instructed to make that memory available, and
* the onlining phase will not require any memory allocations, which is
* helpful in low-memory situations.
*/
Cheers,
David / dhildenb
PATCH v2 2/7 mm/memory_hotplug: avoid poisoning memmap during mhp addition phase
In reply to Sumanth KorikkarWhen memory block is marked inaccessible, avoid page_init_poison() on memmap during memory hotplug addition phase. Instead, perform it later when the memory is physically accessible in memory hotplug online phase.
When the memory block is marked accessible (by default turned on without passing any mhp_flags), page poisoning initialization on memmap is performed in sparse_add_section().
Page init poisining on memmap is performed with cond_resched(). This reflects the functionality of commit d33695b16a9f ("mm/memory_hotplug:
poison memmap in remove_pfn_range_from_zone()")
Architectures can pass MHP_OFFLINE_INACCESSIBLE mhp_flag in add_memory() to mark the memory block as initially inaccessible during memory hotplug addition phase.
--- drivers/base/memory.c | 3 ++- include/linux/memory_hotplug.h | 2 +- mm/memory_hotplug.c | 27 ++++++++++++++++++++++++++- mm/sparse.c | 3 ++- 4 files changed, 31 insertions(+), 4 deletions(-)
drivers/base/memory.c +2 -1
@@ -209,7 +209,8 @@ static int memory_block_online(struct memory_block *mem)mem_hotplug_begin ();if (nr_vmemmap_pages) { - ret =mhp_init_memmap_on_memory (start_pfn, nr_vmemmap_pages, zone); + ret =mhp_init_memmap_on_memory (start_pfn, nr_vmemmap_pages, + zone, mem->inaccessible);if (ret) goto out; }
include/linux/memory_hotplug.h +1 -1
@@ -164,7 +164,7 @@ extern void adjust_present_page_count(struct page *page, long nr_pages);/* VM interface that may be used by firmware interface */ extern int mhp_init_memmap_on_memory (unsigned long pfn,unsigned long nr_pages, -struct zone *zone); +struct zone *zone,bool mhp_off_inaccessible);extern void mhp_deinit_memmap_on_memory (unsigned long pfn,unsigned long nr_pages);extern int online_pages (unsigned long pfn,unsigned long nr_pages,struct zone *zone,struct memory_group *group);
mm/memory_hotplug.c +26 -1
@@ -1083,8 +1083,25 @@ void adjust_present_page_count(struct page *page, struct memory_group *group, group->present_kernel_pages += nr_pages; } +static void page_init_poison_with_resched (unsigned long start_pfn,unsigned long nr_pages) +{ +const unsigned long end_pfn = start_pfn + nr_pages; +unsigned long pfn, cur_nr_pages; + +/* Poison struct pages because they are now uninitialized again. */ +for (pfn = start_pfn; pfn < end_pfn; pfn += cur_nr_pages) { +cond_resched (); + +/* Select all remaining pages up to the next section boundary */ + cur_nr_pages = +min (end_pfn - pfn,SECTION_ALIGN_UP (pfn +1 ) - pfn); +page_init_poison (pfn_to_page (pfn), +sizeof (struct page ) * cur_nr_pages); + } +} +int mhp_init_memmap_on_memory (unsigned long pfn,unsigned long nr_pages, -struct zone *zone) +struct zone *zone,bool mhp_off_inaccessible) {unsigned long end_pfn = pfn + nr_pages;int ret, i;
@@ -1092,6 +1109,14 @@ int mhp_init_memmap_on_memory(unsigned long pfn, unsigned long nr_pages, ret =kasan_add_zero_shadow (__va (PFN_PHYS (pfn)),PFN_PHYS (nr_pages));if (ret)return ret; +/* +* Memory block is accessible at this stage and hence poison the struct +* pages now. If the memory block is accessible during memory hotplug +* addition phase, then page poisining is already performed in +* sparse_add_section(). +*/ +if (mhp_off_inaccessible) +page_init_poison_with_resched (pfn, nr_pages);move_pfn_range_to_zone (zone, pfn, nr_pages,NULL ,MIGRATE_UNMOVABLE );for (i =0 ; i < nr_pages; i++)
mm/sparse.c +2 -1
@@ -907,7 +907,8 @@ int __meminit sparse_add_section(int nid, unsigned long start_pfn,* Poison uninitialized struct pages in order to catch invalid flags * combinations. */ -page_init_poison (memmap,sizeof (struct page ) * nr_pages); +if (!altmap || !altmap->inaccessible) +page_init_poison (memmap,sizeof (struct page ) * nr_pages); ms =__nr_to_section (section_nr);set_section_nid (section_nr, nid);
Signature · 1 line
2.39.2
PATCH v2 3/7 mm/memory_hotplug: introduce MEM_PREPARE_ONLINE/MEM_FINISH_OFFLINE notifiers
In reply to Sumanth KorikkarIntroduce MEM_PREPARE_ONLINE/MEM_FINISH_OFFLINE memory notifiers to prepare the transition of memory to and from a physically accessible state. This enhancement is crucial for implementing the "memmap on memory" feature for s390 in a subsequent patch.
Platforms such as x86 can support physical memory hotplug via ACPI. When there is physical memory hotplug, ACPI event leads to the memory addition with the following callchain:acpi_memory_device_add()
-> acpi_memory_enable_device()
-> __add_memory()
After this, the hotplugged memory is physically accessible, and altmap support prepared, before the "memmap on memory" initialization in memory_block_online() is called.
On s390, memory hotplug works in a different way. The available hotplug memory has to be defined upfront in the hypervisor, but it is made physically accessible only when the user sets it online via sysfs, currently in the MEM_GOING_ONLINE notifier. This is too late and "memmap on memory" initialization is performed before calling MEM_GOING_ONLINE notifier.
During the memory hotplug addition phase, altmap support is prepared (but not yet accessed) and during the memory onlining phase s390 requires memory to be physically accessible and then subsequently initiate the "memmap on memory" initialization process.
The new MEM_PREPARE_ONLINE notifier allows to work around the problem, by providing a hook to prepare the memory and make it physically accessible. Similarly, the MEM_FINISH_OFFLINE notifier allows to make the memory physically inaccessible at the end of memory_block_offline().
All architectures ignore unknown memory notifiers, so this patch should not introduce any functional changes.
--- drivers/base/memory.c | 18 +++++++++++++++++- include/linux/memory.h | 2 ++ 2 files changed, 19 insertions(+), 1 deletion(-)
drivers/base/memory.c +17 -1
@@ -188,6 +188,7 @@ static int memory_block_online(struct memory_block *mem)unsigned long start_pfn =section_nr_to_pfn (mem->start_section_nr);unsigned long nr_pages =PAGES_PER_SECTION * sections_per_block;unsigned long nr_vmemmap_pages =0 ; +struct memory_notify arg;struct zone *zone;int ret;
@@ -197,6 +198,14 @@ static int memory_block_online(struct memory_block *mem) zone =zone_for_pfn_range (mem->online_type, mem->nid, mem->group, start_pfn, nr_pages); + arg.start_pfn = start_pfn; + arg.nr_pages = nr_pages; +mem_hotplug_begin (); + ret =memory_notify (MEM_PREPARE_ONLINE , &arg); + ret =notifier_to_errno (ret); +if (ret) + goto out_notifier; +/* * Although vmemmap pages have a different lifecycle than the pages * they describe (they remain until the memory is unplugged), doing
@@ -207,7 +216,6 @@ static int memory_block_online(struct memory_block *mem)if (mem->altmap) nr_vmemmap_pages = mem->altmap->free; -mem_hotplug_begin ();if (nr_vmemmap_pages) { ret =mhp_init_memmap_on_memory (start_pfn, nr_vmemmap_pages, zone, mem->inaccessible);
@@ -232,7 +240,11 @@ static int memory_block_online(struct memory_block *mem) nr_vmemmap_pages); mem->zone = zone; +mem_hotplug_done (); +return ret; out: +memory_notify (MEM_FINISH_OFFLINE , &arg); +out_notifier:mem_hotplug_done ();return ret; }
@@ -245,6 +257,7 @@ static int memory_block_offline(struct memory_block *mem)unsigned long start_pfn =section_nr_to_pfn (mem->start_section_nr);unsigned long nr_pages =PAGES_PER_SECTION * sections_per_block;unsigned long nr_vmemmap_pages =0 ; +struct memory_notify arg;int ret;if (!mem->zone)
@@ -276,6 +289,9 @@ static int memory_block_offline(struct memory_block *mem)mhp_deinit_memmap_on_memory (start_pfn, nr_vmemmap_pages); mem->zone =NULL ; + arg.start_pfn = start_pfn; + arg.nr_pages = nr_pages; +memory_notify (MEM_FINISH_OFFLINE , &arg); out:mem_hotplug_done ();return ret;
include/linux/memory.h +2 -0
@@ -97,6 +97,8 @@ int set_memory_block_size_order(unsigned int order);#define MEM_GOING_ONLINE (1<<3)#define MEM_CANCEL_ONLINE (1<<4)#define MEM_CANCEL_OFFLINE (1<<5) +#define MEM_PREPARE_ONLINE (1<<6) +#define MEM_FINISH_OFFLINE (1<<7)struct memory_notify {unsigned long start_pfn;
Signature · 1 line
2.39.2
PATCH v2 4/7 s390/mm: allocate vmemmap pages from self-contained memory range
In reply to Sumanth KorikkarAllocate memory map (struct pages array) from the hotplugged memory range, rather than using system memory. The change addresses the issue where standby memory, when configured to be much larger than online memory, could potentially lead to ipl failure due to memory map allocation from online memory. For example, 16MB of memory map allocation is needed for a memory block size of 1GB and when standby memory is configured much larger than online memory, this could lead to ipl failure.
To address this issue, the solution involves introducing "memmap on memory" using the vmem_altmap structure on s390. Architectures that want to implement it should pass the altmap to the vmemmap_populate() function and its associated callchain. This enhancement is discussed in the commit 4b94ffdc4163 ("x86, mm: introduce vmem_altmap to augment vmemmap_populate()").
Provide "memmap on memory" support for s390 by passing the altmap in vmemmap_populate() and its callchain. The allocation path is described as follows:
* When altmap is NULL in vmemmap_populate(), memory map allocation occurs using the existing vmemmap_alloc_block_buf().
* When altmap is not NULL in vmemmap_populate(), memory map allocation still uses vmemmap_alloc_block_buf(), but this function internally calls altmap_alloc_block_buf().
For deallocation, the process is outlined as follows:
* When altmap is NULL in vmemmap_free(), memory map deallocation happens through free_pages().
* When altmap is not NULL in vmemmap_free(), memory map deallocation occurs via vmem_altmap_free().
While memory map allocation is primarily handled through the self-contained memory map range, there might still be a small amount of system memory allocation required for vmemmap pagetables. To mitigate this impact, this feature will be limited to machines with EDAT1 support.
--- arch/s390/mm/init.c | 3 --- arch/s390/mm/vmem.c | 62 +++++++++++++++++++++++++-------------------- 2 files changed, 35 insertions(+), 30 deletions(-)
arch/s390/mm/init.c +0 -3
@@ -281,9 +281,6 @@ int arch_add_memory(int nid, u64 start, u64 size,unsigned long size_pages =PFN_DOWN (size);int rc; -if (WARN_ON_ONCE (params->altmap)) -return -EINVAL ; -if (WARN_ON_ONCE (params->pgprot.pgprot !=PAGE_KERNEL .pgprot))return -EINVAL ;
arch/s390/mm/vmem.c +35 -27
194 lines not on this page · raw message
Signature · 1 line
2.39.2
PATCH v2 5/7 s390/sclp: remove unhandled memory notifier type
In reply to Sumanth KorikkarRemove memory notifier types which are unhandled by s390. Unhandled memory notifier types are covered by default case.
--- drivers/s390/char/sclp_cmd.c | 3 --- 1 file changed, 3 deletions(-)
drivers/s390/char/sclp_cmd.c +0 -3
@@ -340,9 +340,6 @@ static int sclp_mem_notifier(struct notifier_block *nb,if (contains_standby_increment (start, start + size)) rc = -EPERM ;break ; -case MEM_ONLINE : -case MEM_CANCEL_OFFLINE : -break ;case MEM_GOING_ONLINE : rc =sclp_mem_change_state (start, size,1 );break ;
Signature · 1 line
2.39.2
PATCH v2 6/7 s390/mm: implement MEM_PREPARE_ONLINE/MEM_FINISH_OFFLINE notifiers
In reply to Sumanth KorikkarMEM_PREPARE_ONLINE memory notifier makes memory block physical accessible via sclp assign command. The notifier ensures self-contained memory maps are accessible and hence enabling the "memmap on memory" on s390.
MEM_FINISH_OFFLINE memory notifier shifts the memory block to an inaccessible state via sclp unassign command.
Implementation considerations:
* When MHP_MEMMAP_ON_MEMORY is disabled, the system retains the old behavior. This means the memory map is allocated from default memory.
* If MACHINE_HAS_EDAT1 is unavailable, MHP_MEMMAP_ON_MEMORY is automatically disabled. This ensures that vmemmap pagetables do not consume additional memory from the default memory allocator.
* The MEM_GOING_ONLINE notifier has been modified to perform no operation, as MEM_PREPARE_ONLINE already executes the sclp assign command.
* The MEM_CANCEL_ONLINE/MEM_OFFLINE notifier now performs no operation, as MEM_FINISH_OFFLINE already executes the sclp unassign command.
--- drivers/s390/char/sclp_cmd.c | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-)
drivers/s390/char/sclp_cmd.c +22 -6
@@ -18,6 +18,7 @@#include <linux/mm.h> #include <linux/mmzone.h> #include <linux/memory.h> +#include <linux/memory_hotplug.h> #include <linux/module.h> #include <asm/ctlreg.h> #include <asm/chpid.h>
@@ -26,6 +27,7 @@#include <asm/sclp.h> #include <asm/numa.h> #include <asm/facility.h> +#include <asm/page-states.h> #include "sclp.h"
@@ -319,6 +321,7 @@ static bool contains_standby_increment(unsigned long start, unsigned long end)static int sclp_mem_notifier (struct notifier_block *nb,unsigned long action,void *data) { +struct memory_block *memory_block;unsigned long start, size;struct memory_notify *arg;unsigned char id;
@@ -340,18 +343,29 @@ static int sclp_mem_notifier(struct notifier_block *nb,if (contains_standby_increment (start, start + size)) rc = -EPERM ;break ; -case MEM_GOING_ONLINE : +case MEM_PREPARE_ONLINE : + memory_block =find_memory_block (pfn_to_section_nr (arg->start_pfn)); +if (!memory_block) { + rc = -EINVAL ; + goto out; + } rc =sclp_mem_change_state (start, size,1 ); +if (rc || !memory_block->altmap) + goto out; +/* +* Set CMMA state to nodat here, since the struct page memory +* at the beginning of the memory block will not go through the +* buddy allocator later. +*/ +__arch_set_page_nodat ((void *)__va (start), memory_block->altmap->free);break ; -case MEM_CANCEL_ONLINE : -sclp_mem_change_state (start, size,0 ); -break ; -case MEM_OFFLINE : +case MEM_FINISH_OFFLINE :sclp_mem_change_state (start, size,0 );break ;default :break ; } +out:mutex_unlock (&sclp_mem_mutex);return rc ?NOTIFY_BAD :NOTIFY_OK ; }
@@ -397,7 +411,9 @@ static void __init add_memory_merged(u16 rn)if (!size) goto skip_add;for (addr = start; addr < start + size; addr += block_size) -add_memory (0 , addr, block_size,MHP_NONE ); +add_memory (0 , addr, block_size, +MACHINE_HAS_EDAT1 ? +MHP_MEMMAP_ON_MEMORY |MHP_OFFLINE_INACCESSIBLE :MHP_NONE ); skip_add: first_rn = rn; num =1 ;
Signature · 1 line
2.39.2
PATCH v2 7/7 s390: enable MHP_MEMMAP_ON_MEMORY
In reply to Sumanth KorikkarEnable MHP_MEMMAP_ON_MEMORY to support "memmap on memory". memory_hotplug.memmap_on_memory=true kernel parameter should be set in kernel boot option to enable the feature.
--- arch/s390/Kconfig | 1 + 1 file changed, 1 insertion(+)
arch/s390/Kconfig +1 -0
@@ -113,6 +113,7 @@ config S390 select ARCH_INLINE_WRITE_UNLOCK_BH select ARCH_INLINE_WRITE_UNLOCK_IRQ select ARCH_INLINE_WRITE_UNLOCK_IRQRESTORE + select ARCH_MHP_MEMMAP_ON_MEMORY_ENABLE select ARCH_STACKWALK select ARCH_SUPPORTS_ATOMIC_RMW select ARCH_SUPPORTS_DEBUG_PAGEALLOC
Signature · 1 line
2.39.2