rte_posix_osadapter_memory.c

Go to the documentation of this file.

/* _POSIX_C_SOURCE: glibc declares PTHREAD_PRIO_INHERIT and pthread_mutexattr_setprotocol() only under a POSIX
 * feature-test macro (this product builds strict C99), same as mutex.c's own; rte_posix_osadapter_lock.h needs it
 * too. */
#define _POSIX_C_SOURCE 200809L

#include "rte/posix_osadapter/rte_posix_osadapter.h"
#include "rte/utils/cast/rte_cast.h"
#include "rte_posix_osadapter_lock.h"
#include "rte_posix_osadapter_report.h"
 
#include <pthread.h>
#include <stdint.h>
#include "rte/oal/memory/rte_mem_util.h"

#ifndef RTE_POSIX_MEM_ARENA_SIZE
#define RTE_POSIX_MEM_ARENA_SIZE (1024U * 1024U)
#endif
/* Longest wait for g_mem_lock, in ms (OSA rule R2, REQ-OAL-MEM-015). Far above a critical section's hold time (a
 * handful of pointer/counter updates), well below the A/B checkpoint budget (400 ms); 0 makes every pool operation one
 * non-blocking try. */
#ifndef RTE_POSIX_MEM_LOCK_TIMEOUT_MS
#define RTE_POSIX_MEM_LOCK_TIMEOUT_MS 50U
#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
 * rte_mem_pool_storage_t's reserved bytes. */
typedef char posix_mem_pool_storage_fits_[(sizeof(posix_mem_pool_state_t) <= sizeof(rte_mem_pool_storage_t)) ? 1
                                                                                                                 : -1];

static rte_status_t osadapter_create(rte_mem_pool_storage_t *storage, const rte_mem_pool_config_t *config,
                                     rte_mem_pool_handle_t *out_handle);
static rte_status_t osadapter_acquire(rte_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 rte_status_t osadapter_release(rte_mem_pool_handle_t handle, void *block);
static rte_status_t osadapter_stats(rte_mem_pool_handle_t handle, size_t *out_free_blocks, size_t *out_used_blocks);
static rte_status_t mem_lock(void);

static uint8_t g_arena[RTE_POSIX_MEM_ARENA_SIZE];
static size_t g_arena_used = 0U;
static pthread_mutex_t g_mem_lock;   /* created by rte_posix_osadapter_memory_init(), see file header */
static bool g_mem_initialised = false; /* true once g_mem_lock exists */
static const rte_osadapter_memory_t s_posix_memory_osadapter = { osadapter_create, osadapter_acquire, osadapter_release,
                                                                  osadapter_stats };

 

const rte_osadapter_memory_t *rte_posix_osadapter_memory(void)
{
    return &s_posix_memory_osadapter;
}
 
rte_status_t rte_posix_osadapter_memory_init(void)
{
    rte_status_t status = RTE_STATUS_OK;
    pthread_mutexattr_t attr;
 
    if (!g_mem_initialised)
    {
        /* OSA rule R2 (REQ-OAL-MUTEX-004): the pool lock uses priority inheritance, requested at run time on every
         * host exactly as mutex.c's create does (no _POSIX_THREAD_PRIO_INHERIT compile gate). A refusal at any of
         * the three calls fails the init; there is no fallback to a plain mutex. */
        if (pthread_mutexattr_init(&attr) != 0)
        {
            status = RTE_STATUS_INTERNAL_ERROR;
        }
        else
        {
            if (pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT) != 0)
            {
                status = RTE_STATUS_INTERNAL_ERROR;
            }
            else if (pthread_mutex_init(&g_mem_lock, &attr) != 0)
            {
                status = RTE_STATUS_INTERNAL_ERROR;
            }
            else
            {
                /* priority-inheritance pool lock initialised */
            }
            (void)pthread_mutexattr_destroy(&attr);
        }
 
        if (status == RTE_STATUS_OK)
        {
            g_mem_initialised = true;
        }
        else
        {
            /* OSA rule R6: report the violation; the pool stays uninitialised and the caller's setup fails. */
            POSIX_OSA_REPORT_RT_ATTRIBUTE("memory pool lock refused priority inheritance - init failed");
        }
    }
 
    return status;
}
 
 
/****Local functions ****/
 
