📄 tcc.c
字号:
task -> tc_ready_previous = task;
task -> tc_ready_next = task;
*(task -> tc_priority_head)= task;
/* Update the priority group bit map to indicate that this
priority now has a task ready. */
TCD_Priority_Groups =
TCD_Priority_Groups | (task -> tc_priority_group);
/* Update the sub-priority bit map to show that this priority
is ready. */
*(task -> tc_sub_priority_ptr) =
(*(task -> tc_sub_priority_ptr)) | task -> tc_sub_priority;
/* Determine if this newly ready task is higher priority
than the current task. */
if ((INT) (task -> tc_priority) < TCD_Highest_Priority)
{
/* Update the highest priority field. */
TCD_Highest_Priority = (INT) task -> tc_priority;
/* See if there is a task to execute. */
if (TCD_Execute_Task == NU_NULL)
/* Make this task the current. */
TCT_Set_Execute_Task(task);
/* Check to see if the task to execute is preemptable. */
/* SPR455 checks if we are in Application_Initialize */
else if ((TCD_Execute_Task -> tc_preemption)
|| (INC_Initialize_State == INC_START_INITIALIZE))
{
/* Yes, the task to execute is preemptable. Replace
it with the new task. */
TCT_Set_Execute_Task(task);
/* Now, check and see if the current thread is a task.
If so, return a status that indicates a context
switch is needed. */
if ((TCD_Current_Thread) &&
(((TC_TCB *) TCD_Current_Thread) -> tc_id ==
TC_TASK_ID))
/* Yes, a context switch is needed. */
status = NU_TRUE;
}
}
}
}
}
else
{
/* Check for a resumption of a delayed pure suspend. */
if (suspend_type == NU_PURE_SUSPEND)
/* Clear the delayed suspension. */
task -> tc_delayed_suspend = NU_FALSE;
/* Check for a signal active and the saved status the same as
the resume request. */
if ((suspend_type == task -> tc_saved_status) &&
(task -> tc_signal_active))
{
/* Indicate the saved status as ready. */
task -> tc_saved_status = NU_READY;
/* Determine if the task's timer is active. */
if (task -> tc_timer_active)
{
/* Stop the timer. */
TMC_Stop_Task_Timer(&(task -> tc_timer_control));
/* Clear the timer active flag. */
task -> tc_timer_active = NU_FALSE;
}
}
}
#ifdef NU_PROFILE_PLUS
PRF_PLUS_TCC_RESUME_TASK_1
#endif /* NU_PROFILE_PLUS */
/* Return back the status. */
return(status);
}
/*************************************************************************/
/* */
/* FUNCTION */
/* */
/* TCC_Resume_Service */
/* */
/* DESCRIPTION */
/* */
/* This function provides an interface identical to the application */
/* service call to resume a task. */
/* */
/* CALLED BY */
/* */
/* Application */
/* TCCE_Resume_Service Error checking function */
/* */
/* CALLS */
/* */
/* [HIC_Make_History_Entry] Make entry in history log */
/* TCC_Resume_Task Resume a task */
/* [TCT_Check_Stack] Stack checking function */
/* TCT_Control_To_System Transfer control to system */
/* TCT_Protect Protect system structures */
/* TCT_Unprotect Release system protection */
/* */
/* INPUTS */
/* */
/* task_ptr Task control block pointer */
/* */
/* OUTPUTS */
/* */
/* NU_SUCCESS Always returns success */
/* */
/*************************************************************************/
STATUS TCC_Resume_Service(NU_TASK *task_ptr)
{
TC_PROTECT *save_protect; /* Save current protection */
NU_SUPERV_USER_VARIABLES
/* Switch to supervisor mode */
NU_SUPERVISOR_MODE();
#ifdef NU_ENABLE_STACK_CHECK
/* Call stack checking function to check for an overflow condition. */
TCT_Check_Stack();
#endif
#ifdef NU_ENABLE_HISTORY
/* Make an entry that corresponds to this function in the system history
log. */
HIC_Make_History_Entry(NU_RESUME_TASK_ID, (UNSIGNED) task_ptr,
(UNSIGNED) 0, (UNSIGNED) 0);
#endif
/* Save current protection. */
if (TCD_Current_Thread != NU_NULL)
{
save_protect = TCT_Get_Current_Protect();
}
else
{
save_protect = NU_NULL;
}
/* Protect system structures. */
TCT_Protect(&TCD_System_Protect);
/* Call the actual resume task function. If the function returns a
NU_TRUE, context switching is needed. */
if (TCC_Resume_Task(task_ptr, NU_PURE_SUSPEND))
{
/* Transfer control back to the system for a context switch. */
TCT_Control_To_System();
}
/* Determine how to get out of protection. */
if (save_protect)
{
/* Restore current protection. */
TCT_Set_Current_Protect(save_protect);
/* Release system protect. */
TCT_Unprotect_Specific(&TCD_System_Protect);
}
else
/* Release protection of system structures. */
TCT_Unprotect();
/* Return to user mode */
NU_USER_MODE();
/* Always return a successful status. */
return(NU_SUCCESS);
}
/*************************************************************************/
/* */
/* FUNCTION */
/* */
/* TCC_Suspend_Task */
/* */
/* DESCRIPTION */
/* */
/* This function suspends the specified task. If the specified */
/* task is the calling task, control is transferred back to the */
/* system. */
/* */
/* CALLED BY */
/* */
/* Other Components */
/* TCC_Suspend_Service Task suspend service */
/* */
/* CALLS */
/* */
/* [HIC_Make_History_Entry] Make entry in history log */
/* TCT_Control_To_System Transfer control to system */
/* TCT_Protect Protect system structures */
/* TCT_Set_Execute_Task Set TCD_Execute_Task pointer */
/* TCT_Protect_Switch Allow protected task to run */
/* briefly */
/* TCT_Unprotect Release system protection */
/* TMC_Start_Task_Timer Start a task timer */
/* */
/* INPUTS */
/* */
/* task_ptr Task control block pointer */
/* suspend_type Type of suspension to lift */
/* cleanup Cleanup routine */
/* information Information for cleanup */
/* timeout Timeout on the suspension */
/* */
/* OUTPUTS */
/* */
/* None */
/* */
/*************************************************************************/
VOID TCC_Suspend_Task(NU_TASK *task_ptr, OPTION suspend_type,
VOID (*cleanup) (VOID *), VOID *information, UNSIGNED timeout)
{
R1 TC_TCB *task; /* Task control block ptr */
R2 INT index; /* Working index variable */
DATA_ELEMENT temp; /* Temporary variable */
/* Move input task pointer into internal pointer. */
task = (TC_TCB *) task_ptr;
#ifdef NU_ENABLE_STACK_CHECK
/* Call stack checking function to check for an overflow condition. */
TCT_Check_Stack();
#endif
/* Determine if there is a timeout to initiate. */
if (timeout != NU_SUSPEND)
{
/* Indicate that a task timer is active. */
task -> tc_timer_active = NU_TRUE;
/* Start a timeout on the suspension. */
TMC_Start_Task_Timer(&(task -> tc_timer_control),timeout);
}
/* Check for a non self-suspension. In such cases, the target task
cannot have any type of protection in force. */
if (task != (TC_TCB *) TCD_Current_Thread)
{
do
{
/* Check for protection. Remember that system protection is
in effect. */
if (task -> tc_current_protect)
{
/⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -