+ mm-hugetlb-split-hugetlb_cma-in-nodes-with-memory.patch added to -mm tree

+ mm-hugetlb-split-hugetlb_cma-in-nodes-with-memory.patch added to -mm tree

[akpm]

The patch titled
     Subject: mm/hugetlb: split hugetlb_cma in nodes with memory
has been added to the -mm tree.  Its filename is
     mm-hugetlb-split-hugetlb_cma-in-nodes-with-memory.patch

This patch should soon appear at
    http://ozlabs.org/~akpm/mmots/broken-out/mm-hugetlb-split-hugetlb_cma-in-nodes-with-memory.patch
and later at
    http://ozlabs.org/~akpm/mmotm/broken-out/mm-hugetlb-split-hugetlb_cma-in-nodes-with-memory.patch

Before you just go and hit "reply", please:
   a) Consider who else should be cc'ed
   b) Prefer to cc a suitable mailing list as well
   c) Ideally: find the original patch on the mailing list and do a
      reply-to-all to that, adding suitable additional cc's

*** Remember to use Documentation/process/submit-checklist.rst when testing your code ***

The -mm tree is included into linux-next and is updated
there every 3-4 working days

------------------------------------------------------
From: Barry Song <song.bao.hua@hisilicon.com>
Subject: mm/hugetlb: split hugetlb_cma in nodes with memory

Online nodes are not necessarily memory containing nodes.  Splitting
huge_cma in online nodes can lead to inconsistent hugetlb_cma size with
user setting.  For example, for one system with 4 numa nodes and only one
of them has memory, if users set hugetlb_cma to 4GB, it will split into
four 1GB.  So only the node with memory will get 1GB CMA.  All other three
nodes get nothing.  That means the whole system gets only 1GB CMA while
users ask for 4GB.

Thus, it is more sensible to split hugetlb_cma in nodes with memory.  For
the above case, the only node with memory will reserve 4GB cma which is
same with user setting in bootargs.  In order to split cma in nodes with
memory, hugetlb_cma_reserve() should scan over those nodes with N_MEMORY
state rather than N_ONLINE state.  That means the function should be
called only after arch code has finished setting the N_MEMORY state of
nodes.

The problem is always there if N_ONLINE != N_MEMORY.  It is a general
problem to all platforms.  But there is some trivial difference among
different architectures.  For example, for ARM64, before
hugetlb_cma_reserve() is called, all nodes have got N_ONLINE state.  So
hugetlb will get inconsistent cma size when some online nodes have no
memory.  For x86 case, the problem is hidden because X86 happens to just
set N_ONLINE on the nodes with memory when hugetlb_cma_reserve() is
called.

Anyway, this patch moves to scan N_MEMORY in hugetlb_cma_reserve() and
lets both x86 and ARM64 call the function after N_MEMORY state is ready. 
It also documents the requirement in the definition of
hugetlb_cma_reserve().

Link: http://lkml.kernel.org/r/20200710120950.37716-1-song.bao.hua@hisilicon.com
Signed-off-by: Barry Song <song.bao.hua@hisilicon.com>
Cc: Roman Gushchin <guro@fb.com>
Cc: Catalin Marinas <catalin.marinas@arm.com>
Cc: Will Deacon <will@kernel.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Borislav Petkov <bp@alien8.de>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Mike Kravetz <mike.kravetz@oracle.com>
Cc: Mike Rapoport <rppt@linux.ibm.com>
Cc: Anshuman Khandual <anshuman.khandual@arm.com>
Cc: Jonathan Cameron <jonathan.cameron@huawei.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
---

 arch/arm64/mm/init.c    |   19 ++++++++++---------
 arch/x86/kernel/setup.c |   12 +++++++++---
 mm/hugetlb.c            |   11 +++++++++--
 3 files changed, 28 insertions(+), 14 deletions(-)

--- a/arch/arm64/mm/init.c~mm-hugetlb-split-hugetlb_cma-in-nodes-with-memory
+++ a/arch/arm64/mm/init.c
@@ -421,15 +421,6 @@ void __init bootmem_init(void)
 	arm64_numa_init();
 
 	/*
-	 * must be done after arm64_numa_init() which calls numa_init() to
-	 * initialize node_online_map that gets used in hugetlb_cma_reserve()
-	 * while allocating required CMA size across online nodes.
-	 */
-#ifdef CONFIG_ARM64_4K_PAGES
-	hugetlb_cma_reserve(PUD_SHIFT - PAGE_SHIFT);
-#endif
-
-	/*
 	 * Sparsemem tries to allocate bootmem in memory_present(), so must be
 	 * done after the fixed reservations.
 	 */
