sapi_posix_backend_memory.c

Go to the documentation of this file.

#include "safeapi/posix_backend/sapi_posix_backend.h"
#include "safeapi/utils/cast/sapi_cast.h"
 
#include <stdint.h>
#include "safeapi/oal/memory/sapi_mem_util.h"

#ifndef SAPI_POSIX_MEM_ARENA_SIZE
#define SAPI_POSIX_MEM_ARENA_SIZE (1024U * 1024U)
#endif

typedef struct
{
    uint8_t *base;
    size_t   block_size;
    size_t   block_count;
    size_t   free_count;
    void    *free_list_head;
} posix_mem_pool_state_t;
 
/* C99-compatible static assert: posix_mem_pool_state_t must fit inside
 * sapi_mem_pool_storage_t's reserved bytes. */
typedef char posix_mem_pool_storage_fits_[(sizeof(posix_mem_pool_state_t) <= sizeof(sapi_mem_pool_storage_t)) ? 1
                                                                                                                 : -1];

static sapi_status_t backend_create(sapi_mem_pool_storage_t *storage, const sapi_mem_pool_config_t *config,
                                     sapi_mem_pool_handle_t *out_handle);
static sapi_status_t backend_acquire(sapi_mem_pool_handle_t handle, void **out_block);
static bool block_belongs_to_pool(const posix_mem_pool_state_t *state, const void *block);
static sapi_status_t backend_release(sapi_mem_pool_handle_t handle, void *block);
static sapi_status_t backend_stats(sapi_mem_pool_handle_t handle, size_t *out_free_blocks, size_t *out_used_blocks);

static uint8_t g_arena[SAPI_POSIX_MEM_ARENA_SIZE];
static size_t g_arena_used = 0U;
static const sapi_mem_pool_backend_t s_posix_memory_backend = { backend_create, backend_acquire, backend_release,
                                                                  backend_stats };

 

const sapi_mem_pool_backend_t *sapi_posix_backend_memory(void)
{
    return &s_posix_memory_backend;
}
 
 
/****Local functions ****/
 
static sapi_status_t backend_create(sapi_mem_pool_storage_t *storage, const sapi_mem_pool_config_t *config,
                                     sapi_mem_pool_handle_t *out_handle)
{
    posix_mem_pool_state_t *state;
    size_t total_bytes;
    size_t i;
    uint8_t *base;
 
    if ((storage == NULL) || (config == NULL) || (out_handle == NULL) || (config->block_size == 0U)
        || (config->block_count == 0U))
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    if (config->block_size < sizeof(void *))
    {
        return SAPI_STATUS_INVALID_PARAM; /* too small for the intrusive free list, see file header */
    }
 
    /* Overflow-checked multiply (safeAPIFreamwork REQ-COMMON-CAST-004) -
     * replaces this file's own former hand-rolled "divide back and
     * compare" idiom with the framework's shared primitive. */
    if (sapi_cast_checked_mul_size(config->block_size, config->block_count, &total_bytes) != SAPI_STATUS_OK)
    {
        return SAPI_STATUS_INVALID_PARAM; /* block_size * block_count overflowed size_t */
    }
    if (total_bytes > (SAPI_POSIX_MEM_ARENA_SIZE - g_arena_used))
    {
        return SAPI_STATUS_RESOURCE_EXHAUSTED;
    }
 
    base = &g_arena[g_arena_used];
    g_arena_used += total_bytes;
 
    for (i = 0U; i < config->block_count; i++)
    {
        uint8_t *block = base + (i * config->block_size);
        void *next = (i + 1U < config->block_count) ? (void *)(base + ((i + 1U) * config->block_size)) : NULL;
 
        sapi_mem_copy(block, &next, sizeof(next));
    }
 
    state = (posix_mem_pool_state_t *)(void *)storage;
    state->base = base;
    state->block_size = config->block_size;
    state->block_count = config->block_count;
    state->free_count = config->block_count;
    state->free_list_head = (void *)base;
 
    *out_handle = (sapi_mem_pool_handle_t)(void *)storage;
    return SAPI_STATUS_OK;
}
 
static sapi_status_t backend_acquire(sapi_mem_pool_handle_t handle, void **out_block)
{
    posix_mem_pool_state_t *state = (posix_mem_pool_state_t *)(void *)handle;
    void *block;
    void *next;
 
    if ((state == NULL) || (out_block == NULL))
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    if (state->free_list_head == NULL)
    {
        *out_block = NULL;
        return SAPI_STATUS_RESOURCE_EXHAUSTED;
    }
 
    block = state->free_list_head;
    sapi_mem_copy(&next, block, sizeof(next));
    state->free_list_head = next;
    state->free_count -= 1U;
    *out_block = block;
    return SAPI_STATUS_OK;
}
 
static bool block_belongs_to_pool(const posix_mem_pool_state_t *state, const void *block)
{
    const uint8_t *b = (const uint8_t *)block;
    size_t byte_offset;
 
    if ((b < state->base) || (b >= (state->base + (state->block_size * state->block_count))))
    {
        return false;
    }
    byte_offset = (size_t)(b - state->base);
    return (byte_offset % state->block_size) == 0U;
}
 
static sapi_status_t backend_release(sapi_mem_pool_handle_t handle, void *block)
{
    posix_mem_pool_state_t *state = (posix_mem_pool_state_t *)(void *)handle;
 
    if ((state == NULL) || (block == NULL))
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    if (!block_belongs_to_pool(state, block))
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
 
    sapi_mem_copy(block, &state->free_list_head, sizeof(state->free_list_head));
    state->free_list_head = block;
    state->free_count += 1U;
    return SAPI_STATUS_OK;
}
 
static sapi_status_t backend_stats(sapi_mem_pool_handle_t handle, size_t *out_free_blocks, size_t *out_used_blocks)
{
    posix_mem_pool_state_t *state = (posix_mem_pool_state_t *)(void *)handle;
 
    if ((state == NULL) || (out_free_blocks == NULL) || (out_used_blocks == NULL))
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    *out_free_blocks = state->free_count;
    *out_used_blocks = state->block_count - state->free_count;
    return SAPI_STATUS_OK;
}