mm: cma: NUMA node interface

With introduction of numa node interface for CMA, this patch is for using that interface for allocating memory on numa nodes if NUMA is configured. This will be more efficient and cleaner because first, instead of iterating mem range of each numa node, cma_declare_contigueous_nid() will do its own address finding if we pass 0 for both min_pfn and max_pfn, second, it can also handle caseswhere NUMA is not configured
by passing NUMA_NO_NODE as an argument.

In addition, checking if desired size of memory is available or not, is happening in cma_declare_contiguous_nid() because base and limit will be determined there, since 0(any) for base and 0(any) for limit is passed as argument to the function.

Signed-off-by Aslan Bakirov <[email protected]>

---
 mm/hugetlb.c | 40 +++++++++++-----------------------------
 1 file changed, 11 insertions(+), 29 deletions(-)

mm/hugetlb.c +11 -29

index b9f0c903c4cf..62989220c4ff 100644
@@ -5573,42 +5573,24 @@ void __init hugetlb_cma_reserve(int order)
 
 	reserved = 0;
 	for_each_node_state(nid, N_ONLINE) {
-		unsigned long min_pfn = 0, max_pfn = 0;
 		int res;
-#ifdef CONFIG_NUMA
-		unsigned long start_pfn, end_pfn;
-		int i;
 
-		for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, NULL) {
-			if (!min_pfn)
-				min_pfn = start_pfn;
-			max_pfn = end_pfn;
-		}
-#else
-		min_pfn = min_low_pfn;
-		max_pfn = max_low_pfn;
-#endif
 		size = min(per_node, hugetlb_cma_size - reserved);
 		size = round_up(size, PAGE_SIZE << order);
-
-		if (size > ((max_pfn - min_pfn) << PAGE_SHIFT) / 2) {
-			pr_warn("hugetlb_cma: cma_area is too big, please try less than %lu MiB\n",
-				round_down(((max_pfn - min_pfn) << PAGE_SHIFT) *
-					   nr_online_nodes / 2 / SZ_1M,
-					   PAGE_SIZE << order));
-			break;
-		}
-
-		res = cma_declare_contiguous(PFN_PHYS(min_pfn), size,
-					     PFN_PHYS(max_pfn),
+		
+		
+#ifndef CONFIG_NUMA
+		nid = NUMA_NO_NODE
+#endif		
+		res = cma_declare_contiguous_nid(0, size,
+					     0, 
 					     PAGE_SIZE << order,
 					     0, false,
-					     "hugetlb", &hugetlb_cma[nid]);
+					     "hugetlb", &hugetlb_cma[nid], nid);		
+
 		if (res) {
-			phys_addr_t begpa = PFN_PHYS(min_pfn);
-			phys_addr_t endpa = PFN_PHYS(max_pfn);
-			pr_warn("%s: reservation failed: err %d, node %d, [%pap, %pap)\n",
-				__func__, res, nid, &begpa, &endpa);
+			pr_warn("%s: reservation failed: err %d, node %d\n",
+				__func__, res, nid);
 			break;
 		}
 

Signature · 1 line

2.17.1

Quoted 8 lines · Aslan Bakirov

With introduction of numa node interface for CMA, this patch is for using that interface for allocating memory on numa nodes if NUMA is configured. This will be more efficient and cleaner because first, instead of iterating mem range of each numa node, cma_declare_contigueous_nid() will do its own address finding if we pass 0 for both min_pfn and max_pfn, second, it can also handle caseswhere NUMA is not configured
by passing NUMA_NO_NODE as an argument.

Quoted 4 lines

In addition, checking if desired size of memory is available or not, is happening in cma_declare_contiguous_nid() because base and limit will be determined there, since 0(any) for base and 0(any) for limit is passed as argument to the function.

This looks much better than the original patch. Can we simply squash your and Roman's patch in the mmotm tree and post it for the review in one piece? It would be slightly easier to review that way.

