Changeset 673

Timestamp:

Nov 19, 2020, 11:54:16 PM (3 years ago)

Author:

alain

Message:

Introduce the DEBUG_VFS_ERROR in kernel_config to make
error messges display conditional.

Location:

trunk/kernel/fs

Files:

• devfs.c (modified) (18 diffs)
• devfs.h (modified) (1 diff)
• fatfs.c (modified) (16 diffs)
• ramfs.c (modified) (1 diff)
• vfs.c (modified) (97 diffs)
• vfs.h (modified) (20 diffs)

trunk/kernel/fs/devfs.c

@@ -3 +3 @@
  *
  * Author   Mohamed Lamine Karaoui (2014,2015)
- *          Alain Greiner (2016,2017,2018,2019,2020)
+ *          Alain Greiner          (2016,2017,2018,2019,2020)
  *
  * Copyright (c) Sorbonne Universites
@@ -124 +124 @@
     // update inode "type" field
     inode = GET_PTR( *devfs_dev_inode_xp );
-    inode->type = INODE_TYPE_DIR;
+    inode->type = FILE_TYPE_DIR;
  
     // create dentries <.> and <..> in <dev>
@@ -154 +154 @@
     // update inode "type" field
     inode = GET_PTR( *devfs_external_inode_xp );
-    inode->type = INODE_TYPE_DIR;
+    inode->type = FILE_TYPE_DIR;
  
     // create dentries <.> and <..> in <external>
@@ -201 +201 @@
 
     // create <internal> directory 
-    snprintf( node_name , 16 , "internal_%x" , local_cxy );
+    snprintk( node_name , 16 , "internal_%x" , local_cxy );
 
     error = vfs_add_child_in_parent( local_cxy,              // target cluster
@@ -212 +212 @@
     // set <internal> inode "type" field
     internal_inode_ptr       = GET_PTR( internal_inode_xp );
-    internal_inode_ptr->type = INODE_TYPE_DEV;
+    internal_inode_ptr->type = FILE_TYPE_DEV;
  
     // create dentries <.> and <..> in <internal>
@@ -262 +262 @@
         inode_ptr = GET_PTR( inode_xp );
         inode_ptr->extend = chdev_ptr;
-        inode_ptr->type   = INODE_TYPE_DEV;
+        inode_ptr->type   = FILE_TYPE_DEV;
         
 #if DEBUG_DEVFS_LOCAL_INIT
@@ -305 +305 @@
             inode_ptr = GET_PTR( inode_xp );
             inode_ptr->extend = chdev_ptr;
-            inode_ptr->type   = INODE_TYPE_DEV;
+            inode_ptr->type   = FILE_TYPE_DEV;
         
 #if DEBUG_DEVFS_LOCAL_INIT
@@ -341 +341 @@
             inode_ptr = GET_PTR( inode_xp );
             inode_ptr->extend = chdev_ptr;
-            inode_ptr->type   = INODE_TYPE_DEV;
+            inode_ptr->type   = FILE_TYPE_DEV;
         
 #if DEBUG_DEVFS_LOCAL_INIT
@@ -378 +378 @@
             inode_ptr = GET_PTR( inode_xp );
             inode_ptr->extend = chdev_ptr;
-            inode_ptr->type   = INODE_TYPE_DEV;
+            inode_ptr->type   = FILE_TYPE_DEV;
         
 #if DEBUG_DEVFS_LOCAL_INIT
@@ -417 +417 @@
                 inode_ptr = GET_PTR( inode_xp );
                 inode_ptr->extend = chdev_ptr;
-                inode_ptr->type   = INODE_TYPE_DEV;
+                inode_ptr->type   = FILE_TYPE_DEV;
         
 #if DEBUG_DEVFS_LOCAL_INIT
@@ -456 +456 @@
                 inode_ptr = GET_PTR( inode_xp );
                 inode_ptr->extend = chdev_ptr;
-                inode_ptr->type   = INODE_TYPE_DEV;
+                inode_ptr->type   = FILE_TYPE_DEV;
         
 #if DEBUG_DEVFS_LOCAL_INIT 
@@ -495 +495 @@
                 inode_ptr = GET_PTR( inode_xp );
                 inode_ptr->extend = chdev_ptr;
-                inode_ptr->type   = INODE_TYPE_DEV;
+                inode_ptr->type   = FILE_TYPE_DEV;
         
 #if DEBUG_DEVFS_LOCAL_INIT
@@ -534 +534 @@
                 inode_ptr = GET_PTR( inode_xp );
                 inode_ptr->extend = chdev_ptr;
-                inode_ptr->type   = INODE_TYPE_DEV;
+                inode_ptr->type   = FILE_TYPE_DEV;
         
 #if DEBUG_DEVFS_LOCAL_INIT
@@ -573 +573 @@
                 inode_ptr = GET_PTR( inode_xp );
                 inode_ptr->extend = chdev_ptr;
-                inode_ptr->type   = INODE_TYPE_DEV;
+                inode_ptr->type   = FILE_TYPE_DEV;
  
 #if DEBUG_DEVFS_LOCAL_INIT
@@ -612 +612 @@
                 inode_ptr = GET_PTR( inode_xp );
                 inode_ptr->extend = chdev_ptr;
-                inode_ptr->type   = INODE_TYPE_DEV;
+                inode_ptr->type   = FILE_TYPE_DEV;
         
 #if DEBUG_DEVFS_LOCAL_INIT
@@ -643 +643 @@
     char             k_buf[CONFIG_TXT_KBUF_SIZE];  // local kernel buffer
 
-assert( ( file_xp != XPTR_NULL ) , "file_xp == XPTR_NULL" );
+assert( __FUNCTION__, ( file_xp != XPTR_NULL ) , "file_xp == XPTR_NULL" );
 
 #if (DEBUG_SYS_READ & 1)
@@ -673 +673 @@
 
 // Only TXT devices are associated to a pseudo-file
-assert( ( func == DEV_FUNC_TXT ) , __FUNCTION__, "illegal device func_type");
+assert( __FUNCTION__, ( func == DEV_FUNC_TXT ) , "illegal device func_type");
 
     // initialise number of bytes to move
@@ -770 +770 @@
 
 // detailed argument unused
-assert( (detailed == false) , "detailed argument not supported\n");
+assert( __FUNCTION__, (detailed == false) , "detailed argument not supported\n");
  
     // One loop to scan the target inode xhtab containing the set of dentries

trunk/kernel/fs/devfs.h

@@ -3 +3 @@
  *
  * Authors       Mohamed Lamine Karaoui (2014,2015)
- *               Alain Greiner (2016,2017,2018,2019,2020)
+ *               Alain Greiner          (2016,2017,2018,2019,2020)
  *
  * Copyright (c) 2011,2012 UPMC Sorbonne Universites

trunk/kernel/fs/fatfs.c

@@ -1098 +1098 @@
     error_t    error;
 
-assert( (searched_page_id > first_page_id) ,
+assert( __FUNCTION__, (searched_page_id > first_page_id) ,
 "searched_page_id must be larger than first_page_id\n");
 
@@ -1239 +1239 @@
 
 // check arguments
-assert( (mapper_xp != XPTR_NULL) , "mapper pointer is NULL\n" );
-assert( (name      != NULL     ) , "child name is undefined\n" );
+assert( __FUNCTION__, (mapper_xp != XPTR_NULL) , "mapper pointer is NULL\n" );
+assert( __FUNCTION__, (name      != NULL     ) , "child name is undefined\n" );
 
 #if DEBUG_FATFS_SCAN_DIRECTORY
@@ -1882 +1882 @@
  
 // check arguments
-assert( (parent_inode_xp != XPTR_NULL) , "parent_inode_xp argument is NULL\n" );
-assert( (dentry_ptr      != NULL)      , "dentry_ptr argument is NULL\n" );
+assert( __FUNCTION__, (parent_inode_xp != XPTR_NULL) , "parent_inode_xp argument is NULL\n" );
+assert( __FUNCTION__, (dentry_ptr      != NULL)      , "dentry_ptr argument is NULL\n" );
 
     // get directory inode cluster and local pointer 
@@ -2153 +2153 @@
                     else if (i == 11)                                // ATTR
                     {
-                        if (type == INODE_TYPE_DIR)  buf[i] = 0x10;
+                        if (type == FILE_TYPE_DIR)  buf[i] = 0x10;
                         else                         buf[i] = 0x20;
                     }
@@ -2236 +2236 @@
 
 // check arguments
-assert( (parent_inode_xp != XPTR_NULL) , "parent_inode_xp argument is NULL\n" );
-assert( (dentry_ptr      != NULL)      , "dentry_ptr argument is NULL\n" );
+assert( __FUNCTION__, (parent_inode_xp != XPTR_NULL) , "parent_inode_xp argument is NULL\n" );
+assert( __FUNCTION__, (dentry_ptr      != NULL)      , "dentry_ptr argument is NULL\n" );
 
     // get directory inode cluster and local pointer 
@@ -2344 +2344 @@
 
 // check for LFN entry
-assert( (fatfs_get_remote_record( DIR_ATTR, base_xp + offset ) == ATTR_LONG_NAME_MASK ),
+assert( __FUNCTION__, (fatfs_get_remote_record( DIR_ATTR, base_xp + offset ) == ATTR_LONG_NAME_MASK ),
 "this directory entry must be a LFN\n");
 
@@ -2395 +2395 @@
 
 // check arguments
-assert( (parent_inode_xp != XPTR_NULL)  , "parent_inode_xp is NULL\n" );
-assert( (dentry_ptr      != NULL ) , "dentry_ptr is NULL\n" );
+assert( __FUNCTION__, (parent_inode_xp != XPTR_NULL)  , "parent_inode_xp is NULL\n" );
+assert( __FUNCTION__, (dentry_ptr      != NULL ) , "dentry_ptr is NULL\n" );
 
     // get parent inode cluster and local pointer
@@ -2445 +2445 @@
 
     // update the child inode "type", "size", and "extend" fields
-    vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
+    vfs_file_type_t type = (is_dir) ? FILE_TYPE_DIR : FILE_TYPE_REG;
 
     hal_remote_s32( XPTR( child_cxy , &child_inode_ptr->type   ) , type );
@@ -2486 +2486 @@
 
 // check arguments
-assert( (parent_inode_xp != XPTR_NULL) , "parent_inode_xp argument is NULL\n" );
-assert( (dentry_ptr      != NULL)      , "dentry_ptr argument NULL\n" );
+assert( __FUNCTION__, (parent_inode_xp != XPTR_NULL) , "parent_inode_xp argument is NULL\n" );
+assert( __FUNCTION__, (dentry_ptr      != NULL)      , "dentry_ptr argument NULL\n" );
 
     // get child inode cluster and local pointer
@@ -2574 +2574 @@
 
 // check arguments
-assert( (parent_inode_xp  != XPTR_NULL) , "parent_inode_xp argument is NULL\n" );
-assert( (dentry_ptr       != NULL)      , "dentry_ptr argument is NULL\n" );
+assert( __FUNCTION__, (parent_inode_xp  != XPTR_NULL) , "parent_inode_xp argument is NULL\n" );
+assert( __FUNCTION__, (dentry_ptr       != NULL)      , "dentry_ptr argument is NULL\n" );
 
     // get parent directory cluster ans local pointer
@@ -2680 +2680 @@
 
 // check mapper pointer
-assert( (mapper != NULL) , "mapper is NULL\n");
+assert( __FUNCTION__, (mapper != NULL) , "mapper is NULL\n");
     
 // TODO handle the detailed flag
-assert( (detailed == false), "detailed argument not supported/n");
+assert( __FUNCTION__, (detailed == false), "detailed argument not supported/n");
 
     char       cname[CONFIG_VFS_MAX_NAME_LENGTH];  // name extracted from each dentry
@@ -2829 +2829 @@
 
 // check inode pointer and cluster index
-assert( (inode_xp != XPTR_NULL)          , "inode pointer undefined\n" );
+assert( __FUNCTION__, (inode_xp != XPTR_NULL)          , "inode pointer undefined\n" );
 
 #if DEBUG_FATFS_SYNC_INODE
@@ -2848 +2848 @@
     mapper    = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
 
-assert( (mapper != NULL) , "mapper pointer is NULL\n" );     
+assert( __FUNCTION__, (mapper != NULL) , "mapper pointer is NULL\n" );     
 
     // get inode type and size
@@ -2854 +2854 @@
     type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
 
-assert( (type == INODE_TYPE_FILE) , "inode is not a file\n" );     
+assert( __FUNCTION__, (type == FILE_TYPE_REG) , "inode is not a file\n" );     
 
     // compute number of pages
@@ -3009 +3009 @@
 
 // check inode pointer 
-assert( (inode_xp != XPTR_NULL) , "inode pointer is NULL\n" );
+assert( __FUNCTION__, (inode_xp != XPTR_NULL) , "inode pointer is NULL\n" );
 
     // get inode cluster and local pointer
@@ -3020 +3020 @@
 
 // check first cluster index
-assert( (first_cluster_id != 0) , "inode extend is NULL\n" );
+assert( __FUNCTION__, (first_cluster_id != 0) , "inode extend is NULL\n" );
 
 #if DEBUG_FATFS_RELEASE_INODE

trunk/kernel/fs/ramfs.c

@@ -50 +50 @@
     // update inode type field
     inode_ptr = GET_PTR( inode_xp );
-    inode_ptr->type = INODE_TYPE_DIR;
+    inode_ptr->type = FILE_TYPE_DIR;
 }
 

trunk/kernel/fs/vfs.c

@@ -2 +2 @@
  * vfs.c - Virtual File System implementation.
  *
- * Author  Mohamed Lamine Karaoui (2015)
- *         Alain Greiner (2016,2017,2018,2019,2020)
+ * Author  Mohamed Lamine Karaoui (2014,2015)
+ *         Alain Greiner          (2016,2017,2018,2019,2020)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -38 +38 @@
 #include <thread.h>
 #include <chdev.h>
+#include <pipe.h>
 #include <process.h>
 #include <cluster.h>
@@ -155 +156 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-const char * vfs_inode_type_str( vfs_inode_type_t type )
+const char * vfs_inode_type_str( vfs_file_type_t type )
 {
     switch ( type ) 
     {
-        case INODE_TYPE_FILE: return "FILE";
-        case INODE_TYPE_DIR:  return "DIR ";
-        case INODE_TYPE_FIFO: return "FIFO";
-        case INODE_TYPE_PIPE: return "PIPE";
-        case INODE_TYPE_SOCK: return "SOCK";
-        case INODE_TYPE_DEV:  return "DEV ";
-        case INODE_TYPE_BLK:  return "BLK ";
-        case INODE_TYPE_SYML: return "SYML";
+        case FILE_TYPE_REG: return "FILE";
+        case FILE_TYPE_DIR:  return "DIR ";
+        case FILE_TYPE_FIFO: return "FIFO";
+        case FILE_TYPE_PIPE: return "PIPE";
+        case FILE_TYPE_SOCK: return "SOCK";
+        case FILE_TYPE_DEV:  return "DEV ";
+        case FILE_TYPE_BLK:  return "BLK ";
+        case FILE_TYPE_SYML: return "SYML";
         default:              return "undefined";
     }
@@ -188 +189 @@
     error_t            error;
 
+#if DEBUG_VFS_INODE_CREATE || DEBUG_VFS_ERROR
+uint32_t       cycle      = (uint32_t)hal_get_cycles();
+thread_t *     this       = CURRENT_THREAD;
+#endif
+
     // check fs type and get pointer on context
     if     ( fs_type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
@@ -194 +200 @@
     else
     {
-        printk("\n[ERROR] in %s : illegal FS type\n", __FUNCTION__ );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] / illegal FS type\n",
+__FUNCTION__ , this->process->pid , this->trdid );
+#endif
         return -1;
     }
 
 // check inode descriptor contained in one page
-assert( (sizeof(vfs_inode_t) <= CONFIG_PPM_PAGE_SIZE),
+assert( __FUNCTION__, (sizeof(vfs_inode_t) <= CONFIG_PPM_PAGE_SIZE),
 "inode descriptor must fit in one page" );
 
@@ -207 +218 @@
     if( error )
     {
-        printk("\n[ERROR] in %s : cannot allocate inum\n", __FUNCTION__ );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] cannot allocate inum\n",
+__FUNCTION__ , this->process->pid , this->trdid );
+#endif
         return -1;
     }
@@ -216 +232 @@
     if( mapper_xp == XPTR_NULL )
     {
-        printk("\n[ERROR] in %s : cannot allocate mapper\n", __FUNCTION__ );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] cannot allocate mapper\n",
+__FUNCTION__ , this->process->pid , this->trdid );
+#endif
         vfs_ctx_inum_release( XPTR( cxy , ctx ) , inum );
         return -1;
