Changeset 407 for trunk/kernel/fs

Timestamp:

Nov 7, 2017, 3:08:12 PM (7 years ago)

Author:

alain

Message:

First implementation of fork/exec.

Location:

trunk/kernel/fs

Files:

• . (moved) (moved from trunk/kernel/vfs)
• devfs.c (copied) (copied from trunk/kernel/vfs/devfs.c) (17 diffs)
• devfs.h (modified) (2 diffs)
• fatfs.c (copied) (copied from trunk/kernel/vfs/fatfs.c) (18 diffs)
• fatfs.h (copied) (copied from trunk/kernel/vfs/fatfs.h)
• vfs.c (copied) (copied from trunk/kernel/vfs/vfs.c) (37 diffs)
• vfs.h (modified) (14 diffs)

trunk/kernel/fs/devfs.c

@@ -25 +25 @@
 #include <hal_types.h>
 #include <hal_special.h>
+#include <hal_uspace.h>
 #include <printk.h>
 #include <chdev.h>
+#include <dev_txt.h>
 #include <cluster.h>
 #include <vfs.h>
@@ -39 +41 @@
 extern chdev_directory_t    chdev_dir;      // allocated in kernel_init.c
 
+#if CONFIG_READ_DEBUG
+extern uint32_t  enter_devfs_move;
+extern uint32_t  exit_devfs_move;
+#endif
+
 ///////////////////////////////
 devfs_ctx_t * devfs_ctx_alloc()
@@ -79 +86 @@
     error_t  error;
 
-    devfs_dmsg("\n[DMSG] %s : enter in cluster %x\n",
+    devfs_dmsg("\n[DBG] %s : enter in cluster %x\n",
                __FUNCTION__ , local_cxy );
 
@@ -93 +100 @@
     assert( (error == 0) , __FUNCTION__ , "cannot create <dev>\n" );
 
-    devfs_dmsg("\n[DMSG] %s : <dev> created in cluster %x\n",
+    devfs_dmsg("\n[DBG] %s : <dev> created in cluster %x\n",
                __FUNCTION__ , local_cxy );
 
@@ -107 +114 @@
     assert( (error == 0) , __FUNCTION__ , "cannot create <external>\n" );
 
-    devfs_dmsg("\n[DMSG] %s : <external> created in cluster %x\n",
+    devfs_dmsg("\n[DBG] %s : <external> created in cluster %x\n",
                __FUNCTION__ , local_cxy );
 } 
@@ -119 +126 @@
     xptr_t        chdev_xp;
     cxy_t         chdev_cxy;
+    chdev_t     * chdev_ptr;
     xptr_t        inode_xp;
     uint32_t      channel;
@@ -132 +140 @@
                              devfs_internal_inode_xp );
 
+devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
+__FUNCTION__ , node_name , local_cxy );
+
     // create MMC chdev inode
-    chdev_xp = chdev_dir.mmc[local_cxy];
+    chdev_xp  = chdev_dir.mmc[local_cxy];
     if( chdev_xp != XPTR_NULL)
     {
+        chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
         vfs_add_child_in_parent( local_cxy,
                                  INODE_TYPE_DEV,
                                  FS_TYPE_DEVFS,
                                  *devfs_internal_inode_xp,
-                                 "mmc",
+                                 chdev_ptr->name,
                                  GET_PTR( chdev_xp ),
                                  &inode_xp );
+
+devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
+__FUNCTION__ , chdev_ptr->name , local_cxy );
+
     }
 
@@ -151 +167 @@
         if( chdev_xp != XPTR_NULL)
         {
-            snprintf( node_name , 16 , "dma_%d" , channel );
+            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
             vfs_add_child_in_parent( local_cxy,
                                      INODE_TYPE_DEV,
                                      FS_TYPE_DEVFS,
                                      *devfs_internal_inode_xp,
-                                     node_name,
+                                     chdev_ptr->name,
                                      GET_PTR( chdev_xp ),
                                      &inode_xp );
+
+devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
+__FUNCTION__ , chdev_ptr->name , local_cxy );
+
         }
     }
@@ -167 +187 @@
     {
         chdev_cxy = GET_CXY( chdev_xp );
+        chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
         if( chdev_cxy == local_cxy )
         {
@@ -173 +194 @@
                                      FS_TYPE_DEVFS,
                                      devfs_external_inode_xp,
-                                     "iob",
+                                     chdev_ptr->name,
                                      GET_PTR( chdev_xp ),
                                      &inode_xp );
+
+devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
+__FUNCTION__ , chdev_ptr->name , local_cxy );
+
         }
     }
@@ -184 +209 @@
     {
         chdev_cxy = GET_CXY( chdev_xp );
+        chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
         if( chdev_cxy == local_cxy )
         {
@@ -190 +216 @@
                                      FS_TYPE_DEVFS,
                                      devfs_external_inode_xp,
-                                     "pic",
+                                     chdev_ptr->name,
                                      GET_PTR( chdev_xp ),
                                      &inode_xp );
-        }
-    }
-
-    // create a TXT inode in each cluster containing a TXT chdev
+
+devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
+__FUNCTION__ , chdev_ptr->name , local_cxy );
+
+        }
+    }
+
+    // create a TXT_RX inode in each cluster containing a TXT_RX chdev
     for( channel = 0 ; channel < CONFIG_MAX_TXT_CHANNELS ; channel++ )
     {
-        chdev_xp = chdev_dir.txt[channel];
-        if( chdev_xp != XPTR_NULL )
-        {
-            chdev_cxy = GET_CXY( chdev_xp );
-            if( chdev_cxy == local_cxy )
-            {
-                snprintf( node_name , 16 , "txt_%d" , channel );
-                vfs_add_child_in_parent( local_cxy,
-                                         INODE_TYPE_DEV,
-                                         FS_TYPE_DEVFS,
-                                         devfs_external_inode_xp,
-                                         node_name,
-                                         GET_PTR( chdev_xp ),
-                                         &inode_xp );
+        chdev_xp = chdev_dir.txt_rx[channel];
+        if( chdev_xp != XPTR_NULL )
+        {
+            chdev_cxy = GET_CXY( chdev_xp );
+            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+            if( chdev_cxy == local_cxy )
+            {
+                vfs_add_child_in_parent( local_cxy,
+                                         INODE_TYPE_DEV,
+                                         FS_TYPE_DEVFS,
+                                         devfs_external_inode_xp,
+                                         chdev_ptr->name,
+                                         GET_PTR( chdev_xp ),
+                                         &inode_xp );
+
+devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
+__FUNCTION__ , chdev_ptr->name , local_cxy );
+
+            }
+        }
+    }
+
+    // create a TXT_TX inode in each cluster containing a TXT_TX chdev
+    for( channel = 0 ; channel < CONFIG_MAX_TXT_CHANNELS ; channel++ )
+    {
+        chdev_xp = chdev_dir.txt_tx[channel];
+        if( chdev_xp != XPTR_NULL )
+        {
+            chdev_cxy = GET_CXY( chdev_xp );
+            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+            if( chdev_cxy == local_cxy )
+            {
+                vfs_add_child_in_parent( local_cxy,
+                                         INODE_TYPE_DEV,
+                                         FS_TYPE_DEVFS,
+                                         devfs_external_inode_xp,
+                                         chdev_ptr->name,
+                                         GET_PTR( chdev_xp ),
+                                         &inode_xp );
+
+devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
+__FUNCTION__ , chdev_ptr->name , local_cxy );
+
             }
         }
@@ -224 +283 @@
         {
             chdev_cxy = GET_CXY( chdev_xp );
-            if( chdev_cxy == local_cxy )
-            {
-                snprintf( node_name , 16 , "ioc_%d" , channel );
-                vfs_add_child_in_parent( local_cxy,
-                                         INODE_TYPE_DEV,
-                                         FS_TYPE_DEVFS,
-                                         devfs_external_inode_xp,
-                                         node_name,
-                                         GET_PTR( chdev_xp ),
-                                         &inode_xp );
+            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+            if( chdev_cxy == local_cxy )
+            {
+                vfs_add_child_in_parent( local_cxy,
+                                         INODE_TYPE_DEV,
+                                         FS_TYPE_DEVFS,
+                                         devfs_external_inode_xp,
+                                         chdev_ptr->name,
+                                         GET_PTR( chdev_xp ),
+                                         &inode_xp );
+
+devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
+__FUNCTION__ , chdev_ptr->name , local_cxy );
+
             }
         }
@@ -245 +308 @@
         {
             chdev_cxy = GET_CXY( chdev_xp );
-            if( chdev_cxy == local_cxy )
-            {
-                snprintf( node_name , 16 , "fbf_%d" , channel );
-                vfs_add_child_in_parent( local_cxy,
-                                         INODE_TYPE_DEV,
-                                         FS_TYPE_DEVFS,
-                                         devfs_external_inode_xp,
-                                         node_name,
-                                         GET_PTR( chdev_xp ),
-                                         &inode_xp );
+            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+            if( chdev_cxy == local_cxy )
+            {
+                vfs_add_child_in_parent( local_cxy,
+                                         INODE_TYPE_DEV,
+                                         FS_TYPE_DEVFS,
+                                         devfs_external_inode_xp,
+                                         chdev_ptr->name,
+                                         GET_PTR( chdev_xp ),
+                                         &inode_xp );
+
+devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
+__FUNCTION__ , chdev_ptr->name , local_cxy );
+
             }
         }
@@ -266 +333 @@
         {
             chdev_cxy = GET_CXY( chdev_xp );
-            if( chdev_cxy == local_cxy )
-            {
-                snprintf( node_name , 16 , "nic_rx_%d" , channel );
-                vfs_add_child_in_parent( local_cxy,
-                                         INODE_TYPE_DEV,
-                                         FS_TYPE_DEVFS,
-                                         devfs_external_inode_xp,
-                                         node_name,
-                                         GET_PTR( chdev_xp ),
-                                         &inode_xp );
+            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+            if( chdev_cxy == local_cxy )
+            {
+                vfs_add_child_in_parent( local_cxy,
+                                         INODE_TYPE_DEV,
+                                         FS_TYPE_DEVFS,
+                                         devfs_external_inode_xp,
+                                         chdev_ptr->name,
+                                         GET_PTR( chdev_xp ),
+                                         &inode_xp );
+
+devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
+__FUNCTION__ , chdev_ptr->name , local_cxy );
+
             }
         }
@@ -287 +358 @@
         {
             chdev_cxy = GET_CXY( chdev_xp );
-            if( chdev_cxy == local_cxy )
-            {
-                snprintf( node_name , 16 , "nic_tx_%d" , channel );
-                vfs_add_child_in_parent( local_cxy,
-                                         INODE_TYPE_DEV,
-                                         FS_TYPE_DEVFS,
-                                         devfs_external_inode_xp,
-                                         node_name,
-                                         GET_PTR( chdev_xp ),
-                                         &inode_xp );
+            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+            if( chdev_cxy == local_cxy )
+            {
+                vfs_add_child_in_parent( local_cxy,
+                                         INODE_TYPE_DEV,
+                                         FS_TYPE_DEVFS,
+                                         devfs_external_inode_xp,
+                                         chdev_ptr->name,
+                                         GET_PTR( chdev_xp ),
+                                         &inode_xp );
+
+devfs_dmsg("\n[DBG] %s : created <%s> inode in cluster %x\n",
+__FUNCTION__ , chdev_ptr->name , local_cxy );
+
             }
         }
@@ -302 +377 @@
 }  // end devfs_local_init()
 
+//////////////////////////////////////////
+int devfs_user_move( bool_t     to_buffer,
+                     xptr_t     file_xp,
+                     void     * u_buf,
+                     uint32_t   size )
+{
+    assert( ( file_xp != XPTR_NULL ) , __FUNCTION__ , "file_xp == XPTR_NULL" );
+
+    assert( ( size < CONFIG_TXT_KBUF_SIZE ) , __FUNCTION__ , "string size too large" );
+
+    cxy_t              file_cxy;     // remote file descriptor cluster 
+    vfs_file_t       * file_ptr;     // remote file descriptor local pointer
+    vfs_inode_type_t   inode_type;   // associated inode type
+    vfs_inode_t      * inode_ptr;    // associated inode local pointer
+    chdev_t          * chdev_ptr;    // associated chdev type
+    uint32_t           func;         // chdev functionnal type
+    uint32_t           channel;      // chdev channel index
+    error_t            error;
+
+    char               k_buf[CONFIG_TXT_KBUF_SIZE];  // local kernel buffer
+
+devfs_dmsg("\n[DBG] %s enter / cycle %d\n", 
+__FUNCTION__ , hal_time_stamp() );
+
+#if CONFIG_READ_DEBUG
+enter_devfs_move = hal_time_stamp();
+#endif
+
+    // get cluster and local pointer on remote file descriptor
+    // associated inode and chdev are stored in same cluster as the file desc.
+    file_cxy  = GET_CXY( file_xp );
+    file_ptr  = (vfs_file_t *)GET_PTR( file_xp );
+
+    // get inode type from remote file descriptor
+    inode_type = hal_remote_lw( XPTR( file_cxy , &file_ptr->type ) );
+    inode_ptr  = (vfs_inode_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
+
+    assert( (inode_type == INODE_TYPE_DEV) , __FUNCTION__ ,
+    "inode type is not INODE_TYPE_DEV" );
+
+    // get chdev local pointer from remote inode extension
+    chdev_ptr = (chdev_t *)hal_remote_lpt( XPTR( file_cxy , &inode_ptr->extend ) );
+ 
+    // get chdev functionnal type and channel
+    func    = hal_remote_lw( XPTR( file_cxy , &chdev_ptr->func ) );
+    channel = hal_remote_lw( XPTR( file_cxy , &chdev_ptr->channel ) );
+
+    // action depends on "func" and "to_buffer" 
+    if( func == DEV_FUNC_TXT )
+    {
+        if( to_buffer )     // TXT read
+        { 
+            uint32_t i;
+            for( i = 0 ; i < size ; i++ )
+            {
+                error = dev_txt_read( channel , &k_buf[i] );
+
+                if( error ) 
+                {
+
+devfs_dmsg("\n[DBG] %s exit error / cycle %d\n", 
+__FUNCTION__ , hal_time_stamp() );
+
+                    return -1;
+                }
+                else
+                {
+                    hal_strcpy_to_uspace( u_buf , k_buf , size );
+                }
+             }
+
+#if CONFIG_READ_DEBUG
+exit_devfs_move = hal_time_stamp();
+#endif
+
+devfs_dmsg("\n[DBG] %s exit success / size = %d / cycle %d\n", 
+__FUNCTION__ , size , hal_time_stamp() );
+
+            return size;
+        } 
+        else                // TXT write  
+        {
+            hal_strcpy_from_uspace( k_buf , u_buf , size );
+
+            error = dev_txt_write( channel , k_buf , size );
+            if( error ) 
+            {
+
+devfs_dmsg("\n[DBG] %s exit error / cycle %d\n", 
+__FUNCTION__ , hal_time_stamp() );
+
+                return -1;
+            }
+            else
+            {
+
+devfs_dmsg("\n[DBG] %s exit success / size = %d / cycle %d\n", 
+__FUNCTION__ , size , hal_time_stamp() );
+
+                return size;
+            }
+        }
+    }
+    else
+    {
+        panic("device type %s does not support direct user access", chdev_func_str(func) );
+
+        return -1;
+    }
+}  // end devfs_user_move()
+
+

trunk/kernel/fs/devfs.h

@@ -41 +41 @@
 //
 // The DEVFS extensions to the generic VFS are the following:
-// 1) The vfs_ctx_t "extend" field is a void* pointing on the devfs_ctx_t structure.
+// 1) The vfs_ctx_t "extend" void* field is pointing on the devfs_ctx_t structure.
 //    This structure contains two extended pointers on the DEVFS "dev" directory inode,
 //    and on the "external" directory inode.
-// 2) The vfs_inode_t "extend" field is a void*, pointing on the associated 
-//    chdev descriptor.
+// 2) The vfs_inode_t "extend" void* field is pointing on the chdev descriptor.
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -119 +118 @@
                        xptr_t * devfs_internal_inode_xp );
                        
+/****************************************************************************************** 
+ * This function moves <size> bytes between a device, and a - possibly distributed - 
+ * user space <buffer>. It uses the <file_xp> and <to_buffer> arguments, to call the 
+ * relevant device access function.
+ * It is called by the sys_read() and sys_write() functions.
+ * The <size> argument cannot be larger than the CONFIG_TXT_KBUF_SIZE configuration
+ * parameter, as this function makes a copy between the user space buffer, and a local
+ * kernel buffer allocated in the kernel stack.
+ ******************************************************************************************
+ * @ to_buffer : device -> buffer if true / buffer -> device if false. 
+ * @ file_xp   : extended pointer on the remote file descriptor.
+ * @ u_buf     : user space buffer (virtual address).
+ * @ size      : requested number of bytes from offset.
+ * @ returns number of bytes actually moved if success / -1 if error.
+ *****************************************************************************************/
+int devfs_user_move( bool_t   to_buffer,
+                     xptr_t   file_xp, 
+                     void   * u_buf,
+                     uint32_t size );
+
+
 #endif  /* _DEVFS_H_ */

trunk/kernel/fs/fatfs.c

@@ -262 +262 @@
     "no FAT access required for first page\n");
 
-    fatfs_dmsg("\n[DMSG] %s : enter / first_cluster_id = %d / searched_page_index = %d\n",
-    __FUNCTION__ , first_cluster_id , searched_page_index );
+fatfs_dmsg("\n[DBG] %s : core[%x,%d] enters / first_cluster_id = %d / searched_index = %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, first_cluster_id, searched_page_index );
 
     // get number of FAT slots per page
@@ -289 +289 @@
         next_cluster_id = current_page_buffer[current_page_offset];
 
-        fatfs_dmsg("\n[DMSG] %s : traverse FAT / current_page_index = %d\n"
-                   "       current_page_offset = %d / next_cluster_id = %d\n",
-        __FUNCTION__ , current_page_index , current_page_offset , next_cluster_id );
+fatfs_dmsg("\n[DBG] %s : core[%x,%d] traverse FAT / current_page_index = %d\n"
+"current_page_offset = %d / next_cluster_id = %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, current_page_index,
+current_page_offset , next_cluster_id );
 
         // update loop variables
@@ -301 +302 @@
     if( next_cluster_id == 0xFFFFFFFF ) return EIO;
    
-    fatfs_dmsg("\n[DMSG] %s : exit / cluster_id = %d\n", __FUNCTION__ , next_cluster_id );
+fatfs_dmsg("\n[DBG] %s : core[%x;%d] exit / cluster_id = %d\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, next_cluster_id );
 
     *searched_cluster_id = next_cluster_id;
@@ -333 +335 @@
     uint8_t     * buffer;
 
-    fatfs_dmsg("\n[DMSG] %s : enter for fatfs_ctx = %x\n",
+    fatfs_dmsg("\n[DBG] %s : enter for fatfs_ctx = %x\n",
                __FUNCTION__ , fatfs_ctx );
 
@@ -347 +349 @@
                    "cannot allocate memory for 512 bytes buffer\n" );
      
-    fatfs_dmsg("\n[DMSG] %s : allocated 512 bytes buffer\n", __FUNCTION__ );
+    fatfs_dmsg("\n[DBG] %s : allocated 512 bytes buffer\n", __FUNCTION__ );
 
     // load the boot record from device
@@ -353 +355 @@
     error = dev_ioc_sync_read( buffer , 0 , 1 );
 
-    fatfs_dmsg("\n[DMSG] %s : buffer loaded\n", __FUNCTION__ );
+fatfs_dmsg("\n[DBG] %s : buffer loaded\n", __FUNCTION__ );
 
     assert( (error == 0) , __FUNCTION__ , "cannot access boot record\n" );
@@ -415 +417 @@
     kmem_free( &req );
 
-    fatfs_dmsg("\n[DMSG] %s : boot record read & released\n",
+    fatfs_dmsg("\n[DBG] %s : boot record read & released\n",
                __FUNCTION__ );
 
@@ -437 +439 @@
     fatfs_ctx->fat_mapper_xp         = XPTR( local_cxy , fat_mapper );
 
-    fatfs_dmsg("\n[DMSG] %s : exit for fatfs_ctx = %x\n",
-               __FUNCTION__ , fatfs_ctx );
+fatfs_dmsg("\n[DBG] %s : exit for fatfs_ctx = %x\n", __FUNCTION__ , fatfs_ctx );
 
 }  // end fatfs_ctx_init()
@@ -471 +472 @@
     inode = mapper->inode;
 
-    fatfs_dmsg("\n[DMSG] %s : core[%x,%d] enter for page %d / inode %x / mapper %x\n",
-    __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , index , inode , mapper );
+fatfs_dmsg("\n[DBG] %s : core[%x,%d] enter for page %d / inode %x / mapper %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , index , inode , mapper );
 
     // get page base address
@@ -488 +489 @@
         lba = fatfs_ctx->fat_begin_lba + (count * index);
  
-        fatfs_dmsg("\n[DMSG] %s : core[%x,%d] access FAT on device / lba = %d\n",
-        __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , lba );
+fatfs_dmsg("\n[DBG] %s : core[%x,%d] access FAT on device / lba = %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , lba );
 
         // access device
@@ -511 +512 @@
         else                        // FAT mapper access required
         {
-            fatfs_dmsg("\n[DMSG] %s : core[%x,%d] must access FAT\n",
-            __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid );
-
             // get cluster and local pointer on FAT mapper
             xptr_t     fat_mapper_xp  = fatfs_ctx->fat_mapper_xp;
@@ -522 +520 @@
             if( fat_mapper_cxy == local_cxy )    // FAT mapper is local
             {
+
+fatfs_dmsg("\n[DBG] %s : core[%x,%d] access local FAT mapper\n"
+"fat_mapper_cxy = %x / fat_mapper_ptr = %x / first_cluster_id = %d / index = %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
+fat_mapper_cxy , fat_mapper_ptr , first_cluster_id , index );
+
                 error = fatfs_get_cluster( fat_mapper_ptr,
                                            first_cluster_id,
@@ -529 +533 @@
             else                                 // FAT mapper is remote
             {
+
+fatfs_dmsg("\n[DBG] %s : core[%x,%d] access remote FAT mapper\n"
+"fat_mapper_cxy = %x / fat_mapper_ptr = %x / first_cluster_id = %d / index = %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid ,
+fat_mapper_cxy , fat_mapper_ptr , first_cluster_id , index );
+
                 rpc_fatfs_get_cluster_client( fat_mapper_cxy,
                                               fat_mapper_ptr,
@@ -540 +550 @@
         }
 
-        fatfs_dmsg("\n[DMSG] %s : core[%x,%d] access device for inode %x / cluster_id %d\n",
-        __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , inode , searched_cluster_id );
+fatfs_dmsg("\n[DBG] %s : core[%x,%d] access device for inode %x / cluster_id %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , inode , searched_cluster_id );
 
         // get lba from cluster_id
@@ -553 +563 @@
     }
 
-    fatfs_dmsg("\n[DMSG] %s : core[%x,%d] exit for page %d / inode %x / mapper %x\n",
-    __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , index , inode , mapper );
+fatfs_dmsg("\n[DBG] %s : core[%x,%d] exit for page %d / inode %x / mapper %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , index , inode , mapper );
 
 #if (CONFIG_FATFS_DEBUG & 0x1)
@@ -584 +594 @@
     // - scan the directory entries in each 4 Kbytes page
 
-    fatfs_dmsg("\n[DMSG] %s : enter for child <%s> in parent inode %l\n",
-               __FUNCTION__ , name , XPTR( local_cxy , parent_inode ) );
+fatfs_dmsg("\n[DBG] %s : enter for child <%s> in parent inode %l\n",
+__FUNCTION__ , name , XPTR( local_cxy , parent_inode ) );
 
     mapper_t * mapper = parent_inode->mapper;
@@ -705 +715 @@
     if ( found == -1 )  // found end of directory => failure 
     {
-        fatfs_dmsg("\n[DMSG] %s : exit / child <%s> not found in parent inode %l\n",
-                   __FUNCTION__ , name , XPTR( local_cxy , parent_inode ) );
+
+fatfs_dmsg("\n[DBG] %s : exit / child <%s> not found in parent inode %l\n",
+__FUNCTION__ , name , XPTR( local_cxy , parent_inode ) );
 
         return ENOENT;
@@ -723 +734 @@
         hal_remote_sw( XPTR( child_cxy , &child_ptr->extend ) , cluster );
 
-        fatfs_dmsg("\n[DMSG] %s : exit / child <%s> found in parent inode %l\n",
-                   __FUNCTION__ , name , XPTR( local_cxy , parent_inode ) );
+fatfs_dmsg("\n[DBG] %s : exit / child <%s> found in parent inode %l\n",
+__FUNCTION__ , name , XPTR( local_cxy , parent_inode ) );
 
         return 0;

trunk/kernel/fs/vfs.c

@@ -156 +156 @@
     error_t            error;
 
-    vfs_dmsg("\n[INFO] %s : core[%x,%d] enter / dentry_xp = %l\n",
-    __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , dentry_xp );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] enter / dentry = %x in cluster %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, GET_PTR(dentry_xp), GET_CXY(dentry_xp) );
  
     // check fs type and get pointer on context
@@ -229 +229 @@
     remote_spinlock_init( XPTR( local_cxy , &inode->main_lock ) );
 
-    vfs_dmsg("\n[INFO] %s : core[%x,%d] exit / inode_xp = %l / dentry_xp = %l\n",
-    __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, XPTR(local_cxy,inode), dentry_xp );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] exit / inode = %x in cluster %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, inode , local_cxy );
  
     // return extended pointer on inode
@@ -262 +262 @@
                         xptr_t        child_xp )
 {
-    vfs_dmsg("\n[INFO] %s : core[%x,%d] enter for <%s> / cycle %d\n",
-    __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , name , hal_time_stamp() );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s> / cycle %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , name , hal_time_stamp() );
 
     error_t error = 0;
@@ -292 +292 @@
     }
 
-    vfs_dmsg("\n[INFO] %s : core[%x,%d] exit for <%s> / cycle %d\n",
-    __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , name , hal_time_stamp() );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for <%s> / cycle %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , name , hal_time_stamp() );
 
     return error;
@@ -413 +413 @@
 
     // display inode header
-    printk("\n*** inode <%s> / inode_xp = %l / dentry_xp = %l ***\n",
-           name , inode_xp , dentry_xp );
+    printk("\n***** inode <%s> [%x in cluster %x]\n",
+           name , GET_PTR(inode_xp) , GET_CXY(inode_xp) );
 
     // display children from xhtab
@@ -435 +435 @@
         kmem_req_t       req;        // request to kernel memory allocator
 
-    vfs_dmsg("\n[INFO] %s : core[%x,%d] enter for <%s> / parent inode = %x / cycle %d\n",
-    __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, name, parent, hal_time_stamp() );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s> / parent inode = %x / cycle %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, name, parent, hal_time_stamp() );
 
     // get pointer on context
@@ -484 +484 @@
     *dentry_xp = XPTR( local_cxy , dentry );
 
-    vfs_dmsg("\n[INFO] %s : core[%x,%d] exit for <%s> / dentry = %l / cycle %d\n",
-    __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, name, *dentry_xp, hal_time_stamp() );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for <%s> / dentry = %x in cluster %x / cycle %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, name, dentry, local_cxy , hal_time_stamp() );
 
     return 0;
@@ -586 +586 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-////////////////////////////////////
-error_t vfs_open( xptr_t     cwd_xp,
-                          char     * path,
-                          uint32_t   flags,
-                  uint32_t   mode, 
-                          xptr_t   * new_file_xp,
-                  uint32_t * new_file_id )
+//////////////////////////////////////
+error_t vfs_open( process_t * process,
+                          char      * path,
+                          uint32_t    flags,
+                  uint32_t    mode, 
+                          xptr_t    * new_file_xp,
+                  uint32_t  * new_file_id )
 {
     error_t       error;
@@ -603 +603 @@
     uint32_t      file_id;      // created file descriptor index in reference fd_array
 
-    vfs_dmsg("\n[INFO] %s : core[%x,%d] enter for <%s> / cycle %d\n",
-    __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path, (uint32_t)hal_time_stamp() );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s> / cycle %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path, (uint32_t)hal_time_stamp() );
 
     // compute lookup working mode
@@ -614 +614 @@
     // compute attributes for the created file
     file_attr = 0;
-    if( (flags & O_RDONLY ) == 0 )  file_attr |= FD_ATTR_READ_ENABLE;
-    if( (flags & O_WRONLY ) == 0 )  file_attr |= FD_ATTR_WRITE_ENABLE;
+    if( (flags & O_RDONLY ) == 0 )  file_attr |= FD_ATTR_WRITE_ENABLE;
+    if( (flags & O_WRONLY ) == 0 )  file_attr |= FD_ATTR_READ_ENABLE;
     if( (flags & O_SYNC   )      )  file_attr |= FD_ATTR_SYNC;
     if( (flags & O_APPEND )      )  file_attr |= FD_ATTR_APPEND;
@@ -621 +621 @@
 
     // get extended pointer on target inode
-    error = vfs_lookup( cwd_xp , path , lookup_mode , &inode_xp );
+    error = vfs_lookup( process->vfs_cwd_xp , path , lookup_mode , &inode_xp );
 
     if( error ) return error;
@@ -629 +629 @@
     inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
     
+vfs_dmsg("\n[DBG] %s : core[%x,%d] found inode for <%s> in cluster %x / cycle %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path, inode_cxy , (uint32_t)hal_time_stamp() );
+
     // create a new file descriptor in cluster containing inode
     if( inode_cxy == local_cxy )      // target cluster is local
@@ -641 +644 @@
     if( error )  return error;
 
-    // allocate and register a new file descriptor index in reference cluster fd_array
-    error = process_fd_register( file_xp , &file_id );
+    // allocate and register a new file descriptor index in reference process
+    error = process_fd_register( process , file_xp , &file_id );
 
     if( error ) return error;
 
-    vfs_dmsg("\n[INFO] %s : core[%x,%d] exit for <%s> / file_xp = %l / cycle %d\n",
-    __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path, file_xp, hal_time_stamp() );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for <%s> / file = %x in cluster %x / cycle %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path,
+GET_PTR(file_xp), GET_CXY(file_xp), hal_time_stamp() );
 
     // success
@@ -656 +660 @@
 }  // end vfs_open()
 
-////////////////////////////////////////////
-error_t vfs_user_move( bool_t   to_buffer,
-                       xptr_t   file_xp,
-                       void   * buffer,
-                       uint32_t size )
-{
-    assert( ( file_xp != XPTR_NULL ) , __FUNCTION__ , "file_xp == XPTR_NULL" );
+//////////////////////////////////////
+int vfs_user_move( bool_t   to_buffer,
+                   xptr_t   file_xp,
+                   void   * buffer,
+                   uint32_t size )
+{
+    assert( ( file_xp != XPTR_NULL ) , __FUNCTION__ , 
+    "file_xp == XPTR_NULL" );
 
     cxy_t              file_cxy;     // remote file descriptor cluster 
@@ -678 +683 @@
     inode_type = hal_remote_lw( XPTR( file_cxy , &file_ptr->type   ) );
    
-    // action depends on inode type
-    if( inode_type == INODE_TYPE_FILE )
-    {
-        // get mapper pointer and file offset from file descriptor
-        file_offset = hal_remote_lw( XPTR( file_cxy , &file_ptr->offset ) );
-        mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
-
-        // move data between mapper and buffer
-        if( file_cxy == local_cxy )
-        {
-            error = mapper_move_user( mapper,
-                                      to_buffer,
-                                      file_offset,
-                                      buffer,
-                                      size );
-        }
-        else
-        {
-            rpc_mapper_move_buffer_client( file_cxy,
-                                           mapper,
-                                           to_buffer,
-                                           true,          // user buffer
-                                           file_offset,
-                                           (uint64_t)(intptr_t)buffer,
-                                           size,
-                                           &error );
-        } 
-
-        if( error ) return -1;
-        else        return 0;
-    }
-    else 
-    {
-        printk("\n[ERROR] in %s : inode is not a file", __FUNCTION__ );
-        return -1;
-    }
+    assert( (inode_type == INODE_TYPE_FILE) , __FUNCTION__ ,
+    "inode type is not INODE_TYPE_FILE" );
+
+    // get mapper pointer and file offset from file descriptor
+    file_offset = hal_remote_lw( XPTR( file_cxy , &file_ptr->offset ) );
+    mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
+
+    // move data between mapper and buffer
+    if( file_cxy == local_cxy )
+    {
+        error = mapper_move_user( mapper,
+                                  to_buffer,
+                                  file_offset,
+                                  buffer,
+                                  size );
+    }
+    else
+    {
+        rpc_mapper_move_buffer_client( file_cxy,
+                                       mapper,
+                                       to_buffer,
+                                       true,          // user buffer
+                                       file_offset,
+                                       (uint64_t)(intptr_t)buffer,
+                                       size,
+                                       &error );
+    } 
+
+    if( error ) return -1;
+    else        return size;
+
 }  // end vfs_user_move()
 
@@ -905 +905 @@
     panic("not implemented");
     return 0;
-}  // vfs_unlink()
-
-///////////////////////////////////////
-error_t vfs_stat( xptr_t       file_xp,
-                  vfs_stat_t * k_stat )
+} 
+
+////////////////////////////////////////
+error_t vfs_stat( xptr_t        file_xp,
+                  struct stat * k_stat )
 {
     panic("not implemented");
@@ -915 +915 @@
 }
 
