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; }