Changeset 602 for trunk/kernel/fs

Timestamp:

Dec 3, 2018, 12:15:53 PM (6 years ago)

Author:

alain

Message:

Improve the FAT32 file system to support cat, rm, cp commands.

Location:

trunk/kernel/fs

Files:

• devfs.c (modified) (19 diffs)
• fatfs.c (modified) (22 diffs)
• fatfs.h (modified) (9 diffs)
• ramfs.c (modified) (2 diffs)
• vfs.c (modified) (55 diffs)
• vfs.h (modified) (19 diffs)

trunk/kernel/fs/devfs.c

@@ -86 +86 @@
 
 /////////////////////////////////////////////////
-void devfs_global_init( xptr_t   parent_inode_xp,
+void devfs_global_init( xptr_t   root_inode_xp,
                         xptr_t * devfs_dev_inode_xp,
                         xptr_t * devfs_external_inode_xp )
 {
     error_t  error;
+    xptr_t   unused_xp;   // required by vfs_add_child_in_parent()
 
     // creates DEVFS "dev" inode in cluster 0
@@ -96 +97 @@
                                      INODE_TYPE_DIR,
                                      FS_TYPE_DEVFS,
-                                     parent_inode_xp,
+                                     root_inode_xp,
                                      "dev",
-                                     NULL,
-                                     devfs_dev_inode_xp ); 
+                                     &unused_xp,
+                                     devfs_dev_inode_xp );
 
     assert( (error == 0) , "cannot create <dev>\n" );
@@ -117 +118 @@
                                      *devfs_dev_inode_xp,
                                      "external",
-                                     NULL,
-                                     devfs_external_inode_xp ); 
+                                     &unused_xp,
+                                     devfs_external_inode_xp );
 
     assert( (error == 0) , "cannot create <external>\n" );
@@ -129 +130 @@
 #endif
 
-} 
+}  // end devfs_global_init()
 
 ///////////////////////////////////////////////////
@@ -141 +142 @@
     chdev_t     * chdev_ptr;
     xptr_t        inode_xp;
+    cxy_t         inode_cxy;
+    vfs_inode_t * inode_ptr;
     uint32_t      channel;
+    xptr_t        unused_xp;    // required by add_child_in_parent()
 
     // create "internal" directory 
@@ -150 +154 @@
                              devfs_dev_inode_xp,
                              node_name,
-                             NULL,
+                             &unused_xp,
                              devfs_internal_inode_xp );
 #if DEBUG_DEVFS_INIT 
