sapi_posix_backend_task.c

Go to the documentation of this file.

#define _POSIX_C_SOURCE 200809L

#include "safeapi/posix_backend/sapi_posix_backend.h"
 
#include <errno.h>
#include <pthread.h>
#include <signal.h>
#include "safeapi/oal/memory/sapi_mem_util.h"
#include <time.h>
 
typedef struct
{
    pthread_t thread;
    sapi_task_config_t config;
    volatile sig_atomic_t running;
    volatile sig_atomic_t should_stop;
    sapi_task_handle_t self_handle;
} posix_task_state_t;
 
/* C99-compatible static assert: posix_task_state_t must fit inside
 * sapi_task_storage_t's reserved bytes. */
typedef char posix_task_storage_fits_[(sizeof(posix_task_state_t) <= sizeof(sapi_task_storage_t)) ? 1 : -1];
 
#if !defined(__linux__)
static void ms_to_timespec(sapi_duration_ms_t ms, struct timespec *out_ts)
{
    out_ts->tv_sec = (time_t)(ms / 1000U);
    out_ts->tv_nsec = (long)((ms % 1000U) * 1000000L);
}
#endif
 
#if defined(__linux__)
static void timespec_add_ms(struct timespec *ts, sapi_duration_ms_t ms)
{
    ts->tv_sec += (time_t)(ms / 1000U);
    ts->tv_nsec += (long)((ms % 1000U) * 1000000L);
    if (ts->tv_nsec >= 1000000000L)
    {
        ts->tv_sec += 1;
        ts->tv_nsec -= 1000000000L;
    }
}
#endif

static void apply_priority_best_effort(pthread_t thread, uint32_t priority)
{
    struct sched_param sched;
    int min_prio = sched_get_priority_min(SCHED_FIFO);
    int max_prio = sched_get_priority_max(SCHED_FIFO);
    int wanted;
 
    if ((min_prio < 0) || (max_prio < 0))
    {
        return;
    }
 
    wanted = (int)priority;
    if (wanted < min_prio)
    {
        wanted = min_prio;
    }
    if (wanted > max_prio)
    {
        wanted = max_prio;
    }
 
    sapi_mem_set(&sched, 0, sizeof(sched));
    sched.sched_priority = wanted;
    (void)pthread_setschedparam(thread, SCHED_FIFO, &sched);
}
 
static void *task_thread_main(void *arg)
{
    posix_task_state_t *state = (posix_task_state_t *)arg;
 
    if (state->config.period_ms == 0U)
    {
        /* Run-once task: entry() always runs exactly once. should_stop is
         * NOT consulted here - it exists to interrupt a *periodic* task
         * between cycles. A one-shot task has no "between cycles" to
         * interrupt, and a caller cannot meaningfully cancel work that
         * hasn't started yet: sapi_task_start() has already committed to
         * running entry() once. suspend()/destroy() on a run-once task
         * therefore just blocks (pthread_join) until this single call
         * completes, rather than racing to skip it.
         *
         * (Previously this branch also checked should_stop==0 before
         * calling entry(), which created a genuine race: if suspend()/
         * destroy() ran on another thread before this thread was first
         * scheduled by the OS, should_stop could already be 1 here and
         * entry() would be silently skipped - the task would appear to
         * "do nothing" with no error reported anywhere.) */
        state->config.entry(state->config.user_ctx);
    }
    else
    {
#if defined(__linux__)
        struct timespec next_wake_ts;
 
        if (clock_gettime(CLOCK_MONOTONIC, &next_wake_ts) != 0)
        {
            next_wake_ts.tv_sec = 0;
            next_wake_ts.tv_nsec = 0;
        }
 
        while (state->should_stop == 0)
        {
            int rc;
            timespec_add_ms(&next_wake_ts, state->config.period_ms);
            do
            {
                rc = clock_nanosleep(CLOCK_MONOTONIC, TIMER_ABSTIME, &next_wake_ts, NULL);
            } while ((rc == EINTR) && (state->should_stop == 0));
 
            if (state->should_stop != 0)
            {
                break;
            }
 
            state->config.entry(state->config.user_ctx);
        }
#else
        struct timespec period_ts;
 
        ms_to_timespec(state->config.period_ms, &period_ts);
 
        while (state->should_stop == 0)
        {
            struct timespec remaining = period_ts;
            int rc;
 
            do
            {
                rc = nanosleep(&remaining, &remaining);
            } while ((rc != 0) && (errno == EINTR) && (state->should_stop == 0));
 
            if (state->should_stop != 0)
            {
                break;
            }
 
            state->config.entry(state->config.user_ctx);
        }
#endif
    }
 
    state->running = 0;
    return NULL;
}
 
static sapi_status_t backend_create(sapi_task_storage_t *storage, const sapi_task_config_t *config,
                                     sapi_task_handle_t *out_handle)
{
    posix_task_state_t *state;
 
    if ((storage == NULL) || (config == NULL) || (out_handle == NULL) || (config->entry == NULL))
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
 
    state = (posix_task_state_t *)(void *)storage;
    sapi_mem_set(state, 0, sizeof(*state));
    state->config = *config;
    state->self_handle = (sapi_task_handle_t)(void *)storage;
    *out_handle = state->self_handle;
    return SAPI_STATUS_OK;
}
 
static sapi_status_t backend_suspend(sapi_task_handle_t handle)
{
    posix_task_state_t *state = (posix_task_state_t *)(void *)handle;
 
    if (state == NULL)
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
    if (state->running != 0)
    {
        state->should_stop = 1;
        (void)pthread_join(state->thread, NULL);
        state->running = 0;
    }
    return SAPI_STATUS_OK;
}
 
static sapi_status_t backend_start(sapi_task_handle_t handle)
{
    posix_task_state_t *state = (posix_task_state_t *)(void *)handle;
    sapi_status_t suspend_status;
    pthread_attr_t attr;
    pthread_attr_t *attr_ptr = NULL;
 
    if (state == NULL)
    {
        return SAPI_STATUS_INVALID_PARAM;
    }
 
    /* Starting an already-running task means "restart from the top" -
     * see file header. */
    suspend_status = backend_suspend(handle);
    if (suspend_status != SAPI_STATUS_OK)
    {
        return suspend_status;
    }
 
    state->should_stop = 0;
 
    if (state->config.stack_size > 0U)
    {
        if (pthread_attr_init(&attr) == 0)
        {
            (void)pthread_attr_setstacksize(&attr, state->config.stack_size);
            attr_ptr = &attr;
        }
    }
 
    if (pthread_create(&state->thread, attr_ptr, task_thread_main, state) != 0)
    {
        if (attr_ptr != NULL)
        {
            (void)pthread_attr_destroy(attr_ptr);
        }
        return SAPI_STATUS_INTERNAL_ERROR;
    }
    state->running = 1;
 
    apply_priority_best_effort(state->thread, state->config.priority);
 
    if (attr_ptr != NULL)
    {
        (void)pthread_attr_destroy(attr_ptr);
    }
    return SAPI_STATUS_OK;
}
 
static sapi_status_t backend_destroy(sapi_task_handle_t handle)
{
    return backend_suspend(handle);
}
 
static const sapi_task_backend_t s_posix_task_backend = { backend_create, backend_start, backend_suspend,
                                                            backend_destroy };
 
const sapi_task_backend_t *sapi_posix_backend_task(void)
{
    return &s_posix_task_backend;
}