Changeset 626 for trunk/kernel

trunk/kernel/Makefile

-                      r612
+                      r626
               build/syscalls/sys_is_fg.o
+SYS_OBJS_5  = build/syscalls/sys_exit.o
+SYS_OBJS_5  = build/syscalls/sys_exit.o            \
+              build/syscalls/sys_sync.o            \
+              build/syscalls/sys_fsync.o
 VFS_OBJS    = build/fs/vfs.o              \
 …
 # List of directories to be searched for included files
 # when compiling for kernel.elf generation
 KERNEL_INCLUDE = -I.                  \
                  -Ikern             \
                  -Idevices          \
                  -Isyscalls         \
                  -I$(SHARED_INCLUDE)  \
+KERNEL_INCLUDE = -I.                   \
+                 -Ikern                \
+                 -Idevices             \
+                 -Isyscalls            \
+                 -I$(SHARED_INCLUDE)   \
                  -I$(HAL_ARCH)/drivers \
                  -Isyscalls            \

trunk/kernel/devices/dev_ioc.c

-                      r619
+                      r626
  * dev_ioc.c - IOC (Block Device Controler) generic device API implementation.
+ *
  * Author  Alain Greiner    (2016,2017,2018)
+ * Author  Alain Greiner    (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
 extern chdev_directory_t  chdev_dir;     // allocated in kernel_init.c
+////////////////////////////////////////
+char * dev_ioc_cmd_str( cmd_type_t cmd )
+{
+    if     ( cmd == IOC_READ       )  return "READ";
+    else if( cmd == IOC_WRITE      )  return "WRITE";
+    else if( cmd == IOC_SYNC_READ  )  return "SYNC_READ";
+    else if( cmd == IOC_SYNC_WRITE )  return "SYNC_WRITE";
+    else                              return "undefined";
+}
 //////////////////////////////////
 …
 ////////////////////////////////////i/////////////////////////////////////////////
 error_t dev_ioc_sync_access( uint32_t   cmd_type,
                              uint8_t  * buffer,
+                             xptr_t     buffer_xp,
                              uint32_t   lba,
                              uint32_t   count )
 …
     if( chdev_dir.iob )
+    {
         if (cmd_type == IOC_SYNC_READ) dev_mmc_inval( XPTR(local_cxy,buffer) , count<<9 );
         else                           dev_mmc_sync ( XPTR(local_cxy,buffer) , count<<9 );
+        if (cmd_type == IOC_SYNC_READ) dev_mmc_inval( buffer_xp , count<<9 );
+        else                           dev_mmc_sync ( buffer_xp , count<<9 );
+    }
 …
     this->ioc_cmd.dev_xp    = ioc_xp;
     this->ioc_cmd.type      = cmd_type;
     this->ioc_cmd.buf_xp    = XPTR( local_cxy , buffer );
+    this->ioc_cmd.buf_xp    = buffer_xp;
     this->ioc_cmd.lba       = lba;
     this->ioc_cmd.count     = count;
 …
     return this->ioc_cmd.error;
 }  // end ioc_sync_access()
 /////////////////////////////////////////////
 error_t dev_ioc_sync_read( uint8_t  * buffer,
+}  // end dev_ioc_sync_access()
+////////////////////////////////////////////////
+error_t dev_ioc_sync_read( xptr_t     buffer_xp,
                            uint32_t   lba,
                            uint32_t   count )
 …
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_DEV_IOC_RX < cycle )
+printk("\n[%s] thread[%x,%x] : lba  %x / buffer %x / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, lba, buffer, cycle );
+#endif
+    return dev_ioc_sync_access( IOC_SYNC_READ , buffer , lba , count );
+printk("\n[%s] thread[%x,%x] : lba  %x / buffer(%x,%x) / count %d / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid,
+lba, GET_CXY(buffer_xp), GET_PTR(buffer_xp), count, cycle );
+#endif
+    return dev_ioc_sync_access( IOC_SYNC_READ , buffer_xp , lba , count );
+}
 //////////////////////////////////////////////
 error_t dev_ioc_sync_write( uint8_t  * buffer,
+/////////////////////////////////////////////////
+error_t dev_ioc_sync_write( xptr_t     buffer_xp,
                             uint32_t   lba,
                             uint32_t   count )
+{
+#if DEBUG_DEV_IOC_RX
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_IOC_RX < cycle )
+printk("\n[%s] thread[%x,%x] enters / lba  %x / buffer %x / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, lba, buffer, cycle );
+#endif
+    return dev_ioc_sync_access( IOC_SYNC_WRITE , buffer , lba , count );
+#if DEBUG_DEV_IOC_TX
+thread_t * this  = CURRENT_THREAD;
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEV_IOC_TX < cycle )
+printk("\n[%s] thread[%x,%x] : lba  %x / buffer(%x,%x) / count %d / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid,
+lba, GET_CXY(buffer_xp), GET_PTR(buffer_xp), count, cycle );
+#endif
+    return dev_ioc_sync_access( IOC_SYNC_WRITE , buffer_xp , lba , count );
+}

trunk/kernel/devices/dev_ioc.h

-                      r614
+                      r626
  * dev_ioc.h - IOC (Block Device Controler) generic device API definition.
+ *
  * Author  Alain Greiner    (2016,2017,2018)
+ * Author  Alain Greiner    (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
  * - SYNC_WRITE : move blocks from memory to device, with a busy waiting policy.
  * A READ or WRITE operation requires dynamic ressource allocation. The calling thread
+ * The READ or WRITE operations require dynamic ressource allocation. The calling thread
  * is descheduled, and the work is done by the server thread associated to IOC device.
  * The general scenario is detailed below.
 …
+ *
  * The SYNC_READ and SYNC_WRITE operations are used by the kernel in the initialisation
+ * phase. These operations do not not use the IOC device waiting queue, the server thread,
+ * and the IOC IRQ, but implement a busy-waiting policy for the calling thread.
+ * phase, to update the FAT (both the FAT mapper and the FAT on IOC device), or to update
+ * a directory on IOC device when a new file is created.
+ * - These synchronous operations do not not use the IOC device waiting queue,
+ *   the server thread, and the IOC IRQ, but implement a busy-waiting policy
+ *   for the calling thread.
+ * - As the work
  *****************************************************************************************/
 …
+}
 ioc_command_t;
