Changeset 656 for trunk/kernel/libk

Timestamp:

Dec 6, 2019, 12:07:51 PM (5 years ago)

Author:

alain

Message:

Fix several bugs in the FATFS and in the VFS,
related to the creation of big files requiring
more than 4 Kbytes (one cluster) on device.

Location:

trunk/kernel/libk

Files:

• grdxt.c (modified) (11 diffs)
• grdxt.h (modified) (5 diffs)
• list.h (modified) (7 diffs)
• xlist.h (modified) (1 diff)

trunk/kernel/libk/grdxt.c

@@ -315 +315 @@
                 else                    
                 {
-                    *found_key = (ix1 << (w2+w3)) | (ix2 << w1) | ix3;
+                    *found_key = (ix1 << (w2+w3)) | (ix2 << w3) | ix3;
                     return ptr3[ix3];
                 }
@@ -343 +343 @@
     grdxt_t * rt_ptr = GET_PTR( rt_xp );
 
+#if DEBUG_GRDXT_INSERT
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if(DEBUG_GRDXT_INSERT < cycle)
+printk("\n[%s] enter / rt_xp (%x,%x) / key %x / value %x\n",
+__FUNCTION__, rt_cxy, rt_ptr, key, (intptr_t)value ); 
+#endif
+
     // get widths
     uint32_t        w1 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix1_width ) );
@@ -348 +355 @@
     uint32_t        w3 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix3_width ) );
 
+#if DEBUG_GRDXT_INSERT
+if(DEBUG_GRDXT_INSERT < cycle)
+printk("\n[%s] get widths : w1 %d / w2 %d / w3 %d\n",
+__FUNCTION__, w1, w2, w3 ); 
+#endif
+
 // Check key value
 assert( ((key >> (w1 + w2 + w3)) == 0 ), "illegal key value %x\n", key );
@@ -356 +369 @@
         uint32_t        ix3 = key & ((1 << w3) - 1);         // index in level 3 array
 
+#if DEBUG_GRDXT_INSERT
+if(DEBUG_GRDXT_INSERT < cycle)
+printk("\n[%s] compute indexes : ix1 %d / ix2 %d / ix3 %d\n",
+__FUNCTION__, ix1, ix2, ix3 ); 
+#endif
+
     // get ptr1
     void ** ptr1 = hal_remote_lpt( XPTR( rt_cxy , &rt_ptr->root ) );
@@ -361 +380 @@
     if( ptr1 == NULL ) return -1;
 
+#if DEBUG_GRDXT_INSERT
+if(DEBUG_GRDXT_INSERT < cycle)
+printk("\n[%s] compute ptr1 = %x\n",
+__FUNCTION__, (intptr_t)ptr1 ); 
+#endif
+
     // get ptr2
     void ** ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
+
+#if DEBUG_GRDXT_INSERT
+if(DEBUG_GRDXT_INSERT < cycle)
+printk("\n[%s] get current ptr2 = %x\n",
+__FUNCTION__, (intptr_t)ptr2 ); 
+#endif
 
     // allocate memory for the missing level_2 array if required
@@ -374 +405 @@
 
         if( ptr2 == NULL ) return -1;
-
+        
         // update level_1 entry
         hal_remote_spt( XPTR( rt_cxy , &ptr1[ix1] ) , ptr2 );
+
+#if DEBUG_GRDXT_INSERT
+if(DEBUG_GRDXT_INSERT < cycle)
+printk("\n[%s] update ptr1[%d] : &ptr1[%d] = %x / ptr2 = %x\n",
+__FUNCTION__, ix1, ix1, &ptr1[ix1], ptr2 );
+#endif
+
     }
 
     // get ptr3
     void ** ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
+
+#if DEBUG_GRDXT_INSERT
+if(DEBUG_GRDXT_INSERT < cycle)
+printk("\n[%s] get current ptr3 = %x\n",
+__FUNCTION__, (intptr_t)ptr3 ); 
+#endif
 
     // allocate memory for the missing level_3 array if required
@@ -395 +439 @@
         // update level_2 entry
         hal_remote_spt( XPTR( rt_cxy , &ptr2[ix2] ) , ptr3 );
