Changeset 610 for trunk/kernel/fs

Timestamp:

Dec 27, 2018, 7:38:58 PM (5 years ago)

Author:

alain

Message:

Fix several bugs in VFS to support the following
ksh commandis : cp, mv, rm, mkdir, cd, pwd

Location:

trunk/kernel/fs

Files:

• devfs.c (modified) (13 diffs)
• fatfs.c (modified) (5 diffs)
• fatfs.h (modified) (1 diff)
• vfs.c (modified) (61 diffs)
• vfs.h (modified) (25 diffs)

trunk/kernel/fs/devfs.c

@@ -93 +93 @@
     xptr_t   unused_xp;   // required by vfs_add_child_in_parent()
 
-    // creates DEVFS "dev" inode in cluster 0
+    // create DEVFS "dev" inode in cluster 0
     error = vfs_add_child_in_parent( 0,                // cxy
                                      INODE_TYPE_DIR,
@@ -102 +102 @@
                                      devfs_dev_inode_xp );
 
-    assert( (error == 0) , "cannot create <dev>\n" );
+// check success
+assert( (error == 0) , "cannot create <dev>\n" );
 
 #if DEBUG_DEVFS_INIT
@@ -149 +150 @@
     // create "internal" directory 
     snprintf( node_name , 16 , "internal_%x" , local_cxy );
