Changeset 165 for soft/giet_vm/boot


Ignore:
Timestamp:
Jul 4, 2012, 2:51:18 PM (12 years ago)
Author:
alain
Message:

Introducing various modifications in kernel initialisation

Location:
soft/giet_vm/boot
Files:
1 deleted
2 edited

Legend:

Unmodified
Added
Removed
  • soft/giet_vm/boot/boot_handler.c

    r163 r165  
    66///////////////////////////////////////////////////////////////////////////////////
    77// The boot_handler.h and boot_handler.c files are part of the GIET nano-kernel.
    8 // This code can be used in the boot phase to build all the pages tables then jumps
    9 // in to the seg_kernel_init segment with an activated MMU.
     8// This code is executed in the boot phase by proc0 to build  all the pages tables,
     9// then jump in the seg_kernel_init segment with an activated MMU.
    1010//
    11 // It uses the SoCLib generic MMU (paged virtual memory) to provide two services:
    12 //
     11// The SoCLib generic MMU (paged virtual memory) provides two services:
    1312// 1) classical memory protection, when several independant applications compiled
    1413//    in different virtual spaces are executing on the same hardware platform.
     
    1615//    of the software objects (virtual segments) on the physical memory banks.
    1716//
    18 // It uses the MAPPING_INFO binary data structures, that must be pre-loaded in the
    19 // boot ROM in the seg_boot_mapping segment (at address seg_mapping_base).
     17// The boot code uses the MAPPING_INFO binary data structures, that must be pre-loaded
     18// in the the seg_boot_mapping segment (at address seg_mapping_base).
    2019// This MAPPING_INFO data structure defines both the hardware architecture,
    2120// and the mapping:
     
    3231// As most applications use only a limited number of segments, the number of PT2s
    3332// actually used by a given virtual space is generally smaller than 2048, and is
    34 // defined in the MAPPING_INFO_BINARY data structure(using the length field).
    35 // The value is calculated and put in _max_pte2 indexed by the vspace_id.
     33// defined in the MAPPING_INFO_BINARY data structure (using the length field).
     34// The value is calculated and put in _max_pt2 indexed by the vspace_id.
    3635// The physical alignment constraints, is ensured by the align flag in the MAPPING_INFO
    3736// structure.
     
    4140// - a first 8K aligned PT1[2148] array, indexed by the (ix1) field of VPN.
    4241//   The PT1 contains 2048 PTD of 4 bytes => 8K bytes.
    43 // - an aray of array PT2[1024][_max_pte2[vspace_id]], indexed by
     42// - an aray of array PT2[1024][_max_pt2[vspace_id]], indexed by
    4443//   the (ix2) field of the VPN, and by the PT2 index (pt2_id).
    45 //   Each PT2 contains 512 PTE2 of 8bytes => 4Kbytes * _max_pte2[vspace_id]
    46 // The size of each page table is 8K + (_max_pte2[vspace_id])*4K bytes.
     44//   Each PT2 contains 512 PTE2 of 8bytes => 4Kbytes * _max_pt2[vspace_id]
     45// The size of each page table is 8K + (_max_pt2[vspace_id])*4K bytes.
    4746// All page tables must be stored in the seg_kernel_pt segment (at address
    4847// seg_kernel_pt_base)
    4948////////////////////////////////////////////////////////////////////////////////////
    5049
    51 #include <mips32_registers.h>
     50#include "../sys/mips32_registers.h"
    5251#include <boot_handler.h>
    5352#include <mapping_info.h>
    54 #include <mwmr.h>
     53#include <mwmr_channel.h>
    5554
    5655#include <stdarg.h>
     
    6261
    6362////////////////////////////////////////////////////////////////////////////
    64 //  Global variables
     63//  Page Tables global variables
    6564////////////////////////////////////////////////////////////////////////////
    6665
    67 // Page Tables
    68 // Next free PT2 index
     66// Next free PT2 index array
    6967unsigned int  _next_free_pt2[GIET_NB_VSPACE_MAX] =
    7068                         { [0 ... GIET_NB_VSPACE_MAX-1] = 0 };
    7169
    72 // Max PT2 index
    73 unsigned int  _max_pte2[GIET_NB_VSPACE_MAX] =
     70// Max number of PT2 array
     71unsigned int  _max_pt2[GIET_NB_VSPACE_MAX] =
    7472                         { [0 ... GIET_NB_VSPACE_MAX-1] = 0 };
    7573
    76 // Page table pointers
     74// Page table pointers array
    7775page_table_t* _ptabs[GIET_NB_VSPACE_MAX];
    7876
     
    107105
    108106////////////////////////////////////////////////////////////////////////////
    109 // boot_tty_puts()
     107// boot_puts()
    110108// (it uses TTY0)
    111109////////////////////////////////////////////////////////////////////////////
    112 void boot_tty_puts(const char *buffer)
     110void boot_puts(const char *buffer)
    113111{
    114112    unsigned int* tty_address = (unsigned int*)&seg_tty_base;
     
    124122
    125123////////////////////////////////////////////////////////////////////////////
    126 // boot_tty_putw()
     124// boot_putw()
    127125// (it uses TTY0)
    128126////////////////////////////////////////////////////////////////////////////
    129 void boot_tty_putw(unsigned int val)
     127void boot_putw(unsigned int val)
    130128{
    131129    static const char   HexaTab[] = "0123456789ABCDEF";
     
    142140        val = val >> 4;
    143141    }
    144     boot_tty_puts(buf);
     142    boot_puts(buf);
    145143}
    146144
     
    219217    mapping_vseg_t*         vseg    = boot_get_vseg_base ( header );
    220218    mapping_task_t*         task    = boot_get_task_base ( header );;
    221     mapping_vobj_t*    vobj   = boot_get_vobj_base( header );
     219    mapping_vobj_t*     vobj    = boot_get_vobj_base( header );
    222220
    223221    // header
    224     boot_tty_puts("mapping_info");
    225 
    226     boot_tty_puts("\n - signature = ");
    227     boot_tty_putw(header->signature);
    228     boot_tty_puts("\n - name      = ");
    229     boot_tty_puts(header->name);
    230     boot_tty_puts("\n - clusters  = ");
    231     boot_tty_putw(header->clusters);
    232     boot_tty_puts("\n - psegs     = ");
    233     boot_tty_putw(header->psegs);
    234     boot_tty_puts("\n - ttys      = ");
    235     boot_tty_putw(header->ttys);
    236     boot_tty_puts("\n - vspaces   = ");
    237     boot_tty_putw(header->vspaces);
    238     boot_tty_puts("\n - globals   = ");
    239     boot_tty_putw(header->globals);
    240     boot_tty_puts("\n - vsegs     = ");
    241     boot_tty_putw(header->vsegs);
    242     boot_tty_puts("\n - tasks     = ");
    243     boot_tty_putw(header->tasks);
    244     boot_tty_puts("\n\n");
     222    boot_puts("mapping_info");
     223
     224    boot_puts("\n - signature = ");
     225    boot_putw(header->signature);
     226    boot_puts("\n - name      = ");
     227    boot_puts(header->name);
     228    boot_puts("\n - clusters  = ");
     229    boot_putw(header->clusters);
     230    boot_puts("\n - psegs     = ");
     231    boot_putw(header->psegs);
     232    boot_puts("\n - ttys      = ");
     233    boot_putw(header->ttys);
     234    boot_puts("\n - fbs       = ");
     235    boot_putw(header->fbs);
     236    boot_puts("\n - vspaces   = ");
     237    boot_putw(header->vspaces);
     238    boot_puts("\n - globals   = ");
     239    boot_putw(header->globals);
     240    boot_puts("\n - vsegs     = ");
     241    boot_putw(header->vsegs);
     242    boot_puts("\n - vobjs     = ");
     243    boot_putw(header->vobjs);
     244    boot_puts("\n - tasks     = ");
     245    boot_putw(header->tasks);
     246    boot_puts("\n\n");
    245247
    246248    // clusters
    247249    for ( cluster_id = 0 ; cluster_id < header->clusters ; cluster_id++ )
    248250    {
    249         boot_tty_puts("cluster ");
    250         boot_tty_putw(cluster_id);
    251 
    252         boot_tty_puts("\n - procs  = ");
    253         boot_tty_putw(cluster[cluster_id].procs);
    254         boot_tty_puts("\n - timers = ");
    255         boot_tty_putw(cluster[cluster_id].timers);
    256         boot_tty_puts("\n - dmas   = ");
    257         boot_tty_putw(cluster[cluster_id].dmas);
    258         boot_tty_puts("\n\n");
     251        boot_puts("cluster ");
     252        boot_putw(cluster_id);
     253
     254        boot_puts("\n - procs  = ");
     255        boot_putw(cluster[cluster_id].procs);
     256        boot_puts("\n\n");
    259257    }
    260258
     
    262260    for ( pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ )
    263261    {
    264         boot_tty_puts("pseg ");
    265         boot_tty_putw(pseg_id);
    266 
    267         boot_tty_puts("\n - name   = ");
    268         boot_tty_puts( pseg[pseg_id].name );
    269         boot_tty_puts("\n - base   = ");
    270         boot_tty_putw( pseg[pseg_id].base );
    271         boot_tty_puts("\n - length = ");
    272         boot_tty_putw( pseg[pseg_id].length );
    273         boot_tty_puts("\n\n");
     262        boot_puts("pseg ");
     263        boot_putw(pseg_id);
     264
     265        boot_puts("\n - name   = ");
     266        boot_puts( pseg[pseg_id].name );
     267        boot_puts("\n - base   = ");
     268        boot_putw( pseg[pseg_id].base );
     269        boot_puts("\n - length = ");
     270        boot_putw( pseg[pseg_id].length );
     271        boot_puts("\n\n");
    274272    }
    275273
     
    277275    for ( vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ )
    278276    {
    279         boot_tty_puts("global vseg ");
    280         boot_tty_putw(vseg_id);
    281 
    282         boot_tty_puts("\n - name   = ");
    283         boot_tty_puts( vseg[vseg_id].name );
    284         boot_tty_puts("\n - vbase  = ");
    285         boot_tty_putw( vseg[vseg_id].vbase );
    286         boot_tty_puts("\n - length = ");
    287         boot_tty_putw( vseg[vseg_id].length );
    288         boot_tty_puts("\n - mode   = ");
    289         boot_tty_putw( vseg[vseg_id].mode );
    290         boot_tty_puts("\n - ident = ");
    291         boot_tty_putw( vseg[vseg_id].ident );
    292         boot_tty_puts("\n - psegname = ");
    293         boot_tty_puts( pseg[vseg[vseg_id].psegid].name );
    294         boot_tty_puts("\n");
    295         for ( vobj_id = vseg[vseg_id].vobj_offset ; vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; vobj_id++ )
    296         {
    297                         boot_tty_puts("vobjs: \n");
    298             boot_tty_putw( vobj[vobj_id].name);
    299             boot_tty_puts("\n");
    300             boot_tty_puts("\t name     = ");
    301                         boot_tty_putw(  vobj[vobj_id].name);
    302                         boot_tty_puts("\n");
    303             boot_tty_puts("\t type     = ");
    304                         boot_tty_putw( vobj[vobj_id].type);
    305                         boot_tty_puts("\n");
    306             boot_tty_puts("\t length   = ");
    307                         boot_tty_putw(   vobj[vobj_id].length);
    308                         boot_tty_puts("\n");
    309             boot_tty_puts("\t align    = ");
    310                         boot_tty_putw(   vobj[vobj_id].align);
    311                         boot_tty_puts("\n");
    312             boot_tty_puts("\t binpath  = ");
    313                         boot_tty_putw(   vobj[vobj_id].binpath);
    314                         boot_tty_puts("\n\n");
     277        boot_puts("global vseg ");
     278        boot_putw(vseg_id);
     279
     280        boot_puts("\n - name        = ");
     281        boot_puts( vseg[vseg_id].name );
     282        boot_puts("\n - vbase       = ");
     283        boot_putw( vseg[vseg_id].vbase );
     284        boot_puts("\n - length      = ");
     285        boot_putw( vseg[vseg_id].length );
     286        boot_puts("\n - mode        = ");
     287        boot_putw( vseg[vseg_id].mode );
     288        boot_puts("\n - ident       = ");
     289        boot_putw( vseg[vseg_id].ident );
     290        boot_puts("\n - psegname    = ");
     291        boot_puts( pseg[vseg[vseg_id].psegid].name );
     292        boot_puts("\n - vobjs       = ");
     293        boot_putw( vseg[vseg_id].vobjs );
     294        boot_puts("\n - vobj_offset = ");
     295        boot_putw( vseg[vseg_id].vobj_offset );
     296        boot_puts("\n");
     297        for ( vobj_id = vseg[vseg_id].vobj_offset ;
     298              vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ;
     299              vobj_id++ )
     300        {
     301                        boot_puts("\n\t vobj ");
     302            boot_puts( vobj[vobj_id].name);
     303            boot_puts("\n\t type     = ");
     304                        boot_putw( vobj[vobj_id].type);
     305            boot_puts("\n\t length   = ");
     306                        boot_putw(   vobj[vobj_id].length);
     307            boot_puts("\n\t align    = ");
     308                        boot_putw(   vobj[vobj_id].align);
     309            boot_puts("\n\t binpath  = ");
     310                        boot_puts(   vobj[vobj_id].binpath);
     311                        boot_puts("\n\n");
    315312        }
    316313    }
     
    319316    for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
    320317    {
    321         unsigned int func_id = vspace[vspace_id].vobj_offset + vspace[vspace_id].funcs_offset;
    322         boot_tty_puts("vspace ");
    323         boot_tty_putw(vspace_id);
    324 
    325         boot_tty_puts("\n - name    = ");
    326         boot_tty_puts( vspace[vspace_id].name );
    327         boot_tty_puts("\n - funcs    = ");
    328         boot_tty_puts( vobj[func_id].name );
    329         boot_tty_puts( vspace[vspace_id].name );
    330         boot_tty_puts("\n - ttys    = ");
    331         boot_tty_putw( vspace[vspace_id].ttys );
    332         boot_tty_puts("\n\n");
     318        unsigned int start_id = vspace[vspace_id].vobj_offset +
     319                                vspace[vspace_id].start_offset;
     320
     321        boot_puts("vspace ");
     322        boot_putw(vspace_id);
     323
     324        boot_puts("\n - name        = ");
     325        boot_puts( vspace[vspace_id].name );
     326        boot_puts("\n - start_vobj  = ");
     327        boot_puts( vobj[start_id].name );
     328        boot_puts("\n - vsegs       = ");
     329        boot_putw( vspace[vspace_id].vsegs );
     330        boot_puts("\n - vobjs       = ");
     331        boot_putw( vspace[vspace_id].vobjs );
     332        boot_puts("\n - tasks       = ");
     333        boot_putw( vspace[vspace_id].tasks );
     334        boot_puts("\n - vseg_offset = ");
     335        boot_putw( vspace[vspace_id].vseg_offset );
     336        boot_puts("\n - vobj_offset = ");
     337        boot_putw( vspace[vspace_id].vobj_offset );
     338        boot_puts("\n - task_offset = ");
     339        boot_putw( vspace[vspace_id].task_offset );
     340        boot_puts("\n\n");
    333341
    334342        for ( vseg_id = vspace[vspace_id].vseg_offset ;
     
    336344              vseg_id++ )
    337345        {
    338             boot_tty_puts("    private vseg ");
    339             boot_tty_putw( vseg_id );
    340 
    341             boot_tty_puts("\n    - name   = ");
    342             boot_tty_puts( vseg[vseg_id].name );
    343             boot_tty_puts("\n    - vbase  = ");
    344             boot_tty_putw( vseg[vseg_id].vbase );
    345             boot_tty_puts("\n    - length = ");
    346             boot_tty_putw( vseg[vseg_id].length );
    347             boot_tty_puts("\n    - mode   = ");
    348             boot_tty_putw( vseg[vseg_id].mode );
    349             boot_tty_puts("\n    - ident = ");
    350             boot_tty_putw( vseg[vseg_id].ident );
    351             boot_tty_puts("\n    - psegname = ");
    352             boot_tty_puts( pseg[vseg[vseg_id].psegid].name );
    353             boot_tty_puts("\n");
    354             for ( vobj_id = vseg[vseg_id].vobj_offset ; vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ; vobj_id++ )
     346            boot_puts("    private vseg ");
     347            boot_putw( vseg_id );
     348
     349            boot_puts("\n    - name        = ");
     350            boot_puts( vseg[vseg_id].name );
     351            boot_puts("\n    - vbase       = ");
     352            boot_putw( vseg[vseg_id].vbase );
     353            boot_puts("\n    - length      = ");
     354            boot_putw( vseg[vseg_id].length );
     355            boot_puts("\n    - mode        = ");
     356            boot_putw( vseg[vseg_id].mode );
     357            boot_puts("\n    - ident       = ");
     358            boot_putw( vseg[vseg_id].ident );
     359            boot_puts("\n    - psegname    = ");
     360            boot_puts( pseg[vseg[vseg_id].psegid].name );
     361            boot_puts("\n    - vobjs       = ");
     362            boot_putw( vseg[vseg_id].vobjs );
     363            boot_puts("\n    - vobj_offset = ");
     364            boot_putw( vseg[vseg_id].vobj_offset );
     365            boot_puts("\n");
     366
     367            for ( vobj_id = vseg[vseg_id].vobj_offset ;
     368                  vobj_id < vseg[vseg_id].vobj_offset + vseg[vseg_id].vobjs ;
     369                  vobj_id++ )
    355370            {
    356                 boot_tty_puts("\t\t vobjs     = ");
    357                                 boot_tty_putw(     vobj[vobj_id].name);
    358                                 boot_tty_puts("\n");
    359                 boot_tty_puts("\t\t name     = ");
    360                                 boot_tty_putw(     vobj[vobj_id].name);
    361                                 boot_tty_puts("\n");
    362                 boot_tty_puts("\t\t type     = ");
    363                                 boot_tty_putw( vobj[vobj_id].type);
    364                                 boot_tty_puts("\n");
    365                 boot_tty_puts("\t\t length   = ");
    366                                 boot_tty_putw(   vobj[vobj_id].length);
    367                                 boot_tty_puts("\n");
    368                 boot_tty_puts("\t\t align    = ");
    369                                 boot_tty_putw(   vobj[vobj_id].align);
    370                                 boot_tty_puts("\n");
    371                 boot_tty_puts("\t\t binpath  = ");
    372                                 boot_tty_putw(   vobj[vobj_id].binpath);
    373                                 boot_tty_puts("\n");
     371                boot_puts("\n\t\t vobj ");
     372                boot_puts( vobj[vobj_id].name);
     373                boot_puts("\n\t\t type     = ");
     374                boot_putw( vobj[vobj_id].type);
     375                boot_puts("\n\t\t length   = ");
     376                            boot_putw(   vobj[vobj_id].length);
     377                boot_puts("\n\t\t align    = ");
     378                            boot_putw(   vobj[vobj_id].align);
     379                boot_puts("\n\t\t binpath  = ");
     380                        boot_puts(   vobj[vobj_id].binpath);
     381                        boot_puts("\n\n");
    374382            }
    375383        }
     
    379387              task_id++ )
    380388        {
    381             boot_tty_puts("     task");
    382             boot_tty_putw( task_id );
    383 
    384             boot_tty_puts("\n     - name = ");
    385             boot_tty_puts( task[task_id].name );
    386             boot_tty_puts("\n     - clusterid = ");
    387             boot_tty_putw( task[task_id].clusterid );
    388             boot_tty_puts("\n     - proclocid = ");
    389             boot_tty_putw( task[task_id].proclocid );
    390             boot_tty_puts("\n     - vobjlocid = ");
    391             boot_tty_putw( task[task_id].vobjlocid );
    392             boot_tty_puts("\n     - startid   = ");
    393             boot_tty_putw( task[task_id].startid );
    394             boot_tty_puts("\n     - ttylocid  = ");
    395             boot_tty_putw( task[task_id].ttylocid );
    396             boot_tty_puts("\n\n");
     389            boot_puts("     task");
     390            boot_putw( task_id );
     391
     392            boot_puts("\n     - name = ");
     393            boot_puts( task[task_id].name );
     394            boot_puts("\n     - clusterid = ");
     395            boot_putw( task[task_id].clusterid );
     396            boot_puts("\n     - proclocid = ");
     397            boot_putw( task[task_id].proclocid );
     398            boot_puts("\n     - vobjlocid = ");
     399            boot_putw( task[task_id].vobjlocid );
     400            boot_puts("\n     - startid   = ");
     401            boot_putw( task[task_id].startid );
     402            boot_puts("\n     - use_tty   = ");
     403            boot_putw( task[task_id].use_tty );
     404            boot_puts("\n     - use_fb   = ");
     405            boot_putw( task[task_id].use_fb );
     406            boot_puts("\n\n");
    397407        }
    398408    }
     
    403413// boot_pseg_get()
    404414// This function returns the pointer on a physical segment
    405 // identified  by the segment index.
     415// identified  by the pseg index.
    406416//////////////////////////////////////////////////////////////////////////////
    407417mapping_pseg_t* boot_pseg_get( unsigned int seg_id)
     
    413423    if ( seg_id >= header->psegs )
    414424    {
    415         boot_tty_puts("\n[BOOT ERROR] : seg_id argument too large\n");
    416         boot_tty_puts("               in function boot_pseg_get()\n");
     425        boot_puts("\n[BOOT ERROR] : seg_id argument too large\n");
     426        boot_puts("               in function boot_pseg_get()\n");
    417427        boot_exit();
    418428    }
     
    420430    return &pseg[seg_id];                                   
    421431} // end boot_pseg_get()
    422 
    423432
    424433//////////////////////////////////////////////////////////////////////////////
     
    450459
    451460       
    452     unsigned int max_pte2   = _max_pte2[vspace_id];
    453     if(max_pte2 == 0)
    454     {
    455         boot_tty_puts("Unfound page table for vspace ");
    456         boot_tty_putw(vspace_id);
    457         boot_tty_puts("\n");
     461    unsigned int max_pt2   = _max_pt2[vspace_id];
     462    if(max_pt2 == 0)
     463    {
     464        boot_puts("Unfound page table for vspace ");
     465        boot_putw(vspace_id);
     466        boot_puts("\n");
    458467        boot_exit();
    459468    }
     
    463472    {
    464473        pt2_id = _next_free_pt2[vspace_id];
    465         if ( pt2_id == max_pte2 )
    466         {
    467             boot_tty_puts("\n[BOOT ERROR] in boot_add_pte() function\n");
    468             boot_tty_puts("the length of the ptab vobj is too small\n");
     474        if ( pt2_id == max_pt2 )
     475        {
     476            boot_puts("\n[BOOT ERROR] in boot_add_pte() function\n");
     477            boot_puts("the length of the ptab vobj is too small\n");
    469478            boot_exit();
    470479        }
     
    487496    if ( ( *pt_flags & PTE_V) != 0 )    // page already mapped
    488497    {
    489         if(global)
    490         {
    491             boot_tty_puts("\n[BOOT ERROR] in boot_add_pte() function\n");
    492             boot_tty_puts("page already mapped\n");
    493             boot_exit();
    494         }else
    495         {
    496             /**
    497              * The case where a global vseg is already mapped as private vseg of a
    498              * vspace_id. Typically used when a vseg is being replicated.
    499              */ 
    500             boot_tty_puts("\n[BOOT] global PTE for vspace ");
    501             boot_tty_putw(vspace_id);
    502             boot_tty_puts(" already mapped, vpn = ");
    503             boot_tty_putw(vpn);
    504             boot_tty_puts("\n");
    505             return;
    506         }
     498        boot_puts("\n[BOOT ERROR] in boot_add_pte() function\n");
     499        boot_puts("page already mapped\n");
     500        boot_exit();
    507501    }
    508502
     
    549543
    550544#if BOOT_DEBUG_PT
    551 boot_tty_puts("- vseg ");
    552 boot_tty_puts( vseg[vseg_id].name );
    553 boot_tty_puts(" / flags = ");
    554 boot_tty_putw( flags );
    555 boot_tty_puts("\n");
     545boot_puts("- vseg ");
     546boot_puts( vseg[vseg_id].name );
     547boot_puts(" / flags = ");
     548boot_putw( flags );
     549boot_puts(" / npages = ");
     550boot_putw( npages );
     551boot_puts("\n");
    556552#endif       
    557553        // loop on 4K pages
     
    583579
    584580#if BOOT_DEBUG_PT
    585 boot_tty_puts("- vseg ");
    586 boot_tty_puts( vseg[vseg_id].name );
    587 boot_tty_puts(" / flags = ");
    588 boot_tty_putw( flags );
    589 boot_tty_puts(" / npages = ");
    590 boot_tty_putw( npages );
    591 boot_tty_puts("\n");
     581boot_puts("- vseg ");
     582boot_puts( vseg[vseg_id].name );
     583boot_puts(" / flags = ");
     584boot_putw( flags );
     585boot_puts(" / npages = ");
     586boot_putw( npages );
     587boot_puts("\n");
    592588#endif       
    593589        // loop on 4K pages
     
    606602} // end boot_vspace_pt_build()
    607603
    608 
    609604///////////////////////////////////////////////////////////////////////////
    610605// Align the value "toAlign" to the required alignement indicated by
    611606// alignPow2 ( the logarithme of 2 the alignement).
    612607///////////////////////////////////////////////////////////////////////////
    613 unsigned int align_to( unsigned toAlign, unsigned alignPow2)
    614 {
    615     unsigned mask = (1 << alignPow2) - 1;
    616     return ((toAlign + mask ) & ~mask );//page aligned
    617 }
    618 
    619 ///////////////////////////////////////////////////////////////////////////
    620 // Initialise vobjs
    621 // For now only one type is initialised the: PTAB
    622 //
    623 // param:
    624 //  vobj: the vobj to initialise
    625 //  region_id: the vspace in wich the vobj is located or the global space(-1).
    626 ///////////////////////////////////////////////////////////////////////////
    627 void initailise_vobj(mapping_vobj_t* vobj, unsigned int region_id)
    628 {
    629     if(vobj->type == PTAB)
    630     {
    631         if(region_id == ((unsigned int) -1))
    632         {
    633             boot_tty_puts( "No PTAB vobjs are allowed in the global region" );
    634             boot_exit();
    635         }
    636         if(vobj->length < (PT1_SIZE + PT2_SIZE) ) //at least one pt2 => ( max_pt2 >= 1)
    637         {
    638             boot_tty_puts("PTAB too small, minumum size is ");
    639             boot_tty_putw( PT1_SIZE + PT2_SIZE);
    640             boot_exit();
    641         }
    642 
    643         _ptabs[region_id]        = (page_table_t*) vobj->paddr;
    644         _max_pte2[region_id]    = (vobj->length - PT1_SIZE) / PT2_SIZE;
    645 
    646 #if BOOT_DEBUG_VIEW
    647         boot_tty_puts("ptabs for vspace ");
    648         boot_tty_putw(region_id);
    649         boot_tty_puts(" address: ");
    650         boot_tty_putw((unsigned)_ptabs[region_id]);
    651         boot_tty_puts("\n");
    652 #endif
    653     }
     608unsigned int align_to( unsigned int toAlign,
     609                       unsigned int alignPow2)
     610{
     611    unsigned int    mask = (1 << alignPow2) - 1;
     612    return ((toAlign + mask ) & ~mask );
    654613}
    655614
     
    660619// It updates the page allocator (nextfreepage field of the pseg),
    661620// and checks a possible pseg overflow.
    662 // region_id: the vspace in wich the vseg is located or the global space(-1).
     621// It is a global vseg if vspace_id = (-1)
    663622///////////////////////////////////////////////////////////////////////////
    664 void boot_vseg_map( mapping_vseg_t* vseg, unsigned int region_id )
    665 {
    666     unsigned pages;
    667     unsigned vobj_id;
    668     unsigned cur_vaddr;
    669     unsigned cur_paddr;
     623void boot_vseg_map( mapping_vseg_t*     vseg,
     624                    unsigned int        vspace_id )
     625{
     626    unsigned int        pages;
     627    unsigned int        vobj_id;
     628    unsigned int        cur_vaddr;
     629    unsigned int        cur_paddr;
    670630    mapping_header_t*   header = (mapping_header_t*)&seg_mapping_base; 
    671631    mapping_vobj_t*     vobj   = boot_get_vobj_base( header );
     
    677637    if ( vseg->ident != 0 )            // identity mapping required
    678638    {
    679         // check physical segment overflow 
    680         if ( (vseg->vbase < pseg->base) ||
    681              ((vseg->vbase + vseg->length) > (pseg->base + pseg->length)) )
    682         {
    683             boot_tty_puts("\n[BOOT ERROR] in boot_vseg_map() function\n");
    684             boot_tty_puts("impossible identity mapping for virtual segment: ");
    685             boot_tty_puts( vseg->name );
    686             boot_tty_puts("\n");
    687             boot_exit();
    688         }
    689         vseg->pbase = vseg->vbase;
     639         vseg->pbase = vseg->vbase;
    690640    }
    691641    else                                // unconstrained mapping
    692642    {
    693         // check physical segment overflow
    694         if ( (vseg->vbase + vseg->length) > (pseg->base + pseg->length) )
    695         {
    696             boot_tty_puts("\n[BOOT ERROR] in boot_vseg_map() function\n");
    697             boot_tty_puts("physical segment ");
    698             boot_tty_puts( pseg->name );
    699             boot_tty_puts(" is too small to map virtual segment");
    700             boot_tty_puts( vseg->name );
    701             boot_tty_puts("\n");
    702             boot_exit();
    703         }
    704643        vseg->pbase = pseg->base + (pseg->next_free_page<<12);
    705644    }
    706645   
    707 
    708     //loop on vobj:
    709     // + to computes the length of the current vseg
    710     // + Align vobjs
    711     // + Initialise the vobj
     646    // loop on vobjs to computes the length of the vseg,
     647    // initialise the vaddr and paddr fields of all vobjs,
     648    // and initialise the page table pointers array
    712649    cur_vaddr = vseg->vbase;
    713650    cur_paddr = vseg->pbase;
    714     for(vobj_id= vseg->vobj_offset; vobj_id < (vseg->vobj_offset + vseg->vobjs); vobj_id++)
    715     {
    716         if(vobj[vobj_id].align)
     651
     652    for( vobj_id = vseg->vobj_offset;
     653         vobj_id < (vseg->vobj_offset + vseg->vobjs);
     654         vobj_id++)
     655    {
     656        if ( vobj[vobj_id].align )
    717657        {
    718658            cur_paddr = align_to(cur_paddr, vobj[vobj_id].align);
    719659        }
    720660
    721         //set vaddr/paddr
     661        // set vaddr/paddr
    722662        vobj[vobj_id].vaddr = cur_vaddr;       
    723663        vobj[vobj_id].paddr = cur_paddr; 
    724664     
    725         //set next vaddr/paddr
     665        // set next vaddr/paddr
    726666        cur_vaddr += vobj[vobj_id].length;
    727667        cur_paddr += vobj[vobj_id].length;
    728         initailise_vobj(&vobj[vobj_id], region_id);
     668
     669        // initialise _ptabs[] and _max_pt2[]
     670        if ( vobj[vobj_id].type == VOBJ_TYPE_PTAB )
     671        {
     672            if(vobj[vobj_id].length < (PT1_SIZE + PT2_SIZE) ) // max_pt2 >= 1
     673            {
     674                boot_puts( "\n[BOOT ERROR] in boot_vseg_map() function: " );
     675                boot_puts("PTAB vobj is too small in vspace ");
     676                boot_putw(vspace_id);
     677                boot_puts("\n");
     678                boot_exit();
     679            }
     680            if(vspace_id == ((unsigned int) -1))    // global vseg
     681            {
     682                boot_puts( "\n[BOOT ERROR] in boot_vseg_map() function: " );
     683                boot_puts( "a PTAB vobj cannot be global" );
     684                boot_exit();
     685            }
     686            _ptabs[vspace_id]   = (page_table_t*)vobj[vobj_id].paddr;
     687            _max_pt2[vspace_id] = (vobj[vobj_id].length - PT1_SIZE) / PT2_SIZE;
     688        }
    729689    }
    730690   
    731     //set the length
    732     vseg->length = align_to((cur_paddr - vseg->pbase), 12);
     691    //set the vseg length
     692    unsigned int plength = pseg->length;
     693    unsigned int vlength = cur_paddr - vseg->pbase;
     694    vseg->length = align_to(vlength, 12);
     695
     696    // checking pseg overflow
     697    if ( (vseg->pbase < pseg->base) ||
     698         ((vseg->pbase + vlength) > (pseg->base + plength)) )
     699    {
     700        boot_puts("\n[BOOT ERROR] in boot_vseg_map() function\n");
     701        boot_puts("impossible identity mapping for virtual segment: ");
     702        boot_puts( vseg->name );
     703        boot_puts("\n");
     704        boot_puts("vseg pbase = ");
     705        boot_putw( vseg->pbase );
     706        boot_puts("\n");
     707        boot_puts("vseg length = ");
     708        boot_putw( vseg->length );
     709        boot_puts("\n");
     710        boot_puts("pseg pbase = ");
     711        boot_putw( pseg->base );
     712        boot_puts("\n");
     713        boot_puts("pseg length = ");
     714        boot_putw( pseg->length );
     715        boot_puts("\n");
     716        boot_exit();
     717    }
    733718
    734719    // computes number of pages
     
    743728
    744729#if BOOT_DEBUG_PT
    745 boot_tty_puts("- vseg ");
    746 boot_tty_puts( vseg->name );
    747 boot_tty_puts(" : vbase = ");
    748 boot_tty_putw( vseg->vbase );
    749 boot_tty_puts(" / pbase = ");
    750 boot_tty_putw( vseg->pbase );
    751 boot_tty_puts("\n");
     730boot_puts("- vseg ");
     731boot_puts( vseg->name );
     732boot_puts(" : vbase = ");
     733boot_putw( vseg->vbase );
     734boot_puts(" / pbase = ");
     735boot_putw( vseg->pbase );
     736boot_puts("\n");
    752737#endif 
    753738
     
    755740
    756741/////////////////////////////////////////////////////////////////////
    757 // This function cheks the mapping_info data structure
     742// This function checks the mapping_info data structure
    758743/////////////////////////////////////////////////////////////////////
    759744void boot_check_mapping()
     
    764749    if ( header->signature != IN_MAPPING_SIGNATURE )
    765750    {
    766         boot_tty_puts("\n[BOOT ERROR] Illegal mapping signature: ");
    767         boot_tty_putw(header->signature);
    768         boot_tty_puts("\n");
     751        boot_puts("\n[BOOT ERROR] Illegal mapping signature: ");
     752        boot_putw(header->signature);
     753        boot_puts("\n");
    769754        boot_exit();
    770755    }
     
    777762    if ( header->clusters != NB_CLUSTERS )
    778763    {
    779         boot_tty_puts("\n[BOOT ERROR] Incoherent NB_CLUSTERS");
    780         boot_tty_puts("\n             - In giet_config,  value = ");
    781         boot_tty_putw ( NB_CLUSTERS );
    782         boot_tty_puts("\n             - In mapping_info, value = ");
    783         boot_tty_putw ( header->clusters );
    784         boot_tty_puts("\n");
     764        boot_puts("\n[BOOT ERROR] Incoherent NB_CLUSTERS");
     765        boot_puts("\n             - In giet_config,  value = ");
     766        boot_putw ( NB_CLUSTERS );
     767        boot_puts("\n             - In mapping_info, value = ");
     768        boot_putw ( header->clusters );
     769        boot_puts("\n");
    785770        boot_exit();
    786771    }
     
    789774    if ( header->ttys != NB_TTYS )
    790775    {
    791         boot_tty_puts("\n[BOOT ERROR] Incoherent NB_TTYS");
    792         boot_tty_puts("\n             - In giet_config,  value = ");
    793         boot_tty_putw ( NB_TTYS );
    794         boot_tty_puts("\n             - In mapping_info, value = ");
    795         boot_tty_putw ( header->ttys );
    796         boot_tty_puts("\n");
     776        boot_puts("\n[BOOT ERROR] Incoherent NB_TTYS");
     777        boot_puts("\n             - In giet_config,  value = ");
     778        boot_putw ( NB_TTYS );
     779        boot_puts("\n             - In mapping_info, value = ");
     780        boot_putw ( header->ttys );
     781        boot_puts("\n");
    797782        boot_exit();
    798783    }
     
    801786    if ( header->vspaces > GIET_NB_VSPACE_MAX )
    802787    {
    803         boot_tty_puts("\n[BOOT ERROR] : number of vspaces > GIET_NB_VSPACE_MAX\n");
    804         boot_tty_puts("\n");
     788        boot_puts("\n[BOOT ERROR] : number of vspaces > GIET_NB_VSPACE_MAX\n");
     789        boot_puts("\n");
    805790        boot_exit();
    806791    }
     
    825810    unsigned int        pseg_id;
    826811
    827     // first loop on virtual spaces to map global vsegs
     812    // checking mapping_info
     813    boot_check_mapping();
     814
     815    // physical page allocators must be initialised
     816    for ( pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ )
     817    {
     818        pseg[pseg_id].next_free_page = 0;
     819    }
    828820
    829821#if BOOT_DEBUG_PT
    830 boot_tty_puts("\n******* mapping global vsegs ********");
     822boot_puts("\n******* mapping global vsegs ********\n");
    831823#endif
    832824           
    833     // physical page allocators must be initialised ???
    834     for ( pseg_id = 0 ; pseg_id < header->psegs ; pseg_id++ )
    835     {
    836         pseg[pseg_id].next_free_page = 0;
    837     }
    838 
     825    // step 1 : first loop on virtual spaces to map global vsegs
    839826    for ( vseg_id = 0 ; vseg_id < header->globals ; vseg_id++ )
    840827    {
     
    842829    }
    843830
    844     // loop on virtual vspaces to map private vsegs
     831    // step 2 : loop on virtual vspaces to map private vsegs
    845832    for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
    846833    {
    847834
    848835#if BOOT_DEBUG_PT
    849 boot_tty_puts("\n******* mapping private vsegs in vspace ");
    850 boot_tty_puts(vspace[vspace_id].name);
    851 boot_tty_puts(" ********\n");
     836boot_puts("\n******* mapping private vsegs in vspace ");
     837boot_puts(vspace[vspace_id].name);
     838boot_puts(" ********\n");
    852839#endif
    853840           
     
    860847    }
    861848
    862     // loop on the vspaces to build the page tables
     849    // step 3 : loop on the vspaces to build the page tables
    863850    for ( vspace_id = 0 ; vspace_id < header->vspaces ; vspace_id++ )
    864851    {
    865852
    866853#if BOOT_DEBUG_PT
    867 boot_tty_puts("\n******* building page table for vspace ");
    868 boot_tty_puts(vspace[vspace_id].name);
    869 boot_tty_puts(" ********\n");
     854boot_puts("\n******* building page table for vspace ");
     855boot_puts(vspace[vspace_id].name);
     856boot_puts(" ********\n");
    870857#endif
    871858           
    872859        boot_vspace_pt_build( vspace_id );
     860
     861#if BOOT_DEBUG_PT
     862boot_puts(">>> page table physical address = ");
     863boot_putw((unsigned)_ptabs[vspace_id]);
     864boot_puts("\n");
     865#endif
    873866    }
     867
     868    boot_puts("\n[BOOT] Page Tables initialisation completed at cycle ");
     869    boot_putw( boot_time() );
     870    boot_puts("\n");
     871
    874872} // end boot_pt_init()
    875 
    876 
    877 
    878 ////////////////////////////////////////////////////////////////////////////////////
    879 // boot_init()
    880 // This function is executed by one single processor to initialize the page
    881 // tables, the tasks contexts and the peripherals, for all applications.
    882 ////////////////////////////////////////////////////////////////////////////////////
    883 void boot_init()
    884 {
    885     // checking mapping_info
    886     boot_check_mapping();
    887 
    888     // building page tables
    889     boot_pt_init();
    890     boot_tty_puts("\n[BOOT] Page Tables completed at cycle ");
    891     boot_tty_putw( boot_time() );
    892     boot_tty_puts("\n");
    893 
    894 } // end boot_init()
    895873
    896874// Local Variables:
  • soft/giet_vm/boot/reset.S

    r162 r165  
    11/********************************************************************************/
    2 /*      File : reset.S                                                              */
    3 /*      Author : Alain Greiner  & Mohamed karaoui               */
    4 /*      Date : 03/06/2012                                                           */
     2/*      File : reset.S                                                              */
     3/*      Author : Alain Greiner  & Mohamed karaoui                                   */
     4/*      Date : 03/06/2012                                                                                       */
    55/********************************************************************************/
    66/* This boot code is for a multi-cluster, multi-processor architecture,             */
    7 /* running one or several multi-tasks software application(s) defined in the    */
     7/* running one or several multi-tasks software application(s) defined in        */
    88/* the mapping_info data-structure.                                                                     */
    9 /* It uses the mapping_info data structure to build the page tables.            */
    10 /* Processor 0 is in charge of building all pages tables.                       */
     9/* Procesor 0 uses the mapping_info data structure to build all page tables     */
     10/* before jumping to the kernel_init code.                                                                              */
    1111/* Other processors are waiting until the mapping_info signature has been       */
    1212/* modified by processor 0 (done while executing kernel_init code).             */
     13/* Implementation note:                                                                                                                 */
    1314/* The entry point is 0xbfc00000, but the actual boot code starts at address    */
    1415/* 0xbfc00500, and a minimal boot exception handler is implemented at address   */
     
    1718               
    1819#include <giet_config.h>
    19 #include <mips32_registers.h>
     20#include "../sys/mips32_registers.h"
    2021
    2122#define EXCEP_ORG               0x380
     
    4445boot_excep:
    4546    la  a0,     boot_error_string
    46     jal boot_tty_puts
     47    jal boot_puts
    4748    nop
    4849    mfc0        a0,     CP0_TIME
    49         jal     boot_tty_putw
     50        jal     boot_putw
    5051        nop
    5152    la  a0,     boot_lf_string
    52     jal boot_tty_puts
     53    jal boot_puts
     54    nop
     55
     56        la      a0,     boot_pid_string
     57    jal boot_puts
     58    nop
     59    mfc0        k0,     CP0_PROCID
     60    andi        a0,     k0,     0xFFF
     61        jal     boot_putw
     62    nop
     63    la  a0,     boot_lf_string
     64    jal boot_puts
    5365    nop
    5466
    5567        la      a0,     boot_epc_string
    56     jal boot_tty_puts
     68    jal boot_puts
    5769    nop
    5870    mfc0        a0,     CP0_EPC
    59 
    60         jal     boot_tty_putw
     71        jal     boot_putw
    6172    nop
    6273    la  a0,     boot_lf_string
    63     jal boot_tty_puts
     74    jal boot_puts
    6475    nop
    6576
    6677        la      a0,     boot_cr_string
    67     jal boot_tty_puts
     78    jal boot_puts
    6879    nop
    6980    mfc0        a0,     CP0_CR
    70         jal     boot_tty_putw
     81        jal     boot_putw
    7182    nop
    7283    la  a0,     boot_lf_string
    73     jal boot_tty_puts
     84    jal boot_puts
    7485    nop
    7586
    7687        la      a0,     boot_sr_string
    77     jal boot_tty_puts
     88    jal boot_puts
    7889    nop
    7990    mfc0        a0,     CP0_SR
    80         jal     boot_tty_putw
     91        jal     boot_putw
    8192    nop
    8293    la  a0,     boot_lf_string
    83     jal boot_tty_puts
     94    jal boot_puts
    8495    nop
    8596
    8697        la      a0,     boot_bar_string
    87     jal boot_tty_puts
     98    jal boot_puts
    8899    nop
    89100    mfc0        a0,     CP0_BAR
    90         jal     boot_tty_putw
     101        jal     boot_putw
    91102    nop
    92103    la  a0,     boot_lf_string
    93     jal boot_tty_puts
     104    jal boot_puts
    94105    nop
    95106
     
    101112/*******************************************/
    102113    .align      2
    103         .org    START_ORG
     114    .org        START_ORG
    104115
    105116boot_start:
    106117    /* get the procid */
    107118    mfc0        k0,     CP0_PROCID
    108         andi    k0,     k0,     0x3FF   /* no more than 1024 processors... */
     119    andi        k0,     k0,     0xFFF   /* no more than 4096 processors... */
    109120
    110         /* Only processor 0 does init */
    111         bne     k0,     zero,   boot_wait_signature
     121    /* Only processor 0 does init */
     122    bne k0,     zero,   boot_wait_signature
    112123    nop
    113124
    114         /* temporary stack for procesor 0 : 16K */
    115         la          sp, seg_boot_stack_base
    116         addiu   sp,     sp,     0x4000 
     125    /* Processor 0 get a temporary stack */
     126    la      sp, seg_boot_stack_base
     127    addiu       sp,     sp,     0x3000                          /* SP <= seg_boot_stack + 12K */
    117128
    118     /* plat-form initialisation */
    119         jal     boot_init
     129    /* Processor 0 initialises all Page Tables */
     130    jal boot_pt_init
    120131    nop
    121     j to_kinit
     132 
     133    /* jump to kernel_init */
     134    j           boot_to_kernel_init
    122135    nop
    123136
    124137boot_wait_signature:
     138
     139    /* all other processors are waiting signature change */
    125140    la  k0, seg_mapping_base
    126     cache   0x11,   0(k0)           /* invalidate local cache copy */
    127     lw  k0, 0(k0)                   /* k0 <= mapping_info[0] */
     141    cache   0x11,   0(k0)                               /* invalidate local cache copy */
     142    lw  k0, 0(k0)                                               /* k0 <= mapping_info[0]      */
    128143    li  k1,     OUT_MAPPING_SIGNATURE
    129144    bne k1, k0, boot_wait_signature
    130145    nop
    131146       
    132 to_kinit:
    133     /* All processors initialize PTPR / MODE */
    134     /* and jump to kernel_init code.                                     */
     147    /* all other processors get a temporary stack of 256 bytes */
     148    la      sp, seg_boot_stack_base
     149    addiu   sp, sp, 0x3100                             
     150    mfc0        k0, CP0_PROCID
     151    andi    k0, k0, 0xFFF
     152    sll     k0, k0, 8                                   
     153    addu    sp, sp, k0          /* SP <= seg_boot_stack_base + 12K + (pid+1)*256 */
    135154
    136     /* get the procid */
    137     mfc0        s0,     CP0_PROCID
    138         andi    s0,     s0,     0x3FF           /* no more than 1024 processors... TOFIX*/
     155boot_to_kernel_init:
    139156
    140     /* load a PTPR */
    141         la          k1, _ptabs
     157    /* all processors initialize PTPR with PTAB[0] */
     158    la      k1, _ptabs
    142159    lw      k1, 0(k1)   
    143160    srl     k1, k1, 13
    144     mtc2        k1,     CP2_PTPR                /* ptpr <= _ptabs[0]  */
     161    mtc2        k1,     CP2_PTPR                /* PTPR <= _ptabs[0]  */
    145162
    146         /* activates MMU */
    147         li          k1, 0xF
    148         mtc2    k1,     CP2_MODE                /* load MODE register */
     163        /* all processors activate MMU */
     164    li      k1, 0xF
     165    mtc2    k1, CP2_MODE        /* MODE register */
    149166
    150167    /* jump to kernel_init */
    151         la          k0, seg_kernel_init_base
     168    la      k0, seg_kernel_init_base
    152169    j       k0
    153170    nop
    154171
    155 
    156 boot_error_string:      .asciiz "\n[BOOT] Fatal Error at cycle"
     172boot_error_string:      .asciiz "\n[BOOT] Fatal Error in reset.S at cycle "
     173boot_pid_string:        .asciiz "    PID  = "
    157174boot_sr_string:         .asciiz "    SR   = "
    158175boot_cr_string:         .asciiz "    CR   = "
Note: See TracChangeset for help on using the changeset viewer.