Changeset 568

Timestamp:

Oct 5, 2018, 12:02:49 AM (6 years ago)

Author:

alain

Message:

omplete restructuration of kernel locks.

Location:

trunk/kernel/fs

Files:

• devfs.c (modified) (18 diffs)
• devfs.h (modified) (1 diff)
• fatfs.c (modified) (5 diffs)
• ramfs.c (modified) (1 diff)
• vfs.c (modified) (58 diffs)
• vfs.h (modified) (5 diffs)

trunk/kernel/fs/devfs.c

@@ -52 +52 @@
 #endif
 
-///////////////////////////////
+/////////////////////////////////////
 devfs_ctx_t * devfs_ctx_alloc( void )
 {
@@ -91 +91 @@
 {
     error_t  error;
-
-#if DEBUG_DEVFS_INIT
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
-printk("\n[DBG] %s : thread %x enter at cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , cycle );
-#endif
 
     // creates DEVFS "dev" inode in cluster 0
@@ -110 +103 @@
     assert( (error == 0) , "cannot create <dev>\n" );
 
-#if( DEBUG_DEVFS_INIT & 1 )
-if( DEBUG_DEVFS_INIT < cycle )
-printk("\n[DBG] %s : created <dev> inode at cycle %d\n", __FUNCTION__, cycle );
+#if DEBUG_DEVFS_INIT
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <dev> inode / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid ,cycle );
 #endif
 
@@ -129 +124 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_DEVFS_INIT < cycle )
-printk("\n[DBG] %s : thread %x exit at cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , cycle );
+printk("\n[DBG] %s : thread %x in process %x created <external> inode / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid , cycle );
 #endif
 
@@ -147 +142 @@
     uint32_t      channel;
 
-#if DEBUG_DEVFS_INIT
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
-printk("\n[DBG] %s : thread %x enter at cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , cycle );
-#endif
-
-    // create "internal" directory linked to "dev"
+    // create "internal" directory 
     snprintf( node_name , 16 , "internal_%x" , local_cxy );
     vfs_add_child_in_parent( local_cxy,
@@ -163 +151 @@
                              NULL,
                              devfs_internal_inode_xp );
+#if DEBUG_DEVFS_INIT 
+uint32_t cycle = (uint32_t)hal_get_cycles();
+trdid_t  trdid = CURRENT_THREAD->trdid;
+pid_t    pid   = CURRENT_THREAD->process->pid;
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <%s> in cluster %x / cycle %d\n",
+__FUNCTION__, trdid, pid, node_name, local_cxy, cycle );
+#endif
 
     // create MMC chdev inode
@@ -176 +172 @@
                                  GET_PTR( chdev_xp ),
                                  &inode_xp );
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <mmc> inode in cluster %x\n",
+__FUNCTION__, trdid, pid, local_cxy, cycle );
+#endif
+
     }
 
@@ -192 +195 @@
                                      GET_PTR( chdev_xp ),
                                      &inode_xp );
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <dma[%d]> inode in cluster %x\n",
+__FUNCTION__, trdid, pid, channel, local_cxy, cycle );
+#endif
         }
     }
@@ -210 +219 @@
                                      GET_PTR( chdev_xp ),
                                      &inode_xp );
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <iob> inode in cluster %x\n",
+__FUNCTION__, trdid, pid, local_cxy, cycle );
+#endif
         }
     }
@@ -228 +243 @@
                                      GET_PTR( chdev_xp ),
                                      &inode_xp );
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <pic> inode in cluster %x\n",
+__FUNCTION__, trdid, pid, local_cxy, cycle );
+#endif
         }
     }
@@ -248 +269 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <txt_rx[%d]> inode in cluster %x\n",
+__FUNCTION__, trdid, pid, channel, local_cxy, cycle );
+#endif
             }
         }
@@ -269 +296 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
+#if DEBUG_DEVFS_INIT 
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <txt_tx[%d]> inode in cluster %x\n",
+__FUNCTION__, trdid, pid, channel, local_cxy, cycle );
+#endif
             }
         }
@@ -290 +323 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <ioc[%d]> inode in cluster %x\n",
+__FUNCTION__, trdid, pid, channel, local_cxy, cycle );
+#endif
             }
         }
