Changeset 21 for trunk/kernel/mm


Ignore:
Timestamp:
Jun 3, 2017, 6:56:47 PM (4 years ago)
Author:
max@…
Message:

cosmetic & comments

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/kernel/mm/vmm.c

    r14 r21  
    55 *           Mohamed Lamine Karaoui (2015)
    66 *           Alain Greiner (2016)
    7  * 
     7 *
    88 * Copyright (c) UPMC Sorbonne Universites
    99 *
     
    5252////////////////////////////////////
    5353void vmm_init( process_t * process )
    54 { 
     54{
    5555    error_t   error;
    5656    vseg_t  * vseg_kentry;
     
    7272        hal_core_sleep();
    7373    }
    74    
     74
    7575    // check max number of stacks slots
    7676    if( CONFIG_THREAD_MAX_PER_CLUSTER > 32 )
    7777    {
    78         printk("\n[PANIC] in %s : max number ot threads per cluster for a sihgle process"
     78        printk("\n[PANIC] in %s : max number of threads per cluster for a single process"
    7979               " cannot be larger than 32\n", __FUNCTION__ );
    8080        hal_core_sleep();
     
    8282
    8383    // check STACK zone size
    84     if( (CONFIG_VMM_STACK_SIZE * CONFIG_THREAD_MAX_PER_CLUSTER) > 
     84    if( (CONFIG_VMM_STACK_SIZE * CONFIG_THREAD_MAX_PER_CLUSTER) >
    8585        (CONFIG_VMM_VSPACE_SIZE - CONFIG_VMM_STACK_BASE) )
    8686    {
     
    9090    }
    9191
    92     // initialise the rwlock protecting the vsegs list
     92    // initialize the rwlock protecting the vsegs list
    9393        rwlock_init( &vmm->vsegs_lock );
    9494
     
    102102    if( error )
    103103    {
    104         printk("\n[PANIC] in %s : cannot initialise radix tree for process %x\n",
     104        printk("\n[PANIC] in %s : cannot initialize radix tree for process %x\n",
    105105               __FUNCTION__ , process->pid );
    106106        hal_core_sleep();
     
    111111    size = CONFIG_VMM_KENTRY_SIZE << CONFIG_PPM_PAGE_SHIFT;
    112112    vseg_kentry = vmm_create_vseg( process , base , size , VSEG_TYPE_CODE );
    113     if( vseg_kentry == NULL ) 
     113    if( vseg_kentry == NULL )
    114114    {
    115115        printk("\n[PANIC] in %s : cannot register kent vseg for process %x\n",
     
    123123    size = CONFIG_VMM_ARGS_SIZE << CONFIG_PPM_PAGE_SHIFT;
    124124    vseg_args = vmm_create_vseg( process , base , size , VSEG_TYPE_DATA );
    125     if( vseg_args == NULL ) 
     125    if( vseg_args == NULL )
    126126    {
    127127        printk("\n[PANIC] in %s : cannot register args vseg for process %x\n",
     
    135135    size = CONFIG_VMM_ENVS_SIZE << CONFIG_PPM_PAGE_SHIFT;
    136136    vseg_envs = vmm_create_vseg( process , base , size , VSEG_TYPE_DATA );
    137     if( vseg_envs == NULL ) 
     137    if( vseg_envs == NULL )
    138138    {
    139139        printk("\n[PANIC] in %s : cannot register envs vseg for process %x\n",
     
    147147    size = (CONFIG_VMM_MMAP_BASE-CONFIG_VMM_HEAP_BASE) << CONFIG_PPM_PAGE_SHIFT;
    148148    vseg_heap = vmm_create_vseg( process , base , size , VSEG_TYPE_HEAP );
    149     if( vseg_heap == NULL ) 
     149    if( vseg_heap == NULL )
    150150    {
    151151        printk("\n[PANIC] in %s : cannot register heap vseg in for process %x\n",
     
    174174    for( i = 0 ; i < 32 ; i++ ) list_root_init( &vmm->mmap_mgr.zombi_list[i] );
    175175
    176     // initialise instrumentation counters
     176    // initialize instrumentation counters
    177177        vmm->pgfault_nr          = 0;
    178178        vmm->u_err_nr            = 0;
     
    227227/////////////////////////////////////////////////
    228228vseg_t * vmm_check_conflict( process_t * process,
    229                              vpn_t       vpn_base, 
     229                             vpn_t       vpn_base,
    230230                             vpn_t       vpn_size )
    231231{
     
    238238        {
    239239                vseg = LIST_ELEMENT( iter , vseg_t , list );
    240                 if( ((vpn_base + vpn_size) > vseg->vpn_base) && 
    241              (vpn_base < (vseg->vpn_base + vseg->vpn_size)) ) return vseg; 
     240                if( ((vpn_base + vpn_size) > vseg->vpn_base) &&
     241             (vpn_base < (vseg->vpn_base + vseg->vpn_size)) ) return vseg;
    242242        }
    243243    return NULL;
     
    249249////////////////////////////////////////////////////////////////////////////////////////////
    250250// @ vmm      : pointer on VMM.
    251 // @ vpn_base : (return value) first alocated page
     251// @ vpn_base : (return value) first allocated page
    252252// @ vpn_size : (return value) number of allocated pages
    253253////////////////////////////////////////////////////////////////////////////////////////////
     
    268268    // update bitmap
    269269    bitmap_set( &mgr->bitmap , index );
    270            
     270
    271271    // release lock on stack allocator
    272272    spinlock_unlock( &mgr->lock );
    273273
    274     // returns vpn_base, vpn_size (one page non allocated) 
     274    // returns vpn_base, vpn_size (one page non allocated)
    275275    *vpn_base = mgr->vpn_base + index * CONFIG_VMM_STACK_SIZE + 1;
    276276    *vpn_size = CONFIG_VMM_STACK_SIZE - 1;
     
    285285// @ vmm      : [in] pointer on VMM.
    286286// @ npages   : [in] requested number of pages.
    287 // @ vpn_base : [out] first allocated page. 
     287// @ vpn_base : [out] first allocated page.
    288288// @ vpn_size : [out] actual number of allocated pages.
    289289////////////////////////////////////////////////////////////////////////////////////////////
     
    297297    vpn_t      base;
    298298    vpn_t      size;
    299     vpn_t      free;   
    300 
    301     // mmap vseg size must be power of 2 
     299    vpn_t      free;
     300
     301    // mmap vseg size must be power of 2
    302302    // compute actual size and index in zombi_list array
    303303    size  = POW2_ROUNDUP( npages );
     
    333333        // compute base
    334334        base = vseg->vpn_base;
    335     }   
    336            
     335    }
     336
    337337    // release lock on mmap allocator
    338338    spinlock_unlock( &mgr->lock );
     
    343343    return 0;
    344344
    345 }  // end vmm_mmap_allocator()
     345}  // end vmm_mmap_alloc()
    346346
    347347//////////////////////////////////////////////
    348348vseg_t * vmm_create_vseg( process_t * process,
    349                           intptr_t    base, 
    350                               intptr_t    size, 
     349                          intptr_t    base,
     350                              intptr_t    size,
    351351                              uint32_t    type )
    352352{
    353353    vseg_t     * vseg;          // created vseg pointer
    354     vpn_t        vpn_base;      // vseg first page 
     354    vpn_t        vpn_base;      // vseg first page
    355355    vpn_t        vpn_size;      // number of pages
    356356        error_t      error;
     
    358358    // get pointer on VMM
    359359        vmm_t * vmm = &process->vmm;
    360  
     360
    361361        vmm_dmsg("\n[INFO] %s enter for process %x / base = %x / size = %x / type = %s\n",
    362362                     __FUNCTION__ , process->pid , base , size , vseg_type_name[type] );
    363    
     363
    364364    // compute base, size, vpn_base, vpn_size, depending on type
    365365    // we use the VMM specific allocators for STACK and MMAP vsegs
     
    379379        size = vpn_size << CONFIG_PPM_PAGE_SHIFT;
    380380    }
    381     else if( (type == VSEG_TYPE_ANON) || 
    382              (type == VSEG_TYPE_FILE) || 
     381    else if( (type == VSEG_TYPE_ANON) ||
     382             (type == VSEG_TYPE_FILE) ||
    383383             (type == VSEG_TYPE_REMOTE) )
    384384    {
     
    407407    if( vseg != NULL )
    408408    {
    409         printk("\n[ERROR] in %s for process %x : new vseg [vpn_base = %x / vpn_size = %x]\n" 
     409        printk("\n[ERROR] in %s for process %x : new vseg [vpn_base = %x / vpn_size = %x]\n"
    410410               "  overlap existing vseg [vpn_base = %x / vpn_size = %x]\n",
    411                __FUNCTION__ , process->pid, vpn_base, vpn_size, 
    412                vseg->vpn_base, vseg->vpn_size ); 
     411               __FUNCTION__ , process->pid, vpn_base, vpn_size,
     412               vseg->vpn_base, vseg->vpn_size );
    413413        return NULL;
    414414    }
     
    434434        rwlock_wr_unlock( &vmm->vsegs_lock );
    435435
    436         vmm_dmsg("\n[INFO] : %s exit for process %x, vseg [%x, %x] has been mapped\n", 
     436        vmm_dmsg("\n[INFO] : %s exit for process %x, vseg [%x, %x] has been mapped\n",
    437437                     __FUNCTION__ , process->pid , vseg->min , vseg->max );
    438  
     438
    439439        return vseg;
    440440
     
    517517    gpt_t * gpt = &process_zero.vmm.gpt;
    518518
    519     // define number of small pages per PTE 
     519    // define number of small pages per PTE
    520520        if( attr & GPT_SMALL ) order = 0;   // 1 small page
    521521        else                   order = 9;   // 512 small pages
     
    531531            req.flags = AF_KERNEL | AF_ZERO;
    532532            page      = (page_t *)kmem_alloc( &req );
    533                 if( page == NULL ) 
     533                if( page == NULL )
    534534        {
    535535            printk("\n[ERROR] in %s : cannot allocate physical memory\n", __FUNCTION__ );
     
    540540        ppn = ppm_page2ppn( page );
    541541        error = hal_gpt_set_pte( gpt , vpn , ppn , attr );
    542                 if( error ) 
     542                if( error )
    543543        {
    544544            printk("\n[ERROR] in %s : cannot register PPE\n", __FUNCTION__ );
     
    546546        }
    547547        }
    548  
     548
    549549        return 0;
    550550} // end vmm_map_vseg()
     
    554554                     vseg_t    * vseg )
    555555{
    556     vpn_t       vpn;        // VPN of current PTE 
    557     vpn_t       vpn_min;    // VPN of first PTE 
     556    vpn_t       vpn;        // VPN of current PTE
     557    vpn_t       vpn_min;    // VPN of first PTE
    558558    vpn_t       vpn_max;    // VPN of last PTE (excluded)
    559559
     
    583583    intptr_t addr_min = base;
    584584        intptr_t addr_max = base + size;
    585     uint32_t shift    = CONFIG_PPM_PAGE_SHIFT;       
     585    uint32_t shift    = CONFIG_PPM_PAGE_SHIFT;
    586586
    587587    // get pointer on vseg
     
    589589
    590590        if( vseg == NULL)  return EINVAL;
    591  
     591
    592592    // get VMM lock protecting vsegs list
    593593        rwlock_wr_lock( &vmm->vsegs_lock );
    594  
     594
    595595        if( (vseg->min > addr_min) || (vseg->max < addr_max) )   // region not included in vseg
    596596    {
     
    659659    error_t   error;
    660660
    661     // this function must be called by in the reference cluster 
     661    // this function must be called by in the reference cluster
    662662    if( process->is_ref == false );
    663663    {
     
    673673
    674674    // if PTE unmapped => allocate one small physical page to map it
    675     if( (attr & GPT_MAPPED) == 0 ) 
     675    if( (attr & GPT_MAPPED) == 0 )
    676676    {
    677677        // get vseg pointer
     
    702702        page_t     * page;
    703703        if( target_cxy == local_cxy )        // target cluster is the local cluster
    704         { 
     704        {
    705705            req.type  = KMEM_PAGE;
    706706            req.size  = 0;
     
    723723        }
    724724
    725         // defineg GPT attributes from vseg flags
     725        // define GPT attributes from vseg flags
    726726        attr = GPT_MAPPED | GPT_SMALL;
    727727        if( vseg->flags & VSEG_USER  ) attr |= GPT_USER;
     
    741741
    742742    *ret_ppn  = ppn;
    743     *ret_attr = attr; 
     743    *ret_attr = attr;
    744744    return 0;
    745745}  // end vmm_get_pte()
     
    751751{
    752752    uint32_t         attr;          // missing page attributes
    753     ppn_t            ppn;           // missing page PPN 
     753    ppn_t            ppn;           // missing page PPN
    754754    error_t          error;         // return value
    755755
     
    766766        rpc_vmm_get_pte_client( ref_cxy , ref_ptr , vpn , &attr , &ppn , &error );
    767767    }
    768     else                              // local cluster is the reference cluster       
     768    else                              // local cluster is the reference cluster
    769769    {
    770770        error = vmm_get_pte( process , vpn , &attr , &ppn );
     
    775775    {
    776776        printk("\n[ERROR] in %s : cannot allocate memory / process = %x / vpn = %x\n",
    777                __FUNCTION__ , process->pid , vpn ); 
     777               __FUNCTION__ , process->pid , vpn );
    778778            return ENOMEM;
    779779    }
     
    784784    {
    785785        printk("\n[ERROR] in %s : cannot register PTE / process = %x / vpn = %x\n",
    786                __FUNCTION__ , process->pid , vpn ); 
     786               __FUNCTION__ , process->pid , vpn );
    787787        return ENOMEM;
    788788    }
    789  
     789
    790790    return 0;
    791791}  // end vmm_handle_page_fault()
     
    807807    }
    808808
    809     // access page table 
     809    // access page table
    810810    error_t  error;
    811811    vpn_t    vpn;
     
    834834        return error;
    835835    }
    836  
     836
    837837    // return paddr
    838838    *paddr = (((paddr_t)ppn) << CONFIG_PPM_PAGE_SHIFT) | offset;
    839839    return 0;
    840  
     840
    841841}  // end vmm_v2p_translate()
    842842
Note: See TracChangeset for help on using the changeset viewer.