Changeset 628 for trunk

Timestamp:

May 6, 2019, 1:28:01 PM (6 years ago)

Author:

alain

Message:

Introduce teh page_min / page_max mechanism in the fatfs_release_inode()
function, to avoid to scan all pages in FAT mapper.

Location:

trunk

Files:

• kernel/fs/fatfs.c (modified) (27 diffs)
• kernel/fs/fatfs.h (modified) (2 diffs)
• kernel/fs/vfs.c (modified) (4 diffs)
• kernel/kern/kernel_init.c (modified) (2 diffs)
• kernel/kern/rpc.c (modified) (5 diffs)
• kernel/kern/rpc.h (modified) (1 diff)
• kernel/kernel_config.h (modified) (4 diffs)
• kernel/mm/mapper.c (modified) (13 diffs)
• kernel/mm/mapper.h (modified) (2 diffs)
• libs/mini-libc/stdio.c (modified) (3 diffs)
• params-hard.mk (modified) (1 diff)
• user/fft/fft.c (modified) (38 diffs)
• user/ksh/ksh.c (modified) (3 diffs)
• user/sort/sort.c (modified) (3 diffs)

trunk/kernel/fs/fatfs.c

@@ -442 +442 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// 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.
+// This static function synchronously updates the FAT on IOC device.
+// It scan the FAT mapper to copy on IOC device all dirty pages in the interval
+// defined by the <page_min> & <page_max> arguments.
+// It can be called by a thread running in any cluster.
+// WARNING : We don't take the lock protecting the FAT mapper, because the FAT lock
+// (in FATFS context) must be taken by the calling function.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ fatfs_ctx_xp  : extended pointer on FATFS context in FAT cluster.
+// @ page_min      : first page to be checked.
+// @ page_max      : last page to be checked
 // @ 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 )
+static error_t fatfs_update_ioc_fat( xptr_t   fatfs_ctx_xp,
+                                     uint32_t page_min,
+                                     uint32_t page_max )
+{
+
+#if DEBUG_FATFS_UPDATE_IOC
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_FATFS_UPDATE_IOC < cycle )
+printk("\n[%s] thread[%x,%x] enter / page_min %d / page_max %d / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, page_min, page_max, cycle );
+#endif
+
+    error_t       error;
+    cxy_t         fat_cxy;         // FAT cluster identifier
+    fatfs_ctx_t * fatfs_ctx;       // local pointer on FATFS context in FAT cluster
+    xptr_t        fat_mapper_xp;   // extended pointer on FAT mapper
+    mapper_t    * fat_mapper_ptr;  // local pointer on FAT mapper
+    uint32_t      page_id;         // current page index in FAT mapper
+    xptr_t        rt_xp;           // extended pointer on FAT mapper radix tree
+    xptr_t        page_xp;         // extended pointer on current page in FAT mapper
+    page_t      * page_ptr;        // local pointer on current page
+    uint32_t      flags;           // current page flags
+
+    // get pointer and cluster on FATFS context in FAT cluster
+    fat_cxy   = GET_CXY( fatfs_ctx_xp );
+    fatfs_ctx = GET_PTR( fatfs_ctx_xp );
+ 
+    // get FAT mapper pointers from FATFS context 
+    fat_mapper_xp  = hal_remote_l64( XPTR( fat_cxy , &fatfs_ctx->fat_mapper_xp ) );
+    fat_mapper_ptr = GET_PTR( fat_mapper_xp );
+
+// check FAT cluster
+assert( (fat_cxy == GET_CXY( fat_mapper_xp )) , "unconsistent FAT cluster" );
+
+    // build extended pointer on FAT mapper radix tree
+    rt_xp   = XPTR( fat_cxy , &fat_mapper_ptr->rt );
+
+    // scan all pages in [min,max] interval
+    for( page_id = page_min ; page_id <= page_max ; page_id++ )
+    {
+        // get extended pointer on page descriptor from FAT mapper
+        page_xp = grdxt_remote_lookup( rt_xp , page_id );
+
+        // check only existing pages
+        if ( page_xp != XPTR_NULL )
+        {
+            page_ptr = GET_PTR( page_xp );
+            flags    = hal_remote_l32( XPTR( fat_cxy , &page_ptr->flags ) );
+
+            // copy only dirty pages
+            if ( flags & PG_DIRTY )
+            {
+
+#if (DEBUG_FATFS_UPDATE_IOC & 1)
+if( DEBUG_FATFS_UPDATE_IOC < cycle )
+printk("\n[%s] thread[%x,%x] copy page %d from FAT mapper to IOC device\n",
+__FUNCTION__, page_id );
+#endif
+                // move page from mapper to device
+                error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
+
+                if ( error )  return -1;
+
+                // reset page dirty flag
+                ppm_page_undo_dirty( page_xp );
+            }
+        }
+    }  // end loop on pages
+
+#if DEBUG_FATFS_UPDATE_IOC
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_FATFS_UPDATE_IOC < cycle )
+printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, cycle );
+#endif
+
+    return 0;
+
+}  // end fatfs_update_ioc_fat()
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// This static function synchronously updates the FS_INFO sector on IOC device,
+// from values contained in the FATFS context in FAT cluster.
+// It uses and updates the FS_INFO buffer allocated in the FAT cluster.
+// It can be called by a thread running in any cluster.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ fatfs_ctx_xp  : extended pointer on FATFS context in FAT cluster.
+// @ return 0 if success, return -1 if the FS_INFO sector cannot be updated.
+//////////////////////////////////////////////////////////////////////////////////////////
+static error_t fatfs_update_ioc_fsinfo( xptr_t fatfs_ctx_xp )
 {
     cxy_t         fat_cxy;             // FAT cluster identifier
     fatfs_ctx_t * fatfs_ctx_ptr;       // local pointer on fatfs context in FAT cluster
+    uint32_t      free_clusters;       // current vale of "free_clusters" in fatfs context
+    uint32_t      free_cluster_hint;   // current vale of "free_cluster_hint" in fatfs context
     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
@@ -466 +558 @@
     fatfs_ctx_ptr = GET_PTR( fatfs_ctx_xp ); 
 
-    // get pointers on FS_INFO buffer in FAT cluster
+    // force FATFS context update
+    hal_fence();
+
+    // get relevant info from fatfs context in FAT cluster
+    fs_info_lba        = hal_remote_l32( XPTR( fat_cxy , &fatfs_ctx_ptr->fs_info_lba ) );
+    free_clusters      = hal_remote_l32( XPTR( fat_cxy , &fatfs_ctx_ptr->free_clusters ) );
+    free_cluster_hint  = hal_remote_l32( XPTR( fat_cxy , &fatfs_ctx_ptr->free_cluster_hint ) );
     fs_info_buffer_ptr = hal_remote_lpt( XPTR( fat_cxy , &fatfs_ctx_ptr->fs_info_buffer ) );
+
+    // build extended pointer on FS_INFO buffer in FAT cluster
     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 );
@@ -480 +577 @@
     return dev_ioc_sync_write( fs_info_buffer_xp , fs_info_lba , 1 );
  
-}  // fatfs_free_clusters_update_ioc()
+}  // end fatfs_update_ioc_fsinfo()
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -488 +585 @@
 // 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 lock protecting exclusive access to these variables
-//           must be taken by the calling function. 
+// It synchronously updates the FS_INFO sector on the IOC device. 
+// It can be called by a thead running in any cluster. 
+// The lock protecting exclusive access to the FAT must be taken by the calling function. 
 //////////////////////////////////////////////////////////////////////////////////////////
 // @ fatfs_ctx_xp  : extended pointer on FATFS context in FAT cluster. 
@@ -502 +597 @@
 {
     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      page_max;     // max number of pages in FAT mapper
-    xptr_t        page_xp;      // extended pointer on current page in FAT mapper
-    xptr_t        base_xp;      // extended pointer on current page base
-    xptr_t        slot_xp;      // extended pointer on current slot in FAT mapper
+    cxy_t         fat_cxy;        // FAT cluster identifier
+    fatfs_ctx_t * fat_ctx_ptr;    // local pointer on fatfs context in FAT cluster
+    xptr_t        fat_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      page_max;       // max number of pages in FAT mapper
+    xptr_t        page_xp;        // extended pointer on current page in FAT mapper
+    xptr_t        base_xp;        // extended pointer on current page base
+    xptr_t        slot_xp;        // extended pointer on current slot in FAT mapper
 
 #if DEBUG_FATFS_FREE_CLUSTERS
@@ -537 +632 @@
 
     // get extended pointer on FAT mapper
-    mapper_xp = hal_remote_l64( XPTR( fat_cxy , &fat_ctx_ptr->fat_mapper_xp ) );
+    fat_mapper_xp = hal_remote_l64( XPTR( fat_cxy , &fat_ctx_ptr->fat_mapper_xp ) );
 
     // initialise variables to scan the FAT mapper
@@ -549 +644 @@
     {
         // get current page from mapper
-        page_xp = mapper_remote_get_page( mapper_xp , page_id );
+        page_xp = mapper_remote_get_page( fat_mapper_xp , page_id );
 
         if( page_xp == XPTR_NULL )
@@ -574 +669 @@
 
                 // update FS_INFO sector on IOC device
-                error = fatfs_free_clusters_update_ioc( fatfs_ctx_xp , numb , hint );
+                error = fatfs_update_ioc_fat( fatfs_ctx_xp,
+                                              page_id,
+                                              page_id );
 
                 if( error ) 
@@ -585 +682 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() )
-printk("\n[%s] thread[%x,%x] updated free cluster info  / hint %x / number %x\n",
+printk("\n[%s] thread[%x,%x] exit / hint %x / free %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, 
-hal_remote_l32(hint_xp), hal_remote_l32(numb_xp) );
+hal_remote_l32(hint_xp), hal_remote_l32(numb_xp), cycle );
 #endif
                 return 0;
@@ -612 +709 @@
 // This static function increments the "free_clusters" variable, and updates the
 // "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.
+// by the <fat_ctx_xp> argument, when a FATFS cluster is released.
 // 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 lock protecting exclusive access to these variables
-//           must be taken by the calling function. 
+// It does NOT update the  FS_INFO sector on the IOC device.
+// It can be called by a thead running in any cluster. 
+// The lock protecting exclusive access to the FAT must be taken by the calling function. 
 //////////////////////////////////////////////////////////////////////////////////////////
 // @ fatfs_ctx_xp  : extended pointer on FATFS context in FAT cluster. 
@@ -665 +760 @@
 
     // update FS_INFO sector on IOC device
-    error = fatfs_free_clusters_update_ioc( fatfs_ctx_xp , numb , hint );
+    error = fatfs_update_ioc_fsinfo( fatfs_ctx_xp );
 
     if( error ) 
@@ -674 +769 @@
 
 #if DEBUG_FATFS_FREE_CLUSTERS 
-thread_t * this = CURRENT_THREAD;
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_FATFS_FREE_CLUSTERS < (uint32_t)hal_get_cycles() )
-printk("\n[%s] thread[%x,%x] updated free cluster info : hint %x / number %x\n",
+printk("\n[%s] thread[%x,%x] exit / hint %x / free %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
-hal_remote_l32( hint_xp ), hal_remote_l32( numb_xp ) );
+hal_remote_l32( hint_xp ), hal_remote_l32( numb_xp ), cycle );
 #endif
 
@@ -686 +781 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// This recursive function is called by the generic function fatfs_release_all_clusters()
-// It release all clusters allocated to a given inode in the FAT mapper.
-// The removal is done in reverse order of the linked list (from last to first).
-// It does NOT update the FS on the IOC device.
-//////////////////////////////////////////////////////////////////////////////////////////
-// @ mapper_cxy : FAT mapper cluster identifier.
-// @ mapper_ptr : local pointer on FAT mapper.
-// @ fatfs_ctx  : local pointer on FATFS context in FAT cluster.
-// @ cluster    : index of cluster to be released from FAT mapper.
-// @ return 0 if success / return -1 if error (cannot access FAT)
-//////////////////////////////////////////////////////////////////////////////////////////
-static error_t fatfs_recursive_release( cxy_t         mapper_cxy,
-                                        mapper_t    * mapper_ptr,
-                                        fatfs_ctx_t * fatfs_ctx,
-                                        uint32_t      cluster )
-{
-    uint32_t next;
-
-    // build extended pointer on FAT mapper
-    xptr_t mapper_xp = XPTR( mapper_cxy , mapper_ptr );
+// This recursive function is called by the generic function fatfs_release_inode().
+// It release all FATFS clusters allocated to a given inode to the FAT mapper.
+// It can be called by a thread running in any cluster, as it use remote pointers
+// to access both the FAT mapper and the FATFS context in the FAT cluster, defined
+// by the <fat_mapper_xp> and <fatfs_ctx_xp> arguments.
+// The removal is done in reverse order of the linked list (from last cluster to first).
+// It returns in the <dirty_page_min> and <dirty_page_max> buffers the indexes of the
+// modified pages in the FAT mapper.
+// It updates the FAT mapper and the free_cluster info in the FATFS context, but does NOT
+// update the FAT and the FS_INFO on IOC device.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ fat_mapper_xp  : [in]  extended pointer on FAT mapper.
+// @ fatfs_ctx_xp   : [in]  extended pointer on FATFS context in FAT cluster.
+// @ cluster        : [in]  index of cluster to be released from FAT mapper.
+// @ dirty_page_min : [out] pointer on buffer for min dirty page index.
+// @ dirty_page_max : [out] pointer on buffer for max dirty page index.
+// @ return 0 if success / return -1 if error.
+//////////////////////////////////////////////////////////////////////////////////////////
+static error_t fatfs_recursive_release( xptr_t      fat_mapper_xp,
+                                        xptr_t      fatfs_ctx_xp,
+                                        uint32_t    cluster,
+                                        uint32_t  * dirty_page_min,
+                                        uint32_t  * dirty_page_max )
+{
+    uint32_t next;       // next cluster index
+    uint32_t page_id;    // page index in FAT mapper
+    uint32_t word_id;    // word index in page
+
+    // get page index and word index from cluster
+    page_id = cluster >> 10;
+    word_id = cluster & 0x3FF;
 
     // get next cluster index from FAT mapper
-    if ( mapper_remote_get_32( mapper_xp,
-                               cluster,
+    if ( mapper_remote_get_32( fat_mapper_xp,
+                               page_id,
+                               word_id,
                                &next ) ) return -1;
 
@@ -722 +829 @@
     {
         // call fatfs_recursive_release() on next cluster
-        if ( fatfs_recursive_release( mapper_cxy,
-                                      mapper_ptr,
-                                      fatfs_ctx,
-                                      next ) ) return -1;
+        if ( fatfs_recursive_release( fat_mapper_xp,
+                                      fatfs_ctx_xp,
+                                      next,
+                                      dirty_page_min,
+                                      dirty_page_max ) ) return -1;
     }       
 
-    // update current cluster in FAT mapper
-    if ( mapper_remote_set_32( mapper_xp, 
-                               cluster,
+    // update FAT mapper
+    if ( mapper_remote_set_32( fat_mapper_xp,
+                               page_id, 
+                               word_id,
                                FREE_CLUSTER ) ) return -1;
 
-    // Update free_cluster info in FATFS context and in FS_INFO sector
-    return fatfs_free_clusters_increment( XPTR( mapper_cxy , fatfs_ctx ) , cluster );
+    // update dirty_page_min / dirty_page_max buffers
+    if( page_id < *dirty_page_min ) *dirty_page_min = page_id;
+    if( page_id > *dirty_page_max ) *dirty_page_max = page_id;
+
+    // Update free_cluster info in FATFS context 
+    return fatfs_free_clusters_increment( fatfs_ctx_xp , cluster );
 
 }  // end fatfs_recursive_release()
@@ -1109 +1222 @@
     fatfs_ctx->fs_info_buffer        = buffer;
 
-    remote_rwlock_init( XPTR( local_cxy , &fatfs_ctx->lock ) , LOCK_FATFS_FREE );
+    remote_rwlock_init( XPTR( local_cxy , &fatfs_ctx->lock ) , LOCK_FATFS_FAT );
 
 #if (DEBUG_FATFS_CTX_INIT & 0x1)
@@ -1760 +1873 @@
     error_t        error;
 
-    char       dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
+    char           dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
 
 // check arguments
@@ -2158 +2271 @@
 }  // end fatfs_sync_inode()
 
+
+
+
+
+
 //////////////////////////////
 error_t fatfs_sync_fat( void )
@@ -2278 +2396 @@
     ioc_free_cluster_hint = fatfs_get_remote_record( FS_FREE_CLUSTER_HINT , tmp_buf_xp );
 
+#if DEBUG_FATFS_SYNC_FSINFO
+if( DEBUG_FATFS_SYNC_FSINFO < cycle )
+printk("\n[%s] thread[%x,%x] / ctx_free %x / ioc_free %x / ctx_hint %x / ioc_hint %x\n",
+__FUNCTION__ , this->process->pid, this->trdid, 
+ctx_free_clusters, ioc_free_clusters, ctx_free_cluster_hint, ioc_free_cluster_hint );
+#endif
+
     // check values
     if( (ioc_free_clusters     != ctx_free_clusters) || 
@@ -2327 +2452 @@
     fatfs_ctx_t * loc_fatfs_ctx;  // local pointer on local FATFS context
     fatfs_ctx_t * fat_fatfs_ctx;  // local pointer on FATFS context in FAT cluster
-    xptr_t        mapper_xp;      // extended pointer on FAT mapper
+    xptr_t        fat_mapper_xp;  // extended pointer on FAT mapper
     cxy_t         fat_cxy;        // Fat mapper cluster identifier
     xptr_t        page_xp;        // extended pointer on current page descriptor in mapper
@@ -2350 +2475 @@
 
     // get extended pointer on FAT mapper
-    mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
+    fat_mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
 
     // get FAT cluster
-    fat_cxy = GET_CXY( mapper_xp );
+    fat_cxy = GET_CXY( fat_mapper_xp );
     
     // get local pointer on FATFS context in FAT cluster 
@@ -2394 +2519 @@
 
     // get relevant page descriptor from FAT mapper
-    page_xp = mapper_remote_get_page( mapper_xp , page_id );
+    page_xp = mapper_remote_get_page( fat_mapper_xp , page_id );
 
     if( page_xp == XPTR_NULL )
@@ -2427 +2552 @@
     hal_remote_s32( slot_xp , END_OF_CHAIN_CLUSTER_MAX );
 
-    // synchronously update FAT on device
+    // we don't mark the FAT mapper page as dirty,
+    // because we synchronously update FAT on IOC device
     error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
 
@@ -2457 +2583 @@
     vfs_ctx_t   * vfs_ctx;        // local pointer on VFS context (same in all clusters).
     fatfs_ctx_t * loc_fatfs_ctx;  // local pointer on local FATFS context
-    fatfs_ctx_t * fat_fatfs_ctx;  // local pointer on FATFS context in FAT cluster
-    xptr_t        mapper_xp;      // extended pointer on FAT mapper
-    cxy_t         mapper_cxy;     // Fat mapper cluster identifier
-    mapper_t    * mapper_ptr;     // local pointer on FAT mapper
-    xptr_t        lock_xp;        // extended pointer on lock protecting free clusters info.
+    cxy_t         fat_cxy;        // FAT cluster identifier
+    xptr_t        fatfs_ctx_xp;   // extended pointer on FATFS context in FAT cluster
+    fatfs_ctx_t * fatfs_ctx_ptr;  // local pointer on FATFS context in FAT cluster
+    xptr_t        fat_mapper_xp;  // extended pointer on FAT mapper
+    mapper_t    * fat_mapper_ptr; // local pointer on FAT mapper
+    xptr_t        lock_xp;        // extended pointer on lock protecting FAT.
     xptr_t        first_xp;       // extended pointer on inode extension
     uint32_t      first_cluster;  // first cluster index for released inode
     vfs_inode_t * inode_ptr;      // local pointer on target inode
     cxy_t         inode_cxy;      // target inode cluster identifier
+    error_t       error;
 
 // check inode pointer 
@@ -2491 +2619 @@
 #endif
 
-#if (DEBUG_FATFS_RELEASE_INODE & 1)
-fatfs_display_fat( 0 , 512 );
-#endif
-
     // get local pointer on VFS context (same in all clusters)
     vfs_ctx = &fs_context[FS_TYPE_FATFS];
@@ -2501 +2625 @@
     loc_fatfs_ctx = vfs_ctx->extend;
 
-    // get pointers and cluster on FAT mapper
-    mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
-    mapper_cxy = GET_CXY( mapper_xp );
-    mapper_ptr = GET_PTR( mapper_xp );
+    // get pointers on FAT mapper
+    fat_mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
+    fat_cxy        = GET_CXY( fat_mapper_xp );
+    fat_mapper_ptr = GET_PTR( fat_mapper_xp );
     
-    // get local pointer on FATFS context in FAT cluster 
-    fat_fatfs_ctx = hal_remote_lpt( XPTR( mapper_cxy , &vfs_ctx->extend ) );
+    // get pointers on FATFS context in FAT cluster 
+    fatfs_ctx_ptr  = hal_remote_lpt( XPTR( fat_cxy , &vfs_ctx->extend ) );
+    fatfs_ctx_xp   = XPTR( fat_cxy , fatfs_ctx_ptr );
 
     // get extended pointer on FAT lock in FAT cluster
-    lock_xp = XPTR( mapper_cxy , &fat_fatfs_ctx->lock );
+    lock_xp = XPTR( fat_cxy , &fatfs_ctx_ptr->lock );
 
     // take FAT lock in write mode
     remote_rwlock_wr_acquire( lock_xp );
 
+#if (DEBUG_FATFS_RELEASE_INODE & 0x11 == 0x11)
+mapper_display_page( fat_mapper_xp , 0 , 4096 );
+#endif
+
     // call the recursive function to release all clusters from FAT mapper
-    if ( fatfs_recursive_release( mapper_cxy,
-                                  mapper_ptr,
-                                  fat_fatfs_ctx,
-                                  first_cluster ) )
+    uint32_t dirty_page_min = 0xFFFFFFFF;
+    uint32_t dirty_page_max = 0;
+
+    if ( fatfs_recursive_release( fat_mapper_xp,
+                                  fatfs_ctx_xp,
+                                  first_cluster,
+                                  &dirty_page_min,
+                                  &dirty_page_max ) )
     {
         printk("\n[ERROR] in %s : cannot update FAT mapper\n", __FUNCTION__ );
@@ -2531 +2664 @@
 #endif
 
+#if (DEBUG_FATFS_RELEASE_INODE & 0x11 == 0x11)
+mapper_display_page( fat_mapper_xp , 0 , 4096 );
+#endif
+
     // update FAT on IOC device (from FAT mapper)
-    if ( fatfs_sync_fat() )
-    {
-        printk("\n[ERROR] in %s : cannot update FAT on device\n", __FUNCTION__ );
+    error = fatfs_update_ioc_fat( fatfs_ctx_xp,
+                                  dirty_page_min,
+                                  dirty_page_max );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot update FAT on IOC device\n", __FUNCTION__ );
         remote_rwlock_wr_release( lock_xp );
         return -1;
@@ -2544 +2685 @@
 #endif
 
-    // update FS-INFO sector on IOC device (from FATFS context)
-    if ( fatfs_sync_free_info() )
-    {
-        printk("\n[ERROR] in %s: cannot update FS_INFO on device\n", __FUNCTION__ );
+    // update FS-INFO on IOC device (from FATFS context)
+    error = fatfs_update_ioc_fsinfo( fatfs_ctx_xp );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s: cannot update FSINFO on IOC device\n", __FUNCTION__ );
         remote_rwlock_wr_release( lock_xp );
         return -1;
     }
+
+#if (DEBUG_FATFS_RELEASE_INODE & 1)
+if( DEBUG_FATFS_RELEASE_INODE < cycle )
+printk("\n[%s] updated FS_INFO on IOC device for >%s>\n", __FUNCTION__, name );
+#endif
 
     // release FAT lock

trunk/kernel/fs/fatfs.h

@@ -180 +180 @@
  *   functions to modify the FAT in both the FAT mapper and on IOC device.
  *
- * WARNING é : Almost all fields are constant values, but the <free_cluster_hint>, 
- * <free_clusters> and <lock> are shared variables. 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, 
- * containing the FAT mapper.
+ * WARNING 2 : Most fields are constant values, but the <free_cluster_hint>,
+ * <free_clusters>, <dirty_page_min>, <dirty_page_max>, <lock>, and the <fs_info_buffer>
+ * are shared variables, that can be modified by any thread running in any cluster.
+ * The <fs_info_buffer> contains a copy of the FS_INFO sector, and is only allocated in
+ * the FAT cluster (i.e. in cluster 0). It is used by all to synchronously update the 
+ * free clusters info on IOC device.
+ *  => For all these variables, only the values stored in the FAT cluster must be used.
  ****************************************************************************************/
 
@@ -201 +202 @@
 
     /* shared variables (only the copy in FAT cluster must be used)                     */
+    uint32_t            dirty_page_min;        /*! min dirty page index in FAT mapper   */
+    uint32_t            dirty_page_max;        /*! max dirty page index in FAT mapper   */
     uint32_t            free_cluster_hint;     /*! cluster[hint+1] is the first free    */
     uint32_t            free_clusters;         /*! free clusters number                 */

trunk/kernel/fs/vfs.c

@@ -815 +815 @@
 assert( (inode_type == INODE_TYPE_FILE), "bad inode type" );
 
+    // get mapper pointer and file offset from file descriptor
+    file_offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
+    mapper      = hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
+
 #if DEBUG_VFS_USER_MOVE
 char          name[CONFIG_VFS_MAX_NAME_LENGTH];
@@ -824 +828 @@
 {
     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 );
+    printk("\n[%s] thread[%x,%x] enter / %d bytes / map(%s) -> buf(%x) / offset %d / cycle %d\n",
+    __FUNCTION__ , this->process->pid, this->trdid, size, name, buffer, file_offset, 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 );
+    printk("\n[%s] thread[%x,%x] enter / %d bytes / buf(%x) -> map(%s) / offset %d / cycle %d\n",
+    __FUNCTION__ , this->process->pid, this->trdid, size, buffer, name, file_offset, cycle );
 }
 #endif
-
-    // get mapper pointer and file offset from file descriptor
-    file_offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
-    mapper      = hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
 
     // move data between mapper and buffer
@@ -856 +856 @@
 {
     if( to_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 );
+    printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+    __FUNCTION__ , this->process->pid, cycle );
     else            
-    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 );
+    printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
+    __FUNCTION__ , this->process->pid, cycle );
 }
 #endif
@@ -2538 +2538 @@
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s] thread[%x,%x] look for <%s> in <%s> / last = %d\n",
+printk("\n[%s] thread[%x,%x] search <%s> in <%s> / last = %d\n",
 __FUNCTION__, process->pid, this->trdid, name, pathname, last );
 #endif

trunk/kernel/kern/kernel_init.c

@@ -162 +162 @@
     "PROCESS_USERSYNC",      // 26
     "PROCESS_FDARRAY",       // 27
-    "FATFS_FREE",            // 28
-    "PROCESS_DIR",           // 29
+    "PROCESS_DIR",           // 28
+    "unused_29",             // 29
 
     "PROCESS_THTBL",         // 30
@@ -173 +173 @@
     "VMM_GPT",               // 35
     "VFS_MAIN",              // 36
+    "FATFS_FAT",             // 37
 };        
 

trunk/kernel/kern/rpc.c

@@ -1735 +1735 @@
                                    error_t     * error )          // out
 {
-#if DEBUG_RPC_VFS_FS_GET_DENTRY
-thread_t * this = CURRENT_THREAD;
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_RPC_VFS_FS_GET_DENTRY )
+#if DEBUG_RPC_VFS_FS_NEW_DENTRY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_NEW_DENTRY )
 printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
@@ -1747 +1747 @@
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
-    rpc.index    = RPC_VFS_FS_GET_DENTRY;
+    rpc.index    = RPC_VFS_FS_NEW_DENTRY;
     rpc.blocking = true;
     rpc.rsp      = &responses;
@@ -1762 +1762 @@
     *error   = (error_t)rpc.args[3];
 
-#if DEBUG_RPC_VFS_FS_GET_DENTRY
-cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_RPC_VFS_FS_GET_DENTRY )
+#if DEBUG_RPC_VFS_FS_NEW_DENTRY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_NEW_DENTRY )
 printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
@@ -1773 +1773 @@
 void rpc_vfs_fs_new_dentry_server( xptr_t xp )
 {
-#if DEBUG_RPC_VFS_FS_GET_DENTRY
-thread_t * this = CURRENT_THREAD;
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_RPC_VFS_FS_GET_DENTRY )
+#if DEBUG_RPC_VFS_FS_NEW_DENTRY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_NEW_DENTRY )
 printk("\n[%s] thread[%x,%x] on core %d enter / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );
@@ -1807 +1807 @@
     hal_remote_s64( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
 
-#if DEBUG_RPC_VFS_FS_GET_DENTRY
-cycle = (uint32_t)hal_get_cycles();
-if( cycle > DEBUG_RPC_VFS_FS_GET_DENTRY )
+#if DEBUG_RPC_VFS_FS_NEW_DENTRY
+cycle = (uint32_t)hal_get_cycles();
+if( cycle > DEBUG_RPC_VFS_FS_NEW_DENTRY )
 printk("\n[%s] thread[%x,%x] on core %d exit / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, this->core->lid , cycle );

trunk/kernel/kern/rpc.h

@@ -77 +77 @@
     RPC_VFS_FILE_CREATE           = 14,
     RPC_VFS_FILE_DESTROY          = 15,
-    RPC_VFS_FS_GET_DENTRY         = 16,
+    RPC_VFS_FS_NEW_DENTRY         = 16,
     RPC_VFS_FS_ADD_DENTRY         = 17,
     RPC_VFS_FS_REMOVE_DENTRY      = 18,

trunk/kernel/kernel_config.h

@@ -91 +91 @@
 #define DEBUG_FATFS_SYNC_INODE            0
 #define DEBUG_FATFS_UPDATE_DENTRY         0
+#define DEBUG_FATFS_UPDATE_IOC            0
 
 #define DEBUG_HAL_CONTEXT                 0
@@ -150 +151 @@
 #define DEBUG_RPC_THREAD_USER_CREATE      0
 #define DEBUG_RPC_THREAD_KERNEL_CREATE    0
+#define DEBUG_RPC_VFS_DENTRY_CREATE       0
+#define DEBUG_RPC_VFS_DENTRY_DESTROY      0
+#define DEBUG_RPC_VFS_DEVICE_GET_DENTRY   0
+#define DEBUG_RPC_VFS_FILE_CREATE         0
+#define DEBUG_RPC_VFS_FILE_DESTROY        0
+#define DEBUG_RPC_VFS_FS_NEW_DENTRY       0
+#define DEBUG_RPC_VFS_FS_ADD_DENTRY       0
 #define DEBUG_RPC_VFS_INODE_CREATE        0
 #define DEBUG_RPC_VFS_INODE_DESTROY       0
-#define DEBUG_RPC_VFS_DENTRY_CREATE       0
-#define DEBUG_RPC_VFS_DENTRY_DESTROY      0
-#define DEBUG_RPC_VFS_FILE_CREATE         0
-#define DEBUG_RPC_VFS_FILE_DESTROY        0
-#define DEBUG_RPC_VFS_DEVICE_GET_DENTRY   0
 #define DEBUG_RPC_VMM_CREATE_VSEG         0
 #define DEBUG_RPC_VMM_GET_PTE             0
@@ -298 +301 @@
 #define LOCK_PROCESS_USERSYNC 26   // remote (Q)  protect lists of user synchros in process
 #define LOCK_PROCESS_FDARRAY  27   // remote (Q)  protect array of open files in owner process 
-#define LOCK_FATFS_FREE       28   // remote (Q)  protect the FATFS context (free clusters)
-#define LOCK_PROCESS_DIR      29   // remote (Q)  protect xlist of open directories in process
+#define LOCK_PROCESS_DIR      28   // remote (Q)  protect xlist of open directories in process
 
 #define LOCK_PROCESS_THTBL    30   // local  (RW) protect local array of threads in a process 
@@ -309 +311 @@
 #define LOCK_VMM_GPT          35   // remote (RW) protect GPT (local page table)
 #define LOCK_VFS_MAIN         36   // remote (RW) protect vfs traversal (in root inode)
+#define LOCK_FATFS_FAT        37   // remote (RW) protect exclusive access to the FATFS FAT
 
 

trunk/kernel/mm/mapper.c

@@ -395 +395 @@
 {
     uint32_t   page_offset;    // first byte to move to/from a mapper page
-    uint32_t   page_count;     // number of bytes to move to/from a mapper page
+    uint32_t   page_bytes;     // number of bytes to move to/from a mapper page
     uint32_t   page_id;        // current mapper page index
     uint32_t   done;           // number of moved bytes
@@ -420 +420 @@
 #endif
 
-    // compute offsets of first and last bytes in file
+    // compute indexes of first and last bytes in file
     uint32_t min_byte = file_offset;
     uint32_t max_byte = file_offset + size - 1;
@@ -444 +444 @@
 
         // compute number of bytes in page
-        if      ( first   == last  ) page_count = size;
-        else if ( page_id == first ) page_count = CONFIG_PPM_PAGE_SIZE - page_offset;
-        else if ( page_id == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
-        else                         page_count = CONFIG_PPM_PAGE_SIZE;
+        if      ( first   == last  ) page_bytes = size;
+        else if ( page_id == first ) page_bytes = CONFIG_PPM_PAGE_SIZE - page_offset;
+        else if ( page_id == last  ) page_bytes = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
+        else                         page_bytes = CONFIG_PPM_PAGE_SIZE;
 
 #if (DEBUG_MAPPER_MOVE_USER & 1)
 if( DEBUG_MAPPER_MOVE_USER < cycle )
 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
-
-        // get extended pointer on page descriptor
+__FUNCTION__, this->process->pid, this->trdid, page_id , page_offset , page_bytes );
+#endif
+
+        // get extended pointer on page descriptor in mapper
         page_xp = mapper_remote_get_page( mapper_xp , page_id ); 
 
@@ -476 +476 @@
         if( to_buffer )
         {
-            hal_copy_to_uspace( map_cxy , map_ptr , buf_ptr , page_count ); 
+            hal_copy_to_uspace( map_cxy , map_ptr + page_offset , buf_ptr , page_bytes ); 
 
 #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 );
+__FUNCTION__, this->process->pid, this->trdid, page_bytes,
+name, map_cxy, map_ptr + page_offset, local_cxy, buf_ptr );
 #endif
 
@@ -489 +489 @@
         {
             ppm_page_do_dirty( page_xp ); 
-            hal_copy_from_uspace( map_cxy , map_ptr , buf_ptr , page_count ); 
+            hal_copy_from_uspace( map_cxy , map_ptr + page_offset , buf_ptr , page_bytes ); 
 
 #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 );
+__FUNCTION__, this->process->pid, this->trdid, page_bytes,
+local_cxy, buf_ptr, name, map_cxy, map_ptr + page_offset );
 mapper_display_page(  mapper_xp , page_id, 128 );
 #endif
@@ -501 +501 @@
         }
 
-        done += page_count;
+        done += page_bytes;
     }
 
@@ -529 +529 @@
 {
     uint32_t   page_offset;    // first byte to move to/from a mapper page
-    uint32_t   page_count;     // number of bytes to move to/from a mapper page
+    uint32_t   page_bytes;     // number of bytes to move to/from a mapper page
     uint32_t   page_id;        // current mapper page index
     uint32_t   done;           // number of moved bytes
@@ -588 +588 @@
 
         // compute number of bytes to move in page
-        if      ( first == last  )   page_count = size;
-        else if ( page_id == first ) page_count = CONFIG_PPM_PAGE_SIZE - page_offset;
-        else if ( page_id == last  ) page_count = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
-        else                         page_count = CONFIG_PPM_PAGE_SIZE;
+        if      ( first == last  )   page_bytes = size;
+        else if ( page_id == first ) page_bytes = CONFIG_PPM_PAGE_SIZE - page_offset;
+        else if ( page_id == last  ) page_bytes = (max_byte & CONFIG_PPM_PAGE_MASK) + 1;
+        else                         page_bytes = CONFIG_PPM_PAGE_SIZE;
 
         // get extended pointer on page descriptor
@@ -621 +621 @@
     if( to_buffer )
     printk("\n[%s] mapper <%s> page %d => buffer(%x,%x) / %d bytes\n",
-    __FUNCTION__, name, page_id, dst_cxy, dst_ptr, page_count );
+    __FUNCTION__, name, page_id, dst_cxy, dst_ptr, page_bytes );
     else
     printk("\n[%s] buffer(%x,%x) => mapper <%s> page %d / %d bytes\n",
-    __FUNCTION__, src_cxy, src_ptr, name, page_id, page_count );
+    __FUNCTION__, src_cxy, src_ptr, name, page_id, page_bytes );
 }
 #endif
 
         // move fragment
-        hal_remote_memcpy( XPTR( dst_cxy , dst_ptr ), XPTR( src_cxy , src_ptr ), page_count );
-
-        done += page_count;
+        hal_remote_memcpy( XPTR( dst_cxy , dst_ptr ), XPTR( src_cxy , src_ptr ), page_bytes );
+
+        done += page_bytes;
     }
 
@@ -647 +647 @@
 ///////////////////////////////////////////////////
 error_t mapper_remote_get_32( xptr_t     mapper_xp,
+                              uint32_t   page_id,
                               uint32_t   word_id,
-                              uint32_t * p_value )
-{
-    uint32_t   page_id;      // page index in file
-    uint32_t   local_id;     // word index in page
+                              uint32_t * value )
+{
     xptr_t     page_xp;      // extended pointer on searched page descriptor
     xptr_t     base_xp;      // extended pointer on searched page base 
-
     
-    // get page index and local word index
-    page_id  = word_id >> 10;
-    local_id = word_id & 0x3FF;
-
     // get page containing the searched word
     page_xp  = mapper_remote_get_page( mapper_xp , page_id );
@@ -669 +663 @@
 
     // get the value from mapper
-    *p_value = hal_remote_l32( base_xp + (local_id<<2) ); 
+    *value = hal_remote_l32( base_xp + (word_id<<2) ); 
 
     return 0;
@@ -677 +671 @@
 ///////////////////////////////////////////////////
 error_t mapper_remote_set_32( xptr_t     mapper_xp,
+                              uint32_t   page_id,
                               uint32_t   word_id,
                               uint32_t   value )
 {
-    
-    uint32_t   page_id;      // page index in file
-    uint32_t   local_id;     // word index in page
     xptr_t     page_xp;      // extended pointer on searched page descriptor
     xptr_t     base_xp;      // extended pointer on searched page base 
 
-    // get page index and local vord index
-    page_id  = word_id >> 10;
-    local_id = word_id & 0x3FF;
-
     // get page containing the searched word
     page_xp  = mapper_remote_get_page( mapper_xp , page_id );
@@ -699 +687 @@
 
     // set value to mapper
-    hal_remote_s32( (base_xp + (local_id << 2)) , value );
-
-    // set the dirty flag
+    hal_remote_s32( (base_xp + (word_id << 2)) , value );
+
+    // set the dirty flag in page descriptor
     ppm_page_do_dirty( page_xp );
 

trunk/kernel/mm/mapper.h

@@ -206 +206 @@
  *******************************************************************************************
  * @ mapper_xp  : [in]  extended pointer on the mapper.
- * @ word_id    : [in]  32 bits word index in file.
- * @ p_value    : [out] local pointer on destination buffer.
+ * @ page_id    : [in]  page index in mapper.
+ * @ word_id    : [in]  32 bits word index in page.
+ * @ value      : [out] local pointer on destination buffer.
  * @ returns 0 if success / return -1 if error.
  ******************************************************************************************/
 error_t mapper_remote_get_32( xptr_t     mapper_xp,
+                              uint32_t   page_id,
                               uint32_t   word_id,
-                              uint32_t * p_value );
+                              uint32_t * value );
 
 /*******************************************************************************************
@@ -220 +222 @@
  * In case of miss, it takes the mapper lock in WRITE_MODE, load the missing
  * page from device to mapper, and release the mapper lock.
+ * It does not update the FAT on IOC device.
  *******************************************************************************************
  * @ mapper_xp  : [in]  extended pointer on the mapper.
- * @ word_id    : [in]  32 bits word index in file.
+ * @ page_id    : [in]  page index in mapper.
+ * @ word_id    : [in]  32 bits word index in page.
  * @ value      : [in]  value to be written.
  * @ returns 0 if success / return -1 if error.
  ******************************************************************************************/
 error_t mapper_remote_set_32( xptr_t     mapper_xp,
+                              uint32_t   page_id,
                               uint32_t   word_id,
                               uint32_t   value );

trunk/libs/mini-libc/stdio.c

@@ -51 +51 @@
 }
 
