Changeset 23 for trunk/kernel/vfs

Timestamp:

Jun 18, 2017, 10:06:41 PM (8 years ago)

Author:

alain

Message:

Introduce syscalls.

Location:

trunk/kernel/vfs

Files:

• devfs.c (added)
• devfs.h (added)
• fatfs.c (copied) (copied from trunk/kernel/vfs/fatfs.c) (8 diffs)
• fatfs.h (copied) (copied from trunk/kernel/vfs/fatfs.h) (7 diffs)
• ramfs.c (copied) (copied from trunk/kernel/vfs/ramfs.c) (2 diffs)
• ramfs.h (copied) (copied from trunk/kernel/vfs/ramfs.h) (2 diffs)
• vfs.c (modified) (33 diffs)
• vfs.h (modified) (21 diffs)

trunk/kernel/vfs/fatfs.c

@@ -2 +2 @@
  * fatfs.c - FATFS file system API implementation.
  *
- * Author    Mohamed Lamine Karaoui (2015)
- *           Alain Greiner (2016)
+ * Author    Mohamed Lamine Karaoui (2014,2015)
+ *           Alain Greiner (2016,2017)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -32 +32 @@
 #include <rpc.h>
 #include <mapper.h>
+#include <cluster.h>
 #include <dev_ioc.h>
 #include <fatfs.h>
 
-
 //////////////////////////////////////////////////////////////////////////////////////////
+//          Extern  variables         
+//////////////////////////////////////////////////////////////////////////////////////////
+
+extern vfs_ctx_t        fs_context[FS_TYPES_NR];   // allocated in vfs.c file
+
+extern remote_barrier_t global_barrier;            // allocated dans kernel_init.c
+ 
 //////////////////////////////////////////////////////////////////////////////////////////
 // FATFS specific functions : these functions cannot be called by the VFS 
 //////////////////////////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////////////////////////
 
 //////////////////////////////////////////////////////////
@@ -46 +52 @@
                                         uint32_t      cluster )
 {
-    return (ctx->cluster_begin_lba + ((cluster - 2) * ctx->sectors_per_cluster));
+    return (ctx->cluster_begin_lba + ((cluster - 2) << 3));
 }
 
@@ -95 +101 @@
 
 }  // end fatfs_get_cluster()
+
+///////////////////////////////////////////////////////////////////////////////////////
+// This static function return an integer record value (one, two, or four bytes) 
+// from a memory buffer, taking into account endianness.
+///////////////////////////////////////////////////////////////////////////////////////
+// @ offset        : first byte of record in buffer.
+// @ size          : record length in bytes (1/2/4).
+// @ buffer        : pointer on buffer base.
+// @ little endian : the most significant byte has the highest address when true.
+// @ return the integer value in a 32 bits word.
+///////////////////////////////////////////////////////////////////////////////////////
+static uint32_t get_record_from_buffer( uint32_t    offset,
+                                        uint32_t    size,
+                                        uint8_t   * buffer,
+                                        uint32_t    little_endian )
+{
+    uint32_t n;
+    uint32_t res  = 0;
+
+    if ( little_endian)
+    {
+        for( n = size ; n > 0 ; n-- ) res = (res<<8) | buffer[offset+n-1];
+    }
+    else
+    {
+        for( n = 0 ; n < size ; n++ ) res = (res<<8) | buffer[offset+n];
+    }
+    return res;
+
+}  // end get_record_from_buffer()
+
 
 
@@ -162 +199 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////
+//          The following functions are called by the VFS.
 ///////////////////////////////////////////////////////////////////////////////////////
-// Generic API : the following functions are called by the VFS, 
-//               and must be defined by all isupported file systems.
-///////////////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////////////////////////////////
-error_t fatfs_inode_create( struct vfs_inode_s * vfs_inode )
-{
-    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
-    hal_core_sleep();
-
+
+
+///////////////////
+xptr_t fatfs_init()
+{
+    kmem_req_t    req;
+    fatfs_ctx_t * fatfs_ctx;       // local pointer on FATFS context 
+    vfs_ctx_t   * vfs_ctx;         // local pointer on VFS context 
+    xptr_t        root_inode_xp;   // extended pointer on root inode
+    error_t       error;
+
+    // get local pointer on VFS context for FATFS
+    vfs_ctx = &fs_context[FS_TYPE_FATFS];
+
+    // get number of kernel instances and extended pointer on global barrier 
+    cluster_t * cluster     = LOCAL_CLUSTER;
+    uint32_t    nb_clusters = cluster->x_size * cluster->y_size;
+    xptr_t      barrier_xp  = XPTR( cluster->io_cxy , &global_barrier );
+
+    ///// step 1 : all clusters allocate memory for FATFS context 
+
+    // allocate memory for FATFS context extension
+        req.type    = KMEM_FATFS_CTX;
+        req.size    = sizeof(fatfs_ctx_t);
+    req.flags   = AF_KERNEL | AF_ZERO;
+        fatfs_ctx   = (fatfs_ctx_t *)kmem_alloc( &req );
+
+    if( fatfs_ctx == NULL ) 
+    {
+        printk("\n[PANIC] in %s : no memory for FATFS context\n", __FUNCTION__ );
+        hal_core_sleep();
+    }
+    
+    ///// step 2 : only cluster_0 access device and creates root inode
+
+    if( local_cxy == 0 )
+    {
+        // create VFS root inode
+        error = vfs_inode_create( XPTR_NULL,        // no parent dentry
+                                  FS_TYPE_FATFS,
+                                  INODE_TYPE_DIR,
+                                  0,                // attr
+                                  0,                // rights
+                                  0,                // uid
+                                  0,                // gid
+                                  &root_inode_xp );
+
+        assert( (error == 0 ) , __FUNCTION__ , "cannot create VFS root inode" );
+
+        // initialize VFS context / access device to initialize FATFS context
+        error = fatfs_ctx_init( vfs_ctx,
+                                fatfs_ctx,
+                                root_inode_xp );
+
+        // create FATFS root inode
+        error = fatfs_inode_create( GET_PTR( root_inode_xp ) , 
+                                    fatfs_ctx->root_dir_cluster );
+
+        if( error )
+        {
+            printk("\n[PANIC] in %s : cannot create FATFS root inode\n", __FUNCTION__ );
+            hal_core_sleep();
+        }
+
+    }
+
+    //////////////// synchronize all clusters
+    remote_barrier( barrier_xp , nb_clusters );
+
+    ///// step 3 : all others clusters initialize both context and extension
+
+    if( local_cxy != 0 )
+    {
+        // copy VFS context from remote cluster_0 to local cluster
+        hal_remote_memcpy( XPTR( local_cxy , vfs_ctx ), 
+                           XPTR( 0 , vfs_ctx ),
+                           sizeof(vfs_ctx_t) );
+
+        // copy FATFS context from remote cluster_0 to local cluster
+        hal_remote_memcpy( XPTR( local_cxy , fatfs_ctx ), 
+                           XPTR( 0 , vfs_ctx->extend ) ,
+                           sizeof(fatfs_ctx_t) );
+
+        // update extend field in local copy of VFS context
+        vfs_ctx->extend = fatfs_ctx;
+    }
+
+    return root_inode_xp;
+
+}  // end fatfs_init()
+
+//////////////////////////////////////////////
+error_t fatfs_ctx_init( vfs_ctx_t   * vfs_ctx,
+                        fatfs_ctx_t * fatfs_ctx,
+                        xptr_t        root_inode_xp )
+{
+    error_t  error;
+    uint8_t  buffer[512];    // buffer for boot record
+
+    // make a synchronous access to IOC device to read the boot record from device
+    error = dev_ioc_sync_read( buffer , 0 , 1 );
+    assert( (error == 0) , __FUNCTION__ , "cannot access FAT boot record" );
+
+    // check sector size from boot record
+    uint32_t sector_size = get_record_from_buffer( BPB_BYTSPERSEC , buffer , 1 );
+    assert( (sector_size == 512) , __FUNCTION__ , "sector size must be 512 bytes" );
+
+    // check cluster size from boot record
+    uint32_t nb_sectors = get_record_from_buffer( BPB_SECPERCLUS , buffer , 1 );
+    assert( (nb_sectors == 8) , __FUNCTION__ , "cluster size must be 8 sectors" );
+
+    // check number of FAT copies from boot record
+    uint32_t nb_fats = get_record_from_buffer( BPB_NUMFATS , buffer , 1 );
+    assert( (nb_fats == 1) , __FUNCTION__ , "number of FAT copies must be 1" );
+
+    // get & check number of sectors in FAT from boot record
+    uint32_t fat_sectors = get_record_from_buffer( BPB_FAT32_FATSZ32 , buffer , 1 );
+    assert( ((fat_sectors & 0xF) == 0) , __FUNCTION__ , "FAT not multiple of 16 sectors");
+
+    // get and check root cluster from boot record
+    uint32_t root_cluster = get_record_from_buffer( BPB_FAT32_ROOTCLUS , buffer , 1 );
+    assert( (root_cluster == 2) , __FUNCTION__ , "Root cluster index must be  2");
+
+    // get FAT lba from boot record
+    uint32_t fat_lba = get_record_from_buffer( BPB_RSVDSECCNT , buffer , 1 );
+    
+    // allocate a mapper for the FAT itself
+    mapper_t * fat_mapper = mapper_create();
+    assert( (fat_mapper != NULL) , __FUNCTION__ , "no memory for FAT mapper" );
+
+    // initialize the FATFS context
+    fatfs_ctx->fat_begin_lba         = fat_lba;
+    fatfs_ctx->fat_sectors_count     = fat_sectors; 
+    fatfs_ctx->bytes_per_sector      = sector_size;
+    fatfs_ctx->bytes_per_cluster     = sector_size * nb_sectors;
+    fatfs_ctx->cluster_begin_lba     = fat_lba + fat_sectors;
+    fatfs_ctx->root_dir_cluster      = 2;
+    fatfs_ctx->last_allocated_sector = 0;    // TODO ???
+    fatfs_ctx->last_allocated_index  = 0;    // TODO ???
+    fatfs_ctx->fat_mapper_xp         = XPTR( local_cxy , fat_mapper );
+
+    // initialize the VFS context
+    vfs_ctx->type    = FS_TYPE_FATFS;
+    vfs_ctx->attr    = 0;                    // not READ_ONLY / not SYNC
+    vfs_ctx->count   = fat_sectors << 10;    // total number of sectors in data region
+    vfs_ctx->blksize = 512;                  // number of bytes per sector
+    vfs_ctx->root_xp = root_inode_xp;
+    vfs_ctx->extend  = fatfs_ctx;
+
+    spinlock_init( &vfs_ctx->lock );
+
+    bitmap_init( vfs_ctx->bitmap , CONFIG_VFS_MAX_INODES );
+
+    return 0;
+
+}  // end fatfs_ctx_init()
+ 
+
+
+////////////////////////////////////////////////////
+void fatfs_ctx_destroy( struct vfs_ctx_s * vfs_ctx )
+{
+    kmem_req_t    req;
+    fatfs_ctx_t * fatfs_ctx;
+
+    // get pointer on FATFS context extension
+    fatfs_ctx = (fatfs_ctx_t *)vfs_ctx->extend;
+
+    req.type = KMEM_FATFS_INODE;
+    req.ptr  = fatfs_ctx;
+    kmem_free( &req );
+}
+
+
+////////////////////////////////////////////////////
+error_t fatfs_inode_create( vfs_inode_t * vfs_inode,
+                            uint32_t      first_cluster )
+{
     kmem_req_t      req;
     fatfs_inode_t * fatfs_inode;
 
-    // allocate memory for fatfs inode
+    // allocate memory for FATFS inode extension
         req.type    = KMEM_FATFS_INODE;
         req.size    = sizeof(fatfs_inode_t);
@@ -185 +390 @@
     if( fatfs_inode == NULL ) return ENOMEM;
 
-    // initialise ramfs_inode 
-    fatfs_inode->first_cluster = 0;   // TODO ???
-    fatfs_inode->ctx           = (fatfs_ctx_t *)vfs_inode->ctx->extend;
+    // link FATFS inode to VFS inode
+    vfs_inode->extend = fatfs_inode;
+
+    // initialise FATFS inode 
+    fatfs_inode->first_cluster = first_cluster;
  
-    // link fatfs_inode to vfs_inode
-    vfs_inode->extend = fatfs_inode;
-
     return 0;
-
-}
-
-//////////////////////////////////////////////////////
-void fatfs_inode_destroy( struct vfs_inode_s * inode )
-{
-    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
-    hal_core_sleep();
-}
-
-//////////////////////////////////////////////////
-error_t fatfs_ctx_create( struct vfs_ctx_s * ctx )
-{
-    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
-    hal_core_sleep();
-
-    return 0;
-}
-
-////////////////////////////////////////////////
-void fatfs_ctx_destroy( struct vfs_ctx_s * ctx )
-{
-    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
-    hal_core_sleep();
-}
+}
+
+///////////////////////////////////////////////////
+void fatfs_inode_destroy( vfs_inode_t * vfs_inode )
+{
+    kmem_req_t      req;
+    fatfs_inode_t * fatfs_inode;
+
+    // get pointer on FATFS inode 
+    fatfs_inode = (fatfs_inode_t *)vfs_inode->extend;
+
+    req.type = KMEM_FATFS_INODE;
+    req.ptr  = fatfs_inode;
+    kmem_free( &req );
+
+        vfs_inode->extend = NULL;
+}
+
 
 ////////////////////////////////////////////////
