static void _Thread_Remove_life_change_request( Thread_Control *the_thread )
{
ISR_lock_Context lock_context;
uint32_t pending_requests;
_Thread_State_acquire( the_thread, &lock_context );
pending_requests = the_thread->Life.pending_life_change_requests;
the_thread->Life.pending_life_change_requests = pending_requests - 1;
if ( pending_requests == 1 ) {
/*
* Do not remove states used for thread queues to avoid race conditions on
* SMP configurations. We could interrupt an extract operation on another
* processor disregarding the thread wait flags. Rely on
* _Thread_queue_Extract_with_proxy() for removal of these states.
*/
_Thread_Clear_state_locked(
the_thread,
STATES_LIFE_IS_CHANGING | STATES_SUSPENDED
| ( STATES_BLOCKED & ~STATES_LOCALLY_BLOCKED )
);
}
_Thread_State_release( the_thread, &lock_context );
}
void _Thread_Exit(
Thread_Control *executing,
Thread_Life_state set,
void *exit_value
)
{
ISR_lock_Context lock_context;
_Assert(
_Watchdog_Get_state( &executing->Timer.Watchdog ) == WATCHDOG_INACTIVE
);
_Assert(
executing->current_state == STATES_READY
|| executing->current_state == STATES_SUSPENDED
);
_Thread_State_acquire( executing, &lock_context );
_Thread_Set_exit_value( executing, exit_value );
_Thread_Change_life_locked(
executing,
0,
set,
THREAD_LIFE_PROTECTED | THREAD_LIFE_CHANGE_DEFERRED
);
_Thread_State_release( executing, &lock_context );
}
static Per_CPU_Control *_Thread_Wait_for_join(
Thread_Control *executing,
Per_CPU_Control *cpu_self
)
{
#if defined(RTEMS_POSIX_API)
ISR_lock_Context lock_context;
_Thread_State_acquire( executing, &lock_context );
if (
_Thread_Is_joinable( executing )
&& _Thread_queue_Is_empty( &executing->Join_queue.Queue )
) {
_Thread_Set_state_locked( executing, STATES_WAITING_FOR_JOIN_AT_EXIT );
_Thread_State_release( executing, &lock_context );
_Thread_Dispatch_enable( cpu_self );
/* Let other threads run */
cpu_self = _Thread_Dispatch_disable();
} else {
_Thread_State_release( executing, &lock_context );
}
#endif
return cpu_self;
}
States_Control _Thread_Set_state(
Thread_Control *the_thread,
States_Control state
)
{
ISR_lock_Context lock_context;
States_Control previous_state;
States_Control next_state;
_Assert( state != 0 );
_Thread_State_acquire( the_thread, &lock_context );
previous_state = the_thread->current_state;
next_state = _States_Set( state, previous_state);
the_thread->current_state = next_state;
if ( _States_Is_ready( previous_state ) ) {
_Scheduler_Block( the_thread );
}
_Thread_State_release( the_thread, &lock_context );
return previous_state;
}
void _Thread_Close( Thread_Control *the_thread, Thread_Control *executing )
{
Thread_queue_Context queue_context;
_Thread_queue_Context_initialize( &queue_context );
_Thread_queue_Context_set_expected_level( &queue_context, 2 );
_Thread_queue_Context_set_no_timeout( &queue_context );
_Thread_State_acquire( the_thread, &queue_context.Lock_context.Lock_context );
_Thread_Join(
the_thread,
STATES_WAITING_FOR_JOIN,
executing,
&queue_context
);
_Thread_Cancel( the_thread, executing, NULL );
}
static void CPU_usage_Per_thread_handler(
Thread_Control *the_thread
)
{
const Scheduler_Control *scheduler;
ISR_lock_Context state_lock_context;
ISR_lock_Context scheduler_lock_context;
_Thread_State_acquire( the_thread, &state_lock_context );
scheduler = _Scheduler_Get( the_thread );
_Scheduler_Acquire_critical( scheduler, &scheduler_lock_context );
_Timestamp_Set_to_zero( &the_thread->cpu_time_used );
_Scheduler_Release_critical( scheduler, &scheduler_lock_context );
_Thread_State_release( the_thread, &state_lock_context );
}
void _Thread_Cancel(
Thread_Control *the_thread,
Thread_Control *executing,
void *exit_value
)
{
ISR_lock_Context lock_context;
Thread_Life_state previous;
Per_CPU_Control *cpu_self;
Priority_Control priority;
_Assert( the_thread != executing );
_Thread_State_acquire( the_thread, &lock_context );
_Thread_Set_exit_value( the_thread, exit_value );
previous = _Thread_Change_life_locked(
the_thread,
0,
THREAD_LIFE_TERMINATING,
0
);
cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
priority = _Thread_Get_priority( executing );
if ( _States_Is_dormant( the_thread->current_state ) ) {
_Thread_State_release( the_thread, &lock_context );
_Thread_Make_zombie( the_thread );
} else if ( _Thread_Is_life_change_allowed( previous ) ) {
_Thread_Add_life_change_request( the_thread );
_Thread_State_release( the_thread, &lock_context );
_Thread_Finalize_life_change( the_thread, priority );
} else {
_Thread_Add_life_change_request( the_thread );
_Thread_Clear_state_locked( the_thread, STATES_SUSPENDED );
_Thread_State_release( the_thread, &lock_context );
_Thread_Raise_real_priority( the_thread, priority );
_Thread_Remove_life_change_request( the_thread );
}
_Thread_Dispatch_enable( cpu_self );
}
static bool _POSIX_signals_Unblock_thread_done(
Thread_Control *the_thread,
POSIX_API_Control *api,
bool status
)
{
ISR_lock_Context lock_context;
_Thread_State_acquire( the_thread, &lock_context );
_Thread_Add_post_switch_action(
the_thread,
&api->Signal_action,
_POSIX_signals_Action_handler
);
_Thread_State_release( the_thread, &lock_context );
return status;
}
void _Thread_Life_action_handler(
Thread_Control *executing,
Thread_Action *action,
ISR_lock_Context *lock_context
)
{
Thread_Life_state previous_life_state;
Per_CPU_Control *cpu_self;
(void) action;
previous_life_state = executing->Life.state;
executing->Life.state = previous_life_state | THREAD_LIFE_PROTECTED;
_Thread_State_release( executing, lock_context );
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 );
}
cpu_self = _Thread_Dispatch_disable();
if ( _Thread_Is_life_terminating( previous_life_state ) ) {
cpu_self = _Thread_Wait_for_join( executing, cpu_self );
_Thread_Make_zombie( executing );
/* FIXME: Workaround for https://devel.rtems.org/ticket/2751 */
cpu_self->dispatch_necessary = true;
_Assert( cpu_self->heir != executing );
_Thread_Dispatch_enable( cpu_self );
RTEMS_UNREACHABLE();
}
_Assert( _Thread_Is_life_restarting( previous_life_state ) );
_Thread_State_acquire( executing, lock_context );
_Thread_Change_life_locked(
executing,
THREAD_LIFE_PROTECTED | THREAD_LIFE_RESTARTING,
0,
0
);
_Thread_State_release( executing, lock_context );
_Assert(
_Watchdog_Get_state( &executing->Timer.Watchdog ) == WATCHDOG_INACTIVE
);
_Assert(
executing->current_state == STATES_READY
|| executing->current_state == STATES_SUSPENDED
);
_User_extensions_Destroy_iterators( executing );
_Thread_Load_environment( executing );
#if ( CPU_HARDWARE_FP == TRUE ) || ( CPU_SOFTWARE_FP == TRUE )
if ( executing->fp_context != NULL ) {
_Context_Restore_fp( &executing->fp_context );
}
#endif
_Context_Restart_self( &executing->Registers );
RTEMS_UNREACHABLE();
}
void _Thread_Change_priority(
Thread_Control *the_thread,
Priority_Control new_priority,
void *arg,
Thread_Change_priority_filter filter,
bool prepend_it
)
{
ISR_lock_Context lock_context;
ISR_lock_Control *lock;
lock = _Thread_Lock_acquire( the_thread, &lock_context );
/*
* For simplicity set the priority restore hint unconditionally since this is
* an average case optimization. Otherwise complicated atomic operations
* would be necessary. Synchronize with a potential read of the resource
* count in the filter function. See also _CORE_mutex_Surrender(),
* _Thread_Set_priority_filter() and _Thread_Restore_priority_filter().
*/
the_thread->priority_restore_hint = true;
_Atomic_Fence( ATOMIC_ORDER_ACQ_REL );
/*
* Do not bother recomputing all the priority related information if
* we are not REALLY changing priority.
*/
if ( ( *filter )( the_thread, &new_priority, arg ) ) {
uint32_t my_generation;
my_generation = the_thread->priority_generation + 1;
the_thread->current_priority = new_priority;
the_thread->priority_generation = my_generation;
( *the_thread->Wait.operations->priority_change )(
the_thread,
new_priority,
the_thread->Wait.queue
);
_Thread_Lock_release( lock, &lock_context );
_Thread_State_acquire( the_thread, &lock_context );
if ( the_thread->priority_generation == my_generation ) {
if ( _States_Is_ready( the_thread->current_state ) ) {
_Scheduler_Change_priority(
the_thread,
new_priority,
prepend_it
);
} else {
_Scheduler_Update_priority( the_thread, new_priority );
}
}
_Thread_State_release( the_thread, &lock_context );
} else {
_Thread_Lock_release( lock, &lock_context );
}
}
