1 // SPDX-License-Identifier: GPL-2.0-or-later
2 #include "alloc_api.h"
3
4 static int alloc_test_flags = TEST_F_NONE;
5
6 static inline const char * const get_memblock_alloc_name(int flags)
7 {
8 if (flags & TEST_F_RAW)
9 return "memblock_alloc_raw";
10 return "memblock_alloc";
11 }
12
13 static inline void *run_memblock_alloc(phys_addr_t size, phys_addr_t align)
14 {
15 if (alloc_test_flags & TEST_F_RAW)
16 return memblock_alloc_raw(size, align);
17 return memblock_alloc(size, align);
18 }
19
20 /*
21 * A simple test that tries to allocate a small memory region.
22 * Expect to allocate an aligned region near the end of the available memory.
23 */
24 static int alloc_top_down_simple_check(void)
25 {
26 struct memblock_region *rgn = &memblock.reserved.regions[0];
27 void *allocated_ptr = NULL;
28 phys_addr_t size = SZ_2;
29 phys_addr_t expected_start;
30
31 PREFIX_PUSH();
32 setup_memblock();
33
34 expected_start = memblock_end_of_DRAM() - SMP_CACHE_BYTES;
35
36 allocated_ptr = run_memblock_alloc(size, SMP_CACHE_BYTES);
37
38 ASSERT_NE(allocated_ptr, NULL);
39 assert_mem_content(allocated_ptr, size, alloc_test_flags);
40
41 ASSERT_EQ(rgn->size, size);
42 ASSERT_EQ(rgn->base, expected_start);
43
44 ASSERT_EQ(memblock.reserved.cnt, 1);
45 ASSERT_EQ(memblock.reserved.total_size, size);
46
47 test_pass_pop();
48
49 return 0;
50 }
51
52 /*
53 * A test that tries to allocate memory next to a reserved region that starts at
54 * the misaligned address. Expect to create two separate entries, with the new
55 * entry aligned to the provided alignment:
56 *
57 * +
58 * | +--------+ +--------|
59 * | | rgn2 | | rgn1 |
60 * +------------+--------+---------+--------+
61 * ^
62 * |
63 * Aligned address boundary
64 *
65 * The allocation direction is top-down and region arrays are sorted from lower
66 * to higher addresses, so the new region will be the first entry in
67 * memory.reserved array. The previously reserved region does not get modified.
68 * Region counter and total size get updated.
69 */
70 static int alloc_top_down_disjoint_check(void)
71 {
72 /* After allocation, this will point to the "old" region */
73 struct memblock_region *rgn1 = &memblock.reserved.regions[1];
74 struct memblock_region *rgn2 = &memblock.reserved.regions[0];
75 struct region r1;
76 void *allocated_ptr = NULL;
77 phys_addr_t r2_size = SZ_16;
78 /* Use custom alignment */
79 phys_addr_t alignment = SMP_CACHE_BYTES * 2;
80 phys_addr_t total_size;
81 phys_addr_t expected_start;
82
83 PREFIX_PUSH();
84 setup_memblock();
85
86 r1.base = memblock_end_of_DRAM() - SZ_2;
87 r1.size = SZ_2;
88
89 total_size = r1.size + r2_size;
90 expected_start = memblock_end_of_DRAM() - alignment;
91
92 memblock_reserve(r1.base, r1.size);
93
94 allocated_ptr = run_memblock_alloc(r2_size, alignment);
95
96 ASSERT_NE(allocated_ptr, NULL);
97 assert_mem_content(allocated_ptr, r2_size, alloc_test_flags);
98
99 ASSERT_EQ(rgn1->size, r1.size);
100 ASSERT_EQ(rgn1->base, r1.base);
101
102 ASSERT_EQ(rgn2->size, r2_size);
103 ASSERT_EQ(rgn2->base, expected_start);
104
105 ASSERT_EQ(memblock.reserved.cnt, 2);
106 ASSERT_EQ(memblock.reserved.total_size, total_size);
107
108 test_pass_pop();
109
110 return 0;
111 }
112
113 /*
114 * A test that tries to allocate memory when there is enough space at the end
115 * of the previously reserved block (i.e. first fit):
116 *
117 * | +--------+--------------|
118 * | | r1 | r2 |
119 * +--------------+--------+--------------+
120 *
121 * Expect a merge of both regions. Only the region size gets updated.
122 */
123 static int alloc_top_down_before_check(void)
124 {
125 struct memblock_region *rgn = &memblock.reserved.regions[0];
126 void *allocated_ptr = NULL;
127 /*
128 * The first region ends at the aligned address to test region merging
129 */
130 phys_addr_t r1_size = SMP_CACHE_BYTES;
131 phys_addr_t r2_size = SZ_512;
132 phys_addr_t total_size = r1_size + r2_size;
133
134 PREFIX_PUSH();
135 setup_memblock();
136
137 memblock_reserve(memblock_end_of_DRAM() - total_size, r1_size);
138
139 allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES);
140
141 ASSERT_NE(allocated_ptr, NULL);
142 assert_mem_content(allocated_ptr, r2_size, alloc_test_flags);
143
144 ASSERT_EQ(rgn->size, total_size);
145 ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - total_size);
146
147 ASSERT_EQ(memblock.reserved.cnt, 1);
148 ASSERT_EQ(memblock.reserved.total_size, total_size);
149
150 test_pass_pop();
151
152 return 0;
153 }
154
155 /*
156 * A test that tries to allocate memory when there is not enough space at the
157 * end of the previously reserved block (i.e. second fit):
158 *
159 * | +-----------+------+ |
160 * | | r2 | r1 | |
161 * +------------+-----------+------+-----+
162 *
163 * Expect a merge of both regions. Both the base address and size of the region
164 * get updated.
165 */
166 static int alloc_top_down_after_check(void)
167 {
168 struct memblock_region *rgn = &memblock.reserved.regions[0];
169 struct region r1;
170 void *allocated_ptr = NULL;
171 phys_addr_t r2_size = SZ_512;
172 phys_addr_t total_size;
173
174 PREFIX_PUSH();
175 setup_memblock();
176
177 /*
178 * The first region starts at the aligned address to test region merging
179 */
180 r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES;
181 r1.size = SZ_8;
182
183 total_size = r1.size + r2_size;
184
185 memblock_reserve(r1.base, r1.size);
186
187 allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES);
188
189 ASSERT_NE(allocated_ptr, NULL);
190 assert_mem_content(allocated_ptr, r2_size, alloc_test_flags);
191
192 ASSERT_EQ(rgn->size, total_size);
193 ASSERT_EQ(rgn->base, r1.base - r2_size);
194
195 ASSERT_EQ(memblock.reserved.cnt, 1);
196 ASSERT_EQ(memblock.reserved.total_size, total_size);
197
198 test_pass_pop();
199
200 return 0;
201 }
202
203 /*
204 * A test that tries to allocate memory when there are two reserved regions with
205 * a gap too small to fit the new region:
206 *
207 * | +--------+----------+ +------|
208 * | | r3 | r2 | | r1 |
209 * +-------+--------+----------+---+------+
210 *
211 * Expect to allocate a region before the one that starts at the lower address,
212 * and merge them into one. The region counter and total size fields get
213 * updated.
214 */
215 static int alloc_top_down_second_fit_check(void)
216 {
217 struct memblock_region *rgn = &memblock.reserved.regions[0];
218 struct region r1, r2;
219 void *allocated_ptr = NULL;
220 phys_addr_t r3_size = SZ_1K;
221 phys_addr_t total_size;
222
223 PREFIX_PUSH();
224 setup_memblock();
225
226 r1.base = memblock_end_of_DRAM() - SZ_512;
227 r1.size = SZ_512;
228
229 r2.base = r1.base - SZ_512;
230 r2.size = SZ_256;
231
232 total_size = r1.size + r2.size + r3_size;
233
234 memblock_reserve(r1.base, r1.size);
235 memblock_reserve(r2.base, r2.size);
236
237 allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES);
238
239 ASSERT_NE(allocated_ptr, NULL);
240 assert_mem_content(allocated_ptr, r3_size, alloc_test_flags);
241
242 ASSERT_EQ(rgn->size, r2.size + r3_size);
243 ASSERT_EQ(rgn->base, r2.base - r3_size);
244
245 ASSERT_EQ(memblock.reserved.cnt, 2);
246 ASSERT_EQ(memblock.reserved.total_size, total_size);
247
248 test_pass_pop();
249
250 return 0;
251 }
252
253 /*
254 * A test that tries to allocate memory when there are two reserved regions with
255 * a gap big enough to accommodate the new region:
256 *
257 * | +--------+--------+--------+ |
258 * | | r2 | r3 | r1 | |
259 * +-----+--------+--------+--------+-----+
260 *
261 * Expect to merge all of them, creating one big entry in memblock.reserved
262 * array. The region counter and total size fields get updated.
263 */
264 static int alloc_in_between_generic_check(void)
265 {
266 struct memblock_region *rgn = &memblock.reserved.regions[0];
267 struct region r1, r2;
268 void *allocated_ptr = NULL;
269 phys_addr_t gap_size = SMP_CACHE_BYTES;
270 phys_addr_t r3_size = SZ_64;
271 /*
272 * Calculate regions size so there's just enough space for the new entry
273 */
274 phys_addr_t rgn_size = (MEM_SIZE - (2 * gap_size + r3_size)) / 2;
275 phys_addr_t total_size;
276
277 PREFIX_PUSH();
278 setup_memblock();
279
280 r1.size = rgn_size;
281 r1.base = memblock_end_of_DRAM() - (gap_size + rgn_size);
282
283 r2.size = rgn_size;
284 r2.base = memblock_start_of_DRAM() + gap_size;
285
286 total_size = r1.size + r2.size + r3_size;
287
288 memblock_reserve(r1.base, r1.size);
289 memblock_reserve(r2.base, r2.size);
290
291 allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES);
292
293 ASSERT_NE(allocated_ptr, NULL);
294 assert_mem_content(allocated_ptr, r3_size, alloc_test_flags);
295
296 ASSERT_EQ(rgn->size, total_size);
297 ASSERT_EQ(rgn->base, r1.base - r2.size - r3_size);
298
299 ASSERT_EQ(memblock.reserved.cnt, 1);
300 ASSERT_EQ(memblock.reserved.total_size, total_size);
301
302 test_pass_pop();
303
304 return 0;
305 }
306
307 /*
308 * A test that tries to allocate memory when the memory is filled with reserved
309 * regions with memory gaps too small to fit the new region:
310 *
311 * +-------+
312 * | new |
313 * +--+----+
314 * | +-----+ +-----+ +-----+ |
315 * | | res | | res | | res | |
316 * +----+-----+----+-----+----+-----+----+
317 *
318 * Expect no allocation to happen.
319 */
320 static int alloc_small_gaps_generic_check(void)
321 {
322 void *allocated_ptr = NULL;
323 phys_addr_t region_size = SZ_1K;
324 phys_addr_t gap_size = SZ_256;
325 phys_addr_t region_end;
326
327 PREFIX_PUSH();
328 setup_memblock();
329
330 region_end = memblock_start_of_DRAM();
331
332 while (region_end < memblock_end_of_DRAM()) {
333 memblock_reserve(region_end + gap_size, region_size);
334 region_end += gap_size + region_size;
335 }
336
337 allocated_ptr = run_memblock_alloc(region_size, SMP_CACHE_BYTES);
338
339 ASSERT_EQ(allocated_ptr, NULL);
340
341 test_pass_pop();
342
343 return 0;
344 }
345
346 /*
347 * A test that tries to allocate memory when all memory is reserved.
348 * Expect no allocation to happen.
349 */
350 static int alloc_all_reserved_generic_check(void)
351 {
352 void *allocated_ptr = NULL;
353
354 PREFIX_PUSH();
355 setup_memblock();
356
357 /* Simulate full memory */
358 memblock_reserve(memblock_start_of_DRAM(), MEM_SIZE);
359
360 allocated_ptr = run_memblock_alloc(SZ_256, SMP_CACHE_BYTES);
361
362 ASSERT_EQ(allocated_ptr, NULL);
363
364 test_pass_pop();
365
366 return 0;
367 }
368
369 /*
370 * A test that tries to allocate memory when the memory is almost full,
371 * with not enough space left for the new region:
372 *
373 * +-------+
374 * | new |
375 * +-------+
376 * |-----------------------------+ |
377 * | reserved | |
378 * +-----------------------------+---+
379 *
380 * Expect no allocation to happen.
381 */
382 static int alloc_no_space_generic_check(void)
383 {
384 void *allocated_ptr = NULL;
385 phys_addr_t available_size = SZ_256;
386 phys_addr_t reserved_size = MEM_SIZE - available_size;
387
388 PREFIX_PUSH();
389 setup_memblock();
390
391 /* Simulate almost-full memory */
392 memblock_reserve(memblock_start_of_DRAM(), reserved_size);
393
394 allocated_ptr = run_memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
395
396 ASSERT_EQ(allocated_ptr, NULL);
397
398 test_pass_pop();
399
400 return 0;
401 }
402
403 /*
404 * A test that tries to allocate memory when the memory is almost full,
405 * but there is just enough space left:
406 *
407 * |---------------------------+---------|
408 * | reserved | new |
409 * +---------------------------+---------+
410 *
411 * Expect to allocate memory and merge all the regions. The total size field
412 * gets updated.
413 */
414 static int alloc_limited_space_generic_check(void)
415 {
416 struct memblock_region *rgn = &memblock.reserved.regions[0];
417 void *allocated_ptr = NULL;
418 phys_addr_t available_size = SZ_256;
419 phys_addr_t reserved_size = MEM_SIZE - available_size;
420
421 PREFIX_PUSH();
422 setup_memblock();
423
424 /* Simulate almost-full memory */
425 memblock_reserve(memblock_start_of_DRAM(), reserved_size);
426
427 allocated_ptr = run_memblock_alloc(available_size, SMP_CACHE_BYTES);
428
429 ASSERT_NE(allocated_ptr, NULL);
430 assert_mem_content(allocated_ptr, available_size, alloc_test_flags);
431
432 ASSERT_EQ(rgn->size, MEM_SIZE);
433 ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
434
435 ASSERT_EQ(memblock.reserved.cnt, 1);
436 ASSERT_EQ(memblock.reserved.total_size, MEM_SIZE);
437
438 test_pass_pop();
439
440 return 0;
441 }
442
443 /*
444 * A test that tries to allocate memory when there is no available memory
445 * registered (i.e. memblock.memory has only a dummy entry).
446 * Expect no allocation to happen.
447 */
448 static int alloc_no_memory_generic_check(void)
449 {
450 struct memblock_region *rgn = &memblock.reserved.regions[0];
451 void *allocated_ptr = NULL;
452
453 PREFIX_PUSH();
454
455 reset_memblock_regions();
456
457 allocated_ptr = run_memblock_alloc(SZ_1K, SMP_CACHE_BYTES);
458
459 ASSERT_EQ(allocated_ptr, NULL);
460 ASSERT_EQ(rgn->size, 0);
461 ASSERT_EQ(rgn->base, 0);
462 ASSERT_EQ(memblock.reserved.total_size, 0);
463
464 test_pass_pop();
465
466 return 0;
467 }
468
469 /*
470 * A test that tries to allocate a region that is larger than the total size of
471 * available memory (memblock.memory):
472 *
473 * +-----------------------------------+
474 * | new |
475 * +-----------------------------------+
476 * | |
477 * | |
478 * +---------------------------------+
479 *
480 * Expect no allocation to happen.
481 */
482 static int alloc_too_large_generic_check(void)
483 {
484 struct memblock_region *rgn = &memblock.reserved.regions[0];
485 void *allocated_ptr = NULL;
486
487 PREFIX_PUSH();
488 setup_memblock();
489
490 allocated_ptr = run_memblock_alloc(MEM_SIZE + SZ_2, SMP_CACHE_BYTES);
491
492 ASSERT_EQ(allocated_ptr, NULL);
493 ASSERT_EQ(rgn->size, 0);
494 ASSERT_EQ(rgn->base, 0);
495 ASSERT_EQ(memblock.reserved.total_size, 0);
496
497 test_pass_pop();
498
499 return 0;
500 }
501
502 /*
503 * A simple test that tries to allocate a small memory region.
504 * Expect to allocate an aligned region at the beginning of the available
505 * memory.
506 */
507 static int alloc_bottom_up_simple_check(void)
508 {
509 struct memblock_region *rgn = &memblock.reserved.regions[0];
510 void *allocated_ptr = NULL;
511
512 PREFIX_PUSH();
513 setup_memblock();
514
515 allocated_ptr = run_memblock_alloc(SZ_2, SMP_CACHE_BYTES);
516
517 ASSERT_NE(allocated_ptr, NULL);
518 assert_mem_content(allocated_ptr, SZ_2, alloc_test_flags);
519
520 ASSERT_EQ(rgn->size, SZ_2);
521 ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
522
523 ASSERT_EQ(memblock.reserved.cnt, 1);
524 ASSERT_EQ(memblock.reserved.total_size, SZ_2);
525
526 test_pass_pop();
527
528 return 0;
529 }
530
531 /*
532 * A test that tries to allocate memory next to a reserved region that starts at
533 * the misaligned address. Expect to create two separate entries, with the new
534 * entry aligned to the provided alignment:
535 *
536 * +
537 * | +----------+ +----------+ |
538 * | | rgn1 | | rgn2 | |
539 * +----+----------+---+----------+-----+
540 * ^
541 * |
542 * Aligned address boundary
543 *
544 * The allocation direction is bottom-up, so the new region will be the second
545 * entry in memory.reserved array. The previously reserved region does not get
546 * modified. Region counter and total size get updated.
547 */
548 static int alloc_bottom_up_disjoint_check(void)
549 {
550 struct memblock_region *rgn1 = &memblock.reserved.regions[0];
551 struct memblock_region *rgn2 = &memblock.reserved.regions[1];
552 struct region r1;
553 void *allocated_ptr = NULL;
554 phys_addr_t r2_size = SZ_16;
555 /* Use custom alignment */
556 phys_addr_t alignment = SMP_CACHE_BYTES * 2;
557 phys_addr_t total_size;
558 phys_addr_t expected_start;
559
560 PREFIX_PUSH();
561 setup_memblock();
562
563 r1.base = memblock_start_of_DRAM() + SZ_2;
564 r1.size = SZ_2;
565
566 total_size = r1.size + r2_size;
567 expected_start = memblock_start_of_DRAM() + alignment;
568
569 memblock_reserve(r1.base, r1.size);
570
571 allocated_ptr = run_memblock_alloc(r2_size, alignment);
572
573 ASSERT_NE(allocated_ptr, NULL);
574 assert_mem_content(allocated_ptr, r2_size, alloc_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);
580 ASSERT_EQ(rgn2->base, expected_start);
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 when there is enough space at
592 * the beginning of the previously reserved block (i.e. first fit):
593 *
594 * |------------------+--------+ |
595 * | r1 | r2 | |
596 * +------------------+--------+---------+
597 *
598 * Expect a merge of both regions. Only the region size gets updated.
599 */
600 static int alloc_bottom_up_before_check(void)
601 {
602 struct memblock_region *rgn = &memblock.reserved.regions[0];
603 void *allocated_ptr = NULL;
604 phys_addr_t r1_size = SZ_512;
605 phys_addr_t r2_size = SZ_128;
606 phys_addr_t total_size = r1_size + r2_size;
607
608 PREFIX_PUSH();
609 setup_memblock();
610
611 memblock_reserve(memblock_start_of_DRAM() + r1_size, r2_size);
612
613 allocated_ptr = run_memblock_alloc(r1_size, SMP_CACHE_BYTES);
614
615 ASSERT_NE(allocated_ptr, NULL);
616 assert_mem_content(allocated_ptr, r1_size, alloc_test_flags);
617
618 ASSERT_EQ(rgn->size, total_size);
619 ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
620
621 ASSERT_EQ(memblock.reserved.cnt, 1);
622 ASSERT_EQ(memblock.reserved.total_size, total_size);
623
624 test_pass_pop();
625
626 return 0;
627 }
628
629 /*
630 * A test that tries to allocate memory when there is not enough space at
631 * the beginning of the previously reserved block (i.e. second fit):
632 *
633 * | +--------+--------------+ |
634 * | | r1 | r2 | |
635 * +----+--------+--------------+---------+
636 *
637 * Expect a merge of both regions. Only the region size gets updated.
638 */
639 static int alloc_bottom_up_after_check(void)
640 {
641 struct memblock_region *rgn = &memblock.reserved.regions[0];
642 struct region r1;
643 void *allocated_ptr = NULL;
644 phys_addr_t r2_size = SZ_512;
645 phys_addr_t total_size;
646
647 PREFIX_PUSH();
648 setup_memblock();
649
650 /*
651 * The first region starts at the aligned address to test region merging
652 */
653 r1.base = memblock_start_of_DRAM() + SMP_CACHE_BYTES;
654 r1.size = SZ_64;
655
656 total_size = r1.size + r2_size;
657
658 memblock_reserve(r1.base, r1.size);
659
660 allocated_ptr = run_memblock_alloc(r2_size, SMP_CACHE_BYTES);
661
662 ASSERT_NE(allocated_ptr, NULL);
663 assert_mem_content(allocated_ptr, r2_size, alloc_test_flags);
664
665 ASSERT_EQ(rgn->size, total_size);
666 ASSERT_EQ(rgn->base, r1.base);
667
668 ASSERT_EQ(memblock.reserved.cnt, 1);
669 ASSERT_EQ(memblock.reserved.total_size, total_size);
670
671 test_pass_pop();
672
673 return 0;
674 }
675
676 /*
677 * A test that tries to allocate memory when there are two reserved regions, the
678 * first one starting at the beginning of the available memory, with a gap too
679 * small to fit the new region:
680 *
681 * |------------+ +--------+--------+ |
682 * | r1 | | r2 | r3 | |
683 * +------------+-----+--------+--------+--+
684 *
685 * Expect to allocate after the second region, which starts at the higher
686 * address, and merge them into one. The region counter and total size fields
687 * get updated.
688 */
689 static int alloc_bottom_up_second_fit_check(void)
690 {
691 struct memblock_region *rgn = &memblock.reserved.regions[1];
692 struct region r1, r2;
693 void *allocated_ptr = NULL;
694 phys_addr_t r3_size = SZ_1K;
695 phys_addr_t total_size;
696
697 PREFIX_PUSH();
698 setup_memblock();
699
700 r1.base = memblock_start_of_DRAM();
701 r1.size = SZ_512;
702
703 r2.base = r1.base + r1.size + SZ_512;
704 r2.size = SZ_256;
705
706 total_size = r1.size + r2.size + r3_size;
707
708 memblock_reserve(r1.base, r1.size);
709 memblock_reserve(r2.base, r2.size);
710
711 allocated_ptr = run_memblock_alloc(r3_size, SMP_CACHE_BYTES);
712
713 ASSERT_NE(allocated_ptr, NULL);
714 assert_mem_content(allocated_ptr, r3_size, alloc_test_flags);
715
716 ASSERT_EQ(rgn->size, r2.size + r3_size);
717 ASSERT_EQ(rgn->base, r2.base);
718
719 ASSERT_EQ(memblock.reserved.cnt, 2);
720 ASSERT_EQ(memblock.reserved.total_size, total_size);
721
722 test_pass_pop();
723
724 return 0;
725 }
726
727 /* Test case wrappers */
728 static int alloc_simple_check(void)
729 {
730 test_print("\tRunning %s...\n", __func__);
731 memblock_set_bottom_up(false);
732 alloc_top_down_simple_check();
733 memblock_set_bottom_up(true);
734 alloc_bottom_up_simple_check();
735
736 return 0;
737 }
738
739 static int alloc_disjoint_check(void)
740 {
741 test_print("\tRunning %s...\n", __func__);
742 memblock_set_bottom_up(false);
743 alloc_top_down_disjoint_check();
744 memblock_set_bottom_up(true);
745 alloc_bottom_up_disjoint_check();
746
747 return 0;
748 }
749
750 static int alloc_before_check(void)
751 {
752 test_print("\tRunning %s...\n", __func__);
753 memblock_set_bottom_up(false);
754 alloc_top_down_before_check();
755 memblock_set_bottom_up(true);
756 alloc_bottom_up_before_check();
757
758 return 0;
759 }
760
761 static int alloc_after_check(void)
762 {
763 test_print("\tRunning %s...\n", __func__);
764 memblock_set_bottom_up(false);
765 alloc_top_down_after_check();
766 memblock_set_bottom_up(true);
767 alloc_bottom_up_after_check();
768
769 return 0;
770 }
771
772 static int alloc_in_between_check(void)
773 {
774 test_print("\tRunning %s...\n", __func__);
775 run_top_down(alloc_in_between_generic_check);
776 run_bottom_up(alloc_in_between_generic_check);
777
778 return 0;
779 }
780
781 static int alloc_second_fit_check(void)
782 {
783 test_print("\tRunning %s...\n", __func__);
784 memblock_set_bottom_up(false);
785 alloc_top_down_second_fit_check();
786 memblock_set_bottom_up(true);
787 alloc_bottom_up_second_fit_check();
788
789 return 0;
790 }
791
792 static int alloc_small_gaps_check(void)
793 {
794 test_print("\tRunning %s...\n", __func__);
795 run_top_down(alloc_small_gaps_generic_check);
796 run_bottom_up(alloc_small_gaps_generic_check);
797
798 return 0;
799 }
800
801 static int alloc_all_reserved_check(void)
802 {
803 test_print("\tRunning %s...\n", __func__);
804 run_top_down(alloc_all_reserved_generic_check);
805 run_bottom_up(alloc_all_reserved_generic_check);
806
807 return 0;
808 }
809
810 static int alloc_no_space_check(void)
811 {
812 test_print("\tRunning %s...\n", __func__);
813 run_top_down(alloc_no_space_generic_check);
814 run_bottom_up(alloc_no_space_generic_check);
815
816 return 0;
817 }
818
819 static int alloc_limited_space_check(void)
820 {
821 test_print("\tRunning %s...\n", __func__);
822 run_top_down(alloc_limited_space_generic_check);
823 run_bottom_up(alloc_limited_space_generic_check);
824
825 return 0;
826 }
827
828 static int alloc_no_memory_check(void)
829 {
830 test_print("\tRunning %s...\n", __func__);
831 run_top_down(alloc_no_memory_generic_check);
832 run_bottom_up(alloc_no_memory_generic_check);
833
834 return 0;
835 }
836
837 static int alloc_too_large_check(void)
838 {
839 test_print("\tRunning %s...\n", __func__);
840 run_top_down(alloc_too_large_generic_check);
841 run_bottom_up(alloc_too_large_generic_check);
842
843 return 0;
844 }
845
846 static int memblock_alloc_checks_internal(int flags)
847 {
848 const char *func = get_memblock_alloc_name(flags);
849
850 alloc_test_flags = flags;
851 prefix_reset();
852 prefix_push(func);
853 test_print("Running %s tests...\n", func);
854
855 reset_memblock_attributes();
856 dummy_physical_memory_init();
857
858 alloc_simple_check();
859 alloc_disjoint_check();
860 alloc_before_check();
861 alloc_after_check();
862 alloc_second_fit_check();
863 alloc_small_gaps_check();
864 alloc_in_between_check();
865 alloc_all_reserved_check();
866 alloc_no_space_check();
867 alloc_limited_space_check();
868 alloc_no_memory_check();
869 alloc_too_large_check();
870
871 dummy_physical_memory_cleanup();
872
873 prefix_pop();
874
875 return 0;
876 }
877
878 int memblock_alloc_checks(void)
879 {
880 memblock_alloc_checks_internal(TEST_F_NONE);
881 memblock_alloc_checks_internal(TEST_F_RAW);
882
883 return 0;
884 }
885
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.