Merge pull request #219 from jphickey/fix-176-mpool-coveragetest

Fix #176, implement mpool test cases

mpool/inc/v7_mpool.h

@@ -359,6 +359,18 @@ void bplib_mpool_init_secondary_link(bplib_mpool_block_t *base_block, bplib_mpoo
  */
 bplib_mpool_block_t *bplib_mpool_get_block_from_link(bplib_mpool_block_t *lblk);
 
+/**
+ * @brief Gets the offset of the block user content section
+ *
+ * Some block types have an area that may be used for general purpose data storage.
+ * The size and offset of this area depends on the block type.  This gets the offset
+ * of the start of the area for the given a block type.
+ *
+ * @param bt Block type
+ * @return size_t
+ */
+size_t bplib_mpool_get_user_data_offset_by_blocktype(bplib_mpool_blocktype_t bt);
+
 /**
  * @brief Gets the capacity (maximum size) of the generic data block
  *
@@ -567,6 +579,18 @@ int bplib_mpool_foreach_item_in_list(bplib_mpool_block_t *list, bool always_remo
 bplib_mpool_block_t *bplib_mpool_search_list(const bplib_mpool_block_t *list, bplib_mpool_callback_func_t match_fn,
                                              void *match_arg);
 
+/**
+ * @brief Garbage collection routine
+ *
+ * Processes the list of recycled blocks and performing any additional cleanup work
+ *
+ * @param pool The mpool object
+ * @param limit The maximum number of entries to process
+ *
+ * @returns The number of blocks collected
+ */
+uint32_t bplib_mpool_collect_blocks(bplib_mpool_t *pool, uint32_t limit);
+
 /**
  * @brief Run basic maintenance on the memory pool
  *
@@ -625,6 +649,13 @@ size_t bplib_mpool_query_mem_current_use(bplib_mpool_t *pool);
  */
 size_t bplib_mpool_query_mem_max_use(bplib_mpool_t *pool);
 
+/**
+ * @brief Initializes the global lock table
+ *
+ * Must be called once per process using bplib (not per instance).
+ */
+void bplib_mpool_lock_init(void);
+
 /* DEBUG/TEST verification routines */
 
 void bplib_mpool_debug_scan(bplib_mpool_t *pool);

mpool/src/v7_mpool.c

@@ -745,7 +745,7 @@ int bplib_mpool_list_iter_goto_last(const bplib_mpool_block_t *list, bplib_mpool
  *-----------------------------------------------------------------*/
 int bplib_mpool_list_iter_forward(bplib_mpool_list_iter_t *iter)
 {
-    if (bplib_mpool_is_list_head(iter->pending_entry))
+    if (iter->pending_entry == NULL || bplib_mpool_is_list_head(iter->pending_entry))
     {
         iter->position = NULL;
         return BP_ERROR;
@@ -763,7 +763,7 @@ int bplib_mpool_list_iter_forward(bplib_mpool_list_iter_t *iter)
  *-----------------------------------------------------------------*/
 int bplib_mpool_list_iter_reverse(bplib_mpool_list_iter_t *iter)
 {
-    if (bplib_mpool_is_list_head(iter->pending_entry))
+    if (iter->pending_entry == NULL || bplib_mpool_is_list_head(iter->pending_entry))
     {
         iter->position = NULL;
         return BP_ERROR;
@@ -1136,7 +1136,9 @@ void bplib_mpool_debug_scan(bplib_mpool_t *pool)
     memset(count_by_type, 0, sizeof(count_by_type));
     count_invalid = 0;
     pchunk        = &pool->admin_block;
-    for (i = 0; i < admin->num_bufs_total; ++i)
+
+    /* Note that num_bufs_total does not include the admin block (0) */
+    for (i = 0; i <= admin->num_bufs_total; ++i)
     {
         if (i == 0)
         {

mpool/src/v7_mpool_bblocks.c

@@ -122,17 +122,19 @@ void bplib_mpool_bblock_canonical_init(bplib_mpool_block_t *base_block, bplib_mp
  * Function: bplib_mpool_bblock_primary_alloc
  *
  *-----------------------------------------------------------------*/
-bplib_mpool_block_t *bplib_mpool_bblock_primary_alloc(bplib_mpool_t *pool, uint32_t magic_number, void *init_arg, uint8_t priority, uint64_t timeout)
+bplib_mpool_block_t *bplib_mpool_bblock_primary_alloc(bplib_mpool_t *pool, uint32_t magic_number, void *init_arg,
+                                                      uint8_t priority, uint64_t timeout)
 {
     bplib_mpool_block_content_t *result;
     bplib_mpool_lock_t          *lock;
-    bool within_timeout;
+    bool                         within_timeout;
 
-    lock   = bplib_mpool_lock_resource(pool);
+    lock           = bplib_mpool_lock_resource(pool);
     within_timeout = true;
     while (true)
     {
-        result = bplib_mpool_alloc_block_internal(pool, bplib_mpool_blocktype_primary, magic_number, init_arg, priority);
+        result =
+            bplib_mpool_alloc_block_internal(pool, bplib_mpool_blocktype_primary, magic_number, init_arg, priority);
         if (result != NULL || !within_timeout)
         {
             break;
@@ -156,7 +158,8 @@ bplib_mpool_block_t *bplib_mpool_bblock_canonical_alloc(bplib_mpool_t *pool, uin
     bplib_mpool_lock_t          *lock;
 
     lock   = bplib_mpool_lock_resource(pool);
-    result = bplib_mpool_alloc_block_internal(pool, bplib_mpool_blocktype_canonical, magic_number, init_arg, BPLIB_MPOOL_ALLOC_PRI_MED);
+    result = bplib_mpool_alloc_block_internal(pool, bplib_mpool_blocktype_canonical, magic_number, init_arg,
+                                              BPLIB_MPOOL_ALLOC_PRI_MED);
     bplib_mpool_lock_release(lock);
 
     return (bplib_mpool_block_t *)result;
@@ -172,9 +175,9 @@ bplib_mpool_block_t *bplib_mpool_bblock_cbor_alloc(bplib_mpool_t *pool)
     bplib_mpool_block_content_t *result;
     bplib_mpool_lock_t          *lock;
 
-    lock = bplib_mpool_lock_resource(pool);
-    result =
-        bplib_mpool_alloc_block_internal(pool, bplib_mpool_blocktype_generic, MPOOL_CACHE_CBOR_DATA_SIGNATURE, NULL, BPLIB_MPOOL_ALLOC_PRI_MED);
+    lock   = bplib_mpool_lock_resource(pool);
+    result = bplib_mpool_alloc_block_internal(pool, bplib_mpool_blocktype_generic, MPOOL_CACHE_CBOR_DATA_SIGNATURE,
+                                              NULL, BPLIB_MPOOL_ALLOC_PRI_MED);
     bplib_mpool_lock_release(lock);
 
     return (bplib_mpool_block_t *)result;
@@ -258,7 +261,11 @@ size_t bplib_mpool_bblock_cbor_export(bplib_mpool_block_t *list, void *out_ptr,
     blk       = list;
     while (data_left > 0)
     {
-        blk     = bplib_mpool_get_next_block(blk);
+        blk = bplib_mpool_get_next_block(blk);
+        if (blk == list)
+        {
+            break;
+        }
         src_ptr = bplib_mpool_bblock_cbor_cast(blk);
         if (src_ptr == NULL)
         {

mpool/src/v7_mpool_internal.h

@@ -344,6 +344,9 @@ const bplib_mpool_block_content_t *bplib_mpool_get_block_content_const(const bpl
 /* similar to bplib_mpool_get_block_content() but also dereferences any ref blocks */
 bplib_mpool_block_content_t *bplib_mpool_block_dereference_content(bplib_mpool_block_t *cb);
 
+void bplib_mpool_init_base_object(bplib_mpool_block_header_t *block_hdr, uint16_t user_content_length,
+                                  uint32_t content_type_signature);
+
 bplib_mpool_block_content_t *bplib_mpool_alloc_block_internal(bplib_mpool_t *pool, bplib_mpool_blocktype_t blocktype,
                                                               uint32_t content_type_signature, void *init_arg,
                                                               uint8_t priority);

mpool/ut-coverage/test_bplib_mpool.h

@@ -23,6 +23,25 @@
 #include "utstubs.h"
 #include "uttest.h"
 
+#include "v7_mpool_internal.h"
+
+typedef struct
+{
+    bplib_mpool_t               pool;
+    bplib_mpool_block_content_t blk[3];
+} UT_bplib_mpool_buf_t;
+
+/* helper functions used in multiple tests */
+void UT_AltHandler_PointerReturn(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context);
+int  test_bplib_mpool_callback_stub(void *arg, bplib_mpool_block_t *blk);
+void test_make_singleton_link(bplib_mpool_t *parent_pool, bplib_mpool_block_t *b);
+void test_setup_mpblock(bplib_mpool_t *pool, bplib_mpool_block_content_t *b, bplib_mpool_blocktype_t blktype,
+                        uint32 sig);
+void test_setup_allocation(bplib_mpool_t *pool, bplib_mpool_block_content_t *db, bplib_mpool_block_content_t *apib);
+
+void TestBplibMpool_ResetTestEnvironment(void);
+
+/* Registration functions */
 void TestBplibMpoolBBlocks_Register(void);
 void TestBplibMpoolFlows_Register(void);
 void TestBplibMpoolJob_Register(void);

mpool/ut-coverage/test_bplib_mpool_setup.c

@@ -21,6 +21,93 @@
  */
 #include "test_bplib_mpool.h"
 
+void TestBplibMpool_ResetTestEnvironment(void)
+{
+    UT_ResetState(0);
+}
+
+void UT_AltHandler_PointerReturn(void *UserObj, UT_EntryKey_t FuncKey, const UT_StubContext_t *Context)
+{
+    UT_Stub_SetReturnValue(FuncKey, UserObj);
+}
+
+int test_bplib_mpool_callback_stub(void *arg, bplib_mpool_block_t *blk)
+{
+    return UT_DEFAULT_IMPL(test_bplib_mpool_callback_stub);
+}
+
+void test_make_singleton_link(bplib_mpool_t *parent_pool, bplib_mpool_block_t *b)
+{
+    if (parent_pool != NULL)
+    {
+        b->parent_offset = ((uintptr_t)b - (uintptr_t)parent_pool) / sizeof(bplib_mpool_block_content_t);
+    }
+    else
+    {
+        b->parent_offset = 0;
+    }
+
+    b->next = b;
+    b->prev = b;
+}
+
+void test_setup_mpblock(bplib_mpool_t *pool, bplib_mpool_block_content_t *b, bplib_mpool_blocktype_t blktype,
+                        uint32 sig)
+{
+    b->header.base_link.type         = blktype;
+    b->header.content_type_signature = sig;
+    test_make_singleton_link(pool, &b->header.base_link);
+
+    /*
+     * Need to also initialize the fields within the content part, this calls the real internal function to do so.
+     * It is done here because it is needed to be valid more often than not; test cases may unset/corrupt fields
+     * if there is a specific path to target
+     */
+    memset(&b->u, 0, sizeof(b->u));
+    switch (blktype)
+    {
+        case bplib_mpool_blocktype_primary:
+            bplib_mpool_bblock_primary_init(&b->header.base_link, &b->u.primary.pblock);
+            break;
+        case bplib_mpool_blocktype_canonical:
+            bplib_mpool_bblock_canonical_init(&b->header.base_link, &b->u.canonical.cblock);
+            break;
+        case bplib_mpool_blocktype_admin:
+            bplib_mpool_subq_init(&b->header.base_link, &b->u.admin.free_blocks);
+            bplib_mpool_subq_init(&b->header.base_link, &b->u.admin.recycle_blocks);
+            bplib_mpool_init_list_head(&b->header.base_link, &b->u.admin.active_list);
+            break;
+        case bplib_mpool_blocktype_flow:
+            bplib_mpool_flow_init(&b->header.base_link, &b->u.flow.fblock);
+            break;
+
+        default:
+            break;
+    }
+}
+
+void test_setup_allocation(bplib_mpool_t *pool, bplib_mpool_block_content_t *db, bplib_mpool_block_content_t *apib)
+{
+    bplib_mpool_block_admin_content_t *admin;
+    void                              *api_content;
+
+    test_setup_mpblock(pool, &pool->admin_block, bplib_mpool_blocktype_admin, 0);
+    test_setup_mpblock(pool, db, bplib_mpool_blocktype_undefined, 0);
+    if (apib != NULL)
+    {
+        test_setup_mpblock(pool, apib, bplib_mpool_blocktype_api, 0);
+        api_content = &apib->u;
+    }
+    else
+    {
+        api_content = NULL;
+    }
+
+    admin = bplib_mpool_get_admin(pool);
+    bplib_mpool_subq_push_single(&admin->free_blocks, &db->header.base_link);
+    UT_SetHandlerFunction(UT_KEY(bplib_rbt_search_generic), UT_AltHandler_PointerReturn, api_content);
+}
+
 void UtTest_Setup(void)
 {
     TestBplibMpoolBase_Register();