Changeset 624 for trunk/boot


Ignore:
Timestamp:
Mar 12, 2019, 1:37:38 PM (5 years ago)
Author:
alain
Message:

Fix several bugs to use the instruction MMU in kernel mode
in replacement of the instruction address extension register,
and remove the "kentry" segment.

This version is running on the tsar_generic_iob" platform.

One interesting bug: the cp0_ebase defining the kernel entry point
(for interrupts, exceptions and syscalls) must be initialized
early in kernel_init(), because the VFS initialisation done by
kernel_ini() uses RPCs, and RPCs uses Inter-Processor-Interrup.

Location:
trunk/boot/tsar_mips32
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/boot/tsar_mips32/Makefile

    r572 r624  
    1313# always out-of-date, need to be regenerated everytime they are called
    1414.PHONY: compile                         \
    15         ../../hard_config.h           \
     15        ../../hard_config.h     \
    1616                dirs                                \
    17                 build/boot.elf      \
    18 
    19 # Macros to be processed by the C preprocessor.
    20 MACROS           = -DARCHINFO_PATHNAME="\"arch_info.bin\""              \
    21                            -DKERNEL_PATHNAME="\"/bin/kernel/kernel.elf\""
     17                build/boot.elf     
    2218
    2319# Objects to be linked for boot.elf generation

  • trunk/boot/tsar_mips32/boot.c

    r623 r624  
    2525/****************************************************************************
    2626 * This file contains the ALMOS-MKH. boot-loader for the TSAR architecture. *
    27  *                                                                          *
    28  * It supports a clusterised, shared memory, multi-processor architecture,  *
     27 * that is a clusterised, shared memory, multi-processor architecture,      *
    2928 * where each processor core is identified by a composite index [cxy,lid]   *
    3029 * with one physical memory bank per cluster.                               *
    … …  
    8685// the Boot Page Table contains two PTE1, and should be aligned on 8 Kbytes
    8786
    88 uint32_t                        boot_pt[2] __attribute__((aligned(2048)));
     87uint32_t                        boot_pt[2] __attribute__((aligned(0x2000)));
    8988
    9089// synchronization variables.
    … …  
    101100uint32_t                        seg_kdata_base;   // kdata segment base address
    102101uint32_t                        seg_kdata_size;   // kdata segment size (bytes)
    103 uint32_t                        seg_kentry_base;  // kcode segment base address
    104 uint32_t                        seg_kentry_size;  // kcode segment size (bytes)
    105 
    106 uint32_t                        kernel_entry;    // kernel entry point
     102
     103uint32_t                        kernel_entry;     // kernel_init() function
    107104
    108105// Functions
    … …  
    147144static void boot_archinfo_load( void )
    148145{
    149     archinfo_header_t* header = (archinfo_header_t*)ARCHINFO_BASE; 
     146    archinfo_header_t * header = (archinfo_header_t*)ARCHINFO_BASE; 
    150147   
    151148    // Load file into memory
    152149    if (boot_fat32_load(ARCHINFO_PATHNAME, ARCHINFO_BASE, ARCHINFO_MAX_SIZE))
    153150    {
    154         boot_printf("\n[BOOT ERROR]: boot_archinfo_load(): "
    155         "<%s> file not found\n",
    156         ARCHINFO_PATHNAME);
     151        boot_printf("\n[BOOT ERROR]in %s : <%s> file not found\n",
     152        __FUNCTION__, ARCHINFO_PATHNAME);
    157153        boot_exit();
    158154    }
    … …  
    175171/**************************************************************************************
    176172 * This function loads the 'kernel.elf' file into the boot cluster memory buffer,
    177  * analyzes it, and places the three kcode, kentry, kdata segments at their final
    178  * physical adresses (defined the .elf file).       
    179  * It set the global variables defining the kernel layout.
     173 * analyzes it, and places the kcode and kdata segments at their final physical
     174 * adresses (defined the .elf file), and set the kernel layout global variables.
    180175 *************************************************************************************/
    181176static void boot_kernel_load( void )
    … …  
    192187    bool_t       kcode_found;     // kcode segment found.
    193188    bool_t       kdata_found;     // kdata segment found.
    194     bool_t       kentry_found;    // kentry segment found.
    195189    uint32_t     seg_id;          // iterator for segments loop.
    196190
    … …  
    233227    kcode_found  = false;
    234228    kdata_found  = false;
    235     kentry_found = false;
    236229    for (seg_id = 0; seg_id < segments_nb; seg_id++)
    237230    {
    … …  
    265258
    266259            // Note: we suppose that the 'kernel.elf' file contains exactly
    267             // three loadable segments ktext, kentry, & kdata:
    268             // - the kcode segment is read-only and base == KCODE_BASE
    269             // - the kentry segment is read-only and base == KENTRY_BASE
    270 
    271             if( ((program_header[seg_id].p_flags & PF_W) == 0) &&
    272                  (program_header[seg_id].p_paddr == KCODE_BASE) )     // kcode segment
     260            // two loadable segments : kcode & kdata
     261
     262            if( program_header[seg_id].p_paddr == KCODE_BASE )     // kcode segment
    273263            {
    274264                if( kcode_found )
    … …  
    283273                seg_kcode_base = seg_paddr;
    284274                seg_kcode_size = seg_memsz;
    285             }
    286             else if( program_header[seg_id].p_paddr == KENTRY_BASE ) // kentry segment
    287             {
    288                 if( kentry_found )
    289                 {
    290                     boot_printf("\n[BOOT_ERROR] in %s for file %s :\n"
    291                     "   two kentry segments found\n",
    292                     __FUNCTION__ , KERNEL_PATHNAME );
    293                     boot_exit();
    294                 }
    295 
    296                 kentry_found     = true;
    297                 seg_kentry_base = seg_paddr;
    298                 seg_kentry_size = seg_memsz;
    299275            }
    300276            else                                                    // kdata segment
    … …  
    322298        boot_exit();
    323299    }
    324     if( kentry_found == false )
    325     {
    326         boot_printf("\n[BOOT_ERROR] in %s for file %s : seg_kentry not found\n",
    327         __FUNCTION__ , KERNEL_PATHNAME );
    328         boot_exit();
    329     }
    330300    if( kdata_found == false )
    331301    {
    … …  
    336306
    337307    // check segments sizes
    338     if( seg_kentry_size > KENTRY_MAX_SIZE )
    339     {
    340         boot_printf("\n[BOOT_ERROR] in %s for file %s : seg_kentry too large\n",
    341         __FUNCTION__ , KERNEL_PATHNAME );
    342         boot_exit();
    343     }
    344 
    345308    if( (seg_kcode_size + seg_kdata_size) > KCODE_MAX_SIZE )
    346309    {
    … …  
    386349    boot_device_t      * boot_dev;
    387350
    388     // get pointer on ARCHINFO header  and on the four arch_info arrays
     351 #if DEBUG_BOOT_INFO
     352boot_printf("\n[BOOT INFO] %s : enter at cycle %d\n",
     353__FUNCTION__ , boot_get_proctime() );
     354#endif
     355
     356   // get pointer on ARCHINFO header  and on the four arch_info arrays
    389357    header       = (archinfo_header_t*)ARCHINFO_BASE;
    390358    core_base    = archinfo_get_core_base   (header);
    … …  
    406374    boot_info->kdata_base  = seg_kdata_base;
    407375    boot_info->kdata_size  = seg_kdata_size;
    408     boot_info->kentry_base = seg_kentry_base;
    409     boot_info->kentry_size = seg_kentry_size;
    410376
    411377    // loop on arch_info clusters to build cluster_info[][] array
    … …  
    806772        if (cxy == 0)
    807773        {
    808             boot_printf("\n[BOOT] core[%x,%d] enters at cycle %d\n",
    809                         cxy , lid , boot_get_proctime() );
     774            boot_printf("\n[BOOT] core[%x,%d] active at cycle %d\n",
     775            cxy, lid, boot_get_proctime() );
    810776
    811777            // Initialize IOC driver
    … …  
    858824            boot_check_core(boot_info, lid);
    859825
    860 // TO BE DONE
    861 // core[0][0] identity maps two big pages for the boot and kernel code,
    862 // boot_page_table_init( 0 );
    863 
    864 // TO BE DONE
    865 // core[0][0] activates the instruction MMU to use the local copy of boot code
    866 // boot_activate_ins_mmu( 0 );
     826            // identity maps two big pages for the boot and kernel code,
     827            boot_page_table_init( 0 );
     828
     829            // activate the instruction MMU to use the local copy of boot code
     830            boot_activate_ins_mmu( 0 );
    867831
    868832            // Activate other core[cxy][0] / get number of activated cores
    … …  
    889853            // but all cores must access the code stored in cluster 0
    890854
    891             // Each CP0 copies the boot code (data and instructions)
     855#if DEBUG_BOOT_MULTI
     856boot_printf("\n[BOOT] core[%x,%d] active at cycle %d\n",
     857cxy, lid, boot_get_proctime() );
     858#endif
     859            // Each core[cxy][0] copies the boot code (data and instructions)
    892860            // from the cluster 0 to the local cluster.
    893861            boot_remote_memcpy( XPTR( cxy           , BOOT_BASE ),
    … …  
    899867            cxy , lid , boot_get_proctime() );
    900868
    901 // TO BE DONE
    902 // Each core identity maps two big pages for the boot and kernel code,
    903 // boot_page_table_init( cxy );
    904 
    905 // Each core activates the instruction MMU to use the local copy of boot code
    906 // boot_activate_ins_mmu( cxy );
     869            // identity maps two big pages for the boot and kernel code,
     870            boot_page_table_init( cxy );
     871
     872            // activate the instruction MMU to use the local copy of boot code
     873            boot_activate_ins_mmu( cxy );
    907874
    908875            // Each CP0 copies the arch_info.bin into the local memory.
    … …  
    914881            cxy , lid , boot_get_proctime() );
    915882
    916             // Each CP0 copies the kcode segment into local memory
     883            // copy the kcode segment into local memory
    917884            boot_remote_memcpy( XPTR( cxy           , seg_kcode_base ),
    918885                                XPTR( BOOT_CORE_CXY , seg_kcode_base ),
    … …  
    924891                                seg_kdata_size );
    925892
    926             // [TO BE REMOVED<D-°>
    927             // Each CP0 copies the kentry segment into local memory
    928             boot_remote_memcpy( XPTR( cxy           , seg_kentry_base ),
    929                                 XPTR( BOOT_CORE_CXY , seg_kentry_base ),
    930                                 seg_kentry_size );
    931 
    932893            boot_printf("\n[BOOT] core[%x,%d] replicated kernel code at cycle %d\n",
    933894            cxy , lid , boot_get_proctime() );
    … …  
    965926         **********************************************************************/
    966927
    967 // TO BE DONE
    968 // each core activate the instruction MMU to use the local copy of the boot code
    969 // boot_activate_ins_mmu( cxy );
     928#if DEBUG_BOOT_MULTI
     929boot_printf("\n[BOOT] core[%x,%d] active at cycle %d\n",
     930cxy, lid, boot_get_proctime() );
     931#endif
     932        // activate the instruction MMU to use the local copy of the boot code
     933        boot_activate_ins_mmu( cxy );
    970934
    971935        // Get local boot_info_t structure base address.
    … …  
    979943    }
    980944
    981     // the "kernel_entry" global variable, set by boot_kernel_load() define
    982     // the adress of the kernel_init() function.
     945    // All cores enter the kernel_init() function. The address is contained in
     946    // the "kernel_entry" global variable, set by boot_kernel_load() function.
    983947    // Each core initialise the following registers before jumping to kernel:
    984948    // - gr_29    : stack pointer / kernel stack allocated in idle thread descriptor,
    985949    // - c0_sr    : status register / reset BEV bit
    986950    // - gr_04    : kernel_init() argument / pointer on boot_info structure
    987     // - c0_ebase : kentry_base
    988 
    989     // compute "sp" from base address of idle thread descriptors array and lid.
    990951    // The array of idle-thread descriptors is allocated in the kdata segment,
    991952    // just after the boot_info structure.
     953
     954#if DEBUG_BOOT_MULTI
     955boot_printf("\n[BOOT] core[%x,%d] jump to kernel_init = %x at cycle %d\n",
     956cxy, lid, __FUNCTION__, kernel_entry, boot_get_proctime() );
     957#endif
     958
    992959    uint32_t base;
    993960    uint32_t offset = sizeof( boot_info_t );
    … …  
    998965    uint32_t sp = base + ((lid + 1) * CONFIG_THREAD_DESC_SIZE) - 16;
    999966
    1000     // get "ebase" from kerneL_info
    1001     uint32_t ebase = boot_info->kentry_base;
    1002 
    1003 // TO BE DONE
    1004 // The cp0_ebase will not be set by the assenbly code below
    1005 // when the kentry segment will be removed => done in kernel init
    1006 
    1007967    asm volatile( "mfc0  $27,  $12           \n"
    1008968                  "lui   $26,  0xFFBF        \n"
    … …  
    1012972                  "move  $4,   %0            \n"
    1013973                  "move  $29,  %1            \n"
    1014                   "mtc0  %2,   $15,  1       \n"
    1015                   "jr    %3                  \n"
     974                  "jr    %2                  \n"
    1016975                  :
    1017976                  : "r"(boot_info) ,
    1018977                    "r"(sp) ,
    1019                     "r"(ebase) ,
    1020978                    "r"(kernel_entry)
    1021979                  : "$26" , "$27" , "$29" , "$4" );

  • trunk/boot/tsar_mips32/boot.ld

    r610 r624  
    66/* define the boot code base address */
    77
    8 boot_code_base = 0x100000;
     8boot_code_base = 0x200000;
    99
    1010/* Set the entry point of the boot-loader */
    … …  
    1818{
    1919    . = boot_code_base;
    20     .text :
     20    .code :
    2121    {
    2222        *(.text)
    … …  
    2727    {
    2828        *(.data*)
    29     }
    30     .bss :
    31     {
    3229        *(.bss)
     30        *(.scommon)
    3331    }
    3432}

  • trunk/boot/tsar_mips32/boot_config.h

    r572 r624  
    77
    88// Debug options
     9#define DEBUG_BOOT_MULTI    0       
    910#define DEBUG_BOOT_INFO     0
    1011#define DEBUG_BOOT_ELF      0
    … …  
    1314#define DEBUG_BOOT_FAT32    0
    1415
    15 // Core identifier format
    16 #define USE_FIXED_FORMAT    1
     16// Boot cluster definition
     17#define BOOT_CLUSTER_CXY    0
    1718
    1819// cache line
    1920#define CACHE_LINE_SIZE     64
    2021
    21 // Preloader temporary segment
     22// paths for kernel.elf and arch_info.bin files
     23#define ARCHINFO_PATHNAME   "arch_info.bin"
     24#define KERNEL_PATHNAME     "bin/kernel/kernel.elf"
     25
     26// Preloader segment
    2227#define PRELOADER_BASE      0x00000000      // 'preloader' physical base address
    2328#define PRELOADER_MAX_SIZE  0x00004000      // 'preloader' max size
    2429
    25 // kentry segment
    26 #define KENTRY_BASE         0x00004000      // 'kentry' segment physical base address       
    27 #define KENTRY_MAX_SIZE     0x00004000      // 'kentry' segment max size
    28 
    2930// kcode segment
    30 #define KCODE_BASE          0x00008000      // 'kcode' segment physical base address
    31 #define KCODE_MAX_SIZE      0x000F8000      // 'kcode' + 'kdata' segments max size
     31#define KCODE_BASE          0x00004000      // 'kcode' segment physical base address
     32#define KCODE_MAX_SIZE      0x000FC000      // 'kcode' + 'kdata' segments max size
    3233
    3334// boot.elf file temporary buffer
    34 #define BOOT_BASE           0x00100000      // 'boot.elf' file physical base address   
    35 #define BOOT_MAX_SIZE       0x00010000      // 'boot.elf' file max size
     35#define BOOT_BASE           0x00200000      // 'boot.elf' file physical base address   
     36#define BOOT_MAX_SIZE       0x00010000      // 'boot.elf' file max size (64 Kbytes)
    3637
    3738// arch_info file temporary buffer
    38 #define ARCHINFO_BASE       0x00200000      // 'arch_info.bin' file physical base address
    39 #define ARCHINFO_MAX_SIZE   0x00010000      // 'arch_info.bin' file max size
     39#define ARCHINFO_BASE       0x00300000      // 'arch_info.bin' file physical base address
     40#define ARCHINFO_MAX_SIZE   0x00010000      // 'arch_info.bin' file max size (64 Kbytes)
    4041
    4142// kernel.elf file temporary buffer
    42 #define KERN_BASE           0x00300000      // 'kernel.elf' file base address
     43#define KERN_BASE           0x00400000      // 'kernel.elf' file base address
    4344#define KERN_MAX_SIZE       0x00200000      // 'kernel.elf' file max size
    4445
    4546// Temporary stacks segments
    46 #define BOOT_STACK_BASE     0x00504000      // Boot stack base address
     47#define BOOT_STACK_BASE     0x00600000      // Boot stack base address
    4748#define BOOT_STACK_SIZE     0x00004000      // Boot stack size (16Kb)
    4849
Note: See TracChangeset for help on using the changeset viewer.