Ignore:
Timestamp:
Aug 16, 2017, 3:27:05 PM (4 years ago)
Author:
alain
Message:

Simplify the hal_mmu_exception() function.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/hal/tsar_mips32/core/hal_gpt.c

    r315 r391  
    3636////////////////////////////////////////////////////////////////////////////////////////
    3737// This define the masks for the TSAR MMU PTE attributes. (from TSAR MMU specification)
    38 // the GPT masks are derived from the TSAR MMU PTE attributes
    39 // in the TSAR specific hal_gpt_create() function.
    4038////////////////////////////////////////////////////////////////////////////////////////
    4139
     
    7674#define TSAR_MMU_ATTR_FROM_PTE2( pte2 )    (pte2 & 0xFFC000FF)
    7775
    78 /****************************************************************************************
    79  * These global variables defines the masks for the Generic Page Table Entry attributes,
    80  * and must be defined in all GPT implementation.
    81  ***************************************************************************************/
    82 
    83 uint32_t  GPT_MAPPED;
    84 uint32_t  GPT_SMALL;
    85 uint32_t  GPT_READABLE;
    86 uint32_t  GPT_WRITABLE; 
    87 uint32_t  GPT_EXECUTABLE;
    88 uint32_t  GPT_CACHABLE;
    89 uint32_t  GPT_USER; 
    90 uint32_t  GPT_DIRTY;
    91 uint32_t  GPT_ACCESSED;
    92 uint32_t  GPT_GLOBAL;
    93 uint32_t  GPT_COW;
    94 uint32_t  GPT_SWAP;
    95 uint32_t  GPT_LOCKED;
    96 
    9776/////////////////////////////////////
    9877error_t hal_gpt_create( gpt_t * gpt )
     
    128107        gpt->page = GET_PTR( page_xp );
    129108
     109/*
    130110    // initialize PTE entries attributes masks
    131111    GPT_MAPPED     = TSAR_MMU_PRESENT;
     
    142122    GPT_SWAP       = TSAR_MMU_SWAP;
    143123    GPT_LOCKED     = TSAR_MMU_LOCKED;
    144 
     124*/
    145125        return 0;
    146126} // end hal_gpt_create()
     
    174154        {
    175155        pte1 = pt1[ix1];
    176                 if( (pte1 & GPT_MAPPED) != 0 )  // PTE1 valid
     156                if( (pte1 & TSAR_MMU_PRESENT) != 0 )  // PTE1 valid
    177157        {
    178             if( (pte1 & GPT_SMALL) == 0 )   // BIG page
     158            if( (pte1 & TSAR_MMU_PTD1) == 0 )   // BIG page
    179159            {
    180                 if( (pte1 & GPT_USER) != 0 )
     160                if( (pte1 & TSAR_MMU_USER) != 0 )
    181161                {
    182162                    // warning message
    183163                    printk("\n[WARNING] in %s : found an USER BIG page / ix1 = %d\n",
    184                            __FUNCTION__ , ix1 );
     164                    __FUNCTION__ , ix1 );
    185165
    186166                    // release the big physical page if reference cluster
     
    192172                }
    193173            }
    194             else                           // SMALL page
     174            else                              // SMALL page
    195175            {
    196176                // get local pointer on PT2
     
    205185                    {
    206186                        attr = TSAR_MMU_ATTR_FROM_PTE2( pt2[2 * ix2] );
    207                                 if( ((attr & GPT_MAPPED) != 0 ) && ((attr & GPT_USER) != 0) ) 
     187                                if( ((attr & TSAR_MMU_PRESENT) != 0 ) && ((attr & TSAR_MMU_USER) != 0) ) 
    208188                        {
    209189                            // release the physical page
     
    250230        {
    251231        pte1 = pt1[ix1];
    252                 if( (pte1 & GPT_MAPPED) != 0 )
     232                if( (pte1 & TSAR_MMU_PRESENT) != 0 )
    253233        {
    254             if( (pte1 & GPT_SMALL) == 0 )  // BIG page
     234            if( (pte1 & TSAR_MMU_PTD1) == 0 )  // BIG page
    255235            {
    256236                printk(" - BIG   : pt1[%d] = %x\n", ix1 , pte1 );
     
    267247                    pte2_attr = TSAR_MMU_ATTR_FROM_PTE2( pt2[2 * ix2] );
    268248                    pte2_ppn  = TSAR_MMU_PPN_FROM_PTE2( pt2[2 * ix2 + 1] );
    269                             if( (pte2_attr & GPT_MAPPED) != 0 )
     249                            if( (pte2_attr & TSAR_MMU_PRESENT) != 0 )
    270250                    {
    271251                        printk(" - SMALL   : pt1[%d] = %x / pt2[%d] / pt2[%d]\n",
     
    306286
    307287    pt1   = gpt->ptr;
    308         small = (attr & GPT_SMALL);
     288        small = (attr & TSAR_MMU_PTD1);
    309289
    310290    // get PT1 entry value
     
    331311    // From this point, the requested PTE is a PTE2 (small page)
    332312
    333         if( (pte1 & GPT_MAPPED) == 0 )      // the PT1 entry is not valid
     313        if( (pte1 & TSAR_MMU_PRESENT) == 0 )      // the PT1 entry is not valid
    334314        {
    335315        // allocate one physical page for the PT2
     
    376356        {
    377357        // This valid entry must be a PTD1
    378         if( (pte1 & GPT_SMALL) == 0 )
     358        if( (pte1 & TSAR_MMU_PTD1) == 0 )
    379359        {
    380360                        printk("\n[ERROR] in %s : set a small page in a big PT1 entry / PT1[%d] = %x\n",
     
    418398    pte1 = pt1[ix1];
    419399
    420         if( (pte1 & GPT_MAPPED) == 0 )   // PT1 entry not present
     400        if( (pte1 & TSAR_MMU_PRESENT) == 0 )   // PT1 entry not present
    421401        {
    422402                *attr = 0;
     
    424404        }
    425405
    426         if( (pte1 & GPT_SMALL) == 0 )     // it's a PTE1
     406        if( (pte1 & TSAR_MMU_PTD1) == 0 )     // it's a PTE1
    427407        {
    428408                *attr = TSAR_MMU_ATTR_FROM_PTE1( pte1 );
     
    454434    kmem_req_t req;
    455435
     436    // get ix1 & ix2 indexes
    456437    uint32_t   ix1 = TSAR_MMU_IX1_FROM_VPN( vpn );
    457438    uint32_t   ix2 = TSAR_MMU_IX2_FROM_VPN( vpn );
     439
     440    // get pointer on calling process
     441    process_t  * process = CURRENT_THREAD->process;
     442
     443    // compute is_ref
     444    bool_t is_ref = ( GET_CXY( process->ref_xp ) == local_cxy );
    458445
    459446    // get PTE1 value
     
    461448    pte1     = pt1[ix1];
    462449
    463         if( (pte1 & GPT_MAPPED) == 0 )   // PT1 entry not present
     450        if( (pte1 & TSAR_MMU_PRESENT) == 0 )   // PT1 entry not present
    464451        {
    465452                return;
    466453        }
    467454
    468         if( (pte1 & GPT_SMALL) == 0 )     // it's a PTE1
     455        if( (pte1 & TSAR_MMU_PTD1) == 0 )      // it's a PTE1
    469456        {
    470457        // get PPN
     
    475462            hal_fence();
    476463
    477         // releases the big page
    478         req.type  = KMEM_PAGE;
    479             req.size  = 9;
    480         req.ptr   = (void*)(ppn << CONFIG_PPM_PAGE_SHIFT);
    481             kmem_free( &req );
     464        // releases the physical page if local
     465        // req.type  = KMEM_PAGE;
     466            // req.size  = 9;
     467        // req.ptr   = (void*)(ppn << CONFIG_PPM_PAGE_SHIFT);
     468            // kmem_free( &req );
    482469
    483470        return;
    484471        }
    485     else                              // it's a PTD1
     472    else                                   // it's a PTD1
    486473    {
    487474        // compute PT2 base address
     
    493480
    494481        // unmap the small page
    495             pt2[2*ix2]   = 0;
    496             hal_fence();
    497             pt2[2*ix2+1] = 0;
    498             hal_fence();
    499 
    500         // releases the small page
    501         req.type  = KMEM_PAGE;
    502             req.size  = 0;
    503         req.ptr   = (void*)(ppn << CONFIG_PPM_PAGE_SHIFT);
    504             kmem_free( &req );
     482            pt2[2*ix2]   = 0;            // only attr is reset
     483            hal_fence();       
     484
     485        // releases the small page
     486        // req.type  = KMEM_PAGE;
     487            // req.size  = 0;
     488        // req.ptr   = (void*)(ppn << CONFIG_PPM_PAGE_SHIFT);
     489            // kmem_free( &req );
    505490
    506491        return;
     
    534519
    535520    // If present, the page must be small
    536         if( ((pte1 & GPT_MAPPED) != 0) && ((pte1 & GPT_SMALL) == 0) )
     521        if( ((pte1 & TSAR_MMU_PRESENT) != 0) && ((pte1 & TSAR_MMU_PTD1) == 0) )
    537522    {
    538523        printk("\n[ERROR] in %s : try to lock a big page / PT1[%d] = %x\n",
     
    541526    }
    542527
    543         if( (pte1 & GPT_MAPPED) == 0 )  // missing PT1 entry   
     528        if( (pte1 & TSAR_MMU_PRESENT) == 0 )  // missing PT1 entry   
    544529        {
    545530        // allocate one physical page for PT2
     
    585570    {
    586571        // This valid entry must be a PTD1
    587         if( (pte1 & GPT_SMALL) == 0 )
     572        if( (pte1 & TSAR_MMU_PTD1) == 0 )
    588573        {
    589574                        printk("\n[ERROR] in %s : set a small page in a big PT1 entry / PT1[%d] = %x\n",
     
    647632
    648633    // check PTE1 present and small page
    649     if( ((pte1 & GPT_MAPPED) == 0) || ((pte1 & GPT_SMALL) == 0) )
     634    if( ((pte1 & TSAR_MMU_PRESENT) == 0) || ((pte1 & TSAR_MMU_PTD1) == 0) )
    650635    {
    651636        printk("\n[ERROR] in %s : try to unlock a big or undefined page / PT1[%d] = %x\n",
     
    665650
    666651    // check PTE2 present and locked
    667     if( ((attr & GPT_MAPPED) == 0) || ((attr & GPT_LOCKED) == 0) );
     652    if( ((attr & TSAR_MMU_PRESENT) == 0) || ((attr & GPT_LOCKED) == 0) );
    668653    {
    669654        printk("\n[ERROR] in %s : try to unlock an undefined page / PT1[%d] = %x\n",
     
    710695        {
    711696        pte1 = src_pt1[ix1];
    712                 if( (pte1 & GPT_MAPPED) != 0 )
     697                if( (pte1 & TSAR_MMU_PRESENT) != 0 )
    713698        {
    714             if( (pte1 & GPT_SMALL) == 0 )  // PTE1 => big kernel page
     699            if( (pte1 & TSAR_MMU_PTD1) == 0 )  // PTE1 => big kernel page
    715700            {
    716701                // big kernel pages are shared by all processes => copy it
     
    754739                    pte2_attr = TSAR_MMU_ATTR_FROM_PTE2( src_pt2[2 * ix2] );
    755740
    756                             if( (pte2_attr & GPT_MAPPED) != 0 )  // valid PTE2 in SRC_GPT
     741                            if( (pte2_attr & TSAR_MMU_PRESENT) != 0 )  // valid PTE2 in SRC_GPT
    757742                    {
    758743                        // get GPT_WRITABLE & PPN
Note: See TracChangeset for help on using the changeset viewer.