Quoted 2 lines

Signed-off-by Aslan Bakirov <[email protected]>

Thanks!

Quoted 64 lines

---
 mm/hugetlb.c | 40 +++++++++++-----------------------------
 1 file changed, 11 insertions(+), 29 deletions(-)

mm/hugetlb.c +11 -29

index b9f0c903c4cf..62989220c4ff 100644
@@ -5573,42 +5573,24 @@ void __init hugetlb_cma_reserve(int order)
 
 	reserved = 0;
 	for_each_node_state(nid, N_ONLINE) {
-		unsigned long min_pfn = 0, max_pfn = 0;
 		int res;
-#ifdef CONFIG_NUMA
-		unsigned long start_pfn, end_pfn;
-		int i;
 
-		for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, NULL) {
-			if (!min_pfn)
-				min_pfn = start_pfn;
-			max_pfn = end_pfn;
-		}
-#else
-		min_pfn = min_low_pfn;
-		max_pfn = max_low_pfn;
-#endif
 		size = min(per_node, hugetlb_cma_size - reserved);
 		size = round_up(size, PAGE_SIZE << order);
-
-		if (size > ((max_pfn - min_pfn) << PAGE_SHIFT) / 2) {
-			pr_warn("hugetlb_cma: cma_area is too big, please try less than %lu MiB\n",
-				round_down(((max_pfn - min_pfn) << PAGE_SHIFT) *
-					   nr_online_nodes / 2 / SZ_1M,
-					   PAGE_SIZE << order));
-			break;
-		}
-
-		res = cma_declare_contiguous(PFN_PHYS(min_pfn), size,
-					     PFN_PHYS(max_pfn),
+		
+		
+#ifndef CONFIG_NUMA
+		nid = NUMA_NO_NODE
+#endif		
+		res = cma_declare_contiguous_nid(0, size,
+					     0, 
 					     PAGE_SIZE << order,
 					     0, false,
-					     "hugetlb", &hugetlb_cma[nid]);
+					     "hugetlb", &hugetlb_cma[nid], nid);		
+
 		if (res) {
-			phys_addr_t begpa = PFN_PHYS(min_pfn);
-			phys_addr_t endpa = PFN_PHYS(max_pfn);
-			pr_warn("%s: reservation failed: err %d, node %d, [%pap, %pap)\n",
-				__func__, res, nid, &begpa, &endpa);
+			pr_warn("%s: reservation failed: err %d, node %d\n",
+				__func__, res, nid);
 			break;
 		}
 

Signature · 1 line

2.17.1

Signature · 2 lines

Michal Hocko
SUSE Labs

Quoted 14 lines · Michal Hocko

Quoted 12 lines · Aslan Bakirov

With introduction of numa node interface for CMA, this patch is for using that interface for allocating memory on numa nodes if NUMA is configured. This will be more efficient and cleaner because first, instead of iterating mem range of each numa node, cma_declare_contigueous_nid() will do its own address finding if we pass 0 for both min_pfn and max_pfn, second, it can also handle caseswhere NUMA is not configured
by passing NUMA_NO_NODE as an argument.

In addition, checking if desired size of memory is available or not, is happening in cma_declare_contiguous_nid() because base and limit will be determined there, since 0(any) for base and 0(any) for limit is passed as argument to the function.

Quoted 3 lines

This looks much better than the original patch. Can we simply squash your and Roman's patch in the mmotm tree and post it for the review in one piece? It would be slightly easier to review that way.

I'm glad you liked it! I agree, it's much nicer now, thanks to Aslan!

I think it's simpler to keep it as a separate patch, because there was already a fix by Randy Dunlap on top of my original version.

Quoted 1 line

Quoted 1 line

Signed-off-by Aslan Bakirov <[email protected]>

Acked-by Roman Gushchin <[email protected]>

Thanks!

Quoted 71 lines

Thanks!

Quoted 64 lines