@@ -295 +334 @@
 
     // create a FBF inode in each cluster containing a FBF chdev
-    for( channel = 0 ; channel < CONFIG_MAX_IOC_CHANNELS ; channel++ )
+    for( channel = 0 ; channel < CONFIG_MAX_FBF_CHANNELS ; channel++ )
     {
         chdev_xp = chdev_dir.fbf[channel];
@@ -311 +350 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <fbf[%d]> inode in cluster %x\n",
+__FUNCTION__, trdid, pid, channel, local_cxy, cycle );
+#endif
             }
         }
@@ -332 +377 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <nic_rx[%d]> inode in cluster %x\n",
+__FUNCTION__, trdid, pid, channel, local_cxy, cycle );
+#endif
             }
         }
@@ -353 +404 @@
                                          GET_PTR( chdev_xp ),
                                          &inode_xp );
-            }
-        }
-    }
-
-#if DEBUG_DEVFS_INIT
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_DEVFS_INIT < cycle )
-printk("\n[DBG] %s : thread %x exit at cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , cycle );
-#endif
-
+#if DEBUG_DEVFS_INIT
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_DEVFS_INIT < cycle )
+printk("\n[DBG] %s : thread %x in process %x created <nic_tx[%d]> inode in cluster %x\n",
+__FUNCTION__, trdid, pid, channel, local_cxy, cycle );
+#endif
+            }
+        }
+    }
 }  // end devfs_local_init()
 
@@ -408 +457 @@
 
     // get chdev functionnal type and channel
-    func    = hal_remote_lw( XPTR( chdev_cxy , &chdev_ptr->func ) );
-    channel = hal_remote_lw( XPTR( chdev_cxy , &chdev_ptr->channel ) );
+    func    = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->func ) );
+    channel = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->channel ) );
 
     // action depends on "func" and "to_buffer" 

trunk/kernel/fs/devfs.h

@@ -88 +88 @@
  * This function start to create the DEVFS subtree. 
  * This function should be called once in the cluster containing the VFS parent inode.
- * More precisely, it creates in cluster IO the "dev" and "external" DEVFS directories.
+ * More precisely, it creates in cluster 0 the "dev" and "external" DEVFS directories.
  * For each one, it creates the inode and link the associated dentry to parent inode.
  * The DEVFS root inode is linked to the VFS parent inode identified by <parent_inode_xp>.

trunk/kernel/fs/fatfs.c

@@ -44 +44 @@
 extern vfs_ctx_t          fs_context[FS_TYPES_NR];   // allocated in vfs.c file
 
-extern remote_barrier_t   global_barrier;            // allocated in kernel_init.c
- 
 //////////////////////////////////////////////////////////////////////////////////////////
 //              FATFS specific and static functions 
@@ -55 +53 @@
 //////////////////////////////////////////////////////////////////////////////////////////
 
-static inline
-int get_length(
-    int offset __attribute__((unused) ),
-    int length)
-{
-    return length;
-}
-
-static inline
-int get_offset(
-    int offset,
-    int length __attribute__((unused)) )
-{
-    return offset;
-}
+static inline int get_length( int offset __attribute__((unused)), int length ) { return length; }
+
+static inline int get_offset( int offset, int length __attribute__((unused)) ) { return offset; }
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -231 +217 @@
 
 //////////////////////////////////////////////////////////////////////////////////////////
-//              FATFS specific but extern functions 
+//              FATFS specific extern functions 
 //////////////////////////////////////////////////////////////////////////////////////////
 
@@ -338 +324 @@
 ///////////////////////////////////////////////////////////////////////////////////////
 