@@ -232 +253 @@
     if( inode_ptr == NULL )
     {
-        printk("\n[ERROR] in %s : cannot allocate inode descriptor\n", __FUNCTION__ );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] cannot allocate inode\n",
+__FUNCTION__ , this->process->pid , this->trdidi );
+#endif
         vfs_ctx_inum_release( XPTR( cxy , ctx ) , inum );
         mapper_destroy( mapper_xp );
@@ -242 +268 @@
  
     // initialize inode descriptor
-    hal_remote_s32( XPTR( cxy , &inode_ptr->type   ) , INODE_TYPE_FILE );  // default value
+    hal_remote_s32( XPTR( cxy , &inode_ptr->type   ) , FILE_TYPE_REG );  // default value
     hal_remote_s32( XPTR( cxy , &inode_ptr->inum   ) , inum );  
     hal_remote_s32( XPTR( cxy , &inode_ptr->attr   ) , attr );  
@@ -269 +295 @@
 
 #if DEBUG_VFS_INODE_CREATE
-uint32_t       cycle      = (uint32_t)hal_get_cycles();
-thread_t *     this       = CURRENT_THREAD;
 if( DEBUG_VFS_INODE_CREATE < cycle )
 printk("\n[%s] thread[%x,%x] created inode (%x,%x) / ctx %x / fs_type %d / cycle %d\n",
@@ -287 +311 @@
     cxy_t         inode_cxy = GET_CXY( inode_xp );
 
+    // get local pointer on mapper
+    mapper_t    * mapper_ptr = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ));
+
     // release memory allocated for mapper
-    mapper_destroy( XPTR( inode_cxy , &inode_ptr->mapper ) );
+    mapper_destroy( XPTR( inode_cxy , mapper_ptr ) );
 
     // release memory allocated for inode descriptor
@@ -458 +485 @@
 void vfs_inode_display( xptr_t inode_xp )
 {
-    assert( (inode_xp != XPTR_NULL), "inode pointer is NULL");
+    assert( __FUNCTION__, (inode_xp != XPTR_NULL), "inode pointer is NULL");
 
     char  name[CONFIG_VFS_MAX_NAME_LENGTH];
@@ -468 +495 @@
     vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
 
-    vfs_inode_type_t type    = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
+    vfs_file_type_t type    = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
     uint32_t         attr    = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->attr ) );
     uint32_t         size    = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->size ) );
@@ -511 +538 @@
     vfs_dentry_t   * dentry_ptr;     // dentry descriptor (to be allocated)
 
-#if DEBUG_VFS_DENTRY_CREATE
+#if DEBUG_VFS_DENTRY_CREATE || DEBUG_VFS_ERROR
 thread_t * this  = CURRENT_THREAD;
 uint32_t   cycle = (uint32_t)hal_get_cycles();
+#endif
+
+#if DEBUG_VFS_DENTRY_CREATE
 if( DEBUG_VFS_DENTRY_CREATE < cycle )
 printk("\n[%s] thread[%x,%x] enters for <%s> /  fs_type %x / cycle %d\n",
@@ -525 +555 @@
     else 
     {
-        printk("\n[ERROR] in %s undefined fs_type %d\n", __FUNCTION__, fs_type );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] / undefined fs_type %d\n",
+__FUNCTION__ , this->process->pid, this->trdid, fs_type );
+#endif
         return -1;
     }
@@ -542 +577 @@
     if( dentry_ptr == NULL ) 
     {
-        printk("\n[ERROR] in %s : cannot allocate dentry descriptor\n",
-        __FUNCTION__ );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] cannot allocate dentry descriptor\n",
+__FUNCTION__ , this->process->pid, this->trdid );
+#endif
         return -1;
     }
@@ -594 +633 @@
                          xptr_t   * file_xp )
 {
-    vfs_file_t  * file_ptr;
-        kmem_req_t    req;
-    uint32_t      type;
-    mapper_t    * mapper;
-    vfs_ctx_t   * ctx;
+    vfs_file_t   * file_ptr;
+        kmem_req_t     req;
+    uint32_t       type;
+    mapper_t     * mapper;
+    pipe_t       * pipe;
+    vfs_ctx_t    * ctx;
 
     // get inode cluster and local pointer
@@ -607 +647 @@
 thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VFS_OPEN < cycle )
+if( DEBUG_VFS_FILE_CREATE < cycle )
 printk("\n[%s] thread[%x,%x] enter for inode (%x,%x) / cycle %d\n",
 __FUNCTION__, this->process->pid, this->trdid, inode_cxy, inode_ptr, cycle );
@@ -620 +660 @@
     if( file_ptr == NULL ) return -1;
 
-    // get type, ctx and mapper from inode descriptor
+    // get type, ctx, mapper, and buffer from inode descriptor
     type   = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
     ctx    = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->ctx ) );
     mapper = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
+    pipe   = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->pipe ) );
 
     // initializes new file descriptor
     hal_remote_s32( XPTR( inode_cxy , &file_ptr->type     ) , type );
     hal_remote_s32( XPTR( inode_cxy , &file_ptr->attr     ) , attr );
