Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 #include "alloc_nid_api.h"
0003 
0004 /*
0005  * A simple test that tries to allocate a memory region within min_addr and
0006  * max_addr range:
0007  *
0008  *        +                   +
0009  *   |    +       +-----------+      |
0010  *   |    |       |    rgn    |      |
0011  *   +----+-------+-----------+------+
0012  *        ^                   ^
0013  *        |                   |
0014  *        min_addr           max_addr
0015  *
0016  * Expect to allocate a cleared region that ends at max_addr.
0017  */
0018 static int alloc_try_nid_top_down_simple_check(void)
0019 {
0020     struct memblock_region *rgn = &memblock.reserved.regions[0];
0021     void *allocated_ptr = NULL;
0022     char *b;
0023 
0024     PREFIX_PUSH();
0025 
0026     phys_addr_t size = SZ_128;
0027     phys_addr_t min_addr;
0028     phys_addr_t max_addr;
0029     phys_addr_t rgn_end;
0030 
0031     setup_memblock();
0032 
0033     min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
0034     max_addr = min_addr + SZ_512;
0035 
0036     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
0037                            min_addr, max_addr, NUMA_NO_NODE);
0038     b = (char *)allocated_ptr;
0039     rgn_end = rgn->base + rgn->size;
0040 
0041     ASSERT_NE(allocated_ptr, NULL);
0042     ASSERT_EQ(*b, 0);
0043 
0044     ASSERT_EQ(rgn->size, size);
0045     ASSERT_EQ(rgn->base, max_addr - size);
0046     ASSERT_EQ(rgn_end, max_addr);
0047 
0048     ASSERT_EQ(memblock.reserved.cnt, 1);
0049     ASSERT_EQ(memblock.reserved.total_size, size);
0050 
0051     test_pass_pop();
0052 
0053     return 0;
0054 }
0055 
0056 /*
0057  * A simple test that tries to allocate a memory region within min_addr and
0058  * max_addr range, where the end address is misaligned:
0059  *
0060  *         +       +            +
0061  *  |      +       +---------+  +    |
0062  *  |      |       |   rgn   |  |    |
0063  *  +------+-------+---------+--+----+
0064  *         ^       ^            ^
0065  *         |       |            |
0066  *       min_add   |            max_addr
0067  *                 |
0068  *                 Aligned address
0069  *                 boundary
0070  *
0071  * Expect to allocate a cleared, aligned region that ends before max_addr.
0072  */
0073 static int alloc_try_nid_top_down_end_misaligned_check(void)
0074 {
0075     struct memblock_region *rgn = &memblock.reserved.regions[0];
0076     void *allocated_ptr = NULL;
0077     char *b;
0078 
0079     PREFIX_PUSH();
0080 
0081     phys_addr_t size = SZ_128;
0082     phys_addr_t misalign = SZ_2;
0083     phys_addr_t min_addr;
0084     phys_addr_t max_addr;
0085     phys_addr_t rgn_end;
0086 
0087     setup_memblock();
0088 
0089     min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
0090     max_addr = min_addr + SZ_512 + misalign;
0091 
0092     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
0093                            min_addr, max_addr, NUMA_NO_NODE);
0094     b = (char *)allocated_ptr;
0095     rgn_end = rgn->base + rgn->size;
0096 
0097     ASSERT_NE(allocated_ptr, NULL);
0098     ASSERT_EQ(*b, 0);
0099 
0100     ASSERT_EQ(rgn->size, size);
0101     ASSERT_EQ(rgn->base, max_addr - size - misalign);
0102     ASSERT_LT(rgn_end, max_addr);
0103 
0104     ASSERT_EQ(memblock.reserved.cnt, 1);
0105     ASSERT_EQ(memblock.reserved.total_size, size);
0106 
0107     test_pass_pop();
0108 
0109     return 0;
0110 }
0111 
0112 /*
0113  * A simple test that tries to allocate a memory region, which spans over the
0114  * min_addr and max_addr range:
0115  *
0116  *         +               +
0117  *  |      +---------------+       |
0118  *  |      |      rgn      |       |
0119  *  +------+---------------+-------+
0120  *         ^               ^
0121  *         |               |
0122  *         min_addr        max_addr
0123  *
0124  * Expect to allocate a cleared region that starts at min_addr and ends at
0125  * max_addr, given that min_addr is aligned.
0126  */
0127 static int alloc_try_nid_exact_address_generic_check(void)
0128 {
0129     struct memblock_region *rgn = &memblock.reserved.regions[0];
0130     void *allocated_ptr = NULL;
0131     char *b;
0132 
0133     PREFIX_PUSH();
0134 
0135     phys_addr_t size = SZ_1K;
0136     phys_addr_t min_addr;
0137     phys_addr_t max_addr;
0138     phys_addr_t rgn_end;
0139 
0140     setup_memblock();
0141 
0142     min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES;
0143     max_addr = min_addr + size;
0144 
0145     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
0146                            min_addr, max_addr, NUMA_NO_NODE);
0147     b = (char *)allocated_ptr;
0148     rgn_end = rgn->base + rgn->size;
0149 
0150     ASSERT_NE(allocated_ptr, NULL);
0151     ASSERT_EQ(*b, 0);
0152 
0153     ASSERT_EQ(rgn->size, size);
0154     ASSERT_EQ(rgn->base, min_addr);
0155     ASSERT_EQ(rgn_end, max_addr);
0156 
0157     ASSERT_EQ(memblock.reserved.cnt, 1);
0158     ASSERT_EQ(memblock.reserved.total_size, size);
0159 
0160     test_pass_pop();
0161 
0162     return 0;
0163 }
0164 
0165 /*
0166  * A test that tries to allocate a memory region, which can't fit into
0167  * min_addr and max_addr range:
0168  *
0169  *           +          +     +
0170  *  |        +----------+-----+    |
0171  *  |        |   rgn    +     |    |
0172  *  +--------+----------+-----+----+
0173  *           ^          ^     ^
0174  *           |          |     |
0175  *           Aligned    |    max_addr
0176  *           address    |
0177  *           boundary   min_add
0178  *
0179  * Expect to drop the lower limit and allocate a cleared memory region which
0180  * ends at max_addr (if the address is aligned).
0181  */
0182 static int alloc_try_nid_top_down_narrow_range_check(void)
0183 {
0184     struct memblock_region *rgn = &memblock.reserved.regions[0];
0185     void *allocated_ptr = NULL;
0186     char *b;
0187 
0188     PREFIX_PUSH();
0189 
0190     phys_addr_t size = SZ_256;
0191     phys_addr_t min_addr;
0192     phys_addr_t max_addr;
0193 
0194     setup_memblock();
0195 
0196     min_addr = memblock_start_of_DRAM() + SZ_512;
0197     max_addr = min_addr + SMP_CACHE_BYTES;
0198 
0199     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
0200                            min_addr, max_addr, NUMA_NO_NODE);
0201     b = (char *)allocated_ptr;
0202 
0203     ASSERT_NE(allocated_ptr, NULL);
0204     ASSERT_EQ(*b, 0);
0205 
0206     ASSERT_EQ(rgn->size, size);
0207     ASSERT_EQ(rgn->base, max_addr - size);
0208 
0209     ASSERT_EQ(memblock.reserved.cnt, 1);
0210     ASSERT_EQ(memblock.reserved.total_size, size);
0211 
0212     test_pass_pop();
0213 
0214     return 0;
0215 }
0216 
0217 /*
0218  * A test that tries to allocate a memory region, which can't fit into
0219  * min_addr and max_addr range, with the latter being too close to the beginning
0220  * of the available memory:
0221  *
0222  *   +-------------+
0223  *   |     new     |
0224  *   +-------------+
0225  *         +       +
0226  *         |       +              |
0227  *         |       |              |
0228  *         +-------+--------------+
0229  *         ^       ^
0230  *         |       |
0231  *         |       max_addr
0232  *         |
0233  *         min_addr
0234  *
0235  * Expect no allocation to happen.
0236  */
0237 static int alloc_try_nid_low_max_generic_check(void)
0238 {
0239     void *allocated_ptr = NULL;
0240 
0241     PREFIX_PUSH();
0242 
0243     phys_addr_t size = SZ_1K;
0244     phys_addr_t min_addr;
0245     phys_addr_t max_addr;
0246 
0247     setup_memblock();
0248 
0249     min_addr = memblock_start_of_DRAM();
0250     max_addr = min_addr + SMP_CACHE_BYTES;
0251 
0252     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
0253                            min_addr, max_addr, NUMA_NO_NODE);
0254 
0255     ASSERT_EQ(allocated_ptr, NULL);
0256 
0257     test_pass_pop();
0258 
0259     return 0;
0260 }
0261 
0262 /*
0263  * A test that tries to allocate a memory region within min_addr min_addr range,
0264  * with min_addr being so close that it's next to an allocated region:
0265  *
0266  *          +                        +
0267  *  |       +--------+---------------|
0268  *  |       |   r1   |      rgn      |
0269  *  +-------+--------+---------------+
0270  *          ^                        ^
0271  *          |                        |
0272  *          min_addr                 max_addr
0273  *
0274  * Expect a merge of both regions. Only the region size gets updated.
0275  */
0276 static int alloc_try_nid_min_reserved_generic_check(void)
0277 {
0278     struct memblock_region *rgn = &memblock.reserved.regions[0];
0279     void *allocated_ptr = NULL;
0280     char *b;
0281 
0282     PREFIX_PUSH();
0283 
0284     phys_addr_t r1_size = SZ_128;
0285     phys_addr_t r2_size = SZ_64;
0286     phys_addr_t total_size = r1_size + r2_size;
0287     phys_addr_t min_addr;
0288     phys_addr_t max_addr;
0289     phys_addr_t reserved_base;
0290 
0291     setup_memblock();
0292 
0293     max_addr = memblock_end_of_DRAM();
0294     min_addr = max_addr - r2_size;
0295     reserved_base = min_addr - r1_size;
0296 
0297     memblock_reserve(reserved_base, r1_size);
0298 
0299     allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
0300                            min_addr, max_addr, NUMA_NO_NODE);
0301     b = (char *)allocated_ptr;
0302 
0303     ASSERT_NE(allocated_ptr, NULL);
0304     ASSERT_EQ(*b, 0);
0305 
0306     ASSERT_EQ(rgn->size, total_size);
0307     ASSERT_EQ(rgn->base, reserved_base);
0308 
0309     ASSERT_EQ(memblock.reserved.cnt, 1);
0310     ASSERT_EQ(memblock.reserved.total_size, total_size);
0311 
0312     test_pass_pop();
0313 
0314     return 0;
0315 }
0316 
0317 /*
0318  * A test that tries to allocate a memory region within min_addr and max_addr,
0319  * with max_addr being so close that it's next to an allocated region:
0320  *
0321  *             +             +
0322  *  |          +-------------+--------|
0323  *  |          |     rgn     |   r1   |
0324  *  +----------+-------------+--------+
0325  *             ^             ^
0326  *             |             |
0327  *             min_addr      max_addr
0328  *
0329  * Expect a merge of regions. Only the region size gets updated.
0330  */
0331 static int alloc_try_nid_max_reserved_generic_check(void)
0332 {
0333     struct memblock_region *rgn = &memblock.reserved.regions[0];
0334     void *allocated_ptr = NULL;
0335     char *b;
0336 
0337     PREFIX_PUSH();
0338 
0339     phys_addr_t r1_size = SZ_64;
0340     phys_addr_t r2_size = SZ_128;
0341     phys_addr_t total_size = r1_size + r2_size;
0342     phys_addr_t min_addr;
0343     phys_addr_t max_addr;
0344 
0345     setup_memblock();
0346 
0347     max_addr = memblock_end_of_DRAM() - r1_size;
0348     min_addr = max_addr - r2_size;
0349 
0350     memblock_reserve(max_addr, r1_size);
0351 
0352     allocated_ptr = memblock_alloc_try_nid(r2_size, SMP_CACHE_BYTES,
0353                            min_addr, max_addr, NUMA_NO_NODE);
0354     b = (char *)allocated_ptr;
0355 
0356     ASSERT_NE(allocated_ptr, NULL);
0357     ASSERT_EQ(*b, 0);
0358 
0359     ASSERT_EQ(rgn->size, total_size);
0360     ASSERT_EQ(rgn->base, min_addr);
0361 
0362     ASSERT_EQ(memblock.reserved.cnt, 1);
0363     ASSERT_EQ(memblock.reserved.total_size, total_size);
0364 
0365     test_pass_pop();
0366 
0367     return 0;
0368 }
0369 
0370 /*
0371  * A test that tries to allocate memory within min_addr and max_add range, when
0372  * there are two reserved regions at the borders, with a gap big enough to fit
0373  * a new region:
0374  *
0375  *                +           +
0376  *  |    +--------+   +-------+------+  |
0377  *  |    |   r2   |   |  rgn  |  r1  |  |
0378  *  +----+--------+---+-------+------+--+
0379  *                ^           ^
0380  *                |           |
0381  *                min_addr    max_addr
0382  *
0383  * Expect to merge the new region with r1. The second region does not get
0384  * updated. The total size field gets updated.
0385  */
0386 
0387 static int alloc_try_nid_top_down_reserved_with_space_check(void)
0388 {
0389     struct memblock_region *rgn1 = &memblock.reserved.regions[1];
0390     struct memblock_region *rgn2 = &memblock.reserved.regions[0];
0391     void *allocated_ptr = NULL;
0392     char *b;
0393     struct region r1, r2;
0394 
0395     PREFIX_PUSH();
0396 
0397     phys_addr_t r3_size = SZ_64;
0398     phys_addr_t gap_size = SMP_CACHE_BYTES;
0399     phys_addr_t total_size;
0400     phys_addr_t max_addr;
0401     phys_addr_t min_addr;
0402 
0403     setup_memblock();
0404 
0405     r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
0406     r1.size = SMP_CACHE_BYTES;
0407 
0408     r2.size = SZ_128;
0409     r2.base = r1.base - (r3_size + gap_size + r2.size);
0410 
0411     total_size = r1.size + r2.size + r3_size;
0412     min_addr = r2.base + r2.size;
0413     max_addr = r1.base;
0414 
0415     memblock_reserve(r1.base, r1.size);
0416     memblock_reserve(r2.base, r2.size);
0417 
0418     allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
0419                            min_addr, max_addr, NUMA_NO_NODE);
0420     b = (char *)allocated_ptr;
0421 
0422     ASSERT_NE(allocated_ptr, NULL);
0423     ASSERT_EQ(*b, 0);
0424 
0425     ASSERT_EQ(rgn1->size, r1.size + r3_size);
0426     ASSERT_EQ(rgn1->base, max_addr - r3_size);
0427 
0428     ASSERT_EQ(rgn2->size, r2.size);
0429     ASSERT_EQ(rgn2->base, r2.base);
0430 
0431     ASSERT_EQ(memblock.reserved.cnt, 2);
0432     ASSERT_EQ(memblock.reserved.total_size, total_size);
0433 
0434     test_pass_pop();
0435 
0436     return 0;
0437 }
0438 
0439 /*
0440  * A test that tries to allocate memory within min_addr and max_add range, when
0441  * there are two reserved regions at the borders, with a gap of a size equal to
0442  * the size of the new region:
0443  *
0444  *                 +        +
0445  *  |     +--------+--------+--------+     |
0446  *  |     |   r2   |   r3   |   r1   |     |
0447  *  +-----+--------+--------+--------+-----+
0448  *                 ^        ^
0449  *                 |        |
0450  *                 min_addr max_addr
0451  *
0452  * Expect to merge all of the regions into one. The region counter and total
0453  * size fields get updated.
0454  */
0455 static int alloc_try_nid_reserved_full_merge_generic_check(void)
0456 {
0457     struct memblock_region *rgn = &memblock.reserved.regions[0];
0458     void *allocated_ptr = NULL;
0459     char *b;
0460     struct region r1, r2;
0461 
0462     PREFIX_PUSH();
0463 
0464     phys_addr_t r3_size = SZ_64;
0465     phys_addr_t total_size;
0466     phys_addr_t max_addr;
0467     phys_addr_t min_addr;
0468 
0469     setup_memblock();
0470 
0471     r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
0472     r1.size = SMP_CACHE_BYTES;
0473 
0474     r2.size = SZ_128;
0475     r2.base = r1.base - (r3_size + r2.size);
0476 
0477     total_size = r1.size + r2.size + r3_size;
0478     min_addr = r2.base + r2.size;
0479     max_addr = r1.base;
0480 
0481     memblock_reserve(r1.base, r1.size);
0482     memblock_reserve(r2.base, r2.size);
0483 
0484     allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
0485                            min_addr, max_addr, NUMA_NO_NODE);
0486     b = (char *)allocated_ptr;
0487 
0488     ASSERT_NE(allocated_ptr, NULL);
0489     ASSERT_EQ(*b, 0);
0490 
0491     ASSERT_EQ(rgn->size, total_size);
0492     ASSERT_EQ(rgn->base, r2.base);
0493 
0494     ASSERT_EQ(memblock.reserved.cnt, 1);
0495     ASSERT_EQ(memblock.reserved.total_size, total_size);
0496 
0497     test_pass_pop();
0498 
0499     return 0;
0500 }
0501 
0502 /*
0503  * A test that tries to allocate memory within min_addr and max_add range, when
0504  * there are two reserved regions at the borders, with a gap that can't fit
0505  * a new region:
0506  *
0507  *                       +    +
0508  *  |  +----------+------+    +------+   |
0509  *  |  |    r3    |  r2  |    |  r1  |   |
0510  *  +--+----------+------+----+------+---+
0511  *                       ^    ^
0512  *                       |    |
0513  *                       |    max_addr
0514  *                       |
0515  *                       min_addr
0516  *
0517  * Expect to merge the new region with r2. The second region does not get
0518  * updated. The total size counter gets updated.
0519  */
0520 static int alloc_try_nid_top_down_reserved_no_space_check(void)
0521 {
0522     struct memblock_region *rgn1 = &memblock.reserved.regions[1];
0523     struct memblock_region *rgn2 = &memblock.reserved.regions[0];
0524     void *allocated_ptr = NULL;
0525     char *b;
0526     struct region r1, r2;
0527 
0528     PREFIX_PUSH();
0529 
0530     phys_addr_t r3_size = SZ_256;
0531     phys_addr_t gap_size = SMP_CACHE_BYTES;
0532     phys_addr_t total_size;
0533     phys_addr_t max_addr;
0534     phys_addr_t min_addr;
0535 
0536     setup_memblock();
0537 
0538     r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
0539     r1.size = SMP_CACHE_BYTES;
0540 
0541     r2.size = SZ_128;
0542     r2.base = r1.base - (r2.size + gap_size);
0543 
0544     total_size = r1.size + r2.size + r3_size;
0545     min_addr = r2.base + r2.size;
0546     max_addr = r1.base;
0547 
0548     memblock_reserve(r1.base, r1.size);
0549     memblock_reserve(r2.base, r2.size);
0550 
0551     allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
0552                            min_addr, max_addr, NUMA_NO_NODE);
0553     b = (char *)allocated_ptr;
0554 
0555     ASSERT_NE(allocated_ptr, NULL);
0556     ASSERT_EQ(*b, 0);
0557 
0558     ASSERT_EQ(rgn1->size, r1.size);
0559     ASSERT_EQ(rgn1->base, r1.base);
0560 
0561     ASSERT_EQ(rgn2->size, r2.size + r3_size);
0562     ASSERT_EQ(rgn2->base, r2.base - r3_size);
0563 
0564     ASSERT_EQ(memblock.reserved.cnt, 2);
0565     ASSERT_EQ(memblock.reserved.total_size, total_size);
0566 
0567     test_pass_pop();
0568 
0569     return 0;
0570 }
0571 
0572 /*
0573  * A test that tries to allocate memory within min_addr and max_add range, but
0574  * it's too narrow and everything else is reserved:
0575  *
0576  *            +-----------+
0577  *            |    new    |
0578  *            +-----------+
0579  *                 +      +
0580  *  |--------------+      +----------|
0581  *  |      r2      |      |    r1    |
0582  *  +--------------+------+----------+
0583  *                 ^      ^
0584  *                 |      |
0585  *                 |      max_addr
0586  *                 |
0587  *                 min_addr
0588  *
0589  * Expect no allocation to happen.
0590  */
0591 
0592 static int alloc_try_nid_reserved_all_generic_check(void)
0593 {
0594     void *allocated_ptr = NULL;
0595     struct region r1, r2;
0596 
0597     PREFIX_PUSH();
0598 
0599     phys_addr_t r3_size = SZ_256;
0600     phys_addr_t gap_size = SMP_CACHE_BYTES;
0601     phys_addr_t max_addr;
0602     phys_addr_t min_addr;
0603 
0604     setup_memblock();
0605 
0606     r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES;
0607     r1.size = SMP_CACHE_BYTES;
0608 
0609     r2.size = MEM_SIZE - (r1.size + gap_size);
0610     r2.base = memblock_start_of_DRAM();
0611 
0612     min_addr = r2.base + r2.size;
0613     max_addr = r1.base;
0614 
0615     memblock_reserve(r1.base, r1.size);
0616     memblock_reserve(r2.base, r2.size);
0617 
0618     allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
0619                            min_addr, max_addr, NUMA_NO_NODE);
0620 
0621     ASSERT_EQ(allocated_ptr, NULL);
0622 
0623     test_pass_pop();
0624 
0625     return 0;
0626 }
0627 
0628 /*
0629  * A test that tries to allocate a memory region, where max_addr is
0630  * bigger than the end address of the available memory. Expect to allocate
0631  * a cleared region that ends before the end of the memory.
0632  */
0633 static int alloc_try_nid_top_down_cap_max_check(void)
0634 {
0635     struct memblock_region *rgn = &memblock.reserved.regions[0];
0636     void *allocated_ptr = NULL;
0637     char *b;
0638 
0639     PREFIX_PUSH();
0640 
0641     phys_addr_t size = SZ_256;
0642     phys_addr_t min_addr;
0643     phys_addr_t max_addr;
0644 
0645     setup_memblock();
0646 
0647     min_addr = memblock_end_of_DRAM() - SZ_1K;
0648     max_addr = memblock_end_of_DRAM() + SZ_256;
0649 
0650     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
0651                            min_addr, max_addr, NUMA_NO_NODE);
0652     b = (char *)allocated_ptr;
0653 
0654     ASSERT_NE(allocated_ptr, NULL);
0655     ASSERT_EQ(*b, 0);
0656 
0657     ASSERT_EQ(rgn->size, size);
0658     ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
0659 
0660     ASSERT_EQ(memblock.reserved.cnt, 1);
0661     ASSERT_EQ(memblock.reserved.total_size, size);
0662 
0663     test_pass_pop();
0664 
0665     return 0;
0666 }
0667 
0668 /*
0669  * A test that tries to allocate a memory region, where min_addr is
0670  * smaller than the start address of the available memory. Expect to allocate
0671  * a cleared region that ends before the end of the memory.
0672  */
0673 static int alloc_try_nid_top_down_cap_min_check(void)
0674 {
0675     struct memblock_region *rgn = &memblock.reserved.regions[0];
0676     void *allocated_ptr = NULL;
0677     char *b;
0678 
0679     PREFIX_PUSH();
0680 
0681     phys_addr_t size = SZ_1K;
0682     phys_addr_t min_addr;
0683     phys_addr_t max_addr;
0684 
0685     setup_memblock();
0686 
0687     min_addr = memblock_start_of_DRAM() - SZ_256;
0688     max_addr = memblock_end_of_DRAM();
0689 
0690     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
0691                            min_addr, max_addr, NUMA_NO_NODE);
0692     b = (char *)allocated_ptr;
0693 
0694     ASSERT_NE(allocated_ptr, NULL);
0695     ASSERT_EQ(*b, 0);
0696 
0697     ASSERT_EQ(rgn->size, size);
0698     ASSERT_EQ(rgn->base, memblock_end_of_DRAM() - size);
0699 
0700     ASSERT_EQ(memblock.reserved.cnt, 1);
0701     ASSERT_EQ(memblock.reserved.total_size, size);
0702 
0703     test_pass_pop();
0704 
0705     return 0;
0706 }
0707 
0708 /*
0709  * A simple test that tries to allocate a memory region within min_addr and
0710  * max_addr range:
0711  *
0712  *        +                       +
0713  *   |    +-----------+           |      |
0714  *   |    |    rgn    |           |      |
0715  *   +----+-----------+-----------+------+
0716  *        ^                       ^
0717  *        |                       |
0718  *        min_addr                max_addr
0719  *
0720  * Expect to allocate a cleared region that ends before max_addr.
0721  */
0722 static int alloc_try_nid_bottom_up_simple_check(void)
0723 {
0724     struct memblock_region *rgn = &memblock.reserved.regions[0];
0725     void *allocated_ptr = NULL;
0726     char *b;
0727 
0728     PREFIX_PUSH();
0729 
0730     phys_addr_t size = SZ_128;
0731     phys_addr_t min_addr;
0732     phys_addr_t max_addr;
0733     phys_addr_t rgn_end;
0734 
0735     setup_memblock();
0736 
0737     min_addr = memblock_start_of_DRAM() + SMP_CACHE_BYTES * 2;
0738     max_addr = min_addr + SZ_512;
0739 
0740     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
0741                            min_addr, max_addr,
0742                            NUMA_NO_NODE);
0743     b = (char *)allocated_ptr;
0744     rgn_end = rgn->base + rgn->size;
0745 
0746     ASSERT_NE(allocated_ptr, NULL);
0747     ASSERT_EQ(*b, 0);
0748 
0749     ASSERT_EQ(rgn->size, size);
0750     ASSERT_EQ(rgn->base, min_addr);
0751     ASSERT_LT(rgn_end, max_addr);
0752 
0753     ASSERT_EQ(memblock.reserved.cnt, 1);
0754     ASSERT_EQ(memblock.reserved.total_size, size);
0755 
0756     test_pass_pop();
0757 
0758     return 0;
0759 }
0760 
0761 /*
0762  * A simple test that tries to allocate a memory region within min_addr and
0763  * max_addr range, where the start address is misaligned:
0764  *
0765  *        +                     +
0766  *  |     +   +-----------+     +     |
0767  *  |     |   |    rgn    |     |     |
0768  *  +-----+---+-----------+-----+-----+
0769  *        ^   ^----.            ^
0770  *        |        |            |
0771  *     min_add     |            max_addr
0772  *                 |
0773  *                 Aligned address
0774  *                 boundary
0775  *
0776  * Expect to allocate a cleared, aligned region that ends before max_addr.
0777  */
0778 static int alloc_try_nid_bottom_up_start_misaligned_check(void)
0779 {
0780     struct memblock_region *rgn = &memblock.reserved.regions[0];
0781     void *allocated_ptr = NULL;
0782     char *b;
0783 
0784     PREFIX_PUSH();
0785 
0786     phys_addr_t size = SZ_128;
0787     phys_addr_t misalign = SZ_2;
0788     phys_addr_t min_addr;
0789     phys_addr_t max_addr;
0790     phys_addr_t rgn_end;
0791 
0792     setup_memblock();
0793 
0794     min_addr = memblock_start_of_DRAM() + misalign;
0795     max_addr = min_addr + SZ_512;
0796 
0797     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
0798                            min_addr, max_addr,
0799                            NUMA_NO_NODE);
0800     b = (char *)allocated_ptr;
0801     rgn_end = rgn->base + rgn->size;
0802 
0803     ASSERT_NE(allocated_ptr, NULL);
0804     ASSERT_EQ(*b, 0);
0805 
0806     ASSERT_EQ(rgn->size, size);
0807     ASSERT_EQ(rgn->base, min_addr + (SMP_CACHE_BYTES - misalign));
0808     ASSERT_LT(rgn_end, max_addr);
0809 
0810     ASSERT_EQ(memblock.reserved.cnt, 1);
0811     ASSERT_EQ(memblock.reserved.total_size, size);
0812 
0813     test_pass_pop();
0814 
0815     return 0;
0816 }
0817 
0818 /*
0819  * A test that tries to allocate a memory region, which can't fit into min_addr
0820  * and max_addr range:
0821  *
0822  *                      +    +
0823  *  |---------+         +    +      |
0824  *  |   rgn   |         |    |      |
0825  *  +---------+---------+----+------+
0826  *                      ^    ^
0827  *                      |    |
0828  *                      |    max_addr
0829  *                      |
0830  *                      min_add
0831  *
0832  * Expect to drop the lower limit and allocate a cleared memory region which
0833  * starts at the beginning of the available memory.
0834  */
0835 static int alloc_try_nid_bottom_up_narrow_range_check(void)
0836 {
0837     struct memblock_region *rgn = &memblock.reserved.regions[0];
0838     void *allocated_ptr = NULL;
0839     char *b;
0840 
0841     PREFIX_PUSH();
0842 
0843     phys_addr_t size = SZ_256;
0844     phys_addr_t min_addr;
0845     phys_addr_t max_addr;
0846 
0847     setup_memblock();
0848 
0849     min_addr = memblock_start_of_DRAM() + SZ_512;
0850     max_addr = min_addr + SMP_CACHE_BYTES;
0851 
0852     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
0853                            min_addr, max_addr,
0854                            NUMA_NO_NODE);
0855     b = (char *)allocated_ptr;
0856 
0857     ASSERT_NE(allocated_ptr, NULL);
0858     ASSERT_EQ(*b, 0);
0859 
0860     ASSERT_EQ(rgn->size, size);
0861     ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
0862 
0863     ASSERT_EQ(memblock.reserved.cnt, 1);
0864     ASSERT_EQ(memblock.reserved.total_size, size);
0865 
0866     test_pass_pop();
0867 
0868     return 0;
0869 }
0870 
0871 /*
0872  * A test that tries to allocate memory within min_addr and max_add range, when
0873  * there are two reserved regions at the borders, with a gap big enough to fit
0874  * a new region:
0875  *
0876  *                +           +
0877  *  |    +--------+-------+   +------+  |
0878  *  |    |   r2   |  rgn  |   |  r1  |  |
0879  *  +----+--------+-------+---+------+--+
0880  *                ^           ^
0881  *                |           |
0882  *                min_addr    max_addr
0883  *
0884  * Expect to merge the new region with r2. The second region does not get
0885  * updated. The total size field gets updated.
0886  */
0887 
0888 static int alloc_try_nid_bottom_up_reserved_with_space_check(void)
0889 {
0890     struct memblock_region *rgn1 = &memblock.reserved.regions[1];
0891     struct memblock_region *rgn2 = &memblock.reserved.regions[0];
0892     void *allocated_ptr = NULL;
0893     char *b;
0894     struct region r1, r2;
0895 
0896     PREFIX_PUSH();
0897 
0898     phys_addr_t r3_size = SZ_64;
0899     phys_addr_t gap_size = SMP_CACHE_BYTES;
0900     phys_addr_t total_size;
0901     phys_addr_t max_addr;
0902     phys_addr_t min_addr;
0903 
0904     setup_memblock();
0905 
0906     r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
0907     r1.size = SMP_CACHE_BYTES;
0908 
0909     r2.size = SZ_128;
0910     r2.base = r1.base - (r3_size + gap_size + r2.size);
0911 
0912     total_size = r1.size + r2.size + r3_size;
0913     min_addr = r2.base + r2.size;
0914     max_addr = r1.base;
0915 
0916     memblock_reserve(r1.base, r1.size);
0917     memblock_reserve(r2.base, r2.size);
0918 
0919     allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
0920                            min_addr, max_addr,
0921                            NUMA_NO_NODE);
0922     b = (char *)allocated_ptr;
0923 
0924     ASSERT_NE(allocated_ptr, NULL);
0925     ASSERT_EQ(*b, 0);
0926 
0927     ASSERT_EQ(rgn1->size, r1.size);
0928     ASSERT_EQ(rgn1->base, max_addr);
0929 
0930     ASSERT_EQ(rgn2->size, r2.size + r3_size);
0931     ASSERT_EQ(rgn2->base, r2.base);
0932 
0933     ASSERT_EQ(memblock.reserved.cnt, 2);
0934     ASSERT_EQ(memblock.reserved.total_size, total_size);
0935 
0936     test_pass_pop();
0937 
0938     return 0;
0939 }
0940 
0941 /*
0942  * A test that tries to allocate memory within min_addr and max_add range, when
0943  * there are two reserved regions at the borders, with a gap of a size equal to
0944  * the size of the new region:
0945  *
0946  *                         +   +
0947  *  |----------+    +------+   +----+  |
0948  *  |    r3    |    |  r2  |   | r1 |  |
0949  *  +----------+----+------+---+----+--+
0950  *                         ^   ^
0951  *                         |   |
0952  *                         |  max_addr
0953  *                         |
0954  *                         min_addr
0955  *
0956  * Expect to drop the lower limit and allocate memory at the beginning of the
0957  * available memory. The region counter and total size fields get updated.
0958  * Other regions are not modified.
0959  */
0960 
0961 static int alloc_try_nid_bottom_up_reserved_no_space_check(void)
0962 {
0963     struct memblock_region *rgn1 = &memblock.reserved.regions[2];
0964     struct memblock_region *rgn2 = &memblock.reserved.regions[1];
0965     struct memblock_region *rgn3 = &memblock.reserved.regions[0];
0966     void *allocated_ptr = NULL;
0967     char *b;
0968     struct region r1, r2;
0969 
0970     PREFIX_PUSH();
0971 
0972     phys_addr_t r3_size = SZ_256;
0973     phys_addr_t gap_size = SMP_CACHE_BYTES;
0974     phys_addr_t total_size;
0975     phys_addr_t max_addr;
0976     phys_addr_t min_addr;
0977 
0978     setup_memblock();
0979 
0980     r1.base = memblock_end_of_DRAM() - SMP_CACHE_BYTES * 2;
0981     r1.size = SMP_CACHE_BYTES;
0982 
0983     r2.size = SZ_128;
0984     r2.base = r1.base - (r2.size + gap_size);
0985 
0986     total_size = r1.size + r2.size + r3_size;
0987     min_addr = r2.base + r2.size;
0988     max_addr = r1.base;
0989 
0990     memblock_reserve(r1.base, r1.size);
0991     memblock_reserve(r2.base, r2.size);
0992 
0993     allocated_ptr = memblock_alloc_try_nid(r3_size, SMP_CACHE_BYTES,
0994                            min_addr, max_addr,
0995                            NUMA_NO_NODE);
0996     b = (char *)allocated_ptr;
0997 
0998     ASSERT_NE(allocated_ptr, NULL);
0999     ASSERT_EQ(*b, 0);
1000 
1001     ASSERT_EQ(rgn3->size, r3_size);
1002     ASSERT_EQ(rgn3->base, memblock_start_of_DRAM());
1003 
1004     ASSERT_EQ(rgn2->size, r2.size);
1005     ASSERT_EQ(rgn2->base, r2.base);
1006 
1007     ASSERT_EQ(rgn1->size, r1.size);
1008     ASSERT_EQ(rgn1->base, r1.base);
1009 
1010     ASSERT_EQ(memblock.reserved.cnt, 3);
1011     ASSERT_EQ(memblock.reserved.total_size, total_size);
1012 
1013     test_pass_pop();
1014 
1015     return 0;
1016 }
1017 
1018 /*
1019  * A test that tries to allocate a memory region, where max_addr is
1020  * bigger than the end address of the available memory. Expect to allocate
1021  * a cleared region that starts at the min_addr
1022  */
1023 static int alloc_try_nid_bottom_up_cap_max_check(void)
1024 {
1025     struct memblock_region *rgn = &memblock.reserved.regions[0];
1026     void *allocated_ptr = NULL;
1027     char *b;
1028 
1029     PREFIX_PUSH();
1030 
1031     phys_addr_t size = SZ_256;
1032     phys_addr_t min_addr;
1033     phys_addr_t max_addr;
1034 
1035     setup_memblock();
1036 
1037     min_addr = memblock_start_of_DRAM() + SZ_1K;
1038     max_addr = memblock_end_of_DRAM() + SZ_256;
1039 
1040     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1041                            min_addr, max_addr,
1042                            NUMA_NO_NODE);
1043     b = (char *)allocated_ptr;
1044 
1045     ASSERT_NE(allocated_ptr, NULL);
1046     ASSERT_EQ(*b, 0);
1047 
1048     ASSERT_EQ(rgn->size, size);
1049     ASSERT_EQ(rgn->base, min_addr);
1050 
1051     ASSERT_EQ(memblock.reserved.cnt, 1);
1052     ASSERT_EQ(memblock.reserved.total_size, size);
1053 
1054     test_pass_pop();
1055 
1056     return 0;
1057 }
1058 
1059 /*
1060  * A test that tries to allocate a memory region, where min_addr is
1061  * smaller than the start address of the available memory. Expect to allocate
1062  * a cleared region at the beginning of the available memory.
1063  */
1064 static int alloc_try_nid_bottom_up_cap_min_check(void)
1065 {
1066     struct memblock_region *rgn = &memblock.reserved.regions[0];
1067     void *allocated_ptr = NULL;
1068     char *b;
1069 
1070     PREFIX_PUSH();
1071 
1072     phys_addr_t size = SZ_1K;
1073     phys_addr_t min_addr;
1074     phys_addr_t max_addr;
1075 
1076     setup_memblock();
1077 
1078     min_addr = memblock_start_of_DRAM();
1079     max_addr = memblock_end_of_DRAM() - SZ_256;
1080 
1081     allocated_ptr = memblock_alloc_try_nid(size, SMP_CACHE_BYTES,
1082                            min_addr, max_addr,
1083                            NUMA_NO_NODE);
1084     b = (char *)allocated_ptr;
1085 
1086     ASSERT_NE(allocated_ptr, NULL);
1087     ASSERT_EQ(*b, 0);
1088 
1089     ASSERT_EQ(rgn->size, size);
1090     ASSERT_EQ(rgn->base, memblock_start_of_DRAM());
1091 
1092     ASSERT_EQ(memblock.reserved.cnt, 1);
1093     ASSERT_EQ(memblock.reserved.total_size, size);
1094 
1095     test_pass_pop();
1096 
1097     return 0;
1098 }
1099 
1100 /* Test case wrappers */
1101 static int alloc_try_nid_simple_check(void)
1102 {
1103     test_print("\tRunning %s...\n", __func__);
1104     memblock_set_bottom_up(false);
1105     alloc_try_nid_top_down_simple_check();
1106     memblock_set_bottom_up(true);
1107     alloc_try_nid_bottom_up_simple_check();
1108 
1109     return 0;
1110 }
1111 
1112 static int alloc_try_nid_misaligned_check(void)
1113 {
1114     test_print("\tRunning %s...\n", __func__);
1115     memblock_set_bottom_up(false);
1116     alloc_try_nid_top_down_end_misaligned_check();
1117     memblock_set_bottom_up(true);
1118     alloc_try_nid_bottom_up_start_misaligned_check();
1119 
1120     return 0;
1121 }
1122 
1123 static int alloc_try_nid_narrow_range_check(void)
1124 {
1125     test_print("\tRunning %s...\n", __func__);
1126     memblock_set_bottom_up(false);
1127     alloc_try_nid_top_down_narrow_range_check();
1128     memblock_set_bottom_up(true);
1129     alloc_try_nid_bottom_up_narrow_range_check();
1130 
1131     return 0;
1132 }
1133 
1134 static int alloc_try_nid_reserved_with_space_check(void)
1135 {
1136     test_print("\tRunning %s...\n", __func__);
1137     memblock_set_bottom_up(false);
1138     alloc_try_nid_top_down_reserved_with_space_check();
1139     memblock_set_bottom_up(true);
1140     alloc_try_nid_bottom_up_reserved_with_space_check();
1141 
1142     return 0;
1143 }
1144 
1145 static int alloc_try_nid_reserved_no_space_check(void)
1146 {
1147     test_print("\tRunning %s...\n", __func__);
1148     memblock_set_bottom_up(false);
1149     alloc_try_nid_top_down_reserved_no_space_check();
1150     memblock_set_bottom_up(true);
1151     alloc_try_nid_bottom_up_reserved_no_space_check();
1152 
1153     return 0;
1154 }
1155 
1156 static int alloc_try_nid_cap_max_check(void)
1157 {
1158     test_print("\tRunning %s...\n", __func__);
1159     memblock_set_bottom_up(false);
1160     alloc_try_nid_top_down_cap_max_check();
1161     memblock_set_bottom_up(true);
1162     alloc_try_nid_bottom_up_cap_max_check();
1163 
1164     return 0;
1165 }
1166 
1167 static int alloc_try_nid_cap_min_check(void)
1168 {
1169     test_print("\tRunning %s...\n", __func__);
1170     memblock_set_bottom_up(false);
1171     alloc_try_nid_top_down_cap_min_check();
1172     memblock_set_bottom_up(true);
1173     alloc_try_nid_bottom_up_cap_min_check();
1174 
1175     return 0;
1176 }
1177 
1178 static int alloc_try_nid_min_reserved_check(void)
1179 {
1180     test_print("\tRunning %s...\n", __func__);
1181     memblock_set_bottom_up(false);
1182     alloc_try_nid_min_reserved_generic_check();
1183     memblock_set_bottom_up(true);
1184     alloc_try_nid_min_reserved_generic_check();
1185 
1186     return 0;
1187 }
1188 
1189 static int alloc_try_nid_max_reserved_check(void)
1190 {
1191     test_print("\tRunning %s...\n", __func__);
1192     memblock_set_bottom_up(false);
1193     alloc_try_nid_max_reserved_generic_check();
1194     memblock_set_bottom_up(true);
1195     alloc_try_nid_max_reserved_generic_check();
1196 
1197     return 0;
1198 }
1199 
1200 static int alloc_try_nid_exact_address_check(void)
1201 {
1202     test_print("\tRunning %s...\n", __func__);
1203     memblock_set_bottom_up(false);
1204     alloc_try_nid_exact_address_generic_check();
1205     memblock_set_bottom_up(true);
1206     alloc_try_nid_exact_address_generic_check();
1207 
1208     return 0;
1209 }
1210 
1211 static int alloc_try_nid_reserved_full_merge_check(void)
1212 {
1213     test_print("\tRunning %s...\n", __func__);
1214     memblock_set_bottom_up(false);
1215     alloc_try_nid_reserved_full_merge_generic_check();
1216     memblock_set_bottom_up(true);
1217     alloc_try_nid_reserved_full_merge_generic_check();
1218 
1219     return 0;
1220 }
1221 
1222 static int alloc_try_nid_reserved_all_check(void)
1223 {
1224     test_print("\tRunning %s...\n", __func__);
1225     memblock_set_bottom_up(false);
1226     alloc_try_nid_reserved_all_generic_check();
1227     memblock_set_bottom_up(true);
1228     alloc_try_nid_reserved_all_generic_check();
1229 
1230     return 0;
1231 }
1232 
1233 static int alloc_try_nid_low_max_check(void)
1234 {
1235     test_print("\tRunning %s...\n", __func__);
1236     memblock_set_bottom_up(false);
1237     alloc_try_nid_low_max_generic_check();
1238     memblock_set_bottom_up(true);
1239     alloc_try_nid_low_max_generic_check();
1240 
1241     return 0;
1242 }
1243 
1244 int memblock_alloc_nid_checks(void)
1245 {
1246     const char *func_testing = "memblock_alloc_try_nid";
1247 
1248     prefix_reset();
1249     prefix_push(func_testing);
1250     test_print("Running %s tests...\n", func_testing);
1251 
1252     reset_memblock_attributes();
1253     dummy_physical_memory_init();
1254 
1255     alloc_try_nid_simple_check();
1256     alloc_try_nid_misaligned_check();
1257     alloc_try_nid_narrow_range_check();
1258     alloc_try_nid_reserved_with_space_check();
1259     alloc_try_nid_reserved_no_space_check();
1260     alloc_try_nid_cap_max_check();
1261     alloc_try_nid_cap_min_check();
1262 
1263     alloc_try_nid_min_reserved_check();
1264     alloc_try_nid_max_reserved_check();
1265     alloc_try_nid_exact_address_check();
1266     alloc_try_nid_reserved_full_merge_check();
1267     alloc_try_nid_reserved_all_check();
1268     alloc_try_nid_low_max_check();
1269 
1270     dummy_physical_memory_cleanup();
1271 
1272     prefix_pop();
1273 
1274     return 0;
1275 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!