Index: trunk/kernel/vfs/fatfs.c
===================================================================
--- trunk/kernel/vfs/fatfs.c	(revision 101)
+++ trunk/kernel/vfs/fatfs.c	(revision 188)
@@ -46,10 +46,17 @@
  
 //////////////////////////////////////////////////////////////////////////////////////////
-// FATFS specific functions : these functions cannot be called by the VFS 
-//////////////////////////////////////////////////////////////////////////////////////////
-
-//////////////////////////////////////////////////////////
-inline uint32_t fatfs_lba_from_cluster( fatfs_ctx_t * ctx,
-                                        uint32_t      cluster )
+//              FATFS private functions 
+//////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////////////////////////////////////////////
+// This function returns the LBA of the first sector of a FAT cluster.
+// This function can be called by any thread running in any cluster.
+//////////////////////////////////////////////////////////////////////////////////////////
+// @ ctx	  :	pointer on FATFS context.
+// @ cluster  :	cluster index in FATFS.
+// @ return the lba value.
+//////////////////////////////////////////////////////////////////////////////////////////
+static inline uint32_t fatfs_lba_from_cluster( fatfs_ctx_t * ctx,
+                                               uint32_t      cluster )
 {
     return (ctx->cluster_begin_lba + ((cluster - 2) << 3));
@@ -200,105 +207,38 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////
-//          The following functions are called by the VFS.
+// Generic API : the following functions are called by the kernel
+//               and must be defined by all supported file systems.
 ///////////////////////////////////////////////////////////////////////////////////////
 
-
-///////////////////
-xptr_t fatfs_init()
+///////////////////////////////
+fatfs_ctx_t * fatfs_ctx_alloc()
 {
     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()
+
+	return (fatfs_ctx_t *)kmem_alloc( &req );
+}
 
 //////////////////////////////////////////////
-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;
-    kmem_req_t  req;
+void fatfs_ctx_init( fatfs_ctx_t * fatfs_ctx )
+{
+    error_t       error;
+    kmem_req_t    req;
+    uint8_t     * buffer;
+
+    fatfs_dmsg("\n[INFO] %s : enters at cycle %d\n", 
+               __FUNCTION__ , hal_get_cycles() );
+
+    // allocate memory for FATFS context
+	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 );
+
+    nolock_assert( (fatfs_ctx != NULL) , __FUNCTION__ ,
+                   "cannot allocate memory for FATFS context\n" );
 
     // allocate a 512 bytes buffer to store the boot record
@@ -306,13 +246,14 @@
     req.flags   = AF_KERNEL | AF_ZERO;
 	buffer      = (uint8_t *)kmem_alloc( &req );
+
+    nolock_assert( (buffer != NULL) , __FUNCTION__ ,
+                   "cannot allocate memory for 512 bytes buffer\n" );
      
-    fatfs_dmsg("\n[INFO] %s : enters with buffer = %x\n", 
-               __FUNCTION__ , (intptr_t)buffer );
-
     // load the boot record from device
     // using a synchronous access to IOC device  
     error = dev_ioc_sync_read( buffer , 0 , 1 );
 
-    assert( (error == 0) , __FUNCTION__ , "cannot access boot record" );
+    nolock_assert( (error == 0) , __FUNCTION__ ,
+                   "cannot access boot record\n" );
 
 #if CONFIG_FATFS_DEBUG
@@ -336,25 +277,30 @@
     uint32_t sector_size = get_record_from_buffer( BPB_BYTSPERSEC , buffer , 1 );
 
-    assert( (sector_size == 512) , __FUNCTION__ , "sector size must be 512 bytes" );
+    nolock_assert( (sector_size == 512) , __FUNCTION__ ,
+                   "sector size must be 512 bytes\n" );
 
     // 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" );
+    nolock_assert( (nb_sectors == 8) , __FUNCTION__ ,
+                   "cluster size must be 8 sectors\n" );
 
     // 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" );
+    nolock_assert( (nb_fats == 1) , __FUNCTION__ ,
+                   "number of FAT copies must be 1\n" );
 
     // 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");
+    nolock_assert( ((fat_sectors & 0xF) == 0) , __FUNCTION__ ,
+                   "FAT not multiple of 16 sectors\n");
 
     // 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");
+    nolock_assert( (root_cluster == 2) , __FUNCTION__ ,
+                   "root cluster index must be  2\n");
 
     // get FAT lba from boot record
@@ -375,5 +321,5 @@
     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->sectors_per_cluster   = nb_sectors;
     fatfs_ctx->cluster_begin_lba     = fat_lba + fat_sectors;
     fatfs_ctx->root_dir_cluster      = 2;
@@ -396,77 +342,14 @@
                fatfs_ctx->fat_mapper_xp );
 
-    // 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 )
+
+/////////////////////////////////////////////////
+void fatfs_ctx_destroy( fatfs_ctx_t * fatfs_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.type = KMEM_FATFS_CTX;
     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 extension
-	req.type    = KMEM_FATFS_INODE;
-	req.size    = sizeof(fatfs_inode_t);
-    req.flags   = AF_KERNEL | AF_ZERO;
-	fatfs_inode = (fatfs_inode_t *)kmem_alloc( &req );
-
-    if( fatfs_inode == NULL ) return ENOMEM;
-
-    // link FATFS inode to VFS inode
-    vfs_inode->extend = fatfs_inode;
-
-    // initialise FATFS inode 
-    fatfs_inode->first_cluster = first_cluster;
- 
-    return 0;
-}
-
-///////////////////////////////////////////////////
-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;
-}
-
 
 ////////////////////////////////////////////////
@@ -484,12 +367,9 @@
     vfs_inode_t * vfs_inode = mapper->inode;
 
-    // get FATFS inode pointer for VFS inode
-    fatfs_inode_t * fatfs_inode = (fatfs_inode_t *)vfs_inode->extend;
-
-    // get first cluster index from FATFS inode
-    uint32_t  first_cluster = fatfs_inode->first_cluster;
-
-    // get FATFS context pointer from FATFS inode
-    fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)vfs_inode->ctx->extend;
+    // get first cluster index from VFS inode
+    uint32_t  first_cluster = (uint32_t)(intptr_t)vfs_inode->extend;
+
+    // get FATFS context pointer from VFS context
+    fatfs_ctx_t * fatfs_ctx = (fatfs_ctx_t *)fs_context[FS_TYPE_FATFS].extend;
 
     // get number of sectors 