+    hal_remote_spt( XPTR( inode_cxy , &file_ptr->ctx      ) , ctx );
     hal_remote_s32( XPTR( inode_cxy , &file_ptr->offset   ) , 0 );
-    hal_remote_s32( XPTR( inode_cxy , &file_ptr->refcount ) , 1 );
     hal_remote_spt( XPTR( inode_cxy , &file_ptr->inode    ) , inode_ptr );
-    hal_remote_spt( XPTR( inode_cxy , &file_ptr->ctx      ) , ctx );
     hal_remote_spt( XPTR( inode_cxy , &file_ptr->mapper   ) , mapper );
+    hal_remote_spt( XPTR( inode_cxy , &file_ptr->pipe     ) , pipe );
 
     remote_rwlock_init( XPTR( inode_cxy , &file_ptr->lock ), LOCK_VFS_FILE );
@@ -639 +680 @@
 
 #if DEBUG_VFS_FILE_CREATE
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VFS_OPEN < cycle )
-printk("\n[%s] thread[%x,%x] created file (%x,%x) %x\n",
-__FUNCTION__, this->process->pid, this->trdid, inode_cxy, file_ptr, cycle );
+if( (DEBUG_VFS_FILE_CREATE < cycle) && (type == FILE_TYPE_REG))
+{
+    char name[CONFIG_VFS_MAX_NAME_LENGTH];
+    vfs_file_get_name( XPTR( inode_cxy , file_ptr ) , name );
+    printk("\n[%s] thread[%x,%x] created file (%x,%x) / %s (%s)\n",
+    __FUNCTION__, this->process->pid, this->trdid,
+    inode_cxy, file_ptr, vfs_inode_type_str(type), name );
+}
+if( (DEBUG_VFS_FILE_CREATE < cycle) && (type != FILE_TYPE_REG))
+{
+    printk("\n[%s] thread[%x,%x] created file (%x,%x) / %s\n",
+    __FUNCTION__, this->process->pid, this->trdid,
+    inode_cxy, file_ptr, vfs_inode_type_str(type) );
+}
 #endif
 
@@ -655 +706 @@
     vfs_file_t * file_ptr = GET_PTR( file_xp );
     cxy_t        file_cxy = GET_CXY( file_xp );
+
+#if DEBUG_VFS_FILE_DESTROY
+char name[CONFIG_VFS_MAX_NAME_LENGTH];
+vfs_file_get_name( file_xp , name );
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_FILE_DESTROY < cycle )
+printk("\n[%s] thread[%x,%x] enter / file_ptr %x / file_cxy %x / <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, file_ptr, file_cxy, name, cycle );
+#endif
 
     // release file descriptor
@@ -662 +723 @@
         kmem_remote_free( file_cxy , &req );
 
-#if DEBUG_VFS_CLOSE
-char name[CONFIG_VFS_MAX_NAME_LENGTH];
-vfs_file_get_name( file_xp , name );
-thread_t * this = CURRENT_THREAD;
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_VFS_CLOSE < cycle )
-printk("\n[%s] thread[%x,%x] deleted file <%s> in cluster %x / cycle %d\n",
-__FUNCTION__, this->process->pid, this->trdid, name, file_cxy, cycle );
+#if DEBUG_VFS_FILE_DESTROY
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_FILE_DESTROY < cycle )
+printk("\n[%s] thread[%x,%x] exit for <%s> / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, file_ptr, file_cxy, name, cycle );
 #endif
 
 }  // end vfs_file_destroy() 
-
-
-////////////////////////////////////////
-void vfs_file_count_up( xptr_t file_xp )
-{
-    // get file cluster and local pointer
-    cxy_t        file_cxy = GET_CXY( file_xp );
-    vfs_file_t * file_ptr = GET_PTR( file_xp ); 
-
-    // atomically increment count
-    hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , 1 ); 
-}
-
-//////////////////////////////////////////
-void vfs_file_count_down( xptr_t file_xp )
-{
-    // get file cluster and local pointer
-    cxy_t        file_cxy = GET_CXY( file_xp );
-    vfs_file_t * file_ptr = GET_PTR( file_xp ); 
-
-    // atomically decrement count
-    hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , -1 ); 
-}
 
 ///////////////////////////////////////
@@ -755 +790 @@
     if( (flags & O_EXCL   )      )  lookup_mode |= VFS_LOOKUP_EXCL;
  
+#if DEBUG_VFS_OPEN || DEBUG_VFS_ERROR
+uint32_t cycle = (uint32_t)hal_get_cycles();
+#endif
+
 #if DEBUG_VFS_OPEN
-uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_OPEN < cycle )
 printk("\n[%s] thread[%x,%x] enter for <%s> / root_inode (%x,%x) / cycle %d\n",
@@ -791 +829 @@
     if( error )
     {
-        printk("\n[ERROR] in %s : cannot get inode <%s>\n",
-        __FUNCTION__ , path );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] cannot get inode <%s>\n",
+__FUNCTION__ , process->pid, this->trdid , path );
+#endif
         return -1;
     }
@@ -824 +866 @@
     if( error ) return error;
 
+    // get new file descriptor cluster and local pointer
+    cxy_t        file_cxy = GET_CXY( file_xp );
+    vfs_file_t * file_ptr = GET_PTR( file_xp );
+
+    //get file type
+    uint32_t file_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type ));
+
+    // link the client thead to the pipe for a FIFO type
+    if( file_type == FILE_TYPE_FIFO )
+    {
+        // get local pointer on attached pipe
+        pipe_t * pipe = hal_remote_lpt( XPTR( file_cxy , &file_ptr->pipe ));
+
+        // build extended pointer on client thread
+        xptr_t thread_xp = XPTR( local_cxy , this );
+
+        // update pipe descriptor
+        if( flags & O_RDONLY ) hal_remote_s64( XPTR(file_cxy,&pipe->reader_xp) , thread_xp );
+        if( flags & O_WRONLY ) hal_remote_s64( XPTR(file_cxy,&pipe->writer_xp) , thread_xp );
+    }
+
 #if DEBUG_VFS_OPEN
 cycle = (uint32_t)hal_get_cycles();
@@ -849 +912 @@
     mapper_t         * mapper;         // local pointer on file mapper
     vfs_inode_t      * inode;          // local pointer on file inode
-    vfs_inode_type_t   type;           // inode type
+    vfs_file_type_t   type;           // inode type
     uint32_t           offset;         // current offset in file
     uint32_t           size;           // current file size
@@ -856 +919 @@
 
 // check argument
-assert( (file_xp != XPTR_NULL), "file_xp == XPTR_NULL" );
+assert( __FUNCTION__, (file_xp != XPTR_NULL), "file_xp == XPTR_NULL" );
 
     // get cluster and local pointer on remote file descriptor
@@ -870 +933 @@
    
 // check inode type
-assert( (type == INODE_TYPE_FILE), "bad inode type" );
+assert( __FUNCTION__, (type == FILE_TYPE_REG), "bad inode type" );
+
+#if DEBUG_VFS_USER_MOVE || DEBUG_VFS_ERROR
+uint32_t      cycle      = (uint32_t)hal_get_cycles();
+thread_t    * this       = CURRENT_THREAD;
+#endif
 
 #if DEBUG_VFS_USER_MOVE
 char          name[CONFIG_VFS_MAX_NAME_LENGTH];
-uint32_t      cycle      = (uint32_t)hal_get_cycles();
-thread_t    * this       = CURRENT_THREAD;
 vfs_inode_get_name( XPTR( file_cxy , inode ) , name );
 if( cycle > DEBUG_VFS_USER_MOVE )
@@ -929 +995 @@
     if( error ) 
     {
-        printk("\n[ERROR] in %s : cannot move data", __FUNCTION__ );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s thread[%x,%x] cannot move data",
+__FUNCTION__, this->process->pid, this->trdid );
+#endif
         return -1;
     }
@@ -961 +1032 @@
     cxy_t              file_cxy;     // remote file descriptor cluster 
     vfs_file_t       * file_ptr;     // remote file descriptor local pointer
-    vfs_inode_type_t   inode_type;   // remote file type
+    vfs_file_type_t   inode_type;   // remote file type
     uint32_t           file_offset;  // current offset in file
     mapper_t         * mapper_ptr;   // remote mapper local pointer
@@ -968 +1039 @@
 
 // check argument
-assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL" );
+assert( __FUNCTION__, (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL" );
 
     // get cluster and local pointer on remote file descriptor
@@ -978 +1049 @@
 
 // check inode type
-assert( (inode_type == INODE_TYPE_FILE), "bad file type" );
+assert( __FUNCTION__, (inode_type == FILE_TYPE_REG), "bad file type" );
 
     // get mapper pointers and file offset from file descriptor
@@ -1035 +1106 @@
 
 // check arguments
-assert( (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL" );
-assert( (new_offset != NULL )  , "new_offset == NULL" );
+assert( __FUNCTION__, (file_xp != XPTR_NULL) , "file_xp == XPTR_NULL" );
+assert( __FUNCTION__, (new_offset != NULL )  , "new_offset == NULL" );
 
     // get cluster and local pointer on remote file descriptor
@@ -1114 +1185 @@
 
 // check argument
-assert( (file_xp != XPTR_NULL) , "file_xp is XPTR_NULL" );
+assert( __FUNCTION__, (file_xp != XPTR_NULL) , "file_xp is XPTR_NULL" );
 
     thread_t  * this    = CURRENT_THREAD;
@@ -1241 +1312 @@
         xptr_t entry_xp = XPTR( process_cxy , &process_ptr->fd_array.array[file_id] );
         hal_remote_s64( entry_xp , XPTR_NULL );
-        vfs_file_count_down( file_xp );
         hal_fence();
     }    
@@ -1309 +1379 @@
 #endif
 
-    // build extended pointer on lock protecting Inode Tree (in VFS root inode)
+    // 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 );
@@ -1398 +1468 @@
 
     // update inode "type" field
-    hal_remote_s32( XPTR( inode_cxy , &inode_ptr->type ) , INODE_TYPE_DIR ); 
+    hal_remote_s32( XPTR( inode_cxy , &inode_ptr->type ) , FILE_TYPE_DIR ); 
     
 #if(DEBUG_VFS_MKDIR & 1)
@@ -1576 +1646 @@
 
     ///////////////////////////////////////////////////////////////////////
-    if( (inode_type == INODE_TYPE_FILE) || (inode_type == INODE_TYPE_DIR) )
+    if( (inode_type == FILE_TYPE_REG) || (inode_type == FILE_TYPE_DIR) )
     {
         // 1. create one new dentry
@@ -1666 +1736 @@
     vfs_inode_t     * inode_ptr;          // target inode local pointer
     uint32_t          inode_links;        // target inode links count
-    vfs_inode_type_t  inode_type;         // target inode type
+    vfs_file_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
@@ -1805 +1875 @@
 
     ///////////////////////////////////////////////////////////////////////
-    if( (inode_type == INODE_TYPE_FILE) || (inode_type == INODE_TYPE_DIR) )
+    if( (inode_type == FILE_TYPE_REG) || (inode_type == FILE_TYPE_DIR) )  
     {
 
@@ -1814 +1884 @@
 vfs_inode_type_str(inode_type), inode_links );
 #endif
-
-        // 1. Release clusters allocated to target inode 
+        // 1. Release space allocated to inode on IOC device 
         //    and synchronize the FAT on IOC device if last link.
         if( inode_links == 1 ) 
@@ -1834 +1903 @@
             }
 
-            // release clusters on IOC device
+            // release space on IOC device
             error = vfs_fs_release_inode( inode_xp ); 
 
@@ -1869 +1938 @@
 __FUNCTION__, process->pid, this->trdid, path );
 #endif
-        // 3. remove dentry from Inode Tree (and associated chils inode when last link)
+        // 3. remove dentry from Inode Tree (and associated child inode when last link)
         vfs_remove_child_from_parent( dentry_xp );
 
@@ -1876 +1945 @@
 
 #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__, process->pid, this->trdid, path, cycle );
+#endif
+        return 0;
+    }
+    ////////////////////////////////////////
+    else if( inode_type == FILE_TYPE_FIFO )
+    {
+        // 1. destroy the associated pipe
+        pipe_t * pipe    = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->pipe )); 
+        pipe_destroy( XPTR( inode_cxy , pipe ) );
+
+#if(DEBUG_VFS_UNLINK & 1)
+if( DEBUG_VFS_UNLINK < cycle )
+printk("\n[%s] thread[%x,%x] released <%s> pipe\n",
+__FUNCTION__, process->pid, this->trdid, path );
+#endif
+
+        // 2. remove dentry from Inode Tree (and associated child 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",
@@ -1975 +2070 @@
     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