@@ -223 +420 @@
                                   bool_t   is_read )
 {
-    // get source buffer base address
-    char * buffer = (char *)ppm_page2base( page );
+    // get memory buffer base address
+    uint8_t * buffer = (uint8_t *)ppm_page2base( page );
  
     // get pointer on source mapper and page index from page descriptor
-    mapper_t * src_mapper  = page->mapper;
+    mapper_t * mapper      = page->mapper;
     uint32_t   page_index  = page->index;
 
-    if( src_mapper == NULL)
-    {
-        printk("\n[PANIC] in %s : no mapper for this page\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
-
     // get VFS inode pointer from mapper
-    vfs_inode_t * vfs_inode = src_mapper->inode;
+    vfs_inode_t * vfs_inode = mapper->inode;
 
     // get FATFS inode pointer for VFS inode
@@ -246 +437 @@
 
     // get FATFS context pointer from FATFS inode
-    fatfs_ctx_t * fatfs_ctx = fatfs_inode->ctx;
+    fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)vfs_inode->ctx->extend;
 
     // get number of sectors 

trunk/kernel/vfs/fatfs.h

@@ -2 +2 @@
  * fatfs.h - FATFS file system API definition.
  *
- * Author    Mohamed Lamine Karaoui (2015)
- *           Alain Greiner (2016)
+ * Author    Mohamed Lamine Karaoui (2014,2015)
+ *           Alain Greiner (2016,2017)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -28 +28 @@
 #include <hal_types.h>
 #include <rwlock.h>
+#include <vfs.h>
+
+
+///////////////////////////////////////////////////////////////////////////////////////////
+// The FATFS File System implements a FAT32 read/write file system.
+///////////////////////////////////////////////////////////////////////////////////////////
+
+/*************** Partition Boot Sector Format **********************************/
+//                                     offset |  length
+#define BS_JMPBOOT                          0 ,  3
+#define BS_OEMNAME                          3 ,  8
+#define BPB_BYTSPERSEC                     11 ,  2
+#define BPB_SECPERCLUS                     13 ,  1
+#define BPB_RSVDSECCNT                     14 ,  2
+#define BPB_NUMFATS                        16 ,  1
+#define BPB_ROOTENTCNT                     17 ,  2
+#define BPB_TOTSEC16                       19 ,  2
+#define BPB_MEDIA                          21 ,  1
+#define BPB_FATSZ16                        22 ,  2
+#define BPB_SECPERTRK                      24 ,  2
+#define BPB_NUMHEADS                       26 ,  2
+#define BPB_HIDDSEC                        28 ,  4
+#define BPB_TOTSEC32                       32 ,  4
+#define BPB_PARTITION_TABLE               446 , 64 
+
+// FAT 32
+#define BPB_FAT32_FATSZ32                  36 ,  4
+#define BPB_FAT32_EXTFLAGS                 40 ,  2
+#define BPB_FAT32_FSVER                    42 ,  2
+#define BPB_FAT32_ROOTCLUS                 44 ,  4
+#define BPB_FAT32_FSINFO                   48 ,  2
+#define BPB_FAT32_BKBOOTSEC                50 ,  2
+#define BS_FAT32_DRVNUM                    64 ,  1
+#define BS_FAT32_BOOTSIG                   66 ,  1
+#define BS_FAT32_VOLID                     67 ,  4
+#define BS_FAT32_VOLLAB                    71 , 11
+#define BS_FAT32_FILSYSTYPE                82 ,  8
+
+// Partitions
+#define FIRST_PARTITION_ACTIVE            446 ,  8
+#define FIRST_PARTITION_BEGIN_LBA         454 ,  4
+#define FIRST_PARTITION_SIZE              458 ,  4 
+#define SECOND_PARTITION_ACTIVE           462 ,  8
+#define SECOND_PARTITION_BEGIN_LBA        470 ,  4
+#define SECOND_PARTITION_SIZE             474 ,  4
+#define THIRD_PARTITION_ACTIVE            478 ,  8
+#define THIRD_PARTITION_BEGIN_LBA         486 ,  4
+#define THIRD_PARTITION_SIZE              490 ,  4
+#define FOURTH_PARTITION_ACTIVE           494 ,  8
+#define FOURTH_PARTITION_BEGIN_LBA        502 ,  4
+#define FOURTH_PARTITION_SIZE             506 ,  4    
+/*******************************************************************************/
+
+#define MBR_SIGNATURE_POSITION            510 , 2
+#define MBR_SIGNATURE_VALUE               0xAA55  
+
+/************** FAT_FS_INFO SECTOR  ********************************************/
+#define FS_SIGNATURE_VALUE_1              0x52526141
+#define FS_SIGNATURE_VALUE_2              0x72724161
+#define FS_SIGNATURE_VALUE_3              0x000055AA  
+#define FS_SIGNATURE_POSITION_1           0   , 4  
+#define FS_SIGNATURE_POSITION_2           484 , 4
+#define FS_SIGNATURE_POSITION_3           508 , 4  
+#define FS_FREE_CLUSTERS                  488 , 4
+#define FS_FREE_CLUSTER_HINT              492 , 4
+/*******************************************************************************/
+
+#define DIR_ENTRY_SIZE          32
+                   
+#define NAME_MAX_SIZE           31
+
+/******* Directory Entry Structure (32 bytes) **********************************/
+//                            offset | length
+#define DIR_NAME                   0 , 11   // dir_entry name
+#define DIR_ATTR                  11 ,  1   // attributes
+#define DIR_NTRES                 12 ,  1   // reserved for the OS        
+#define DIR_CRT_TIMES_TENTH       13 ,  1 
+#define DIR_FST_CLUS_HI           20 ,  2   // cluster index 16 MSB bits
+#define DIR_WRT_TIME              22 ,  2   // time of last write
+#define DIR_WRT_DATE              24 ,  2   // date of last write
+#define DIR_FST_CLUS_LO           26 ,  2   // cluster index 16 LSB bit
+#define DIR_FILE_SIZE             28 ,  4   // dir_entry size (up to 4 Gbytes)
+/*******************************************************************************/
+
+/******* LFN Directory Entry Structure  (32 bytes) *****************************/
+//                            offset | length
+#define LDIR_ORD                   0 ,  1   // Sequence number (from 0x01 to 0x0f)    
+#define LDIR_NAME_1                1 , 10   // name broken into 3 parts 
+#define LDIR_ATTR                 11 ,  1   // attributes (must be 0x0F) 
+#define LDIR_TYPE                 12 ,  1   // directory type (must be 0x00)
+#define LDIR_CHKSUM               13 ,  1   // checksum of name in short dir  
+#define LDIR_NAME_2               14 , 12 
+#define LDIR_RSVD                 26 ,  2   // artifact of previous fat (must be 0)
+#define LDIR_NAME_3               28 ,  4   
+/*******************************************************************************/
+
+/***********************  DIR_ATTR values  (attributes) ************************/
+#define ATTR_READ_ONLY            0x01
+#define ATTR_HIDDEN               0x02
+#define ATTR_SYSTEM               0x04
+#define ATTR_VOLUME_ID            0x08
+#define ATTR_DIRECTORY            0x10
+#define ATTR_ARCHIVE              0x20
+#define ATTR_LONG_NAME_MASK       0x0f      // READ_ONLY|HIDDEN|SYSTEM|VOLUME_ID
+/*******************************************************************************/
+
+/********************* DIR_ORD special values **********************************/
+#define FREE_ENTRY                0xE5     // this entry is free in the directory
+#define NO_MORE_ENTRY             0x00     // no more entry in the directory
+/*******************************************************************************/
+
+/******************** CLuster Index Special Values *****************************/
+#define FREE_CLUSTER              0x00000000
+#define RESERVED_CLUSTER          0x00000001
+#define BAD_CLUSTER               0x0FFFFFF7
+#define END_OF_CHAIN_CLUSTER_MIN  0x0ffffff8
+#define END_OF_CHAIN_CLUSTER_MAX  0x0fffffff
+/*******************************************************************************/
 
 /****  Forward declarations  ****/
 
 struct mapper_s;
-struct device_s;
+struct page_s;
+struct vfs_ctx_s;
 struct vfs_inode_s;
-struct vfs_ctx_s;
-struct page_s;
-
-/*****************************************************************************************
- * This structure defines a FATFS specific context extension. 
+
+/*****************************************************************************************
+ * This structure defines a FATFS specific context (extension to VFS context). 
  ****************************************************************************************/
 
 typedef struct fatfs_ctx_s
 {
-    rwlock_t          lock;                  /*! TODO protect what ???                  */
-    uint32_t          fat_begin_lba;         /*! first lba of FAT region                */
+    uint32_t          fat_begin_lba;         /*! lba of FAT region                      */
     uint32_t          fat_sectors_count;     /*! number of sectors in FAT region        */
     uint32_t          bytes_per_sector;      /*!                                        */
     uint32_t          bytes_per_cluster;     /*!                                        */
-    uint32_t          cluster_begin_lba;     /*! first lba of data region on device     */
-    uint32_t          sectors_per_cluster;   /*!                                        */
-    uint32_t          rootdir_first_cluster; /*                                         */
-    uint32_t          last_allocated_sector; /*!                                        */
-    uint32_t          last_allocated_index;  /*! TODO last allocated cluster ???        */
-    xptr_t            fat_mapper_xp;         /*! FAT mapper (in IO cluster)             */ 
+    uint32_t          cluster_begin_lba;     /*! lba of data region                     */
+    uint32_t          sectors_per_cluster;   /*! cluster index for root directory       */
+    uint32_t          root_dir_cluster;      /*!                                        */
+    uint32_t          last_allocated_sector; /*! TODO ???                               */
+    uint32_t          last_allocated_index;  /*! TODO ???                               */
+    xptr_t            fat_mapper_xp;         /*! FAT mapper (in IO cluster)             */
 }
 fatfs_ctx_t;
 
 /*****************************************************************************************
- * This structure defines the FAT specific inode extension (versus the VFS inode).
+ * This structure defines the FATFS specific inode (extension to VFS inode).
  ****************************************************************************************/
 
 typedef struct fatfs_inode_s
 {
-    struct fatfs_ctx_s * ctx;                /*! local pointer on the FATFS context     */ 
-        uint32_t             first_cluster;      /*! first cluster for this file/dir        */ 
+        uint32_t          first_cluster;         /*! first cluster for this file/dir        */ 
 }
 fatfs_inode_t;
@@ -70 +185 @@
 
 
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// These functions are specific to the FATFS, and cannot be called by the VFS.
+//////////////////////////////////////////////////////////////////////////////////////////
+
 /*****************************************************************************************
  * This function returns the LBA of the first sector of a FAT cluster.
@@ -76 +196 @@
  * @ ctx          :     pointer on FATFS context.
  * @ cluster  : cluster index in FATFS.
- * # return the lba value.
+ * @ return the lba value.
  ****************************************************************************************/
 inline uint32_t fatfs_lba_from_cluster( fatfs_ctx_t * ctx,
@@ -105 +225 @@
                            uint32_t        * cluster );
 
+
+
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// These functions are called by the VFS, and must be implemented by all File Systems.
+//////////////////////////////////////////////////////////////////////////////////////////
+
+/******************************************************************************************
+ * This function initializes the FATFS file system as the root FS.
+ * It is executed cooperatively during kernel init by all CP0s in all clusters.
+ * The initilisation is made in three phases, separated by synchronisation barrier:     
+ * - phase 1 : all CP0s in all clusters allocate memory for the local copy of
+ *   the FATFS context.
+ * - phase 2 : cluster_0 only creates the root inode descriptor, access the external
+ *   device to get information stored on the boot record, and initialises both 
+ *   the VFS context, and the FATFS context.
+ * - phase 3 : all other clusters initialize their local VFS context and FATFS context
+ *   from values contained in cluster_0, using hal_remote_memcpy().
+ ******************************************************************************************
+ * @ return an extended pointer on the created root inode / return XPTR_NULL if failure.
+ *****************************************************************************************/
+xptr_t fatfs_init();
+
+/******************************************************************************************
+ * This function mount the FATFS on the root FS.
+ * TODO not implemented [AG]
+ ******************************************************************************************
+ * @ parent_inode_xp : extended pointer on the parent inode.
+ *****************************************************************************************/
+error_t fatfs_mount( xptr_t parent_inode_xp );
+
+
+/*****************************************************************************************
+ * This function  initializes both the VFS context and the FATFS context.
+ * Both the VFS context and the FATFS context must have been previously allocated.
+ * It access the device to read the boot record, and is supposed to be called only 
+ * in cluster_0 (in other clusters these contexts are replicated from values 
+ * contained in cluster_0).
+ *****************************************************************************************
+ * @ vfs_ctx        : local pointer on VFS context for FATFS.
+ * @ fatfs_ctx      : local pointer on specific FATFS context.
+ * @ root_inode_xp  : extended pointer on VFS root inode.
+ ****************************************************************************************/
+error_t fatfs_ctx_init( struct vfs_ctx_s   * vfs_ctx,
+                        struct fatfs_ctx_s * fatfs_ctx,
+                        xptr_t               root_inode_xp );
+
+/*****************************************************************************************
+ * This function releases memory dynamically allocated for the FATFS context extension.
+ *****************************************************************************************
+ * @ vfs_ctx   : local pointer on VFS context.
+ ****************************************************************************************/
+void fatfs_ctx_destroy( struct vfs_ctx_s * vfs_ctx );
+
+
+
 /*****************************************************************************************
  * This function allocates memory for a FATFS inode, initializes it,
  * and link it to the VFS inode.
  *****************************************************************************************
+ * @ inode         : local pointer on the VFS inode.
+ * @ first_cluster : first cluster index in the FAT32.
+ * @ return 0 if success / return ENOMEM if error. 
+ ****************************************************************************************/
+error_t fatfs_inode_create( struct vfs_inode_s * inode,
+                            uint32_t             first_cluster);
+
+/*****************************************************************************************
+ * This function releases memory allocated for a FATFS inode.
+ *****************************************************************************************
  * @ inode   : local pointer on vfs_inode.
- * @ return 0 if success / return ENOMEM if error. 
- ****************************************************************************************/
-error_t fatfs_inode_create( struct vfs_inode_s * inode );
-
-/*****************************************************************************************
- * This function releases memory allocated for a FATFS inode.
- *****************************************************************************************
- * @ inode   : local pointer on vfs_inode.
  ****************************************************************************************/
 void fatfs_inode_destroy( struct vfs_inode_s * inode );
 
-/*****************************************************************************************
- * This function allocates memory for a FATFS context, initialises it, 
- * and link it to the local VFS context.
- *****************************************************************************************
- * @ inode   : local pointer on VFS context.
- * @ return 0 if success / return ENOMEM if error. 
- ****************************************************************************************/
-error_t fatfs_ctx_create( struct vfs_ctx_s * ctx );
-
-/*****************************************************************************************
- * This function releases memory allocated for a FATFS context.
- *****************************************************************************************
- * @ ctx   : local pointer on VFS context.
- ****************************************************************************************/
-void fatfs_ctx_destroy( struct vfs_ctx_s * ctx );
-
-/*****************************************************************************************
- * This function moves a page from the mapper to the FATFS file system.
+
+
+/*****************************************************************************************
+ * This function moves a page from the mapper to the FATFS file system on device.
  * It must be called by a thread running in cluster containing the mapper.
- * The pointer on the mapper and the page index in file are supposed to be registered
+ * The pointer on the mapper and the page index in file are registered
  * in the page descriptor. 
  *****************************************************************************************
@@ -151 +315 @@
  * This function moves a page from the FATFS file system on device to the mapper.
  * It must be called by a thread running in cluster containing the mapper.
- * The pointer on the mapper and the page index in file are supposed to be registered
+ * The pointer on the mapper and the page index in file are registered
  * in the page descriptor. 
  *****************************************************************************************
@@ -160 +324 @@
 
 
+
+
 #endif  /* _FATFS_H_ */

trunk/kernel/vfs/ramfs.c

@@ -2 +2 @@
  * ramfs.c  RAMFS file system API implementation.
  *
- * Authors   Mohamed Lamine Karaoui (2015)
- *           Alain Greiner (2016)
+ * Authors   Mohamed Lamine Karaoui (2014,2015)
+ *           Alain Greiner (2016,2017)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -32 +32 @@
 
 
-///////////////////////////////////////////////////////////////////////////////////////
-// RAMFS specific functions : these static functions cannot be called by the VFS 
-///////////////////////////////////////////////////////////////////////////////////////
 
 
 
 ///////////////////////////////////////////////////////////////////////////////////////
-// Generic API : the following functions are called by the VFS, 
-//               and must be defined by all supported file systems.
+//             The following functions are called by the VFS. 
 ///////////////////////////////////////////////////////////////////////////////////////
 
-////////////////////////////////////////////////////////////
-error_t ramfs_inode_create( struct vfs_inode_s * vfs_inode )
+//////////////////////////////////////////////
+error_t ramfs_mount( xptr_t   parent_inode_xp,
+                     char   * ramfs_root_name )
 {
-    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
-    hal_core_sleep();
+    xptr_t        root_inode_xp;   // unused                      
+ 
+    // create VFS dentry and VFS inode for RAMFS root directory
+    return  vfs_add_child_in_parent( INODE_TYPE_DIR,
+                                     FS_TYPE_RAMFS,
+                                     parent_inode_xp,
+                                     ramfs_root_name,
+                                     &root_inode_xp );
+}
 
-    kmem_req_t      req;
-    ramfs_inode_t * ramfs_inode;
 
-    // allocate memory for ramfs inode
-        req.type    = KMEM_RAMFS_INODE;
-        req.size    = sizeof(ramfs_inode_t);
-    req.flags   = AF_KERNEL | AF_ZERO;
-        ramfs_inode = (ramfs_inode_t *)kmem_alloc( &req );
+////////////////////////////////////////////
+error_t ramfs_ctx_init( vfs_ctx_t * vfs_ctx,
+                        xptr_t      root_inode_xp )
 
-    if( ramfs_inode == NULL ) return ENOMEM;
+{
+    vfs_ctx->type    = FS_TYPE_RAMFS;
+    vfs_ctx->attr    = 0;                // not READ_ONLY / not SYNC
+    vfs_ctx->count   = 0;                // unused for RAMFS
+    vfs_ctx->blksize = 512;              // unused for RAMFS
+    vfs_ctx->root_xp = root_inode_xp;
+    vfs_ctx->extend  = NULL;             // unused for DEVFS
 
-    // initialise ramfs_inode TODO
+    spinlock_init( &vfs_ctx->lock );
 
-    // link vfs_inode to ramfs_inode
-    vfs_inode->extend = ramfs_inode;
+    bitmap_init( vfs_ctx->bitmap , CONFIG_VFS_MAX_INODES );
 
     return 0;
 }
 
-//////////////////////////////////////////////////////
-void ramfs_inode_destroy( struct vfs_inode_s * inode )
-{
-    assert( false , __FUNCTION__ , "not fully implemented yet" );
-}
-
-/////////////////////////////////////////////////
-error_t ramfs_write_page( struct page_s  * page )
-{
-    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
-    hal_core_sleep();
-
-    return 0;
-}
-
-////////////////////////////////////////////////
-error_t ramfs_read_page( struct page_s  * page )
-{
-    printk("\n[PANIC] %s not fully implemented yet\n", __FUNCTION__ );
-    hal_core_sleep();
-
-    return 0;
-}
-   

trunk/kernel/vfs/ramfs.h

@@ -2 +2 @@
  * ramfs.h  RAMFS file system API definition.
  *
- * Authors   Mohamed Lamine Karaoui (2015)
- *           Alain Greiner (2016)
+ * Authors   Mohamed Lamine Karaoui (2014,2015)
+ *           Alain Greiner (2016,2017)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -26 +26 @@
 #define _RAMFS_H_
 
+///////////////////////////////////////////////////////////////////////////////////////////
+// The RAMFS File System Rdoes not uses any external device to store data.
+// It stores the dynamically created files and directories in the VFS mappers.
+// The ramfs_read_page() and ramfs_write_page() functions should never be used.
+// The RAMFS cannot be used as the root FS.
+// There is no RAMFS context extension, and no RAMFS inode extension.
+///////////////////////////////////////////////////////////////////////////////////////////
+
+
 /****  Forward declarations  ****/
 
-struct vfs_inode_s;
-struct page_s;
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// These functions are called by the VFS, and must be implemented by all FS.
+//////////////////////////////////////////////////////////////////////////////////////////
+
+/******************************************************************************************
+ * This function does not exist, as the RAMFS cannot be the root FS.
+ *****************************************************************************************/
+xptr_t ramfs_init();
+
+/******************************************************************************************
+ * This function mount a RAMFS on a given inode of the root FS.
+ * It actually creates a new VFS dentry in the cluster containing the parent inode,
+ * and create a new VFS inode in another cluster.
+ ******************************************************************************************
+ * @ parent_inode_xp : extended pointer on the parent inode.
+ * @ ramfs_root_name : RAMFS root directory name.
+ *****************************************************************************************/
+error_t ramfs_mount( xptr_t   parent_inode_xp,
+                     char   * ramfs_root_name );
 
 /*****************************************************************************************
- * This structure defines a RAMFS specific context extension. 
+ * This function initializes all fields of the VFS context.
+ * No extra memory is allocated for a RAMFS context.
  ****************************************************************************************/
-
-typedef struct ramfs_ctx_s
-{
-    intptr_t          base;                                                                 
-    rwlock_t          size;
-}
-ramfs_ctx_t;
+error_t ramfs_ctx_init( struct vfs_ctx_s * vfs_ctx,
+                        xptr_t             root_inode_xp );
 
 /*****************************************************************************************
- * This structure defines the RAMFS inode specific extension (versus the VFS inode).
+ * This function does not exist for a RAMFS context, as there is no RAMFS context.
  ****************************************************************************************/
-
-typedef struct ramfs_inode_s
-{
-    struct vfs_inode_s * vfs_inode;   /*! local pointer on VFS inode                    */
-}
-ramfs_inode_t;
-
-
-
+error_t ramfs_ctx_destroy();
 
 /*****************************************************************************************
- * This function allocates memory for a RAMFS inode, and link it to the VFS inode.
- *****************************************************************************************
- * @ inode   : local pointer on vfs_inode.
- * @ return 0 if success / return ENOMEM if error. 
+ * This function does not exist, as the RAMFS does not use a RAMFS inode extension.
  ****************************************************************************************/
 error_t ramfs_inode_create( struct vfs_inode_s * inode );
 
 /*****************************************************************************************
- * This function releases memory allocated for a RAMFS inode.
- *****************************************************************************************
- * @ inode   : local pointer on vfs_inode.
+ * This function does not exist, as the RAMFS does not use a RAMFS inode extension.
  ****************************************************************************************/
 void ramfs_inode_destroy( struct vfs_inode_s * inode );
 
 /*****************************************************************************************
- * This function moves a page from the mapper to the RAMFS file system.
- * It must be called by a thread running in cluster containing the mapper.
- * The pointer on the mapper and the page index in file are supposed to be registered
- * in the page descriptor. 
-******************************************************************************************
- * @ page    : local pointer on source page descriptor.
- * @ return 0 if success / return EIO if error. 
+ * This function does nothing for the RAMFS File System.
  ****************************************************************************************/
-error_t ramfs_write_page( struct page_s  * page );
+error_t ramfs_write_page( struct page_s * page );
 
 /*****************************************************************************************
- * This function moves a page from the RAMFS file system to the mapper.
- * It must be called by a thread running in cluster containing the mapper.
- * The pointer on the mapper and the page index in file are supposed to be registered
- * in the page descriptor. 
- *****************************************************************************************
- * @ page    : local pointer on destination page descriptor.
- * @ return 0 if success / return EIO if error. 
+ * This function does not exist for the RAMFS File System.
  ****************************************************************************************/
-error_t ramfs_read_page( struct page_s  * page );
+error_t ramfs_read_page( struct page_s * page );
 
 
-   
 #endif  /* _RAMFS_H_ */

trunk/kernel/vfs/vfs.c

@@ -35 +35 @@
 #include <slist.h>
 #include <xhtab.h>
+#include <rpc.h>
 #include <errno.h>
 #include <kmem.h>
@@ -40 +41 @@
 #include <thread.h>
 #include <process.h>
+#include <vfs.h>
 #include <fatfs.h>
 #include <ramfs.h>
-#include <vfs.h>
+#include <devfs.h>
+#include <syscalls.h>
 
 
@@ -49 +52 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-// array of supported FS contexts (indexed by the FS type)
+// array of supported FS contexts 
 vfs_ctx_t   fs_context[FS_TYPES_NR];
 
@@ -56 +59 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-/////////////////////////////////////////////////
+////////////////////////////////////////////
 error_t vfs_ctx_inum_alloc( vfs_ctx_t * ctx,
                             uint32_t  * inum )
@@ -64 +67 @@
 
     // get lid from local inum allocator
-    uint32_t lid = bitmap_ffc( ctx->inum , CONFIG_VFS_MAX_INODES );
+    uint32_t lid = bitmap_ffc( ctx->bitmap , CONFIG_VFS_MAX_INODES );
 
     if( lid == -1 )   // no more free slot => error
@@ -77 +80 @@
     {
         // set slot allocated
-        bitmap_set( ctx->inum , lid );
+        bitmap_set( ctx->bitmap , lid );
 
         // release lock
@@ -92 +95 @@
                            uint32_t    inum )
 {
-    bitmap_clear( ctx->inum , inum & 0xFFFF ); 
+    bitmap_clear( ctx->bitmap , inum & 0xFFFF ); 
 }
 
@@ -99 +102 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-////////////////////////////////////////////////
-error_t vfs_inode_create( xptr_t      dentry_xp,
-                          uint32_t    type,
-                          uint32_t    attr,
-                          uint32_t    mode,
-                          uid_t       uid,
-                          gid_t       gid,
-                          xptr_t    * inode_xp )
+//////////////////////////////////////////////////////
+
+error_t vfs_inode_create( xptr_t            dentry_xp,
+                          vfs_fs_type_t     fs_type,
+                          vfs_inode_type_t  inode_type,
+                          uint32_t          attr,
+                          uint32_t          rights,
+                          uid_t             uid,
+                          gid_t             gid,
+                          xptr_t          * inode_xp )
 {
     mapper_t         * mapper;     // associated mapper( to be allocated)
@@ -115 +120 @@
     error_t            error;
 
-    // check type and get pointer on context
-    if     ( type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
-    else if( type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
+    // check fs type and get pointer on context
+    if     ( fs_type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
+    else if( fs_type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
+    else if( fs_type == FS_TYPE_DEVFS ) ctx = &fs_context[FS_TYPE_DEVFS];
     else
     {
@@ -144 +150 @@
     }
 
-    // allocate memory for inode descriptor
+    // allocate memory for VFS inode descriptor
         req.type  = KMEM_VFS_INODE;
         req.size  = sizeof(vfs_inode_t);
@@ -160 +166 @@
     // initialize inode descriptor
     inode->gc         = 0;
+    inode->type       = inode_type;
     inode->inum       = inum;
     inode->attr       = attr;
-    inode->mode       = mode;
+    inode->rights     = rights;
     inode->uid        = uid;
     inode->gid        = gid;
@@ -174 +181 @@
 
     // initialize dentries hash table, if new inode is a directory
-    if( attr & INODE_ATTR_DIR )  xhtab_init( &inode->children , XHTAB_DENTRY_TYPE );
+    if( inode_type == INODE_TYPE_DIR ) xhtab_init( &inode->children , XHTAB_DENTRY_TYPE );
 
     // initialize inode locks 
     remote_rwlock_init( XPTR( local_cxy , &inode->data_lock ) );
     remote_spinlock_init( XPTR( local_cxy , &inode->main_lock ) );
-
-    // create FS specific inode
-    if     ( ctx->type == FS_TYPE_FATFS )  fatfs_inode_create( inode );
-    else if( ctx->type == FS_TYPE_RAMFS )  ramfs_inode_create( inode );
 
     // return extended pointer on inode
@@ -284 +287 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-//////////////////////////////////////////////
-error_t vfs_dentry_create( uint32_t      type,
-                           char        * name,
-                           vfs_inode_t * parent,
-                           xptr_t      * dentry_xp )
+///////////////////////////////////////////////////
+error_t vfs_dentry_create( vfs_fs_type_t   fs_type,
+                           char          * name,
+                           vfs_inode_t   * parent,
+                           xptr_t        * dentry_xp )
 {
     vfs_ctx_t      * ctx;        // context descriptor
     vfs_dentry_t   * dentry;     // dentry descriptor (to be allocated)
         kmem_req_t       req;        // request to kernel memory allocator
-    xptr_t           xhtab_xp;   // extended pointer on xhtab_t embedded in inode
-    xptr_t           xlist_xp;   // extended pointer on xlist_entry_t in dentry
+
+printk("\n            @@@ dentry_create : 0 / name = %s\n", name );
 
     // check type and get pointer on context
-    if     ( type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
-    else if( type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
+    if     ( fs_type == FS_TYPE_FATFS ) ctx = &fs_context[FS_TYPE_FATFS];
+    else if( fs_type == FS_TYPE_RAMFS ) ctx = &fs_context[FS_TYPE_RAMFS];
+    else if( fs_type == FS_TYPE_DEVFS ) ctx = &fs_context[FS_TYPE_DEVFS];
     else
     {
@@ -309 +313 @@
     uint32_t length = strlen( name );
 
-    if( length > (CONFIG_VFS_MAX_NAME_LENGTH - 1) )
+    if( length >= CONFIG_VFS_MAX_NAME_LENGTH )
     {
         printk("\n[ERROR] in %s : name too long\n", __FUNCTION__ );
         return EINVAL;
     }
+
+printk("\n            @@@ dentry_create : 1 / name = %s\n", name );
 
     // allocate memory for dentry descriptor
@@ -328 +334 @@
 
     // initialize dentry descriptor
+
     dentry->ctx     = ctx;
     dentry->length  = length;
@@ -333 +340 @@
     strcpy( dentry->name , name );
 
-    // return extended pointer on dentry to caller
+printk("\n            @@@ dentry_create : 2 / name = %s\n", name );
+
+    // register dentry in hash table rooted in parent inode
+    xhtab_insert( XPTR( local_cxy , &parent->children ),
+                  name, 
+                  XPTR( local_cxy , &dentry->xlist ) );
+
+printk("\n            @@@ dentry_create : 3 / name = %s\n", name );
+
+    // return extended pointer on dentry 
     *dentry_xp = XPTR( local_cxy , dentry );
 
-    // register dentry in hash table rooted in parent inode
-    xhtab_xp    = XPTR( local_cxy , &parent->children );
-    xlist_xp    = XPTR( local_cxy , &dentry->xlist );
-    xhtab_register( xhtab_xp  , name , xlist_xp );
-    
     return 0;
 
@@ -365 +376 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-////////////////////////////////////////
-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 = (vfs_file_t *)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 = (vfs_file_t *)GET_PTR( file_xp ); 
-
-    // atomically decrement count
-    hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , -1 ); 
-}
-
-////////////////////////////////////////////////
-error_t vfs_file_create( xptr_t        inode_xp,
-                         uint32_t      type,
+/////////////////////////////////////////////
+error_t vfs_file_create( vfs_inode_t * inode,
                          uint32_t      attr,
-                         xptr_t      * file_xp )  
-{
-    vfs_file_t  * file_ptr;
+                         xptr_t      * file_xp )
+{
+    vfs_file_t  * file;
         kmem_req_t    req;
-
-    // get inode cluster and local pointer
-    cxy_t         inode_cxy = GET_CXY( inode_xp );
-    vfs_inode_t * inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
-
-    // check cluster identifier
-    if( inode_cxy != local_cxy )
-    {
-        printk("\n[PANIC] in %s : local cluster is not the inode owner\n", __FUNCTION__ );
-        hal_core_sleep();
-    }
 
     // allocate memory for new file descriptor
@@ -411 +388 @@
         req.size  = sizeof(vfs_file_t);
     req.flags = AF_KERNEL | AF_ZERO;
-        file_ptr  = (vfs_file_t *)kmem_alloc( &req );
-
-    if( file_ptr == NULL ) return ENOMEM;
-
-    // get inode local pointer
+        file      = (vfs_file_t *)kmem_alloc( &req );
+
+    if( file == NULL ) return ENOMEM;
+
     // initializes new file descriptor
-    file_ptr->gc       = 0;
-    file_ptr->type     = type;
-    file_ptr->attr     = attr;
-    file_ptr->offset   = 0;
-    file_ptr->refcount = 0;
-    file_ptr->inode    = inode_ptr;
-    file_ptr->ctx      = inode_ptr->ctx;
-    file_ptr->mapper   = inode_ptr->mapper;
-
-    remote_rwlock_init( XPTR( local_cxy , &file_ptr->lock ) );
-
-    *file_xp = XPTR( local_cxy , file_ptr );
-    return 0;
-}
-
-////////////////////////////////////////
-void vfs_file_destroy( xptr_t  file_xp )
-{
-    // get file cluster and local pointer
-    cxy_t        file_cxy = GET_CXY( file_xp );
-    vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
-
-    if( file_cxy != local_cxy )
-    {
-        printk("\n[PANIC] in %s : file descriptor not in local cluster\n", __FUNCTION__ );
-        hal_core_sleep(); 
-    }
-
-    if( file_ptr->refcount )
+    file->gc       = 0;
+    file->type     = inode->type;
+    file->attr     = attr;
+    file->offset   = 0;
+    file->refcount = 0;
+    file->inode    = inode;
+    file->ctx      = inode->ctx;
+    file->mapper   = inode->mapper;
+
+    remote_rwlock_init( XPTR( local_cxy , &file->lock ) );
+
+    *file_xp = XPTR( local_cxy , file );
+    return 0;
+
+}  // end vfs_file_create()
+
+///////////////////////////////////////////
+void vfs_file_destroy( vfs_file_t *  file )
+{
+    if( file->refcount )
     {
         printk("\n[PANIC] in %s : file refcount non zero\n", __FUNCTION__ );
@@ -452 +419 @@
 
         kmem_req_t req;
-        req.ptr   = file_ptr;
+        req.ptr   = file;
         req.type  = KMEM_VFS_FILE;
         kmem_free( &req );
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////
-//           File related functions
+
+}  // 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 = (vfs_file_t *)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 = (vfs_file_t *)GET_PTR( file_xp ); 
+
+    // atomically decrement count
+    hal_remote_atomic_add( XPTR( file_cxy , &file_ptr->refcount ) , -1 ); 
+}
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//           File access related functions
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -465 +456 @@
                           char     * path,
                           uint32_t   flags,
-                          xptr_t   * file_xp )
-{
-    return 0;
-}
-
-///////////////////////////////////
-uint32_t vfs_read( xptr_t   file_xp, 
-                   void   * buffer,
-                   uint32_t size )
-{
-    return 0;
-}
-
-////////////////////////////////////
-uint32_t vfs_write( xptr_t   file_xp,
-                    void   * buffer,
-                    uint32_t size )
-{
-    return 0;
-}
+                  uint32_t   mode, 
+                          xptr_t   * new_file_xp,
+                  uint32_t * new_file_id )
+{
+    error_t       error;
+    xptr_t        inode_xp;     // extended pointer on target inode
+    cxy_t         inode_cxy;    // inode cluster identifier       
+    vfs_inode_t * inode_ptr;    // inode local pointer
+    uint32_t      file_attr;    // file descriptor attributes
+    uint32_t      lookup_mode;  // lookup working mode        
+    xptr_t        file_xp;      // extended pointer on created file descriptor
+    uint32_t      file_id;      // created file descriptor index in reference fd_array
+
+    // compute lookup working mode
+    lookup_mode = VFS_LOOKUP_OPEN;
+    if( (flags & O_DIR    )      )  lookup_mode |= VFS_LOOKUP_DIR;
+    if( (flags & O_CREAT  )      )  lookup_mode |= VFS_LOOKUP_CREATE;
+    if( (flags & O_EXCL   )      )  lookup_mode |= VFS_LOOKUP_EXCL;
+ 
+    // compute attributes for the created file
+    file_attr = 0;
+    if( (flags & O_RDONLY ) == 0 )  file_attr |= FD_ATTR_READ_ENABLE;
+    if( (flags & O_WRONLY ) == 0 )  file_attr |= FD_ATTR_WRITE_ENABLE;
+    if( (flags & O_SYNC   )      )  file_attr |= FD_ATTR_SYNC;
+    if( (flags & O_APPEND )      )  file_attr |= FD_ATTR_APPEND;
+    if( (flags & O_CLOEXEC)      )  file_attr |= FD_ATTR_CLOSE_EXEC;
+
+    // get extended pointer on target inode
+    error = vfs_lookup( cwd_xp , path , lookup_mode , &inode_xp );
+
+    if( error ) return error;
+
+    // get target inode cluster and local pointer
+    inode_cxy = GET_CXY( inode_xp );
+    inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
+    
+    // create a new file descriptor in cluster containing inode
+    if( inode_cxy == local_cxy )      // target cluster is local
+    {
+        error = vfs_file_create( inode_ptr , file_attr , &file_xp );
+    }
+    else                              // target cluster is remote
+    {
+        rpc_vfs_file_create_client( inode_cxy , inode_ptr , file_attr , &file_xp , &error );
+    }
+
+    if( error )  return error;
+
+    // allocate and register a new file descriptor index in reference cluster fd_array
+    error = process_fd_register( file_xp , &file_id );
+
+    if( error ) return error;
+
+    // success
+    *new_file_xp = file_xp;
+    *new_file_id = file_id;
+    return 0;
+
+}  // end vfs_open()
+
+/////////////////////////////////////
+error_t vfs_move( bool_t   to_buffer,
+                  xptr_t   file_xp,
+                  void   * buffer,
+                  uint32_t size )
+{
+    assert( ( file_xp != XPTR_NULL ) , __FUNCTION__ , "file_xp == XPTR_NULL" );
+
+    cxy_t              file_cxy;     // remote file descriptor cluster 
+    vfs_file_t       * file_ptr;     // remote file descriptor local pointer
+    vfs_inode_type_t   inode_type;
+    uint32_t           file_offset;  // current offset in file
+    mapper_t         * mapper;
+    error_t            error;
+
+    // get cluster and local pointer on remote file descriptor
+    file_cxy  = GET_CXY( file_xp );
+    file_ptr  = (vfs_file_t *)GET_PTR( file_xp );
+
+    // get inode type from remote file descriptor
+    inode_type = hal_remote_lw( XPTR( file_cxy , &file_ptr->type   ) );
+   
+    // action depends on inode type
+    if( inode_type == INODE_TYPE_FILE )
+    {
+        // get mapper pointer and file offset from file descriptor
+        file_offset = hal_remote_lw( XPTR( file_cxy , &file_ptr->offset ) );
+        mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
+
+        // move data between mapper and buffer
+        if( file_cxy == local_cxy )
+        {
+            error = mapper_move( mapper,
+                                 to_buffer,
+                                 file_offset,
+                                 buffer,
+                                 size );
+        }
+        else
+        {
+            rpc_mapper_move_client( file_cxy,
+                                    mapper,
+                                    to_buffer,
+                                    file_offset,
+                                    buffer,
+                                    size,
+                                    &error );
+        } 
+
+        return error;
+    }
+    else if (inode_type == INODE_TYPE_DIR )
+    {
+        printk("\n[ERROR] in %s : inode is a directory", __FUNCTION__ );
+        return EINVAL;
+    }
+    else if (inode_type == INODE_TYPE_DEV )
+    {
+        // TODO
+        return 0;
+    }
+    else
+    {
+        printk("\n[PANIC] in %s : illegal inode type\n", __FUNCTION__ );
+        hal_core_sleep();
+        return -1;
+    }
+}  // end vfs_access()
 
 //////////////////////////////////////
@@ -492 +591 @@
                    uint32_t * new_offset )
 {
-    return 0;
-}
-
-//////////////////////////////////////
-error_t vfs_close( xptr_t     file_xp, 
-                   uint32_t * refcount )
-{
-    return 0;
-}
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+
+    assert( ( file_xp != XPTR_NULL ) , __FUNCTION__ , "file_xp == XPTR_NULL" );
+
+}  // vfs_lseek()
+
+///////////////////////////////////
+error_t vfs_close( xptr_t   file_xp,
+                   uint32_t file_id )
+{
+    assert( (file_xp != XPTR_NULL) , __FUNCTION__ , "file_xp == XPTR_NULL" );
+
+    assert( (file_id < CONFIG_PROCESS_FILE_MAX_NR) , __FUNCTION__ , "illegal file_id" );
+
+    thread_t  * this    = CURRENT_THREAD;
+    process_t * process = this->process;
+
+    // get cluster and local pointer on remote file descriptor
+    cxy_t        file_cxy = GET_CXY( file_xp );
+    vfs_file_t * file_ptr = (vfs_file_t *)GET_PTR( file_xp );
+
+    // get local pointer on local cluster manager
+    cluster_t * cluster = LOCAL_CLUSTER;
+
+    // get owner process cluster and lpid
+    cxy_t   owner_cxy  = CXY_FROM_PID( process->pid );
+    lpid_t  lpid       = LPID_FROM_PID( process->pid );
+
+    // get extended pointers on copies root and lock
+    xptr_t root_xp = XPTR( owner_cxy , &cluster->pmgr.copies_root[lpid] );
+    xptr_t lock_xp = XPTR( owner_cxy , &cluster->pmgr.copies_lock[lpid] );
+
+    // take the lock protecting the copies
+    remote_spinlock_lock( lock_xp );
+
+    // 1) loop on the process descriptor copies to cancel all fd_array[file_id] entries
+    xptr_t  iter_xp;
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        xptr_t      process_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
+        cxy_t       process_cxy = GET_CXY( process_xp );
+        process_t * process_ptr = (process_t *)GET_PTR( process_xp );
+
+        xptr_t lock_xp  = XPTR( process_cxy , &process_ptr->fd_array.lock );
+        xptr_t entry_xp = XPTR( process_cxy , &process_ptr->fd_array.array[file_id] );
+
+        // lock is required for atomic write of a 64 bits word
+        remote_rwlock_wr_lock( lock_xp );
+        hal_remote_swd( entry_xp , XPTR_NULL );
+        remote_rwlock_wr_unlock( lock_xp );
+
+        hal_wbflush();
+    }    
+
+    // 2) release memory allocated to file descriptor in remote cluster
+    if( file_cxy == local_cxy )             // file cluster is local
+    {
+        vfs_file_destroy( file_ptr );
+    }
+    else                                    // file cluster is local
+    {
+        rpc_vfs_file_destroy_client( file_cxy , file_ptr );
+    }
+
+    return 0;
+
+}  // end vfs_close()
 
 ////////////////////////////////////
@@ -506 +665 @@
                     char   * path )
 {
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}  // vfs_unlink()
+
+///////////////////////////////////////
+error_t vfs_stat( xptr_t       file_xp,
+                  vfs_stat_t * k_stat )
+{
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+
+////////////////////////////////////////////
+error_t vfs_readdir( xptr_t         file_xp,
+                     vfs_dirent_t * k_dirent )
+{
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
     return 0;
 }
 
 //////////////////////////////////////
-error_t vfs_stat( xptr_t       file_xp,
-                  vfs_stat_t * stat )
-{
-    return 0;
-}
-
-//////////////////////////////////////////////////////////////////////////////////////////
-//           Directory related functions
-//////////////////////////////////////////////////////////////////////////////////////////
-
-
-
-
-
-//////////////////////////////////////////////////////////////////////////////////////////
+error_t vfs_mkdir( xptr_t     file_xp,
+                   char     * path,
+                   uint32_t   mode )
+{
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+
+////////////////////////////////////
+error_t vfs_rmdir( xptr_t   file_xp,
+                   char   * path )
+{
+    printk("\n[PANIC] %s non implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+
+///////////////////////////////////
+error_t vfs_chdir( xptr_t   cwd_xp,
+                   char   * path )
+{
+    error_t           error;
+    xptr_t            inode_xp;     // extended pointer on target inode
+    cxy_t             inode_cxy;    // target inode cluster identifier       
+    vfs_inode_t     * inode_ptr;    // target inode local pointer
+    uint32_t          mode;         // lookup working mode        
+    vfs_inode_type_t  inode_type;   // target inode type
+
+    // set lookup working mode
+    mode = 0;
+
+    // get extended pointer on target inode
+    error = vfs_lookup( cwd_xp , path , mode , &inode_xp );
+
+    if( error ) return error;
+
+    // get inode cluster and local pointer
+    inode_cxy = GET_CXY( inode_xp );
+    inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
+
+    // get inode type from remote file
+    inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) );
+
+    if( inode_type != INODE_TYPE_DIR )
+    {
+        CURRENT_THREAD->errno = ENOTDIR;
+        return -1;
+    }
+
+    printk("\n[PANIC] %s non fully implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+
+///////////////////////////////////
+error_t vfs_chmod( xptr_t   cwd_xp,
+                   char   * path,
+                   uint32_t rights )
+{
+    error_t           error;
+    xptr_t            inode_xp;     // extended pointer on target inode
+    cxy_t             inode_cxy;    // inode cluster identifier       
+    vfs_inode_t     * inode_ptr;    // inode local pointer
+    uint32_t          mode;         // lookup working mode
+    vfs_inode_type_t  inode_type;   // target inode type
+
+    // set lookup working mode
+    mode = 0;
+ 
+    // get extended pointer on target inode
+    error = vfs_lookup( cwd_xp , path , mode , &inode_xp );
+
+    if( error ) return error;
+
+    // get inode cluster and local pointer
+    inode_cxy = GET_CXY( inode_xp );
+    inode_ptr = (vfs_inode_t *)GET_PTR( inode_xp );
+    
+    // get inode type from remote inode
+    inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) );
+
+    
+    printk("\n[PANIC] %s non fully implemented\n", __FUNCTION__ );
+    hal_core_sleep();
+    return 0;
+}
+
+///////////////////////////////////
+error_t vfs_mkfifo( xptr_t   cwd_xp,
+                    char   * path,
+                    uint32_t rights )
+{
+    printk("\n[PANIC] in %s : not implemented yet\n", __FUNCTION__ );
+    hal_core_sleep(); 
+    return 0;
+}
+
+
+
+/////////////////////////////////////////////////////////////////////////////////////////r
 //            Inode Tree functions
 //////////////////////////////////////////////////////////////////////////////////////////
 
 //////////////////////////////////////////////////////////////////////////////////////////
-// This static function is used by the vfs_lookup() function.
+// This function is used by the vfs_lookup() function.
 // It takes an extended pointer on a remote inode (parent directory inode),
 // and check access_rights violation for the calling thread.
@@ -641 +906 @@
 }
 
-////////////////////////////////////////
-error_t vfs_lookup( xptr_t       cwd_xp,
-                    char       * pathname,
-                    uint32_t     client_uid,
-                    uint32_t     client_gid,
-                                        xptr_t     * inode_xp,
-                    xptr_t     * ctx_xp )
+//////////////////////////////////////////////
+error_t vfs_lookup( xptr_t             cwd_xp,
+                    char             * pathname,
+                    uint32_t           mode,
+                                        xptr_t           * inode_xp )
 {
     char          name[CONFIG_VFS_MAX_NAME_LENGTH];   // one name in path 
 
-    xptr_t        parent_xp;    // extended pointer on parent inode
-    cxy_t         parent_cxy;   // cluster for parentc inode
-    vfs_inode_t * parent_ptr;   // local pointer on parent inode  
-    xptr_t        child_xp;     // extended pointer on child inode
-    cxy_t         child_cxy;    // cluster for child inode
-    vfs_inode_t * child_ptr;    // local pointer on child inode  
-    char        * current;      // current pointer on path
-    char        * next;         // next value for current pointer   
-    bool_t        last;         // true when the name is the last in path
-    bool_t        found;        // true when a child has been found
-    thread_t    * this;         // pointer on calling thread descriptor
-    process_t   * process;      // pointer on calling process descriptor
-    vfs_ctx_t   * ctx;          // parent inode context
-    uint32_t      type;         // file system type of parent inode
-    error_t       error;
+    xptr_t             parent_xp;    // extended pointer on parent inode
+    cxy_t              parent_cxy;   // cluster for parent inode
+    vfs_inode_t      * parent_ptr;   // local pointer on parent inode  
+    xptr_t             child_xp;     // extended pointer on child inode
+    cxy_t              child_cxy;    // cluster for child inode
+    vfs_inode_t      * child_ptr;    // local pointer on child inode  
+    vfs_inode_type_t   inode_type;   // child inode type
+    vfs_fs_type_t      fs_type;      // File system type
+    vfs_ctx_t        * ctx_ptr;      // local pointer on FS context
+    char             * current;      // current pointer on path
+    char             * next;         // next value for current pointer   
+    bool_t             last;         // true when the name is the last in path
+    bool_t             found;        // true when a child has been found
+    thread_t         * this;         // pointer on calling thread descriptor
+    process_t        * process;      // pointer on calling process descriptor
+    error_t            error;
 
     this    = CURRENT_THREAD;
@@ -687 +951 @@
     do
     {
-        // get cluster and local pointer for parent inode
-        parent_cxy = GET_CXY( parent_xp );
-        parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
-        
-        // get parent inode FS type
-        ctx = (vfs_ctx_t *)(intptr_t)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
-        type = ctx->type;
-
-        // get one name from path
+        // get one name from path and the last flag
         vfs_get_name_from_path( current , name , &next , &last );
 
@@ -708 +964 @@
             vfs_inode_remote_unlock( parent_xp );
 
-            // insert a new dentry/inode in parent inode
-            error = vfs_add_child_in_parent( type , parent_xp , name , &child_xp );
+            // get cluster and local pointer on parent inode
+            parent_cxy = GET_CXY( parent_xp );
+            parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
+
+            // get parent inode FS type
+            ctx_ptr = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
+            fs_type = ctx_ptr->type;
+
+            // get child inode type
+            if( (last == false) || (mode & VFS_LOOKUP_DIR) ) inode_type = INODE_TYPE_DIR;
+            else                                             inode_type = INODE_TYPE_FILE;
+
+            // insert a child dentry/inode in parent inode
+            error = vfs_add_child_in_parent( inode_type,
+                                             fs_type, 
+                                             parent_xp, 
+                                             name, 
+                                             &child_xp );
 
             if( error )
@@ -723 +995 @@
 
         // check access rights
-        error = vfs_access_denied( child_xp,
-                                   client_uid,
-                                   client_gid );
-        if( error ) 
-        {
-            printk("\n[ERROR] in %s : permission denied for %s\n", __FUNCTION__ , name );
-            return EACCES;
-        }
+        // error = vfs_access_denied( child_xp,
+        //                            client_uid,
+        //                            client_gid );
+        // if( error ) 
+        // {
+        //     printk("\n[ERROR] in %s : permission denied for %s\n", __FUNCTION__ , name );
+        //     return EACCES;
+        // }
 
         // take lock on child inode if not last
@@ -753 +1025 @@
     // return searched pointers
     *inode_xp = child_xp;
-    *ctx_xp   = (xptr_t)hal_remote_lwd( XPTR( child_cxy , &child_ptr->ctx ) );
 
     return 0;
@@ -770 +1041 @@
         uint32_t     count;       // number of characters written in buffer
         uint32_t     index;       // slot index in buffer
-    xptr_t       inode_xp;  // extended pointer on    
+    xptr_t       inode_xp;    // extended pointer on    
 
     // implementation note:
@@ -829 +1100 @@
 }  // end vfs_get_path()
 
-///////////////////////////////////////////////
-error_t vfs_add_child_in_parent( uint32_t type,
-                                 xptr_t   parent_xp,
-                                 char   * name,   
-                                 xptr_t * child_xp )
-{
-    xptr_t     dentry_xp;  // extended pointer on created dentry
-    xptr_t     inode_xp;   // extended pointer on created inode
-    error_t    error;
+///////////////////////////////////////////////////////////////
+error_t vfs_add_child_in_parent( vfs_inode_type_t   inode_type,
+                                 vfs_fs_type_t      fs_type,
+                                 xptr_t             parent_xp,
+                                 char             * name,
+                                 xptr_t           * child_xp )
+{
+    error_t         error;
+    xptr_t          dentry_xp;   // extended pointer on created dentry
+    xptr_t          inode_xp;    // extended pointer on created inode
+    cxy_t           parent_cxy;  // parent inode cluster identifier
+    vfs_inode_t   * parent_ptr;  // parent inode local pointer
+    vfs_ctx_t     * parent_ctx;  // parent inode context local pointer
 
     // get parent inode cluster and local pointer
-    cxy_t         parent_cxy = GET_CXY( parent_xp );
-    vfs_inode_t * parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
+    parent_cxy = GET_CXY( parent_xp );
+    parent_ptr = (vfs_inode_t *)GET_PTR( parent_xp );
+
+    // get parent inode context local pointer
+    parent_ctx = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->ctx ) );
 
     // create dentry
     if( parent_cxy == local_cxy )      // parent cluster is the local cluster
     {
-        error = vfs_dentry_create( type,
+        error = vfs_dentry_create( fs_type,
                                    name,
                                    parent_ptr,
@@ -854 +1132 @@
     {
         rpc_vfs_dentry_create_client( parent_cxy,
-                                      type,
+                                      fs_type,
                                       name,
                                       parent_ptr,
@@ -887 +1165 @@
     {
         error = vfs_inode_create( dentry_xp,
-                                  type,
+                                  fs_type,
+                                  inode_type,
                                   attr,
                                   mode,
@@ -898 +1177 @@
         rpc_vfs_inode_create_client( child_cxy,
                                      dentry_xp,
-                                     type,
+                                     fs_type,
+                                     inode_type,
                                      attr,
                                      mode,
@@ -925 +1205 @@
 
 
+
+
+//////////////////////////////////////////////////////////////////////////////////////////
+//            Mapper related functions
+//////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////
+error_t vfs_move_page_to_mapper( page_t * page )
+{
+    error_t         error = 0;
+
+    assert( (page != NULL) , __FUNCTION__ , "page pointer is NULL\n" );
+
+    mapper_t * mapper = page->mapper;
+
+    assert( (mapper != NULL) , __FUNCTION__ , "no mapper for page\n" );
+
+    // get FS type
+    vfs_fs_type_t fs_type = mapper->inode->ctx->type;
+
+    // update mapper if permitted by file system type
+    if( fs_type == FS_TYPE_FATFS )
+    {
+        // get mapper lock in WRITE_MODE
+        rwlock_wr_lock( &mapper->lock );
+
+        error = fatfs_read_page( page ); 
+
+        // release mapper lock 
+        rwlock_wr_unlock( &mapper->lock );
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , __FUNCTION__ , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , __FUNCTION__ , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , __FUNCTION__ , "undefined file system type\n" );
+    }
+
+    return error;
+
+}  // end vfs_move_page_to_mapper()
+
+//////////////////////////////////////////////////
+error_t vfs_move_page_from_mapper( page_t * page )
+{
+    error_t         error = 0;
+
+    assert( (page != NULL) , __FUNCTION__ , "page pointer is NULL\n" );
+
+    mapper_t * mapper = page->mapper;
+
+    assert( (mapper != NULL) , __FUNCTION__ , "no mapper for page\n" );
+
+    // get FS type
+    vfs_fs_type_t  fs_type = mapper->inode->ctx->type;
+
+    // update file system if permitted by file system type
+    if( fs_type == FS_TYPE_FATFS )
+    {
+            if( page_is_flag( page , PG_DIRTY ) ) 
+            {
+            // get mapper lock in READ_MODE
+            rwlock_rd_lock( &mapper->lock );
+
+            error = fatfs_write_page( page );
+
+            // release mapper lock from READ_MODE
+            rwlock_rd_unlock( &mapper->lock );
+
+            // clear dirty bit if success
+                    if( error == 0 ) page_undo_dirty( page );
+         }
+    }
+    else if( fs_type == FS_TYPE_RAMFS )
+    {
+        assert( false , __FUNCTION__ , "should not be called for RAMFS\n" );
+    }
+    else if( fs_type == FS_TYPE_DEVFS )
+    {
+        assert( false , __FUNCTION__ , "should not be called for DEVFS\n" );
+    }
+    else
+    {
+        assert( false , __FUNCTION__ , "undefined file system type\n" );
+    }
+        
+    return error;
+
+}  // end vfs_move_page_from_mapper()
+
+

trunk/kernel/vfs/vfs.h

@@ -2 +2 @@
  * vfs.h - Virtual File System definition.
  *
- * Author  Mohamed Lamine Karaoui (2015)
- *         Alain Greiner (2016)
+ * Author  Mohamed Lamine Karaoui (2014,2015)
+ *         Alain Greiner (2016,2017)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -42 +42 @@
 #include <fatfs.h>
 #include <ramfs.h>
+#include <devfs.h>
 
 /****  Forward declarations  ***/
@@ -63 +64 @@
 struct device_s;
 struct vseg_s;
-
-/*********************************************************************************************
- * This defines the various Flags arguments for an open() or opendir() system call.
- ********************************************************************************************/
-
-#define VFS_O_APPEND         0x00080000
-#define VFS_O_RDONLY         0x00100000
-#define VFS_O_WRONLY         0x00200000
-#define VFS_O_RDWR           0x00300000
-#define VFS_O_CREATE         0x00400000
-#define VFS_O_EXCL           0x00800000
-#define VFS_O_TRUNC          0x01000000
-#define VFS_O_SYNC               0x08000000
-
-/*********************************************************************************************
- * This defines the various types of command for an lseek() system call.
- ********************************************************************************************/
-
-#define VFS_SEEK_SET         0
-#define VFS_SEEK_CUR         1
-#define VFS_SEEK_END         2
-
-/*********************************************************************************************
- * TODO : the following flags were defined in the vfs-params.h file...
- *        ... and must be documented. [AG]
- ********************************************************************************************/
-
-
-//////////////////////////////////////
-///    keep these flags compact    ///
-//////////////////////////////////////
-#define VFS_REGFILE          0x0000000
-#define VFS_DIR              0x0000001
-#define VFS_FIFO             0x0000002
-#define VFS_DEV_CHR          0x0000004
-#define VFS_DEV_BLK          0x0000008
-#define VFS_DEV              0x000000C
-#define VFS_SOCK             0x0000010
-#define VFS_SYMLNK           0x0000020
-//////////////////////////////////////
-
-#define VFS_RD_ONLY          0x0000040
-#define VFS_SYS              0x0000080
-#define VFS_ARCHIVE          0x0000100
-#define VFS_PIPE             0x0000200
-
-#define VFS_IFMT             0x0170000
-#define VFS_IFSOCK           0x0140000
-#define VFS_IFLNK            0x0120000
-#define VFS_IFREG            0x0100000
-#define VFS_IFBLK            0x0060000
-#define VFS_IFDIR            0x0040000
-#define VFS_IFCHR            0x0020000
-#define VFS_IFIFO            0x0010000
-
-#define VFS_ISUID            0x0004000
-#define VFS_ISGID            0x0002000
-#define VFS_ISVTX            0x0001000
+struct page_s;
+
+
+/******************************************************************************************
+ * These flags are used to define the working mode of the vfs_lookup() function.  
+ *****************************************************************************************/
+
+#define VFS_LOOKUP_DIR      0x01     /* the searched inode is a directory                */
+#define VFS_LOOKUP_OPEN         0x02     /* the search is for an open/opendir                */
+#define VFS_LOOKUP_PARENT       0x04     /* return the parent inode (not the inode itself)   */
+#define VFS_LOOKUP_CREATE   0x10     /* file must be created if missing                  */
+#define VFS_LOOKUP_EXCL     0x20     /* file cannot previously exist                     */    
+
+/******************************************************************************************
+ * This define the masks for the POSIX access rights to inodes
+ *****************************************************************************************/
+
+#define VFS_ISUID                0x0004000
+#define VFS_ISGID                0x0002000
+#define VFS_ISVTX                0x0001000
 
 #define VFS_IRWXU            0x0000700
@@ -126 +89 @@
 #define VFS_IWUSR            0x0000200
 #define VFS_IXUSR            0x0000100
+
 #define VFS_IRWXG            0x0000070
 #define VFS_IRGRP            0x0000040
 #define VFS_IWGRP            0x0000020
 #define VFS_IXGRP            0x0000010
+
 #define VFS_IRWXO            0x0000007
 #define VFS_IROTH            0x0000004
@@ -139 +104 @@
 #define VFS_IEXEC            VFS_IXUSR
 
-#define VFS_SET(state,flag)    (state) |= (flag)
-#define VFS_IS(state,flag)     (state) & (flag)
-#define VFS_CLEAR(state,flag)  (state) &= ~(flag)
-
-
-/* Lookup flags */
-#define VFS_LOOKUP_FILE         0x1
-#define VFS_LOOKUP_LAST         0x2
-#define VFS_LOOKUP_OPEN         0x4
-#define VFS_LOOKUP_RESTART      0x8
-#define VFS_LOOKUP_RETRY        0x10
-#define VFS_LOOKUP_PARENT       0x20
-#define VFS_LOOKUP_HELD         0x40
-
-/* Context flags*/
-#define VFS_FS_LOCAL            0x1
-#define VFS_FS_USE_MAPPER       0x2
-
-
-
+
+/******************************************************************************************
+ * This structure defines informations common to all inodes and dentries
+ * of a given file system. As it is declared a global variable in the kdata segment,
+ * it is replicated in all clusters and handled as private by each OS intance.
+ *****************************************************************************************/
+
+typedef enum
+{
+        FS_TYPE_DEVFS = 0,
+        FS_TYPE_FATFS = 1,
+        FS_TYPE_RAMFS = 2,
+ 
+        FS_TYPES_NR   = 3,
+}
+vfs_fs_type_t;
+
+typedef enum
+{
+    CTX_ATTR_READ_ONLY    = 0x01,            /*! write access prohibited                 */
+    CTX_ATTR_SYNC         = 0x10,            /*! synchronise FS on each write            */
+}
+vfs_ctx_attr_t;
+
+typedef struct vfs_ctx_s
+{
+        vfs_fs_type_t  type;                     /*! File System type                        */
+        uint32_t           attr;                     /*! global attributes for all files in FS   */
+        uint32_t       count;                    /*! total number of clusters on device      */
+        uint32_t       blksize;                  /*! device cluster size (bytes)             */
+        xptr_t         root_xp;                  /*! extended pointer on root inode          */
+    spinlock_t     lock;                     /*! lock protecting inum allocator          */
+    uint32_t       bitmap[BITMAP_SIZE(CONFIG_VFS_MAX_INODES)];  /* inum allocator        */
+    void         * extend;                   /*! FS specific context extension           */
+}
+vfs_ctx_t;
 
 /******************************************************************************************
@@ -166 +147 @@
  * The <parent> inode is unique for a directory (not hard links for directories). 
  * For a file, the parent field points to the first dentry who created this inode.
- * Syncronisation:
+ * Syncrhonisation:
  * - the main_lock (spinlock) is used during the inode tree traversal or for inode
  *   modification (add/remove children).
@@ -172 +153 @@
  *   in the mapper. 
  * - the mapper lock (rwlock) is only used during the radix tree traversal to return
- *   to return the relevant page for red/write.
- *****************************************************************************************/
+ *   the relevant page for read/write.
+ *****************************************************************************************/
+
+/* this enum define the VFS inode types values */
 
 typedef enum   
 {
-    INODE_TYPE_NORMAL,                 /*! file or directory                            */
-    INODE_TYPE_PIPE,                   /*! POSIX pipe                                   */
-    INODE_TYPE_SOCKET,                 /*! POSIX socket                                 */
-    INODE_TYPE_DEV,                    /*! peripheral channel                           */
+    INODE_TYPE_FILE    =     0x001,      /*! file                                        */
+    INODE_TYPE_DIR     =     0x002,      /*! directory                                   */
+    INODE_TYPE_FIFO    =     0x004,      /*! POSIX named pipe                            */
+    INODE_TYPE_PIPE    =     0x008,      /*! POSIX anonymous pipe                        */
+    INODE_TYPE_SOCKET  =     0x010,      /*! POSIX socket                                */
+    INODE_TYPE_DEV     =     0x020,      /*! character peripheral channel                */
+    INODE_TYPE_SYML    =     0x080,      /*! symbolic link                               */
 }
 vfs_inode_type_t;
 
+/* this enum define the VFS inode attributes values */
+
 typedef enum 
 {
-    INODE_ATTR_DIRTY  = 0x01,
-    INODE_ATTR_DIR    = 0x02,
-    INODE_ATTR_INLOAD = 0x04,
-    INODE_ATTR_NEW    = 0x08,
+    INODE_ATTR_DIRTY   =     0x01,       /* modified versus the value on device          */ 
+    INODE_ATTR_INLOAD  =     0x04,       /* loading from device in progress              */
+    INODE_ATTR_NEW     =     0x08,       /* not saved on device yet                      */
 }
 vfs_inode_attr_t;
@@ -195 +182 @@
 typedef struct vfs_inode_s
 {
-        struct vfs_ctx_s      * ctx;         /*! Rlocal pointer on FS context                */
+        struct vfs_ctx_s      * ctx;         /*! local pointer on FS context                 */
     uint32_t                gc;          /*! generation counter                          */
         uint32_t                inum;        /*! inode identifier (unique in file system)    */
         uint32_t                attr;        /*! inode attributes (see above)                */
-        uint32_t                type;        /*! inode type (see above)                      */
+        vfs_inode_type_t        type;        /*! inode type (see above)                      */
         uint32_t                size;        /*! number of bytes                             */
         uint32_t                links;       /*! number of alias dentry                      */
         uid_t                   uid;         /*! user owner identifier                       */
         gid_t                   gid;         /*! group owner identifier                      */
-    uint32_t                mode;        /*! access mode                                 */
+    uint32_t                rights;      /*! access rights                               */
         uint32_t                    refcount;    /*! reference counter (all pointers)            */
         xptr_t                  parent_xp;   /*! extended pointer on parent dentry           */
-        xhtab_t                 children;    /*! embedded htab of dir entries (for dir type) */
+        xhtab_t                 children;    /*! embedded xhtab of vfs_dentry_t              */
         remote_rwlock_t         data_lock;   /*! protect read/write to data and to size      */
         remote_spinlock_t       main_lock;   /*! protect inode tree traversal and modifs     */
-        xlist_entry_t           xlist;       /*! member of set of inodes in same cluster     */
+        list_entry_t            list;        /*! member of set of inodes in same cluster     */
         xlist_entry_t           wait_root;   /*! root of threads waiting on this inode       */
         struct vfs_inode_op_s * op;          /*! TODO ???                                    */
@@ -240 +227 @@
 
 /******************************************************************************************
- * This structure describes an open file/directory for a given process.
+ * 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.
+ * Aa 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_fd_attr_t;
+    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.                 */
         uint32_t                gc;         /*! generation counter                           */
-        uint32_t                type;       /*! see above                                    */
-        uint32_t                attr;       /*! see above                                    */
+        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                    */
-        remote_rwlock_t       lock;       /*! protect offset modifications                 */
+        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 vfs_ctx_s      * ctx;        /*! file system features                         */
-        struct vfs_file_op_s  * op;         /*! local set of function pointers               */
+        void                  * extend;     /*! FS specific extension                        */
 }
 vfs_file_t;
 
 /******************************************************************************************
- * This structure defines informations common to all inodes and dentries
- * of a given file system. As it is declared a global variable in the kdata segment,
- * it is replicated in all clusters and handled as private by each OS intance.
- *****************************************************************************************/
-
-typedef enum
-{
-        FS_TYPE_SYSFS = 0,
-        FS_TYPE_DEVFS = 1,
-        FS_TYPE_FATFS = 2,
-        FS_TYPE_RAMFS = 3,
- 
-        FS_TYPES_NR   = 4,
-}
-vfs_types_t;
-
-typedef enum
-{
-    CTX_ATTR_READ_ONLY    = 0x01,       /*! read access possible                         */
-    CTX_ATTR_SYNC         = 0x10,       /*! synchronise FS on each write                 */
-}
-vfs_ctx_attr_t;
-
-typedef struct vfs_ctx_s
-{
-        uint32_t                      type;          /*! File System type                        */
-        uint32_t                      attr;          /*! global attributes for all files in FS   */
-        uint32_t                  count;         /*! number of clusters                      */
-        uint32_t                  blksize;       /*! cluster size                            */
-    xptr_t                    ioc_xp;        /*! extended pointer on IOC device          */
-        xptr_t                    root_xp;       /*! extended pointer on root inode          */
-
-    spinlock_t                lock;          /*! lock protecting inum allocator          */
-        BITMAP( inum , CONFIG_VFS_MAX_INODES );  /*! inum allocator                          */ 
-
-    void                    * extend;        /*! FS specific context extension           */
-}
-vfs_ctx_t;
-
-/******************************************************************************************
- * This structure define the informations associated to a given file descriptor,
- * that are returned by the vfs_stat() function.
+ * This structure define the informations associated to a file descriptor,
+ * returned to user space by the stat() system call.
  *****************************************************************************************/
 
@@ -335 +284 @@
 vfs_stat_t;
 
-
-
-
-
-
-/****************************************************************************************** 
- * This structure defines the set of operations that can be done on a VFS context. 
- * TODO A quoi cela sert-il ? [AG]
- *****************************************************************************************/
-
-typedef error_t (vfs_create_context_t)  ( vfs_ctx_t * context );
-typedef error_t (vfs_destroy_context_t) ( vfs_ctx_t * context );
-typedef error_t (vfs_read_root_t)       ( vfs_ctx_t * context , vfs_inode_t * root );
-typedef error_t (vfs_reply_root_t)      ( vfs_ctx_t * context , vfs_inode_t * root );
-typedef error_t (vfs_write_root_t)      ( vfs_ctx_t * context , vfs_inode_t * root );
-
-struct vfs_ctx_op_s
-{
-        vfs_create_context_t  * create;      /*! allocate memory and initialize a context   */
-        vfs_destroy_context_t * destroy;     /*! release memory allocated to a context      */
-        vfs_read_root_t       * read_root;   /*! TODO                                       */
-        vfs_reply_root_t      * repli_root;  /*! TODO                                       */
-        vfs_write_root_t      * write_root;  /*! TODO                                       */
-}
-vfs_ctx_op_t;
-
-/****************************************************************************************** 
- * This structure defines the set of operations that can be done on a VFS inode. 
- * TODO A quoi cela sert-il ? [AG]
- *****************************************************************************************/
-
-typedef error_t (vfs_init_inode_t)    ( vfs_inode_t * inode );
-typedef error_t (vfs_create_inode_t)  ( vfs_inode_t * parent , vfs_dentry_t  * dentry );
-typedef error_t (vfs_lookup_inode_t)  ( vfs_inode_t * parent , vfs_dentry_t  * dentry );
-typedef error_t (vfs_write_inode_t)   ( vfs_inode_t * inode );
-typedef error_t (vfs_release_inode_t) ( vfs_inode_t * inode );
-typedef error_t (vfs_unlink_inode_t)  ( vfs_inode_t * parent , vfs_dentry_t  * dentry , uint32_t flags );
-typedef error_t (vfs_stat_inode_t)    ( vfs_inode_t * inode );
-typedef error_t (vfs_trunc_inode_t)   ( vfs_inode_t * inode );
-typedef error_t (vfs_delete_inode_t)  ( vfs_inode_t * inode );
-
-typedef struct vfs_inode_op_s
-{
-        vfs_init_inode_t    * init;     /*! initialise inode from scratch                    */
-        vfs_create_inode_t  * create;   /*! allocate memory for one inode                    */
-        vfs_lookup_inode_t  * lookup;   /*! get one directory entry by name                  */ 
-        vfs_write_inode_t   * write;    /*! update the device from the inode                 */
-        vfs_release_inode_t * release;  /*! reset one inode and release associated objects   */
-        vfs_unlink_inode_t  * unlink;   /*! unlink a directory entry from parent inode       */
-        vfs_delete_inode_t  * delete;   /*! release memory allocated to inode when count = 0 */
-        vfs_stat_inode_t    * stat;     /*! TODO                                             */
-        vfs_trunc_inode_t   * trunc;    /*! change the size of a file                        */
-}
-vfs_inode_op_t;
-
-/****************************************************************************************** 
- * This structure defines the set of operations that can be done on a VFS dentry.
- * TODO A quoi cela sert-il ? [AG]
- *****************************************************************************************/
-
-typedef error_t (vfs_compare_dentry_t) ( char * first , char * second );
-
-typedef struct vfs_dentry_op_s
-{
-        vfs_compare_dentry_t * compare;
-}
-vfs_dentry_op_t;
-
-/****************************************************************************************** 
- * This structure defines the set of operations that can be done on a VFS file.  
- * TODO A quoi cela sert-il ? [AG]
- *****************************************************************************************/
-
-typedef error_t (vfs_open_file_t)    ( vfs_file_t * file , void * priv );
-typedef error_t (vfs_read_file_t)    ( vfs_file_t * file , char * buffer );
-typedef error_t (vfs_write_file_t)   ( vfs_file_t * file , char * buffer );
-typedef error_t (vfs_lseek_file_t)   ( vfs_file_t * file );
-typedef error_t (vfs_close_file_t)   ( vfs_file_t * file );
-typedef error_t (vfs_release_file_t) ( vfs_file_t * file );
-typedef error_t (vfs_read_dir_t)     ( vfs_file_t * file );
-typedef error_t (vfs_mmap_file_t)    ( vfs_file_t * file , struct vseg_s * vseg );
-typedef error_t (vfs_munmap_file_t)  ( vfs_file_t * file , struct vseg_s * vseg );
-
-typedef struct vfs_file_op_s
-{
-        vfs_open_file_t    * open;
-        vfs_read_file_t    * read;
-        vfs_write_file_t   * write;
-        vfs_lseek_file_t   * lseek;
-        vfs_read_dir_t     * readdir;
-        vfs_close_file_t   * close;
-        vfs_release_file_t * release;
-        vfs_mmap_file_t    * mmap;
-        vfs_munmap_file_t  * munmap;
-}
-vfs_file_op_t;
-
-
-
+/*********************************************************************************************
+ * This structure defines the information associated to a directory entry,
+ * returned to user space by the readdir() system call.
+ ********************************************************************************************/
+
+typedef struct vfs_dirent_s
+{
+    uint32_t    inum;                               /*! inode identifier                    */
+    uint32_t    type;                               /*! inode type                          */
+    char        name[CONFIG_VFS_MAX_NAME_LENGTH];   /*! dentry name                         */
+}
+vfs_dirent_t;
 
 
@@ -441 +303 @@
 /*****************************************************************************************/ 
 
-/****************************************************************************************** 
- * This function initializes the Virtual File System.     
- *****************************************************************************************/
-void vfs_init();
-
-/****************************************************************************************** 
- * This function mount a given file system type for a given process.     
+
+/****************************************************************************************** 
+ * This function mount a given file system type for a given process TODO.     
  *****************************************************************************************/
 error_t vfs_mount_fs_root( struct device_s  * device,
@@ -482 +340 @@
 
 
-/*****************************************************************************************/
-/************************ File Descriptor related functions ******************************/
+
+/*****************************************************************************************/
+/********************* Inode related functions *******************************************/
+/*****************************************************************************************/
+
+/****************************************************************************************** 
+ * This function allocates memory from local cluster for an inode descriptor and the 
+ * associated mapper. It initialise these descriptors from arguments values. 
+ * The parent dentry must have been previously created.
+ * If the client thread is not running in the cluster containing this inode,
+ * it must use the rpc_vfs_inode_create_client() function.
+ ******************************************************************************************
+ * @ dentry_xp  : extended pointer on associated dentry (in parent inode cluster).
+ * @ fs_type    : file system type.
+ * @ inode_type : inode type.
+ * @ attr       : inode attributes.
+ * @ rights     : inode access rights.
+ * @ uid        : user owner ID.
+ * @ gid        : group owner ID.
+ * @ inode_xp   : [out] buffer for extended pointer on created inode.
+ * # return 0 if success / return ENOMEM or EINVAL if error.
+ *****************************************************************************************/
+error_t vfs_inode_create( xptr_t            dentry_xp,
+                          vfs_fs_type_t     fs_type,
+                          vfs_inode_type_t  inode_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.
+ * It must be executed by a thread running in the cluster containing the inode,
+ * and the inode refcount must be zero.
+ * If the client thread is not running in the owner cluster, it must use the
+ * rpc_vfs_inode_destroy_client() function.
+ ****************************************************************************************** 
+ * @ inode  : local pointer on inode descriptor.
+ *****************************************************************************************/
+void vfs_inode_destroy( vfs_inode_t *  inode );  
+
+/****************************************************************************************** 
+ * This function atomically increment/decrement the inode refcount.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************/
+void vfs_inode_remote_up( xptr_t  inode_xp );
+void vfs_inode_remote_down( xptr_t  inode_xp );
+
+/****************************************************************************************** 
+ * This function returns the <size> of a file/dir from a remote inode,
+ * taking the remote_rwlock protecting <size> in READ_MODE.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ * @ return the current size.
+ *****************************************************************************************/
+uint32_t vfs_inode_get_size( xptr_t inode_xp );
+
+/****************************************************************************************** 
+ * This function set the <size> of a file/dir to a remote inode,
+ * taking the remote_rwlock protecting <size> in WRITE_MODE.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ * @ size      : value to be written.
+ *****************************************************************************************/
+void vfs_inode_set_size( xptr_t   inode_xp,
+                         uint32_t size );
+
+/****************************************************************************************** 
+ * This function takes the main lock of a remote inode.
+ * This lock protect all inode fiels, including the children dentries.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ *****************************************************************************************/
+void vfs_inode_remote_lock( xptr_t inode_xp );
+
+/****************************************************************************************** 
+ * This function releases the main lock of a remote inode.
+ * This lock protect all inode fiels, including the children dentries.
+ *****************************************************************************************
+ * @ inode_xp  : extended pointer on the remote inode.
+ *****************************************************************************************/
+void vfs_inode_remote_unlock( xptr_t inode_xp );
+
+
+
+
+/****************************************************************************************** 
+ * This function TODO                                                          
+ *****************************************************************************************/
+error_t vfs_inode_hold( vfs_inode_t * inode,
+                        uint32_t      gc );
+
+/****************************************************************************************** 
+ * This function TODO                                                          
+ *****************************************************************************************/
+error_t vfs_inode_trunc( vfs_inode_t * inode );
+
+/****************************************************************************************** 
+ * This function TODO                                                          
+ *****************************************************************************************/
+error_t vfs_inode_link( vfs_inode_t * inode,
+                        uint32_t      igc );
+
+/****************************************************************************************** 
+ * This function TODO                                                          
+ *****************************************************************************************/
+error_t vfs_inode_unlink( vfs_inode_t * inode );
+
+/****************************************************************************************** 
+ * This function TODO                                                          
+ *****************************************************************************************/
+error_t vfs_inode_stat( vfs_inode_t * inode,
+                        uint32_t      inum );
+
+/****************************************************************************************** 
+ * This function TODO                                                          
+ *****************************************************************************************/
+error_t vfs_icache_del( vfs_inode_t * inode );
+
+
+/****************************************************************************************** 
+ * This function TODO  Pourquoi 2 arguments ?
+ *****************************************************************************************/
+error_t vfs_stat_inode( vfs_inode_t * inode,
+                        uint32_t      inum );
+
+
+/*****************************************************************************************/
+/***************** Dentry related functions **********************************************/
+/*****************************************************************************************/
+
+/****************************************************************************************** 
+ * This function allocates memory from local cluster for a dentry descriptor, 
+ * initialises it from  arguments values, and returns the extended pointer on dentry.
+ * The inode field is not initialized, because the inode does not exist yet.
+ * If the client thread is not running in the target cluster for this inode,
+ * it must use the rpc_dentry_create_client() function.
+ ******************************************************************************************
+ * @ fs_type    : file system type.
+ * @ name       : directory entry file/dir name.
+ * @ parent     : local pointer on parent inode.
+ * @ dentry_xp  : [out] buffer for extended pointer on created dentry.
+ * @ return 0 if success / return ENOMEM or EINVAL if error.
+ *****************************************************************************************/
+error_t vfs_dentry_create( vfs_fs_type_t   fs_type,
+                           char          * name,
+                           vfs_inode_t   * parent,
+                           xptr_t        * dentry_xp );
+ 
+/****************************************************************************************** 
+ * This function releases memory allocated to a dentry descriptor.
+ * It must be executed by a thread running in the cluster containing the dentry,
+ * and the dentry refcount must be zero.
+ * If the client thread is not running in the owner cluster, it must use the
+ * rpc_dentry_destroy_client() function.
+ ****************************************************************************************** 
+ * @ dentry  : local pointer on dentry descriptor.
+ *****************************************************************************************/
+void vfs_dentry_destroy( vfs_dentry_t *  dentry );  
+
+/****************************************************************************************** 
+ * These functions atomically increment/decrement the dentry refcount.
+ * It can be called by any thread running in any cluster.
+ *****************************************************************************************/
+void vfs_dentry_remote_up( xptr_t dentry_xp );
+void vfs_dentry_remote_down( xptr_t dentry_xp );
+
+
+/*****************************************************************************************/
+/************************ File descriptor related functions ******************************/
 /*****************************************************************************************/
 
 /****************************************************************************************** 
  * This function allocates memory and initializes a new local file descriptor.
- * It must be executed in the owner cluster containing the inode.
+ * It must be executed in the cluster containing the inode.
  * If the client thread is not running in the owner cluster, it must use the
  * rpc_vfs_file_create_client() function.
  ****************************************************************************************** 
- * @ inode_xp : extended pointer on associated inode.
- * @ type     : file descriptor type.
+ * @ inode    : local pointer on associated inode.
  * @ attr     : 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   type,
-                         uint32_t   attr,
-                         xptr_t   * file_xp );  
+error_t vfs_file_create( vfs_inode_t * inode,
+                         uint32_t      attr,
+                         xptr_t      * file_xp );  
 
 /****************************************************************************************** 
@@ -510 +535 @@
  * rpc_vfs_file_destroy_client() function.
  ****************************************************************************************** 
- * @ file_xp  : extended pointer on file descriptor.
- *****************************************************************************************/
-void vfs_file_destroy( xptr_t  file_xp );  
-
+ * @ file  : local pointer on file descriptor.
+ *****************************************************************************************/
+void vfs_file_destroy( vfs_file_t *  file );  
 
 /****************************************************************************************** 
@@ -525 +549 @@
 
 /*****************************************************************************************/
-/********************* Inode related functions *******************************************/
-/*****************************************************************************************/
-
-/****************************************************************************************** 
- * This function allocates memory from local cluster for an inode descriptor and the 
- * associated mapper. It initialise these descriptors from arguments values. 
- * The parent dentry must have been previously created.
- * If the client thread is not running in the cluster containing this inode,
- * it must use the rpc_vfs_inode_create_client() function.
- ******************************************************************************************
- * @ dentry_xp  : extended pointer on associated dentry (in parent inode cluster).
- * @ type       : file system type.
- * @ attr       : inode attributes.
- * @ mode       : inode access mode.
- * @ uid        : user owner ID.
- * @ gid        : group owner ID.
- * @ inode_xp   : [out] buffer for extended pointer on created inode.
- * # return 0 if success / return ENOMEM or EINVAL if error.
- *****************************************************************************************/
-error_t vfs_inode_create( xptr_t      dentry_xp,
-                          uint32_t    type,
-                          uint32_t    attr,
-                          uint32_t    mode,
-                          uid_t       uid,
-                          gid_t       gid,
-                          xptr_t    * inode_xp );
-
-/****************************************************************************************** 
- * This function releases memory allocated to an inode descriptor.
- * It must be executed by a thread running in the cluster containing the inode,
- * and the inode refcount must be zero.
- * If the client thread is not running in the owner cluster, it must use the
- * rpc_vfs_inode_destroy_client() function.
- ****************************************************************************************** 
- * @ inode  : local pointer on inode descriptor.
- *****************************************************************************************/
-void vfs_inode_destroy( vfs_inode_t *  inode );  
-
-/****************************************************************************************** 
- * This function atomically increment the inode refcount.
- * It can be called by any thread running in any cluster.
- *****************************************************************************************/
-void vfs_inode_remote_up( xptr_t  inode_xp );
-
-/****************************************************************************************** 
- * This function atomically decrement the inode refcount. 
- * It can be called by any thread running in any cluster.
- *****************************************************************************************/
-void vfs_inode_remote_down( 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.
- *****************************************************************************************
- * @ inode_xp  : extended pointer on the remote inode.
- * @ return the current size.
- *****************************************************************************************/
-uint32_t vfs_inode_get_size( xptr_t inode_xp );
-
-/****************************************************************************************** 
- * This function set the <size> of a file/dir to a remote inode,
- * taking the remote_rwlock protecting <size> in WRITE_MODE.
- *****************************************************************************************
- * @ inode_xp  : extended pointer on the remote inode.
- * @ size      : value to be written.
- *****************************************************************************************/
-void vfs_inode_set_size( xptr_t   inode_xp,
-                         uint32_t size );
-
-/****************************************************************************************** 
- * This function takes the main lock of a remote inode.
- * This lock protect all inode fiels, including the children dentries.
- *****************************************************************************************
- * @ inode_xp  : extended pointer on the remote inode.
- *****************************************************************************************/
-void vfs_inode_remote_lock( xptr_t inode_xp );
-
-/****************************************************************************************** 
- * This function releases the main lock of a remote inode.
- * This lock protect all inode fiels, including the children dentries.
- *****************************************************************************************
- * @ inode_xp  : extended pointer on the remote inode.
- *****************************************************************************************/
-void vfs_inode_remote_unlock( xptr_t inode_xp );
-
-
-
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_inode_hold( vfs_inode_t * inode,
-                        uint32_t      gc );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_inode_trunc( vfs_inode_t * inode );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_inode_link( vfs_inode_t * inode,
-                        uint32_t      igc );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_inode_unlink( vfs_inode_t * inode );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_inode_stat( vfs_inode_t * inode,
-                        uint32_t      inum );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_icache_del( vfs_inode_t * inode );
-
-
-/****************************************************************************************** 
- * This function TODO  Pourquoi 2 arguments ?
- *****************************************************************************************/
-error_t vfs_stat_inode( vfs_inode_t * inode,
-                        uint32_t      inum );
-
-
-/*****************************************************************************************/
-/***************** Dentry related functions **********************************************/
-/*****************************************************************************************/
-
-/****************************************************************************************** 
- * This function allocates memory from local cluster for a dentry descriptor, 
- * initialises it from  arguments values, and returns the extended pointer on dentry.
- * The inode field is not initialized, because the inode does not exist yet.
- * If the client thread is not running in the target cluster for this inode,
- * it must use the rpc_dentry_create_client() function.
- ******************************************************************************************
- * @ type       : file system type.
- * @ name       : directory entry file/dir name.
- * @ parent     : local pointer on parent inode.
- * @ dentry_xp  : [out] buffer for extended pointer on created inode.
- * @ return 0 if success / return ENOMEM or EINVAL if error.
- *****************************************************************************************/
-error_t vfs_dentry_create( uint32_t      type,
-                           char        * name,
-                           vfs_inode_t * parent,
-                           xptr_t      * dentry_xp );
- 
-/****************************************************************************************** 
- * This function releases memory allocated to a dentry descriptor.
- * It must be executed by a thread running in the cluster containing the dentry,
- * and the dentry refcount must be zero.
- * If the client thread is not running in the owner cluster, it must use the
- * rpc_dentry_destroy_client() function.
- ****************************************************************************************** 
- * @ dentry  : local pointer on dentry descriptor.
- *****************************************************************************************/
-void vfs_dentry_destroy( vfs_dentry_t *  dentry );  
-
-/****************************************************************************************** 
- * This function atomically increment the dentry refcount.                                
- * It can be called by any thread running in any cluster.
- *****************************************************************************************/
-void vfs_dentry_remote_up( xptr_t dentry_xp );
-
-/****************************************************************************************** 
- * This function atomically decrement the dentry refcount.                                
- * It can be called by any thread running in any cluster.
- *****************************************************************************************/
-void vfs_dentry_remote_down( xptr_t dentry_xp );
-
-
-/*****************************************************************************************/
-/*                 Inode-Tree related functions                                          */ 
+/******************* Inode-Tree related functions ****************************************/ 
 /*****************************************************************************************/ 
 
@@ -721 +569 @@
 /******************************************************************************************
  * This function takes a pathname (absolute or relative to cwd) and returns an extended 
- * pointer on the associated inode, and an extended pointer on the inode context.
- * If a given name in the path is not found in the inode tree, it try to load the missing
- * dentry/inode couple, from informations found in the parent directory.
- * If this directory entry does not exist on device, it returns an error.
- ******************************************************************************************
- * @ cwd_xp     : extended pointer on current directory (for relative path).
- * @ pathname   : path in kernel space (can be relative or absolute).
- * @ client_uid : client thread user ID (for checking).
- * @ client_gid : client thread group ID (for checking).
- * @ inode_xp   : [out] buffer for extended pointer on inode.
- * @ ctx_xp     : [out] buffer for extended pointer on inode context.
- * @ return 0 if success / ENOENT if inode not found / EACCES if permissopn denied
- *****************************************************************************************/
-error_t vfs_lookup( xptr_t       cwd_xp,
-                    char       * pathname,
-                    uint32_t     client_uid,
-                    uint32_t     client_gid,
-                                        xptr_t     * inode_xp,
-                    xptr_t     * ctx_xp );
+ * pointer on the associated inode.
+ * - If a given name in the path is not found in the inode tree, it try to load the missing
+ *   dentry/inode couple, from informations found in the parent directory.
+ * - If this directory entry does not exist on device, it returns an error.
+ * - If the the file identified by the pathname does not exist on device but the
+ *   flag CREATE is set, the inode is created.
+ * - If the the file identified by the pathname exist on device but both flags EXCL
+ *   and CREATE are set, an error is returned.
+ ******************************************************************************************
+ * @ cwd_xp      : extended pointer on current directory (for relative path).
+ * @ pathname    : path in kernel space (can be relative or absolute).
+ * @ lookup_mode : flags defining the working mode (defined above in this file).
+ * @ inode_xp    : [out] buffer for extended pointer on inode.
+ * @ return 0 if success / ENOENT if inode not found , EACCES if permissopn denied,
+ *                        EAGAIN if a new complete lookup must be made
+ *****************************************************************************************/
+error_t vfs_lookup( xptr_t             cwd_xp,
+                    char             * pathname,
+                    uint32_t           lookup_mode,
+                                        xptr_t           * inode_xp );
 
 /******************************************************************************************
@@ -747 +596 @@
  * - The dentry is created in the cluster containing the existing <parent_xp> inode.
  * - the child inode and its associated mapper are created in a randomly selected cluster.
- * - The dentry name is defined by the <name> argument.
- ******************************************************************************************
- * @ type       : new inode type
+ * - The new dentry name is defined by the <name> argument.
+ * - The new inode and the parent inode can have different FS types.
+ ******************************************************************************************
+ * @ inode_type : new inode type
+ * @ fs_type    : new inode FS type.
  * @ parent_xp  : extended pointer on parent inode.
  * @ name       : new directory entry name.
@@ -755 +606 @@
  * @ return 0 if success / ENOENT if entry not found in parent directory
  *****************************************************************************************/
-error_t vfs_add_child_in_parent( uint32_t type,
-                                 xptr_t   parent_xp,
-                                 char   * name,   
-                                 xptr_t * child_xp );
-
-/******************************************************************************************
- * TODO
+error_t vfs_add_child_in_parent( vfs_inode_type_t   inode_type,
+                                 vfs_fs_type_t      fs_type,
+                                 xptr_t             parent_xp,
+                                 char             * name,   
+                                 xptr_t           * child_xp );
+
+/******************************************************************************************
+ * This function removes a couple dentry/inode from the Inode-Tree, and remove it from
+ * the external device.
+ * TODO                   
  ******************************************************************************************
  * @ child_xp   : extended pointer on removed inode.
@@ -767 +621 @@
 error_t vfs_remove_child_from_parent( xptr_t child_xp );
 
-/*****************************************************************************************/
-/************************ File related functions *****************************************/
+
+
+
+
+
+/*****************************************************************************************/
+/****************** File access API ******************************************************/
 /*****************************************************************************************/
 
 /****************************************************************************************** 
  * This function allocates a vfs_file_t structure in the cluster containing the inode
- * associated to the requested file, initializes it, and returns an extended pointer 
- * on this remote open file descriptor. 
+ * associated to the file identified by <cwd_xp> & <path>.
+ * It initializes it, register it in the reference process fd_array, and returns both 
+ * the extended pointer on the remote file descriptor, and the index in the fd_array. 
  * The pathname can be relative to current directory or absolute.
- * If the inode does not exist in the inode cache, it try to find file on the mounted
+ * If the inode does not exist in the inode cache, it try to find the file on the mounted
  * device, and creates an inode on a pseudo randomly selected cluster if found.
  * It the requested file does not exist on device, it creates a new inode if the
  * O_CREAT flag is set and return an error otherwise. 
  ****************************************************************************************** 
- * @ cwd_xp    : extended pointer on current directory file descriptor (for relative path).
- * @ path      : file pathname (absolute or relative to current directory).
- * @ flags     : O_RDONLY, O_WRONLY, O_CREATE etc...
- * @ file_xp   : [out] buffer for extended pointer on created remote file descriptor.
+ * @ cwd_xp      : extended pointer on current working directory file descriptor.
+ * @ path        : file pathname (absolute or relative to current directory).
+ * @ flags       : defined above 
+ * @ mode        : access rights (as defined by chmod)
+ * @ file_xp     : [out] buffer for extended pointer on created remote file descriptor.
+ * @ file_id     : [out] buffer for created file descriptor index in reference fd_array.
  * @ return 0 if success / return non-zero if error.
  *****************************************************************************************/
@@ -790 +652 @@
                           char     * path,
                           uint32_t   flags,
-                          xptr_t   * file_xp );
-
-/****************************************************************************************** 
- * This function moves <size> bytes from the file identified by the open file descriptor
- * <file_xp> to the local kernel <buffer> , taken into account the offset in <file_xp>.
- ****************************************************************************************** 
- * @ file_xp   : extended pointer on the remote open file descriptor.
- * @ buffer    : local pointer on destination kernel buffer.
+                  uint32_t   mode,
+                          xptr_t   * file_xp,
+                          uint32_t * file_id );
+
+/****************************************************************************************** 
+ * This function moves <size> bytes between the file identified by the open file descriptor
+ * <file_xp> and a local kernel <buffer> , taken into account the offset in <file_xp>.
+ * The transfer direction is defined by the <to_buffer> argument.
+ ******************************************************************************************
+ * @ to_buffer : mapper -> buffer if true / buffer->mapper if false. 
+ * @ file_xp   : extended pointer on the remote file descriptor.
+ * @ buffer    : local pointer on local kernel buffer.
  * @ size      : requested number of bytes from offset.
- * @ returns number of bytes actually transfered / 0 if EOF / -1 if error.
- *****************************************************************************************/
-uint32_t vfs_read( xptr_t   file_xp, 
-                   void   * buffer,
-                   uint32_t size );
-
-/****************************************************************************************** 
- * This function moves <size> bytes from the local kernel <buffer> to the open file 
- * descriptor <file_xp>, taken into account the offset defined in <file_xp>.
- ****************************************************************************************** 
- * @ file_xp   : extended pointer on the remote open file descriptor.
- * @ buffer    : local pointer on source kernel buffer.
- * @ size      : requested number of bytes to be written from offset.
  * @ returns number of bytes actually transfered / -1 if error.
  *****************************************************************************************/
-uint32_t vfs_write( xptr_t   file_xp,
-                    void   * buffer,
-                    uint32_t size );
+error_t vfs_move( bool_t   to_buffer,
+                  xptr_t   file_xp, 
+                  void   * buffer,
+                  uint32_t size );
 
 /****************************************************************************************** 
@@ -837 +691 @@
 
 /****************************************************************************************** 
- * This function close an open file descriptor.                              
+ * This function close an open file descriptor: 
+ * 1) All entries in fd_array copies are directly cancelled by the calling thread,
+ *    using remote accesses. 
+ * 2) The memory allocated to file descriptor in cluster containing the inode is released.
+ *    It requires a RPC if cluster containing the file descriptor is remote.
  ******************************************************************************************
  * @ file_xp     : extended pointer on the file descriptor.
- * @ refcount    : number of references after close.
- * @ return 0 if success / return -1 if error
- *****************************************************************************************/
-error_t vfs_close( xptr_t     file_xp, 
-                   uint32_t * refcount );
-
-/****************************************************************************************** 
- * This function remove from the file system a directory entry identified by its pathname.
- * The pathname can be relative to current directory or absolute.
- ******************************************************************************************
- * @ cwd_xp   : extended pointer on the current directory file descriptor.
+ * @ file_id     : file descriptor index in fd_array.
+ * @ returns 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_close( xptr_t    file_xp,
+                   uint32_t  file_id );
+
+/****************************************************************************************** 
+ * This function remove from the file system a directory entry identified by the
+ * <cwd_xp> & <path> arguments.
+ ******************************************************************************************
+ * @ cwd_xp   : extended pointer on the current working directory file descriptor.
  * @ path     : pathname (absolute or relative to current directory).
+ * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
 error_t vfs_unlink( xptr_t   cwd_xp,
@@ -857 +716 @@
 
 /****************************************************************************************** 
- * This function returns in the <ustat> structure various informations on the file TODO
+ * This function returns, in the structure pointed by the <k_stat> kernel pointer,
+ * various informations on the file descriptor identified by the <file_xp> argument.
+ * TODO not implemented yet...
+ ******************************************************************************************
+ * @ file_xp    : extended pointer on the file descriptor of the searched directory .
+ * @ k_dirent   : local pointer on the dirent_t structure in kernel space.
+ * @ returns 0 if success / -1 if error.
  *****************************************************************************************/
 error_t vfs_stat( xptr_t       file_xp,
-                  vfs_stat_t * ustat );
-
-
-
-
-/*****************************************************************************************/
-/************************ Directory related functions ************************************/
-/*****************************************************************************************/
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_opendir( xptr_t      cwd_xp,
-                     char      * path,
-                     uint32_t    flags,
-                     xptr_t      file_xp );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *    fat32_readdir need cleaning
- *****************************************************************************************/
-error_t vfs_readdir( xptr_t            file_xp,
-                     char            * path );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_mkdir( xptr_t            file_xp,
-                   char            * path,
-                   uint32_t          mode );
-
-/****************************************************************************************** 
- * This function remove a directory from the file system.
- *****************************************************************************************/
-error_t vfs_rmdir( xptr_t            file_xp,
-                   char            * path );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_chdir( char            * pathname,
-                   xptr_t            cwd_xp );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_chmod( char            * pathname,
-                   vfs_file_t      * cwd,
-                   uint32_t          mode );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_closedir( xptr_t       file_xp,
-                      uint32_t   * refcount );
-
-
-
-
-/*****************************************************************************************/
-/*******************  Pipe related functions *********************************************/
-/*****************************************************************************************/
-
-/****************************************************************************************** 
- * This function TODO ???                                                         
- *****************************************************************************************/
-error_t vfs_pipe( xptr_t pipefd[2] );
-
-/****************************************************************************************** 
- * This function TODO                                                          
- *****************************************************************************************/
-error_t vfs_mkfifo( xptr_t            cwd_xp,
-                    char            * path,
-                    uint32_t          mode );
-
-
-
+                  vfs_stat_t * k_stat );
+
+/****************************************************************************************** 
+ * This function returns, in the structure pointed by the <k_dirent> kernel pointer, 
+ * various infos on the directory entry currently pointed by the <file_xp> file descriptor.
+ * TODO not implemented yet...
+ ******************************************************************************************
+ * @ file_xp    : extended pointer on the file descriptor of the searched directory .
+ * @ k_dirent   : local pointer on the dirent_t structure in kernel space.
+ * @ returns 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_readdir( xptr_t         file_xp,
+                     vfs_dirent_t * k_dirent );
+
+/****************************************************************************************** 
+ * This function  creates a new inode and associated dentry  for the directory defined
+ * by the <cwd_xp> & <path> arguments.
+ * TODO not implemented yet...
+ ******************************************************************************************
+ * @ cwd_xp   : extended pointer on the current working directory file descriptor.
+ * @ path     : pathname (absolute or relative to current directory).                     
+ * @ mode     : access rights (as defined by chmod)
+ * @ returns 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_mkdir( xptr_t     cwd_xp,
+                   char     * path,
+                   uint32_t   mode );
+
+/****************************************************************************************** 
+ * This function remove a directory identified by the <cwd_xp / path> arguments
+ * from the file system.
+ * TODO not implemented yet...
+ ******************************************************************************************
+ * @ cwd_xp   : extended pointer on the current working directory file descriptor.
+ * @ path     : pathname (absolute or relative to current directory).                     
+ * @ returns 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_rmdir( xptr_t   cwd_xp,
+                   char   * path );
+
+/****************************************************************************************** 
+ * This function makes the directory identified by <cwd_xp / path> arguments to become
+ * the working directory for the calling process.
+ ****************************************************************************************** 
+ * @ cwd_xp      : extended pointer on current directory file descriptor (relative path).
+ * @ path        : file pathname (absolute or relative to current directory).
+ * return 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_chdir( xptr_t   cwd_xp,
+                   char   * path );
+
+/****************************************************************************************** 
+ * This function change the access rigths for the file identified by the <cwd_xp / path>
+ * arguments. The new access rights are defined by the <mode> argument value.
+ ****************************************************************************************** 
+ * @ cwd_xp      : extended pointer on current directory file descriptor (relative path).
+ * @ path        : file pathname (absolute or relative to current directory).
+ * @ mode        : access rights new value.
+ * return 0 if success / -1 if error.
+ *****************************************************************************************/
+error_t vfs_chmod( xptr_t        cwd_xp,
+                   char        * path,
+                   uint32_t      mode );
+
+/****************************************************************************************** 
+ * This function creates a named FIFO file.
+ * TODO not implemented yet                                                          
+ ****************************************************************************************** 
+ * @ path        : FIFO pathname (absolute or relative to current directory).
+ * @ cwd_xp      : extended pointer on the current working directory file descriptor.
+ * @ mode        : access rights new value.
+ *****************************************************************************************/
+error_t vfs_mkfifo( xptr_t       cwd_xp,
+                    char       * path,
+                    uint32_t     mode );
+
+
+/*****************************************************************************************/
+/****************** Mapper access API ****************************************************/
+/*****************************************************************************************/
+
+/******************************************************************************************
+ * This function makes an I/O operation to move one page from VFS to a given mapper,
+ * in case of MISS on the mapper cache.
+ * Depending on the file system type, it calls the proper, FS specific function.
+ * It must be executed by a thread running in the cluster containing the mapper.
+ * The mapper pointer is obtained from the page descriptor.
+ * It takes the mapper lock before launching the IO operation.
+ ******************************************************************************************
+ * @ page   : local pointer on the page descriptor. 
+ * @ returns 0 if success / return EINVAL if it cannot access the external device.
+ *****************************************************************************************/
+error_t vfs_move_page_to_mapper( struct page_s * page );
+
+/******************************************************************************************
+ * This function makes an I/0 operation to move one page from a given mapper to VFS,
+ * when a dirty page in the mapper cache must be updated in the File System.
+ * Depending on the file system type, it calls the proper, FS specific function.
+ * It must be executed by a thread running in the cluster containing the mapper.
+ * The mapper pointer is obtained from the page descriptor.
+ * It takes the mapper lock before launching the IO operation.
+ * It does nothing if the page is not dirty. If the page is dirty, it clear the page
+ * dirty bit, and remove the page from the PPM dirty list. 
+ ******************************************************************************************
+ * @ page   : local pointer on the page descriptor. 
+ * @ returns 0 if success / return EINVAL if it cannot access the external device.
+ *****************************************************************************************/
+error_t vfs_move_page_from_mapper( struct page_s * page );       
+
+
+
+
+
+
+/////////////////////////////////////////////////////////////////////////////////////////// 
+// These typedef define the FS specific operations that must be implemented by any 
+// specific file system to be supported by the ALMOS_MKH VFS.
+// These typedef are not actually used, and are only defined for documentation
+/////////////////////////////////////////////////////////////////////////////////////////// 
+
+typedef error_t (fs_init_t)          ( xptr_t vfs_root_xp );
+
+typedef error_t (fs_inode_extend_t)  ( struct vfs_inode_s * inode,
+                                       void               * extend );
+ 
+typedef void    (fs_inode_release_t) ( struct vfs_inode_s * inode );
+
+typedef error_t (fs_write_page_t)    ( struct page_s * page );
+
+typedef error_t (fs_read_page_t)     ( struct page_s * page );
+
+
+
+
+
+
+
+
+/* deprecated [AG]
+
+typedef error_t (lookup_inode_t)  ( vfs_inode_t  * parent , 
+                                    vfs_dentry_t * dentry );
+
+typedef error_t (write_inode_t)   ( vfs_inode_t  * inode );
+
+typedef error_t (release_inode_t) ( vfs_inode_t  * inode );
+
+typedef error_t (unlink_inode_t)  ( vfs_inode_t  * parent,
+                                    vfs_dentry_t * dentry,
+                                    uint32_t       flags );
+
+typedef error_t (stat_inode_t)    ( vfs_inode_t  * inode );
+
+typedef error_t (trunc_inode_t)   ( vfs_inode_t  * inode );
+
+typedef error_t (delete_inode_t)  ( vfs_inode_t  * inode );
+
+typedef struct vfs_inode_op_s
+{
+        init_inode_t    * init;   
+        create_inode_t  * create;  
+        lookup_inode_t  * lookup;  
+        write_inode_t   * write; 
+        release_inode_t * release;
+        unlink_inode_t  * unlink; 
+        delete_inode_t  * delete; 
+        stat_inode_t    * stat;
+        trunc_inode_t   * trunc;    // change the size of a file 
+}
+vfs_inode_op_t;
+
+ ****************************************************************************************** 
+ * These typedef define the set of FS specific operations on a VFS DENTRY descriptor.
+ * They must be implemented by any specific file system to be supported by ALMOS_MKH.
+ * This code is not actually used, and is only defined for documentation
+ ******************************************************************************************
+
+
+typedef error_t (vfs_compare_dentry_t) ( char * first , char * second );
+
+typedef struct vfs_dentry_op_s
+{
+        vfs_compare_dentry_t * compare;
+}
+vfs_dentry_op_t;
+
+
+ ****************************************************************************************** 
+ * These typedef define the set of FS specific operations on FILE descriptors
+ * They must be implemented by any specific file system to be supported by ALMOS_MKH.
+ * This code is not actually used, and is only defined for documentation
+ ******************************************************************************************
+
+
+typedef error_t (open_file_t   ) ( vfs_file_t * file,
+                                   void       * extend );
+
+typedef error_t (read_file_t   ) ( vfs_file_t * file,
+                                   char       * buffer,
+                                   uint32_t     count );
+
+typedef error_t (write_file_t  ) ( vfs_file_t * file,
+                                   char       * buffer,
+                                   uint32_t     count );
+
+typedef error_t (lseek_file_t  ) ( vfs_file_t * file );
+
+typedef error_t (close_file_t  ) ( vfs_file_t * file );
+
+typedef error_t (release_file_t) ( vfs_file_t * file );
+
+typedef error_t (read_dir_t    ) ( vfs_file_t * file );
+
+typedef error_t (mmap_file_t   ) ( vfs_file_t    * file ,
+                                   struct vseg_s * vseg );
+
+typedef error_t (munmap_file_t ) ( vfs_file_t    * file,
+                                   struct vseg_s * vseg );
+
+typedef struct vfs_file_op_s
+{
+        open_file_t    * open;
+        read_file_t    * read;
+        write_file_t   * write;
+        lseek_file_t   * lseek;
+        read_dir_t     * readdir;
+        close_file_t   * close;
+        release_file_t * release;
+        mmap_file_t    * mmap;
+        munmap_file_t  * munmap;
+}
+vfs_file_op_t;
+
+*/
 
 #endif  /* _VFS_H_ */