Changeset 656 for trunk/kernel

Timestamp:

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

Author:

alain

Message:

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

Location:

trunk/kernel

Files:

• fs/fatfs.c (modified) (22 diffs)
• fs/fatfs.h (modified) (10 diffs)
• fs/vfs.c (modified) (20 diffs)
• fs/vfs.h (modified) (4 diffs)
• kernel_config.h (modified) (4 diffs)
• libk/grdxt.c (modified) (11 diffs)
• libk/grdxt.h (modified) (5 diffs)
• libk/list.h (modified) (7 diffs)
• libk/xlist.h (modified) (1 diff)
• mm/kcm.c (modified) (3 diffs)
• mm/kmem.c (modified) (12 diffs)
• mm/kmem.h (modified) (2 diffs)
• mm/mapper.c (modified) (16 diffs)
• mm/mapper.h (modified) (3 diffs)
• mm/page.h (modified) (1 diff)
• mm/ppm.c (modified) (21 diffs)
• mm/ppm.h (modified) (3 diffs)
• mm/vmm.c (modified) (29 diffs)
• mm/vmm.h (modified) (2 diffs)
• syscalls/sys_display.c (modified) (5 diffs)
• syscalls/sys_read.c (modified) (6 diffs)
• syscalls/sys_write.c (modified) (5 diffs)

trunk/kernel/fs/fatfs.c

@@ -850 +850 @@
 
 }  // end fatfs_recursive_release()
+
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// This static function access the FAT (File Allocation Table), stored in the FAT mapper,
+// and returns in <searched_cluster_id> the FATFS cluster_id for a given page of a given 
+// inode, identified by the <searched_page_id> argument, that is the page index in file
+// (i.e. the page index in file mapper). The entry point in the FAT is defined by the
+// <first_cluster_id> argument, that is the cluster_id of an already allocated cluster.
+// It can be the cluster_id of the first page of the file (always registered in the
+// fatfs_inode extension), or any page of the file whose <first_page_id> argument
+// is smaller than the searched <first_page_id> argument. 
+// This function can be called by a thread running in any cluster, as it uses remote
+// access primitives when the FAT mapper is remote.
+// The FAT mapper being a WRITE-THROUGH cache, this function updates the FAT mapper 
+// from informations stored on IOC device in case of miss when scanning the FAT mapper.
+// The searched inode mapper being a WRITE-BACK cache, this function allocates a new
+// cluster_id when the searched page exist in the inode mapper, and there is no FATFS 
+// cluster allocated yet for this page. It updates the FAT, but it does NOT copy the
+// mapper page content to the File System.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ first_page_id       : [in]  index in file mapper for an existing page.
+// @ first_cluster_id    : [in]  cluster_id for this existing page. 
+// @ searched_page_id    : [in]  index in file mapper for the searched page.
+// @ searched_cluster_id : [out] cluster_id for the searched page.
+// @ return 0 if success / return -1 if a FAT mapper miss cannot be solved,
+//                         or if a missing cluster_id cannot be allocated.
+//////////////////////////////////////////////////////////////////////////////////////////
+static error_t fatfs_get_cluster( uint32_t   first_page_id,
+                                  uint32_t   first_cluster_id,
+                                  uint32_t   searched_page_id,
+                                  uint32_t * searched_cluster_id )
+{
+    uint32_t   current_page_id;        // index of page in file mapper
+    uint32_t   current_cluster_id;     // index of cluster in FATFS
+    xptr_t     lock_xp;                // extended pointer on FAT lock
+
+assert( (searched_page_id > first_page_id) ,
+"searched_page_id must be larger than first_page_id\n");
+
+#if DEBUG_FATFS_GET_CLUSTER
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+thread_t * this  = CURRENT_THREAD;
+if( DEBUG_FATFS_GET_CLUSTER < cycle )
+printk("\n[%s] thread[%x,%x] enter / first_cluster_id %x / searched_page_id %d / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, first_cluster_id, searched_page_id, cycle );
+#endif
+
+    // get local pointer on VFS context (same in all clusters)
+    vfs_ctx_t * vfs_ctx = &fs_context[FS_TYPE_FATFS];
+
+    // get local pointer on local FATFS context
+    fatfs_ctx_t * loc_fatfs_ctx = vfs_ctx->extend;
+
+    // get extended pointer and cluster on FAT mapper
+    xptr_t fat_mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
+    cxy_t  fat_cxy        = GET_CXY( fat_mapper_xp );
+
+    // get local pointer on FATFS context in FAT cluster 
+    fatfs_ctx_t * fat_fatfs_ctx = hal_remote_lpt( XPTR( fat_cxy , &vfs_ctx->extend ) );
+
+    // build extended pointer on FAT lock in FAT cluster
+    lock_xp = XPTR( fat_cxy , &fat_fatfs_ctx->lock );
+
+    // take FAT lock in read mode
+    remote_rwlock_rd_acquire( lock_xp );
+
+    // initialize loop variables
+    current_page_id    = first_page_id;
+    current_cluster_id = first_cluster_id;
+
+    // scan FAT mapper (i.e. traverse FAT linked list)
+    // starting from first_page_id until searched_page_id 
+    // each iteration in this loop can change both
+    // the FAT page index and the slot index in FAT 
+    while( current_page_id < searched_page_id )
+    {
+        // FAT mapper page and slot indexes (1024 slots per FAT page)
+        uint32_t fat_page_index   = current_cluster_id >> 10;
+        uint32_t fat_slot_index   = current_cluster_id & 0x3FF;
+
+        // get pointer on current page descriptor in FAT mapper
+        xptr_t current_page_xp = mapper_remote_get_page( fat_mapper_xp , fat_page_index );
+
+        if( current_page_xp == XPTR_NULL )
+        {
+            printk("\n[ERROR] in %s : cannot get page %d from FAT mapper\n",
+            __FUNCTION__ , fat_page_index );
+            remote_rwlock_rd_release( lock_xp );
+            return -1;
+        }
+
+        // get pointer on buffer containing the FAT mapper page
+        xptr_t base_xp = ppm_page2base( current_page_xp );
+        uint32_t * buffer = (uint32_t *)GET_PTR( base_xp );
+
+        // get next_cluster_id from FAT slot  
+        uint32_t next_cluster_id = hal_remote_l32( XPTR( fat_cxy, &buffer[fat_slot_index] ) );
+
+        // allocate a new FAT cluster when there is no cluster
+        // allocated on device for the current page
+        if( next_cluster_id >= END_OF_CHAIN_CLUSTER_MIN ) 
+        {
+            // release the FAT lock in read mode,
+            remote_rwlock_rd_release( lock_xp );
+
+            // allocate a new cluster_id (and update both FAT mapper and FAT on device).
+            error_t error = fatfs_cluster_alloc( &next_cluster_id );
+
+            if( error )
+            {
+                printk("\n[ERROR] in %s : cannot allocate cluster on FAT32 for page %d\n",
+                __FUNCTION__ , current_page_id );
+                remote_rwlock_wr_release( lock_xp );
+                return -1;
+            }
+
+#if (DEBUG_FATFS_GET_CLUSTER & 1)
+if( DEBUG_FATFS_GET_CLUSTER < cycle )
+printk("\n[%s] allocated a new cluster_id %d in FATFS\n",
+__FUNCTION__, next_cluster_id );
+#endif
+            // take the FAT lock in read mode,
+            remote_rwlock_rd_acquire( lock_xp );
+        }
+
+#if (DEBUG_FATFS_GET_CLUSTER & 1)
+if( DEBUG_FATFS_GET_CLUSTER < cycle )
+printk("\n[%s] traverse FAT / fat_page_index %d / fat_slot_index %d / next_cluster_id %x\n",
+__FUNCTION__, fat_page_index, fat_slot_index , next_cluster_id );
+#endif
+
+        // update loop variables
+        current_cluster_id = next_cluster_id;
+        current_page_id++;
+    }
+   
+    // release FAT lock
+    remote_rwlock_rd_release( lock_xp );
+
+#if DEBUG_FATFS_GET_CLUSTER
+if( DEBUG_FATFS_GET_CLUSTER < cycle )
+printk("\n[%s] thread[%x,%x] exit / searched_cluster_id = %d\n",
+__FUNCTION__, this->process->pid, this->trdid, current_cluster_id );
+#endif
+
+    *searched_cluster_id = current_cluster_id;
+    return 0;
+
+}  // end fatfs_get_cluster()
+
+
+
 
 
@@ -904 +1056 @@
 //////////////////////////////////////////
 void fatfs_display_fat( uint32_t  page_id,
-                        uint32_t  nentries )
+                        uint32_t  min_slot,
+                        uint32_t  nb_slots )
 {
     uint32_t line;
-    uint32_t maxline;
 
     // compute number of lines to display
-    maxline = nentries >> 3;
-    if( nentries & 0x7 ) maxline++;
+    uint32_t min_line = min_slot >> 3;
+    uint32_t max_line = (min_slot + nb_slots - 1) >> 3;
 
     // get pointer on local FATFS context
@@ -917 +1069 @@
     fatfs_ctx_t * loc_fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend;
 
-    // get extended pointer on FAT mapper
-    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 pointers on FAT mapper (in FAT cluster)
+    xptr_t     mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
+    cxy_t      mapper_cxy = GET_CXY( 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 ) );
+    fatfs_ctx_t * fat_fatfs_ctx = hal_remote_lpt( XPTR( mapper_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
+    uint32_t hint = hal_remote_l32( XPTR( mapper_cxy , &fat_fatfs_ctx->free_cluster_hint ) );
+    uint32_t free = hal_remote_l32( XPTR( mapper_cxy , &fat_fatfs_ctx->free_clusters ) );
+
+    // get extended pointer on requested page descriptor in FAT mapper 
+    xptr_t page_xp = mapper_remote_get_page( mapper_xp , page_id );
+
+    // get pointers on requested page base
     xptr_t     base_xp  = ppm_page2base( page_xp );
     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++ )
-    {
-        printk("%x : %X | %X | %X | %X | %X | %X | %X | %X\n", (line<<3),
+    mapper_cxy, page_id, base, free, hint );
+
+    for( line = min_line ; line <= max_line ; line++ )
+    {
+        printk("%d : %X | %X | %X | %X | %X | %X | %X | %X\n", (line<<3),
         hal_remote_l32( base_xp + ((line<<5)      ) ),
         hal_remote_l32( base_xp + ((line<<5) + 4  ) ),
@@ -954 +1104 @@
 
 }  // end fatfs_display_fat()
-
-///////////////////////////////////////////////////////
-error_t fatfs_get_cluster( uint32_t   first_cluster_id,
-                           uint32_t   searched_page_index,
-                           uint32_t * searched_cluster_id )
-{
-    xptr_t     current_page_xp;        // pointer on current page descriptor
-    uint32_t * buffer;                 // pointer on current page (array of uint32_t)
-    uint32_t   current_page_index;     // index of current page in FAT 
-    uint32_t   current_slot_index;     // index of slot in current page
-    uint32_t   page_count_in_file;     // index of page in file (index in linked list)
-    uint32_t   next_cluster_id;        // content of current FAT slot
-    xptr_t     lock_xp;                // extended pointer on FAT lock
-
-assert( (searched_page_index > 0) ,
-"no FAT access required for first page\n");
-
-#if DEBUG_FATFS_GET_CLUSTER
-uint32_t   cycle = (uint32_t)hal_get_cycles();
-thread_t * this  = CURRENT_THREAD;
-if( DEBUG_FATFS_GET_CLUSTER < cycle )
-printk("\n[%s] thread[%x,%x] enter / first_cluster_id %d / searched_index %d / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, first_cluster_id, searched_page_index, cycle );
-#endif
-
-    // get local pointer on VFS context (same in all clusters)
-    vfs_ctx_t * vfs_ctx = &fs_context[FS_TYPE_FATFS];
-
-    // get local pointer on local FATFS context
-    fatfs_ctx_t * loc_fatfs_ctx = vfs_ctx->extend;
-
-    // get extended pointer and cluster on FAT mapper
-    xptr_t fat_mapper_xp  = loc_fatfs_ctx->fat_mapper_xp;
-    cxy_t  fat_cxy        = GET_CXY( fat_mapper_xp );
-
-    // get local pointer on FATFS context in FAT cluster 
-    fatfs_ctx_t * fat_fatfs_ctx = hal_remote_lpt( XPTR( fat_cxy , &vfs_ctx->extend ) );
-
-    // build extended pointer on FAT lock in FAT cluster
-    lock_xp = XPTR( fat_cxy , &fat_fatfs_ctx->lock );
-
-    // take FAT lock in read mode
-    remote_rwlock_rd_acquire( lock_xp );
-
-    // initialize loop variable (1024 slots per page)
-    current_page_index  = first_cluster_id >> 10;
-    current_slot_index  = first_cluster_id & 0x3FF;
-    page_count_in_file  = 0;
-    next_cluster_id     = 0xFFFFFFFF;
-
-    // scan FAT mapper (i.e. traverse FAT linked list)
-    while( page_count_in_file < searched_page_index )
-    {
-        // get pointer on current page descriptor in FAT mapper
-        current_page_xp = mapper_remote_get_page( fat_mapper_xp , current_page_index );
-
-        if( current_page_xp == XPTR_NULL )
-        {
-            printk("\n[ERROR] in %s : cannot get next page from FAT mapper\n", __FUNCTION__);
-            remote_rwlock_rd_release( lock_xp );
-            return -1;
-        }
-
-        // get pointer on buffer for current page
-        xptr_t base_xp = ppm_page2base( current_page_xp );
-        buffer = (uint32_t *)GET_PTR( base_xp );
-
-        // get FAT slot content 
-        next_cluster_id = hal_remote_l32( XPTR( fat_cxy, &buffer[current_slot_index] ) );
-
-#if (DEBUG_FATFS_GET_CLUSTER & 1)
-if( DEBUG_FATFS_GET_CLUSTER < cycle )
-printk("\n[%s] traverse FAT / current_page_index = %d\n"
-"current_slot_index = %d / next_cluster_id = %d\n",
-__FUNCTION__, current_page_index, current_slot_index , next_cluster_id );
-#endif
-        // update loop variables
-        current_page_index = next_cluster_id >> 10;
-        current_slot_index = next_cluster_id & 0x3FF;
-        page_count_in_file++;
-    }
-
-    if( next_cluster_id == 0xFFFFFFFF )
-    {
-        printk("\n[ERROR] in %s : searched_cluster_id not found in FAT\n", __FUNCTION__ );
-        remote_rwlock_rd_release( lock_xp );
-        return -1;
-    }
-   
-    // release FAT lock
-    remote_rwlock_rd_release( lock_xp );
-
-#if DEBUG_FATFS_GET_CLUSTER
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_FATFS_GET_CLUSTER < cycle )
-printk("\n[%s] thread[%x,%x] exit / searched_cluster_id = %d / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, next_cluster_id / cycle );
-#endif
-
-    *searched_cluster_id = next_cluster_id;
-    return 0;
-
-}  // end fatfs_get_cluster()
 
 
@@ -1691 +1738 @@
 // by the <mapper> argument, to find the directory entry identified by the <name> argument,
 // and return a pointer on the directory entry, described as and array of 32 bytes, and the
-// incex of this entry in the FAT32 mapper, seen as an array of 32 bytes entries.
+// index of this entry in the FAT32 mapper, seen as an array of 32 bytes entries.
 // It is called by the fatfs_new_dentry() and fatfs_update_dentry() functions.
 // It must be called by a thread running in the cluster containing the mapper.
@@ -1701 +1748 @@
 // @ return 0 if found / return 1 if not found / return -1 if mapper access error. 
 //////////////////////////////////////////////////////////////////////////////////////////////
-error_t fatfs_scan_directory( mapper_t *  mapper,
-                              char     *  name,
-                              uint8_t  ** entry,
-                              uint32_t *  index )
+static error_t fatfs_scan_directory( mapper_t *  mapper,
+                                     char     *  name,
+                                     uint8_t  ** entry,
+                                     uint32_t *  index )
 {
     // Two embedded loops to scan the directory mapper:
@@ -1725 +1772 @@
 #endif
 
-    char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracted from each directory entry
+    char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracted from directory entry
 
     char       lfn1[16];         // buffer for one partial cname
@@ -1761 +1808 @@
 #if (DEBUG_FATFS_SCAN_DIRECTORY & 0x1)
 if( DEBUG_FATFS_SCAN_DIRECTORY < cycle )
-mapper_display_page( mapper_xp , page_id , 256 );
+mapper_display_page( mapper_xp , page_xp , 256 );
 #endif
         // scan this page until end of directory, end of page, or name found
@@ -1883 +1930 @@
     error_t        error;
 
-    char           dir_name[CONFIG_VFS_MAX_NAME_LENGTH];
+    char           parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
 
 // check arguments
@@ -1900 +1947 @@
 assert( (xlist_is_empty( root_xp ) == false ), "child inode must have one parent\n");
 
-#if DEBUG_FATFS_GET_DENTRY
+#if DEBUG_FATFS_NEW_DENTRY
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
-vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , dir_name );
-if( DEBUG_FATFS_GET_DENTRY < cycle )
+vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , parent_name );
+if( DEBUG_FATFS_NEW_DENTRY < cycle )
 printk("\n[%s]  thread[%x,%x] enter for child <%s> in parent <%s> / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, name , dir_name , cycle );
+__FUNCTION__, this->process->pid, this->trdid, name , parent_name , cycle );
 #endif
 
@@ -1916 +1963 @@
 
     // return non fatal error if not found
-    if( error ) return -1;
+    if( error )
+    {
+        vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , parent_name );
+        printk("\n[ERROR] in %s : cannot find <%s> entry in <%s> directory mapper\n",
+        __FUNCTION__, name , parent_name, name );
+        return -1;
+    }
+  
 
     // get relevant infos from FAT32 directory entry
@@ -1946 +2000 @@
     if( found == false )
     { 
-        vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , dir_name );
+        vfs_inode_get_name( XPTR( local_cxy , parent_inode ) , parent_name );
         printk("\n[ERROR] in %s : cannot find <%s> directory in list of parents for <%s>\n",
-        __FUNCTION__, dir_name, name );
+        __FUNCTION__, parent_name, name );
         return -1;
     }
@@ -1962 +2016 @@
     dentry_ptr->extend = (void *)(intptr_t)index;
 
-#if DEBUG_FATFS_GET_DENTRY
+#if DEBUG_FATFS_NEW_DENTRY
 cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_FATFS_GET_DENTRY < cycle )
-printk("\n[%s]  thread[%x,%x] exit / intialised inode & dentry for <%s> in <%s> / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, name, dir_name, cycle );
+if( DEBUG_FATFS_NEW_DENTRY < cycle )
+printk("\n[%s]  thread[%x,%x] exit for <%s> in <%s> / cluster_id %x / size %d  / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, parent_name, cluster, size,  cycle );
+#endif
+
+
+#if (DEBUG_FATFS_NEW_DENTRY & 1)
+if( DEBUG_FATFS_NEW_DENTRY < cycle )
+{
+    fatfs_display_fat( 0 , 0 , 64 );
+    fatfs_display_fat( cluster >> 10 ,  (cluster & 0x3FF) , 32 );
+}
 #endif
 
@@ -1988 +2051 @@
 assert( (inode  != NULL) , "inode is NULL\n" );
 assert( (dentry != NULL) , "dentry is NULL\n" );
-assert( (size   != 0   ) , "size is 0\n" );
 
 #if DEBUG_FATFS_UPDATE_DENTRY
@@ -2013 +2075 @@
     }
 
-    // set size in FAT32 directory entry
-    fatfs_set_record( DIR_FILE_SIZE , entry , size );
-
-    // get local pointer on modified page base
-    void * base = (void *)((intptr_t)entry & (~CONFIG_PPM_PAGE_MASK)); 
-
-    // get extended pointer on modified page descriptor
-    xptr_t page_xp = ppm_base2page( XPTR( local_cxy , base ) );
-
-    // synchronously update the modified page on device
-    error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
-
-    if( error )
-    { 
-        vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
-        printk("\n[ERROR] in %s : cannot update parent directory <%s> on device\n",
-        __FUNCTION__, dir_name );
-        return -1;
+    // get current size value
+    uint32_t current_size = fatfs_get_record( DIR_FILE_SIZE , entry );
+
+    // update dentry in mapper & device only if required
+    if( size != current_size )
+    {
+        // set size field in FAT32 directory entry
+        fatfs_set_record( DIR_FILE_SIZE , entry , size );
+
+        // get pointer on modified page base
+        void * base = (void *)((intptr_t)entry & (~CONFIG_PPM_PAGE_MASK)); 
+
+        // get extended pointer on modified page descriptor
+        xptr_t page_xp = ppm_base2page( XPTR( local_cxy , base ) );
+
+        // synchronously update the modified page on device
+        error = fatfs_move_page( page_xp , IOC_SYNC_WRITE );
+
+        if( error )
+        { 
+            vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
+            printk("\n[ERROR] in %s : cannot update parent directory <%s> on device\n",
+            __FUNCTION__, dir_name );
+            return -1;
+        }
     }
 
@@ -2586 +2655 @@
     return 0;
 
-}  // end fat_cluster_alloc()
+}  // end fatfs_cluster_alloc()
 
 //////////////////////////////////////////////
@@ -2737 +2806 @@
 #endif
 
-    // get page cluster an local pointer
+    // get page cluster and local pointer
     cxy_t    page_cxy = GET_CXY( page_xp );
     page_t * page_ptr = GET_PTR( page_xp );
@@ -2754 +2823 @@
     inode_ptr  = hal_remote_lpt( XPTR( page_cxy , &mapper_ptr->inode ) );
 