+    vfs_file_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
@@ -2027 +2122 @@
     inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
 
-    if( inode_type != INODE_TYPE_DIR )
+    if( inode_type != FILE_TYPE_DIR )
     {
         printk("\n[ERROR] in %s : <%s> is not a directory\n",
@@ -2073 +2168 @@
 
 // check lookup working mode
-assert( (rights == 0), "access rights non implemented yet" );
+assert( __FUNCTION__, (rights == 0), "access rights non implemented yet" );
  
     // get extended pointer on target inode
@@ -2093 +2188 @@
     // TODO finalize implementation
 
-assert( false , "not implemented" );
+assert( __FUNCTION__, false , "not implemented" );
 
     // set inode rights in remote inode
@@ -2099 +2194 @@
 
     return 0;
-}
-
-///////////////////////////////////
-error_t vfs_mkfifo( xptr_t   cwd_xp,
+
+}   // end vfs_chmod()
+
+/////////////////////////////////////
+error_t vfs_mkfifo( xptr_t   root_xp,
                     char   * path,
-                    uint32_t rights )
-{
-    assert( false , "not implemented %l %x %x", cwd_xp, path, rights );
+                    uint32_t mode )
+{
+    error_t       error;
+    xptr_t        parent_inode_xp;         // extended pointer on parent inode in path
+    xptr_t        fifo_dentry_xp;          // extended pointer on created dentry
+    xptr_t        fifo_inode_xp;           // extended pointer on created inode
+    cxy_t         fifo_cxy;                // selected cluster for fifo inode
+
+    char          fifo_name[CONFIG_VFS_MAX_NAME_LENGTH];
+
+    thread_t    * this    = CURRENT_THREAD;
+    process_t   * process = this->process;
+
+    // build extended pointer on lock protecting Inode Tree
+    xptr_t        vfs_root_xp  = process->vfs_root_xp;
+    vfs_inode_t * vfs_root_ptr = GET_PTR( vfs_root_xp );
+    cxy_t         vfs_root_cxy = GET_CXY( vfs_root_xp );
+    xptr_t        vfs_lock_xp  = XPTR( vfs_root_cxy , &vfs_root_ptr->main_lock );
+
+    // take the lock protecting the Inode-Tree in write mode
+    remote_rwlock_wr_acquire( vfs_lock_xp );
+
+    // 1. get extended pointer on parent inode and fifo name from vfs
+    error = vfs_lookup( root_xp,
+                        path,
+                        VFS_LOOKUP_PARENT,
+                        &parent_inode_xp,
+                        fifo_name );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot get parent inode for <%s> path\n",
+        __FUNCTION__ , path );
+        return -1;
+    }
+
+    // get parent inode cluster and local pointer
+    cxy_t         parent_cxy = GET_CXY( parent_inode_xp );
+    vfs_inode_t * parent_ptr = GET_PTR( parent_inode_xp );
+
+    // 2. select a cluster for new fifo inode 
+    fifo_cxy = cluster_random_select();
+
+    // get parent inode FS type
+    vfs_ctx_t    * ctx_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
+    vfs_fs_type_t  fs_type = hal_remote_l32( XPTR( parent_cxy , &ctx_ptr->type ) );
+
+    // 3. insert a new inode and dentry in Inode-Tree
+    error = vfs_add_child_in_parent( fifo_cxy,
+                                     fs_type, 
+                                     parent_inode_xp,
+                                     fifo_name,           
+                                     &fifo_dentry_xp,   
+                                     &fifo_inode_xp );
+   
+    // get fifo inode local pointer
+    vfs_inode_t * fifo_inode_ptr = GET_PTR( fifo_inode_xp );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot create fifo inode for <%s> path\n",
+        __FUNCTION__ , path );
+        return -1;
+    }
+
+    // 4. allocate memory for a pipe descriptor, for the
+    //    remote_buf_t descriptor, and for the associated data buffer
+    pipe_t * pipe = pipe_create( fifo_cxy,
+                                 CONFIG_PIPE_BUF_SIZE ); 
+    if( pipe == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot create pipe for <%s> path\n",
+        __FUNCTION__ , path );
+        return -1;
+    }
+
+    // 5. update fifo_inode "type", "pipe", and "rights" fields
+    hal_remote_s32( XPTR( fifo_cxy , &fifo_inode_ptr->type ) , FILE_TYPE_FIFO ); 
+    hal_remote_s32( XPTR( fifo_cxy , &fifo_inode_ptr->rights ) , mode ); 
+    hal_remote_spt( XPTR( fifo_cxy , &fifo_inode_ptr->pipe ) , pipe   );
+
+    // release the lock protecting the Inode-Tree from write mode
+    remote_rwlock_wr_release( vfs_lock_xp );
+
     return 0;
-}
+
+}   // end vfs_mkfifo()
 
 
@@ -2126 +2303 @@
     cxy_t              inode_cxy;
     vfs_inode_t      * inode_ptr;
-    vfs_inode_type_t   inode_type;
+    vfs_file_type_t   inode_type;
     uint32_t           inode_size;
     uint32_t           inode_attr;
@@ -2159 +2336 @@
                                         "                              " };  // level 15
 
-assert( (inode_xp != XPTR_NULL) , "inode_xp cannot be NULL" );
-assert( (name_xp  != XPTR_NULL) , "name_xp cannot be NULL" );
-assert( (indent < 16)           , "depth cannot be larger than 15" );
+assert( __FUNCTION__, (inode_xp != XPTR_NULL) , "inode_xp cannot be NULL" );
+assert( __FUNCTION__, (name_xp  != XPTR_NULL) , "name_xp cannot be NULL" );
+assert( __FUNCTION__, (indent < 16)           , "depth cannot be larger than 15" );
     
     // get current inode cluster and local pointer
@@ -2187 +2364 @@
     // scan directory entries when current inode is a directory
     // don't scan the the "." and ".." directories to break loops 
-    if( (inode_type == INODE_TYPE_DIR) && 
+    if( (inode_type == FILE_TYPE_DIR) && 
         (strcmp( name , "." ) != 0)    &&
         (strcmp( name , ".." ) != 0) )
@@ -2449 +2626 @@
 
 // check pathname / root_xp consistency
-assert( ((pathname[0] != '/') || (root_xp == process->vfs_root_xp)), 
+assert( __FUNCTION__, ((pathname[0] != '/') || (root_xp == process->vfs_root_xp)), 
 "root inode must be VFS root for path <%s>", pathname );
 
+#if DEBUG_VFS_LOOKUP || DEBUG_VFS_ERROR
+uint32_t cycle = (uint32_t)hal_get_cycles();
+#endif
+
 #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 );
@@ -2564 +2744 @@
                 if( error )
                 {
-                    printk("\n[ERROR] in %s : cannot create inode <%s> in path <%s>\n",
-                    __FUNCTION__ , name, pathname );
+
+#if DEBUG_VFS_ERROR  
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] cannot create inode <%s> in path <%s>\n",
+__FUNCTION__ , process->pid, this->trdid, name, pathname );
+#endif
                     return -1;
                 }
@@ -2575 +2759 @@
 #if (DEBUG_VFS_LOOKUP & 1)
 if( DEBUG_VFS_LOOKUP < cycle )
-printk("\n[%s] thread[%x,%x] created missing inode <%s> in cluster %x\n",
+printk("\n[%s] thread[%x,%x] created dentry/inode <%s> in cluster %x\n",
 __FUNCTION__, process->pid, this->trdid, name, child_cxy );
 #endif
@@ -2591 +2775 @@
                         if ( error )
                         {
-                            printk("\n[ERROR] in %s : cannot add dentry <%s> in parent dir\n",
-                            __FUNCTION__, name );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] cannot add dentry <%s> in parent dir\n",
+__FUNCTION__, process->pid, this->trdid, name );
+#endif
                             vfs_remove_child_from_parent( dentry_xp );
                             return -1;
@@ -2601 +2789 @@
 printk("\n[%s] thread[%x,%x] child <%s> not found in parent mapper => created it\n",
 __FUNCTION__, process->pid, this->trdid, name );
-vfs_inode_display( child_xp );
 #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 );
+
+#if DEBUG_VFS_ERROR      
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] cannot found node <%s> in parent for <%s>\n",
+__FUNCTION__ , process->pid, this->trdid, name, pathname );
+#endif
                         vfs_remove_child_from_parent( dentry_xp );
                         return -1;
@@ -2617 +2808 @@
                     if( last && create && excl )
                     {
-                        printk("\n[ERROR] in %s : node already exist <%s>\n",
-                        __FUNCTION__, name );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] found an existing node <%s>  %\n",
+__FUNCTION__ , process->pid, this->trdid, pathname );
+#endif
                        return -1;
                     }
@@ -2629 +2824 @@
                     // 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( type == FILE_TYPE_DIR ) 
                     {
                         error = vfs_inode_load_all_pages( child_xp );
@@ -2635 +2830 @@
                         if ( error )
                         {
-                            printk("\n[ERROR] in %s : cannot load <%s> from device\n",
-                            __FUNCTION__ , name );
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] cannot load <%s> from device\n",
+__FUNCTION__ , process->pid, this->trdid, name );
+#endif
                             vfs_remove_child_from_parent( dentry_xp );
                             return -1;
