38  * Expect to create a new entry. The region counter and total memory get
47 	struct region r = {  in memblock_add_simple_check()
71  * Expect to create a new entry. The region counter and total memory get
80 	struct region r = {  in memblock_add_node_simple_check()
115  * region counter fields get updated.
124 	struct region r1 = {  in memblock_add_disjoint_check()
128 	struct region r2 = {  in memblock_add_disjoint_check()
166  * Expect to merge the two entries into one region that starts at r2.base
168  * the available memory is updated, and the region counter stays the same.
177 	struct region r1 = {  in memblock_add_overlap_top_check()
181 	struct region r2 = {  in memblock_add_overlap_top_check()
218  * Expect to merge the two entries into one region that starts at r1.base
220  * the available memory is updated, and the region counter stays the same.
229 	struct region r1 = {  in memblock_add_overlap_bottom_check()
233 	struct region r2 = {  in memblock_add_overlap_bottom_check()
269  * Expect to merge two entries into one region that stays the same.
278 	struct region r1 = {  in memblock_add_within_check()
282 	struct region r2 = {  in memblock_add_within_check()
310 	struct region r = {  in memblock_add_twice_check()
338  * Expect to merge the three entries into one region that starts at r1.base
339  * and has size of r1.size + r2.size + r3.size. The region counter and total
349 	struct region r1 = {  in memblock_add_between_check()
353 	struct region r2 = {  in memblock_add_between_check()
357 	struct region r3 = {  in memblock_add_between_check()
403 	struct region r = {  in memblock_add_near_max_check()
436 	struct region r = {  in memblock_add_many_check()
453 	 * as the memory region which will be choosed by memblock_double_array().  in memblock_add_many_check()
507 	 * we must not use it. So restore the origin memory region to make sure  in memblock_add_many_check()
543  * (memblock.reserved). Expect to create a new entry. The region counter
552 	struct region r = {  in memblock_reserve_simple_check()
578  * (memblock.reserved). The total size and region counter for
588 	struct region r1 = {  in memblock_reserve_disjoint_check()
592 	struct region r2 = {  in memblock_reserve_disjoint_check()
631  * Expect to merge two entries into one region that starts at r2.base and
633  * reserved memory is updated, and the region counter is not updated.
642 	struct region r1 = {  in memblock_reserve_overlap_top_check()
646 	struct region r2 = {  in memblock_reserve_overlap_top_check()
684  * Expect to merge two entries into one region that starts at r1.base and
686  * reserved memory is updated, and the region counter is not updated.
695 	struct region r1 = {  in memblock_reserve_overlap_bottom_check()
699 	struct region r2 = {  in memblock_reserve_overlap_bottom_check()
737  * Expect to merge two entries into one region that stays the same. The
746 	struct region r1 = {  in memblock_reserve_within_check()
750 	struct region r2 = {  in memblock_reserve_within_check()
774  * Expect the region counter and total size of reserved memory to not
779 	struct region r = {  in memblock_reserve_twice_check()
807  * Expect to merge the three entries into one reserved region that starts at
808  * r1.base and has size of r1.size + r2.size + r3.size. The region counter and
818 	struct region r1 = {  in memblock_reserve_between_check()
822 	struct region r2 = {  in memblock_reserve_between_check()
826 	struct region r3 = {  in memblock_reserve_between_check()
872 	struct region r = {  in memblock_reserve_near_max_check()
905 	struct region r = {  in memblock_reserve_many_check()
917 	/* Add a valid memory region used by double_array(). */  in memblock_reserve_many_check()
922 		/* Reserve some fakes memory region to fulfill the memblock. */  in memblock_reserve_many_check()
928 		/* Keep the gap so these memory region will not be merged. */  in memblock_reserve_many_check()
938 	 * This is the memory region size used by the doubled reserved.regions,  in memblock_reserve_many_check()
945 	 * The double_array() will find a free memory region as the new  in memblock_reserve_many_check()
946 	 * reserved.regions, and the used memory region will be reserved, so  in memblock_reserve_many_check()
947 	 * there will be one more region exist in the reserved memblock. And the  in memblock_reserve_many_check()
948 	 * one more reserved region's size is new_reserved_regions_size.  in memblock_reserve_many_check()
974 	 * we must not use it. So restore the origin memory region to make sure  in memblock_reserve_many_check()
998 /* Keep the gap so these memory region will not be merged. */
1004 	struct region r = {  in memblock_reserve_all_locations_check()
1017 		/* Add a valid memory region used by double_array(). */  in memblock_reserve_all_locations_check()
1025 			/* Reserve some fakes memory region to fulfill the memblock. */  in memblock_reserve_all_locations_check()
1043 		 * This is the memory region size used by the doubled reserved.regions,  in memblock_reserve_all_locations_check()
1050 		 * The double_array() will find a free memory region as the new  in memblock_reserve_all_locations_check()
1051 		 * reserved.regions, and the used memory region will be reserved, so  in memblock_reserve_all_locations_check()
1052 		 * there will be one more region exist in the reserved memblock. And the  in memblock_reserve_all_locations_check()
1053 		 * one more reserved region's size is new_reserved_regions_size.  in memblock_reserve_all_locations_check()
1079 		 * we must not use it. So restore the origin memory region to make sure  in memblock_reserve_all_locations_check()
1121 /* Keep the gap so these memory region will not be merged. */
1127 	struct region r = {  in memblock_reserve_many_may_conflict_check()
1154 		/* Add a valid memory region used by double_array(). */  in memblock_reserve_many_may_conflict_check()
1157 		 * Add a memory region which will be reserved as 129th memory  in memblock_reserve_many_may_conflict_check()
1158 		 * region. This is not expected to be used by double_array().  in memblock_reserve_many_may_conflict_check()
1166 			/* Reserve some fakes memory region to fulfill the memblock. */  in memblock_reserve_many_may_conflict_check()
1184 		 * This is the memory region size used by the doubled reserved.regions,  in memblock_reserve_many_may_conflict_check()
1191 		 * The double_array() will find a free memory region as the new  in memblock_reserve_many_may_conflict_check()
1192 		 * reserved.regions, and the used memory region will be reserved, so  in memblock_reserve_many_may_conflict_check()
1193 		 * there will be one more region exist in the reserved memblock. And the  in memblock_reserve_many_may_conflict_check()
1194 		 * one more reserved region's size is new_reserved_regions_size.  in memblock_reserve_many_may_conflict_check()
1202 		 * The first reserved region is allocated for double array  in memblock_reserve_many_may_conflict_check()
1227 		 * we must not use it. So restore the origin memory region to make sure  in memblock_reserve_many_may_conflict_check()
1265  * A simple test that tries to remove a region r1 from the array of
1266  * available memory regions. By "removing" a region we mean overwriting it
1267  * with the next region r2 in memblock.memory:
1277  * r2 is the first available region. The region counter and total size
1286 	struct region r1 = {  in memblock_remove_simple_check()
1290 	struct region r2 = {  in memblock_remove_simple_check()
1314  * A test that tries to remove a region r2 that was not registered as
1335 	struct region r1 = {  in memblock_remove_absent_check()
1339 	struct region r2 = {  in memblock_remove_absent_check()
1362  * A test that tries to remove a region r2 that overlaps with the
1387 	struct region r1 = {  in memblock_remove_overlap_top_check()
1391 	struct region r2 = {  in memblock_remove_overlap_top_check()
1418  * A test that tries to remove a region r2 that overlaps with the end of
1419  * the already existing region r1 (that is r2.base < r1.base + r1.size):
1441 	struct region r1 = {  in memblock_remove_overlap_bottom_check()
1445 	struct region r2 = {  in memblock_remove_overlap_bottom_check()
1470  * A test that tries to remove a region r2 that is within the range of
1484  * Expect that the region is split into two - one that ends at r2.base and
1486  * region counter and total size are updated.
1496 	struct region r1 = {  in memblock_remove_within_check()
1500 	struct region r2 = {  in memblock_remove_within_check()
1530  * A simple test that tries to remove a region r1 from the array of
1531  * available memory regions when r1 is the only available region.
1533  * region is added. The region counter stays the same, and the total size
1542 	struct region r1 = {  in memblock_remove_only_region_check()
1565  * A simple test that tries remove a region r2 from the array of available
1586 	struct region r1 = {  in memblock_remove_near_max_check()
1591 	struct region r2 = {  in memblock_remove_near_max_check()
1616  * A test that tries to remove a region r3 that overlaps with two existing
1638 	struct region r1 = {  in memblock_remove_overlap_two_check()
1642 	struct region r2 = {  in memblock_remove_overlap_two_check()
1646 	struct region r3 = {  in memblock_remove_overlap_two_check()
1700  * earlier as reserved. By "freeing" a region we mean overwriting it with
1710  * Expect to reserve two memory regions and then erase r1 region with the
1711  * value of r2. The region counter and total size are updated.
1719 	struct region r1 = {  in memblock_free_simple_check()
1723 	struct region r2 = {  in memblock_free_simple_check()
1747  * A test that tries to free a region r2 that was not marked as reserved
1768 	struct region r1 = {  in memblock_free_absent_check()
1772 	struct region r2 = {  in memblock_free_absent_check()
1795  * A test that tries to free a region r2 that overlaps with the beginning
1820 	struct region r1 = {  in memblock_free_overlap_top_check()
1824 	struct region r2 = {  in memblock_free_overlap_top_check()
1849  * A test that tries to free a region r2 that overlaps with the end of
1869 	struct region r1 = {  in memblock_free_overlap_bottom_check()
1873 	struct region r2 = {  in memblock_free_overlap_bottom_check()
1898  * A test that tries to free a region r2 that is within the range of the
1912  * Expect that the region is split into two - one that ends at r2.base and
1914  * region counter and total size fields are updated.
1924 	struct region r1 = {  in memblock_free_within_check()
1928 	struct region r2 = {  in memblock_free_within_check()
1959  * earlier as reserved when r1 is the only available region.
1961  * overwritten with a dummy region. The region counter stays the same,
1970 	struct region r1 = {  in memblock_free_only_region_check()
1993  * A simple test that tries free a region r2 when r2 extends past PHYS_ADDR_MAX:
2013 	struct region r1 = {  in memblock_free_near_max_check()
2018 	struct region r2 = {  in memblock_free_near_max_check()
2043  * A test that tries to free a reserved region r3 that overlaps with two
2065 	struct region r1 = {  in memblock_free_overlap_two_check()
2069 	struct region r2 = {  in memblock_free_overlap_two_check()
2073 	struct region r3 = {  in memblock_free_overlap_two_check()
2170  * A test that tries to trim memory when both ends of the memory region are
2181 	struct region r = {  in memblock_trim_memory_aligned_check()
2204  * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end
2227 	struct region r1 = {  in memblock_trim_memory_too_small_check()
2231 	struct region r2 = {  in memblock_trim_memory_too_small_check()
2255  * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base
2282 	struct region r1 = {  in memblock_trim_memory_unaligned_base_check()
2286 	struct region r2 = {  in memblock_trim_memory_unaligned_base_check()
2316  * r2. Region r1 is aligned on both ends and region r2 is aligned at the base
2343 	struct region r1 = {  in memblock_trim_memory_unaligned_end_check()
2347 	struct region r2 = {  in memblock_trim_memory_unaligned_end_check()
2392 	struct region r = {  in memblock_overlaps_region_check()