+    //////////////////////////////  FAT mapper  /////////////////////////////////////////
+    if( inode_ptr == NULL )
+    {
+
 #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, GET_PTR(buffer_xp) );
-#endif
-
-    //////////////////////////////  FAT mapper
-    if( inode_ptr == NULL )
-    {
+printk("\n[%s] thread[%x,%x] enters for %s /  page %d in FAT mapper / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, dev_ioc_cmd_str(cmd_type), page_id, cycle );
+#endif
         // get lba from FATFS context and page_id 
         uint32_t      lba = fatfs_ctx->fat_begin_lba + (page_id << 3);
@@ -2778 +2846 @@
 #if DEBUG_FATFS_MOVE_PAGE
 if( DEBUG_FATFS_MOVE_PAGE < cycle )
-{
-    if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) )
-        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 FAT mapper page %d to IOC / cycle %d\n",
-        __FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
-}
-#endif
-
-    }
-    /////////////////////////  inode mapper
+printk("\n[%s] thread[%x,%x] exit / page %d in FAT mapper\n",
+__FUNCTION__, this->process->pid, this->trdid, page_id, cycle );
+#endif
+
+    }
+    /////////////////////////  inode mapper  ////////////////////////////////////////////
     else                       
     {
@@ -2795 +2857 @@
 #if DEBUG_FATFS_MOVE_PAGE
 vfs_inode_get_name( XPTR( page_cxy , inode_ptr ) , name );
-#endif
-
-        uint32_t  searched_cluster;
-        uint32_t  first_cluster;
-
-        // get first_cluster from inode extension
-        void * extend = hal_remote_lpt( XPTR( page_cxy , &inode_ptr->extend ) );
-        first_cluster = (uint32_t)(intptr_t)extend;
-
-        // compute searched_cluster
+if( DEBUG_FATFS_MOVE_PAGE < cycle )
+printk("\n[%s] thread[%x,%x] enters for %s / page %d in <%s> mapper/ cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, 
+dev_ioc_cmd_str( cmd_type ), page_id, name, cycle );
+#endif
+
+        uint32_t  searched_cluster_id;
+        uint32_t  first_cluster_id;
+
+        // get first_cluster_id from inode extension
+        void * extend    = hal_remote_lpt( XPTR( page_cxy , &inode_ptr->extend ) );
+        first_cluster_id = (uint32_t)(intptr_t)extend;
+
+        // compute searched_cluster_id
         if( page_id == 0 )            // no need to access FAT mapper
         {
             // searched cluster is first cluster
-            searched_cluster = first_cluster;
+            searched_cluster_id = first_cluster_id;
         }
         else                        // FAT mapper access required
         {
-            // access FAT mapper to get searched cluster
-            error = fatfs_get_cluster( first_cluster,
+            // scan FAT mapper to get searched_cluster_id
+            error = fatfs_get_cluster( 0,                    // first page in mapper
+                                       first_cluster_id,
                                        page_id,
-                                       &searched_cluster );
+                                       &searched_cluster_id );
             if( error )
             {
-                printk("\n[ERROR] in %s : cannot access FAT mapper\n", __FUNCTION__ );
+                printk("\n[ERROR] in %s : cannot get cluster_id\n", __FUNCTION__ );
                 return -1;
             }
@@ -2824 +2891 @@
 
         // get lba for searched_cluster
-        uint32_t lba = fatfs_lba_from_cluster( fatfs_ctx , searched_cluster );
-
-        // access IOC device
+        uint32_t lba = fatfs_lba_from_cluster( fatfs_ctx , searched_cluster_id );
+
+        // access IOC device to move 8 blocks
         error = dev_ioc_move_data( cmd_type , buffer_xp , lba , 8 );
 
@@ -2837 +2904 @@
 #if DEBUG_FATFS_MOVE_PAGE
 if( DEBUG_FATFS_MOVE_PAGE < cycle )
-{
-    if ( (cmd_type == IOC_READ) || (cmd_type == IOC_SYNC_READ) )
-    printk("\n[%s] thread[%x,%x] load page %d of <%s> / cluster_id %x / cycle %d\n",
-    __FUNCTION__, this->process->pid, this->trdid, page_id, name, searched_cluster, cycle );
-    else
-    printk("\n[%s] thread[%x,%x] sync page %d of <%s> / cluster_id %x / cycle %d\n",
-    __FUNCTION__, this->process->pid, this->trdid, page_id, name, searched_cluster, cycle );
-}
+vfs_inode_get_name( XPTR( page_cxy, inode_ptr ) , name );
+printk("\n[%s] thread[%x,%x] exit / page %d in <%s> mapper / cluster_id %x\n",
+__FUNCTION__, this->process->pid, this->trdid, page_id, name, searched_cluster_id );
 #endif
 

trunk/kernel/fs/fatfs.h

@@ -32 +32 @@
 
 
-/**************************************************************************************
+/******************************************************************************************
  * The FATFS File System implements a FAT32 read/write file system.
  *
@@ -43 +43 @@
  *    on the FAT mapper.
  * 2) The vfs_inode_t "extend" contains, for each inode,
- *    the first FAT cluster index (after cast to intptr).
+ *    the first FAT32 cluster_id (after cast to intptr).
  * 3) The vfs_dentry_t "extend" field contains, for each dentry, the entry index
- *    in the FATFS directory (32 bytes per FATFS entry).
- *************************************************************************************/
+ *    in the FATFS directory (32 bytes per FATFS directory entry).
+ *
+ * In the FAT32 File System, the File Allocation Table is is actually an array 
+ * of uint32_t slots. Each slot in this array contains the index (called cluster_id)
+ * of another slot in this array, to form one linked list for each file stored on
+ * device in the FAT32 File System. This index in the FAT array is also the index of
+ * the FATFS cluster on the device. One FATFS cluster is supposed to contain one PPM page. 
+ * For a given file, the entry point in the FAT is the cluster_id of the FATFS cluster 
+ * containing the first page of the file, but it can be any cluster_id already allocated
+ * to the file. 
+ *****************************************************************************************/
  
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -213 +222 @@
 
 /*****************************************************************************************
- * This function access the FAT (File Allocation Table), stored in the FAT mapper, and
- * returns in <searched_cluster> the FATFS cluster index for a given page of a given 
- * inode identified by the <first_cluster> and <page_id> arguments.
- * It can be called by a thread running in any cluster, as it uses remote access
- * primitives when the FAT mapper is remote.
- * The FAT is actually an array of uint32_t slots. Each slot in this array contains the 
- * index of another slot in this array, to form one linked list for each file stored on
- * device in the FATFS file system. This index in the FAT array is also the index of the
- * FATFS cluster on the device. One FATFS cluster is supposed to contain one PPM page. 
- * For a given file, the entry point in the FAT is simply the index of the FATFS cluster 
- * containing the first page of the file. The FAT mapper being a cache, this function 
- * updates the FAT mapper from informations stored on IOC device in case of miss.
- *****************************************************************************************
- * @ first_cluster       : [in]  index of first FATFS cluster allocated to the file.
- * @ page_id             : [in]  index of searched page in file.
- * @ searched_cluster    : [out] found FATFS cluster index.
- * @ return 0 if success / return -1 if a FAT mapper miss cannot be solved.
- ****************************************************************************************/
-error_t fatfs_get_cluster( uint32_t   first_cluster,
-                           uint32_t   page_id,
-                           uint32_t * searched_cluster );
-
-/*****************************************************************************************
- * This function display the content of the FATFS context copy in cluster identified
- * by the <cxy> argument.
+ * This debug 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.
  *****************************************************************************************
@@ -245 +231 @@
 
 /*****************************************************************************************
- * 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 debug function access the FAT mapper to display the current FAT state,
+ * as defined by the <page_id>, <min_slot>, and <nb_slots> arguments.
+ * It loads the missing pages from IOC to 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).
+ * @ page_id   : page index in FAT mapper (one page is 4 Kbytes = 1024 slots).
+ * @ min_slot  : first slot in page
+ * @ nb_slots  : number of slots (one slot is 4 bytes).
  ****************************************************************************************/
 void fatfs_display_fat( uint32_t  page_id,
-                        uint32_t  nb_entries );
+                        uint32_t  min_slot,
+                        uint32_t  nb_slots );
 
 
@@ -330 +319 @@
  *****************************************************************************************
  * 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.
+ * a directory entry identified by the <name> argument.  In case of success, it completes
+ * initialization the inode/dentry couple, identified by the  <child_inode_xp> argument.
+ * 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.
@@ -421 +410 @@
  * TODO : the current implementation check ALL pages in the FAT region, even if most
  * pages are empty, and not copied in mapper. It is sub-optimal.
- * - A first solution is to maintain in the FAT context two "dirty_min" and "dirty_max"
- *  variables defining the smallest/largest dirty page index in FAT mapper... 
+ * A solution is to maintain in the FAT context two "dirty_min" and "dirty_max"
+ * variables defining the smallest/largest dirty page index in FAT mapper... 
  *****************************************************************************************
  * @ return 0 if success / return -1 if failure during IOC device access.
@@ -448 +437 @@
  * in <searched_cluster> the FATFS cluster index of a free cluster.
  * It can be called by a thread running in any cluster, as it uses remote access
- * primitives when the FAT mapper is remote. It takes the queuelock stored in the FATFS
+ * primitives when the FAT mapper is remote. It takes the rwlock stored in the FATFS
  * context located in the same cluster as the FAT mapper itself, to get exclusive
  * access to the FAT. It uses and updates the <free_cluster_hint> and <free_clusters>
@@ -457 +446 @@
  * - it returns the allocated cluster index.
  *****************************************************************************************
- * @ searched_cluster    : [out] found FATFS cluster index.
+ * @ searched_cluster_id  : [out] allocated FATFS cluster index.
  * @ return 0 if success / return -1 if no more free clusters on IOC device.
  ****************************************************************************************/
-error_t fatfs_cluster_alloc( uint32_t * searched_cluster );
+error_t fatfs_cluster_alloc( uint32_t * searched_cluster_id );
 
 /*****************************************************************************************
  * This function implements the generic vfs_fs_release_inode() function for the FATFS.
-  *****************************************************************************************
+ *****************************************************************************************
+ * This function is used to remove a given file or directory from FATFS the file system.
  * 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. 
@@ -470 +460 @@
  * the clusters in reverse order of the linked list (from last to first). 
  * When the FAT mapper has been updated, it calls the fatfs_sync_fat() function to
- * synchronously update all dirty pages in the FAT mapper to the IOC device.
+ * synchronously update all modified pages in the FAT mapper to the IOC device.
  * Finally the FS-INFO sector on the IOC device is updated.
  *****************************************************************************************
@@ -485 +475 @@
  * 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 updates the FAT region 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 read/write the FAT region on IOC device.
+ * - For a regular file, it scan the FAT mapper to get the cluster_id on IOC device,
+ *   and read/write this cluster.
  * It can be called by any thread running in any cluster.
  *
  * WARNING : For the FAT mapper, the inode field in the mapper MUST be NULL, as this
- * is used to indicate that the corresponding mapper is the FAT mapper.
+ *           is used to indicate that the corresponding mapper is the FAT mapper.
+ *
+ * TODO : In this first implementation, the entry point in the FAT to get the cluster_id
+ *        is always the cluster_id of the first page, registered in the inode extension.
+ *        This can introduce a quadratic cost when trying of acessing all pages of a
+ *        big file. An optimisation would be to introduce in the inode extension two
+ *        new fields <other_page_id> & <other_cluster_id>, defining a second entry point
+ *        in the FAT.
  *****************************************************************************************
  * @ page_xp   : extended pointer on page descriptor.

trunk/kernel/fs/vfs.c

@@ -235 +235 @@
 
 #if DEBUG_VFS_INODE_CREATE
-char           name[CONFIG_VFS_MAX_NAME_LENGTH];
 uint32_t       cycle      = (uint32_t)hal_get_cycles();
 thread_t *     this       = CURRENT_THREAD;
-vfs_inode_get_name( *inode_xp , name );
 if( DEBUG_VFS_INODE_CREATE < cycle )
-printk("\n[%s] thread[%x,%x] created <%s> / inode [%x,%x] / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, name, local_cxy, inode, cycle );
+printk("\n[%s] thread[%x,%x] created inode (%x,%x) / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, local_cxy, inode, cycle );
 #endif
  
@@ -513 +511 @@
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_DENTRY_CREATE < cycle )
-printk("\n[%s] thread[%x,%x] created <%s> / dentry [%x,%x] / cycle %d\n",
+printk("\n[%s] thread[%x,%x] created dentry <%s> : (%x,%x) / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, name, local_cxy, dentry, cycle );
 #endif
@@ -777 +775 @@
 }  // end vfs_open()
 
-//////////////////////////////////////
-int vfs_user_move( bool_t   to_buffer,
-                   xptr_t   file_xp,
-                   void   * buffer,
-                   uint32_t size )
-{
-    cxy_t              file_cxy;     // remote file descriptor cluster 
-    vfs_file_t       * file_ptr;     // remote file descriptor local pointer
-    vfs_inode_type_t   inode_type;
-    uint32_t           file_offset;  // current offset in file
-    mapper_t         * mapper;
+///////////////////////////////////////////
+uint32_t vfs_user_move( bool_t   to_buffer,
+                        xptr_t   file_xp,
+                        void   * buffer,
+                        uint32_t count )
+{
+    cxy_t              file_cxy;       // remote file descriptor cluster 
+    vfs_file_t       * file_ptr;       // remote file descriptor local pointer
+    mapper_t         * mapper;         // local pointer on file mapper
+    vfs_inode_t      * inode;          // local pointer on file inode
+    vfs_inode_type_t   type;           // inode type
+    uint32_t           offset;         // current offset in file
+    uint32_t           size;           // current file size
+    uint32_t           nbytes;         // number of bytes actually transfered
     error_t            error;
 
@@ -797 +798 @@
     file_ptr  = GET_PTR( file_xp );
 
-    // get inode type from remote file descriptor
-    inode_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type   ) );
+    // get various infos from remote file descriptor 
+    type   = hal_remote_l32( XPTR( file_cxy , &file_ptr->type   ) );
+    offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
+    mapper = hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
+    inode  = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode  ) );
+    size   = hal_remote_l32( XPTR( file_cxy , &inode->size      ) );
    
 // check inode type
-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 ) );
+assert( (type == INODE_TYPE_FILE), "bad inode type" );
 
 #if DEBUG_VFS_USER_MOVE
@@ -811 +812 @@
 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 )
@@ -817 +817 @@
     if( to_buffer ) 
     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 );
+    __FUNCTION__ , this->process->pid, this->trdid, count, name, buffer, offset, cycle );
     else            
     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 );
+    __FUNCTION__ , this->process->pid, this->trdid, count, buffer, name, offset, cycle );
 }
 #endif
 
-    // move data between mapper and buffer
-    error = mapper_move_user( XPTR( file_cxy , mapper ),
-                              to_buffer,
-                              file_offset,
-                              buffer,
-                              size );
+    if( to_buffer ) // => compute the number of bytes to move and make the move
+    {
+        // compute number of bytes to move
+        if     ( size <= offset )         nbytes = 0; 
+        else if( size < offset + count )  nbytes = size - offset;
+        else                              nbytes = count;
+
+        // move data from mapper to buffer when required
+        if( nbytes > 0 )
+        {      
+            error = mapper_move_user( XPTR( file_cxy , mapper ),
+                                      to_buffer,
+                                      offset,
+                                      buffer,
+                                      nbytes );
+        }
+        else
+        {
+            error = 0;
+        }
+    }
+    else // to mapper => make the move and update the file size if required
+    {
+        nbytes = count;
+
+        // move data from buffer to mapper
+        error = mapper_move_user( XPTR( file_cxy , mapper ),
+                                  to_buffer,
+                                  offset,
+                                  buffer,
+                                  count );
+
+        // update file size in inode if required
+        if( offset + count > size ) 
+        {
+            vfs_inode_update_size( XPTR( file_cxy , inode ) , offset + count );
+        }
+    }
+        
     if( error ) 
     {
@@ -837 +870 @@
 
     // update file offset in file descriptor
-    hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->offset ) , size );
+    hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->offset ) , nbytes );
 
 #if DEBUG_VFS_USER_MOVE
@@ -844 +877 @@
 {
     if( to_buffer ) 
-    printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
-    __FUNCTION__ , this->process->pid, cycle );
+    printk("\n[%s] thread[%x,%x] exit / %d bytes moved from mapper to buffer\n",
+    __FUNCTION__ , this->process->pid, nbytes );
     else            
-    printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
-    __FUNCTION__ , this->process->pid, cycle );
+    printk("\n[%s] thread[%x,%x] exit / %d bytes moved from buffer to mapper / size %d\n",
+    __FUNCTION__ , this->process->pid, nbytes, hal_remote_l32(XPTR(file_cxy,&inode->size)) );
 }
 #endif
 
-    return size;
+    return nbytes;
 
 }  // end vfs_user_move()
@@ -2483 +2516 @@
 #endif
 
+#if ( DEBUG_VFS_LOOKUP & 1 )
+if( DEBUG_VFS_LOOKUP < cycle )
+vfs_display( root_xp );
+#endif
+
     // compute lookup flags
     create = (lookup_mode & VFS_LOOKUP_CREATE) == VFS_LOOKUP_CREATE;
@@ -2527 +2565 @@
 #endif
 
-        // search the child dentry matching name in parent inode
+        // search the child dentry matching name in parent inode XHTAB
         found = vfs_get_child( parent_xp,
                                name,
@@ -2593 +2631 @@
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s] thread[%x,%x] created missing inode for <%s> in cluster %x\n",
+printk("\n[%s] thread[%x,%x] created missing inode <%s> in cluster %x\n",
 __FUNCTION__, process->pid, this->trdid, name, child_cxy );
 #endif
@@ -2771 +2809 @@
 {
     error_t     error;
-    uint32_t    cluster;
+    uint32_t    cluster_id;
     uint32_t    child_type;
     uint32_t    child_size;
@@ -2798 +2836 @@
     vfs_inode_t  * child_ptr  = GET_PTR( child_xp );
 
-    // 1. allocate one free cluster in file system to child inode,
+    // 1. allocate one free cluster_id in file system to child inode,
     // and update the File Allocation Table in both the FAT mapper and IOC device.
     // It depends on the child inode FS type.
@@ -2804 +2842 @@
 
     error = vfs_fs_cluster_alloc( ctx->type,
-                                  &cluster );
+                                  &cluster_id );
     if ( error )
     {
-        printk("\n[ERROR] in %s : cannot find a free VFS cluster\n",
+        printk("\n[ERROR] in %s : cannot find a free VFS cluster_id\n",
         __FUNCTION__ );
         return -1;
@@ -2814 +2852 @@
 #if( DEBUG_VFS_NEW_DENTRY_INIT & 1)
 if( DEBUG_VFS_NEW_DENTRY_INIT < cycle )
-printk("\n[%s] thread[%x,%x] allocated FS cluster %x to <%s>\n",
-__FUNCTION__ , this->process->pid, this->trdid, cluster, child_name );
+printk("\n[%s] thread[%x,%x] allocated FS cluster_id %x to <%s>\n",
+__FUNCTION__ , this->process->pid, this->trdid, cluster_id, child_name );
 #endif
 
     // 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;
+    child_size = 0;
     
     hal_remote_s32( XPTR( child_cxy , &child_ptr->size )   , child_size );
-    hal_remote_spt( XPTR( child_cxy , &child_ptr->extend ) , (void*)(intptr_t)cluster );
+    hal_remote_spt( XPTR( child_cxy , &child_ptr->extend ) , (void*)(intptr_t)cluster_id );
 
     // 3. update the parent inode mapper, and 
@@ -3285 +3323 @@
 #if(DEBUG_VFS_ADD_CHILD & 1)
 if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[%s] thread[%x,%x] / dentry <%s> created (%x,%x)\n",
+printk("\n[%s] thread[%x,%x] created dentry <%s> : (%x,%x)\n",
 __FUNCTION__, this->process->pid, this->trdid, name, parent_cxy, new_dentry_ptr );
 #endif
@@ -3332 +3370 @@
 #if(DEBUG_VFS_ADD_CHILD & 1)
 if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[%s] thread[%x,%x] / inode <%s> created (%x,%x)\n",
+printk("\n[%s] thread[%x,%x] created inode <%s> : (%x,%x)\n",
 __FUNCTION__ , this->process->pid, this->trdid, name , child_cxy, new_inode_ptr );
 #endif
@@ -3345 +3383 @@
 #if(DEBUG_VFS_ADD_CHILD & 1)
 if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[%s] thread[%x,%x] link dentry(%x,%x) to child inode(%x,%x)\n",
+printk("\n[%s] thread[%x,%x] linked dentry(%x,%x) to child inode(%x,%x)\n",
 __FUNCTION__, this->process->pid, this->trdid, 
 parent_cxy, new_dentry_ptr, child_cxy, new_inode_ptr );
@@ -3357 +3395 @@
 #if(DEBUG_VFS_ADD_CHILD & 1)
 if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[%s] thread[%x,%x] link dentry(%x,%x) to parent inode(%x,%x)\n",
+printk("\n[%s] thread[%x,%x] linked dentry(%x,%x) to parent inode(%x,%x)\n",
 __FUNCTION__, this->process->pid, this->trdid, 
 parent_cxy, new_dentry_ptr, parent_cxy, parent_inode_ptr );
@@ -3814 +3852 @@
     return error;
 
-} // end vfs_fs_alloc_cluster()
+} // end vfs_fs_cluster_alloc()
 
 ////////////////////////////////////////////////

trunk/kernel/fs/vfs.h

@@ -602 +602 @@
  *    and synchronously update the IOC device).
  * 2. It set the "size", and "extend" fields in child inode descriptor.
+ *    The size is 4096 for a directory, the size is 0 for a file.
  * 3. It updates the parent directory mapper to introduce the new child,
  *    and synchronously update the IOC device.
@@ -660 +661 @@
  * account the offset in <file_xp>. The transfer direction is defined by <to_buffer>.
  * It is called by the sys_read() and sys_write() functions.
+ * - for a read, it checks the actual file size (registered in the inode descriptor),
+ *   against the (offset + count), and moves only the significant bytes.
+ * - for a write, it updates the the file size in inode descriptor if required.
+ * In case of write to the mapper, the "inode.size" field is updated as required.
  ******************************************************************************************
  * @ to_buffer : mapper -> buffer if true / buffer -> mapper if false. 
  * @ file_xp   : extended pointer on the remote file descriptor.
  * @ buffer    : user space pointer on buffer (can be physically distributed).
- * @ size      : requested number of bytes from offset.
+ * @ count     : requested number of bytes from offset.
  * @ returns number of bytes actually moved if success / -1 if error.
  *****************************************************************************************/
-int vfs_user_move( bool_t   to_buffer,
-                   xptr_t   file_xp, 
-                   void   * buffer,
-                   uint32_t size );
+uint32_t vfs_user_move( bool_t   to_buffer,
+                        xptr_t   file_xp, 
+                        void   * buffer,
+                        uint32_t count );
 
 /****************************************************************************************** 
@@ -745 +750 @@
  *    to the file, and removes these pages from the dirty list, using an RPC if required.
  * 2) It updates the file size in all parent directory mapper(s), and update the modified
- *    pages on the block device, using RPCs if required.
+ *    pages on the block device, using RPCs if required, only if the size is modified.
  * 3) All entries in the fd_array copies are directly reset by the calling thread,
  *    using remote accesses. 
@@ -895 +900 @@
  * argument to/from the IOC device from/to the mapper, as defined by the <cmd_type>.
  * Depending on the file system type, it calls the proper, FS specific function.
- * It is used in case of MISS on the mapper, or when a dirty page in the mapper must
- * be updated in the File System.
- * The mapper pointer is obtained from the page descriptor.
+ * It is used in case of MISS on the mapper (read), or when a dirty page in the mapper
+ * must be updated in the File System (write).
+ * The mapper pointer, and the page index in file are obtained from the page descriptor.
  * It can be executed by any thread running in any cluster.
  * This function does NOT take any lock.

trunk/kernel/kernel_config.h

@@ -84 +84 @@
 #define DEBUG_FATFS_RELEASE_INODE         0
 #define DEBUG_FATFS_REMOVE_DENTRY         0
+#define DEBUG_FATFS_SCAN_DIRECTORY        0
 #define DEBUG_FATFS_SYNC_FAT              0
 #define DEBUG_FATFS_SYNC_FSINFO           0
@@ -89 +90 @@
 #define DEBUG_FATFS_UPDATE_DENTRY         0
 #define DEBUG_FATFS_UPDATE_IOC            0
+
+#define DEBUG_GRDXT_INSERT                0
 
 #define DEBUG_HAL_CONTEXT_FORK            0
@@ -119 +122 @@
 #define DEBUG_MAPPER_GET_PAGE             0
 #define DEBUG_MAPPER_HANDLE_MISS          0
+#define DEBUG_MAPPER_MOVE_KERNEL          0
 #define DEBUG_MAPPER_MOVE_USER            0
-#define DEBUG_MAPPER_MOVE_KERNEL          0
 #define DEBUG_MAPPER_SYNC                 0
 
@@ -243 +246 @@
 #define DEBUG_VFS_FILE_CREATE             0
 #define DEBUG_VFS_GET_PATH                0
-#define DEBUG_VFS_INODE_CREATE            0
+#define DEBUG_VFS_INODE_CREATE            0 
 #define DEBUG_VFS_INODE_LOAD_ALL          0
 #define DEBUG_VFS_KERNEL_MOVE             0

trunk/kernel/libk/grdxt.c

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

trunk/kernel/libk/grdxt.h

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

trunk/kernel/libk/list.h

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

trunk/kernel/libk/xlist.h

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

trunk/kernel/mm/kcm.c

@@ -509 +509 @@
         {
         // get one 4 Kbytes page from remote PPM
-        page_t * page = ppm_remote_alloc_pages( kcm_cxy , 0 );
-
-            if( page == NULL )
+        xptr_t page_xp = ppm_remote_alloc_pages( kcm_cxy , 0 );
+
+            if( page_xp == XPTR_NULL )
             {
                     printk("\n[ERROR] in %s : failed to allocate page in cluster %x\n",
@@ -519 +519 @@
         }
 
-            // get remote page base address
-            xptr_t base_xp = ppm_page2base( XPTR( kcm_cxy , page ) );
+            // get extended pointer on allocated buffer
+            xptr_t base_xp = ppm_page2base( page_xp );
 
         // get local pointer on kcm_page
@@ -529 +529 @@
             hal_remote_s64( XPTR( kcm_cxy , &kcm_page->status ) , 0 );
             hal_remote_spt( XPTR( kcm_cxy , &kcm_page->kcm )    , kcm_ptr );
-            hal_remote_spt( XPTR( kcm_cxy , &kcm_page->page )   , page );
+            hal_remote_spt( XPTR( kcm_cxy , &kcm_page->page )   , GET_PTR( page_xp ) );
 
             // introduce new page in remote KCM active_list

trunk/kernel/mm/kmem.c

@@ -45 +45 @@
         flags = req->flags;
 
-    ////////////////////////////////// PPM 
+    ////////////////////// 
         if( type == KMEM_PPM )
         {
@@ -76 +76 @@
         return ptr;
         }
-    ///////////////////////////////////// KCM 
+    /////////////////////////// 
         else if( type == KMEM_KCM )
         {
@@ -102 +102 @@
         return ptr;
         }
-    //////////////////////////////////// KHM 
+    /////////////////////////// 
         else if( type == KMEM_KHM )
         {
@@ -140 +140 @@
     uint32_t type = req->type;
 
+    //////////////////////
         if( type == KMEM_PPM )
         {
@@ -146 +147 @@
         ppm_free_pages( page );
     }
+    ///////////////////////////
     else if( type == KMEM_KCM )
     {
         kcm_free( req->ptr );
         }
+    ///////////////////////////
     else if( type == KMEM_KHM )
     {
@@ -172 +175 @@
         flags = req->flags;
 
-        ///////////////////////////////// PPM
-        if( type == KMEM_PPM )
-        {
-                // allocate the number of requested pages
-                page_t * page_ptr = ppm_remote_alloc_pages( cxy , order );
-
-                if( page_ptr == NULL )
+        //////////////////////
+        if( type == KMEM_PPM )
+        {
+                // allocate the number of requested pages from remote cluster
+                xptr_t page_xp = ppm_remote_alloc_pages( cxy , order );
+
+                if( page_xp == XPTR_NULL )
                 {
                         printk("\n[ERROR] in %s : failed for PPM / order %d in cluster %x\n",
@@ -185 +188 @@
                 }
 
-        xptr_t page_xp = XPTR( cxy , page_ptr );
-
-        // get pointer on buffer from the page descriptor
+        // get extended pointer on remote buffer
         xptr_t base_xp = ppm_page2base( page_xp );
 
@@ -193 +194 @@
                 if( flags & AF_ZERO ) hal_remote_memset( base_xp , 0 , CONFIG_PPM_PAGE_SIZE );
 
-        void * ptr = GET_PTR( base_xp );
 
 #if DEBUG_KMEM_REMOTE
@@ -201 +201 @@
 printk("\n[%s] thread[%x,%x] from PPM / %d page(s) / ppn %x / cxy %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid,
-1<<order, ppm_page2ppn(XPTR(local_cxy,ptr)), cxy, cycle );
-#endif
-        return ptr;
-        }
-    /////////////////////////////////// KCM
+1<<order, ppm_page2ppn( page_xp ), cxy, cycle );
+#endif
+        return GET_PTR( base_xp );
+        }
+    ///////////////////////////
         else if( type == KMEM_KCM ) 
         {
@@ -231 +231 @@
         return ptr;
         }
-        /////////////////////////////////// KHM 
+        /////////////////////////// 
         else if( type == KMEM_KHM )                
         {
@@ -250 +250 @@
     uint32_t type = req->type;
 
+    //////////////////////
         if( type == KMEM_PPM )
         {
@@ -256 +257 @@
         ppm_remote_free_pages( cxy , page );
     }
+    ///////////////////////////
     else if( type == KMEM_KCM )
     {
         kcm_remote_free( cxy , req->ptr );
         }
+    ///////////////////////////
     else if( type == KMEM_KHM )
     {

trunk/kernel/mm/kmem.h

@@ -29 +29 @@
 
 /*************************************************************************************
- * This enum defines the three Kernel Memory Allocaror types: 
+ * This enum defines the three Kernel Memory Allocaror types 
  ************************************************************************************/
 
@@ -71 +71 @@
  * - KHM (Kernel Heap Manager) allocates physical memory buffers of M bytes,
  *       M can have any value, and req.order = M.
+ *
+ * WARNING: the physical memory allocated with a given allocator type must be
+ *          released using the same allocator type.
  *************************************************************************************
  * @ cxy   : target cluster identifier for a remote access.

trunk/kernel/mm/mapper.c

@@ -27 +27 @@
 #include <hal_special.h>
 #include <hal_uspace.h>
+#include <hal_vmm.h>
 #include <grdxt.h>
 #include <string.h>
@@ -141 +142 @@
     error_t    error;
 
+    uint32_t   inode_size;    
+    uint32_t   inode_type;
+
     thread_t * this = CURRENT_THREAD;
 
     // get target mapper cluster and local pointer
-    cxy_t      mapper_cxy = GET_CXY( mapper_xp );
-    mapper_t * mapper_ptr = GET_PTR( mapper_xp );
+    cxy_t         mapper_cxy = GET_CXY( mapper_xp );
+    mapper_t    * mapper_ptr = GET_PTR( mapper_xp );
+
+    // get inode pointer
+    vfs_inode_t * inode = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
+
+    // get inode size and type if relevant
+    if( inode != NULL )
+    {
+        inode_size = hal_remote_l32( XPTR( mapper_cxy , &inode->size ) );
+        inode_type = hal_remote_l32( XPTR( mapper_cxy , &inode->type ) );
+    }
+    else
+    {
+        inode_size = 0;
+        inode_type = 0;
+    }
 
 #if DEBUG_MAPPER_HANDLE_MISS
 uint32_t      cycle = (uint32_t)hal_get_cycles();
 char          name[CONFIG_VFS_MAX_NAME_LENGTH];
-vfs_inode_t * inode = mapper->inode;
 if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode != NULL) )
 {
-    vfs_inode_get_name( XPTR( local_cxy , inode ) , name );
-    printk("\n[%s] thread[%x,%x] enter for page %d in <%s> / cluster %x / cycle %d",
+    vfs_inode_get_name( XPTR( mapper_cxy , inode ) , name );
+    printk("\n[%s] thread[%x,%x] enter for page %d in <%s> / cxy %x / cycle %d\n",
     __FUNCTION__, this->process->pid, this->trdid, page_id, name, mapper_cxy, cycle );
-    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 / cluster %x / cycle %d",
+    printk("\n[%s] thread[%x,%x] enter for page %d in FAT / cxy %x / cycle %d\n",
     __FUNCTION__, this->process->pid, this->trdid, page_id, mapper_cxy, cycle );
-    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt), "FAT" );
+}
+#endif
+
+#if( DEBUG_MAPPER_HANDLE_MISS & 2 ) 
+if( DEBUG_MAPPER_HANDLE_MISS < cycle ) 
+{
+    if (inode != NULL) grdxt_remote_display( XPTR( mapper_cxy , &mapper_ptr->rt ) , name );
+    else               grdxt_remote_display( XPTR( mapper_cxy , &mapper_ptr->rt ) , "FAT" );
 }
 #endif
 
     // allocate one 4 Kbytes page from the remote mapper cluster
-    page_t * page_ptr = ppm_remote_alloc_pages( mapper_cxy , 0 );
+    xptr_t page_xp = ppm_remote_alloc_pages( mapper_cxy , 0 );
+    page_t * page_ptr = GET_PTR( page_xp );
                             
-    if( page_ptr == NULL )
+    if( page_xp == XPTR_NULL )
     {
         printk("\n[ERROR] in %s : thread [%x,%x] cannot allocate page in cluster %x\n",
@@ -176 +201 @@
     }
 
-    // build extended pointer on new page descriptor
-    xptr_t page_xp = XPTR( mapper_cxy , page_ptr );
-
     // initialize the page descriptor 
     page_remote_init( page_xp );
 
+    // initialize specific page descriptor fields
     hal_remote_s32( XPTR( mapper_cxy , &page_ptr->refcount ) , 1          );
     hal_remote_s32( XPTR( mapper_cxy , &page_ptr->index )    , page_id    );
@@ -200 +223 @@
     }
 
-    // launch I/O operation to load page from IOC device to mapper
-    error = vfs_fs_move_page( page_xp , IOC_SYNC_READ );
-
-    if( error )
-    {
-        printk("\n[ERROR] in %s : thread[%x,%x] cannot load page from device\n",
-        __FUNCTION__ , this->process->pid, this->trdid );
-        mapper_remote_release_page( mapper_xp , page_ptr );
-        return -1;
+    // launch I/O operation to load page from IOC device when required:
+    // - it is the FAT mapper
+    // - it is a directory mapper
+    // - it is a file mapper, and it exist data on IOC device for this page
+    if( (inode == NULL) || (inode_type == INODE_TYPE_DIR) || (inode_size > (page_id << 10) ) )
+    {
+        error = vfs_fs_move_page( page_xp , IOC_SYNC_READ );
+
+        if( error )
+        {
+            printk("\n[ERROR] in %s : thread[%x,%x] cannot load page from device\n",
+            __FUNCTION__ , this->process->pid, this->trdid );
+            mapper_remote_release_page( mapper_xp , page_ptr );
+            return -1;
+         }
     }
 
@@ -215 +244 @@
 
 #if DEBUG_MAPPER_HANDLE_MISS
-cycle = (uint32_t)hal_get_cycles();
+ppn_t ppn = ppm_page2ppn( page_xp );
 if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode != NULL) )
 {
-    printk("\n[%s] thread[%x,%x] exit for page %d in <%s> / ppn %x / cycle %d",
-    __FUNCTION__, this->process->pid, this->trdid,
-    page_id, name, ppm_page2ppn( page_xp ), cycle );
-    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt) , name );
+    printk("\n[%s] thread[%x,%x] exit for page %d in <%s> / page %x / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, name, page_ptr, ppn );
 }
 if( (DEBUG_MAPPER_HANDLE_MISS < cycle) && (inode == NULL) )
 {
-    printk("\n[%s] thread[%x,%x] exit for page %d in FAT / ppn %x / cycle %d",
-    __FUNCTION__, this->process->pid, this->trdid,
-    page_id, ppm_page2ppn( page_xp ), cycle );
-    if( DEBUG_MAPPER_HANDLE_MISS & 1 ) grdxt_display( XPTR(local_cxy,&mapper->rt ), "FAT" );
+    printk("\n[%s] thread[%x,%x] exit for page %d in FAT / page %x / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, page_ptr, ppn );
+}
+#endif
+
+#if( DEBUG_MAPPER_HANDLE_MISS & 2 ) 
+if( DEBUG_MAPPER_HANDLE_MISS < cycle ) 
+{
+    if (inode != NULL) grdxt_remote_display( XPTR( mapper_cxy , &mapper_ptr->rt ) , name );
+    else               grdxt_remote_display( XPTR( mapper_cxy , &mapper_ptr->rt ) , "FAT" );
 }
 #endif
@@ -241 +274 @@
 {
     error_t       error;
-    mapper_t    * mapper_ptr;
-    cxy_t         mapper_cxy;
-    xptr_t        lock_xp;        // extended pointer on mapper lock
-    xptr_t        page_xp;        // extended pointer on searched page descriptor
-    xptr_t        rt_xp;          // extended pointer on radix tree in mapper
 
     thread_t * this = CURRENT_THREAD;
 
     // get mapper cluster and local pointer
-    mapper_ptr = GET_PTR( mapper_xp );
-    mapper_cxy = GET_CXY( mapper_xp );
+    mapper_t * mapper_ptr = GET_PTR( mapper_xp );
+    cxy_t      mapper_cxy = GET_CXY( mapper_xp );
 
 #if DEBUG_MAPPER_GET_PAGE
@@ -270 +298 @@
 #endif
 
+#if( DEBUG_MAPPER_GET_PAGE & 2 )
+if( DEBUG_MAPPER_GET_PAGE < cycle ) 
+ppm_remote_display( local_cxy );
+#endif
+
     // check thread can yield
     thread_assert_can_yield( this , __FUNCTION__ );
 
     // build extended pointer on mapper lock and mapper rt
-    lock_xp  = XPTR( mapper_cxy , &mapper_ptr->lock );
-    rt_xp    = XPTR( mapper_cxy , &mapper_ptr->rt );
+    xptr_t lock_xp  = XPTR( mapper_cxy , &mapper_ptr->lock );
+    xptr_t rt_xp    = XPTR( mapper_cxy , &mapper_ptr->rt );
 
     // take mapper lock in READ_MODE
@@ -281 +314 @@
 
     // search page in radix tree
-    page_xp  = grdxt_remote_lookup( rt_xp , page_id );
+    xptr_t page_xp  = grdxt_remote_lookup( rt_xp , page_id );
 
     // test mapper miss 
@@ -310 +343 @@
 
 #if (DEBUG_MAPPER_GET_PAGE & 1)
-if( DEBUG_MAPPER_GET_PAGE < cycle )
-printk("\n[%s] thread[%x,%x] load missing page from FS : ppn %x\n",
-__FUNCTION__, this->process->pid, this->trdid, ppm_page2ppn(page_xp) );
+if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode != NULL) )
+{
+    printk("\n[%s] thread[%x,%x] introduced missing page in <%s> mapper / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, name, ppm_page2ppn(page_xp) );
+}
+if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode == NULL) )
+{
+    printk("\n[%s] thread[%x,%x] introduced missing page in FAT mapper / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, ppm_page2ppn(page_xp) );
+}
 #endif
         
@@ -328 +368 @@
 if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode != NULL) )
 {
-    printk("\n[%s] thread[%x,%x] exit for page %d of <%s> mapper / ppn %x / cycle %d\n",
-    __FUNCTION__, this->process->pid, this->trdid, page_id,
-    name, ppm_page2ppn(page_xp), cycle );
+    printk("\n[%s] thread[%x,%x] exit for page %d of <%s> mapper / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, name, ppm_page2ppn(page_xp) );
 }
 if( (DEBUG_MAPPER_GET_PAGE < cycle) && (inode == NULL) )
 {
-    printk("\n[%s] thread[%x,%x] exit for page %d of FAT mapper  / ppn %x / cycle %d\n",
-    __FUNCTION__, this->process->pid, this->trdid, page_id,
-    ppm_page2ppn(page_xp), cycle );
-}
+    printk("\n[%s] thread[%x,%x] exit for page %d of FAT mapper  / ppn %x\n",
+    __FUNCTION__, this->process->pid, this->trdid, page_id, ppm_page2ppn(page_xp) );
+}
+#endif
+
+#if( DEBUG_MAPPER_GET_PAGE & 2)
+if( DEBUG_MAPPER_GET_PAGE < cycle ) 
+ppm_remote_display( local_cxy );
 #endif
 
@@ -476 +519 @@
 __FUNCTION__, this->process->pid, this->trdid, page_bytes,
 local_cxy, buf_ptr, name, GET_CXY(map_xp), GET_PTR(map_xp) );
-mapper_display_page(  mapper_xp , page_id, 128 );
+mapper_display_page(  mapper_xp , page_xp , 128 );
 #endif
 
@@ -600 +643 @@
 {
     if( to_buffer )
-    printk("\n[%s] mapper <%s> page %d => buffer(%x,%x) / %d bytes\n",
+    printk("\n[%s] mapper <%s> page %d => buffer (%x,%x) / %d bytes\n",
     __FUNCTION__, name, page_id, dst_cxy, dst_ptr, page_bytes );
     else
-    printk("\n[%s] buffer(%x,%x) => mapper <%s> page %d / %d bytes\n",
+    printk("\n[%s] buffer (%x,%x) => mapper <%s> page %d / %d bytes\n",
     __FUNCTION__, src_cxy, src_ptr, name, page_id, page_bytes );
 }
@@ -617 +660 @@
 cycle  = (uint32_t)hal_get_cycles();
 if( DEBUG_MAPPER_MOVE_KERNEL < cycle )
-printk("\n[%s] thread[%x,%x] exit / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, cycle );
+printk("\n[%s] thread[%x,%x] exit / mapper <%s> / buffer (%x,%x) / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name, buffer_cxy, buffer_ptr, cycle );
 #endif
 
@@ -707 +750 @@
         if( page == NULL ) break;
 
-assert( (page->index == found_key ), "wrong page descriptor index" );
-assert( (page->order == 0),          "mapper page order must be 0" );
+assert( (page->index == found_key ), "page_index (%d) != key (%d)", page->index, found_key );
+assert( (page->order == 0), "page_order (%d] != 0", page->order );
 
         // build extended pointer on page descriptor
@@ -753 +796 @@
 }  // end mapper_sync()
 
-//////////////////////////////////////////////////
-error_t mapper_display_page( xptr_t     mapper_xp,
-                             uint32_t   page_id,
-                             uint32_t   nbytes )
-{
-    xptr_t        page_xp;        // extended pointer on page descriptor
-    xptr_t        base_xp;        // extended pointer on page base
+///////////////////////////////////////////////
+void mapper_display_page( xptr_t     mapper_xp,
+                          xptr_t     page_xp,
+                          uint32_t   nbytes )
+{
     char          buffer[4096];   // local buffer
-    uint32_t    * tabi;           // pointer on uint32_t to scan buffer
     uint32_t      line;           // line index
     uint32_t      word;           // word index
-    cxy_t         mapper_cxy;     // mapper cluster identifier
-    mapper_t    * mapper_ptr;     // mapper local pointer
-    vfs_inode_t * inode_ptr;      // inode local pointer
  
     char       name[CONFIG_VFS_MAX_NAME_LENGTH];
 
-    if( nbytes > 4096)
-    {
-        printk("\n[ERROR] in %s : nbytes (%d) cannot be larger than 4096\n",
-        __FUNCTION__, nbytes );
-        return -1;
-    }
-    
-    // get extended pointer on page descriptor
-    page_xp = mapper_remote_get_page( mapper_xp , page_id );
-
-    if( page_xp == XPTR_NULL)
-    {
-        printk("\n[ERROR] in %s : cannot access page %d in mapper\n",
-        __FUNCTION__, page_id );
-        return -1;
-    }
-
-    // get cluster and local pointer
-    mapper_cxy = GET_CXY( mapper_xp );
-    mapper_ptr = GET_PTR( mapper_xp );
+assert( (nbytes <= 4096)         , "nbytes cannot be larger than 4096");
+assert( (mapper_xp != XPTR_NULL) , "mapper_xp argument cannot be null");
+assert( (page_xp   != XPTR_NULL) , "page_xp argument cannot be null");
+
+    // get mapper cluster and local pointer
+    cxy_t      mapper_cxy = GET_CXY( mapper_xp );
+    mapper_t * mapper_ptr = GET_PTR( mapper_xp );
+
+    // get page cluster an local pointer
+    cxy_t    page_cxy = GET_CXY( page_xp );
+    page_t * page_ptr = GET_PTR( page_xp );
+
+    // get page_id and mapper from page descriptor
+    uint32_t   page_id = hal_remote_l32( XPTR( page_cxy , &page_ptr->index ) );
+    mapper_t * mapper  = hal_remote_lpt( XPTR( page_cxy , &page_ptr->mapper ) );
+
+assert( (mapper_cxy == page_cxy ) , "mapper and page must be in same cluster");
+assert( (mapper_ptr == mapper   ) , "unconsistent mapper_xp & page_xp arguments");
 
     // get inode
-    inode_ptr = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
+    vfs_inode_t * inode_ptr = hal_remote_lpt( XPTR( mapper_cxy , &mapper_ptr->inode ) );
 
     // get inode name
-    if( inode_ptr == NULL ) strcpy( name , "fat" );
+    if( inode_ptr == NULL ) strcpy( name , "FAT" );
     else  vfs_inode_get_name( XPTR( mapper_cxy , inode_ptr ) , name );
     
     // get extended pointer on page base
-    base_xp = ppm_page2base( page_xp );
+    xptr_t base_xp = ppm_page2base( page_xp );
    
     // copy remote page to local buffer
     hal_remote_memcpy( XPTR( local_cxy , buffer ) , base_xp , nbytes );
 
+    // display header
+    uint32_t * tabi = (uint32_t *)buffer;
+    printk("\n***** mapper <%s> / page_id %d / cxy %x / mapper %x / buffer %x\n",
+    name, page_id, mapper_cxy, mapper_ptr, GET_PTR( base_xp ) );
+
     // display 8 words per line
-    tabi = (uint32_t *)buffer;
-    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++ )
     {
@@ -815 +852 @@
     }
 
-    return 0;
-
-}  // end mapper_display_page
-
-
+}  // end mapper_display_page()
+
+

trunk/kernel/mm/mapper.h

@@ -62 +62 @@
  *   and the  allocated memory is only released when the mapper/inode is destroyed.
  *
- * 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 in mapper descriptor is redundant and probably unused. 
+ * TODO the "type" field in mapper descriptor is redundant and probably unused. 
  ******************************************************************************************/
 
@@ -161 +159 @@
 
 /********************************************************************************************
- * This function move data between a remote mapper, identified by the <mapper_xp> argument,
- * and a localised remote kernel buffer. It can be called by a thread running any cluster. 
+ * This function move <size> bytes from/to a remote mapper, identified by the <mapper_xp>
+ * argument, to/from a remote kernel buffer, identified by the <buffer_xp> argument.
+ * It can be called by a thread running in any cluster. 
  * If required, the data transfer is split in "fragments", where one fragment contains 
- * contiguous bytes in the same mapper page.
- * It uses a "remote_memcpy" to move a fragment to/from the kernel buffer.
- * In case of write, the dirty bit is set for all pages written in the mapper.
+ * contiguous bytes in the same mapper page. Each fragment uses a "remote_memcpy".
+ * In case of write to mapper, the dirty bit is set for all pages written in the mapper.
  *******************************************************************************************
  * @ mapper_xp    : extended pointer on mapper.
@@ -248 +246 @@
 
 /*******************************************************************************************
- * This debug function displays the content of a given page of a given mapper.
- * - the mapper is identified by the <mapper_xp> argument.
- * - the page is identified by the <page_id> argument.
- * - the number of bytes to display in page is defined by the <nbytes> argument.
+ * This debug function displays the content of a given page of a given mapper, identified
+ * by the <mapper_xp> and <page_xp> arguments.
+ * The number of bytes to display in page is defined by the <nbytes> argument.
  * The format is eigth (32 bits) words per line in hexadecimal.
  * It can be called by any thread running in any cluster.
- * In case of miss in mapper, it load the missing page from device to mapper.
  *******************************************************************************************
  * @ mapper_xp  : [in]  extended pointer on the mapper.
- * @ page_id    : [in]  page index in file.
- * @ nbytes     : [in]  value to be written.
- * @ returns 0 if success / return -1 if error.
- ******************************************************************************************/
-error_t mapper_display_page( xptr_t     mapper_xp,
-                             uint32_t   page_id,
-                             uint32_t   nbytes );
+ * @ page_xp    : [in]  extended pointer on page descriptor.
+ * @ nbytes     : [in]  number of bytes in page.
+ * @ returns 0 if success / return -1 if error.
+ ******************************************************************************************/
+void mapper_display_page( xptr_t     mapper_xp,
+                          xptr_t     page_xp,
+                          uint32_t   nbytes );
 
 

trunk/kernel/mm/page.h

@@ -49 +49 @@
  * - The remote_busylock is used to allows any remote thread to atomically
  *   test/modify the forks counter or the flags.
- * - The list entry is used to register the page in a free list or in dirty list.
- *   The refcount is used for page release to KMEM.
+ * - The list field is used to register the page in a free list, or in dirty list,
+ *   as a given page cannot be simultaneously dirty and free.
+ * - The refcount is used to release the page to the PPM.
  * NOTE: the size is 48 bytes for a 32 bits core.
  ************************************************************************************/

trunk/kernel/mm/ppm.c

@@ -151 +151 @@
         page_t   * buddy;               // searched buddy page descriptor
         uint32_t   buddy_index;         // buddy page index in page_tbl[]
-        page_t   * current;             // current (merged) page descriptor
+        page_t   * current_ptr;         // current (merged) page descriptor
         uint32_t   current_index;       // current (merged) page index in page_tbl[]
         uint32_t   current_order;       // current (merged) page order
@@ -168 +168 @@
 
     // initialise loop variables
-    current       = page;
+    current_ptr   = page;
     current_order = page->order;
         current_index = page - ppm->pages_tbl;
@@ -191 +191 @@
                 buddy->order = 0;
 
-                // compute next (merged) page index in page_tbl[]
+                // compute next values for loop variables
                 current_index &= buddy_index;
-
-        // compute next (merged) page order
         current_order++;
-
-        // compute next (merged) page descripror
-        current = pages_tbl + current_index; 
+        current_ptr = pages_tbl + current_index; 
     }
 
         // update order field for merged page descriptor 
-        current->order = current_order;
+        current_ptr->order = current_order;
 
         // insert merged page in relevant free list
-        list_add_first( &ppm->free_pages_root[current_order] , &current->list );
+        list_add_first( &ppm->free_pages_root[current_order] , &current_ptr->list );
         ppm->free_pages_nr[current_order] ++;
 
 }  // end ppm_free_pages_nolock()
-
 
 ////////////////////////////////////////////
@@ -221 +216 @@
     thread_t * this = CURRENT_THREAD;
 
+        ppm_t    * ppm = &LOCAL_CLUSTER->ppm;
+
 #if DEBUG_PPM_ALLOC_PAGES
 uint32_t cycle = (uint32_t)hal_get_cycles();
 #endif
 
-#if (DEBUG_PPM_ALLOC_PAGES & 1)
+#if DEBUG_PPM_ALLOC_PAGES 
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
 {
     printk("\n[%s] thread[%x,%x] enter for %d page(s) in cluster %x / cycle %d\n",
     __FUNCTION__, this->process->pid, this->trdid, 1<<order, local_cxy, cycle );
-    ppm_remote_display( local_cxy );
-}
-#endif
-
-        ppm_t    * ppm = &LOCAL_CLUSTER->ppm;
+    if( DEBUG_PPM_ALLOC_PAGES & 1 ) ppm_remote_display( local_cxy );
+}
+#endif
 
 // check order
@@ -316 +311 @@
     dqdt_increment_pages( local_cxy , order );
 
+    hal_fence();
+
 #if DEBUG_PPM_ALLOC_PAGES
 if( DEBUG_PPM_ALLOC_PAGES < cycle )
@@ -322 +319 @@
     __FUNCTION__, this->process->pid, this->trdid, 
     1<<order, local_cxy, ppm_page2ppn(XPTR( local_cxy , found_block )), cycle );
-    ppm_remote_display( local_cxy );
+    if( DEBUG_PPM_ALLOC_PAGES & 1 ) ppm_remote_display( local_cxy );
 }
 #endif
@@ -340 +337 @@
 #endif
 
-#if ( DEBUG_PPM_FREE_PAGES & 1 )
+#if DEBUG_PPM_FREE_PAGES 
 if( DEBUG_PPM_FREE_PAGES < cycle )
 {
@@ -346 +343 @@
     __FUNCTION__, this->process->pid, this->trdid, 
     1<<page->order, local_cxy, ppm_page2ppn(XPTR(local_cxy , page)), cycle );
-    ppm_remote_display( local_cxy );
+    if( DEBUG_PPM_FREE_PAGES & 1 ) ppm_remote_display( local_cxy );
+}
 #endif
 
@@ -362 +360 @@
     // update DQDT
     dqdt_decrement_pages( local_cxy , page->order );
+
+    hal_fence();
 
 #if DEBUG_PPM_FREE_PAGES
@@ -369 +369 @@
     __FUNCTION__, this->process->pid, this->trdid, 
     1<<page->order, local_cxy, ppm_page2ppn(XPTR(local_cxy , page)) , cycle );
-    ppm_remote_display( local_cxy );
+    if( DEBUG_PPM_FREE_PAGES & 1 ) ppm_remote_display( local_cxy );
 }
 #endif
@@ -376 +376 @@
 
 
-
-
 /////////////////////////////////////////////
-void * ppm_remote_alloc_pages( cxy_t     cxy,
+xptr_t ppm_remote_alloc_pages( cxy_t     cxy,
                                uint32_t  order )
 {
@@ -389 +387 @@
     thread_t * this  = CURRENT_THREAD;
 
+// check order
+assert( (order < CONFIG_PPM_MAX_ORDER) , "illegal order argument = %d\n" , order );
+
+    // get local pointer on PPM (same in all clusters)
+        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
+
 #if DEBUG_PPM_REMOTE_ALLOC_PAGES
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 #endif
 
-#if ( DEBUG_PPM_REMOTE_ALLOC_PAGES & 1 )
+#if DEBUG_PPM_REMOTE_ALLOC_PAGES 
 if( DEBUG_PPM_REMOTE_ALLOC_PAGES < cycle )
 {
-    printk("\n[%s] thread[%x,%x] enter for %d small page(s) in cluster %x / cycle %d\n",
+    printk("\n[%s] thread[%x,%x] enter for %d page(s) in cluster %x / cycle %d\n",
     __FUNCTION__, this->process->pid, this->trdid, 1<<order, cxy, cycle );
-    ppm_remote_display( cxy );
-}
-#endif
-
-// check order
-assert( (order < CONFIG_PPM_MAX_ORDER) , "illegal order argument = %d\n" , order );
-
-    // get local pointer on PPM (same in all clusters)
-        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
+    if( DEBUG_PPM_REMOTE_ALLOC_PAGES & 1 ) ppm_remote_display( cxy );
+}
+#endif
 
     //build extended pointer on lock protecting remote PPM
@@ -489 +487 @@
     dqdt_increment_pages( cxy , order );
 
+    hal_fence();
+
 #if DEBUG_PPM_REMOTE_ALLOC_PAGES
 if( DEBUG_PPM_REMOTE_ALLOC_PAGES < cycle )
@@ -495 +495 @@
     __FUNCTION__, this->process->pid, this->trdid, 
     1<<order, cxy, ppm_page2ppn(XPTR( cxy , found_block )), cycle );
-    ppm_remote_display( cxy );
-}
-#endif
-
-        return found_block;
+    if( DEBUG_PPM_REMOTE_ALLOC_PAGES & 1 ) ppm_remote_display( cxy );
+}
+#endif
+
+        return XPTR( cxy , found_block );
 
 }  // end ppm_remote_alloc_pages()
@@ -515 +515 @@
         uint32_t   current_order;    // current (merged) page order
 
+    // get local pointer on PPM (same in all clusters)
+        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
+
+    // get page ppn and order
+    uint32_t   order = hal_remote_l32( XPTR( page_cxy , &page_ptr->order ) );
+
 #if DEBUG_PPM_REMOTE_FREE_PAGES
 thread_t * this  = CURRENT_THREAD;
 uint32_t   cycle = (uint32_t)hal_get_cycles();
-#endif
-
-#if ( DEBUG_PPM_REMOTE_FREE_PAGES & 1 )
+ppn_t      ppn   = ppm_page2ppn( XPTR( page_cxy , page_ptr ) );
+#endif
+
+#if DEBUG_PPM_REMOTE_FREE_PAGES
 if( DEBUG_PPM_REMOTE_FREE_PAGES < cycle )
 {
     printk("\n[%s] thread[%x,%x] enter for %d page(s) in cluster %x / ppn %x / cycle %d\n",
-    __FUNCTION__, this->process->pid, this->trdid, 
-    1<<page_ptr->order, page_cxy, ppm_page2ppn(XPTR( page_cxy , page_ptr )), cycle );
-    ppm_remote_display( page_cxy );
+    __FUNCTION__, this->process->pid, this->trdid, 1<<order, page_cxy, ppn, cycle );
+    if( DEBUG_PPM_REMOTE_FREE_PAGES & 1 ) ppm_remote_display( page_cxy );
 }
 #endif
@@ -533 +539 @@
     page_xp = XPTR( page_cxy , page_ptr );
     
-    // get local pointer on PPM (same in all clusters)
-        ppm_t * ppm = &LOCAL_CLUSTER->ppm;
-
     // build extended pointer on lock protecting remote PPM
     xptr_t lock_xp = XPTR( page_cxy , &ppm->free_lock );
@@ -556 +559 @@
     // initialise loop variables
     current_ptr   = page_ptr;
-    current_order = hal_remote_l32( XPTR( page_cxy , &page_ptr->order ) );
+    current_order = order;
         current_index = page_ptr - ppm->pages_tbl;
 
@@ -582 +585 @@
         hal_remote_s32( XPTR( page_cxy , &buddy_ptr->order ) , 0 );
 
-                // compute next (merged) page index in page_tbl[]
+                // compute next values for loop variables
                 current_index &= buddy_index;
-
-        // compute next (merged) page order
         current_order++;
-
-        // compute next (merged) page descripror
         current_ptr = pages_tbl + current_index; 
 
@@ -594 +593 @@
 
         // update current (merged) page descriptor order field
-        current_ptr = pages_tbl + current_index;
     hal_remote_s32( XPTR( page_cxy , &current_ptr->order ) , current_order );
 
         // insert current (merged) page into relevant free list
-        list_remote_add_first( page_cxy , &ppm->free_pages_root[current_order] , &current_ptr->list );
+        list_remote_add_first( page_cxy, &ppm->free_pages_root[current_order], &current_ptr->list );
     hal_remote_atomic_add( XPTR( page_cxy , &ppm->free_pages_nr[current_order] ) , 1 );
 
@@ -607 +605 @@
     dqdt_decrement_pages( page_cxy , page_ptr->order );
 
+    hal_fence();
+
 #if DEBUG_PPM_REMOTE_FREE_PAGES
 if( DEBUG_PPM_REMOTE_FREE_PAGES < cycle )
 {
     printk("\n[%s] thread[%x,%x] released %d page(s) in cluster %x / ppn %x / cycle %d\n",
-    __FUNCTION__, this->process->pid, this->trdid, 
-    1<<page_ptr->order, page_cxy, ppm_page2ppn(XPTR( page_cxy , page_ptr ) ), cycle );
-    ppm_remote_display( page_cxy );
+    __FUNCTION__, this->process->pid, this->trdid, 1<<order, page_cxy, ppn, cycle );
+    if( DEBUG_PPM_REMOTE_FREE_PAGES & 1 ) ppm_remote_display( page_cxy );
 }
 #endif
@@ -658 +657 @@
         uint32_t n = hal_remote_l32( XPTR( cxy , &ppm->free_pages_nr[order] ) );
 
-        // display direct free_list[order]
-                nolock_printk("- forward  : order = %d / n = %d\t: ", order , n );
+        // display forward free_list[order]
+                nolock_printk("- forward  : order = %d / n = %d : ", order , n );
                 LIST_REMOTE_FOREACH( cxy , &ppm->free_pages_root[order] , iter )
+                {
+            page_xp = XPTR( cxy , LIST_ELEMENT( iter , page_t , list ) );
+                        nolock_printk("%x," , ppm_page2ppn( page_xp ) );
+                }
+                nolock_printk("\n");
+
+        // display backward free_list[order]
+                nolock_printk("- backward : order = %d / n = %d : ", order , n );
+                LIST_REMOTE_FOREACH_BACKWARD( cxy , &ppm->free_pages_root[order] , iter )
                 {
             page_xp = XPTR( cxy , LIST_ELEMENT( iter , page_t , list ) );

trunk/kernel/mm/ppm.h

@@ -84 +84 @@
 /*****************************************************************************************
  * This local allocator must be called by a thread running in local cluster. 
- * It allocates n contiguous physical 4 Kbytes pages from the local cluster, where 
- * n is a power of 2 defined by the <order> argument. 
+ * It allocates N contiguous physical 4 Kbytes pages from the local cluster, where 
+ * N is a power of 2 defined by the <order> argument. 
  * In normal use, it should not be called directly, as the recommended way to allocate
  * physical pages is to call the generic allocator defined in kmem.h.
@@ -116 +116 @@
 /*****************************************************************************************
  * This remote  allocator can be called by any thread running in any cluster. 
- * It allocates n contiguous physical 4 Kbytes pages from cluster identified 
- * by the <cxy> argument, where n is a power of 2 defined by the <order> argument. 
+ * It allocates N contiguous physical 4 Kbytes pages from cluster identified 
+ * by the <cxy> argument, where N is a power of 2 defined by the <order> argument. 
  * In normal use, it should not be called directly, as the recommended way to allocate
  * physical pages is to call the generic allocator defined in kmem.h.
@@ -123 +123 @@
  * @ cxy       : remote cluster identifier.
  * @ order     : ln2( number of 4 Kbytes pages)
- * @ returns a local pointer on remote page descriptor if success / XPTR_NULL if error.
- ****************************************************************************************/
-void *  ppm_remote_alloc_pages( cxy_t    cxy,
+ * @ returns an extended pointer on page descriptor if success / XPTR_NULL if error.
+ ****************************************************************************************/
+xptr_t  ppm_remote_alloc_pages( cxy_t    cxy,
                                 uint32_t order );
 

trunk/kernel/mm/vmm.c

@@ -1745 +1745 @@
 
 ////////////////////////////////////////////////////////////////////////////////////////////
-// This static function is called by the vmm_remove_vseg() and vmm_resize_vseg() functions.
-// Depending on the vseg <type>, it decrements the physical page refcount, and
-// conditionnally release to the relevant kmem the physical page identified by <ppn>.
+// This static function is called by the vmm_remove_vseg() and vmm_resize_vseg() functions
+// to update the physical page descriptor identified by the <ppn> argument. 
+// It decrements the refcount, set the dirty bit when required, and releases the physical
+// page to kmem depending on the vseg type.
+// - KERNEL : refcount decremented / not released to kmem    / dirty bit not set
+// - FILE   : refcount decremented / not released to kmem    / dirty bit set when required.
+// - CODE   : refcount decremented / released to kmem        / dirty bit not set.
+// - STAK   : refcount decremented / released to kmem        / dirty bit not set.
+// - DATA   : refcount decremented / released to kmem if ref / dirty bit not set.
+// - MMAP   : refcount decremented / released to kmem if ref / dirty bit not set.
 ////////////////////////////////////////////////////////////////////////////////////////////
 // @ process  : local pointer on process.
 // @ vseg     : local pointer on vseg.
 // @ ppn      : released pysical page index. 
+// @ dirty    : set the dirty bit in page descriptor when non zero.
 ////////////////////////////////////////////////////////////////////////////////////////////
 static void vmm_ppn_release( process_t * process,
                              vseg_t    * vseg,
-                             ppn_t       ppn )
+                             ppn_t       ppn,
+                             uint32_t    dirty )
 {
-    bool_t do_release;
+    bool_t do_kmem_release;
 
     // get vseg type
     vseg_type_t type = vseg->type;
 
-    // compute is_ref
+    // compute is_ref <=> this vseg is the reference vseg
     bool_t is_ref = (GET_CXY( process->ref_xp ) == local_cxy);
 
@@ -1774 +1783 @@
     hal_remote_atomic_add( count_xp , -1 );
 
-    // compute the do_release condition depending on vseg type
-    if( (type == VSEG_TYPE_FILE)  ||
-        (type == VSEG_TYPE_KCODE) || 
+    // compute the do_kmem_release condition depending on vseg type
+    if( (type == VSEG_TYPE_KCODE) || 
         (type == VSEG_TYPE_KDATA) || 
         (type == VSEG_TYPE_KDEV) )            
     {
-        // no physical page release for FILE and KERNEL 
-        do_release = false;
-    }
+        // no physical page release for KERNEL 
+        do_kmem_release = false;
+    }
+    else if( type == VSEG_TYPE_FILE )
+    {
+        // no physical page release for KERNEL 
+        do_kmem_release = false;
+
+        // set dirty bit if required
+        if( dirty ) ppm_page_do_dirty( page_xp );
+    }   
     else if( (type == VSEG_TYPE_CODE)  ||
              (type == VSEG_TYPE_STACK) ) 
     {
         // always release physical page for private vsegs
-        do_release = true;
+        do_kmem_release = true;
     }
     else if( (type == VSEG_TYPE_ANON)  ||
@@ -1793 +1809 @@
     {
         // release physical page if reference cluster
-        do_release = is_ref;
+        do_kmem_release = is_ref;
     }
     else if( is_ref )  // vseg_type == DATA in reference cluster
@@ -1814 +1830 @@
 
         // release physical page if forks == 0
-        do_release = (forks == 0); 
+        do_kmem_release = (forks == 0); 
     }
     else              // vseg_type == DATA not in reference cluster
     {
         // no physical page release if not in reference cluster 
-        do_release = false;
+        do_kmem_release = false;
     }
 
     // release physical page to relevant kmem when required
-    if( do_release )
-    {
-        ppm_remote_free_pages( page_cxy , page_ptr );
+    if( do_kmem_release )
+    {
+        kmem_req_t req;
+        req.type = KMEM_PPM;
+        req.ptr  = GET_PTR( ppm_ppn2base( ppn ) );
+
+        kmem_remote_free( page_cxy , &req );
 
 #if DEBUG_VMM_PPN_RELEASE
@@ -1892 +1912 @@
             hal_gpt_reset_pte( gpt_xp , vpn );
 
-            // release physical page when required
-            vmm_ppn_release( process , vseg , ppn );
+            // release physical page depending on vseg type
+            vmm_ppn_release( process , vseg , ppn , attr & GPT_DIRTY );
         }
     }
@@ -1986 +2006 @@
 
             // release physical page when required
-            vmm_ppn_release( process , vseg , ppn );
+            vmm_ppn_release( process , vseg , ppn , attr & GPT_DIRTY );
         }
     }
@@ -2008 +2028 @@
 
             // release physical page when required
-            vmm_ppn_release( process , vseg , ppn );
+            vmm_ppn_release( process , vseg , ppn , attr & GPT_DIRTY );
         }
     }
@@ -2170 +2190 @@
 // @ vseg   : local pointer on vseg.
 // @ vpn    : unmapped vpn.
