sapi_posix_backend_platform.c

Go to the documentation of this file.

/* _GNU_SOURCE: this file needs RLIMIT_MEMLOCK / getrlimit() (XSI, not base
 * POSIX), mlockall()/MCL_FUTURE (<sys/mman.h>) and the POSIX scheduling
 * API together - _GNU_SOURCE exposes all three on glibc. Harmless on
 * non-Linux libc; the Linux-only calls are __linux__-guarded below anyway.
 * Must be defined before any header is included. */
#define _GNU_SOURCE

#include "safeapi/posix_backend/sapi_posix_backend.h"
 
#if defined(__linux__)
#include <sys/mman.h>
#include <sys/resource.h>
#include <sched.h>
#include <pthread.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include "safeapi/oal/memory/sapi_mem_util.h"
#include "safeapi/oal/log/sapi_log.h"
#endif

#if defined(__linux__)
#define POSIX_PLATFORM_STACK_PREFAULT_BYTES (128U * 1024U)
#define POSIX_PLATFORM_PAGE_BYTES 4096U
#endif


static sapi_status_t backend_realtime_init(uint32_t rt_priority);
#if defined(__linux__)
static void posix_platform_lock_memory(void);
static void posix_platform_prefault_stack(void);
static void posix_platform_set_rt_priority(uint32_t rt_priority);
#endif

static const sapi_platform_backend_t s_posix_platform_backend = { backend_realtime_init };

 

const sapi_platform_backend_t *sapi_posix_backend_platform(void)
{
    return &s_posix_platform_backend;
}
 
 
/****Local functions ****/
 
static sapi_status_t backend_realtime_init(uint32_t rt_priority)
{
    /* The framework (sapi_platform_realtime_init) has already rejected
     * rt_priority > 99 before dispatching here. */
#if defined(__linux__)
    posix_platform_lock_memory();
    posix_platform_prefault_stack();
    if (rt_priority > 0U)
    {
        posix_platform_set_rt_priority(rt_priority);
    }
#else
    (void)rt_priority;
#endif
    return SAPI_STATUS_OK;
}
 
#if defined(__linux__)
static void posix_platform_lock_memory(void)
{
    struct rlimit memlock_limit;
    int lock_flags = MCL_CURRENT | MCL_FUTURE;
    char msg[160];
 
    if ((getrlimit(RLIMIT_MEMLOCK, &memlock_limit) == 0) && (memlock_limit.rlim_cur != RLIM_INFINITY))
    {
        /* Bounded lockable memory: MCL_FUTURE here would make the next
         * pthread_create() fail with EAGAIN (see file header). Lock only
         * what is already mapped. */
        lock_flags = MCL_CURRENT;
        (void)snprintf(msg, sizeof(msg),
                        "RLIMIT_MEMLOCK bounded at %lu KiB - locking current memory only "
                        "(MCL_FUTURE would break later thread creation)",
                        (unsigned long)(memlock_limit.rlim_cur / 1024UL));
        sapi_log_write(SAPI_LOG_LEVEL_WARNING, "RT-LINUX", msg);
    }
 
    if (mlockall(lock_flags) != 0)
    {
        (void)snprintf(msg, sizeof(msg), "mlockall(0x%x) skipped or not permitted (errno=%d: %s)",
                        (unsigned int)lock_flags, errno, strerror(errno));
        sapi_log_write(SAPI_LOG_LEVEL_WARNING, "RT-LINUX", msg);
    }
    else if (lock_flags == MCL_CURRENT)
    {
        sapi_log_write(SAPI_LOG_LEVEL_INFO, "RT-LINUX", "mlockall(MCL_CURRENT) enabled: current memory locked into RAM");
    }
    else
    {
        sapi_log_write(SAPI_LOG_LEVEL_INFO, "RT-LINUX",
                        "mlockall(MCL_CURRENT|MCL_FUTURE) enabled: memory locked into RAM");
    }
}
 
static void posix_platform_prefault_stack(void)
{
    volatile uint8_t dummy_stack[POSIX_PLATFORM_STACK_PREFAULT_BYTES];
    size_t page_idx;
 
    for (page_idx = 0U; page_idx < sizeof(dummy_stack); page_idx += POSIX_PLATFORM_PAGE_BYTES)
    {
        dummy_stack[page_idx] = 0U;
    }
}
 
static void posix_platform_set_rt_priority(uint32_t rt_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 = (int)rt_priority;
    char msg[128];
 
    if ((min_prio < 0) || (max_prio < 0))
    {
        return;
    }
    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;
 
    if (pthread_setschedparam(pthread_self(), SCHED_FIFO, &sched) == 0)
    {
        (void)snprintf(msg, sizeof(msg), "SCHED_FIFO priority successfully set to %d", wanted);
        sapi_log_write(SAPI_LOG_LEVEL_INFO, "RT-LINUX", msg);
    }
    else
    {
        (void)snprintf(msg, sizeof(msg), "pthread_setschedparam(SCHED_FIFO, prio=%d) skipped or unprivileged (errno=%d: %s)",
                        wanted, errno, strerror(errno));
        sapi_log_write(SAPI_LOG_LEVEL_WARNING, "RT-LINUX", msg);
    }
}
#endif /* __linux__ */