rte_posix_osadapter_mutex.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 task.c's own. */
#define _POSIX_C_SOURCE 200809L

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


typedef struct
{
    pthread_mutex_t mutex;
    rte_mutex_handle_t self_handle;
} posix_mutex_state_t;
 
/* C99-compatible static assert: posix_mutex_state_t must fit inside
 * rte_mutex_storage_t's reserved bytes (a negative array size is a
 * compile error) - same convention as rte_posix_osadapter_timer.c's own. */
typedef char posix_mutex_storage_fits_[(sizeof(posix_mutex_state_t) <= sizeof(rte_mutex_storage_t)) ? 1 : -1];

static rte_status_t osadapter_create(rte_mutex_storage_t *storage, rte_mutex_handle_t *out_handle);
static rte_status_t osadapter_lock(rte_mutex_handle_t handle);
static rte_status_t osadapter_unlock(rte_mutex_handle_t handle);
static rte_status_t osadapter_destroy(rte_mutex_handle_t handle);
static rte_status_t osadapter_lock_timed(rte_mutex_handle_t handle, rte_duration_ms_t timeout_ms);

static const rte_osadapter_mutex_t s_posix_mutex_osadapter = { osadapter_create, osadapter_lock, osadapter_unlock,
                                                              osadapter_destroy, osadapter_lock_timed };

 

const rte_osadapter_mutex_t *rte_posix_osadapter_mutex(void)
{
    return &s_posix_mutex_osadapter;
}
 
 
/****Local functions ****/
 
static rte_status_t osadapter_create(rte_mutex_storage_t *storage, rte_mutex_handle_t *out_handle)
{
    rte_status_t status = RTE_STATUS_OK;
    posix_mutex_state_t *state;
    pthread_mutexattr_t attr;
 
    if ((storage == NULL) || (out_handle == NULL))
    {
        status = RTE_STATUS_INVALID_PARAM;
    }
    else
    {
        state = (posix_mutex_state_t *)(void *)storage;
        rte_mem_set(state, 0, sizeof(*state));
 
        /* OSA rule R2 (REQ-OAL-MUTEX-004): every mutex uses priority inheritance. Requested at run time on every
         * host - no _POSIX_THREAD_PRIO_INHERIT compile gate: macOS declares it -1 yet accepts the protocol at run
         * time, so a gate would refuse every macOS mutex. A refusal at any of the three calls fails the create;
         * 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(&state->mutex, &attr) != 0)
            {
                status = RTE_STATUS_INTERNAL_ERROR;
            }
            else
            {
                /* priority-inheritance mutex initialised */
            }
            (void)pthread_mutexattr_destroy(&attr);
        }
 
        if (status == RTE_STATUS_OK)
        {
            state->self_handle = (rte_mutex_handle_t)(void *)storage;
            *out_handle = state->self_handle;
        }
        else
        {
            /* OSA rule R6: report the violation; *out_handle stays unwritten and the caller's setup fails. */
            POSIX_OSA_REPORT_RT_ATTRIBUTE("mutex refused priority inheritance - create failed");
        }
    }
 
    return status;
}
 
static rte_status_t osadapter_lock(rte_mutex_handle_t handle)
{
    posix_mutex_state_t *state = (posix_mutex_state_t *)(void *)handle;
 
    if (state == NULL)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    if (pthread_mutex_lock(&state->mutex) != 0)
    {
        return RTE_STATUS_INTERNAL_ERROR;
    }
    return RTE_STATUS_OK;
}
 
static rte_status_t osadapter_unlock(rte_mutex_handle_t handle)
{
    posix_mutex_state_t *state = (posix_mutex_state_t *)(void *)handle;
 
    if (state == NULL)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    if (pthread_mutex_unlock(&state->mutex) != 0)
    {
        return RTE_STATUS_INTERNAL_ERROR;
    }
    return RTE_STATUS_OK;
}
 
static rte_status_t osadapter_destroy(rte_mutex_handle_t handle)
{
    posix_mutex_state_t *state = (posix_mutex_state_t *)(void *)handle;
 
    if (state == NULL)
    {
        return RTE_STATUS_INVALID_PARAM;
    }
    if (pthread_mutex_destroy(&state->mutex) != 0)
    {
        return RTE_STATUS_INTERNAL_ERROR;
    }
    return RTE_STATUS_OK;
}
 
static rte_status_t osadapter_lock_timed(rte_mutex_handle_t handle, rte_duration_ms_t timeout_ms)
{
    posix_mutex_state_t *state = (posix_mutex_state_t *)(void *)handle;
    rte_status_t status;
 
    if (state == NULL)
    {
        status = RTE_STATUS_INVALID_PARAM;
    }
    else
    {
        /* REQ-OAL-MUTEX-014: the bounded wait (timeout_ms == 0 is one non-blocking try) is shared with the memory
         * OSAdapter's pool lock, see rte_posix_osadapter_lock.h. */
        status = posix_osa_lock_bounded(&state->mutex, timeout_ms);
    }
    return status;
}