@@ -164 +168 @@
     if( chdev_xp != XPTR_NULL)
     {
-        chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+        chdev_ptr = GET_PTR( chdev_xp );
         vfs_add_child_in_parent( local_cxy,
                                  INODE_TYPE_DEV,
@@ -170 +174 @@
                                  *devfs_internal_inode_xp,
                                  chdev_ptr->name,
-                                 GET_PTR( chdev_xp ),
+                                 &unused_xp,
                                  &inode_xp );
+
+        // update child inode "extend" field
+        inode_cxy = GET_CXY( inode_xp );
+        inode_ptr = GET_PTR( inode_xp );
+        hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+        
 #if DEBUG_DEVFS_INIT
 cycle = (uint32_t)hal_get_cycles();
@@ -184 +194 @@
     for( channel = 0 ; channel < LOCAL_CLUSTER->cores_nr ; channel++ )
     {
-        chdev_xp = chdev_dir.dma[channel];
+        chdev_xp  = chdev_dir.dma[channel];
         if( chdev_xp != XPTR_NULL)
         {
-            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+            chdev_ptr = GET_PTR( chdev_xp );
             vfs_add_child_in_parent( local_cxy,
                                      INODE_TYPE_DEV,
@@ -193 +203 @@
                                      *devfs_internal_inode_xp,
                                      chdev_ptr->name,
-                                     GET_PTR( chdev_xp ),
+                                     &unused_xp,
                                      &inode_xp );
+
+            // update child inode "extend" field
+            inode_cxy = GET_CXY( inode_xp );
+            inode_ptr = GET_PTR( inode_xp );
+            hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+        
 #if DEBUG_DEVFS_INIT
 cycle = (uint32_t)hal_get_cycles();
@@ -209 +225 @@
     {
         chdev_cxy = GET_CXY( chdev_xp );
-        chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+        chdev_ptr = GET_PTR( chdev_xp );
         if( chdev_cxy == local_cxy )
         {
@@ -217 +233 @@
                                      devfs_external_inode_xp,
                                      chdev_ptr->name,
-                                     GET_PTR( chdev_xp ),
+                                     &unused_xp,
                                      &inode_xp );
+
+            // update child inode "extend" field
+            inode_cxy = GET_CXY( inode_xp );
+            inode_ptr = GET_PTR( inode_xp );
+            hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+        
 #if DEBUG_DEVFS_INIT
 cycle = (uint32_t)hal_get_cycles();
@@ -233 +255 @@
     {
         chdev_cxy = GET_CXY( chdev_xp );
-        chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+        chdev_ptr = GET_PTR( chdev_xp );
         if( chdev_cxy == local_cxy )
         {
@@ -241 +263 @@
                                      devfs_external_inode_xp,
                                      chdev_ptr->name,
-                                     GET_PTR( chdev_xp ),
+                                     &unused_xp,
                                      &inode_xp );
+
+            // update child inode "extend" field
+            inode_cxy = GET_CXY( inode_xp );
+            inode_ptr = GET_PTR( inode_xp );
+            hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+        
 #if DEBUG_DEVFS_INIT
 cycle = (uint32_t)hal_get_cycles();
@@ -256 +284 @@
     {
         chdev_xp = chdev_dir.txt_rx[channel];
+        if( chdev_xp != XPTR_NULL )
+        {
+            chdev_cxy = GET_CXY( chdev_xp );
+            chdev_ptr = GET_PTR( chdev_xp );
+            if( chdev_cxy == local_cxy )
+            {
+                vfs_add_child_in_parent( local_cxy,
+                                         INODE_TYPE_DEV,
+                                         FS_TYPE_DEVFS,
+                                         devfs_external_inode_xp,
+                                         chdev_ptr->name,
+                                         &unused_xp,
+                                         &inode_xp );
+
+                // update child inode "extend" field
+                inode_cxy = GET_CXY( inode_xp );
+                inode_ptr = GET_PTR( inode_xp );
+                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+        
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[%s] thread[%x,%x] created <txt_rx[%d]> inode in cluster %x\n",
+__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
+#endif
+            }
+        }
+    }
+
+    // create a TXT_TX inode in each cluster containing a TXT_TX chdev
+    for( channel = 0 ; channel < CONFIG_MAX_TXT_CHANNELS ; channel++ )
+    {
+        chdev_xp = chdev_dir.txt_tx[channel];
+        if( chdev_xp != XPTR_NULL )
+        {
+            chdev_cxy = GET_CXY( chdev_xp );
+            chdev_ptr = GET_PTR( chdev_xp );
+            if( chdev_cxy == local_cxy )
+            {
+                vfs_add_child_in_parent( local_cxy,
+                                         INODE_TYPE_DEV,
+                                         FS_TYPE_DEVFS,
+                                         devfs_external_inode_xp,
+                                         chdev_ptr->name,
+                                         &unused_xp,
+                                         &inode_xp );
+
+                // update child inode "extend" field
+                inode_cxy = GET_CXY( inode_xp );
+                inode_ptr = GET_PTR( inode_xp );
+                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+        
+#if DEBUG_DEVFS_INIT 
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[%s] thread[%x,%x] created <txt_tx[%d]> inode in cluster %x\n",
+__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
+#endif
+            }
+        }
+    }
+
+    // create an IOC inode in each cluster containing an IOC chdev 
+    for( channel = 0 ; channel < CONFIG_MAX_IOC_CHANNELS ; channel++ )
+    {
+        chdev_xp = chdev_dir.ioc[channel];
+        if( chdev_xp != XPTR_NULL )
+        {
+            chdev_cxy = GET_CXY( chdev_xp );
+            chdev_ptr = GET_PTR( chdev_xp );
+            if( chdev_cxy == local_cxy )
+            {
+                vfs_add_child_in_parent( local_cxy,
+                                         INODE_TYPE_DEV,
+                                         FS_TYPE_DEVFS,
+                                         devfs_external_inode_xp,
+                                         chdev_ptr->name,
+                                         &unused_xp,
+                                         &inode_xp );
+
+                // update child inode "extend" field
+                inode_cxy = GET_CXY( inode_xp );
+                inode_ptr = GET_PTR( inode_xp );
+                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+        
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[%s] thread[%x,%x] created <ioc[%d]> inode in cluster %x\n",
+__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
+#endif
+            }
+        }
+    }
+
+    // create a FBF inode in each cluster containing a FBF chdev
+    for( channel = 0 ; channel < CONFIG_MAX_FBF_CHANNELS ; channel++ )
+    {
+        chdev_xp = chdev_dir.fbf[channel];
+        if( chdev_xp != XPTR_NULL )
+        {
+            chdev_cxy = GET_CXY( chdev_xp );
+            chdev_ptr = GET_PTR( chdev_xp );
+            if( chdev_cxy == local_cxy )
+            {
+                vfs_add_child_in_parent( local_cxy,
+                                         INODE_TYPE_DEV,
+                                         FS_TYPE_DEVFS,
+                                         devfs_external_inode_xp,
+                                         chdev_ptr->name,
+                                         &unused_xp,
+                                         &inode_xp );
+
+                // update child inode "extend" field
+                inode_cxy = GET_CXY( inode_xp );
+                inode_ptr = GET_PTR( inode_xp );
+                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+        
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[%s] thread[%x,%x] created <fbf[%d]> inode in cluster %x\n",
+__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
+#endif
+            }
+        }
+    }
+
+    // create a NIC_RX inode in each cluster containing a NIC_RX chdev 
+    for( channel = 0 ; channel < CONFIG_MAX_NIC_CHANNELS ; channel++ )
+    {
+        chdev_xp = chdev_dir.nic_rx[channel];
         if( chdev_xp != XPTR_NULL )
         {
@@ -267 +427 @@
                                          devfs_external_inode_xp,
                                          chdev_ptr->name,
-                                         GET_PTR( chdev_xp ),
+                                         &unused_xp,
                                          &inode_xp );
 #if DEBUG_DEVFS_INIT
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_DEVFS_INIT < cycle )
-printk("\n[%s] thread[%x,%x] created <txt_rx[%d]> inode in cluster %x\n",
+printk("\n[%s] thread[%x,%x] created <nic_rx[%d]> inode in cluster %x\n",
 __FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
 #endif
@@ -279 +439 @@
     }
 
-    // create a TXT_TX inode in each cluster containing a TXT_TX chdev
-    for( channel = 0 ; channel < CONFIG_MAX_TXT_CHANNELS ; channel++ )
-    {
-        chdev_xp = chdev_dir.txt_tx[channel];
+    // create a NIC_TX inode in each cluster containing a NIC_TX chdev 
+    for( channel = 0 ; channel < CONFIG_MAX_NIC_CHANNELS ; channel++ )
+    {
+        chdev_xp = chdev_dir.nic_tx[channel];
         if( chdev_xp != XPTR_NULL )
         {
             chdev_cxy = GET_CXY( chdev_xp );
-            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+            chdev_ptr = GET_PTR( chdev_xp );
             if( chdev_cxy == local_cxy )
             {
@@ -294 +454 @@
                                          devfs_external_inode_xp,
                                          chdev_ptr->name,
-                                         GET_PTR( chdev_xp ),
+                                         &unused_xp,
                                          &inode_xp );
-#if DEBUG_DEVFS_INIT 
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
-printk("\n[%s] thread[%x,%x] created <txt_tx[%d]> inode in cluster %x\n",
-__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
-#endif
-            }
-        }
-    }
-
-    // create an IOC inode in each cluster containing an IOC chdev 
-    for( channel = 0 ; channel < CONFIG_MAX_IOC_CHANNELS ; channel++ )
-    {
-        chdev_xp = chdev_dir.ioc[channel];
-        if( chdev_xp != XPTR_NULL )
-        {
-            chdev_cxy = GET_CXY( chdev_xp );
-            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
-            if( chdev_cxy == local_cxy )
-            {
-                vfs_add_child_in_parent( local_cxy,
-                                         INODE_TYPE_DEV,
-                                         FS_TYPE_DEVFS,
-                                         devfs_external_inode_xp,
-                                         chdev_ptr->name,
-                                         GET_PTR( chdev_xp ),
-                                         &inode_xp );
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
-printk("\n[%s] thread[%x,%x] created <ioc[%d]> inode in cluster %x\n",
-__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
-#endif
-            }
-        }
-    }
-
-    // create a FBF inode in each cluster containing a FBF chdev
-    for( channel = 0 ; channel < CONFIG_MAX_FBF_CHANNELS ; channel++ )
-    {
-        chdev_xp = chdev_dir.fbf[channel];
-        if( chdev_xp != XPTR_NULL )
-        {
-            chdev_cxy = GET_CXY( chdev_xp );
-            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
-            if( chdev_cxy == local_cxy )
-            {
-                vfs_add_child_in_parent( local_cxy,
-                                         INODE_TYPE_DEV,
-                                         FS_TYPE_DEVFS,
-                                         devfs_external_inode_xp,
-                                         chdev_ptr->name,
-                                         GET_PTR( chdev_xp ),
-                                         &inode_xp );
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
-printk("\n[%s] thread[%x,%x] created <fbf[%d]> inode in cluster %x\n",
-__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
-#endif
-            }
-        }
-    }
-
-    // create a NIC_RX inode in each cluster containing a NIC_RX chdev 
-    for( channel = 0 ; channel < CONFIG_MAX_NIC_CHANNELS ; channel++ )
-    {
-        chdev_xp = chdev_dir.nic_rx[channel];
-        if( chdev_xp != XPTR_NULL )
-        {
-            chdev_cxy = GET_CXY( chdev_xp );
-            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
-            if( chdev_cxy == local_cxy )
-            {
-                vfs_add_child_in_parent( local_cxy,
-                                         INODE_TYPE_DEV,
-                                         FS_TYPE_DEVFS,
-                                         devfs_external_inode_xp,
-                                         chdev_ptr->name,
-                                         GET_PTR( chdev_xp ),
-                                         &inode_xp );
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
-printk("\n[%s] thread[%x,%x] created <nic_rx[%d]> inode in cluster %x\n",
-__FUNCTION__, this->process->pid, this->trdid, channel, local_cxy, cycle );
-#endif
-            }
-        }
-    }
-
-    // create a NIC_TX inode in each cluster containing a NIC_TX chdev 
-    for( channel = 0 ; channel < CONFIG_MAX_NIC_CHANNELS ; channel++ )
-    {
-        chdev_xp = chdev_dir.nic_tx[channel];
-        if( chdev_xp != XPTR_NULL )
-        {
-            chdev_cxy = GET_CXY( chdev_xp );
-            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
-            if( chdev_cxy == local_cxy )
-            {
-                vfs_add_child_in_parent( local_cxy,
-                                         INODE_TYPE_DEV,
-                                         FS_TYPE_DEVFS,
-                                         devfs_external_inode_xp,
-                                         chdev_ptr->name,
-                                         GET_PTR( chdev_xp ),
-                                         &inode_xp );
+
+                // update child inode "extend" field
+                inode_cxy = GET_CXY( inode_xp );
+                inode_ptr = GET_PTR( inode_xp );
+                hal_remote_spt( XPTR( inode_cxy , &inode_ptr->extend ) , chdev_ptr );
+        
 #if DEBUG_DEVFS_INIT
 cycle = (uint32_t)hal_get_cycles();
@@ -462 +520 @@
     channel = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->channel ) );
 
+// Only TXT devices are associated to a pseudo-file
 assert( ( func == DEV_FUNC_TXT ) , __FUNCTION__, "illegal device func_type");
 

trunk/kernel/fs/fatfs.c

@@ -2 +2 @@
  * fatfs.c - FATFS file system API implementation.
  *
- * Author    Alain Greiner (2016,2017)
+ * Author    Alain Greiner (2016,2017,2018)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -42 +42 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-extern vfs_ctx_t          fs_context[FS_TYPES_NR];   // allocated in vfs.c file
-
-//////////////////////////////////////////////////////////////////////////////////////////
-//              FATFS specific and static functions 
+extern vfs_ctx_t     fs_context[FS_TYPES_NR];   // allocated in kernel_init.c file
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//              FATFS specific static functions 
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -89 +89 @@
     uint32_t res  = 0;
 
-    if ( little_endian)
+    if ( little_endian )
     {
         for( n = size ; n > 0 ; n-- ) res = (res<<8) | buffer[offset+n-1];
     }
-    else
+    else // big_endian
     {
         for( n = 0 ; n < size ; n++ ) res = (res<<8) | buffer[offset+n];
@@ -100 +100 @@
 
 }  // end fatfs_get_record()
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// This function writes one, two, or four bytes from a 32 bits integer to a memory buffer,
+// taking into account endianness.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ offset        : first byte of record in buffer.
+// @ size          : record length in bytes (1/2/4).
+// @ buffer        : pointer on buffer base.
+// @ little endian : the most significant byte has the highest address when true.
+// @ return the integer value in a 32 bits word.
+//////////////////////////////////////////////////////////////////////////////////////////
+static void fatfs_set_record( uint32_t    offset,
+                              uint32_t    size,
+                              uint8_t   * buffer,
+                              uint32_t    little_endian,
+                              uint32_t    value )
+{
+    uint32_t n;
+
+    if ( little_endian )
+    {
+        for( n = size ; n > 0 ; n-- ) buffer[offset+n-1] = (uint8_t)(value>>((n-1)<<3));
+    }
+    else // big_endian
+    {
+        for( n = 0 ; n < size ; n++ ) buffer[offset+n] = (uint8_t)(value>>((size-1-n)<<3));
+    }
+
+}  // end fatfs_set_record()
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -136 +165 @@
 
     name[j] = '\0';
-}
+
+}  // fatfs_get_name_from_short()
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -213 +243 @@
     name[name_offset] = 0;
 
-} // end get_name_from_long()
+} // end fatfs_get_name_from_long()
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// This static function analyse the <name> input argument, and returns in other
+// output arguments various informations required to store the name in FATFS directory.
+// The <name> length cannot be larger than 31 characters :
+// - Short name (less than 13 characters) require 1 LFN entry.
+// - Medium names (from 14 to 26 characters require 2 LFN entries.
+// - Large names (up to 31 characters) require 3 LFN entries.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ name     : [in]  complete directory entry name.
+// @ length   : [out] total number of characters in name.
+// @ nb_lfn   : [out] number of LFN entries required to store the name.
+// @ sfn      : [out] a legal SFN name extracted from name / upper case and 8-3 format.
+// @ checksum : [out] checksum to be stored in SFN.
+// @ returns 0 on success / returns 1 if the name length is larger than 31 characters.
+//////////////////////////////////////////////////////////////////////////////////////////
+static error_t fatfs_name_format( const char  * name,
+                                  uint32_t    * length,
+                                  uint32_t    * nb_lfn,
+                                  char        * sfn,
+                                  uint8_t     * checksum )
+{
+    // compute name length
+    uint32_t name_length = strlen( name );
+    *length = name_length;
+
+    uint32_t suffix_length = 0;
+    uint32_t prefix_length = 0;
+    uint32_t dot_found     = 0;
+    uint32_t i;
+
+    // compute prefix and suffix length
+    // only the last '.' is taken into account
+    for ( i=0 ; i<name_length ; i++ )
+    {
+        if (name[i] == '.' )
+        {
+            if ( dot_found ) 
+            {
+                prefix_length += suffix_length + 1;
+                suffix_length =  0;
+            }
+            else
+            {
+                dot_found = 1;
+            }
+        }
+        else
+        { 
+            if ( dot_found)  suffix_length++;
+            else             prefix_length++;
+        }
+    } 
+
+    // build SFN prefix (8bits)
+    if (prefix_length <= 8)
+    {
+        for( i=0 ; i<8 ; i++)
+        {
+            if ( i<prefix_length ) sfn[i] = to_upper( name[i] );
+            else                   sfn[i] = 0x20;
+        }
+    }
+    else
+    {
+        for( i=0 ; i<6 ; i++)
+        {
+            sfn[i] = to_upper( name[i] );
+        }
+        sfn[6] = 0x7E;
+        sfn[7] = 0x31;
+    }
+
+    // build SFN suffix (3 bits)
+    if ( suffix_length == 0 )
+    {
+        sfn[8]  = 0x20;
+        sfn[9]  = 0x20;
+        sfn[10] = 0x20;
+    }
+    else if ( suffix_length == 1 )
+    {
+        sfn[8]  = to_upper( name[name_length-1] );
+        sfn[9]  = 0x20;
+        sfn[10] = 0x20;
+    }
+    else if ( suffix_length == 2 )
+    {
+        sfn[8]  = to_upper( name[name_length-2] );
+        sfn[9]  = to_upper( name[name_length-1] );
+        sfn[10] = 0x20;
+    }
+    else
+    {
+        sfn[8]  = to_upper( name[name_length-suffix_length] );
+        sfn[9]  = to_upper( name[name_length-suffix_length+1] );
+        sfn[10] = to_upper( name[name_length-suffix_length+2] );
+    }
+
+    // compute 8 bits checksum
+    uint8_t sum = 0;
+    for ( i=0 ; i<11 ; i++ )
+    {
+        sum = (((sum & 0x01)<<7) | ((sum & 0xFE)>>1)) + sfn[i];
+    }
+    *checksum = sum;
+
+    // set nb_lfn and length values
+    if      ( name_length <= 13 )
+    {
+        *nb_lfn  = 1;
+        return 0;
+    }
+    else if ( name_length <= 26 )
+    {
+        *nb_lfn  = 2;
+        return 0;
+    }
+    else if ( name_length <= 31 )
+    {
+        *nb_lfn  = 3;
+        return 0;
+    }
+    else
+    {
+        return 1;
+    }
+}   // end fatfs_name_format()  
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// This static function - atomically - decrements "free_clusters", and updates 
+// the "free_cluster_hint" shared variables in the FATFS context in the FAT cluster.
+// It scan the FAT to find the first free slot larger than the <cluster> argument,
+// and set "free_cluster_hint" <= (free - 1).
+//
+// WARNING : The free_lock protecting exclusive access to these variables
+//           must be taken by the calling function. 
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ cluster     : recently allocated cluster index in FAT.
+//////////////////////////////////////////////////////////////////////////////////////////
+static error_t fatfs_free_clusters_decrement( uint32_t  cluster )
+{
+    fatfs_ctx_t * loc_ctx;      // local pointer on local FATFS context
+    fatfs_ctx_t * fat_ctx;      // local pointer on FATFS in cluster containing FAT mapper
+    cxy_t         mapper_cxy;   // cluster identifier for cluster containing FAT mapper
+    xptr_t        mapper_xp;    // extended pointer on FAT mapper
+    xptr_t        hint_xp;      // extended pointer on "free_cluster_hint" shared variable
+    xptr_t        numb_xp;      // extended pointer on "free_clusters" shared variable 
+    uint32_t      numb;         // "free_clusters" variable current value
+    uint32_t      page_id;      // page index in FAT mapper
+    uint32_t      slot_id;      // slot index in one page of FAT (1024 slots per page)
+    uint32_t      page_max;     // max number of pages in FAT mapper
+    xptr_t        page_xp;      // extended pointer on current page in FAT mapper
+    xptr_t        slot_xp;      // extended pointer on current slot in FAT mapper
+
+#if DEBUG_FATFS_FREE_CLUSTERS
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() )
+printk("\n[%s] thread[%x,%x] enter for allocated cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cluster , cycle );
+#endif
+
+    // get local pointer on local FATFS context
+    loc_ctx = fs_context[FS_TYPE_FATFS].extend;
+
+    // get cluster containing FAT mapper
+    mapper_xp  = loc_ctx->fat_mapper_xp;
+    mapper_cxy = GET_CXY( mapper_xp ); 
+
+    // get local pointer on FATFS context in FAT cluster
+    fat_ctx = hal_remote_lpt( XPTR( mapper_cxy , &fs_context[FS_TYPE_FATFS].extend ) );
+
+    // build extended pointers on free_clusters, and free_cluster_hint
+    hint_xp = XPTR( mapper_cxy , &fat_ctx->free_cluster_hint );
+    numb_xp = XPTR( mapper_cxy , &fat_ctx->free_clusters );
+
+    // update "free_clusters"
+    numb = hal_remote_l32( numb_xp );
+    hal_remote_s32( numb_xp , numb - 1 );
+
+    // scan FAT mapper to find the first free slot > cluster
+    // and update "free_cluster_hint" as (free - 1)
+    page_id  = (cluster + 1) >> 10;
+    slot_id  = (cluster + 1) & 0x3FF;
+    page_max = (loc_ctx->fat_sectors_count >> 3);
+
+    // scan FAT mapper / loop on pages
+    while ( page_id < page_max )            
+    {
+        // get current page from mapper
+        page_xp = mapper_remote_get_page( mapper_xp , page_id );
+
+        if( page_xp == XPTR_NULL )
+        {
+            printk("\n[ERROR] in %s : cannot access FAT mapper\n", __FUNCTION__ );
+            return -1;
+        }
+
+        // scan FAT mapper / loop on slots
+        while ( slot_id < 1024 )
+        {
+            // get extended pointer on current slot
+            slot_xp = ppm_page2base( page_xp ) + (slot_id << 2);
+
+            // test FAT slot value 
+            if ( hal_remote_l32( slot_xp ) == FREE_CLUSTER )
+            {
+                // update "free_cluster_hint" <= (free - 1)
+                hal_remote_s32( hint_xp , (page_id << 10) + slot_id - 1 );
+
+#if DEBUG_FATFS_FREE_CLUSTERS 
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() )
+printk("\n[%s] thread[%x,%x] exit / hint %x / free_clusters %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+hal_remote_l32(hint_xp), hal_remote_l32(numb_xp), cycle );
+#endif
+                return 0;
+            }
+
+            // increment  slot_id
+            slot_id++;
+
+        }  // end loop on slots
+
+        // update loop variables
+        page_id++;
+        slot_id = 0;
+
+    }  // end loop on pages
+
+    // return error if no free cluster found 
+    printk("\n[ERROR] in %s : No free cluster found\n", __FUNCTION__ );
+    return -1;
+    
+}  // end fatfs_free_clusters_decrement()
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// This static function atomically increments <free_clusters>, and updates 
+// the <free_cluster_hint> shared variables in the FATFS context in the FAT cluster.
+// If the released cluster index is smaller than the current (hint + 1) value, 
+// it set "free_cluster_hint" <= cluster - 1.
+//
+// WARNING : The free_lock protecting exclusive access to these variables
+//           must be taken by the calling function. 
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ cluster     : recently released cluster index in FAT.
+//////////////////////////////////////////////////////////////////////////////////////////
+static void fatfs_free_clusters_increment( uint32_t  cluster )
+{
+    fatfs_ctx_t * loc_ctx;      // local pointer on local FATFS context
+    fatfs_ctx_t * fat_ctx;      // local pointer on FATFS in cluster containing FAT mapper
+    cxy_t         fat_cxy;      // cluster identifier for cluster containing FAT mapper
+    xptr_t        hint_xp;      // extended pointer on "free_cluster_hint" shared variable
+    xptr_t        numb_xp;      // extended pointer on "free_clusters" shared variable 
+    uint32_t      hint;         // "free_cluster_hint" variable current value
+    uint32_t      numb;         // "free_clusters" variable current value
+
+    // get local pointer on local FATFS context
+    loc_ctx = fs_context[FS_TYPE_FATFS].extend;
+
+    // get cluster containing FAT mapper
+    fat_cxy = GET_CXY( loc_ctx->fat_mapper_xp );
+
+    // get local pointer on FATFS context in FAT cluster
+    fat_ctx = hal_remote_lpt( XPTR( fat_cxy , &fs_context[FS_TYPE_FATFS].extend ) );
+
+    // build extended pointers free_lock, free_clusters, and free_cluster_hint
+    hint_xp = XPTR( fat_cxy , &fat_ctx->free_cluster_hint );
+    numb_xp = XPTR( fat_cxy , &fat_ctx->free_clusters );
+
+    // get current value of free_cluster_hint and free_clusters
+    hint = hal_remote_l32( hint_xp );
+    numb = hal_remote_l32( numb_xp );
+
+    // update free_cluster_hint if required
+    if ( cluster < (hint + 1) ) hal_remote_s32( hint_xp , (cluster - 1) );
+
+    // update free_clusters
+    hal_remote_s32( numb_xp , numb + 1 );
+
+#if DEBUG_FATFS_FREE_CLUSTERS 
+thread_t * this = CURRENT_THREAD;
+if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() )
+printk("\n[%s] thread[%x,%x] updates free cluster info : hint %x / number %x\n",
+__FUNCTION__, this->process->pid, this->trdid,
+hal_remote_l32( hint_xp ), hal_remote_l32( numb_xp ) );
+#endif
+
+}  // end fatfs_free_clusters_increment()
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// This recursive function is called by the generic function fatfs_release_all_clusters()
+// It release all clusters allocated to a given inode in the FAT mapper.
+// The removal is done in reverse order of the linked list (from last to first).
+// It does NOT update the FS on the IOC device.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ fat_mapper_xp : extended pointer on FAT mapper.
+// @ cluster       : cluster index in FAT.
+// @ return 0 if success / return -1 if error (cannot access FAT)
+//////////////////////////////////////////////////////////////////////////////////////////
+static error_t fatfs_recursive_release( xptr_t    fat_mapper_xp,
+                                        uint32_t  cluster )
+{
+    uint32_t next;
+
+    // get next cluster from FAT mapper
+    if ( mapper_remote_get_32( fat_mapper_xp , cluster , &next ) ) return -1;
+
+#if (DEBUG_FATFS_RELEASE_INODE & 1)
+thread_t * this = CURRENT_THREAD;
+if ( DEBUG_FATFS_RELEASE_INODE < (uint32_t)hal_get_cycles() )
+printk("\n[%s] thread[%x,%x] access FAT for cluster %x / next %x\n",
+__FUNCTION__, this->process->pid, this->trdid, cluster, next );
+#endif
+
+    if ( next < END_OF_CHAIN_CLUSTER_MIN )  // non terminal case
+    {
+        // call fatfs_recursive_release() on next cluster
+        if ( fatfs_recursive_release( fat_mapper_xp , next ) ) return -1;
+    }       
+
+    // update current cluster in FAT mapper
+    if ( mapper_remote_set_32( fat_mapper_xp, cluster , FREE_CLUSTER ) ) return -1;
+
+    // Update free_cluster_hint and free_clusters in FAT context
+    fatfs_free_clusters_increment( cluster );
+
+    return 0;
+
+}  // end fatfs_recursive_release()
 
 
@@ -220 +582 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-//////////////////////////////////////////////////////////////////////////////////////////
+//////////////////////////////
 void fatfs_ctx_display( void )
 {
+    // get pointer on local FATFS context
     vfs_ctx_t   * vfs_ctx   = &fs_context[FS_TYPE_FATFS];
     fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend;
 
     printk("\n*** FAT context ***\n" 
-           "- fat_sectors      = %d\n"
-           "- sector size      = %d\n"
-           "- cluster size     = %d\n"
-           "- fat_first_lba    = %d\n"
-           "- data_first_lba   = %d\n"
-           "- root_dir_cluster = %d\n"
-           "- mapper_xp        = %l\n",
+           "- fat_sectors       = %d\n"
+           "- sector size       = %d\n"
+           "- cluster size      = %d\n"
+           "- fat_first_lba     = %d\n"
+           "- data_first_lba    = %d\n"
+           "- root_dir_cluster  = %d\n"
+           "- free_clusters     = %d\n"
+           "- free_cluster_hint = %d\n"
+           "- fat_mapper_xp     = %l\n",
            fatfs_ctx->fat_sectors_count,
            fatfs_ctx->bytes_per_sector,
@@ -240 +605 @@
            fatfs_ctx->cluster_begin_lba,
            fatfs_ctx->root_dir_cluster,
+           fatfs_ctx->free_clusters,
+           fatfs_ctx->free_cluster_hint,
            fatfs_ctx->fat_mapper_xp );
-}
-
-/////////////////////////////////////////////
-error_t fatfs_get_cluster( mapper_t * mapper,
-                           uint32_t   first_cluster_id,
+
+}  // end fatfs_ctx_display()
+
+//////////////////////////////////////////
+void fatfs_display_fat( uint32_t  page_id,
+                        uint32_t  nentries )
+{
+    uint32_t line;
+    uint32_t maxline;
+
+    // copute numner of lines to display
+    maxline = nentries >> 3;
+    if( nentries & 0x7 ) maxline++;
+
+    // get pointer on local FATFS context
+    vfs_ctx_t   * vfs_ctx   = &fs_context[FS_TYPE_FATFS];
+    fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend;
+
+    // get extended pointer on FAT mapper
+    xptr_t fat_mapper_xp = fatfs_ctx->fat_mapper_xp;
+
+    // get extended pointer and cluster of FAT mapper requested page 
+    xptr_t     page_xp  = mapper_remote_get_page( fat_mapper_xp , page_id );
+
+    // get extended pointer on requested page base
+    xptr_t     base_xp  = ppm_page2base( page_xp );
+
+    printk("\n***** FAT content / page %d *****\n", page_id );
+    for( line = 0 ; line < maxline ; line++ )
+    {
+        printk("%x : %X | %X | %X | %X | %X | %X | %X | %X\n", (line<<3),
+        hal_remote_l32( base_xp + ((line<<5)      ) ),
+        hal_remote_l32( base_xp + ((line<<5) + 4  ) ),
+        hal_remote_l32( base_xp + ((line<<5) + 8  ) ),
+        hal_remote_l32( base_xp + ((line<<5) + 12 ) ),
+        hal_remote_l32( base_xp + ((line<<5) + 16 ) ),
+        hal_remote_l32( base_xp + ((line<<5) + 20 ) ),
+        hal_remote_l32( base_xp + ((line<<5) + 24 ) ),
+        hal_remote_l32( base_xp + ((line<<5) + 28 ) ) );
+    }
+
+}  // end fatfs_display_fat()
+
+///////////////////////////////////////////////////////
+error_t fatfs_get_cluster( uint32_t   first_cluster_id,
                            uint32_t   searched_page_index,
                            uint32_t * searched_cluster_id )
 {
-    page_t   * current_page_desc;      // pointer on current page descriptor
-    uint32_t * current_page_buffer;    // pointer on current page (array of uint32_t)
+    xptr_t     current_page_xp;        // pointer on current page descriptor
+    uint32_t * buffer;                 // pointer on current page (array of uint32_t)
     uint32_t   current_page_index;     // index of current page in FAT 
     uint32_t   current_page_offset;    // offset of slot in current page
@@ -256 +663 @@
     uint32_t   next_cluster_id;        // content of current FAT slot
 
-    assert( (searched_page_index > 0) ,
-    "no FAT access required for first page\n");
+assert( (searched_page_index > 0) ,
+"no FAT access required for first page\n");
 
 #if DEBUG_FATFS_GET_CLUSTER
-uint32_t cycle = (uint32_t)hal_get_cycles();
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
 if( DEBUG_FATFS_GET_CLUSTER < cycle )
-printk("\n[DBG] %s : thread %x enter / first_cluster_id %d / searched_index / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, first_cluster_id, searched_page_index, cycle );
-#endif
-
-    // get number of FAT slots per page
-    uint32_t slots_per_page = CONFIG_PPM_PAGE_SIZE >> 2;
-
-    // initialize loop variable
-    current_page_index  = first_cluster_id / slots_per_page;
-    current_page_offset = first_cluster_id % slots_per_page;
+printk("\n[%s] thread[%x,%x] enter / first_cluster_id %d / searched_index / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, first_cluster_id, searched_page_index, cycle );
+#endif
+
+    // get local pointer on local FATFS context
+    fatfs_ctx_t * ctx = fs_context[FS_TYPE_FATFS].extend;
+
+    // get extended pointer and cluster on FAT mapper
+    xptr_t mapper_xp  = ctx->fat_mapper_xp;
+    cxy_t  mapper_cxy = GET_CXY( mapper_xp );
+
+    // initialize loop variable (1024 slots per page)
+    current_page_index  = first_cluster_id >> 10;
+    current_page_offset = first_cluster_id & 0x3FF;
     page_count_in_file  = 0;
     next_cluster_id     = 0xFFFFFFFF;
@@ -279 +691 @@
     {
         // get pointer on current page descriptor
-        current_page_desc = mapper_get_page( mapper , current_page_index );
-
-        if( current_page_desc == NULL ) return EIO;
+        current_page_xp = mapper_remote_get_page( mapper_xp , current_page_index );
+
+        if( current_page_xp == XPTR_NULL )
+        {
+            // TODO
+            return -1;
+        }
 
         // get pointer on buffer for current page
-        xptr_t base_xp = ppm_page2base( XPTR( local_cxy , current_page_desc ) );
-        current_page_buffer = (uint32_t *)GET_PTR( base_xp );
+        xptr_t base_xp = ppm_page2base( current_page_xp );
+        buffer = (uint32_t *)GET_PTR( base_xp );
 
         // get FAT slot content 
-        next_cluster_id = current_page_buffer[current_page_offset];
+        next_cluster_id = hal_remote_l32( XPTR( mapper_cxy , &buffer[current_page_offset] ) );
 
 #if (DEBUG_FATFS_GET_CLUSTER & 1)
 if( DEBUG_FATFS_GET_CLUSTER < cycle )
-printk("\n[DBG] %s : traverse FAT / current_page_index = %d\n"
+printk("\n[%s] traverse FAT / current_page_index = %d\n"
 "current_page_offset = %d / next_cluster_id = %d\n",
 __FUNCTION__, current_page_index, current_page_offset , next_cluster_id );
@@ -298 +714 @@
 
         // update loop variables
-        current_page_index  = next_cluster_id / slots_per_page;
-        current_page_offset = next_cluster_id % slots_per_page;
+        current_page_index  = next_cluster_id >> 10;
+        current_page_offset = next_cluster_id & 0x3FF;
         page_count_in_file++;
     }
 
-    if( next_cluster_id == 0xFFFFFFFF ) return EIO;
+    if( next_cluster_id == 0xFFFFFFFF ) return -1;
    
 #if DEBUG_FATFS_GET_CLUSTER
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_FATFS_GET_CLUSTER < cycle )
-printk("\n[DBG] %s : thread %x exit / searched_cluster_id = %d / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, next_cluster_id / cycle );
+printk("\n[%s] thread[%x,%x] exit / searched_cluster_id = %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, next_cluster_id / cycle );
 #endif
 
@@ -320 +736 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////
-// Generic API : the following functions are called by the kernel (VFS)
+// Generic API : the following functions are called by the kernel VFS
 //               and must be defined by all supported file systems.
 ///////////////////////////////////////////////////////////////////////////////////////
@@ -342 +758 @@
     uint8_t     * buffer;
 
-#if DEBUG_FATFS_INIT
+#if DEBUG_FATFS_CTX_INIT
 uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_FATFS_INIT < cycle )
-printk("\n[DBG] %s : thread %x enter for fatfs_ctx = %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , fatfs_ctx , cycle );
-#endif
-
-    assert( (fatfs_ctx != NULL) ,
-    "cannot allocate memory for FATFS context\n" );
+if( DEBUG_FATFS_CTX_INIT < cycle )
+printk("\n[%s] thread[%x,%x] enter for fatfs_ctx = %x / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, fatfs_ctx , cycle );
+#endif
+
+// check argument
+assert( (fatfs_ctx != NULL) , "pointer on FATFS context is NULL\n" );
+
+// check only cluster 0 does FATFS init
+assert( (local_cxy == 0) , "only cluster 0 can initialize FATFS\n");
 
     // allocate a 512 bytes buffer to store the boot record
@@ -357 +776 @@
         buffer      = (uint8_t *)kmem_alloc( &req );
 
-    assert( (buffer != NULL) ,
-    "cannot allocate memory for 512 bytes buffer\n" );
+    if( buffer == NULL ) 
+    {
+        printk("\n[PANIC] in %s : cannot allocate buffer\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
      
-    // load the boot record from device
-    // using a synchronous access to IOC device  
+    // load the BOOT record from device
     error = dev_ioc_sync_read( buffer , 0 , 1 );
 
-    assert( (error == 0) ,
-    "cannot access boot record\n" );
-
-#if (DEBUG_FATFS_INIT & 0x1)
-if( DEBUG_FATFS_INIT < cycle )
+    if ( error )
+    {
+        printk("\n[PANIC] in %s : cannot access boot record\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+
+#if (DEBUG_FATFS_CTX_INIT & 0x1)
+if( DEBUG_FATFS_CTX_INIT < cycle )
 {
     uint32_t   line;
@@ -387 +811 @@
 #endif
 
-    // check sector size from boot record
+    // get sector size from boot record
     uint32_t sector_size = fatfs_get_record( BPB_BYTSPERSEC , buffer , 1 );
-
-    assert( (sector_size == 512) ,
-            "sector size must be 512 bytes\n" );
-
-    // check cluster size from boot record
+    if ( sector_size != 512 )
+    {
+        printk("\n[PANIC] in %s : sector size must be 512 bytes\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+
+    // get cluster size from boot record
     uint32_t nb_sectors = fatfs_get_record( BPB_SECPERCLUS , buffer , 1 );
-
-    assert( (nb_sectors == 8) ,
-    "cluster size must be 8 sectors\n" );
-
-    // check number of FAT copies from boot record
+    if ( nb_sectors != 8 )
+    {
+        printk("\n[PANIC] in %s : cluster size must be 8 sectors\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+
+    // get number of FAT copies from boot record
     uint32_t nb_fats = fatfs_get_record( BPB_NUMFATS , buffer , 1 );
-
-    assert( (nb_fats == 1) ,
-    "number of FAT copies must be 1\n" );
-
-    // get & check number of sectors in FAT from boot record
+    if ( nb_fats != 1 )
+    {
+        printk("\n[PANIC] in %s : number of FAT copies must be 1\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+
+    // get number of sectors in FAT from boot record
     uint32_t fat_sectors = fatfs_get_record( BPB_FAT32_FATSZ32 , buffer , 1 );
-
-    assert( ((fat_sectors & 0xF) == 0) ,
-    "FAT not multiple of 16 sectors\n");
-
-    // get and check root cluster from boot record
+    if ( (fat_sectors & 0xF) != 0 )
+    {
+        printk("\n[PANIC] in %s : FAT size not multiple of 16 sectors\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+
+    // get root cluster from boot record
     uint32_t root_cluster = fatfs_get_record( BPB_FAT32_ROOTCLUS , buffer , 1 );
-
-    assert( (root_cluster == 2) ,
-    "root cluster index must be  2\n");
+    if ( root_cluster != 2 ) 
+    {
+        printk("\n[PANIC] in %s : root cluster index must be 2\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
 
     // get FAT lba from boot record
     uint32_t fat_lba = fatfs_get_record( BPB_RSVDSECCNT , buffer , 1 );
+
+    // get FS_INFO sector lba from boot record
+    uint32_t fs_info_lba = fatfs_get_record( BPB_FAT32_FSINFO , buffer , 1 );
+
+    // load the FS_INFO record from device
+    error = dev_ioc_sync_read( buffer , fs_info_lba , 1 );
+
+    if ( error )
+    {
+        printk("\n[PANIC] in %s : cannot access FS_INFO record\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+
+    // get free clusters number from FS_INFO record
+    uint32_t free_clusters = fatfs_get_record( FS_FREE_CLUSTERS , buffer , 1 );
+    if ( free_clusters >= fat_sectors << 7 )
+    {
+        printk("\n[PANIC] in %s : unconsistent free_clusters\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+
+    // get cluster hint from FS_INFO record
+    uint32_t free_cluster_hint = fatfs_get_record( FS_FREE_CLUSTER_HINT , buffer , 1 );
+    if ( free_cluster_hint >= fat_sectors << 7 )
+    {
+        printk("\n[PANIC] in %s : unconsistent free_cluster_hint\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
 
     // release the 512 bytes buffer
@@ -427 +889 @@
     // allocate a mapper for the FAT itself
     mapper_t * fat_mapper = mapper_create( FS_TYPE_FATFS );
-
-    assert( (fat_mapper != NULL) ,
-    "no memory for FAT mapper" );
+    if ( fat_mapper == NULL )
+    {
+        printk("\n[PANIC] in %s : no memory for FAT mapper\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
 
     // WARNING : the inode field MUST be NULL for the FAT mapper
@@ -441 +905 @@
     fatfs_ctx->cluster_begin_lba     = fat_lba + fat_sectors;
     fatfs_ctx->root_dir_cluster      = 2;
-    fatfs_ctx->last_allocated_sector = 0;    // TODO ???
-    fatfs_ctx->last_allocated_index  = 0;    // TODO ???
     fatfs_ctx->fat_mapper_xp         = XPTR( local_cxy , fat_mapper );
-
-#if DEBUG_FATFS_INIT
+    fatfs_ctx->free_clusters         = free_clusters;
+    fatfs_ctx->free_cluster_hint     = free_cluster_hint;
+
+    remote_queuelock_init( XPTR( local_cxy , &fatfs_ctx->free_lock ) , LOCK_FATFS_FREE );
+
+#if DEBUG_FATFS_CTX_INIT
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_FATFS_INIT < cycle )
-printk("\n[DBG] %s : thread %x exit for fatfs_ctx = %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , fatfs_ctx , cycle );
+if( DEBUG_FATFS_CTX_INIT < cycle )
+printk("\n[%s]  thread[%x,%x] exit for fatfs_ctx = %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, fatfs_ctx, cycle );
 #endif
 
@@ -463 +929 @@
 }
 
-//////////////////////////////////////////////
-error_t fatfs_mapper_move_page( page_t * page,
-                                bool_t   to_mapper )
+///////////////////////////////////////////////
+error_t fatfs_add_dentry( vfs_inode_t  * inode,
+                          vfs_dentry_t * dentry )
 {
     error_t       error;
-    vfs_inode_t * inode;
-    mapper_t    * mapper;
-    uint32_t      index;       // page index in mapper
-    uint8_t     * buffer;      // page base address in mapper
-    uint32_t      count;       // number of sectors in a page
-    uint32_t      lba;         // block address on device
-    fatfs_ctx_t * fatfs_ctx;   // pointer on local FATFS context
-
-    // get pointer on mapper and page index from page descriptor
-    mapper = page->mapper;
-    index  = page->index;
-
-    // get inode pointer from mapper
-    inode = mapper->inode;
-
-#if DEBUG_FATFS_MOVE
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_FATFS_MOVE < cycle )
-printk("\n[DBG] %s : thread %x enter / page %d / inode %x / mapper %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , index , inode , mapper , cycle );
-#endif
-
-    // get page base address
-    xptr_t base_xp = ppm_page2base( XPTR( local_cxy , page ) );
-    buffer = (uint8_t *)GET_PTR( base_xp );
- 
-    // get number of sectors for one page (from FATFS context)
-    fatfs_ctx = (fatfs_ctx_t *)fs_context[FS_TYPE_FATFS].extend;
-    count = fatfs_ctx->sectors_per_cluster;
-
-    // test FAT/normal inode
-    if( inode == NULL )      // it is the FAT mapper
-    {
-        // get lba from page index 
-        lba = fatfs_ctx->fat_begin_lba + (count * index);
- 
-#if (DEBUG_FATFS_MOVE & 0x1)
-if( DEBUG_FATFS_MOVE < cycle )
-printk("\n[DBG] %s : access FAT on device / lba = %d\n", __FUNCTION__ , lba );
-#endif
-
-        // access device
-        if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , count );
-        else            error = dev_ioc_write( buffer , lba , count );     
-
-        if( error ) return EIO;
-    }
-    else                     // it is a normal inode mapper
-    {
-        uint32_t  searched_cluster_id;
-
-        // get first_cluster_id from inode extension
-        uint32_t  first_cluster_id = (uint32_t)(intptr_t)inode->extend;
-
-        // compute cluster_id
-        if( index == 0 )            // no need to access FAT mapper
+    uint32_t      length;        // dentry name length
+    uint32_t      nb_lfn;        // number or required LFN
+    char          sfn[11];       // buffer for SFN name
+    uint8_t       checksum;      // name checksum 
+    mapper_t    * mapper;        // loal pointer on parent inode mapper
+    xptr_t        mapper_xp;     // extended pointer on parent inode mapper
+    xptr_t        child_xp;      // extended pointer on child inode 
+    cxy_t         child_cxy;     // child inode cluster
+    vfs_inode_t * child_ptr;     // child inode local pointer
+    uint32_t      size;          // child inode size
+    uint32_t      type;          // child inode type
+    uint32_t      cluster;       // child inode cluster index
+
+#if DEBUG_FATFS_ADD_DENTRY
+char       dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
+if( DEBUG_FATFS_ADD_DENTRY < cycle )
+printk("\n[%s]  thread[%x,%x] enter / parent <%s> / child <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
+#endif
+
+// check arguments
+assert( (inode != NULL) , "inode pointer is NULL\n" );
+assert( (dentry != NULL) , "dentry pointer is NULL\n" );
+assert( (inode->type == INODE_TYPE_DIR) , "inode is not a directory\n" );
+assert( (inode->mapper != NULL ) , "mapper pointer is NULL\n" );
+  
+    // get pointers on directory mapper
+    mapper    = inode->mapper;
+    mapper_xp = XPTR( local_cxy , mapper );
+
+    // get extended pointers on remote child inode
+    child_xp  = dentry->child_xp;
+    child_cxy = GET_CXY( child_xp );
+    child_ptr = GET_PTR( child_xp );
+
+    // get relevant infos from child inode
+    type    =                     hal_remote_l32( XPTR( child_cxy , &child_ptr->type ) );
+    size    =                     hal_remote_l32( XPTR( child_cxy , &child_ptr->size ) );
+    cluster = (uint32_t)(intptr_t)hal_remote_lpt( XPTR( child_cxy , &child_ptr->extend ) );
+
+    // analyse dentry name
+    error = fatfs_name_format( dentry->name,
+                               &length,
+                               &nb_lfn,
+                               sfn,
+                               &checksum );
+    if ( error )
+    {
+        printk("\n[ERROR] in %s : dentry name > 31 bytes\n", __FUNCTION__ );
+        return -1;
+    }
+                               
+    // Search end of directory with two embedded loops:
+    // - scan the pages in the mapper
+    // - scan the entries in each page to find NO_MORE_ENTRY
+
+    xptr_t     page_xp;                 // extended pointer on page descriptor
+    xptr_t     base_xp;                 // extended pointer on page base
+    uint8_t  * base;                    // local pointer on page base (array of bytes)
+    uint32_t   page_id = 0;             // page index in mapper
+    uint32_t   offset  = 0;             // position in page
+    uint32_t   found   = 0;             // NO_MORE_ENTRY found
+
+    // loop on pages in mapper
+    while ( found == 0 )
+    {
+        // get extended pointer on page descriptor in mapper 
+        page_xp  = mapper_remote_get_page( mapper_xp , page_id );
+
+        if ( page_xp == XPTR_NULL )
         {
-            searched_cluster_id = first_cluster_id;
+            printk("\n[ERROR] in %s : cannot extend directory mapper\n", __FUNCTION__ );
+            return -1;
         }
-        else                        // FAT mapper access required
+        
+        // get pointer on page base
+        base_xp = ppm_page2base( page_xp );
+        base = GET_PTR( base_xp );
+
+        // loop on directory entries in this page
+        while ( (offset < 4096) && (found == 0) )
         {
-            // get cluster and local pointer on FAT mapper
-            xptr_t     fat_mapper_xp  = fatfs_ctx->fat_mapper_xp;
-            cxy_t      fat_mapper_cxy = GET_CXY( fat_mapper_xp );
-            mapper_t * fat_mapper_ptr = (mapper_t *)GET_PTR( fat_mapper_xp );
-
-            // access FAT mapper
-            if( fat_mapper_cxy == local_cxy )    // FAT mapper is local
+            if ( fatfs_get_record( LDIR_ORD, (base + offset), 0 ) == NO_MORE_ENTRY )
             {
-
-#if (DEBUG_FATFS_MOVE & 0x1)
-if( DEBUG_FATFS_MOVE < cycle )
-printk("\n[DBG] %s : access local FAT mapper\n"
-"fat_mapper_cxy = %x / fat_mapper_ptr = %x / first_cluster_id = %d / index = %d\n",
-__FUNCTION__ , fat_mapper_cxy , fat_mapper_ptr , first_cluster_id , index );
-#endif
-                error = fatfs_get_cluster( fat_mapper_ptr,
-                                           first_cluster_id,
-                                           index,
-                                           &searched_cluster_id );
+                found = 1;
+            }  
+            else
+            {
+                offset = offset + 32;
             }
-            else                                 // FAT mapper is remote
+        }  // end loop on entries
+
+        if ( found == 0 )
+        {
+            page_id++;
+            offset = 0;
+        }
+    }  // end loop on pages
+
+    // Modify the directory mapper: depending on the name length,
+    // the new child requires to write (3, 4, or 5) directory entries.
+    // To actually register the new child, we use a 5 steps FSM
+    // (one state per entry to be written), that is traversed as:
+    // LFN3 -> LFN2 -> LFN1 -> NORMAL -> NOMORE 
+    // At most two pages are modified:
+    // - the page containing the NO_MORE_ENTRY is always modified
+    // - the following page can be modified if the name spread on to pages.
+
+    char * name = dentry->name;
+
+    uint32_t step;          // FSM state
+
+    if      ( nb_lfn == 1 ) step = 3;
+    else if ( nb_lfn == 2 ) step = 4;
+    else if ( nb_lfn == 3 ) step = 5;
+    
+    uint8_t  * entry;       // pointer on directory entry to be written
+    uint32_t   i;           // byte index in one 32 bytes directory
+    uint32_t   c;           // character index in name
+
+    while ( step )   
+    {
+        // when the new child is split on two pages,
+        // we need to access a new page in mapper
+        if ( offset >= 4096 )
+        {
+            // copy the modified page to IOC device
+            fatfs_move_page( page_xp , false );   
+
+            // get the next page in FAT mapper
+            page_xp  = mapper_remote_get_page( mapper_xp , page_id + 1 );
+
+            if ( page_xp == XPTR_NULL )
             {
-
-#if (DEBUG_FATFS_MOVE & 0x1)
-if( DEBUG_FATFS_MOVE < cycle )
-printk("\n[DBG] %s : access remote FAT mapper\n"
-"fat_mapper_cxy = %x / fat_mapper_ptr = %x / first_cluster_id = %d / index = %d\n",
-__FUNCTION__ , fat_mapper_cxy , fat_mapper_ptr , first_cluster_id , index );
-#endif
-                rpc_fatfs_get_cluster_client( fat_mapper_cxy,
-                                              fat_mapper_ptr,
-                                              first_cluster_id,
-                                              index,
-                                              &searched_cluster_id,
-                                              &error );
+                printk("\n[ERROR] in %s : cannot extend directory mapper\n", __FUNCTION__ );
+                return -1;
             }
-
-            if( error )  return EIO;
+        
+            // get pointer on page base
+            base_xp = ppm_page2base( page_xp );
+            base = GET_PTR( base_xp );
+            
+            // update offset
+            offset = 0;
         }
 
-#if (DEBUG_FATFS_MOVE & 0x1)
-if( DEBUG_FATFS_MOVE < cycle )
-printk("\n[DBG] %s : access device for inode %x / cluster_id %d\n",
-__FUNCTION__ , inode , searched_cluster_id );
-#endif
-
-        // get lba from cluster_id
-        lba = fatfs_lba_from_cluster( fatfs_ctx , searched_cluster_id );
-
-        // access device
-        if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , count );
-        else            error = dev_ioc_write( buffer , lba , count );     
-
-        if( error ) return EIO;
-    }
-
-#if DEBUG_FATFS_MOVE
+        // compute directory entry address
+        entry = base + offset;
+
+#if (DEBUG_FATFS_ADD_DENTRY & 1)
+if( DEBUG_FATFS_ADD_DENTRY < cycle )
+printk("\n[%s] FSM step = %d / offset = %x / nb_lfn = %d\n",
+__FUNCTION__, step, offset, nb_lfn );
+#endif
+
+        // write 32 bytes (one directory entry) per iteration
+        switch ( step )
+        {
+            case 5:   // write LFN3 entry
+            {
+                c = 26;
+                // scan the 32 bytes in dir_entry
+                for ( i = 0 ; i < 32 ; i++ )
+                {
+                    if (i == 0)
+                    {
+                        if ( nb_lfn == 3) entry[i] = 0x43;
+                        else              entry[i] = 0x03;
+                    }
+                    else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1))   ||
+                                ((i >= 14) && (i<=25) && ((i&1)==0))   ||
+                                ((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
+                              ( c < length ) )
+                    {
+                                          entry[i] = name[c];
+                                          c++;
+                    }
+                    else if (i == 11)     entry[i] = 0x0F;
+                    else if (i == 13)     entry[i] = checksum;
+                    else                  entry[i] = 0x00;
+                }
+                step--;
+                break;
+            }
+            case 4:   // write LFN2 entry  
+            {
+                c = 13;
+                // scan the 32 bytes in dir_entry
+                for ( i = 0 ; i < 32 ; i++ )
+                {
+                    if (i == 0)
+                    {
+                        if ( nb_lfn == 2) entry[i] = 0x42;
+                        else              entry[i] = 0x02;
+                    }
+                    else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1))   ||
+                                ((i >= 14) && (i<=25) && ((i&1)==0))   ||
+                                ((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
+                              ( c < length ) )
+                    {
+                                          entry[i] = name[c];
+                                          c++;
+                    }
+                    else if (i == 11)     entry[i] = 0x0F;
+                    else if (i == 13)     entry[i] = checksum;
+                    else                  entry[i] = 0x00;
+                }
+                step--;
+                break;
+            }
+            case 3:   // Write LFN1 entry   
+            {
+                c = 0;
+                // scan the 32 bytes in dir_entry
+                for ( i = 0 ; i < 32 ; i++ )
+                {
+                    if (i == 0)
+                    {
+                        if ( nb_lfn == 1) entry[i] = 0x41;
+                        else              entry[i] = 0x01;
+                    }
+                    else if ( ( ((i >= 1 ) && (i<=10) && ((i&1)==1))   ||
+                                ((i >= 14) && (i<=25) && ((i&1)==0))   ||
+                                ((i >= 28) && (i<=31) && ((i&1)==0)) ) &&
+                              ( c < length ) )
+                    {
+                                          entry[i] = name[c];
+                                          c++;
+                    }
+                    else if (i == 11)     entry[i] = 0x0F;
+                    else if (i == 13)     entry[i] = checksum;
+                    else                  entry[i] = 0x00;
+                }
+                step--;
+                break;
+            }
+            case 2:   // write NORMAL entry     
+            {
+                // scan the 32 bytes in dir_entry
+                for ( i = 0 ; i < 32 ; i++ )
+                {
+                    if      ( i < 11 )                              // 8.3 SFN
+                    {
+                                          entry[i] = sfn[i];
+                    }
+                    else if (i == 11)                               // ATTR
+                    {
+                        if (type == INODE_TYPE_DIR)  entry[i] = 0x10;
+                        else                         entry[i] = 0x20;
+                    }
+                    else if (i == 20)     entry[i] = cluster>>16;   // cluster.B2
+                    else if (i == 21)     entry[i] = cluster>>24;   // cluster.B3
+                    else if (i == 26)     entry[i] = cluster>>0;    // cluster.B0
+                    else if (i == 27)     entry[i] = cluster>>8;    // cluster.B1
+                    else if (i == 28)     entry[i] = size>>0;       // size.B0
+                    else if (i == 29)     entry[i] = size>>8;       // size.B1
+                    else if (i == 30)     entry[i] = size>>16;      // size.B2
+                    else if (i == 31)     entry[i] = size>>24;      // size.B3
+                    else                  entry[i] = 0x00;
+                }
+
+                // update the "extend" field in dentry descriptor
+                dentry->extend = (void*)(intptr_t)(((page_id<<12) + offset)>>5);
+
+                step--;
+                break;
+            }
+            case 1:   // write NOMORE entry  
+            {
+                entry [0] = 0x00;
+                step--;
+                break;
+            }
+        } // end switch step
+
+        offset += 32;
+
+    } // exit while     
+
+    // copy the modified page to the IOC device
+    fatfs_move_page( page_xp , false );   
+
+#if DEBUG_FATFS_ADD_DENTRY
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_FATFS_MOVE < cycle )
-printk("\n[DBG] %s : thread %x exit / page %d / inode %x / mapper %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , index , inode , mapper , cycle );
-#endif
-
-#if (DEBUG_FATFS_MOVE & 0x1)
-if( DEBUG_FATFS_MOVE < cycle )
-{
-    uint32_t * tab = (uint32_t *)buffer;
-    uint32_t line , word;
-    printk("\n***** %s : First 64 words of loaded page\n", __FUNCTION__ );
-    for( line = 0 ; line < 8 ; line++ )
-    {
-        printk("%X : ", line );
-        for( word = 0 ; word < 8 ; word++ ) printk("%X ", tab[(line<<3) + word] );
-        printk("\n");
-    }
-}
+if( DEBUG_FATFS_ADD_DENTRY < cycle )
+printk("\n[%s]  thread[%x,%x] exit / parent %s / child %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
 #endif
 
     return 0;
 
-}  // end fatfs_mapper_move_page()
-
-/////////////////////////////////////////////////////
-error_t fatfs_inode_load( vfs_inode_t * parent_inode,
+}  // end fatfs_add_dentry()
+
+//////////////////////////////////////////////////
+error_t fatfs_remove_dentry( vfs_inode_t  * inode,
+                             vfs_dentry_t * dentry )
+{
+    xptr_t     mapper_xp;  // extended pointer on mapper
+    mapper_t * mapper;     // local pointer on mapper
+    xptr_t     page_xp;    // extended pointer on mapper page descriptor
+    xptr_t     base_xp;    // extended pointer on mapper page base
+    uint8_t  * base;       // local pointer on mapper page base
+
+#if DEBUG_FATFS_REMOVE_DENTRY
+char       dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
+if( DEBUG_FATFS_REMOVE_DENTRY < cycle )
+printk("\n[%s]  thread[%x,%x] enter / parent <%s> / child <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
+#endif
+
+// check arguments
+assert( (inode != NULL) , "inode pointer is NULL\n" );
+assert( (dentry != NULL) , "dentry pointer is NULL\n" );
+assert( (inode->type == INODE_TYPE_DIR) , "inode is not a directory\n" );
+assert( (inode->mapper != NULL ) , "mapper pointer is NULL\n" );
+
+    // get pointers on directory mapper
+    mapper    = inode->mapper;
+    mapper_xp = XPTR( local_cxy , mapper );
+
+    // compute number of LFN entries
+    uint32_t nb_lfn;
+    uint32_t name_length = strlen( dentry->name );
+
+    if      ( name_length <= 13 ) nb_lfn  = 1;
+    else if ( name_length <= 26 ) nb_lfn  = 2;
+    else                          nb_lfn  = 3;
+
+    // we must invalidate (2, 3 or 4) 32 bytes entries:
+    // the NORMAL entry (registered in dentry->extend) and all preceding LFN entries
+    // At most two pages are modified:
+    // - the page containing the NORMAL entry is always modified.
+    // - the preceding page is modified when the name spread on two pages. 
+
+    // get 32 bytes directory entry index from dentry->extend 
+    uint32_t  dentry_id  = (uint32_t)(intptr_t)dentry->extend; 
+
+    // get page index and offset in parent directory mapper
+    uint32_t  page_id    = dentry_id >> 7;
+    uint32_t  offset     = (dentry_id & 0x7F)<<5;
+
+    // get extended pointer on page descriptor from parent directory mapper
+    page_xp  = mapper_remote_get_page( mapper_xp , page_id );
+
+    if ( page_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : cannot extend directory mapper\n", __FUNCTION__ );
+        return -1;
+    }
+        
+    // get pointers on page base
+    base_xp = ppm_page2base( page_xp );
+    base    = GET_PTR( base_xp );
+
+    // invalidate NORMAL entry in directory cache
+    base[offset] = 0xE5;
+
+    // invalidate LFN entries
+    while ( nb_lfn )
+    {
+        if (offset == 0)  // we must load page (page_id - 1)
+        {
+
+// check page_id 
+assert( (page_id > 0), "page_id and offset cannot be both 0\n" );
+
+            // copy the modified page to the IOC device
+            fatfs_move_page( page_xp , false );   
+
+            // get extended pointer on page descriptor from parent directory mapper
+            page_xp  = mapper_remote_get_page( mapper_xp , page_id );
+
+            if ( page_xp == XPTR_NULL )
+            {
+                printk("\n[ERROR] in %s : cannot access directory mapper\n", __FUNCTION__ );
+                return -1;
+            }
+        
+            // get pointers on page base
+            base_xp = ppm_page2base( page_xp );
+            base    = GET_PTR( base_xp );
+
+            // update offset
+            offset = 4096;
+        }
+
+        offset = offset - 32;
+
+// check for LFN entry
+assert( (fatfs_get_record( DIR_ATTR, base + offset, 0 ) == ATTR_LONG_NAME_MASK ),
+"this directory entry must be a LFN\n");
+
+        // invalidate LFN entry
+        base[offset] = 0xE5;
+
+        nb_lfn--;
+    }     
+
+    // copy the modified page to the IOC device
+    fatfs_move_page( page_xp , false );   
+    
+
+#if DEBUG_FATFS_REMOVE_DENTRY
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_REMOVE_DENTRY < cycle )
+printk("\n[%s]  thread[%x,%x] exit / parent %s / child %s / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
+#endif
+
+    return 0;
+
+}  // end fatfs_remove_dentry
+
+////////////////////////////////////////////////////////////////
+error_t fatfs_child_init( vfs_inode_t * parent_inode,
                           char        * name,
                           xptr_t        child_inode_xp )
 {
     // Two embedded loops:
-    // - scan the parent mapper pages 
+    // - scan the parent directory mapper pages 
     // - scan the directory entries in each 4 Kbytes page
 
-#if DEBUG_FATFS_LOAD
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_FATFS_LOAD < cycle )
-printk("\n[DBG] %s : thread %x enter for child <%s> in parent inode %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , name , parent_inode , cycle );
-#endif
-
-    mapper_t * mapper = parent_inode->mapper;
-
-    assert( (mapper != NULL) , "parent mapper undefined\n");
+#if DEBUG_FATFS_CHILD_INIT
+char       parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , parent_name );
+if( DEBUG_FATFS_CHILD_INIT < cycle )
+printk("\n[%s]  thread[%x,%x] enter for child <%s> in parent <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name , parent_name , cycle );
+#endif
+
+// check parent_inode and child_inode
+assert( (parent_inode != NULL) , "parent_inode is NULL\n" );
+assert( (child_inode_xp != XPTR_NULL ) , "child_inode is XPTR_NULL\n" );
+
+    mapper_t * mapper    = parent_inode->mapper;
+    xptr_t     mapper_xp = XPTR( local_cxy , mapper );
+
+// check parent mapper
+assert( (mapper != NULL) , "parent mapper is NULL\n");
     
     char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracter from each directory entry
@@ -636 +1387 @@
     char       lfn2[16];         // buffer for one partial cname
     char       lfn3[16];         // buffer for one partial cname
-    page_t   * page;             // pointer on current page descriptor
-    uint8_t  * base;             // pointer on current page base
-    uint32_t   offset  = 0;      // byte offset in page
-    uint32_t   index   = 0;      // page index in mapper
+    xptr_t     page_xp;          // extended pointer on page descriptor
+    xptr_t     base_xp;          // extended pointer on page base
+    uint8_t  * base;             // local pointer on page base
     uint32_t   attr;             // directory entry ATTR field
     uint32_t   ord;              // directory entry ORD field
     uint32_t   seq;              // sequence index
-    uint32_t   lfn     = 0;      // LFN entries number
-    uint32_t   size    = 0;      // searched file/dir size (bytes) 
-    uint32_t   cluster = 0;      // searched file/dir cluster index
-    uint32_t   is_dir  = 0;      // searched file/dir type
-    uint32_t   dentry;           // directory entry index 
-    int32_t    found   = 0;      // not found (0) / name found (1) / end of dir (-1)
+    uint32_t   lfn       = 0;    // LFN entries number
+    uint32_t   size      = 0;    // searched file/dir size (bytes) 
+    uint32_t   cluster   = 0;    // searched file/dir cluster index
+    uint32_t   is_dir    = 0;    // searched file/dir type
+    int32_t    found     = 0;    // not found (0) / name found (1) / end of dir (-1)
+    uint32_t   page_id   = 0;    // page index in mapper
+    uint32_t   dentry_id = 0;    // directory entry index 
+    uint32_t   offset    = 0;    // byte offset in page
 
     // scan the parent directory mapper
@@ -654 +1406 @@
     {
         // get one page
-        page = mapper_get_page( mapper , index );
-
-        assert( (page != NULL) , "bad parent mapper\n");
+        page_xp = mapper_remote_get_page( mapper_xp , page_id );
+
+        if( page_xp == XPTR_NULL) return EIO;
 
         // get page base
-        xptr_t base_xp = ppm_page2base( XPTR( local_cxy , page ) );
-        base = (uint8_t *)GET_PTR( base_xp );
-
-#if (DEBUG_FATFS_LOAD & 0x1)
-if( DEBUG_FATFS_LOAD < cycle )
+        base_xp = ppm_page2base( page_xp );
+        base    = (uint8_t *)GET_PTR( base_xp );
+
+#if (DEBUG_FATFS_CHILD_INIT & 0x1)
+if( DEBUG_FATFS_CHILD_INIT < cycle )
 {
     uint32_t * buf = (uint32_t *)base;
     uint32_t line , word;
-    printk("\n***** %s : First 16 dentries for parent inode %x\n",
-    __FUNCTION__ , parent_inode );
+    printk("\n[%s] First 16 dentries for <%s>\n",
+    __FUNCTION__ , parent_name );
     for( line = 0 ; line < 16 ; line++ )
     {
@@ -728 +1480 @@
                     cluster = (fatfs_get_record( DIR_FST_CLUS_HI , base + offset , 1 ) << 16) |
                               (fatfs_get_record( DIR_FST_CLUS_LO , base + offset , 1 )      ) ;
-                    dentry  = ((index<<12) + offset)>>5;
-                    is_dir  = ((attr & ATTR_DIRECTORY) == ATTR_DIRECTORY);
-                    size    = fatfs_get_record( DIR_FILE_SIZE , base + offset , 1 );
-                    found   = 1;
+                    dentry_id = ((page_id<<12) + offset)>>5;
+                    is_dir    = ((attr & ATTR_DIRECTORY) == ATTR_DIRECTORY);
+                    size      = fatfs_get_record( DIR_FILE_SIZE , base + offset , 1 );
+                    found     = 1;
                 }
                 offset = offset + 32;
                 lfn    = 0;
             }
-        }  // end loop on directory entries
-        index++;
+        }  // end loop on directory entries in page
+
+        page_id++;
         offset = 0;
+
     }  // end loop on pages
 
@@ -746 +1500 @@
     {
 
-#if DEBUG_FATFS_LOAD
+#if DEBUG_FATFS_CHILD_INIT
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_FATFS_LOAD < cycle )
-printk("\n[DBG] %s : thread %x exit / child <%s> not found / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD, name, cycle );
-#endif
-
-        return ENOENT;
-    }
-    else               // found searched child name
-    {
-        // get child inode cluster and local pointer
-        cxy_t         child_cxy = GET_CXY( child_inode_xp );
-        vfs_inode_t * child_ptr = (vfs_inode_t *)GET_PTR( child_inode_xp );
-
-        // update the child inode "type", "size", and "extend" fields
-        vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
-
-        hal_remote_s32( XPTR( child_cxy , &child_ptr->type   ) , type );
-        hal_remote_s32( XPTR( child_cxy , &child_ptr->size   ) , size );
-        hal_remote_s32( XPTR( child_cxy , &child_ptr->extend ) , cluster );
-
-#if DEBUG_FATFS_LOAD
+if( DEBUG_FATFS_CHILD_INIT < cycle )
+printk("\n[%s]  thread[%x,%x] exit / child <%s> not found / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, cycle );
+#endif
+
+        return -1;
+    }
+
+    // get child inode cluster and local pointer
+    cxy_t          inode_cxy = GET_CXY( child_inode_xp );
+    vfs_inode_t  * inode_ptr = (vfs_inode_t *)GET_PTR( child_inode_xp );
+
+    // get dentry pointers and cluster
+    xptr_t         dentry_xp  = hal_remote_l64( XPTR( inode_cxy , &inode_ptr->parent_xp ) );  
+    vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
+    cxy_t          dentry_cxy = GET_CXY( dentry_xp );
+
+// dentry descriptor must be in same cluster as parent inode
+assert( (dentry_cxy == local_cxy) , "illegal dentry cluster\n" );
+
+    // update the child inode "type", "size", and "extend" fields
+    vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
+
+    hal_remote_s32( XPTR( inode_cxy , &inode_ptr->type   ) , type );
+    hal_remote_s32( XPTR( inode_cxy , &inode_ptr->size   ) , size );
+    hal_remote_s32( XPTR( inode_cxy , &inode_ptr->extend ) , cluster );
+
+    // update the dentry "extend" field
+    dentry_ptr->extend = (void *)(intptr_t)dentry_id;
+
+#if DEBUG_FATFS_CHILD_INIT
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_FATFS_LOAD < cycle )
-printk("\n[DBG] %s : thread %x exit / child <%s> loaded / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD, name, cycle );
-#endif
-
-        return 0;
-    }
-}  // end fatfs_inode_load()
+if( DEBUG_FATFS_CHILD_INIT < cycle )
+printk("\n[%s]  thread[%x,%x] exit / child <%s> loaded in <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, parent_name, cycle );
+#endif
+
+    return 0;
+
+}  // end fatfs_child_init()
+
+///////////////////////////////////////////////
+error_t fatfs_sync_inode( vfs_inode_t * inode )
+{
+
+// check inode pointer and cluster index
+assert( (inode != NULL)                  , "inode pointer undefined\n" );
+assert( (inode->mapper != NULL )         , "mapper pointer undefined\n" );
+assert( (inode->type == INODE_TYPE_FILE) , "inode must be a file\n" );     
+
+#if DEBUG_FATFS_SYNC_INODE
+char       name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
+if( DEBUG_FATFS_SYNC_INODE < cycle )
+printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, name, cycle );
+#endif
+
+    error_t    error;
+    mapper_t * mapper;
+    page_t   * page;
+    uint32_t   page_id;
+
+    // get mapper from inode 
+    mapper = inode->mapper;
+
+    // compute max number of pages in mapper from file size
+    uint32_t size  = inode->size;
+    uint32_t pages = size >> CONFIG_PPM_PAGE_SHIFT;
+    if( size & CONFIG_PPM_PAGE_MASK ) pages++; 
+         
+    // get pointer on mapper radix tree
+    grdxt_t * rt = &mapper->rt;
+
+    // scan all pages
+    for( page_id = 0 ; page_id < pages ; page_id++ )
+    {
+        // get page descriptor from mapper
+        page = grdxt_lookup( rt , page_id );
+
+        // check all existing pages
+        if ( page != NULL )
+        {
+            if ( page->flags & PG_DIRTY )
+            {
+
+#if (DEBUG_FATFS_SYNC_INODE & 1)
+if( DEBUG_FATFS_SYNC_INODE < cycle )
+printk("\n[%s] thread[%x,%x] synchronizes page %d from <%s> mapper to IOC device\n",
+__FUNCTION__, page_id, name );
+#endif
+                // build extended pointer on page descriptor
+                xptr_t page_xp = XPTR( local_cxy , page );
+
+                // move page from mapper to device
+                error = fatfs_move_page( page_xp , false );
+
+                if ( error )  return -1;
+
+                // reset page dirty flag
+                ppm_page_undo_dirty( page_xp );
+            }
+        }
+    }  // end loop on pages
+
+#if DEBUG_FATFS_SYNC_INODE
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_SYNC_INODE < cycle )
+printk("\n[%s] thread[%x,%x] exit for <%s> / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, name, cycle );
+#endif
+
+    return 0;
+
+}  // end fatfs_sync_inode()
+
+//////////////////////////////
+error_t fatfs_sync_fat( void )
+{
+
+#if DEBUG_FATFS_SYNC_FAT
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_FATFS_SYNC_FAT < cycle )
+printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, cycle );
+#endif
+
+    uint32_t   page_id;
+    error_t    error;
+
+    // get FAT mapper pointers an cluster 
+    fatfs_ctx_t * fatfs_ctx  = fs_context[FS_TYPE_FATFS].extend;
+    xptr_t        mapper_xp  = fatfs_ctx->fat_mapper_xp;
+    cxy_t         mapper_cxy = GET_CXY( mapper_xp );
+    mapper_t    * mapper_ptr = GET_PTR( mapper_xp );
+
+    // compute max number of 4 Kbytes pages in FAT mapper 
+    // TODO : this could be improved (see fatfs.h) [AG]
+    uint32_t   pages = fatfs_ctx->fat_sectors_count >> 3;
+         
+    // get pointers on remote FAT mapper radix tree
+    grdxt_t  * rt_ptr = &mapper_ptr->rt;
+    xptr_t     rt_xp  = XPTR( mapper_cxy , rt_ptr );
+
+    // scan all pages
+    for( page_id = 0 ; page_id < pages ; page_id++ )
+    {
+        // get extended pointer on page descriptor from FAT mapper
+        xptr_t page_xp = grdxt_remote_lookup( rt_xp , page_id );
+
+        // check all existing pages
+        if ( page_xp != XPTR_NULL )
+        {
+            page_t * page_ptr = GET_PTR( page_xp );
+            uint32_t flags    = hal_remote_l32( XPTR( mapper_cxy , &page_ptr->flags ) );
+
+            if ( flags & PG_DIRTY )
+            {
+
+#if (DEBUG_FATFS_SYNC_FAT & 1)
+if( DEBUG_FATFS_SYNC_FAT < cycle )
+printk("\n[%s] thread[%x,%x] synchronizes page %d from FAT mapper to IOC device\n",
+__FUNCTION__, page_id );
+#endif
+                // move page from mapper to device
+                error = fatfs_move_page( page_xp , false );
+
+                if ( error )  return -1;
+
+                // reset page dirty flag
+                ppm_page_undo_dirty( page_xp );
+            }
+        }
+    }  // end loop on pages
+
+#if DEBUG_FATFS_SYNC_FAT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_SYNC_FAT < cycle )
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, cycle );
+#endif
+
+    return 0;
+
+}  // end fatfs_sync_fat()
+
+////////////////////////////////////
+error_t fatfs_sync_free_info( void )
+{
+
+#if DEBUG_FATFS_SYNC_FSINFO
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_FATFS_SYNC_FSINFO < cycle )
+printk("\n[%s] thread[%x,%x] enter / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, cycle );
+#endif
+
+    uint8_t     * buffer;   // dynamically allocated aligned 512 bytes buffer
+    kmem_req_t    req;
+    error_t       error;
+
+    // get FS_INFO lba, free_ from FATFS context
+    fatfs_ctx_t * fatfs_ctx  = fs_context[FS_TYPE_FATFS].extend;
+    uint32_t      lba        = fatfs_ctx->fs_info_lba;
+    uint32_t      hint       = fatfs_ctx->free_cluster_hint;
+    uint32_t      number     = fatfs_ctx->free_clusters;
+
+    // allocate buffer to store the FS_INFO sector
+        req.type    = KMEM_512_BYTES;
+    req.flags   = AF_KERNEL | AF_ZERO;
+        buffer      = (uint8_t *)kmem_alloc( &req );
+    if( buffer == NULL ) 
+    {
+        printk("\n[PANIC] in %s : cannot allocate buffer\n", __FUNCTION__ );
+        return ENOMEM;
+    }
+     
+    // load the FS_INFO sector from device to buffer
+    error = dev_ioc_read( buffer , lba , 1 );
+    if ( error )
+    {
+        printk("\n[PANIC] in %s : cannot read FS_INFO record\n", __FUNCTION__ );
+        return EIO;
+    }
+
+    // update buffer 
+    fatfs_set_record( FS_FREE_CLUSTERS     , buffer , 1 , number );
+    fatfs_set_record( FS_FREE_CLUSTER_HINT , buffer , 1 , hint );
+
+    // write modified FS_INFO sector from buffer to device
+    error = dev_ioc_write( buffer , lba , 1 );
+    if ( error )
+    {
+        printk("\n[PANIC] in %s : cannot write FS_INFO record\n", __FUNCTION__ );
+        return EIO;
+    }
+
+    // release the 512 bytes buffer
+    req.type = KMEM_512_BYTES;
+    req.ptr  = buffer;
+    kmem_free( &req );
+
+#if DEBUG_FATFS_SYNC_FSINFO
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_SYNC_FSINFO < cycle )
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, cycle );
+#endif
+
+    return 0;
+
+}  // end fatfs_sync_fs_info()
+
+//////////////////////////////////////////////////////////
+error_t fatfs_cluster_alloc( uint32_t * searched_cluster )
+{
+    uint32_t      page_id;        // page index in mapper
+    uint32_t      slot_id;        // slot index in page (1024 slots per page)
+    uint32_t      hint;           // first free cluster index in FAT
+    uint32_t      free_clusters;  // total number of free clusters
+    vfs_ctx_t   * vfs_ctx;        // local pointer on VFS context (same in all clusters)
+    fatfs_ctx_t * loc_fatfs_ctx;  // local pointer on local FATFS context
+    fatfs_ctx_t * fat_fatfs_ctx;  // local pointer on FATFS context in FAT cluster
+    xptr_t        mapper_xp;      // extended pointer on FAT mapper
+    cxy_t         mapper_cxy;     // Fat mapper cluster identifier
+    xptr_t        page_xp;        // extended pointer on current page descriptor in mapper
+    xptr_t        slot_xp;        // extended pointer on FAT slot defined by hint
+    xptr_t        lock_xp;        // extended pointer on lock protecting free clusters info
+    xptr_t        hint_xp;        // extended pointer on free_cluster_hint in FAT cluster
+    xptr_t        numb_xp;        // extended pointer on free_clusters_number in FAT cluster
+
+#if DEBUG_FATFS_CLUSTER_ALLOC
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
+printk("\n[%s] thread[%x,%x] enter / cycle = %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+
+    // get local pointer on VFS context (same in all clusters)
+    vfs_ctx = &fs_context[FS_TYPE_FATFS];
+
+    // get local pointer on local FATFS context
+    loc_fatfs_ctx = vfs_ctx->extend;
+
+    // get extended pointer and cluster on FAT mapper
+    mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
+    mapper_cxy = GET_CXY( mapper_xp );
+    
+    // get local pointer on FATFS context in FAT cluster 
+    fat_fatfs_ctx = hal_remote_lpt( XPTR( mapper_cxy , &vfs_ctx->extend ) );
+
+    // build relevant extended pointers in on free clusters info in FAT cluster 
+    lock_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_lock );
+    hint_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_cluster_hint );
+    numb_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_clusters );
+
+    // take the lock protecting free clusters
+    remote_queuelock_acquire( lock_xp );
+
+    // get hint and free_clusters values from FATFS context 
+    hint          = hal_remote_l32( hint_xp );
+    free_clusters = hal_remote_l32( numb_xp );
+        
+    // get page index & slot index for the first free cluster 
+    page_id  = (hint + 1) >> 10;
+    slot_id  = (hint + 1) & 0x3FF;
+
+    // get relevant page from mapper
+    page_xp = mapper_remote_get_page( mapper_xp , page_id );
+
+    if( page_xp == XPTR_NULL )
+    {
+        printk("\n[ERROR] in %s : cannot acces FAT mapper\n", __FUNCTION__ );
+        return -1;
+    }
+
+    // build extended pointer on free cluster slot 
+    slot_xp = ppm_page2base( page_xp ) + (slot_id<<2);
+         
+#if (DEBUG_FATFS_CLUSTER_ALLOC & 1)
+if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
+printk("\n[%s] thread[%x,%x] get free info / hint %x / free_clusters %x\n",
+__FUNCTION__, this->process->pid, this->trdid, hint, free_clusters );
+#endif
+
+    // check "free_clusters"
+    if ( free_clusters == 0 )
+    {
+        printk("\n[ERROR] in %s : no more free FATFS clusters\n", __FUNCTION__ );
+        remote_queuelock_acquire( lock_xp );
+        return -1;
+    }
+    else if ( free_clusters < CONFIG_VFS_FREE_CLUSTERS_MIN )
+    {
+        printk("\n[WARNING] in %s : only %n free FATFS clusters\n", 
+        __FUNCTION__, CONFIG_VFS_FREE_CLUSTERS_MIN );
+    }
+
+    // check "hint" 
+    if( hal_remote_l32( slot_xp ) != FREE_CLUSTER )
+    { 
+        printk("\n[ERROR] in %s : illegal hint cluster\n", __FUNCTION__ );
+        remote_queuelock_acquire( lock_xp );
+        return -1;
+    }
+
+    // update allocated cluster in FAT mapper
+    hal_remote_s32( slot_xp , END_OF_CHAIN_CLUSTER_MAX );
+
+    // update free cluster info
+    fatfs_free_clusters_decrement( hint + 1 );
+
+    // release free clusters busylock
+    remote_queuelock_release( lock_xp );
+
+#if DEBUG_FATFS_CLUSTER_ALLOC 
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
+printk("\n[%s] thread[%x,%x] exit / cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, hint + 1, cycle );
+#endif
+
+    *searched_cluster = hint + 1;
+    return 0;
+
+}  // end fat_cluster_alloc()
+
+//////////////////////////////////////////////
+error_t fatfs_release_inode( xptr_t inode_xp )
+{
+    vfs_ctx_t   * vfs_ctx;        // local pointer on VFS context (same in all clusters).
+    fatfs_ctx_t * loc_fatfs_ctx;  // local pointer on local FATFS context
+    fatfs_ctx_t * fat_fatfs_ctx;  // local pointer on FATFS context in FAT cluster
+    xptr_t        mapper_xp;      // extended pointer on FAT mapper
+    cxy_t         mapper_cxy;     // Fat mapper cluster identifier
+    xptr_t        lock_xp;        // extended pointer on lock protecting free clusters info.
+    xptr_t        first_xp;       // extended pointer on inode extension
+    uint32_t      first_cluster;  // first cluster index for released inode
+    vfs_inode_t * inode_ptr;
+    cxy_t         inode_cxy;
+
+// check inode pointer 
+assert( (inode_xp != XPTR_NULL) , "inode pointer is NULL\n" );
+
+    // get first_cluster from inode extension
+    inode_ptr     = GET_PTR( inode_xp );
+    inode_cxy     = GET_CXY( inode_xp );
+    first_xp      = XPTR( inode_cxy , &inode_ptr->extend );
+    first_cluster = (uint32_t)(intptr_t)hal_remote_lpt( first_xp );
+
+// check first cluster index
+assert( (first_cluster != 0) , "inode extend is NULL\n" );
+
+#if DEBUG_FATFS_RELEASE_INODE
+char       name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+vfs_inode_get_name( inode_xp , name );
+if( DEBUG_FATFS_RELEASE_INODE < cycle )
+printk("\n[%s] thread[%x,%x] enter for <%s> / first_cluster %x / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, name, first_cluster, cycle );
+#endif
+
+    // get local pointer on VFS context (same in all clusters)
+    vfs_ctx = &fs_context[FS_TYPE_FATFS];
+
+    // get local pointer on local FATFS context
+    loc_fatfs_ctx = vfs_ctx->extend;
+
+    // get extended pointer and cluster on FAT mapper
+    mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
+    mapper_cxy = GET_CXY( mapper_xp );
+    
+    // get local pointer on FATFS context in FAT cluster 
+    fat_fatfs_ctx = hal_remote_lpt( XPTR( mapper_cxy , &vfs_ctx->extend ) );
+
+    // get extended pointer on free clusters lock in FAT cluster
+    lock_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->free_lock );
+
+    // take lock protecting free clusters
+    remote_queuelock_acquire( lock_xp );
+
+    // call the recursive function to release all clusters from FAT mapper
+    if ( fatfs_recursive_release( mapper_xp , first_cluster ) )
+    {
+        printk("\n[ERROR] in %s : cannot update FAT mapper\n", __FUNCTION__ );
+        remote_queuelock_release( lock_xp );
+        return -1;
+    }
+
+    // release lock protecting free cluster
+    remote_queuelock_release( lock_xp );
+
+#if (DEBUG_FATFS_RELEASE_INODE & 1)
+if( DEBUG_FATFS_RELEASE_INODE < cycle )
+printk("\n[%s] inode <%s> removed from FAT mapper\n", __FUNCTION__, name );
+#endif
+
+    // update FAT on IOC device (from FAT mapper)
+    if ( fatfs_sync_fat() )
+    {
+        printk("\n[ERROR] in %s : cannot update FAT on device\n", __FUNCTION__ );
+        return -1;
+    }
+
+#if (DEBUG_FATFS_RELEASE_INODE & 1)
+if( DEBUG_FATFS_RELEASE_INODE < cycle )
+printk("\n[%s] inode <%s> removed from FAT on IOC device\n", __FUNCTION__, name );
+#endif
+
+    // update FS-INFO sector on IOC device (from FATFS context)
+    if ( fatfs_sync_free_info() )
+    {
+        printk("\n[ERROR] in %s: cannot update FS_INFO on device\n", __FUNCTION__ );
+        return -1;
+    }
+
+#if DEBUG_FATFS_RELEASE_INODE
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_RELEASE_INODE < cycle )
+printk("\n[%s] thread[%x,%x] removed <%s> inode from FATFS / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, name, cycle );
+#endif
+
+    return 0;
+
+}  // end fatfs_release_inode()
+
+/////////////////////////////////////////
+error_t fatfs_move_page( xptr_t  page_xp,
+                         bool_t  to_mapper )
+{
+    error_t       error;
+    vfs_inode_t * inode_ptr;
+    mapper_t    * mapper_ptr;      
+    uint32_t      page_id;     // page index in mapper
+
+#if DEBUG_FATFS_MOVE_PAGE
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+char       name[CONFIG_VFS_MAX_NAME_LENGTH];
+#endif
+
+    // get page cluster an local pointer
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    page_t * page_ptr = GET_PTR( page_xp );
+
+    // get mapper pointer and page index from page descriptor
+    mapper_ptr = hal_remote_lpt( XPTR( page_cxy , &page_ptr->mapper ) );
+    page_id    = hal_remote_l32( XPTR( page_cxy , &page_ptr->index ) );
+
+    // get pointer on local FATFS context
+    fatfs_ctx_t * fatfs_ctx      = fs_context[FS_TYPE_FATFS].extend;
+
+    // get page base address
+    xptr_t    base_xp = ppm_page2base( page_xp );
+    uint8_t * buffer  = (uint8_t *)GET_PTR( base_xp );
+ 
+    // get inode pointer from mapper
+    inode_ptr  = hal_remote_lpt( XPTR( page_cxy , &mapper_ptr->inode ) );
+
+    ////////////////////////////// it is the FAT mapper
+    if( inode_ptr == NULL )
+    {
+        // get lba from FATFS context and page_id 
+        uint32_t      lba        = fatfs_ctx->fat_begin_lba + (page_id << 3);
+ 
+        // access device
+        if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , 8 );
+        else            error = dev_ioc_write( buffer , lba , 8 );     
+
+        if( error ) return EIO;
+
+#if (DEBUG_FATFS_MOVE_PAGE & 0x1)
+if( DEBUG_FATFS_MOVE_PAGE < cycle )
+{
+    uint32_t * tab = (uint32_t *)buffer;
+    uint32_t line , word;
+    printk("\n***** %s : First 64 words of page %d in FAT mapper\n",
+    __FUNCTION__ , page_id );
+    for( line = 0 ; line < 8 ; line++ )
+    {
+        printk("%X : ", line );
+        for( word = 0 ; word < 8 ; word++ ) printk("%X ", tab[(line<<3) + word] );
+        printk("\n");
+    }
+}
+#endif
+
+#if DEBUG_FATFS_MOVE_PAGE
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_MOVE_PAGE < cycle )
+{
+    if (to_mapper)
+         printk("\n[%s] thread[%x,%x] load page %d of FAT / cycle %d\n",
+         __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
+    else
+        printk("\n[%s] thread[%x,%x] sync page %d of FAT / cycle %d\n",
+        __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
+}
+#endif
+
+    }
+    ///////////////////////// it is an inode mapper
+    else                       
+    {
+
+#if DEBUG_FATFS_MOVE_PAGE
+vfs_inode_get_name( XPTR( page_cxy , inode_ptr ) , name );
+#endif
+
+        uint32_t  searched_cluster;
+        uint32_t  first_cluster;
+
+        // get first_cluster from inode extension
+        void * extend = hal_remote_lpt( XPTR( page_cxy , &inode_ptr->extend ) );
+        first_cluster = (uint32_t)(intptr_t)extend;
+
+        // compute searched_cluster
+        if( page_id == 0 )            // no need to access FAT mapper
+        {
+            // searched cluster is first cluster
+            searched_cluster = first_cluster;
+        }
+        else                        // FAT mapper access required
+        {
+            // access FAT mapper to get searched cluster
+            error = fatfs_get_cluster( first_cluster,
+                                       page_id,
+                                       &searched_cluster );
+            if( error )  return EIO;
+        }
+
+        // get lba from searched_cluster
+        uint32_t lba = fatfs_lba_from_cluster( fatfs_ctx , searched_cluster );
+
+        // access device
+        if( to_mapper ) error = dev_ioc_sync_read ( buffer , lba , 8 );
+        else            error = dev_ioc_write( buffer , lba , 8 );     
+
+        if( error ) return EIO;
+
+#if (DEBUG_FATFS_MOVE_PAGE & 0x1)
+if( DEBUG_FATFS_MOVE_PAGE < cycle )
+{
+    uint32_t * tab = (uint32_t *)buffer;
+    uint32_t line , word;
+    printk("\n***** %s : First 64 words of page %d in <%s> mapper\n",
+    __FUNCTION__, page_id, name );
+    for( line = 0 ; line < 8 ; line++ )
+    {
+        printk("%X : ", line );
+        for( word = 0 ; word < 8 ; word++ ) printk("%X ", tab[(line<<3) + word] );
+        printk("\n");
+    }
+}
+#endif
+
+#if DEBUG_FATFS_MOVE_PAGE
+cycle = (uint32_t)hal_get_cycles();
+if(DEBUG_FATFS_MOVE_PAGE < cycle)
+{
+    if(to_mapper)
+        printk("\n[%s] thread[%x,%x] load page %d of <%s> inode / cycle %d\n",
+        __FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
+    else
+        printk("\n[%s] thread[%x,%x] sync page %d of <%s> inode / cycle %d\n",
+        __FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
+}
+#endif
+
+    }
+
+    return 0;
+
+}  // end fatfs_move_page()
+
+

trunk/kernel/fs/fatfs.h

@@ -3 +3 @@
  *
  * Author    Mohamed Lamine Karaoui (2014,2015)
- *           Alain Greiner (2016,2017)
+ *           Alain Greiner (2016,2017,2018)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -27 +27 @@
 
 #include <hal_kernel_types.h>
-#include <rwlock.h>
+#include <remote_queuelock.h>
 #include <vfs.h>
 
@@ -35 +35 @@
 //
 // The FATFS extensions to the generic VFS are the following:
+//
 // 1) The vfs_ctx_t "extend" field is a void* pointing on the fatfs_ctx_t structure.
 //    This structure contains various general informations such as the total
@@ -41 +42 @@
 //    cluster index for the root directory. It contains also an extended pointer
 //    on the FAT mapper.
-// 2) The vfs_inode_t "extend" field is a void*, but contains for each inode,
+//
+// 2) The vfs_inode_t "extend" contains, for each inode,
 //    the first FAT cluster index (after cast to intptr).
+//
+// 3) The vfs_dentry_t "extend" field contains, for each dentry, the entry index
+//    in the FATFS directory (32 bytes per FATFS entry). 
 ///////////////////////////////////////////////////////////////////////////////////////////
 
@@ -163 +168 @@
 struct vfs_ctx_s;
 struct vfs_inode_s;
-
-/*****************************************************************************************
- * This structure defines a FATFS specific context (extension to VFS context). 
+struct vfs_dentry_s;
+
+/*****************************************************************************************
+ * This structure defines a FATFS specific context (extension to VFS context).
+ * This extension is replicated in all clusters.
+ *
+ * WARNING : Almost all fields are constant values, but the <free_cluster_hint> and
+ * <free_clusters> are shared variables. All kernel instances use the variables
+ * in cluster 0, using the <free_lock> remote busy_lock for exclusive access.
  ****************************************************************************************/
 
 typedef struct fatfs_ctx_s
 {
-    uint32_t          fat_sectors_count;     /*! number of sectors in FAT region        */
-    uint32_t          bytes_per_sector;      /*! number of bytes per sector             */
-    uint32_t          sectors_per_cluster;   /*! number of sectors per cluster          */
-    uint32_t          fat_begin_lba;         /*! lba of FAT region                      */
-    uint32_t          cluster_begin_lba;     /*! lba of data region                     */
-    uint32_t          root_dir_cluster;      /*! cluster index for the root directory   */
-    uint32_t          last_allocated_sector; /*! TODO ???                               */
-    uint32_t          last_allocated_index;  /*! TODO ???                               */
-    xptr_t            fat_mapper_xp;         /*! FAT mapper (in IO cluster)             */
+    uint32_t            fat_sectors_count;     /*! number of sectors in FAT region      */
+    uint32_t            bytes_per_sector;      /*! number of bytes per sector           */
+    uint32_t            sectors_per_cluster;   /*! number of sectors per cluster        */
+    uint32_t            fat_begin_lba;         /*! lba of FAT region                    */
+    uint32_t            cluster_begin_lba;     /*! lba of data region                   */
+    uint32_t            fs_info_lba;           /*! lba of FS_INFO sector                */
+    uint32_t            root_dir_cluster;      /*! cluster index for  root directory    */
+    xptr_t              fat_mapper_xp;         /*! extended pointer on FAT mapper       */
+    uint32_t            free_cluster_hint;     /*! start point to search free cluster   */
+    uint32_t            free_clusters;         /*! free clusters number                 */
+    remote_queuelock_t  free_lock;             /*! exclusive access to hint & number    */
 }
 fatfs_ctx_t;
@@ -186 +199 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-/******************************************************************************************
- * This function scan the FAT (File Allocation Table), stored in the FAT mapper,
- * and returns the FATFS cluster index for a given page of a given file.
- * It must be called by a thread running in the cluster containing the FAT mapper.
- * We can use a RPC to scan the remote FAT mapper, because the RPC_FIFO will avoid 
- * contention in the cluster containing the FAT mapper, and the RPC latency is not 
- * critical compared to the device access latency.
+/*****************************************************************************************
+ * This function access the FAT (File Allocation Table), stored in the FAT mapper, and
+ * returns in <searched_cluster> the FATFS cluster index for a given page of a given 
+ * inode identified by the <first_cluster> and <page_id> arguments.
+ * It can be called by a thread running in any cluster, as it uses remote access
+ * primitives when the FAT mapper is remote.
  * The FAT is actually an array of uint32_t slots. Each slot in this array contains the 
  * index of another slot in this array, to form one linked list for each file stored on
@@ -198 +210 @@
  * FATFS cluster on the device. One FATFS cluster is supposed to contain one PPM page. 
  * For a given file, the entry point in the FAT is simply the index of the FATFS cluster 
- * containing the first page of the file. The mapper being a cache, this function 
- * automatically updates the FAT mapper from informations stored on device in case of miss.
- ******************************************************************************************
- * @ mapper                  : local pointer on the FAT mapper.
- * @ first_cluster       : index of the first FATFS cluster allocated to the file.
- * @ page_index          : index of searched page in file.
- * @ searched_cluster_id : [out] found FATFS cluster index.
- * @ return 0 if success / return EIO if a FAT mapper miss cannot be solved.
- *****************************************************************************************/
-error_t fatfs_get_cluster( struct mapper_s * mapper,
-                           uint32_t          first_cluster,
-                           uint32_t          page_index,
-                           uint32_t        * searched_cluster_id );
-
-/******************************************************************************************
+ * containing the first page of the file. The FAT mapper being a cache, this function 
+ * updates the FAT mapper from informations stored on IOC device in case of miss.
+ *****************************************************************************************
+ * @ first_cluster       : [in]  index of first FATFS cluster allocated to the file.
+ * @ page_id             : [in]  index of searched page in file.
+ * @ searched_cluster    : [out] found FATFS cluster index.
+ * @ return 0 if success / return -1 if a FAT mapper miss cannot be solved.
+ ****************************************************************************************/
+error_t fatfs_get_cluster( uint32_t   first_cluster,
+                           uint32_t   page_id,
+                           uint32_t * searched_cluster );
+
+/*****************************************************************************************
  * This function display the content of the FATFS context.
- *****************************************************************************************/
+ ****************************************************************************************/
 void fatfs_ctx_display( void );
 
+/*****************************************************************************************
+ * This function displays the content of a part of the File Allocation Table.
+ * It loads the requested page fom device to mapper if required.
+ *****************************************************************************************
+ * @ page_id   : page index in FAT mapper (one page is 4 Kbytes).
+ * @ nentries  : number of entries (one entry is 4 bytes).
+ ****************************************************************************************/
+void fatfs_display_fat( uint32_t  page_id,
+                        uint32_t  nentries );
+
+
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// Generic API: These functions are called by the kernel,
+// Generic API: These functions are called by the kernel VFS,
 //              and must be implemented by all File Systems.
 //////////////////////////////////////////////////////////////////////////////////////////
 
-/******************************************************************************************
+/*****************************************************************************************
  * This fuction allocates memory from local cluster for a FATFS context descriptor.
- ******************************************************************************************
+ *****************************************************************************************
  * @ return a pointer on the created context / return NULL if failure.
- *****************************************************************************************/
+ ****************************************************************************************/
 fatfs_ctx_t * fatfs_ctx_alloc( void );
 
 /*****************************************************************************************
- * This function access the boot device, and initialises the FATFS context
+ * This function access the boot device, and initialises the local FATFS context
  * from informations contained in the boot record. 
  *****************************************************************************************
@@ -246 +267 @@
 
 /*****************************************************************************************
- * This function moves a page from/to the mapper to/from the FATFS file system on device.
- * It must be called by a thread running in cluster containing the mapper.
- * The pointer on the mapper and the page index in file are found in the page descriptor.
- * WARNING : The inode field in the mapper MUST be NULL for the FAT mapper, as this
- * is used to implement a specific behaviour to access the FAT zone on device.
- *****************************************************************************************
- * @ page      : local pointer on page descriptor.
- * @ to_mapper : transfer direction
- * @ return 0 if success / return EIO if error. 
- ****************************************************************************************/
-error_t fatfs_mapper_move_page( struct page_s * page,
-                                bool_t          to_mapper );
-
-/*****************************************************************************************
- * This function scan an existing parent directory, identified by the <parent> argument,
- * to find a directory entry identified by the <name> argument and update the remote
- * child inode descriptor, identified by the <child_xp> argument.
- * It set the "type", "size", and "extend" (FAT cluster index) fields in child inode.
+ * This function implements the generic vfs_fs_add_dentry() function for the FATFS.
+ *****************************************************************************************
+ * This function updates a directory identified by the <inode> argument
+ * to add a new directory entry identified by the <dentry> argument.
+ * All modified pages in directory mapper are synchronously updated on IOC device.
+ * It must be called by a thread running in the cluster containing the inode.
+ *
+ * Implementation note : this function works in two steps:
+ * - It scan the set of 32 bytes FATFS directry entries, using two embedded loops  
+ *   to find the end of directory (NO_MORE_ENTRY marker).
+ * - Then it writes 3, 4, or 5 directory entries (depending on the name length), using 
+ *   a 5 steps FSM (one state per entry to be written), updates on IOC device the 
+ *   modified pages, and updates the dentry extension field, that must contain 
+ *   the dentry index in FATFS directory.
+ *****************************************************************************************
+ * @ inode    : local pointer on directory inode.
+ * @ dentry   : local pointer on dentry.
+ * @ return 0 if success / return ENOENT if not found, or EIO if no access to IOC device.
+ ****************************************************************************************/
+error_t fatfs_add_dentry( struct vfs_inode_s  * inode,
+                          struct vfs_dentry_s * dentry );
+
+/*****************************************************************************************
+ * This function implements the generic vfs_fs_remove_dentry() function for the FATFS.
+ *****************************************************************************************
+ * This function updates a directory identified by the <inode> argument
+ * to remove a directory entry identified by the <dentry> argument.
+ * All modified pages in directory mapper are synchronously updated on IOC device.
+ * It must be called by a thread running in the cluster containing the inode.
+ *
+ * Implementation note: this function uses the dentry extension to directly access 
+ * the NORMAL directory entry and invalidate all involved LFN entries. Then it
+ * updates the modified pages on IOC device.
+ *****************************************************************************************
+ * @ inode    : local pointer on directory inode.
+ * @ dentry   : local pointer on dentry.
+ * @ return 0 if success / return ENOENT if not found, or EIO if no access to IOC device.
+ ****************************************************************************************/
+error_t fatfs_remove_dentry( struct vfs_inode_s  * inode,
+                             struct vfs_dentry_s * dentry );
+
+/*****************************************************************************************
+ * This function implements the generic vfs_fs_child_init() function for the FATFS.
+ *****************************************************************************************
+ * It scan the mapper of an existing parent directory, identified by the <parent> 
+ * argument, to find a directory entry identified by the <name> argument.
+ * It updates the existing remote child inode, identified by the <child_xp> argument,
+ * - it set the "type", "size", and "extend" fields in inode descriptor.
+ * - it set the " extend" field in dentry descriptor.
  * It must be called by a thread running in the cluster containing the parent inode.
  *****************************************************************************************
@@ -271 +323 @@
  * @ return 0 if success / return ENOENT if child not found.
  ****************************************************************************************/
-error_t fatfs_inode_load( struct vfs_inode_s * parent_inode,
+error_t fatfs_child_init( struct vfs_inode_s * parent_inode,
                           char               * name,
                           xptr_t               child_inode_xp );
 
+/*****************************************************************************************
+ * This function implements the generic vfs_fs_sync_inode() function for the FATFS.
+ *****************************************************************************************
+ * It updates the FATFS on the IOC device for a given inode identified by 
+ * the <inode> argument. It scan all pages registered in the associated mapper,
+ * and copies from mapper to device each page marked as dirty.
+ * WARNING : The target <inode> cannot be a directory, because all modifications in a 
+ * directory * are synchronously done on the IOC device by the two fatfs_add_dentry() 
+ * and fatfs_remove_dentry() functions.
+ *****************************************************************************************
+ * @ inode   : local pointer on inode.
+ * @ return 0 if success / return EIO if failure during device access. 
+ ****************************************************************************************/
+error_t fatfs_sync_inode( struct vfs_inode_s * inode );
+
+/*****************************************************************************************
+ * This function implements the generic vfs_fs_sync_fat() function for the FATFS.
+ *****************************************************************************************
+ * It updates the FATFS on the IOC device for the FAT itself.
+ * It scan all clusters registered in the FAT mapper, and copies from mapper to device 
+ * each page marked as dirty.
+ *
+ * TODO : the current implementation check ALL pages in the FAT region, even if most
+ * pages are empty, and not copied in mapper. It is sub-optimal.
+ * - A first solution is to maintain in the FAT context two "dirty_min" and "dirty_max"
+ *  variables defining the smallest/largest dirty page index in FAT mapper... 
+ *****************************************************************************************
+ * @ return 0 if success / return EIO if failure during device access.
+ ****************************************************************************************/
+error_t fatfs_sync_fat( void );
+
+/*****************************************************************************************
+ * This function implements the generic vfs_fs_sync_fsinfo() function for the FATFS.
+ *****************************************************************************************
+ * It updates the FS_INFO sector on the IOC device. 
+ * It copies the <free_cluster_hint> and <free_clusters> variables from
+ * the FATFS context in cluster 0 to the FS_INFO sector on device. 
+ *****************************************************************************************
+ * @ return 0 if success / return EIO if failure during device access.
+ ****************************************************************************************/
+error_t fatfs_sync_free_info( void );
+
+/*****************************************************************************************
+ * This function implements the generic vfs_fs_cluster_alloc() function for the FATFS.
+ *****************************************************************************************
+ * It access the FAT (File allocation table), stored in the FAT mapper, and returns
+ * in <searched_cluster> the FATFS cluster index of a free cluster.
+ * It can be called by a thread running in any cluster, as it uses remote access
+ * primitives when the FAT mapper is remote. It takes the "free_lock" stored in the 
+ * FATFS context located in the same cluster as the FAT mapper itself, to get exclusive
+ * access to the FAT. It uses (and updates) the <free_cluster_hint> and <free_clusters> 
+ * shared variables in this FATFS context.
+ * It updates the FAT mapper, and synchronously updates the FAT region on IOC device. 
+ * The FAT mapper being a cache, this function updates the FAT mapper from informations
+ * stored on IOC device in case of miss.
+ *****************************************************************************************
+ * @ searched_cluster    : [out] found FATFS cluster index.
+ * @ return 0 if success / return -1 if no more free clusters on IOC device.
+ ****************************************************************************************/
+error_t fatfs_cluster_alloc( uint32_t * searched_cluster );
+
+/*****************************************************************************************
+ * This function implements the generic vfs_fs_release_inode() function for the FATFS.
+ *****************************************************************************************
+ * It releases all clusters allocated to a file/directory identified by the <inode_xp>
+ * argument. All released clusters are marked FREE_CLUSTER in the FAT mapper. 
+ * This function calls the recursive function fatfs_cluster_release() to release 
+ * the clusters in reverse order of the linked list (from last to first). 
+ * When the FAT mapper has been updated, it calls the fatfs_sync_fat() function to
+ * synchronously update all dirty pages in the FAT mapper to the IOC device.
+ * Finally the FS-INFO sector on the IOC device is updated.
+ *****************************************************************************************
+ * @ inode_xp   : extended pointer on inode.
+ * @ return 0 if success / return EIO if failure during device access.
+ ****************************************************************************************/
+error_t fatfs_release_inode( xptr_t inode_xp );
+
+/*****************************************************************************************
+ * This function implements the generic vfs_fs_move_page() function for the FATFS.
+ *****************************************************************************************
+ * This function moves a page from/to the mapper to/from the FATFS file system on device.
+ * The page must have been previously allocated and registered in the mapper, but the  
+ * page - and the mapper - can be located in another cluster than the calling thread.
+ * The pointer on the mapper and the page index in file are found in the page descriptor.
+ * It is used both for the regular file/directory mappers, and for the FAT mapper.
+ * For the FAT mapper, it access the FATFS to get the location on IOC device.
+ * For a regular file, it access the FAT mapper to get the cluster index on IOC device.
+ * It can be called by any thread running in any cluster.
+ *
+ * WARNING : For the FAT mapper, the inode field in the mapper MUST be NULL, as this
+ * is used to indicate that the corresponding mapper is the FAT mapper.
+ *****************************************************************************************
+ * @ page_xp   : extended pointer on page descriptor.
+ * @ to_mapper : true for device->mapper / false for mapper->device
+ * @ return 0 if success / return EIO if error during device access. 
+ ****************************************************************************************/
+error_t fatfs_move_page( xptr_t  page_xp,
+                         bool_t  to_mapper );
+
+
+
+
+
+
 #endif  /* _FATFS_H_ */

trunk/kernel/fs/ramfs.c

@@ -35 +35 @@
                      char   * ramfs_root_name )
 {
-    xptr_t    root_inode_xp;   // unused                      
+    xptr_t    unused_xp;   // required by vfs_add_child_in_parent()                     
  
     cxy_t     cxy = cluster_random_select();
@@ -45 +45 @@
                                      parent_inode_xp,
                                      ramfs_root_name,
-                                     NULL,
-                                     &root_inode_xp );
+                                     &unused_xp,
+                                     &unused_xp );
 }
 

trunk/kernel/fs/vfs.c

@@ -57 +57 @@
 extern char *             lock_type_str[];            // allocated in kernel_init.c
   
-//////////////////////////////////////////////////////////////////////////////////////////
-//           Context related functions
+///////////////////////////////////////////////////////////////////////////////////////////
+//           VFS Context related functions
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -123 +123 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
-//           Inode related functions
+//           VFS inode descriptor related functions
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -145 +145 @@
                           vfs_fs_type_t     fs_type,
                           vfs_inode_type_t  inode_type,
-                          void            * extend,
                           uint32_t          attr,
                           uint32_t          rights,
@@ -228 +227 @@
     inode->ctx        = ctx;
     inode->mapper     = mapper;
-    inode->extend     = extend;
+    inode->extend     = NULL;
 
     // initialise inode field in mapper
@@ -258 +257 @@
 }  // end vfs_inode_create()  
 
-////////////////////////////////////////////////
-error_t vfs_inode_destroy( vfs_inode_t * inode )
-{
-    assert( (inode->refcount == 0) , "inode refcount non zero\n" );
+/////////////////////////////////////////////
+void vfs_inode_destroy( vfs_inode_t * inode )
+{
+
+// check inode refcount
+assert( (inode->refcount == 0) , "inode refcount non zero\n" );
 
     // release memory allocated for mapper
@@ -272 +273 @@
         kmem_free( &req );
 
-    return 0;
-
 }  // end vfs_inode_destroy()
-
-/////////////////////////////////////////////
-error_t vfs_inode_load( vfs_inode_t * parent,
-                        char        * name,
-                        xptr_t        child_xp )
-{
-
-#if DEBUG_VFS_INODE_LOAD
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VFS_INODE_LOAD < cycle )
-printk("\n[%s] thread %x enter for <%s> / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD , name , cycle );
-#endif
-
-    error_t error = 0;
-
-    assert( (parent != NULL) , "parent pointer is NULL\n");
-
-    assert( (child_xp != XPTR_NULL) , "child pointer is NULL\n");
-
-    // get parent inode FS type
-    vfs_fs_type_t fs_type = parent->ctx->type;
-
-    // call relevant FS function
-    if( fs_type == FS_TYPE_FATFS )
-    {
-        error = fatfs_inode_load( parent , name , child_xp );
-    }
-    else if( fs_type == FS_TYPE_RAMFS )
-    {
-        assert( false , "should not be called for RAMFS\n" );
-    }
-    else if( fs_type == FS_TYPE_DEVFS )
-    {
-        assert( false , "should not be called for DEVFS\n" );
-    }
-    else
-    {
-        assert( false , "undefined file system type\n" );
-    }
-
-#if DEBUG_VFS_INODE_LOAD
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VFS_INODE_LOAD < cycle )
-printk("\n[%s] thread %x exit for <%s> / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD , name , cycle );
-#endif
-
-    return error;
-
-} // end vfs_inode_load()
 
 ////////////////////////////////////////////
@@ -429 +377 @@
 }  // end vfs_inode_get_name()
 
+///////////////////////////////////////////////////////
+error_t vfs_inode_load_all_pages( vfs_inode_t * inode )
+{
+
+assert( (inode != NULL) , "inode pointer is NULL\n" );
+
+    uint32_t   page_id;
+    xptr_t     page_xp;
+
+    mapper_t * mapper = inode->mapper;
+    uint32_t   size   = inode->size;
+
+assert( (mapper != NULL) , "mapper pointer is NULL\n" );
+
+#if DEBUG_VFS_INODE_LOAD_ALL
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+char       name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
+if( DEBUG_VFS_INODE_LOAD_ALL < cycle )
+printk("\n[%s] thread[%x,%x] enter for <%s> in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, local_cxy, cycle );
+#endif
+
+    // compute number of pages
+    uint32_t npages = size >> CONFIG_PPM_PAGE_SHIFT;
+    if( (size & CONFIG_PPM_PAGE_MASK) || (size == 0) ) npages++;
+
+    // loop on pages 
+    for( page_id = 0 ; page_id < npages ; page_id ++ )
+    {
+        // If the mage is missing, this function allocates the missing page,
+        // and load the page from IOC device into mapper
+        page_xp = mapper_remote_get_page( XPTR( local_cxy , mapper ), page_id );
+
+        if( page_xp == XPTR_NULL ) return -1;
+    }
+
+#if DEBUG_VFS_INODE_LOAD_ALL
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_INODE_LOAD_ALL < cycle )
+printk("\n[%s] thread[%x,%x] exit for <%x> in cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, local_cxy, cycle );
+#endif
+
+    return 0;
+
+}  // end vfs_inode_load_all_pages()
+
 ////////////////////////////////////////////////////////////////////////////////////////////
-//           Dentry related functions
+//          VFS dentry descriptor related functions
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -480 +477 @@
     dentry->length  = length;
     dentry->parent  = parent;
+    dentry->extend  = NULL;
     strcpy( dentry->name , name );
 
@@ -509 +507 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_DENTRY_CREATE < cycle )
-printk("\n[%s] thread[%x,%x] exit for <%s> / dentry %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, name, dentry, cycle );
+printk("\n[%s] thread[%x,%x] exit for <%s> / dentry [%x,%x] / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, local_cxy, dentry, cycle );
 #endif
 
@@ -517 +515 @@
 }  // end vfs_dentry_create()
 
-///////////////////////////////////////////////////
-error_t vfs_dentry_destroy( vfs_dentry_t * dentry )
-{
-    error_t error;
-
-    assert( (dentry->refcount == 0) , __FUNCTION__ , "dentry refcount non zero\n" );
+////////////////////////////////////////////////
+void vfs_dentry_destroy( vfs_dentry_t * dentry )
+{
+
+// check dentry refcount
+assert( (dentry->refcount == 0) , "dentry refcount non zero\n" );
 
     // get pointer on parent inode
@@ -528 +526 @@
 
     // remove this dentry from parent inode htab
-    error = xhtab_remove( XPTR( local_cxy , &parent->children ),
-                          dentry->name,
-                          XPTR( local_cxy , &dentry->list ) ); 
-
-    if( error ) return EINVAL;     
+    xhtab_remove( XPTR( local_cxy , &parent->children ),
+                  dentry->name,
+                  XPTR( local_cxy , &dentry->list ) ); 
 
     // release memory allocated to dentry
@@ -540 +536 @@
         kmem_free( &req );
 
-    return 0;
+}  // end vfs_dentry_destroy()
+
+//////////////////////////////////////////////
+void vfs_dentry_remote_up( xptr_t  dentry_xp )
+{
+    // get dentry cluster and local pointer
+    cxy_t          dentry_cxy = GET_CXY( dentry_xp );
+    vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
+
+    hal_remote_atomic_add( XPTR( dentry_cxy , &dentry_ptr->refcount ) , 1 );    
 }
 
+////////////////////////////////////////////////
+void vfs_dentry_remote_down( xptr_t  dentry_xp )
+{
+    // get dentry cluster and local pointer
+    cxy_t          dentry_cxy = GET_CXY( dentry_xp );
+    vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
+
+    hal_remote_atomic_add( XPTR( dentry_cxy , &dentry_ptr->refcount ) , -1 );    
+}
+
 
 
 //////////////////////////////////////////////////////////////////////////////////////////
-//           File descriptor related functions
+//       VFS file descriptor related functions
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -645 +660 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
-//           File access related functions
+//           "syscalls" API related functions
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -665 +680 @@
     uint32_t      file_id;      // created file descriptor index in reference fd_array
 
-    assert( (mode == 0), __FUNCTION__,
-    "the mode parameter is not supported yet\n" );
+
+    if( mode != 0 )
+    {
+        printk("\n[ERROR] in %s : the mode parameter is not supported yet\n" );
+        return -1;
+    }
 
 #if DEBUG_VFS_OPEN
@@ -736 +755 @@
                    uint32_t size )
 {
-    assert( ( file_xp != XPTR_NULL ) , "file_xp == XPTR_NULL" );
-
     cxy_t              file_cxy;     // remote file descriptor cluster 
     vfs_file_t       * file_ptr;     // remote file descriptor local pointer
@@ -745 +762 @@
     error_t            error;
 
+// check argument
+assert( (file_xp != XPTR_NULL), "file_xp == XPTR_NULL\n" );
+
     // get cluster and local pointer on remote file descriptor
     file_cxy  = GET_CXY( file_xp );
@@ -752 +772 @@
     inode_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type   ) );
    
-    assert( (inode_type == INODE_TYPE_FILE) ,
-    "inode type is not INODE_TYPE_FILE" );
+// check inode type
+assert( (inode_type == INODE_TYPE_FILE), "inode type is not INODE_TYPE_FILE" );
 
     // get mapper pointer and file offset from file descriptor
@@ -770 +790 @@
     else
     {
-        rpc_mapper_move_buffer_client( file_cxy,
-                                       mapper,
-                                       to_buffer,
-                                       true,          // user buffer
-                                       file_offset,
-                                       (uint64_t)(intptr_t)buffer,
-                                       size,
-                                       &error );
+        rpc_mapper_move_user_client( file_cxy,
+                                     mapper,
+                                     to_buffer,
+                                     file_offset,
+                                     buffer,
+                                     size,
+                                     &error );
     } 
 
-    if( error ) return -1;
-    else        return size;
+    // update file offset in file descriptor
+    hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->offset ) , size );
+
+    if( error ) 
+    {
+        return -1;
+    }
+
+    return size;
 
 }  // end vfs_user_move()
@@ -791 +817 @@
                          uint32_t size )
 {
-    assert( ( file_xp != XPTR_NULL ) , "file_xp == XPTR_NULL" );
-
     cxy_t              file_cxy;     // remote file descriptor cluster 
     vfs_file_t       * file_ptr;     // remote file descriptor local pointer
-    vfs_inode_type_t   inode_type;
+    vfs_inode_type_t   inode_type;   // remote file type
     uint32_t           file_offset;  // current offset in file
-    mapper_t         * mapper;
+    mapper_t         * mapper_ptr;   // remote mapper local pointer
+    xptr_t             mapper_xp;    // remote mapper extended pointer
     error_t            error;
+
+// check argument
+assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL\n" );
 
     // get cluster and local pointer on remote file descriptor
@@ -810 +838 @@
     if( inode_type == INODE_TYPE_FILE )
     {
-        // get mapper pointer and file offset from file descriptor
+        // get mapper pointers and file offset from file descriptor
         file_offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
-        mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
+        mapper_ptr  = hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
+        mapper_xp   = XPTR( file_cxy , mapper_ptr );
 
         // move data between mapper and buffer
-        if( file_cxy == local_cxy )
-        {
-            error = mapper_move_kernel( mapper,
-                                        to_buffer,
-                                        file_offset,
-                                        buffer_xp,
-                                        size );
-        }
-        else
-        {
-            rpc_mapper_move_buffer_client( file_cxy,
-                                           mapper,
-                                           to_buffer,
-                                           false,          // kernel buffer
-                                           file_offset,
-                                           buffer_xp,
-                                           size,
-                                           &error );
-        } 
-
+        error = mapper_move_kernel( mapper_xp,
+                                    to_buffer,
+                                    file_offset,
+                                    buffer_xp,
+                                    size );
         if( error ) return -1;
-        else        return 0;
     }
     else 
@@ -843 +856 @@
         return -1;
     }
+
+    return 0;
+
 }  // end vfs_kernel_move()
 
@@ -853 +869 @@
     xptr_t         offset_xp;
     xptr_t         lock_xp;
+    xptr_t         size_xp;
     cxy_t          file_cxy;
     vfs_file_t  *  file_ptr;
@@ -858 +875 @@
     uint32_t       new;
 
-    assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL" );
+// check argument
+assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL\n" );
 
     // get cluster and local pointer on remote file descriptor
@@ -864 +882 @@
     file_ptr = GET_PTR( file_xp );
 
-    // build extended pointers on lock and offset
+    // get local pointer on remote inode
+    inode_ptr = (vfs_inode_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
+
+    // build extended pointers on lock, offset and size
     offset_xp = XPTR( file_cxy , &file_ptr->offset );
     lock_xp   = XPTR( file_cxy , &file_ptr->lock );
+    size_xp   = XPTR( file_cxy , &inode_ptr->size );
 
     // take file descriptor lock
@@ -881 +903 @@
     else if ( whence == SEEK_END )   // new = size + offset
     { 
-        // get local pointer on remote inode
-        inode_ptr = (vfs_inode_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
-
-        new = hal_remote_l32( XPTR( file_cxy , &inode_ptr->size ) ) + offset;
+        new = hal_remote_l32( size_xp ) + offset;
     }
     else
@@ -893 +912 @@
     }
 
+#if DEBUG_VFS_LSEEK
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+char       name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( XPTR( file_cxy , inode_ptr ) , name );
+if( cycle > DEBUG_VFS_LSEEK )
+printk("\n[%s] thread[%x,%x] for <%s> / new offset %d / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, name, new, cycle );
+#endif
+
     // set new offset
     hal_remote_s32( offset_xp , new );
@@ -900 +929 @@
 
     // success
-    if ( new_offset != NULL )
-        *new_offset = new;
+    if ( new_offset != NULL ) *new_offset = new;
     return 0;
 
@@ -922 +950 @@
     process_t  * process_ptr;      // process copy local pointer
 
-    assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL" );
-
-    assert( (file_id < CONFIG_PROCESS_FILE_MAX_NR) , "illegal file_id" );
+// check arguments
+assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL\n" );
+assert( (file_id < CONFIG_PROCESS_FILE_MAX_NR) , "illegal file_id\n" );
 
     thread_t  * this    = CURRENT_THREAD;
@@ -1019 +1047 @@
                     char   * path )
 {
-    assert( false , "not implemented cwd_xp %x, path <%s> \n",
-      cwd_xp, path );   
-    return 0;
-} 
+    error_t           error;
+    xptr_t            inode_xp;           // extended pointer on target inode
+    cxy_t             inode_cxy;          // target inode cluster identifier       
+    vfs_inode_t     * inode_ptr;          // target inode local pointer
+    uint32_t          inode_refcount;     // target inode refcount
+    vfs_inode_type_t  type;               // target inode type
+    mapper_t        * mapper;             // pointer on target inode mapper
+    xptr_t            dentry_xp;          // extended pointer on target dentry
+    cxy_t             dentry_cxy;         // target dentry cluster identifier
+    vfs_dentry_t    * dentry_ptr;         // target dentry local pointer
+    uint32_t          dentry_refcount;    // target dentry refcount
+    vfs_inode_t     * dentry_parent_ptr;  // parent inode local pointer
+
+#if DEBUG_VFS_UNLINK
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_UNLINK < cycle )
+printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, path, cycle );
+#endif
+
+    // get extended pointer on target inode
+    error = vfs_lookup( cwd_xp , path , 0 , &inode_xp );
+
+    if( error ) return error;
+
+    // get inode cluster and local pointer
+    inode_cxy = GET_CXY( inode_xp );
+    inode_ptr = GET_PTR( inode_xp );
+
+    // get inode type, refcount, mapper, dentry_xp
+    type              = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
+    inode_refcount    = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->refcount ) );
+    mapper            = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
+    dentry_xp         = hal_remote_l64( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
+
+    // get dentry cluster, local pointer, refcount, and pointers on parent inode
+    dentry_ptr        = GET_PTR( dentry_xp );
+    dentry_cxy        = GET_CXY( dentry_xp );
+    dentry_refcount   = hal_remote_l32( XPTR( dentry_cxy , &dentry_ptr->refcount ) );
+    dentry_parent_ptr = hal_remote_lpt( XPTR( dentry_cxy , &dentry_ptr->parent ) );
+
+// check inode & dentry refcount
+assert( (inode_refcount  == 1), "illegal inode refcount for <%s>\n", path );
+assert( (dentry_refcount == 1), "illegal dentry refcount for <%s>\n", path );
+
+    /////////////////////////////
+    if( type == INODE_TYPE_FILE )
+    {
+        // 1. release clusters allocated to file in the FAT mapper
+        //    synchronize the FAT on IOC device 
+        error = vfs_fs_release_inode( inode_xp ); 
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot update FAT mapper <%s>\n", path );
+            return -1;
+        }
+
+#if(DEBUG_VFS_UNLINK & 1)
+if( DEBUG_VFS_UNLINK < cycle )
+printk("\n[%s] thread[%x,%x] removed <%s> inode from FAT (mapper and IOC device)\n",
+__FUNCTION__, this->process->pid, this->trdid, path );
+#endif
+
+        // 2. update parent directory in Inode Tree
+        //    synchronize the parent directory on IOC device
+        if (dentry_cxy == local_cxy)                           // dentry is local
+        {
+            error = vfs_fs_remove_dentry( dentry_parent_ptr,
+                                          dentry_ptr );
+        }
+        else                                                  // dentry is remote
+        {
+            rpc_vfs_fs_remove_dentry_client( dentry_cxy,
+                                             dentry_parent_ptr,
+                                             dentry_ptr,
+                                             &error );
+        }
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot update dentry on device for <%s>\n", path );
+            return -1;
+        }
+
+#if(DEBUG_VFS_UNLINK & 1)
+if( DEBUG_VFS_UNLINK < cycle )
+printk("\n[%s] thread[%x,%x] removed <%s> inode from parent dir (mapper and IOC device)\n",
+__FUNCTION__, this->process->pid, this->trdid, path );
+#endif
+        // 3. remove inode (including mapper & dentry) from Inode Tree
+        vfs_remove_child_from_parent( inode_xp );
+
+#if DEBUG_VFS_UNLINK
+if( DEBUG_VFS_UNLINK < cycle )
+printk("\n[%s] thread[%x,%x] exit / removed <%s> inode from Inode Tree / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, path, cycle );
+#endif
+        return 0;
+    }
+    /////////////////////////////////
+    else if( type == INODE_TYPE_DIR )
+    {
+        printk("\n[ERROR] in %s : unsupported type %s\n", vfs_inode_type_str( type ) );
+        return -1;
+    }
+    ////
+    else
+    {
+        printk("\n[ERROR] in %s : unsupported type %s\n", vfs_inode_type_str( type ) );
+        return -1;
+    }
+
+}  // end vfs_unlink() 
 
 //////////////////////////////////////
@@ -1058 +1195 @@
 
     return 0;
-}
+
+}  // end vfs_stat()
 
 /////////////////////////////////////////////
@@ -1172 +1310 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
-//            Inode Tree functions
+//       Distributed Inode Tree access related functions
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1336 +1474 @@
 }  // end vfs_display()
 
+/*
 //////////////////////////////////////////////////////////////////////////////////////////
-// This function is used by the vfs_lookup() function.
+// This static function is used by the vfs_lookup() function.
 // It takes an extended pointer on a remote inode (parent directory inode),
 // and check access_rights violation for the calling thread.
@@ -1347 +1486 @@
 // @ return true if access rights are violated.
 //////////////////////////////////////////////////////////////////////////////////////////
-bool_t vfs_access_denied( xptr_t   inode_xp,
+static bool_t vfs_access_denied( xptr_t   inode_xp,
                           uint32_t client_uid,
                           uint32_t client_gid )
@@ -1364 +1503 @@
     else                                             return true;
 }
+*/
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -1465 +1605 @@
     cxy_t              parent_cxy;   // cluster for parent inode
     vfs_inode_t      * parent_ptr;   // local pointer on parent inode  
+    xptr_t             dentry_xp;    // extended pointer on dentry       
     xptr_t             child_xp;     // extended pointer on child inode
     cxy_t              child_cxy;    // cluster for child inode
-    vfs_inode_t      * child_ptr;    // local pointer on child inode  
+    vfs_inode_t      * child_ptr;    // local pointer on child inode
+    vfs_inode_type_t   child_type;   // child inode type
     vfs_fs_type_t      fs_type;      // File system type
     vfs_ctx_t        * ctx_ptr;      // local pointer on FS context
@@ -1519 +1661 @@
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s]  look for <%s> / last = %d\n",
-__FUNCTION__ , name , last );
+printk("\n[%s] thread[%x,%x] look for <%s> in <%s> / last = %d\n",
+__FUNCTION__, process->pid, this->trdid, name, pathname, last );
 #endif
 
@@ -1533 +1675 @@
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s]  miss <%s> node => try to create it\n",
-__FUNCTION__ , name );
+printk("\n[%s] thread[%x,%x] miss <%s> node => try to create it\n",
+__FUNCTION__, process->pid, this->trdid, name );
 #endif
             // if a child node is not found in the inode tree,
@@ -1544 +1686 @@
             // . if it is not found in the parent mapper:
             //   - if ( not last or not create ) an error is reported
-            //   - if (last and create and dir) a new directory is created
-            //   - if (last and create and not dir) a new file is created
+            //   - if (last and create) a new file or directory is created
 
             // release lock on parent inode
             vfs_inode_unlock( parent_xp );
  
-            // get parent inode FS type
+            // get parent inode cluster and local pointer
             parent_cxy = GET_CXY( parent_xp );
             parent_ptr = GET_PTR( parent_xp );
-            ctx_ptr    = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy,&parent_ptr->ctx ) );
+
+            // get parent inode FS type
+            ctx_ptr    = hal_remote_lpt( XPTR( parent_cxy,&parent_ptr->ctx ) );
             fs_type    = hal_remote_l32( XPTR( parent_cxy , &ctx_ptr->type ) );
 
             // select a cluster for missing inode
             child_cxy = cluster_random_select();
+
+            // define child inode type
+            if( dir ) child_type = INODE_TYPE_DIR;
+            else      child_type = INODE_TYPE_FILE;
  
             // insert a new child dentry/inode in inode tree
             error = vfs_add_child_in_parent( child_cxy,
-                                             0,           // type will be updated later
+                                             child_type, 
                                              fs_type, 
                                              parent_xp, 
                                              name, 
-                                             NULL,        // fs_type_specific inode extend
+                                             &dentry_xp,
                                              &child_xp );
             if( error )
             {
-                printk("\n[ERROR] in %s : cannot create node %s for path <%s>\n",
+                printk("\n[ERROR] in %s : cannot create node <%s> in path <%s>\n",
                 __FUNCTION__ , name, pathname );
-                return ENOMEM;
+                return -1;
             }
 
-            // get child inode cluster and local pointer
-            child_cxy = GET_CXY( child_xp );
+            // get child inode local pointer
             child_ptr = GET_PTR( child_xp );
 
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s]  missing <%s> inode speculatively created / cxy %x / ptr %x\n",
-__FUNCTION__ , name , child_cxy, child_ptr );
-#endif
-             // scan parent mapper to complete the missing inode
+printk("\n[%s] thread[%x,%x] created missing inode <%s> in cluster %x\n",
+__FUNCTION__, process->pid, this->trdid, name, child_cxy );
+#endif
+            // scan parent mapper to find the missing dentry, and complete 
+            // the initialisation of dentry and child inode desciptors
             if( parent_cxy == local_cxy )
+
             {
-                error = vfs_inode_load( parent_ptr,
-                                        name,
-                                        child_xp );
+                error = vfs_fs_child_init( parent_ptr,
+                                           name,
+                                           child_xp );
             }
             else
             {
-                rpc_vfs_inode_load_client( parent_cxy,
-                                           parent_ptr,
-                                           name,
-                                           child_xp,
-                                           &error );
+                rpc_vfs_fs_child_init_client( parent_cxy,
+                                              parent_ptr,
+                                              name,
+                                              child_xp,
+                                              &error );
             }
 
             if ( error )   // child not found in parent mapper
             {
-                if( last && create && dir )  // new directory  => update inode type
+                if ( last && create )  // add a new dentry in parent
                 {
-                     hal_remote_s32( XPTR( child_cxy, &child_ptr->type ), INODE_TYPE_DIR );
+                    error = vfs_new_child_init( parent_xp,                
+                                                dentry_xp,
+                                                child_xp );
+                    if ( error )
+                    {
+                        printk("\n[ERROR] in %s : cannot init inode <%s> in path <%s>\n",
+                        __FUNCTION__, name, pathname );
+                        vfs_remove_child_from_parent( child_xp );
+                        return -1;
+                    }
 
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s]  created node <%s> in path %s / type DIR\n",
-__FUNCTION__ , name, pathname );
+printk("\n[%s] thread[%x,%x] created inode <%s> in path\n",
+__FUNCTION__, process->pid, this->trdid, name );
 #endif
                 }
-                else if ( last && create )   // new file => update inode type
-                {
-                     hal_remote_s32( XPTR( child_cxy, &child_ptr->type ), INODE_TYPE_FILE );
-
-#if (DEBUG_VFS_LOOKUP & 1)
-if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s]  created node <%s> in path %s / type FILE\n",
-__FUNCTION__ , name, pathname );
-#endif
-                }
-                else                         // not last or not create => remove created node 
+                else                   // not last or not create => error
                 {                       
                      printk("\n[ERROR] in %s : <%s> node not found in parent for <%s>\n",
@@ -1629 +1776 @@
                 }
             }
-            else          // child found in parent
+            else          // child found in parent mapper
             {
                 // load child mapper from device if child is a directory (prefetch)
@@ -1636 +1783 @@
                     if( child_cxy == local_cxy )
                     {
-                        error = vfs_mapper_load_all( child_ptr );
+                        error = vfs_inode_load_all_pages( child_ptr );
                     }
                     else
                     {
-                        rpc_vfs_mapper_load_all_client( child_cxy,
-                                                        child_ptr,
-                                                        &error );
+                        rpc_vfs_inode_load_all_pages_client( child_cxy,
+                                                             child_ptr,
+                                                             &error );
                     }
                     if ( error )
@@ -1654 +1801 @@
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s]  load mapper from device for node <%s> in path %s\n",
-__FUNCTION__ , name, pathname );
+printk("\n[%s] thread[%x,%x] loaded from IOC device mapper for <%s> in <%s>\n",
+__FUNCTION__ , process->pid, this->trdid, name, pathname );
 #endif
                 }