-////////////////////////////////////////////
-error_t vfs_readdir( xptr_t         file_xp,
-                     vfs_dirent_t * k_dirent )
+/////////////////////////////////////////////
+error_t vfs_readdir( xptr_t          file_xp,
+                     struct dirent * k_dirent )
 {
     panic("not implemented");
@@ -1094 +1094 @@
 
     // display inode
-    nolock_printk("%s%s <%s> : inode = %l / mapper = %l / dentry = %l\n",
+    nolock_printk("%s%s <%s> : inode = %x / mapper = %x / cluster %x\n",
                   indent_str[indent], vfs_inode_type_str( inode_type ), name,
-                  inode_xp , XPTR( inode_cxy , mapper_ptr ) , dentry_xp );
+                  inode_ptr , mapper_ptr , inode_cxy );
 
     // scan directory entries  
@@ -1171 +1171 @@
 
     // get pointers on TXT0 chdev
-    xptr_t    txt0_xp  = chdev_dir.txt[0];
+    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
     cxy_t     txt0_cxy = GET_CXY( txt0_xp );
     chdev_t * txt0_ptr = GET_PTR( txt0_xp );
@@ -1338 +1338 @@
     process = this->process;
 
-    vfs_dmsg("\n[INFO] %s : core[%x,%d] enter for <%s> / cycle %d\n",
-    __FUNCTION__ , local_cxy , this->core->lid , pathname , hal_time_stamp() );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s> / cycle %d\n",
+__FUNCTION__ , local_cxy , this->core->lid , pathname , hal_time_stamp() );
 
     // get extended pointer on first inode to search
@@ -1362 +1362 @@
         vfs_get_name_from_path( current , name , &next , &last );
 
-        vfs_dmsg("\n[INFO] %s : core[%x,%d] look for <%s> / last = %d\n",
-        __FUNCTION__ , local_cxy , this->core->lid , name , last );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] look for <%s> / last = %d\n",
+__FUNCTION__ , local_cxy , this->core->lid , name , last );
 
         // search a child dentry matching name in parent inode
@@ -1380 +1380 @@
         if (found == false ) // child node not found in inode tree 
         {
-            vfs_dmsg("\n[INFO] %s : core[%x,%d] miss <%s> => load it\n",
-            __FUNCTION__ , local_cxy , this->core->lid , name );
+
+vfs_dmsg("\n[DBG] %s : core[%x,%d] miss <%s> => load it\n",
+__FUNCTION__ , local_cxy , this->core->lid , name );
 
             // release lock on parent inode
@@ -1405 +1406 @@
             if( error )
             {
-                printk("\n[ERROR] in %s : no memory for inode %s in path %s\n",
+                printk("\n[ERROR] in %s : no memory for inode <%s> in path <%s>\n",
                 __FUNCTION__ , name , pathname );
                 return ENOMEM;
@@ -1428 +1429 @@
             if ( error )
             {
-                printk("\n[ERROR] in %s : core[%x,%d] / <%s> not found in parent\n",
-                __FUNCTION__ , local_cxy , this->core->lid , name );
+                printk("\n[ERROR] in %s : core[%x,%d] / <%s> node not found in <%s>\n",
+                __FUNCTION__ , local_cxy , this->core->lid , name , pathname );
                 return ENOENT;
             }
@@ -1464 +1465 @@
             vfs_inode_lock( parent_xp );
 
-            vfs_dmsg("\n[INFO] %s : core[%x,%d] created node <%s>\n",
-            __FUNCTION__ , local_cxy , this->core->lid , name );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] created node <%s>\n",
+__FUNCTION__ , local_cxy , this->core->lid , name );
+
         }
 
-        vfs_dmsg("\n[INFO] %s : core[%x,%d] found <%s> / parent = %l / child = %l\n",
-        __FUNCTION__ , local_cxy , this->core->lid , name , parent_xp , child_xp );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] found <%s> / inode = %x in cluster %x\n",
+__FUNCTION__ , local_cxy , this->core->lid , name , GET_PTR(child_xp) , GET_CXY(child_xp) );
 
         // TODO check access rights here [AG]
@@ -1494 +1496 @@
     vfs_inode_unlock( parent_xp );
 
-    vfs_dmsg("\n[INFO] %s : exit <%s> found / inode = %l\n",
-                 __FUNCTION__ , pathname , child_xp );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for <%s> / inode = %x in cluster %x\n",
+__FUNCTION__,local_cxy,this->core->lid,pathname,GET_PTR(child_xp),GET_CXY(child_xp) );
 
     // return searched pointer
@@ -1593 +1595 @@
     parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
 
-    vfs_dmsg("\n[INFO] %s : enter for <%s> / core[%x,%d] / child_cxy = %x / parent_xp = %l\n",
-    __FUNCTION__ , name , local_cxy , CURRENT_THREAD->core->lid , child_cxy , parent_xp );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for <%s> / child_cxy = %x / parent_cxy = %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , name , child_cxy , parent_cxy );
 
     // 1. create dentry
@@ -1604 +1606 @@
                                    &dentry_xp );
 
-        vfs_dmsg("\n[INFO] %s : dentry <%s> created in local cluster %x\n",
-        __FUNCTION__ , name , local_cxy );
+vfs_dmsg("\n[DBG] %s : dentry <%s> created in local cluster %x\n",
+__FUNCTION__ , name , local_cxy );
+
     }
     else                               // parent cluster is remote
@@ -1616 +1619 @@
                                       &error );
 
-        vfs_dmsg("\n[INFO] %s : dentry <%s> created in remote cluster %x\n",
-        __FUNCTION__ , name , parent_cxy );
+vfs_dmsg("\n[DBG] %s : dentry <%s> created in remote cluster %x\n",
+__FUNCTION__ , name , parent_cxy );
+
     }
                                       
@@ -1623 +1627 @@
     {
         printk("\n[ERROR] in %s : cannot create dentry in cluster %x\n",
-               __FUNCTION__ , parent_cxy );
+        __FUNCTION__ , parent_cxy );
         return ENOMEM;
     }
@@ -1645 +1649 @@
                                   &inode_xp );
 
-        vfs_dmsg("\n[INFO] %s : inode %l created in local cluster %x\n",
-                 __FUNCTION__ , inode_xp , local_cxy );
+vfs_dmsg("\n[DBG] %s : inode %x created in local cluster %x\n",
+__FUNCTION__ , GET_PTR(inode_xp) , local_cxy );
+
     }
     else                              // child cluster is remote
@@ -1662 +1667 @@
                                      &error );
 
-        vfs_dmsg("\n[INFO] %s : inode %l created in remote cluster %x\n",
-                 __FUNCTION__ , inode_xp , child_cxy );
+vfs_dmsg("\n[DBG] %s : inode %x created in remote cluster %x\n",
+__FUNCTION__ , GET_PTR(inode_xp) , child_cxy );
+
     }
                                      
@@ -1682 +1688 @@
     hal_remote_swd( XPTR( dentry_cxy , &dentry_ptr->child_xp ) , inode_xp );
 
-    vfs_dmsg("\n[INFO] %s : exit in cluster %x for <%s>\n",
-    __FUNCTION__ , local_cxy , name );
+vfs_dmsg("\n[DBG] %s : exit in cluster %x for <%s>\n",
+__FUNCTION__ , local_cxy , name );
 
     // success : return extended pointer on child inode
@@ -1707 +1713 @@
     assert( (mapper != NULL) , __FUNCTION__ , "no mapper for page\n" );
 
-    vfs_dmsg("\n[DMSG] %s : enters for page %d / inode_cxy = %x / inode_ptr = %x\n",
-    __FUNCTION__ , page->index , local_cxy , mapper->inode );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] enters for page %d / mapper = %x / inode = %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid , page->index , mapper, mapper->inode );
 
     // get FS type
@@ -1733 +1739 @@
     }
 
-    vfs_dmsg("\n[DMSG] %s : exit for page %d / inode_cxy = %x / inode_ptr = %x\n",
-    __FUNCTION__ , page->index , local_cxy , mapper->inode );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for page %d / mapper = %x / inode = %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, page->index, mapper, mapper->inode );
 
     return error;
@@ -1753 +1759 @@
     assert( (mapper != NULL) , __FUNCTION__ , "mapper pointer is NULL\n" );
 
-    vfs_dmsg("\n[INFO] %s : core[%x,%d] enter for inode %l / cycle %d\n",
-    __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, XPTR(local_cxy , inode) );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] enter for inode %x in cluster %x/ cycle %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, inode , local_cxy , hal_time_stamp() );
 
     // compute number of pages
@@ -1770 +1776 @@
     }
 
