sapi_posix_backend_mutex.c

Go to the documentation of this file.

#include "safeapi/posix_backend/sapi_posix_backend.h"
 
#include <pthread.h>
#include "safeapi/oal/memory/sapi_mem_util.h"


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

static sapi_status_t backend_create(sapi_mutex_storage_t *storage, sapi_mutex_handle_t *out_handle);
static sapi_status_t backend_lock(sapi_mutex_handle_t handle);
static sapi_status_t backend_unlock(sapi_mutex_handle_t handle);
static sapi_status_t backend_destroy(sapi_mutex_handle_t handle);

static const sapi_mutex_backend_t s_posix_mutex_backend = { backend_create, backend_lock, backend_unlock,
                                                              backend_destroy };

 

const sapi_mutex_backend_t *sapi_posix_backend_mutex(void)
{
    return &s_posix_mutex_backend;
}
 
 
/****Local functions ****/
 
static sapi_status_t backend_create(sapi_mutex_storage_t *storage, sapi_mutex_handle_t *out_handle)
{
    posix_mutex_state_t *state;
    pthread_mutexattr_t attr;
    int attr_init_ok = 0;
    int init_rc;
 
    if ((storage == NULL) || (out_handle == NULL))
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
 
    state = (posix_mutex_state_t *)(void *)storage;
    sapi_mem_set(state, 0, sizeof(*state));
 
    /* Initialize attributes and try enabling Priority Inheritance (PTHREAD_PRIO_INHERIT)
     * to prevent priority inversion under RT Linux / PREEMPT_RT. */
    if (pthread_mutexattr_init(&attr) == 0)
    {
        attr_init_ok = 1;
#if defined(_POSIX_THREAD_PRIO_INHERIT) && (_POSIX_THREAD_PRIO_INHERIT > 0)
        (void)pthread_mutexattr_setprotocol(&attr, PTHREAD_PRIO_INHERIT);
#endif
    }
 
    init_rc = pthread_mutex_init(&state->mutex, (attr_init_ok != 0) ? &attr : NULL);
    if ((init_rc != 0) && (attr_init_ok != 0))
    {
        /* Fallback without priority inheritance if the platform/kernel rejects it */
        init_rc = pthread_mutex_init(&state->mutex, NULL);
    }
 
    if (attr_init_ok != 0)
    {
        (void)pthread_mutexattr_destroy(&attr);
    }
 
    if (init_rc != 0)
    {
        return SAPI_STATUS_INTERNAL_ERROR;
    }
 
    state->self_handle = (sapi_mutex_handle_t)(void *)storage;
    *out_handle = state->self_handle;
    return SAPI_STATUS_OK;
}
 
static sapi_status_t backend_lock(sapi_mutex_handle_t handle)
{
    posix_mutex_state_t *state = (posix_mutex_state_t *)(void *)handle;
 
    if (state == NULL)
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    if (pthread_mutex_lock(&state->mutex) != 0)
    {
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    return SAPI_STATUS_OK;
}
 
static sapi_status_t backend_unlock(sapi_mutex_handle_t handle)
{
    posix_mutex_state_t *state = (posix_mutex_state_t *)(void *)handle;
 
    if (state == NULL)
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    if (pthread_mutex_unlock(&state->mutex) != 0)
    {
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    return SAPI_STATUS_OK;
}
 
static sapi_status_t backend_destroy(sapi_mutex_handle_t handle)
{
    posix_mutex_state_t *state = (posix_mutex_state_t *)(void *)handle;
 
    if (state == NULL)
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    if (pthread_mutex_destroy(&state->mutex) != 0)
    {
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    return SAPI_STATUS_OK;
}