---
 mm/hugetlb.c | 40 +++++++++++-----------------------------
 1 file changed, 11 insertions(+), 29 deletions(-)

mm/hugetlb.c +11 -29

index b9f0c903c4cf..62989220c4ff 100644
@@ -5573,42 +5573,24 @@ void __init hugetlb_cma_reserve(int order)
 
 	reserved = 0;
 	for_each_node_state(nid, N_ONLINE) {
-		unsigned long min_pfn = 0, max_pfn = 0;
 		int res;
-#ifdef CONFIG_NUMA
-		unsigned long start_pfn, end_pfn;
-		int i;
 
-		for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, NULL) {
-			if (!min_pfn)
-				min_pfn = start_pfn;
-			max_pfn = end_pfn;
-		}
-#else
-		min_pfn = min_low_pfn;
-		max_pfn = max_low_pfn;
-#endif
 		size = min(per_node, hugetlb_cma_size - reserved);
 		size = round_up(size, PAGE_SIZE << order);
-
-		if (size > ((max_pfn - min_pfn) << PAGE_SHIFT) / 2) {
-			pr_warn("hugetlb_cma: cma_area is too big, please try less than %lu MiB\n",
-				round_down(((max_pfn - min_pfn) << PAGE_SHIFT) *
-					   nr_online_nodes / 2 / SZ_1M,
-					   PAGE_SIZE << order));
-			break;
-		}
-
-		res = cma_declare_contiguous(PFN_PHYS(min_pfn), size,
-					     PFN_PHYS(max_pfn),
+		
+		
+#ifndef CONFIG_NUMA
+		nid = NUMA_NO_NODE
+#endif		
+		res = cma_declare_contiguous_nid(0, size,
+					     0, 
 					     PAGE_SIZE << order,
 					     0, false,
-					     "hugetlb", &hugetlb_cma[nid]);
+					     "hugetlb", &hugetlb_cma[nid], nid);		
+
 		if (res) {
-			phys_addr_t begpa = PFN_PHYS(min_pfn);
-			phys_addr_t endpa = PFN_PHYS(max_pfn);
-			pr_warn("%s: reservation failed: err %d, node %d, [%pap, %pap)\n",
-				__func__, res, nid, &begpa, &endpa);
+			pr_warn("%s: reservation failed: err %d, node %d\n",
+				__func__, res, nid);
 			break;
 		}
 

Signature · 1 line

2.17.1

Signature · 2 lines

Michal Hocko
SUSE Labs

Quoted 19 lines · Roman Gushchin

Quoted 17 lines · Michal Hocko

Quoted 8 lines · Aslan Bakirov

With introduction of numa node interface for CMA, this patch is for using that interface for allocating memory on numa nodes if NUMA is configured. This will be more efficient and cleaner because first, instead of iterating mem range of each numa node, cma_declare_contigueous_nid() will do its own address finding if we pass 0 for both min_pfn and max_pfn, second, it can also handle caseswhere NUMA is not configured
by passing NUMA_NO_NODE as an argument.

Quoted 4 lines

In addition, checking if desired size of memory is available or not, is happening in cma_declare_contiguous_nid() because base and limit will be determined there, since 0(any) for base and 0(any) for limit is passed as argument to the function.

This looks much better than the original patch. Can we simply squash your and Roman's patch in the mmotm tree and post it for the review in one piece? It would be slightly easier to review that way.

Quoted 4 lines

I'm glad you liked it! I agree, it's much nicer now, thanks to Aslan!

I think it's simpler to keep it as a separate patch, because there was already a fix by Randy Dunlap on top of my original version.

Why would be squashing all those into a single one be a problem. I will not insist of course but I would much rather see a single patch which is easy to review and doesn't contain any intermediate hacks to prevent

FWIW, for review purposes, this is Roman's patch with all followups from mmotm/next (hopefully didn't miss any) and then squashed with patch 2/2 from this thread. It can be applied like this:

