Changeset 630 for trunk/hal/tsar_mips32

Timestamp:

May 21, 2019, 6:00:06 PM (6 years ago)

Author:

alain

Message:

1) Fix a bug in the vfs_add_special_dentries() function:
The <.> and <..> dentries must not be created on IOC and on the mapper
for the VFS root directory.
2) Fix a bug in the hal_gpt_allocate_pt2 function, related to the
use of the TSAR_LOCKED attribute to avoid concurrent mapping of the PTD1.

File:

• trunk/hal/tsar_mips32/core/hal_gpt.c (modified) (5 diffs)

trunk/hal/tsar_mips32/core/hal_gpt.c

@@ -318 +318 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// This static function check that a PTE1 entry, in the PT1 of a possibly remote GPT,
-// identified by the <pte1_xp> argument is mapped. If this entry is not mapped, 
-// it allocates a - local or remote - PT2, updates the PTE1 value in PT1, and
-// returns the PTE1 value in the <pte1> buffer.
-// It uses the TSR_MMU_LOCKED attribute in PTE1 to handle possible concurrent
-// mappings of the missing PTE1:
-// - If the PTE1 is unmapped and unlocked => it tries to atomically lock this PTE1,
-//   and map it if lock is successful.
-// - If the PTE1 is unmapped but locked => it poll the PTE1 value, unti the mapping
-//   is done by the other thread.
-// - If the PTE1 is already mapped => it does nothing
-// It returns an error if it cannot allocate memory fot a new PT2.
+// This static function returns in the <ptd1_value> buffer the current value of
+// the PT1 entry identified by the <pte1_xp> argument, that must contain a PTD1
+// (i.e. a pointer on a PT2). If this PT1 entry is not mapped yet, it allocates a
+// new PT2 and updates the PT1 entry, using the TSAR_MMU_LOCKED attribute in PT1
+// entry, to handle possible concurrent mappings of the missing PTD1:
+// 1) If the PT1 entry is unmapped, it tries to atomically lock this PTD1.
+//    - if the atomic lock is successful it allocates a new PT1, and updates the PTD1.
+//    - else, it simply waits, in a polling loop, the mapping done by another thread.
+//    In both cases, returns the PTD1 value, when the mapping is completed. 
+// 2) If the PT1 entry is already mapped, it returns the PTD1 value, and does
+//    nothing else.
 /////////////////////////////////////////////////////////////////////////////////////////
-static error_t hal_gpt_allocate_pt2( xptr_t     pte1_xp,
-                                   uint32_t * pte1_value ) 
-{
-    cxy_t      gpt_cxy;     // target GPT cluster = GET_CXY( pte1_xp );
-    uint32_t   pte1;        // PTE1 value
+static error_t hal_gpt_allocate_pt2( xptr_t     ptd1_xp,
+                                     uint32_t * ptd1_value ) 
+{
+    cxy_t      gpt_cxy;     // target GPT cluster = GET_CXY( ptd1_xp );
+    uint32_t   ptd1;        // PTD1 value
     ppn_t      pt2_ppn;     // PPN of page containing the new PT2
     bool_t     atomic;
@@ -342 +341 @@
 
     // get GPT cluster identifier
-    gpt_cxy = GET_CXY( pte1_xp );
-
-    // get current pte1 value
-    pte1 = hal_remote_l32( pte1_xp );
-
-    if( ((pte1 & TSAR_PTE_MAPPED) == 0) &&   // PTE1 unmapped and unlocked
-        ((pte1 & TSAR_PTE_LOCKED) == 0) )    // try to allocate a new PT2
+    gpt_cxy = GET_CXY( ptd1_xp );
+
+    // get current ptd1 value
+    ptd1 = hal_remote_l32( ptd1_xp );
+
+    if( (ptd1 & TSAR_PTE_MAPPED) == 0)    // PTD1 unmapped and unlocked
         {
-        // atomically lock the PTE1 to prevent concurrent PTE1 mappings
-        atomic = hal_remote_atomic_cas( pte1_xp,
-                                        pte1,
-                                        pte1 | TSAR_PTE_LOCKED );
-
-        if( atomic )  // PTE1 successfully locked
+        // atomically lock the PTD1 to prevent concurrent PTD1 mappings
+        atomic = hal_remote_atomic_cas( ptd1_xp,
+                                        ptd1,
+                                        ptd1 | TSAR_PTE_LOCKED );
+
+        if( atomic )  // PTD1 successfully locked
                 {
             // allocate one physical page for PT2
@@ -377 +375 @@
             pt2_ppn = ppm_page2ppn( page_xp );
 
-            // build  PTE1 value
-            pte1 = TSAR_PTE_MAPPED | TSAR_PTE_SMALL | pt2_ppn;
+            // build  PTD1
+            ptd1 = TSAR_PTE_MAPPED | TSAR_PTE_SMALL | pt2_ppn;
 
             // set the PTD1 value in PT1
-            hal_remote_s32( pte1_xp , pte1 );
+            hal_remote_s32( ptd1_xp , ptd1 );
             hal_fence();
 
@@ -388 +386 @@
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_GPT_ALLOCATE_PT2 < cycle )
-printk("\n[%s] : thread[%x,%x] map PTE1 / cxy %x / ix1 %d / pt1 %x / ptd1 %x\n", 
-__FUNCTION__, this->process->pid, this->trdid, gpt_cxy, ix1, pt1_ptr, pte1 );
+printk("\n[%s] : thread[%x,%x] map PTD1 / cxy %x / ix1 %d / pt1 %x / ptd1 %x\n", 
+__FUNCTION__, this->process->pid, this->trdid, gpt_cxy, ix1, pt1_ptr, ptd1 );
 #endif
         }
-        else
+        else         // PTD1 modified by another thread 
         {
-            // poll PTE1 until mapped by another thread
-            while( (pte1 & TSAR_PTE_MAPPED) == 0 )  pte1 = hal_remote_l32( pte1_xp );
+            // poll PTD1 until mapped by another thread
+            while( (ptd1 & TSAR_PTE_MAPPED) == 0 )  ptd1 = hal_remote_l32( ptd1_xp );
         } 
     }
-    else if( ((pte1 & TSAR_PTE_MAPPED) == 0) &&
-             ((pte1 & TSAR_PTE_LOCKED) != 0) )  
-    {
-        // poll PTE1 until mapped by another thread
-        while( (pte1 & TSAR_PTE_MAPPED) == 0 )  pte1 = hal_remote_l32( pte1_xp );
-        }
-    else                                   // PTE1 mapped => just use it
+    else                                   // PTD1 mapped => just use it
     {
 
@@ -411 +403 @@
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_HAL_GPT_ALLOCATE_PT2 < cycle )
-printk("\n[%s] : thread[%x,%x] PTE1 mapped / cxy %x / ix1 %d / pt1 %x / ptd1 %x\n", 
-__FUNCTION__, this->process->pid, this->trdid, gpt_cxy, ix1, pt1_ptr, pte1 );
+printk("\n[%s] : thread[%x,%x] PTD1 mapped / cxy %x / ix1 %d / pt1 %x / ptd1 %x\n", 
+__FUNCTION__, this->process->pid, this->trdid, gpt_cxy, ix1, pt1_ptr, ptd1 );
 #endif
 
     }
 
-    *pte1_value = pte1;
+    *ptd1_value = ptd1;
     return 0;