void rtems_initialize_data_structures(void) { /* * Dispatching and interrupts are disabled until the end of the * initialization sequence. This prevents an inadvertent context * switch before the executive is initialized. * * WARNING: Interrupts should have been disabled by the BSP and * are disabled by boot_card(). */ #if defined(RTEMS_MULTIPROCESSING) /* * Initialize the system state based on whether this is an MP system. * In an MP configuration, internally we view single processor * systems as a very restricted multiprocessor system. */ _Configuration_MP_table = Configuration.User_multiprocessing_table; if ( _Configuration_MP_table == NULL ) { _Configuration_MP_table = (void *)&_Initialization_Default_multiprocessing_table; _System_state_Handler_initialization( FALSE ); } else { _System_state_Handler_initialization( TRUE ); } #else _System_state_Handler_initialization( FALSE ); #endif /* * Initialize any target architecture specific support as early as possible */ _CPU_Initialize(); #if defined(RTEMS_MULTIPROCESSING) _Objects_MP_Handler_early_initialization(); #endif /* * Do this as early as possible to ensure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); _API_extensions_Initialization(); _Thread_Dispatch_initialization(); /* * Before this is called, we are not allowed to allocate memory * from the Workspace because it is not initialized. */ _Workspace_Handler_initialization(); #if defined(RTEMS_SMP) _SMP_Handler_initialize(); #endif _User_extensions_Handler_initialization(); _ISR_Handler_initialization(); /* * Initialize the internal support API and allocator Mutex */ _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; _API_Mutex_Initialization( 1 ); _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex ); _Priority_bit_map_Handler_initialization(); _Watchdog_Handler_initialization(); _TOD_Handler_initialization(); _Thread_Handler_initialization(); _Scheduler_Handler_initialization(); #if defined(RTEMS_MULTIPROCESSING) _Objects_MP_Handler_initialization(); _MPCI_Handler_initialization( RTEMS_TIMEOUT ); #endif /* MANAGERS */ _RTEMS_API_Initialize(); _Extension_Manager_initialization(); _IO_Manager_initialization(); #ifdef RTEMS_POSIX_API _POSIX_API_Initialize(); #endif /* * Discover and initialize the secondary cores in an SMP system. */ #if defined(RTEMS_SMP) _SMP_Processor_count = bsp_smp_initialize( rtems_configuration_smp_maximum_processors ); #endif _System_state_Set( SYSTEM_STATE_BEFORE_MULTITASKING ); /* * No threads should be created before this point!!! * _Thread_Executing and _Thread_Heir are not set. * * At this point all API extensions are in place. After the call to * _Thread_Create_idle() _Thread_Executing and _Thread_Heir will be set. */ _Thread_Create_idle(); /* * Scheduling can properly occur now as long as we avoid dispatching. */ }
void rtems_initialize_data_structures(void) { _System_state_Handler_initialization( FALSE ); _CPU_Initialize(); /* * Do this as early as possible to ensure no debugging output * is even attempted to be printed. */ _Debug_Manager_initialization(); _API_extensions_Initialization(); _Thread_Dispatch_initialization(); _User_extensions_Handler_initialization(); _ISR_Handler_initialization(); /* * Initialize the internal support API and allocator Mutex */ _Objects_Information_table[OBJECTS_INTERNAL_API] = _Internal_Objects; _API_Mutex_Initialization( 2 ); _API_Mutex_Allocate( &_RTEMS_Allocator_Mutex ); _API_Mutex_Allocate( &_Once_Mutex ); _Watchdog_Handler_initialization(); _TOD_Handler_initialization(); _Thread_Handler_initialization(); _Scheduler_Handler_initialization(); _SMP_Handler_initialize(); _CPU_set_Handler_initialization(); /* MANAGERS */ /* * Install our API Object Management Table and initialize the * various managers. */ _Objects_Information_table[OBJECTS_CLASSIC_API] = _RTEMS_Objects; _RTEMS_tasks_Manager_initialization(); _Semaphore_Manager_initialization(); /* * Install our API Object Management Table and initialize the * various managers. */ _Objects_Information_table[OBJECTS_POSIX_API] = _POSIX_Objects; _POSIX_Key_Manager_initialization(); /* * Discover and initialize the secondary cores in an SMP system. */ _SMP_Handler_initialize(); _System_state_Set( SYSTEM_STATE_BEFORE_MULTITASKING ); /* * No threads should be created before this point!!! * _Thread_Executing and _Thread_Heir are not set. * * At this point all API extensions are in place. After the call to * _Thread_Create_idle() _Thread_Executing and _Thread_Heir will be set. */ _Thread_Create_idle(); /* * Scheduling can properly occur now as long as we avoid dispatching. */ _System_state_Set( SYSTEM_STATE_UP ); _SMP_Request_start_multitasking(); _Thread_Start_multitasking(); /* Add Initialization of the Thread_Dispatch wrapper */ Init__wrap__Thread_Dispatch(); /* * Now we are back in a non-dispatching critical section */ #if defined(RTEMS_SMP) { ISR_Level level; /* * On SMP we enter _Thread_Handler() with interrupts disabled and * _Thread_Dispatch() obtained the per-CPU lock for us. We have to * release it here and set the desired interrupt level of the thread. */ Per_CPU_Control *cpu_self = _Per_CPU_Get(); _Assert( cpu_self->thread_dispatch_disable_level == 1 ); _Assert( _ISR_Get_level() != 0 ); cpu_self->thread_dispatch_disable_level = 0; _Profiling_Thread_dispatch_enable( cpu_self, 0 ); /* For whatever reason, we haven't locked our per cpu yet in the * Scheduler Simulator. Until this is done, this release is not needed. */ /* _Per_CPU_Release( cpu_self ); */ level = _Thread_Executing->Start.isr_level; _ISR_Set_level( level); /* * The thread dispatch level changed from one to zero. Make sure we lose * no thread dispatch necessary update. */ _Thread_Dispatch(); } #else _Thread_Enable_dispatch(); #endif /* * Print an initial message */ check_heir_and_executing(); }