void _ISR_Handler_initialization( void )
{
_ISR_Nest_level = 0;
#if (CPU_SIMPLE_VECTORED_INTERRUPTS == TRUE)
_ISR_Vector_table = _Workspace_Allocate_or_fatal_error(
sizeof(ISR_Handler_entry) * ISR_NUMBER_OF_VECTORS
);
_CPU_Initialize_vectors();
#endif
#if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE )
{
size_t stack_size = rtems_configuration_get_interrupt_stack_size();
uint32_t max_cpus = rtems_configuration_get_maximum_processors();
uint32_t cpu;
if ( !_Stack_Is_enough( stack_size ) )
_Terminate(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL
);
for ( cpu = 0 ; cpu < max_cpus; ++cpu ) {
Per_CPU_Control *per_cpu = _Per_CPU_Get_by_index( cpu );
void *low = _Workspace_Allocate_or_fatal_error( stack_size );
void *high = _Addresses_Add_offset( low, stack_size );
#if (CPU_STACK_ALIGNMENT != 0)
high = _Addresses_Align_down( high, CPU_STACK_ALIGNMENT );
#endif
per_cpu->interrupt_stack_low = low;
per_cpu->interrupt_stack_high = high;
/*
* Interrupt stack might have to be aligned and/or setup in a specific
* way. Do not use the local low or high variables here since
* _CPU_Interrupt_stack_setup() is a nasty macro that might want to play
* with the real memory locations.
*/
#if defined(_CPU_Interrupt_stack_setup)
_CPU_Interrupt_stack_setup(
per_cpu->interrupt_stack_low,
per_cpu->interrupt_stack_high
);
#endif
}
}
#endif
#if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE )
_CPU_Install_interrupt_stack();
#endif
}
void _ISR_Handler_initialization( void )
{
_ISR_Nest_level = 0;
#if (CPU_SIMPLE_VECTORED_INTERRUPTS == TRUE)
_ISR_Vector_table = _Workspace_Allocate_or_fatal_error(
sizeof(ISR_Handler_entry) * ISR_NUMBER_OF_VECTORS
);
_CPU_Initialize_vectors();
#endif
#if ( CPU_ALLOCATE_INTERRUPT_STACK == TRUE )
{
size_t stack_size = rtems_configuration_get_interrupt_stack_size();
if ( !_Stack_Is_enough( stack_size ) )
_Internal_error_Occurred(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_INTERRUPT_STACK_TOO_SMALL
);
_CPU_Interrupt_stack_low = _Workspace_Allocate_or_fatal_error(
stack_size
);
_CPU_Interrupt_stack_high = _Addresses_Add_offset(
_CPU_Interrupt_stack_low,
stack_size
);
}
#if (CPU_STACK_ALIGNMENT != 0)
_CPU_Interrupt_stack_high = (void *)
((uintptr_t) _CPU_Interrupt_stack_high & ~(CPU_STACK_ALIGNMENT - 1));
#endif
/* Interrupt stack might have to be aligned and/or setup
* in a specific way.
*/
#if defined(_CPU_Interrupt_stack_setup)
_CPU_Interrupt_stack_setup(_CPU_Interrupt_stack_low, _CPU_Interrupt_stack_high);
#endif
#endif
#if ( CPU_HAS_HARDWARE_INTERRUPT_STACK == TRUE )
_CPU_Install_interrupt_stack();
#endif
}
void _SMP_Handler_initialize(void)
{
int cpu;
size_t size;
uintptr_t ptr;
/*
* Initialize per CPU structures.
*/
size = (_SMP_Processor_count) * sizeof(Per_CPU_Control);
memset( _Per_CPU_Information, '\0', size );
/*
* Initialize per cpu pointer table
*/
size = Configuration.interrupt_stack_size;
_Per_CPU_Information_p[0] = &_Per_CPU_Information[0];
for (cpu=1 ; cpu < rtems_configuration_smp_maximum_processors; cpu++ ) {
Per_CPU_Control *p = &_Per_CPU_Information[cpu];
_Per_CPU_Information_p[cpu] = p;
p->interrupt_stack_low = _Workspace_Allocate_or_fatal_error( size );
ptr = (uintptr_t) _Addresses_Add_offset( p->interrupt_stack_low, size );
ptr &= ~(CPU_STACK_ALIGNMENT - 1);
p->interrupt_stack_high = (void *)ptr;
p->state = RTEMS_BSP_SMP_CPU_INITIAL_STATE;
RTEMS_COMPILER_MEMORY_BARRIER();
}
}
void _Scheduler_simple_Initialize ( void )
{
Scheduler_simple_Control *scheduler =
_Workspace_Allocate_or_fatal_error( sizeof( *scheduler ) );
_Chain_Initialize_empty( &scheduler->Ready );
_Scheduler.information = scheduler;
}
void _Scheduler_simple_smp_Initialize( void )
{
Scheduler_simple_smp_Control *self =
_Workspace_Allocate_or_fatal_error( sizeof( *self ) );
_Chain_Initialize_empty( &self->ready );
_Chain_Initialize_empty( &self->scheduled );
_Scheduler.information = self;
}
void _Scheduler_priority_SMP_Initialize( void )
{
Scheduler_SMP_Control *self = _Workspace_Allocate_or_fatal_error(
sizeof( *self ) + PRIORITY_MAXIMUM * sizeof( Chain_Control )
);
_Chain_Initialize_empty( &self->scheduled );
_Scheduler_priority_Ready_queue_initialize( &self->ready[ 0 ] );
_Scheduler.information = self;
}
void _POSIX_signals_Manager_Initialization(void)
{
uint32_t signo;
uint32_t maximum_queued_signals;
maximum_queued_signals = Configuration_POSIX_API.maximum_queued_signals;
memcpy(
_POSIX_signals_Vectors,
_POSIX_signals_Default_vectors,
sizeof( _POSIX_signals_Vectors )
);
/*
* Initialize the set of pending signals for the entire process
*/
sigemptyset( &_POSIX_signals_Pending );
/*
* Initialize the queue we use to block for signals
*/
_Thread_queue_Initialize(
&_POSIX_signals_Wait_queue,
THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_SIGNAL | STATES_INTERRUPTIBLE_BY_SIGNAL,
EAGAIN
);
/* XXX status codes */
/*
* Allocate the siginfo pools.
*/
for ( signo=1 ; signo<= SIGRTMAX ; signo++ )
_Chain_Initialize_empty( &_POSIX_signals_Siginfo[ signo ] );
if ( maximum_queued_signals ) {
_Chain_Initialize(
&_POSIX_signals_Inactive_siginfo,
_Workspace_Allocate_or_fatal_error(
maximum_queued_signals * sizeof( POSIX_signals_Siginfo_node )
),
maximum_queued_signals,
sizeof( POSIX_signals_Siginfo_node )
);
} else {
_Chain_Initialize_empty( &_POSIX_signals_Inactive_siginfo );
}
}
void _IO_Manager_initialization(void)
{
uint32_t index;
rtems_driver_address_table *driver_table;
uint32_t drivers_in_table;
uint32_t number_of_drivers;
driver_table = Configuration.Device_driver_table;
drivers_in_table = Configuration.number_of_device_drivers;
number_of_drivers = Configuration.maximum_drivers;
/*
* If the user claims there are less drivers than are actually in
* the table, then let's just go with the table's count.
*/
if ( number_of_drivers <= drivers_in_table )
number_of_drivers = drivers_in_table;
/*
* If the maximum number of driver is the same as the number in the
* table, then we do not have to copy the driver table. They can't
* register any dynamically.
*/
if ( number_of_drivers == drivers_in_table ) {
_IO_Driver_address_table = driver_table;
_IO_Number_of_drivers = number_of_drivers;
return;
}
/*
* The application requested extra slots in the driver table, so we
* have to allocate a new driver table and copy theirs to it.
*/
_IO_Driver_address_table = (rtems_driver_address_table *)
_Workspace_Allocate_or_fatal_error(
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
_IO_Number_of_drivers = number_of_drivers;
memset(
_IO_Driver_address_table, 0,
sizeof( rtems_driver_address_table ) * ( number_of_drivers )
);
for ( index = 0 ; index < drivers_in_table ; index++ )
_IO_Driver_address_table[index] = driver_table[index];
}
void _SMP_Handler_initialize(void)
{
uint32_t max_cpus = rtems_configuration_get_maximum_processors();
uint32_t cpu;
/*
* Initialize per cpu pointer table
*/
_Per_CPU_Information_p[0] = _Per_CPU_Get_by_index( 0 );
for ( cpu = 1 ; cpu < max_cpus; ++cpu ) {
Per_CPU_Control *p = _Per_CPU_Get_by_index( cpu );
_Per_CPU_Information_p[cpu] = p;
#if CPU_ALLOCATE_INTERRUPT_STACK == TRUE
{
size_t size = rtems_configuration_get_interrupt_stack_size();
uintptr_t ptr;
p->interrupt_stack_low = _Workspace_Allocate_or_fatal_error( size );
ptr = (uintptr_t) _Addresses_Add_offset( p->interrupt_stack_low, size );
ptr &= ~(CPU_STACK_ALIGNMENT - 1);
p->interrupt_stack_high = (void *)ptr;
}
#endif
}
/*
* Discover and initialize the secondary cores in an SMP system.
*/
max_cpus = bsp_smp_initialize( max_cpus );
_SMP_Processor_count = max_cpus;
for ( cpu = 1 ; cpu < max_cpus; ++cpu ) {
const Per_CPU_Control *per_cpu = _Per_CPU_Get_by_index( cpu );
_Per_CPU_Wait_for_state(
per_cpu,
PER_CPU_STATE_READY_TO_BEGIN_MULTITASKING
);
}
}
static void _POSIX_Keys_Initialize_keypool( void )
{
Freechain_Control *keypool = &_POSIX_Keys_Keypool;
size_t initial_count = _POSIX_Keys_Get_initial_keypool_size();
_Freechain_Initialize( keypool, _POSIX_Keys_Keypool_extend );
if ( initial_count > 0 ) {
size_t size = initial_count * sizeof( POSIX_Keys_Key_value_pair );
POSIX_Keys_Key_value_pair *nodes =
_Workspace_Allocate_or_fatal_error( size );
_Chain_Initialize(
&keypool->Freechain,
nodes,
initial_count,
sizeof( *nodes )
);
}
}
void _Thread_MP_Handler_initialization (
uint32_t maximum_proxies
)
{
_Chain_Initialize_empty( &_Thread_MP_Active_proxies );
if ( maximum_proxies == 0 ) {
_Chain_Initialize_empty( &_Thread_MP_Inactive_proxies );
return;
}
_Chain_Initialize(
&_Thread_MP_Inactive_proxies,
_Workspace_Allocate_or_fatal_error(
maximum_proxies * sizeof( Thread_Proxy_control )
),
maximum_proxies,
sizeof( Thread_Proxy_control )
);
}
void _Thread_MP_Handler_initialization (
uint32_t maximum_proxies
)
{
size_t proxy_size;
size_t alloc_size;
char *proxies;
uint32_t i;
if ( maximum_proxies == 0 ) {
return;
}
proxy_size = sizeof( Thread_Proxy_control )
+ THREAD_QUEUE_HEADS_SIZE( _Scheduler_Count );
alloc_size = maximum_proxies * proxy_size;
proxies = _Workspace_Allocate_or_fatal_error( alloc_size );
memset( proxies, 0, alloc_size );
_Chain_Initialize(
&_Thread_MP_Inactive_proxies,
proxies,
maximum_proxies,
proxy_size
);
for ( i = 0 ; i < maximum_proxies ; ++i ) {
Thread_Proxy_control *proxy;
proxy = (Thread_Proxy_control *) ( proxies + i * proxy_size );
_Thread_Timer_initialize( &proxy->Timer, _Per_CPU_Get_by_index( 0 ) );
proxy->Wait.spare_heads = &proxy->Thread_queue_heads[ 0 ];
_Thread_queue_Heads_initialize( proxy->Wait.spare_heads );
}
}
void _Objects_MP_Handler_initialization(void)
{
uint32_t maximum_global_objects;
maximum_global_objects = _Configuration_MP_table->maximum_global_objects;
_Objects_MP_Maximum_global_objects = maximum_global_objects;
if ( maximum_global_objects == 0 ) {
_Chain_Initialize_empty( &_Objects_MP_Inactive_global_objects );
return;
}
_Chain_Initialize(
&_Objects_MP_Inactive_global_objects,
_Workspace_Allocate_or_fatal_error(
maximum_global_objects * sizeof( Objects_MP_Control )
),
maximum_global_objects,
sizeof( Objects_MP_Control )
);
}
void _Objects_Extend_information(
Objects_Information *information
)
{
Objects_Control *the_object;
Chain_Control Inactive;
uint32_t block_count;
uint32_t block;
uint32_t index_base;
uint32_t minimum_index;
uint32_t index;
uint32_t maximum;
size_t block_size;
void *new_object_block;
bool do_extend;
/*
* Search for a free block of indexes. If we do NOT need to allocate or
* extend the block table, then we will change do_extend.
*/
do_extend = true;
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
if ( information->object_blocks[ block ] == NULL ) {
do_extend = false;
break;
} else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
return;
}
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
}
/*
* Do we need to grow the tables?
*/
if ( do_extend ) {
ISR_Level level;
void **object_blocks;
uint32_t *inactive_per_block;
Objects_Control **local_table;
void *old_tables;
size_t block_size;
/*
* Growing the tables means allocating a new area, doing a copy and
* updating the information table.
*
* If the maximum is minimum we do not have a table to copy. First
* time through.
*
* The allocation has :
*
* void *objects[block_count];
* uint32_t inactive_count[block_count];
* Objects_Control *local_table[maximum];
*
* This is the order in memory. Watch changing the order. See the memcpy
* below.
*/
/*
* Up the block count and maximum
*/
block_count++;
/*
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
return;
}
/*
* Break the block into the various sections.
*/
inactive_per_block = (uint32_t *) _Addresses_Add_offset(
object_blocks, block_count * sizeof(void*) );
local_table = (Objects_Control **) _Addresses_Add_offset(
inactive_per_block, block_count * sizeof(uint32_t) );
/*
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
information->local_table,
(information->maximum + minimum_index) * sizeof(Objects_Control *) );
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
local_table[ index ] = NULL;
}
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
information->the_api,
information->the_class,
_Objects_Local_node,
information->maximum
);
_ISR_Enable( level );
_Workspace_Free( old_tables );
block_count++;
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
&Inactive,
information->object_blocks[ block ],
information->allocation_size,
information->size
);
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
the_object->id = _Objects_Build_id(
information->the_api,
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
information->inactive =
(Objects_Maximum)(information->inactive + information->allocation_size);
}
void _Objects_Initialize_information(
Objects_Information *information,
Objects_APIs the_api,
uint32_t the_class,
uint32_t maximum,
uint16_t size,
bool is_string,
uint32_t maximum_name_length
#if defined(RTEMS_MULTIPROCESSING)
,
bool supports_global,
Objects_Thread_queue_Extract_callout extract
#endif
)
{
static Objects_Control *null_local_table = NULL;
uint32_t minimum_index;
uint32_t name_length;
uint32_t maximum_per_allocation;
#if defined(RTEMS_MULTIPROCESSING)
uint32_t index;
#endif
information->the_api = the_api;
information->the_class = the_class;
information->size = size;
information->local_table = 0;
information->inactive_per_block = 0;
information->object_blocks = 0;
information->inactive = 0;
#if defined(RTEMS_SCORE_OBJECT_ENABLE_STRING_NAMES)
information->is_string = is_string;
#endif
/*
* Set the maximum value to 0. It will be updated when objects are
* added to the inactive set from _Objects_Extend_information()
*/
information->maximum = 0;
/*
* Register this Object Class in the Object Information Table.
*/
_Objects_Information_table[ the_api ][ the_class ] = information;
/*
* Are we operating in limited or unlimited (e.g. auto-extend) mode.
*/
information->auto_extend =
(maximum & OBJECTS_UNLIMITED_OBJECTS) ? true : false;
maximum_per_allocation = maximum & ~OBJECTS_UNLIMITED_OBJECTS;
/*
* Unlimited and maximum of zero is illogical.
*/
if ( information->auto_extend && maximum_per_allocation == 0) {
_Internal_error_Occurred(
INTERNAL_ERROR_CORE,
true,
INTERNAL_ERROR_UNLIMITED_AND_MAXIMUM_IS_0
);
}
/*
* The allocation unit is the maximum value
*/
information->allocation_size = maximum_per_allocation;
/*
* Provide a null local table entry for the case of any empty table.
*/
information->local_table = &null_local_table;
/*
* Calculate minimum and maximum Id's
*/
minimum_index = (maximum_per_allocation == 0) ? 0 : 1;
information->minimum_id =
_Objects_Build_id( the_api, the_class, _Objects_Local_node, minimum_index );
/*
* Calculate the maximum name length
*/
name_length = maximum_name_length;
if ( name_length & (OBJECTS_NAME_ALIGNMENT-1) )
name_length = (name_length + OBJECTS_NAME_ALIGNMENT) &
~(OBJECTS_NAME_ALIGNMENT-1);
information->name_length = name_length;
_Chain_Initialize_empty( &information->Inactive );
/*
* Initialize objects .. if there are any
*/
if ( maximum_per_allocation ) {
/*
* Always have the maximum size available so the current performance
* figures are create are met. If the user moves past the maximum
* number then a performance hit is taken.
*/
_Objects_Extend_information( information );
}
/*
* Take care of multiprocessing
*/
#if defined(RTEMS_MULTIPROCESSING)
information->extract = extract;
if ( (supports_global == true) && _System_state_Is_multiprocessing ) {
information->global_table =
(Chain_Control *) _Workspace_Allocate_or_fatal_error(
(_Objects_Maximum_nodes + 1) * sizeof(Chain_Control)
);
for ( index=1; index <= _Objects_Maximum_nodes ; index++ )
_Chain_Initialize_empty( &information->global_table[ index ] );
}
else
information->global_table = NULL;
#endif
}
void _POSIX_signals_Manager_Initialization(void)
{
uint32_t signo;
uint32_t maximum_queued_signals;
maximum_queued_signals = Configuration_POSIX_API.maximum_queued_signals;
/*
* Ensure we have the same number of vectors and default vector entries
*/
#if defined(RTEMS_DEBUG)
assert(
sizeof(_POSIX_signals_Vectors) == sizeof(_POSIX_signals_Default_vectors)
);
#endif
memcpy(
_POSIX_signals_Vectors,
_POSIX_signals_Default_vectors,
sizeof( _POSIX_signals_Vectors )
);
/*
* Initialize the set of pending signals for the entire process
*/
sigemptyset( &_POSIX_signals_Pending );
/*
* Initialize the queue we use to block for signals
*/
_Thread_queue_Initialize(
&_POSIX_signals_Wait_queue,
THREAD_QUEUE_DISCIPLINE_FIFO,
STATES_WAITING_FOR_SIGNAL | STATES_INTERRUPTIBLE_BY_SIGNAL,
EAGAIN
);
/* XXX status codes */
/*
* Allocate the siginfo pools.
*/
for ( signo=1 ; signo<= SIGRTMAX ; signo++ )
_Chain_Initialize_empty( &_POSIX_signals_Siginfo[ signo ] );
if ( maximum_queued_signals ) {
_Chain_Initialize(
&_POSIX_signals_Inactive_siginfo,
_Workspace_Allocate_or_fatal_error(
maximum_queued_signals * sizeof( POSIX_signals_Siginfo_node )
),
maximum_queued_signals,
sizeof( POSIX_signals_Siginfo_node )
);
} else {
_Chain_Initialize_empty( &_POSIX_signals_Inactive_siginfo );
}
/*
* Initialize the Alarm Timer
*/
_Watchdog_Initialize( &_POSIX_signals_Alarm_timer, NULL, 0, NULL );
_Watchdog_Initialize( &_POSIX_signals_Ualarm_timer, NULL, 0, NULL );
}
