void _POSIX_signals_Action_handler( Thread_Control *executing, Thread_Action *action, Per_CPU_Control *cpu, ISR_Level level ) { POSIX_API_Control *api; int signo; ISR_lock_Context lock_context; int hold_errno; (void) action; _Thread_Action_release_and_ISR_enable( cpu, level ); api = executing->API_Extensions[ THREAD_API_POSIX ]; /* * We need to ensure that if the signal handler executes a call * which overwrites the unblocking status, we restore it. */ hold_errno = executing->Wait.return_code; /* * api may be NULL in case of a thread close in progress */ if ( !api ) return; /* * If we invoke any user code, there is the possibility that * a new signal has been posted that we should process so we * restart the loop if a signal handler was invoked. * * The first thing done is to check there are any signals to be * processed at all. No point in doing this loop otherwise. */ while (1) { _POSIX_signals_Acquire( &lock_context ); if ( !(~api->signals_blocked & (api->signals_pending | _POSIX_signals_Pending)) ) { _POSIX_signals_Release( &lock_context ); break; } _POSIX_signals_Release( &lock_context ); for ( signo = SIGRTMIN ; signo <= SIGRTMAX ; signo++ ) { _POSIX_signals_Check_signal( api, signo, false ); _POSIX_signals_Check_signal( api, signo, true ); } /* Unfortunately - nothing like __SIGFIRSTNOTRT in newlib signal .h */ for ( signo = SIGHUP ; signo <= __SIGLASTNOTRT ; signo++ ) { _POSIX_signals_Check_signal( api, signo, false ); _POSIX_signals_Check_signal( api, signo, true ); } } executing->Wait.return_code = hold_errno; }
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 ); } } }
static void _Thread_Run_post_switch_actions( Thread_Control *executing ) { ISR_Level level; Per_CPU_Control *cpu_self; Thread_Action *action; cpu_self = _Thread_Action_ISR_disable_and_acquire( executing, &level ); action = _Thread_Get_post_switch_action( executing ); while ( action != NULL ) { _Chain_Set_off_chain( &action->Node ); ( *action->handler )( executing, action, cpu_self, level ); cpu_self = _Thread_Action_ISR_disable_and_acquire( executing, &level ); action = _Thread_Get_post_switch_action( executing ); } _Thread_Action_release_and_ISR_enable( cpu_self, level ); }
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(); } } }