-///////////////////////////////
+/////////////////////////////////////
 fatfs_ctx_t * fatfs_ctx_alloc( void )
 {
@@ -778 +764 @@
         vfs_inode_type_t type = (is_dir) ? INODE_TYPE_DIR : INODE_TYPE_FILE;
 
-        hal_remote_sw( XPTR( child_cxy , &child_ptr->type   ) , type );
-        hal_remote_sw( XPTR( child_cxy , &child_ptr->size   ) , size );
-        hal_remote_sw( XPTR( child_cxy , &child_ptr->extend ) , cluster );
+        hal_remote_s32( XPTR( child_cxy , &child_ptr->type   ) , type );
+        hal_remote_s32( XPTR( child_cxy , &child_ptr->size   ) , size );
+        hal_remote_s32( XPTR( child_cxy , &child_ptr->extend ) , cluster );
 
 #if DEBUG_FATFS_LOAD

trunk/kernel/fs/ramfs.c

@@ -26 +26 @@
 #include <hal_kernel_types.h>
 #include <hal_special.h>
-#include <printk.h>
-#include <kmem.h>
 #include <vfs.h>
+#include <cluster.h>
 #include <ramfs.h>
 

trunk/kernel/fs/vfs.c

@@ -28 +28 @@
 #include <hal_atomic.h>
 #include <hal_special.h>
-#include <readlock.h>
-#include <spinlock.h>
 #include <printk.h>
 #include <list.h>
@@ -43 +41 @@
 #include <chdev.h>
 #include <process.h>
+#include <cluster.h>
 #include <vfs.h>
 #include <fatfs.h>
@@ -55 +54 @@
 
 extern vfs_ctx_t          fs_context[FS_TYPES_NR];    // allocated in kernel_init.c
-
 extern chdev_directory_t  chdev_dir;                  // allocated in kernel_init.c  
+extern char *             lock_type_str[];            // allocated in kernel_init.c
   
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -79 +78 @@
     vfs_ctx->extend         = extend;
 
-    spinlock_init( &vfs_ctx->lock );
+    busylock_init( &vfs_ctx->lock , LOCK_VFS_CTX );
 
     bitmap_init( vfs_ctx->bitmap , BITMAP_SIZE(CONFIG_VFS_MAX_INODES) ); 
@@ -89 +88 @@
 {
     // get lock on inum allocator
-    spinlock_lock( &ctx->lock );
+    busylock_acquire( &ctx->lock );
 
     // get lid from local inum allocator
@@ -97 +96 @@
     {
         // release lock
-        spinlock_unlock( &ctx->lock );
+        busylock_release( &ctx->lock );
 
         // return error
@@ -108 +107 @@
 
         // release lock
-        spinlock_unlock( &ctx->lock );
+        busylock_release( &ctx->lock );
 
         // return inum
@@ -160 +159 @@
 
 #if DEBUG_VFS_INODE_CREATE
-uint32_t cycle = (uint32_t)hal_get_cycles();
+char           name[CONFIG_VFS_MAX_NAME_LENGTH];
+uint32_t       cycle      = (uint32_t)hal_get_cycles();
+cxy_t          dentry_cxy = GET_CXY( dentry_xp );
+vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
+thread_t *     this       = CURRENT_THREAD;
+if( dentry_xp != XPTR_NULL ) hal_remote_strcpy( XPTR( local_cxy  , name ), 
+                                                XPTR( dentry_cxy , dentry_ptr->name ) );
+else                         strcpy( name , "/" );
 if( DEBUG_VFS_INODE_CREATE < cycle )
-printk("\n[DBG] %s : thread %x enter / dentry = %x in cluster %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, GET_PTR(dentry_xp), GET_CXY(dentry_xp), cycle );
+printk("\n[DBG] %s : thread %x in process %x enter for <%s> / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, name, cycle );
 #endif
  
@@ -232 +238 @@
     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 ) );
+    // initialize inode lock 
+    remote_rwlock_init( XPTR( local_cxy , &inode->data_lock ), LOCK_VFS_INODE );
+
+    // initialise lock protecting inode three traversal
+    remote_busylock_init( XPTR( local_cxy , &inode->main_lock ), LOCK_VFS_MAIN );
 
 #if DEBUG_VFS_INODE_CREATE
-cycle = (uint32_t)hal_get_cycles();
+cycle      = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_INODE_CREATE < cycle )
-printk("\n[DBG] %s : thread %x exit / inode = %x in cluster %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, inode, local_cxy, cycle );
+printk("\n[DBG] %s : thread %x in process %x exit for <%s> / inode [%x,%x] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, name, local_cxy, inode, cycle );
 #endif
  
@@ -346 +354 @@
 
     // get size
-    remote_rwlock_rd_lock( XPTR( cxy , &ptr->data_lock ) );
-    uint32_t size = hal_remote_lw( XPTR( cxy , &ptr->size ) );
-    remote_rwlock_rd_unlock( XPTR( cxy , &ptr->data_lock ) );
+    remote_rwlock_rd_acquire( XPTR( cxy , &ptr->data_lock ) );
+    uint32_t size = hal_remote_l32( XPTR( cxy , &ptr->size ) );
+    remote_rwlock_rd_release( XPTR( cxy , &ptr->data_lock ) );
     return size;
 }
@@ -361 +369 @@
 
     // set size
-    remote_rwlock_wr_unlock( XPTR( cxy , &ptr->data_lock ) );
-    hal_remote_sw( XPTR( cxy , &ptr->size ) , size );
-    remote_rwlock_wr_unlock( XPTR( cxy , &ptr->data_lock ) );
+    remote_rwlock_wr_release( XPTR( cxy , &ptr->data_lock ) );
+    hal_remote_s32( XPTR( cxy , &ptr->size ) , size );
+    remote_rwlock_wr_release( XPTR( cxy , &ptr->data_lock ) );
 }
 
@@ -374 +382 @@
 
     // release the main lock
-    remote_spinlock_unlock( XPTR( cxy , &ptr->main_lock ) );
+    remote_busylock_release( XPTR( cxy , &ptr->main_lock ) );
 }
 
@@ -385 +393 @@
 
     // get the main lock
-    remote_spinlock_lock( XPTR( cxy , &ptr->main_lock ) );
+    remote_busylock_acquire( XPTR( cxy , &ptr->main_lock ) );
 }
 
@@ -403 +411 @@
 
     // get parent dentry
-    dentry_xp  = hal_remote_lwd( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
+    dentry_xp  = hal_remote_l64( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
 
     // get local copy of name
@@ -475 +483 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_DENTRY_CREATE < cycle )
-printk("\n[DBG] %s : dentry initialised\n", __FUNCTION__ );
+printk("\n[DBG] %s : thread %x in process %x / dentry <%s> initialised / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, dentry->name, cycle );
 #endif
 
@@ -488 +497 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_DENTRY_CREATE < cycle )
-printk("\n[DBG] %s : dentry registerd in htab\n", __FUNCTION__ );
+printk("\n[DBG] %s : thread %x in process %x / dentry <%s> registered / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, dentry->name, cycle );
 #endif
 
@@ -544 +554 @@
     vfs_file_t  * file;
         kmem_req_t    req;
+
+#if DEBUG_VFS_FILE_CREATE
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_VFS_OPEN < cycle )
+printk("\n[DBG] %s : thread %x in process %x enter for inode %x in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, inode, local_cxy, cycle );
+#endif
 
     // allocate memory for new file descriptor
@@ -563 +580 @@
     file->mapper   = inode->mapper;
 
-    remote_rwlock_init( XPTR( local_cxy , &file->lock ) );
+    remote_rwlock_init( XPTR( local_cxy , &file->lock ), LOCK_VFS_FILE );
 
     *file_xp = XPTR( local_cxy , file );
 
-#if DEBUG_VFS_OPEN
-uint32_t cycle = (uint32_t)hal_get_cycles();
+#if DEBUG_VFS_FILE_CREATE
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_OPEN < cycle )
 printk("\n[DBG] %s : thread %x in process %x created file %x in cluster %x / cycle %d\n",
@@ -729 +746 @@
 
     // get inode type from remote file descriptor
-    inode_type = hal_remote_lw( XPTR( file_cxy , &file_ptr->type   ) );
+    inode_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type   ) );
    
     assert( (inode_type == INODE_TYPE_FILE) ,
@@ -735 +752 @@
 
     // get mapper pointer and file offset from file descriptor
-    file_offset = hal_remote_lw( XPTR( file_cxy , &file_ptr->offset ) );
+    file_offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
     mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
 
@@ -784 +801 @@
 
     // get inode type from remote file descriptor
-    inode_type = hal_remote_lw( XPTR( file_cxy , &file_ptr->type   ) );
+    inode_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type   ) );
    
     // action depends on inode type