static rte_status_t osadapter_create(rte_mem_pool_storage_t *storage, const rte_mem_pool_config_t *config,
                                     rte_mem_pool_handle_t *out_handle)
{
    posix_mem_pool_state_t *state;
    rte_status_t status;
    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 RTE_STATUS_INVALID_PARAM;
    }
    if (config->block_size < sizeof(void *))
    {
        return RTE_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 (rte_cast_checked_mul_size(config->block_size, config->block_count, &total_bytes) != RTE_STATUS_OK)
    {
        return RTE_STATUS_INVALID_PARAM; /* block_size * block_count overflowed size_t */
    }
    status = mem_lock();
    if (status != RTE_STATUS_OK)
    {
        return status;
    }
    if (total_bytes > (RTE_POSIX_MEM_ARENA_SIZE - g_arena_used))
    {
        (void)pthread_mutex_unlock(&g_mem_lock);
        return RTE_STATUS_RESOURCE_EXHAUSTED;
    }
 
    base = &g_arena[g_arena_used];
    g_arena_used += total_bytes;
    (void)pthread_mutex_unlock(&g_mem_lock); /* the claimed range is private to this pool from here on */
 
    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;
 
        rte_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 = (rte_mem_pool_handle_t)(void *)storage;
    return RTE_STATUS_OK;
}
 
static rte_status_t osadapter_acquire(rte_mem_pool_handle_t handle, void **out_block)
{
    posix_mem_pool_state_t *state = (posix_mem_pool_state_t *)(void *)handle;
    rte_status_t status;
    void *block;
    void *next;
 
    if ((state == NULL) || (out_block == NULL))
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    status = mem_lock();
    if (status != RTE_STATUS_OK)
    {
        *out_block = NULL;
        return status;
    }
    if (state->free_list_head == NULL)
    {
        (void)pthread_mutex_unlock(&g_mem_lock);
        *out_block = NULL;
        return RTE_STATUS_RESOURCE_EXHAUSTED;
    }
 
    block = state->free_list_head;
    rte_mem_copy(&next, block, sizeof(next));
    state->free_list_head = next;
    state->free_count -= 1U;
    (void)pthread_mutex_unlock(&g_mem_lock);
    *out_block = block;
    return RTE_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 rte_status_t osadapter_release(rte_mem_pool_handle_t handle, void *block)
{
    posix_mem_pool_state_t *state = (posix_mem_pool_state_t *)(void *)handle;
    rte_status_t status;
 
    if ((state == NULL) || (block == NULL))
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    if (!g_mem_initialised)
    {
        return RTE_STATUS_INVALID_STATE; /* no pool exists before init; checked before the pool state is read */
    }
    if (!block_belongs_to_pool(state, block))
    {
        return RTE_STATUS_INVALID_PARAM;
    }
 
    status = mem_lock();
    if (status != RTE_STATUS_OK)
    {
        return status;
    }
    rte_mem_copy(block, &state->free_list_head, sizeof(state->free_list_head));
    state->free_list_head = block;
    state->free_count += 1U;
    (void)pthread_mutex_unlock(&g_mem_lock);
    return RTE_STATUS_OK;
}
 
static rte_status_t osadapter_stats(rte_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;
    rte_status_t status;
 
    if ((state == NULL) || (out_free_blocks == NULL) || (out_used_blocks == NULL))
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    status = mem_lock();
    if (status != RTE_STATUS_OK)
    {
        return status;
    }
    *out_free_blocks = state->free_count;
    *out_used_blocks = state->block_count - state->free_count;
    (void)pthread_mutex_unlock(&g_mem_lock);
    return RTE_STATUS_OK;
}
 
/* Takes the pool lock, waiting at most RTE_POSIX_MEM_LOCK_TIMEOUT_MS (OSA rule R2, REQ-OAL-MEM-015):
 * RTE_STATUS_INVALID_STATE (lock not touched) until rte_posix_osadapter_memory_init() has succeeded; otherwise
 * posix_osa_lock_bounded()'s result - RTE_STATUS_OK with the lock held, RTE_STATUS_TIMEOUT when it was not acquired
 * within the bound, RTE_STATUS_INTERNAL_ERROR for a platform failure (lock not held in either case). */
static rte_status_t mem_lock(void)
{
    rte_status_t status;
 
    if (!g_mem_initialised)
    {
        status = RTE_STATUS_INVALID_STATE;
    }
    else
    {
        status = posix_osa_lock_bounded(&g_mem_lock, RTE_POSIX_MEM_LOCK_TIMEOUT_MS);
    }
 
    return status;
}