- checkout v5.6
- apply patch 1/2 from this thread
- apply below

----8<----

Quoted 1 line

From dc10a593f2b8dfc7be920b4b088a8d55068fc6bc Mon Sep 17 00:00:00 2001

From: Roman Gushchin <[email protected]>
Date: Thu, 2 Apr 2020 13:49:04 +1100
Subject: [PATCH] mm: hugetlb: optionally allocate gigantic hugepages using cma

Commit 944d9fec8d7a ("hugetlb: add support for gigantic page allocation at runtime") has added the run-time allocation of gigantic pages. However it actually works only at early stages of the system loading, when the majority of memory is free. After some time the memory gets fragmented by non-movable pages, so the chances to find a contiguous 1 GB block are getting close to zero. Even dropping caches manually doesn't help a lot.

At large scale rebooting servers in order to allocate gigantic hugepages is quite expensive and complex. At the same time keeping some constant percentage of memory in reserved hugepages even if the workload isn't using it is a big waste: not all workloads can benefit from using 1 GB pages.

The following solution can solve the problem:
1) On boot time a dedicated cma area* is reserved. The size is passed as a kernel argument.
2) Run-time allocations of gigantic hugepages are performed using the cma allocator and the dedicated cma area

In this case gigantic hugepages can be allocated successfully with a high probability, however the memory isn't completely wasted if nobody is using 1GB hugepages: it can be used for pagecache, anon memory, THPs, etc.

* On a multi-node machine a per-node cma area is allocated on each node. Following gigantic hugetlb allocation are using the first available numa node if the mask isn't specified by a user.

Usage:
1) configure the kernel to allocate a cma area for hugetlb allocations:
pass hugetlb_cma=10G as a kernel argument

2) allocate hugetlb pages as usual, e.g.
echo 10 > /sys/kernel/mm/hugepages/hugepages-1048576kB/nr_hugepages

If the option isn't enabled or the allocation of the cma area failed, the current behavior of the system is preserved.

x86 and arm-64 are covered by this patch, other architectures can be trivially added later.

Link http://lkml.kernel.org/r/[email protected] open here

Signed-off-by Roman Gushchin <[email protected]>

Tested-by Andreas Schaufler <[email protected]>

Cc Michal Hocko <[email protected]>

Cc Rik van Riel <[email protected]>

Cc Andreas Schaufler <[email protected]>

Cc Mike Kravetz <[email protected]>

Cc Joonsoo Kim <[email protected]>

Signed-off-by Andrew Morton <[email protected]>

Signed-off-by Stephen Rothwell <[email protected]>

mm: hugetlb: Use node interface of cma

With introduction of numa node interface for CMA, this patch is for using that interface for allocating memory on numa nodes if NUMA is configured. This will be more efficient and cleaner because first, instead of iterating mem range of each numa node, cma_declare_contigueous_nid() will do its own address finding if we pass 0 for both min_pfn and max_pfn, second, it can also handle caseswhere NUMA is not configured
by passing NUMA_NO_NODE as an argument.

In addition, checking if desired size of memory is available or not, is happening in cma_declare_contiguous_nid() because base and limit will be determined there, since 0(any) for base and 0(any) for limit is passed as argument to the function.

Signed-off-by Aslan Bakirov <[email protected]>

Acked-by Roman Gushchin <[email protected]>

---
 .../admin-guide/kernel-parameters.txt         |  7 ++
 arch/arm64/mm/init.c                          |  6 ++
 arch/x86/kernel/setup.c                       |  4 +
 include/linux/hugetlb.h                       |  8 ++
 mm/hugetlb.c                                  | 98 +++++++++++++++++++
 5 files changed, 123 insertions(+)

mm/hugetlb.c +22 -0