+/******************************************************************************************
+ * This function returns a printable string for a IOC command type.
+ ******************************************************************************************
+ * @ cmd  : command type.
+ * @ return pointer on string.
+ *****************************************************************************************/
+char * dev_ioc_cmd_str( cmd_type_t cmd );
 /******************************************************************************************
 …
  * registered in the device pending request queue, and the calling thread is descheduled,
  * waiting on transfer completion. It will be resumed by the IRQ signaling completion.
  * It must be called in the client cluster.
+ * It must be called by a local thread.
  ******************************************************************************************
  * @ buffer    : local pointer on target buffer in memory (must be block aligned).
  * @ lba       : first block index on device.
  * @ count     : number of blocks to transfer.
  * @ returns 0 if success / returns EINVAL if error.
+ * @ returns 0 if success / returns -1 if error.
  *****************************************************************************************/
 error_t dev_ioc_read( uint8_t      * buffer,
 …
  * registered in the device pending request queue, and the calling thread is descheduled,
  * waiting on transfer completion. It will be resumed by the IRQ signaling completion.
  * It must be called in the client cluster.
+ * It must be called by a local thread.
  ******************************************************************************************
  * @ buffer    : local pointer on source buffer in memory (must be block aligned).
  * @ lba       : first block index on device.
  * @ count     : number of blocks to transfer.
  * @ returns 0 if success / returns EINVAL if error.
+ * @ returns 0 if success / returns -1 if error.
  *****************************************************************************************/
 error_t dev_ioc_write( uint8_t      * buffer,
 …
 /******************************************************************************************
  * This blocking function moves one or several contiguous blocks of data
  * from the block device to a local memory buffer.
+ * from the block device to a - possibly remote - memory buffer.
  * It does  not uses the IOC device waiting queue and server thread, and does not use
  * the IOC IRQ, but call directly the relevant IOC driver, implementing a busy-waiting
  * policy for the calling thread.
  * It must be called in the client cluster.
  ******************************************************************************************
  * @ buffer    : local pointer on target buffer in memory (must be block aligned).
  * @ lba       : first block index on device.
  * @ count     : number of blocks to transfer.
  * @ returns 0 if success / returns EINVAL if error.
  *****************************************************************************************/
 error_t dev_ioc_sync_read( uint8_t      * buffer,
+ * It can be called by a thread running in any cluster.
+ ******************************************************************************************
+ * @ buffer_xp : extended pointer on target buffer in memory (must be block aligned).
+ * @ lba       : first block index on device.
+ * @ count     : number of blocks to transfer.
+ * @ returns 0 if success / returns -1 if error.
+ *****************************************************************************************/
+error_t dev_ioc_sync_read( xptr_t         buffer_xp,
                            uint32_t       lba,
                            uint32_t       count );
 …
 /******************************************************************************************
  * This blocking function moves one or several contiguous blocks of data
  * from a local memory buffer to the block device.
+ * from a - possibly remote - memory buffer to the block device.
  * It does  not uses the IOC device waiting queue and server thread, and does not use
  * the IOC IRQ, but call directly the relevant IOC driver, implementing a busy-waiting
  * policy for the calling thread.
  * It must be called in the client cluster.
  ******************************************************************************************
  * @ buffer    : local pointer on source buffer in memory (must be block aligned).
  * @ lba       : first block index on device.
  * @ count     : number of blocks to transfer.
  * @ returns 0 if success / returns EINVAL if error.
  *****************************************************************************************/
 error_t dev_ioc_sync_write( uint8_t      * buffer,
+ * It can be called by a thread running in any cluster.
+ ******************************************************************************************
+ * @ buffer_xp : extended pointer on source buffer in memory (must be block aligned).
+ * @ lba       : first block index on device.
+ * @ count     : number of blocks to transfer.
+ * @ returns 0 if success / returns -1 if error.
+ *****************************************************************************************/
+error_t dev_ioc_sync_write( xptr_t         buffer_xp,
                             uint32_t       lba,
                             uint32_t       count );

trunk/kernel/devices/dev_mmc.c

-                      r605
+                      r626
     // get buffer cluster and local pointer
     cxy_t  buf_cxy = GET_CXY( buf_xp );
     void * buf_ptr = GET_PTR( buf_xp );
+    cxy_t     buf_cxy = GET_CXY( buf_xp );
+    uint8_t * buf_ptr = GET_PTR( buf_xp );
+    assert( (((intptr_t)buf_ptr & (CONFIG_CACHE_LINE_SIZE -1)) == 0) ,
+             "buffer not aligned on cache line" );
+    // force buffer align
+    uint32_t  delta = (uint32_t)buf_ptr & (CONFIG_CACHE_LINE_SIZE - 1);
+    uint8_t * base  = buf_ptr - delta;
+    uint32_t  size  = buf_size + delta;
     // store command arguments in thread descriptor
     this->mmc_cmd.dev_xp    = chdev_dir.mmc[buf_cxy];
     this->mmc_cmd.type      = MMC_CC_INVAL;
     this->mmc_cmd.buf_ptr   = buf_ptr;
     this->mmc_cmd.buf_size  = buf_size;
+    this->mmc_cmd.buf_ptr   = base;
+    this->mmc_cmd.buf_size  = size;
     // call MMC driver
 …
     void * buf_ptr = GET_PTR( buf_xp );
+    assert( (((intptr_t)buf_ptr & (CONFIG_CACHE_LINE_SIZE -1)) == 0) ,
+             "buffer not aligned on cache line" );
+    // force buffer align
+    uint32_t  delta = (uint32_t)buf_ptr & (CONFIG_CACHE_LINE_SIZE - 1);
+    uint8_t * base  = buf_ptr - delta;
+    uint32_t  size  = buf_size + delta;
     // store command arguments in thread descriptor
     this->mmc_cmd.dev_xp    = chdev_dir.mmc[buf_cxy];
     this->mmc_cmd.type      = MMC_CC_SYNC;
     this->mmc_cmd.buf_ptr   = buf_ptr;
     this->mmc_cmd.buf_size  = buf_size;
+    this->mmc_cmd.buf_ptr   = base;
+    this->mmc_cmd.buf_size  = size;
     // call MMC driver

trunk/kernel/devices/dev_txt.c

r619	r626
2	2	* dev_txt.c - TXT (Text Terminal) generic device API implementation.
3	3	*
4		* Author Alain Greiner (2016,2017,2018)
	4	* Author Alain Greiner (2016,2017,2018,2019)
5	5	*
6	6	* Copyright (c) UPMC Sorbonne Universites

trunk/kernel/devices/dev_txt.h

-                      r565
+                      r626
  * dev_txt.h - TXT (Text Terminal) generic device API definition.
+ *
  * Author  Alain Greiner    (2016)
+ * Author  Alain Greiner    (2016,2017,2018,2019))
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
     const char * buffer;    /*! local pointer on characters array                        */
     uint32_t     count;     /*! number of characters in buffer                           */
     uint32_t    channel;   /*! channel, aka which tty to write to                        */
+    uint32_t     channel;   /*! channel, aka which tty to write to                       */
+}
 txt_sync_args_t;
 /******************************************************************************************
  * This function returns a printable string for the comman type.
+ * This function returns a printable string for the command type.
  ******************************************************************************************
  * @ type     : command type (TXT_READ / TXT_WRITE / TXT_SYNC_WRITE)
 …
  * interfering with another possible TXT access to another terminal.
  * As it is used for debug, the command arguments <buffer> and <count> are registerd
  * in a specific "dbg_cmd" field of the calling thread.
+ * in a specific "txt_syc_args_t" structure passed to the driver "aux" function.
  ****************************************************************************************
  * @ buffer    : local pointer on source buffer containing the string.

trunk/kernel/fs/fatfs.c

-                      r625
+                      r626
 #include <fatfs.h>
+#define LITTLE_ENDIAN  1
 //////////////////////////////////////////////////////////////////////////////////////////
 …
 //////////////////////////////////////////////////////////////////////////////////////////
 // This function return an integer record value (one, two, or four bytes)
 // from 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.
+// This function return an integer record value (one, two, or four bytes) from a local
+// array of bytes, taking into account the global LITTLE_ENDIAN parameter:
+// if LITTLE_ENDIAN is true, the most significant byte has the highest address.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ offset        : first byte in array.
+// @ nbytes        : record length in bytes (1/2/4).
+// @ buffer        : local pointer on byte array.
 // @ return the integer value in a 32 bits word.
 //////////////////////////////////////////////////////////////////////////////////////////
 static uint32_t fatfs_get_record( uint32_t    offset,
+                                  uint32_t    size,
+                                  uint8_t   * buffer,
+                                  uint32_t    little_endian )
+{
+    uint32_t n;
+    uint32_t res  = 0;
+    if ( little_endian )
+    {
+        for( n = size ; n > 0 ; n-- ) res = (res<<8) | buffer[offset+n-1];
+    }
+    else // big_endian
+    {
+        for( n = 0 ; n < size ; n++ ) res = (res<<8) | buffer[offset+n];
+                                  uint32_t    nbytes,
+                                  uint8_t   * buffer )
+{
+    uint32_t i;
+    uint32_t res = 0;
+    if ( LITTLE_ENDIAN )
+    {
+        for( i = nbytes ; i > 0 ; i-- ) res = (res<<8) | buffer[offset+i-1];
+    }
+    else
+    {
+        for( i = 0 ; i < nbytes ; i++ ) res = (res<<8) | buffer[offset+i];
+    }
     return res;
 …
 //////////////////////////////////////////////////////////////////////////////////////////
 // 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.
+// This function return an integer record value (one, two, or four bytes) from a remote
+// array of bytes, taking into account the global LITTLE_ENDIAN parameter:
+// if LITTLE_ENDIAN is true, the most significant byte has the highest address.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ offset        : first byte in array.
+// @ nbytes        : record length in bytes (1/2/4).
+// @ buffer_xp     : extended pointer on byte array.
 // @ return the integer value in a 32 bits word.
 //////////////////////////////////////////////////////////////////////////////////////////
+static uint32_t fatfs_get_remote_record( uint32_t   offset,
+                                         uint32_t   nbytes,
+                                         xptr_t     buffer_xp )
+{
+    uint32_t i;
+    uint32_t res = 0;
+    if ( LITTLE_ENDIAN )
+    {
+        for( i = nbytes ; i > 0 ; i-- )
+        {
+            res = (res<<8) | hal_remote_lb( buffer_xp+offset+i-1 );
+        }
+    }
+    else
+    {
+        for( i = 0 ; i < nbytes ; i++ )
+        {
+            res = (res<<8) | hal_remote_lb( buffer_xp+offset+i );
+        }
+    }
+    return res;
+}  // end fatfs_get_remote_record()
+//////////////////////////////////////////////////////////////////////////////////////////
+// This function writes one, two, or four bytes from a 32 bits integer to a local
+// array of bytes, taking into account the global LITTLE_ENDIAN parameter:
+// if LITTLE_ENDIAN is true, the most significant byte has the highest address.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ offset        : first byte in array.
+// @ nbytes        : record length in bytes (1/2/4).
+// @ buffer        : local pointer on byte array.
+// @ value         : 32 bits integer value.
+//////////////////////////////////////////////////////////////////////////////////////////
 static void fatfs_set_record( uint32_t    offset,
                               uint32_t    size,
+                              uint32_t    nbytes,
                               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));
+    uint32_t i;
+    if ( LITTLE_ENDIAN )
+    {
+        for( i = nbytes ; i > 0 ; i-- ) buffer[offset+i-1] = (uint8_t)(value>>((i-1)<<3));
+    }
+    else
+    {
+        for( i = 0 ; i < nbytes ; i++ ) buffer[offset+i] = (uint8_t)(value>>((nbytes-1-i)<<3));
+    }
+}  // end fatfs_set_record()
+//////////////////////////////////////////////////////////////////////////////////////////
+// This function writes one, two, or four bytes from a 32 bits integer to a remote
+// array of bytes, taking into account the global LITTLE_ENDIAN parameter:
+// if LITTLE_ENDIAN is true, the most significant byte has the highest address.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ offset        : first byte in array.
+// @ nbytes        : record length in bytes (1/2/4).
+// @ buffer_xp     : extended pointer on byte array.
+// @ value         : 32 bits integer value.
+//////////////////////////////////////////////////////////////////////////////////////////
+static void fatfs_set_remote_record( uint32_t    offset,
+                                     uint32_t    nbytes,
+                                     xptr_t      buffer_xp,
+                                     uint32_t    value )
+{
+    uint32_t i;
+    if ( LITTLE_ENDIAN )
+    {
+        for( i = nbytes ; i > 0 ; i-- )
+        {
+            hal_remote_sb( (buffer_xp+offset+i-1) , (uint8_t)(value>>((i-1)<<3)) );
+        }
+    }
+    else
+    {
+        for( i = 0 ; i < nbytes ; i++ )
+        {
+            hal_remote_sb( (buffer_xp+offset+i) , (uint8_t)(value>>((nbytes-1-i)<<3)) );
+        }
+    }
 …
 //////////////////////////////////////////////////////////////////////////////////////////
+// This static function is called by both the fatfs_free_clusters_increment(),
+// and the fatfs_free_cluster_decrement() functions defined below.
+// It synchronously updates the  "free_clusters" and "free_cluster_hint" variables
+// in FS_INFO sector on the IOC device, each times these variables are modified.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ fatfs_ctx_xp      : extended pointer on fatfs context in FAT cluster.
+// @ free_clusters     : new free_clusters value.
+// @ free_cluster_hint : new free_cluster_hint value.
+// @ return 0 if success, return -1 if the FS_INFO sector cannot be updated.
+//////////////////////////////////////////////////////////////////////////////////////////
+static error_t fatfs_free_clusters_update_ioc( xptr_t    fatfs_ctx_xp,
+                                               uint32_t  free_clusters,
+                                               uint32_t  free_cluster_hint )
+{
+    cxy_t         fat_cxy;             // FAT cluster identifier
+    fatfs_ctx_t * fatfs_ctx_ptr;       // local pointer on fatfs context in FAT cluster
+    uint8_t     * fs_info_buffer_ptr;  // local pointer on FS_INFO buffer in FAT cluster
+    xptr_t        fs_info_buffer_xp;   // extended pointer on FS_INFO buffer in FAT cluster
+    uint32_t      fs_info_lba;         // FS_INFO sector lba on IOC device
+    // get cluster and local pointer on FAT cluster context
+    fat_cxy       = GET_CXY( fatfs_ctx_xp );
+    fatfs_ctx_ptr = GET_PTR( fatfs_ctx_xp );
+    // get pointers on FS_INFO buffer in FAT cluster
+    fs_info_buffer_ptr = hal_remote_lpt( XPTR( fat_cxy , &fatfs_ctx_ptr->fs_info_buffer ) );
+    fs_info_buffer_xp  = XPTR( fat_cxy , fs_info_buffer_ptr );
+    // get lba of FS_INFO sector on IOC device from fatfs context
+    fs_info_lba = hal_remote_l32( XPTR( fat_cxy , &fatfs_ctx_ptr->fs_info_lba ) );
+    // update the FS_INFO buffer in FAT cluster
+    fatfs_set_remote_record( FS_FREE_CLUSTERS     , fs_info_buffer_xp , free_clusters );
+    fatfs_set_remote_record( FS_FREE_CLUSTER_HINT , fs_info_buffer_xp , free_cluster_hint );
+    // update the FS_INFO sector on IOC device
+    return dev_ioc_sync_write( fs_info_buffer_xp , fs_info_lba , 1 );
+}  // fatfs_free_clusters_update_ioc()
+//////////////////////////////////////////////////////////////////////////////////////////
 // This static function decrements the  "free_clusters" variable, and updates the
 // "free_cluster_hint" variable in the FATFS context, identified by the <fat_ctx_cxy>
 // and <fat_ctx_ptr> arguments (cluster containing the FAT mapper).
+// "free_cluster_hint" variable in the FATFS context in FAT cluster, identified
+// by the <fat_ctx_xp> argument, when a new <cluster> has been allocated from FAT.
 // It scan all slots in the FAT mapper seen as an array of 32 bits words, looking for the
 // first free slot larger than the <cluster> argument, to update "free_cluster_hint".
+// It calls the fatfs_free_clusters_update_ioc() function to synchronously update the
+// FS_INFO sector on the IOC device. It can be called by a thead running in any cluster.
 //
 // WARNING : The free_lock protecting exclusive access to these variables
 //           must be taken by the calling function.
 //////////////////////////////////////////////////////////////////////////////////////////
+// @ fat_ctx_cxy  : FAT mapper cluster identifier.
+// @ fat_ctx_ptr  : local pointer on FATFS context.
+// @ cluster      : recently allocated cluster index in FAT.
+//////////////////////////////////////////////////////////////////////////////////////////
+static error_t fatfs_free_clusters_decrement( cxy_t         fat_ctx_cxy,
+                                              fatfs_ctx_t * fat_ctx_ptr,
+                                              uint32_t      cluster )
+{
+// @ fatfs_ctx_xp  : extended pointer on FATFS context in FAT cluster.
+// @ cluster       : recently allocated cluster index in FAT.
+// @ return 0 if success, return -1 if the FS_INFO sector cannot be updated.
+//////////////////////////////////////////////////////////////////////////////////////////
+static error_t fatfs_free_clusters_decrement( xptr_t    fatfs_ctx_xp,
+                                              uint32_t  cluster )
+{
+    error_t       error;
+    cxy_t         fat_cxy;      // FAT cluster identifier
+    fatfs_ctx_t * fat_ctx_ptr;  // local pointer on fatfs context in FAT cluster
     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      hint;         // "free_cluster_hint" 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   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
 if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() )
+if( DEBUG_FATFS_FREE_CLUSTERS < cycle )
 printk("\n[%s] thread[%x,%x] enter for allocated cluster %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, cluster , cycle );
 #endif
+    // build extended pointers on free_clusters, and free_cluster_hint
+    hint_xp = XPTR( fat_ctx_cxy , &fat_ctx_ptr->free_cluster_hint );
+    numb_xp = XPTR( fat_ctx_cxy , &fat_ctx_ptr->free_clusters );
+    // update "free_clusters"
+    numb = hal_remote_l32( numb_xp );
+    hal_remote_s32( numb_xp , numb - 1 );
+    // get FAT cluster an local pointer on fatfs context in FAT cluster
+    fat_cxy      = GET_CXY( fatfs_ctx_xp );
+    fat_ctx_ptr  = GET_PTR( fatfs_ctx_xp );
+    // build extended pointers on free_clusters, and free_cluster_hint in fatfs context
+    hint_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_cluster_hint );
+    numb_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_clusters );
+    // update "free_clusters" value
+    numb = hal_remote_l32( numb_xp ) - 1;
+    hal_remote_s32( numb_xp , numb );
     // get extended pointer on FAT mapper
     mapper_xp = hal_remote_l64( XPTR( fat_ctx_cxy , &fat_ctx_ptr->fat_mapper_xp ) );
+    mapper_xp = hal_remote_l64( XPTR( fat_cxy , &fat_ctx_ptr->fat_mapper_xp ) );
     // initialise variables to scan the FAT mapper
 …
     page_id  = (cluster + 1) >> 10;
     slot_id  = (cluster + 1) & 0x3FF;
     page_max = hal_remote_l32( XPTR( fat_ctx_cxy, &fat_ctx_ptr->fat_sectors_count ) ) >> 3;
+    page_max = hal_remote_l32( XPTR( fat_cxy, &fat_ctx_ptr->fat_sectors_count ) ) >> 3;
     // scan FAT mapper / loop on pages
 …
             if ( hal_remote_l32( slot_xp ) == FREE_CLUSTER )
+            {
+                // update "free_cluster_hint"
+                hal_remote_s32( hint_xp , (page_id << 10) + slot_id - 1 );
+                // update "free_cluster_hint" value
+                hint = (page_id << 10) + slot_id - 1;
+                hal_remote_s32( hint_xp , hint );
+                // update FS_INFO sector on IOC device
+                error = fatfs_free_clusters_update_ioc( fatfs_ctx_xp , numb , hint );
+                if( error )
+                {
+                    printk("\n[ERROR] in %s : cannot update FS_INFO on IOC\n", __FUNCTION__ );
+                    return -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 );
+printk("\n[%s] thread[%x,%x] updated 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
                 return 0;
 …
         }  // end loop on slots
         // update (page_id,slot_id) variables
+        // update page_id & slot_id variables
         page_id++;
         slot_id = 0;
 …
 //////////////////////////////////////////////////////////////////////////////////////////
 // This static function increments the "free_clusters" variable, and updates the
 // "free_cluster_hint" variables in the FATFS context, identified by the <fat_ctx_cxy>
 // and <fat_ctx_ptr> argument (cluster containing the FAT mapper).
+// "free_cluster_hint" variables in the FATFS context in FAT cluster, identified
+// by the <fat_ctx_xp> argument, when a cluster is released to FAT.
 // If the released cluster index is smaller than the current (hint) value,
 // it set "free_cluster_hint" <= cluster.
+// It calls the fatfs_free_clusters_update_ioc() function to synchronously update the
+// FS_INFO sector on the IOC device. It can be called by a thead running in any cluster.
 //
 // WARNING : The free_lock protecting exclusive access to these variables
 //           must be taken by the calling function.
 //////////////////////////////////////////////////////////////////////////////////////////
+// @ fat_ctx_cxy  : FAT mapper cluster identifier.
+// @ fat_ctx_ptr  : local pointer on FATFS context.
+// @ cluster     : recently released cluster index in FAT.
+//////////////////////////////////////////////////////////////////////////////////////////
+static void fatfs_free_clusters_increment( cxy_t         fat_ctx_cxy,
+                                           fatfs_ctx_t * fat_ctx_ptr,
+                                           uint32_t      cluster )
+{
+// @ fatfs_ctx_xp  : extended pointer on FATFS context in FAT cluster.
+// @ cluster       : recently released cluster index in FAT.
+// @ return 0 if success, return -1 if the FS_INFO sector cannot be updated.
+//////////////////////////////////////////////////////////////////////////////////////////
+static error_t fatfs_free_clusters_increment( xptr_t   fatfs_ctx_xp,
+                                              uint32_t cluster )
+{
+    error_t       error;
+    cxy_t         fat_cxy;      // FAT cluster identifier
+    fatfs_ctx_t * fat_ctx_ptr;  // local pointer on fatfs context in FAT cluster
     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
+#if DEBUG_FATFS_FREE_CLUSTERS
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_FATFS_FREE_CLUSTERS < cycle )
+printk("\n[%s] thread[%x,%x] enter for released cluster %x / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cluster , cycle );
+#endif
+    // get FAT cluster an local pointer on fatfs context in FAT cluster
+    fat_cxy      = GET_CXY( fatfs_ctx_xp );
+    fat_ctx_ptr  = GET_PTR( fatfs_ctx_xp );
     // build extended pointers on free_clusters, and free_cluster_hint
     hint_xp = XPTR( fat_ctx_cxy , &fat_ctx_ptr->free_cluster_hint );
     numb_xp = XPTR( fat_ctx_cxy , &fat_ctx_ptr->free_clusters );
+    hint_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_cluster_hint );
+    numb_xp = XPTR( fat_cxy , &fat_ctx_ptr->free_clusters );
     // get current value of free_cluster_hint and free_clusters
 …
     numb = hal_remote_l32( numb_xp );
+    // update free_cluster_hint if required
+    if ( (cluster - 1) < hint ) hal_remote_s32( hint_xp , (cluster - 1) );
+    // update "numb" and "hint" variables as required
+    numb++;
+    if ( (cluster - 1) < hint ) hint = cluster - 1;
     // update free_clusters
+    hal_remote_s32( numb_xp , numb + 1 );
+    hal_remote_s32( numb_xp , numb );
+    hal_remote_s32( hint_xp , hint );
+    // update FS_INFO sector on IOC device
+    error = fatfs_free_clusters_update_ioc( fatfs_ctx_xp , numb , hint );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot update FS_INFO on IOC\n", __FUNCTION__ );
+        return -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",
+printk("\n[%s] thread[%x,%x] updated 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
+    return 0;
 }  // end fatfs_free_clusters_increment()
 …
                                FREE_CLUSTER ) ) return -1;
+    // Update free_cluster_hint and free_clusters in FAT context
+    fatfs_free_clusters_increment( mapper_cxy,
+                                   fatfs_ctx,
+                                   cluster );
+    return 0;
+    // Update free_cluster info in FATFS context and in FS_INFO sector
+    return fatfs_free_clusters_increment( XPTR( mapper_cxy , fatfs_ctx ) , cluster );
 }  // end fatfs_recursive_release()
 …
 //////////////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////
+void fatfs_ctx_display( fatfs_ctx_t * ctx )
+{
+    printk("\n*** FAT context ***\n"
+///////////////////////////////////
+void fatfs_display_ctx( cxy_t cxy )
+{
+    // get pointer on local FATFS context
+    vfs_ctx_t   * vfs_ctx = &fs_context[FS_TYPE_FATFS];
+        fatfs_ctx_t * ctx     = hal_remote_lpt( XPTR( cxy , &vfs_ctx->extend ) );
+    uint32_t fat_sectors       = hal_remote_l32( XPTR( cxy , &ctx->fat_sectors_count ) );
+    uint32_t sector_size       = hal_remote_l32( XPTR( cxy , &ctx->bytes_per_sector ) );
+    uint32_t sec_per_clus      = hal_remote_l32( XPTR( cxy , &ctx->sectors_per_cluster ) );
+    uint32_t fat_lba           = hal_remote_l32( XPTR( cxy , &ctx->fat_begin_lba ) );
+    uint32_t data_lba          = hal_remote_l32( XPTR( cxy , &ctx->cluster_begin_lba ) );
+    uint32_t fsinfo_lba        = hal_remote_l32( XPTR( cxy , &ctx->fs_info_lba ) );
+    uint32_t root_dir_clus     = hal_remote_l32( XPTR( cxy , &ctx->root_dir_cluster ) );
+    uint32_t free_clusters     = hal_remote_l32( XPTR( cxy , &ctx->free_clusters ) );
+    uint32_t free_cluster_hint = hal_remote_l32( XPTR( cxy , &ctx->free_cluster_hint ) );
+    xptr_t   mapper_xp         = hal_remote_l64( XPTR( cxy , &ctx->fat_mapper_xp ) );
+    void   * fs_info_buffer    = hal_remote_lpt( XPTR( cxy , &ctx->fs_info_buffer ) );
+    printk("\n*** FAT context in cluster %x\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",
+           ctx->fat_sectors_count,
+           ctx->bytes_per_sector,
+           ctx->sectors_per_cluster * ctx->bytes_per_sector,
+           ctx->fat_begin_lba,
+           ctx->cluster_begin_lba,
+           ctx->root_dir_cluster,
+           ctx->free_clusters,
+           ctx->free_cluster_hint,
+           ctx->fat_mapper_xp );
+}  // end ctx_display()
+           "- fat_lba           = %x\n"
+           "- data_lba          = %x\n"
+           "- fsinfo_lba        = %x\n"
+           "- root_dir_cluster  = %x\n"
+           "- free_clusters     = %x\n"
+           "- free_cluster_hint = %x\n"
+           "- fat_mapper_ptr    = %x\n"
+           "- fs_info_buffer    = %x\n",
+           cxy,
+           fat_sectors,
+           sector_size,
+           sector_size * sec_per_clus,
+           fat_lba,
+           data_lba,
+           fsinfo_lba,
+           root_dir_clus,
+           free_clusters,
+           free_cluster_hint,
+           GET_PTR( mapper_xp ),
+           fs_info_buffer );
+}  // end fatfs_ctx_display()
 //////////////////////////////////////////
 …
     uint32_t maxline;
     // copute numner of lines to display
+    // compute number 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;
+    vfs_ctx_t   * vfs_ctx       = &fs_context[FS_TYPE_FATFS];
+    fatfs_ctx_t * loc_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 fat_mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
+    // get FAT cluster identifier
+    cxy_t  fat_cxy = GET_CXY( fat_mapper_xp );
+    // get pointer on FATFS context in FAT cluster
+    fatfs_ctx_t * fat_fatfs_ctx = hal_remote_lpt( XPTR( fat_cxy , &vfs_ctx->extend ) );
+    // get current value of hint and free_clusters
+    uint32_t hint = hal_remote_l32( XPTR( fat_cxy , &fat_fatfs_ctx->free_cluster_hint ) );
+    uint32_t free = hal_remote_l32( XPTR( fat_cxy , &fat_fatfs_ctx->free_clusters ) );
+    // get extended pointer on requested page in FAT mapper
     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 );
+    void     * base     = GET_PTR( base_xp );
+    printk("\n***** FAT mapper / cxy %x / page_id %d / base %x / free_clusters %x / hint %x\n",
+    fat_cxy, page_id, base, free, hint );
     for( line = 0 ; line < maxline ; line++ )
+    {
 …
     kmem_req_t    req;
     uint8_t     * buffer;
+    xptr_t        buffer_xp;
 #if DEBUG_FATFS_CTX_INIT
 …
 assert( (fatfs_ctx != NULL) , "pointer on FATFS context is NULL" );
 // check only cluster 0 does FATFS init
+// check only cluster 0 does FATFS initialization
 assert( (local_cxy == 0) , "only cluster 0 can initialize FATFS");
+    // allocate a 512 bytes buffer to store the boot record
+    // allocate a permanent 512 bytes buffer to store
+    // - temporarily the BOOT sector
+    // - permanently the FS_INFO sector
         req.type    = KMEM_512_BYTES;
     req.flags   = AF_KERNEL | AF_ZERO;
         buffer      = (uint8_t *)kmem_alloc( &req );
+    buffer_xp   = XPTR( local_cxy , buffer );
     if( buffer == NULL )
 …
     // load the BOOT record from device
     error = dev_ioc_sync_read( buffer , 0 , 1 );
+    error = dev_ioc_sync_read( buffer_xp , 0 , 1 );
     if ( error )
 …
     // get sector size from boot record
     uint32_t sector_size = fatfs_get_record( BPB_BYTSPERSEC , buffer , 1 );
+    uint32_t sector_size = fatfs_get_record( BPB_BYTSPERSEC , buffer );
     if ( sector_size != 512 )
+    {
 …
     // get cluster size from boot record
     uint32_t nb_sectors = fatfs_get_record( BPB_SECPERCLUS , buffer , 1 );
+    uint32_t nb_sectors = fatfs_get_record( BPB_SECPERCLUS , buffer );
     if ( nb_sectors != 8 )
+    {
 …
     // get number of FAT copies from boot record
     uint32_t nb_fats = fatfs_get_record( BPB_NUMFATS , buffer , 1 );
+    uint32_t nb_fats = fatfs_get_record( BPB_NUMFATS , buffer );
     if ( nb_fats != 1 )
+    {
 …
     // get number of sectors in FAT from boot record
     uint32_t fat_sectors = fatfs_get_record( BPB_FAT32_FATSZ32 , buffer , 1 );
+    uint32_t fat_sectors = fatfs_get_record( BPB_FAT32_FATSZ32 , buffer );
     if ( (fat_sectors & 0xF) != 0 )
+    {
 …
     // get root cluster from boot record
     uint32_t root_cluster = fatfs_get_record( BPB_FAT32_ROOTCLUS , buffer , 1 );
+    uint32_t root_cluster = fatfs_get_record( BPB_FAT32_ROOTCLUS , buffer );
     if ( root_cluster != 2 )
+    {
 …
     // get FAT lba from boot record
     uint32_t fat_lba = fatfs_get_record( BPB_RSVDSECCNT , buffer , 1 );
+    uint32_t fat_lba = fatfs_get_record( BPB_RSVDSECCNT , buffer );
     // get FS_INFO sector lba from boot record
     uint32_t fs_info_lba = fatfs_get_record( BPB_FAT32_FSINFO , buffer , 1 );
+    uint32_t fs_info_lba = fatfs_get_record( BPB_FAT32_FSINFO , buffer );
     // load the FS_INFO record from device
     error = dev_ioc_sync_read( buffer , fs_info_lba , 1 );
+    error = dev_ioc_sync_read( buffer_xp , fs_info_lba , 1 );
     if ( error )
 …
+    }
     // get free clusters number from FS_INFO record
     uint32_t free_clusters = fatfs_get_record( FS_FREE_CLUSTERS , buffer , 1 );
+    // get free_clusters number from FS_INFO record
+    uint32_t free_clusters = fatfs_get_record( FS_FREE_CLUSTERS , buffer );
     if ( free_clusters >= fat_sectors << 7 )
+    {
 …
+    }
+    // get cluster hint from FS_INFO record
+    uint32_t free_cluster_hint = fatfs_get_record( FS_FREE_CLUSTER_HINT , buffer , 1 );
+    // get free_cluster_hint from FS_INFO record
+    uint32_t free_cluster_hint = fatfs_get_record( FS_FREE_CLUSTER_HINT , buffer );
     if ( free_cluster_hint >= fat_sectors << 7 )
+    {
 …
         hal_core_sleep();
+    }
-    // release the 512 bytes buffer
-    req.type = KMEM_512_BYTES;
-    req.ptr  = buffer;
-    kmem_free( &req );
     // allocate a mapper for the FAT itself
 …
+    }
     // WARNING : the inode field MUST be NULL for the FAT mapper
+    // the inode field is NULL for the FAT mapper
     fat_mapper->inode = NULL;
     // initialize the FATFS context
 …
     fatfs_ctx->root_dir_cluster      = 2;
     fatfs_ctx->fat_mapper_xp         = XPTR( local_cxy , fat_mapper );
+    fatfs_ctx->fs_info_lba           = fs_info_lba;
     fatfs_ctx->free_clusters         = free_clusters;
     fatfs_ctx->free_cluster_hint     = free_cluster_hint;
+    fatfs_ctx->fs_info_buffer        = buffer;
     remote_queuelock_init( XPTR( local_cxy , &fatfs_ctx->free_lock ) , LOCK_FATFS_FREE );
 …
         while ( (offset < 4096) && (found == 0) )
+        {
             if ( fatfs_get_record( LDIR_ORD, (base + offset), 0 ) == NO_MORE_ENTRY )
+            if ( fatfs_get_record( LDIR_ORD, (base + offset) ) == NO_MORE_ENTRY )
+            {
                 found = 1;
 …
 // check for LFN entry
 assert( (fatfs_get_record( DIR_ATTR, base + offset, 0 ) == ATTR_LONG_NAME_MASK ),
+assert( (fatfs_get_record( DIR_ATTR, base + offset ) == ATTR_LONG_NAME_MASK ),
 "this directory entry must be a LFN\n");
 …
         while( (offset < 4096) && (found == 0) )
+        {
             attr = fatfs_get_record( DIR_ATTR , base + offset , 0 );
             ord  = fatfs_get_record( LDIR_ORD , base + offset , 0 );
+            attr = fatfs_get_record( DIR_ATTR , base + offset );
+            ord  = fatfs_get_record( LDIR_ORD , base + offset );
             if (ord == NO_MORE_ENTRY)                 // no more entry => break
 …
 // check arguments
+assert( (parent_inode != NULL)         , "parent_inode is NULL\n" );
+assert( (name         != NULL)         , "name is NULL\n" );
+assert( (child_inode_xp != XPTR_NULL ) , "child_inode is XPTR_NULL\n" );
+assert( (parent_inode   != NULL)       , "parent_inode is NULL\n" );
+assert( (name           != NULL)       , "name is NULL\n" );
+assert( (child_inode_xp != XPTR_NULL ) , "child_inode is NULL\n" );
+    // get child inode cluster and local pointer
+    child_inode_cxy = GET_CXY( child_inode_xp );
+    child_inode_ptr = GET_PTR( child_inode_xp );
+    // build extended pointer on root of list of parent dentries
+    root_xp = XPTR( child_inode_cxy , &child_inode_ptr->parents );
+// check child inode has at least one parent
+assert( (xlist_is_empty( root_xp ) == false ), "child inode must have one parent\n");
 #if DEBUG_FATFS_GET_DENTRY
 …
     error  = fatfs_scan_directory( mapper, name , &entry , &index );
+    if( error )
+    {
+        vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , dir_name );
+        printk("\n[ERROR] in %s : cannot find <%s> in parent mapper <%s>\n",
+        __FUNCTION__, name , dir_name );
+        return -1;
+    }
+    // return non fatal error if not found
+    if( error ) return -1;
     // get relevant infos from FAT32 directory entry
+    cluster = (fatfs_get_record( DIR_FST_CLUS_HI , entry , 1 ) << 16) |
+              (fatfs_get_record( DIR_FST_CLUS_LO , entry , 1 )      ) ;
+    is_dir  = (fatfs_get_record( DIR_ATTR        , entry , 1 ) & ATTR_DIRECTORY);
+    size    =  fatfs_get_record( DIR_FILE_SIZE   , entry , 1 );
+    // get child inode cluster and local pointer
+    child_inode_cxy = GET_CXY( child_inode_xp );
+    child_inode_ptr = GET_PTR( child_inode_xp );
+    // build extended pointer on root of list of parent dentries
+    root_xp = XPTR( child_inode_cxy , &child_inode_ptr->parents );
+// check child inode has at least one parent
+assert( (xlist_is_empty( root_xp ) == false ), "child inode must have one parent\n");
+    cluster = (fatfs_get_record( DIR_FST_CLUS_HI , entry ) << 16) |
+              (fatfs_get_record( DIR_FST_CLUS_LO , entry )      ) ;
+    is_dir  = (fatfs_get_record( DIR_ATTR        , entry ) & ATTR_DIRECTORY);
+    size    =  fatfs_get_record( DIR_FILE_SIZE   , entry );
     // scan list of parent dentries to search the parent_inode
 …
     // set size in FAT32 directory entry
     fatfs_set_record( DIR_FILE_SIZE , entry , 1 , size );
+    fatfs_set_record( DIR_FILE_SIZE , entry , size );
     // get local pointer on modified page base
 …
             bool_t valid = (dentry_id >= min_dentry) && (dirent_id <  max_dirent );
             attr = fatfs_get_record( DIR_ATTR , base + offset , 0 );
             ord  = fatfs_get_record( LDIR_ORD , base + offset , 0 );
+            attr = fatfs_get_record( DIR_ATTR , base + offset );
+            ord  = fatfs_get_record( LDIR_ORD , base + offset );
             if (ord == NO_MORE_ENTRY)                 // no more entry => break
 …
 error_t fatfs_sync_free_info( void )
+{
+    error_t       error;
+    fatfs_ctx_t * fatfs_ctx_ptr;              // local pointer on fatfs context in cluster 0
+    uint32_t      ctx_free_clusters;          // number of free clusters from fatfs context
+    uint32_t      ctx_free_cluster_hint;      // free cluster hint from fatfs context
+    uint32_t      ioc_free_clusters;          // number of free clusters from fatfs context
+    uint32_t      ioc_free_cluster_hint;      // free cluster hint from fatfs context
+    uint32_t      fs_info_lba;                // lba of FS_INFO sector on IOC device
+    uint8_t     * fs_info_buffer;             // local pointer on FS_INFO buffer in cluster 0
+    xptr_t        fs_info_buffer_xp;          // extended pointer on FS_INFO buffer in cluster 0
+    uint8_t       tmp_buf[512];               // 512 bytes temporary buffer
+    xptr_t        tmp_buf_xp;                 // extended pointer on temporary buffer
 #if DEBUG_FATFS_SYNC_FSINFO
 …
 #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 );
+    // get pointer on fatfs context in cluster 0
+    fatfs_ctx_ptr = hal_remote_lpt( XPTR( 0 , &fs_context[FS_TYPE_FATFS].extend ) );
+    // get "free_clusters" and "free_cluster_hint" from fatfs context in cluster 0
+    ctx_free_clusters     = hal_remote_l32( XPTR( 0 , &fatfs_ctx_ptr->free_clusters ) );
+    ctx_free_cluster_hint = hal_remote_l32( XPTR( 0 , &fatfs_ctx_ptr->free_cluster_hint ) );
+    // get fs_info_lba
+    fs_info_lba = hal_remote_l32( XPTR( 0 , &fatfs_ctx_ptr->fs_info_lba ) );
+    // build extended pointer on temporary buffer
+    tmp_buf_xp = XPTR( local_cxy , tmp_buf );
+    // copy FS_INFO sector from IOC to local buffer
+    error = dev_ioc_sync_read( tmp_buf_xp , fs_info_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 );
+        printk("\n[ERROR] in %s : cannot access FS_INFO on IOC device\n", __FUNCTION__ );
+        return -1;
+    }
+    // get current values of "free_clusters" and "free_cluster_hint" from FS_INFO on IOC
+    ioc_free_clusters     = fatfs_get_remote_record( FS_FREE_CLUSTERS     , tmp_buf_xp );
+    ioc_free_cluster_hint = fatfs_get_remote_record( FS_FREE_CLUSTER_HINT , tmp_buf_xp );
+    // check values
+    if( (ioc_free_clusters     != ctx_free_clusters) ||
+        (ioc_free_cluster_hint != ctx_free_cluster_hint) )
+    {
+        printk("\n[WARNING] in %s : unconsistent free clusters info\n"
+        " ioc_free %x / ctx_free %x / ioc_hint %x / ctx_hint %x\n",
+        __FUNCTION__, ioc_free_clusters, ctx_free_clusters,
+        ioc_free_cluster_hint, ctx_free_cluster_hint );
+        // get pointers on FS_INFO buffer in cluster 0
+        fs_info_buffer    = hal_remote_lpt( XPTR( 0 , &fatfs_ctx_ptr->fs_info_buffer ) );
+        fs_info_buffer_xp = XPTR( 0 , fs_info_buffer );
+        // update FS_INFO buffer in cluster 0
+        fatfs_set_remote_record(FS_FREE_CLUSTERS    ,fs_info_buffer_xp,ctx_free_clusters );
+        fatfs_set_remote_record(FS_FREE_CLUSTER_HINT,fs_info_buffer_xp,ctx_free_cluster_hint);
+        // update the FS_INFO sector on IOC device
+        error = dev_ioc_sync_write( fs_info_buffer_xp , fs_info_lba , 1 );
+        if ( error )
+        {
+            printk("\n[ERROR] in %s : cannot update FS_INFO on IOC device\n", __FUNCTION__ );
+            return -1;
+        }
+    }
 #if DEBUG_FATFS_SYNC_FSINFO
 …
     return 0;
 }  // end fatfs_sync_fs_info()
+}  // end fatfs_sync_free_info()
 //////////////////////////////////////////////////////////
 error_t fatfs_cluster_alloc( uint32_t * searched_cluster )
+{
+    error_t       error;
     uint32_t      page_id;        // page index in FAT mapper
     uint32_t      slot_id;        // slot index in page (1024 slots per page)
 …
     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
+    cxy_t         fat_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
+    xptr_t        free_xp;        // extended pointer on free_clusters_number in FAT cluster
 #if DEBUG_FATFS_CLUSTER_ALLOC
 …
     loc_fatfs_ctx = vfs_ctx->extend;
     // get extended pointer and cluster on FAT mapper
+    // get extended pointer on FAT mapper
     mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
+    mapper_cxy = GET_CXY( mapper_xp );
+    // get FAT cluster
+    fat_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 ) );
+    fat_fatfs_ctx = hal_remote_lpt( XPTR( fat_cxy , &vfs_ctx->extend ) );
     // build relevant extended pointers on free clusters info in mapper 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 );
+    lock_xp = XPTR( fat_cxy , &fat_fatfs_ctx->free_lock );
+    hint_xp = XPTR( fat_cxy , &fat_fatfs_ctx->free_cluster_hint );
+    free_xp = XPTR( fat_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
+    // get hint and free_clusters values from FATFS context in FAT cluster
     cluster       = hal_remote_l32( hint_xp ) + 1;
     free_clusters = hal_remote_l32( numb_xp );
+    free_clusters = hal_remote_l32( free_xp );
 #if (DEBUG_FATFS_CLUSTER_ALLOC & 1)
 …
+    }
     // get page index & slot index for selected cluster
     page_id  = cluster >> 10;
     slot_id  = cluster & 0x3FF;
     // get relevant page descriptor from mapper
+    // get relevant page descriptor from FAT mapper
     page_xp = mapper_remote_get_page( mapper_xp , page_id );
 …
+    }
+    // update free cluster info in FATFS context
+    fatfs_free_clusters_decrement( mapper_cxy , fat_fatfs_ctx , cluster );
+    // update free cluster info in FATFS context and in FS_INFO sector
+    error = fatfs_free_clusters_decrement( XPTR( fat_cxy , fat_fatfs_ctx ) , cluster );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot update free cluster info\n", __FUNCTION__ );
+        remote_queuelock_acquire( lock_xp );
+        return -1;
+    }
+    // update FAT mapper
+    hal_remote_s32( slot_xp , END_OF_CHAIN_CLUSTER_MAX );
+    // synchronously update FAT on device
+    error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot update FAT on IOC device\n", __FUNCTION__ );
+        remote_queuelock_acquire( lock_xp );
+        return -1;
+    }
     // release free clusters busylock
     remote_queuelock_release( lock_xp );
-    // update FAT mapper
-    hal_remote_s32( slot_xp , END_OF_CHAIN_CLUSTER_MAX );
-    // synchronously update FAT on device
-    fatfs_move_page( page_xp , IOC_SYNC_WRITE );
 #if DEBUG_FATFS_CLUSTER_ALLOC
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_FATFS_CLUSTER_ALLOC < cycle )
 printk("\n[%s] thread[%x,%x] exit / updated cluster %x in FAT / cycle %d\n",
+printk("\n[%s] thread[%x,%x] exit / allocated cluster %x in FAT / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, cluster, cycle );
 #endif
 …
     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;
+    vfs_inode_t * inode_ptr;      // local pointer on target inode
+    cxy_t         inode_cxy;      // target inode cluster identifier
 // check inode pointer
 …
     // get page base address
     xptr_t    base_xp = ppm_page2base( page_xp );
     uint8_t * buffer  = (uint8_t *)GET_PTR( base_xp );
+    xptr_t    buffer_xp  = ppm_page2base( page_xp );
+    uint8_t * buffer_ptr = (uint8_t *)GET_PTR( buffer_xp );
     // get inode pointer from mapper
     inode_ptr  = hal_remote_lpt( XPTR( page_cxy , &mapper_ptr->inode ) );
+    ////////////////////////////// it is the FAT mapper
+#if DEBUG_FATFS_MOVE_PAGE
+if( DEBUG_FATFS_MOVE_PAGE < cycle )
+printk("\n[%s] thread[%x,%x] enters : %s / cxy %x / mapper %x / inode %x / page %x\n",
+__FUNCTION__, this->process->pid, this->trdid,
+dev_ioc_cmd_str( cmd_type ), page_cxy, mapper_ptr, inode_ptr, buffer_ptr );
+#endif
+    //////////////////////////////  FAT mapper
     if( inode_ptr == NULL )
+    {
 …
         // access device
+        if     ( cmd_type == IOC_SYNC_READ  ) error = dev_ioc_sync_read ( buffer , lba , 8 );
+        else if( cmd_type == IOC_SYNC_WRITE ) error = dev_ioc_sync_write( buffer , lba , 8 );
+        else if( cmd_type == IOC_READ       ) error = dev_ioc_read      ( buffer , lba , 8 );
+        else if( cmd_type == IOC_WRITE      ) error = dev_ioc_write     ( buffer , lba , 8 );
+        else                                  error = -1;
+        if( error ) return EIO;
+        if     (cmd_type == IOC_SYNC_READ ) error = dev_ioc_sync_read ( buffer_xp  , lba , 8 );
+        else if(cmd_type == IOC_SYNC_WRITE) error = dev_ioc_sync_write( buffer_xp  , lba , 8 );
+        else if(cmd_type == IOC_READ      ) error = dev_ioc_read      ( buffer_ptr , lba , 8 );
+        else if(cmd_type == IOC_WRITE     ) error = dev_ioc_write     ( buffer_ptr , lba , 8 );
+        else                                error = -1;
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot access device\n", __FUNCTION__ );
+            return -1;
+        }
 #if DEBUG_FATFS_MOVE_PAGE
 …
+{
     if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) )
          printk("\n[%s] thread[%x,%x] load page %d of FAT / cycle %d\n",
          __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
+        printk("\n[%s] thread[%x,%x] load FAT mapper page %d from IOC / 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",
+        printk("\n[%s] thread[%x,%x] sync FAT mapper page %d to IOC / cycle %d\n",
         __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
+}
 …
+    }
     ///////////////////////// it is an inode mapper
+    /////////////////////////  inode mapper
     else
+    {
 …
+        }
         // get lba from searched_cluster
+        // get lba for searched_cluster
         uint32_t lba = fatfs_lba_from_cluster( fatfs_ctx , searched_cluster );
+        // access device
+        if     (cmd_type == IOC_SYNC_READ ) error = dev_ioc_sync_read ( buffer_xp  , lba , 8 );
+        else if(cmd_type == IOC_SYNC_WRITE) error = dev_ioc_sync_write( buffer_xp  , lba , 8 );
+        else if(cmd_type == IOC_READ      ) error = dev_ioc_read      ( buffer_ptr , lba , 8 );
+        else if(cmd_type == IOC_WRITE     ) error = dev_ioc_write     ( buffer_ptr , lba , 8 );
+        else                                error = -1;
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot access device\n", __FUNCTION__ );
+            return -1;
+        }
 #if DEBUG_FATFS_MOVE_PAGE
 …
 #endif
-        // access device
-        if     ( cmd_type == IOC_SYNC_READ  ) error = dev_ioc_sync_read ( buffer , lba , 8 );
-        else if( cmd_type == IOC_SYNC_WRITE ) error = dev_ioc_sync_write( buffer , lba , 8 );
-        else if( cmd_type == IOC_READ       ) error = dev_ioc_read      ( buffer , lba , 8 );
-        else if( cmd_type == IOC_WRITE      ) error = dev_ioc_write     ( buffer , lba , 8 );
-        else                                  error = -1;
-        if( error )
+        {
-            printk("\n[ERROR] in %s : cannot access device\n", __FUNCTION__ );
-            return -1;
+        }
+    }

trunk/kernel/fs/fatfs.h

-                      r625
+                      r626
 /*****************************************************************************************
  * 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.
+ * This fatfs context is replicated in all clusters.
+ *
+ * WARNING : Almost all fields are constant values, but the <free_cluster_hint>,
+ * <free_clusters> and <free_lock> are shared variables. Moreover, the <fs_info_buffer>,
+ * only allocated in cluster 0, contains a copy of the FS_INFO sector. It is used by all
+ * kernel instances to synchronously update the free clusters info on IOC device.
+ * For these four variables, all kernel instances must use the values in cluster 0,
+ * and take the <free_lock> stored in this cluster for exclusive access to FAT.
  ****************************************************************************************/
 typedef struct fatfs_ctx_s
+{
+    /* read-only constants replicated in all clusters                                   */
     uint32_t            fat_sectors_count;     /*! number of sectors in FAT region      */
     uint32_t            bytes_per_sector;      /*! number of bytes per sector           */
 …
     uint32_t            root_dir_cluster;      /*! cluster index for  root directory    */
     xptr_t              fat_mapper_xp;         /*! extended pointer on FAT mapper       */
+    /* shared variables (only the copy in FAT cluster must be used)                     */
     uint32_t            free_cluster_hint;     /*! cluster[hint+1] is the first free    */
     uint32_t            free_clusters;         /*! free clusters number                 */
+    remote_queuelock_t  free_lock;             /*! exclusive access to hint & number    */
+    remote_queuelock_t  free_lock;             /*! exclusive access to FAT              */
+    uint8_t           * fs_info_buffer;        /*! local pointer on FS_INFO buffer      */
+}
 fatfs_ctx_t;
 …
 /*****************************************************************************************
+ * This function display the content of the local FATFS context.
+ *****************************************************************************************
+ * @ ctx  : local pointer on the context.
+ ****************************************************************************************/
+void fatfs_ctx_display( fatfs_ctx_t * ctx );
+/*****************************************************************************************
+ * 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).
+ * This function display the content of the FATFS context copy in cluster identified
+ * by the <cxy> argument.
+ * This function can be called by a thread running in any cluster.
+ *****************************************************************************************
+ * @ cxy       :  target cluster identifier.
+ ****************************************************************************************/
+void fatfs_display_ctx( cxy_t cxy );
+/*****************************************************************************************
+ * This function access the FAT mapper to display one page of the File Allocation Table.
+ * It loads the requested page fom IOC device to FAT mapper if required.
+ * This function can be called by a thread running in any cluster.
+ *****************************************************************************************
+ * @ page_id     : page index in FAT mapper (one page is 4 Kbytes).
+ * @ nb_entries  : number of entries (one entry is 4 bytes).
  ****************************************************************************************/
 void fatfs_display_fat( uint32_t  page_id,
                         uint32_t  nentries );
+                        uint32_t  nb_entries );
 …
 /*****************************************************************************************
+ * This function access the boot device, and initialises the local FATFS context
+ * from informations contained in the boot record.
+ * This function access the boot device, and initialises the local FATFS context,
+ * from informations contained in the boot record. This initialisation includes the
+ * creation of the FAT mapper in cluster 0.
  *****************************************************************************************
  * @ vfs_ctx   : local pointer on VFS context for FATFS.
 …
  * This function implements the generic vfs_fs_add_dentry() function for the FATFS.
  *****************************************************************************************
  * This function updates a directory identified by the <inode> argument
+ * This function updates a directory mapper 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.
+ * All modified pages in the directory mapper are synchronously updated on IOC device.
+ * It must be called by a thread running in the cluster containing the directory inode.
+ *
  * Implementation note : this function works in two steps:
 …
  * This function implements the generic vfs_fs_new_dentry() function for the FATFS.
  *****************************************************************************************
  * It initializes a new inode/dentry couple in Inode Tree, attached to the directory
  * identified by the <parent_inode> argument. The directory entry is identified
  * by the <name> argument. The child inode descriptor, identified by the <child_inode_xp>
  * argument, and the associated dentry descriptor must have been previously allocated.
  * It scan the parent mapper to find the <name> argument.
  * It set the "type", "size", and "extend" fields in the child inode descriptor.
  * It set the " extend" field in the dentry descriptor.
+ * It scan a parent directory mapper, identified by the <parent_inode> argument to find
+ * a directory entry identified by the <name> argument.  In case of success, it
+ * initializes the inode/dentry couple, identified by the  <child_inode_xp> argument
+ * in the Inode Tree. The child inode descriptor, and the associated dentry descriptor
+ * must have been previously allocated by the caller.
+ * - It set the "type", "size", and "extend" fields in the child inode descriptor.
+ * - It set the " extend" field in the dentry descriptor.
  * It must be called by a thread running in the cluster containing the parent inode.
  *****************************************************************************************
 …
  * @ name            : child name.
  * @ child_inode_xp  : extended pointer on remote child inode (file or directory).
  * @ return 0 if success / return ENOENT if child not found.
+ * @ return 0 if success / return -1 if child not found.
  ****************************************************************************************/
 error_t fatfs_new_dentry( struct vfs_inode_s * parent_inode,
 …
  *****************************************************************************************
  * @ inode   : local pointer on inode.
  * @ return 0 if success / return EIO if failure during device access.
+ * @ return 0 if success / return -1 if failure during IOC 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 updates the FAT 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.
 …
  *  variables defining the smallest/largest dirty page index in FAT mapper...
  *****************************************************************************************
  * @ return 0 if success / return EIO if failure during device access.
+ * @ return 0 if success / return -1 if failure during IOC 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.
+ * It checks the current values of the "free_clusters" and "free_cluster_hint" variables
+ * in the FS_INFO sector on IOC, versus the values stored in the fatfs context.
+ * As these values are synchronously updated on IOC device at each modification,
+ * it does nothing if the values are equal. It updates the FS_INFO sector on IOC device,
+ * and displays a warning message on TXT0 if they are not equal.
+ * This function can be called by any thread running in any cluster.
+ *****************************************************************************************
+ * @ return 0 if success / return -1 if failure during IOC device access.
  ****************************************************************************************/
 error_t fatfs_sync_free_info( void );
 …
  * 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 queuelock stored in the FATFS
  * context (located in the same cluster as the FAT mapper itself), to get exclusive
  * access to the FAT. It uses the <free_cluster_hint> and <free_clusters> variables
  * stored in this FATFS context.
+ * 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>
+ * variables stored in this FATFS context.
  * - it updates the <free_cluster_hint> and <free_clusters> variables in FATFS context.
  * - it updates the FAT mapper (handling miss from IOC device if required).
 …
 /*****************************************************************************************
  * 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.
 …
  * The pointer on the mapper and the page index in file are found in the page descriptor.
  * It is used for both a regular file/directory mapper, and 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.
+ * - For the FAT mapper, it updates the FAT region 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.
+ *

trunk/kernel/fs/vfs.c

-                      r625
+                      r626
 }  // end vfs_inode_load_all_pages()
+/////////////////////////////////////////
+void vfs_inode_display( xptr_t inode_xp )
+{
+    assert( (inode_xp != XPTR_NULL), "inode pointer is NULL");
+    char  name[CONFIG_VFS_MAX_NAME_LENGTH];
+    vfs_inode_get_name( inode_xp , name );
+    cxy_t         inode_cxy = GET_CXY( inode_xp );
+    vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
+    vfs_inode_type_t type    = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
+    uint32_t         attr    = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->attr ) );
+    uint32_t         size    = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->size ) );
+    uint32_t         parents = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->links ) );
+    mapper_t       * mapper  = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
+    void           * extend  = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->extend ) );
+    printk("\n**** inode <%s>\n"
+           " - type    = %s\n"
+           " - attr    = %x\n"
+           " - size    = %d\n"
+           " - parents = %d\n"
+           " - cxy     = %x\n"
+           " - inode   = %x\n"
+           " - mapper  = %x\n"
+           " - extend  = %x\n",
+           name,
+           vfs_inode_type_str( type ),
+           attr,
+           size,
+           parents,
+           inode_cxy,
+           inode_ptr,
+           mapper,
+           extend );
+}  // end vfs_inode_display()
 ////////////////////////////////////////////////////////////////////////////////////////////
 //          VFS dentry descriptor related functions
 …
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_OPEN < cycle )
 printk("\n[%s] thread[%x,%x] exit for <%s> / fdid %d / cluster %x / cycle %d\n",
+printk("\n[%s] thread[%x,%x] exit for <%s> / fdid %d / cxy %x / cycle %d\n",
 __FUNCTION__, process->pid, this->trdid, path, file_id, GET_CXY( file_xp ), cycle );
 #endif
 …
 // check inode type
 assert( (inode_type == INODE_TYPE_FILE), "bad inode type" );
+#if DEBUG_VFS_USER_MOVE
+char          name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t      cycle      = (uint32_t)hal_get_cycles();
+thread_t    * this       = CURRENT_THREAD;
+vfs_inode_t * inode      = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
+vfs_inode_get_name( XPTR( file_cxy , inode ) , name );
+if( cycle > DEBUG_VFS_USER_MOVE )
+{
+    if( to_buffer )
+    printk("\n[%s] thread[%x,%x] enter / %d bytes / mapper(%s) -> buffer(%x) / cycle %d\n",
+    __FUNCTION__ , this->process->pid, this->trdid, size, name, buffer, cycle );
+    else
+    printk("\n[%s] thread[%x,%x] enter / %d bytes / buffer(%x) -> mapper(%s) / cycle %d\n",
+    __FUNCTION__ , this->process->pid, this->trdid, size, buffer, name, cycle );
+}
+#endif
     // get mapper pointer and file offset from file descriptor
 …
 #if DEBUG_VFS_USER_MOVE
+char          name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t      cycle      = (uint32_t)hal_get_cycles();
+thread_t    * this       = CURRENT_THREAD;
+vfs_inode_t * inode      = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
+vfs_inode_get_name( XPTR( file_cxy , inode ) , name );
+cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_VFS_USER_MOVE )
+{
     if( to_buffer )
     printk("\n[%s] thread[%x,%x] moves %d bytes from <%s> mapper to buffer (%x) / cycle %d\n",
     __FUNCTION__ , this->process->pid, this->trdid, size, name, buffer );
+    printk("\n[%s] thread[%x,%x] exit / %d bytes / mapper(%s) -> buffer(%x) / cycle %d\n",
+    __FUNCTION__ , this->process->pid, this->trdid, size, name, buffer, cycle );
     else
     printk("\n[%s] thread[%x,%x] moves %d bytes from buffer (%x) to <%s> mapper / cycle %d\n",
     __FUNCTION__ , this->process->pid, this->trdid, size, buffer, name );
+    printk("\n[%s] thread[%x,%x] exit / %d bytes / buffer(%x) -> mapper(%s) / cycle %d\n",
+    __FUNCTION__ , this->process->pid, this->trdid, size, buffer, name, cycle );
+}
 #endif
 …
             xptr_t inode_children_xp = XPTR( inode_cxy , &inode_ptr->children.items );
-printk("\n@@@ in %s : children_xp = (%x,%x)\n",
-__FUNCTION__, inode_cxy, &inode_ptr->children.items );
             // get target inode number of children
             inode_children = hal_remote_l32( inode_children_xp );
 …
     // display inode
     nolock_printk("%s<%s> : %s / extd %d / %d bytes / dirty %d / cxy %x / inode %x / mapper %x\n",
+    nolock_printk("%s<%s> : %s / extd %x / %d bytes / dirty %d / cxy %x / inode %x / mapper %x\n",
     indent_str[indent], name, vfs_inode_type_str( inode_type ), (uint32_t)inode_extd,
     inode_size, inode_dirty, inode_cxy, inode_ptr, mapper_ptr );
 …
 // This static function is used by the vfs_lookup() function.
 // It takes an extended pointer on a remote parent directory inode, a directory
+// entry name, and returns an extended pointer on the child inode.
+// entry name, and and scan the XHTAB associated to the parent inode to find the
+// searched dentry. It does NOT modify the inode tree in case of miss.
 // It can be used by any thread running in any cluster.
 //////////////////////////////////////////////////////////////////////////////////////////
 …
     bool_t             create;       // searched inode must be created if not found
     bool_t             excl;         // searched inode must not exist
     bool_t             par;          // searched inode is the parent
+    bool_t             parent;       // searched inode is the parent
     thread_t         * this;         // pointer on calling thread descriptor
     process_t        * process;      // pointer on calling process descriptor
 …
     create = (lookup_mode & VFS_LOOKUP_CREATE) == VFS_LOOKUP_CREATE;
     excl   = (lookup_mode & VFS_LOOKUP_EXCL)   == VFS_LOOKUP_EXCL;
     par    = (lookup_mode & VFS_LOOKUP_PARENT) == VFS_LOOKUP_PARENT;
+    parent = (lookup_mode & VFS_LOOKUP_PARENT) == VFS_LOOKUP_PARENT;
     // initialise loop variables
 …
         child_cxy  = GET_CXY( child_xp );
-        // analyse found & last, depending on lookup_mode
         if( found == false )                              // not found in Inode Tree
+        {
             // when a inode is not found in the Inode Tree:
             // - if (last and par) the Inode Tree is not modified
+            // - if (last and parent) the Inode Tree is not modified
             // - else we speculatively introduce a new (dentry/inode) in inode tree,
             //        and scan the parent directory mapper to initialise it.
 …
             //         - if the child is a directory, the child mapper is loaded from device
             if( last && par )   //  does nothing
+            if( last && parent )   //  does nothing
+            {
 …
+                }
+                if ( error )   // child not found in parent mapper
+                // when the missing dentry is not in the parent mapper,
+                // it is a new dentry that must be registered in parent directory mapper
+                if ( error )
+                {
                     if ( last && create )  // add a brand new dentry in parent directory
 …
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
 printk("\n[%s] thread[%x,%x] child <%s> not found in parent mapper => create it\n",
+printk("\n[%s] thread[%x,%x] child <%s> not found in parent mapper => created it\n",
 __FUNCTION__, process->pid, this->trdid, name );
+#endif
+vfs_inode_display( child_xp );
+#endif
+                    }
                     else                   // not last or not create => error
 …
         if ( last )           // last inode in path  => return relevant info
+        {
             if ( par )  // return parent inode and child name
+            if ( parent )  // return parent inode and child name
+            {
 …
     vfs_inode_t  * child_ptr  = GET_PTR( child_xp );
+    // 1. allocate one free cluster to child inode
+    // depending on the child inode FS type
+    // 1. allocate one free cluster in file system to child inode,
+    // and update the File Allocation Table in both the TAF mapper and IOC device.
+    // It depends on the child inode FS type.
     vfs_ctx_t * ctx = hal_remote_lpt( XPTR( child_cxy , &child_ptr->ctx ) );
 …
 #if( DEBUG_VFS_NEW_DENTRY_INIT & 1)
 if( DEBUG_VFS_NEW_DENTRY_INIT < cycle )
 printk("\n[%s] thread[%x,%x] allocated FAT cluster %x to <%s>\n",
+printk("\n[%s] thread[%x,%x] allocated FS cluster %x to <%s>\n",
 __FUNCTION__ , this->process->pid, this->trdid, cluster, child_name );
 #endif
     // 2. update the child inode descriptor
+    // 2. update the child inode descriptor size and extend
     child_type = hal_remote_l32( XPTR( child_cxy , &child_ptr->type ) );
     child_size = (child_type == INODE_TYPE_DIR) ? 4096 : 0;
 …
 #endif
     // register new_dentry in parent_inode xhtab of children
+    // 4. register new_dentry in parent_inode xhtab of children
     children_xhtab_xp = XPTR( parent_cxy , &parent_inode_ptr->children );
     children_entry_xp = XPTR( parent_cxy , &new_dentry_ptr->children );
 …
 #endif
     // update "parent" and "child_xp" fields in new_dentry
+    // 5. update "parent" and "child_xp" fields in new_dentry
     hal_remote_s64( XPTR( parent_cxy , &new_dentry_ptr->child_xp ) , new_inode_xp );
     hal_remote_spt( XPTR( parent_cxy , &new_dentry_ptr->parent ) , parent_inode_ptr );

trunk/kernel/fs/vfs.h

-                      r625
+                      r626
  * argument to a local buffer identified by the <name> argument.
  * The local buffer size must be at least CONFIG_VFS_MAX_NAME_LENGTH.
  *****************************************************************************************
+ ******************************************************************************************
  * @ inode_xp  : extended pointer on the remote inode.
  * @ name      : local buffer pointer.
 …
 error_t vfs_inode_load_all_pages( vfs_inode_t * inode );
+/******************************************************************************************
+ * This debug function display the curren state of an inode descriptor identified by
+ * the <inode_xp> argument.
+ *****************************************************************************************/
+void vfs_inode_display( xptr_t inode_xp );
 /******************************************************************************************
 …
  * It can be executed by any thread running in any cluster (can be different from both
  * the child cluster and the parent cluster).
+ *
  * [Implementation]
+ * The new child inode and the parent inode can have different FS types.
+ * [Implementation note]
  * As there are cross-references between inode and dentry, this function implements
  * a three steps scenario :
+ * a five steps scenario :
  * 1) The dentry descriptor is created in the cluster containing the existing <parent_xp>
  *    inode, and partially initialized, using the RPC_VFS_CREATE DENTRY if required.
  * 2) The inode and its associated mapper are created in cluster identified by <child_cxy>,
  *    and partially initialised, using the RPC_VFS_CREATE_INODE if required.
  *    The new inode and the parent inode can have different FS types.
  * 3) The pointers between the parent inode, the new dentry, and the child inode
  *    are updated, using remote accesses.
  ******************************************************************************************
+ * 3) The pointers on dentry in parent inode are updated, using remote access.
+ * 4) The pointers on dentry in child inode are updated, using remotes access.
+ * 5) The pointers on parent and child inode in dentry are updated, using remotes access.
+ *****************************************************************************************
  * @ child_inode_cxy  : [in]  target cluster for child inode.
  * @ fs_type          : [in]  child inode FS type.
 …
 /******************************************************************************************
  * 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.
+ * This function is called by the vfs_lookup() function when a new (dentry/inode) must
+ * be created from scratch and introduced in both the parent mapper and the IOC device.
+ * The dentry and inode descriptors must have been previously created by the caller.
+ * 1. It allocates one cluster from the relevant FS, updates the FAT mapper,
+ *    and synchronously update the IOC device).
+ * 2. It set the "size", and "extend" fields in child inode descriptor.
+ * 3. It updates the parent directory mapper to introduce the new child,
+ *    and synchronously update the IOC device.
+ * 4. It set the "extend" field in dentry descriptor.
  * It can be called by a thread running in any cluster.
  ******************************************************************************************

trunk/kernel/kern/do_syscall.c

-                      r610
+                      r626
  * do_syscall.c - architecture independant entry-point for system calls.
+ *
  * Author    Alain Greiner (2016,2017,2018)
+ * Author    Alain Greiner (2016,2017,2018, 2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
     sys_exit,               // 50
+    sys_sync,               // 51
+    sys_fsync,              // 52
 };
 …
     case SYS_EXIT:                         return "EXIT";             // 50
+    case SYS_SYNC:                         return "SYNC";             // 51
+    case SYS_FSYNC:                        return "FSYNc";            // 52
     default:                               return "undefined";

trunk/kernel/kern/kernel_init.c

-                      r624
+                      r626
+}
+/////////////////////////////////
+// kleenex debug function
+/////////////////////////////////
+void display_fat( uint32_t step )
+{
+    fatfs_ctx_t * fatfs_ctx = fs_context[FS_TYPE_FATFS].extend;
+    if( fatfs_ctx != NULL )
+    {
+        printk("\n[%s] step %d at cycle %d\n", __FUNCTION__, step, (uint32_t)hal_get_cycles() );
+        xptr_t     mapper_xp = fatfs_ctx->fat_mapper_xp;
+        mapper_display_page( mapper_xp , 0 , 128 );
+    }
+    else
+    {
+        printk("\n[%s] step %d : fatfs context not initialized\n", __FUNCTION__, step );
+    }
+}
 ///////////////////////////////////////////////////////////////////////////////////////////
 // This function is the entry point for the kernel initialisation.
 …
         if( CONFIG_VFS_ROOT_IS_FATFS )
+        {
             // 1. allocate memory for FATFS context extension in cluster 0
+            // 1. allocate memory for FATFS context in cluster 0
             fatfs_ctx_t * fatfs_ctx = fatfs_ctx_alloc();
 …
             // 2. access boot device to initialize FATFS context
             fatfs_ctx_init( fatfs_ctx );
             // 3. get various informations from FATFS context
             uint32_t root_dir_cluster = fatfs_ctx->root_dir_cluster;

trunk/kernel/kern/process.c

-                      r625
+                      r626
 #if( DEBUG_PROCESS_MAKE_FORK & 1 )
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+if( DEBUG_PROCESS_MAKE_FORK < cycle )
 printk("\n[%s] thread[%x,%x] / child takes TXT ownership / cycle %d\n",
 __FUNCTION__ , pid, trdid, cycle );
 …
 #if DEBUG_PROCESS_MAKE_EXEC
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+if( local_cxy == 0x11 )
 printk("\n[%s] thread[%x,%x] enters for %s / cycle %d\n",
 __FUNCTION__, pid, thread->trdid, path, cycle );
 …
 #if (DEBUG_PROCESS_MAKE_EXEC & 1)
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+if( local_cxy == 0x11 )
 printk("\n[%s] thread[%x,%x] opened file <%s> / cycle %d\n",
 __FUNCTION__, pid, thread->trdid, path, cycle );
 …
 #if (DEBUG_PROCESS_MAKE_EXEC & 1)
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+if( local_cxy == 0x11 )
 printk("\n[%s] thread[%x,%x] deleted existing threads / cycle %d\n",
 __FUNCTION__, pid, thread->trdid, cycle );
 …
 #if( DEBUG_PROCESS_MAKE_EXEC & 1 )
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+if( local_cxy == 0x11 )
 printk("\n[%s] thread[%x,%x] completed VMM reset / cycle %d\n",
 __FUNCTION__, pid, thread->trdid, cycle );
 …
 #if( DEBUG_PROCESS_MAKE_EXEC & 1 )
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+if( local_cxy == 0x11 )
 printk("\n[%s] thread[%x,%x] registered args/envs vsegs / cycle %d\n",
 __FUNCTION__, pid, thread->trdid, cycle );
 …
 #if( DEBUG_PROCESS_MAKE_EXEC & 1 )
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+if( local_cxy == 0x11 )
 printk("\n[%s] thread[%x,%x] registered code/data vsegs / cycle %d\n",
 __FUNCTION__, pid, thread->trdid, cycle );

trunk/kernel/libk/grdxt.c

r610	r626
1	1	/*
2		* grdxt.c - Three-levels Generic Radix-tree implementation
	2	* grdxt.c - Three-levels Generic Radix-tree implementation.
3	3	*
4		* authors Alain Greiner (2016)
	4	* authors Alain Greiner (2016,2017,2018,2019))
5	5	*
6	6	* Copyright (c) UPMC Sorbonne Universites

trunk/kernel/libk/grdxt.h

r623	r626
1	1	/*
2		* grdxt.h - Three-levels Generic Radix-tree ~~interface~~
	2	* grdxt.h - Three-levels Generic Radix-tree definition.
3	3	*
4		* Authors Alain Greiner (2016)
	4	* Authors Alain Greiner (2016,2017,2018,2019)
5	5	*
6	6	* Copyright UPMC Sorbonne Universites

trunk/kernel/libk/remote_rwlock.c

-                      r625
+                      r626
         thread_t *  thread_ptr = GET_PTR( thread_xp );
-printk("\n@@@ in %s : release first waiting writer[%x,%x]\n",
-__FUNCTION__, thread_cxy, thread_ptr );
         // remove this waiting thread from waiting list
         xlist_unlink( XPTR( thread_cxy , &thread_ptr->wait_xlist ) );

trunk/kernel/mm/mapper.c

-                      r625
+                      r626
     printk("\n[%s] thread[%x,%x] enter for page %d in <%s> / cycle %d",
     __FUNCTION__, this->process->pid, this->trdid, page_id, name, cycle );
    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), name );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), name );
+}
 if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode == NULL) )
 …
     printk("\n[%s] thread[%x,%x] enter for page %d in FAT / cycle %d",
     __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), "FAT" );
+    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), "FAT" );
+}
 #endif
 …
+    }
     // launch I/O operation to load page from device to mapper
+    // launch I/O operation to load page from IOC device to mapper
     error = vfs_fs_move_page( XPTR( local_cxy , page ) , IOC_SYNC_READ );
 …
 #if DEBUG_MAPPER_MOVE_USER
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+uint32_t      cycle      = (uint32_t)hal_get_cycles();
+thread_t    * this       = CURRENT_THREAD;
+cxy_t         mapper_cxy = GET_CXY( mapper_xp );
+mapper_t    * mapper_ptr = GET_PTR( mapper_xp );
+vfs_inode_t * inode_ptr  = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
+xptr_t        inode_xp   = XPTR( mapper_cxy , inode_ptr );
+char          name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( inode_xp , name );
 if( DEBUG_MAPPER_MOVE_USER < cycle )
+printk("\n[%s] thread[%x,%x] : to_buf %d / buffer %x / size %d / offset %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+to_buffer, buffer, size, file_offset, cycle );
+{
+    if( to_buffer )
+    printk("\n[%s] thread[%x,%x] : mapper(%s) -> buffer(%x) / bytes %d / cycle %d\n",
+    __FUNCTION__, this->process->pid, this->trdid, name, buffer, size, cycle );
+    else
+    printk("\n[%s] thread[%x,%x] : buffer(%x) -> mapper(%s) / bytes %d / cycle %d\n",
+    __FUNCTION__, this->process->pid, this->trdid, buffer, name, size, cycle );
+}
 #endif
 …
 #if (DEBUG_MAPPER_MOVE_USER & 1)
 if( DEBUG_MAPPER_MOVE_USER < cycle )
 printk("\n[%s] thread[%x,%x] : first_page %d / last_page %d\n",
 __FUNCTION__, this->process->pid, this->trdid, first, last );
+printk("\n[%s] thread[%x,%x] : mapper(%x,%x) / first_page %d / last_page %d\n",
+__FUNCTION__, this->process->pid, this->trdid, mapper_cxy, mapper_ptr, first, last );
 #endif
 …
 #if (DEBUG_MAPPER_MOVE_USER & 1)
 if( DEBUG_MAPPER_MOVE_USER < cycle )
 printk("\n[%s] thread[%x,%x] : page_id = %d / page_offset = %d / page_count = %d\n",
+printk("\n[%s] thread[%x,%x] : page_id %d / page_offset %d / bytes %d\n",
 __FUNCTION__, this->process->pid, this->trdid, page_id , page_offset , page_count );
 #endif
 …
         if ( page_xp == XPTR_NULL ) return -1;
+        // compute cluster and pointers on page in mapper
+        xptr_t     map_xp  = ppm_page2base( page_xp );
+        uint8_t  * map_ptr = GET_PTR( map_xp );
+        cxy_t      map_cxy = GET_CXY( map_xp );
 #if (DEBUG_MAPPER_MOVE_USER & 1)
 if( DEBUG_MAPPER_MOVE_USER < cycle )
+printk("\n[%s] thread[%x,%x] : get page (%x,%x) from mapper\n",
+__FUNCTION__, this->process->pid, this->trdid, GET_CXY(page_xp), GET_PTR(page_xp) );
+#endif
+        // compute pointer in mapper
+        xptr_t    base_xp = ppm_page2base( page_xp );
+        uint8_t * map_ptr = (uint8_t *)GET_PTR( base_xp ) + page_offset;
+        // compute pointer in buffer
+printk("\n[%s] thread[%x,%x] : get buffer(%x,%x) in mapper\n",
+__FUNCTION__, this->process->pid, this->trdid, map_cxy, map_ptr );
+#endif
+        // compute pointer in user buffer
         uint8_t * buf_ptr = (uint8_t *)buffer + done;
 …
         if( to_buffer )
+        {
+            hal_copy_to_uspace( buf_ptr , map_ptr , page_count );
+            hal_copy_to_uspace( map_cxy , map_ptr , buf_ptr , page_count );
+#if DEBUG_MAPPER_MOVE_USER & 1
+if( DEBUG_MAPPER_MOVE_USER < cycle )
+printk("\n[%s] thread[%x,%x] moved %d bytes / mapper %s (%x,%x) -> user buffer(%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, page_count,
+name, map_cxy, map_ptr, local_cxy, buf_ptr );
+#endif
+        }
         else
+        {
             ppm_page_do_dirty( page_xp );
+            hal_copy_from_uspace( map_ptr , buf_ptr , page_count );
+            hal_copy_from_uspace( map_cxy , map_ptr , buf_ptr , page_count );
+#if DEBUG_MAPPER_MOVE_USER & 1
+if( DEBUG_MAPPER_MOVE_USER < cycle )
+printk("\n[%s] thread[%x,%x] moved %d bytes / user buffer(%x,%x) -> mapper %s (%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, page_count,
+local_cxy, buf_ptr, name, map_cxy, map_ptr );
+mapper_display_page(  mapper_xp , page_id, 128 );
+#endif
+        }
 …
 #if DEBUG_MAPPER_MOVE_USER
 cycle = (uint32_t)hal_get_cycles();
+cycle      = (uint32_t)hal_get_cycles();
 if( DEBUG_MAPPER_MOVE_USER < cycle )
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+{
+    if( to_buffer )
+    printk("\n[%s] thread[%x,%x] completed mapper(%s) -> buffer(%x) / cycle %d\n",
+    __FUNCTION__, this->process->pid, this->trdid, name, buffer, cycle );
+    else
+    printk("\n[%s] thread[%x,%x] completed buffer(%x) -> mapper(%s) / cycle %d\n",
+    __FUNCTION__, this->process->pid, this->trdid, buffer, name, cycle );
+}
 #endif
 …
 #if DEBUG_MAPPER_SYNC
 if( cycle > DEBUG_MAPPER_SYNC )
 printk("\n[%s] thread[%x,%x] synchonise page %d of <%s> to device\n",
+printk("\n[%s] thread[%x,%x] synchonise page %d of <%s> to IOC device\n",
 __FUNCTION__, this->process->pid, this->trdid, page->index, name );
 #endif
 …
     // display 8 words per line
     tabi = (uint32_t *)buffer;
+    printk("\n***** <%s> first %d bytes of page %d *****\n", name, nbytes, page_id );
+    printk("\n***** mapper <%s> / %d bytes in page %d (%x,%x)\n",
+    name, nbytes, page_id, GET_CXY(base_xp), GET_PTR(base_xp) );
     for( line = 0 ; line < (nbytes >> 5) ; line++ )
+    {

trunk/kernel/mm/mapper.h

-                      r625
+                      r626
  *   and the  allocated memory is only released when the mapper/inode is destroyed.
+ *
+ * TODO : the mapper being only used to implement the VFS cache(s), the mapper.c
+ *        and mapper.h file should be trandfered to the fs directory.
+ * TODO (1) the mapper being only used to implement the VFS cache(s), the mapper.c
+ *          and mapper.h file should be trandfered to the fs directory.
+ * TODO (2) the "type" field is probably unused...
  ******************************************************************************************/
 …
 /*******************************************************************************************
  * This scans all pages present in the mapper identified by the <mapper> argument,
+ * This function scan all pages present in the mapper identified by the <mapper> argument,
  * and synchronize all pages maked as dirty" on disk.
  * These pages are unmarked and removed from the local PPM dirty_list.

trunk/kernel/syscalls/shared_include/shared_almos.h

r623	r626
54	54	DISPLAY_MAPPER = 9,
55	55	DISPLAY_BARRIER = 10,
	56	DISPLAY_FAT = 11,
56	57	}
57	58	display_type_t;

trunk/kernel/syscalls/shared_include/syscalls_numbers.h

-                      r610
+                      r626
  * syscalls_numbers.c - Contains enum of the syscalls.
+ *
  * Author    Alain Greiner (2018)
+ * Author    Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
     SYS_EXIT           = 50,
+    SYS_SYNC           = 51,
+    SYS_FSYNC          = 52,
     SYSCALLS_NR        = 51,
+    SYSCALLS_NR        = 53,
 } syscalls_t;

trunk/kernel/syscalls/sys_barrier.c

-                      r625
+                      r626
                 // copy barrier attributes into kernel space
+                hal_copy_from_uspace( &k_attr , (void*)attr , sizeof(pthread_barrierattr_t) );
+                hal_copy_from_uspace( local_cxy,
+                                      &k_attr,
+                                      (void*)attr,
+                                      sizeof(pthread_barrierattr_t) );
                 if ( count != k_attr.x_size * k_attr.y_size *k_attr.nthreads )

trunk/kernel/syscalls/sys_display.c

-                      r625
+                      r626
     else if( type == DISPLAY_MAPPER            ) return "MAPPER";
     else if( type == DISPLAY_BARRIER           ) return "BARRIER";
+    else if( type == DISPLAY_FAT               ) return "FAT";
     else                                         return "undefined";
+}
 …
             break;
+        }
+        /////////////////
+        case DISPLAY_FAT:
+        {
+            uint32_t  entries = (uint32_t)arg1;
+            if( entries > 4096 )
+                {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for FAT : nb_entries larger than 4096\n",
+__FUNCTION__ );
+#endif
+                        this->errno = EINVAL;
+                        return -1;
+                }
+            if( entries == 0 )  // display fat context in cluster cxy
+            {
+                uint32_t  cxy = (uint32_t)arg0;
+                if( cluster_is_undefined( cxy ) )
+                {
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for FAT : illegal cxy argument %x\n",
+__FUNCTION__ , cxy );
+#endif
+                     this->errno = EINVAL;
+                     return -1;
+                }
+                fatfs_display_ctx( cxy );
+            }
+            else                  // display nb_entries in page
+            {
+                uint32_t page = (uint32_t)arg0;
+                fatfs_display_fat( page , entries );
+            }
+            break;
+        }
         ////////
         default:

trunk/kernel/syscalls/sys_exec.c

-                      r625
+                      r626
     // copy the array of pointers to kernel buffer
+    hal_copy_from_uspace( k_pointers,
+    hal_copy_from_uspace( local_cxy,
+                          k_pointers,
                           u_pointers,
                           CONFIG_PPM_PAGE_SIZE );
 …
         // copy the user string to kernel buffer
+        hal_copy_from_uspace( k_buf_ptr,
+        hal_copy_from_uspace( local_cxy,
+                              k_buf_ptr,
                               k_pointers[index],
                               length );

trunk/kernel/syscalls/sys_fsync.c

-                      r1
+                      r626
 /*
  * sys_fsync: sync file
+ * sys_fsync.c - copy all modified pages of a given file mapper to IOC device.
+ *
  * Copyright (c) 2015 UPMC Sorbonne Universites
+ * Author    Alain Greiner  (2016,1017)
+ *
  * This file is part of ALMOS-kernel.
+ * Copyright (c)  UPMC Sorbonne Universites
+ *
+ * ALMOS-kernel is free software; you can redistribute it and/or modify it
+ * This file is part of ALMOS-MKH.
+ *
+ * ALMOS-MKH is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by
  * the Free Software Foundation; version 2.0 of the License.
+ *
  * ALMOS-kernel is distributed in the hope that it will be useful, but
+ * ALMOS-MKH is distributed in the hope that it will be useful, but
  * WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 …
+ *
  * You should have received a copy of the GNU General Public License
  * along with ALMOS-kernel; if not, write to the Free Software Foundation,
+ * along with ALMOS-MKH; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include <hal_kernel_types.h>
+#include <vfs.h>
+#include <process.h>
+#include <thread.h>
+#include <printk.h>
 #include <types.h>
+#include <syscalls.h>
+int sys_fsync (uint_t fd)
+/////////////////////////////////
+int sys_fsync( uint32_t file_id )
+{
+        //TODO
         return 0;
+    printk("\n[ERROR] in %d : not implemented yet\n", __FUNCTION__, file_id );
+    return ENOSYS;
+}

trunk/kernel/syscalls/sys_get_config.c

-                      r625
+                      r626
     // copy to user space
         hal_copy_to_uspace( x_size  , &k_x_size  , sizeof(uint32_t) );
         hal_copy_to_uspace( y_size  , &k_y_size  , sizeof(uint32_t) );
         hal_copy_to_uspace( ncores  , &k_ncores  , sizeof(uint32_t) );
+        hal_copy_to_uspace( local_cxy, &k_x_size, x_size, sizeof(uint32_t) );
+        hal_copy_to_uspace( local_cxy, &k_y_size, y_size, sizeof(uint32_t) );
+        hal_copy_to_uspace( local_cxy, &k_ncores, ncores, sizeof(uint32_t) );
     hal_fence();

trunk/kernel/syscalls/sys_get_core.c

-                      r625
+                      r626
     // copy to user space
         hal_copy_to_uspace( cxy , &k_cxy , sizeof(uint32_t) );
         hal_copy_to_uspace( lid , &k_lid , sizeof(uint32_t) );
+        hal_copy_to_uspace( local_cxy, &k_cxy, cxy, sizeof(uint32_t) );
+        hal_copy_to_uspace( local_cxy, &k_lid, lid, sizeof(uint32_t) );
         return 0;

trunk/kernel/syscalls/sys_get_cycle.c

r625	r626
64	64
65	65	// copy to user space
66		hal_copy_to_uspace( ~~cycle , &k_cycle~~ , sizeof(uint64_t) );
	66	hal_copy_to_uspace( local_cxy, &k_cycle, cycle, sizeof(uint64_t) );
67	67
68	68	return 0;

trunk/kernel/syscalls/sys_is_fg.c

r625	r626
91	91
92	92	// copy to user space
93		hal_copy_to_uspace( ~~is_fg , &is_txt_owner~~ , sizeof(uint32_t) );
	93	hal_copy_to_uspace( local_cxy, &is_txt_owner, is_fg, sizeof(uint32_t) );
94	94
95	95	hal_fence();

trunk/kernel/syscalls/sys_mmap.c

-                      r625
+                      r626
     // copy attributes from user space to kernel space
+    hal_copy_from_uspace( &k_attr , attr , sizeof(mmap_attr_t) );
+    hal_copy_from_uspace( local_cxy,
+                          &k_attr,
+                          attr,
+                          sizeof(mmap_attr_t) );
     // get addr, fdid, offset, and length attributes
 …
     // copy vseg base address to user space
+    hal_copy_to_uspace( &attr->addr , &vseg->min , sizeof(intptr_t) );
+    hal_copy_to_uspace( local_cxy,
+                        &vseg->min,
+                        &attr->addr,
+                        sizeof(intptr_t) );
     hal_fence();

trunk/kernel/syscalls/sys_opendir.c

-                      r625
+                      r626
     // set ident value in user buffer
+    hal_copy_to_uspace( dirp , &ident , sizeof(intptr_t) );
+    hal_copy_to_uspace( local_cxy,
+                        &ident,
+                        dirp,
+                        sizeof(intptr_t) );
     hal_fence();

trunk/kernel/syscalls/sys_readdir.c

-                      r625
+                      r626
  * sys_readdir.c - Copy one entry from an open VFS directory to an user buffer.
+ *
  * Author    Alain Greiner (2016,2017,2018)
+ * Author    Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
     // copy dirent pointer to user buffer
+    hal_copy_to_uspace( buffer, &direntp , sizeof(void *) );
+    hal_copy_to_uspace( local_cxy,
+                        &direntp,
+                        buffer,
+                        sizeof(void *) );
     // update current index in user_dir structure

trunk/kernel/syscalls/sys_sem.c

-                      r624
+                      r626
             // return value to user
+            hal_copy_to_uspace( current_value , &current , sizeof(uint32_t) );
+            hal_copy_to_uspace( local_cxy,
+                                &current,
+                                current_value,
+                                sizeof(uint32_t) );
+        }
         break;

trunk/kernel/syscalls/sys_stat.c

-                      r624
+                      r626
     // copy k_stat to u_stat
+    hal_copy_to_uspace( u_stat , &k_stat , sizeof(struct stat) );
+    hal_copy_to_uspace( local_cxy,
+                        &k_stat,
+                        u_stat,
+                        sizeof(struct stat) );
     hal_fence();

trunk/kernel/syscalls/sys_thread_create.c

-                      r624
+                      r626
+            }
+            hal_copy_from_uspace( &kern_attr , user_attr , sizeof(pthread_attr_t) );
+            hal_copy_from_uspace( local_cxy,
+                              &kern_attr,
+                              user_attr,
+                              sizeof(pthread_attr_t) );
+    }
 …
         // returns trdid to user space
         trdid = hal_remote_l32( XPTR( child_cxy , &child_ptr->trdid ) );
+        hal_copy_to_uspace( trdid_ptr , &trdid , sizeof(pthread_t) );
+        hal_copy_to_uspace( local_cxy,
+                        &trdid,
+                        trdid_ptr,
+                        sizeof(pthread_t) );
     // activate new thread

trunk/kernel/syscalls/sys_timeofday.c

-                      r624
+                      r626
     // copy values to user space
+        hal_copy_to_uspace( tv , &k_tv , sizeof(struct timeval) );
+        hal_copy_to_uspace( local_cxy,
+                        &k_tv,
+                        tv,
+                        sizeof(struct timeval) );
     hal_fence();

trunk/kernel/syscalls/sys_wait.c

-                      r625
+                      r626
 #endif
                  // return child termination state  to parent process
+                 hal_copy_to_uspace( status , &child_state , sizeof(int) );
+                 hal_copy_to_uspace( local_cxy,
+                                     &child_state,
+                                     status,
+                                     sizeof(int) );
                  return child_pid;
+            }

trunk/kernel/syscalls/syscalls.h

-                      r623
+                      r626
  * syscalls.h - Kernel side services for syscall handling.
+ *
  * Author     Alain Greiner (2016,2017,2018)
+ * Author     Alain Greiner (2016,2017,2018,2019)
+ *
  * Copyright (c) UPMC Sorbonne Universites
 …
  * [43] This debug function displays on the kernel terminal TXT0 an user defined string,
  * or the current state of a kernel structure, identified by the <type> argument.
+ * The <arg0>, <arg1>, and <arg2> arguments depends on the structure type:
+ * - DISPLAY_STRING          : an user defined string
+ * - DISPLAY_VMM             : VSL and GPT for a process identified by <pid>.
+ * - DISPLAY_SCHED           : all threads allocated to a scheduler <cxy> & <lid>.
+ * - DISPLAY_CLUSTER_PROCESS : all processes registered in a cluster identified by <cxy>.
+ * - DISPLAY_TXT_PROCESS     : all processes registered in a cluster identified by <cxy>.
+ * - DISPLAY_VFS             : all files registered in the VFS cache.
+ * - DISPLAY_CHDEV           : all registered channel devices.
+ * - DISPLAY_DQDT            : all DQDT nodes curren values.
+ * - DISPLAY_BUSYLOCKS       : all busylocks taken by one thread.
+ * - DISPLAY_MAPPER          : one page of a given mapper.
+ * The <arg0>, <arg1>, and <arg2> arguments depends on the structure type.
  ******************************************************************************************
  * type      : [in] type of display
 …
 /******************************************************************************************
  * [50] This function implements the exit system call terminating a POSIX process.
+ * [50] This function implements the "exit" system call terminating a POSIX process.
  * It can be called by any thread running in any cluster.
  * It uses both remote accesses to access the owner process descriptor, and the
  * RPC_PROCESS_SIGACTION to delete remote process and thread descriptors.
+ * RPC_PROCESS_SIGACTION to delete remote process copies and thread descriptors.
  * In the present implementation, this function implements actually the _exit():
  * - it does not flush open output streams.
  * - it does not close open streams.
  ******************************************************************************************
+ * @ status   : terminaison status.
+ * @ status   : terminaison status returned to parent process.
+ * @ return 0 if success / return -1 if failure.
  *****************************************************************************************/
 int sys_exit( uint32_t status );
+/******************************************************************************************
+ * [51] This function implements the "sync" system call.
+ * It forces all modified pages in all kernel mappers to be copied to the IOC device.
+ * It can be called by any thread running in any cluster.
+ * TODO not implemented yet.
+ ******************************************************************************************
+ * @ return 0 if success / return -1 if failure.
+ *****************************************************************************************/
+int sys_sync( void );
+/******************************************************************************************
+ * [52] This function implements the "fsync" system call.
+ * It forces all modified pages of the file mapper identified by the <fd> argument
+ * to be copied to the IOC device.
+ * It can be called by any thread running in any cluster.
+ * TODO not implemented yet.
+ ******************************************************************************************
+ * @ file_id   : file descriptor index in fd_array.
+ * @ return 0 if success / return -1 if failure.
+ *****************************************************************************************/
+int sys_fsync( uint32_t file_id );
 #endif  // _SYSCALLS_H_

Context Navigation

Legend:

Download in other formats: