rudism
/
pinebuds
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
pinebuds/rtos/rtx5/rtx_thread.c

1982 lines
58 KiB
C
Raw Permalink Blame History

/*
* Copyright (c) 2013-2019 Arm Limited. All rights reserved.
*
* SPDX-License-Identifier: Apache-2.0
*
* Licensed under the Apache License, Version 2.0 (the License); you may
* not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an AS IS BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* -----------------------------------------------------------------------------
*
* Project: CMSIS-RTOS RTX
* Title: Thread functions
*
* -----------------------------------------------------------------------------
*/
#include "hal_timer.h"
#include "rtx_lib.h"
// OS Runtime Object Memory Usage
#if ((defined(OS_OBJ_MEM_USAGE) && (OS_OBJ_MEM_USAGE != 0)))
osRtxObjectMemUsage_t osRtxThreadMemUsage
__attribute__((section(".data.os.thread.obj"))) = {0U, 0U, 0U};
#endif
#if __RTX_CPU_STATISTICS__
uint32_t rtx_get_hwticks(void) { return hal_sys_timer_get(); }
#endif
// ==== Helper functions ====
/// Set Thread Flags.
/// \param[in] thread thread object.
/// \param[in] flags specifies the flags to set.
/// \return thread flags after setting.
static uint32_t ThreadFlagsSet(os_thread_t *thread, uint32_t flags) {
#if (EXCLUSIVE_ACCESS == 0)
uint32_t primask = __get_PRIMASK();
#endif
uint32_t thread_flags;
#if (EXCLUSIVE_ACCESS == 0)
__disable_irq();
thread->thread_flags |= flags;
thread_flags = thread->thread_flags;
if (primask == 0U) {
__enable_irq();
}
#else
thread_flags = atomic_set32(&thread->thread_flags, flags);
#endif
return thread_flags;
}
/// Clear Thread Flags.
/// \param[in] thread thread object.
/// \param[in] flags specifies the flags to clear.
/// \return thread flags before clearing.
static uint32_t ThreadFlagsClear(os_thread_t *thread, uint32_t flags) {
#if (EXCLUSIVE_ACCESS == 0)
uint32_t primask = __get_PRIMASK();
#endif
uint32_t thread_flags;
#if (EXCLUSIVE_ACCESS == 0)
__disable_irq();
thread_flags = thread->thread_flags;
thread->thread_flags &= ~flags;
if (primask == 0U) {
__enable_irq();
}
#else
thread_flags = atomic_clr32(&thread->thread_flags, flags);
#endif
return thread_flags;
}
/// Check Thread Flags.
/// \param[in] thread thread object.
/// \param[in] flags specifies the flags to check.
/// \param[in] options specifies flags options (osFlagsXxxx).
/// \return thread flags before clearing or 0 if specified flags have not been
/// set.
static uint32_t ThreadFlagsCheck(os_thread_t *thread, uint32_t flags,
uint32_t options) {
#if (EXCLUSIVE_ACCESS == 0)
uint32_t primask;
#endif
uint32_t thread_flags;
if ((options & osFlagsNoClear) == 0U) {
#if (EXCLUSIVE_ACCESS == 0)
primask = __get_PRIMASK();
__disable_irq();
thread_flags = thread->thread_flags;
if ((((options & osFlagsWaitAll) != 0U) &&
((thread_flags & flags) != flags)) ||
(((options & osFlagsWaitAll) == 0U) &&
((thread_flags & flags) == 0U))) {
thread_flags = 0U;
} else {
thread->thread_flags &= ~flags;
}
if (primask == 0U) {
__enable_irq();
}
#else
if ((options & osFlagsWaitAll) != 0U) {
thread_flags = atomic_chk32_all(&thread->thread_flags, flags);
} else {
thread_flags = atomic_chk32_any(&thread->thread_flags, flags);
}
#endif
} else {
thread_flags = thread->thread_flags;
if ((((options & osFlagsWaitAll) != 0U) &&
((thread_flags & flags) != flags)) ||
(((options & osFlagsWaitAll) == 0U) &&
((thread_flags & flags) == 0U))) {
thread_flags = 0U;
}
}
return thread_flags;
}
// ==== Library functions ====
/// Put a Thread into specified Object list sorted by Priority (Highest at
/// Head). \param[in] object generic object. \param[in] thread thread
/// object.
void osRtxThreadListPut(os_object_t *object, os_thread_t *thread) {
os_thread_t *prev, *next;
int32_t priority;
priority = thread->priority;
prev = osRtxThreadObject(object);
next = prev->thread_next;
while ((next != NULL) && (next->priority >= priority)) {
prev = next;
next = next->thread_next;
}
thread->thread_prev = prev;
thread->thread_next = next;
prev->thread_next = thread;
if (next != NULL) {
next->thread_prev = thread;
}
}
/// Get a Thread with Highest Priority from specified Object list and remove it.
/// \param[in] object generic object.
/// \return thread object.
os_thread_t *osRtxThreadListGet(os_object_t *object) {
os_thread_t *thread;
thread = object->thread_list;
object->thread_list = thread->thread_next;
if (thread->thread_next != NULL) {
thread->thread_next->thread_prev = osRtxThreadObject(object);
}
thread->thread_prev = NULL;
return thread;
}
#if (!defined(EVR_RTX_DISABLE) && \
(((OS_EVR_EVFLAGS != 0) && \
!defined(EVR_RTX_EVENT_FLAGS_WAIT_TIMEOUT_DISABLE)) || \
((OS_EVR_MUTEX != 0) && \
!defined(EVR_RTX_MUTEX_ACQUIRE_TIMEOUT_DISABLE)) || \
((OS_EVR_SEMAPHORE != 0) && \
!defined(EVR_RTX_SEMAPHORE_ACQUIRE_TIMEOUT_DISABLE)) || \
((OS_EVR_MEMPOOL != 0) && \
!defined(EVR_RTX_MEMORY_POOL_ALLOC_TIMEOUT_DISABLE)) || \
((OS_EVR_MSGQUEUE != 0) && \
!defined(EVR_RTX_MESSAGE_QUEUE_GET_TIMEOUT_DISABLE)) || \
((OS_EVR_MSGQUEUE != 0) && \
!defined(EVR_RTX_MESSAGE_QUEUE_PUT_TIMEOUT_DISABLE))))
/// Retrieve Thread list root.
/// \param[in] thread thread object.
static void *osRtxThreadListRoot(os_thread_t *thread) {
os_thread_t *thread0;
thread0 = thread;
while (thread0->id == osRtxIdThread) {
thread0 = thread0->thread_prev;
}
return thread0;
}
#endif
/// Re-sort a Thread in linked Object list by Priority (Highest at Head).
/// \param[in] thread thread object.
void osRtxThreadListSort(os_thread_t *thread) {
os_object_t *object;
os_thread_t *thread0;
// Search for object
thread0 = thread;
while ((thread0 != NULL) && (thread0->id == osRtxIdThread)) {
thread0 = thread0->thread_prev;
}
object = osRtxObject(thread0);
if (object != NULL) {
osRtxThreadListRemove(thread);
osRtxThreadListPut(object, thread);
}
}
/// Remove a Thread from linked Object list.
/// \param[in] thread thread object.
void osRtxThreadListRemove(os_thread_t *thread) {
if (thread->thread_prev != NULL) {
thread->thread_prev->thread_next = thread->thread_next;
if (thread->thread_next != NULL) {
thread->thread_next->thread_prev = thread->thread_prev;
}
thread->thread_prev = NULL;
}
}
/// Unlink a Thread from specified linked list.
/// \param[in] thread thread object.
static void osRtxThreadListUnlink(os_thread_t **thread_list,
os_thread_t *thread) {
if (thread->thread_next != NULL) {
thread->thread_next->thread_prev = thread->thread_prev;
}
if (thread->thread_prev != NULL) {
thread->thread_prev->thread_next = thread->thread_next;
thread->thread_prev = NULL;
} else {
*thread_list = thread->thread_next;
}
}
/// Mark a Thread as Ready and put it into Ready list (sorted by Priority).
/// \param[in] thread thread object.
void osRtxThreadReadyPut(os_thread_t *thread) {
thread->state = osRtxThreadReady;
osRtxThreadListPut(&osRtxInfo.thread.ready, thread);
}
/// Insert a Thread into the Delay list sorted by Delay (Lowest at Head).
/// \param[in] thread thread object.
/// \param[in] delay delay value.
static void osRtxThreadDelayInsert(os_thread_t *thread, uint32_t delay) {
os_thread_t *prev, *next;
if (delay == osWaitForever) {
prev = NULL;
next = osRtxInfo.thread.wait_list;
while (next != NULL) {
prev = next;
next = next->delay_next;
}
thread->delay = delay;
thread->delay_prev = prev;
thread->delay_next = NULL;
if (prev != NULL) {
prev->delay_next = thread;
} else {
osRtxInfo.thread.wait_list = thread;
}
} else {
prev = NULL;
next = osRtxInfo.thread.delay_list;
while ((next != NULL) && (next->delay <= delay)) {
delay -= next->delay;
prev = next;
next = next->delay_next;
}
thread->delay = delay;
thread->delay_prev = prev;
thread->delay_next = next;
if (prev != NULL) {
prev->delay_next = thread;
} else {
osRtxInfo.thread.delay_list = thread;
}
if (next != NULL) {
next->delay -= delay;
next->delay_prev = thread;
}
}
}
/// Remove a Thread from the Delay list.
/// \param[in] thread thread object.
static void osRtxThreadDelayRemove(os_thread_t *thread) {
if (thread->delay == osWaitForever) {
if (thread->delay_next != NULL) {
thread->delay_next->delay_prev = thread->delay_prev;
}
if (thread->delay_prev != NULL) {
thread->delay_prev->delay_next = thread->delay_next;
thread->delay_prev = NULL;
} else {
osRtxInfo.thread.wait_list = thread->delay_next;
}
} else {
if (thread->delay_next != NULL) {
thread->delay_next->delay += thread->delay;
thread->delay_next->delay_prev = thread->delay_prev;
}
if (thread->delay_prev != NULL) {
thread->delay_prev->delay_next = thread->delay_next;
thread->delay_prev = NULL;
} else {
osRtxInfo.thread.delay_list = thread->delay_next;
}
}
}
/// Process Thread Delay Tick (executed each System Tick).
void osRtxThreadDelayTick(void) {
os_thread_t *thread;
thread = osRtxInfo.thread.delay_list;
if (thread == NULL) {
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return;
}
thread->delay--;
if (thread->delay == 0U) {
do {
switch (thread->state) {
case osRtxThreadWaitingDelay:
EvrRtxDelayCompleted(thread);
break;
case osRtxThreadWaitingThreadFlags:
EvrRtxThreadFlagsWaitTimeout(thread);
break;
case osRtxThreadWaitingEventFlags:
EvrRtxEventFlagsWaitTimeout(
(osEventFlagsId_t)osRtxThreadListRoot(thread));
break;
case osRtxThreadWaitingMutex:
EvrRtxMutexAcquireTimeout((osMutexId_t)osRtxThreadListRoot(thread));
break;
case osRtxThreadWaitingSemaphore:
EvrRtxSemaphoreAcquireTimeout(
(osSemaphoreId_t)osRtxThreadListRoot(thread));
break;
case osRtxThreadWaitingMemoryPool:
EvrRtxMemoryPoolAllocTimeout(
(osMemoryPoolId_t)osRtxThreadListRoot(thread));
break;
case osRtxThreadWaitingMessageGet:
EvrRtxMessageQueueGetTimeout(
(osMessageQueueId_t)osRtxThreadListRoot(thread));
break;
case osRtxThreadWaitingMessagePut:
EvrRtxMessageQueuePutTimeout(
(osMessageQueueId_t)osRtxThreadListRoot(thread));
break;
default:
// Invalid
break;
}
EvrRtxThreadUnblocked(thread, (osRtxThreadRegPtr(thread))[0]);
osRtxThreadListRemove(thread);
osRtxThreadReadyPut(thread);
thread = thread->delay_next;
} while ((thread != NULL) && (thread->delay == 0U));
if (thread != NULL) {
thread->delay_prev = NULL;
}
osRtxInfo.thread.delay_list = thread;
}
}
/// Get pointer to Thread registers (R0..R3)
/// \param[in] thread thread object.
/// \return pointer to registers R0-R3.
uint32_t *osRtxThreadRegPtr(const os_thread_t *thread) {
uint32_t addr = thread->sp + StackOffsetR0(thread->stack_frame);
// lint -e{923} -e{9078} "cast from unsigned int to pointer"
return ((uint32_t *)addr);
}
/// Block running Thread execution and register it as Ready to Run.
/// \param[in] thread running thread object.
static void osRtxThreadBlock(os_thread_t *thread) {
os_thread_t *prev, *next;
int32_t priority;
thread->state = osRtxThreadReady;
priority = thread->priority;
prev = osRtxThreadObject(&osRtxInfo.thread.ready);
next = prev->thread_next;
while ((next != NULL) && (next->priority > priority)) {
prev = next;
next = next->thread_next;
}
thread->thread_prev = prev;
thread->thread_next = next;
prev->thread_next = thread;
if (next != NULL) {
next->thread_prev = thread;
}
EvrRtxThreadPreempted(thread);
}
/// Switch to specified Thread.
/// \param[in] thread thread object.
void osRtxThreadSwitch(os_thread_t *thread) {
thread->state = osRtxThreadRunning;
osRtxInfo.thread.run.next = thread;
#if __RTX_CPU_STATISTICS__
if (osRtxInfo.thread.run.curr != thread) {
if (osRtxInfo.thread.run.curr)
osRtxInfo.thread.run.curr->swap_out_time =
HWTICKS_TO_MS(rtx_get_hwticks());
thread->swap_in_time = HWTICKS_TO_MS(rtx_get_hwticks());
}
#endif
osRtxThreadStackCheck();
EvrRtxThreadSwitched(thread);
}
/// Dispatch specified Thread or Ready Thread with Highest Priority.
/// \param[in] thread thread object or NULL.
void osRtxThreadDispatch(os_thread_t *thread) {
uint8_t kernel_state;
os_thread_t *thread_running;
os_thread_t *thread_ready;
kernel_state = osRtxKernelGetState();
thread_running = osRtxThreadGetRunning();
if (thread == NULL) {
thread_ready = osRtxInfo.thread.ready.thread_list;
if ((kernel_state == osRtxKernelRunning) && (thread_ready != NULL) &&
(thread_ready->priority > thread_running->priority)) {
// Preempt running Thread
osRtxThreadListRemove(thread_ready);
osRtxThreadBlock(thread_running);
osRtxThreadSwitch(thread_ready);
}
} else {
if ((kernel_state == osRtxKernelRunning) &&
(thread->priority > thread_running->priority)) {
// Preempt running Thread
osRtxThreadBlock(thread_running);
osRtxThreadSwitch(thread);
} else {
// Put Thread into Ready list
osRtxThreadReadyPut(thread);
}
}
}
/// Exit Thread wait state.
/// \param[in] thread thread object.
/// \param[in] ret_val return value.
/// \param[in] dispatch dispatch flag.
void osRtxThreadWaitExit(os_thread_t *thread, uint32_t ret_val,
bool_t dispatch) {
uint32_t *reg;
EvrRtxThreadUnblocked(thread, ret_val);
reg = osRtxThreadRegPtr(thread);
reg[0] = ret_val;
osRtxThreadDelayRemove(thread);
if (dispatch) {
osRtxThreadDispatch(thread);
} else {
osRtxThreadReadyPut(thread);
}
}
/// Enter Thread wait state.
/// \param[in] state new thread state.
/// \param[in] timeout timeout.
/// \return true - success, false - failure.
bool_t osRtxThreadWaitEnter(uint8_t state, uint32_t timeout) {
os_thread_t *thread;
// Check if Kernel is running
if (osRtxKernelGetState() != osRtxKernelRunning) {
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return FALSE;
}
// Check if any thread is ready
if (osRtxInfo.thread.ready.thread_list == NULL) {
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return FALSE;
}
// Get running thread
thread = osRtxThreadGetRunning();
EvrRtxThreadBlocked(thread, timeout);
thread->state = state;
osRtxThreadDelayInsert(thread, timeout);
thread = osRtxThreadListGet(&osRtxInfo.thread.ready);
osRtxThreadSwitch(thread);
return TRUE;
}
/// Check current running Thread Stack.
// lint -esym(759,osRtxThreadStackCheck) "Prototype in header"
// lint -esym(765,osRtxThreadStackCheck) "Global scope (can be overridden)"
__WEAK void osRtxThreadStackCheck(void) {
os_thread_t *thread;
thread = osRtxThreadGetRunning();
if (thread != NULL) {
// lint -e{923} "cast from pointer to unsigned int"
// lint -e{9079} -e{9087} "cast between pointers to different object types"
if ((thread->sp <= (uint32_t)thread->stack_mem) ||
(*((uint32_t *)thread->stack_mem) != osRtxStackMagicWord)) {
(void)osRtxErrorNotify(osRtxErrorStackUnderflow, thread);
}
}
}
#ifdef RTX_TF_M_EXTENSION
/// Get TrustZone Module Identifier of running Thread.
/// \return TrustZone Module Identifier.
uint32_t osRtxTzGetModuleId(void) {
os_thread_t *thread;
uint32_t tz_module;
thread = osRtxThreadGetRunning();
if (thread != NULL) {
tz_module = thread->tz_module;
} else {
tz_module = 0U;
}
return tz_module;
}
#endif
// ==== Post ISR processing ====
/// Thread post ISR processing.
/// \param[in] thread thread object.
static void osRtxThreadPostProcess(os_thread_t *thread) {
uint32_t thread_flags;
// Check if Thread is waiting for Thread Flags
if (thread->state == osRtxThreadWaitingThreadFlags) {
thread_flags =
ThreadFlagsCheck(thread, thread->wait_flags, thread->flags_options);
if (thread_flags != 0U) {
osRtxThreadWaitExit(thread, thread_flags, FALSE);
EvrRtxThreadFlagsWaitCompleted(thread->wait_flags, thread->flags_options,
thread_flags, thread);
}
}
}
// ==== Service Calls ====
/// Create a thread and add it to Active Threads.
/// \note API identical to osThreadNew
static osThreadId_t svcRtxThreadNew(osThreadFunc_t func, void *argument,
const osThreadAttr_t *attr) {
os_thread_t *thread;
uint32_t attr_bits;
void *stack_mem;
uint32_t stack_size;
osPriority_t priority;
uint8_t flags;
const char *name;
uint32_t *ptr;
uint32_t n;
#if (DOMAIN_NS == 1)
TZ_ModuleId_t tz_module;
TZ_MemoryId_t tz_memory;
#endif
// Check parameters
if (func == NULL) {
EvrRtxThreadError(NULL, (int32_t)osErrorParameter);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return NULL;
}
// Process attributes
if (attr != NULL) {
name = attr->name;
attr_bits = attr->attr_bits;
// lint -e{9079} "conversion from pointer to void to pointer to other type"
// [MISRA Note 6]
thread = attr->cb_mem;
// lint -e{9079} "conversion from pointer to void to pointer to other type"
// [MISRA Note 6]
stack_mem = attr->stack_mem;
stack_size = attr->stack_size;
priority = attr->priority;
#if (DOMAIN_NS == 1)
tz_module = attr->tz_module;
#endif
if (thread != NULL) {
// lint -e(923) -e(9078) "cast from pointer to unsigned int" [MISRA Note
// 7]
if ((((uint32_t)thread & 3U) != 0U) ||
(attr->cb_size < sizeof(os_thread_t))) {
EvrRtxThreadError(NULL, osRtxErrorInvalidControlBlock);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return NULL;
}
} else {
if (attr->cb_size != 0U) {
EvrRtxThreadError(NULL, osRtxErrorInvalidControlBlock);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return NULL;
}
}
if (stack_mem != NULL) {
// lint -e(923) -e(9078) "cast from pointer to unsigned int" [MISRA Note
// 7]
if ((((uint32_t)stack_mem & 7U) != 0U) || (stack_size == 0U)) {
EvrRtxThreadError(NULL, osRtxErrorInvalidThreadStack);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return NULL;
}
}
if (priority == osPriorityNone) {
priority = osPriorityNormal;
} else {
if ((priority < osPriorityIdle) || (priority > osPriorityISR)) {
EvrRtxThreadError(NULL, osRtxErrorInvalidPriority);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return NULL;
}
}
} else {
name = NULL;
attr_bits = 0U;
thread = NULL;
stack_mem = NULL;
stack_size = 0U;
priority = osPriorityNormal;
#if (DOMAIN_NS == 1)
tz_module = 0U;
#endif
}
// Check stack size
if ((stack_size != 0U) &&
(((stack_size & 7U) != 0U) || (stack_size < (64U + 8U)))) {
EvrRtxThreadError(NULL, osRtxErrorInvalidThreadStack);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return NULL;
}
// Allocate object memory if not provided
if (thread == NULL) {
if (osRtxInfo.mpi.thread != NULL) {
// lint -e{9079} "conversion from pointer to void to pointer to other
// type" [MISRA Note 5]
thread = osRtxMemoryPoolAlloc(osRtxInfo.mpi.thread);
} else {
// lint -e{9079} "conversion from pointer to void to pointer to other
// type" [MISRA Note 5]
thread = osRtxMemoryAlloc(osRtxInfo.mem.common, sizeof(os_thread_t), 1U);
}
#if (defined(OS_OBJ_MEM_USAGE) && (OS_OBJ_MEM_USAGE != 0))
if (thread != NULL) {
uint32_t used;
osRtxThreadMemUsage.cnt_alloc++;
used = osRtxThreadMemUsage.cnt_alloc - osRtxThreadMemUsage.cnt_free;
if (osRtxThreadMemUsage.max_used < used) {
osRtxThreadMemUsage.max_used = used;
}
}
#endif
flags = osRtxFlagSystemObject;
} else {
flags = 0U;
}
// Allocate stack memory if not provided
if ((thread != NULL) && (stack_mem == NULL)) {
if (stack_size == 0U) {
stack_size = osRtxConfig.thread_stack_size;
if (osRtxInfo.mpi.stack != NULL) {
// lint -e{9079} "conversion from pointer to void to pointer to other
// type" [MISRA Note 5]
stack_mem = osRtxMemoryPoolAlloc(osRtxInfo.mpi.stack);
if (stack_mem != NULL) {
flags |= osRtxThreadFlagDefStack;
}
} else {
// lint -e{9079} "conversion from pointer to void to pointer to other
// type" [MISRA Note 5]
stack_mem = osRtxMemoryAlloc(osRtxInfo.mem.stack, stack_size, 0U);
}
} else {
// lint -e{9079} "conversion from pointer to void to pointer to other
// type" [MISRA Note 5]
stack_mem = osRtxMemoryAlloc(osRtxInfo.mem.stack, stack_size, 0U);
}
if (stack_mem == NULL) {
if ((flags & osRtxFlagSystemObject) != 0U) {
if (osRtxInfo.mpi.thread != NULL) {
(void)osRtxMemoryPoolFree(osRtxInfo.mpi.thread, thread);
} else {
(void)osRtxMemoryFree(osRtxInfo.mem.common, thread);
}
#if (defined(OS_OBJ_MEM_USAGE) && (OS_OBJ_MEM_USAGE != 0))
osRtxThreadMemUsage.cnt_free++;
#endif
}
thread = NULL;
}
flags |= osRtxFlagSystemMemory;
}
#if (DOMAIN_NS == 1)
// Allocate secure process stack
if ((thread != NULL) && (tz_module != 0U)) {
tz_memory = TZ_AllocModuleContext_S(tz_module);
if (tz_memory == 0U) {
EvrRtxThreadError(NULL, osRtxErrorTZ_AllocContext_S);
if ((flags & osRtxFlagSystemMemory) != 0U) {
if ((flags & osRtxThreadFlagDefStack) != 0U) {
(void)osRtxMemoryPoolFree(osRtxInfo.mpi.stack, thread->stack_mem);
} else {
(void)osRtxMemoryFree(osRtxInfo.mem.stack, thread->stack_mem);
}
}
if ((flags & osRtxFlagSystemObject) != 0U) {
if (osRtxInfo.mpi.thread != NULL) {
(void)osRtxMemoryPoolFree(osRtxInfo.mpi.thread, thread);
} else {
(void)osRtxMemoryFree(osRtxInfo.mem.common, thread);
}
#if (defined(OS_OBJ_MEM_USAGE) && (OS_OBJ_MEM_USAGE != 0))
osRtxThreadMemUsage.cnt_free++;
#endif
}
thread = NULL;
}
} else {
tz_memory = 0U;
}
#endif
if (thread != NULL) {
// Initialize control block
// lint --e{923} --e{9078} "cast between pointers and unsigned int"
// lint --e{9079} --e{9087} "cast between pointers to different object
// types" lint --e{9074} "conversion between a pointer to function and
// another type"
thread->id = osRtxIdThread;
thread->state = osRtxThreadReady;
thread->flags = flags;
thread->attr = (uint8_t)attr_bits;
thread->name = name;
thread->thread_next = NULL;
thread->thread_prev = NULL;
thread->delay_next = NULL;
thread->delay_prev = NULL;
thread->thread_join = NULL;
thread->delay = 0U;
thread->priority = (int8_t)priority;
thread->priority_base = (int8_t)priority;
thread->stack_frame = STACK_FRAME_INIT_VAL;
thread->flags_options = 0U;
thread->wait_flags = 0U;
thread->thread_flags = 0U;
thread->mutex_list = NULL;
thread->stack_mem = stack_mem;
thread->stack_size = stack_size;
thread->sp = (uint32_t)stack_mem + stack_size - 64U;
thread->thread_addr = (uint32_t)func;
#if (DOMAIN_NS == 1)
thread->tz_memory = tz_memory;
#ifdef RTX_TF_M_EXTENSION
thread->tz_module = tz_module;
#endif
#endif
#if __RTX_CPU_STATISTICS__
thread->rtime = 0;
thread->step_rtime = 0;
#endif
// Initialize stack
// lint --e{613} false detection: "Possible use of null pointer"
ptr = (uint32_t *)stack_mem;
ptr[0] = osRtxStackMagicWord;
if ((osRtxConfig.flags & osRtxConfigStackWatermark) != 0U) {
for (n = (stack_size / 4U) - (16U + 1U); n != 0U; n--) {
ptr++;
*ptr = osRtxStackFillPattern;
}
}
ptr = (uint32_t *)thread->sp;
for (n = 0U; n != 13U; n++) {
ptr[n] = 0U; // R4..R11, R0..R3, R12
}
ptr[13] = (uint32_t)osThreadExit; // LR
ptr[14] = (uint32_t)func; // PC
ptr[15] = xPSR_InitVal(
(bool_t)((osRtxConfig.flags & osRtxConfigPrivilegedMode) != 0U),
(bool_t)(((uint32_t)func & 1U) != 0U)); // xPSR
ptr[8] = (uint32_t)argument; // R0
// Register post ISR processing function
osRtxInfo.post_process.thread = osRtxThreadPostProcess;
EvrRtxThreadCreated(thread, thread->thread_addr, thread->name);
} else {
EvrRtxThreadError(NULL, (int32_t)osErrorNoMemory);
}
if (thread != NULL) {
osRtxThreadDispatch(thread);
}
return thread;
}
/// Get name of a thread.
/// \note API identical to osThreadGetName
static const char *svcRtxThreadGetName(osThreadId_t thread_id) {
os_thread_t *thread = osRtxThreadId(thread_id);
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread)) {
EvrRtxThreadGetName(thread, NULL);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return NULL;
}
EvrRtxThreadGetName(thread, thread->name);
return thread->name;
}
/// Return the thread ID of the current running thread.
/// \note API identical to osThreadGetId
static osThreadId_t svcRtxThreadGetId(void) {
os_thread_t *thread;
thread = osRtxThreadGetRunning();
EvrRtxThreadGetId(thread);
return thread;
}
/// Get current thread state of a thread.
/// \note API identical to osThreadGetState
static osThreadState_t svcRtxThreadGetState(osThreadId_t thread_id) {
os_thread_t *thread = osRtxThreadId(thread_id);
osThreadState_t state;
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread)) {
EvrRtxThreadGetState(thread, osThreadError);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osThreadError;
}
state = osRtxThreadState(thread);
EvrRtxThreadGetState(thread, state);
return state;
}
/// Get stack size of a thread.
/// \note API identical to osThreadGetStackSize
static uint32_t svcRtxThreadGetStackSize(osThreadId_t thread_id) {
os_thread_t *thread = osRtxThreadId(thread_id);
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread)) {
EvrRtxThreadGetStackSize(thread, 0U);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return 0U;
}
EvrRtxThreadGetStackSize(thread, thread->stack_size);
return thread->stack_size;
}
/// Get available stack space of a thread based on stack watermark recording
/// during execution. \note API identical to osThreadGetStackSpace
static uint32_t svcRtxThreadGetStackSpace(osThreadId_t thread_id) {
os_thread_t *thread = osRtxThreadId(thread_id);
const uint32_t *stack;
uint32_t space;
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread)) {
EvrRtxThreadGetStackSpace(thread, 0U);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return 0U;
}
// Check if stack watermark is not enabled
if ((osRtxConfig.flags & osRtxConfigStackWatermark) == 0U) {
EvrRtxThreadGetStackSpace(thread, 0U);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return 0U;
}
// lint -e{9079} "conversion from pointer to void to pointer to other type"
stack = thread->stack_mem;
if (*stack++ == osRtxStackMagicWord) {
for (space = 4U; space < thread->stack_size; space += 4U) {
if (*stack++ != osRtxStackFillPattern) {
break;
}
}
} else {
space = 0U;
}
EvrRtxThreadGetStackSpace(thread, space);
return space;
}
/// Change priority of a thread.
/// \note API identical to osThreadSetPriority
static osStatus_t svcRtxThreadSetPriority(osThreadId_t thread_id,
osPriority_t priority) {
os_thread_t *thread = osRtxThreadId(thread_id);
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread) ||
(priority < osPriorityIdle) || (priority > osPriorityISR)) {
EvrRtxThreadError(thread, (int32_t)osErrorParameter);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osErrorParameter;
}
// Check object state
if (thread->state == osRtxThreadTerminated) {
EvrRtxThreadError(thread, (int32_t)osErrorResource);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osErrorResource;
}
if (thread->priority != (int8_t)priority) {
thread->priority = (int8_t)priority;
thread->priority_base = (int8_t)priority;
EvrRtxThreadPriorityUpdated(thread, priority);
osRtxThreadListSort(thread);
osRtxThreadDispatch(NULL);
}
return osOK;
}
/// Get current priority of a thread.
/// \note API identical to osThreadGetPriority
static osPriority_t svcRtxThreadGetPriority(osThreadId_t thread_id) {
os_thread_t *thread = osRtxThreadId(thread_id);
osPriority_t priority;
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread)) {
EvrRtxThreadGetPriority(thread, osPriorityError);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osPriorityError;
}
// Check object state
if (thread->state == osRtxThreadTerminated) {
EvrRtxThreadGetPriority(thread, osPriorityError);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osPriorityError;
}
priority = osRtxThreadPriority(thread);
EvrRtxThreadGetPriority(thread, priority);
return priority;
}
/// Pass control to next thread that is in state READY.
/// \note API identical to osThreadYield
static osStatus_t svcRtxThreadYield(void) {
os_thread_t *thread_running;
os_thread_t *thread_ready;
if (osRtxKernelGetState() == osRtxKernelRunning) {
thread_running = osRtxThreadGetRunning();
thread_ready = osRtxInfo.thread.ready.thread_list;
if ((thread_ready != NULL) &&
(thread_ready->priority == thread_running->priority)) {
osRtxThreadListRemove(thread_ready);
osRtxThreadReadyPut(thread_running);
EvrRtxThreadPreempted(thread_running);
osRtxThreadSwitch(thread_ready);
}
}
return osOK;
}
/// Suspend execution of a thread.
/// \note API identical to osThreadSuspend
static osStatus_t svcRtxThreadSuspend(osThreadId_t thread_id) {
os_thread_t *thread = osRtxThreadId(thread_id);
osStatus_t status;
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread)) {
EvrRtxThreadError(thread, (int32_t)osErrorParameter);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osErrorParameter;
}
// Check object state
switch (thread->state & osRtxThreadStateMask) {
case osRtxThreadRunning:
if ((osRtxKernelGetState() != osRtxKernelRunning) ||
(osRtxInfo.thread.ready.thread_list == NULL)) {
EvrRtxThreadError(thread, (int32_t)osErrorResource);
status = osErrorResource;
} else {
status = osOK;
}
break;
case osRtxThreadReady:
osRtxThreadListRemove(thread);
status = osOK;
break;
case osRtxThreadBlocked:
osRtxThreadListRemove(thread);
osRtxThreadDelayRemove(thread);
status = osOK;
break;
case osRtxThreadInactive:
case osRtxThreadTerminated:
default:
EvrRtxThreadError(thread, (int32_t)osErrorResource);
status = osErrorResource;
break;
}
if (status == osOK) {
EvrRtxThreadSuspended(thread);
if (thread->state == osRtxThreadRunning) {
osRtxThreadSwitch(osRtxThreadListGet(&osRtxInfo.thread.ready));
}
// Update Thread State and put it into Delay list
thread->state = osRtxThreadBlocked;
thread->thread_prev = NULL;
thread->thread_next = NULL;
osRtxThreadDelayInsert(thread, osWaitForever);
}
return status;
}
/// Resume execution of a thread.
/// \note API identical to osThreadResume
static osStatus_t svcRtxThreadResume(osThreadId_t thread_id) {
os_thread_t *thread = osRtxThreadId(thread_id);
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread)) {
EvrRtxThreadError(thread, (int32_t)osErrorParameter);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osErrorParameter;
}
// Check object state
if ((thread->state & osRtxThreadStateMask) != osRtxThreadBlocked) {
EvrRtxThreadError(thread, (int32_t)osErrorResource);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osErrorResource;
}
EvrRtxThreadResumed(thread);
// Wakeup Thread
osRtxThreadListRemove(thread);
osRtxThreadDelayRemove(thread);
osRtxThreadDispatch(thread);
return osOK;
}
/// Free Thread resources.
/// \param[in] thread thread object.
static void osRtxThreadFree(os_thread_t *thread) {
// Mark object as inactive and invalid
thread->state = osRtxThreadInactive;
thread->id = osRtxIdInvalid;
#if (DOMAIN_NS == 1)
// Free secure process stack
if (thread->tz_memory != 0U) {
(void)TZ_FreeModuleContext_S(thread->tz_memory);
}
#endif
// Free stack memory
if ((thread->flags & osRtxFlagSystemMemory) != 0U) {
if ((thread->flags & osRtxThreadFlagDefStack) != 0U) {
(void)osRtxMemoryPoolFree(osRtxInfo.mpi.stack, thread->stack_mem);
} else {
(void)osRtxMemoryFree(osRtxInfo.mem.stack, thread->stack_mem);
}
}
// Free object memory
if ((thread->flags & osRtxFlagSystemObject) != 0U) {
if (osRtxInfo.mpi.thread != NULL) {
(void)osRtxMemoryPoolFree(osRtxInfo.mpi.thread, thread);
} else {
(void)osRtxMemoryFree(osRtxInfo.mem.common, thread);
}
#if (defined(OS_OBJ_MEM_USAGE) && (OS_OBJ_MEM_USAGE != 0))
osRtxThreadMemUsage.cnt_free++;
#endif
}
}
/// Detach a thread (thread storage can be reclaimed when thread terminates).
/// \note API identical to osThreadDetach
static osStatus_t svcRtxThreadDetach(osThreadId_t thread_id) {
os_thread_t *thread = osRtxThreadId(thread_id);
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread)) {
EvrRtxThreadError(thread, (int32_t)osErrorParameter);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osErrorParameter;
}
// Check object attributes
if ((thread->attr & osThreadJoinable) == 0U) {
EvrRtxThreadError(thread, osRtxErrorThreadNotJoinable);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osErrorResource;
}
if (thread->state == osRtxThreadTerminated) {
osRtxThreadListUnlink(&osRtxInfo.thread.terminate_list, thread);
osRtxThreadFree(thread);
} else {
thread->attr &= ~osThreadJoinable;
}
EvrRtxThreadDetached(thread);
return osOK;
}
/// Wait for specified thread to terminate.
/// \note API identical to osThreadJoin
static osStatus_t svcRtxThreadJoin(osThreadId_t thread_id) {
os_thread_t *thread = osRtxThreadId(thread_id);
osStatus_t status;
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread)) {
EvrRtxThreadError(thread, (int32_t)osErrorParameter);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osErrorParameter;
}
// Check object attributes
if ((thread->attr & osThreadJoinable) == 0U) {
EvrRtxThreadError(thread, osRtxErrorThreadNotJoinable);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osErrorResource;
}
// Check object state
if (thread->state == osRtxThreadRunning) {
EvrRtxThreadError(thread, (int32_t)osErrorResource);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osErrorResource;
}
if (thread->state == osRtxThreadTerminated) {
osRtxThreadListUnlink(&osRtxInfo.thread.terminate_list, thread);
osRtxThreadFree(thread);
EvrRtxThreadJoined(thread);
status = osOK;
} else {
// Suspend current Thread
if (osRtxThreadWaitEnter(osRtxThreadWaitingJoin, osWaitForever)) {
thread->thread_join = osRtxThreadGetRunning();
thread->attr &= ~osThreadJoinable;
EvrRtxThreadJoinPending(thread);
} else {
EvrRtxThreadError(thread, (int32_t)osErrorResource);
}
status = osErrorResource;
}
return status;
}
/// Terminate execution of current running thread.
/// \note API identical to osThreadExit
static void svcRtxThreadExit(void) {
os_thread_t *thread;
// Check if switch to next Ready Thread is possible
if ((osRtxKernelGetState() != osRtxKernelRunning) ||
(osRtxInfo.thread.ready.thread_list == NULL)) {
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return;
}
// Get running thread
thread = osRtxThreadGetRunning();
// Release owned Mutexes
osRtxMutexOwnerRelease(thread->mutex_list);
// Wakeup Thread waiting to Join
if (thread->thread_join != NULL) {
osRtxThreadWaitExit(thread->thread_join, (uint32_t)osOK, FALSE);
EvrRtxThreadJoined(thread->thread_join);
}
// Switch to next Ready Thread
thread->sp = __get_PSP();
osRtxThreadSwitch(osRtxThreadListGet(&osRtxInfo.thread.ready));
osRtxThreadSetRunning(NULL);
if ((thread->attr & osThreadJoinable) == 0U) {
osRtxThreadFree(thread);
} else {
// Update Thread State and put it into Terminate Thread list
thread->state = osRtxThreadTerminated;
thread->thread_prev = NULL;
thread->thread_next = osRtxInfo.thread.terminate_list;
if (osRtxInfo.thread.terminate_list != NULL) {
osRtxInfo.thread.terminate_list->thread_prev = thread;
}
osRtxInfo.thread.terminate_list = thread;
}
EvrRtxThreadDestroyed(thread);
}
/// Terminate execution of a thread.
/// \note API identical to osThreadTerminate
static osStatus_t svcRtxThreadTerminate(osThreadId_t thread_id) {
os_thread_t *thread = osRtxThreadId(thread_id);
osStatus_t status;
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread)) {
EvrRtxThreadError(thread, (int32_t)osErrorParameter);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return osErrorParameter;
}
// Check object state
switch (thread->state & osRtxThreadStateMask) {
case osRtxThreadRunning:
if ((osRtxKernelGetState() != osRtxKernelRunning) ||
(osRtxInfo.thread.ready.thread_list == NULL)) {
EvrRtxThreadError(thread, (int32_t)osErrorResource);
status = osErrorResource;
} else {
status = osOK;
}
break;
case osRtxThreadReady:
osRtxThreadListRemove(thread);
status = osOK;
break;
case osRtxThreadBlocked:
osRtxThreadListRemove(thread);
osRtxThreadDelayRemove(thread);
status = osOK;
break;
case osRtxThreadInactive:
case osRtxThreadTerminated:
default:
EvrRtxThreadError(thread, (int32_t)osErrorResource);
status = osErrorResource;
break;
}
if (status == osOK) {
// Release owned Mutexes
osRtxMutexOwnerRelease(thread->mutex_list);
// Wakeup Thread waiting to Join
if (thread->thread_join != NULL) {
osRtxThreadWaitExit(thread->thread_join, (uint32_t)osOK, FALSE);
EvrRtxThreadJoined(thread->thread_join);
}
// Switch to next Ready Thread when terminating running Thread
if (thread->state == osRtxThreadRunning) {
thread->sp = __get_PSP();
osRtxThreadSwitch(osRtxThreadListGet(&osRtxInfo.thread.ready));
osRtxThreadSetRunning(NULL);
} else {
osRtxThreadDispatch(NULL);
}
if ((thread->attr & osThreadJoinable) == 0U) {
osRtxThreadFree(thread);
} else {
// Update Thread State and put it into Terminate Thread list
thread->state = osRtxThreadTerminated;
thread->thread_prev = NULL;
thread->thread_next = osRtxInfo.thread.terminate_list;
if (osRtxInfo.thread.terminate_list != NULL) {
osRtxInfo.thread.terminate_list->thread_prev = thread;
}
osRtxInfo.thread.terminate_list = thread;
}
EvrRtxThreadDestroyed(thread);
}
return status;
}
/// Get number of active threads.
/// \note API identical to osThreadGetCount
static uint32_t svcRtxThreadGetCount(void) {
const os_thread_t *thread;
uint32_t count;
// Running Thread
count = 1U;
// Ready List
for (thread = osRtxInfo.thread.ready.thread_list; thread != NULL;
thread = thread->thread_next) {
count++;
}
// Delay List
for (thread = osRtxInfo.thread.delay_list; thread != NULL;
thread = thread->delay_next) {
count++;
}
// Wait List
for (thread = osRtxInfo.thread.wait_list; thread != NULL;
thread = thread->delay_next) {
count++;
}
EvrRtxThreadGetCount(count);
return count;
}
/// Enumerate active threads.
/// \note API identical to osThreadEnumerate
static uint32_t svcRtxThreadEnumerate(osThreadId_t *thread_array,
uint32_t array_items) {
os_thread_t *thread;
uint32_t count;
// Check parameters
if ((thread_array == NULL) || (array_items == 0U)) {
EvrRtxThreadEnumerate(thread_array, array_items, 0U);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return 0U;
}
// Running Thread
*thread_array = osRtxThreadGetRunning();
thread_array++;
count = 1U;
// Ready List
for (thread = osRtxInfo.thread.ready.thread_list;
(thread != NULL) && (count < array_items);
thread = thread->thread_next) {
*thread_array = thread;
thread_array++;
count++;
}
// Delay List
for (thread = osRtxInfo.thread.delay_list;
(thread != NULL) && (count < array_items); thread = thread->delay_next) {
*thread_array = thread;
thread_array++;
count++;
}
// Wait List
for (thread = osRtxInfo.thread.wait_list;
(thread != NULL) && (count < array_items); thread = thread->delay_next) {
*thread_array = thread;
thread_array++;
count++;
}
EvrRtxThreadEnumerate(thread_array - count, array_items, count);
return count;
}
/// Set the specified Thread Flags of a thread.
/// \note API identical to osThreadFlagsSet
static uint32_t svcRtxThreadFlagsSet(osThreadId_t thread_id, uint32_t flags) {
os_thread_t *thread = osRtxThreadId(thread_id);
uint32_t thread_flags;
uint32_t thread_flags0;
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread) ||
((flags & ~(((uint32_t)1U << osRtxThreadFlagsLimit) - 1U)) != 0U)) {
EvrRtxThreadFlagsError(thread, (int32_t)osErrorParameter);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return ((uint32_t)osErrorParameter);
}
// Check object state
if (thread->state == osRtxThreadTerminated) {
EvrRtxThreadFlagsError(thread, (int32_t)osErrorResource);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return ((uint32_t)osErrorResource);
}
// Set Thread Flags
thread_flags = ThreadFlagsSet(thread, flags);
// Check if Thread is waiting for Thread Flags
if (thread->state == osRtxThreadWaitingThreadFlags) {
thread_flags0 =
ThreadFlagsCheck(thread, thread->wait_flags, thread->flags_options);
if (thread_flags0 != 0U) {
if ((thread->flags_options & osFlagsNoClear) == 0U) {
thread_flags = thread_flags0 & ~thread->wait_flags;
} else {
thread_flags = thread_flags0;
}
osRtxThreadWaitExit(thread, thread_flags0, TRUE);
EvrRtxThreadFlagsWaitCompleted(thread->wait_flags, thread->flags_options,
thread_flags0, thread);
}
}
EvrRtxThreadFlagsSetDone(thread, thread_flags);
return thread_flags;
}
/// Clear the specified Thread Flags of current running thread.
/// \note API identical to osThreadFlagsClear
static uint32_t svcRtxThreadFlagsClear(uint32_t flags) {
os_thread_t *thread;
uint32_t thread_flags;
// Check running thread
thread = osRtxThreadGetRunning();
if (thread == NULL) {
EvrRtxThreadFlagsError(NULL, osRtxErrorKernelNotRunning);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return ((uint32_t)osError);
}
// Check parameters
if ((flags & ~(((uint32_t)1U << osRtxThreadFlagsLimit) - 1U)) != 0U) {
EvrRtxThreadFlagsError(thread, (int32_t)osErrorParameter);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return ((uint32_t)osErrorParameter);
}
// Clear Thread Flags
thread_flags = ThreadFlagsClear(thread, flags);
EvrRtxThreadFlagsClearDone(thread_flags);
return thread_flags;
}
/// Get the current Thread Flags of current running thread.
/// \note API identical to osThreadFlagsGet
static uint32_t svcRtxThreadFlagsGet(void) {
const os_thread_t *thread;
// Check running thread
thread = osRtxThreadGetRunning();
if (thread == NULL) {
EvrRtxThreadFlagsGet(0U);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return 0U;
}
EvrRtxThreadFlagsGet(thread->thread_flags);
return thread->thread_flags;
}
/// Wait for one or more Thread Flags of the current running thread to become
/// signaled. \note API identical to osThreadFlagsWait
static uint32_t svcRtxThreadFlagsWait(uint32_t flags, uint32_t options,
uint32_t timeout) {
os_thread_t *thread;
uint32_t thread_flags;
// Check running thread
thread = osRtxThreadGetRunning();
if (thread == NULL) {
EvrRtxThreadFlagsError(NULL, osRtxErrorKernelNotRunning);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return ((uint32_t)osError);
}
// Check parameters
if ((flags & ~(((uint32_t)1U << osRtxThreadFlagsLimit) - 1U)) != 0U) {
EvrRtxThreadFlagsError(thread, (int32_t)osErrorParameter);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return ((uint32_t)osErrorParameter);
}
// Check Thread Flags
thread_flags = ThreadFlagsCheck(thread, flags, options);
if (thread_flags != 0U) {
EvrRtxThreadFlagsWaitCompleted(flags, options, thread_flags, thread);
} else {
// Check if timeout is specified
if (timeout != 0U) {
// Store waiting flags and options
EvrRtxThreadFlagsWaitPending(flags, options, timeout);
thread->wait_flags = flags;
thread->flags_options = (uint8_t)options;
// Suspend current Thread
if (!osRtxThreadWaitEnter(osRtxThreadWaitingThreadFlags, timeout)) {
EvrRtxThreadFlagsWaitTimeout(thread);
}
thread_flags = (uint32_t)osErrorTimeout;
} else {
EvrRtxThreadFlagsWaitNotCompleted(flags, options);
thread_flags = (uint32_t)osErrorResource;
}
}
return thread_flags;
}
#if TASK_HUNG_CHECK_ENABLED
osStatus_t svcRtxThreadSetHungCheck(osThreadId_t thread_id, int32_t enable,
uint32_t timeout) {
os_thread_t *thread = osRtxThreadId(thread_id);
if (thread == NULL)
return osErrorParameter;
thread->hung_check = !!enable;
thread->hung_check_timeout = timeout;
return osOK;
}
#endif
int rtx_task_idle_health_check(void) { return 0; }
// Service Calls definitions
// lint ++flb "Library Begin" [MISRA Note 11]
SVC0_3(ThreadNew, osThreadId_t, osThreadFunc_t, void *, const osThreadAttr_t *)
SVC0_1(ThreadGetName, const char *, osThreadId_t)
SVC0_0(ThreadGetId, osThreadId_t)
SVC0_1(ThreadGetState, osThreadState_t, osThreadId_t)
SVC0_1(ThreadGetStackSize, uint32_t, osThreadId_t)
SVC0_1(ThreadGetStackSpace, uint32_t, osThreadId_t)
SVC0_2(ThreadSetPriority, osStatus_t, osThreadId_t, osPriority_t)
SVC0_1(ThreadGetPriority, osPriority_t, osThreadId_t)
SVC0_0(ThreadYield, osStatus_t)
SVC0_1(ThreadSuspend, osStatus_t, osThreadId_t)
SVC0_1(ThreadResume, osStatus_t, osThreadId_t)
SVC0_1(ThreadDetach, osStatus_t, osThreadId_t)
SVC0_1(ThreadJoin, osStatus_t, osThreadId_t)
SVC0_0N(ThreadExit, void)
SVC0_1(ThreadTerminate, osStatus_t, osThreadId_t)
SVC0_0(ThreadGetCount, uint32_t)
SVC0_2(ThreadEnumerate, uint32_t, osThreadId_t *, uint32_t)
SVC0_2(ThreadFlagsSet, uint32_t, osThreadId_t, uint32_t)
SVC0_1(ThreadFlagsClear, uint32_t, uint32_t)
SVC0_0(ThreadFlagsGet, uint32_t)
SVC0_3(ThreadFlagsWait, uint32_t, uint32_t, uint32_t, uint32_t)
#if TASK_HUNG_CHECK_ENABLED
SVC0_3(ThreadSetHungCheck, osStatus_t, osThreadId_t, int32_t, uint32_t)
#endif
// lint --flb "Library End"
// ==== ISR Calls ====
/// Set the specified Thread Flags of a thread.
/// \note API identical to osThreadFlagsSet
__STATIC_INLINE
uint32_t isrRtxThreadFlagsSet(osThreadId_t thread_id, uint32_t flags) {
os_thread_t *thread = osRtxThreadId(thread_id);
uint32_t thread_flags;
// Check parameters
if ((thread == NULL) || (thread->id != osRtxIdThread) ||
((flags & ~(((uint32_t)1U << osRtxThreadFlagsLimit) - 1U)) != 0U)) {
EvrRtxThreadFlagsError(thread, (int32_t)osErrorParameter);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return ((uint32_t)osErrorParameter);
}
// Check object state
if (thread->state == osRtxThreadTerminated) {
EvrRtxThreadFlagsError(thread, (int32_t)osErrorResource);
// lint -e{904} "Return statement before end of function" [MISRA Note 1]
return ((uint32_t)osErrorResource);
}
// Set Thread Flags
thread_flags = ThreadFlagsSet(thread, flags);
// Register post ISR processing
osRtxPostProcess(osRtxObject(thread));
EvrRtxThreadFlagsSetDone(thread, thread_flags);
return thread_flags;
}
// ==== Library functions ====
/// Thread startup (Idle and Timer Thread).
/// \return true - success, false - failure.
bool_t osRtxThreadStartup(void) {
bool_t ret = TRUE;
// Create Idle Thread
osRtxInfo.thread.idle = osRtxThreadId(
svcRtxThreadNew(osRtxIdleThread, NULL, osRtxConfig.idle_thread_attr));
// Create Timer Thread
if (osRtxConfig.timer_mq_mcnt != 0U) {
osRtxInfo.timer.thread = osRtxThreadId(
svcRtxThreadNew(osRtxTimerThread, NULL, osRtxConfig.timer_thread_attr));
if (osRtxInfo.timer.thread == NULL) {
ret = FALSE;
}
}
return ret;
}
// ==== Public API ====
/// Create a thread and add it to Active Threads.
osThreadId_t osThreadNew(osThreadFunc_t func, void *argument,
const osThreadAttr_t *attr) {
osThreadId_t thread_id;
EvrRtxThreadNew(func, argument, attr);
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadError(NULL, (int32_t)osErrorISR);
thread_id = NULL;
} else {
thread_id = __svcThreadNew(func, argument, attr);
}
return thread_id;
}
/// Get name of a thread.
const char *osThreadGetName(osThreadId_t thread_id) {
const char *name;
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadGetName(thread_id, NULL);
name = NULL;
} else {
name = __svcThreadGetName(thread_id);
}
return name;
}
/// Return the thread ID of the current running thread.
osThreadId_t osThreadGetId(void) {
osThreadId_t thread_id;
if (IsIrqMode() || IsIrqMasked()) {
thread_id = svcRtxThreadGetId();
} else {
thread_id = __svcThreadGetId();
}
return thread_id;
}
const char *osGetThreadName(void) {
os_thread_t *thread = osRtxThreadId(osThreadGetId());
return thread->name;
}
/// Get current thread state of a thread.
osThreadState_t osThreadGetState(osThreadId_t thread_id) {
osThreadState_t state;
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadGetState(thread_id, osThreadError);
state = osThreadError;
} else {
state = __svcThreadGetState(thread_id);
}
return state;
}
/// Get stack size of a thread.
uint32_t osThreadGetStackSize(osThreadId_t thread_id) {
uint32_t stack_size;
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadGetStackSize(thread_id, 0U);
stack_size = 0U;
} else {
stack_size = __svcThreadGetStackSize(thread_id);
}
return stack_size;
}
/// Get available stack space of a thread based on stack watermark recording
/// during execution.
uint32_t osThreadGetStackSpace(osThreadId_t thread_id) {
uint32_t stack_space;
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadGetStackSpace(thread_id, 0U);
stack_space = 0U;
} else {
stack_space = __svcThreadGetStackSpace(thread_id);
}
return stack_space;
}
/// Change priority of a thread.
osStatus_t osThreadSetPriority(osThreadId_t thread_id, osPriority_t priority) {
osStatus_t status;
EvrRtxThreadSetPriority(thread_id, priority);
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadError(thread_id, (int32_t)osErrorISR);
status = osErrorISR;
} else {
status = __svcThreadSetPriority(thread_id, priority);
}
return status;
}
/// Get current priority of a thread.
osPriority_t osThreadGetPriority(osThreadId_t thread_id) {
osPriority_t priority;
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadGetPriority(thread_id, osPriorityError);
priority = osPriorityError;
} else {
priority = __svcThreadGetPriority(thread_id);
}
return priority;
}
/// Pass control to next thread that is in state READY.
osStatus_t osThreadYield(void) {
osStatus_t status;
EvrRtxThreadYield();
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadError(NULL, (int32_t)osErrorISR);
status = osErrorISR;
} else {
status = __svcThreadYield();
}
return status;
}
/// Suspend execution of a thread.
osStatus_t osThreadSuspend(osThreadId_t thread_id) {
osStatus_t status;
EvrRtxThreadSuspend(thread_id);
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadError(thread_id, (int32_t)osErrorISR);
status = osErrorISR;
} else {
status = __svcThreadSuspend(thread_id);
}
return status;
}
/// Resume execution of a thread.
osStatus_t osThreadResume(osThreadId_t thread_id) {
osStatus_t status;
EvrRtxThreadResume(thread_id);
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadError(thread_id, (int32_t)osErrorISR);
status = osErrorISR;
} else {
status = __svcThreadResume(thread_id);
}
return status;
}
/// Detach a thread (thread storage can be reclaimed when thread terminates).
osStatus_t osThreadDetach(osThreadId_t thread_id) {
osStatus_t status;
EvrRtxThreadDetach(thread_id);
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadError(thread_id, (int32_t)osErrorISR);
status = osErrorISR;
} else {
status = __svcThreadDetach(thread_id);
}
return status;
}
/// Wait for specified thread to terminate.
osStatus_t osThreadJoin(osThreadId_t thread_id) {
osStatus_t status;
EvrRtxThreadJoin(thread_id);
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadError(thread_id, (int32_t)osErrorISR);
status = osErrorISR;
} else {
status = __svcThreadJoin(thread_id);
}
return status;
}
/// Terminate execution of current running thread.
__NO_RETURN void osThreadExit(void) {
EvrRtxThreadExit();
__svcThreadExit();
EvrRtxThreadError(NULL, (int32_t)osError);
for (;;) {
}
}
/// Terminate execution of a thread.
osStatus_t osThreadTerminate(osThreadId_t thread_id) {
osStatus_t status;
EvrRtxThreadTerminate(thread_id);
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadError(thread_id, (int32_t)osErrorISR);
status = osErrorISR;
} else {
status = __svcThreadTerminate(thread_id);
}
return status;
}
/// Get number of active threads.
uint32_t osThreadGetCount(void) {
uint32_t count;
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadGetCount(0U);
count = 0U;
} else {
count = __svcThreadGetCount();
}
return count;
}
/// Enumerate active threads.
uint32_t osThreadEnumerate(osThreadId_t *thread_array, uint32_t array_items) {
uint32_t count;
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadEnumerate(thread_array, array_items, 0U);
count = 0U;
} else {
count = __svcThreadEnumerate(thread_array, array_items);
}
return count;
}
/// Set the specified Thread Flags of a thread.
uint32_t osThreadFlagsSet(osThreadId_t thread_id, uint32_t flags) {
uint32_t thread_flags;
EvrRtxThreadFlagsSet(thread_id, flags);
if (IsIrqMode() || IsIrqMasked()) {
thread_flags = isrRtxThreadFlagsSet(thread_id, flags);
} else {
thread_flags = __svcThreadFlagsSet(thread_id, flags);
}
return thread_flags;
}
/// Clear the specified Thread Flags of current running thread.
uint32_t osThreadFlagsClear(uint32_t flags) {
uint32_t thread_flags;
EvrRtxThreadFlagsClear(flags);
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadFlagsError(NULL, (int32_t)osErrorISR);
thread_flags = (uint32_t)osErrorISR;
} else {
thread_flags = __svcThreadFlagsClear(flags);
}
return thread_flags;
}
/// Get the current Thread Flags of current running thread.
uint32_t osThreadFlagsGet(void) {
uint32_t thread_flags;
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadFlagsGet(0U);
thread_flags = 0U;
} else {
thread_flags = __svcThreadFlagsGet();
}
return thread_flags;
}
/// Wait for one or more Thread Flags of the current running thread to become
/// signaled.
uint32_t osThreadFlagsWait(uint32_t flags, uint32_t options, uint32_t timeout) {
uint32_t thread_flags;
EvrRtxThreadFlagsWait(flags, options, timeout);
if (IsIrqMode() || IsIrqMasked()) {
EvrRtxThreadFlagsError(NULL, (int32_t)osErrorISR);
thread_flags = (uint32_t)osErrorISR;
} else {
thread_flags = __svcThreadFlagsWait(flags, options, timeout);
}
return thread_flags;
}
#if TASK_HUNG_CHECK_ENABLED
/// enable/disable the hung check feature of an active thread
osStatus_t osThreadSetHungCheck(osThreadId_t thread_id, int32_t enable,
uint32_t timeout) {
if (IsIrqMode() || IsIrqMasked())
return osErrorISR; // Not allowed in ISR
return __svcThreadSetHungCheck(thread_id, enable, timeout);
}
#endif
Reference in New Issue View Git Blame Copy Permalink