1 // SPDX-License-Identifier: GPL-2.0-or-later
2 #include "alloc_exact_nid_api.h"
3 #include "alloc_nid_api.h"
4 
5 #define FUNC_NAME			"memblock_alloc_exact_nid_raw"
6 
7 /*
8  * contains the fraction of MEM_SIZE contained in each node in basis point
9  * units (one hundredth of 1% or 1/10000)
10  */
11 static const unsigned int node_fractions[] = {
12 	2500, /* 1/4  */
13 	 625, /* 1/16 */
14 	1250, /* 1/8  */
15 	1250, /* 1/8  */
16 	 625, /* 1/16 */
17 	 625, /* 1/16 */
18 	2500, /* 1/4  */
19 	 625, /* 1/16 */
20 };
21 
22 /*
23  * A test that tries to allocate a memory region in a specific NUMA node that
24  * has enough memory to allocate a region of the requested size.
25  * Expect to allocate an aligned region at the end of the requested node.
26  */
27 static int alloc_exact_nid_top_down_numa_simple_check(void)
28 {
29 	int nid_req = 3;
30 	struct memblock_region *new_rgn = &memblock.reserved.regions[0];
31 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
32 	void *allocated_ptr = NULL;
33 	phys_addr_t size;
34 	phys_addr_t min_addr;
35 	phys_addr_t max_addr;
36 
37 	PREFIX_PUSH();
38 	setup_numa_memblock(node_fractions);
39 
40 	ASSERT_LE(SZ_4, req_node->size);
41 	size = req_node->size / SZ_4;
42 	min_addr = memblock_start_of_DRAM();
43 	max_addr = memblock_end_of_DRAM();
44 
45 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
46 						     min_addr, max_addr,
47 						     nid_req);
48 
49 	ASSERT_NE(allocated_ptr, NULL);
50 	ASSERT_MEM_NE(allocated_ptr, 0, size);
51 
52 	ASSERT_EQ(new_rgn->size, size);
53 	ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
54 	ASSERT_LE(req_node->base, new_rgn->base);
55 
56 	ASSERT_EQ(memblock.reserved.cnt, 1);
57 	ASSERT_EQ(memblock.reserved.total_size, size);
58 
59 	test_pass_pop();
60 
61 	return 0;
62 }
63 
64 /*
65  * A test that tries to allocate a memory region in a specific NUMA node that
66  * is partially reserved but has enough memory for the allocated region:
67  *
68  *  |           +---------------------------------------+          |
69  *  |           |               requested               |          |
70  *  +-----------+---------------------------------------+----------+
71  *
72  *  |           +------------------+              +-----+          |
73  *  |           |     reserved     |              | new |          |
74  *  +-----------+------------------+--------------+-----+----------+
75  *
76  * Expect to allocate an aligned region at the end of the requested node. The
77  * region count and total size get updated.
78  */
79 static int alloc_exact_nid_top_down_numa_part_reserved_check(void)
80 {
81 	int nid_req = 4;
82 	struct memblock_region *new_rgn = &memblock.reserved.regions[1];
83 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
84 	void *allocated_ptr = NULL;
85 	struct region r1;
86 	phys_addr_t size;
87 	phys_addr_t min_addr;
88 	phys_addr_t max_addr;
89 
90 	PREFIX_PUSH();
91 	setup_numa_memblock(node_fractions);
92 
93 	ASSERT_LE(SZ_8, req_node->size);
94 	r1.base = req_node->base;
95 	r1.size = req_node->size / SZ_2;
96 	size = r1.size / SZ_4;
97 	min_addr = memblock_start_of_DRAM();
98 	max_addr = memblock_end_of_DRAM();
99 
100 	memblock_reserve(r1.base, r1.size);
101 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
102 						     min_addr, max_addr,
103 						     nid_req);
104 
105 	ASSERT_NE(allocated_ptr, NULL);
106 	ASSERT_MEM_NE(allocated_ptr, 0, size);
107 
108 	ASSERT_EQ(new_rgn->size, size);
109 	ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
110 	ASSERT_LE(req_node->base, new_rgn->base);
111 
112 	ASSERT_EQ(memblock.reserved.cnt, 2);
113 	ASSERT_EQ(memblock.reserved.total_size, size + r1.size);
114 
115 	test_pass_pop();
116 
117 	return 0;
118 }
119 
120 /*
121  * A test that tries to allocate a memory region that spans over the min_addr
122  * and max_addr range and overlaps with two different nodes, where the first
123  * node is the requested node:
124  *
125  *                                min_addr
126  *                                |           max_addr
127  *                                |           |
128  *                                v           v
129  *  |           +-----------------------+-----------+              |
130  *  |           |       requested       |   node3   |              |
131  *  +-----------+-----------------------+-----------+--------------+
132  *                                +           +
133  *  |                       +-----------+                          |
134  *  |                       |    rgn    |                          |
135  *  +-----------------------+-----------+--------------------------+
136  *
137  * Expect to drop the lower limit and allocate a memory region that ends at
138  * the end of the requested node.
139  */
140 static int alloc_exact_nid_top_down_numa_split_range_low_check(void)
141 {
142 	int nid_req = 2;
143 	struct memblock_region *new_rgn = &memblock.reserved.regions[0];
144 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
145 	void *allocated_ptr = NULL;
146 	phys_addr_t size = SZ_512;
147 	phys_addr_t min_addr;
148 	phys_addr_t max_addr;
149 	phys_addr_t req_node_end;
150 
151 	PREFIX_PUSH();
152 	setup_numa_memblock(node_fractions);
153 
154 	req_node_end = region_end(req_node);
155 	min_addr = req_node_end - SZ_256;
156 	max_addr = min_addr + size;
157 
158 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
159 						     min_addr, max_addr,
160 						     nid_req);
161 
162 	ASSERT_NE(allocated_ptr, NULL);
163 	ASSERT_MEM_NE(allocated_ptr, 0, size);
164 
165 	ASSERT_EQ(new_rgn->size, size);
166 	ASSERT_EQ(new_rgn->base, req_node_end - size);
167 	ASSERT_LE(req_node->base, new_rgn->base);
168 
169 	ASSERT_EQ(memblock.reserved.cnt, 1);
170 	ASSERT_EQ(memblock.reserved.total_size, size);
171 
172 	test_pass_pop();
173 
174 	return 0;
175 }
176 
177 /*
178  * A test that tries to allocate a memory region that spans over the min_addr
179  * and max_addr range and overlaps with two different nodes, where the requested
180  * node ends before min_addr:
181  *
182  *                                         min_addr
183  *                                         |         max_addr
184  *                                         |         |
185  *                                         v         v
186  *  |    +---------------+        +-------------+---------+          |
187  *  |    |   requested   |        |    node1    |  node2  |          |
188  *  +----+---------------+--------+-------------+---------+----------+
189  *                                         +         +
190  *  |          +---------+                                           |
191  *  |          |   rgn   |                                           |
192  *  +----------+---------+-------------------------------------------+
193  *
194  * Expect to drop the lower limit and allocate a memory region that ends at
195  * the end of the requested node.
196  */
197 static int alloc_exact_nid_top_down_numa_no_overlap_split_check(void)
198 {
199 	int nid_req = 2;
200 	struct memblock_region *new_rgn = &memblock.reserved.regions[0];
201 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
202 	struct memblock_region *node2 = &memblock.memory.regions[6];
203 	void *allocated_ptr = NULL;
204 	phys_addr_t size;
205 	phys_addr_t min_addr;
206 	phys_addr_t max_addr;
207 
208 	PREFIX_PUSH();
209 	setup_numa_memblock(node_fractions);
210 
211 	size = SZ_512;
212 	min_addr = node2->base - SZ_256;
213 	max_addr = min_addr + size;
214 
215 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
216 						     min_addr, max_addr,
217 						     nid_req);
218 
219 	ASSERT_NE(allocated_ptr, NULL);
220 	ASSERT_MEM_NE(allocated_ptr, 0, size);
221 
222 	ASSERT_EQ(new_rgn->size, size);
223 	ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
224 	ASSERT_LE(req_node->base, new_rgn->base);
225 
226 	ASSERT_EQ(memblock.reserved.cnt, 1);
227 	ASSERT_EQ(memblock.reserved.total_size, size);
228 
229 	test_pass_pop();
230 
231 	return 0;
232 }
233 
234 /*
235  * A test that tries to allocate memory within min_addr and max_add range when
236  * the requested node and the range do not overlap, and requested node ends
237  * before min_addr. The range overlaps with multiple nodes along node
238  * boundaries:
239  *
240  *                          min_addr
241  *                          |                                 max_addr
242  *                          |                                 |
243  *                          v                                 v
244  *  |-----------+           +----------+----...----+----------+      |
245  *  | requested |           | min node |    ...    | max node |      |
246  *  +-----------+-----------+----------+----...----+----------+------+
247  *                          +                                 +
248  *  |     +-----+                                                    |
249  *  |     | rgn |                                                    |
250  *  +-----+-----+----------------------------------------------------+
251  *
252  * Expect to drop the lower limit and allocate a memory region that ends at
253  * the end of the requested node.
254  */
255 static int alloc_exact_nid_top_down_numa_no_overlap_low_check(void)
256 {
257 	int nid_req = 0;
258 	struct memblock_region *new_rgn = &memblock.reserved.regions[0];
259 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
260 	struct memblock_region *min_node = &memblock.memory.regions[2];
261 	struct memblock_region *max_node = &memblock.memory.regions[5];
262 	void *allocated_ptr = NULL;
263 	phys_addr_t size = SZ_64;
264 	phys_addr_t max_addr;
265 	phys_addr_t min_addr;
266 
267 	PREFIX_PUSH();
268 	setup_numa_memblock(node_fractions);
269 
270 	min_addr = min_node->base;
271 	max_addr = region_end(max_node);
272 
273 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
274 						     min_addr, max_addr,
275 						     nid_req);
276 
277 	ASSERT_NE(allocated_ptr, NULL);
278 	ASSERT_MEM_NE(allocated_ptr, 0, size);
279 
280 	ASSERT_EQ(new_rgn->size, size);
281 	ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
282 
283 	ASSERT_EQ(memblock.reserved.cnt, 1);
284 	ASSERT_EQ(memblock.reserved.total_size, size);
285 
286 	test_pass_pop();
287 
288 	return 0;
289 }
290 
291 /*
292  * A test that tries to allocate a memory region in a specific NUMA node that
293  * has enough memory to allocate a region of the requested size.
294  * Expect to allocate an aligned region at the beginning of the requested node.
295  */
296 static int alloc_exact_nid_bottom_up_numa_simple_check(void)
297 {
298 	int nid_req = 3;
299 	struct memblock_region *new_rgn = &memblock.reserved.regions[0];
300 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
301 	void *allocated_ptr = NULL;
302 	phys_addr_t size;
303 	phys_addr_t min_addr;
304 	phys_addr_t max_addr;
305 
306 	PREFIX_PUSH();
307 	setup_numa_memblock(node_fractions);
308 
309 	ASSERT_LE(SZ_4, req_node->size);
310 	size = req_node->size / SZ_4;
311 	min_addr = memblock_start_of_DRAM();
312 	max_addr = memblock_end_of_DRAM();
313 
314 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
315 						     min_addr, max_addr,
316 						     nid_req);
317 
318 	ASSERT_NE(allocated_ptr, NULL);
319 	ASSERT_MEM_NE(allocated_ptr, 0, size);
320 
321 	ASSERT_EQ(new_rgn->size, size);
322 	ASSERT_EQ(new_rgn->base, req_node->base);
323 	ASSERT_LE(region_end(new_rgn), region_end(req_node));
324 
325 	ASSERT_EQ(memblock.reserved.cnt, 1);
326 	ASSERT_EQ(memblock.reserved.total_size, size);
327 
328 	test_pass_pop();
329 
330 	return 0;
331 }
332 
333 /*
334  * A test that tries to allocate a memory region in a specific NUMA node that
335  * is partially reserved but has enough memory for the allocated region:
336  *
337  *  |           +---------------------------------------+         |
338  *  |           |               requested               |         |
339  *  +-----------+---------------------------------------+---------+
340  *
341  *  |           +------------------+-----+                        |
342  *  |           |     reserved     | new |                        |
343  *  +-----------+------------------+-----+------------------------+
344  *
345  * Expect to allocate an aligned region in the requested node that merges with
346  * the existing reserved region. The total size gets updated.
347  */
348 static int alloc_exact_nid_bottom_up_numa_part_reserved_check(void)
349 {
350 	int nid_req = 4;
351 	struct memblock_region *new_rgn = &memblock.reserved.regions[0];
352 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
353 	void *allocated_ptr = NULL;
354 	struct region r1;
355 	phys_addr_t size;
356 	phys_addr_t min_addr;
357 	phys_addr_t max_addr;
358 	phys_addr_t total_size;
359 
360 	PREFIX_PUSH();
361 	setup_numa_memblock(node_fractions);
362 
363 	ASSERT_LE(SZ_8, req_node->size);
364 	r1.base = req_node->base;
365 	r1.size = req_node->size / SZ_2;
366 	size = r1.size / SZ_4;
367 	min_addr = memblock_start_of_DRAM();
368 	max_addr = memblock_end_of_DRAM();
369 	total_size = size + r1.size;
370 
371 	memblock_reserve(r1.base, r1.size);
372 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
373 						     min_addr, max_addr,
374 						     nid_req);
375 
376 	ASSERT_NE(allocated_ptr, NULL);
377 	ASSERT_MEM_NE(allocated_ptr, 0, size);
378 
379 	ASSERT_EQ(new_rgn->size, total_size);
380 	ASSERT_EQ(new_rgn->base, req_node->base);
381 	ASSERT_LE(region_end(new_rgn), region_end(req_node));
382 
383 	ASSERT_EQ(memblock.reserved.cnt, 1);
384 	ASSERT_EQ(memblock.reserved.total_size, total_size);
385 
386 	test_pass_pop();
387 
388 	return 0;
389 }
390 
391 /*
392  * A test that tries to allocate a memory region that spans over the min_addr
393  * and max_addr range and overlaps with two different nodes, where the first
394  * node is the requested node:
395  *
396  *                                min_addr
397  *                                |           max_addr
398  *                                |           |
399  *                                v           v
400  *  |           +-----------------------+-----------+              |
401  *  |           |       requested       |   node3   |              |
402  *  +-----------+-----------------------+-----------+--------------+
403  *                                +           +
404  *  |           +-----------+                                      |
405  *  |           |    rgn    |                                      |
406  *  +-----------+-----------+--------------------------------------+
407  *
408  * Expect to drop the lower limit and allocate a memory region at the beginning
409  * of the requested node.
410  */
411 static int alloc_exact_nid_bottom_up_numa_split_range_low_check(void)
412 {
413 	int nid_req = 2;
414 	struct memblock_region *new_rgn = &memblock.reserved.regions[0];
415 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
416 	void *allocated_ptr = NULL;
417 	phys_addr_t size = SZ_512;
418 	phys_addr_t min_addr;
419 	phys_addr_t max_addr;
420 	phys_addr_t req_node_end;
421 
422 	PREFIX_PUSH();
423 	setup_numa_memblock(node_fractions);
424 
425 	req_node_end = region_end(req_node);
426 	min_addr = req_node_end - SZ_256;
427 	max_addr = min_addr + size;
428 
429 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
430 						     min_addr, max_addr,
431 						     nid_req);
432 
433 	ASSERT_NE(allocated_ptr, NULL);
434 	ASSERT_MEM_NE(allocated_ptr, 0, size);
435 
436 	ASSERT_EQ(new_rgn->size, size);
437 	ASSERT_EQ(new_rgn->base, req_node->base);
438 	ASSERT_LE(region_end(new_rgn), req_node_end);
439 
440 	ASSERT_EQ(memblock.reserved.cnt, 1);
441 	ASSERT_EQ(memblock.reserved.total_size, size);
442 
443 	test_pass_pop();
444 
445 	return 0;
446 }
447 
448 /*
449  * A test that tries to allocate a memory region that spans over the min_addr
450  * and max_addr range and overlaps with two different nodes, where the requested
451  * node ends before min_addr:
452  *
453  *                                          min_addr
454  *                                         |         max_addr
455  *                                         |         |
456  *                                         v         v
457  *  |    +---------------+        +-------------+---------+         |
458  *  |    |   requested   |        |    node1    |  node2  |         |
459  *  +----+---------------+--------+-------------+---------+---------+
460  *                                         +         +
461  *  |    +---------+                                                |
462  *  |    |   rgn   |                                                |
463  *  +----+---------+------------------------------------------------+
464  *
465  * Expect to drop the lower limit and allocate a memory region that starts at
466  * the beginning of the requested node.
467  */
468 static int alloc_exact_nid_bottom_up_numa_no_overlap_split_check(void)
469 {
470 	int nid_req = 2;
471 	struct memblock_region *new_rgn = &memblock.reserved.regions[0];
472 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
473 	struct memblock_region *node2 = &memblock.memory.regions[6];
474 	void *allocated_ptr = NULL;
475 	phys_addr_t size;
476 	phys_addr_t min_addr;
477 	phys_addr_t max_addr;
478 
479 	PREFIX_PUSH();
480 	setup_numa_memblock(node_fractions);
481 
482 	size = SZ_512;
483 	min_addr = node2->base - SZ_256;
484 	max_addr = min_addr + size;
485 
486 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
487 						     min_addr, max_addr,
488 						     nid_req);
489 
490 	ASSERT_NE(allocated_ptr, NULL);
491 	ASSERT_MEM_NE(allocated_ptr, 0, size);
492 
493 	ASSERT_EQ(new_rgn->size, size);
494 	ASSERT_EQ(new_rgn->base, req_node->base);
495 	ASSERT_LE(region_end(new_rgn), region_end(req_node));
496 
497 	ASSERT_EQ(memblock.reserved.cnt, 1);
498 	ASSERT_EQ(memblock.reserved.total_size, size);
499 
500 	test_pass_pop();
501 
502 	return 0;
503 }
504 
505 /*
506  * A test that tries to allocate memory within min_addr and max_add range when
507  * the requested node and the range do not overlap, and requested node ends
508  * before min_addr. The range overlaps with multiple nodes along node
509  * boundaries:
510  *
511  *                          min_addr
512  *                          |                                 max_addr
513  *                          |                                 |
514  *                          v                                 v
515  *  |-----------+           +----------+----...----+----------+      |
516  *  | requested |           | min node |    ...    | max node |      |
517  *  +-----------+-----------+----------+----...----+----------+------+
518  *                          +                                 +
519  *  |-----+                                                          |
520  *  | rgn |                                                          |
521  *  +-----+----------------------------------------------------------+
522  *
523  * Expect to drop the lower limit and allocate a memory region that starts at
524  * the beginning of the requested node.
525  */
526 static int alloc_exact_nid_bottom_up_numa_no_overlap_low_check(void)
527 {
528 	int nid_req = 0;
529 	struct memblock_region *new_rgn = &memblock.reserved.regions[0];
530 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
531 	struct memblock_region *min_node = &memblock.memory.regions[2];
532 	struct memblock_region *max_node = &memblock.memory.regions[5];
533 	void *allocated_ptr = NULL;
534 	phys_addr_t size = SZ_64;
535 	phys_addr_t max_addr;
536 	phys_addr_t min_addr;
537 
538 	PREFIX_PUSH();
539 	setup_numa_memblock(node_fractions);
540 
541 	min_addr = min_node->base;
542 	max_addr = region_end(max_node);
543 
544 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
545 						     min_addr, max_addr,
546 						     nid_req);
547 
548 	ASSERT_NE(allocated_ptr, NULL);
549 	ASSERT_MEM_NE(allocated_ptr, 0, size);
550 
551 	ASSERT_EQ(new_rgn->size, size);
552 	ASSERT_EQ(new_rgn->base, req_node->base);
553 	ASSERT_LE(region_end(new_rgn), region_end(req_node));
554 
555 	ASSERT_EQ(memblock.reserved.cnt, 1);
556 	ASSERT_EQ(memblock.reserved.total_size, size);
557 
558 	test_pass_pop();
559 
560 	return 0;
561 }
562 
563 /*
564  * A test that tries to allocate a memory region in a specific NUMA node that
565  * does not have enough memory to allocate a region of the requested size:
566  *
567  *  |   +-----+                            |
568  *  |   | req |                            |
569  *  +---+-----+----------------------------+
570  *
571  *  +---------+
572  *  |   rgn   |
573  *  +---------+
574  *
575  * Expect no allocation to happen.
576  */
577 static int alloc_exact_nid_numa_small_node_generic_check(void)
578 {
579 	int nid_req = 1;
580 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
581 	void *allocated_ptr = NULL;
582 	phys_addr_t size;
583 	phys_addr_t min_addr;
584 	phys_addr_t max_addr;
585 
586 	PREFIX_PUSH();
587 	setup_numa_memblock(node_fractions);
588 
589 	size = SZ_2 * req_node->size;
590 	min_addr = memblock_start_of_DRAM();
591 	max_addr = memblock_end_of_DRAM();
592 
593 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
594 						     min_addr, max_addr,
595 						     nid_req);
596 
597 	ASSERT_EQ(allocated_ptr, NULL);
598 
599 	test_pass_pop();
600 
601 	return 0;
602 }
603 
604 /*
605  * A test that tries to allocate a memory region in a specific NUMA node that
606  * is fully reserved:
607  *
608  *  |              +---------+             |
609  *  |              |requested|             |
610  *  +--------------+---------+-------------+
611  *
612  *  |              +---------+             |
613  *  |              | reserved|             |
614  *  +--------------+---------+-------------+
615  *
616  * Expect no allocation to happen.
617  */
618 static int alloc_exact_nid_numa_node_reserved_generic_check(void)
619 {
620 	int nid_req = 2;
621 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
622 	void *allocated_ptr = NULL;
623 	phys_addr_t size;
624 	phys_addr_t min_addr;
625 	phys_addr_t max_addr;
626 
627 	PREFIX_PUSH();
628 	setup_numa_memblock(node_fractions);
629 
630 	size = req_node->size;
631 	min_addr = memblock_start_of_DRAM();
632 	max_addr = memblock_end_of_DRAM();
633 
634 	memblock_reserve(req_node->base, req_node->size);
635 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
636 						     min_addr, max_addr,
637 						     nid_req);
638 
639 	ASSERT_EQ(allocated_ptr, NULL);
640 
641 	test_pass_pop();
642 
643 	return 0;
644 }
645 
646 /*
647  * A test that tries to allocate a memory region in a specific NUMA node that
648  * is partially reserved and does not have enough contiguous memory for the
649  * allocated region:
650  *
651  *  |           +-----------------------+    |
652  *  |           |       requested       |    |
653  *  +-----------+-----------------------+----+
654  *
655  *  |                 +----------+           |
656  *  |                 | reserved |           |
657  *  +-----------------+----------+-----------+
658  *
659  * Expect no allocation to happen.
660  */
661 static int alloc_exact_nid_numa_part_reserved_fail_generic_check(void)
662 {
663 	int nid_req = 4;
664 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
665 	void *allocated_ptr = NULL;
666 	struct region r1;
667 	phys_addr_t size;
668 	phys_addr_t min_addr;
669 	phys_addr_t max_addr;
670 
671 	PREFIX_PUSH();
672 	setup_numa_memblock(node_fractions);
673 
674 	ASSERT_LE(SZ_4, req_node->size);
675 	size = req_node->size / SZ_2;
676 	r1.base = req_node->base + (size / SZ_2);
677 	r1.size = size;
678 
679 	min_addr = memblock_start_of_DRAM();
680 	max_addr = memblock_end_of_DRAM();
681 
682 	memblock_reserve(r1.base, r1.size);
683 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
684 						     min_addr, max_addr,
685 						     nid_req);
686 
687 	ASSERT_EQ(allocated_ptr, NULL);
688 
689 	test_pass_pop();
690 
691 	return 0;
692 }
693 
694 /*
695  * A test that tries to allocate a memory region that spans over the min_addr
696  * and max_addr range and overlaps with two different nodes, where the second
697  * node is the requested node:
698  *
699  *                               min_addr
700  *                               |         max_addr
701  *                               |         |
702  *                               v         v
703  *  |      +--------------------------+---------+                |
704  *  |      |        first node        |requested|                |
705  *  +------+--------------------------+---------+----------------+
706  *
707  * Expect no allocation to happen.
708  */
709 static int alloc_exact_nid_numa_split_range_high_generic_check(void)
710 {
711 	int nid_req = 3;
712 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
713 	void *allocated_ptr = NULL;
714 	phys_addr_t size = SZ_512;
715 	phys_addr_t min_addr;
716 	phys_addr_t max_addr;
717 
718 	PREFIX_PUSH();
719 	setup_numa_memblock(node_fractions);
720 
721 	min_addr = req_node->base - SZ_256;
722 	max_addr = min_addr + size;
723 
724 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
725 						     min_addr, max_addr,
726 						     nid_req);
727 
728 	ASSERT_EQ(allocated_ptr, NULL);
729 
730 	test_pass_pop();
731 
732 	return 0;
733 }
734 
735 /*
736  * A test that tries to allocate memory within min_addr and max_add range when
737  * the requested node and the range do not overlap, and requested node starts
738  * after max_addr. The range overlaps with multiple nodes along node
739  * boundaries:
740  *
741  *        min_addr
742  *        |                                 max_addr
743  *        |                                 |
744  *        v                                 v
745  *  |     +----------+----...----+----------+        +-----------+   |
746  *  |     | min node |    ...    | max node |        | requested |   |
747  *  +-----+----------+----...----+----------+--------+-----------+---+
748  *
749  * Expect no allocation to happen.
750  */
751 static int alloc_exact_nid_numa_no_overlap_high_generic_check(void)
752 {
753 	int nid_req = 7;
754 	struct memblock_region *min_node = &memblock.memory.regions[2];
755 	struct memblock_region *max_node = &memblock.memory.regions[5];
756 	void *allocated_ptr = NULL;
757 	phys_addr_t size = SZ_64;
758 	phys_addr_t max_addr;
759 	phys_addr_t min_addr;
760 
761 	PREFIX_PUSH();
762 	setup_numa_memblock(node_fractions);
763 
764 	min_addr = min_node->base;
765 	max_addr = region_end(max_node);
766 
767 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
768 						     min_addr, max_addr,
769 						     nid_req);
770 
771 	ASSERT_EQ(allocated_ptr, NULL);
772 
773 	test_pass_pop();
774 
775 	return 0;
776 }
777 
778 /*
779  * A test that tries to allocate a memory region in a specific NUMA node that
780  * does not have enough memory to allocate a region of the requested size.
781  * Additionally, none of the nodes have enough memory to allocate the region:
782  *
783  * +-----------------------------------+
784  * |                new                |
785  * +-----------------------------------+
786  *     |-------+-------+-------+-------+-------+-------+-------+-------|
787  *     | node0 | node1 | node2 | node3 | node4 | node5 | node6 | node7 |
788  *     +-------+-------+-------+-------+-------+-------+-------+-------+
789  *
790  * Expect no allocation to happen.
791  */
792 static int alloc_exact_nid_numa_large_region_generic_check(void)
793 {
794 	int nid_req = 3;
795 	void *allocated_ptr = NULL;
796 	phys_addr_t size = MEM_SIZE / SZ_2;
797 	phys_addr_t min_addr;
798 	phys_addr_t max_addr;
799 
800 	PREFIX_PUSH();
801 	setup_numa_memblock(node_fractions);
802 
803 	min_addr = memblock_start_of_DRAM();
804 	max_addr = memblock_end_of_DRAM();
805 
806 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
807 						     min_addr, max_addr,
808 						     nid_req);
809 	ASSERT_EQ(allocated_ptr, NULL);
810 
811 	test_pass_pop();
812 
813 	return 0;
814 }
815 
816 /*
817  * A test that tries to allocate memory within min_addr and max_addr range when
818  * there are two reserved regions at the borders. The requested node starts at
819  * min_addr and ends at max_addr and is the same size as the region to be
820  * allocated:
821  *
822  *                     min_addr
823  *                     |                       max_addr
824  *                     |                       |
825  *                     v                       v
826  *  |      +-----------+-----------------------+-----------------------|
827  *  |      |   node5   |       requested       |         node7         |
828  *  +------+-----------+-----------------------+-----------------------+
829  *                     +                       +
830  *  |             +----+-----------------------+----+                  |
831  *  |             | r2 |          new          | r1 |                  |
832  *  +-------------+----+-----------------------+----+------------------+
833  *
834  * Expect to merge all of the regions into one. The region counter and total
835  * size fields get updated.
836  */
837 static int alloc_exact_nid_numa_reserved_full_merge_generic_check(void)
838 {
839 	int nid_req = 6;
840 	int nid_next = nid_req + 1;
841 	struct memblock_region *new_rgn = &memblock.reserved.regions[0];
842 	struct memblock_region *req_node = &memblock.memory.regions[nid_req];
843 	struct memblock_region *next_node = &memblock.memory.regions[nid_next];
844 	void *allocated_ptr = NULL;
845 	struct region r1, r2;
846 	phys_addr_t size = req_node->size;
847 	phys_addr_t total_size;
848 	phys_addr_t max_addr;
849 	phys_addr_t min_addr;
850 
851 	PREFIX_PUSH();
852 	setup_numa_memblock(node_fractions);
853 
854 	r1.base = next_node->base;
855 	r1.size = SZ_128;
856 
857 	r2.size = SZ_128;
858 	r2.base = r1.base - (size + r2.size);
859 
860 	total_size = r1.size + r2.size + size;
861 	min_addr = r2.base + r2.size;
862 	max_addr = r1.base;
863 
864 	memblock_reserve(r1.base, r1.size);
865 	memblock_reserve(r2.base, r2.size);
866 
867 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
868 						     min_addr, max_addr,
869 						     nid_req);
870 
871 	ASSERT_NE(allocated_ptr, NULL);
872 	ASSERT_MEM_NE(allocated_ptr, 0, size);
873 
874 	ASSERT_EQ(new_rgn->size, total_size);
875 	ASSERT_EQ(new_rgn->base, r2.base);
876 
877 	ASSERT_LE(new_rgn->base, req_node->base);
878 	ASSERT_LE(region_end(req_node), region_end(new_rgn));
879 
880 	ASSERT_EQ(memblock.reserved.cnt, 1);
881 	ASSERT_EQ(memblock.reserved.total_size, total_size);
882 
883 	test_pass_pop();
884 
885 	return 0;
886 }
887 
888 /*
889  * A test that tries to allocate memory within min_addr and max_add range,
890  * where the total range can fit the region, but it is split between two nodes
891  * and everything else is reserved. Additionally, nid is set to NUMA_NO_NODE
892  * instead of requesting a specific node:
893  *
894  *                         +-----------+
895  *                         |    new    |
896  *                         +-----------+
897  *  |      +---------------------+-----------|
898  *  |      |      prev node      | next node |
899  *  +------+---------------------+-----------+
900  *                         +           +
901  *  |----------------------+           +-----|
902  *  |          r1          |           |  r2 |
903  *  +----------------------+-----------+-----+
904  *                         ^           ^
905  *                         |           |
906  *                         |           max_addr
907  *                         |
908  *                         min_addr
909  *
910  * Expect no allocation to happen.
911  */
912 static int alloc_exact_nid_numa_split_all_reserved_generic_check(void)
913 {
914 	void *allocated_ptr = NULL;
915 	struct memblock_region *next_node = &memblock.memory.regions[7];
916 	struct region r1, r2;
917 	phys_addr_t size = SZ_256;
918 	phys_addr_t max_addr;
919 	phys_addr_t min_addr;
920 
921 	PREFIX_PUSH();
922 	setup_numa_memblock(node_fractions);
923 
924 	r2.base = next_node->base + SZ_128;
925 	r2.size = memblock_end_of_DRAM() - r2.base;
926 
927 	r1.size = MEM_SIZE - (r2.size + size);
928 	r1.base = memblock_start_of_DRAM();
929 
930 	min_addr = r1.base + r1.size;
931 	max_addr = r2.base;
932 
933 	memblock_reserve(r1.base, r1.size);
934 	memblock_reserve(r2.base, r2.size);
935 
936 	allocated_ptr = memblock_alloc_exact_nid_raw(size, SMP_CACHE_BYTES,
937 						     min_addr, max_addr,
938 						     NUMA_NO_NODE);
939 
940 	ASSERT_EQ(allocated_ptr, NULL);
941 
942 	test_pass_pop();
943 
944 	return 0;
945 }
946 
947 /* Test case wrappers for NUMA tests */
948 static int alloc_exact_nid_numa_simple_check(void)
949 {
950 	test_print("\tRunning %s...\n", __func__);
951 	memblock_set_bottom_up(false);
952 	alloc_exact_nid_top_down_numa_simple_check();
953 	memblock_set_bottom_up(true);
954 	alloc_exact_nid_bottom_up_numa_simple_check();
955 
956 	return 0;
957 }
958 
959 static int alloc_exact_nid_numa_part_reserved_check(void)
960 {
961 	test_print("\tRunning %s...\n", __func__);
962 	memblock_set_bottom_up(false);
963 	alloc_exact_nid_top_down_numa_part_reserved_check();
964 	memblock_set_bottom_up(true);
965 	alloc_exact_nid_bottom_up_numa_part_reserved_check();
966 
967 	return 0;
968 }
969 
970 static int alloc_exact_nid_numa_split_range_low_check(void)
971 {
972 	test_print("\tRunning %s...\n", __func__);
973 	memblock_set_bottom_up(false);
974 	alloc_exact_nid_top_down_numa_split_range_low_check();
975 	memblock_set_bottom_up(true);
976 	alloc_exact_nid_bottom_up_numa_split_range_low_check();
977 
978 	return 0;
979 }
980 
981 static int alloc_exact_nid_numa_no_overlap_split_check(void)
982 {
983 	test_print("\tRunning %s...\n", __func__);
984 	memblock_set_bottom_up(false);
985 	alloc_exact_nid_top_down_numa_no_overlap_split_check();
986 	memblock_set_bottom_up(true);
987 	alloc_exact_nid_bottom_up_numa_no_overlap_split_check();
988 
989 	return 0;
990 }
991 
992 static int alloc_exact_nid_numa_no_overlap_low_check(void)
993 {
994 	test_print("\tRunning %s...\n", __func__);
995 	memblock_set_bottom_up(false);
996 	alloc_exact_nid_top_down_numa_no_overlap_low_check();
997 	memblock_set_bottom_up(true);
998 	alloc_exact_nid_bottom_up_numa_no_overlap_low_check();
999 
1000 	return 0;
1001 }
1002 
1003 static int alloc_exact_nid_numa_small_node_check(void)
1004 {
1005 	test_print("\tRunning %s...\n", __func__);
1006 	run_top_down(alloc_exact_nid_numa_small_node_generic_check);
1007 	run_bottom_up(alloc_exact_nid_numa_small_node_generic_check);
1008 
1009 	return 0;
1010 }
1011 
1012 static int alloc_exact_nid_numa_node_reserved_check(void)
1013 {
1014 	test_print("\tRunning %s...\n", __func__);
1015 	run_top_down(alloc_exact_nid_numa_node_reserved_generic_check);
1016 	run_bottom_up(alloc_exact_nid_numa_node_reserved_generic_check);
1017 
1018 	return 0;
1019 }
1020 
1021 static int alloc_exact_nid_numa_part_reserved_fail_check(void)
1022 {
1023 	test_print("\tRunning %s...\n", __func__);
1024 	run_top_down(alloc_exact_nid_numa_part_reserved_fail_generic_check);
1025 	run_bottom_up(alloc_exact_nid_numa_part_reserved_fail_generic_check);
1026 
1027 	return 0;
1028 }
1029 
1030 static int alloc_exact_nid_numa_split_range_high_check(void)
1031 {
1032 	test_print("\tRunning %s...\n", __func__);
1033 	run_top_down(alloc_exact_nid_numa_split_range_high_generic_check);
1034 	run_bottom_up(alloc_exact_nid_numa_split_range_high_generic_check);
1035 
1036 	return 0;
1037 }
1038 
1039 static int alloc_exact_nid_numa_no_overlap_high_check(void)
1040 {
1041 	test_print("\tRunning %s...\n", __func__);
1042 	run_top_down(alloc_exact_nid_numa_no_overlap_high_generic_check);
1043 	run_bottom_up(alloc_exact_nid_numa_no_overlap_high_generic_check);
1044 
1045 	return 0;
1046 }
1047 
1048 static int alloc_exact_nid_numa_large_region_check(void)
1049 {
1050 	test_print("\tRunning %s...\n", __func__);
1051 	run_top_down(alloc_exact_nid_numa_large_region_generic_check);
1052 	run_bottom_up(alloc_exact_nid_numa_large_region_generic_check);
1053 
1054 	return 0;
1055 }
1056 
1057 static int alloc_exact_nid_numa_reserved_full_merge_check(void)
1058 {
1059 	test_print("\tRunning %s...\n", __func__);
1060 	run_top_down(alloc_exact_nid_numa_reserved_full_merge_generic_check);
1061 	run_bottom_up(alloc_exact_nid_numa_reserved_full_merge_generic_check);
1062 
1063 	return 0;
1064 }
1065 
1066 static int alloc_exact_nid_numa_split_all_reserved_check(void)
1067 {
1068 	test_print("\tRunning %s...\n", __func__);
1069 	run_top_down(alloc_exact_nid_numa_split_all_reserved_generic_check);
1070 	run_bottom_up(alloc_exact_nid_numa_split_all_reserved_generic_check);
1071 
1072 	return 0;
1073 }
1074 
1075 int __memblock_alloc_exact_nid_numa_checks(void)
1076 {
1077 	test_print("Running %s NUMA tests...\n", FUNC_NAME);
1078 
1079 	alloc_exact_nid_numa_simple_check();
1080 	alloc_exact_nid_numa_part_reserved_check();
1081 	alloc_exact_nid_numa_split_range_low_check();
1082 	alloc_exact_nid_numa_no_overlap_split_check();
1083 	alloc_exact_nid_numa_no_overlap_low_check();
1084 
1085 	alloc_exact_nid_numa_small_node_check();
1086 	alloc_exact_nid_numa_node_reserved_check();
1087 	alloc_exact_nid_numa_part_reserved_fail_check();
1088 	alloc_exact_nid_numa_split_range_high_check();
1089 	alloc_exact_nid_numa_no_overlap_high_check();
1090 	alloc_exact_nid_numa_large_region_check();
1091 	alloc_exact_nid_numa_reserved_full_merge_check();
1092 	alloc_exact_nid_numa_split_all_reserved_check();
1093 
1094 	return 0;
1095 }
1096 
1097 int memblock_alloc_exact_nid_checks(void)
1098 {
1099 	prefix_reset();
1100 	prefix_push(FUNC_NAME);
1101 
1102 	reset_memblock_attributes();
1103 	dummy_physical_memory_init();
1104 
1105 	memblock_alloc_exact_nid_range_checks();
1106 	memblock_alloc_exact_nid_numa_checks();
1107 
1108 	dummy_physical_memory_cleanup();
1109 
1110 	prefix_pop();
1111 
1112 	return 0;
1113 }
1114