+		res = cma_declare_contiguous_nid(0, size,
+					     0, 
+					     PAGE_SIZE << order,
+					     0, false,
+					     "hugetlb", &hugetlb_cma[nid], nid);		
+
+		if (res) {
+			pr_warn("%s: reservation failed: err %d, node %d\n",
+				__func__, res, nid);
+			break;
+		}
+
+		reserved += size;
+		pr_info("hugetlb_cma: reserved %lu MiB on node %d\n",
+			size / SZ_1M, nid);
+
+		if (reserved >= hugetlb_cma_size)
+			break;
+	}
+}
+
+#endif /* CONFIG_CMA */

Signature · 1 line

2.26.0

I've noticed that there is no interfaces exposed by CMA which would let me to declare contigous memory on particular NUMA node.

This patchset adds the ability to try to allocate contiguous memory on specific node.

Implement a new method for declaring contigous memory on particular node and keep cma_declare_contiguous() as a wrapper.

Signed-off-by Aslan Bakirov <[email protected]>

---
 include/linux/cma.h      | 14 ++++++++++++--
 include/linux/memblock.h |  3 +++
 mm/cma.c                 | 15 ++++++++-------
 mm/memblock.c            |  2 +-
 4 files changed, 24 insertions(+), 10 deletions(-)

include/linux/cma.h +12 -2

index 190184b5ff32..9512229744e0 100644
@@ -24,10 +24,20 @@ extern phys_addr_t cma_get_base(const struct cma *cma);
 extern unsigned long cma_get_size(const struct cma *cma);
 extern const char *cma_get_name(const struct cma *cma);
 
-extern int __init cma_declare_contiguous(phys_addr_t base,
+extern int __init cma_declare_contiguous_nid(phys_addr_t base,
 			phys_addr_t size, phys_addr_t limit,
 			phys_addr_t alignment, unsigned int order_per_bit,
-			bool fixed, const char *name, struct cma **res_cma);
+			bool fixed, const char *name, struct cma **res_cma,
+			int nid);
+static inline int __init cma_declare_contiguous(phys_addr_t base,
+			phys_addr_t size, phys_addr_t limit,
+			phys_addr_t alignment, unsigned int order_per_bit,
+			bool fixed, const char *name, struct cma **res_cma)
+			{
+				return cma_declare_contiguous_nid(base, size,
+						limit, alignment, order_per_bit,
+						fixed, name, res_cma, NUMA_NO_NODE);
+			}
 extern int cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
 					unsigned int order_per_bit,
 					const char *name,

include/linux/memblock.h +3 -0

index 079d17d96410..f5878ed25e6e 100644
@@ -348,6 +348,9 @@ static inline int memblock_get_region_node(const struct memblock_region *r)
 
 phys_addr_t memblock_phys_alloc_range(phys_addr_t size, phys_addr_t align,
 				      phys_addr_t start, phys_addr_t end);
+phys_addr_t memblock_alloc_range_nid(phys_addr_t size,
+					  phys_addr_t align, phys_addr_t start,
+					  phys_addr_t end, int nid, bool exact_nid);
 phys_addr_t memblock_phys_alloc_try_nid(phys_addr_t size, phys_addr_t align, int nid);
 
 static inline phys_addr_t memblock_phys_alloc(phys_addr_t size,

mm/cma.c +8 -7

index be55d1988c67..2300669b4253 100644
@@ -220,7 +220,7 @@ int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
 }
 
 /**
- * cma_declare_contiguous() - reserve custom contiguous area
+ * cma_declare_contiguous_nid() - reserve custom contiguous area
  * @base: Base address of the reserved area optional, use 0 for any
  * @size: Size of the reserved area (in bytes),
  * @limit: End address of the reserved memory (optional, 0 for any).

@@ -229,6 +229,7 @@ int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
  * @fixed: hint about where to place the reserved area
  * @name: The name of the area. See function cma_init_reserved_mem()
  * @res_cma: Pointer to store the created cma region.
+ * @nid: nid of the free area to find, %NUMA_NO_NODE for any node
  *
  * This function reserves memory from early allocator. It should be
  * called by arch specific code once the early allocator (memblock or bootmem)

@@ -238,10 +239,10 @@ int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
  * If @fixed is true, reserve contiguous area at exactly @base.  If false,
  * reserve in range from @base to @limit.
  */