+
+#if DEBUG_GRDXT_INSERT
+if(DEBUG_GRDXT_INSERT < cycle)
+printk("\n[%s] update  ptr2[%d] : &ptr2[%d] %x / ptr3 %x\n",
+__FUNCTION__, ix2, ix2, &ptr2[ix2], ptr3 );
+#endif
+
     }
 
     // register value in level_3 array
     hal_remote_spt( XPTR( rt_cxy , &ptr3[ix3] ) , value );
+
+#if DEBUG_GRDXT_INSERT
+if(DEBUG_GRDXT_INSERT < cycle)
+printk("\n[%s] update  ptr3[%d] : &ptr3[%d] %x / value %x\n",
+__FUNCTION__, ix3, ix3, &ptr3[ix3], value );
+#endif
 
     hal_fence();
@@ -498 +555 @@
         uint32_t       ix3;
 
+    void        ** ptr1;
+    void        ** ptr2;
+    void        ** ptr3;
+
 // check rt_xp
 assert( (rt_xp != XPTR_NULL) , "pointer on radix tree is NULL\n" );
@@ -510 +571 @@
     uint32_t       w3 = hal_remote_l32( XPTR( rt_cxy , &rt_ptr->ix3_width ) );
 
-    void ** ptr1 = hal_remote_lpt( XPTR( rt_cxy , &rt_ptr->root ) );
+    ptr1 = hal_remote_lpt( XPTR( rt_cxy , &rt_ptr->root ) );
 
         printk("\n***** Generic Radix Tree for <%s>\n", name );
@@ -516 +577 @@
         for( ix1=0 ; ix1 < (uint32_t)(1<<w1) ; ix1++ )
         {
-            void ** ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
+            ptr2 = hal_remote_lpt( XPTR( rt_cxy , &ptr1[ix1] ) );
         if( ptr2 == NULL )  continue;
     
         for( ix2=0 ; ix2 < (uint32_t)(1<<w2) ; ix2++ )
         {
-                void ** ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
+                ptr3 = hal_remote_lpt( XPTR( rt_cxy , &ptr2[ix2] ) );
             if( ptr3 == NULL ) continue;
 
@@ -530 +591 @@
 
                 uint32_t key = (ix1<<(w2+w3)) + (ix2<<w3) + ix3;
-                printk(" - key = %x / value = %x\n", key , (intptr_t)value );
+                printk(" - key = %x / value = %x / ptr1 = %x / ptr2 = %x / ptr3 = %x\n",
+                key, (intptr_t)value, (intptr_t)ptr1, (intptr_t)ptr2, (intptr_t)ptr3 );
             }
         }

trunk/kernel/libk/grdxt.h

