TIMM_OSAL_ERRORTYPE TIMM_OSAL_DeleteTask (TIMM_OSAL_PTR pTask)
{
TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
TIMM_OSAL_TASK *pHandle = (TIMM_OSAL_TASK *)pTask;
TIMM_OSAL_U32 uSleepTime = TASK_MIN_WAIT_TIME;
if (TIMM_OSAL_NULL == pHandle)
{
bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
goto EXIT;
}
if (pHandle->isCreated != TIMM_OSAL_TRUE)
{
bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
goto EXIT;
}
/*Check the status of the Task*/
while ( Task_Mode_TERMINATED != Task_getMode ( pHandle->task) ) {
TIMM_OSAL_SleepTask ( uSleepTime );
uSleepTime <<= 1;
if ( uSleepTime >= TASK_MAX_WAIT_TIME) {
bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
goto EXIT;
}
}
Task_delete ( &(pHandle->task) );
TIMM_OSAL_Free (pHandle->stackPtr);
TIMM_OSAL_Free (pHandle);
EXIT:
return bReturnStatus;
}
TIMM_OSAL_ERRORTYPE TIMM_OSAL_Task_newpri ( TIMM_OSAL_PTR pTask,
TIMM_OSAL_S32 sNewPriority )
{
TIMM_OSAL_ERRORTYPE bReturnStatus = TIMM_OSAL_ERR_NONE;
TIMM_OSAL_TASK *pHandle = (TIMM_OSAL_TASK *)pTask;
if ( ( TIMM_OSAL_NULL == pHandle ) || ( 0 == sNewPriority ) ||
( sNewPriority >= Task_numPriorities ) )
{
bReturnStatus = TIMM_OSAL_ERR_PARAMETER;
goto EXIT;
}
if (pHandle->isCreated != TIMM_OSAL_TRUE)
{
bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
goto EXIT;
}
if ( Task_Mode_TERMINATED == Task_getMode ( pHandle->task) )
{
bReturnStatus = TIMM_OSAL_ERR_UNKNOWN;
goto EXIT;
}
Task_setPri ( pHandle->task, (Int) sNewPriority );
EXIT:
return bReturnStatus;
}
Int32 Utils_tskDelete(Utils_TskHndl * pHndl)
{
UInt32 sleepTime = 8; /* in OS ticks */
Utils_tskSendCmd(pHndl, UTILS_TSK_CMD_EXIT);
/* wait for command to be received and task to be exited */
Task_sleep(1);
while (Task_Mode_TERMINATED != Task_getMode(pHndl->tsk))
{
Task_sleep(sleepTime);
sleepTime >>= 1;
if (sleepTime == 0)
{
char name[64];
strcpy(name, "INVALID_TSK");
Utils_prfGetTaskName(pHndl->tsk, name);
Vps_printf("Task Delete Error!!!!!!, task %s not deleted\n", name);
UTILS_assert(0);
}
}
Utils_prfLoadUnRegister(pHndl->tsk);
Task_delete(&pHndl->tsk);
Utils_mbxDelete(&pHndl->mbx);
return FVID2_SOK;
}
/*
* ======== Task_stat ========
*/
Void Task_stat(Task_Object *tsk, Task_Stat *statbuf)
{
statbuf->priority = tsk->priority;
statbuf->stack = tsk->stack;
statbuf->stackSize = tsk->stackSize;
statbuf->stackHeap = tsk->stackHeap;
statbuf->env = tsk->env;
statbuf->mode = Task_getMode(tsk);
statbuf->sp = tsk->context;
statbuf->used = Task_SupportProxy_stackUsed((Char *)tsk->stack,
tsk->stackSize);
}
Int32 Utils_tskSetPri(Utils_TskHndl * pHndl, UInt32 newPri)
{
if((Task_Mode_TERMINATED != Task_getMode(pHndl->tsk)) && (newPri != 0) && (newPri < (UInt32)Task_numPriorities))
{
Task_setPri(pHndl->tsk, newPri);
pHndl->tskPri = newPri;
}
else
return FVID2_EFAIL;
return FVID2_SOK;
}
void join_thread(THREAD_TYPE thread)
{
#if defined(_POSIX_THREADS) && !defined(__MINGW32__)
pthread_join(thread, 0);
#elif defined(WOLFSSL_TIRTOS)
while(1) {
if (Task_getMode(thread) == Task_Mode_TERMINATED) {
Task_sleep(5);
break;
}
Task_yield();
}
#else
int res = WaitForSingleObject((HANDLE)thread, INFINITE);
assert(res == WAIT_OBJECT_0);
res = CloseHandle((HANDLE)thread);
assert(res);
#endif
}
/*
* ======== 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
}