-    vfs_dmsg("\n[INFO] %s : core[%x,%d] exit for inode %l / cycle %d\n",
-    __FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, XPTR(local_cxy , inode) );
+vfs_dmsg("\n[DBG] %s : core[%x,%d] exit for inode %x in cluster %x / cycle %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, inode , local_cxy , hal_time_stamp() );
 
     return 0;

trunk/kernel/fs/vfs.h

@@ -38 +38 @@
 #include <xhtab.h>
 #include <errno.h>
-#include <metafs.h>
-
+#include <shared_syscalls.h>
 #include <fatfs.h>
 #include <ramfs.h>
@@ -235 +234 @@
 typedef enum
 {
-    VFS_SEEK_SET,
-    VFS_SEEK_CUR,
-    VFS_SEEK_END,
-}
-vfs_lseek_cmd_t;
-
-typedef enum
-{
     FD_ATTR_READ_ENABLE    = 0x01,     /*! read access possible                         */
     FD_ATTR_WRITE_ENABLE   = 0x02,     /*! write access possible                        */
@@ -267 +258 @@
 vfs_file_t;
 
-/******************************************************************************************
- * This structure define the informations associated to a file descriptor,
- * returned to user space by the stat() system call.
- *****************************************************************************************/
-
-typedef struct vfs_stat_s 
-{
-        uint32_t    dev;        /*! ID of device containing file                             */
-        uint32_t    ino;        /*! inode number                                             */
-        uint32_t    mode;       /*! protection                                               */
-        uint32_t    nlink;      /*! number of hard links                                     */
-        uint32_t    uid;        /*! user ID of owner                                         */
-        uint32_t    gid;        /*! group ID of owner                                        */
-        uint32_t    rdev;       /*! device ID (if special file)                              */
-        uint64_t    size;       /*! total size, in bytes                                     */
-        uint32_t    blksize;    /*! blocksize for file system I/O                            */
-        uint32_t    blocks;     /*! number of 512B blocks allocated                          */
-        uint64_t    atime;      /*! time of last access                                      */
-        uint64_t    mtime;      /*! time of last modification                                */
-        uint64_t    ctime;      /*! time of last status change                               */
-}
-vfs_stat_t;
-
-/*********************************************************************************************
- * This structure defines the information associated to a directory entry,
- * returned to user space by the readdir() system call.
- ********************************************************************************************/
-
-typedef struct vfs_dirent_s
-{
-    uint32_t    inum;                               /*! inode identifier                    */
-    uint32_t    type;                               /*! inode type                          */
-    char        name[CONFIG_VFS_MAX_NAME_LENGTH];   /*! dentry name                         */
-}
-vfs_dirent_t;
-
-
 
 /*****************************************************************************************/
@@ -503 +457 @@
 error_t vfs_inode_unlink( vfs_inode_t * inode );
 
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_inode_stat( vfs_inode_t * inode,
-                        uint32_t      inum );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_icache_del( vfs_inode_t * inode );
-
-
-/****************************************************************************************** 
- * This function TODO  Pourquoi 2 arguments ?
- *****************************************************************************************/
-error_t vfs_stat_inode( vfs_inode_t * inode,
-                        uint32_t      inum );
-
 
 /*****************************************************************************************/
@@ -643 +579 @@
  * @ lookup_mode : flags defining the working mode (defined above in this file).
  * @ inode_xp    : [out] buffer for extended pointer on searched inode.
- * @ return 0 if success / ENOENT if inode not found , EACCES if permissopn denied,
- *                        EAGAIN if a new complete lookup must be made
+ * @ return 0 if success / ENOENT if inode not found , EACCES if permisson denied,
+ *                         EAGAIN if a new complete lookup must be made
  *****************************************************************************************/
 error_t vfs_lookup( xptr_t             cwd_xp,
@@ -653 +589 @@
 /******************************************************************************************
  * This function creates a new couple dentry/inode, and insert it in the Inode-Tree.
- * It can be executed by any thread running in any cluster ( can be differente from both
+ * It can be executed by any thread running in any cluster (can be different from both
  * the child cluster and the parent cluster), as it uses the rpc_dentry_create_client()
  * and rpc_inode_create client() if required. This is done in three steps:
@@ -707 +643 @@
 /****************************************************************************************** 
  * This function allocates a vfs_file_t structure in the cluster containing the inode
- * associated to the file identified by <cwd_xp> & <path>.
- * It initializes it, register it in the reference process fd_array, and returns both 
- * the extended pointer on the remote file descriptor, and the index in the fd_array. 
+ * associated to the file identified by the <cwd_xp> & <path> arguments.
+ * It initializes it, register it in the reference process fd_array identified by the
+ * <process> argument, and returns both the extended pointer on the file descriptor,
+ * and the allocated index in the fd_array. 
  * The pathname can be relative to current directory or absolute.
  * If the inode does not exist in the inode cache, it try to find the file on the mounted
  * device, and creates an inode on a pseudo randomly selected cluster if found.
  * It the requested file does not exist on device, it creates a new inode if the
- * O_CREAT flag is set and return an error otherwise. 
- ****************************************************************************************** 
- * @ cwd_xp      : extended pointer on current working directory file descriptor.
+ * O_CREAT flag is set, and return an error otherwise. 
+ ****************************************************************************************** 
+ * @ process     : local pointer on local process descriptor copy.
  * @ path        : file pathname (absolute or relative to current directory).
- * @ flags       : defined above 
+ * @ flags       : defined above.
  * @ mode        : access rights (as defined by chmod)
  * @ file_xp     : [out] buffer for extended pointer on created remote file descriptor.
@@ -724 +661 @@
  * @ return 0 if success / return non-zero if error.
  *****************************************************************************************/
-error_t vfs_open( xptr_t     cwd_xp,
-                          char     * path,
-                          uint32_t   flags,
-                  uint32_t   mode,
-                          xptr_t   * file_xp,
-                          uint32_t * file_id );
+error_t vfs_open( struct process_s * process,
+                          char             * path,
+                          uint32_t           flags,
+                  uint32_t           mode,
+                          xptr_t           * file_xp,
+                          uint32_t         * file_id );
 
 /****************************************************************************************** 
@@ -735 +672 @@
  * <file_xp> argument, and a - possibly distributed - user space <buffer>, taken into 
  * account the offset in <file_xp>. The transfer direction is defined by <to_buffer>.
- * This function is called by the elf_load_process() function.
+ * It is called by the sys_read() and sys_write() functions.
  ******************************************************************************************
  * @ to_buffer : mapper -> buffer if true / buffer -> mapper if false. 
@@ -741 +678 @@
  * @ buffer    : user space pointer on buffer (can be physically distributed).
  * @ size      : requested number of bytes from offset.
- * @ returns 0 f success / -1 if error.
- *****************************************************************************************/
-error_t vfs_user_move( bool_t   to_buffer,
-                       xptr_t   file_xp, 
-                       void   * buffer,
-                       uint32_t size );
+ * @ 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 );
 
 /****************************************************************************************** 
@@ -752 +689 @@
  * <file_xp> argument, and a - possibly remote - kernel <buffer_xp>, taken into 
  * account the offset in <file_xp>. The transfer direction is defined by <to_buffer>.
- * This function is called by the  system calls.
+ * It is called by the elf_load_process() function.
  ******************************************************************************************
  * @ to_buffer : mapper -> buffer if true / buffer -> mapper if false. 
@@ -758 +695 @@
  * @ buffer_xp : user space pointer on buffer (can be physically distributed).
  * @ size      : requested number of bytes from offset.
- * @ returns number of bytes actually transfered / -1 if error.
+ * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
 error_t vfs_kernel_move( bool_t   to_buffer,
@@ -814 +751 @@
  ******************************************************************************************
  * @ file_xp    : extended pointer on the file descriptor of the searched directory .
- * @ k_dirent   : local pointer on the dirent_t structure in kernel space.
+ * @ k_stat     : local pointer on the stat structure in kernel space.
  * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
-error_t vfs_stat( xptr_t       file_xp,
-                  vfs_stat_t * k_stat );
+error_t vfs_stat( xptr_t        file_xp,
+                  struct stat * k_stat );
 
 /****************************************************************************************** 
@@ -826 +763 @@
  ******************************************************************************************
  * @ file_xp    : extended pointer on the file descriptor of the searched directory .
- * @ k_dirent   : local pointer on the dirent_t structure in kernel space.
+ * @ k_dirent   : local pointer on the dirent structure in kernel space.
  * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
-error_t vfs_readdir( xptr_t         file_xp,
-                     vfs_dirent_t * k_dirent );
+error_t vfs_readdir( xptr_t          file_xp,
+                     struct dirent * k_dirent );
 
 /******************************************************************************************