Changeset 656 for trunk/kernel/fs

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/fs

Files:

• fatfs.c (modified) (22 diffs)
• fatfs.h (modified) (10 diffs)
• vfs.c (modified) (20 diffs)
• vfs.h (modified) (4 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.