@@ -2664 +2862 @@
             if( last && create && excl )
             {
-                printk("\n[ERROR] in %s : node <%s> already exist\n",
-                __FUNCTION__, name );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] found an existing node <%s>\n",
+__FUNCTION__ , process->pid, this->trdid, pathname );
+#endif
                 return -1;
             }
@@ -2676 +2878 @@
         // if( error ) 
         // {
-        //     printk("\n[ERROR] in %s : thread %x / permission denied for %s\n",
-        //     __FUNCTION__ , this , name );
-        //     return EACCES;
+        //     #if DEBUG_VFS_ERROR
+        //     if( DEBUG_VFS_ERROR < cycle )
+        //     printk("\n[ERROR] in %s : thread[%x,%x] / permission denied for <%s>\n",
+        //     __FUNCTION__ , process->pid, this->trdid , pathname );
+        //     #endif
+        //
+        //     return -1;
         // }
 
@@ -2983 +3189 @@
 
 // check buffer overflow
-assert( (index >= 0) , "kernel buffer too small" );
+assert( __FUNCTION__, (index >= 0) , "kernel buffer too small" );
 
             }
@@ -3009 +3215 @@
 
 // check buffer overflow
-assert( (index >= 0) , "kernel buffer too small" );
+assert( __FUNCTION__, (index >= 0) , "kernel buffer too small" );
 
             // update pathname
@@ -3067 +3273 @@
     parent_inode_ptr = GET_PTR( parent_inode_xp );
 
+#if DEBUG_VFS_ADD_CHILD || DEBUG_VFS_ERROR
+uint32_t cycle = (uint32_t)hal_get_cycles();
+thread_t * this = CURRENT_THREAD; 
+#endif
+
 #if DEBUG_VFS_ADD_CHILD
 char parent_name[CONFIG_VFS_MAX_NAME_LENGTH];
 vfs_inode_get_name( parent_inode_xp , parent_name );
-uint32_t cycle = (uint32_t)hal_get_cycles();
-thread_t * this = CURRENT_THREAD; 
 if( DEBUG_VFS_ADD_CHILD < cycle )
 printk("\n[%s] thread[%x,%x] enter / child <%s> / parent <%s> / cycle %d\n",
@@ -3085 +3294 @@
     if( error )
     {
-        printk("\n[ERROR] in %s : cannot create dentry <%s> in cluster %x\n",
-        __FUNCTION__ , name , parent_cxy );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] cannot create dentry <%s> in cluster %x\n",
+__FUNCTION__ , this->process->pid, this->trdid , name , parent_cxy );
+#endif
         return -1;
     }
@@ -3115 +3328 @@
     if( error )
     {
-        printk("\n[ERROR] in %s : cannot create inode in cluster %x\n",
-               __FUNCTION__ , child_cxy );
+
+#if DEBUG_VFS_ERROR
+if( DEBUG_VFS_ERROR < cycle )
+printk("\n[ERROR] in %s : thread[%x,%x] cannot create inode in cluster %x\n",
+__FUNCTION__ , this->process->pid , this->trdid , child_cxy );
+#endif
  
         vfs_dentry_destroy( new_dentry_xp );
@@ -3184 +3401 @@
     vfs_inode_t  * parent_inode_ptr;   // local pointer on parent inode
     uint32_t       links;              // number of child inode parents
+    error_t        error;
+
+#if DEBUG_VFS_REMOVE_CHILD 
+uint32_t   cycle = (uint32_t)hal_get_cycles();
+#endif
 
     char dentry_name[CONFIG_VFS_MAX_NAME_LENGTH];
    
+    thread_t * this  = CURRENT_THREAD;
+
     // get parent cluster and dentry local pointer
     parent_cxy = GET_CXY( dentry_xp );
@@ -3203 +3427 @@
     child_inode_ptr  = GET_PTR( child_inode_xp );
 
+#if DEBUG_VFS_REMOVE_CHILD
+if( DEBUG_VFS_REMOVE_CHILD < cycle )
+printk("\n[%s] thread[%x,%x] enter for dentry[%x,%x] / inode[%x,%x] / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid,
+parent_cxy, dentry_ptr, child_cxy, child_inode_ptr, cycle );
+#endif
+
     // remove dentry from parent_inode
-    xhtab_remove( XPTR( parent_cxy , &parent_inode_ptr->children ),
-                  dentry_name,
-                  XPTR( parent_cxy , &dentry_ptr->children ) );
+    error = xhtab_remove( XPTR( parent_cxy , &parent_inode_ptr->children ),
+                          dentry_name,
+                          XPTR( parent_cxy , &dentry_ptr->children ) );
+
+    if( error )
+    { 
+        printk("\n[WARNING] in %s] thread[%x,%x] cannot remove dentry %s from parent dir\n",
+        __FUNCTION__, this->process->pid, this->trdid, dentry_name ); 
+    }
+
+#if DEBUG_VFS_REMOVE_CHILD
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_REMOVE_CHILD < cycle )
+printk("\n[%s] thread[%x,%x] removed dentry from parent inode / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
 
     // remove dentry from child_inode
     xlist_unlink( XPTR( parent_cxy , &dentry_ptr->parents ) );
+
+    // get and update number of parents dentries
     links = hal_remote_atomic_add( XPTR( child_cxy , &child_inode_ptr->links ) , -1 );
+
+#if DEBUG_VFS_REMOVE_CHILD
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_REMOVE_CHILD < cycle )
+printk("\n[%s] thread[%x,%x] removed dentry from child inode / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
 
     // delete dentry descriptor
     vfs_dentry_destroy( dentry_xp );
 
+#if DEBUG_VFS_REMOVE_CHILD
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_REMOVE_CHILD < cycle )
+printk("\n[%s] thread[%x,%x] deleted dentry descriptor / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+
     // delete child_inode descriptor if last link
-    if( links == 1 )  vfs_inode_destroy( child_inode_xp );
-
+    if( links == 1 )
+    {
+        vfs_inode_destroy( child_inode_xp );
+
+#if DEBUG_VFS_REMOVE_CHILD
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_REMOVE_CHILD < cycle )
+printk("\n[%s] thread[%x,%x] deleted child inode descriptor / cycle %d\n",
+__FUNCTION__, this->process->pid, this->trdid, cycle );
+#endif
+
+    }
 }  // end vfs_remove_child_from_parent()
 
@@ -3233 +3503 @@
     error_t error = 0;
 
-assert( (inode_xp   != XPTR_NULL) , "inode_xp argument is NULL" );
-assert( (dentry_ptr != NULL     ) , "dentry_ptr argument is NULL" );
+assert( __FUNCTION__, (inode_xp   != XPTR_NULL) , "inode_xp argument is NULL" );
+assert( __FUNCTION__, (dentry_ptr != NULL     ) , "dentry_ptr argument is NULL" );
 
     vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
@@ -3242 +3512 @@
     mapper_t * mapper = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
 
-assert( (mapper != NULL) , "mapper pointer is NULL")        
+assert( __FUNCTION__, (mapper != NULL) , "mapper pointer is NULL");        
 
     // get FS type
@@ -3262 +3532 @@
     else
     {
-        assert( false , "undefined file system type" );
+        assert( __FUNCTION__, false , "undefined file system type" );
     }
 
@@ -3275 +3545 @@
     error_t error = 0;
 
-assert( (inode_xp   != XPTR_NULL) , "inode_xp argument is NULL" );
-assert( (dentry_ptr != NULL     ) , "dentry_ptr argument is NULL" );
+assert( __FUNCTION__, (inode_xp   != XPTR_NULL) , "inode_xp argument is NULL" );
+assert( __FUNCTION__, (dentry_ptr != NULL     ) , "dentry_ptr argument is NULL" );
 
     vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
@@ -3284 +3554 @@
     mapper_t * mapper = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
 
-assert( (mapper != NULL) , "mapper pointer is NULL")        
+assert( __FUNCTION__, (mapper != NULL) , "mapper pointer is NULL");        
 
     // get FS type
@@ -3305 +3575 @@
     else
     {
-        assert( false , "undefined file system type" );
+        assert( __FUNCTION__, false , "undefined file system type" );
     }
 
@@ -3318 +3588 @@
     error_t error = 0;
 
-assert( (inode_xp   != XPTR_NULL) , "inode_xp argument is NULL" );
-assert( (dentry_ptr != NULL     ) , "dentry_ptr argument is NULL" );
+assert( __FUNCTION__, (inode_xp   != XPTR_NULL) , "inode_xp argument is NULL" );
+assert( __FUNCTION__, (dentry_ptr != NULL     ) , "dentry_ptr argument is NULL" );
 
     vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
@@ -3327 +3597 @@
     mapper_t * mapper = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
 
-assert( (mapper != NULL) , "mapper pointer is NULL")        
+assert( __FUNCTION__, (mapper != NULL) , "mapper pointer is NULL");
 
     // get FS type