@@ -438,6 +429,16 @@ void __init bootmem_init(void)
 	sparse_init();
 	zone_sizes_init(min, max);
 
+	/*
+	 * must be done after zone_sizes_init() which calls free_area_init()
+	 * that calls node_set_state() to initialize node_states[N_MEMORY]
+	 * because hugetlb_cma_reserve() will scan over nodes with N_MEMORY
+	 * state
+	 */
+#ifdef CONFIG_ARM64_4K_PAGES
+	hugetlb_cma_reserve(PUD_SHIFT - PAGE_SHIFT);
+#endif
+
 	memblock_dump_all();
 }
 
--- a/arch/x86/kernel/setup.c~mm-hugetlb-split-hugetlb_cma-in-nodes-with-memory
+++ a/arch/x86/kernel/setup.c
@@ -1164,9 +1164,6 @@ void __init setup_arch(char **cmdline_p)
 	initmem_init();
 	dma_contiguous_reserve(max_pfn_mapped << PAGE_SHIFT);
 
-	if (boot_cpu_has(X86_FEATURE_GBPAGES))
-		hugetlb_cma_reserve(PUD_SHIFT - PAGE_SHIFT);
-
 	/*
 	 * Reserve memory for crash kernel after SRAT is parsed so that it
 	 * won't consume hotpluggable memory.
@@ -1180,6 +1177,15 @@ void __init setup_arch(char **cmdline_p)
 
 	x86_init.paging.pagetable_init();
 
+	/*
+	 * must be done after zone_sizes_init() which calls free_area_init()
+	 * that calls node_set_state() to initialize node_states[N_MEMORY]
+	 * because hugetlb_cma_reserve() will scan over nodes with N_MEMORY
+	 * state
+	 */
+	if (boot_cpu_has(X86_FEATURE_GBPAGES))
+		hugetlb_cma_reserve(PUD_SHIFT - PAGE_SHIFT);
+
 	kasan_init();
 
 	/*
--- a/mm/hugetlb.c~mm-hugetlb-split-hugetlb_cma-in-nodes-with-memory
+++ a/mm/hugetlb.c
@@ -5680,6 +5680,13 @@ static int __init cmdline_parse_hugetlb_
 
 early_param("hugetlb_cma", cmdline_parse_hugetlb_cma);
 
+/*
+ * hugetlb_cma_reserve() - reserve CMA for gigantic pages on nodes with memory
+ *
+ * must be called after free_area_init() that updates N_MEMORY via node_set_state().
+ * hugetlb_cma_reserve() scans over N_MEMORY nodemask and hence expects the platforms
+ * to have initialized N_MEMORY state.
+ */
 void __init hugetlb_cma_reserve(int order)
 {
 	unsigned long size, reserved, per_node;
@@ -5700,12 +5707,12 @@ void __init hugetlb_cma_reserve(int orde
 	 * If 3 GB area is requested on a machine with 4 numa nodes,
 	 * let's allocate 1 GB on first three nodes and ignore the last one.
 	 */
-	per_node = DIV_ROUND_UP(hugetlb_cma_size, nr_online_nodes);
+	per_node = DIV_ROUND_UP(hugetlb_cma_size, num_node_state(N_MEMORY));
 	pr_info("hugetlb_cma: reserve %lu MiB, up to %lu MiB per node\n",
 		hugetlb_cma_size / SZ_1M, per_node / SZ_1M);
 
 	reserved = 0;
-	for_each_node_state(nid, N_ONLINE) {
+	for_each_node_state(nid, N_MEMORY) {
 		int res;
 
 		size = min(per_node, hugetlb_cma_size - reserved);
_

Patches currently in -mm which might be from song.bao.hua@hisilicon.com are

mm-hugetlb-avoid-hardcoding-while-checking-if-cma-is-enable.patch
mm-hugetlb-split-hugetlb_cma-in-nodes-with-memory.patch
mm-cma-fix-the-name-of-cma-areas.patch
mm-hugetlb-fix-the-name-of-hugetlb-cma.patch