@@ -1668 +1815 @@
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s]  found <%s> / inode %x in cluster %x\n",
-__FUNCTION__ , name , GET_PTR(child_xp) , GET_CXY(child_xp) );
+printk("\n[%s] thread[%x,%x] found <%s> / inode %x in cluster %x\n",
+__FUNCTION__, process->pid, this->trdid, name, GET_PTR(child_xp), GET_CXY(child_xp) );
 #endif
             child_ptr  = GET_PTR( child_xp );
@@ -1710 +1857 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s] thread[%x,%x] exit for <%s>\n" 
-"     parent %x in cluster %x / child %x in cluster %x / cycle %d\n",
-__FUNCTION__ , process->pid, this->trdid, pathname, 
-parent_ptr, parent_cxy, child_ptr, child_cxy, cycle );
+printk("\n[%s] thread[%x,%x] exit for <%s> cycle %d\n",
+__FUNCTION__ , process->pid, this->trdid, pathname, cycle );
 #endif
 
@@ -1723 +1868 @@
 
 }  // end vfs_lookup()
+
+
+
+///////////////////////////////////////////////
+error_t vfs_new_child_init( xptr_t   parent_xp,
+                            xptr_t   dentry_xp,
+                            xptr_t   child_xp )
+{
+    error_t     error;
+    uint32_t    cluster;
+    uint32_t    child_type;
+    uint32_t    child_size;
+
+#if DEBUG_VFS_NEW_CHILD_INIT
+char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
+char child_name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( parent_xp , parent_name );
+vfs_inode_get_name( child_xp  , child_name );
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_VFS_NEW_CHILD_INIT < cycle )
+printk("\n[%s] thread[%x,%x] enter / parent <%s> / child <%s> / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, parent_name, child_name, cycle );
+#endif
+
+    // get parent inode cluster and local pointer
+    cxy_t          parent_cxy = GET_CXY( parent_xp );
+    vfs_inode_t  * parent_ptr = GET_PTR( parent_xp );
+
+    // get dentry local pointer
+    vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
+
+    // get child inode cluster and local pointer
+    cxy_t          child_cxy  = GET_CXY( child_xp );
+    vfs_inode_t  * child_ptr  = GET_PTR( child_xp );
+
+    // 1. allocate one free cluster to child inode
+    // depending on the child inode FS type
+    vfs_ctx_t * ctx = hal_remote_lpt( XPTR( child_cxy , &child_ptr->ctx ) );
+
+    error = vfs_fs_cluster_alloc( ctx->type,
+                                  &cluster );
+    if ( error )
+    {
+        printk("\n[ERROR] in %s : cannot find a free VFS cluster\n",
+        __FUNCTION__ );
+        return -1;
+    }
+
+#if( DEBUG_VFS_NEW_CHILD_INIT & 1)
+if( DEBUG_VFS_NEW_CHILD_INIT < cycle )
+printk("\n[%s] thread[%x,%x] allocated one FAT cluster to <%s>\n",
+__FUNCTION__ , this->process->pid, this->trdid, child_name );
+#endif
+
+    // 2. update the child inode descriptor
+    child_type = hal_remote_l32( XPTR( child_cxy , &child_ptr->type ) );
+    child_size = (child_type == INODE_TYPE_DIR) ? 4096 : 0;
+    
+    hal_remote_s32( XPTR( child_cxy , &child_ptr->size )   , child_size );
+    hal_remote_spt( XPTR( child_cxy , &child_ptr->extend ) , (void*)(intptr_t)cluster );
+
+    // 3. update the parent inode mapper, and 
+    // update the dentry extension if required
+    if( local_cxy == parent_cxy )
+    {
+        error = vfs_fs_add_dentry( parent_ptr,
+                                   dentry_ptr );
+    }
+    else
+    {
+        rpc_vfs_fs_add_dentry_client( parent_cxy,
+                                      parent_ptr,
+                                      dentry_ptr,
+                                      &error );
+    }
+    if ( error )
+    {
+        printk("\n[ERROR] in %s : cannot register child in parent directory\n",
+        __FUNCTION__ );
+        return -1;
+    }
+
+#if DEBUG_VFS_NEW_CHILD_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_NEW_CHILD_INIT < cycle )
+printk("\n[%s] thread[%x,%x] exit / parent <%s> / child <%> / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, parent_name, child_name, cycle );
+#endif
+
+    return 0;
+
+}  // end vfs_new_child_init()
 
 ////////////////////////////////////////////
@@ -1794 +2032 @@
 
       
-//////////////////////////////////////////////////////////////
-error_t vfs_add_child_in_parent( cxy_t              child_cxy,
-                                 vfs_inode_type_t   inode_type,
+////////////////////////////////////////////////////////////////////
+error_t vfs_add_child_in_parent( cxy_t              child_inode_cxy,
+                                 vfs_inode_type_t   child_inode_type,
                                  vfs_fs_type_t      fs_type,
-                                 xptr_t             parent_xp,
+                                 xptr_t             parent_inode_xp,
                                  char             * name,
-                                 void             * extend,
-                                 xptr_t           * child_xp )
+                                 xptr_t           * dentry_xp,
+                                 xptr_t           * child_inode_xp )
 {
     error_t         error;
-    xptr_t          dentry_xp;   // extended pointer on created dentry
-    xptr_t          inode_xp;    // extended pointer on created inode
-    cxy_t           parent_cxy;  // parent inode cluster identifier
-    vfs_inode_t   * parent_ptr;  // parent inode local pointer
+    xptr_t          new_dentry_xp;       // extended pointer on created dentry
+    vfs_dentry_t  * new_dentry_ptr;      // created dentry local pointer
+    xptr_t          new_inode_xp;        // extended pointer on created child inode
+    cxy_t           parent_inode_cxy;    // parent inode cluster identifier
+    vfs_inode_t   * parent_inode_ptr;    // parent inode local pointer
 
     // get parent inode cluster and local pointer
-    parent_cxy = GET_CXY( parent_xp );
-    parent_ptr = GET_PTR( parent_xp );
+    parent_inode_cxy = GET_CXY( parent_inode_xp );
+    parent_inode_ptr = GET_PTR( parent_inode_xp );
 
 #if DEBUG_VFS_ADD_CHILD
+char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( parent_inode_xp , parent_name );
 uint32_t cycle = (uint32_t)hal_get_cycles();
 thread_t * this = CURRENT_THREAD; 
 if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[%s] thread[%x,%x] enter for <%s> / child_cxy %x / parent_cxy %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, name,
-child_cxy, parent_cxy, (uint32_t)hal_get_cycles() );
+printk("\n[%s] thread[%x,%x] enter / child <%s> cxy %x / parent <%s> cxy %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, child_inode_cxy,
+parent_name, parent_inode_cxy, (uint32_t)hal_get_cycles() );
 #endif
 
     // 1. create dentry
-    if( parent_cxy == local_cxy )      // parent cluster is the local cluster
+    if( parent_inode_cxy == local_cxy )      // parent cluster is the local cluster
     {
         error = vfs_dentry_create( fs_type,
                                    name,
-                                   parent_ptr,
-                                   &dentry_xp );
+                                   parent_inode_ptr,
+                                   &new_dentry_xp );
     }
     else                               // parent cluster is remote
     {
-        rpc_vfs_dentry_create_client( parent_cxy,
+        rpc_vfs_dentry_create_client( parent_inode_cxy,
                                       fs_type,
                                       name,
-                                      parent_ptr,
-                                      &dentry_xp,
+                                      parent_inode_ptr,
+                                      &new_dentry_xp,
                                       &error );
     }
@@ -1843 +2084 @@
     {
         printk("\n[ERROR] in %s : cannot create dentry <%s> in cluster %x\n",
-        __FUNCTION__ , name , parent_cxy );
-        return ENOMEM;
-    }
+        __FUNCTION__ , name , parent_inode_cxy );
+        return -1;
+    }
+
+    // get dentry local pointer
+    new_dentry_ptr = GET_PTR( new_dentry_xp );
 
 #if(DEBUG_VFS_ADD_CHILD & 1)
 if( DEBUG_VFS_ADD_CHILD < cycle )
 printk("\n[%s] thread[%x,%x] / dentry <%s> created in cluster %x\n",
-__FUNCTION__, this->process->pid, this->trdid, name, parent_cxy );
+__FUNCTION__, this->process->pid, this->trdid, name, parent_inode_cxy );
 #endif
 