@@ -790 +807 @@
     {
         // get mapper pointer and file offset from file descriptor
-        file_offset = hal_remote_lw( XPTR( file_cxy , &file_ptr->offset ) );
+        file_offset = hal_remote_l32( XPTR( file_cxy , &file_ptr->offset ) );
         mapper = (mapper_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->mapper ) );
 
@@ -848 +865 @@
 
     // take file descriptor lock
-    remote_rwlock_wr_lock( lock_xp );
+    remote_rwlock_wr_acquire( lock_xp );
 
     if      ( whence == SEEK_CUR )   // new = current + offset
     {
-        new = hal_remote_lw( offset_xp ) + offset;
+        new = hal_remote_l32( offset_xp ) + offset;
     }
     else if ( whence == SEEK_SET )   // new = offset
@@ -863 +880 @@
         inode_ptr = (vfs_inode_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
 
-        new = hal_remote_lw( XPTR( file_cxy , &inode_ptr->size ) ) + offset;
+        new = hal_remote_l32( XPTR( file_cxy , &inode_ptr->size ) ) + offset;
     }
     else
     {
         printk("\n[ERROR] in %s : illegal whence value\n", __FUNCTION__ );
-        remote_rwlock_wr_unlock( lock_xp );
+        remote_rwlock_wr_release( lock_xp );
         return -1;
     }
 
     // set new offset
-    hal_remote_sw( offset_xp , new );
+    hal_remote_s32( offset_xp , new );
 
     // release file descriptor lock
-    remote_rwlock_wr_unlock( lock_xp );
+    remote_rwlock_wr_release( lock_xp );
 
     // success
@@ -929 +946 @@
 
     // take the lock protecting the list of copies
-    remote_spinlock_lock( lock_xp );
+    remote_queuelock_acquire( lock_xp );
 
     XLIST_FOREACH( root_xp , iter_xp )
@@ -948 +965 @@
         xptr_t entry_xp         = XPTR( process_cxy , &process_ptr->fd_array.array[file_id] );
 
-// remote_rwlock_wr_lock( fd_array_lock_xp );
-
-        hal_remote_swd( entry_xp , XPTR_NULL );
+// remote_rwlock_wr_acquire( fd_array_lock_xp );
+
+        hal_remote_s64( entry_xp , XPTR_NULL );
         
-// remote_rwlock_wr_unlock( fd_array_lock_xp );
+// remote_rwlock_wr_release( fd_array_lock_xp );
 
         vfs_file_count_down( file_xp );
@@ -960 +977 @@
 
     // release the lock protecting the list of copies
-    remote_spinlock_unlock( lock_xp );
+    remote_queuelock_release( lock_xp );
 
 #if (DEBUG_VFS_CLOSE & 1) 
@@ -1064 +1081 @@
 
     // get inode type from remote file
-    inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) );
+    inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
 
     if( inode_type != INODE_TYPE_DIR )
@@ -1072 +1089 @@
     }
 
-    assert( false , "not implemented\n" );
+    // TODO implement this function using process CWD lock
+
+assert( false , "not implemented\n" );
+
     return 0;
 }
@@ -1101 +1121 @@
     
     // get inode type from remote inode
-    inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) );
+    inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
 
     
@@ -1123 +1143 @@
 //            Inode Tree functions
 //////////////////////////////////////////////////////////////////////////////////////////
-
 
 //////////////////////////////////////////////////////////////////////////
@@ -1172 +1191 @@
 
     // get inode type
-    inode_type = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->type ) );
+    inode_type = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->type ) );
 
     // get local pointer on associated mapper
@@ -1192 +1211 @@
 
         // get xhtab lock
-        xhtab_read_lock( children_xp );
+        xhtab_lock( children_xp );
 
         // get first dentry from xhtab
@@ -1204 +1223 @@
 
             // get extended pointer on child inode
