/*
* ======== Task_exit ========
*/
Void Task_exit()
{
UInt tskKey, hwiKey;
Task_Object *tsk;
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
Int i;
#endif
tsk = Task_self();
#ifndef ti_sysbios_knl_Task_DISABLE_ALL_HOOKS
/*
* Process Task_exit hooks. Should be called outside the Task kernel.
*/
for (i = 0; i < Task_hooks.length; i++) {
if (Task_hooks.elem[i].exitFxn != NULL) {
Task_hooks.elem[i].exitFxn(tsk);
}
}
#endif
Log_write2(Task_LD_exit, (UArg)tsk, (UArg)tsk->fxn);
tskKey = Task_disable();
hwiKey = Hwi_disable();
Task_blockI(tsk);
tsk->mode = Task_Mode_TERMINATED;
Task_processVitalTaskFlag(tsk);
Hwi_restore(hwiKey);
Queue_elemClear((Queue_Elem *)tsk);
/* add to terminated task list if it was dynamically created */
if (Task_deleteTerminatedTasks == TRUE) {
Task_Handle dynTask;
dynTask = Task_Object_first();
while (dynTask) {
if (tsk == dynTask) {
tsk->readyQ = Task_Module_State_terminatedQ();
Queue_put(tsk->readyQ, (Queue_Elem *)tsk);
break;
}
else {
dynTask = Task_Object_next(dynTask);
}
}
}
Task_restore(tskKey);
}
/*
* ======== Task_block ========
*/
Void Task_block(Task_Object *tsk)
{
UInt hwiKey;
hwiKey = Hwi_disable();
Task_blockI(tsk);
Hwi_restore(hwiKey);
}
/*
* ======== Task_sleep ========
*/
Void Task_sleep(UInt timeout)
{
Task_PendElem elem;
UInt hwiKey, tskKey;
Clock_Struct clockStruct;
if (timeout == BIOS_NO_WAIT) {
return;
}
Assert_isTrue((timeout != BIOS_WAIT_FOREVER), Task_A_badTimeout);
/* add Clock event if timeout is not FOREVER */
if (BIOS_clockEnabled) {
Clock_Params clockParams;
Clock_Params_init(&clockParams);
clockParams.arg = (UArg)&elem;
clockParams.startFlag = FALSE; /* will start when necessary, thankyou */
Clock_construct(&clockStruct, (Clock_FuncPtr)Task_sleepTimeout, timeout, &clockParams);
elem.clock = Clock_handle(&clockStruct);
}
hwiKey = Hwi_disable();
/* lock scheduler */
tskKey = Task_disable();
/* get task handle and block tsk */
elem.task = Task_self();
Task_blockI(elem.task);
if (BIOS_clockEnabled) {
Clock_startI(elem.clock);
}
/* Only needed for Task_delete() */
Queue_elemClear(&elem.qElem);
elem.task->pendElem = (Ptr)(&elem);
Hwi_restore(hwiKey);
Log_write3(Task_LM_sleep, (UArg)elem.task, (UArg)elem.task->fxn,
(UArg)timeout);
Task_restore(tskKey); /* the calling task will block here */
/* deconstruct Clock if appropriate */
if (BIOS_clockEnabled) {
Clock_destruct(Clock_struct(elem.clock));
}
}
/*
* ======== Event_pend ========
*/
UInt Event_pend(Event_Object *event, UInt andMask, UInt orMask, UInt32 timeout)
{
UInt hwiKey, tskKey;
Event_PendElem elem;
UInt matchingEvents;
Queue_Handle pendQ;
Clock_Struct clockStruct;
Assert_isTrue(((andMask | orMask) != 0), Event_A_nullEventMasks);
Log_write5(Event_LM_pend, (UArg)event, (UArg)event->postedEvents,
(UArg)andMask, (UArg)orMask, (IArg)((Int)timeout));
/*
* elem is filled in entirely before interrupts are disabled.
* This significantly reduces latency at the potential cost of wasted time
* if it turns out that there is already an event match.
*/
/* add Clock event if timeout is not FOREVER nor NO_WAIT */
if (BIOS_clockEnabled
&& (timeout != BIOS_WAIT_FOREVER)
&& (timeout != BIOS_NO_WAIT)) {
Clock_addI(Clock_handle(&clockStruct), (Clock_FuncPtr)Event_pendTimeout, timeout, (UArg)&elem);
elem.tpElem.clock = Clock_handle(&clockStruct);
elem.pendState = Event_PendState_CLOCK_WAIT;
}
else {
elem.tpElem.clock = NULL;
elem.pendState = Event_PendState_WAIT_FOREVER;
}
/* fill in this task's Event_PendElem */
elem.andMask = andMask;
elem.orMask = orMask;
pendQ = Event_Instance_State_pendQ(event);
/* get task handle */
elem.tpElem.task = Task_self();
/* Atomically check for a match and block if none */
hwiKey = Hwi_disable();
/* check if events are already available */
matchingEvents = Event_checkEvents(event, andMask, orMask);
if (matchingEvents != 0) {
/* remove Clock object from Clock Q */
if (BIOS_clockEnabled && (elem.tpElem.clock != NULL)) {
Clock_removeI(elem.tpElem.clock);
elem.tpElem.clock = NULL;
}
Hwi_restore(hwiKey);
return (matchingEvents);/* yes, then return with matching bits */
}
if (timeout == BIOS_NO_WAIT) {
Hwi_restore(hwiKey);
return (0); /* No match, no wait */
}
Assert_isTrue((BIOS_getThreadType() == BIOS_ThreadType_Task),
Event_A_badContext);
/*
* Verify that THIS core hasn't already disabled the scheduler
* so that the Task_restore() call below will indeed block
*/
Assert_isTrue((Task_enabled()),
Event_A_pendTaskDisabled);
/* lock scheduler */
tskKey = Task_disable();
/* only one Task allowed!!! */
Assert_isTrue(Queue_empty(pendQ), Event_A_eventInUse);
/* leave a pointer for Task_delete() */
elem.tpElem.task->pendElem = (Task_PendElem *)&(elem);
/* add it to Event_PendElem queue */
Queue_enqueue(pendQ, (Queue_Elem *)&elem);
Task_blockI(elem.tpElem.task);
if (BIOS_clockEnabled &&
(elem.pendState == Event_PendState_CLOCK_WAIT)) {
Clock_startI(elem.tpElem.clock);
}
Hwi_restore(hwiKey);
/* unlock task scheduler and block */
Task_restore(tskKey); /* the calling task will switch out here */
/* Here on unblock due to Event_post or Event_pendTimeout */
hwiKey = Hwi_disable();
/* remove Clock object from Clock Q */
if (BIOS_clockEnabled && (elem.tpElem.clock != NULL)) {
Clock_removeI(elem.tpElem.clock);
elem.tpElem.clock = NULL;
}
elem.tpElem.task->pendElem = NULL;
Hwi_restore(hwiKey);
/* event match? */
if (elem.pendState != Event_PendState_TIMEOUT) {
return (elem.matchingEvents);
}
else {
return (0); /* timeout */
}
}
/*
* ======== Semaphore_pend ========
*/
Bool Semaphore_pend(Semaphore_Object *sem, UInt timeout)
{
UInt hwiKey, tskKey;
Semaphore_PendElem elem;
Queue_Handle pendQ;
Clock_Struct clockStruct;
Log_write3(Semaphore_LM_pend, (IArg)sem, (UArg)sem->count, (IArg)((Int)timeout));
/*
* Consider fast path check for count != 0 here!!!
*/
/*
* elem is filled in entirely before interrupts are disabled.
* This significantly reduces latency.
*/
/* add Clock event if timeout is not FOREVER nor NO_WAIT */
if (BIOS_clockEnabled
&& (timeout != BIOS_WAIT_FOREVER)
&& (timeout != BIOS_NO_WAIT)) {
Clock_Params clockParams;
Clock_Params_init(&clockParams);
clockParams.arg = (UArg)&elem;
clockParams.startFlag = FALSE; /* will start when necessary, thankyou */
Clock_construct(&clockStruct, (Clock_FuncPtr)Semaphore_pendTimeout,
timeout, &clockParams);
elem.tpElem.clock = Clock_handle(&clockStruct);
elem.pendState = Semaphore_PendState_CLOCK_WAIT;
}
else {
elem.tpElem.clock = NULL;
elem.pendState = Semaphore_PendState_WAIT_FOREVER;
}
pendQ = Semaphore_Instance_State_pendQ(sem);
hwiKey = Hwi_disable();
/* check semaphore count */
if (sem->count == 0) {
if (timeout == BIOS_NO_WAIT) {
Hwi_restore(hwiKey);
return (FALSE);
}
Assert_isTrue((BIOS_getThreadType() == BIOS_ThreadType_Task),
Semaphore_A_badContext);
/* lock task scheduler */
tskKey = Task_disable();
/* get task handle and block tsk */
elem.tpElem.task = Task_self();
/* leave a pointer for Task_delete() */
elem.tpElem.task->pendElem = (Task_PendElem *)&(elem);
Task_blockI(elem.tpElem.task);
if (((UInt)sem->mode & 0x2) != 0) { /* if PRIORITY bit is set */
Semaphore_PendElem *tmpElem;
Task_Handle tmpTask;
UInt selfPri;
tmpElem = Queue_head(pendQ);
selfPri = Task_getPri(elem.tpElem.task);
while (tmpElem != (Semaphore_PendElem *)pendQ) {
tmpTask = tmpElem->tpElem.task;
/* use '>' here so tasks wait FIFO for same priority */
if (selfPri > Task_getPri(tmpTask)) {
break;
}
else {
tmpElem = Queue_next((Queue_Elem *)tmpElem);
}
}
Queue_insert((Queue_Elem *)tmpElem, (Queue_Elem *)&elem);
}
else {
/* put task at the end of the pendQ */
Queue_enqueue(pendQ, (Queue_Elem *)&elem);
}
/* start Clock if appropriate */
if (BIOS_clockEnabled &&
(elem.pendState == Semaphore_PendState_CLOCK_WAIT)) {
Clock_startI(elem.tpElem.clock);
}
Hwi_restore(hwiKey);
Task_restore(tskKey); /* the calling task will block here */
/* Here on unblock due to Semaphore_post or timeout */
if (Semaphore_supportsEvents && (sem->event != NULL)) {
/* synchronize Event state */
hwiKey = Hwi_disable();
Semaphore_eventSync(sem->event, sem->eventId, sem->count);
Hwi_restore(hwiKey);
}
/* deconstruct Clock if appropriate */
if (BIOS_clockEnabled && (elem.tpElem.clock != NULL)) {
Clock_destruct(Clock_struct(elem.tpElem.clock));
}
elem.tpElem.task->pendElem = NULL;
return ((Bool)(elem.pendState));
}
else {
--sem->count;
if (Semaphore_supportsEvents && (sem->event != NULL)) {
/* synchronize Event state */
Semaphore_eventSync(sem->event, sem->eventId, sem->count);
}
Hwi_restore(hwiKey);
/* deconstruct Clock if appropriate */
if (BIOS_clockEnabled && (elem.tpElem.clock != NULL)) {
Clock_destruct(Clock_struct(elem.tpElem.clock));
}
return (TRUE);
}
}
/*
* ======== Task_sleep ========
*/
Void Task_sleep(UInt32 timeout)
{
Task_PendElem elem;
UInt hwiKey, tskKey;
Clock_Struct clockStruct;
if (timeout == BIOS_NO_WAIT) {
return;
}
Assert_isTrue((timeout != BIOS_WAIT_FOREVER),
Task_A_badTimeout);
/*
* BIOS_clockEnabled check is here to eliminate Clock module
* references in the custom library
*/
if (BIOS_clockEnabled) {
/* add Clock event */
Clock_addI(Clock_handle(&clockStruct), (Clock_FuncPtr)Task_sleepTimeout, timeout, (UArg)&elem);
elem.clock = Clock_handle(&clockStruct);
}
hwiKey = Hwi_disable();
/*
* Verify that THIS core hasn't already disabled the scheduler
* so that the Task_restore() call below will indeed block
*/
Assert_isTrue((Task_enabled()),
Task_A_sleepTaskDisabled);
/* lock scheduler */
tskKey = Task_disable();
/* get task handle and block tsk */
elem.task = Task_self();
Task_blockI(elem.task);
/*
* BIOS_clockEnabled check is here to eliminate Clock module
* references in the custom library
*/
if (BIOS_clockEnabled) {
Clock_startI(elem.clock);
}
/* Only needed for Task_delete() */
Queue_elemClear(&elem.qElem);
elem.task->pendElem = (Ptr)(&elem);
Hwi_restore(hwiKey);
Log_write3(Task_LM_sleep, (UArg)elem.task, (UArg)elem.task->fxn,
(UArg)timeout);
/* unlock task scheduler and block */
Task_restore(tskKey); /* the calling task will block here */
/*
* BIOS_clockEnabled check is here to eliminate Clock module
* references in the custom library
*/
if (BIOS_clockEnabled) {
hwiKey = Hwi_disable();
/* remove Clock object from Clock Q */
Clock_removeI(elem.clock);
elem.clock = NULL;
Hwi_restore(hwiKey);
}
elem.task->pendElem = NULL;
}
