📄 tcc.c
字号:
#endif
#ifdef NU_ENABLE_HISTORY
/* Make an entry that corresponds to this function in the system history
log. */
HIC_Make_History_Entry(NU_TERMINATE_TASK_ID, (UNSIGNED) task,
(UNSIGNED) 0, (UNSIGNED) 0);
#endif
/* Determine if the calling task is the current task. */
if (task == (TC_TCB *) TCD_Current_Thread)
{
/* Protect system data structures. */
TCT_Protect(&TCD_System_Protect);
#ifdef INCLUDE_PROVIEW
_RTProf_DumpTask(task,RT_PROF_TERMINATE_TASK);
#endif /*INCLUDE_PROVIEW*/
/* Suspend the calling task with the NU_TERMINATED status. */
TCC_Suspend_Task(task_ptr, NU_TERMINATED, NU_NULL, NU_NULL,
NU_SUSPEND);
/* No need to un-protect, since control never comes back to this
point and the protection is cleared in TCT_Control_To_System. */
}
else
{
/* Protect scheduling structures. */
TCT_Protect(&TCD_System_Protect);
#ifdef INCLUDE_PROVIEW
_RTProf_DumpTask(task,RT_PROF_TERMINATE_TASK);
#endif /*INCLUDE_PROVIEW*/
/* Keep trying to terminate the specified task until its status
indicates that it is terminated or finished. */
while ((task -> tc_status != NU_FINISHED) &&
task -> tc_status != NU_TERMINATED)
{
/* Is the task in a ready state? */
if (task -> tc_status == NU_READY)
{
/* Terminate the specified task. */
TCC_Suspend_Task(task_ptr, NU_TERMINATED, NU_NULL,
NU_NULL,NU_SUSPEND);
/* Clear system protection. */
TCT_Unprotect();
}
else
{
/* Task is suspended currently. Pickup the suspension
protection. */
suspend_protect = task -> tc_suspend_protect;
/* Save the current status. */
status = task -> tc_status;
/* Release protection on system structures. */
TCT_Unprotect();
/* Determine if there was a suspension protection. If so
protect it first before the scheduling list protection.
This avoids a deadlock situation. */
if (suspend_protect)
/* Protect the terminated task's last suspension
structures. */
TCT_Protect(suspend_protect);
/* Protect the system structures again. */
TCT_Protect(&TCD_System_Protect);
/* Now determine if the same suspension is in force. */
if ((task -> tc_status == status) &&
(task -> tc_suspend_protect == suspend_protect))
{
/* Yes, same suspension is in force. */
/* Call cleanup routine, if there is one. */
if (task -> tc_cleanup)
/* Call cleanup function. */
(*(task -> tc_cleanup)) (task -> tc_cleanup_info);
/* Status the task as terminated. */
task -> tc_status = NU_TERMINATED;
/* Determine if there is a timer active. */
if (task -> tc_timer_active)
{
/* Call the stop timer function. */
TMC_Stop_Task_Timer(&(task -> tc_timer_control));
/* Clear the timer active flag. */
task -> tc_timer_active = NU_FALSE;
}
}
/* Cleanup the protection. */
if (suspend_protect)
{
/* Release specific protection. */
TCT_Unprotect_Specific(suspend_protect);
/* Clear the suspend protect field. */
task -> tc_suspend_protect = NU_NULL;
}
/* Release current protection. */
TCT_Unprotect();
}
/* Protect the scheduling list again. */
TCT_Protect(&TCD_System_Protect);
}
/* Release the protection. */
TCT_Unprotect();
}
/* Return to user mode */
NU_USER_MODE();
/* Return successful completion. */
return(NU_SUCCESS);
}
/*************************************************************************/
/* */
/* FUNCTION */
/* */
/* TCC_Resume_Task */
/* */
/* DESCRIPTION */
/* */
/* This function resumes a previously suspended task. The task */
/* task must currently be suspended for the same reason indicated */
/* by this request. If the task resumed is higher priority than */
/* the calling task and the current task is preemptable, this */
/* function returns a value of NU_TRUE. Otherwise, if no */
/* preemption is required, a NU_FALSE is returned. This routine */
/* must be called from Supervisor mode in a Supervisor/User mode */
/* switching kernel. */
/* */
/* CALLED BY */
/* */
/* Other Components */
/* TCC_Resume_Service Resume service function */
/* */
/* CALLS */
/* */
/* [TCT_Check_Stack] Stack checking function */
/* TCT_Set_Current_Protect Set current protection field */
/* TCT_Set_Execute_Task Set TCD_Execute_Task pointer */
/* TMC_Stop_Task_Timer Stop task timer */
/* */
/* INPUTS */
/* */
/* task_ptr Task control block pointer */
/* suspend_type Type of suspension to lift */
/* */
/* OUTPUTS */
/* */
/* NU_TRUE A higher priority task is */
/* ready to execute */
/* NU_FALSE No change in the task to */
/* execute */
/* */
/* HISTORY */
/* */
/* DATE REMARKS */
/* */
/* 03-01-1993 Created initial version 1.0 */
/* 04-19-1993 Verified version 1.0 */
/* 09-19-1993 Corrected an initialization */
/* problem of de-referencing a */
/* NULL pointer, resulting in */
/* version 1.0d */
/* 09-19-1993 Verified version 1.0d */
/* 03-01-1994 Modified function interface, */
/* added register optimizations, */
/* modified protection logic to */
/* assume that system protection */
/* is already in force, resulting */
/* in version 1.1 */
/* */
/* 03-18-1994 Verified version 1.1 */
/* 10-29-1997 Changed so that tc_cleanup, */
/* tc_cleanup_info, and */
/* tc_suspend_protect are cleared */
/* only if a signal is not active */
/* (SPR115) */
/* 03-20-1998 Corrected SPR455. */
/* */
/*************************************************************************/
STATUS TCC_Resume_Task(NU_TASK *task_ptr, OPTION suspend_type)
{
R1 TC_TCB *task; /* Task control block ptr */
R2 TC_TCB *head; /* Pointer to priority list */
STATUS status = NU_FALSE; /* Status variable */
/* Move 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
/* Check to see if the task is suspended for the reason that this
resume is attempting to clear. */
if (task -> tc_status == suspend_type)
{
/* Yes, this resume call is valid. */
/* If signals are not active, clear any suspend or cleanup
information (SPR115). */
if (!task -> tc_signal_active)
{
task -> tc_suspend_protect = NU_NULL;
task -> tc_cleanup = NU_NULL;
task -> tc_cleanup_info = NU_NULL;
}
/* Determine if there is a timer active and the task is not being
resumed to handle a signal. */
if ((task -> tc_timer_active) && (!task -> tc_signal_active))
{
/* Call the stop timer function. */
TMC_Stop_Task_Timer(&(task -> tc_timer_control));
/* Clear the timer active flag. */
task -> tc_timer_active = NU_FALSE;
}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -