bool _Thread_Set_life_protection( bool protect )
{
bool previous_life_protection;
ISR_Level level;
Per_CPU_Control *cpu;
Thread_Control *executing;
Thread_Life_state previous_life_state;
cpu = _Thread_Action_ISR_disable_and_acquire_for_executing( &level );
executing = cpu->executing;
previous_life_state = executing->Life.state;
previous_life_protection = _Thread_Is_life_protected( previous_life_state );
if ( protect ) {
executing->Life.state = previous_life_state | THREAD_LIFE_PROTECTED;
} else {
executing->Life.state = previous_life_state & ~THREAD_LIFE_PROTECTED;
}
_Thread_Action_release_and_ISR_enable( cpu, level );
#if defined(RTEMS_SMP)
/*
* On SMP configurations it is possible that a life change of an executing
* thread is requested, but this thread didn't notice it yet. The life
* change is first marked in the life state field and then all scheduling and
* other thread state updates are performed. The last step is to issues an
* inter-processor interrupt if necessary. Since this takes some time we
* have to synchronize here.
*/
if (
!_Thread_Is_life_protected( previous_life_state )
&& _Thread_Is_life_changing( previous_life_state )
) {
_Thread_Disable_dispatch();
_Thread_Enable_dispatch();
}
#endif
if (
!protect
&& _Thread_Is_life_changing( previous_life_state )
) {
_Thread_Disable_dispatch();
_Thread_Start_life_change_for_executing( executing );
_Thread_Enable_dispatch();
}
return previous_life_protection;
}
static void _Thread_Request_life_change(
Thread_Control *the_thread,
Thread_Control *executing,
Priority_Control priority,
Thread_Life_state additional_life_state
)
{
Thread_Life_state previous_life_state;
Per_CPU_Control *cpu;
ISR_Level level;
const Scheduler_Control *scheduler;
cpu = _Thread_Action_ISR_disable_and_acquire( the_thread, &level );
previous_life_state = the_thread->Life.state;
the_thread->Life.state = previous_life_state | additional_life_state;
_Thread_Action_release_and_ISR_enable( cpu, level );
scheduler = _Scheduler_Get( the_thread );
if ( the_thread == executing ) {
executing->real_priority = priority;
_Scheduler_Set_priority_if_higher( scheduler, the_thread, priority );
_Thread_Start_life_change_for_executing( executing );
} else if ( previous_life_state == THREAD_LIFE_NORMAL ) {
_Thread_Start_life_change( the_thread, scheduler, priority );
} else {
_Thread_Clear_state( the_thread, STATES_SUSPENDED );
if ( _Thread_Is_life_terminating( additional_life_state ) ) {
the_thread->real_priority = _Scheduler_Highest_priority_of_two(
scheduler,
the_thread->real_priority,
priority
);
_Scheduler_Change_priority_if_higher(
scheduler,
the_thread,
priority,
false
);
}
}
}
void _Thread_Life_action_handler(
Thread_Control *executing,
Thread_Action *action,
Per_CPU_Control *cpu,
ISR_Level level
)
{
Thread_Life_state previous_life_state;
(void) action;
previous_life_state = executing->Life.state;
executing->Life.state = THREAD_LIFE_PROTECTED;
_Thread_Action_release_and_ISR_enable( cpu, level );
if ( _Thread_Is_life_terminating( previous_life_state ) ) {
_User_extensions_Thread_terminate( executing );
} else {
_Assert( _Thread_Is_life_restarting( previous_life_state ) );
_User_extensions_Thread_restart( executing );
}
_Thread_Disable_dispatch();
if ( _Thread_Is_life_terminating( previous_life_state ) ) {
_Thread_Make_zombie( executing );
if ( executing->Life.terminator != NULL ) {
_Thread_Clear_state(
executing->Life.terminator,
STATES_WAITING_FOR_TERMINATION
);
}
_Thread_Enable_dispatch();
_Assert_Not_reached();
} else {
_Assert( _Thread_Is_life_restarting( previous_life_state ) );
if ( _Thread_Is_life_terminating( executing->Life.state ) ) {
/* Someone deleted us in the mean-time */
_Thread_Start_life_change_for_executing( executing );
} else {
_Assert( executing->Timer.state == WATCHDOG_INACTIVE );
_Assert(
executing->current_state == STATES_READY
|| executing->current_state == STATES_SUSPENDED
);
executing->Life.state = THREAD_LIFE_NORMAL;
_Thread_Load_environment( executing );
_Thread_Restart_self( executing );
_Assert_Not_reached();
}
}
}
