Commit 01a178a9 authored by Tang Chen's avatar Tang Chen Committed by Linus Torvalds

acpi, memory-hotplug: support getting hotplug info from SRAT

We now provide an option for users who don't want to specify physical
memory address in kernel commandline.

         /*
          * For movablemem_map=acpi:
          *
          * SRAT:                |_____| |_____| |_________| |_________| ......
          * node id:                0       1         1           2
          * hotpluggable:           n       y         y           n
          * movablemem_map:              |_____| |_________|
          *
          * Using movablemem_map, we can prevent memblock from allocating memory
          * on ZONE_MOVABLE at boot time.
          */

So user just specify movablemem_map=acpi, and the kernel will use
hotpluggable info in SRAT to determine which memory ranges should be set
as ZONE_MOVABLE.

If all the memory ranges in SRAT is hotpluggable, then no memory can be
used by kernel.  But before parsing SRAT, memblock has already reserve
some memory ranges for other purposes, such as for kernel image, and so
on.  We cannot prevent kernel from using these memory.  So we need to
exclude these ranges even if these memory is hotpluggable.

Furthermore, there could be several memory ranges in the single node
which the kernel resides in.  We may skip one range that have memory
reserved by memblock, but if the rest of memory is too small, then the
kernel will fail to boot.  So, make the whole node which the kernel
resides in un-hotpluggable.  Then the kernel has enough memory to use.

NOTE: Using this way will cause NUMA performance down because the
      whole node will be set as ZONE_MOVABLE, and kernel cannot use memory
      on it.  If users don't want to lose NUMA performance, just don't use
      it.

[akpm@linux-foundation.org: fix warning]
[akpm@linux-foundation.org: use strcmp()]
Signed-off-by: default avatarTang Chen <tangchen@cn.fujitsu.com>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Jiang Liu <jiang.liu@huawei.com>
Cc: Jianguo Wu <wujianguo@huawei.com>
Cc: Kamezawa Hiroyuki <kamezawa.hiroyu@jp.fujitsu.com>
Cc: Lai Jiangshan <laijs@cn.fujitsu.com>
Cc: Wu Jianguo <wujianguo@huawei.com>
Cc: Yasuaki Ishimatsu <isimatu.yasuaki@jp.fujitsu.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: "H. Peter Anvin" <hpa@zytor.com>
Cc: Len Brown <lenb@kernel.org>
Cc: "Brown, Len" <len.brown@intel.com>
Signed-off-by: default avatarAndrew Morton <akpm@linux-foundation.org>
Signed-off-by: default avatarLinus Torvalds <torvalds@linux-foundation.org>
parent 27168d38
...@@ -1640,15 +1640,30 @@ bytes respectively. Such letter suffixes can also be entirely omitted. ...@@ -1640,15 +1640,30 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
that the amount of memory usable for all allocations that the amount of memory usable for all allocations
is not too small. is not too small.
movablemem_map=acpi
[KNL,X86,IA-64,PPC] This parameter is similar to
memmap except it specifies the memory map of
ZONE_MOVABLE.
This option inform the kernel to use Hot Pluggable bit
in flags from SRAT from ACPI BIOS to determine which
memory devices could be hotplugged. The corresponding
memory ranges will be set as ZONE_MOVABLE.
NOTE: Whatever node the kernel resides in will always
be un-hotpluggable.
movablemem_map=nn[KMG]@ss[KMG] movablemem_map=nn[KMG]@ss[KMG]
[KNL,X86,IA-64,PPC] This parameter is similar to [KNL,X86,IA-64,PPC] This parameter is similar to
memmap except it specifies the memory map of memmap except it specifies the memory map of
ZONE_MOVABLE. ZONE_MOVABLE.
If more areas are all within one node, then from If user specifies memory ranges, the info in SRAT will
lowest ss to the end of the node will be ZONE_MOVABLE. be ingored. And it works like the following:
If an area covers two or more nodes, the area from - If more ranges are all within one node, then from
ss to the end of the 1st node will be ZONE_MOVABLE, lowest ss to the end of the node will be ZONE_MOVABLE.
and all the rest nodes will only have ZONE_MOVABLE. - If a range is within a node, then from ss to the end
of the node will be ZONE_MOVABLE.
- If a range covers two or more nodes, then from ss to
the end of the 1st node will be ZONE_MOVABLE, and all
the rest nodes will only have ZONE_MOVABLE.
If memmap is specified at the same time, the If memmap is specified at the same time, the
movablemem_map will be limited within the memmap movablemem_map will be limited within the memmap
areas. If kernelcore or movablecore is also specified, areas. If kernelcore or movablecore is also specified,
...@@ -1656,6 +1671,10 @@ bytes respectively. Such letter suffixes can also be entirely omitted. ...@@ -1656,6 +1671,10 @@ bytes respectively. Such letter suffixes can also be entirely omitted.
satisfied. So the administrator should be careful that satisfied. So the administrator should be careful that
the amount of movablemem_map areas are not too large. the amount of movablemem_map areas are not too large.
Otherwise kernel won't have enough memory to start. Otherwise kernel won't have enough memory to start.
NOTE: We don't stop users specifying the node the
kernel resides in as hotpluggable so that this
option can be used as a workaround of firmware
bugs.
MTD_Partition= [MTD] MTD_Partition= [MTD]
Format: <name>,<region-number>,<size>,<offset> Format: <name>,<region-number>,<size>,<offset>
......
...@@ -142,16 +142,72 @@ static inline int save_add_info(void) {return 0;} ...@@ -142,16 +142,72 @@ static inline int save_add_info(void) {return 0;}
#endif #endif
#ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
static void __init handle_movablemem(int node, u64 start, u64 end) static void __init
handle_movablemem(int node, u64 start, u64 end, u32 hotpluggable)
{ {
int overlap; int overlap, i;
unsigned long start_pfn, end_pfn; unsigned long start_pfn, end_pfn;
start_pfn = PFN_DOWN(start); start_pfn = PFN_DOWN(start);
end_pfn = PFN_UP(end); end_pfn = PFN_UP(end);
/* /*
* For movablecore_map=nn[KMG]@ss[KMG]: * For movablemem_map=acpi:
*
* SRAT: |_____| |_____| |_________| |_________| ......
* node id: 0 1 1 2
* hotpluggable: n y y n
* movablemem_map: |_____| |_________|
*
* Using movablemem_map, we can prevent memblock from allocating memory
* on ZONE_MOVABLE at boot time.
*
* Before parsing SRAT, memblock has already reserve some memory ranges
* for other purposes, such as for kernel image. We cannot prevent
* kernel from using these memory, so we need to exclude these memory
* even if it is hotpluggable.
* Furthermore, to ensure the kernel has enough memory to boot, we make
* all the memory on the node which the kernel resides in
* un-hotpluggable.
*/
if (hotpluggable && movablemem_map.acpi) {
/* Exclude ranges reserved by memblock. */
struct memblock_type *rgn = &memblock.reserved;
for (i = 0; i < rgn->cnt; i++) {
if (end <= rgn->regions[i].base ||
start >= rgn->regions[i].base +
rgn->regions[i].size)
continue;
/*
* If the memory range overlaps the memory reserved by
* memblock, then the kernel resides in this node.
*/
node_set(node, movablemem_map.numa_nodes_kernel);
goto out;
}
/*
* If the kernel resides in this node, then the whole node
* should not be hotpluggable.
*/
if (node_isset(node, movablemem_map.numa_nodes_kernel))
goto out;
insert_movablemem_map(start_pfn, end_pfn);
/*
* numa_nodes_hotplug nodemask represents which nodes are put
* into movablemem_map.map[].
*/
node_set(node, movablemem_map.numa_nodes_hotplug);
goto out;
}
/*
* For movablemem_map=nn[KMG]@ss[KMG]:
* *
* SRAT: |_____| |_____| |_________| |_________| ...... * SRAT: |_____| |_____| |_________| |_________| ......
* node id: 0 1 1 2 * node id: 0 1 1 2
...@@ -160,6 +216,8 @@ static void __init handle_movablemem(int node, u64 start, u64 end) ...@@ -160,6 +216,8 @@ static void __init handle_movablemem(int node, u64 start, u64 end)
* *
* Using movablemem_map, we can prevent memblock from allocating memory * Using movablemem_map, we can prevent memblock from allocating memory
* on ZONE_MOVABLE at boot time. * on ZONE_MOVABLE at boot time.
*
* NOTE: In this case, SRAT info will be ingored.
*/ */
overlap = movablemem_map_overlap(start_pfn, end_pfn); overlap = movablemem_map_overlap(start_pfn, end_pfn);
if (overlap >= 0) { if (overlap >= 0) {
...@@ -187,9 +245,12 @@ static void __init handle_movablemem(int node, u64 start, u64 end) ...@@ -187,9 +245,12 @@ static void __init handle_movablemem(int node, u64 start, u64 end)
*/ */
insert_movablemem_map(start_pfn, end_pfn); insert_movablemem_map(start_pfn, end_pfn);
} }
out:
return;
} }
#else /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */ #else /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
static inline void handle_movablemem(int node, u64 start, u64 end) static inline void
handle_movablemem(int node, u64 start, u64 end, u32 hotpluggable)
{ {
} }
#endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */ #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
...@@ -234,7 +295,7 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma) ...@@ -234,7 +295,7 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
(unsigned long long) start, (unsigned long long) end - 1, (unsigned long long) start, (unsigned long long) end - 1,
hotpluggable ? "Hot Pluggable": ""); hotpluggable ? "Hot Pluggable": "");
handle_movablemem(node, start, end); handle_movablemem(node, start, end, hotpluggable);
return 0; return 0;
out_err_bad_srat: out_err_bad_srat:
......
...@@ -1366,9 +1366,11 @@ struct movablemem_entry { ...@@ -1366,9 +1366,11 @@ struct movablemem_entry {
}; };
struct movablemem_map { struct movablemem_map {
bool acpi; /* true if using SRAT info */
int nr_map; int nr_map;
struct movablemem_entry map[MOVABLEMEM_MAP_MAX]; struct movablemem_entry map[MOVABLEMEM_MAP_MAX];
nodemask_t numa_nodes_hotplug; /* on which nodes we specify memory */ nodemask_t numa_nodes_hotplug; /* on which nodes we specify memory */
nodemask_t numa_nodes_kernel; /* on which nodes kernel resides in */
}; };
extern void __init insert_movablemem_map(unsigned long start_pfn, extern void __init insert_movablemem_map(unsigned long start_pfn,
......
...@@ -203,7 +203,10 @@ static unsigned long __meminitdata dma_reserve; ...@@ -203,7 +203,10 @@ static unsigned long __meminitdata dma_reserve;
#ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
/* Movable memory ranges, will also be used by memblock subsystem. */ /* Movable memory ranges, will also be used by memblock subsystem. */
struct movablemem_map movablemem_map; struct movablemem_map movablemem_map = {
.acpi = false,
.nr_map = 0,
};
static unsigned long __meminitdata arch_zone_lowest_possible_pfn[MAX_NR_ZONES]; static unsigned long __meminitdata arch_zone_lowest_possible_pfn[MAX_NR_ZONES];
static unsigned long __meminitdata arch_zone_highest_possible_pfn[MAX_NR_ZONES]; static unsigned long __meminitdata arch_zone_highest_possible_pfn[MAX_NR_ZONES];
...@@ -5314,6 +5317,23 @@ static int __init cmdline_parse_movablemem_map(char *p) ...@@ -5314,6 +5317,23 @@ static int __init cmdline_parse_movablemem_map(char *p)
if (!p) if (!p)
goto err; goto err;
if (!strcmp(p, "acpi"))
movablemem_map.acpi = true;
/*
* If user decide to use info from BIOS, all the other user specified
* ranges will be ingored.
*/
if (movablemem_map.acpi) {
if (movablemem_map.nr_map) {
memset(movablemem_map.map, 0,
sizeof(struct movablemem_entry)
* movablemem_map.nr_map);
movablemem_map.nr_map = 0;
}
return 0;
}
oldp = p; oldp = p;
mem_size = memparse(p, &p); mem_size = memparse(p, &p);
if (p == oldp) if (p == oldp)
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment