/*
* ======== pthread_exit ========
*/
void pthread_exit(void *retval)
{
pthread_Obj *thread = (pthread_Obj *)pthread_self();
/*
* This function terminates the calling thread and returns
* a value via retval that (if the thread is joinable) is available to
* another thread that calls pthread_join().
*
* Any clean-up handlers that have not yet been popped, are popped
* (in the reverse of the order in which they were pushed) and executed.
*/
thread->ret = retval;
/*
* Don't bother disabling the Task scheduler while the thread
* is exiting. It will be up to the application to not make
* such calls as pthread_cancel() or pthread_detach() while the
* thread is exiting.
*/
/* Pop and execute the cleanup handlers */
while (thread->cleanupList != NULL) {
_pthread_cleanup_pop(thread->cleanupList, 1);
}
/* Cleanup any pthread specific data */
_pthread_removeThreadKeys((pthread_t)thread);
if (!thread->detached) {
Semaphore_post(Semaphore_handle(&(thread->joinSem)));
/* Set this task's priority to -1 to stop it from running. */
Task_setPri(thread->task, -1);
}
else {
/* Free memory */
#if ti_sysbios_posix_Settings_supportsMutexPriority__D
Queue_destruct(&(thread->mutexList));
#endif
Semaphore_destruct(&(thread->joinSem));
Memory_free(Task_Object_heap(), thread, sizeof(pthread_Obj));
/*
* Don't call Task_delete on the calling thread. Task_exit()
* will put the task on the terminated queue, and if
* Task_deleteTerminatedTasks is TRUE, the task will be cleaned
* up automatically.
*/
Task_exit();
}
}
/*
* ======== pthread_cancel ========
* The specification of this API is that it be used as a means for one thread
* to termintate the execution of another thread. There is no mention of
* returning an error if the argument, pthread, is the same thread as the
* calling thread.
*/
int pthread_cancel(pthread_t pthread)
{
pthread_Obj *thread = (pthread_Obj *)pthread;
UInt key;
/*
* Cancel the thread. Only asynchronous cancellation is supported,
* since functions that would normally be cancellation points (eg,
* printf()), are not cancellation points for BIOS.
*/
key = Task_disable();
/* Indicate that cancellation is requested. */
thread->cancelPending = 1;
if (thread->cancelState == PTHREAD_CANCEL_ENABLE) {
/* Set this task's priority to -1 to stop it from running. */
Task_setPri(thread->task, -1);
Task_restore(key);
/* Pop and execute the cleanup handlers */
while (thread->cleanupList != NULL) {
_pthread_cleanup_pop(thread->cleanupList, 1);
}
/* Cleanup any pthread specific data */
_pthread_removeThreadKeys(pthread);
if (thread->detached) {
/* Free memory */
#if ti_sysbios_posix_Settings_supportsMutexPriority__D
Queue_destruct(&(thread->mutexList));
#endif
Semaphore_destruct(&(thread->joinSem));
Task_delete(&(thread->task));
Memory_free(Task_Object_heap(), thread, sizeof(pthread_Obj));
}
else {
/* pthread_join() will clean up. */
thread->ret = PTHREAD_CANCELED;
Semaphore_post(Semaphore_handle(&(thread->joinSem)));
}
}
else {
Task_restore(key);
}
return (0);
}
/*
* ======== _pthread_runStub ========
*/
static void _pthread_runStub(UArg arg0, UArg arg1)
{
UInt key;
Ptr arg;
pthread_Obj *thread = (pthread_Obj *)(xdc_uargToPtr(arg1));
arg = Task_getEnv(thread->task);
thread->ret = thread->fxn(arg);
/* Pop and execute the cleanup handlers */
while (thread->cleanupList != NULL) {
_pthread_cleanup_pop(thread->cleanupList, 1);
}
/* Cleanup any pthread specific data */
_pthread_removeThreadKeys((pthread_t)thread);
key = Task_disable();
if (!thread->detached) {
Semaphore_post(Semaphore_handle(&(thread->joinSem)));
/*
* Set this task's priority to -1 to prevent it from being put
* on the terminated queue (and deleted if Task.deleteTerminatedTasks
* is true). pthread_join() will delete the Task object.
*/
Task_setPri(thread->task, -1);
Task_restore(key);
}
else {
Task_restore(key);
/* Free memory */
#if ti_sysbios_posix_Settings_supportsMutexPriority__D
Queue_destruct(&(thread->mutexList));
#endif
Semaphore_destruct(&(thread->joinSem));
Memory_free(Task_Object_heap(), thread, sizeof(pthread_Obj));
/* The system will have to clean up the Task object */
}
/* Task_exit() is called when returning from this function */
}
/*
* ======== pthread_join ========
* Wait for thread to terminate.
*
* If multiple threads simultaneously try to join with the same
* thread, the results are undefined. We will return an error.
*
* If the thread calling pthread_join() is canceled, then the target
* thread will remain joinable (i.e., it will not be detached).
*/
int pthread_join(pthread_t pthread, void **thread_return)
{
pthread_Obj *thread = (pthread_Obj *)pthread;
UInt key;
key = Task_disable();
if ((thread->joinThread != NULL) || (thread->detached != 0)) {
/*
* Error - Another thread has already called pthread_join()
* for this thread, or the thread is in the detached state.
*/
Task_restore(key);
return (EINVAL);
}
if (pthread == pthread_self()) {
Task_restore(key);
return (EDEADLK);
}
/*
* Allow pthread_join() to be called from a BIOS Task. If we
* set joinThread to pthread_self(), we could get NULL if the
* Task arg1 is 0. All we need is a non-NULL value for joinThread.
*/
thread->joinThread = Task_self();
Task_restore(key);
Semaphore_pend(Semaphore_handle(&(thread->joinSem)), BIOS_WAIT_FOREVER);
if (thread_return) {
*thread_return = thread->ret;
}
#if ti_sysbios_posix_Settings_supportsMutexPriority__D
Queue_destruct(&(thread->mutexList));
#endif
Semaphore_destruct(&(thread->joinSem));
Task_delete(&(thread->task));
Memory_free(Task_Object_heap(), thread, sizeof(pthread_Obj));
return (0);
}
/*
* ======== Task_Instance_finalize ========
*/
Void Task_Instance_finalize(Task_Object *tsk, Int status)
{
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
Int i, cnt;
#endif
UInt taskKey, hwiKey;
/*
* Task's can only be deleted from main and task threads.
* Running Tasks can not be deleted.
*/
if (status == 0) {
taskKey = Task_disable();
/*
* Bar users from calling Task_delete() on terminated tasks
* if deleteTerminatedTasks is enabled.
*/
if ((Task_deleteTerminatedTasks == TRUE)
&& (Task_getMode(tsk) == Task_Mode_TERMINATED)
&& (tsk->readyQ == Task_Module_State_terminatedQ())) {
Error_raise(NULL, Task_E_deleteNotAllowed, tsk, 0);
}
Assert_isTrue((Task_getMode(tsk) != Task_Mode_RUNNING),
Task_A_badTaskState);
Assert_isTrue((BIOS_getThreadType() == BIOS_ThreadType_Main) ||
(BIOS_getThreadType() == BIOS_ThreadType_Task),
Task_A_badThreadType);
hwiKey = Hwi_disable();
if (tsk->mode == Task_Mode_READY) {
/* remove task from its ready list */
Queue_remove((Queue_Elem *)tsk);
/* if last task in readyQ, remove corresponding bit in curSet */
if (Queue_empty(tsk->readyQ)) {
Task_module->curSet &= ~tsk->mask;
}
/*
* if task was made ready by a pend timeout but hasn't run yet
* then its clock object is still on the Clock service Q.
*/
if (tsk->pendElem != NULL) {
if (BIOS_clockEnabled && tsk->pendElem->clock) {
Clock_removeI(tsk->pendElem->clock);
}
}
}
if (tsk->mode == Task_Mode_BLOCKED) {
Assert_isTrue(tsk->pendElem != NULL, Task_A_noPendElem);
/* Seemingly redundant test in case Asserts are disabled */
if (tsk->pendElem != NULL) {
Queue_remove(&(tsk->pendElem->qElem));
if (BIOS_clockEnabled && tsk->pendElem->clock) {
Clock_removeI(tsk->pendElem->clock);
}
}
}
if (tsk->mode == Task_Mode_TERMINATED) {
/* remove task from terminated task list */
Queue_remove((Queue_Elem *)tsk);
}
else {
Task_processVitalTaskFlag(tsk);
}
Hwi_restore(hwiKey);
Task_restore(taskKey);
}
/* return if failed before allocating stack */
if (status == 1) {
return;
}
if (BIOS_runtimeCreatesEnabled) {
/* free stack if it was allocated dynamically */
if (tsk->stackHeap != (xdc_runtime_IHeap_Handle)(-1)) {
Memory_free(tsk->stackHeap, tsk->stack, tsk->stackSize);
}
}
/* return if failed to allocate Hook Env */
if (status == 2) {
return;
}
/* status == 0 or status == 3 - in both cases create hook was called */
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
/* free any allocated Hook Envs */
if (Task_hooks.length > 0) {
if (status == 0) {
cnt = Task_hooks.length;
}
else {
cnt = status - 3; /* # successful createFxn() calls */
}
/*
* only call deleteFxn() if createFxn() was successful
*/
for (i = 0; i < cnt; i++) {
if (Task_hooks.elem[i].deleteFxn != NULL) {
Task_hooks.elem[i].deleteFxn(tsk);
}
}
Memory_free(Task_Object_heap(), tsk->hookEnv,
Task_hooks.length * sizeof (Ptr));
}
#endif
}
/*
* ======== Task_Instance_init ========
*/
Int Task_Instance_init(Task_Object *tsk, Task_FuncPtr fxn,
const Task_Params *params, Error_Block *eb)
{
Int align;
Int status;
SizeT stackSize;
Assert_isTrue((BIOS_taskEnabled == TRUE), Task_A_taskDisabled);
Assert_isTrue(((BIOS_getThreadType() != BIOS_ThreadType_Hwi) &&
(BIOS_getThreadType() != BIOS_ThreadType_Swi)), Task_A_badThreadType);
Assert_isTrue((((params->priority == -1) || (params->priority > 0)) &&
(params->priority < (Int)Task_numPriorities)),
Task_A_badPriority);
tsk->priority = params->priority;
/* deal with undefined Task_Params defaults */
if (params->stackHeap == NULL) {
tsk->stackHeap = Task_defaultStackHeap;
}
else {
tsk->stackHeap = params->stackHeap;
}
if (params->stackSize == 0) {
stackSize = Task_defaultStackSize;
}
else {
stackSize = params->stackSize;
}
align = Task_SupportProxy_getStackAlignment();
if (params->stack != NULL) {
if (align != 0) {
UArg stackTemp;
/* align low address to stackAlignment */
stackTemp = (UArg)params->stack;
stackTemp += align - 1;
stackTemp &= -align;
tsk->stack = (Ptr)xdc_uargToPtr(stackTemp);
/* subtract what we removed from the low address from stackSize */
tsk->stackSize = stackSize - (stackTemp - (UArg)params->stack);
/* lower the high address as necessary */
tsk->stackSize &= -align;
}
else {
tsk->stack = params->stack;
tsk->stackSize = stackSize;
}
/* tell Task_delete that stack was provided */
tsk->stackHeap = (xdc_runtime_IHeap_Handle)(-1);
}
else {
if (BIOS_runtimeCreatesEnabled) {
if (align != 0) {
/*
* round stackSize up to the nearest multiple of the alignment.
*/
tsk->stackSize = (stackSize + align - 1) & -align;
}
else {
tsk->stackSize = stackSize;
}
tsk->stack = Memory_alloc(tsk->stackHeap, tsk->stackSize,
align, eb);
if (tsk->stack == NULL) {
return (1);
}
}
}
tsk->fxn = fxn;
tsk->arg0 = params->arg0;
tsk->arg1 = params->arg1;
tsk->env = params->env;
tsk->vitalTaskFlag = params->vitalTaskFlag;
if (tsk->vitalTaskFlag == TRUE) {
Task_module->vitalTasks += 1;
}
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
if (Task_hooks.length > 0) {
tsk->hookEnv = Memory_calloc(Task_Object_heap(),
Task_hooks.length * sizeof (Ptr), 0, eb);
if (tsk->hookEnv == NULL) {
return (2);
}
}
#endif
status = Task_postInit(tsk, eb);
if (Error_check(eb)) {
return (3 + status);
}
return (0); /* no failure states */
}
/*
* ======== pthread_create ========
*/
int pthread_create(pthread_t *newthread, const pthread_attr_t *attr,
void *(*startroutine)(void *), void *arg)
{
Semaphore_Params semParams;
Task_Params taskParams;
pthread_Obj *thread = NULL;
Error_Block eb;
pthread_attr_t *pAttr;
Error_init(&eb);
Task_Params_init(&taskParams);
*newthread = NULL;
thread = (pthread_Obj *)Memory_alloc(Task_Object_heap(),
sizeof(pthread_Obj), 0, &eb);
if (thread == NULL) {
return (ENOMEM);
}
pAttr = (attr == NULL) ? &defaultPthreadAttrs : (pthread_attr_t *)attr;
taskParams.priority = pAttr->priority;
taskParams.stack = pAttr->stack;
taskParams.stackSize = pAttr->stacksize + pAttr->guardsize;
/* Save the function in arg0 for ROV */
taskParams.arg0 = (UArg)startroutine;
taskParams.arg1 = (UArg)thread;
taskParams.env = arg;
taskParams.priority = -1;
thread->detached = (pAttr->detachstate == PTHREAD_CREATE_JOINABLE) ? 0 : 1;
thread->fxn = startroutine;
thread->joinThread = NULL;
thread->cancelState = PTHREAD_CANCEL_ENABLE;
thread->cancelPending = 0;
thread->priority = pAttr->priority;
thread->cleanupList = NULL;
#if ti_sysbios_posix_Settings_supportsMutexPriority__D
thread->blockedMutex = NULL;
Queue_elemClear((Queue_Elem *)thread);
Queue_construct(&(thread->mutexList), NULL);
#endif
Semaphore_Params_init(&semParams);
semParams.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&(thread->joinSem), 0, &semParams);
thread->task = Task_create((Task_FuncPtr)_pthread_runStub,
&taskParams, &eb);
if (thread->task == NULL) {
Semaphore_destruct(&(thread->joinSem));
#if ti_sysbios_posix_Settings_supportsMutexPriority__D
Queue_destruct(&(thread->mutexList));
#endif
Memory_free(Task_Object_heap(), thread, sizeof(pthread_Obj));
return (ENOMEM);
}
*newthread = (pthread_t)thread;
Task_setPri(thread->task, pAttr->priority);
return (0);
}
/*
* ======== Task_Instance_finalize ========
* free stack if alloced during create
*/
Void Task_Instance_finalize(Task_Object *tsk, Int status)
{
Int i, cnt;
/*
* Task's can only be deleted from main and task threads.
* Task's can only be deleted when they are in these states:
* Task_Mode_TERMINATED
* Task_Mode_READY
*/
if (status == 0) {
Assert_isTrue((tsk->mode == Task_Mode_TERMINATED) ||
(tsk->mode == Task_Mode_BLOCKED) ||
((tsk->mode == Task_Mode_READY) && (tsk != Task_self())),
Task_A_badTaskState);
Assert_isTrue((BIOS_getThreadType() == BIOS_ThreadType_Main) ||
(BIOS_getThreadType() == BIOS_ThreadType_Task),
Task_A_badThreadType);
if (tsk->mode == Task_Mode_READY) {
/* remove task from its ready list */
Queue_remove((Queue_Elem *)tsk);
/* if last task in readyQ, remove corresponding bit in curSet */
if (Queue_empty(tsk->readyQ)) {
Task_module->curSet &= ~tsk->mask;
}
}
if (tsk->mode == Task_Mode_BLOCKED) {
Assert_isTrue(tsk->pendElem != NULL, Task_A_noPendElem);
if (tsk->pendElem != NULL) {
Queue_remove(&(tsk->pendElem->qElem));
if (tsk->pendElem->clock) {
Clock_destruct(Clock_struct(tsk->pendElem->clock));
}
}
}
if (tsk->mode == Task_Mode_TERMINATED) {
/* remove task from terminated task list */
Queue_remove((Queue_Elem *)tsk);
}
}
/* return if failed before allocating stack */
if (status == 1) {
return;
}
/* free stack if it was allocated dynamically */
if (tsk->stackHeap != (xdc_runtime_IHeap_Handle)(-1)) {
Memory_free(tsk->stackHeap, tsk->stack, tsk->stackSize);
}
/* return if failed to allocate Hook Env */
if (status == 2) {
return;
}
/* status == 0 or status == 3 - in both cases create hook was called */
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
/* free any allocated Hook Envs */
if (Task_hooks.length > 0) {
if (status == 0) {
cnt = Task_hooks.length;
}
else {
cnt = status - 3; /* # successful createFxn() calls */
}
/*
* only call deleteFxn() if createFxn() was successful
*/
for (i = 0; i < cnt; i++) {
if (Task_hooks.elem[i].deleteFxn != NULL) {
Task_hooks.elem[i].deleteFxn(tsk);
}
}
Memory_free(Task_Object_heap(), tsk->hookEnv,
Task_hooks.length * sizeof (Ptr));
}
#endif
}