+
     vfs_add_child_in_parent( local_cxy,
                              INODE_TYPE_DIR,
@@ -169 +171 @@
     {
         chdev_ptr = GET_PTR( chdev_xp );
+        chdev_cxy = GET_CXY( chdev_xp );
+
+assert( (chdev_cxy == local_cxy ), 
+"illegal MMC chdev_xp in cluster %x\n", local_cxy );
+
         vfs_add_child_in_parent( local_cxy,
                                  INODE_TYPE_DEV,
@@ -198 +205 @@
         {
             chdev_ptr = GET_PTR( chdev_xp );
+            chdev_cxy = GET_CXY( chdev_xp );
+
+assert( (chdev_cxy == local_cxy ), 
+"illegal DMA[%d] chdev_xp in cluster %x\n", channel, local_cxy );
+
             vfs_add_child_in_parent( local_cxy,
                                      INODE_TYPE_DEV,
@@ -226 +238 @@
         chdev_cxy = GET_CXY( chdev_xp );
         chdev_ptr = GET_PTR( chdev_xp );
+
         if( chdev_cxy == local_cxy )
         {
@@ -256 +269 @@
         chdev_cxy = GET_CXY( chdev_xp );
         chdev_ptr = GET_PTR( chdev_xp );
+
         if( chdev_cxy == local_cxy )
         {
@@ -288 +302 @@
             chdev_cxy = GET_CXY( chdev_xp );
             chdev_ptr = GET_PTR( chdev_xp );
+
             if( chdev_cxy == local_cxy )
             {
@@ -321 +336 @@
             chdev_cxy = GET_CXY( chdev_xp );
             chdev_ptr = GET_PTR( chdev_xp );
+
             if( chdev_cxy == local_cxy )
             {
@@ -354 +370 @@
             chdev_cxy = GET_CXY( chdev_xp );
             chdev_ptr = GET_PTR( chdev_xp );
+
             if( chdev_cxy == local_cxy )
             {
@@ -387 +404 @@
             chdev_cxy = GET_CXY( chdev_xp );
             chdev_ptr = GET_PTR( chdev_xp );
+
             if( chdev_cxy == local_cxy )
             {
@@ -419 +437 @@
         {
             chdev_cxy = GET_CXY( chdev_xp );
-            chdev_ptr = (chdev_t *)GET_PTR( chdev_xp );
+            chdev_ptr = GET_PTR( chdev_xp );
+
             if( chdev_cxy == local_cxy )
             {
@@ -447 +466 @@
             chdev_cxy = GET_CXY( chdev_xp );
             chdev_ptr = GET_PTR( chdev_xp );
+
             if( chdev_cxy == local_cxy )
             {

trunk/kernel/fs/fatfs.c

@@ -1246 +1246 @@
 vfs_inode_get_name( XPTR( local_cxy , inode ) , dir_name );
 if( DEBUG_FATFS_REMOVE_DENTRY < cycle )
-printk("\n[%s]  thread[%x,%x] enter / parent <%s> / child <%s> / cycle %d\n",
+printk("\n[%s] thread[%x,%x] enter / parent <%s> / child <%s> / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
 #endif
@@ -1280 +1280 @@
     uint32_t  page_id    = dentry_id >> 7;
     uint32_t  offset     = (dentry_id & 0x7F)<<5;
+
+#if DEBUG_FATFS_REMOVE_DENTRY & 1
+if( DEBUG_FATFS_REMOVE_DENTRY < cycle )
+printk("\n[%s] dentry_id %x / page_id %x / offset %x\n",
+__FUNCTION__, dentry_id, page_id, offset );
+#endif
 
     // get extended pointer on page descriptor from parent directory mapper
@@ -1345 +1351 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_FATFS_REMOVE_DENTRY < cycle )
-printk("\n[%s]  thread[%x,%x] exit / parent %s / child %s / cycle %d\n",
+printk("\n[%s] thread[%x,%x] exit / parent %s / child %s / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, dir_name, dentry->name, cycle );
 #endif
@@ -1358 +1364 @@
                           xptr_t        child_inode_xp )
 {
-    // Two embedded loops:
+    // Two embedded loops to scan the directory mapper:
     // - scan the parent directory mapper pages 
     // - scan the directory entries in each 4 Kbytes page
@@ -1512 +1518 @@
     // get child inode cluster and local pointer
     cxy_t          inode_cxy = GET_CXY( child_inode_xp );
-    vfs_inode_t  * inode_ptr = (vfs_inode_t *)GET_PTR( child_inode_xp );
+    vfs_inode_t  * inode_ptr = GET_PTR( child_inode_xp );
+
+    // build extended pointer on parent dentried root
+    xptr_t parents_root_xp = XPTR( inode_cxy , &inode_ptr->parents );
+
+// check child inode has at least one parent
+assert( (xlist_is_empty( parents_root_xp ) == false ), "child inode must have one parent\n");
 
     // get dentry pointers and cluster
-    xptr_t         dentry_xp  = hal_remote_l64( XPTR( inode_cxy , &inode_ptr->parent_xp ) );  
+    xptr_t         dentry_xp  = XLIST_FIRST( parents_root_xp , vfs_dentry_t , parents );
     vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
     cxy_t          dentry_cxy = GET_CXY( dentry_xp );
 
-// dentry descriptor must be in same cluster as parent inode
+// check dentry descriptor in same cluster as parent inode
 assert( (dentry_cxy == local_cxy) , "illegal dentry cluster\n" );
 

trunk/kernel/fs/fatfs.h

@@ -311 +311 @@
  * This function implements the generic vfs_fs_child_init() function for the FATFS.
  *****************************************************************************************
- * It scan the mapper of an existing parent directory, identified by the <parent> 
- * argument, to find a directory entry identified by the <name> argument.
- * It updates the existing remote child inode, identified by the <child_xp> argument,
+ * It tries to initialise a new child (new inode/dentry couple in Inode Tree), identified
+ * by the <child_inode_xp> argument, from the parent directory mapper, identified by the
+ * <parent_inode> argument.
+ * - It scan the parent mapper to find the <name> argument.
  * - it set the "type", "size", and "extend" fields in inode descriptor.
  * - it set the " extend" field in dentry descriptor.

trunk/kernel/fs/vfs.c

@@ -141 +141 @@
 }
 
-//////////////////////////////////////////////////////
-error_t vfs_inode_create( xptr_t            dentry_xp,
-                          vfs_fs_type_t     fs_type,
+////////////////////////////////////////////////////
+error_t vfs_inode_create( vfs_fs_type_t     fs_type,
                           vfs_inode_type_t  inode_type,
                           uint32_t          attr,
@@ -212 +211 @@
         vfs_ctx_inum_release( ctx , inum );
         mapper_destroy( mapper );
-        return ENOMEM;
+        return -1;
     }
 
     // initialize inode descriptor
-    inode->gc         = 0;
     inode->type       = inode_type;
     inode->inum       = inum;
@@ -223 +221 @@
     inode->uid        = uid;
     inode->gid        = gid;
-    inode->refcount   = 0;
-    inode->parent_xp  = dentry_xp;
     inode->ctx        = ctx;
     inode->mapper     = mapper;
     inode->extend     = NULL;
+    inode->links      = 0;
 
     // initialise inode field in mapper
@@ -233 +230 @@
  
     // initialise threads waiting queue
-    xlist_root_init( XPTR( local_cxy , &inode->wait_root ) );
-
-    // initialize dentries hash table
+    // xlist_root_init( XPTR( local_cxy , &inode->wait_root ) );
+
+    // initialize chidren dentries xhtab
     xhtab_init( &inode->children , XHTAB_DENTRY_TYPE );
 
-    // initialize inode lock 
-    remote_rwlock_init( XPTR( local_cxy , &inode->data_lock ), LOCK_VFS_INODE );
-
-    // initialise lock protecting inode three traversal
-    remote_busylock_init( XPTR( local_cxy , &inode->main_lock ), LOCK_VFS_MAIN );
+    // initialize parents dentries xlist
+    xlist_root_init( XPTR( local_cxy , &inode->parents ) );
+ 
+    // initialize lock protecting size 
+    remote_rwlock_init( XPTR( local_cxy , &inode->size_lock ), LOCK_VFS_SIZE );
+
+    // initialise lock protecting inode tree traversal
+    remote_rwlock_init( XPTR( local_cxy , &inode->main_lock ), LOCK_VFS_MAIN );
+
+    // return extended pointer on inode
+    *inode_xp = XPTR( local_cxy , inode );
 
 #if DEBUG_VFS_INODE_CREATE
@@ -251 +254 @@
 #endif
  
-    // return extended pointer on inode
-    *inode_xp = XPTR( local_cxy , inode );
     return 0;
 
@@ -260 +261 @@
 void vfs_inode_destroy( vfs_inode_t * inode )
 {
-
-// check inode refcount
-assert( (inode->refcount == 0) , "inode refcount non zero\n" );
-
     // release memory allocated for mapper
     mapper_destroy( inode->mapper );
@@ -275 +272 @@
 }  // end vfs_inode_destroy()
 
-////////////////////////////////////////////
-void vfs_inode_remote_up( xptr_t  inode_xp )
-{
-    // get inode cluster and local pointer
-    cxy_t         inode_cxy = GET_CXY( inode_xp );
-    vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
-
-    hal_remote_atomic_add( XPTR( inode_cxy , &inode_ptr->refcount ) , 1 );    
-}
-
-//////////////////////////////////////////////
-void vfs_inode_remote_down( xptr_t  inode_xp )
-{
-    // get inode cluster and local pointer
-    cxy_t         inode_cxy = GET_CXY( inode_xp );
-    vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
-
-    hal_remote_atomic_add( XPTR( inode_cxy , &inode_ptr->refcount ) , -1 );    
-}
-
 //////////////////////////////////////////////
 uint32_t vfs_inode_get_size( xptr_t inode_xp )
@@ -303 +280 @@
 
     // get size
-    remote_rwlock_rd_acquire( XPTR( cxy , &ptr->data_lock ) );
+    remote_rwlock_rd_acquire( XPTR( cxy , &ptr->size_lock ) );
     uint32_t size = hal_remote_l32( XPTR( cxy , &ptr->size ) );
-    remote_rwlock_rd_release( XPTR( cxy , &ptr->data_lock ) );
+    remote_rwlock_rd_release( XPTR( cxy , &ptr->size_lock ) );
     return size;
 }
@@ -318 +295 @@
 
     // set size
-    remote_rwlock_wr_release( XPTR( cxy , &ptr->data_lock ) );
+    remote_rwlock_wr_release( XPTR( cxy , &ptr->size_lock ) );
     hal_remote_s32( XPTR( cxy , &ptr->size ) , size );
-    remote_rwlock_wr_release( XPTR( cxy , &ptr->data_lock ) );
+    remote_rwlock_wr_release( XPTR( cxy , &ptr->size_lock ) );
 }
 
@@ -345 +322 @@
 }
 
-/////////////////////////////////////////
-void vfs_inode_get_name( xptr_t inode_xp,
-                         char * name )
-{
-    cxy_t          inode_cxy;
-    vfs_inode_t  * inode_ptr;
-    xptr_t         dentry_xp;
-    cxy_t          dentry_cxy;
-    vfs_dentry_t * dentry_ptr;
+///////////////////////////////////////////
+void vfs_inode_get_name( xptr_t   inode_xp,
+                         char   * name )
+{
+    cxy_t          inode_cxy;          // inode cluster identifier 
+    vfs_inode_t  * inode_ptr;          // local pointer on inode
+    xptr_t         parents_root_xp;    // extended pointer on inode parents root
     
     // get inode cluster and local pointer
@@ -359 +334 @@
     inode_ptr = GET_PTR( inode_xp );
 
-    // get parent dentry
-    dentry_xp  = hal_remote_l64( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
-
-    // get local copy of name
-    if( dentry_xp == XPTR_NULL )  // it is the VFS root
+    // build extended pointer on parents dentries root
+    parents_root_xp  = XPTR( inode_cxy , &inode_ptr->parents );
+
+    // check VFS root 
+    if( xlist_is_empty( parents_root_xp ) )  // inode is the VFS root
     {
         strcpy( name , "/" );
     }
-    else                          // not the VFS root
-    {
+    else                                     // not the VFS root
+    {
+        xptr_t         dentry_xp;
+        cxy_t          dentry_cxy;
+        vfs_dentry_t * dentry_ptr;
+
+        // get first name in list of parents
+        dentry_xp  = XLIST_FIRST( parents_root_xp , vfs_dentry_t , parents );
         dentry_cxy = GET_CXY( dentry_xp );
         dentry_ptr = GET_PTR( dentry_xp );
 
         hal_remote_strcpy( XPTR( local_cxy  , name ) , 
-                           XPTR( dentry_cxy , &dentry_ptr->name ) );
-    }
+                           XPTR( dentry_cxy , dentry_ptr->name ) );
+    }
+
 }  // end vfs_inode_get_name()
 
@@ -433 +415 @@
 error_t vfs_dentry_create( vfs_fs_type_t   fs_type,
                            char          * name,
-                           vfs_inode_t   * parent,
                            xptr_t        * dentry_xp )
 {
@@ -439 +420 @@
     vfs_dentry_t   * dentry;     // dentry descriptor (to be allocated)
         kmem_req_t       req;        // request to kernel memory allocator
-    error_t          error;
 
 #if DEBUG_VFS_DENTRY_CREATE
@@ -456 +436 @@
     {
         ctx = NULL;
-        return EINVAL;
+        return -1;
     }
 
@@ -470 +450 @@
         dentry     = (vfs_dentry_t *)kmem_alloc( &req );
 
-    if( dentry == NULL ) return ENOMEM;
+    if( dentry == NULL ) 
+    {
+        printk("\n[ERROR] in %s : cannot allocate dentry descriptor\n",
+        __FUNCTION__ );
+        return -1;
+    }
 
     // initialize dentry descriptor
-
     dentry->ctx     = ctx;
     dentry->length  = length;
-    dentry->parent  = parent;
     dentry->extend  = NULL;
     strcpy( dentry->name , name );
-
-#if( DEBUG_VFS_DENTRY_CREATE & 1 )
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VFS_DENTRY_CREATE < cycle )
-printk("\n[%s] thread[%x,%x] / dentry <%s> initialised / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, dentry->name, cycle );
-#endif
-
-    // register dentry in hash table rooted in parent inode
-    error = xhtab_insert( XPTR( local_cxy , &parent->children ),
-                          name, 
-                          XPTR( local_cxy , &dentry->list ) );
-
-    if( error ) return EINVAL;
-
-#if( DEBUG_VFS_DENTRY_CREATE & 1 )
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VFS_DENTRY_CREATE < cycle )
-printk("\n[%s] thread[%x,%x] / dentry <%s> registered / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, dentry->name, cycle );
-#endif
 
     // return extended pointer on dentry 
@@ -518 +480 @@
 void vfs_dentry_destroy( vfs_dentry_t * dentry )
 {
-
-// check dentry refcount
-assert( (dentry->refcount == 0) , "dentry refcount non zero\n" );
-
-    // get pointer on parent inode
-    vfs_inode_t * parent = dentry->parent;
-
-    // remove this dentry from parent inode htab
-    xhtab_remove( XPTR( local_cxy , &parent->children ),
-                  dentry->name,
-                  XPTR( local_cxy , &dentry->list ) ); 
-
     // release memory allocated to dentry
         kmem_req_t req;
@@ -537 +487 @@
 
 }  // end vfs_dentry_destroy()
-
-//////////////////////////////////////////////
-void vfs_dentry_remote_up( xptr_t  dentry_xp )
-{
-    // get dentry cluster and local pointer
-    cxy_t          dentry_cxy = GET_CXY( dentry_xp );
-    vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
-
-    hal_remote_atomic_add( XPTR( dentry_cxy , &dentry_ptr->refcount ) , 1 );    
-}
-
-////////////////////////////////////////////////
-void vfs_dentry_remote_down( xptr_t  dentry_xp )
-{
-    // get dentry cluster and local pointer
-    cxy_t          dentry_cxy = GET_CXY( dentry_xp );
-    vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
-
-    hal_remote_atomic_add( XPTR( dentry_cxy , &dentry_ptr->refcount ) , -1 );    
-}
-
 
 
@@ -616 +545 @@
 void vfs_file_destroy( vfs_file_t *  file )
 {
-    if( file->refcount )
-    {
-        assert( false , "refcount non zero\n" );
-    }       
+
+// check refcount
+assert( (file->refcount == 0) , "refcount non zero\n" );
 
         kmem_req_t req;
@@ -664 +592 @@
 
 //////////////////////////////////////
-error_t vfs_open( process_t * process,
+error_t vfs_open( xptr_t      root_xp,
                           char      * path,
+                  xptr_t      process_xp,
                           uint32_t    flags,
                   uint32_t    mode, 
@@ -671 +600 @@
                   uint32_t  * new_file_id )
 {
-    error_t       error;
-    xptr_t        inode_xp;     // extended pointer on target inode
-    cxy_t         inode_cxy;    // inode cluster identifier       
-    vfs_inode_t * inode_ptr;    // inode local pointer
-    uint32_t      file_attr;    // file descriptor attributes
-    uint32_t      lookup_mode;  // lookup working mode        
-    xptr_t        file_xp;      // extended pointer on created file descriptor
-    uint32_t      file_id;      // created file descriptor index in reference fd_array
-
+    error_t        error;
+    xptr_t         inode_xp;       // extended pointer on target inode
+    cxy_t          inode_cxy;      // inode cluster identifier       
+    vfs_inode_t  * inode_ptr;      // inode local pointer
+    uint32_t       file_attr;      // file descriptor attributes
+    uint32_t       lookup_mode;    // lookup working mode        
+    xptr_t         file_xp;        // extended pointer on created file descriptor
+    uint32_t       file_id;        // created file descriptor index in reference fd_array
+    xptr_t         vfs_root_xp;    // extended pointer on VFS root inode
+    vfs_inode_t  * vfs_root_ptr;   // local pointer on VFS root inode
+    cxy_t          vfs_root_cxy;   // VFS root inode cluster identifier
+    xptr_t         lock_xp;        // extended pointer on Inode Tree lock 
 
     if( mode != 0 )
@@ -687 +619 @@
     }
 
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+
 #if DEBUG_VFS_OPEN
-thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_OPEN < cycle )
-printk("\n[%s]   thread[%x,%x] enter for <%s> / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, path, cycle );
+printk("\n[%s] thread[%x,%x] enter for <%s> / root_inode (%x,%x) / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, path, GET_CXY(root_xp), GET_PTR(root_xp), cycle );
 #endif
 
@@ -709 +643 @@
     if( (flags & O_CLOEXEC)      )  file_attr |= FD_ATTR_CLOSE_EXEC;
 
+    // build extended pointer on lock protecting Inode Tree
+    vfs_root_xp  = process->vfs_root_xp;
+    vfs_root_ptr = GET_PTR( vfs_root_xp );
+    vfs_root_cxy = GET_CXY( vfs_root_xp );
+    lock_xp      = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
+
+    // take lock protecting Inode Tree in read mode
+    remote_rwlock_rd_acquire( lock_xp );
+
     // get extended pointer on target inode
-    error = vfs_lookup( process->vfs_cwd_xp , path , lookup_mode , &inode_xp );
-
-    if( error ) return error;
+    error = vfs_lookup( root_xp,
+                        path,
+                        lookup_mode,
+                        &inode_xp,
+                        NULL );
+
+    // release lock protecting Inode Tree
+    remote_rwlock_rd_release( lock_xp );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot get inode <%s>\n",
+        __FUNCTION__ , path );
+        return -1;
+    }
 
     // get target inode cluster and local pointer
@@ -718 +673 @@
     inode_ptr = GET_PTR( inode_xp );
     
+#if (DEBUG_VFS_OPEN & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_OPEN < cycle )
+printk("\n[%s] thread[%x,%x] found inode(%x,%x) for <%s>\n",
+__FUNCTION__, process->pid, this->trdid, inode_cxy, inode_ptr, path );
+#endif
+
     // create a new file descriptor in cluster containing inode
     if( inode_cxy == local_cxy )      // target cluster is local
@@ -730 +692 @@
     if( error )  return error;
 
+#if (DEBUG_VFS_OPEN & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_OPEN < cycle )
+printk("\n[%s] thread[%x,%x] created file descriptor (%x,%x) for <%s>\n",
+__FUNCTION__, process->pid, this->trdid, GET_CXY(file_xp), GET_PTR(file_xp), path );
+#endif
+
     // allocate and register a new file descriptor index in reference process
-    error = process_fd_register( process , file_xp , &file_id );
+    error = process_fd_register( process_xp , file_xp , &file_id );
 
     if( error ) return error;
@@ -738 +707 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_OPEN < cycle )
-printk("\n[%s]   thread[%x,%x] exit for <%s> / fdid %d / cluster %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, path, file_id, GET_CXY( file_xp ), cycle );
+printk("\n[%s] thread[%x,%x] exit for <%s> / fdid %d / cluster %x / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, path, file_id, GET_CXY( file_xp ), cycle );
 #endif
 
@@ -780 +749 @@
 
     // 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_user_client( file_cxy,
-                                     mapper,
-                                     to_buffer,
-                                     file_offset,
-                                     buffer,
-                                     size,
-                                     &error );
-    } 
+    error = mapper_move_user( XPTR( file_cxy , mapper ),
+                              to_buffer,
+                              file_offset,
+                              buffer,
+                              size );
 
     // update file offset in file descriptor
@@ -834 +790 @@
     // get inode type from remote file descriptor
     inode_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type   ) );
-   
+
     // action depends on inode type
     if( inode_type == INODE_TYPE_FILE )
@@ -1044 +1000 @@
 
 ////////////////////////////////////
-error_t vfs_unlink( xptr_t   cwd_xp,
+error_t vfs_mkdir( xptr_t   root_xp,
+                   char   * path,
+                   uint32_t rights )
+{
+    error_t        error;
+    xptr_t         vfs_root_xp;        // extended pointer on VFS root inode
+    vfs_inode_t  * vfs_root_ptr;       // local pointer on VFS root inode
+    cxy_t          vfs_root_cxy;       // VFS root inode cluster identifier
+    xptr_t         lock_xp;            // extended pointer on lock protecting Inode Tree
+    xptr_t         inode_xp;           // extended pointer on target inode
+    vfs_inode_t  * inode_ptr;          // local pointer on target inode
+    cxy_t          inode_cxy;          // target inode cluster identifier
+    xptr_t         dentry_xp;          // extended pointer on new dentry
+    vfs_dentry_t * dentry_ptr;         // target dentry local pointer
+    xptr_t         parent_xp;          // extended pointer on new parent inode
+    vfs_inode_t  * parent_ptr;         // local pointer on new parent inode  
+    cxy_t          parent_cxy;         // new parent inode cluster identifier
+    vfs_ctx_t    * parent_ctx_ptr;     // local pointer on target inode context
+    uint32_t       parent_fs_type;     // target inode file system type
+
+    xptr_t         parents_root_xp;    // extended pointer on parents field in inode (root)
+    xptr_t         parents_entry_xp;   // extended pointer on parents field in dentry
+    xptr_t         children_xhtab_xp;  // extended pointer on children field in inode (root)
+    xptr_t         children_entry_xp;  // extended pointer on children field in dentry
+
+    char           last_name[CONFIG_VFS_MAX_NAME_LENGTH];
+
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+
+#if DEBUG_VFS_MKDIR
+char root_name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( root_xp , root_name );
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_MKDIR < cycle )
+printk("\n[%s] thread[%x,%x] enter / root <%s> / path <%s> / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, root_name, path, cycle );
+#endif
+
+    // build extended pointer on lock protecting Inode Tree (in VFS root inode)
+    vfs_root_xp  = process->vfs_root_xp;
+    vfs_root_ptr = GET_PTR( vfs_root_xp );
+    vfs_root_cxy = GET_CXY( vfs_root_xp );
+    lock_xp      = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
+
+    // take the lock protecting Inode Tree in write mode
+    remote_rwlock_wr_acquire( lock_xp );
+
+    // 1. get pointers on parent inode
+    error = vfs_lookup( root_xp,
+                        path,
+                        VFS_LOOKUP_DIR | VFS_LOOKUP_PARENT,
+                        &parent_xp,
+                        last_name );
+    if( error )
+    {
+        remote_rwlock_wr_release( lock_xp );
+        printk("\n[ERROR] in %s : cannot get parent inode for <%s>\n",
+        __FUNCTION__, path );
+        return -1;
+    }
+
+    // get parent inode cluster and local pointer
+    parent_cxy = GET_CXY( parent_xp );
+    parent_ptr = GET_PTR( parent_xp );
+
+#if( DEBUG_VFS_MKDIR & 1 )
+if( DEBUG_VFS_MKDIR < cycle )
+printk("\n[%s] thread[%x,%x] get parent inode (%x,%x) for <%s>\n",
+__FUNCTION__, process->pid, this->trdid, parent_cxy, parent_ptr, path );
+#endif
+
+    // get parent inode context, and FS type
+    parent_ctx_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
+    parent_fs_type = hal_remote_l32( XPTR( parent_cxy , &parent_ctx_ptr->type ) );
+
+    // 2. create one new dentry in parent cluster
+    if( parent_cxy == local_cxy )  
+    {
+        error = vfs_dentry_create( parent_fs_type,
+                                   last_name,
+                                   &dentry_xp );
+    }
+    else
+    {
+        rpc_vfs_dentry_create_client( parent_cxy,
+                                      parent_fs_type,
+                                      last_name,
+                                      &dentry_xp,
+                                      &error );
+    }
+
+    if( error )
+    {
+        remote_rwlock_wr_release( lock_xp );
+        printk("\n[ERROR] in %s : cannot create new dentry in cluster %x for <%s>\n",
+        __FUNCTION__, parent_cxy, path );
+        return -1;
+    }
+
+    // get local pointer on dentry 
+    dentry_ptr = GET_PTR( dentry_xp );
+
+#if( DEBUG_VFS_MKDIR & 1 )
+if( DEBUG_VFS_MKDIR < cycle )
+printk("\n[%s] thread[%x,%x] created new dentry (%x,%x) for <%s>\n",
+__FUNCTION__, process->pid, this->trdid, parent_cxy, dentry_ptr, path );
+#endif
+
+    // 3. create new directory inode in child cluster
+    // TODO : define attr / uid / gid
+    uint32_t attr = 0;
+    uint32_t uid  = 0;
+    uint32_t gid  = 0;
+
+    // select a target cluster for new inode
+    inode_cxy = cluster_random_select();
+    
+    if( inode_cxy == local_cxy )      // child cluster is local 
+    {
+        error = vfs_inode_create( parent_fs_type,
+                                  INODE_TYPE_DIR,
+                                  attr,
+                                  rights,
+                                  uid,
+                                  gid,
+                                  &inode_xp );
+    }
+    else                              // child cluster is remote
+    {
+        rpc_vfs_inode_create_client( inode_cxy,
+                                     parent_fs_type,
+                                     INODE_TYPE_DIR,
+                                     attr,
+                                     rights,
+                                     uid,
+                                     gid,
+                                     &inode_xp,
+                                     &error );
+    }
+                                     
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot create new inode in cluster %x for <%s>\n",
+               __FUNCTION__ , inode_cxy , path );
+ 
+        if( parent_cxy == local_cxy ) vfs_dentry_destroy( dentry_ptr );
+        else rpc_vfs_dentry_destroy_client( parent_cxy , dentry_ptr );
+        return -1;
+    }
+
+    // get new inode local pointer
+    inode_ptr = GET_PTR( inode_xp );
+    
+#if(DEBUG_VFS_MKDIR & 1)
+if( DEBUG_VFS_MKDIR < cycle )
+printk("\n[%s] thread[%x,%x] created new inode (%x,%x) for <%s>\n",
+__FUNCTION__ , process->pid, this->trdid, inode_cxy, inode_ptr, path );
+#endif
+
+    // 4. register dentry in new inode list of parents
+    parents_root_xp  = XPTR( inode_cxy  , &inode_ptr->parents );
+    parents_entry_xp = XPTR( parent_cxy , &dentry_ptr->parents );
+    xlist_add_first( parents_root_xp , parents_entry_xp );
+    hal_remote_atomic_add( XPTR( inode_cxy , &inode_ptr->links ) , 1 );
+
+    // 5. register dentry in parent inode 
+    children_xhtab_xp = XPTR( parent_cxy , &parent_ptr->children );
+    children_entry_xp = XPTR( parent_cxy , &dentry_ptr->children );
+    xhtab_insert( children_xhtab_xp , last_name , children_entry_xp );
+
+    // 6. update "parent" and "child_xp" fields in dentry
+    hal_remote_s64( XPTR( parent_cxy , &dentry_ptr->child_xp ) , inode_xp );
+    hal_remote_spt( XPTR( parent_cxy , &dentry_ptr->parent ) , parent_ptr );
+
+#if(DEBUG_VFS_MKDIR & 1)
+if( DEBUG_VFS_MKDIR < cycle )
+printk("\n[%s] thread[%x,%x] updated Inode Tree for <%s>\n",
+__FUNCTION__, process->pid, this->trdid, path );
+#endif
+
+    // release the lock protecting Inode Tree
+    remote_rwlock_wr_release( lock_xp );
+
+    // 5. update parent directory mapper 
+    //    and synchronize the parent directory on IOC device
+    if (parent_cxy == local_cxy)
+    {
+        error = vfs_fs_add_dentry( parent_ptr,
+                                   dentry_ptr );
+    }
+    else
+    {
+        rpc_vfs_fs_add_dentry_client( parent_cxy,
+                                      parent_ptr,
+                                      dentry_ptr,
+                                      &error );
+    }
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot update parent directory for <%s>\n",
+        __FUNCTION__, path );
+        return -1;
+    }
+
+#if(DEBUG_VFS_MKDIR & 1)
+if( DEBUG_VFS_MKDIR < cycle )
+printk("\n[%s] thread[%x,%x] updated parent dir (mapper and IOC) for <%s>\n",
+__FUNCTION__, process->pid, this->trdid, path );
+#endif
+
+    return 0;
+
+}  // end vfs_mkdir()
+
+///////////////////////////////////////
+error_t vfs_link( xptr_t   old_root_xp,
+                  char   * old_path,
+                  xptr_t   new_root_xp,
+                  char   * new_path )
+{
+    error_t        error;
+    xptr_t         vfs_root_xp;        // extended pointer on VFS root inode
+    vfs_inode_t  * vfs_root_ptr;       // local pointer on VFS root inode
+    cxy_t          vfs_root_cxy;       // VFS root inode cluster identifier
+    xptr_t         lock_xp;            // extended pointer on lock protecting Inode Tree
+    xptr_t         inode_xp;           // extended pointer on target inode
+    vfs_inode_t  * inode_ptr;          // local pointer on target inode
+    cxy_t          inode_cxy;          // target inode cluster identifier
+    uint32_t       inode_type;         // target inode type
+    vfs_ctx_t    * inode_ctx_ptr;      // local pointer on target inode context
+    uint32_t       inode_fs_type;      // target inode file system type
+    xptr_t         dentry_xp;          // extended pointer on new dentry
+    vfs_dentry_t * dentry_ptr;         // target dentry local pointer
+    xptr_t         new_parent_xp;      // extended pointer on new parent inode
+    vfs_inode_t  * new_parent_ptr;     // local pointer on new parent inode  
+    cxy_t          new_parent_cxy;     // new parent inode cluster identifier
+
+    xptr_t         parents_root_xp;    // extended pointer on parents field in inode (root)
+    xptr_t         parents_entry_xp;   // extended pointer on parents field in dentry
+    xptr_t         children_xhtab_xp;  // extended pointer on children field in inode (root)
+    xptr_t         children_entry_xp;  // extended pointer on children field in dentry
+
+    char           new_name[CONFIG_VFS_MAX_NAME_LENGTH];
+
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+
+#if DEBUG_VFS_LINK
+char old_root_name[CONFIG_VFS_MAX_NAME_LENGTH];
+char new_root_name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( old_root_xp , old_root_name );
+vfs_inode_get_name( new_root_xp , new_root_name );
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_LINK < cycle )
+printk("\n[%s] thread[%x,%x] enter / old_root <%s> / old_path <%s> / "
+"new_root <%s> / new_path <%s> / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid,
+old_root_name, old_path, new_root_name, new_path, cycle );
+#endif
+
+    // build extended pointer on lock protecting Inode Tree (in VFS root inode)
+    vfs_root_xp  = process->vfs_root_xp;
+    vfs_root_ptr = GET_PTR( vfs_root_xp );
+    vfs_root_cxy = GET_CXY( vfs_root_xp );
+    lock_xp      = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
+
+    // take the lock protecting Inode Tree in write mode
+    remote_rwlock_wr_acquire( lock_xp );
+
+    // get extended pointer on target inode
+    error = vfs_lookup( old_root_xp,
+                        old_path,
+                        0,
+                        &inode_xp,
+                        NULL );
+    if( error )
+    {
+        remote_rwlock_wr_release( lock_xp );
+        printk("\n[ERROR] in %s : cannot get target inode for <%s>\n",
+        __FUNCTION__, old_path );
+        return -1;
+    }
+
+#if( DEBUG_VFS_LINK & 1 )
+if( DEBUG_VFS_LINK < cycle )
+printk("\n[%s] thread[%x,%x] get child inode (%x,%x) for <%s>\n",
+__FUNCTION__, process->pid, this->trdid,
+GET_CXY(inode_xp), GET_PTR(inode_xp), old_path, cycle );
+#endif
+
+    // get extended pointer on parent inode in new path
+    error = vfs_lookup( new_root_xp,
+                        new_path,
+                        VFS_LOOKUP_PARENT,
+                        &new_parent_xp,
+                        new_name );
+    if( error )
+    {
+        remote_rwlock_wr_release( lock_xp );
+        printk("\n[ERROR] in %s : cannot get parent inode for <%s>\n",
+        __FUNCTION__, new_path );
+        return -1;
+    }
+
+#if( DEBUG_VFS_LINK & 1 )
+if( DEBUG_VFS_LINK < cycle )
+printk("\n[%s] thread[%x,%x] get parent inode (%x,%x) for <%s>\n",
+__FUNCTION__, process->pid, this->trdid,
+GET_CXY(new_parent_xp), GET_PTR(new_parent_xp), new_path );
+#endif
+
+    // get target inode cluster and local pointer
+    inode_cxy = GET_CXY( inode_xp );
+    inode_ptr = GET_PTR( inode_xp );
+
+    // get target inode type, context, and FS type
+    inode_type        = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
+    inode_ctx_ptr     = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->ctx ) );
+    inode_fs_type     = hal_remote_l32( XPTR( inode_cxy , &inode_ctx_ptr->type ) );
+
+    // get new parent inode cluster an local pointer
+    new_parent_ptr = GET_PTR( new_parent_xp );
+    new_parent_cxy = GET_CXY( new_parent_xp );
+
+    ///////////////////////////////////////////////////////////////////////
+    if( (inode_type == INODE_TYPE_FILE) || (inode_type == INODE_TYPE_DIR) )
+    {
+        // 1. create one new dentry
+        if( new_parent_cxy == local_cxy )  
+        {
+            error = vfs_dentry_create( inode_fs_type,
+                                       new_name,
+                                       &dentry_xp );
+        }
+        else
+        {
+            rpc_vfs_dentry_create_client( new_parent_cxy,
+                                          inode_fs_type,
+                                          new_name,
+                                          &dentry_xp,
+                                          &error );
+        }
+
+        if( error )
+        {
+            remote_rwlock_wr_release( lock_xp );
+            printk("\n[ERROR] in %s : cannot create new dentry for <%s>\n",
+            __FUNCTION__, new_path );
+            return -1;
+        }
+
+        // get local pointer on dentry 
+        dentry_ptr = GET_PTR( dentry_xp );
+
+        // 2. register dentry in target inode 
+        parents_root_xp  = XPTR( inode_cxy      , &inode_ptr->parents );
+        parents_entry_xp = XPTR( new_parent_cxy , &dentry_ptr->parents );
+        xlist_add_first( parents_root_xp , parents_entry_xp );
+        hal_remote_atomic_add( XPTR( inode_cxy , &inode_ptr->links ) , 1 );
+
+        // 3. register dentry in parent inode 
+        children_xhtab_xp = XPTR( new_parent_cxy , &new_parent_ptr->children );
+        children_entry_xp = XPTR( new_parent_cxy , &dentry_ptr->children );
+        xhtab_insert( children_xhtab_xp , new_name , children_entry_xp );
+
+        // 4. update "parent" and "child_xp" fields in dentry
+        hal_remote_s64( XPTR( new_parent_cxy , &dentry_ptr->child_xp ) , inode_xp );
+        hal_remote_spt( XPTR( new_parent_cxy , &dentry_ptr->parent ) , new_parent_ptr );
+
+#if(DEBUG_VFS_LINK & 1)
+if( DEBUG_VFS_LINK < cycle )
+printk("\n[%s] thread[%x,%x] updated Inode Tree / old <%s> / new <%s>\n",
+__FUNCTION__, process->pid, this->trdid, old_path, new_path );
+vfs_display( new_parent_xp ); 
+#endif
+
+        // release the lock protecting Inode Tree
+        remote_rwlock_wr_release( lock_xp );
+
+        // 5. update new parent directory mapper in Inode Tree
+        //    and synchronize the parent directory on IOC device
+        if (new_parent_cxy == local_cxy)
+        {
+            error = vfs_fs_add_dentry( new_parent_ptr,
+                                       dentry_ptr );
+        }
+        else
+        {
+            rpc_vfs_fs_add_dentry_client( new_parent_cxy,
+                                          new_parent_ptr,
+                                          dentry_ptr,
+                                          &error );
+        }
+        if( error )
+        {
+            printk("\n[ERROR] in %s : cannot update new parent directory for <%s>\n",
+            __FUNCTION__, new_path );
+            return -1;
+        }
+
+#if(DEBUG_VFS_LINK & 1)
+if( DEBUG_VFS_LINK < cycle )
+printk("\n[%s] thread[%x,%x] updated new parent dir (mapper and IOC) / old <%s> / new <%s>\n",
+__FUNCTION__, process->pid, this->trdid, old_path, new_path );
+#endif
+        return 0;
+    }
+    else
+    {
+        // release the lock protecting Inode Tree
+        remote_rwlock_wr_release( lock_xp );
+
+        printk("\n[ERROR] in %s : unsupported inode type %s\n",
+        __FUNCTION__ , vfs_inode_type_str( inode_type ) );
+        return -1;
+    }
+
+}  // end vfs_link()
+
+/////////////////////////////////////
+error_t vfs_unlink( xptr_t   root_xp,
                     char   * path )
 {
     error_t           error;
+    xptr_t            vfs_root_xp;        // extended pointer on VFS root inode
+    vfs_inode_t     * vfs_root_ptr;       // local_pointer on VFS root inode
+    cxy_t             vfs_root_cxy;       // VFS root inode cluster identifier
+    xptr_t            lock_xp;            // extended pointer on lock protecting Inode Tree
+    xptr_t            parent_xp;          // extended pointer on target inode
+    cxy_t             parent_cxy;         // target inode cluster identifier       
+    vfs_inode_t     * parent_ptr;         // target inode local pointer
     xptr_t            inode_xp;           // extended pointer on target inode
     cxy_t             inode_cxy;          // target inode cluster identifier       
     vfs_inode_t     * inode_ptr;          // target inode local pointer
-    uint32_t          inode_refcount;     // target inode refcount
-    vfs_inode_type_t  type;               // target inode type
-    mapper_t        * mapper;             // pointer on target inode mapper
-    xptr_t            dentry_xp;          // extended pointer on target dentry
-    cxy_t             dentry_cxy;         // target dentry cluster identifier
-    vfs_dentry_t    * dentry_ptr;         // target dentry local pointer
-    uint32_t          dentry_refcount;    // target dentry refcount
-    vfs_inode_t     * dentry_parent_ptr;  // parent inode local pointer
+    uint32_t          inode_links;        // target inode links count
+    vfs_inode_type_t  inode_type;         // target inode type
+    uint32_t          inode_children;     // target inode number of children
+    xptr_t            dentry_xp;          // extended pointer on dentry to unlink
+    vfs_dentry_t    * dentry_ptr;         // local pointer on dentry to unlink
+
+    char              name[CONFIG_VFS_MAX_NAME_LENGTH];  // name of link to remove
+
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
 
 #if DEBUG_VFS_UNLINK
-thread_t * this  = CURRENT_THREAD;
 uint32_t   cycle = (uint32_t)hal_get_cycles();
+char root_name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( root_xp , root_name );
 if( DEBUG_VFS_UNLINK < cycle )
-printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, path, cycle );
-#endif
-
-    // get extended pointer on target inode
-    error = vfs_lookup( cwd_xp , path , 0 , &inode_xp );
-
-    if( error ) return error;
-
-    // get inode cluster and local pointer
+printk("\n[%s] thread[%x,%x] enter / root <%s> / path <%s> / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, root_name, path, cycle );
+#endif
+
+    // build extended pointer on lock protecting Inode Tree (in VFS root inode)
+    vfs_root_xp  = process->vfs_root_xp;
+    vfs_root_ptr = GET_PTR( root_xp );
+    vfs_root_cxy = GET_CXY( root_xp );
+    lock_xp      = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
+
+    // take the lock protecting Inode Tree
+    remote_rwlock_wr_acquire( lock_xp );
+
+    // get extended pointer on parent inode
+    error = vfs_lookup( root_xp,
+                        path,
+                        VFS_LOOKUP_PARENT,
+                        &parent_xp,
+                        name );
+    if( error ) 
+    {
+        remote_rwlock_wr_release( lock_xp );
+        printk("\n[ERROR] in %s : cannot get parent inode for <%s> in <%s>\n",
+        __FUNCTION__, name, path );
+        return -1;
+    }
+
+    // get parent inode cluster and local pointer
+    parent_cxy = GET_CXY( parent_xp );
+    parent_ptr = GET_PTR( parent_xp );
+ 
+#if( DEBUG_VFS_UNLINK & 1 )
+char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( parent_xp , parent_name );
+if( DEBUG_VFS_UNLINK < cycle )
+printk("\n[%s] thread[%x,%x] parent inode <%s> is (%x,%x)\n",
+__FUNCTION__, process->pid, this->trdid, parent_name, parent_cxy, parent_ptr );
+#endif
+
+    // build extended pointer on parent inode "children" xhtab
+    xptr_t children_xp = XPTR( parent_cxy , &parent_ptr->children );
+
+    // get extended pointer on dentry to unlink
+    dentry_xp = xhtab_lookup( children_xp , name );
+    
+    if( dentry_xp == XPTR_NULL )
+    {
+        remote_rwlock_wr_release( lock_xp );
+        printk("\n[ERROR] in %s : cannot get target dentry <%s> in <%s>\n",
+        __FUNCTION__, name, path );
+        return -1;
+    }
+    
+    // get local pointer on dentry to unlink
+    dentry_ptr = GET_PTR( dentry_xp );
+
+#if( DEBUG_VFS_UNLINK & 1 )
+if( DEBUG_VFS_UNLINK < cycle )
+printk("\n[%s] thread[%x,%x] dentry <%s> to unlink is (%x,%x)\n",
+__FUNCTION__, process->pid, this->trdid, name, parent_cxy, dentry_ptr );
+#endif
+
+    // get pointer on target inode
+    inode_xp  = hal_remote_l64( XPTR( parent_cxy , &dentry_ptr->child_xp ) );
     inode_cxy = GET_CXY( inode_xp );
     inode_ptr = GET_PTR( inode_xp );
-
-    // get inode type, refcount, mapper, dentry_xp
-    type              = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
-    inode_refcount    = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->refcount ) );
-    mapper            = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
-    dentry_xp         = hal_remote_l64( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
-
-    // get dentry cluster, local pointer, refcount, and pointers on parent inode
-    dentry_ptr        = GET_PTR( dentry_xp );
-    dentry_cxy        = GET_CXY( dentry_xp );
-    dentry_refcount   = hal_remote_l32( XPTR( dentry_cxy , &dentry_ptr->refcount ) );
-    dentry_parent_ptr = hal_remote_lpt( XPTR( dentry_cxy , &dentry_ptr->parent ) );
-
-// check inode & dentry refcount
-assert( (inode_refcount  == 1), "illegal inode refcount for <%s>\n", path );
-assert( (dentry_refcount == 1), "illegal dentry refcount for <%s>\n", path );
-
-    /////////////////////////////
-    if( type == INODE_TYPE_FILE )
-    {
-        // 1. release clusters allocated to file in the FAT mapper
-        //    synchronize the FAT on IOC device 
-        error = vfs_fs_release_inode( inode_xp ); 
-        if( error )
+ 
+#if( DEBUG_VFS_UNLINK & 1 )
+char inode_name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( inode_xp , inode_name );
+if( DEBUG_VFS_UNLINK < cycle )
+printk("\n[%s] thread[%x,%x] target inode <%s> is (%x,%x) / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, inode_name, inode_cxy, inode_ptr, cycle );
+#endif
+
+    // get target inode "type" and "links"
+    inode_type   = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
+    inode_links  = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->links ) );
+
+// check target inode links counter
+assert( (inode_links >= 1), "illegal inode links count %d for <%s>\n", inode_links, path );
+
+    ///////////////////////////////////////////////////////////////////////
+    if( (inode_type == INODE_TYPE_FILE) || (inode_type == INODE_TYPE_DIR) )
+    {
+        // 1. Release clusters allocated to target inode 
+        //    and synchronize the FAT on IOC device if last link.
+        if( inode_links == 1 ) 
         {
-            printk("\n[ERROR] in %s : cannot update FAT mapper <%s>\n", path );
-            return -1;
-        }
+            // build extended pointer on target inode "children" number
+            xptr_t inode_children_xp = XPTR( inode_cxy , &inode_ptr->children.items );
+
+            // get target inode number of children 
+            inode_children = hal_remote_l32( inode_children_xp );
+
+            // check no children
+            if( inode_children != 0 )
+            {
+                remote_rwlock_wr_release( lock_xp );
+                printk("\n[ERROR] in %s : cannot remove <%s> inode that has children\n",
+                __FUNCTION__, path );
+                return -1;
+            }
+
+            // release clusters on IOC device
+            error = vfs_fs_release_inode( inode_xp ); 
+
+            if( error )
+            {
+                remote_rwlock_wr_release( lock_xp );
+                printk("\n[ERROR] in %s : cannot update FAT mapper to remove <%s> inode\n",
+                __FUNCTION__ , path );
+                return -1;
+            }
 
 #if(DEBUG_VFS_UNLINK & 1)
 if( DEBUG_VFS_UNLINK < cycle )
 printk("\n[%s] thread[%x,%x] removed <%s> inode from FAT (mapper and IOC device)\n",
-__FUNCTION__, this->process->pid, this->trdid, path );
-#endif
-
-        // 2. update parent directory in Inode Tree
-        //    synchronize the parent directory on IOC device
-        if (dentry_cxy == local_cxy)                           // dentry is local
+__FUNCTION__, process->pid, this->trdid, path );
+#endif
+        }
+
+        // 2. update parent directory mapper
+        //    and synchronize the parent directory on IOC device
+        if (parent_cxy == local_cxy)
         {
-            error = vfs_fs_remove_dentry( dentry_parent_ptr,
+            error = vfs_fs_remove_dentry( parent_ptr,
                                           dentry_ptr );
         }
-        else                                                  // dentry is remote
+        else            
         {
-            rpc_vfs_fs_remove_dentry_client( dentry_cxy,
-                                             dentry_parent_ptr,
+            rpc_vfs_fs_remove_dentry_client( parent_cxy,
+                                             parent_ptr,
                                              dentry_ptr,
                                              &error );
         }
+
         if( error )
         {
-            printk("\n[ERROR] in %s : cannot update dentry on device for <%s>\n", path );
+            remote_rwlock_wr_release( lock_xp );
+            printk("\n[ERROR] in %s : cannot update dentry on device for <%s>\n",
+            __FUNCTION__ , path );
             return -1;
         }
@@ -1134 +1600 @@
 if( DEBUG_VFS_UNLINK < cycle )
 printk("\n[%s] thread[%x,%x] removed <%s> inode from parent dir (mapper and IOC device)\n",
-__FUNCTION__, this->process->pid, this->trdid, path );
-#endif
-        // 3. remove inode (including mapper & dentry) from Inode Tree
-        vfs_remove_child_from_parent( inode_xp );
+__FUNCTION__, process->pid, this->trdid, path );
+#endif
+        // 3. remove dentry from Inode Tree (and associated chils inode when last link)
+        vfs_remove_child_from_parent( dentry_xp );
+
+        // release the lock protecting Inode Tree
+        remote_rwlock_wr_release( lock_xp );
 
 #if DEBUG_VFS_UNLINK
 if( DEBUG_VFS_UNLINK < cycle )
 printk("\n[%s] thread[%x,%x] exit / removed <%s> inode from Inode Tree / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, path, cycle );
+__FUNCTION__, process->pid, this->trdid, path, cycle );
 #endif
         return 0;
     }
-    /////////////////////////////////
-    else if( type == INODE_TYPE_DIR )
-    {
-        printk("\n[ERROR] in %s : unsupported type %s\n", vfs_inode_type_str( type ) );
+    else
+    {
+        remote_rwlock_wr_release( lock_xp );
+        printk("\n[ERROR] in %s : unsupported inode type %s\n",
+        __FUNCTION__ , vfs_inode_type_str( inode_type ) );
         return -1;
     }
-    ////
-    else
-    {
-        printk("\n[ERROR] in %s : unsupported type %s\n", vfs_inode_type_str( type ) );
+
+}  // end vfs_unlink() 
+
+///////////////////////////////////////////
+error_t vfs_stat( xptr_t     root_inode_xp,
+                  char     * path,
+                  stat_t   * st )
+{
+    error_t       error;
+    xptr_t        inode_xp;           // extended pointer on target inode
+    vfs_inode_t * inode_ptr;          // local pointer on target inode
+    cxy_t         inode_cxy;          // target inode cluster identifier
+    xptr_t        vfs_root_xp;        // extended pointer on VFS root inode
+    vfs_inode_t * vfs_root_ptr;       // local_pointer on VFS root inode
+    cxy_t         vfs_root_cxy;       // VFS root inode cluster identifier
+    xptr_t        lock_xp;            // extended pointer on lock protecting Inode Tree
+
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+
+    // build extended pointer on lock protecting Inode Tree (in VFS root inode)
+    vfs_root_xp  = process->vfs_root_xp;
+    vfs_root_ptr = GET_PTR( vfs_root_xp );
+    vfs_root_cxy = GET_CXY( vfs_root_xp );
+    lock_xp      = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
+
+    // get the lock protecting Inode Tree in read mode
+    remote_rwlock_rd_acquire( lock_xp );
+
+    // get extended pointer on target inode
+    error = vfs_lookup( root_inode_xp,
+                        path,
+                        0,
+                        &inode_xp,
+                        NULL );
+
+    // release the lock protecting Inode Tree
+    remote_rwlock_rd_release( lock_xp );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot found inode <%s>\n",
+        __FUNCTION__ , path );
         return -1;
     }
 
-}  // end vfs_unlink() 
-
-//////////////////////////////////////
-error_t vfs_stat( xptr_t     inode_xp,
-                  stat_t   * st )
-{
     // get cluster and local pointer on inode descriptor
-    vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
-    cxy_t         inode_cxy = GET_CXY( inode_xp );
+    inode_ptr = GET_PTR( inode_xp );
+    inode_cxy = GET_CXY( inode_xp );
 
     // get relevant infos from inode descriptor
@@ -1186 +1689 @@
 #if DEBUG_VFS_STAT
 uint32_t cycle  = (uint32_t)hal_get_cycles();
-thread_t * this = CURRENT_THREAD;
 if( DEBUG_VFS_STAT < cycle )
 printk("\n[%s] thread[%x,%x] set stat %x for inode %x in cluster %x / cycle %d\n"
        " %s / inum %d / size %d\n",
-__FUNCTION__, this->process->pid, this->trdid, st, inode_ptr, inode_cxy, cycle,
+__FUNCTION__, process->pid, this->trdid, st, inode_ptr, inode_cxy, cycle,
 vfs_inode_type_str( type ), inum, size );
 #endif
@@ -1207 +1709 @@
 }
 
-//////////////////////////////////////
-error_t vfs_mkdir( xptr_t     file_xp,
-                   char     * path,
-                   uint32_t   mode )
-{
-    assert( false , "not implemented file_xp: %x, path <%s>, mode: %x\n",
-      file_xp, path, mode );
-    return 0;
-}
-
 ////////////////////////////////////
 error_t vfs_rmdir( xptr_t   file_xp,
@@ -1226 +1718 @@
 }
 
-///////////////////////////////////
-error_t vfs_chdir( xptr_t   cwd_xp,
+////////////////////////////////////
+error_t vfs_chdir( xptr_t   root_xp,
                    char   * path )
 {
     error_t           error;
-    xptr_t            inode_xp;     // extended pointer on target inode
-    cxy_t             inode_cxy;    // target inode cluster identifier       
-    vfs_inode_t     * inode_ptr;    // target inode local pointer
-    uint32_t          mode;         // lookup working mode        
-    vfs_inode_type_t  inode_type;   // target inode type
-
-    // set lookup working mode
-    mode = 0;
+    xptr_t            inode_xp;           // extended pointer on target inode
+    cxy_t             inode_cxy;          // target inode cluster identifier       
+    vfs_inode_t     * inode_ptr;          // target inode local pointer
+    vfs_inode_type_t  inode_type;         // target inode type
+    xptr_t            vfs_root_xp;        // extended pointer on VFS root inode
+    vfs_inode_t     * vfs_root_ptr;       // local_pointer on VFS root inode
+    cxy_t             vfs_root_cxy;       // VFS root inode cluster identifier
+    xptr_t            main_lock_xp;       // extended pointer on lock protecting Inode Tree
+    xptr_t            ref_xp;             // extended pointer on reference process
+    process_t       * ref_ptr;            // local pointer on reference process
+    cxy_t             ref_cxy;            // reference process cluster
+    xptr_t            cwd_lock_xp;        // extended pointer on lock protecting CWD change
+    xptr_t            cwd_xp_xp;          // extended pointer on cwd_xp in reference process
+
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+
+#if DEBUG_VFS_CHDIR
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_CHDIR < cycle )
+printk("\n[%s] thread[%x,%x] enter for path <%s> / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, path, cycle );
+#endif
+
+    // build extended pointer on lock protecting Inode Tree (in VFS root inode)
+    vfs_root_xp  = process->vfs_root_xp;
+    vfs_root_ptr = GET_PTR( vfs_root_xp );
+    vfs_root_cxy = GET_CXY( vfs_root_xp );
+    main_lock_xp = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
+
+    // take lock protecting Inode Tree in read mode
+    remote_rwlock_rd_acquire( main_lock_xp );
 
     // get extended pointer on target inode
-    error = vfs_lookup( cwd_xp , path , mode , &inode_xp );
-
-    if( error ) return error;
-
-    // get inode cluster and local pointer
+    error = vfs_lookup( root_xp,
+                        path,
+                        VFS_LOOKUP_DIR,
+                        &inode_xp,
+                        NULL );
+
+    // release lock protecting Inode Tree in read mode
+    remote_rwlock_rd_release( main_lock_xp );
+
+    if( error ) 
+    {
+        printk("\n[ERROR] in %s : <%s> not found\n",
+        __FUNCTION__, path );
+        return -1;
+    }
+
+    // get inode type from remote file
     inode_cxy = GET_CXY( inode_xp );
     inode_ptr = GET_PTR( inode_xp );
-
-    // get inode type from remote file
     inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
 
     if( inode_type != INODE_TYPE_DIR )
     {
-        CURRENT_THREAD->errno = ENOTDIR;
+        printk("\n[ERROR] in %s : <%s> is not a directory\n",
+        __FUNCTION__, path );
         return -1;
     }
 
-    // TODO implement this function using process CWD lock
-
-assert( false , "not implemented\n" );
+    // build extended pointer on cwd_lock and cwd_xp 
+    ref_xp       = process->ref_xp;
+    ref_ptr      = GET_PTR( ref_xp );
+    ref_cxy      = GET_CXY( ref_xp );
+    cwd_lock_xp  = XPTR( ref_cxy , &ref_ptr->cwd_lock );
+    cwd_xp_xp    = XPTR( ref_cxy , &ref_ptr->cwd_xp );
+
+    // take lock protecting CWD changes
+    remote_busylock_acquire( cwd_lock_xp );
+
+    // update cwd_xp field in reference process descriptor
+    hal_remote_s64( cwd_xp_xp , inode_xp );
+
+    // release lock protecting CWD changes
+    remote_busylock_release( cwd_lock_xp );
+
+#if DEBUG_VFS_CHDIR
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_CHDIR < cycle )
+printk("\n[%s] thread[%x,%x] exit : inode (%x,%x) / &cwd_xp (%x,%x) / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, inode_cxy, inode_ptr, 
+GET_CXY(cwd_xp_xp), GET_PTR(cwd_xp_xp), cycle );
+#endif
 
     return 0;
-}
+
+}  // end vfs_chdir()
 
 ///////////////////////////////////
@@ -1281 +1829 @@
  
     // get extended pointer on target inode
-    error = vfs_lookup( cwd_xp , path , 0 , &inode_xp );
+    error = vfs_lookup( cwd_xp,
+                        path,
+                        0,
+                        &inode_xp,
+                        NULL );
 
     if( error ) return error;
@@ -1292 +1844 @@
     inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
 
-    
-    assert( false , "not implemented\n" );
+    // TODO implement this function
+
+assert( false , "not implemented\n" );
+
     return 0;
 }
@@ -1360 +1914 @@
 assert( (indent < 16)           , "depth cannot be larger than 15\n" );
     
-    // get inode cluster and local pointer
+    // get current inode cluster and local pointer
     inode_cxy = GET_CXY( inode_xp );
     inode_ptr = GET_PTR( inode_xp );
@@ -1428 +1982 @@
     cxy_t          dentry_cxy;
     vfs_dentry_t * dentry_ptr;
+    xptr_t         parents_root_xp;   // root of parent dentries xlist
 
     // get target inode cluster and local pointer 
@@ -1433 +1988 @@
     vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
 
-    // get extended pointer on associated dentry
-    dentry_xp   = hal_remote_l64( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
-
-    // check if target inode is the File System root
-    if( dentry_xp == XPTR_NULL )
+    // build extended pointer on parents dentries root
+    parents_root_xp = XPTR( inode_cxy , &inode_ptr->parents );
+
+    // check VFS root     
+    if( xlist_is_empty( parents_root_xp ) )  // inode is the VFS root
     {
         // build extended pointer on root name
@@ -1444 +1999 @@
     else
     {
-        // get dentry cluster and local pointer
+        // get first parent dentry cluster and pointers
+        dentry_xp  = XLIST_FIRST( parents_root_xp , vfs_dentry_t , parents );
         dentry_cxy = GET_CXY( dentry_xp );
         dentry_ptr = GET_PTR( dentry_xp );
@@ -1520 +2076 @@
                              xptr_t * child_xp )
 {
-    xptr_t  xhtab_xp;    // extended pointer on hash table containing children dentries
-    xptr_t  dentry_xp;   // extended pointer on children dentry
+    xptr_t         xhtab_xp;    // extended pointer on hash table for children dentries
+    xptr_t         dentry_xp;   // extended pointer on children dentry
+    cxy_t          dentry_cxy;
+    vfs_dentry_t * dentry_ptr;
 
     // get parent inode cluster and local pointer
@@ -1530 +2088 @@
     xhtab_xp = XPTR( parent_cxy , &parent_ptr->children );
 
-    // search extended pointer on matching dentry
-    dentry_xp = xhtab_lookup( xhtab_xp , name );
-
-    if( dentry_xp == XPTR_NULL ) return false;
-
-    // get dentry cluster and local pointer
-    cxy_t          dentry_cxy = GET_CXY( dentry_xp );
-    vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
-
-    // return child inode
-    *child_xp = (xptr_t)hal_remote_l64( XPTR( dentry_cxy , &dentry_ptr->child_xp ) );
-    return true;
+    // get pointers on matching dentry
+    dentry_xp  = xhtab_lookup( xhtab_xp , name );
+    dentry_cxy = GET_CXY( dentry_xp );
+    dentry_ptr = GET_PTR( dentry_xp );
+
+    if( dentry_xp == XPTR_NULL ) 
+    {
+        return false;
+    }
+    else
+    {
+        *child_xp = (xptr_t)hal_remote_l64( XPTR( dentry_cxy , &dentry_ptr->child_xp ) );
+        return true;
+    }
 
 }  // end vfs_get_child()
@@ -1553 +2113 @@
 // last name in the path. The names are supposed to be separated by one or several '/'
 // characters, that are not written in  the <name> buffer.
+// 
+// WARNING: the leading characters '/' in the path are skiped before analysis.
+//          The path "/" identifies the VFS root, and is therefore anaysed as an empty
+//          string. This empty string is dignaled by the (-1) return value.  
 //////////////////////////////////////////////////////////////////////////////////////////
 // @ current   : pointer on first character to analyse in buffer containing the path.
@@ -1558 +2122 @@
 // @ next      : [out] pointer on next character to analyse in buffer containing the path.
 // @ last      : [out] true if the returned name is the last (NUL character found).
-// @ return 0 if success / return EINVAL if string empty (first chracter is NUL).
+// @ return 0 if success / return -1 if string empty (first chracter is NUL).
 //////////////////////////////////////////////////////////////////////////////////////////
 static error_t vfs_get_name_from_path( char     * current,
@@ -1570 +2134 @@
     while( *ptr == '/' ) ptr++;
 
-    // return EINVAL if string empty
-    if( *ptr == 0 ) return EINVAL;
+    // signal empty string
+    if( *ptr == 0 )
+    {
+        *last = true;
+        return -1;
+    }
 
     // copy all characters in name until NUL or '/'
@@ -1594 +2162 @@
 }  // end vfs_get name_from_path()
    
-//////////////////////////////////////////////
-error_t vfs_lookup( xptr_t             cwd_xp,
+///////////////////////////////////////////////
+error_t vfs_lookup( xptr_t             root_xp,
                     char             * pathname,
-                    uint32_t           mode,
-                                        xptr_t           * inode_xp )
+                    uint32_t           lookup_mode,
+                                        xptr_t           * inode_xp,
+                                        char             * last_name )
 {
     char               name[CONFIG_VFS_MAX_NAME_LENGTH];   // one name in path 
@@ -1619 +2188 @@
     bool_t             create;       // searched inode must be created if not found
     bool_t             excl;         // searched inode must not exist
+    bool_t             par;          // searched inode is the parent
     thread_t         * this;         // pointer on calling thread descriptor
     process_t        * process;      // pointer on calling process descriptor
@@ -1626 +2196 @@
     process = this->process;
 
+// check pathname / root_xp consistency
+assert( ((pathname[0] != '/') || (root_xp == process->vfs_root_xp)), 
+"root inode must be VFS root for path <%s>\n", pathname );
+
 #if DEBUG_VFS_LOOKUP
 uint32_t cycle = (uint32_t)hal_get_cycles();
+char     root_name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_inode_get_name( root_xp , root_name );
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s] thread[%x,%x] enter for <%s> / cycle %d\n",
-__FUNCTION__, process->pid, this->trdid, pathname, cycle );
+printk("\n[%s] thread[%x,%x] enter / root <%s> / path <%s> / mode %x / cycle %d\n",
+__FUNCTION__, process->pid, this->trdid, root_name, pathname, lookup_mode, cycle );
 #endif
 
     // compute lookup flags
-    dir    = mode & VFS_LOOKUP_DIR;
-    create = mode & VFS_LOOKUP_CREATE;
-    excl   = mode & VFS_LOOKUP_EXCL;
-    
-    // get extended pointer on first inode to search
-    if( pathname[0] == '/' ) parent_xp = process->vfs_root_xp;
-    else                     parent_xp = cwd_xp;
-
-    // initialise other loop variables
-    current  = pathname;
-    next     = NULL;
-    last     = false;
-    child_xp = XPTR_NULL;
-
-    // take lock on parent inode
-    vfs_inode_lock( parent_xp );
-
-    // sequencially loop on nodes in pathname
-    // load from device if one node in path not found in inode tree
+    dir    = (lookup_mode & VFS_LOOKUP_DIR)    == VFS_LOOKUP_DIR;
+    create = (lookup_mode & VFS_LOOKUP_CREATE) == VFS_LOOKUP_CREATE;
+    excl   = (lookup_mode & VFS_LOOKUP_EXCL)   == VFS_LOOKUP_EXCL;
+    par    = (lookup_mode & VFS_LOOKUP_PARENT) == VFS_LOOKUP_PARENT;
+
+    // initialise loop variables
+    parent_xp = root_xp;
+    current   = pathname;
+    next      = NULL;
+    last      = false;
+    child_xp  = XPTR_NULL;
+
+    // loop on nodes in pathname
+    // load from device if one node in path not found in Inode Tree
     // exit loop when last name found (i.e. last == true)
-    do
-    {
-        // get one name from path, and "last" flag
-        vfs_get_name_from_path( current , name , &next , &last );
+    while( 1 )
+    {
+        // get parent inode cluster and local pointer
+        parent_cxy = GET_CXY( parent_xp );
+        parent_ptr = GET_PTR( parent_xp );
+
+        // get one "name" from path, and "last" flag
+        error = vfs_get_name_from_path( current , name , &next , &last );
+
+        // VFS root case
+        if ( error )
+        {
+
+#if DEBUG_VFS_LOOKUP
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_LOOKUP < cycle )
+printk("\n[%s] thread[%x,%x] exit / parent inode(%x,%x) / <%s> / cycle %d\n",
+__FUNCTION__ , process->pid, this->trdid, parent_cxy, parent_ptr, pathname, cycle );
+#endif
+            *inode_xp = process->vfs_root_xp;
+            break;
+        }
 
 #if (DEBUG_VFS_LOOKUP & 1)
@@ -1665 +2254 @@
 #endif
 
-        // search a child dentry matching name in parent inode
+        // search the child dentry matching name in parent inode
         found = vfs_get_child( parent_xp,
                                name,
                                &child_xp );
 
-        if (found == false )  // child not found in inode tree
+        // analyse found & last, depending on lookup_mode
+        if( found == false )                              // not found in Inode Tree 
         {
+            // when a inode is not found in the Inode Tree:
+            // - if (last and par) the Inode Tree is not modified
+            // - else we speculatively introduce a new (dentry/inode) in inode tree,
+            //        and scan the parent directory mapper to initialise it.
+            //     . if it is not found in the parent mapper:
+            //         - if(last and create), a brand new file or directory is created
+            //         - else, an error is reported
+            //     . if it is found in parent mapper:
+            //         - if( last and excl ), an error is reported
+            //         - else the new child (inode & dentry) is initialised in Inode Tree
+            //         - if the child is a directory, the child mapper is loaded from device
+
+            if( last && par )   //  does nothing
+            {
 
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s] thread[%x,%x] miss <%s> node => try to create it\n",
+printk("\n[%s] thread[%x,%x] child not found but only parent requested in <%s>\n",
+__FUNCTION__, process->pid, this->trdid, pathname );
+#endif
+            }
+            else                                    // try to get it from parent mapper
+            {
+
+#if (DEBUG_VFS_LOOKUP & 1)
+if( DEBUG_VFS_LOOKUP < cycle )
+printk("\n[%s] thread[%x,%x] miss <%s> inode in Inode Tree => build from parent mapper\n",
 __FUNCTION__, process->pid, this->trdid, name );
 #endif
-            // if a child node is not found in the inode tree,
-            // we introduce a new (dentry/inode) in inode tree,
-            // and try to find it by scanning the parent directory mapper.
-            // . if it is found in parent mapper:
-            //   - if the child is a directory, the child mapper is loaded from device
-            //   - if the child is not a directory, the search is completed
-            // . if it is not found in the parent mapper:
-            //   - if ( not last or not create ) an error is reported
-            //   - if (last and create) a new file or directory is created
-
-            // release lock on parent inode
-            vfs_inode_unlock( parent_xp );
+                // get parent inode FS type
+                ctx_ptr    = hal_remote_lpt( XPTR( parent_cxy,&parent_ptr->ctx ) );
+                fs_type    = hal_remote_l32( XPTR( parent_cxy , &ctx_ptr->type ) );
+
+                // select a cluster for new inode
+                child_cxy = cluster_random_select();
+
+                // define child inode type
+                if( dir ) child_type = INODE_TYPE_DIR;
+                else      child_type = INODE_TYPE_FILE;
  
-            // get parent inode cluster and local pointer
-            parent_cxy = GET_CXY( parent_xp );
-            parent_ptr = GET_PTR( parent_xp );
-
-            // get parent inode FS type
-            ctx_ptr    = hal_remote_lpt( XPTR( parent_cxy,&parent_ptr->ctx ) );
-            fs_type    = hal_remote_l32( XPTR( parent_cxy , &ctx_ptr->type ) );
-
-            // select a cluster for missing inode
-            child_cxy = cluster_random_select();
-
-            // define child inode type
-            if( dir ) child_type = INODE_TYPE_DIR;
-            else      child_type = INODE_TYPE_FILE;
- 
-            // insert a new child dentry/inode in inode tree
-            error = vfs_add_child_in_parent( child_cxy,
-                                             child_type, 
-                                             fs_type, 
-                                             parent_xp, 
-                                             name, 
-                                             &dentry_xp,
-                                             &child_xp );
-            if( error )
-            {
-                printk("\n[ERROR] in %s : cannot create node <%s> in path <%s>\n",
-                __FUNCTION__ , name, pathname );
-                return -1;
-            }
-
-            // get child inode local pointer
-            child_ptr = GET_PTR( child_xp );
+                // insert (speculatively) a new child dentry/inode in inode tree
+                error = vfs_add_child_in_parent( child_cxy,
+                                                 child_type, 
+                                                 fs_type, 
+                                                 parent_xp, 
+                                                 name, 
+                                                 &dentry_xp,
+                                                 &child_xp );
+                if( error )
+                {
+                    printk("\n[ERROR] in %s : cannot create inode <%s> in path <%s>\n",
+                    __FUNCTION__ , name, pathname );
+                    return -1;
+                }
+
+                // get child inode local pointer
+                child_ptr = GET_PTR( child_xp );
 
 #if (DEBUG_VFS_LOOKUP & 1)
@@ -1729 +2325 @@
 __FUNCTION__, process->pid, this->trdid, name, child_cxy );
 #endif
-            // scan parent mapper to find the missing dentry, and complete 
-            // the initialisation of dentry and child inode desciptors
-            if( parent_cxy == local_cxy )
-
-            {
-                error = vfs_fs_child_init( parent_ptr,
-                                           name,
-                                           child_xp );
-            }
-            else
-            {
-                rpc_vfs_fs_child_init_client( parent_cxy,
-                                              parent_ptr,
-                                              name,
-                                              child_xp,
-                                              &error );
-            }
-
-            if ( error )   // child not found in parent mapper
-            {
-                if ( last && create )  // add a new dentry in parent
+                // scan parent mapper to find the missing dentry, and complete 
+                // the initialisation of dentry and child inode desciptors
+                if( parent_cxy == local_cxy )
+
                 {
-                    error = vfs_new_child_init( parent_xp,                
-                                                dentry_xp,
-                                                child_xp );
-                    if ( error )
+                    error = vfs_fs_child_init( parent_ptr,
+                                               name,
+                                               child_xp );
+                }
+                else
+                {
+                    rpc_vfs_fs_child_init_client( parent_cxy,
+                                                  parent_ptr,
+                                                  name,
+                                                  child_xp,
+                                                  &error );
+                }
+
+                if ( error )   // child not found in parent mapper
+                {
+                    if ( last && create )  // add a brand new dentry in parent
                     {
-                        printk("\n[ERROR] in %s : cannot init inode <%s> in path <%s>\n",
-                        __FUNCTION__, name, pathname );
-                        vfs_remove_child_from_parent( child_xp );
+                        error = vfs_new_child_init( parent_xp,                
+                                                    dentry_xp,
+                                                    child_xp );
+                        if ( error )
+                        {
+                            printk("\n[ERROR] in %s : cannot init inode <%s> in path <%s>\n",
+                            __FUNCTION__, name, pathname );
+                            vfs_remove_child_from_parent( dentry_xp );
+                            return -1;
+                        }
+
+#if (DEBUG_VFS_LOOKUP & 1)
+if( DEBUG_VFS_LOOKUP < cycle )
+printk("\n[%s] thread[%x,%x] child <%s> not found in parent mapper => create it\n",
+__FUNCTION__, process->pid, this->trdid, name );
+#endif
+                    }
+                    else                   // not last or not create => error
+                    {                       
+                        printk("\n[ERROR] in %s : <%s> node not found in parent for <%s>\n",
+                        __FUNCTION__ , name , pathname );
+                        vfs_remove_child_from_parent( dentry_xp );
                         return -1;
                     }
+                }
+                else          // child has been found in parent mapper
+                {
+                    // check the excl
+                    if( last && create && excl )
+                    {
+                        printk("\n[ERROR] in %s : node already exist <%s>\n",
+                        __FUNCTION__, name );
+                       return -1;
+                    }
 
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s] thread[%x,%x] created inode <%s> in path\n",
+printk("\n[%s] thread[%x,%x] initialised inode <%s> from parent mapper\n",
 __FUNCTION__, process->pid, this->trdid, name );
 #endif
-                }
-                else                   // not last or not create => error
-                {                       
-                     printk("\n[ERROR] in %s : <%s> node not found in parent for <%s>\n",
-                     __FUNCTION__ , name , pathname );
-                     vfs_remove_child_from_parent( child_xp );
-                     return ENOENT;
+                    // load child mapper from device if child is a directory (prefetch)
+                    uint32_t type = hal_remote_l32( XPTR( child_cxy , &child_ptr->type ) );
+                    if( type == INODE_TYPE_DIR ) 
+                    {
+                        if( child_cxy == local_cxy )
+                        {
+                            error = vfs_inode_load_all_pages( child_ptr );
+                        }
+                        else
+                        {
+                            rpc_vfs_inode_load_all_pages_client( child_cxy,
+                                                                 child_ptr,
+                                                                 &error );
+                        }
+                        if ( error )
+                        {
+                            printk("\n[ERROR] in %s : cannot load <%s> from device\n",
+                            __FUNCTION__ , name );
+                            vfs_remove_child_from_parent( dentry_xp );
+                            return -1;
+                        }
+
+#if (DEBUG_VFS_LOOKUP & 1)
+if( DEBUG_VFS_LOOKUP < cycle )
+printk("\n[%s] thread[%x,%x] loaded directory mapper for <%s> from IOC\n",
+__FUNCTION__ , process->pid, this->trdid, name );
+#endif
+                    }
                 }
             }
-            else          // child found in parent mapper
-            {
-                // load child mapper from device if child is a directory (prefetch)
-                if( hal_remote_l32( XPTR( child_cxy , &child_ptr->type ) ) == INODE_TYPE_DIR ) 
-                {
-                    if( child_cxy == local_cxy )
-                    {
-                        error = vfs_inode_load_all_pages( child_ptr );
-                    }
-                    else
-                    {
-                        rpc_vfs_inode_load_all_pages_client( child_cxy,
-                                                             child_ptr,
-                                                             &error );
-                    }
-                    if ( error )
-                    {
-                        printk("\n[ERROR] in %s : cannot load <%s> from device\n",
-                        __FUNCTION__ , name );
-                        vfs_remove_child_from_parent( child_xp );
-                        return EIO;
-                    }
-
-#if (DEBUG_VFS_LOOKUP & 1)
-if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s] thread[%x,%x] loaded from IOC device mapper for <%s> in <%s>\n",
-__FUNCTION__ , process->pid, this->trdid, name, pathname );
-#endif
-                }
-            }
-
-            // take lock on parent inode
-            vfs_inode_lock( parent_xp );
         }
-        else   // child found in inode tree
+        else                                    // child directly found in inode tree
         {
         
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s] thread[%x,%x] found <%s> / inode %x in cluster %x\n",
-__FUNCTION__, process->pid, this->trdid, name, GET_PTR(child_xp), GET_CXY(child_xp) );
-#endif
+printk("\n[%s] thread[%x,%x] found <%s> in Inode Tree / inode (%x,%x)\n",
+__FUNCTION__, process->pid, this->trdid, name, GET_CXY(child_xp), GET_PTR(child_xp) );
+#endif
+            // get child inode local pointer and cluster
             child_ptr  = GET_PTR( child_xp );
             child_cxy  = GET_CXY( child_xp );
-            parent_cxy = GET_CXY( parent_xp );
-            parent_ptr = GET_PTR( parent_xp );
-
-            if( last && (mode & VFS_LOOKUP_CREATE) && (mode & VFS_LOOKUP_EXCL) )
+
+            // check the excl flag
+            if( last && create && excl )
             {
-                printk("\n[ERROR] in %s : node already exist <%s>\n", __FUNCTION__, name );
-                return EINVAL;
+                printk("\n[ERROR] in %s : node <%s> already exist\n",
+                __FUNCTION__, name );
+                return -1;
             }
         }
@@ -1842 +2451 @@
 
         // take lock on child inode and release lock on parent
-        vfs_inode_lock( child_xp );
-        vfs_inode_unlock( parent_xp );
-
-        // update loop variables
-        parent_xp = child_xp;
-        current   = next;
-    }
-    while( last == false );
-
-    // release lock 
-    vfs_inode_unlock( parent_xp );
+        // vfs_inode_lock( child_xp );
+        // vfs_inode_unlock( parent_xp );
+
+        // exit when last
+        if ( last )           // last inode in path  => return relevant info
+        {
+            if ( par )  // return parent inode and child name
+            {
 
 #if DEBUG_VFS_LOOKUP
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s] thread[%x,%x] exit for <%s> cycle %d\n",
-__FUNCTION__ , process->pid, this->trdid, pathname, cycle );
-#endif
-
-    // return searched pointer
-    if( mode & VFS_LOOKUP_PARENT ) *inode_xp = parent_xp;
-    else                           *inode_xp = child_xp;
+printk("\n[%s] thread[%x,%x] exit / parent inode(%x,%x) / <%s> / cycle %d\n",
+__FUNCTION__ , process->pid, this->trdid, parent_cxy, parent_ptr, pathname, cycle );
+#endif
+                *inode_xp = parent_xp;
+                strcpy( last_name , name );
+                break; 
+            }
+            else        // return child inode name     
+            {
+
+#if DEBUG_VFS_LOOKUP
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_LOOKUP < cycle )
+printk("\n[%s] thread[%x,%x] exit / child inode (%x,%x) / <%s> / cycle %d\n",
+__FUNCTION__ , process->pid, this->trdid, child_cxy, child_ptr, pathname, cycle );
+#endif
+                *inode_xp = child_xp;
+                break;
+            }
+        }
+        else                     // not the last inode in path => update loop variables
+        {
+            parent_xp = child_xp;
+            current   = next;
+        }
+    }
 
     return 0;
 
 }  // end vfs_lookup()
-
-
 
 ///////////////////////////////////////////////
@@ -1954 +2577 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_NEW_CHILD_INIT < cycle )
-printk("\n[%s] thread[%x,%x] exit / parent <%s> / child <%> / cycle %d\n",
+printk("\n[%s] thread[%x,%x] exit / parent <%s> / child <%s> / cycle %d\n",
 __FUNCTION__ , this->process->pid, this->trdid, parent_name, child_name, cycle );
 #endif
@@ -1962 +2585 @@
 }  // end vfs_new_child_init()
 
-////////////////////////////////////////////
-error_t vfs_get_path( xptr_t    searched_xp,
-                      char    * buffer,
-                      uint32_t  max_size )
-{
-        xptr_t       dentry_xp;   // extended pointer on current dentry
-    char       * name;        // local pointer on current dentry name
-        uint32_t     length;      // length of current dentry name
-        uint32_t     count;       // number of characters written in buffer
-        uint32_t     index;       // slot index in buffer
-    xptr_t       inode_xp;    // extended pointer on    
-
-    // implementation note:
-    // we use two variables "index" and "count" because the buffer
-    // is written in decreasing index order (from leaf to root) 
-    // TODO  : handle conflict with a concurrent rename [AG]
-    // FIXME : handle synchro in the loop  [AG]
-
-        // set the NUL character in buffer / initialise buffer index and count
+//////////////////////////////////////////
+error_t vfs_get_path( xptr_t     inode_xp,
+                      char     * buffer,
+                      char    ** first,
+                      uint32_t   max_size )
+{
+        xptr_t         dentry_xp;        // extended pointer on current dentry
+    vfs_dentry_t * dentry_ptr;       // local pointer on current dentry
+    cxy_t          dentry_cxy;       // current dentry cluster identifier
+    xptr_t         name_xp;          // extended pointer on current dentry name
+        uint32_t       length;           // length of current dentry name
+        int32_t        index;            // slot index in buffer
+    xptr_t         current_xp;       // extended pointer on current inode
+    vfs_inode_t  * current_ptr;      // local pointer on current inode
+    cxy_t          current_cxy;      // current inode cluster identifier
+    xptr_t         vfs_root_xp;      // extended pointer on VFS root inode
+    vfs_inode_t  * vfs_root_ptr;     // local pointer on VFS root inode
+    cxy_t          vfs_root_cxy;     // VFS root inode cluster identifier
+    xptr_t         lock_xp;          // extended pointer on Inode Tree lock 
+    xptr_t         parents_root_xp;  // extended pointer on current inode parents root
+    bool_t         found;            // condition to exit the while loop
+
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+
+#if DEBUG_VFS_GET_PATH
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_GET_PATH < cycle )
+printk("\n[%s] thread[%x,%x] enter : inode (%x,%x) / cycle %d\n",
+__FUNCTION__ , process->pid, this->trdid,
+GET_CXY( inode_xp ), GET_PTR( inode_xp ), cycle );
+#endif
+
+        // set the NUL character in buffer / initialise buffer index
         buffer[max_size - 1] = 0;
-        count    = 1;
-    index    = max_size - 2;
+    index    = (int32_t)(max_size - 1);
 
     // initialize current inode
-    inode_xp  = searched_xp;
-
-    // exit when root inode found (i.e. dentry_xp == XPTR_NULL)
+    current_xp  = inode_xp;
+
+    // build extended pointer on lock protecting Inode Tree
+    vfs_root_xp  = process->vfs_root_xp;
+    vfs_root_ptr = GET_PTR( vfs_root_xp );
+    vfs_root_cxy = GET_CXY( vfs_root_xp );
+    lock_xp      = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
+
+    // take lock protecting Inode Tree in read mode
+    remote_rwlock_rd_acquire( lock_xp );
+
+    // traverse Inode Tree from target inode to VFS root
+    // selecting always the first parent dentry
+    // the buffer is written in "reverse order" (from target inode to root) 
+    // exit the while loop when the VFS root has been found
         do
     {
-        // get inode cluster and local pointer
-        cxy_t         inode_cxy = GET_CXY( inode_xp );
-        vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
-
-        // get extended pointer on parent dentry                
-        dentry_xp = (xptr_t)hal_remote_l64( XPTR( inode_cxy , inode_ptr->parent_xp ) );
-
-        // get dentry cluster and local pointer
-        cxy_t          dentry_cxy = GET_CXY( dentry_xp );
-        vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
-
-        // get dentry name length and pointer
-        length =  hal_remote_l32( XPTR( dentry_cxy , &dentry_ptr->length ) );
-        name   = (char *)hal_remote_lpt( XPTR( dentry_cxy , &dentry_ptr->name ) );
-
-        // update index and count
-        index -= (length + 1); 
-        count += (length + 1);
-
-        // check buffer overflow
-        if( count >= max_size )
+        // get current inode cluster and local pointer
+        current_cxy = GET_CXY( current_xp );
+        current_ptr = GET_PTR( current_xp );
+
+        // build extended pointer on parents dentries root
+        parents_root_xp = XPTR( current_cxy , &current_ptr->parents );
+
+        // compute exit condition <=> current inode is VFS root    
+        found = xlist_is_empty( parents_root_xp );
+
+        if( found )                              // parent is the VFS root
         {
-            printk("\n[ERROR] in %s : kernel buffer too small\n", __FUNCTION__ );
-            return EINVAL;
+            if( index == (int32_t)(max_size - 1) )
+            {
+                // update index
+                index--;
+                 
+                // set separator  
+                        buffer[index] = '/';
+
+// check buffer overflow
+assert( (index >= 0) , "kernel buffer too small\n" );
+
+            }
         }
-
-        // update pathname
-        hal_remote_memcpy( XPTR( local_cxy , &buffer[index + 1] ) ,
-                           XPTR( dentry_cxy , name ) , length );
-                buffer[index] = '/';
-
-                // get extended pointer on next inode
-        inode_xp = (xptr_t)hal_remote_l64( XPTR( dentry_cxy , dentry_ptr->parent ) );
-    }
-    while( (dentry_xp != XPTR_NULL) );
-
+        else                                     // not the VFS root
+        {
+            // get first parent dentry cluster and pointers
+            dentry_xp  = XLIST_FIRST( parents_root_xp , vfs_dentry_t , parents );
+            dentry_cxy = GET_CXY( dentry_xp );
+            dentry_ptr = GET_PTR( dentry_xp );
+
+            // get extended pointer on dentry name and name length
+            name_xp = XPTR( dentry_cxy , dentry_ptr->name );
+            length  = hal_remote_l32( XPTR( dentry_cxy , &dentry_ptr->length ) );
+
+#if (DEBUG_VFS_GET_PATH & 1)
+char debug_name[CONFIG_VFS_MAX_NAME_LENGTH];
+hal_remote_strcpy( XPTR( local_cxy , debug_name ) , name_xp );
+if( DEBUG_VFS_GET_PATH < cycle )
+printk("\n[%s] thread(%x,%s) get current dentry <%s> in cluster %x\n",
+__FUNCTION__ , process->pid, this->trdid, debug_name, current_cxy );
+#endif
+            // update index 
+            index -= (length + 1); 
+
+// check buffer overflow
+assert( (index >= 0) , "kernel buffer too small\n" );
+
+            // update pathname
+            hal_remote_memcpy( XPTR( local_cxy , &buffer[index + 1] ) ,
+                               name_xp , length );
+
+            // set separator  
+                    buffer[index] = '/';
+
+            // get extended pointer on parent inode
+            current_xp = XPTR( dentry_cxy , 
+                               hal_remote_lpt( XPTR( dentry_cxy , &dentry_ptr->parent ) ) );
+        }
+    }
+    while( found == false );
+
+    // release lock protecting Inode Tree in read mode
+    remote_rwlock_rd_release( lock_xp );
+
+#if DEBUG_VFS_GET_PATH
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_GET_PATH < cycle )
+printk("\n[%s] thread[%x,%x] exit : path <%s> / cycle %d\n",
+__FUNCTION__ , process->pid, this->trdid, &buffer[index], cycle );
+#endif
+
+    // return pointer on first character in buffer
+    *first = &buffer[index];
         return 0;
 