@@ -3339 +3609 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS" );
+        assert( __FUNCTION__, false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS" );
+        assert( __FUNCTION__, false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type" );
+        assert( __FUNCTION__, false , "undefined file system type" );
     }
 
@@ -3360 +3630 @@
     error_t error = 0;
 
-assert( (inode_xp   != XPTR_NULL) , "inode_xp argument is NULL" );
-assert( (dentry_ptr != NULL     ) , "dentry_ptr argument is NULL" );
+assert( __FUNCTION__, (inode_xp   != XPTR_NULL) , "inode_xp argument is NULL" );
+assert( __FUNCTION__, (dentry_ptr != NULL     ) , "dentry_ptr argument is NULL" );
 
     vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
@@ -3369 +3639 @@
     mapper_t * mapper = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
 
-assert( (mapper != NULL) , "mapper pointer is NULL")        
+assert( __FUNCTION__, (mapper != NULL) , "mapper pointer is NULL");
 
     // get FS type
@@ -3381 +3651 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS" );
+        assert( __FUNCTION__, false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS" );
+        assert( __FUNCTION__, false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type" );
+        assert( __FUNCTION__, false , "undefined file system type" );
     }
 
@@ -3402 +3672 @@
     error_t error = 0;
 
-assert( (inode_xp   != XPTR_NULL) , "inode_xp argument is NULL" );
-assert( (dentry_ptr != NULL     ) , "dentry_ptr argument is NULL" );
+assert( __FUNCTION__, (inode_xp   != XPTR_NULL) , "inode_xp argument is NULL" );
+assert( __FUNCTION__, (dentry_ptr != NULL     ) , "dentry_ptr argument is NULL" );
 
     vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
@@ -3411 +3681 @@
     mapper_t * mapper = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
 
-assert( (mapper != NULL) , "mapper pointer is NULL")        
+assert( __FUNCTION__, (mapper != NULL) , "mapper pointer is NULL");
 
     // get FS type
@@ -3423 +3693 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS" );
+        assert( __FUNCTION__, false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS" );
+        assert( __FUNCTION__, false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type" );
+        assert( __FUNCTION__, false , "undefined file system type" );
     }
 
@@ -3450 +3720 @@
 
 // check arguments
-assert( (inode != NULL) , "parent pointer is NULL");
-assert( (array != NULL) , "child pointer is NULL");
-assert( (detailed == false) , "detailed argument not supported\n");
+assert( __FUNCTION__, (inode != NULL) , "parent pointer is NULL");
+assert( __FUNCTION__, (array != NULL) , "child pointer is NULL");
+assert( __FUNCTION__, (detailed == false) , "detailed argument not supported\n");
 
     // check inode type
-    if( inode->type != INODE_TYPE_DIR )
+    if( inode->type != FILE_TYPE_DIR )
     {
         printk("\n[ERROR] in %s : target inode is not a directory\n",
@@ -3478 +3748 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS" );
+        assert( __FUNCTION__, false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
@@ -3492 +3762 @@
     else
     {
-        assert( false , "undefined file system type" );
+        assert( __FUNCTION__, false , "undefined file system type" );
     }
 
@@ -3504 +3774 @@
     error_t error = 0;
 
-assert( (inode_xp != XPTR_NULL) , "inode_xp argument is NULL");
+assert( __FUNCTION__, (inode_xp != XPTR_NULL) , "inode_xp argument is NULL");
 
     vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
@@ -3512 +3782 @@
     mapper_t * mapper = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
 
-assert( (mapper != NULL) , "mapper pointer is NULL")        
+assert( __FUNCTION__, (mapper != NULL) , "mapper pointer is NULL");
 
     // get FS type
@@ -3524 +3794 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS" );
+        assert( __FUNCTION__, false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS" );
+        assert( __FUNCTION__, false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type" );
+        assert( __FUNCTION__, false , "undefined file system type" );
     }
 
@@ -3551 +3821 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS" );
+        assert( __FUNCTION__, false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS" );
+        assert( __FUNCTION__, false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type" );
+        assert( __FUNCTION__, false , "undefined file system type" );
     }
 
@@ -3571 +3841 @@
     error_t error = 0;
 
-assert( (inode_xp  != XPTR_NULL) , "inode_xp argument is NULL")        
+assert( __FUNCTION__, (inode_xp  != XPTR_NULL) , "inode_xp argument is NULL");
 
     vfs_inode_t * inode_ptr = GET_PTR( inode_xp );
@@ -3579 +3849 @@
     mapper_t * mapper = hal_remote_lpt( XPTR( inode_cxy , &inode_ptr->mapper ) );
 
-assert( (mapper != NULL) , "mapper pointer is NULL")        
+assert( __FUNCTION__, (mapper != NULL) , "mapper pointer is NULL");
 
     // get FS type from mapper
@@ -3591 +3861 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS" );
+        assert( __FUNCTION__, false , "should not be called for RAMFS" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS" );
+        assert( __FUNCTION__, false , "should not be called for DEVFS" );
     }
     else
     {
-        assert( false , "undefined file system type" );
+        assert( __FUNCTION__, false , "undefined file system type" );
     }
 
@@ -3612 +3882 @@
     error_t error = 0;
 
-assert( (page_xp != XPTR_NULL) , "page pointer is NULL" );
+assert( __FUNCTION__, (page_xp != XPTR_NULL) , "page pointer is NULL" );
 
     page_t * page_ptr = GET_PTR( page_xp );
@@ -3620 +3890 @@
     mapper_t * mapper = hal_remote_lpt( XPTR( page_cxy , &page_ptr->mapper ) );
 
-assert( (mapper != NULL) , "no mapper for page" );
+assert( __FUNCTION__, (mapper != NULL) , "no mapper for page" );
 
     // get FS type
@@ -3632 +3902 @@
     else if( fs_type == FS_TYPE_RAMFS )
     {
-        assert( false , "should not be called for RAMFS\n" );
+        assert( __FUNCTION__, false , "should not be called for RAMFS\n" );
     }
     else if( fs_type == FS_TYPE_DEVFS )
     {
-        assert( false , "should not be called for DEVFS\n" );
+        assert( __FUNCTION__, false , "should not be called for DEVFS\n" );
     }
     else
     {
-        assert( false , "undefined file system type" );
+        assert( __FUNCTION__, false , "undefined file system type" );
     }
 

trunk/kernel/fs/vfs.h

@@ -3 +3 @@
  *
  * Author  Mohamed Lamine Karaoui (2014,2015)
- *         Alain Greiner (2016,2017,2018,2019,2020)
+ *         Alain Greiner          (2016,2017,2018,2019,2020)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -49 +49 @@
 struct vfs_ctx_s;
 struct vfs_file_s;
-
+struct remote_buf_s;
 struct mapper_s;
 struct process_s;
@@ -66 +66 @@
 #define VFS_LOOKUP_CREATE   0x10     /* file must be created if missing                  */
 #define VFS_LOOKUP_EXCL     0x20     /* file cannot previously exist                     */
+
+
+
 
 /******************************************************************************************
@@ -105 +108 @@
 }
 vfs_ctx_t;
+
+/******************************************************************************************
+ *        These functions access / modify  a VFS context.
+ *****************************************************************************************/
+
+/****************************************************************************************** 
+ * This function initialises a (statically allocated) VFS context in cluster identified
+ * by the <cxy> argument. 
+ * It is called by the kernel_init() function.
+ ******************************************************************************************
+ * @ cxy            : target cluster identifier.
+ * @ fs_type        : file system type.
+ * @ total_clusters : total number of clusters on device.
+ * @ cluster_size   : cluster size on device (bytes).
+ * @ vfs_root_xp    : extended pointer on VFS root inode.
+ * @ extend         : fs_type_specific extension.
+ *****************************************************************************************/
+void vfs_ctx_init( cxy_t           cxy,
+                   vfs_fs_type_t   type,
+                       uint32_t        total_clusters,
+                       uint32_t        cluster_size,
+                       xptr_t          vfs_root_xp,
+                   void          * extend );
+
+/****************************************************************************************** 
+ * This function allocates an inode identifier from the local cluster inum allocator.
+ * The inum respects a fixed format:
+ * - the 16 MSB bits contain the cluster identifier : cxy
+ * - the 16 LSB bits contains the local inode identifier  : lid
+ ******************************************************************************************
+ * @ ctx_xp   : [in]  extended pointer on file system context.
+ * @ inum     : [out] buffer for allocated inode identifier.
+ * @ return 0 if success / return non-zero if error.
+ *****************************************************************************************/
+error_t vfs_ctx_inum_alloc( xptr_t     ctx_xp,
+                            uint32_t * inum );
+
+/****************************************************************************************** 
+ * This function release an inode identifier.                                  
+ ******************************************************************************************
+ * @ ctx_xp   : [in] extended pointer on file system context.
+ * @ inum     : [in] released inode identifier.
+ *****************************************************************************************/
+void vfs_ctx_inum_release( xptr_t      ctx_xp,
+                           uint32_t    inum );
+
+
+
+
+
+
+/******************************************************************************************
+ * This file structure describes an open file/directory for a given process.
+ * It is not replicated, and is dynamically allocated in the cluster that contains
+ * the associated inode / socket / pipe , when a thread makes an open(), opendir(),
+ * socket(), or pipe() system call. It cannot exist a <file> structure without a 
+ * a <mapper>, <socket>, or <pipe> structure (depending on type) in same cluster.
+ * It can exist a <file> structure without an <inode> (for PIPE and SOCK types).
+ *****************************************************************************************/
+
+/* this enum define the VFS inode types values                                           */
+/* WARNING : this enum must be kept consistent with macros in <shared_stat.h> file       */
+/*           and with types in <shared_dirent.h> file.                                   */
+
+typedef enum   
+{
+    FILE_TYPE_REG   =     0,           /*! regular file                                 */
+    FILE_TYPE_DIR   =     1,           /*! directory                                    */
+    FILE_TYPE_FIFO  =     2,           /*! POSIX named fifo                             */
+    FILE_TYPE_PIPE  =     3,           /*! POSIX anonymous pipe                         */
+    FILE_TYPE_SOCK  =     4,           /*! POSIX anonymous socket                       */
+    FILE_TYPE_DEV   =     5,           /*! character device                             */
+    FILE_TYPE_BLK   =     6,           /*! block device                                 */
+    FILE_TYPE_SYML  =     7,           /*! symbolic link                                */
+}
+vfs_file_type_t;
+
+typedef enum
+{
+    FD_ATTR_READ_ENABLE    = 0x01,     /*! read access possible                          */
+    FD_ATTR_WRITE_ENABLE   = 0x02,     /*! write access possible                         */
+    FD_ATTR_APPEND         = 0x04,     /*! append on each write                          */
+    FD_ATTR_CLOSE_EXEC     = 0x08,     /*! close file on exec                            */
+    FD_ATTR_SYNC           = 0x10,     /*! synchronise FS on each write                  */
+    FD_ATTR_IS_DIR         = 0x20,     /*! this is a directory                           */
+}
+vfs_file_attr_t;
+
+typedef struct vfs_file_s
+{
+        struct vfs_ctx_s      * ctx;        /*! local pointer on FS context.                 */
+        vfs_file_attr_t         attr;       /*! file attributes bit vector (see above)       */
+        vfs_file_type_t        type;       /*! same type as inode                           */
+        uint32_t                offset;     /*! seek position in file                        */
+        remote_rwlock_t         lock;       /*! protect offset modifications                 */
+        struct vfs_inode_s    * inode;      /*! local pointer on associated inode            */
+        struct mapper_s       * mapper;     /*! associated mapper (REG or DIR types only)    */
+    struct socket_s       * socket;     /*! associated socket (SOCK type only)           */
+    struct pipe_s         * pipe;       /*! associated pipe (FIFO or PIPE types only)    */
+        void                  * extend;     /*! FS specific extension                        */
+}
+vfs_file_t;
+
+/******************************************************************************************
+ *        These low-level functions access / modify a VFS file descriptor
+ *****************************************************************************************/
+
+/****************************************************************************************** 
+ * This function allocates memory and initializes a new file descriptor in the
+ * cluster defined by the <inode_xp> argument.
+ * It can be called by any thread running in any cluster.
+ ****************************************************************************************** 
+ * @ inode_xp  : [in]  extended pointer on associated inode.
+ * @ attr      : [in]  file descriptor attributes.
+ * @ file_xp   : [out] buffer for extended pointer on created file descriptor.
+ * @ return 0 if success / return ENOMEM if error.
+ *****************************************************************************************/
+error_t vfs_file_create( xptr_t        inode_xp,
+                         uint32_t      attr,
+                         xptr_t      * file_xp );  
+
+/****************************************************************************************** 
+ * This function releases memory allocated to file descriptor identified
+ * by the <file_xp> argument.
+ * It can be called by any thread running in any cluster.
+ ****************************************************************************************** 
+ * @ file_xp  : [in] extended pointer on file descriptor.
+ *****************************************************************************************/
+void vfs_file_destroy( xptr_t  file_xp );  
+
+/****************************************************************************************** 
+ * This debug function copies the name of a the file identified by <file_xp>
+ * argument to a local buffer identified by the <name> argument.
+ * The local buffer size must be at least CONFIG_VFS_MAX_NAME_LENGTH. 
+ *****************************************************************************************
+ * @ ionde_xp  : [in] extended pointer on the remote inode.
+ * @ name      : [out] local string.
+ ***************************************************************************************/
+void vfs_file_get_name( xptr_t inode_xp,
+                        char * name );
+
+
+
 
 /******************************************************************************************
@@ -124 +270 @@
  *****************************************************************************************/
 
-/* this enum define the VFS inode types values                                           */
-/* WARNING : this enum must be kept consistent with macros in <shared_stat.h> file       */
-/*           and with types in <shared_dirent.h> file.                                   */
-
-typedef enum   
-{
-    INODE_TYPE_FILE  =     0,           /*! regular file                                 */
-    INODE_TYPE_DIR   =     1,           /*! directory                                    */
-    INODE_TYPE_FIFO  =     2,           /*! POSIX named pipe                             */
-    INODE_TYPE_PIPE  =     3,           /*! POSIX anonymous pipe                         */
-    INODE_TYPE_SOCK  =     4,           /*! POSIX socket                                 */
-    INODE_TYPE_DEV   =     5,           /*! character device                             */
-    INODE_TYPE_BLK   =     6,           /*! block device                                 */
-    INODE_TYPE_SYML  =     7,           /*! symbolic link                                */
-}
-vfs_inode_type_t;
-
 /* this enum define the VFS inode attributes values */
 
@@ -153 +282 @@
 typedef struct vfs_inode_s
 {
-    struct vfs_ctx_s * ctx;              /*! local pointer on FS context                 */
-    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           uid;              /*! user owner identifier                       */
-    uint32_t           gid;              /*! group owner identifier                      */
-    uint32_t           rights;           /*! access rights                               */
-    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    size_lock;        /*! protect read/write to size                  */
-    remote_rwlock_t    main_lock;        /*! protect inode tree traversal and modifs     */
-    struct mapper_s  * mapper;           /*! associated file cache                       */
-    void             * extend;           /*! fs_type_specific inode extension            */
+    struct vfs_ctx_s    * ctx;           /*! local pointer on FS context                 */
+    uint32_t              inum;          /*! inode identifier (unique in file system)    */
+    uint32_t              attr;          /*! inode attributes (see above)                */
+    vfs_file_type_t      type;          /*! inode type (see above)                      */
+    uint32_t              size;          /*! number of bytes                             */
+    uint32_t              uid;           /*! user owner identifier                       */
+    uint32_t              gid;           /*! group owner identifier                      */
+    uint32_t              rights;        /*! access rights                               */
+    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       size_lock;     /*! protect read/write to size                  */
+    remote_rwlock_t       main_lock;     /*! protect inode tree traversal and modifs     */
+    struct mapper_s     * mapper;        /*! associated file (REG or DIR types only)     */
+    struct remote_buf_s * pipe;          /*! associated pipe (FIFO type only)            */
+    void                * extend;        /*! fs_type_specific inode extension            */
 }
 vfs_inode_t;
@@ -191 +321 @@
 #define VFS_IWOTH      0x0000002
 #define VFS_IXOTH      0x0000001
+
+/******************************************************************************************
+ *        These low-level functions access / modify a VFS inode descriptor
+ *****************************************************************************************/
+
+/****************************************************************************************** 
+ * This function returns a printable string for the inode type.
+ *****************************************************************************************/
+const char * vfs_inode_type_str( vfs_file_type_t type );
+
+/****************************************************************************************** 
+ * This function allocates memory in cluster identified by the <cxy> argument 
+ * for an inode descriptor and for the associated mapper, and partially initialise 
+ * this inode from arguments values.
+ * It does NOT link it to the Inode Tree, as this is done by add_child_in_parent(). 
+ * It can be called by any thread running in any cluster.
+ ******************************************************************************************
+ * @ cxy        : [in]  target cluster identifier
+ * @ fs_type    : [in]  file system type.
+ * @ attr       : [in]  inode attributes.
+ * @ rights     : [in]  inode access rights.
+ * @ uid        : [in]  user owner ID.
+ * @ gid        : [in]  group owner ID.
+ * @ inode_xp   : [out] buffer for extended pointer on created inode.
+ * @ return 0 if success / return -1 if error.
+ *****************************************************************************************/
+error_t vfs_inode_create( cxy_t             cxy,
+                          vfs_fs_type_t     fs_type,
+                          uint32_t          attr,
+                          uint32_t          rights,
+                          uid_t             uid,
+                          gid_t             gid,
+                          xptr_t          * inode_xp );
+
+/****************************************************************************************** 
+ * 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 (should be synchronized before deletion).
+ * It can be called by any thread running in any cluster.
+ ****************************************************************************************** 
+ * @ inode_xp  : extended pointer on inode descriptor.
+ *****************************************************************************************/
+void vfs_inode_destroy( xptr_t  inode_xp );  
+
+/****************************************************************************************** 
+ * This function returns the <size> of a file/dir from a remote inode,
+ * taking the remote_rwlock protecting <size> in READ_MODE.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ * @ return the current size.
+ *****************************************************************************************/
+uint32_t vfs_inode_get_size( xptr_t inode_xp );
+
+/****************************************************************************************** 
+ * This function updates the "size" field of a remote inode identified by <inode_xp>.
+ * It takes the rwlock protecting the file size in WRITE_MODE, and set the "size" field
+ * when the current size is smaller than the requested <size> argument. 
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ * @ size      : requested size value.
+ *****************************************************************************************/
+void vfs_inode_update_size( xptr_t   inode_xp,
+                            uint32_t size );
+
+/****************************************************************************************** 
+ * This function takes the main lock of a remote inode identified by the <inode_xp>.
+ * This lock protect all inode fields, including the children dentries.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ *****************************************************************************************/
+void vfs_inode_lock( xptr_t inode_xp );
+
+/****************************************************************************************** 
+ * This function releases the main lock of a remote inode identified by <inode_xp>.
+ * This lock protect all inode fiels, including the children dentries.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ *****************************************************************************************/
+void vfs_inode_unlock( xptr_t inode_xp );
+
+/****************************************************************************************** 
+ * This debug function copies the name of a remote inode identified by the <inode_xp>
+ * argument to a local buffer identified by the <name> argument.
+ * The local buffer size must be at least CONFIG_VFS_MAX_NAME_LENGTH. 
+ * It can be called by any thread running in any cluster.
+ ******************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ * @ name      : local buffer pointer.
+ *****************************************************************************************/
+void vfs_inode_get_name( xptr_t inode_xp,
+                         char * name );
+
+/******************************************************************************************
+ * This function accesses successively all pages of a file identified by the <inode_xp>,
+ * argument, to force misses, and load all pages into mapper.
+ * The target inode can be a directory or a file, but this function is mainly used 
+ * to prefetch a complete directory to the mapper.
+ * This function does NOT take any lock.
+ * It can be called by any thread running in any cluster.
+ ******************************************************************************************
+ * @ inode_xp  : extended pointer on inode.
+ * @ return 0 if success / return -1 if device access failure.
+ *****************************************************************************************/
+error_t vfs_inode_load_all_pages( xptr_t inode_xp );
+
+/****************************************************************************************** 
+ * This debug function display the curren state of an inode descriptor.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************/
+void vfs_inode_display( xptr_t inode_xp );
+
+
+
+
+
 
 /******************************************************************************************
@@ -215 +464 @@
 
 /******************************************************************************************
- * This file structure describes an open file/directory for a given process.
- * It is not replicated, and is dynamically allocated in the cluster that contains
- * the inode, when a thread makes an open() or opendir() system call.
- * It cannot exist a file structure without an inode structure in same cluster.
- * As the fd_array (containing extended pointers on the open file descriptors)
- * is replicated in all process descriptors, we need a references counter.
- *****************************************************************************************/
-
-typedef enum
-{
-    FD_ATTR_READ_ENABLE    = 0x01,     /*! read access possible                          */
-    FD_ATTR_WRITE_ENABLE   = 0x02,     /*! write access possible                         */
-    FD_ATTR_APPEND         = 0x04,     /*! append on each write                          */
-    FD_ATTR_CLOSE_EXEC     = 0x08,     /*! close file on exec                            */
-    FD_ATTR_SYNC           = 0x10,     /*! synchronise FS on each write                  */
-    FD_ATTR_IS_DIR         = 0x20,     /*! this is a directory                           */
-}
-vfs_file_attr_t;
-
-typedef struct vfs_file_s
-{
-        struct vfs_ctx_s      * ctx;        /*! local pointer on FS context.                 */
-        vfs_file_attr_t         attr;       /*! file attributes bit vector (see above)       */
-        vfs_inode_type_t        type;       /*! same type as inode                           */
-        uint32_t                offset;     /*! seek position in file                        */
-        uint32_t                refcount;   /*! all pointers on this file descriptor         */
-        remote_rwlock_t         lock;       /*! protect offset modifications                 */
-        struct mapper_s       * mapper;     /*! associated file cache                        */
-        struct vfs_inode_s    * inode;      /*! local pointer on associated inode            */
-    struct socket_s       * socket;     /*! local pointer on associated socket           */
-        void                  * extend;     /*! FS specific extension                        */
-}
-vfs_file_t;
-
-
-/******************************************************************************************
- *        These functions access / modify  a VFS context.
- *****************************************************************************************/
-
-/****************************************************************************************** 
- * This function initialises a (statically allocated) VFS context in cluster identified
- * by the <cxy> argument. 
- * It is called by the kernel_init() function.
- ******************************************************************************************
- * @ cxy            : target cluster identifier.
- * @ fs_type        : file system type.
- * @ total_clusters : total number of clusters on device.
- * @ cluster_size   : cluster size on device (bytes).
- * @ vfs_root_xp    : extended pointer on VFS root inode.
- * @ extend         : fs_type_specific extension.
- *****************************************************************************************/
-void vfs_ctx_init( cxy_t           cxy,
-                   vfs_fs_type_t   type,
-                       uint32_t        total_clusters,
-                       uint32_t        cluster_size,
-                       xptr_t          vfs_root_xp,
-                   void          * extend );
-
-/****************************************************************************************** 
- * This function allocates an inode identifier from the local cluster inum allocator.
- * The inum respects a fixed format:
- * - the 16 MSB bits contain the cluster identifier : cxy
- * - the 16 LSB bits contains the local inode identifier  : lid
- ******************************************************************************************
- * @ ctx_xp   : [in]  extended pointer on file system context.
- * @ inum     : [out] buffer for allocated inode identifier.
- * @ return 0 if success / return non-zero if error.
- *****************************************************************************************/
-error_t vfs_ctx_inum_alloc( xptr_t     ctx_xp,
-                            uint32_t * inum );
-
-/****************************************************************************************** 
- * This function release an inode identifier.                                  
- ******************************************************************************************
- * @ ctx_xp   : [in] extended pointer on file system context.
- * @ inum     : [in] released inode identifier.
- *****************************************************************************************/
-void vfs_ctx_inum_release( xptr_t      ctx_xp,
-                           uint32_t    inum );
-
-
-
-/******************************************************************************************
- *        These low-level functions access / modify a VFS inode descriptor
- *****************************************************************************************/
-
-/****************************************************************************************** 
- * This function returns a printable string for the inode type.
- *****************************************************************************************/
-const char * vfs_inode_type_str( vfs_inode_type_t type );
-
-/****************************************************************************************** 
- * This function allocates memory in cluster identified by the <cxy> argument 
- * for an inode descriptor and for the associated mapper, and partially initialise 
- * this inode from arguments values.
- * It does NOT link it to the Inode Tree, as this is done by add_child_in_parent(). 
- * It can be called by any thread running in any cluster.
- ******************************************************************************************
- * @ cxy        : [in]  target cluster identifier
- * @ fs_type    : [in]  file system type.
- * @ attr       : [in]  inode attributes.
- * @ rights     : [in]  inode access rights.
- * @ uid        : [in]  user owner ID.
- * @ gid        : [in]  group owner ID.
- * @ inode_xp   : [out] buffer for extended pointer on created inode.
- * @ return 0 if success / return -1 if error.
- *****************************************************************************************/
-error_t vfs_inode_create( cxy_t             cxy,
-                          vfs_fs_type_t     fs_type,
-                          uint32_t          attr,
-                          uint32_t          rights,
-                          uid_t             uid,
-                          gid_t             gid,
-                          xptr_t          * inode_xp );
-
-/****************************************************************************************** 
- * 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 (should be synchronized before deletion).
- * It can be called by any thread running in any cluster.
- ****************************************************************************************** 
- * @ inode_xp  : extended pointer on inode descriptor.
- *****************************************************************************************/
-void vfs_inode_destroy( xptr_t  inode_xp );  
-
-/****************************************************************************************** 
- * This function returns the <size> of a file/dir from a remote inode,
- * taking the remote_rwlock protecting <size> in READ_MODE.
- * It can be called by any thread running in any cluster.
- *****************************************************************************************
- * @ inode_xp  : extended pointer on the remote inode.
- * @ return the current size.
- *****************************************************************************************/
-uint32_t vfs_inode_get_size( xptr_t inode_xp );
-
-/****************************************************************************************** 
- * This function updates the "size" field of a remote inode identified by <inode_xp>.
- * It takes the rwlock protecting the file size in WRITE_MODE, and set the "size" field
- * when the current size is smaller than the requested <size> argument. 
- * It can be called by any thread running in any cluster.
- *****************************************************************************************
- * @ inode_xp  : extended pointer on the remote inode.
- * @ size      : requested size value.
- *****************************************************************************************/
-void vfs_inode_update_size( xptr_t   inode_xp,
-                            uint32_t size );
-
-/****************************************************************************************** 
- * This function takes the main lock of a remote inode identified by the <inode_xp>.
- * This lock protect all inode fields, including the children dentries.
- * It can be called by any thread running in any cluster.
- *****************************************************************************************
- * @ inode_xp  : extended pointer on the remote inode.
- *****************************************************************************************/
-void vfs_inode_lock( xptr_t inode_xp );
-
-/****************************************************************************************** 
- * This function releases the main lock of a remote inode identified by <inode_xp>.
- * This lock protect all inode fiels, including the children dentries.
- * It can be called by any thread running in any cluster.
- *****************************************************************************************
- * @ inode_xp  : extended pointer on the remote inode.
- *****************************************************************************************/
-void vfs_inode_unlock( xptr_t inode_xp );
-
-/****************************************************************************************** 
- * This debug function copies the name of a remote inode identified by the <inode_xp>
- * argument to a local buffer identified by the <name> argument.
- * The local buffer size must be at least CONFIG_VFS_MAX_NAME_LENGTH. 
- * It can be called by any thread running in any cluster.
- ******************************************************************************************
- * @ inode_xp  : extended pointer on the remote inode.
- * @ name      : local buffer pointer.
- *****************************************************************************************/
-void vfs_inode_get_name( xptr_t inode_xp,
-                         char * name );
-
-/******************************************************************************************
- * This function accesses successively all pages of a file identified by the <inode_xp>,
- * argument, to force misses, and load all pages into mapper.
- * The target inode can be a directory or a file, but this function is mainly used 
- * to prefetch a complete directory to the mapper.
- * This function does NOT take any lock.
- * It can be called by any thread running in any cluster.
- ******************************************************************************************
- * @ inode_xp  : extended pointer on inode.
- * @ return 0 if success / return -1 if device access failure.
- *****************************************************************************************/
-error_t vfs_inode_load_all_pages( xptr_t inode_xp );
-
-/****************************************************************************************** 
- * This debug function display the curren state of an inode descriptor.
- * It can be called by any thread running in any cluster.
- *****************************************************************************************/
-void vfs_inode_display( xptr_t inode_xp );
-
-/******************************************************************************************
  *        These low-level functions access / modify a VFS dentry descriptor
  *****************************************************************************************/
@@ -442 +494 @@
 
 
-/******************************************************************************************
- *        These low-level functions access / modify a VFS file descriptor
- *****************************************************************************************/
-
-/****************************************************************************************** 
- * This function allocates memory and initializes a new file descriptor in the
- * cluster defined by the <inode_xp> argument.
- * It can be called by any thread running in any cluster.
- ****************************************************************************************** 
- * @ inode_xp  : [in]  extended pointer on associated inode.
- * @ attr      : [in]  file descriptor attributes.
- * @ file_xp   : [out] buffer for extended pointer on created file descriptor.
- * @ return 0 if success / return ENOMEM if error.
- *****************************************************************************************/
-error_t vfs_file_create( xptr_t        inode_xp,
-                         uint32_t      attr,
-                         xptr_t      * file_xp );  
-
-/****************************************************************************************** 
- * This function releases memory allocated to file descriptor identified
- * by the <file_xp> argument.
- * It can be called by any thread running in any cluster.
- ****************************************************************************************** 
- * @ file_xp  : [in] extended pointer on file descriptor.
- *****************************************************************************************/
-void vfs_file_destroy( xptr_t  file_xp );  
-
-/****************************************************************************************** 
- * These functions increment (resp. decrement) the count field in a remote file
- * descriptor, using a remote_atomic access. 
- *****************************************************************************************
- * @ file_xp  : extended pointer on file descriptor.
- *****************************************************************************************/
-void vfs_file_count_up  ( xptr_t   file_xp );
-void vfs_file_count_down( xptr_t   file_xp );
-
-/****************************************************************************************** 
- * This debug function copies the name of a the file identified by <file_xp>
- * argument to a local buffer identified by the <name> argument.
- * The local buffer size must be at least CONFIG_VFS_MAX_NAME_LENGTH. 
- *****************************************************************************************
- * @ ionde_xp  : [in] extended pointer on the remote inode.
- * @ name      : [out] local string.
- ***************************************************************************************/
-void vfs_file_get_name( xptr_t inode_xp,
-                        char * name );
+
+
 
 
@@ -532 +540 @@
  *   the missing dentry/inode couple, from informations found in the parent directory.
  * - 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
+ * - If 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
@@ -539 +547 @@
  *   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. 
+ * WARNING : The lock protecting the Inode Tree must be taken in read mode by the caller. 
  *
  * TODO the access rights are not checked yet.
@@ -558 +566 @@
 /******************************************************************************************
  * 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, 
+ * Only the distributed Inode-Tree is modified: it does NOT modify the parent mapper, 
  * and does NOT update the FS on IOC device.
- * It set the inode type to the default INODE_TYPE_FILE value
+ * It set the inode type to the default FILE_TYPE_REG value.
  * It can be executed by any thread running in any cluster (can be different from both
  * the child cluster and the parent cluster).
  * The new child inode and the parent inode can have different FS types.
- * [Implementation note]
+ *
+ * WARNING : The lock protecting the Inode Tree must be taken in write mode by the caller. 
+ ******************************************************************************************
+ * Implementation note
  * As there are cross-references between inode and dentry, this function implements
  * a five steps scenario :
@@ -591 +602 @@
 
 /******************************************************************************************
- * This function removes a remote dentry from the Inode-Tree.
+ * This function removes a remote dentry and the associated inode from the Inode-Tree.
  * - It removes the dentry from the parent inode xhtab ("children" field), and from the
  *   child inode xlist ("parents" field).
@@ -601 +612 @@
  * It can be executed by any thread running in any cluster (can be different from both
  * the inode cluster and the dentry cluster).
+ *
+ * WARNING : The lock protecting the Inode Tree must be taken in write mode by the caller. 
  ******************************************************************************************
  * @ dentry_xp   : extended pointer on removed dentry.
@@ -613 +626 @@
  * This function is called by all functions creating a brand new directory : vfs_mkdir(),
  * devfs_global_init(), and devfs_local_init().
+ *
+ * WARNING : The lock protecting the Inode Tree must be taken in write mode by the caller. 
  ******************************************************************************************
  * @ child_xp    : extended pointer on new directory inode.
@@ -624 +639 @@
  * This recursive function diplays a complete inode/dentry sub-tree.
  * Any inode can be selected as the sub-tree root.
- * WARNING : this function is not protected against a concurrent inode/dentry removal...
+ *
+ * TODO : this function should be protected against a concurrent Inode-Tree change.
  ******************************************************************************************
  * @ inode_xp   : extended pointer on sub-tree root inode.
@@ -632 +648 @@
 /****************************************************************************************** 
  * This function mount a given file system type for a given process 
- * TODO non implemented yet [AG].     
+ * TODO non implemented [AG].     
  *****************************************************************************************/
 error_t vfs_mount_fs_root( struct device_s  * device,
@@ -829 +845 @@
 
 /****************************************************************************************** 
- * This function  creates a new directory as defined by the <root_xp> & <path> arguments.
- * TODO not implemented yet...
+ * This function  creates a new inode/dentry couple for a new directory, and registers it
+ * in the Inode Tree, as defined by the <root_xp>,  <path>, and <mode> arguments.
  ******************************************************************************************
  * @ root_xp  : extended pointer on the path root directory.
@@ -855 +871 @@
  * 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.
+ * TODO not implemented yet
  ****************************************************************************************** 
  * @ root_xp  : extended pointer on the path root directory.
@@ -866 +883 @@
 
 /****************************************************************************************** 
- * This function creates a named FIFO file.
- * TODO not implemented yet                                                          
+ * This function creates a new inode/dentry couple of FIFO type, and registers it
+ * in the Inode Tree as specified by the <root_xp>, <path>, and <mode> arguments.
  ****************************************************************************************** 
- * @ root_xp  : extended pointer on the path root directory.
- * @ path     : pathname (absolute or relative to CWD).
- * @ mode     : access rights new value.
+ * @ root_xp  : [in] extended pointer on the root directory in path.
+ * @ path     : [in] pathname (absolute or relative to CWD).
+ * @ mode     : [in] access rights new value.
  *****************************************************************************************/
 error_t vfs_mkfifo( xptr_t       root_xp,