-int __init cma_declare_contiguous(phys_addr_t base,
+int __init cma_declare_contiguous_nid(phys_addr_t base,
 			phys_addr_t size, phys_addr_t limit,
 			phys_addr_t alignment, unsigned int order_per_bit,
-			bool fixed, const char *name, struct cma **res_cma)
+			bool fixed, const char *name, struct cma **res_cma, int nid)
 {
 	phys_addr_t memblock_end = memblock_end_of_DRAM();
 	phys_addr_t highmem_start;

@@ -336,14 +337,14 @@ int __init cma_declare_contiguous(phys_addr_t base,
 		 * memory in case of failure.
 		 */
 		if (base < highmem_start && limit > highmem_start) {
-			addr = memblock_phys_alloc_range(size, alignment,
-							 highmem_start, limit);
+			addr = memblock_alloc_range_nid(size, alignment,
+							 highmem_start, limit, nid, false);
 			limit = highmem_start;
 		}
 
 		if (!addr) {
-			addr = memblock_phys_alloc_range(size, alignment, base,
-							 limit);
+			addr = memblock_alloc_range_nid(size, alignment, base,
+							 limit, nid, false);
 			if (!addr) {
 				ret = -ENOMEM;
 				goto err;

mm/memblock.c +1 -1

index 4d06bbaded0f..c79ba6f9920c 100644
@@ -1349,7 +1349,7 @@ __next_mem_pfn_range_in_zone(u64 *idx, struct zone *zone,
  * Return:
  * Physical address of allocated memory block on success, %0 on failure.
  */
-static phys_addr_t __init memblock_alloc_range_nid(phys_addr_t size,
+phys_addr_t __init memblock_alloc_range_nid(phys_addr_t size,
 					phys_addr_t align, phys_addr_t start,
 					phys_addr_t end, int nid,
 					bool exact_nid)

Signature · 1 line

2.17.1

I've noticed that there is no interfaces exposed by CMA which would let me to declare contigous memory on particular NUMA node.

This patchset adds the ability to try to allocate contiguous memory on specific node.

Implement a new method for declaring contigous memory on particular node and keep cma_declare_contiguous() as a wrapper.

Signed-off-by Aslan Bakirov <[email protected]>

mm/cma.c +1 -1

@@ -220,7 +220,7 @@ int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
 }
 
 /**
- * cma_declare_contiguous() - reserve custom contiguous area
+ * cma_declare_contiguous_nid() - reserve custom contiguous area
  * @base: Base address of the reserved area optional, use 0 for any
  * @size: Size of the reserved area (in bytes),
  * @limit: End address of the reserved memory (optional, 0 for any).

mm/cma.c +2 -2

  *
  * This function reserves memory from early allocator. It should be
  * called by arch specific code once the early allocator (memblock or bootmem)

@@ -238,10 +239,10 @@ int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
  * If @fixed is true, reserve contiguous area at exactly @base.  If false,
  * reserve in range from @base to @limit.
  */
-int __init cma_declare_contiguous(phys_addr_t base,
+int __init cma_declare_contiguous_nid(phys_addr_t base,
 			phys_addr_t size, phys_addr_t limit,
 			phys_addr_t alignment, unsigned int order_per_bit,
-			bool fixed, const char *name, struct cma **res_cma)
+			bool fixed, const char *name, struct cma **res_cma, int nid)
 {
 	phys_addr_t memblock_end = memblock_end_of_DRAM();
 	phys_addr_t highmem_start;

Quoted 1 line · Aslan Bakirov

I've noticed that there is no interfaces exposed by CMA which would let

me

Quoted 2 lines

to declare contigous memory on particular NUMA node.

Quoted 2 lines

This patchset adds the ability to try to allocate contiguous memory on specific node.

I would say more explicitly that 'try' here means it will fallback to other nodes if the specific one doesn't work. At least AFAICS that's what it does by
calling memblock_alloc_range_nid() with exact_nid=false.

Quoted 3 lines

Implement a new method for declaring contigous memory on particular node and keep cma_declare_contiguous() as a wrapper.

Should there be also support for using this node spcification in the cma=X boot
param?

For this, I would wait for a real usecase for now, because adding it is

Quoted 1 line

Signed-off-by Aslan Bakirov <[email protected]>

...

mm/cma.c int __init cma_init_reserved_mem(phys_addr_t base,

Quoted 3 lines

mm/cma.c +0 -0

@@ -220,7 +220,7 @@ int __init cma_init_reserved_mem(phys_addr_t base,

phys_addr_t size,

mm/cma.c int __init cma_init_reserved_mem(phys_addr_t base,

Quoted 9 lines

mm/cma.c +1 -1

 }
 
 /**
- * cma_declare_contiguous() - reserve custom contiguous area
+ * cma_declare_contiguous_nid() - reserve custom contiguous area
  * @base: Base address of the reserved area optional, use 0 for any
  * @size: Size of the reserved area (in bytes),
  * @limit: End address of the reserved memory (optional, 0 for any).

@@ -229,6 +229,7 @@ int __init cma_init_reserved_mem(phys_addr_t base,

phys_addr_t size,

mm/cma.c int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size, · line 232

Quoted 4 lines

mm/cma.c +1 -0

  * @fixed: hint about where to place the reserved area
  * @name: The name of the area. See function cma_init_reserved_mem()
  * @res_cma: Pointer to store the created cma region.
+ * @nid: nid of the free area to find, %NUMA_NO_NODE for any node

The bit about fallback should be also specified here.

mm/cma.c int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,

Quoted 3 lines

mm/cma.c +0 -0

  *
  * This function reserves memory from early allocator. It should be
  * called by arch specific code once the early allocator (memblock or

bootmem)

mm/cma.c int __init cma_init_reserved_mem(phys_addr_t base,

Quoted 1 line

mm/cma.c +0 -0

@@ -238,10 +239,10 @@ int __init cma_init_reserved_mem(phys_addr_t base,

phys_addr_t size,

mm/cma.c int __init cma_init_reserved_mem(phys_addr_t base, · line 239

Quoted 1 line

mm/cma.c +0 -0

  * If @fixed is true, reserve contiguous area at exactly @base.  If

false,

mm/cma.c int __init cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,

Quoted 8 lines

mm/cma.c +2 -2

  * reserve in range from @base to @limit.
  */
-int __init cma_declare_contiguous(phys_addr_t base,
+int __init cma_declare_contiguous_nid(phys_addr_t base,
                      phys_addr_t size, phys_addr_t limit,
                      phys_addr_t alignment, unsigned int order_per_bit,
-                     bool fixed, const char *name, struct cma **res_cma)
+                     bool fixed, const char *name, struct cma

**res_cma, int nid)

Quoted 3 lines

mm/cma.c +0 -0

 {
      phys_addr_t memblock_end = memblock_end_of_DRAM();
      phys_addr_t highmem_start;

Quoted 5 lines · Aslan Bakirov

I've noticed that there is no interfaces exposed by CMA which would let me to declare contigous memory on particular NUMA node.

This patchset adds the ability to try to allocate contiguous memory on specific node.

I would say more explicitly that 'try' here means it will fallback to other nodes if the specific one doesn't work. At least AFAICS that's what it does by calling memblock_alloc_range_nid() with exact_nid=false.

Quoted 3 lines

Implement a new method for declaring contigous memory on particular node and keep cma_declare_contiguous() as a wrapper.

Should there be also support for using this node spcification in the cma=X boot param?