-// @ return an extended pointer on the allocated page
+// @ return an extended pointer on the allocated page descriptor.
 //////////////////////////////////////////////////////////////////////////////////////
 static xptr_t vmm_page_allocate( vseg_t * vseg,
@@ -2186 +2206 @@
     xptr_t       page_xp;
     cxy_t        page_cxy;
-    page_t     * page_ptr;
     uint32_t     index;
 
@@ -2197 +2216 @@
 assert( ( type != VSEG_TYPE_FILE ) , "illegal vseg type\n" );
 
+    // compute target cluster identifier
     if( flags & VSEG_DISTRIB )    // distributed => cxy depends on vpn LSB
     {
@@ -2214 +2234 @@
 
     // allocate one small physical page from target cluster
-    page_ptr = ppm_remote_alloc_pages( page_cxy , 0 );
-
-    page_xp = XPTR( page_cxy , page_ptr );
+    kmem_req_t req;
+    req.type  = KMEM_PPM;
+    req.order = 0;
+    req.flags = AF_ZERO;
+
+    // get local pointer on page base
+    void * ptr = kmem_remote_alloc( page_cxy , &req );
+
+    // get extended pointer on page descriptor
+    page_xp = ppm_base2page( XPTR( page_cxy , ptr ) );
 
 #if DEBUG_VMM_PAGE_ALLOCATE
@@ -2245 +2272 @@
 uint32_t   cycle = (uint32_t)hal_get_cycles();
 thread_t * this  = CURRENT_THREAD;
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
-printk("\n[%s] thread[%x,%x] enter for vpn %x / type %s / page_id  %d / cycle %d\n",
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
+printk("\n[%s] thread[%x,%x] enter for vpn %x / vseg %s / page_id  %d / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, vseg_type_str(type), page_id, cycle );
+#endif
+
+#if (DEBUG_VMM_GET_ONE_PPN & 2)
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
 #endif
 
@@ -2291 +2323 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
 printk("\n[%s] thread[%x,%x] for vpn = %x / elf_offset = %x\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, elf_offset );
@@ -2305 +2337 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
 printk("\n[%s] thread[%x,%x] for vpn  %x / fully in BSS\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn );
@@ -2322 +2354 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
 printk("\n[%s] thread[%x,%x] for vpn  %x / fully in mapper\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn );
@@ -2339 +2371 @@
 
 #if (DEBUG_VMM_GET_ONE_PPN & 0x1)
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
 printk("\n[%s] thread[%x,%x] for vpn  %x / both mapper & BSS\n"
 "      %d bytes from mapper / %d bytes from BSS\n",
@@ -2365 +2397 @@
                 }
             }    
-        }  // end initialisation for CODE or DATA types   
+
+        }  // end if CODE or DATA types   
     } 
 
@@ -2372 +2405 @@
 
 #if DEBUG_VMM_GET_ONE_PPN
-cycle = (uint32_t)hal_get_cycles();
-if( (DEBUG_VMM_GET_ONE_PPN < cycle) && (vpn == 0x40b) )
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
 printk("\n[%s] thread[%x,%x] exit for vpn %x / ppn %x / cycle %d\n",
 __FUNCTION__ , this->process->pid, this->trdid , vpn , *ppn, cycle );
+#endif
+
+#if (DEBUG_VMM_GET_ONE_PPN & 2)
+if( DEBUG_VMM_GET_ONE_PPN < cycle )
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
 #endif
 
@@ -2404 +2441 @@
 
 #if DEBUG_VMM_HANDLE_PAGE_FAULT
-if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) & (vpn > 0) )
 printk("\n[%s] thread[%x,%x] enter for vpn %x / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, vpn, start_cycle );
 #endif
 
-#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 1)
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 2)
 if( (start_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
-hal_vmm_display( this->process , true );
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
 #endif
 
@@ -2504 +2541 @@
 #if (CONFIG_INSTRUMENTATION_PGFAULTS || DEBUG_VMM_HANDLE_PAGE_FAULT)
 uint32_t end_cycle = (uint32_t)hal_get_cycles();
-uint32_t cost      = end_cycle - start_cycle;
 #endif
 
@@ -2513 +2549 @@
 #endif
 
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 2)
+if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
+#endif
+
 #if CONFIG_INSTRUMENTATION_PGFAULTS 
+uint32_t cost      = end_cycle - start_cycle;
 this->info.local_pgfault_nr++;
 this->info.local_pgfault_cost += cost;
@@ -2584 +2626 @@
 #if (CONFIG_INSTRUMENTATION_PGFAULTS || DEBUG_VMM_HANDLE_PAGE_FAULT)
 uint32_t end_cycle = (uint32_t)hal_get_cycles();
-uint32_t cost      = end_cycle - start_cycle;
 #endif
 
@@ -2593 +2634 @@
 #endif
 
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 2)
+if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
+#endif
+
 #if CONFIG_INSTRUMENTATION_PGFAULTS 
+uint32_t cost      = end_cycle - start_cycle;
 this->info.false_pgfault_nr++;
 this->info.false_pgfault_cost += cost;
@@ -2651 +2698 @@
 #if (CONFIG_INSTRUMENTATION_PGFAULTS || DEBUG_VMM_HANDLE_PAGE_FAULT)
 uint32_t end_cycle = (uint32_t)hal_get_cycles();
-uint32_t cost      = end_cycle - start_cycle;
 #endif
 
@@ -2660 +2706 @@
 #endif
 
+#if (DEBUG_VMM_HANDLE_PAGE_FAULT & 2)
+if( (end_cycle > DEBUG_VMM_HANDLE_PAGE_FAULT) && (vpn > 0) )
+hal_vmm_display( XPTR( local_cxy , this->process ) , true );
+#endif
+
 #if CONFIG_INSTRUMENTATION_PGFAULTS 
+uint32_t cost      = end_cycle - start_cycle;
 this->info.global_pgfault_nr++;
 this->info.global_pgfault_cost += cost;
@@ -2676 +2728 @@
 #if (CONFIG_INSTRUMENTATION_PGFAULTS || DEBUG_VMM_HANDLE_PAGE_FAULT)
 uint32_t end_cycle = (uint32_t)hal_get_cycles();
-uint32_t cost      = end_cycle - start_cycle;
 #endif
 
@@ -2686 +2737 @@
 
 #if CONFIG_INSTRUMENTATION_PGFAULTS 
+uint32_t cost      = end_cycle - start_cycle;
 this->info.false_pgfault_nr++;
 this->info.false_pgfault_cost += cost;
@@ -2720 +2772 @@
 #endif
 
-#if ((DEBUG_VMM_HANDLE_COW & 3) == 3 )
+#if (DEBUG_VMM_HANDLE_COW & 2)
 hal_vmm_display( XPTR( local_cxy , process ) , true );
 #endif
@@ -2902 +2954 @@
 #endif
 
-#if ((DEBUG_VMM_HANDLE_COW & 3) == 3)
+#if (DEBUG_VMM_HANDLE_COW & 2)
 hal_vmm_display( XPTR( local_cxy , process ) , true );
 #endif

trunk/kernel/mm/vmm.h

@@ -312 +312 @@
 
 /*********************************************************************************************
- * This function removes from the VMM of a process descriptor identified by the <process>
- * argument the vseg identified by the <vseg> argument.  
- * It is called by the vmm_user_reset(), vmm_global_delete_vseg() and vmm_destroy() functions.
+ * This function removes from the VMM of a local process descriptor, identified by
+ * the <process> argument, the vseg identified by the <vseg> argument.  
+ * It is called by the vmm_user_reset(), vmm_global_delete_vseg(), vmm_destroy() functions.
  * It must be called by a local thread, running in the cluster containing the modified VMM.
  * Use the RPC_VMM_REMOVE_VSEG if required.
@@ -324 +324 @@
  *   . for ANON and REMOTE, the vseg is not released, but registered in local zombi_list.
  *   . for STACK the vseg is released to the local stack allocator.
- *   . for all other types, the vseg is released to the local kmem.
+ *   . for all other types, the vseg descriptor is released to the local kmem.
  * Regarding the physical pages release:
  *   . for KERNEL and FILE, the pages are not released to kmem.
- *   . for CODE and STACK, the pages are released to local kmem when they are not COW.
+ *   . for CODE and STACK, the pages are released to local kmem.
  *   . for DATA, ANON and REMOTE, the pages are released to relevant kmem only when
  *     the local cluster is the reference cluster.

trunk/kernel/syscalls/sys_display.c

@@ -300 +300 @@
             xptr_t        mapper_xp;
             mapper_t    * mapper_ptr;
+            xptr_t        page_xp;
 
             char          kbuf[CONFIG_VFS_MAX_PATH_LENGTH];
@@ -315 +316 @@
  __FUNCTION__ );
 #endif
-                this->errno = ENFILE;
-                return -1;
-            }
-
+                this->errno = EINVAL;
+                return -1;
+            }
+
+            // check nbytes
+            if( nbytes >= 4096 )
+            {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s for MAPPER : nbytes cannot be larger than 4096\n",
+ __FUNCTION__ );
+#endif
+                this->errno = EINVAL;
+                return -1;
+            }
+            
             // copy pathname in kernel space
             hal_strcpy_from_uspace( XPTR( local_cxy , kbuf ),
@@ -366 +379 @@
             mapper_xp  = XPTR( inode_cxy , mapper_ptr );
 
-            // display mapper
-            error = mapper_display_page( mapper_xp , page_id , nbytes );
-
-            if( error )
+            // get extended pointer on target page
+            page_xp = mapper_remote_get_page( mapper_xp , page_id );
+
+            if( page_xp == XPTR_NULL )
                 {
 
 #if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s for MAPPER : cannot display page %d\n",
+printk("\n[ERROR] in %s for MAPPER : cannot get page %d\n",
 __FUNCTION__ , page_id );
 #endif
@@ -379 +392 @@
                         return -1;
                 }
+
+            // display mapper
+            mapper_display_page( mapper_xp , page_xp , nbytes );
+
 
             break;
@@ -463 +480 @@
                 uint32_t page = (uint32_t)arg0;
 
-                fatfs_display_fat( page , entries );
+                fatfs_display_fat( page , 0 , entries );
             }
 

trunk/kernel/syscalls/sys_read.c

@@ -63 +63 @@
     cxy_t         file_cxy;        // remote file cluster identifier
     uint32_t      file_type;       // file type
-    uint32_t      file_attr;       // file_attribute
+    uint32_t      file_offset;     // file offset 
+    uint32_t      file_attr;       // file attributes
+    vfs_inode_t * inode_ptr;       // local pointer on file inode
     uint32_t      nbytes;          // number of bytes actually read
     reg_t         save_sr;         // required to enable IRQs during syscall
@@ -129 +131 @@
     file_cxy = GET_CXY( file_xp );
 
-    // get file type and attributes 
-    file_type   = hal_remote_l32( XPTR( file_cxy , &file_ptr->type ) );
-    file_attr   = hal_remote_l32( XPTR( file_cxy , &file_ptr->attr ) );
+    // get inode, file type, offset and attributes 
+    inode_ptr   = hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode  ) );
+    file_type   = hal_remote_l32( XPTR( file_cxy , &file_ptr->type   ) );
+    file_offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
+    file_attr   = hal_remote_l32( XPTR( file_cxy , &file_ptr->attr   ) );
 
     // enable IRQs
     hal_enable_irq( &save_sr );
 
-    // action depend on file type
+    // action depend on file type:
+
     if( file_type == INODE_TYPE_FILE )      // read from file mapper 
     {
@@ -152 +157 @@
             }
 
-        // move count bytes from mapper
+        // try to move count bytes from mapper
         nbytes = vfs_user_move( true,               // from mapper to buffer
                                 file_xp,
                                 vaddr, 
                                 count );
-        if( nbytes != count )
-        {
-
-#if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : thread[%x,‰x] cannot read %d bytes from file %d\n",
-__FUNCTION__, process->pid, this->trdid, count, file_id );
-#endif
-            this->errno = EIO;
-            hal_restore_irq( save_sr );
-            return -1;
-        }
     }
     else if( file_type == INODE_TYPE_DEV )  // read from TXT device
@@ -184 +178 @@
             txt_owner_xp  = hal_remote_l64( XPTR( chdev_cxy , &chdev_ptr->ext.txt.owner_xp ) );
 
-            // check TXT_RX ownership
+            // wait for TXT_RX ownership
             if ( process_owner_xp != txt_owner_xp )
             {
@@ -202 +196 @@
         }
 
-        // move count bytes from device
+        // try to move count bytes from TXT device
         nbytes = devfs_user_move( true,             // from device to buffer
                                   file_xp,
                                   vaddr,
                                   count );
-        if( nbytes != count )
-        {
-
-#if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : thread[%x,‰x] cannot read data from file %d\n",
-__FUNCTION__, process->pid, this->trdid, file_id );
-#endif
-            this->errno = EIO;
-            hal_restore_irq( save_sr );
-            return -1;
-        }
     }
     else    // not FILE and not DEV
@@ -229 +212 @@
         hal_restore_irq( save_sr );
                 return -1;
+    }
+
+    // check error
+    if( nbytes == 0xFFFFFFFF )
+    {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : thread[%x,‰x] cannot read data from file %d\n",
+__FUNCTION__, process->pid, this->trdid, file_id );
+#endif
+        this->errno = EIO;
+        hal_restore_irq( save_sr );
+        return -1;
     }
 

trunk/kernel/syscalls/sys_write.c

@@ -62 +62 @@
     cxy_t         file_cxy;        // remote file cluster identifier
     uint32_t      file_type;       // file type
-    uint32_t      file_offset;     // current file offset
-    uint32_t      file_attr;       // file_attribute
+    uint32_t      file_offset;     // file offset
+    uint32_t      file_attr;       // file attributes
     vfs_inode_t * inode_ptr;       // local pointer on associated inode
     uint32_t      nbytes;          // number of bytes actually written
@@ -138 +138 @@
     hal_enable_irq( &save_sr );
 
-    // action depend on file type
+    // action depend on file type:
+
     if( file_type == INODE_TYPE_FILE )  // write to a file mapper 
     {
@@ -159 +160 @@
                                 vaddr, 
                                 count );
-        if ( nbytes != count )
-        {
-
-#if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : thread[%x,%x] cannot write %d bytes into file %d\n",
-__FUNCTION__ , process->pid, this->trdid, count, file_id );
-#endif
-            hal_restore_irq( save_sr );
-            this->errno = EIO;
-            return -1;
-
-        }
-
-        // update file size in inode descriptor
-        // only if (file_offset + count) > current_size
-        // note: the parent directory entry in mapper will
-        // be updated by the close syscall      
-        xptr_t inode_xp = XPTR( file_cxy , inode_ptr );
-        vfs_inode_update_size( inode_xp , file_offset + count );
     }
     else if( file_type == INODE_TYPE_DEV )  // write to TXT device
@@ -186 +168 @@
                                   vaddr,
                                   count );
-        if( nbytes != count )
-        {
+    }
+    else  // not FILE and not DEV
+    {
+
+#if DEBUG_SYSCALLS_ERROR
+printk("\n[ERROR] in %s : thread[%x,%x] / illegal inode type %\n",
+__FUNCTION__, vfs_inode_type_str( file_type ) );
+#endif
+        hal_restore_irq( save_sr );
+                this->errno = EBADFD;
+                return -1;
+    }
+
+    // chek error
+    if( nbytes == 0xFFFFFFFF )
+    {
 
 #if DEBUG_SYSCALLS_ERROR
@@ -193 +189 @@
 __FUNCTION__ , process->pid, this->trdid, file_id );
 #endif
-            hal_restore_irq( save_sr );
-            this->errno = EIO;
-            return -1;
-        }
-    }
-    else  // not FILE and not DEV
-    {
-
-#if DEBUG_SYSCALLS_ERROR
-printk("\n[ERROR] in %s : thread[%x,%x] / illegal inode type %\n",
-__FUNCTION__, vfs_inode_type_str( file_type ) );
-#endif
         hal_restore_irq( save_sr );
-                this->errno = EBADFD;
-                return -1;
+        this->errno = EIO;
+        return -1;
     }