void _Thread_Set_transient(
Thread_Control *the_thread
)
{
ISR_Level level;
uint32_t old_state;
Chain_Control *ready;
ready = the_thread->ready;
_ISR_Disable( level );
old_state = the_thread->current_state;
the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state );
if ( _States_Is_ready( old_state ) ) {
if ( _Chain_Has_only_one_node( ready ) ) {
_Chain_Initialize_empty( ready );
_Priority_Remove_from_bit_map( &the_thread->Priority_map );
} else
_Chain_Extract_unprotected( &the_thread->Object.Node );
}
_ISR_Enable( level );
}
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;
}
Thread_Control *_Thread_MP_Allocate_proxy (
States_Control the_state
)
{
Thread_Control *the_thread;
Thread_Proxy_control *the_proxy;
the_thread = (Thread_Control *)_Chain_Get( &_Thread_MP_Inactive_proxies );
if ( !_Thread_Is_null( the_thread ) ) {
the_proxy = (Thread_Proxy_control *) the_thread;
_Thread_Executing->Wait.return_code = THREAD_STATUS_PROXY_BLOCKING;
the_proxy->receive_packet = _MPCI_Receive_server_tcb->receive_packet;
the_proxy->Object.id = _MPCI_Receive_server_tcb->receive_packet->source_tid;
the_proxy->current_priority =
_MPCI_Receive_server_tcb->receive_packet->source_priority;
the_proxy->current_state = _States_Set( STATES_DORMANT, the_state );
the_proxy->Wait = _Thread_Executing->Wait;
_Chain_Append( &_Thread_MP_Active_proxies, &the_proxy->Active );
return the_thread;
}
_Internal_error_Occurred(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_OUT_OF_PROXIES
);
/*
* NOTE: The following return ensures that the compiler will
* think that all paths return a value.
*/
return NULL;
}
void _Thread_Set_transient(
Thread_Control *the_thread
)
{
ISR_Level level;
uint32_t old_state;
_ISR_Disable( level );
old_state = the_thread->current_state;
the_thread->current_state = _States_Set( STATES_TRANSIENT, old_state );
if ( _States_Is_ready( old_state ) ) {
_Scheduler_Extract( the_thread );
}
_ISR_Enable( level );
}
uint32_t _MPCI_Send_request_packet (
uint32_t destination,
MP_packet_Prefix *the_packet,
States_Control extra_state
)
{
Thread_Control *executing = _Thread_Executing;
the_packet->source_tid = executing->Object.id;
the_packet->source_priority = executing->current_priority;
the_packet->to_convert =
( the_packet->to_convert - sizeof(MP_packet_Prefix) ) / sizeof(uint32_t);
executing->Wait.id = the_packet->id;
executing->Wait.queue = &_MPCI_Remote_blocked_threads;
_Thread_Disable_dispatch();
(*_MPCI_table->send_packet)( destination, the_packet );
_Thread_queue_Enter_critical_section( &_MPCI_Remote_blocked_threads );
/*
* See if we need a default timeout
*/
if (the_packet->timeout == MPCI_DEFAULT_TIMEOUT)
the_packet->timeout = _MPCI_table->default_timeout;
_Thread_queue_Enqueue(
&_MPCI_Remote_blocked_threads,
executing,
the_packet->timeout
);
executing->current_state =
_States_Set( extra_state, executing->current_state );
_Thread_Enable_dispatch();
return executing->Wait.return_code;
}
void _Thread_Set_state(
Thread_Control *the_thread,
States_Control state
)
{
ISR_Level level;
States_Control current_state;
_ISR_Disable( level );
current_state = the_thread->current_state;
if ( _States_Is_ready( current_state ) ) {
the_thread->current_state = state;
_Scheduler_Block( _Scheduler_Get( the_thread ), the_thread );
} else {
the_thread->current_state = _States_Set( state, current_state);
}
_ISR_Enable( level );
}
void _Thread_Set_state(
Thread_Control *the_thread,
States_Control state
)
{
ISR_Level level;
_ISR_Disable( level );
if ( !_States_Is_ready( the_thread->current_state ) ) {
the_thread->current_state =
_States_Set( state, the_thread->current_state );
_ISR_Enable( level );
return;
}
the_thread->current_state = state;
_Scheduler_Block( the_thread );
_ISR_Enable( level );
}
void _Thread_Suspend(
Thread_Control *the_thread
)
{
ISR_Level level;
Chain_Control *ready;
ready = the_thread->ready;
_ISR_Disable( level );
#if defined(RTEMS_ITRON_API)
the_thread->suspend_count++;
#endif
if ( !_States_Is_ready( the_thread->current_state ) ) {
the_thread->current_state =
_States_Set( STATES_SUSPENDED, the_thread->current_state );
_ISR_Enable( level );
return;
}
the_thread->current_state = STATES_SUSPENDED;
if ( _Chain_Has_only_one_node( ready ) ) {
_Chain_Initialize_empty( ready );
_Priority_Remove_from_bit_map( &the_thread->Priority_map );
} else
_Chain_Extract_unprotected( &the_thread->Object.Node );
_ISR_Flash( level );
if ( _Thread_Is_heir( the_thread ) )
_Thread_Calculate_heir();
if ( _Thread_Is_executing( the_thread ) )
_Context_Switch_necessary = true;
_ISR_Enable( level );
}
void _Thread_Set_state(
Thread_Control *the_thread,
States_Control state
)
{
ISR_Level level;
Chain_Control *ready;
ready = the_thread->ready;
_ISR_Disable( level );
if ( !_States_Is_ready( the_thread->current_state ) ) {
the_thread->current_state =
_States_Set( state, the_thread->current_state );
_ISR_Enable( level );
return;
}
the_thread->current_state = state;
if ( _Chain_Has_only_one_node( ready ) ) {
_Chain_Initialize_empty( ready );
_Priority_Remove_from_bit_map( &the_thread->Priority_map );
} else
_Chain_Extract_unprotected( &the_thread->Object.Node );
_ISR_Flash( level );
if ( _Thread_Is_heir( the_thread ) )
_Thread_Calculate_heir();
if ( _Thread_Is_executing( the_thread ) )
_Context_Switch_necessary = TRUE;
_ISR_Enable( level );
}
Thread_Control *_Thread_MP_Allocate_proxy (
States_Control the_state
)
{
Thread_Proxy_control *the_proxy;
ISR_lock_Context lock_context;
_Thread_MP_Proxies_acquire( &lock_context );
the_proxy = (Thread_Proxy_control *)
_Chain_Get_unprotected( &_Thread_MP_Inactive_proxies );
if ( the_proxy != NULL ) {
Thread_Control *executing;
MP_packet_Prefix *receive_packet;
Objects_Id source_tid;
executing = _Thread_Executing;
receive_packet = _MPCI_Receive_server_tcb->receive_packet;
source_tid = receive_packet->source_tid;
executing->Wait.return_code = THREAD_STATUS_PROXY_BLOCKING;
the_proxy->receive_packet = receive_packet;
the_proxy->Object.id = source_tid;
the_proxy->current_priority = receive_packet->source_priority;
the_proxy->current_state = _States_Set( STATES_DORMANT, the_state );
the_proxy->Wait.count = executing->Wait.count;
the_proxy->Wait.return_argument = executing->Wait.return_argument;
the_proxy->Wait.return_argument_second = executing->Wait.return_argument_second;
the_proxy->Wait.option = executing->Wait.option;
the_proxy->Wait.return_code = executing->Wait.return_code;
the_proxy->Wait.timeout_code = executing->Wait.timeout_code;
the_proxy->thread_queue_callout = _Thread_queue_MP_callout_do_nothing;
_RBTree_Insert_inline(
&_Thread_MP_Active_proxies,
&the_proxy->Active,
&source_tid,
_Thread_MP_Proxy_less
);
_Thread_MP_Proxies_release( &lock_context );
return (Thread_Control *) the_proxy;
}
_Thread_MP_Proxies_release( &lock_context );
_Terminate(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_OUT_OF_PROXIES
);
/*
* NOTE: The following return ensures that the compiler will
* think that all paths return a value.
*/
return NULL;
}