@@ -2033 +2721 @@
       
 ////////////////////////////////////////////////////////////////////
-error_t vfs_add_child_in_parent( cxy_t              child_inode_cxy,
-                                 vfs_inode_type_t   child_inode_type,
+error_t vfs_add_child_in_parent( cxy_t              child_cxy,
+                                 vfs_inode_type_t   child_type,
                                  vfs_fs_type_t      fs_type,
                                  xptr_t             parent_inode_xp,
                                  char             * name,
-                                 xptr_t           * dentry_xp,
+                                 xptr_t           * child_dentry_xp,
                                  xptr_t           * child_inode_xp )
 {
-    error_t         error;
-    xptr_t          new_dentry_xp;       // extended pointer on created dentry
-    vfs_dentry_t  * new_dentry_ptr;      // created dentry local pointer
-    xptr_t          new_inode_xp;        // extended pointer on created child inode
-    cxy_t           parent_inode_cxy;    // parent inode cluster identifier
-    vfs_inode_t   * parent_inode_ptr;    // parent inode local pointer
-
-    // get parent inode cluster and local pointer
-    parent_inode_cxy = GET_CXY( parent_inode_xp );
+    error_t        error;
+    cxy_t          parent_cxy;          // parent inode cluster identifier
+    vfs_inode_t  * parent_inode_ptr;    // parent inode local pointer
+    xptr_t         new_dentry_xp;       // extended pointer on created dentry
+    vfs_dentry_t * new_dentry_ptr;      // created dentry local pointer
+    xptr_t         new_inode_xp;        // extended pointer on created child inode
+    vfs_inode_t  * new_inode_ptr;       // local pointer on created child inode
+
+    xptr_t         parents_root_xp;     // extended pointer on child inode  "parents" field
+    xptr_t         parents_entry_xp;    // extended pointer on child dentry "parents" field
+    xptr_t         children_xhtab_xp;   // extended pointer on parent inode "children" field
+    xptr_t         children_entry_xp;   // extended pointer on child dentry "children" field
+    
+    // get parent inode cluster and pointer
+    parent_cxy       = GET_CXY( parent_inode_xp );
     parent_inode_ptr = GET_PTR( parent_inode_xp );
 
@@ -2058 +2752 @@
 thread_t * this = CURRENT_THREAD; 
 if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[%s] thread[%x,%x] enter / child <%s> cxy %x / parent <%s> cxy %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, name, child_inode_cxy,
-parent_name, parent_inode_cxy, (uint32_t)hal_get_cycles() );
-#endif
-
-    // 1. create dentry
-    if( parent_inode_cxy == local_cxy )      // parent cluster is the local cluster
+printk("\n[%s] thread[%x,%x] enter / child <%s> / parent <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, name,
+parent_name, (uint32_t)hal_get_cycles() );
+#endif
+
+    // 1. create dentry in parent cluster
+    if( parent_cxy == local_cxy )           // parent cluster is local
     {
         error = vfs_dentry_create( fs_type,
                                    name,
-                                   parent_inode_ptr,
                                    &new_dentry_xp );
     }
-    else                               // parent cluster is remote
-    {
-        rpc_vfs_dentry_create_client( parent_inode_cxy,
+    else                                    // parent cluster is remote
+    {
+        rpc_vfs_dentry_create_client( parent_cxy,
                                       fs_type,
                                       name,
-                                      parent_inode_ptr,
                                       &new_dentry_xp,
                                       &error );
@@ -2084 +2776 @@
     {
         printk("\n[ERROR] in %s : cannot create dentry <%s> in cluster %x\n",
-        __FUNCTION__ , name , parent_inode_cxy );
+        __FUNCTION__ , name , parent_cxy );
         return -1;
     }
@@ -2093 +2785 @@
 #if(DEBUG_VFS_ADD_CHILD & 1)
 if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[%s] thread[%x,%x] / dentry <%s> created in cluster %x\n",
-__FUNCTION__, this->process->pid, this->trdid, name, parent_inode_cxy );
-#endif
-
-    // 2. create child inode TODO : define attr / mode / uid / gid
+printk("\n[%s] thread[%x,%x] / dentry <%s> created (%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, name, parent_cxy, new_dentry_ptr );
+#endif
+
+    // 2. create child inode in child cluster
+    // TODO : define attr / mode / uid / gid
     uint32_t attr = 0;
     uint32_t mode = 0;
@@ -2103 +2796 @@
     uint32_t gid  = 0;
     
-    if( child_inode_cxy == local_cxy )      // child cluster is the local cluster
-    {
-        error = vfs_inode_create( new_dentry_xp,
-                                  fs_type,
-                                  child_inode_type,
+    if( child_cxy == local_cxy )      // child cluster is local 
+    {
+        error = vfs_inode_create( fs_type,
+                                  child_type,
                                   attr,
                                   mode,
@@ -2116 +2808 @@
     else                              // child cluster is remote
     {
-        rpc_vfs_inode_create_client( child_inode_cxy,
-                                     new_dentry_xp,
+        rpc_vfs_inode_create_client( child_cxy,
                                      fs_type,
-                                     child_inode_type,
+                                     child_type,
                                      attr,
                                      mode,
@@ -2131 +2822 @@
     {
         printk("\n[ERROR] in %s : cannot create inode in cluster %x\n",
-               __FUNCTION__ , child_inode_cxy );
+               __FUNCTION__ , child_cxy );
  
-        if( parent_inode_cxy == local_cxy ) vfs_dentry_destroy( new_dentry_ptr );
-        else rpc_vfs_dentry_destroy_client( parent_inode_cxy , new_dentry_ptr );
+        if( parent_cxy == local_cxy ) vfs_dentry_destroy( new_dentry_ptr );
+        else rpc_vfs_dentry_destroy_client( parent_cxy , new_dentry_ptr );
         return -1;
     }
 
+    // get new inode local pointer
+    new_inode_ptr = GET_PTR( new_inode_xp );
+    
 #if(DEBUG_VFS_ADD_CHILD & 1)
 if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[%s] thread[%x,%x] / inode <%s> created in cluster %x\n",
-__FUNCTION__ , this->process->pid, this->trdid, name , child_inode_cxy );
-#endif
-
-    // 3. update "child_xp" field in dentry and increment refcounts
-    hal_remote_s64( XPTR( parent_inode_cxy , &new_dentry_ptr->child_xp ) , new_inode_xp );
-    vfs_inode_remote_up( new_inode_xp );
-    vfs_dentry_remote_up( new_dentry_xp );
+printk("\n[%s] thread[%x,%x] / inode <%s> created (%x,%x)\n",
+__FUNCTION__ , this->process->pid, this->trdid, name , child_cxy, new_inode_ptr );
+#endif
+
+    // 3. register new_dentry in new_inode xlist of parents 
+    parents_root_xp  = XPTR( child_cxy , &new_inode_ptr->parents );
+    parents_entry_xp = XPTR( parent_cxy, &new_dentry_ptr->parents );
+    xlist_add_first( parents_root_xp , parents_entry_xp );
+    hal_remote_atomic_add( XPTR( child_cxy , &new_inode_ptr->links ) , 1 );
+
+#if(DEBUG_VFS_ADD_CHILD & 1)
+if( local_cxy == 1 )
+// if( DEBUG_VFS_ADD_CHILD < cycle )
+printk("\n[%s] thread[%x,%x] / dentry (%x,%x) registered in child inode (%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, 
+parent_cxy, new_dentry_ptr, child_cxy, new_inode_ptr );
+#endif
+
+    // 4. register new_dentry in parent_inode xhtab of children
+    children_xhtab_xp = XPTR( parent_cxy , &parent_inode_ptr->children );
+    children_entry_xp = XPTR( parent_cxy , &new_dentry_ptr->children );
+    xhtab_insert( children_xhtab_xp , name , children_entry_xp );
+
+#if(DEBUG_VFS_ADD_CHILD & 1)
+if( DEBUG_VFS_ADD_CHILD < cycle )
+printk("\n[%s] thread[%x,%x] / dentry (%x,%x) registered in parent inode (%x,%x)\n",
+__FUNCTION__, this->process->pid, this->trdid, 
+parent_cxy, new_dentry_ptr, parent_cxy, parent_inode_ptr );
+#endif
+
+    // 5. update "parent" and "child_xp" fields in new_dentry
+    hal_remote_s64( XPTR( parent_cxy , &new_dentry_ptr->child_xp ) , new_inode_xp );
+    hal_remote_spt( XPTR( parent_cxy , &new_dentry_ptr->parent ) , parent_inode_ptr );
 
 #if DEBUG_VFS_ADD_CHILD
@@ -2157 +2876 @@
 
     // return extended pointer on dentry & child inode
-    *dentry_xp      = new_dentry_xp;
-    *child_inode_xp = new_inode_xp;
+    *child_dentry_xp = new_dentry_xp;
+    *child_inode_xp  = new_inode_xp;
     return 0;
 
 }  // end vfs_add_child_in_parent()
 
-////////////////////////////////////////////////////
-void vfs_remove_child_from_parent( xptr_t inode_xp )
-{
-    cxy_t          inode_cxy;
-    vfs_inode_t  * inode_ptr;
-    xptr_t         dentry_xp;
-    cxy_t          dentry_cxy;
-    vfs_dentry_t * dentry_ptr;
+/////////////////////////////////////////////////////
+void vfs_remove_child_from_parent( xptr_t dentry_xp )
+{
+    cxy_t          parent_cxy;         // parent inode cluster identifier
+    cxy_t          child_cxy;          // child inode cluster identifier
+    vfs_dentry_t * dentry_ptr;         // local pointer on dentry
+    xptr_t         child_inode_xp;     // extended pointer on child inode
+    vfs_inode_t  * child_inode_ptr;    // local pointer on child inode
+    vfs_inode_t  * parent_inode_ptr;   // local pointer on parent inode
+    uint32_t       links;              // number of child inode parents
+
+    char dentry_name[CONFIG_VFS_MAX_NAME_LENGTH];
    
-    // get inode cluster and local pointer
-    inode_cxy = GET_CXY( inode_xp );
-    inode_ptr = GET_PTR( inode_xp );
-
-    // get associated dentry cluster and pointers 
-    dentry_xp  = hal_remote_l64( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
-    dentry_cxy = GET_CXY( dentry_xp ); 
+    // get parent cluster and dentry local pointer
+    parent_cxy = GET_CXY( dentry_xp );
     dentry_ptr = GET_PTR( dentry_xp );
 
-// check dentry refcount
-assert( ( hal_remote_l32( XPTR( dentry_cxy , &dentry_ptr->refcount ) ) == 1 ),
-"dentry refcount must be 1\n" );
-
-// check inode refcount
-assert( ( hal_remote_l32( XPTR( inode_cxy , &inode_ptr->refcount ) ) == 1 ),
-"inode refcount must be 1\n" );
-
-    // decrement refcount for inode and dentry
-    vfs_inode_remote_down( inode_xp );
-    vfs_dentry_remote_down( dentry_xp );
-
-    // delete dentry
-    if( dentry_cxy == local_cxy )
+    // get a local copy of dentry name
+    hal_remote_strcpy( XPTR( local_cxy  , dentry_name ),
+                       XPTR( parent_cxy , &dentry_ptr->name ) );
+
+    // get parent_inode local pointer
+    parent_inode_ptr = hal_remote_lpt( XPTR( parent_cxy , &dentry_ptr->parent ) );
+  
+    // get child cluster and child_inode pointers 
+    child_inode_xp   = hal_remote_l64( XPTR( parent_cxy , &dentry_ptr->child_xp ) );
+    child_cxy        = GET_CXY( child_inode_xp ); 
+    child_inode_ptr  = GET_PTR( child_inode_xp );
+
+    // remove dentry from parent_inode
+    xhtab_remove( XPTR( parent_cxy , &parent_inode_ptr->children ),
+                  dentry_name,
+                  XPTR( parent_cxy , &dentry_ptr->children ) );
+
+    // remove dentry from child_inode
+    xlist_unlink( XPTR( parent_cxy , &dentry_ptr->parents ) );
+    links = hal_remote_atomic_add( XPTR( child_cxy , &child_inode_ptr->links ) , -1 );
+
+    // delete dentry descriptor
+    if( parent_cxy == local_cxy )
     {
          vfs_dentry_destroy( dentry_ptr );
@@ -2200 +2927 @@
     else
     {
-         rpc_vfs_dentry_destroy_client( dentry_cxy,
+         rpc_vfs_dentry_destroy_client( parent_cxy,
                                         dentry_ptr );
     }
 
-    // delete inode
-    if( inode_cxy == local_cxy )
-    {
-         vfs_inode_destroy( inode_ptr );
-    }
-    else
-    {
-         rpc_vfs_inode_destroy_client( inode_cxy,
-                                       inode_ptr );
+    // delete child_inode descriptor if last link
+    if( links == 1 )
+    {
+        if( child_cxy == local_cxy )
+        {
+            vfs_inode_destroy( child_inode_ptr );
+        }
+        else
+        {
+            rpc_vfs_inode_destroy_client( child_cxy , child_inode_ptr );
+        }
     }
 
@@ -2374 +3103 @@
 } // end vfs_fs_child_init()
 
+////////////////////////////////////////////////
+error_t vfs_fs_sync_inode( vfs_inode_t * inode )
+{
+    error_t error = 0;
+
+// check arguments
+assert( (inode != NULL) , "inode pointer is NULL\n");
+
+    // get inode FS type
+    vfs_fs_type_t fs_type = inode->ctx->type;
+
+    // call relevant FS function
+    if( fs_type == FS_TYPE_FATFS )
+    {
+        error = fatfs_sync_inode( inode );
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , "undefined file system type\n" );
+    }
+
+    return error;
+
+}  // end vfs_fs_sync_inode()
+
+////////////////////////////////////////////////
+error_t vfs_fs_sync_fat( vfs_fs_type_t fs_type )
+{
+    error_t error = 0;
+
+    // call relevant FS function
+    if( fs_type == FS_TYPE_FATFS )
+    {
+        error = fatfs_sync_fat();
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , "undefined file system type\n" );
+    }
+
+    return error;
+
+}  // end vfs_fs_sync_fat()
+
+//////////////////////////////////////////////////////
+error_t vfs_fs_sync_free_info( vfs_fs_type_t fs_type )
+{
+    error_t error = 0;
+
+    // call relevant FS function
+    if( fs_type == FS_TYPE_FATFS )
+    {
+        error = fatfs_sync_free_info();
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , "undefined file system type\n" );
+    }
+
+    return error;
+
+}  // end vfs_fs_sync_fat()
+
 /////////////////////////////////////////////////
 error_t vfs_fs_cluster_alloc( uint32_t   fs_type,

trunk/kernel/fs/vfs.h

@@ -69 +69 @@
  *****************************************************************************************/
 
-#define VFS_LOOKUP_DIR      0x01     /* the searched inode is a directory                */
+#define VFS_LOOKUP_DIR      0x01     /* the searched inode must be a directory           */
 #define VFS_LOOKUP_OPEN         0x02     /* the search is for an open/opendir                */
 #define VFS_LOOKUP_PARENT       0x04     /* return the parent inode (not the inode itself)   */
 #define VFS_LOOKUP_CREATE   0x10     /* file must be created if missing                  */
-#define VFS_LOOKUP_EXCL     0x20     /* file cannot previously exist                     */    
+#define VFS_LOOKUP_EXCL     0x20     /* file cannot previously exist                     */
 
 /******************************************************************************************
@@ -117 +117 @@
 /******************************************************************************************
  * This structure define a VFS inode.
- * It contains an extended pointer on the parent dentry, and (for directory only)
- * an hash table (xhtab) registering all children dentries.
- * The <parent> inode is unique for a directory (no hard links for directories). 
- * For a file, the parent field points to the first dentry who created this inode.
+ * An inode has several children dentries (if it is a directory), an can have several
+ * parents dentries (if it hass several aliases links):
+ * - The "parents" field is the root of the xlist of parents dentries, and the "links"
+ *   fiels define the number of aliases parent dentries. only a FILE inode can have
+ *   several parents (no hard links for directories). 
+ * - The "children" field is an embedded xhtab containing pointers on all local children
+ *   dentries. This set of children is empty for a FILE inode.
  * Synchronisation:
- * - the main_lock (remote_busylock) is used during the inode tree traversal,
- *   or for inode modification (add/remove children).
- * - the data_lock (remote_rwlock) is used during read/write accesses to the data
- *   stored in the mapper. 
- * - the mapper lock (remote rwlock) is only used during the radix tree traversal 
- *   to return the relevant page for read/write.
+ * - the main_lock (remote_rwlock) is used during the inode tree traversal,
+ *   or for inode modification (add/remove children in xhtab).
+ * - the size_lock (remote_rwlock) is used during read/write accesses to the size
+ *   field in the mapper. 
+ * - access to the data stored in the associated mapper use the mapper remote_rwlock 
+ *   protecting radix tree traversal and modifications.
  *****************************************************************************************/
 
@@ -158 +161 @@
 {
         struct vfs_ctx_s * ctx;              /*! local pointer on FS context                 */
-    uint32_t           gc;               /*! generation counter                          */
         uint32_t           inum;             /*! inode identifier (unique in file system)    */
         uint32_t           attr;             /*! inode attributes (see above)                */
         vfs_inode_type_t   type;             /*! inode type (see above)                      */
         uint32_t           size;             /*! number of bytes                             */
-        uint32_t           links;            /*! number of alias dentry                      */
         uint32_t           uid;              /*! user owner identifier                       */
         uint32_t           gid;              /*! group owner identifier                      */
     uint32_t           rights;           /*! access rights                               */
-        uint32_t               refcount;         /*! reference counter (all pointers)            */
-        xptr_t             parent_xp;        /*! extended pointer on parent dentry           */
+        xlist_entry_t      parents;          /*! root of list of parents dentries            */
+        uint32_t           links;            /*! number of parent dentries (hard links)      */
         xhtab_t            children;         /*! embedded xhtab of children dentries         */
-        remote_rwlock_t    data_lock;        /*! protect read/write to data and to size      */
-        remote_busylock_t  main_lock;        /*! protect inode tree traversal and modifs     */
-        list_entry_t       list;             /*! member of set of inodes in same cluster     */
-        xlist_entry_t      wait_root;        /*! root of threads waiting on this inode       */
+        remote_rwlock_t    size_lock;        /*! protect read/write to size                  */
+        remote_rwlock_t    main_lock;        /*! protect inode tree traversal and modifs     */
+//  list_entry_t       list;             /*! member of set of inodes in same cluster     */
+//  list_entry_t       wait_root;        /*! root of threads waiting on this inode       */
         struct mapper_s  * mapper;           /*! associated file cache                       */
         void             * extend;           /*! fs_type_specific inode extension            */
@@ -183 +184 @@
 #define VFS_ISUID          0x0004000
 #define VFS_ISGID          0x0002000
-#define VFS_ISVTX          0x0001000
+define VFS_ISVTX           0x0001000
 
 #define VFS_IRWXU      0x0000700
@@ -203 +204 @@
  * This structure defines a directory entry.
  * A dentry contains the name of a remote file/dir, an extended pointer on the 
- * inode representing this file/dir, and a local pointer on the inode representing 
+ * inode representing this file/dir, a local pointer on the inode representing 
  * the parent directory.
+ * A dentry can be member of the set of children of a given directory inode (xhtab).
+ * A dentry can be member of the set of parents  of a given inode (xlist).
  *****************************************************************************************/
 
@@ -212 +215 @@
         char                 name[CONFIG_VFS_MAX_NAME_LENGTH];
         uint32_t             length;         /*! name length (bytes)                         */
-        uint32_t             refcount;       /*! reference counter (all pointers)            */
     struct vfs_inode_s * parent;         /*! local pointer on parent inode               */
     xptr_t               child_xp;       /*! extended pointer on child inode             */
-    xlist_entry_t        list;           /*! member of list of dentries with same key    */
+    xlist_entry_t        children;       /*! member of set of children dentries          */
+    xlist_entry_t        parents;        /*! member of set of parent dentries            */
         void               * extend;         /*! FS specific extension                       */
 }
@@ -301 +304 @@
 
 
-
 /******************************************************************************************
  *        These low-level functions access / modify a VFS inode descriptor
@@ -314 +316 @@
  * This function allocates memory from local cluster for an inode descriptor and the 
  * associated mapper. It initialise these descriptors from arguments values. 
- * The parent dentry must have been previously created.
  * If the client thread is not running in the cluster containing this inode,
  * it must use the rpc_vfs_inode_create_client() function.
  ******************************************************************************************
- * @ dentry_xp  : extended pointer on associated dentry (in parent inode cluster).
  * @ fs_type    : file system type.
  * @ inode_type : inode type.
@@ -328 +328 @@
  * @ return 0 if success / return ENOMEM or EINVAL if error.
  *****************************************************************************************/
-error_t vfs_inode_create( xptr_t            dentry_xp,
-                          vfs_fs_type_t     fs_type,
+error_t vfs_inode_create( vfs_fs_type_t     fs_type,
                           vfs_inode_type_t  inode_type,
                           uint32_t          attr,
@@ -340 +339 @@
  * This function releases memory allocated to an inode descriptor, including
  * all memory allocated to the mapper (both mapper descriptor and radix tree).
- * The mapper should not contain any dirty page (shold be synchronized before deletion),
- * and the inode refcount must be zero.
+ * The mapper should not contain any dirty page (should be synchronized before deletion).
  * It must be executed by a thread running in the cluster containing the inode.
  * Use the rpc_vfs_inode_destroy_client() function if required.
@@ -348 +346 @@
  *****************************************************************************************/
 void vfs_inode_destroy( vfs_inode_t *  inode );  
-
-/****************************************************************************************** 
- * This function atomically increment/decrement the inode refcount.
- * It can be called by any thread running in any cluster.
- *****************************************************************************************/
-void vfs_inode_remote_up( xptr_t  inode_xp );
-void vfs_inode_remote_down( xptr_t  inode_xp );
 
 /****************************************************************************************** 
@@ -423 +414 @@
  * This function allocates memory from local cluster for a dentry descriptor, 
  * initialises it from  arguments values, and returns the extended pointer on dentry.
- * The inode field is not initialized, because the inode does not exist yet.
  * If the client thread is not running in the target cluster for this inode,
  * it must use the rpc_dentry_create_client() function.
@@ -429 +419 @@
  * @ fs_type    : file system type.
  * @ name       : directory entry file/dir name.
- * @ parent     : local pointer on parent inode.
  * @ dentry_xp  : [out] buffer for extended pointer on created dentry.
  * @ return 0 if success / return ENOMEM or EINVAL if error.
@@ -435 +424 @@
 error_t vfs_dentry_create( vfs_fs_type_t   fs_type,
                            char          * name,
-                           vfs_inode_t   * parent,
                            xptr_t        * dentry_xp );
  
 /****************************************************************************************** 
- * This function releases memory allocated to a dentry descriptor.
- * The dentry refcount must be zero. 
+ * This function removes the dentry from the parent inode xhtab, and releases the memory
+ * allocated to the dentry descriptor.
  * It must be executed by a thread running in the cluster containing the dentry.
  * Use the rpc_vfs_dentry_destroy_client() function if required.
@@ -447 +435 @@
  *****************************************************************************************/
 void vfs_dentry_destroy( vfs_dentry_t *  dentry );  
-
-/****************************************************************************************** 
- * These functions atomically increment/decrement the dentry refcount.
- * It can be called by any thread running in any cluster.
- *****************************************************************************************/
-void vfs_dentry_remote_up( xptr_t dentry_xp );
-void vfs_dentry_remote_down( xptr_t dentry_xp );
 
 
@@ -496 +477 @@
 
 /******************************************************************************************
- *        These functions access / modify the distributed VFS Inode Treee
- *****************************************************************************************/
-
-/****************************************************************************************** 
- * This function returns in a kernel buffer allocated by the caller function,
- * the pathname of a file/dir identified by an extended pointer on the inode. 
+ *        These functions access / modify the distributed VFS Inode Tree
+ *****************************************************************************************/
+
+/****************************************************************************************** 
+ * This function returns in a kernel <buffer> allocated by the caller function,
+ * the pathname of a file/dir identified by the <inode_xp> argument. 
  * It traverse the Inode Tree from the target node to the root.
  * It can be called by any thread running in any cluster.
- ******************************************************************************************
- * @ inode_xp    : pointer on inode descriptor.
- * @ buffer      : kernel buffer for pathname (must be allocated by caller).
- * @ size        : max number of characters in buffer.
+ * As this buffer if filled in "reverse order" (i.e. from the target inode to the root),
+ * the pathname is stored in the higher part of the buffer. 
+ * A pointer on the first character of the pathname is returned in <first> buffer.
+ *
+ * WARNING : This function takes & releases the remote_rwlock protecting the Inode Tree.
+ ******************************************************************************************
+ * @ inode_xp    : [in]  extended pointer on target inode descriptor.
+ * @ buffer      : [in]  kernel buffer for pathname (allocated by caller).
+ * @ first       : [out] pointer on first character in buffer.
+ * @ max_size    : [in]  max number of characters in buffer.
  * @ return 0 if success / return EINVAL if buffer too small.
  *****************************************************************************************/
 error_t vfs_get_path( xptr_t    inode_xp,
                       char    * buffer,
+                      char   ** first,
                       uint32_t  max_size );
 
 /******************************************************************************************
- * This function takes a pathname (absolute or relative to cwd) and returns an extended 
- * pointer on the associated inode.
+ * This function traverses the the Inode Tree, from inode identified by the <root_xp> 
+ * argument, and returns in <inode_xp> the inode identified by the < pathname> argument. 
+ * It can be called by a thread running in any cluster.
+ * It supports the following flags that define the lookup modes :
+ * - VFS_LOOKUP_DIR    : the searched inode must be a directory 
+ * - VFS_LOOKUP_OPEN   : the search is for an open/opendir
+ * - VFS_LOOKUP_PARENT : return the parent inode (not the inode itself) 
+ * - VFS_LOOKUP_CREATE : file/directory must be created if missing on IOC 
+ * - VFS_LOOKUP_EXCL   : file cannot previously exist
+ * As the inode Tree is a cache, the search policy is the following :
  * - If a given directory name in the path is not found in the inode tree, it try to load
  *   the missing dentry/inode couple, from informations found in the parent directory.
- * - If this directory entry does not exist on device, it returns an error.
- * - If the the file identified by the pathname does not exist on device but the
- *   flag CREATE is set, the inode is created.
- * - If the the file identified by the pathname exist on device but both flags EXCL
+ * - If this directory entry does not exist on IOC, it returns an error.
+ * - If the the file identified by the pathname does not exist on IOC but the
+ *   flag CREATE is set, the inode is created. It returns an error otherwise.
+ * - If the the file identified by the pathname exist on device, but both flags EXCL
  *   and CREATE are set, an error is returned.
- ******************************************************************************************
- * @ cwd_xp      : extended pointer on current directory (for relative path).
- * @ pathname    : path in kernel space (can be relative or absolute).
- * @ lookup_mode : flags defining the working mode (defined above in this file).
+ * - If the PARENT flag is set, it returns in <inode_xp> an extended pointer on the parent
+ *   inode, and copies in <last_name> buffer a string containing the last name in path.
+ *
+ * WARNING : The remote_rwlock protecting the Inode Tree must be taken by the caller. 
+ *
+ * TODO the access rights are not checked yet.
+ ******************************************************************************************
+ * @ root_xp     : [in]  extended pointer on root inode (can be root of a subtree). 
+ * @ pathname    : [in]  path (can be relative or absolute).
+ * @ lookup_mode : [in]  flags defining the searching mode.
  * @ inode_xp    : [out] buffer for extended pointer on searched inode.
+ * @ last_name   : [out] pointer on buffer for last name in path.
  * @ 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,
+ *****************************************************************************************/
+error_t vfs_lookup( xptr_t             root_xp,
                     char             * pathname,
                     uint32_t           lookup_mode,
-                                        xptr_t           * inode_xp );
+                                        xptr_t           * inode_xp,
+                    char             * last_name );
 
 /******************************************************************************************
  * This function creates a new couple dentry/inode, and insert it in the Inode-Tree.
+ * Only the distributed Inode Tree is modified: it does NOT modify the parent mapper, 
+ * and does NOT update the FS on IOC device.
  * 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 RPCs if required.
- * Only the distributed Inode Tree is modified: Even for a new file, this function
- * does NOT modify the parent mapper, and does NOT update the FS on IOC device.
+ * the child cluster and the parent cluster).
  * 
  * [Implementation]
@@ -563 +566 @@
  * @ return 0 if success / -1 if dentry or inode cannot be created.
  *****************************************************************************************/
-error_t vfs_add_child_in_parent( cxy_t              child_inodecxy,
-                                 vfs_inode_type_t   chilg_inode_type,
+error_t vfs_add_child_in_parent( cxy_t              child_inode_cxy,
+                                 vfs_inode_type_t   child_inode_type,
                                  vfs_fs_type_t      fs_type,
                                  xptr_t             parent_inode_xp,
@@ -572 +575 @@
 
 /******************************************************************************************
- * This function removes a couple dentry/inode from the Inode-Tree.
- * Both the inode and dentry references counters must be 1.
+ * This function removes a remote dentry from the Inode-Tree.
+ * - It removes the dentry from the parent inode xhtab ("children" field), and from the
+ *   child inode xlist ("parents" field).
+ * - It releases the memory allocated to the dentry descriptor.
+ * - If the number of parents of the child inode is one, it also releases the memory
+ *   allocated to the child inode.
+ * Only the Inode Tree is modified: it does NOT modify the parent mapper, 
+ * and does NOT update the FS on IOC device.
  * It can be executed by any thread running in any cluster (can be different from both
- * the inode cluster and the dentry cluster), as it uses RPCs if required.
- ******************************************************************************************
- * @ child_xp   : extended pointer on removed inode.
- *****************************************************************************************/
-void vfs_remove_child_from_parent( xptr_t inode_xp );
+ * the inode cluster and the dentry cluster).
+ ******************************************************************************************
+ * @ dentry_xp   : extended pointer on removed dentry.
+ *****************************************************************************************/
+void vfs_remove_child_from_parent( xptr_t dentry_xp );
 
 /******************************************************************************************
@@ -599 +608 @@
  *****************************************************************************************/
 error_t vfs_new_child_init( xptr_t   parent_xp,
-                         xptr_t   dentry_xp,
-                         xptr_t   child_xp );
+                            xptr_t   dentry_xp,
+                            xptr_t   child_xp );
 
 /******************************************************************************************
@@ -661 +670 @@
 /****************************************************************************************** 
  * This function allocates a vfs_file_t structure in the cluster containing the inode
- * associated to the file identified by the <cwd_xp> & <path> arguments.
+ * identified by the <root_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. 
+ * <process_xp> argument, and returns both the extended pointer on the file descriptor,
+ * and the allocated index in the <file_xp> and <file_id> buffers. 
  * 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
+ * If the inode does not exist in the inode cache, it try to find the file on the IOC
  * 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. 
+ *
+ * WARNING : this function takes & releases the remote_rwlock protecting the Inode Tree.
  ****************************************************************************************** 
- * @ process     : local pointer on local process descriptor copy.
+ * @ root_xp     : extended pointer on path root inode.
  * @ path        : file pathname (absolute or relative to current directory).
+ * @ process_xp  : extended pointer on client reference process.
  * @ flags       : defined in vfs_file_t structure.
  * @ mode        : access rights (as defined by chmod).
@@ -679 +691 @@
  * @ return 0 if success / return non-zero if error.
  *****************************************************************************************/
-error_t vfs_open( struct process_s * process,
+error_t vfs_open( xptr_t             root_xp,
                           char             * path,
+                  xptr_t             process_xp,
                           uint32_t           flags,
                   uint32_t           mode,
@@ -721 +734 @@
 /****************************************************************************************** 
  * This function is called by the kernel to create in the file system a new directory 
- * entry identified by the <cwd_xp> & <path_1>, linked to the node identified by the
- * <cwd_xp> & <path_2> arguments.  It can be any type of node.
- * If the link is successful, the link count of the target node is incremented.
- * <path_1> and <path_2> share equal access rights to the underlying object.
+ * identified by the <root_xp> & <path> arguments, with the access permission defined
+ * by the <rights> argument. All nodes in the path - but the last -  must exist.
+ *
+ * WARNING : this function takes & releases the remote_rwlock protecting the Inode Tree.
+ ******************************************************************************************
+ * @ root_xp : extended pointer on path root inode (any inode in Inode Tree).
+ * @ path    : pathname (absolute or relative to current directory).
+ * @ rights  : access rights.
+ * @ returns 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_mkdir( xptr_t   root_xp,
+                   char   * path,
+                   uint32_t rights );
+
+/****************************************************************************************** 
+ * This function is called by the kernel to create in the file system a new directory 
+ * entry identified by the <new_root_xp> & <new_path> arguments, to be linked to an
+ * existing inode, identified by the  <old_root_xp> & <old_path> arguments.
+ * If the link is successful, the link count of the target inode is incremented.
+ * The <new_path> and <old_path> share equal access rights to the underlying inode.
  * Both the IOC device and the Inode Tree are modified. 
- ******************************************************************************************
- * @ cwd_xp   : extended pointer on current working directory file descriptor.
- * @ path_1   : new pathname (absolute or relative to current directory).
- * @ path_1   : existing pathname (absolute or relative to current directory).
+ $
+ * TODO This function should handle any type of node, but the current implementation
+ * handles only the FILE and DIR types.
+ *
+ * WARNING : this function takes & releases the remote_rwlock protecting the Inode Tree.
+ ******************************************************************************************
+ * @ old_root_xp : extended pointer on old path root inode (any inode in Inode Tree).
+ * @ old_path    : old pathname (absolute or relative to current directory).
+ * @ nld_root_xp : extended pointer on new path root inode (any inode in Inode Tree).
+ * @ new_path    : new pathname (absolute or relative to current directory).
  * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
-error_t vfs_link( xptr_t   cwd_xp,
-                  char   * path_1,
-                  char   * path_2 );
+error_t vfs_link( xptr_t   old_root_xp,
+                  char   * old_path,
+                  xptr_t   new_root_xp,
+                  char   * new_path );
 
 /****************************************************************************************** 
  * This function is called by the kernel to remove from the file system a directory entry
- * identified by the  <cwd_xp> & <path> arguments. The target node can be any type of node.
- * The link count of the target node is decremented. If the removed link is the last,
- * the target node is deleted.
+ * identified by the  <root_xp> & <path> arguments.
+ * The link count of the target node is decremented.
+ * If the removed link is the last, the target inode is deleted.
  * Both the IOC device and the Inode Tree are modified. 
- ******************************************************************************************
- * @ cwd_xp   : extended pointer on the current working directory file descriptor.
+ *
+ * TODO This function should handle any type of node, but the current implementation
+ * handles only only the FILE and DIR types.
+ *
+ * WARNING : this function takes & releases the remote_rwlock protecting the Inode Tree.
+ ******************************************************************************************
+ * @ root_xp  : extended pointer on root inode (can be any inode in Inode Tree).
  * @ path     : pathname (absolute or relative to current directory).
  * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
-error_t vfs_unlink( xptr_t   cwd_xp,
+error_t vfs_unlink( xptr_t   root_xp,
                     char   * path );
 
 /****************************************************************************************** 
- * This function returns, in the structure pointed by the <st> pointer,
- * various informations on the inode identified by the <inode_xp> argument.
- * TODO : only partially implemented yet...
- ******************************************************************************************
- * @ inode_xp   : extended pointer on the remote inode.
+ * This function returns, in the structure pointed by the <st> pointer, various
+ * informations on the inode identified by the <root_inode_xp> and <patname> arguments.
+ *
+ * TODO : only partially implemented yet (only size and inum fields).
+ *
+ * WARNING : this function takes & releases the remote_rwlock protecting the Inode Tree.
+ ******************************************************************************************
+ * @ root_xp    : extended pointer on path root inode (any inode in Inode Tree)
+ * @ pathname   : pathname to target inode.
  * @ st         : local pointer on the stat structure in kernel space.
  * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
-error_t vfs_stat( xptr_t        inode_xp,
+error_t vfs_stat( xptr_t        root_xp,
+                  char        * pathname,
                   struct stat * st );
 
@@ -775 +821 @@
 
 /****************************************************************************************** 
- * This function  creates a new inode and associated dentry  for the directory defined
- * by the <cwd_xp> & <path> arguments.
+ * This function  creates a new directory as defined by the <root_xp> & <path> arguments.
  * TODO not implemented yet...
  ******************************************************************************************
- * @ cwd_xp   : extended pointer on the current working directory file descriptor.
- * @ path     : pathname (absolute or relative to current directory).                     
+ * @ root_xp  : extended pointer on the path root directory.
+ * @ path     : pathname (absolute or relative to CWD).                     
  * @ mode     : access rights (as defined by chmod)
  * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
-error_t vfs_mkdir( xptr_t     cwd_xp,
+error_t vfs_mkdir( xptr_t     root_xp,
                    char     * path,
                    uint32_t   mode );
 
 /****************************************************************************************** 
- * This function makes the directory identified by <cwd_xp / path> arguments to become
- * the working directory for the calling process.
+ * This function makes the directory identified by the <root_xp and <path> arguments 
+ * to become the working directory for the calling process.
  ****************************************************************************************** 
- * @ cwd_xp      : extended pointer on current directory file descriptor (relative path).
- * @ path        : file pathname (absolute or relative to current directory).
+ * @ root_xp  : extended pointer on the path root directory.
+ * @ path     : pathname (absolute or relative to CWD).
  * return 0 if success / -1 if error.
  *****************************************************************************************/
-error_t vfs_chdir( xptr_t   cwd_xp,
+error_t vfs_chdir( xptr_t   root_xp,
                    char   * path );
 
 /****************************************************************************************** 
- * This function change the access rigths for the file identified by the <cwd_xp / path>
- * arguments. The new access rights are defined by the <mode> argument value.
+ * This function change the access rigths for the file/directory identified by the 
+ * <root_xp> and <path> arguments as defined by the <mode> argument value.
  ****************************************************************************************** 
- * @ cwd_xp      : extended pointer on current directory file descriptor (relative path).
- * @ path        : file pathname (absolute or relative to current directory).
- * @ mode        : access rights new value.
+ * @ root_xp  : extended pointer on the path root directory.
+ * @ path     : pathname (absolute or relative to CWD).
+ * @ mode     : access rights
  * return 0 if success / -1 if error.
  *****************************************************************************************/
-error_t vfs_chmod( xptr_t        cwd_xp,
+error_t vfs_chmod( xptr_t        root_xp,
                    char        * path,
                    uint32_t      mode );
@@ -816 +861 @@
  * TODO not implemented yet                                                          
  ****************************************************************************************** 
- * @ path        : FIFO pathname (absolute or relative to current directory).
- * @ cwd_xp      : extended pointer on the current working directory file descriptor.
- * @ mode        : access rights new value.
- *****************************************************************************************/
-error_t vfs_mkfifo( xptr_t       cwd_xp,
+ * @ root_xp  : extended pointer on the path root directory.
+ * @ path     : pathname (absolute or relative to CWD).
+ * @ mode     : access rights new value.
+ *****************************************************************************************/
+error_t vfs_mkfifo( xptr_t       root_xp,
                     char       * path,
                     uint32_t     mode );
@@ -905 +950 @@
 
 /*****************************************************************************************
- * This function updates the FS on the IOC device for the FAT itself.
- * It scan all clusters registered in the FAT mapper, and copies to device 
- * each page marked as dirty.
+ * This function updates the FS defined by the <fs_type> argument on the IOC device
+ * for the FAT itself. It scan all clusters registered in the FAT mapper, and copies 
+ * to device each page marked as dirty.
  *
  * Depending on the file system type, it calls the relevant, FS specific function.
  * It can be called by a thread running in any cluster.
  *****************************************************************************************
+ * @ fs_type   : specific file system type.
  * @ return 0 if success / return EIO if failure during device access.
  ****************************************************************************************/
-error_t vfs_fs_sync_fat( void );
+error_t vfs_fs_sync_fat( vfs_fs_type_t fs_type );
 
 /*****************************************************************************************
- * This function updates the free clusters info on the IOC device. 
+ * This function updates the free clusters info on the IOC device for the FS defined
+ * by the <fs_type> argument. 
  *
  * Depending on the file system type, it calls the relevant, FS specific function.
  * It can be called by a thread running in any cluster.
  *****************************************************************************************
+ * @ fs_type   : specific file system type.
  * @ return 0 if success / return EIO if failure during device access.
  ****************************************************************************************/
-error_t vfs_fs_sync_free_info( void );
+error_t vfs_fs_sync_free_info( vfs_fs_type_t fs_type );
 
 /******************************************************************************************