rte_posix_osadapter_lock.c

Go to the documentation of this file.

/* _POSIX_C_SOURCE: glibc declares pthread_mutex_timedlock(), clock_gettime() and nanosleep() only under a POSIX
 * feature-test macro (this product builds strict C99), same as mutex.c's own. */
#define _POSIX_C_SOURCE 200809L

#include "rte_posix_osadapter_lock.h"
 
#include <errno.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdint.h>
#include <time.h>

#define POSIX_LOCK_NS_PER_MS 1000000L
#define POSIX_LOCK_NS_PER_S  1000000000L
#if !defined(__linux__)
#define POSIX_LOCK_POLL_NS   1000000L
#endif


static rte_status_t try_lock_once(pthread_mutex_t *mutex);
static rte_status_t lock_until_deadline(pthread_mutex_t *mutex, rte_duration_ms_t timeout_ms);
static void deadline_add_ms(struct timespec *ts, rte_duration_ms_t ms);


 

rte_status_t posix_osa_lock_bounded(pthread_mutex_t *mutex, rte_duration_ms_t timeout_ms)
{
    rte_status_t status;
 
    if (mutex == NULL)
    {
        status = RTE_STATUS_INVALID_PARAM;
    }
    else if (timeout_ms == 0U)
    {
        /* REQ-OAL-MUTEX-014: timeout_ms == 0 is one non-blocking try. */
        status = try_lock_once(mutex);
    }
    else
    {
        status = lock_until_deadline(mutex, timeout_ms);
    }
    return status;
}
 
 
/****Local functions ****/

static rte_status_t try_lock_once(pthread_mutex_t *mutex)
{
    rte_status_t status;
    int rc = pthread_mutex_trylock(mutex);
 
    if (rc == 0)
    {
        status = RTE_STATUS_OK;
    }
    else if (rc == EBUSY)
    {
        status = RTE_STATUS_TIMEOUT;
    }
    else
    {
        status = RTE_STATUS_INTERNAL_ERROR;
    }
    return status;
}
 
#if defined(__linux__)
static rte_status_t lock_until_deadline(pthread_mutex_t *mutex, rte_duration_ms_t timeout_ms)
{
    rte_status_t status;
    struct timespec deadline;
 
    if (clock_gettime(CLOCK_REALTIME, &deadline) != 0)
    {
        status = RTE_STATUS_INTERNAL_ERROR; /* no deadline - never wait unbounded */
    }
    else
    {
        int rc;
 
        deadline_add_ms(&deadline, timeout_ms);
        rc = pthread_mutex_timedlock(mutex, &deadline);
        if (rc == 0)
        {
            status = RTE_STATUS_OK;
        }
        else if (rc == ETIMEDOUT)
        {
            status = RTE_STATUS_TIMEOUT;
        }
        else
        {
            status = RTE_STATUS_INTERNAL_ERROR;
        }
    }
    return status;
}
#else
static rte_status_t lock_until_deadline(pthread_mutex_t *mutex, rte_duration_ms_t timeout_ms)
{
    rte_status_t status;
    struct timespec deadline;
 
    if (clock_gettime(CLOCK_MONOTONIC, &deadline) != 0)
    {
        status = RTE_STATUS_INTERNAL_ERROR; /* no deadline - never wait unbounded */
    }
    else
    {
        bool waiting;
 
        deadline_add_ms(&deadline, timeout_ms);
        status = try_lock_once(mutex);
        waiting = (status == RTE_STATUS_TIMEOUT);
        while (waiting)
        {
            struct timespec now;
 
            if (clock_gettime(CLOCK_MONOTONIC, &now) != 0)
            {
                status = RTE_STATUS_INTERNAL_ERROR;
                waiting = false;
            }
            else
            {
                int64_t remaining_ns = (((int64_t)deadline.tv_sec - (int64_t)now.tv_sec) * POSIX_LOCK_NS_PER_S) +
                                       ((int64_t)deadline.tv_nsec - (int64_t)now.tv_nsec);
 
                if (remaining_ns <= 0)
                {
                    waiting = false; /* deadline reached: status stays RTE_STATUS_TIMEOUT */
                }
                else
                {
                    struct timespec nap;
 
                    nap.tv_sec = 0;
                    nap.tv_nsec = (long)((remaining_ns < POSIX_LOCK_POLL_NS) ? remaining_ns : POSIX_LOCK_POLL_NS);
                    /* An EINTR only ends the sleep early; the deadline still bounds the loop. */
                    (void)nanosleep(&nap, NULL);
                    status = try_lock_once(mutex);
                    waiting = (status == RTE_STATUS_TIMEOUT);
                }
            }
        }
    }
    return status;
}
#endif

static void deadline_add_ms(struct timespec *ts, rte_duration_ms_t ms)
{
    rte_duration_ms_t whole_s = ms / 1000U;
    rte_duration_ms_t rest_ms = ms % 1000U;
 
    ts->tv_sec += (time_t)whole_s;
    ts->tv_nsec += (long)rest_ms * POSIX_LOCK_NS_PER_MS;
    if (ts->tv_nsec >= POSIX_LOCK_NS_PER_S)
    {
        ts->tv_sec += 1;
        ts->tv_nsec -= POSIX_LOCK_NS_PER_S;
    }
}