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

Introducing various modifications in kernel initialisation

File:
1 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:
Note: See TracChangeset for help on using the changeset viewer.