@@ -1859 +2103 @@
     uint32_t gid  = 0;
     
-    if( child_cxy == local_cxy )      // child cluster is the local cluster
-    {
-        error = vfs_inode_create( dentry_xp,
+    if( child_inode_cxy == local_cxy )      // child cluster is the local cluster
+    {
+        error = vfs_inode_create( new_dentry_xp,
                                   fs_type,
-                                  inode_type,
-                                  extend,
+                                  child_inode_type,
                                   attr,
                                   mode,
                                   uid,
                                   gid,
-                                  &inode_xp );
+                                  &new_inode_xp );
     }
     else                              // child cluster is remote
     {
-        rpc_vfs_inode_create_client( child_cxy,
-                                     dentry_xp,
+        rpc_vfs_inode_create_client( child_inode_cxy,
+                                     new_dentry_xp,
                                      fs_type,
-                                     inode_type,
-                                     extend,
+                                     child_inode_type,
                                      attr,
                                      mode,
                                      uid,
                                      gid,
-                                     &inode_xp,
+                                     &new_inode_xp,
                                      &error );
     }
@@ -1889 +2131 @@
     {
         printk("\n[ERROR] in %s : cannot create inode in cluster %x\n",
-               __FUNCTION__ , child_cxy );
+               __FUNCTION__ , child_inode_cxy );
  
-        vfs_dentry_t * dentry = GET_PTR( dentry_xp );
-        if( parent_cxy == local_cxy ) vfs_dentry_destroy( dentry );
-        else rpc_vfs_dentry_destroy_client( parent_cxy , dentry , &error );
-        return ENOMEM;
+        if( parent_inode_cxy == local_cxy ) vfs_dentry_destroy( new_dentry_ptr );
+        else rpc_vfs_dentry_destroy_client( parent_inode_cxy , new_dentry_ptr );
+        return -1;
     }
 
@@ -1900 +2141 @@
 if( DEBUG_VFS_ADD_CHILD < cycle )
 printk("\n[%s] thread[%x,%x] / inode <%s> created in cluster %x\n",
-__FUNCTION__ , this->process->pid, this->trdid, name , child_cxy );
-#endif
-
-    // 3. update extended pointer on inode in dentry
-    cxy_t          dentry_cxy = GET_CXY( dentry_xp );
-    vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
-    hal_remote_s64( XPTR( dentry_cxy , &dentry_ptr->child_xp ) , inode_xp );
+__FUNCTION__ , this->process->pid, this->trdid, name , child_inode_cxy );
+#endif
+
+    // 3. update "child_xp" field in dentry and increment refcounts
+    hal_remote_s64( XPTR( parent_inode_cxy , &new_dentry_ptr->child_xp ) , new_inode_xp );
+    vfs_inode_remote_up( new_inode_xp );
+    vfs_dentry_remote_up( new_dentry_xp );
 
 #if DEBUG_VFS_ADD_CHILD
@@ -1915 +2156 @@
 #endif
 
-    // success : return extended pointer on child inode
-    *child_xp = inode_xp;
+    // return extended pointer on dentry & child inode
+    *dentry_xp      = new_dentry_xp;
+    *child_inode_xp = new_inode_xp;
     return 0;
 
-    // FIXME update the refcount fields in both inode and dentry
-
 }  // end vfs_add_child_in_parent()
 
-///////////////////////////////////////////////////////
-error_t vfs_remove_child_from_parent( xptr_t inode_xp )
+////////////////////////////////////////////////////
+void vfs_remove_child_from_parent( xptr_t inode_xp )
 {
     cxy_t          inode_cxy;
@@ -1931 +2171 @@
     cxy_t          dentry_cxy;
     vfs_dentry_t * dentry_ptr;
-    error_t        error;
    
     // get inode cluster and local pointer
@@ -1937 +2176 @@
     inode_ptr = GET_PTR( inode_xp );
 
-    // get cluster and pointers of associated dentry
+    // get associated dentry cluster and pointers 
     dentry_xp  = hal_remote_l64( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
     dentry_cxy = GET_CXY( dentry_xp ); 
     dentry_ptr = GET_PTR( dentry_xp );
 
-    // FIXME update the refcount fields in both inode and dentry
+// check dentry refcount
+assert( ( hal_remote_l32( XPTR( dentry_cxy , &dentry_ptr->refcount ) ) == 1 ),
+"dentry refcount must be 1\n" );
+
+// check inode refcount
+assert( ( hal_remote_l32( XPTR( inode_cxy , &inode_ptr->refcount ) ) == 1 ),
+"inode refcount must be 1\n" );
+
+    // decrement refcount for inode and dentry
+    vfs_inode_remote_down( inode_xp );
+    vfs_dentry_remote_down( dentry_xp );
 
     // delete dentry
     if( dentry_cxy == local_cxy )
     {
-         error = vfs_dentry_destroy( dentry_ptr );
+         vfs_dentry_destroy( dentry_ptr );
     }
     else
     {
          rpc_vfs_dentry_destroy_client( dentry_cxy,
-                                        dentry_ptr,
-                                        &error );
-    }
-    if( error ) return EINVAL;
+                                        dentry_ptr );
+    }
 
     // delete inode
