task.h

Go to the documentation of this file.

#pragma once
#include "FreeRTOS.h"
#include "thread.h"
#include <locks.h>
#define INC_TASK_H
 
/**
 * \file
 * \brief Minimal FreeRTOS task compatibility APIs.
 *
 * This file defines the compatibility wrappers for FreeRTOS's task APIs.
 *
 * FreeRTOS's task abstraction is similar to a UNIX process and does not map
 * directly to a CHERIoT RTOS concept.  CHERIoT RTOS also does not support
 * dynamic thread creation and so the task-creation APIs are defined to give
 * compile-time errors.
 */
 
/**
 * Initialise a timeout with the current number of elapsed ticks.  This is used
 * in a blocking function in conjunction with `xTaskCheckForTimeOut()`.  The
 * value returned here should be passed as the first argument of
 * `xTaskCheckForTimeOut()`.
 */
static inline void vTaskSetTimeOutState(TimeOut_t *timeout)
{
    SystickReturn ret = thread_systemtick_get();
    *timeout          = ((uint64_t)ret.hi << 32) | ret.lo;
}
 
/**
 * Return whether a timeout has expired.  The first argument should be a
 * pointer to the value returned by `vTaskSetTimeOutState()` before any
 * blocking operations.  The second argument is the number of ticks to wait.
 * This function returns `pdTRUE` if the timeout has expired, or `pdFALSE` if
 * the timeout has not expired, and updates the arguments to reflect the
 * remaining time to wait.
 */
static inline BaseType_t xTaskCheckForTimeOut(TimeOut_t  *pxTimeOut,
                                              TickType_t *pxTicksToWait)
{
    BaseType_t xReturn;
    uint64_t   timeBlock;
    TickType_t xElapsedTime;
 
    vTaskSetTimeOutState(&timeBlock);
 
    xElapsedTime = timeBlock - *pxTimeOut;
    if (xElapsedTime < *pxTicksToWait)
    {
        *pxTicksToWait -= xElapsedTime;
        *pxTimeOut = timeBlock;
        xReturn    = pdFALSE;
    }
    else
    {
        *pxTicksToWait = (TickType_t)0;
        xReturn        = pdTRUE;
    }
 
    return xReturn;
}
 
/**
 * Block the current thread for a given number of ticks.
 */
static inline void vTaskDelay(const TickType_t xTicksToDelay)
{
    struct Timeout timeout = {0, xTicksToDelay};
    /*
     * The FreeRTOS API does not have a way to signal failure of sleep, so we
     * override the nodiscard annotation on thread_sleep.
     */
    (void)thread_sleep(&timeout, ThreadSleepNoEarlyWake);
}
 
/**
 * Return the number of ticks elapsed since the system booted.  This is
 * truncated to a 32-bit value.
 */
static inline TickType_t xTaskGetTickCount(void)
{
    return thread_systemtick_get().lo;
}
 
/**
 * Returns the current thread ID.
 */
static inline TaskHandle_t xTaskGetCurrentTaskHandle(void)
{
    return thread_id_get();
}
 
__BEGIN_DECLS
 
/**
 * Lock used to simulate disabling interrupts in `taskENTER_CRITICAL` and
 * `taskEXIT_CRITICAL`.  Code using these APIs must provide a definition to
 * accompany this declaration.
 */
extern struct RecursiveMutexState __CriticalSectionFlagLock;
 
/**
 * Lock used to simulate disabling interrupts in `vTaskSuspendAll` and
 * `xTaskResumeAll`.  Code using these APIs must provide a definition to
 * accompany this declaration.
 */
extern struct RecursiveMutexState __SuspendFlagLock;
 
__END_DECLS
 
/**
 * Critical section.  This acquires a recursive mutex.  In FreeRTOS, this
 * disables interrupts.  The CHERIoT RTOS security model does not permit
 * interrupts to be arbitrarily disabled, only for designated scopes.  Callers
 * of this should be carefully audited to ensure that they are safe.
 */
static inline void taskENTER_CRITICAL(void)
{
    Timeout t = {0, UnlimitedTimeout};
    recursivemutex_trylock(&t, &__CriticalSectionFlagLock);
}
 
/**
 * Exit a critical section entered with `taskENTER_CRITICAL`.
 */
static inline void taskEXIT_CRITICAL(void)
{
    recursivemutex_unlock(&__CriticalSectionFlagLock);
}
 
/**
 * Critical section.  This acquires a recursive mutex.  In FreeRTOS, this
 * disables interrupts.  The CHERIoT RTOS security model does not permit
 * interrupts to be arbitrarily disabled, only for designated scopes.  Callers
 * of this should be carefully audited to ensure that they are safe.
 */
static inline void vTaskSuspendAll(void)
{
    Timeout t = {0, UnlimitedTimeout};
    recursivemutex_trylock(&t, &__SuspendFlagLock);
}
 
/**
 * Exit a critical section entered with `vTaskSuspendAll`.
 */
static inline BaseType_t xTaskResumeAll(void)
{
    recursivemutex_unlock(&__SuspendFlagLock);
    return pdTRUE;
}
 
/**
 * Exit a critical section entered with `vTaskSuspendAll`.
 */
static inline void vTaskResumeAll(void)
{
    recursivemutex_unlock(&__SuspendFlagLock);
}
 
/**
 * Task creation API.  CHERIoT RTOS does not permit dynamic thread creation and
 * so this simply provides a warning so that ported code can be modified to
 * avoid the API.
 */
#define xTaskCreate(...)                                                       \
    _Pragma("GCC warning \"Dynamic thread creation is not supported\"")(       \
      TaskHandle_t) -                                                          \
      1
 
/**
 * Task creation API.  CHERIoT RTOS does not permit dynamic thread creation and
 * so this simply provides a warning so that ported code can be modified to
 * avoid the API.
 */
#define xTaskCreateStatic(...)                                                 \
    _Pragma("GCC warning \"Dynamic thread creation is not supported\"")(       \
      TaskHandle_t) -                                                          \
      1