Merge tag 'memblock-v5.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/rppt/memblock

5. Add tests for memblock_alloc_node() to check if the correct NUMA node is set

   for the new region

6. Update comments in tests/basic_api.c to match the style used in

   tests/alloc_*.c

/*

 * A simple test that adds a memory block of a specified base address

 * and size to the collection of available memory regions (memblock.memory).

 * It checks if a new entry was created and if region counter and total memory

 * were correctly updated.

 * Expect to create a new entry. The region counter and total memory get

 * updated.

 */

static int memblock_add_simple_check(void)

{

}

/*

 * A simple test that adds a memory block of a specified base address, size

 * A simple test that adds a memory block of a specified base address, size,

 * NUMA node and memory flags to the collection of available memory regions.

 * It checks if the new entry, region counter and total memory size have

 * expected values.

 * Expect to create a new entry. The region counter and total memory get

 * updated.

 */

static int memblock_add_node_simple_check(void)

{

/*

 * A test that tries to add two memory blocks that don't overlap with one

 * another. It checks if two correctly initialized entries were added to the

 * collection of available memory regions (memblock.memory) and if this

 * change was reflected in memblock.memory's total size and region counter.

 * another:

 *

 *  |        +--------+        +--------+  |

 *  |        |   r1   |        |   r2   |  |

 *  +--------+--------+--------+--------+--+

 *

 * Expect to add two correctly initialized entries to the collection of

 * available memory regions (memblock.memory). The total size and

 * region counter fields get updated.

 */

static int memblock_add_disjoint_check(void)

{

}

/*

 * A test that tries to add two memory blocks, where the second one overlaps

 * with the beginning of the first entry (that is r1.base < r2.base + r2.size).

 * After this, it checks if two entries are merged into one region that starts

 * at r2.base and has size of two regions minus their intersection. It also

 * verifies the reported total size of the available memory and region counter.

 * A test that tries to add two memory blocks r1 and r2, where r2 overlaps

 * with the beginning of r1 (that is r1.base < r2.base + r2.size):

 *

 *  |    +----+----+------------+          |

 *  |    |    |r2  |   r1       |          |

 *  +----+----+----+------------+----------+

 *       ^    ^

 *       |    |

 *       |    r1.base

 *       |

 *       r2.base

 *

 * Expect to merge the two entries into one region that starts at r2.base

 * and has size of two regions minus their intersection. The total size of

 * the available memory is updated, and the region counter stays the same.

 */

static int memblock_add_overlap_top_check(void)

{

}

/*

 * A test that tries to add two memory blocks, where the second one overlaps

 * with the end of the first entry (that is r2.base < r1.base + r1.size).

 * After this, it checks if two entries are merged into one region that starts

 * at r1.base and has size of two regions minus their intersection. It verifies

 * that memblock can still see only one entry and has a correct total size of

 * the available memory.

 * A test that tries to add two memory blocks r1 and r2, where r2 overlaps

 * with the end of r1 (that is r2.base < r1.base + r1.size):

 *

 *  |  +--+------+----------+              |

 *  |  |  | r1   | r2       |              |

 *  +--+--+------+----------+--------------+

 *     ^  ^

 *     |  |

 *     |  r2.base

 *     |

 *     r1.base

 *

 * Expect to merge the two entries into one region that starts at r1.base

 * and has size of two regions minus their intersection. The total size of

 * the available memory is updated, and the region counter stays the same.

 */

static int memblock_add_overlap_bottom_check(void)

{

}

/*

 * A test that tries to add two memory blocks, where the second one is

 * within the range of the first entry (that is r1.base < r2.base &&

 * r2.base + r2.size < r1.base + r1.size). It checks if two entries are merged

 * into one region that stays the same. The counter and total size of available

 * memory are expected to not be updated.

 * A test that tries to add two memory blocks r1 and r2, where r2 is

 * within the range of r1 (that is r1.base < r2.base &&

 * r2.base + r2.size < r1.base + r1.size):

 *

 *  |   +-------+--+-----------------------+

 *  |   |       |r2|      r1               |

 *  +---+-------+--+-----------------------+

 *      ^

 *      |

 *      r1.base

 *

 * Expect to merge two entries into one region that stays the same.

 * The counter and total size of available memory are not updated.

 */

static int memblock_add_within_check(void)

{

}

/*

 * A simple test that tries to add the same memory block twice. The counter

 * and total size of available memory are expected to not be updated.

 * A simple test that tries to add the same memory block twice. Expect

 * the counter and total size of available memory to not be updated.

 */

static int memblock_add_twice_check(void)

{

/*

 * A simple test that marks a memory block of a specified base address

 * and size as reserved and to the collection of reserved memory regions

  * (memblock.reserved). It checks if a new entry was created and if region

  * counter and total memory size were correctly updated.

 * (memblock.reserved). Expect to create a new entry. The region counter

 * and total memory size are updated.

 */

static int memblock_reserve_simple_check(void)

{

}

/*

 * A test that tries to mark two memory blocks that don't overlap as reserved

 * and checks if two entries were correctly added to the collection of reserved

 * memory regions (memblock.reserved) and if this change was reflected in

 * memblock.reserved's total size and region counter.

 * A test that tries to mark two memory blocks that don't overlap as reserved:

 *

 *  |        +--+      +----------------+  |

 *  |        |r1|      |       r2       |  |

 *  +--------+--+------+----------------+--+

 *

 * Expect to add two entries to the collection of reserved memory regions

 * (memblock.reserved). The total size and region counter for

 * memblock.reserved are updated.

 */

static int memblock_reserve_disjoint_check(void)

{

}

/*

 * A test that tries to mark two memory blocks as reserved, where the

 * second one overlaps with the beginning of the first (that is

 * r1.base < r2.base + r2.size).

 * It checks if two entries are merged into one region that starts at r2.base

 * and has size of two regions minus their intersection. The test also verifies

 * that memblock can still see only one entry and has a correct total size of

 * the reserved memory.

 * A test that tries to mark two memory blocks r1 and r2 as reserved,

 * where r2 overlaps with the beginning of r1 (that is

 * r1.base < r2.base + r2.size):

 *

 *  |  +--------------+--+--------------+  |

 *  |  |       r2     |  |     r1       |  |

 *  +--+--------------+--+--------------+--+

 *     ^              ^

 *     |              |

 *     |              r1.base

 *     |

 *     r2.base

 *

 * Expect to merge two entries into one region that starts at r2.base and

 * has size of two regions minus their intersection. The total size of the

 * reserved memory is updated, and the region counter is not updated.

 */

static int memblock_reserve_overlap_top_check(void)

{

}

/*

 * A test that tries to mark two memory blocks as reserved, where the

 * second one overlaps with the end of the first entry (that is

 * r2.base < r1.base + r1.size).

 * It checks if two entries are merged into one region that starts at r1.base

 * and has size of two regions minus their intersection. It verifies that

 * memblock can still see only one entry and has a correct total size of the

 * reserved memory.

 * A test that tries to mark two memory blocks r1 and r2 as reserved,

 * where r2 overlaps with the end of r1 (that is

 * r2.base < r1.base + r1.size):

 *

 *  |  +--------------+--+--------------+  |

 *  |  |       r1     |  |     r2       |  |

 *  +--+--------------+--+--------------+--+

 *     ^              ^

 *     |              |

 *     |              r2.base

 *     |

 *     r1.base

 *

 * Expect to merge two entries into one region that starts at r1.base and

 * has size of two regions minus their intersection. The total size of the

 * reserved memory is updated, and the region counter is not updated.

 */

static int memblock_reserve_overlap_bottom_check(void)

{

}

/*

 * A test that tries to mark two memory blocks as reserved, where the second

 * one is within the range of the first entry (that is

 * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)).

 * It checks if two entries are merged into one region that stays the

 * same. The counter and total size of available memory are expected to not be

 * updated.

 * A test that tries to mark two memory blocks r1 and r2 as reserved,

 * where r2 is within the range of r1 (that is

 * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)):

 *

 *  | +-----+--+---------------------------|

 *  | |     |r2|          r1               |

 *  +-+-----+--+---------------------------+

 *    ^     ^

 *    |     |

 *    |     r2.base

 *    |

 *    r1.base

 *

 * Expect to merge two entries into one region that stays the same. The

 * counter and total size of available memory are not updated.

 */

static int memblock_reserve_within_check(void)

{

/*

 * A simple test that tries to reserve the same memory block twice.

 * The region counter and total size of reserved memory are expected to not

 * Expect the region counter and total size of reserved memory to not

 * be updated.

 */

static int memblock_reserve_twice_check(void)

}

/*

  * A simple test that tries to remove the first entry of the array of

 * A simple test that tries to remove a region r1 from the array of

 * available memory regions. By "removing" a region we mean overwriting it

  * with the next region in memblock.memory. To check this is the case, the

  * test adds two memory blocks and verifies that the value of the latter

  * was used to erase r1 region.  It also checks if the region counter and

  * total size were updated to expected values.

 * with the next region r2 in memblock.memory:

 *

 *  |  ......          +----------------+  |

 *  |  : r1 :          |       r2       |  |

 *  +--+----+----------+----------------+--+

 *                     ^

 *                     |

 *                     rgn.base

 *

 * Expect to add two memory blocks r1 and r2 and then remove r1 so that

 * r2 is the first available region. The region counter and total size

 * are updated.

 */

static int memblock_remove_simple_check(void)

{

}

/*

  * A test that tries to remove a region that was not registered as available

  * memory (i.e. has no corresponding entry in memblock.memory). It verifies

  * that array, regions counter and total size were not modified.

 * A test that tries to remove a region r2 that was not registered as

 * available memory (i.e. has no corresponding entry in memblock.memory):

 *

 *                     +----------------+

 *                     |       r2       |

 *                     +----------------+

 *  |  +----+                              |

 *  |  | r1 |                              |

 *  +--+----+------------------------------+

 *     ^

 *     |

 *     rgn.base

 *

 * Expect the array, regions counter and total size to not be modified.

 */

static int memblock_remove_absent_check(void)

{

}

/*

 * A test that tries to remove a region which overlaps with the beginning of

 * the already existing entry r1 (that is r1.base < r2.base + r2.size). It

 * checks if only the intersection of both regions is removed from the available

 * memory pool. The test also checks if the regions counter and total size are

 * updated to expected values.

 * A test that tries to remove a region r2 that overlaps with the

 * beginning of the already existing entry r1

 * (that is r1.base < r2.base + r2.size):

 *

 *           +-----------------+

 *           |       r2        |

 *           +-----------------+

 *  |                 .........+--------+  |

 *  |                 :     r1 |  rgn   |  |

 *  +-----------------+--------+--------+--+

 *                    ^        ^

 *                    |        |

 *                    |        rgn.base

 *                    r1.base

 *

 * Expect that only the intersection of both regions is removed from the

 * available memory pool. The regions counter and total size are updated.

 */

static int memblock_remove_overlap_top_check(void)

{

}

/*

 * A test that tries to remove a region which overlaps with the end of the

 * first entry (that is r2.base < r1.base + r1.size). It checks if only the

 * intersection of both regions is removed from the available memory pool.

 * The test also checks if the regions counter and total size are updated to

 * expected values.

 * A test that tries to remove a region r2 that overlaps with the end of

 * the already existing region r1 (that is r2.base < r1.base + r1.size):

 *

 *        +--------------------------------+

 *        |               r2               |

 *        +--------------------------------+

 *  | +---+.....                           |

 *  | |rgn| r1 :                           |

 *  +-+---+----+---------------------------+

 *    ^

 *    |

 *    r1.base

 *

 * Expect that only the intersection of both regions is removed from the

 * available memory pool. The regions counter and total size are updated.

 */

static int memblock_remove_overlap_bottom_check(void)

{

}

/*

 * A test that tries to remove a region which is within the range of the

 * already existing entry (that is

 * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)).

 * It checks if the region is split into two - one that ends at r2.base and

 * second that starts at r2.base + size, with appropriate sizes. The test

 * also checks if the region counter and total size were updated to

 * expected values.

 * A test that tries to remove a region r2 that is within the range of

 * the already existing entry r1 (that is

 * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)):

 *

 *                  +----+

 *                  | r2 |

 *                  +----+

 *  | +-------------+....+---------------+ |

 *  | |     rgn1    | r1 |     rgn2      | |

 *  +-+-------------+----+---------------+-+

 *    ^

 *    |

 *    r1.base

 *

 * Expect that the region is split into two - one that ends at r2.base and

 * another that starts at r2.base + r2.size, with appropriate sizes. The

 * region counter and total size are updated.

 */

static int memblock_remove_within_check(void)

{

}

/*

 * A simple test that tries to free a memory block that was marked earlier

 * as reserved. By "freeing" a region we mean overwriting it with the next

 * entry in memblock.reserved. To check this is the case, the test reserves

 * two memory regions and verifies that the value of the latter was used to

 * erase r1 region.

 * The test also checks if the region counter and total size were updated.

 * A simple test that tries to free a memory block r1 that was marked

 * earlier as reserved. By "freeing" a region we mean overwriting it with

 * the next entry r2 in memblock.reserved:

 *

 *  |              ......           +----+ |

 *  |              : r1 :           | r2 | |

 *  +--------------+----+-----------+----+-+

 *                                  ^

 *                                  |

 *                                  rgn.base

 *

 * Expect to reserve two memory regions and then erase r1 region with the

 * value of r2. The region counter and total size are updated.

 */

static int memblock_free_simple_check(void)

{

}

/*

  * A test that tries to free a region that was not marked as reserved

  * (i.e. has no corresponding entry in memblock.reserved). It verifies

  * that array, regions counter and total size were not modified.

 * A test that tries to free a region r2 that was not marked as reserved

 * (i.e. has no corresponding entry in memblock.reserved):

 *

 *                     +----------------+

 *                     |       r2       |

 *                     +----------------+

 *  |  +----+                              |

 *  |  | r1 |                              |

 *  +--+----+------------------------------+

 *     ^

 *     |

 *     rgn.base

 *

 * The array, regions counter and total size are not modified.

 */

static int memblock_free_absent_check(void)

{

}

/*

 * A test that tries to free a region which overlaps with the beginning of

 * the already existing entry r1 (that is r1.base < r2.base + r2.size). It

 * checks if only the intersection of both regions is freed. The test also

 * checks if the regions counter and total size are updated to expected

 * values.

 * A test that tries to free a region r2 that overlaps with the beginning

 * of the already existing entry r1 (that is r1.base < r2.base + r2.size):

 *

 *     +----+

 *     | r2 |

 *     +----+

 *  |    ...+--------------+               |

 *  |    :  |    r1        |               |

 *  +----+--+--------------+---------------+

 *       ^  ^

 *       |  |

 *       |  rgn.base

 *       |

 *       r1.base

 *

 * Expect that only the intersection of both regions is freed. The

 * regions counter and total size are updated.

 */

static int memblock_free_overlap_top_check(void)

{

}

/*

 * A test that tries to free a region which overlaps with the end of the

 * first entry (that is r2.base < r1.base + r1.size). It checks if only the

 * intersection of both regions is freed. The test also checks if the

 * regions counter and total size are updated to expected values.

 * A test that tries to free a region r2 that overlaps with the end of

 * the already existing entry r1 (that is r2.base < r1.base + r1.size):

 *

 *                   +----------------+

 *                   |       r2       |

 *                   +----------------+

 *  |    +-----------+.....                |

 *  |    |       r1  |    :                |

 *  +----+-----------+----+----------------+

 *

 * Expect that only the intersection of both regions is freed. The

 * regions counter and total size are updated.

 */

static int memblock_free_overlap_bottom_check(void)

{

}

/*

 * A test that tries to free a region which is within the range of the

 * already existing entry (that is

 * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)).

 * It checks if the region is split into two - one that ends at r2.base and

 * second that starts at r2.base + size, with appropriate sizes. It is

 * expected that the region counter and total size fields were updated t

 * reflect that change.

 * A test that tries to free a region r2 that is within the range of the

 * already existing entry r1 (that is

 * (r1.base < r2.base) && (r2.base + r2.size < r1.base + r1.size)):

 *

 *                    +----+

 *                    | r2 |

 *                    +----+

 *  |    +------------+....+---------------+

 *  |    |    rgn1    | r1 |     rgn2      |

 *  +----+------------+----+---------------+

 *       ^

 *       |

 *       r1.base

 *

 * Expect that the region is split into two - one that ends at r2.base and

 * another that starts at r2.base + r2.size, with appropriate sizes. The

 * region counter and total size fields are updated.

 */

static int memblock_free_within_check(void)

{