projects/linux·blob master · refs

2733 lines · 79.0 KiB

1// SPDX-License-Identifier: GPL-2.0-or-later
2#include "alloc_nid_api.h"
3
4static int alloc_nid_test_flags = TEST_F_NONE;
5
6/*
7 * contains the fraction of MEM_SIZE contained in each node in basis point
8 * units (one hundredth of 1% or 1/10000)
9 */
10static const unsigned int node_fractions[] = {
11 2500, /* 1/4 */
12 625, /* 1/16 */
13 1250, /* 1/8 */
14 1250, /* 1/8 */
15 625, /* 1/16 */
16 625, /* 1/16 */
17 2500, /* 1/4 */
18 625, /* 1/16 */
19};
20
21static inline const char * const get_memblock_alloc_nid_name(int flags)
22{
23 if (flags & TEST_F_EXACT)
24 return "memblock_alloc_exact_nid_raw";
25 if (flags & TEST_F_RAW)
26 return "memblock_alloc_try_nid_raw";
27 return "memblock_alloc_try_nid";
28}
29
30static inline void *run_memblock_alloc_nid(phys_addr_t size,
31 phys_addr_t align,
32 phys_addr_t min_addr,
33 phys_addr_t max_addr, int nid)
34{
35 assert(!(alloc_nid_test_flags & TEST_F_EXACT) ||
36 (alloc_nid_test_flags & TEST_F_RAW));
37 /*
38 * TEST_F_EXACT should be checked before TEST_F_RAW since
39 * memblock_alloc_exact_nid_raw() performs raw allocations.
40 */
41 if (alloc_nid_test_flags & TEST_F_EXACT)
42 return memblock_alloc_exact_nid_raw(size, align, min_addr,
43 max_addr, nid);
44 if (alloc_nid_test_flags & TEST_F_RAW)
45 return memblock_alloc_try_nid_raw(size, align, min_addr,
46 max_addr, nid);
47 return memblock_alloc_try_nid(size, align, min_addr, max_addr, nid);
48}
49
50/*
51 * A simple test that tries to allocate a memory region within min_addr and
52 * max_addr range:
53 *
54 * + +
55 * | + +-----------+ |
56 * | | | rgn | |
57 * +----+-------+-----------+------+
58 * ^ ^
59 * | |
60 * min_addr max_addr
61 *
62 * Expect to allocate a region that ends at max_addr.
63 */
64static int alloc_nid_top_down_simple_check(void)
65{
66 struct memblock_region *rgn = &memblock.reserved.regions[0];
67 void *allocated_ptr = NULL;
68 phys_addr_t size = SZ_128;
69 phys_addr_t min_addr;
70 phys_addr_t max_addr;
71 phys_addr_t rgn_end;
72
73 PREFIX_PUSH();
74 setup_memblock();
75
76 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
77 max_addr = min_addr + SZ_512;
78
79 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
80 min_addr, max_addr,
81 NUMA_NO_NODE);
82 rgn_end = rgn->base + rgn->size;
83
84 ASSERT_NE(allocated_ptr, NULL);
85 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
86
87 ASSERT_EQ(rgn->size, size);
88 ASSERT_EQ(rgn->base, max_addr - size);
89 ASSERT_EQ(rgn_end, max_addr);
90
91 ASSERT_EQ(memblock.reserved.cnt, 1);
92 ASSERT_EQ(memblock.reserved.total_size, size);
93
94 test_pass_pop();
95
96 return 0;
97}
98
99/*
100 * A simple test that tries to allocate a memory region within min_addr and
101 * max_addr range, where the end address is misaligned:
102 *
103 * + + +
104 * | + +---------+ + |
105 * | | | rgn | | |
106 * +------+-------+---------+--+----+
107 * ^ ^ ^
108 * | | |
109 * min_add | max_addr
110 * |
111 * Aligned address
112 * boundary
113 *
114 * Expect to allocate an aligned region that ends before max_addr.
115 */
116static int alloc_nid_top_down_end_misaligned_check(void)
117{
118 struct memblock_region *rgn = &memblock.reserved.regions[0];
119 void *allocated_ptr = NULL;
120 phys_addr_t size = SZ_128;
121 phys_addr_t misalign = SZ_2;
122 phys_addr_t min_addr;
123 phys_addr_t max_addr;
124 phys_addr_t rgn_end;
125
126 PREFIX_PUSH();
127 setup_memblock();
128
129 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
130 max_addr = min_addr + SZ_512 + misalign;
131
132 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
133 min_addr, max_addr,
134 NUMA_NO_NODE);
135 rgn_end = rgn->base + rgn->size;
136
137 ASSERT_NE(allocated_ptr, NULL);
138 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
139
140 ASSERT_EQ(rgn->size, size);
141 ASSERT_EQ(rgn->base, max_addr - size - misalign);
142 ASSERT_LT(rgn_end, max_addr);
143
144 ASSERT_EQ(memblock.reserved.cnt, 1);
145 ASSERT_EQ(memblock.reserved.total_size, size);
146
147 test_pass_pop();
148
149 return 0;
150}
151
152/*
153 * A simple test that tries to allocate a memory region, which spans over the
154 * min_addr and max_addr range:
155 *
156 * + +
157 * | +---------------+ |
158 * | | rgn | |
159 * +------+---------------+-------+
160 * ^ ^
161 * | |
162 * min_addr max_addr
163 *
164 * Expect to allocate a region that starts at min_addr and ends at
165 * max_addr, given that min_addr is aligned.
166 */
167static int alloc_nid_exact_address_generic_check(void)
168{
169 struct memblock_region *rgn = &memblock.reserved.regions[0];
170 void *allocated_ptr = NULL;
171 phys_addr_t size = SZ_1K;
172 phys_addr_t min_addr;
173 phys_addr_t max_addr;
174 phys_addr_t rgn_end;
175
176 PREFIX_PUSH();
177 setup_memblock();
178
179 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES;
180 max_addr = min_addr + size;
181
182 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
183 min_addr, max_addr,
184 NUMA_NO_NODE);
185 rgn_end = rgn->base + rgn->size;
186
187 ASSERT_NE(allocated_ptr, NULL);
188 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
189
190 ASSERT_EQ(rgn->size, size);
191 ASSERT_EQ(rgn->base, min_addr);
192 ASSERT_EQ(rgn_end, max_addr);
193
194 ASSERT_EQ(memblock.reserved.cnt, 1);
195 ASSERT_EQ(memblock.reserved.total_size, size);
196
197 test_pass_pop();
198
199 return 0;
200}
201
202/*
203 * A test that tries to allocate a memory region, which can't fit into
204 * min_addr and max_addr range:
205 *
206 * + + +
207 * | +----------+-----+ |
208 * | | rgn + | |
209 * +--------+----------+-----+----+
210 * ^ ^ ^
211 * | | |
212 * Aligned | max_addr
213 * address |
214 * boundary min_add
215 *
216 * Expect to drop the lower limit and allocate a memory region which
217 * ends at max_addr (if the address is aligned).
218 */
219static int alloc_nid_top_down_narrow_range_check(void)
220{
221 struct memblock_region *rgn = &memblock.reserved.regions[0];
222 void *allocated_ptr = NULL;
223 phys_addr_t size = SZ_256;
224 phys_addr_t min_addr;
225 phys_addr_t max_addr;
226
227 PREFIX_PUSH();
228 setup_memblock();
229
230 min_addr = memblock_start_of_DRAM() + SZ_512;
231 max_addr = min_addr + SMP_CACHE_BYTES;
232
233 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
234 min_addr, max_addr,
235 NUMA_NO_NODE);
236
237 ASSERT_NE(allocated_ptr, NULL);
238 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
239
240 ASSERT_EQ(rgn->size, size);
241 ASSERT_EQ(rgn->base, max_addr - size);
242
243 ASSERT_EQ(memblock.reserved.cnt, 1);
244 ASSERT_EQ(memblock.reserved.total_size, size);
245
246 test_pass_pop();
247
248 return 0;
249}
250
251/*
252 * A test that tries to allocate a memory region, which can't fit into
253 * min_addr and max_addr range, with the latter being too close to the beginning
254 * of the available memory:
255 *
256 * +-------------+
257 * | new |
258 * +-------------+
259 * + +
260 * | + |
261 * | | |
262 * +-------+--------------+
263 * ^ ^
264 * | |
265 * | max_addr
266 * |
267 * min_addr
268 *
269 * Expect no allocation to happen.
270 */
271static int alloc_nid_low_max_generic_check(void)
272{
273 void *allocated_ptr = NULL;
274 phys_addr_t size = SZ_1K;
275 phys_addr_t min_addr;
276 phys_addr_t max_addr;
277
278 PREFIX_PUSH();
279 setup_memblock();
280
281 min_addr = memblock_start_of_DRAM();
282 max_addr = min_addr + SMP_CACHE_BYTES;
283
284 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
285 min_addr, max_addr,
286 NUMA_NO_NODE);
287
288 ASSERT_EQ(allocated_ptr, NULL);
289
290 test_pass_pop();
291
292 return 0;
293}
294
295/*
296 * A test that tries to allocate a memory region within min_addr min_addr range,
297 * with min_addr being so close that it's next to an allocated region:
298 *
299 * + +
300 * | +--------+---------------|
301 * | | r1 | rgn |
302 * +-------+--------+---------------+
303 * ^ ^
304 * | |
305 * min_addr max_addr
306 *
307 * Expect a merge of both regions. Only the region size gets updated.
308 */
309static int alloc_nid_min_reserved_generic_check(void)
310{
311 struct memblock_region *rgn = &memblock.reserved.regions[0];
312 void *allocated_ptr = NULL;
313 phys_addr_t r1_size = SZ_128;
314 phys_addr_t r2_size = SZ_64;
315 phys_addr_t total_size = r1_size + r2_size;
316 phys_addr_t min_addr;
317 phys_addr_t max_addr;
318 phys_addr_t reserved_base;
319
320 PREFIX_PUSH();
321 setup_memblock();
322
323 max_addr = memblock_end_of_DRAM();
324 min_addr = max_addr - r2_size;
325 reserved_base = min_addr - r1_size;
326
327 memblock_reserve_kern(reserved_base, r1_size);
328
329 allocated_ptr = run_memblock_alloc_nid(r2_size, SMP_CACHE_BYTES,
330 min_addr, max_addr,
331 NUMA_NO_NODE);
332
333 ASSERT_NE(allocated_ptr, NULL);
334 assert_mem_content(allocated_ptr, r2_size, alloc_nid_test_flags);
335
336 ASSERT_EQ(rgn->size, total_size);
337 ASSERT_EQ(rgn->base, reserved_base);
338
339 ASSERT_EQ(memblock.reserved.cnt, 1);
340 ASSERT_EQ(memblock.reserved.total_size, total_size);
341
342 test_pass_pop();
343
344 return 0;
345}
346
347/*
348 * A test that tries to allocate a memory region within min_addr and max_addr,
349 * with max_addr being so close that it's next to an allocated region:
350 *
351 * + +
352 * | +-------------+--------|
353 * | | rgn | r1 |
354 * +----------+-------------+--------+
355 * ^ ^
356 * | |
357 * min_addr max_addr
358 *
359 * Expect a merge of regions. Only the region size gets updated.
360 */
361static int alloc_nid_max_reserved_generic_check(void)
362{
363 struct memblock_region *rgn = &memblock.reserved.regions[0];
364 void *allocated_ptr = NULL;
365 phys_addr_t r1_size = SZ_64;
366 phys_addr_t r2_size = SZ_128;
367 phys_addr_t total_size = r1_size + r2_size;
368 phys_addr_t min_addr;
369 phys_addr_t max_addr;
370
371 PREFIX_PUSH();
372 setup_memblock();
373
374 max_addr = memblock_end_of_DRAM() - r1_size;
375 min_addr = max_addr - r2_size;
376
377 memblock_reserve_kern(max_addr, r1_size);
378
379 allocated_ptr = run_memblock_alloc_nid(r2_size, SMP_CACHE_BYTES,
380 min_addr, max_addr,
381 NUMA_NO_NODE);
382
383 ASSERT_NE(allocated_ptr, NULL);
384 assert_mem_content(allocated_ptr, r2_size, alloc_nid_test_flags);
385
386 ASSERT_EQ(rgn->size, total_size);
387 ASSERT_EQ(rgn->base, min_addr);
388
389 ASSERT_EQ(memblock.reserved.cnt, 1);
390 ASSERT_EQ(memblock.reserved.total_size, total_size);
391
392 test_pass_pop();
393
394 return 0;
395}
396
397/*
398 * A test that tries to allocate memory within min_addr and max_add range, when
399 * there are two reserved regions at the borders, with a gap big enough to fit
400 * a new region:
401 *
402 * + +
403 * | +--------+ +-------+------+ |
404 * | | r2 | | rgn | r1 | |
405 * +----+--------+---+-------+------+--+
406 * ^ ^
407 * | |
408 * min_addr max_addr
409 *
410 * Expect to merge the new region with r1. The second region does not get
411 * updated. The total size field gets updated.
412 */
413
414static int alloc_nid_top_down_reserved_with_space_check(void)
415{
416 struct memblock_region *rgn1 = &memblock.reserved.regions[1];
417 struct memblock_region *rgn2 = &memblock.reserved.regions[0];
418 void *allocated_ptr = NULL;
419 struct region r1, r2;
420 phys_addr_t r3_size = SZ_64;
421 phys_addr_t gap_size = SMP_CACHE_BYTES;
422 phys_addr_t total_size;
423 phys_addr_t max_addr;
424 phys_addr_t min_addr;
425
426 PREFIX_PUSH();
427 setup_memblock();
428
429 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
430 r1.size = SMP_CACHE_BYTES;
431
432 r2.size = SZ_128;
433 r2.base = r1.base - (r3_size + gap_size + r2.size);
434
435 total_size = r1.size + r2.size + r3_size;
436 min_addr = r2.base + r2.size;
437 max_addr = r1.base;
438
439 memblock_reserve_kern(r1.base, r1.size);
440 memblock_reserve_kern(r2.base, r2.size);
441
442 allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES,
443 min_addr, max_addr,
444 NUMA_NO_NODE);
445
446 ASSERT_NE(allocated_ptr, NULL);
447 assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags);
448
449 ASSERT_EQ(rgn1->size, r1.size + r3_size);
450 ASSERT_EQ(rgn1->base, max_addr - r3_size);
451
452 ASSERT_EQ(rgn2->size, r2.size);
453 ASSERT_EQ(rgn2->base, r2.base);
454
455 ASSERT_EQ(memblock.reserved.cnt, 2);
456 ASSERT_EQ(memblock.reserved.total_size, total_size);
457
458 test_pass_pop();
459
460 return 0;
461}
462
463/*
464 * A test that tries to allocate memory within min_addr and max_add range, when
465 * there are two reserved regions at the borders, with a gap of a size equal to
466 * the size of the new region:
467 *
468 * + +
469 * | +--------+--------+--------+ |
470 * | | r2 | r3 | r1 | |
471 * +-----+--------+--------+--------+-----+
472 * ^ ^
473 * | |
474 * min_addr max_addr
475 *
476 * Expect to merge all of the regions into one. The region counter and total
477 * size fields get updated.
478 */
479static int alloc_nid_reserved_full_merge_generic_check(void)
480{
481 struct memblock_region *rgn = &memblock.reserved.regions[0];
482 void *allocated_ptr = NULL;
483 struct region r1, r2;
484 phys_addr_t r3_size = SZ_64;
485 phys_addr_t total_size;
486 phys_addr_t max_addr;
487 phys_addr_t min_addr;
488
489 PREFIX_PUSH();
490 setup_memblock();
491
492 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
493 r1.size = SMP_CACHE_BYTES;
494
495 r2.size = SZ_128;
496 r2.base = r1.base - (r3_size + r2.size);
497
498 total_size = r1.size + r2.size + r3_size;
499 min_addr = r2.base + r2.size;
500 max_addr = r1.base;
501
502 memblock_reserve_kern(r1.base, r1.size);
503 memblock_reserve_kern(r2.base, r2.size);
504
505 allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES,
506 min_addr, max_addr,
507 NUMA_NO_NODE);
508
509 ASSERT_NE(allocated_ptr, NULL);
510 assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags);
511
512 ASSERT_EQ(rgn->size, total_size);
513 ASSERT_EQ(rgn->base, r2.base);
514
515 ASSERT_EQ(memblock.reserved.cnt, 1);
516 ASSERT_EQ(memblock.reserved.total_size, total_size);
517
518 test_pass_pop();
519
520 return 0;
521}
522
523/*
524 * A test that tries to allocate memory within min_addr and max_add range, when
525 * there are two reserved regions at the borders, with a gap that can't fit
526 * a new region:
527 *
528 * + +
529 * | +----------+------+ +------+ |
530 * | | r3 | r2 | | r1 | |
531 * +--+----------+------+----+------+---+
532 * ^ ^
533 * | |
534 * | max_addr
535 * |
536 * min_addr
537 *
538 * Expect to merge the new region with r2. The second region does not get
539 * updated. The total size counter gets updated.
540 */
541static int alloc_nid_top_down_reserved_no_space_check(void)
542{
543 struct memblock_region *rgn1 = &memblock.reserved.regions[1];
544 struct memblock_region *rgn2 = &memblock.reserved.regions[0];
545 void *allocated_ptr = NULL;
546 struct region r1, r2;
547 phys_addr_t r3_size = SZ_256;
548 phys_addr_t gap_size = SMP_CACHE_BYTES;
549 phys_addr_t total_size;
550 phys_addr_t max_addr;
551 phys_addr_t min_addr;
552
553 PREFIX_PUSH();
554 setup_memblock();
555
556 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
557 r1.size = SMP_CACHE_BYTES;
558
559 r2.size = SZ_128;
560 r2.base = r1.base - (r2.size + gap_size);
561
562 total_size = r1.size + r2.size + r3_size;
563 min_addr = r2.base + r2.size;
564 max_addr = r1.base;
565
566 memblock_reserve_kern(r1.base, r1.size);
567 memblock_reserve_kern(r2.base, r2.size);
568
569 allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES,
570 min_addr, max_addr,
571 NUMA_NO_NODE);
572
573 ASSERT_NE(allocated_ptr, NULL);
574 assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags);
575
576 ASSERT_EQ(rgn1->size, r1.size);
577 ASSERT_EQ(rgn1->base, r1.base);
578
579 ASSERT_EQ(rgn2->size, r2.size + r3_size);
580 ASSERT_EQ(rgn2->base, r2.base - r3_size);
581
582 ASSERT_EQ(memblock.reserved.cnt, 2);
583 ASSERT_EQ(memblock.reserved.total_size, total_size);
584
585 test_pass_pop();
586
587 return 0;
588}
589
590/*
591 * A test that tries to allocate memory within min_addr and max_add range, but
592 * it's too narrow and everything else is reserved:
593 *
594 * +-----------+
595 * | new |
596 * +-----------+
597 * + +
598 * |--------------+ +----------|
599 * | r2 | | r1 |
600 * +--------------+------+----------+
601 * ^ ^
602 * | |
603 * | max_addr
604 * |
605 * min_addr
606 *
607 * Expect no allocation to happen.
608 */
609
610static int alloc_nid_reserved_all_generic_check(void)
611{
612 void *allocated_ptr = NULL;
613 struct region r1, r2;
614 phys_addr_t r3_size = SZ_256;
615 phys_addr_t gap_size = SMP_CACHE_BYTES;
616 phys_addr_t max_addr;
617 phys_addr_t min_addr;
618
619 PREFIX_PUSH();
620 setup_memblock();
621
622 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES;
623 r1.size = SMP_CACHE_BYTES;
624
625 r2.size = MEM_SIZE - (r1.size + gap_size);
626 r2.base = memblock_start_of_DRAM();
627
628 min_addr = r2.base + r2.size;
629 max_addr = r1.base;
630
631 memblock_reserve(r1.base, r1.size);
632 memblock_reserve(r2.base, r2.size);
633
634 allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES,
635 min_addr, max_addr,
636 NUMA_NO_NODE);
637
638 ASSERT_EQ(allocated_ptr, NULL);
639
640 test_pass_pop();
641
642 return 0;
643}
644
645/*
646 * A test that tries to allocate a memory region, where max_addr is
647 * bigger than the end address of the available memory. Expect to allocate
648 * a region that ends before the end of the memory.
649 */
650static int alloc_nid_top_down_cap_max_check(void)
651{
652 struct memblock_region *rgn = &memblock.reserved.regions[0];
653 void *allocated_ptr = NULL;
654 phys_addr_t size = SZ_256;
655 phys_addr_t min_addr;
656 phys_addr_t max_addr;
657
658 PREFIX_PUSH();
659 setup_memblock();
660
661 min_addr = memblock_end_of_DRAM() - SZ_1K;
662 max_addr = memblock_end_of_DRAM() + SZ_256;
663
664 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
665 min_addr, max_addr,
666 NUMA_NO_NODE);
667
668 ASSERT_NE(allocated_ptr, NULL);
669 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
670
671 ASSERT_EQ(rgn->size, size);
672 ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
673
674 ASSERT_EQ(memblock.reserved.cnt, 1);
675 ASSERT_EQ(memblock.reserved.total_size, size);
676
677 test_pass_pop();
678
679 return 0;
680}
681
682/*
683 * A test that tries to allocate a memory region, where min_addr is
684 * smaller than the start address of the available memory. Expect to allocate
685 * a region that ends before the end of the memory.
686 */
687static int alloc_nid_top_down_cap_min_check(void)
688{
689 struct memblock_region *rgn = &memblock.reserved.regions[0];
690 void *allocated_ptr = NULL;
691 phys_addr_t size = SZ_1K;
692 phys_addr_t min_addr;
693 phys_addr_t max_addr;
694
695 PREFIX_PUSH();
696 setup_memblock();
697
698 min_addr = memblock_start_of_DRAM() - SZ_256;
699 max_addr = memblock_end_of_DRAM();
700
701 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
702 min_addr, max_addr,
703 NUMA_NO_NODE);
704
705 ASSERT_NE(allocated_ptr, NULL);
706 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
707
708 ASSERT_EQ(rgn->size, size);
709 ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
710
711 ASSERT_EQ(memblock.reserved.cnt, 1);
712 ASSERT_EQ(memblock.reserved.total_size, size);
713
714 test_pass_pop();
715
716 return 0;
717}
718
719/*
720 * A simple test that tries to allocate a memory region within min_addr and
721 * max_addr range:
722 *
723 * + +
724 * | +-----------+ | |
725 * | | rgn | | |
726 * +----+-----------+-----------+------+
727 * ^ ^
728 * | |
729 * min_addr max_addr
730 *
731 * Expect to allocate a region that ends before max_addr.
732 */
733static int alloc_nid_bottom_up_simple_check(void)
734{
735 struct memblock_region *rgn = &memblock.reserved.regions[0];
736 void *allocated_ptr = NULL;
737 phys_addr_t size = SZ_128;
738 phys_addr_t min_addr;
739 phys_addr_t max_addr;
740 phys_addr_t rgn_end;
741
742 PREFIX_PUSH();
743 setup_memblock();
744
745 min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
746 max_addr = min_addr + SZ_512;
747
748 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
749 min_addr, max_addr,
750 NUMA_NO_NODE);
751 rgn_end = rgn->base + rgn->size;
752
753 ASSERT_NE(allocated_ptr, NULL);
754 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
755
756 ASSERT_EQ(rgn->size, size);
757 ASSERT_EQ(rgn->base, min_addr);
758 ASSERT_LT(rgn_end, max_addr);
759
760 ASSERT_EQ(memblock.reserved.cnt, 1);
761 ASSERT_EQ(memblock.reserved.total_size, size);
762
763 test_pass_pop();
764
765 return 0;
766}
767
768/*
769 * A simple test that tries to allocate a memory region within min_addr and
770 * max_addr range, where the start address is misaligned:
771 *
772 * + +
773 * | + +-----------+ + |
774 * | | | rgn | | |
775 * +-----+---+-----------+-----+-----+
776 * ^ ^----. ^
777 * | | |
778 * min_add | max_addr
779 * |
780 * Aligned address
781 * boundary
782 *
783 * Expect to allocate an aligned region that ends before max_addr.
784 */
785static int alloc_nid_bottom_up_start_misaligned_check(void)
786{
787 struct memblock_region *rgn = &memblock.reserved.regions[0];
788 void *allocated_ptr = NULL;
789 phys_addr_t size = SZ_128;
790 phys_addr_t misalign = SZ_2;
791 phys_addr_t min_addr;
792 phys_addr_t max_addr;
793 phys_addr_t rgn_end;
794
795 PREFIX_PUSH();
796 setup_memblock();
797
798 min_addr = memblock_start_of_DRAM() + misalign;
799 max_addr = min_addr + SZ_512;
800
801 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
802 min_addr, max_addr,
803 NUMA_NO_NODE);
804 rgn_end = rgn->base + rgn->size;
805
806 ASSERT_NE(allocated_ptr, NULL);
807 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
808
809 ASSERT_EQ(rgn->size, size);
810 ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
811 ASSERT_LT(rgn_end, max_addr);
812
813 ASSERT_EQ(memblock.reserved.cnt, 1);
814 ASSERT_EQ(memblock.reserved.total_size, size);
815
816 test_pass_pop();
817
818 return 0;
819}
820
821/*
822 * A test that tries to allocate a memory region, which can't fit into min_addr
823 * and max_addr range:
824 *
825 * + +
826 * |---------+ + + |
827 * | rgn | | | |
828 * +---------+---------+----+------+
829 * ^ ^
830 * | |
831 * | max_addr
832 * |
833 * min_add
834 *
835 * Expect to drop the lower limit and allocate a memory region which
836 * starts at the beginning of the available memory.
837 */
838static int alloc_nid_bottom_up_narrow_range_check(void)
839{
840 struct memblock_region *rgn = &memblock.reserved.regions[0];
841 void *allocated_ptr = NULL;
842 phys_addr_t size = SZ_256;
843 phys_addr_t min_addr;
844 phys_addr_t max_addr;
845
846 PREFIX_PUSH();
847 setup_memblock();
848
849 min_addr = memblock_start_of_DRAM() + SZ_512;
850 max_addr = min_addr + SMP_CACHE_BYTES;
851
852 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
853 min_addr, max_addr,
854 NUMA_NO_NODE);
855
856 ASSERT_NE(allocated_ptr, NULL);
857 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
858
859 ASSERT_EQ(rgn->size, size);
860 ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
861
862 ASSERT_EQ(memblock.reserved.cnt, 1);
863 ASSERT_EQ(memblock.reserved.total_size, size);
864
865 test_pass_pop();
866
867 return 0;
868}
869
870/*
871 * A test that tries to allocate memory within min_addr and max_add range, when
872 * there are two reserved regions at the borders, with a gap big enough to fit
873 * a new region:
874 *
875 * + +
876 * | +--------+-------+ +------+ |
877 * | | r2 | rgn | | r1 | |
878 * +----+--------+-------+---+------+--+
879 * ^ ^
880 * | |
881 * min_addr max_addr
882 *
883 * Expect to merge the new region with r2. The second region does not get
884 * updated. The total size field gets updated.
885 */
886
887static int alloc_nid_bottom_up_reserved_with_space_check(void)
888{
889 struct memblock_region *rgn1 = &memblock.reserved.regions[1];
890 struct memblock_region *rgn2 = &memblock.reserved.regions[0];
891 void *allocated_ptr = NULL;
892 struct region r1, r2;
893 phys_addr_t r3_size = SZ_64;
894 phys_addr_t gap_size = SMP_CACHE_BYTES;
895 phys_addr_t total_size;
896 phys_addr_t max_addr;
897 phys_addr_t min_addr;
898
899 PREFIX_PUSH();
900 setup_memblock();
901
902 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
903 r1.size = SMP_CACHE_BYTES;
904
905 r2.size = SZ_128;
906 r2.base = r1.base - (r3_size + gap_size + r2.size);
907
908 total_size = r1.size + r2.size + r3_size;
909 min_addr = r2.base + r2.size;
910 max_addr = r1.base;
911
912 memblock_reserve_kern(r1.base, r1.size);
913 memblock_reserve_kern(r2.base, r2.size);
914
915 allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES,
916 min_addr, max_addr,
917 NUMA_NO_NODE);
918
919 ASSERT_NE(allocated_ptr, NULL);
920 assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags);
921
922 ASSERT_EQ(rgn1->size, r1.size);
923 ASSERT_EQ(rgn1->base, max_addr);
924
925 ASSERT_EQ(rgn2->size, r2.size + r3_size);
926 ASSERT_EQ(rgn2->base, r2.base);
927
928 ASSERT_EQ(memblock.reserved.cnt, 2);
929 ASSERT_EQ(memblock.reserved.total_size, total_size);
930
931 test_pass_pop();
932
933 return 0;
934}
935
936/*
937 * A test that tries to allocate memory within min_addr and max_add range, when
938 * there are two reserved regions at the borders, with a gap of a size equal to
939 * the size of the new region:
940 *
941 * + +
942 * |----------+ +------+ +----+ |
943 * | r3 | | r2 | | r1 | |
944 * +----------+----+------+---+----+--+
945 * ^ ^
946 * | |
947 * | max_addr
948 * |
949 * min_addr
950 *
951 * Expect to drop the lower limit and allocate memory at the beginning of the
952 * available memory. The region counter and total size fields get updated.
953 * Other regions are not modified.
954 */
955
956static int alloc_nid_bottom_up_reserved_no_space_check(void)
957{
958 struct memblock_region *rgn1 = &memblock.reserved.regions[2];
959 struct memblock_region *rgn2 = &memblock.reserved.regions[1];
960 struct memblock_region *rgn3 = &memblock.reserved.regions[0];
961 void *allocated_ptr = NULL;
962 struct region r1, r2;
963 phys_addr_t r3_size = SZ_256;
964 phys_addr_t gap_size = SMP_CACHE_BYTES;
965 phys_addr_t total_size;
966 phys_addr_t max_addr;
967 phys_addr_t min_addr;
968
969 PREFIX_PUSH();
970 setup_memblock();
971
972 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
973 r1.size = SMP_CACHE_BYTES;
974
975 r2.size = SZ_128;
976 r2.base = r1.base - (r2.size + gap_size);
977
978 total_size = r1.size + r2.size + r3_size;
979 min_addr = r2.base + r2.size;
980 max_addr = r1.base;
981
982 memblock_reserve(r1.base, r1.size);
983 memblock_reserve(r2.base, r2.size);
984
985 allocated_ptr = run_memblock_alloc_nid(r3_size, SMP_CACHE_BYTES,
986 min_addr, max_addr,
987 NUMA_NO_NODE);
988
989 ASSERT_NE(allocated_ptr, NULL);
990 assert_mem_content(allocated_ptr, r3_size, alloc_nid_test_flags);
991
992 ASSERT_EQ(rgn3->size, r3_size);
993 ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
994
995 ASSERT_EQ(rgn2->size, r2.size);
996 ASSERT_EQ(rgn2->base, r2.base);
997
998 ASSERT_EQ(rgn1->size, r1.size);
999 ASSERT_EQ(rgn1->base, r1.base);
1000
1001 ASSERT_EQ(memblock.reserved.cnt, 3);
1002 ASSERT_EQ(memblock.reserved.total_size, total_size);
1003
1004 test_pass_pop();
1005
1006 return 0;
1007}
1008
1009/*
1010 * A test that tries to allocate a memory region, where max_addr is
1011 * bigger than the end address of the available memory. Expect to allocate
1012 * a region that starts at the min_addr.
1013 */
1014static int alloc_nid_bottom_up_cap_max_check(void)
1015{
1016 struct memblock_region *rgn = &memblock.reserved.regions[0];
1017 void *allocated_ptr = NULL;
1018 phys_addr_t size = SZ_256;
1019 phys_addr_t min_addr;
1020 phys_addr_t max_addr;
1021
1022 PREFIX_PUSH();
1023 setup_memblock();
1024
1025 min_addr = memblock_start_of_DRAM() + SZ_1K;
1026 max_addr = memblock_end_of_DRAM() + SZ_256;
1027
1028 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1029 min_addr, max_addr,
1030 NUMA_NO_NODE);
1031
1032 ASSERT_NE(allocated_ptr, NULL);
1033 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1034
1035 ASSERT_EQ(rgn->size, size);
1036 ASSERT_EQ(rgn->base, min_addr);
1037
1038 ASSERT_EQ(memblock.reserved.cnt, 1);
1039 ASSERT_EQ(memblock.reserved.total_size, size);
1040
1041 test_pass_pop();
1042
1043 return 0;
1044}
1045
1046/*
1047 * A test that tries to allocate a memory region, where min_addr is
1048 * smaller than the start address of the available memory. Expect to allocate
1049 * a region at the beginning of the available memory.
1050 */
1051static int alloc_nid_bottom_up_cap_min_check(void)
1052{
1053 struct memblock_region *rgn = &memblock.reserved.regions[0];
1054 void *allocated_ptr = NULL;
1055 phys_addr_t size = SZ_1K;
1056 phys_addr_t min_addr;
1057 phys_addr_t max_addr;
1058
1059 PREFIX_PUSH();
1060 setup_memblock();
1061
1062 min_addr = memblock_start_of_DRAM();
1063 max_addr = memblock_end_of_DRAM() - SZ_256;
1064
1065 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1066 min_addr, max_addr,
1067 NUMA_NO_NODE);
1068
1069 ASSERT_NE(allocated_ptr, NULL);
1070 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1071
1072 ASSERT_EQ(rgn->size, size);
1073 ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
1074
1075 ASSERT_EQ(memblock.reserved.cnt, 1);
1076 ASSERT_EQ(memblock.reserved.total_size, size);
1077
1078 test_pass_pop();
1079
1080 return 0;
1081}
1082
1083/* Test case wrappers for range tests */
1084static int alloc_nid_simple_check(void)
1085{
1086 test_print("\tRunning %s...\n", __func__);
1087 memblock_set_bottom_up(false);
1088 alloc_nid_top_down_simple_check();
1089 memblock_set_bottom_up(true);
1090 alloc_nid_bottom_up_simple_check();
1091
1092 return 0;
1093}
1094
1095static int alloc_nid_misaligned_check(void)
1096{
1097 test_print("\tRunning %s...\n", __func__);
1098 memblock_set_bottom_up(false);
1099 alloc_nid_top_down_end_misaligned_check();
1100 memblock_set_bottom_up(true);
1101 alloc_nid_bottom_up_start_misaligned_check();
1102
1103 return 0;
1104}
1105
1106static int alloc_nid_narrow_range_check(void)
1107{
1108 test_print("\tRunning %s...\n", __func__);
1109 memblock_set_bottom_up(false);
1110 alloc_nid_top_down_narrow_range_check();
1111 memblock_set_bottom_up(true);
1112 alloc_nid_bottom_up_narrow_range_check();
1113
1114 return 0;
1115}
1116
1117static int alloc_nid_reserved_with_space_check(void)
1118{
1119 test_print("\tRunning %s...\n", __func__);
1120 memblock_set_bottom_up(false);
1121 alloc_nid_top_down_reserved_with_space_check();
1122 memblock_set_bottom_up(true);
1123 alloc_nid_bottom_up_reserved_with_space_check();
1124
1125 return 0;
1126}
1127
1128static int alloc_nid_reserved_no_space_check(void)
1129{
1130 test_print("\tRunning %s...\n", __func__);
1131 memblock_set_bottom_up(false);
1132 alloc_nid_top_down_reserved_no_space_check();
1133 memblock_set_bottom_up(true);
1134 alloc_nid_bottom_up_reserved_no_space_check();
1135
1136 return 0;
1137}
1138
1139static int alloc_nid_cap_max_check(void)
1140{
1141 test_print("\tRunning %s...\n", __func__);
1142 memblock_set_bottom_up(false);
1143 alloc_nid_top_down_cap_max_check();
1144 memblock_set_bottom_up(true);
1145 alloc_nid_bottom_up_cap_max_check();
1146
1147 return 0;
1148}
1149
1150static int alloc_nid_cap_min_check(void)
1151{
1152 test_print("\tRunning %s...\n", __func__);
1153 memblock_set_bottom_up(false);
1154 alloc_nid_top_down_cap_min_check();
1155 memblock_set_bottom_up(true);
1156 alloc_nid_bottom_up_cap_min_check();
1157
1158 return 0;
1159}
1160
1161static int alloc_nid_min_reserved_check(void)
1162{
1163 test_print("\tRunning %s...\n", __func__);
1164 run_top_down(alloc_nid_min_reserved_generic_check);
1165 run_bottom_up(alloc_nid_min_reserved_generic_check);
1166
1167 return 0;
1168}
1169
1170static int alloc_nid_max_reserved_check(void)
1171{
1172 test_print("\tRunning %s...\n", __func__);
1173 run_top_down(alloc_nid_max_reserved_generic_check);
1174 run_bottom_up(alloc_nid_max_reserved_generic_check);
1175
1176 return 0;
1177}
1178
1179static int alloc_nid_exact_address_check(void)
1180{
1181 test_print("\tRunning %s...\n", __func__);
1182 run_top_down(alloc_nid_exact_address_generic_check);
1183 run_bottom_up(alloc_nid_exact_address_generic_check);
1184
1185 return 0;
1186}
1187
1188static int alloc_nid_reserved_full_merge_check(void)
1189{
1190 test_print("\tRunning %s...\n", __func__);
1191 run_top_down(alloc_nid_reserved_full_merge_generic_check);
1192 run_bottom_up(alloc_nid_reserved_full_merge_generic_check);
1193
1194 return 0;
1195}
1196
1197static int alloc_nid_reserved_all_check(void)
1198{
1199 test_print("\tRunning %s...\n", __func__);
1200 run_top_down(alloc_nid_reserved_all_generic_check);
1201 run_bottom_up(alloc_nid_reserved_all_generic_check);
1202
1203 return 0;
1204}
1205
1206static int alloc_nid_low_max_check(void)
1207{
1208 test_print("\tRunning %s...\n", __func__);
1209 run_top_down(alloc_nid_low_max_generic_check);
1210 run_bottom_up(alloc_nid_low_max_generic_check);
1211
1212 return 0;
1213}
1214
1215static int memblock_alloc_nid_range_checks(void)
1216{
1217 test_print("Running %s range tests...\n",
1218 get_memblock_alloc_nid_name(alloc_nid_test_flags));
1219
1220 alloc_nid_simple_check();
1221 alloc_nid_misaligned_check();
1222 alloc_nid_narrow_range_check();
1223 alloc_nid_reserved_with_space_check();
1224 alloc_nid_reserved_no_space_check();
1225 alloc_nid_cap_max_check();
1226 alloc_nid_cap_min_check();
1227
1228 alloc_nid_min_reserved_check();
1229 alloc_nid_max_reserved_check();
1230 alloc_nid_exact_address_check();
1231 alloc_nid_reserved_full_merge_check();
1232 alloc_nid_reserved_all_check();
1233 alloc_nid_low_max_check();
1234
1235 return 0;
1236}
1237
1238/*
1239 * A test that tries to allocate a memory region in a specific NUMA node that
1240 * has enough memory to allocate a region of the requested size.
1241 * Expect to allocate an aligned region at the end of the requested node.
1242 */
1243static int alloc_nid_top_down_numa_simple_check(void)
1244{
1245 int nid_req = 3;
1246 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1247 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1248 void *allocated_ptr = NULL;
1249 phys_addr_t size;
1250 phys_addr_t min_addr;
1251 phys_addr_t max_addr;
1252
1253 PREFIX_PUSH();
1254 setup_numa_memblock(node_fractions);
1255
1256 ASSERT_LE(SZ_4, req_node->size);
1257 size = req_node->size / SZ_4;
1258 min_addr = memblock_start_of_DRAM();
1259 max_addr = memblock_end_of_DRAM();
1260
1261 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1262 min_addr, max_addr, nid_req);
1263
1264 ASSERT_NE(allocated_ptr, NULL);
1265 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1266
1267 ASSERT_EQ(new_rgn->size, size);
1268 ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
1269 ASSERT_LE(req_node->base, new_rgn->base);
1270
1271 ASSERT_EQ(memblock.reserved.cnt, 1);
1272 ASSERT_EQ(memblock.reserved.total_size, size);
1273
1274 test_pass_pop();
1275
1276 return 0;
1277}
1278
1279/*
1280 * A test that tries to allocate a memory region in a specific NUMA node that
1281 * does not have enough memory to allocate a region of the requested size:
1282 *
1283 * | +-----+ +------------------+ |
1284 * | | req | | expected | |
1285 * +---+-----+----------+------------------+-----+
1286 *
1287 * | +---------+ |
1288 * | | rgn | |
1289 * +-----------------------------+---------+-----+
1290 *
1291 * Expect to allocate an aligned region at the end of the last node that has
1292 * enough memory (in this case, nid = 6) after falling back to NUMA_NO_NODE.
1293 */
1294static int alloc_nid_top_down_numa_small_node_check(void)
1295{
1296 int nid_req = 1;
1297 int nid_exp = 6;
1298 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1299 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1300 struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1301 void *allocated_ptr = NULL;
1302 phys_addr_t size;
1303 phys_addr_t min_addr;
1304 phys_addr_t max_addr;
1305
1306 PREFIX_PUSH();
1307 setup_numa_memblock(node_fractions);
1308
1309 size = SZ_2 * req_node->size;
1310 min_addr = memblock_start_of_DRAM();
1311 max_addr = memblock_end_of_DRAM();
1312
1313 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1314 min_addr, max_addr, nid_req);
1315
1316 ASSERT_NE(allocated_ptr, NULL);
1317 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1318
1319 ASSERT_EQ(new_rgn->size, size);
1320 ASSERT_EQ(new_rgn->base, region_end(exp_node) - size);
1321 ASSERT_LE(exp_node->base, new_rgn->base);
1322
1323 ASSERT_EQ(memblock.reserved.cnt, 1);
1324 ASSERT_EQ(memblock.reserved.total_size, size);
1325
1326 test_pass_pop();
1327
1328 return 0;
1329}
1330
1331/*
1332 * A test that tries to allocate a memory region in a specific NUMA node that
1333 * is fully reserved:
1334 *
1335 * | +---------+ +------------------+ |
1336 * | |requested| | expected | |
1337 * +--------------+---------+------------+------------------+-----+
1338 *
1339 * | +---------+ +---------+ |
1340 * | | reserved| | new | |
1341 * +--------------+---------+---------------------+---------+-----+
1342 *
1343 * Expect to allocate an aligned region at the end of the last node that is
1344 * large enough and has enough unreserved memory (in this case, nid = 6) after
1345 * falling back to NUMA_NO_NODE. The region count and total size get updated.
1346 */
1347static int alloc_nid_top_down_numa_node_reserved_check(void)
1348{
1349 int nid_req = 2;
1350 int nid_exp = 6;
1351 struct memblock_region *new_rgn = &memblock.reserved.regions[1];
1352 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1353 struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1354 void *allocated_ptr = NULL;
1355 phys_addr_t size;
1356 phys_addr_t min_addr;
1357 phys_addr_t max_addr;
1358
1359 PREFIX_PUSH();
1360 setup_numa_memblock(node_fractions);
1361
1362 size = req_node->size;
1363 min_addr = memblock_start_of_DRAM();
1364 max_addr = memblock_end_of_DRAM();
1365
1366 memblock_reserve(req_node->base, req_node->size);
1367 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1368 min_addr, max_addr, nid_req);
1369
1370 ASSERT_NE(allocated_ptr, NULL);
1371 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1372
1373 ASSERT_EQ(new_rgn->size, size);
1374 ASSERT_EQ(new_rgn->base, region_end(exp_node) - size);
1375 ASSERT_LE(exp_node->base, new_rgn->base);
1376
1377 ASSERT_EQ(memblock.reserved.cnt, 2);
1378 ASSERT_EQ(memblock.reserved.total_size, size + req_node->size);
1379
1380 test_pass_pop();
1381
1382 return 0;
1383}
1384
1385/*
1386 * A test that tries to allocate a memory region in a specific NUMA node that
1387 * is partially reserved but has enough memory for the allocated region:
1388 *
1389 * | +---------------------------------------+ |
1390 * | | requested | |
1391 * +-----------+---------------------------------------+----------+
1392 *
1393 * | +------------------+ +-----+ |
1394 * | | reserved | | new | |
1395 * +-----------+------------------+--------------+-----+----------+
1396 *
1397 * Expect to allocate an aligned region at the end of the requested node. The
1398 * region count and total size get updated.
1399 */
1400static int alloc_nid_top_down_numa_part_reserved_check(void)
1401{
1402 int nid_req = 4;
1403 struct memblock_region *new_rgn = &memblock.reserved.regions[1];
1404 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1405 void *allocated_ptr = NULL;
1406 struct region r1;
1407 phys_addr_t size;
1408 phys_addr_t min_addr;
1409 phys_addr_t max_addr;
1410
1411 PREFIX_PUSH();
1412 setup_numa_memblock(node_fractions);
1413
1414 ASSERT_LE(SZ_8, req_node->size);
1415 r1.base = req_node->base;
1416 r1.size = req_node->size / SZ_2;
1417 size = r1.size / SZ_4;
1418 min_addr = memblock_start_of_DRAM();
1419 max_addr = memblock_end_of_DRAM();
1420
1421 memblock_reserve(r1.base, r1.size);
1422 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1423 min_addr, max_addr, nid_req);
1424
1425 ASSERT_NE(allocated_ptr, NULL);
1426 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1427
1428 ASSERT_EQ(new_rgn->size, size);
1429 ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
1430 ASSERT_LE(req_node->base, new_rgn->base);
1431
1432 ASSERT_EQ(memblock.reserved.cnt, 2);
1433 ASSERT_EQ(memblock.reserved.total_size, size + r1.size);
1434
1435 test_pass_pop();
1436
1437 return 0;
1438}
1439
1440/*
1441 * A test that tries to allocate a memory region in a specific NUMA node that
1442 * is partially reserved and does not have enough contiguous memory for the
1443 * allocated region:
1444 *
1445 * | +-----------------------+ +----------------------|
1446 * | | requested | | expected |
1447 * +-----------+-----------------------+---------+----------------------+
1448 *
1449 * | +----------+ +-----------|
1450 * | | reserved | | new |
1451 * +-----------------+----------+---------------------------+-----------+
1452 *
1453 * Expect to allocate an aligned region at the end of the last node that is
1454 * large enough and has enough unreserved memory (in this case,
1455 * nid = NUMA_NODES - 1) after falling back to NUMA_NO_NODE. The region count
1456 * and total size get updated.
1457 */
1458static int alloc_nid_top_down_numa_part_reserved_fallback_check(void)
1459{
1460 int nid_req = 4;
1461 int nid_exp = NUMA_NODES - 1;
1462 struct memblock_region *new_rgn = &memblock.reserved.regions[1];
1463 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1464 struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1465 void *allocated_ptr = NULL;
1466 struct region r1;
1467 phys_addr_t size;
1468 phys_addr_t min_addr;
1469 phys_addr_t max_addr;
1470
1471 PREFIX_PUSH();
1472 setup_numa_memblock(node_fractions);
1473
1474 ASSERT_LE(SZ_4, req_node->size);
1475 size = req_node->size / SZ_2;
1476 r1.base = req_node->base + (size / SZ_2);
1477 r1.size = size;
1478
1479 min_addr = memblock_start_of_DRAM();
1480 max_addr = memblock_end_of_DRAM();
1481
1482 memblock_reserve(r1.base, r1.size);
1483 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1484 min_addr, max_addr, nid_req);
1485
1486 ASSERT_NE(allocated_ptr, NULL);
1487 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1488
1489 ASSERT_EQ(new_rgn->size, size);
1490 ASSERT_EQ(new_rgn->base, region_end(exp_node) - size);
1491 ASSERT_LE(exp_node->base, new_rgn->base);
1492
1493 ASSERT_EQ(memblock.reserved.cnt, 2);
1494 ASSERT_EQ(memblock.reserved.total_size, size + r1.size);
1495
1496 test_pass_pop();
1497
1498 return 0;
1499}
1500
1501/*
1502 * A test that tries to allocate a memory region that spans over the min_addr
1503 * and max_addr range and overlaps with two different nodes, where the first
1504 * node is the requested node:
1505 *
1506 * min_addr
1507 * | max_addr
1508 * | |
1509 * v v
1510 * | +-----------------------+-----------+ |
1511 * | | requested | node3 | |
1512 * +-----------+-----------------------+-----------+--------------+
1513 * + +
1514 * | +-----------+ |
1515 * | | rgn | |
1516 * +-----------------------+-----------+--------------------------+
1517 *
1518 * Expect to drop the lower limit and allocate a memory region that ends at
1519 * the end of the requested node.
1520 */
1521static int alloc_nid_top_down_numa_split_range_low_check(void)
1522{
1523 int nid_req = 2;
1524 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1525 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1526 void *allocated_ptr = NULL;
1527 phys_addr_t size = SZ_512;
1528 phys_addr_t min_addr;
1529 phys_addr_t max_addr;
1530 phys_addr_t req_node_end;
1531
1532 PREFIX_PUSH();
1533 setup_numa_memblock(node_fractions);
1534
1535 req_node_end = region_end(req_node);
1536 min_addr = req_node_end - SZ_256;
1537 max_addr = min_addr + size;
1538
1539 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1540 min_addr, max_addr, nid_req);
1541
1542 ASSERT_NE(allocated_ptr, NULL);
1543 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1544
1545 ASSERT_EQ(new_rgn->size, size);
1546 ASSERT_EQ(new_rgn->base, req_node_end - size);
1547 ASSERT_LE(req_node->base, new_rgn->base);
1548
1549 ASSERT_EQ(memblock.reserved.cnt, 1);
1550 ASSERT_EQ(memblock.reserved.total_size, size);
1551
1552 test_pass_pop();
1553
1554 return 0;
1555}
1556
1557/*
1558 * A test that tries to allocate a memory region that spans over the min_addr
1559 * and max_addr range and overlaps with two different nodes, where the second
1560 * node is the requested node:
1561 *
1562 * min_addr
1563 * | max_addr
1564 * | |
1565 * v v
1566 * | +--------------------------+---------+ |
1567 * | | expected |requested| |
1568 * +------+--------------------------+---------+----------------+
1569 * + +
1570 * | +---------+ |
1571 * | | rgn | |
1572 * +-----------------------+---------+--------------------------+
1573 *
1574 * Expect to drop the lower limit and allocate a memory region that
1575 * ends at the end of the first node that overlaps with the range.
1576 */
1577static int alloc_nid_top_down_numa_split_range_high_check(void)
1578{
1579 int nid_req = 3;
1580 int nid_exp = nid_req - 1;
1581 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1582 struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1583 void *allocated_ptr = NULL;
1584 phys_addr_t size = SZ_512;
1585 phys_addr_t min_addr;
1586 phys_addr_t max_addr;
1587 phys_addr_t exp_node_end;
1588
1589 PREFIX_PUSH();
1590 setup_numa_memblock(node_fractions);
1591
1592 exp_node_end = region_end(exp_node);
1593 min_addr = exp_node_end - SZ_256;
1594 max_addr = min_addr + size;
1595
1596 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1597 min_addr, max_addr, nid_req);
1598
1599 ASSERT_NE(allocated_ptr, NULL);
1600 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1601
1602 ASSERT_EQ(new_rgn->size, size);
1603 ASSERT_EQ(new_rgn->base, exp_node_end - size);
1604 ASSERT_LE(exp_node->base, new_rgn->base);
1605
1606 ASSERT_EQ(memblock.reserved.cnt, 1);
1607 ASSERT_EQ(memblock.reserved.total_size, size);
1608
1609 test_pass_pop();
1610
1611 return 0;
1612}
1613
1614/*
1615 * A test that tries to allocate a memory region that spans over the min_addr
1616 * and max_addr range and overlaps with two different nodes, where the requested
1617 * node ends before min_addr:
1618 *
1619 * min_addr
1620 * | max_addr
1621 * | |
1622 * v v
1623 * | +---------------+ +-------------+---------+ |
1624 * | | requested | | node1 | node2 | |
1625 * +----+---------------+--------+-------------+---------+----------+
1626 * + +
1627 * | +---------+ |
1628 * | | rgn | |
1629 * +----------+---------+-------------------------------------------+
1630 *
1631 * Expect to drop the lower limit and allocate a memory region that ends at
1632 * the end of the requested node.
1633 */
1634static int alloc_nid_top_down_numa_no_overlap_split_check(void)
1635{
1636 int nid_req = 2;
1637 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1638 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1639 struct memblock_region *node2 = &memblock.memory.regions[6];
1640 void *allocated_ptr = NULL;
1641 phys_addr_t size;
1642 phys_addr_t min_addr;
1643 phys_addr_t max_addr;
1644
1645 PREFIX_PUSH();
1646 setup_numa_memblock(node_fractions);
1647
1648 size = SZ_512;
1649 min_addr = node2->base - SZ_256;
1650 max_addr = min_addr + size;
1651
1652 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1653 min_addr, max_addr, nid_req);
1654
1655 ASSERT_NE(allocated_ptr, NULL);
1656 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1657
1658 ASSERT_EQ(new_rgn->size, size);
1659 ASSERT_EQ(new_rgn->base, region_end(req_node) - size);
1660 ASSERT_LE(req_node->base, new_rgn->base);
1661
1662 ASSERT_EQ(memblock.reserved.cnt, 1);
1663 ASSERT_EQ(memblock.reserved.total_size, size);
1664
1665 test_pass_pop();
1666
1667 return 0;
1668}
1669
1670/*
1671 * A test that tries to allocate memory within min_addr and max_add range when
1672 * the requested node and the range do not overlap, and requested node ends
1673 * before min_addr. The range overlaps with multiple nodes along node
1674 * boundaries:
1675 *
1676 * min_addr
1677 * | max_addr
1678 * | |
1679 * v v
1680 * |-----------+ +----------+----...----+----------+ |
1681 * | requested | | min node | ... | max node | |
1682 * +-----------+-----------+----------+----...----+----------+------+
1683 * + +
1684 * | +-----+ |
1685 * | | rgn | |
1686 * +---------------------------------------------------+-----+------+
1687 *
1688 * Expect to allocate a memory region at the end of the final node in
1689 * the range after falling back to NUMA_NO_NODE.
1690 */
1691static int alloc_nid_top_down_numa_no_overlap_low_check(void)
1692{
1693 int nid_req = 0;
1694 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1695 struct memblock_region *min_node = &memblock.memory.regions[2];
1696 struct memblock_region *max_node = &memblock.memory.regions[5];
1697 void *allocated_ptr = NULL;
1698 phys_addr_t size = SZ_64;
1699 phys_addr_t max_addr;
1700 phys_addr_t min_addr;
1701
1702 PREFIX_PUSH();
1703 setup_numa_memblock(node_fractions);
1704
1705 min_addr = min_node->base;
1706 max_addr = region_end(max_node);
1707
1708 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1709 min_addr, max_addr, nid_req);
1710
1711 ASSERT_NE(allocated_ptr, NULL);
1712 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1713
1714 ASSERT_EQ(new_rgn->size, size);
1715 ASSERT_EQ(new_rgn->base, max_addr - size);
1716 ASSERT_LE(max_node->base, new_rgn->base);
1717
1718 ASSERT_EQ(memblock.reserved.cnt, 1);
1719 ASSERT_EQ(memblock.reserved.total_size, size);
1720
1721 test_pass_pop();
1722
1723 return 0;
1724}
1725
1726/*
1727 * A test that tries to allocate memory within min_addr and max_add range when
1728 * the requested node and the range do not overlap, and requested node starts
1729 * after max_addr. The range overlaps with multiple nodes along node
1730 * boundaries:
1731 *
1732 * min_addr
1733 * | max_addr
1734 * | |
1735 * v v
1736 * | +----------+----...----+----------+ +-----------+ |
1737 * | | min node | ... | max node | | requested | |
1738 * +-----+----------+----...----+----------+--------+-----------+---+
1739 * + +
1740 * | +-----+ |
1741 * | | rgn | |
1742 * +---------------------------------+-----+------------------------+
1743 *
1744 * Expect to allocate a memory region at the end of the final node in
1745 * the range after falling back to NUMA_NO_NODE.
1746 */
1747static int alloc_nid_top_down_numa_no_overlap_high_check(void)
1748{
1749 int nid_req = 7;
1750 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1751 struct memblock_region *min_node = &memblock.memory.regions[2];
1752 struct memblock_region *max_node = &memblock.memory.regions[5];
1753 void *allocated_ptr = NULL;
1754 phys_addr_t size = SZ_64;
1755 phys_addr_t max_addr;
1756 phys_addr_t min_addr;
1757
1758 PREFIX_PUSH();
1759 setup_numa_memblock(node_fractions);
1760
1761 min_addr = min_node->base;
1762 max_addr = region_end(max_node);
1763
1764 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1765 min_addr, max_addr, nid_req);
1766
1767 ASSERT_NE(allocated_ptr, NULL);
1768 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1769
1770 ASSERT_EQ(new_rgn->size, size);
1771 ASSERT_EQ(new_rgn->base, max_addr - size);
1772 ASSERT_LE(max_node->base, new_rgn->base);
1773
1774 ASSERT_EQ(memblock.reserved.cnt, 1);
1775 ASSERT_EQ(memblock.reserved.total_size, size);
1776
1777 test_pass_pop();
1778
1779 return 0;
1780}
1781
1782/*
1783 * A test that tries to allocate a memory region in a specific NUMA node that
1784 * has enough memory to allocate a region of the requested size.
1785 * Expect to allocate an aligned region at the beginning of the requested node.
1786 */
1787static int alloc_nid_bottom_up_numa_simple_check(void)
1788{
1789 int nid_req = 3;
1790 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1791 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1792 void *allocated_ptr = NULL;
1793 phys_addr_t size;
1794 phys_addr_t min_addr;
1795 phys_addr_t max_addr;
1796
1797 PREFIX_PUSH();
1798 setup_numa_memblock(node_fractions);
1799
1800 ASSERT_LE(SZ_4, req_node->size);
1801 size = req_node->size / SZ_4;
1802 min_addr = memblock_start_of_DRAM();
1803 max_addr = memblock_end_of_DRAM();
1804
1805 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1806 min_addr, max_addr, nid_req);
1807
1808 ASSERT_NE(allocated_ptr, NULL);
1809 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1810
1811 ASSERT_EQ(new_rgn->size, size);
1812 ASSERT_EQ(new_rgn->base, req_node->base);
1813 ASSERT_LE(region_end(new_rgn), region_end(req_node));
1814
1815 ASSERT_EQ(memblock.reserved.cnt, 1);
1816 ASSERT_EQ(memblock.reserved.total_size, size);
1817
1818 test_pass_pop();
1819
1820 return 0;
1821}
1822
1823/*
1824 * A test that tries to allocate a memory region in a specific NUMA node that
1825 * does not have enough memory to allocate a region of the requested size:
1826 *
1827 * |----------------------+-----+ |
1828 * | expected | req | |
1829 * +----------------------+-----+----------------+
1830 *
1831 * |---------+ |
1832 * | rgn | |
1833 * +---------+-----------------------------------+
1834 *
1835 * Expect to allocate an aligned region at the beginning of the first node that
1836 * has enough memory (in this case, nid = 0) after falling back to NUMA_NO_NODE.
1837 */
1838static int alloc_nid_bottom_up_numa_small_node_check(void)
1839{
1840 int nid_req = 1;
1841 int nid_exp = 0;
1842 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1843 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1844 struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1845 void *allocated_ptr = NULL;
1846 phys_addr_t size;
1847 phys_addr_t min_addr;
1848 phys_addr_t max_addr;
1849
1850 PREFIX_PUSH();
1851 setup_numa_memblock(node_fractions);
1852
1853 size = SZ_2 * req_node->size;
1854 min_addr = memblock_start_of_DRAM();
1855 max_addr = memblock_end_of_DRAM();
1856
1857 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1858 min_addr, max_addr, nid_req);
1859
1860 ASSERT_NE(allocated_ptr, NULL);
1861 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1862
1863 ASSERT_EQ(new_rgn->size, size);
1864 ASSERT_EQ(new_rgn->base, exp_node->base);
1865 ASSERT_LE(region_end(new_rgn), region_end(exp_node));
1866
1867 ASSERT_EQ(memblock.reserved.cnt, 1);
1868 ASSERT_EQ(memblock.reserved.total_size, size);
1869
1870 test_pass_pop();
1871
1872 return 0;
1873}
1874
1875/*
1876 * A test that tries to allocate a memory region in a specific NUMA node that
1877 * is fully reserved:
1878 *
1879 * |----------------------+ +-----------+ |
1880 * | expected | | requested | |
1881 * +----------------------+-----+-----------+--------------------+
1882 *
1883 * |-----------+ +-----------+ |
1884 * | new | | reserved | |
1885 * +-----------+----------------+-----------+--------------------+
1886 *
1887 * Expect to allocate an aligned region at the beginning of the first node that
1888 * is large enough and has enough unreserved memory (in this case, nid = 0)
1889 * after falling back to NUMA_NO_NODE. The region count and total size get
1890 * updated.
1891 */
1892static int alloc_nid_bottom_up_numa_node_reserved_check(void)
1893{
1894 int nid_req = 2;
1895 int nid_exp = 0;
1896 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1897 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1898 struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
1899 void *allocated_ptr = NULL;
1900 phys_addr_t size;
1901 phys_addr_t min_addr;
1902 phys_addr_t max_addr;
1903
1904 PREFIX_PUSH();
1905 setup_numa_memblock(node_fractions);
1906
1907 size = req_node->size;
1908 min_addr = memblock_start_of_DRAM();
1909 max_addr = memblock_end_of_DRAM();
1910
1911 memblock_reserve(req_node->base, req_node->size);
1912 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1913 min_addr, max_addr, nid_req);
1914
1915 ASSERT_NE(allocated_ptr, NULL);
1916 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1917
1918 ASSERT_EQ(new_rgn->size, size);
1919 ASSERT_EQ(new_rgn->base, exp_node->base);
1920 ASSERT_LE(region_end(new_rgn), region_end(exp_node));
1921
1922 ASSERT_EQ(memblock.reserved.cnt, 2);
1923 ASSERT_EQ(memblock.reserved.total_size, size + req_node->size);
1924
1925 test_pass_pop();
1926
1927 return 0;
1928}
1929
1930/*
1931 * A test that tries to allocate a memory region in a specific NUMA node that
1932 * is partially reserved but has enough memory for the allocated region:
1933 *
1934 * | +---------------------------------------+ |
1935 * | | requested | |
1936 * +-----------+---------------------------------------+---------+
1937 *
1938 * | +------------------+-----+ |
1939 * | | reserved | new | |
1940 * +-----------+------------------+-----+------------------------+
1941 *
1942 * Expect to allocate an aligned region in the requested node that merges with
1943 * the existing reserved region. The total size gets updated.
1944 */
1945static int alloc_nid_bottom_up_numa_part_reserved_check(void)
1946{
1947 int nid_req = 4;
1948 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
1949 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
1950 void *allocated_ptr = NULL;
1951 struct region r1;
1952 phys_addr_t size;
1953 phys_addr_t min_addr;
1954 phys_addr_t max_addr;
1955 phys_addr_t total_size;
1956
1957 PREFIX_PUSH();
1958 setup_numa_memblock(node_fractions);
1959
1960 ASSERT_LE(SZ_8, req_node->size);
1961 r1.base = req_node->base;
1962 r1.size = req_node->size / SZ_2;
1963 size = r1.size / SZ_4;
1964 min_addr = memblock_start_of_DRAM();
1965 max_addr = memblock_end_of_DRAM();
1966 total_size = size + r1.size;
1967
1968 __memblock_reserve(r1.base, r1.size, nid_req, MEMBLOCK_RSRV_KERN);
1969 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
1970 min_addr, max_addr, nid_req);
1971
1972 ASSERT_NE(allocated_ptr, NULL);
1973 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
1974
1975 ASSERT_EQ(new_rgn->size, total_size);
1976 ASSERT_EQ(new_rgn->base, req_node->base);
1977 ASSERT_LE(region_end(new_rgn), region_end(req_node));
1978
1979 ASSERT_EQ(memblock.reserved.cnt, 1);
1980 ASSERT_EQ(memblock.reserved.total_size, total_size);
1981
1982 test_pass_pop();
1983
1984 return 0;
1985}
1986
1987/*
1988 * A test that tries to allocate a memory region in a specific NUMA node that
1989 * is partially reserved and does not have enough contiguous memory for the
1990 * allocated region:
1991 *
1992 * |----------------------+ +-----------------------+ |
1993 * | expected | | requested | |
1994 * +----------------------+-------+-----------------------+---------+
1995 *
1996 * |-----------+ +----------+ |
1997 * | new | | reserved | |
1998 * +-----------+------------------------+----------+----------------+
1999 *
2000 * Expect to allocate an aligned region at the beginning of the first
2001 * node that is large enough and has enough unreserved memory (in this case,
2002 * nid = 0) after falling back to NUMA_NO_NODE. The region count and total size
2003 * get updated.
2004 */
2005static int alloc_nid_bottom_up_numa_part_reserved_fallback_check(void)
2006{
2007 int nid_req = 4;
2008 int nid_exp = 0;
2009 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2010 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
2011 struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
2012 void *allocated_ptr = NULL;
2013 struct region r1;
2014 phys_addr_t size;
2015 phys_addr_t min_addr;
2016 phys_addr_t max_addr;
2017
2018 PREFIX_PUSH();
2019 setup_numa_memblock(node_fractions);
2020
2021 ASSERT_LE(SZ_4, req_node->size);
2022 size = req_node->size / SZ_2;
2023 r1.base = req_node->base + (size / SZ_2);
2024 r1.size = size;
2025
2026 min_addr = memblock_start_of_DRAM();
2027 max_addr = memblock_end_of_DRAM();
2028
2029 memblock_reserve(r1.base, r1.size);
2030 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
2031 min_addr, max_addr, nid_req);
2032
2033 ASSERT_NE(allocated_ptr, NULL);
2034 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2035
2036 ASSERT_EQ(new_rgn->size, size);
2037 ASSERT_EQ(new_rgn->base, exp_node->base);
2038 ASSERT_LE(region_end(new_rgn), region_end(exp_node));
2039
2040 ASSERT_EQ(memblock.reserved.cnt, 2);
2041 ASSERT_EQ(memblock.reserved.total_size, size + r1.size);
2042
2043 test_pass_pop();
2044
2045 return 0;
2046}
2047
2048/*
2049 * A test that tries to allocate a memory region that spans over the min_addr
2050 * and max_addr range and overlaps with two different nodes, where the first
2051 * node is the requested node:
2052 *
2053 * min_addr
2054 * | max_addr
2055 * | |
2056 * v v
2057 * | +-----------------------+-----------+ |
2058 * | | requested | node3 | |
2059 * +-----------+-----------------------+-----------+--------------+
2060 * + +
2061 * | +-----------+ |
2062 * | | rgn | |
2063 * +-----------+-----------+--------------------------------------+
2064 *
2065 * Expect to drop the lower limit and allocate a memory region at the beginning
2066 * of the requested node.
2067 */
2068static int alloc_nid_bottom_up_numa_split_range_low_check(void)
2069{
2070 int nid_req = 2;
2071 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2072 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
2073 void *allocated_ptr = NULL;
2074 phys_addr_t size = SZ_512;
2075 phys_addr_t min_addr;
2076 phys_addr_t max_addr;
2077 phys_addr_t req_node_end;
2078
2079 PREFIX_PUSH();
2080 setup_numa_memblock(node_fractions);
2081
2082 req_node_end = region_end(req_node);
2083 min_addr = req_node_end - SZ_256;
2084 max_addr = min_addr + size;
2085
2086 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
2087 min_addr, max_addr, nid_req);
2088
2089 ASSERT_NE(allocated_ptr, NULL);
2090 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2091
2092 ASSERT_EQ(new_rgn->size, size);
2093 ASSERT_EQ(new_rgn->base, req_node->base);
2094 ASSERT_LE(region_end(new_rgn), req_node_end);
2095
2096 ASSERT_EQ(memblock.reserved.cnt, 1);
2097 ASSERT_EQ(memblock.reserved.total_size, size);
2098
2099 test_pass_pop();
2100
2101 return 0;
2102}
2103
2104/*
2105 * A test that tries to allocate a memory region that spans over the min_addr
2106 * and max_addr range and overlaps with two different nodes, where the second
2107 * node is the requested node:
2108 *
2109 * min_addr
2110 * | max_addr
2111 * | |
2112 * v v
2113 * |------------------+ +----------------------+---------+ |
2114 * | expected | | previous |requested| |
2115 * +------------------+--------+----------------------+---------+------+
2116 * + +
2117 * |---------+ |
2118 * | rgn | |
2119 * +---------+---------------------------------------------------------+
2120 *
2121 * Expect to drop the lower limit and allocate a memory region at the beginning
2122 * of the first node that has enough memory.
2123 */
2124static int alloc_nid_bottom_up_numa_split_range_high_check(void)
2125{
2126 int nid_req = 3;
2127 int nid_exp = 0;
2128 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2129 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
2130 struct memblock_region *exp_node = &memblock.memory.regions[nid_exp];
2131 void *allocated_ptr = NULL;
2132 phys_addr_t size = SZ_512;
2133 phys_addr_t min_addr;
2134 phys_addr_t max_addr;
2135 phys_addr_t exp_node_end;
2136
2137 PREFIX_PUSH();
2138 setup_numa_memblock(node_fractions);
2139
2140 exp_node_end = region_end(req_node);
2141 min_addr = req_node->base - SZ_256;
2142 max_addr = min_addr + size;
2143
2144 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
2145 min_addr, max_addr, nid_req);
2146
2147 ASSERT_NE(allocated_ptr, NULL);
2148 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2149
2150 ASSERT_EQ(new_rgn->size, size);
2151 ASSERT_EQ(new_rgn->base, exp_node->base);
2152 ASSERT_LE(region_end(new_rgn), exp_node_end);
2153
2154 ASSERT_EQ(memblock.reserved.cnt, 1);
2155 ASSERT_EQ(memblock.reserved.total_size, size);
2156
2157 test_pass_pop();
2158
2159 return 0;
2160}
2161
2162/*
2163 * A test that tries to allocate a memory region that spans over the min_addr
2164 * and max_addr range and overlaps with two different nodes, where the requested
2165 * node ends before min_addr:
2166 *
2167 * min_addr
2168 * | max_addr
2169 * | |
2170 * v v
2171 * | +---------------+ +-------------+---------+ |
2172 * | | requested | | node1 | node2 | |
2173 * +----+---------------+--------+-------------+---------+---------+
2174 * + +
2175 * | +---------+ |
2176 * | | rgn | |
2177 * +----+---------+------------------------------------------------+
2178 *
2179 * Expect to drop the lower limit and allocate a memory region that starts at
2180 * the beginning of the requested node.
2181 */
2182static int alloc_nid_bottom_up_numa_no_overlap_split_check(void)
2183{
2184 int nid_req = 2;
2185 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2186 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
2187 struct memblock_region *node2 = &memblock.memory.regions[6];
2188 void *allocated_ptr = NULL;
2189 phys_addr_t size;
2190 phys_addr_t min_addr;
2191 phys_addr_t max_addr;
2192
2193 PREFIX_PUSH();
2194 setup_numa_memblock(node_fractions);
2195
2196 size = SZ_512;
2197 min_addr = node2->base - SZ_256;
2198 max_addr = min_addr + size;
2199
2200 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
2201 min_addr, max_addr, nid_req);
2202
2203 ASSERT_NE(allocated_ptr, NULL);
2204 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2205
2206 ASSERT_EQ(new_rgn->size, size);
2207 ASSERT_EQ(new_rgn->base, req_node->base);
2208 ASSERT_LE(region_end(new_rgn), region_end(req_node));
2209
2210 ASSERT_EQ(memblock.reserved.cnt, 1);
2211 ASSERT_EQ(memblock.reserved.total_size, size);
2212
2213 test_pass_pop();
2214
2215 return 0;
2216}
2217
2218/*
2219 * A test that tries to allocate memory within min_addr and max_add range when
2220 * the requested node and the range do not overlap, and requested node ends
2221 * before min_addr. The range overlaps with multiple nodes along node
2222 * boundaries:
2223 *
2224 * min_addr
2225 * | max_addr
2226 * | |
2227 * v v
2228 * |-----------+ +----------+----...----+----------+ |
2229 * | requested | | min node | ... | max node | |
2230 * +-----------+-----------+----------+----...----+----------+------+
2231 * + +
2232 * | +-----+ |
2233 * | | rgn | |
2234 * +-----------------------+-----+----------------------------------+
2235 *
2236 * Expect to allocate a memory region at the beginning of the first node
2237 * in the range after falling back to NUMA_NO_NODE.
2238 */
2239static int alloc_nid_bottom_up_numa_no_overlap_low_check(void)
2240{
2241 int nid_req = 0;
2242 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2243 struct memblock_region *min_node = &memblock.memory.regions[2];
2244 struct memblock_region *max_node = &memblock.memory.regions[5];
2245 void *allocated_ptr = NULL;
2246 phys_addr_t size = SZ_64;
2247 phys_addr_t max_addr;
2248 phys_addr_t min_addr;
2249
2250 PREFIX_PUSH();
2251 setup_numa_memblock(node_fractions);
2252
2253 min_addr = min_node->base;
2254 max_addr = region_end(max_node);
2255
2256 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
2257 min_addr, max_addr, nid_req);
2258
2259 ASSERT_NE(allocated_ptr, NULL);
2260 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2261
2262 ASSERT_EQ(new_rgn->size, size);
2263 ASSERT_EQ(new_rgn->base, min_addr);
2264 ASSERT_LE(region_end(new_rgn), region_end(min_node));
2265
2266 ASSERT_EQ(memblock.reserved.cnt, 1);
2267 ASSERT_EQ(memblock.reserved.total_size, size);
2268
2269 test_pass_pop();
2270
2271 return 0;
2272}
2273
2274/*
2275 * A test that tries to allocate memory within min_addr and max_add range when
2276 * the requested node and the range do not overlap, and requested node starts
2277 * after max_addr. The range overlaps with multiple nodes along node
2278 * boundaries:
2279 *
2280 * min_addr
2281 * | max_addr
2282 * | |
2283 * v v
2284 * | +----------+----...----+----------+ +---------+ |
2285 * | | min node | ... | max node | |requested| |
2286 * +-----+----------+----...----+----------+---------+---------+---+
2287 * + +
2288 * | +-----+ |
2289 * | | rgn | |
2290 * +-----+-----+---------------------------------------------------+
2291 *
2292 * Expect to allocate a memory region at the beginning of the first node
2293 * in the range after falling back to NUMA_NO_NODE.
2294 */
2295static int alloc_nid_bottom_up_numa_no_overlap_high_check(void)
2296{
2297 int nid_req = 7;
2298 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2299 struct memblock_region *min_node = &memblock.memory.regions[2];
2300 struct memblock_region *max_node = &memblock.memory.regions[5];
2301 void *allocated_ptr = NULL;
2302 phys_addr_t size = SZ_64;
2303 phys_addr_t max_addr;
2304 phys_addr_t min_addr;
2305
2306 PREFIX_PUSH();
2307 setup_numa_memblock(node_fractions);
2308
2309 min_addr = min_node->base;
2310 max_addr = region_end(max_node);
2311
2312 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
2313 min_addr, max_addr, nid_req);
2314
2315 ASSERT_NE(allocated_ptr, NULL);
2316 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2317
2318 ASSERT_EQ(new_rgn->size, size);
2319 ASSERT_EQ(new_rgn->base, min_addr);
2320 ASSERT_LE(region_end(new_rgn), region_end(min_node));
2321
2322 ASSERT_EQ(memblock.reserved.cnt, 1);
2323 ASSERT_EQ(memblock.reserved.total_size, size);
2324
2325 test_pass_pop();
2326
2327 return 0;
2328}
2329
2330/*
2331 * A test that tries to allocate a memory region in a specific NUMA node that
2332 * does not have enough memory to allocate a region of the requested size.
2333 * Additionally, none of the nodes have enough memory to allocate the region:
2334 *
2335 * +-----------------------------------+
2336 * | new |
2337 * +-----------------------------------+
2338 * |-------+-------+-------+-------+-------+-------+-------+-------|
2339 * | node0 | node1 | node2 | node3 | node4 | node5 | node6 | node7 |
2340 * +-------+-------+-------+-------+-------+-------+-------+-------+
2341 *
2342 * Expect no allocation to happen.
2343 */
2344static int alloc_nid_numa_large_region_generic_check(void)
2345{
2346 int nid_req = 3;
2347 void *allocated_ptr = NULL;
2348 phys_addr_t size = MEM_SIZE / SZ_2;
2349 phys_addr_t min_addr;
2350 phys_addr_t max_addr;
2351
2352 PREFIX_PUSH();
2353 setup_numa_memblock(node_fractions);
2354
2355 min_addr = memblock_start_of_DRAM();
2356 max_addr = memblock_end_of_DRAM();
2357
2358 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
2359 min_addr, max_addr, nid_req);
2360 ASSERT_EQ(allocated_ptr, NULL);
2361
2362 test_pass_pop();
2363
2364 return 0;
2365}
2366
2367/*
2368 * A test that tries to allocate memory within min_addr and max_addr range when
2369 * there are two reserved regions at the borders. The requested node starts at
2370 * min_addr and ends at max_addr and is the same size as the region to be
2371 * allocated:
2372 *
2373 * min_addr
2374 * | max_addr
2375 * | |
2376 * v v
2377 * | +-----------+-----------------------+-----------------------|
2378 * | | node5 | requested | node7 |
2379 * +------+-----------+-----------------------+-----------------------+
2380 * + +
2381 * | +----+-----------------------+----+ |
2382 * | | r2 | new | r1 | |
2383 * +-------------+----+-----------------------+----+------------------+
2384 *
2385 * Expect to merge all of the regions into one. The region counter and total
2386 * size fields get updated.
2387 */
2388static int alloc_nid_numa_reserved_full_merge_generic_check(void)
2389{
2390 int nid_req = 6;
2391 int nid_next = nid_req + 1;
2392 struct memblock_region *new_rgn = &memblock.reserved.regions[0];
2393 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
2394 struct memblock_region *next_node = &memblock.memory.regions[nid_next];
2395 void *allocated_ptr = NULL;
2396 struct region r1, r2;
2397 phys_addr_t size = req_node->size;
2398 phys_addr_t total_size;
2399 phys_addr_t max_addr;
2400 phys_addr_t min_addr;
2401
2402 PREFIX_PUSH();
2403 setup_numa_memblock(node_fractions);
2404
2405 r1.base = next_node->base;
2406 r1.size = SZ_128;
2407
2408 r2.size = SZ_128;
2409 r2.base = r1.base - (size + r2.size);
2410
2411 total_size = r1.size + r2.size + size;
2412 min_addr = r2.base + r2.size;
2413 max_addr = r1.base;
2414
2415 __memblock_reserve(r1.base, r1.size, nid_req, MEMBLOCK_RSRV_KERN);
2416 __memblock_reserve(r2.base, r2.size, nid_req, MEMBLOCK_RSRV_KERN);
2417
2418 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
2419 min_addr, max_addr, nid_req);
2420
2421 ASSERT_NE(allocated_ptr, NULL);
2422 assert_mem_content(allocated_ptr, size, alloc_nid_test_flags);
2423
2424 ASSERT_EQ(new_rgn->size, total_size);
2425 ASSERT_EQ(new_rgn->base, r2.base);
2426
2427 ASSERT_LE(new_rgn->base, req_node->base);
2428 ASSERT_LE(region_end(req_node), region_end(new_rgn));
2429
2430 ASSERT_EQ(memblock.reserved.cnt, 1);
2431 ASSERT_EQ(memblock.reserved.total_size, total_size);
2432
2433 test_pass_pop();
2434
2435 return 0;
2436}
2437
2438/*
2439 * A test that tries to allocate memory within min_addr and max_add range,
2440 * where the total range can fit the region, but it is split between two nodes
2441 * and everything else is reserved. Additionally, nid is set to NUMA_NO_NODE
2442 * instead of requesting a specific node:
2443 *
2444 * +-----------+
2445 * | new |
2446 * +-----------+
2447 * | +---------------------+-----------|
2448 * | | prev node | next node |
2449 * +------+---------------------+-----------+
2450 * + +
2451 * |----------------------+ +-----|
2452 * | r1 | | r2 |
2453 * +----------------------+-----------+-----+
2454 * ^ ^
2455 * | |
2456 * | max_addr
2457 * |
2458 * min_addr
2459 *
2460 * Expect no allocation to happen.
2461 */
2462static int alloc_nid_numa_split_all_reserved_generic_check(void)
2463{
2464 void *allocated_ptr = NULL;
2465 struct memblock_region *next_node = &memblock.memory.regions[7];
2466 struct region r1, r2;
2467 phys_addr_t size = SZ_256;
2468 phys_addr_t max_addr;
2469 phys_addr_t min_addr;
2470
2471 PREFIX_PUSH();
2472 setup_numa_memblock(node_fractions);
2473
2474 r2.base = next_node->base + SZ_128;
2475 r2.size = memblock_end_of_DRAM() - r2.base;
2476
2477 r1.size = MEM_SIZE - (r2.size + size);
2478 r1.base = memblock_start_of_DRAM();
2479
2480 min_addr = r1.base + r1.size;
2481 max_addr = r2.base;
2482
2483 memblock_reserve(r1.base, r1.size);
2484 memblock_reserve(r2.base, r2.size);
2485
2486 allocated_ptr = run_memblock_alloc_nid(size, SMP_CACHE_BYTES,
2487 min_addr, max_addr,
2488 NUMA_NO_NODE);
2489
2490 ASSERT_EQ(allocated_ptr, NULL);
2491
2492 test_pass_pop();
2493
2494 return 0;
2495}
2496
2497/*
2498 * A simple test that tries to allocate a memory region through the
2499 * memblock_alloc_node() on a NUMA node with id `nid`. Expected to have the
2500 * correct NUMA node set for the new region.
2501 */
2502static int alloc_node_on_correct_nid(void)
2503{
2504 int nid_req = 2;
2505 void *allocated_ptr = NULL;
2506#ifdef CONFIG_NUMA
2507 struct memblock_region *req_node = &memblock.memory.regions[nid_req];
2508#endif
2509 phys_addr_t size = SZ_512;
2510
2511 PREFIX_PUSH();
2512 setup_numa_memblock(node_fractions);
2513
2514 allocated_ptr = memblock_alloc_node(size, SMP_CACHE_BYTES, nid_req);
2515
2516 ASSERT_NE(allocated_ptr, NULL);
2517#ifdef CONFIG_NUMA
2518 ASSERT_EQ(nid_req, req_node->nid);
2519#endif
2520
2521 test_pass_pop();
2522
2523 return 0;
2524}
2525
2526/* Test case wrappers for NUMA tests */
2527static int alloc_nid_numa_simple_check(void)
2528{
2529 test_print("\tRunning %s...\n", __func__);
2530 memblock_set_bottom_up(false);
2531 alloc_nid_top_down_numa_simple_check();
2532 memblock_set_bottom_up(true);
2533 alloc_nid_bottom_up_numa_simple_check();
2534
2535 return 0;
2536}
2537
2538static int alloc_nid_numa_small_node_check(void)
2539{
2540 test_print("\tRunning %s...\n", __func__);
2541 memblock_set_bottom_up(false);
2542 alloc_nid_top_down_numa_small_node_check();
2543 memblock_set_bottom_up(true);
2544 alloc_nid_bottom_up_numa_small_node_check();
2545
2546 return 0;
2547}
2548
2549static int alloc_nid_numa_node_reserved_check(void)
2550{
2551 test_print("\tRunning %s...\n", __func__);
2552 memblock_set_bottom_up(false);
2553 alloc_nid_top_down_numa_node_reserved_check();
2554 memblock_set_bottom_up(true);
2555 alloc_nid_bottom_up_numa_node_reserved_check();
2556
2557 return 0;
2558}
2559
2560static int alloc_nid_numa_part_reserved_check(void)
2561{
2562 test_print("\tRunning %s...\n", __func__);
2563 memblock_set_bottom_up(false);
2564 alloc_nid_top_down_numa_part_reserved_check();
2565 memblock_set_bottom_up(true);
2566 alloc_nid_bottom_up_numa_part_reserved_check();
2567
2568 return 0;
2569}
2570
2571static int alloc_nid_numa_part_reserved_fallback_check(void)
2572{
2573 test_print("\tRunning %s...\n", __func__);
2574 memblock_set_bottom_up(false);
2575 alloc_nid_top_down_numa_part_reserved_fallback_check();
2576 memblock_set_bottom_up(true);
2577 alloc_nid_bottom_up_numa_part_reserved_fallback_check();
2578
2579 return 0;
2580}
2581
2582static int alloc_nid_numa_split_range_low_check(void)
2583{
2584 test_print("\tRunning %s...\n", __func__);
2585 memblock_set_bottom_up(false);
2586 alloc_nid_top_down_numa_split_range_low_check();
2587 memblock_set_bottom_up(true);
2588 alloc_nid_bottom_up_numa_split_range_low_check();
2589
2590 return 0;
2591}
2592
2593static int alloc_nid_numa_split_range_high_check(void)
2594{
2595 test_print("\tRunning %s...\n", __func__);
2596 memblock_set_bottom_up(false);
2597 alloc_nid_top_down_numa_split_range_high_check();
2598 memblock_set_bottom_up(true);
2599 alloc_nid_bottom_up_numa_split_range_high_check();
2600
2601 return 0;
2602}
2603
2604static int alloc_nid_numa_no_overlap_split_check(void)
2605{
2606 test_print("\tRunning %s...\n", __func__);
2607 memblock_set_bottom_up(false);
2608 alloc_nid_top_down_numa_no_overlap_split_check();
2609 memblock_set_bottom_up(true);
2610 alloc_nid_bottom_up_numa_no_overlap_split_check();
2611
2612 return 0;
2613}
2614
2615static int alloc_nid_numa_no_overlap_low_check(void)
2616{
2617 test_print("\tRunning %s...\n", __func__);
2618 memblock_set_bottom_up(false);
2619 alloc_nid_top_down_numa_no_overlap_low_check();
2620 memblock_set_bottom_up(true);
2621 alloc_nid_bottom_up_numa_no_overlap_low_check();
2622
2623 return 0;
2624}
2625
2626static int alloc_nid_numa_no_overlap_high_check(void)
2627{
2628 test_print("\tRunning %s...\n", __func__);
2629 memblock_set_bottom_up(false);
2630 alloc_nid_top_down_numa_no_overlap_high_check();
2631 memblock_set_bottom_up(true);
2632 alloc_nid_bottom_up_numa_no_overlap_high_check();
2633
2634 return 0;
2635}
2636
2637static int alloc_nid_numa_large_region_check(void)
2638{
2639 test_print("\tRunning %s...\n", __func__);
2640 run_top_down(alloc_nid_numa_large_region_generic_check);
2641 run_bottom_up(alloc_nid_numa_large_region_generic_check);
2642
2643 return 0;
2644}
2645
2646static int alloc_nid_numa_reserved_full_merge_check(void)
2647{
2648 test_print("\tRunning %s...\n", __func__);
2649 run_top_down(alloc_nid_numa_reserved_full_merge_generic_check);
2650 run_bottom_up(alloc_nid_numa_reserved_full_merge_generic_check);
2651
2652 return 0;
2653}
2654
2655static int alloc_nid_numa_split_all_reserved_check(void)
2656{
2657 test_print("\tRunning %s...\n", __func__);
2658 run_top_down(alloc_nid_numa_split_all_reserved_generic_check);
2659 run_bottom_up(alloc_nid_numa_split_all_reserved_generic_check);
2660
2661 return 0;
2662}
2663
2664static int alloc_node_numa_on_correct_nid(void)
2665{
2666 test_print("\tRunning %s...\n", __func__);
2667 run_top_down(alloc_node_on_correct_nid);
2668 run_bottom_up(alloc_node_on_correct_nid);
2669
2670 return 0;
2671}
2672
2673int __memblock_alloc_nid_numa_checks(void)
2674{
2675 test_print("Running %s NUMA tests...\n",
2676 get_memblock_alloc_nid_name(alloc_nid_test_flags));
2677
2678 alloc_nid_numa_simple_check();
2679 alloc_nid_numa_small_node_check();
2680 alloc_nid_numa_node_reserved_check();
2681 alloc_nid_numa_part_reserved_check();
2682 alloc_nid_numa_part_reserved_fallback_check();
2683 alloc_nid_numa_split_range_low_check();
2684 alloc_nid_numa_split_range_high_check();
2685
2686 alloc_nid_numa_no_overlap_split_check();
2687 alloc_nid_numa_no_overlap_low_check();
2688 alloc_nid_numa_no_overlap_high_check();
2689 alloc_nid_numa_large_region_check();
2690 alloc_nid_numa_reserved_full_merge_check();
2691 alloc_nid_numa_split_all_reserved_check();
2692
2693 alloc_node_numa_on_correct_nid();
2694
2695 return 0;
2696}
2697
2698static int memblock_alloc_nid_checks_internal(int flags)
2699{
2700 alloc_nid_test_flags = flags;
2701
2702 prefix_reset();
2703 prefix_push(get_memblock_alloc_nid_name(flags));
2704
2705 reset_memblock_attributes();
2706 dummy_physical_memory_init();
2707
2708 memblock_alloc_nid_range_checks();
2709 memblock_alloc_nid_numa_checks();
2710
2711 dummy_physical_memory_cleanup();
2712
2713 prefix_pop();
2714
2715 return 0;
2716}
2717
2718int memblock_alloc_nid_checks(void)
2719{
2720 memblock_alloc_nid_checks_internal(TEST_F_NONE);
2721 memblock_alloc_nid_checks_internal(TEST_F_RAW);
2722
2723 return 0;
2724}
2725
2726int memblock_alloc_exact_nid_range_checks(void)
2727{
2728 alloc_nid_test_flags = (TEST_F_RAW | TEST_F_EXACT);
2729
2730 memblock_alloc_nid_range_checks();
2731
2732 return 0;
2733}