-///////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////////////
+// This static function analyses the <format> and the <args> to build a formated
+// string in the buffer defined by <string> and <length>.
+// It does NOT add a terminating NUL character in the <string buffer>.
+// If success, it returns the number of bytes actually copied in the string buffer.
+// It returns -1 in case of illegal format, or if the formated string exceeds the
+// the length argument. 
+////////////////////////////////////////////////////////////////////////////////////////
 static int xprintf( char         * string,
                     int            length,
@@ -57 +64 @@
                     va_list      * args ) 
 {
-    int ps = 0;    // write index to the string buffer
+    int ps = 0;    // index in the string buffer
 
 #define TO_STREAM(x) do { string[ps] = (x); ps++; if(ps==length) return -1; } while(0);
@@ -83 +90 @@
 
     {
-        char              buf[30];    // buffer to display one number
+        char              buf[30];    // buffer to store the string for one number
         char *            pbuf;       // pointer on first char to display
         unsigned int      len = 0;    // number of char to display

trunk/params-hard.mk

@@ -2 +2 @@
 
 ARCH      = /users/alain/soc/tsar-trunk-svn-2013/platforms/tsar_generic_iob
-X_SIZE    = 4
-Y_SIZE    = 4
-NB_PROCS  = 1
+X_SIZE    = 2
+Y_SIZE    = 2
+NB_PROCS  = 4
 NB_TTYS   = 3
 IOC_TYPE  = IOC_BDV

trunk/user/fft/fft.c

@@ -28 +28 @@
 // - RANDOM   : data points have pseudo random values
 //
-// This application uses 4 shared data arrays, that are distributed 
-// in all clusters (one buffer per cluster):
+// The main parameters for this generic application are the following:      
+//  - M : N = 2**M = number of data points / M must be an even number. 
+//  - T : nthreads = ncores defined by the hardware / must be power of 2. 
+//
+// This application uses 4 shared data arrays, that are dynamically
+// allocated an distributed, using the remote_malloc() function, with 
+// one sub-buffer per cluster:
 // - data[N] contains N input data points, with 2 double per point.
 // - trans[N] contains N intermediate data points, 2 double per point.
@@ -36 +41 @@
 // For data, trans, twid, each sub-buffer contains (N/nclusters) points.
 // For umain, each sub-buffer contains (rootN/nclusters) points.
-//
-// The main parameters for this generic application are the following:      
-//  - M : N = 2**M = number of data points / M must be an even number. 
-//  - T : nthreads = ncores defined by the hardware / must be power of 2. 
 //
 // There is one thread per core.
@@ -50 +51 @@
 //  - DEBUG_MAIN  : Display intermediate results in main()
 //  - DEBUG_FFT1D : Display intermediate results in FFT1D()
-//  - DEBUG_ROW  :
+//  - DEBUG_ROW   : Display intermedite results in FFTrow()
 //
 // Regarding final instrumentation:
@@ -87 +88 @@
 
 #define DEFAULT_M               12              // 4096 data points
-#define MODE                    COSIN
-#define CHECK                   0
-#define DEBUG_MAIN              2               // trace main() function (detailed if odd)
-#define DEBUG_SLAVE             2               // trace slave() function (detailed if odd)
-#define DEBUG_FFT1D             2               // trace FFT1D() function (detailed if odd)
+#define USE_DQT_BARRIER         0               // use DDT barrier if non zero
+#define MODE                    COSIN           // DATA array initialisation mode
+#define CHECK                   0               
+#define DEBUG_MAIN              1               // trace main() function (detailed if odd)
+#define DEBUG_SLAVE             0               // trace slave() function (detailed if odd)
+#define DEBUG_FFT1D             0               // trace FFT1D() function (detailed if odd)
 #define DEBUG_ROW               0               // trace FFTRow() function (detailed if odd)
 #define PRINT_ARRAY             0
@@ -138 +140 @@
 // synchronisation barrier (all threads)
 pthread_barrier_t      barrier;
-pthread_barrierattr_t  barrierattr;
+pthread_barrierattr_t  barrier_attr;
 
 // threads identifiers, attributes, and arguments 
@@ -213 +215 @@
 void main ( void )
 {
+    int                 error;
+
     unsigned int        main_cxy;          // main thread cluster
     unsigned int        main_x;            // main thread X coordinate
@@ -240 +244 @@
     if( get_config( &x_size , &y_size , &ncores ) )
     {
-        printf("\n[FFT ERROR] cannot get hardware configuration\n");
+        printf("\n[fft error] cannot get hardware configuration\n");
         exit( 0 );
     }
@@ -247 +251 @@
     if( (ncores != 1) && (ncores != 2) && (ncores != 4) )
     {
-        printf("\n[FFT ERROR] number of cores per cluster must be 1/2/4\n");
+        printf("\n[fft error] number of cores per cluster must be 1/2/4\n");
         exit( 0 );
     }
@@ -254 +258 @@
     if( (x_size != 1) && (x_size != 2) && (x_size != 4) && (x_size != 8) && (x_size != 16) )
     {
-        printf("\n[FFT ERROR] x_size must be 1/2/4/8/16\n");
+        printf("\n[fft error] x_size must be 1/2/4/8/16\n");
         exit( 0 );
     }
@@ -261 +265 @@
     if( (y_size != 1) && (y_size != 2) && (y_size != 4) && (y_size != 8) && (y_size != 16) )
     {
-        printf("\n[FFT ERROR] y_size must be 1/2/4/8/16\n");
+        printf("\n[fft error] y_size must be 1/2/4/8/16\n");
         exit( 0 );
     }
@@ -277 +281 @@
     if( rootN < nthreads )
     {
-        printf("\n[FFT ERROR] sqrt(N) must be larger than T\n");
+        printf("\n[fft error] sqrt(N) must be larger than T\n");
         exit( 0 );
     }
@@ -287 +291 @@
     main_tid = (((main_x * y_size) + main_y) * ncores) + main_lid; 
 
-    printf("\n[FFT] starts on core[%x,%d] / %d complex points / %d thread(s) / PID %x\n",
+    printf("\n[fft] starts on core[%x,%d] / %d complex points / %d thread(s) / PID %x\n",
     main_cxy, main_lid, N, nthreads, getpid() );
 
@@ -308 +312 @@
     }
 
-    printf("\n[FFT] main completes remote_malloc\n");
+    printf("\n[fft] main completes remote_malloc\n");
 
     // arrays initialisation
@@ -315 +319 @@
     InitT( twid );
 
-    printf("\n[FFT] main completes arrays init\n");
+    printf("\n[fft] main completes arrays init\n");
 
 #if CHECK 
@@ -335 +339 @@
 
     // initialise barrier
-    barrierattr.x_size   = x_size;
-    barrierattr.y_size   = y_size;
-    barrierattr.nthreads = ncores;
-    if( pthread_barrier_init( &barrier, &barrierattr , nthreads) )
-    {
-        printf("\n[FFT ERROR] cannot initialize barrier\n");
+    if( USE_DQT_BARRIER )
+    {
+        barrier_attr.x_size   = x_size;
+        barrier_attr.y_size   = y_size;
+        barrier_attr.nthreads = ncores;
+        error = pthread_barrier_init( &barrier, &barrier_attr , nthreads );
+    }
+    else
+    {
+        error = pthread_barrier_init( &barrier, NULL , nthreads );
+    }
+
+    if( error )
+    {
+        printf("\n[fft error] cannot initialize barrier\n");
         exit( 0 );
     }
 
-    printf("\n[FFT] main completes barrier init\n");
+    printf("\n[fft] main completes barrier init\n");
 
     // launch other threads to execute the slave() function
@@ -377 +390 @@
                                          &args[tid]) ) // pointer on function arguments 
                     {
-                        printf("\n[FFT ERROR] creating thread %x\n", tid );
+                        printf("\n[fft error] creating thread %x\n", tid );
                         exit( 0 );
                     }
-#if DEBUG_MAIN
+#if (DEBUG_MAIN & 1)
 unsigned long long debug_cycle; 
 get_cycle( &debug_cycle ); 
-printf("\n[FFT] main created thread %x on core[%x,%d] / cycle %d\n",
+printf("\n[fft] main created thread %d on core[%x,%d] / cycle %d\n",
 tid, cxy, lid, (unsigned int)debug_cycle );
 #endif
@@ -390 +403 @@
         }
     }
+
 
     // register sequencial initalisation completion cycle
@@ -395 +409 @@
     init_time = (unsigned int)(end_init_cycle - start_init_cycle);
 
-    printf("\n[FFT] main enters parallel execution\n");
+    printf("\n[fft] main completes threads creation\n");
     
     // main itself executes the slave() function
@@ -414 +428 @@
                     if( pthread_join( trdid[tid] , NULL ) )
                     {
-                        printf("\n[FFT ERROR] in main thread joining thread %x\n", tid );
+                        printf("\n[fft error] in main thread joining thread %x\n", tid );
                         exit( 0 );
                     }
                     
-#if DEBUG_MAIN
-printf("\n[FFT] main thread %d joined thread %d\n", main_tid, tid );
+#if (DEBUG_MAIN & 1)
+printf("\n[fft] main thread %d joined thread %d\n", main_tid, tid );
 #endif
 
@@ -441 +455 @@
 
     // instrumentation 
+    char name[64];
+    char path[128];
     char string[256];
-
-    snprintf( string , 256 , "/home/fft_%d_%d_%d_%d", x_size , y_size , ncores , N );
+    int  ret;
+
+    // build file name
+    if( USE_DQT_BARRIER )
+    snprintf( name , 64 , "fft_dqt_%d_%d_%d_%d", x_size , y_size , ncores , N );
+    else
+    snprintf( name , 64 , "fft_smp_%d_%d_%d_%d", x_size , y_size , ncores , N );
+
+    // build pathname
+    snprintf( path , 128 , "/home/%s", name );
 
     // open instrumentation file
-//  FILE * f = fopen( string , NULL );
-//  if ( f == NULL ) 
-//  { 
-//      printf("\n[FFT ERROR] cannot open instrumentation file %s\n", string );
-//      exit( 0 );
-//  }
-
-    snprintf( string , 256 , "\n[FFT] instrumentation : (%dx%dx%d) threads / %d points\n",
-    x_size, y_size, ncores , N ); 
-
-    // display on terminal, and save to instrumentation file
-    printf( "%s" , string );
-//  fprintf( f , string );
-
+    FILE * f = fopen( path , NULL );
+    if ( f == NULL ) 
+    { 
+        printf("\n[fft error] cannot open instrumentation file <%s>\n", path );
+        exit( 0 );
+    }
+    printf("\n[fft] file <%s> open\n", path );
+
+    // display header on terminal, and save to file
+    printf("\n----- %s -----\n", name );
+
+    ret = fprintf( f , "\n----- %s -----\n", name );
+    if( ret < 0 )
+    {
+        printf("\n[fft error] cannot write header to file <%s>\n", path );
+        exit(0);
+    }
+
+    // display results for each thread on terminal, and save to file
     for (tid = 0 ; tid < nthreads ; tid++) 
     {
-        snprintf( string , 256 , "\ntid %d : Init %d / Parallel %d / Sync %d\n",
+        snprintf( string , 256 , "- tid %d : Sequencial %d / Parallel %d / Barrier %d\n",
         tid, init_time, parallel_time[tid], sync_time[tid] );
 
         // display on terminal, and save to instrumentation file
         printf("%s" , string );
-//      fprintf( f , string );
-    }
-
-    // close instrumentation file and exit
-//  fclose( f );
-                             
-
-/*
-    long min_para = parallel_time[0];
-    long max_para = parallel_time[0];
-    long min_sync = sync_time[0];
-    long max_sync = sync_time[0];
+        fprintf( f , "%s" , string );
+        if( ret < 0 )
+        {
+            printf("\n[fft error] cannot write thread %d to file <%s>\n", tid, path );
+            exit(0);
+        }
+    }
+
+    // display MIN/MAX values on terminal and save to file
+    unsigned int min_para = parallel_time[0];
+    unsigned int max_para = parallel_time[0];
+    unsigned int min_sync = sync_time[0];
+    unsigned int max_sync = sync_time[0];
 
     for (tid = 1 ; tid < nthreads ; tid++) 
@@ -488 +518 @@
     }
 
-    snprintf( string , 256 , "\n      Init       Parallel   Barrier\n"
+    snprintf( string , 256 , "\n      Sequencial  Parallel       Barrier\n"
                              "MIN : %d\t | %d\t | %d\t   (cycles)\n" 
                              "MAX : %d\t | %d\t | %d\t   (cycles)\n",
                              (int)init_time, (int)min_para, (int)min_sync,
                              (int)init_time, (int)max_para, (int)max_sync );
-*/
-
-    pthread_exit( NULL );
+    printf("%s", string );
+    ret = fprintf( f , "%s", string );
+    if( ret < 0 )
+    {
+        printf("\n[fft error] cannot write MIN/MAX to file <%s>\n", path );
+        exit(0);
+    }
+
+    // close instrumentation file
+    ret = fclose( f );
+    if( ret )
+    {
+        printf("\n[fft error] cannot close file <%s>\n", path );
+        exit(0);
+    }
+    printf("\n[sort] file <%s> closed\n", path );
+
+    exit( 0 );
 
 } // end main()
@@ -525 +570 @@
 
 #if DEBUG_SLAVE
-printf("\n[FFT] %s : thread %x enter / cycle %d\n",
+printf("\n[fft] %s : thread %x enter / cycle %d\n",
 __FUNCTION__, MyNum, (unsigned int)parallel_start );
 #endif
@@ -569 +614 @@
 
 #if DEBUG_SLAVE
-printf("\n[FFT] %s : thread %x exit / parallel_time %d / sync_time %d / cycle %d\n",
-__FUNCTION__, MyNum, parallel_time[MyNum], sync_time[MyNum], (unsigned int)parallel_stop );
+printf("\n[fft] %s : thread %x exit / cycle %d\n", __FUNCTION__, MyNum, parallel_stop );
 #endif
 
@@ -805 +849 @@
 unsigned long long cycle;
 get_cycle( &cycle );
-printf("\n[FFT] %s : thread %x enter / first %d / last %d / cycle %d\n",
+printf("\n[fft] %s : thread %x enter / first %d / last %d / cycle %d\n",
 __FUNCTION__, MyNum, MyFirst, MyLast, (unsigned int)cycle );
 #endif
@@ -814 +858 @@
 #if( DEBUG_FFT1D & 1 )
 get_cycle( &cycle );
-printf("\n[FFT] %s : thread %x after first transpose / cycle %d\n",
+printf("\n[fft] %s : thread %x after first transpose / cycle %d\n",
 __FUNCTION__, MyNum, (unsigned int)cycle );
 if( PRINT_ARRAY ) PrintArray( tmp , N );
@@ -827 +871 @@
 #if( DEBUG_FFT1D & 1 )
 get_cycle( &cycle );
-printf("\n[FFT] %s : thread %x exit barrier after first transpose / cycle %d\n",
+printf("\n[fft] %s : thread %x exit barrier after first transpose / cycle %d\n",
 __FUNCTION__, MyNum, (unsigned int)cycle );
 #endif
@@ -840 +884 @@
 
 #if( DEBUG_FFT1D & 1 )
-printf("\n[FFT] %s : thread %x after first twiddle\n", __FUNCTION__, MyNum);
+printf("\n[fft] %s : thread %x after first twiddle\n", __FUNCTION__, MyNum);
 if( PRINT_ARRAY ) PrintArray( tmp , N );
 #endif
@@ -850 +894 @@
 
 #if( DEBUG_FFT1D & 1 )
-printf("\n[FFT] %s : thread %x exit barrier after first twiddle\n", __FUNCTION__, MyNum);
+printf("\n[fft] %s : thread %x exit barrier after first twiddle\n", __FUNCTION__, MyNum);
 #endif
 
@@ -859 +903 @@
 
 #if( DEBUG_FFT1D & 1 )
-printf("\n[FFT] %s : thread %x after second transpose\n", __FUNCTION__, MyNum);
+printf("\n[fft] %s : thread %x after second transpose\n", __FUNCTION__, MyNum);
 if( PRINT_ARRAY ) PrintArray( x , N );
 #endif
@@ -869 +913 @@
 
 #if( DEBUG_FFT1D & 1 )
-printf("\n[FFT] %s : thread %x exit barrier after second transpose\n", __FUNCTION__, MyNum);
+printf("\n[fft] %s : thread %x exit barrier after second transpose\n", __FUNCTION__, MyNum);
 #endif
 
@@ -882 +926 @@
 
 #if( DEBUG_FFT1D & 1 )
-printf("\n[FFT] %s : thread %x after FFT on rows\n", __FUNCTION__, MyNum);
+printf("\n[fft] %s : thread %x after FFT on rows\n", __FUNCTION__, MyNum);
 if( PRINT_ARRAY ) PrintArray( x , N );
 #endif
@@ -892 +936 @@
 
 #if( DEBUG_FFT1D & 1 )
-printf("\n[FFT] %s : thread %x exit barrier after FFT on rows\n", __FUNCTION__, MyNum);
+printf("\n[fft] %s : thread %x exit barrier after FFT on rows\n", __FUNCTION__, MyNum);
 #endif
     sync_time[MyNum] += (long)(barrier_stop - barrier_start);
@@ -900 +944 @@
 
 #if( DEBUG_FFT1D & 1 )
-printf("\n[FFT] %s : thread %x after third transpose\n", __FUNCTION__, MyNum);
+printf("\n[fft] %s : thread %x after third transpose\n", __FUNCTION__, MyNum);
 if( PRINT_ARRAY ) PrintArray( x , N );
 #endif
@@ -910 +954 @@
 
 #if( DEBUG_FFT1D & 1 )
-printf("\n[FFT] %s : thread %x exit barrier after third transpose\n", __FUNCTION__, MyNum);
+printf("\n[fft] %s : thread %x exit barrier after third transpose\n", __FUNCTION__, MyNum);
 #endif
 
@@ -920 +964 @@
 
 #if DEBUG_FFT1D
-printf("\n[FFT] %s : thread %x completed\n", __FUNCTION__, MyNum);
+printf("\n[fft] %s : thread %x completed\n", __FUNCTION__, MyNum);
 if( PRINT_ARRAY ) PrintArray( x , N );
 #endif
@@ -1111 +1155 @@
 #if DEBUG_ROW
 unsigned int p;
-printf("\n[FFT] ROW data in / %d points / offset = %d\n", rootN , offset_x );
+printf("\n[fft] ROW data in / %d points / offset = %d\n", rootN , offset_x );
 
 for ( p = 0 ; p < rootN ; p++ )
@@ -1127 +1171 @@
 
 #if DEBUG_ROW
-printf("\n[FFT] ROW data after reverse / %d points / offset = %d\n", rootN , offset_x );
+printf("\n[fft] ROW data after reverse / %d points / offset = %d\n", rootN , offset_x );
 
 for ( p = 0 ; p < rootN ; p++ )
@@ -1198 +1242 @@
 
 #if DEBUG_ROW
-printf("\n[FFT] ROW data out / %d points / offset = %d\n", rootN , offset_x );
+printf("\n[fft] ROW data out / %d points / offset = %d\n", rootN , offset_x );
 for ( p = 0 ; p < rootN ; p++ )
 {

trunk/user/ksh/ksh.c

@@ -1178 +1178 @@
 #endif
 
-/*
-// Lauch one or several commands without interactive mode 
-
-// 1. first command
+
+/* 1. first direct command
 if( sem_wait( &semaphore ) )
 {
@@ -1189 +1187 @@
 else
 {
-    printf("\n[ksh] display fat 0 32\n");
+    printf("\n[ksh] load bin/user/sort.elf\n");
 }
 
-strcpy( cmd , "display fat 0 32" );
+strcpy( cmd , "load bin/user/sort.elf" );
 execute( cmd );
-
-// 2. second command
+*/
+
+
+
+/* 2. second direct command
 if( sem_wait( &semaphore ) )
 {
@@ -1203 +1204 @@
 else
 {
-    printf("\n[ksh] load bin/user/pgcd.elf\n");
+    printf("\n[ksh] rm home/fft_1_2_1_4096\n");
 }
 
-strcpy( cmd , "load bin/user/pgcd.elf" );
+strcpy( cmd , "rm home/fft_1_2_1_4096" );
 execute( cmd );
-
-// end non-interactive mode
 */
+
+
 
         enum fsm_states 

trunk/user/sort/sort.c

@@ -29 +29 @@
 #include <hal_macros.h>
 
-#define ARRAY_LENGTH        4096       // number of items
+#define ARRAY_LENGTH        1024       // number of items
 #define MAX_THREADS         1024       // 16 * 16 * 4
 
@@ -35 +35 @@
 #define DISPLAY_ARRAY       0          // display items values before and after
 #define DEBUG_MAIN          1          // trace main function
-#define DEBUG_SORT          0          // trace sort function
+#define DEBUG_SORT          1          // trace sort function
 #define INTERACTIVE_MODE    0          // activate idbg() during instrumentation
 #define CHECK_RESULT        0          // for debug
@@ -337 +337 @@
 
 #if DEBUG_MAIN
-printf("\n[sort] main completes barrier init\n");
+if( USE_DQT_BARRIER ) printf("\n[sort] main completes DQT barrier init\n");
+else                  printf("\n[sort] main completes simple barrier init\n");
 #endif