@@ -1965 +2212 @@
     {
          rpc_vfs_inode_destroy_client( inode_cxy,
-                                       inode_ptr,
-                                       &error );
-    }
-    if( error ) return EINVAL;
-
-    return 0;
+                                       inode_ptr );
+    }
 
 }  // end vfs_remove_child_from_parent()
 
 //////////////////////////////////////////////////////////////////////////////////////////
-//            Mapper related functions
+//    API used by VFS to access a specific FS  
 //////////////////////////////////////////////////////////////////////////////////////////
 
-////////////////////////////////////////////
-error_t vfs_mapper_move_page( page_t * page,
-                              bool_t   to_mapper )
+///////////////////////////////////////////
+error_t vfs_fs_move_page( xptr_t   page_xp,
+                          bool_t   to_mapper )
 {
     error_t error = 0;
 
-    assert( (page != NULL) , "page pointer is NULL\n" );
-
-    mapper_t    * mapper = page->mapper;
-
-    assert( (mapper != NULL) , "no mapper for page\n" );
-
-#if DEBUG_VFS_MAPPER_MOVE
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-thread_t * this  = CURRENT_THREAD;
-if( DEBUG_VFS_MAPPER_MOVE < cycle )
-printk("\n[%s] thread[%x,%x] enter for page %d / mapper %x / inode %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, page->index, mapper, mapper->inode, cycle );
-#endif
+assert( (page_xp != XPTR_NULL) , "page pointer is NULL\n" );
+
+    page_t * page_ptr = GET_PTR( page_xp );
+    cxy_t    page_cxy = GET_CXY( page_xp );
+
+    // get local pointer on page mapper
+    mapper_t * mapper = hal_remote_lpt( XPTR( page_cxy , &page_ptr->mapper ) );
+
+assert( (mapper != NULL) , "no mapper for page\n" );
+
+    // get FS type
+    vfs_fs_type_t fs_type = hal_remote_l32( XPTR( page_cxy , &mapper->type ) );
+
+    // call relevant FS function
+    if( fs_type == FS_TYPE_FATFS )
+    {
+        error = fatfs_move_page( page_xp , to_mapper ); 
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , "undefined file system type\n" );
+    }
+
+    return error;
+
+}  // end vfs_fs_move_page()
+
+////////////////////////////////////////////////
+error_t vfs_fs_add_dentry( vfs_inode_t  * inode,
+                           vfs_dentry_t * dentry )
+{
+    error_t error = 0;
+
+assert( (inode  != NULL) , "inode  pointer is NULL\n" );
+assert( (dentry != NULL) , "dentry pointer is NULL\n" );
+
+    mapper_t * mapper = inode->mapper;
+
+assert( (mapper != NULL) , "mapper pointer is NULL\n" );
 
     // get FS type
@@ -2004 +2281 @@
     if( fs_type == FS_TYPE_FATFS )
     {
-        // enter mapper in write mode
-        rwlock_wr_acquire( &mapper->lock );
-
-        // move page to mapper
-        error = fatfs_mapper_move_page( page , to_mapper ); 
-
-        // exit mapper in write mode
-        rwlock_wr_release( &mapper->lock );
+        error = fatfs_add_dentry( inode , dentry ); 
     }
     else if( fs_type == FS_TYPE_RAMFS )
@@ -2026 +2296 @@
     }
 
-#if DEBUG_VFS_MAPPER_MOVE
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VFS_MAPPER_MOVE < cycle )
-printk("\n[%s] thread[%x,%x] exit for page %d / mapper %x / inode %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, page->index, mapper, mapper->inode, cycle );
-#endif
-
     return error;
 
-}  // end vfs_move_page()
-
-//////////////////////////////////////////////////
-error_t vfs_mapper_load_all( vfs_inode_t * inode )
-{
-    assert( (inode != NULL) , "inode pointer is NULL\n" );
-
-    uint32_t   index;
-    page_t   * page;
+}  // end vfs_fs_add_dentry()
+
+///////////////////////////////////////////////////
+error_t vfs_fs_remove_dentry( vfs_inode_t  * inode,
+                              vfs_dentry_t * dentry )
+{
+    error_t error = 0;
+
+assert( (inode  != NULL) , "inode  pointer is NULL\n" );
+assert( (dentry != NULL) , "dentry pointer is NULL\n" );
 
     mapper_t * mapper = inode->mapper;
-    uint32_t   size   = inode->size;
 
 assert( (mapper != NULL) , "mapper pointer is NULL\n" );
 
-#if DEBUG_VFS_MAPPER_LOAD
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-thread_t * this  = CURRENT_THREAD;
-if( DEBUG_VFS_MAPPER_MOVE < cycle )
-printk("\n[%s] thread[%x,%x] enter for inode %x in cluster %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, inode, local_cxy, cycle );
-#endif
-
-    // compute number of pages
-    uint32_t npages = size >> CONFIG_PPM_PAGE_SHIFT;
-    if( (size & CONFIG_PPM_PAGE_MASK) || (size == 0) ) npages++;
-
-    // loop on pages 
-    for( index = 0 ; index < npages ; index ++ )
-    {
-        // this function allocates the missing page in mapper,
-        // and call the vfs_mapper_move_page() to load the page from device
-        page = mapper_get_page( mapper , index );
-
-        if( page == NULL ) return EIO;
-    }
-
-#if DEBUG_VFS_MAPPER_LOAD
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VFS_MAPPER_MOVE < cycle )
-printk("\n[%s] thread[%x,%x] exit for inode %x in cluster %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, inode, local_cxy, cycle );
-#endif
-
-    return 0;
-
-}  // end vfs_mapper_load_all()
-
+    // get FS type
+    vfs_fs_type_t fs_type = mapper->type;
+
+    // call relevant FS function
+    if( fs_type == FS_TYPE_FATFS )
+    {
+        error = fatfs_remove_dentry( inode , dentry ); 
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , "undefined file system type\n" );
+    }
+
+    return error;
+
+}  // end vfs_fs_remove_dentry()
+
+////////////////////////////////////////////////
+error_t vfs_fs_child_init( vfs_inode_t * parent,
+                           char        * name,
+                           xptr_t        child_xp )
+{
+    error_t error = 0;
+
+// check arguments
+assert( (parent != NULL) , "parent pointer is NULL\n");
+assert( (child_xp != XPTR_NULL) , "child pointer is NULL\n");
+
+    // get parent inode FS type
+    vfs_fs_type_t fs_type = parent->ctx->type;
+
+    // call relevant FS function
+    if( fs_type == FS_TYPE_FATFS )
+    {
+        error = fatfs_child_init( parent , name , child_xp );
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , "undefined file system type\n" );
+    }
+
+    return error;
+
+} // end vfs_fs_child_init()
+
+/////////////////////////////////////////////////
+error_t vfs_fs_cluster_alloc( uint32_t   fs_type,
+                              uint32_t * cluster )
+{
+    error_t error = 0;
+
+    // call relevant FS function
+    if( fs_type == FS_TYPE_FATFS )
+    {
+        error = fatfs_cluster_alloc( cluster );
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , "undefined file system type\n" );
+    }
+
+    return error;
+
+} // end vfs_fs_alloc_cluster()
+
+////////////////////////////////////////////////
+error_t vfs_fs_release_inode( xptr_t  inode_xp )
+{
+    error_t error = 0;
+
+assert( (inode_xp  != XPTR_NULL) , "inode pointer is NULL\n")        
+
+    vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
+    cxy_t         inode_cxy = GET_CXY( inode_xp );
+
+    // get local pointer on page mapper 
+    mapper_t * mapper = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
+
+assert( (mapper != NULL) , "mapper pointer is NULL\n")        
+
+    // get FS type from mapper
+    vfs_fs_type_t fs_type = hal_remote_l32( XPTR( inode_cxy , &mapper->type ) );
+
+    // call relevant FS function
+    if( fs_type == FS_TYPE_FATFS )
+    {
+        error = fatfs_release_inode( inode_xp ); 
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , "undefined file system type\n" );
+    }
+
+    return error;
+    
+}  // end vfs_fs_release_inode()
+
+

trunk/kernel/fs/vfs.h

@@ -78 +78 @@
  * This structure defines a VFS context, that contains informations common to all inodes
  * and dentries for a given file system. As it is declared as a global variable in the
- * kdata segment, it is handled as private by each OS intance in a given cluster.
+ * kdata segment (fs_context[] array), it is replicated in all clusters.
+ * The <extend> field is a pointer on the FS specific context extension. 
+ * This extension is dynamically allocated by kernel_init in all clusters.
+ * In each cluster, both this VFS context and the FS specific context are handled as
+ * private by the local OS intance.
  *****************************************************************************************/
 
@@ -252 +256 @@
 
 
-/*****************************************************************************************/
-/******************** VFS global functions ***********************************************/
-/*****************************************************************************************/ 
-
-
-/****************************************************************************************** 
- * This function mount a given file system type for a given process TODO.     
- *****************************************************************************************/
-error_t vfs_mount_fs_root( struct device_s  * device,
-                                       uint32_t           fs_type,
-                                       struct process_s * process );
-
-
-/*****************************************************************************************/
-/******************* VFS Context related functions ****************************************/
-/*****************************************************************************************/
+/******************************************************************************************
+ *        These functions access / modify  a VFS context.
+ *****************************************************************************************/
 
 /****************************************************************************************** 
@@ -311 +302 @@
 
 
-/*****************************************************************************************/
-/********************* Inode related functions *******************************************/
-/*****************************************************************************************/
+/******************************************************************************************
+ *        These low-level functions access / modify a VFS inode descriptor
+ *****************************************************************************************/
+
+/****************************************************************************************** 
+ * This function returns a printable string for the inode type.
+ *****************************************************************************************/
+const char * vfs_inode_type_str( vfs_inode_type_t type );
 
 /****************************************************************************************** 
@@ -325 +321 @@
  * @ fs_type    : file system type.
  * @ inode_type : inode type.
- * @ extend     : local pointer on vs_type_specific extension.
  * @ attr       : inode attributes.
  * @ rights     : inode access rights.
@@ -336 +331 @@
                           vfs_fs_type_t     fs_type,
                           vfs_inode_type_t  inode_type,
-                          void            * extend,
                           uint32_t          attr,
                           uint32_t          rights,
@@ -344 +338 @@
 
 /****************************************************************************************** 
- * This function releases memory allocated to an inode descriptor.
- * It must be executed by a thread running in the cluster containing the inode,
- * and the inode refcount must be zero. If the client thread is not running in the owner 
- * cluster, you must use the rpc_vfs_inode_destroy_client() function.
+ * This function releases memory allocated to an inode descriptor, including
+ * all memory allocated to the mapper (both mapper descriptor and radix tree).
+ * The mapper should not contain any dirty page (shold be synchronized before deletion),
+ * and the inode refcount must be zero.
+ * It must be executed by a thread running in the cluster containing the inode.
+ * Use the rpc_vfs_inode_destroy_client() function if required.
  ****************************************************************************************** 
  * @ inode  : local pointer on inode descriptor.
- * @ return 0 if success / return EINVAL if error.
- *****************************************************************************************/
-error_t vfs_inode_destroy( vfs_inode_t *  inode );  
-
-/******************************************************************************************
- * This function scan an existing parent inode directory, identified by the <parent> 
- * argument to find a directory entry identified by the <name> argument, and update 
- * the remote child inode, identified by the <child_xp> argument.
- * Depending on the file system type, it calls the relevant, FS specific function,
- * to scan the directory, and set the "type", "size", and "extend" fields.
- * It must be called by a thread running in the cluster containing the parent inode.
- ******************************************************************************************
- * @ parent    : local pointer on parent inode (directory).
- * @ name      : child name.
- * @ child_xp  : extended pointer on remote child inode (file or directory)
- * @ return 0 if success / return ENOENT if not found.
- *****************************************************************************************/
-error_t vfs_inode_load( vfs_inode_t * parent,
-                        char        * name,
-                        xptr_t        child_xp );
+ *****************************************************************************************/
+void vfs_inode_destroy( vfs_inode_t *  inode );  
 
 /****************************************************************************************** 
@@ -399 +377 @@
 /****************************************************************************************** 
  * This function takes the main lock of a remote inode.
- * This lock protect all inode fiels, including the children dentries.
+ * This lock protect all inode fields, including the children dentries.
  *****************************************************************************************
  * @ inode_xp  : extended pointer on the remote inode.
@@ -424 +402 @@
                          char * name );
 
-
-/*****************************************************************************************/
-/***************** Dentry related functions **********************************************/
-/*****************************************************************************************/
+/******************************************************************************************
+ * This function accesses successively all pages of a file identified by the <inode>,
+ * argument, to force misses, and load all pages into mapper.
+ * The target inode can be a directory or a file, but this function is mainly used 
+ * to prefetch a complete directory to the mapper.
+ * It must be executed by a thread running in the cluster containing the inode.
+ * This function does NOT take any lock.
+ ******************************************************************************************
+ * @ inode  : local pointer on inode.
+ * @ return 0 if success / return -1 if device access failure.
+ *****************************************************************************************/
+error_t vfs_inode_load_all_pages( vfs_inode_t * inode );
+
+
+/******************************************************************************************
+ *        These low-level functions access / modify a VFS dentry descriptor
+ *****************************************************************************************/
 
 /****************************************************************************************** 
@@ -449 +440 @@
 /****************************************************************************************** 
  * This function releases memory allocated to a dentry descriptor.
- * It must be executed by a thread running in the cluster containing the dentry,
- * and the dentry refcount must be zero. If the client thread is not running in the owner
- * cluster, you must use the rpc_dentry_destroy_client() function.
+ * The dentry refcount must be zero. 
+ * It must be executed by a thread running in the cluster containing the dentry.
+ * Use the rpc_vfs_dentry_destroy_client() function if required.
  ****************************************************************************************** 
  * @ dentry  : local pointer on dentry descriptor.
- * @ return 0 if success / return EINVAL if error.
- *****************************************************************************************/
-error_t vfs_dentry_destroy( vfs_dentry_t *  dentry );  
+ *****************************************************************************************/
+void vfs_dentry_destroy( vfs_dentry_t *  dentry );  
 
 /****************************************************************************************** 
@@ -466 +456 @@
 
 
-/*****************************************************************************************/
-/************************ File descriptor related functions ******************************/
-/*****************************************************************************************/
+/******************************************************************************************
+ *        These low-level functions access / modify a VFS file descriptor
+ *****************************************************************************************/
 
 /****************************************************************************************** 
@@ -505 +495 @@
 
 
-/*****************************************************************************************/
-/******************* Inode-Tree related functions ****************************************/ 
-/*****************************************************************************************/ 
-
-/****************************************************************************************** 
- * This function returns a printable string for the inode type.
- *****************************************************************************************/
-const char * vfs_inode_type_str( vfs_inode_type_t type );
+/******************************************************************************************
+ *        These functions access / modify the distributed VFS Inode Treee
+ *****************************************************************************************/
 
 /****************************************************************************************** 
@@ -555 +540 @@
  * This function creates a new couple dentry/inode, and insert it in the Inode-Tree.
  * It can be executed by any thread running in any cluster (can be different from both
- * the child cluster and the parent cluster), as it uses the rpc_dentry_create_client()
- * and rpc_inode_create client() if required. This is done in three steps:
- * 1) The dentry is created in the cluster containing the existing <parent_xp> inode.
- *    The new dentry name is defined by the <name> argument.
- * 2) The inode and its associated mapper are created in cluster identified by <child_cxy>.
- *    The new inode and the parent inode can have different FS types.
- * 3) The "child_xp" field in created dentry (pointing on the created inode) is updated.
- ******************************************************************************************
- * @ child_cxy  : target cluster for child inode.
- * @ inode_type : new inode type
- * @ fs_type    : new inode FS type.
- * @ parent_xp  : extended pointer on parent inode.
- * @ name       : new directory entry name.
- * @ extend     : fs_type_specific inode extension.
- * @ child_xp   : [out] buffer for extended pointer on child inode.
- * @ return 0 if success / ENOMEM if dentry or inode cannot be created.
- *****************************************************************************************/
-error_t vfs_add_child_in_parent( cxy_t              child_cxy,
-                                 vfs_inode_type_t   inode_type,
+ * the child cluster and the parent cluster), as it uses RPCs if required.
+ * Only the distributed Inode Tree is modified: Even for a new file, this function
+ * does NOT modify the parent mapper, and does NOT update the FS on IOC device.
+ * 
+ * [Implementation]
+ * As there are cross-references between the inode and the associated dentry, this
+ * function implement a three steps scenario :
+ * 1) The dentry descriptor is created in the cluster containing the existing <parent_xp>
+ *    inode, and is only partially initialized : "fs_type", "name", "parent_xp" fields.
+ * 2) The inode and its associated mapper are created in cluster identified by <child_cxy>,
+ *    and initialised. The new inode and the parent inode can have different FS types.
+ * 3) The "child_xp" field in dentry (pointing on the created inode) is updated,
+ *    and the refcount is incremented for both the inode and the dentry.
+ ******************************************************************************************
+ * @ child_inode_cxy  : [in]  target cluster for child inode.
+ * @ child_inode_type : [in]  child inode type
+ * @ fs_type          : [in]  child inode FS type.
+ * @ parent_inode_xp  : [in]  extended pointer on parent inode.
+ * @ name             : [in]  new directory entry name.
+ * @ dentry_xp        : [out] buffer for extended pointer on dentry
+ * @ child_inode_xp   : [out] buffer for extended pointer on child inode.
+ * @ return 0 if success / -1 if dentry or inode cannot be created.
+ *****************************************************************************************/
+error_t vfs_add_child_in_parent( cxy_t              child_inodecxy,
+                                 vfs_inode_type_t   chilg_inode_type,
                                  vfs_fs_type_t      fs_type,
-                                 xptr_t             parent_xp,
-                                 char             * name,   
-                                 void             * extend,
-                                 xptr_t           * child_xp );
-
-/******************************************************************************************
- * This function removes a couple dentry/inode from the Inode-Tree, and remove it from
- * the external device.
+                                 xptr_t             parent_inode_xp,
+                                 char             * name,
+                                 xptr_t           * dentry_xp,   
+                                 xptr_t           * child_inode_xp );
+
+/******************************************************************************************
+ * This function removes a couple dentry/inode from the Inode-Tree.
+ * Both the inode and dentry references counters must be 1.
+ * It can be executed by any thread running in any cluster (can be different from both
+ * the inode cluster and the dentry cluster), as it uses RPCs if required.
  ******************************************************************************************
  * @ child_xp   : extended pointer on removed inode.
  *****************************************************************************************/
-error_t vfs_remove_child_from_parent( xptr_t inode_xp );
+void vfs_remove_child_from_parent( xptr_t inode_xp );
+
+/******************************************************************************************
+ * This function is called by the vfs_lookup() function when a new dentry/inode must
+ * be created from scratch and introduced in both the Inode Tree and the IOC device.
+ * The dentry and inode descriptors have been created by the caller:
+ * - It allocates one cluster from the relevant FS, and updates the File Allocation
+ *   Table (both the FAT mapper, and the IOC device).
+ * - It set the "size", and "extend" fields in child inode descriptor.
+ * - It updates the parent directory to introduce the new child in the parent directory
+ *   inode descriptor (radix tree), in theparent inode mapper, and on IOC device.
+ * - It set the "extend" field in dentry descriptor.
+ * It can be called by a thread running in any cluster.
+ ******************************************************************************************
+ * @ parent_xp   : extended pointer on parent inode descriptor.
+ * @ dentry_xp   : extended pointer on new dentry descriptor.
+ * @ child_xp    : extended pointer on child inode descriptor.
+ * @ return 0 if success / -1 if failure.
+ *****************************************************************************************/
+error_t vfs_new_child_init( xptr_t   parent_xp,
+                         xptr_t   dentry_xp,
+                         xptr_t   child_xp );
 
 /******************************************************************************************
@@ -597 +611 @@
 void vfs_display( xptr_t   inode_xp );
 
-
-
-
-
-/*****************************************************************************************/
-/****************** File access API ******************************************************/
-/*****************************************************************************************/
+/****************************************************************************************** 
+ * This function mount a given file system type for a given process 
+ * TODO non implemented yet [AG].     
+ *****************************************************************************************/
+error_t vfs_mount_fs_root( struct device_s  * device,
+                                       uint32_t           fs_type,
+                                       struct process_s * process );
+
+
+
+/******************************************************************************************
+ *        These functions define the VFS "syscalls" API (user commands)
+ *****************************************************************************************/
+
+/****************************************************************************************** 
+ * This function moves <size> bytes between a remote file mapper, identified by the 
+ * <file_xp> argument, and a - possibly distributed - user space <buffer>, taken into 
+ * account the offset in <file_xp>. The transfer direction is defined by <to_buffer>.
+ * It is called by the sys_read() and sys_write() functions.
+ ******************************************************************************************
+ * @ to_buffer : mapper -> buffer if true / buffer -> mapper if false. 
+ * @ file_xp   : extended pointer on the remote file descriptor.
+ * @ buffer    : user space pointer on buffer (can be physically distributed).
+ * @ size      : requested number of bytes from offset.
+ * @ returns number of bytes actually moved if success / -1 if error.
+ *****************************************************************************************/
+int vfs_user_move( bool_t   to_buffer,
+                   xptr_t   file_xp, 
+                   void   * buffer,
+                   uint32_t size );
+
+/****************************************************************************************** 
+ * This function moves <size> bytes between a remote file mapper, identified by the 
+ * <file_xp> argument, and a - possibly remote - kernel <buffer_xp>, taken into 
+ * account the offset in <file_xp>. The transfer direction is defined by <to_buffer>.
+ * It is called by the elf_load_process() function.
+ ******************************************************************************************
+ * @ to_buffer : mapper -> buffer if true / buffer -> mapper if false. 
+ * @ file_xp   : extended pointer on the remote file descriptor.
+ * @ buffer_xp : user space pointer on buffer (can be physically distributed).
+ * @ size      : requested number of bytes from offset.
+ * @ returns 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_kernel_move( bool_t   to_buffer,
+                         xptr_t   file_xp, 
+                         xptr_t   buffer_xp,
+                         uint32_t size );
 
 /****************************************************************************************** 
@@ -619 +673 @@
  * @ process     : local pointer on local process descriptor copy.
  * @ path        : file pathname (absolute or relative to current directory).
- * @ flags       : defined above.
- * @ mode        : access rights (as defined by chmod)
+ * @ flags       : defined in vfs_file_t structure.
+ * @ mode        : access rights (as defined by chmod).
  * @ file_xp     : [out] buffer for extended pointer on created remote file descriptor.
  * @ file_id     : [out] buffer for created file descriptor index in reference fd_array.
@@ -631 +685 @@
                           xptr_t           * file_xp,
                           uint32_t         * file_id );
-
-/****************************************************************************************** 
- * This function moves <size> bytes between a remote file mapper, identified by the 
- * <file_xp> argument, and a - possibly distributed - user space <buffer>, taken into 
- * account the offset in <file_xp>. The transfer direction is defined by <to_buffer>.
- * It is called by the sys_read() and sys_write() functions.
- ******************************************************************************************
- * @ to_buffer : mapper -> buffer if true / buffer -> mapper if false. 
- * @ file_xp   : extended pointer on the remote file descriptor.
- * @ buffer    : user space pointer on buffer (can be physically distributed).
- * @ size      : requested number of bytes from offset.
- * @ returns number of bytes actually moved if success / -1 if error.
- *****************************************************************************************/
-int vfs_user_move( bool_t   to_buffer,
-                   xptr_t   file_xp, 
-                   void   * buffer,
-                   uint32_t size );
-
-/****************************************************************************************** 
- * This function moves <size> bytes between a remote file mapper, identified by the 
- * <file_xp> argument, and a - possibly remote - kernel <buffer_xp>, taken into 
- * account the offset in <file_xp>. The transfer direction is defined by <to_buffer>.
- * It is called by the elf_load_process() function.
- ******************************************************************************************
- * @ to_buffer : mapper -> buffer if true / buffer -> mapper if false. 
- * @ file_xp   : extended pointer on the remote file descriptor.
- * @ buffer_xp : user space pointer on buffer (can be physically distributed).
- * @ size      : requested number of bytes from offset.
- * @ returns 0 if success / -1 if error.
- *****************************************************************************************/
-error_t vfs_kernel_move( bool_t   to_buffer,
-                         xptr_t   file_xp, 
-                         xptr_t   buffer_xp,
-                         uint32_t size );
 
 /****************************************************************************************** 
@@ -685 +705 @@
 
 /****************************************************************************************** 
- * This function close the -non-replicated- file descriptor identified by the <file_xp>
+ * This function close the - non-replicated - file descriptor identified by the <file_xp>
  * and <file_id> arguments.
  * 1) All entries in the fd_array copies are directly reset by the calling thread,
@@ -700 +720 @@
 
 /****************************************************************************************** 
- * This function remove from the file system a directory entry identified by the
- * <cwd_xp> & <path> arguments.
+ * This function is called by the kernel to create in the file system a new directory 
+ * entry identified by the <cwd_xp> & <path_1>, linked to the node identified by the
+ * <cwd_xp> & <path_2> arguments.  It can be any type of node.
+ * If the link is successful, the link count of the target node is incremented.
+ * <path_1> and <path_2> share equal access rights to the underlying object.
+ * Both the IOC device and the Inode Tree are modified. 
+ ******************************************************************************************
+ * @ cwd_xp   : extended pointer on current working directory file descriptor.
+ * @ path_1   : new pathname (absolute or relative to current directory).
+ * @ path_1   : existing pathname (absolute or relative to current directory).
+ * @ returns 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_link( xptr_t   cwd_xp,
+                  char   * path_1,
+                  char   * path_2 );
+
+/****************************************************************************************** 
+ * This function is called by the kernel to remove from the file system a directory entry
+ * identified by the  <cwd_xp> & <path> arguments. The target node can be any type of node.
+ * The link count of the target node is decremented. If the removed link is the last,
+ * the target node is deleted.
+ * Both the IOC device and the Inode Tree are modified. 
  ******************************************************************************************
  * @ cwd_xp   : extended pointer on the current working directory file descriptor.
@@ -747 +787 @@
                    char     * path,
                    uint32_t   mode );
-
-/****************************************************************************************** 
- * This function remove a directory identified by the <cwd_xp / path> arguments
- * from the file system.
- * TODO not implemented yet...
- ******************************************************************************************
- * @ cwd_xp   : extended pointer on the current working directory file descriptor.
- * @ path     : pathname (absolute or relative to current directory).                     
- * @ returns 0 if success / -1 if error.
- *****************************************************************************************/
-error_t vfs_rmdir( xptr_t   cwd_xp,
-                   char   * path );
 
 /****************************************************************************************** 
@@ -797 +825 @@
 
 
-/*****************************************************************************************/
-/****************** Mapper access API ****************************************************/
-/*****************************************************************************************/
-
-/******************************************************************************************
- * This function makes an I/O operation to move one page to/from device from/to the mapper.
+
+/******************************************************************************************
+ *        These functions define the VFS "FS" API (to a specific File System)
+ *****************************************************************************************/
+
+/******************************************************************************************
+ * This function updates the mapper associated to a directory inode identified by the 
+ * <parent> argument, to add a new entry identified by the <dentry> argument. 
+ * The directory inode descriptor and the dentry descriptor are in the same cluster.
+ * Depending on the file system type, it calls the proper, FS specific function.
+ * It ulso pdates the dentry descriptor and/or the inode descriptor extensions
+ * as required by the specific file system type.
+ * Finally, it synchronously updates the parent directory on IOC device.
+ *
+ * It must be executed by a thread running in the cluster containing the parent directory.
+ * It can be the RPC_VFS_VS_ADD_DENTRY. This function does NOT take any lock.
+ ******************************************************************************************
+ * @ parent  : local pointer on parent (directory) inode.
+ * @ dentry  : local pointer on dentry containing name.
+ * @ return 0 if success / return -1 if device access failure.
+ *****************************************************************************************/
+error_t vfs_fs_add_dentry( vfs_inode_t  * parent,
+                           vfs_dentry_t * dentry );
+
+/******************************************************************************************
+ * This function updates the mapper associated to a directory inode identified by the 
+ * <parent> argument, to remove an entry identified by the <dentry> argument. 
+ * The directory inode descriptor and the dentry descriptor are in the same cluster.
+ * Depending on the file system type, it calls the proper, FS specific function.
+ * Finally, it synchronously updates the parent directory on IOC device.
+ *
+ * It must be executed by a thread running in the cluster containing the parent directory.
+ * It can be the RPC_VFS_VS_REMOVE_DENTRY. This function does NOT take any lock.
+ ******************************************************************************************
+ * @ parent  : local pointer on parent (directory) inode.
+ * @ dentry  : local pointer on dentry containing name.
+ * @ return 0 if success / return -1 if device access failure.
+ *****************************************************************************************/
+error_t vfs_fs_remove_dentry( vfs_inode_t  * parent,
+                              vfs_dentry_t * dentry );
+
+/******************************************************************************************
+ * This function scan the mapper of an an existing parent inode directory, identified by
+ * the <parent> argument to find a directory entry identified by the <name> argument,
+ * and updates both the child inode descriptor, identified by the <child_xp> argument,
+ * and the associated dentry descriptor :
+ * - It set the "size", and "extend" fields in inode descriptor.
+ * - It set the "extend" field in dentry descriptor.
+ * It is called by the vfs_lookup() function in case of miss.
+ *
+ * Depending on the file system type, it calls the relevant, FS specific function.
+ * It must be called by a thread running in the cluster containing the parent inode.
+ * This function does NOT take any lock.
+ ******************************************************************************************
+ * @ parent    : local pointer on parent inode (directory).
+ * @ name      : child name.
+ * @ child_xp  : extended pointer on remote child inode (file or directory)
+ * @ return 0 if success / return ENOENT if not found.
+ *****************************************************************************************/
+error_t vfs_fs_child_init( vfs_inode_t * parent,
+                           char        * name,
+                           xptr_t        child_xp );
+
+/*****************************************************************************************
+ * This function  updates the FS on the IOC device for a given inode identified by 
+ * the <inode> argument. It scan all pages registered in the associated mapper,
+ * and copies from mapper to device each page marked as dirty.
+ * WARNING : The target <inode> cannot be a directory, because all modifications in a 
+ * directory are synchronously done on the IOC device by the two vfs_fs_add_dentry() 
+ * and vfs_fs_remove_dentry() functions.
+ *
+ * Depending on the file system type, it calls the relevant, FS specific function.
+ * It must be called by a thread running in the inode cluster.
+ *****************************************************************************************
+ * @ inode   : local pointer on inode.
+ * @ return 0 if success / return EIO if failure during device access. 
+ ****************************************************************************************/
+error_t vfs_fs_sync_inode( struct vfs_inode_s * inode );
+
+/*****************************************************************************************
+ * This function updates the FS on the IOC device for the FAT itself.
+ * It scan all clusters registered in the FAT mapper, and copies to device 
+ * each page marked as dirty.
+ *
+ * Depending on the file system type, it calls the relevant, FS specific function.
+ * It can be called by a thread running in any cluster.
+ *****************************************************************************************
+ * @ return 0 if success / return EIO if failure during device access.
+ ****************************************************************************************/
+error_t vfs_fs_sync_fat( void );
+
+/*****************************************************************************************
+ * This function updates the free clusters info on the IOC device. 
+ *
+ * Depending on the file system type, it calls the relevant, FS specific function.
+ * It can be called by a thread running in any cluster.
+ *****************************************************************************************
+ * @ return 0 if success / return EIO if failure during device access.
+ ****************************************************************************************/
+error_t vfs_fs_sync_free_info( void );
+
+/******************************************************************************************
+ * This function allocates a free cluster from the FS identified by the <fs_type>
+ * argument. It updates the selected FS File Allocation Table.
+ *
+ * Depending on the file system type, it calls the relevant, FS specific function.
+ * It can be called by a thread running in any cluster.
+ ******************************************************************************************
+ * @ fs_type   : [in]  File System type.
+ * @ cluster   : [out] cluster index in File system.
+ * @ return 0 if success / return -1 if no free cluster
+ *****************************************************************************************/
+error_t vfs_fs_cluster_alloc( uint32_t   fs_type,
+                              uint32_t * cluster );
+
+/******************************************************************************************
+ * This function makes all I/O operations required to release all clusters allocated
+ * on IOC device to a given inode, identified by the <inode_xp> argument.
+ * Depending on the file system type, it calls the proper, FS specific function.
+ * It is called by the vfs_unlink() function.
+ * It can be executed by a thread running in any cluster.
+ * This function does NOT take any lock.
+ ******************************************************************************************
+ * @ inode_xp  : extended pointer on inode.
+ * @ return 0 if success / return -1 if device access failure.
+ *****************************************************************************************/
+error_t vfs_fs_release_inode( xptr_t  inode_xp ); 
+
+/******************************************************************************************
+ * This function makes the I/O operation to move one page identified by the <page_xp>
+ * argument to/from the IOC device from/to the mapper, as defined by <to_mapper>.
+ * Depending on the file system type, it calls the proper, FS specific function.
  * It is used in case of MISS on the mapper, or when a dirty page in the mapper must
  * be updated in the File System.
- * Depending on the file system type, it calls the proper, FS specific function.
- * It must be executed by a thread running in the cluster containing the mapper.
  * The mapper pointer is obtained from the page descriptor.
- * It takes the mapper lock before launching the IO operation.
- ******************************************************************************************
- * @ page      : local pointer on the page descriptor.
+ * It can be executed by any thread running in any cluster.
+ * This function does NOT take any lock.
+ ******************************************************************************************
+ * @ page_xp   : extended pointer on the page descriptor.
  * @ to_mapper : transfer direction.
- * @ returns 0 if success / return EINVAL if it cannot access the external device.
- *****************************************************************************************/
-error_t vfs_mapper_move_page( struct page_s * page,
-                              bool_t          to_mapper );
-
-/******************************************************************************************
- * This function makes the I/O operations required to move, from device to mapper,
- * all pages covering a given inode, identified by the <inode> argument. The target
- * inode can be a directory or a file, but this function is mainly used to load (prefetch) 
- * a complete directory to the mapper.
- * Depending on the file system type, it calls the proper, FS specific function.
- * It must be executed by a thread running in the cluster containing the mapper.
- * The mapper pointer is obtained from the inode descriptor.
- * It takes the mapper lock before launching the IO operation.
- ******************************************************************************************
- * @ inode  : local pointer on inode.
- * @ return 0 if success / return EIO if device access failure.
- *****************************************************************************************/
-error_t vfs_mapper_load_all( vfs_inode_t * inode );
+ * @ returns 0 if success / return -1 if device access failure.
+ *****************************************************************************************/
+error_t vfs_fs_move_page( xptr_t  page_xp,
+                          bool_t  to_mapper );