memblock/tests/basic_api.c

110  *  |        |   r1   |        |   r2   |  |
128 	struct region r2 = {
137 	memblock_add(r2.base, r2.size);
142 	ASSERT_EQ(rgn2->base, r2.base);
143 	ASSERT_EQ(rgn2->size, r2.size);
146 	ASSERT_EQ(memblock.memory.total_size, r1.size + r2.size);
154  * A test that tries to add two memory blocks r1 and r2, where r2 overlaps
155  * with the beginning of r1 (that is r1.base < r2.base + r2.size):
158  *  |    |    |r2  |   r1       |          |
164  *       r2.base
166  * Expect to merge the two entries into one region that starts at r2.base
181 	struct region r2 = {
188 	total_size = (r1.base - r2.base) + r1.size;
192 	memblock_add(r2.base, r2.size);
194 	ASSERT_EQ(rgn->base, r2.base);
206  * A test that tries to add two memory blocks r1 and r2, where r2 overlaps
207  * with the end of r1 (that is r2.base < r1.base + r1.size):
210  *  |  |  | r1   | r2       |              |
214  *     |  r2.base
233 	struct region r2 = {
240 	total_size = (r2.base - r1.base) + r2.size;
244 	memblock_add(r2.base, r2.size);
258  * A test that tries to add two memory blocks r1 and r2, where r2 is
259  * within the range of r1 (that is r1.base < r2.base &&
260  * r2.base + r2.size < r1.base + r1.size):
263  *  |   |       |r2|      r1               |
282 	struct region r2 = {
291 	memblock_add(r2.base, r2.size);
335  *  |        |   r1   |   r3   |   r2   |  |
339  * and has size of r1.size + r2.size + r3.size. The region counter and total
353 	struct region r2 = {
364 	total_size = r1.size + r2.size + r3.size;
368 	memblock_add(r2.base, r2.size);
574  *  |        |r1|      |       r2       |  |
592 	struct region r2 = {
601 	memblock_reserve(r2.base, r2.size);
606 	ASSERT_EQ(rgn2->base, r2.base);
607 	ASSERT_EQ(rgn2->size, r2.size);
610 	ASSERT_EQ(memblock.reserved.total_size, r1.size + r2.size);
618  * A test that tries to mark two memory blocks r1 and r2 as reserved,
619  * where r2 overlaps with the beginning of r1 (that is
620  * r1.base < r2.base + r2.size):
623  *  |  |       r2     |  |     r1       |  |
629  *     r2.base
631  * Expect to merge two entries into one region that starts at r2.base and
646 	struct region r2 = {
653 	total_size = (r1.base - r2.base) + r1.size;
657 	memblock_reserve(r2.base, r2.size);
659 	ASSERT_EQ(rgn->base, r2.base);
671  * A test that tries to mark two memory blocks r1 and r2 as reserved,
672  * where r2 overlaps with the end of r1 (that is
673  * r2.base < r1.base + r1.size):
676  *  |  |       r1     |  |     r2       |  |
680  *     |              r2.base
699 	struct region r2 = {
706 	total_size = (r2.base - r1.base) + r2.size;
710 	memblock_reserve(r2.base, r2.size);
724  * A test that tries to mark two memory blocks r1 and r2 as reserved,
725  * where r2 is within the range of r1 (that is
726  * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)):
729  *  | |     |r2|          r1               |
733  *    |     r2.base
750 	struct region r2 = {
759 	memblock_reserve(r2.base, r2.size);
804  *  |        |   r1   |   r3   |   r2   |  |
808  * r1.base and has size of r1.size + r2.size + r3.size. The region counter and
822 	struct region r2 = {
833 	total_size = r1.size + r2.size + r3.size;
837 	memblock_reserve(r2.base, r2.size);
1009  * with the next region r2 in memblock.memory:
1012  *  |  : r1 :          |       r2       |  |
1018  * Expect to add two memory blocks r1 and r2 and then remove r1 so that
1019  * r2 is the first available region. The region counter and total size
1032 	struct region r2 = {
1041 	memblock_add(r2.base, r2.size);
1044 	ASSERT_EQ(rgn->base, r2.base);
1045 	ASSERT_EQ(rgn->size, r2.size);
1048 	ASSERT_EQ(memblock.memory.total_size, r2.size);
1056  * A test that tries to remove a region r2 that was not registered as
1060  *                     |       r2       |
1081 	struct region r2 = {
1090 	memblock_remove(r2.base, r2.size);
1104  * A test that tries to remove a region r2 that overlaps with the
1106  * (that is r1.base < r2.base + r2.size):
1109  *           |       r2        |
1133 	struct region r2 = {
1141 	r2_end = r2.base + r2.size;
1146 	memblock_remove(r2.base, r2.size);
1148 	ASSERT_EQ(rgn->base, r1.base + r2.base);
1160  * A test that tries to remove a region r2 that overlaps with the end of
1161  * the already existing region r1 (that is r2.base < r1.base + r1.size):
1164  *        |               r2               |
1187 	struct region r2 = {
1194 	total_size = r2.base - r1.base;
1198 	memblock_remove(r2.base, r2.size);
1212  * A test that tries to remove a region r2 that is within the range of
1214  * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)):
1217  *                  | r2 |
1226  * Expect that the region is split into two - one that ends at r2.base and
1227  * another that starts at r2.base + r2.size, with appropriate sizes. The
1242 	struct region r2 = {
1249 	r1_size = r2.base - r1.base;
1250 	r2_size = (r1.base + r1.size) - (r2.base + r2.size);
1255 	memblock_remove(r2.base, r2.size);
1260 	ASSERT_EQ(rgn2->base, r2.base + r2.size);
1307  * A simple test that tries remove a region r2 from the array of available
1308  * memory regions when r2 extends past PHYS_ADDR_MAX:
1311  *                               |   r2   |
1317  * Expect that only the portion between PHYS_ADDR_MAX and r2.base is removed.
1333 	struct region r2 = {
1340 	total_size = r1.size - (PHYS_ADDR_MAX - r2.base);
1344 	memblock_remove(r2.base, r2.size);
1359  * regions r1 and r2:
1365  *  |    |    |r1  :   :       |r2      |     |
1368  * Expect that only the intersections of r1 with r3 and r2 with r3 are removed
1384 	struct region r2 = {
1395 	r2_end = r2.base + r2.size;
1403 	memblock_add(r2.base, r2.size);
1443  * the next entry r2 in memblock.reserved:
1446  *  |              : r1 :           | r2 | |
1453  * value of r2. The region counter and total size are updated.
1465 	struct region r2 = {
1474 	memblock_reserve(r2.base, r2.size);
1477 	ASSERT_EQ(rgn->base, r2.base);
1478 	ASSERT_EQ(rgn->size, r2.size);
1481 	ASSERT_EQ(memblock.reserved.total_size, r2.size);
1489  * A test that tries to free a region r2 that was not marked as reserved
1493  *                     |       r2       |
1514 	struct region r2 = {
1523 	memblock_free((void *)r2.base, r2.size);
1537  * A test that tries to free a region r2 that overlaps with the beginning
1538  * of the already existing entry r1 (that is r1.base < r2.base + r2.size):
1541  *     | r2 |
1566 	struct region r2 = {
1573 	total_size = (r1.size + r1.base) - (r2.base + r2.size);
1577 	memblock_free((void *)r2.base, r2.size);
1579 	ASSERT_EQ(rgn->base, r2.base + r2.size);
1591  * A test that tries to free a region r2 that overlaps with the end of
1592  * the already existing entry r1 (that is r2.base < r1.base + r1.size):
1595  *                   |       r2       |
1615 	struct region r2 = {
1622 	total_size = r2.base - r1.base;
1626 	memblock_free((void *)r2.base, r2.size);
1640  * A test that tries to free a region r2 that is within the range of the
1642  * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)):
1645  *                    | r2 |
1654  * Expect that the region is split into two - one that ends at r2.base and
1655  * another that starts at r2.base + r2.size, with appropriate sizes. The
1670 	struct region r2 = {
1677 	r1_size = r2.base - r1.base;
1678 	r2_size = (r1.base + r1.size) - (r2.base + r2.size);
1683 	memblock_free((void *)r2.base, r2.size);
1688 	ASSERT_EQ(rgn2->base, r2.base + r2.size);
1735  * A simple test that tries free a region r2 when r2 extends past PHYS_ADDR_MAX:
1738  *                               |   r2   |
1744  * Expect that only the portion between PHYS_ADDR_MAX and r2.base is freed.
1760 	struct region r2 = {
1767 	total_size = r1.size - (PHYS_ADDR_MAX - r2.base);
1771 	memblock_free((void *)r2.base, r2.size);
1786  * existing reserved regions r1 and r2:
1792  *  |    |    |r1  :   :       |r2      |     |
1795  * Expect that only the intersections of r1 with r3 and r2 with r3 are freed
1811 	struct region r2 = {
1822 	r2_end = r2.base + r2.size;
1830 	memblock_reserve(r2.base, r2.size);
1946  * r2. Region r1 is aligned on both ends and region r2 is unaligned on one end
1952  * |        |        r1       |        |  r2  |   |
1959  * Expect that r1 will not be trimmed and r2 will be removed. Expect the
1973 	struct region r2 = {
1982 	memblock_add(r2.base, r2.size);
1997  * r2. Region r1 is aligned on both ends and region r2 is unaligned at the base
2004  * |        |        r1       |          |      r2       |   |
2011  * Expect that r1 will not be trimmed and r2 will be trimmed at the base.
2028 	struct region r2 = {
2035 	new_r2_base = r2.base + (alignment - offset);
2036 	new_r2_size = r2.size - (alignment - offset);
2040 	memblock_add(r2.base, r2.size);
2058  * r2. Region r1 is aligned on both ends and region r2 is aligned at the base
2065  * |        |        r1       |        |      r2       |   |
2072  * Expect that r1 will not be trimmed and r2 will be trimmed at the end.
2089 	struct region r2 = {
2096 	new_r2_size = r2.size - (alignment - offset);
2100 	memblock_add(r2.base, r2.size);
2106 	ASSERT_EQ(rgn2->base, r2.base);