@@ -61 +61 @@
 /*******************************************************************************************
  * This function initialises the radix-tree descriptor,
+ * and allocates memory for the first level array of pointers.
  * It must be called by a local thread.
- * and allocates memory for the first level array of pointers.
  *******************************************************************************************
  * @ rt        : pointer on the radix-tree descriptor.
@@ -77 +77 @@
 /*******************************************************************************************
  * This function releases all memory allocated to the radix-tree infrastructure.
+ * A warning message is printed on the kernel TXT0 if the radix tree is not empty.
  * It must be called by a local thread.
- * A warning message is printed on the kernel TXT0 if the radix tree is not empty.
  *******************************************************************************************
  * @ rt      : pointer on the radix-tree descriptor.
@@ -86 +86 @@
 /*******************************************************************************************
  * This function insert a new item in the radix-tree.
+ * It dynamically allocates memory for new second and third level arrays if required.
  * It must be called by a local thread.
- * It dynamically allocates memory for new second and third level arrays if required.
  *******************************************************************************************
  * @ rt      : pointer on the radix-tree descriptor.
@@ -100 +100 @@
 /*******************************************************************************************
  * This function removes an item identified by its key from the radix tree,
+ * and returns a pointer on the removed item. No memory is released.
  * It must be called by a local thread.
- * and returns a pointer on the removed item. No memory is released.
  *******************************************************************************************
  * @ rt      : pointer on the radix-tree descriptor.
@@ -124 +124 @@
 /*******************************************************************************************
  * This function scan all radix-tree entries in increasing key order, starting from
+ * the value defined by the <start_key> argument, and return a pointer on the first valid
+ * registered item, and the found item key value.
  * It must be called by a local thread.
- * the value defined by the <key> argument, and return a pointer on the first valid
- * registered item, and the found item key value.
  *******************************************************************************************
  * @ rt         : pointer on the radix-tree descriptor.
  * @ start_key  : key starting value for the scan.
  * @ found_key  : [out] buffer for found key value.
- * @ return pointer on first valid item if found / return NULL if not found.
+ * @ return pointer on first valid item if found / return NULL if no item found.
  ******************************************************************************************/
 void * grdxt_get_first( grdxt_t  * rt,

trunk/kernel/libk/list.h

@@ -1 +1 @@
 /*
- * list.h - Double circular linked list
+ * list.h - Local double circular linked list, using local pointers.
  *
  * Authors Ghassan Almaless  (2008,2009,2010,2011,2012)
@@ -91 +91 @@
 
 /***************************************************************************
- * This macro returns t pointer on the first element of a list. 
+ * This macro returns a pointer on the first element of a list. 
  ***************************************************************************
  * @ root     : pointer on the list root
@@ -171 +171 @@
                                    list_entry_t * entry )
 {
-    list_entry_t * next = root->next;  
-
-        entry->next = next;
+    list_entry_t * first = root->next;  
+
+        entry->next = first;
         entry->pred = root;
   
-        root->next = entry;
-        next->pred = entry;
+        root->next  = entry;
+        first->pred = entry;
 }
 
@@ -190 +190 @@
                                   list_entry_t * entry )
 {
-    list_entry_t * pred = root->pred;
+    list_entry_t * last = root->pred;
 
         entry->next = root;
-        entry->pred = pred;
+        entry->pred = last;
   
         root->pred = entry;
-        pred->next = entry;
+        last->next = entry;
 }
 
@@ -366 +366 @@
                                           list_entry_t * entry )
 {
-    list_entry_t * next = hal_remote_lpt( XPTR( cxy , &root->next ) );
+    list_entry_t * first = hal_remote_lpt( XPTR( cxy , &root->next ) );
         
-        hal_remote_spt( XPTR( cxy , &entry->next ) , next );
+        hal_remote_spt( XPTR( cxy , &entry->next ) , first );
         hal_remote_spt( XPTR( cxy , &entry->pred ) , root );
   
-        hal_remote_spt( XPTR( cxy , &root->next ) , entry );
-        hal_remote_spt( XPTR( cxy , &next->pred ) , entry );
+        hal_remote_spt( XPTR( cxy , &root->next )  , entry );
+        hal_remote_spt( XPTR( cxy , &first->pred ) , entry );
 }
 
@@ -387 +387 @@
                                          list_entry_t * entry )
 {
-    list_entry_t * pred = hal_remote_lpt( XPTR( cxy , &root->pred ) );
+    list_entry_t * last = hal_remote_lpt( XPTR( cxy , &root->pred ) );
         
         hal_remote_spt( XPTR( cxy , &entry->next ) , root );
-        hal_remote_spt( XPTR( cxy , &entry->pred ) , pred );
+        hal_remote_spt( XPTR( cxy , &entry->pred ) , last );
   
         hal_remote_spt( XPTR( cxy , &root->pred ) , entry );
-        hal_remote_spt( XPTR( cxy , &pred->next ) , entry );
+        hal_remote_spt( XPTR( cxy , &last->next ) , entry );
 }
 
@@ -401 +401 @@
  ***************************************************************************
  * @ cxy     : remote list cluster identifier
- * @ entry   : pointer on the entry to be removed.
+ * @ entry   : local pointer on the remote entry to be removed.
  **************************************************************************/
 static inline void list_remote_unlink( cxy_t          cxy,

trunk/kernel/libk/xlist.h

@@ -1 +1 @@
 /*
- * xlist.h - Double Circular Linked lists, using extended pointers.
+ * xlist.h - Trans-cluster double circular linked list, using extended pointers.
  *
  * Author : Alain Greiner (2016,2017,2018,2019)