-            child_inode_xp = hal_remote_lwd( XPTR( child_dentry_cxy,
+            child_inode_xp = hal_remote_l64( XPTR( child_dentry_cxy,
                                                    &child_dentry_ptr->child_xp ) );
 
@@ -1210 +1229 @@
             child_dentry_name_xp = XPTR( child_dentry_cxy , &child_dentry_ptr->name );
 
-            // recursive call on child inode
+            // recursive call on inode display
             vfs_recursive_display( child_inode_xp,
                                    child_dentry_name_xp,
@@ -1220 +1239 @@
 
         // release xhtab lock
-        xhtab_read_unlock( children_xp );
+        xhtab_unlock( children_xp );
     }
 }  // end vfs_recursive_display()
@@ -1231 +1250 @@
     cxy_t          dentry_cxy;
     vfs_dentry_t * dentry_ptr;
-    uint32_t       save_sr;
 
     // get target inode cluster and local pointer 
@@ -1238 +1256 @@
 
     // get extended pointer on associated dentry
-    dentry_xp   = hal_remote_lwd( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
+    dentry_xp   = hal_remote_l64( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
 
     // check if target inode is the File System root
@@ -1265 +1283 @@
 
     // get TXT0 lock in busy waiting mode
-    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    remote_busylock_acquire( lock_xp );
 
     // print header
@@ -1274 +1292 @@
 
     // release lock
-    remote_spinlock_unlock_busy( lock_xp , save_sr );
+    remote_busylock_release( lock_xp );
 
 }  // end vfs_display()
@@ -1298 +1316 @@
 
     // get inode access mode, UID, and GID
-    // TODO uint32_t  mode = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->mode ) );
-    uid_t     uid  = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->uid  ) );
-    gid_t     gid  = hal_remote_lw( XPTR( inode_cxy , &inode_ptr->gid  ) );
+    // TODO uint32_t  mode = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->mode ) );
+    uid_t     uid  = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->uid  ) );
+    gid_t     gid  = hal_remote_l32( XPTR( inode_cxy , &inode_ptr->gid  ) );
 
     // FIXME : me must use mode
@@ -1342 +1360 @@
 
     // return child inode
-    *child_xp = (xptr_t)hal_remote_lwd( XPTR( dentry_cxy , &dentry_ptr->child_xp ) );
+    *child_xp = (xptr_t)hal_remote_l64( XPTR( dentry_cxy , &dentry_ptr->child_xp ) );
     return true;
 
@@ -1496 +1514 @@
             parent_ptr = GET_PTR( parent_xp );
             ctx_ptr    = (vfs_ctx_t *)hal_remote_lpt( XPTR( parent_cxy,&parent_ptr->ctx ) );
-            fs_type    = hal_remote_lw( XPTR( parent_cxy , &ctx_ptr->type ) );
+            fs_type    = hal_remote_l32( XPTR( parent_cxy , &ctx_ptr->type ) );
 
             // select a cluster for missing inode
@@ -1545 +1563 @@
                 if( last && create && dir )  // new directory  => update inode type
                 {
-                     hal_remote_sw( XPTR( child_cxy, &child_ptr->type ), INODE_TYPE_DIR );
+                     hal_remote_s32( XPTR( child_cxy, &child_ptr->type ), INODE_TYPE_DIR );
 
 #if (DEBUG_VFS_LOOKUP & 1)
@@ -1555 +1573 @@
                 else if ( last && create )   // new file => update inode type
                 {
-                     hal_remote_sw( XPTR( child_cxy, &child_ptr->type ), INODE_TYPE_FILE );
+                     hal_remote_s32( XPTR( child_cxy, &child_ptr->type ), INODE_TYPE_FILE );
 
 #if (DEBUG_VFS_LOOKUP & 1)
@@ -1574 +1592 @@
             {
                 // load child mapper from device if child is a directory (prefetch)
-                if( hal_remote_lw( XPTR( child_cxy , &child_ptr->type ) ) == INODE_TYPE_DIR ) 
+                if( hal_remote_l32( XPTR( child_cxy , &child_ptr->type ) ) == INODE_TYPE_DIR ) 
                 {
                     if( child_cxy == local_cxy )
@@ -1700 +1718 @@
 
         // get extended pointer on parent dentry                
-        dentry_xp = (xptr_t)hal_remote_lwd( XPTR( inode_cxy , inode_ptr->parent_xp ) );
+        dentry_xp = (xptr_t)hal_remote_l64( XPTR( inode_cxy , inode_ptr->parent_xp ) );
 
         // get dentry cluster and local pointer
@@ -1707 +1725 @@
 
         // get dentry name length and pointer
-        length =  hal_remote_lw( XPTR( dentry_cxy , &dentry_ptr->length ) );
+        length =  hal_remote_l32( XPTR( dentry_cxy , &dentry_ptr->length ) );
         name   = (char *)hal_remote_lpt( XPTR( dentry_cxy , &dentry_ptr->name ) );
 
@@ -1727 +1745 @@
 
                 // get extended pointer on next inode
-        inode_xp = (xptr_t)hal_remote_lwd( XPTR( dentry_cxy , dentry_ptr->parent ) );
+        inode_xp = (xptr_t)hal_remote_l64( XPTR( dentry_cxy , dentry_ptr->parent ) );
     }
     while( (dentry_xp != XPTR_NULL) );
@@ -1757 +1775 @@
 #if DEBUG_VFS_ADD_CHILD
 uint32_t cycle = (uint32_t)hal_get_cycles();
+thread_t * this = CURRENT_THREAD; 
 if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[DBG] %s : thread %x enter for <%s> / child_cxy = %x / parent_cxy = %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, name,
+printk("\n[DBG] %s : thread %x in process %x enter for <%s>\n"
+"      child_cxy = %x / parent_cxy = %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, name,
 child_cxy, parent_cxy, (uint32_t)hal_get_cycles() );
 #endif
@@ -1770 +1790 @@
                                    parent_ptr,
                                    &dentry_xp );
-
-#if (DEBUG_VFS_ADD_CHILD & 1)
-if( (DEBUG_VFS_ADD_CHILD < cycle) && (error == 0) )
-printk("\n[DBG] %s : dentry <%s> created in cluster %x\n", __FUNCTION__, name, local_cxy );
-#endif
-
     }
     else                               // parent cluster is remote
@@ -1785 +1799 @@
                                       &dentry_xp,
                                       &error );
-
-#if (DEBUG_VFS_ADD_CHILD & 1)
-if( (DEBUG_VFS_ADD_CHILD < cycle) && (error == 0) )
-printk("\n[DBG] %s : dentry <%s> created in cluster %x\n", __FUNCTION__, name, parent_cxy );
-#endif
-
     }
                                       
@@ -1799 +1807 @@
         return ENOMEM;
     }
+
+#if(DEBUG_VFS_ADD_CHILD & 1)
+if( DEBUG_VFS_ADD_CHILD < cycle )
+printk("\n[DBG] %s : thread %x in process %x / dentry <%s> created in cluster %x\n",
+__FUNCTION__, this->trdid, this->process->pid, name, parent_cxy );
+#endif
 
     // 2. create child inode TODO : define attr / mode / uid / gid
@@ -1817 +1831 @@
                                   gid,
                                   &inode_xp );
-
-#if (DEBUG_VFS_ADD_CHILD & 1)
-if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[DBG] %s : inode <%x> created in cluster %x\n",
-__FUNCTION__ , GET_PTR(inode_xp) , local_cxy );
-#endif
-
     }
     else                              // child cluster is remote
@@ -1838 +1845 @@
                                      &inode_xp,
                                      &error );
-
-#if (DEBUG_VFS_ADD_CHILD & 1)
-if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[DBG] %s : inode <%s> created in cluster %x\n",
-__FUNCTION__ , GET_PTR(inode_xp) , child_cxy );
-#endif
-
     }
                                      
@@ -1858 +1858 @@
     }
 
+#if(DEBUG_VFS_ADD_CHILD & 1)
+if( DEBUG_VFS_ADD_CHILD < cycle )
+printk("\n[DBG] %s : thread %x in process %x / inode <%s> created in cluster %x\n",
+__FUNCTION__ , this->trdid, this->process->pid, name , child_cxy );
+#endif
+
     // 3. update extended pointer on inode in dentry
     cxy_t          dentry_cxy = GET_CXY( dentry_xp );
     vfs_dentry_t * dentry_ptr = GET_PTR( dentry_xp );
-    hal_remote_swd( XPTR( dentry_cxy , &dentry_ptr->child_xp ) , inode_xp );
+    hal_remote_s64( XPTR( dentry_cxy , &dentry_ptr->child_xp ) , inode_xp );
 
 #if DEBUG_VFS_ADD_CHILD
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_VFS_ADD_CHILD < cycle )
-printk("\n[DBG] %s : thread %x in process %x exit for <%s>\n",
-__FUNCTION__, CURRENT_THREAD, CURRENT_THREAD->process->pid, name );
+printk("\n[DBG] %s : thread %x in process %x exit for <%s> / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, name, (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1893 +1899 @@
 
     // get cluster and pointers of associated dentry
-    dentry_xp  = hal_remote_lwd( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
+    dentry_xp  = hal_remote_l64( XPTR( inode_cxy , &inode_ptr->parent_xp ) );
     dentry_cxy = GET_CXY( dentry_xp ); 
     dentry_ptr = GET_PTR( dentry_xp );
@@ -1958 +1964 @@
     if( fs_type == FS_TYPE_FATFS )
     {
-        rwlock_wr_lock( &mapper->lock );
+        // enter mapper in write mode
+        rwlock_wr_acquire( &mapper->lock );
+
+        // move page to mapper
         error = fatfs_mapper_move_page( page , to_mapper ); 
-        rwlock_wr_unlock( &mapper->lock );
+
+        // exit mapper in write mode
+        rwlock_wr_release( &mapper->lock );
     }
     else if( fs_type == FS_TYPE_RAMFS )

trunk/kernel/fs/vfs.h

@@ -30 +30 @@
 #include <hal_atomic.h>
 #include <remote_rwlock.h>
-#include <remote_spinlock.h>
-#include <spinlock.h>
+#include <remote_busylock.h>
+#include <busylock.h>
 #include <list.h>
 #include <xlist.h>
-#include <slist.h>
 #include <bits.h>
 #include <xhtab.h>
@@ -105 +104 @@
 
 /******************************************************************************************
- * 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.
+ * This structure defines a VFS context, that contains informations common to all inodes
+ * and dentries for a given file system. As it is declared as a global variable in the
+ * kdata segment, it is handled as private by each OS intance in a given cluster.
  *****************************************************************************************/
 
@@ -134 +133 @@
         uint32_t       cluster_size;             /*! cluster size on device (bytes)          */
         xptr_t         vfs_root_xp;              /*! extended pointer on VFS root inode      */
-    spinlock_t     lock;                     /*! lock protecting inum allocator          */
+    busylock_t     lock;                     /*! lock protecting inum allocator          */
     uint32_t       bitmap[BITMAP_SIZE(CONFIG_VFS_MAX_INODES)];  /* inum allocator        */
     void         * extend;                   /*! FS specific context extension           */
@@ -143 +142 @@
  * This structure define a VFS inode.
  * It contains an extended pointer on the parent dentry, and (for directory only)
- * an hash table xhtab refering all children dentries.
- * The <parent> inode is unique for a directory (not hard links for directories). 
+ * an hash table (xhtab) registering all children dentries.
+ * The <parent> inode is unique for a directory (no hard links for directories). 
  * For a file, the parent field points to the first dentry who created this inode.
- * Syncrhonisation:
- * - the main_lock (spinlock) is used during the inode tree traversal or for inode
- *   modification (add/remove children).
- * - the data_lock (rwlock) is used during read/write accesses to the data stored
- *   in the mapper. 
- * - the mapper lock (rwlock) is only used during the radix tree traversal to return
- *   the relevant page for read/write.
+ * Synchronisation:
+ * - the main_lock (remote_busylock) is used during the inode tree traversal,
+ *   or for inode modification (add/remove children).
+ * - the data_lock (remote_rwlock) is used during read/write accesses to the data
+ *   stored in the mapper. 
+ * - the mapper lock (remote rwlock) is only used during the radix tree traversal 
+ *   to return the relevant page for read/write.
  *****************************************************************************************/
 
@@ -195 +194 @@
         xhtab_t            children;         /*! embedded xhtab of children dentries         */
         remote_rwlock_t    data_lock;        /*! protect read/write to data and to size      */
-        remote_spinlock_t  main_lock;        /*! protect inode tree traversal and modifs     */
+        remote_busylock_t  main_lock;        /*! protect inode tree traversal and modifs     */
         list_entry_t       list;             /*! member of set of inodes in same cluster     */
         xlist_entry_t      wait_root;        /*! root of threads waiting on this inode       */