Changeset 564 for trunk/kernel/kern

Timestamp:

Oct 4, 2018, 11:47:36 PM (5 years ago)

Author:

alain

Message:

Complete restructuration of kernel locks.

Location:

trunk/kernel/kern

Files:

• chdev.c (modified) (29 diffs)
• chdev.h (modified) (4 diffs)
• cluster.c (modified) (37 diffs)
• cluster.h (modified) (8 diffs)
• cluster_info.c (deleted)
• cluster_info.h (deleted)
• cond_var.c (deleted)
• cond_var.h (deleted)
• core.c (modified) (1 diff)
• core.h (modified) (1 diff)
• dqdt.c (modified) (18 diffs)
• dqdt.h (modified) (3 diffs)
• kernel_init.c (modified) (55 diffs)
• mwmr.c (deleted)
• mwmr.h (deleted)
• printk.c (modified) (12 diffs)
• printk.h (modified) (7 diffs)
• process.c (modified) (94 diffs)
• process.h (modified) (13 diffs)
• rpc.c (modified) (106 diffs)
• rpc.h (modified) (3 diffs)
• scheduler.c (modified) (25 diffs)
• scheduler.h (modified) (7 diffs)
• signal.c (deleted)
• signal.h (deleted)
• thread.c (modified) (39 diffs)
• thread.h (modified) (11 diffs)
• time.c (deleted)

trunk/kernel/kern/chdev.c

@@ -37 +37 @@
 #include <devfs.h>
 
-
-extern chdev_directory_t    chdev_dir;   // allocated in kernel_init.c
+//////////////////////////////////////////////////////////////////////////////////////
+// Extern global variables
+//////////////////////////////////////////////////////////////////////////////////////
+
+extern chdev_directory_t    chdev_dir;         // allocated in kernel_init.c
+
 
 #if (DEBUG_SYS_READ & 1)
@@ -57 +61 @@
 char * chdev_func_str( uint32_t func_type ) 
 {
-  switch ( func_type ) {
+    switch ( func_type ) 
+    {
     case DEV_FUNC_RAM: return "RAM";
     case DEV_FUNC_ROM: return "ROM";
@@ -91 +96 @@
     if( chdev == NULL ) return NULL;
 
-    // initialize waiting threads queue and associated lock
-    remote_spinlock_init( XPTR( local_cxy , &chdev->wait_lock ) );
+    // initialize lock
+    remote_busylock_init( XPTR( local_cxy , &chdev->wait_lock ), LOCK_CHDEV_QUEUE );
+
+    // initialise waiting queue
     xlist_root_init( XPTR( local_cxy , &chdev->wait_root ) );
 
@@ -130 +137 @@
     core_t   * core_ptr;      // local pointer on core running the server thread
     uint32_t   server_lid;    // core running the server thread local index
-    xptr_t     lock_xp;       // extended pointer on lock protecting the chdev queue
+    xptr_t     lock_xp;       // extended pointer on lock protecting the chdev state
     uint32_t   save_sr;       // for critical section
 
@@ -147 +154 @@
     chdev_t * chdev_ptr = GET_PTR( chdev_xp );
 
+// check calling thread can yield
+assert( (this->busylocks == 0),
+"cannot yield : busylocks = %d\n", this->busylocks );
+
     // get local and extended pointers on server thread
     server_ptr = (thread_t *)hal_remote_lpt( XPTR( chdev_cxy , &chdev_ptr->server) );
@@ -155 +166 @@
 
     // get server core local index
-    server_lid = hal_remote_lw( XPTR( chdev_cxy , &core_ptr->lid ) );
+    server_lid = hal_remote_l32( XPTR( chdev_cxy , &core_ptr->lid ) );
 
 #if (DEBUG_CHDEV_CMD_RX || DEBUG_CHDEV_CMD_TX)
-bool_t is_rx = hal_remote_lw( XPTR( chdev_cxy , &chdev_ptr->is_rx ) );
+bool_t is_rx = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->is_rx ) );
 #endif
     
@@ -185 +196 @@
 
     // build extended pointer on lock protecting chdev waiting queue
-    lock_xp = XPTR( chdev_cxy , &chdev_ptr->wait_lock );
+    lock_xp            = XPTR( chdev_cxy , &chdev_ptr->wait_lock );
 
     // critical section for the following sequence: 
-    // (1) take the lock protecting waiting queue 
+    // (1) take the lock protecting the chdev state
     // (2) block the client thread
     // (3) unblock the server thread if required
@@ -200 +211 @@
     hal_disable_irq( &save_sr );
 
-    // take the lock protecting chdev waiting queue
-    remote_spinlock_lock( lock_xp );
+    // take the lock protecting chdev queue
+    remote_busylock_acquire( lock_xp );
 
     // block current thread
@@ -217 +228 @@
 
     // unblock server thread if required
-    if( hal_remote_lw( blocked_xp ) & THREAD_BLOCKED_IDLE )
+    if( hal_remote_l32( blocked_xp ) & THREAD_BLOCKED_IDLE )
     thread_unblock( server_xp , THREAD_BLOCKED_IDLE );
 
@@ -243 +254 @@
 #endif
  
-    // send IPI to core running the server thread when server != client
+    // send IPI to core running the server thread when server core != client core
     if( (server_lid != this->core->lid) || (local_cxy != chdev_cxy) )
     {
@@ -262 +273 @@
     }
  
-    // release lock
-    remote_spinlock_unlock( lock_xp );
+    // release lock protecting chdev queue
+    remote_busylock_release( lock_xp );
 
     // deschedule
-    assert( thread_can_yield() , "illegal sched_yield\n" );
     sched_yield("blocked on I/O");
 
@@ -308 +318 @@
     server = CURRENT_THREAD;
 
-    // get root and lock on command queue
+    // build extended pointer on root of client threads queue
     root_xp = XPTR( local_cxy , &chdev->wait_root );
+
+    // build extended pointer on lock protecting client threads queue
     lock_xp = XPTR( local_cxy , &chdev->wait_lock );
 
@@ -316 +328 @@
     while( 1 )
     {
+
+#if DEBUG_CHDEV_SERVER_RX
+uint32_t rx_cycle = (uint32_t)hal_get_cycles();
+if( (chdev->is_rx) && (DEBUG_CHDEV_SERVER_RX < rx_cycle) )
+printk("\n[DBG] %s : dev_thread %x start RX / cycle %d\n",
+__FUNCTION__ , server->trdid , rx_cycle );
+#endif
+
+#if DEBUG_CHDEV_SERVER_TX
+uint32_t tx_cycle = (uint32_t)hal_get_cycles();
+if( (chdev->is_rx == 0) && (DEBUG_CHDEV_SERVER_TX < tx_cycle) )
+printk("\n[DBG] %s : dev_thread %x start TX / cycle %d\n",
+__FUNCTION__ , server->trdid , tx_cycle );
+#endif
+
         // get the lock protecting the waiting queue
-        remote_spinlock_lock( lock_xp );
+        remote_busylock_acquire( lock_xp );
 
         // check waiting queue state
         if( xlist_is_empty( root_xp ) ) // waiting queue empty 
         {
+
+#if DEBUG_CHDEV_SERVER_RX
+rx_cycle = (uint32_t)hal_get_cycles();
+if( (chdev->is_rx) && (DEBUG_CHDEV_SERVER_RX < rx_cycle) )
+printk("\n[DBG] %s : dev_thread %x found RX queue empty => blocks / cycle %d\n",
+__FUNCTION__ , server->trdid , rx_cycle );
+#endif
+
+#if DEBUG_CHDEV_SERVER_TX
+tx_cycle = (uint32_t)hal_get_cycles();
+if( (chdev->is_rx == 0) && (DEBUG_CHDEV_SERVER_TX < tx_cycle) )
+printk("\n[DBG] %s : dev_thread %x found TX queue empty => blocks / cycle %d\n",
+__FUNCTION__ , server->trdid , tx_cycle );
+#endif
+
             // release lock 
-            remote_spinlock_unlock( lock_xp );
+            remote_busylock_release( lock_xp );
 
             // block 
             thread_block( XPTR( local_cxy , server ) , THREAD_BLOCKED_IDLE ); 
 
+// check server thread can yield
+assert( (server->busylocks == 0),
+"cannot yield : busylocks = %d\n", server->busylocks );
+
             // deschedule
-            assert( thread_can_yield() , "illegal sched_yield\n" );
             sched_yield("I/O queue empty");
         } 
@@ -335 +380 @@
         {
             // get extended pointer on first client thread
-            client_xp = XLIST_FIRST_ELEMENT( root_xp , thread_t , wait_list );
+            client_xp = XLIST_FIRST( root_xp , thread_t , wait_list );
 
             // get client thread cluster and local pointer
@@ -345 +390 @@
 
             // release lock 
-            remote_spinlock_unlock( lock_xp );
+            remote_busylock_release( lock_xp );
 
 #if DEBUG_CHDEV_SERVER_RX
-uint32_t rx_cycle = (uint32_t)hal_get_cycles();
+rx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx) && (DEBUG_CHDEV_SERVER_RX < rx_cycle) )
-printk("\n[DBG] %s : server_thread %x start RX / client %x / cycle %d\n",
-__FUNCTION__ , server , client_ptr , rx_cycle );
+printk("\n[DBG] %s : dev_thread %x for RX found client thread %x in process %x / cycle %d\n",
+__FUNCTION__, server->trdid ,client_ptr->trdid ,client_ptr->process->pid, rx_cycle );
 #endif
 
 #if DEBUG_CHDEV_SERVER_TX
-uint32_t tx_cycle = (uint32_t)hal_get_cycles();
+tx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx == 0) && (DEBUG_CHDEV_SERVER_TX < tx_cycle) )
-printk("\n[DBG] %s : server_thread %x start TX / client %x / cycle %d\n",
-__FUNCTION__ , server , client_ptr , tx_cycle );
+printk("\n[DBG] %s : dev_thread %x for TX found client thread %x in process %x / cycle %d\n",
+__FUNCTION__, server->trdid ,client_ptr->trdid ,client_ptr->process->pid, tx_cycle );
 #endif
 
@@ -378 +423 @@
 rx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx) && (DEBUG_CHDEV_SERVER_RX < rx_cycle) )
-printk("\n[DBG] %s : server_thread %x completes RX / client %x / cycle %d\n",
-__FUNCTION__ , server , client_ptr , rx_cycle );
+printk("\n[DBG] %s : dev_thread %x completes RX for client %x in process %x / cycle %d\n",
+__FUNCTION__, server->trdid, client_ptr->trdid, client_ptr->process->pid, rx_cycle );
 #endif
 
@@ -385 +430 @@
 tx_cycle = (uint32_t)hal_get_cycles();
 if( (chdev->is_rx == 0) && (DEBUG_CHDEV_SERVER_TX < tx_cycle) )
-printk("\n[DBG] %s : server_thread %x completes TX / client %x / cycle %d\n",
-__FUNCTION__ , server , client_ptr , tx_cycle );
+printk("\n[DBG] %s : dev_thread %x completes TX for client %x in process %x / cycle %d\n",
+__FUNCTION__, server->trdid, client_ptr->trdid, client_ptr->process->pid, tx_cycle );
 #endif
 
@@ -419 +464 @@
 
     // get inode type from file descriptor
-    inode_type = hal_remote_lw( XPTR( file_cxy , &file_ptr->type ) );
+    inode_type = hal_remote_l32( XPTR( file_cxy , &file_ptr->type ) );
     inode_ptr  = (vfs_inode_t *)hal_remote_lpt( XPTR( file_cxy , &file_ptr->inode ) );
 
@@ -432 +477 @@
 }  // end chdev_from_file()
 
-////////////////////////
+//////////////////////////////
 void chdev_dir_display( void )
 {
@@ -439 +484 @@
     chdev_t * ptr;
     uint32_t  base;
-    reg_t     save_sr;
 
     // get pointers on TXT0 chdev
@@ -446 +490 @@
     chdev_t * txt0_ptr = GET_PTR( txt0_xp );
 
-    // get extended pointer on remote TXT0 chdev lock
+    // get extended pointer on TXT0 lock
     xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
 
-    // get TXT0 lock in busy waiting mode
-    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    // get TXT0 lock 
+    remote_busylock_acquire( lock_xp );
 
     // header
@@ -456 +500 @@
 
     // IOB
-    if (chdev_dir.iob != NULL )
+    if (chdev_dir.iob != XPTR_NULL )
     {
         cxy  = GET_CXY( chdev_dir.iob );
         ptr  = GET_PTR( chdev_dir.iob );
-        base = (uint32_t)hal_remote_lwd( XPTR( cxy , &ptr->base ) );
+        base = (uint32_t)hal_remote_l64( XPTR( cxy , &ptr->base ) );
         nolock_printk("  - iob       : cxy = %X / ptr = %X / base = %X\n", cxy, ptr, base);
     }
@@ -467 +511 @@
     cxy  = GET_CXY( chdev_dir.pic );
     ptr  = GET_PTR( chdev_dir.pic );
-    base = (uint32_t)hal_remote_lwd( XPTR( cxy , &ptr->base ) );
+    base = (uint32_t)hal_remote_l64( XPTR( cxy , &ptr->base ) );
     nolock_printk("  - pic       : cxy = %X / ptr = %X / base = %X\n", cxy, ptr, base);
 
@@ -475 +519 @@
         cxy = GET_CXY( chdev_dir.txt_rx[i] );
         ptr = GET_PTR( chdev_dir.txt_rx[i] );
-        base = (uint32_t)hal_remote_lwd( XPTR( cxy , &ptr->base ) );
+        base = (uint32_t)hal_remote_l64( XPTR( cxy , &ptr->base ) );
         nolock_printk("  - txt_rx[%d] : cxy = %X / ptr = %X / base = %X\n", i, cxy, ptr, base);
 
         cxy = GET_CXY( chdev_dir.txt_tx[i] );
         ptr = GET_PTR( chdev_dir.txt_tx[i] );
-        base = (uint32_t)hal_remote_lwd( XPTR( cxy , &ptr->base ) );
+        base = (uint32_t)hal_remote_l64( XPTR( cxy , &ptr->base ) );
         nolock_printk("  - txt_tx[%d] : cxy = %X / ptr = %X / base = %X\n", i, cxy, ptr, base);
     }
@@ -489 +533 @@
         cxy = GET_CXY( chdev_dir.ioc[i] );
         ptr = GET_PTR( chdev_dir.ioc[i] );
-        base = (uint32_t)hal_remote_lwd( XPTR( cxy , &ptr->base ) );
+        base = (uint32_t)hal_remote_l64( XPTR( cxy , &ptr->base ) );
         nolock_printk("  - ioc[%d]    : cxy = %X / ptr = %X / base = %X\n", i, cxy, ptr, base);
     }
@@ -498 +542 @@
         cxy  = GET_CXY( chdev_dir.fbf[i] );
         ptr  = GET_PTR( chdev_dir.fbf[i] );
-        base = (uint32_t)hal_remote_lwd( XPTR( cxy , &ptr->base ) );
+        base = (uint32_t)hal_remote_l64( XPTR( cxy , &ptr->base ) );
         nolock_printk("  - fbf[%d]    : cxy = %X / ptr = %X / base = %X\n", i, cxy, ptr, base);
     }
@@ -507 +551 @@
         cxy = GET_CXY( chdev_dir.nic_rx[i] );
         ptr = GET_PTR( chdev_dir.nic_rx[i] );
-        base = (uint32_t)hal_remote_lwd( XPTR( cxy , &ptr->base ) );
+        base = (uint32_t)hal_remote_l64( XPTR( cxy , &ptr->base ) );
         nolock_printk("  - nic_rx[%d] : cxy = %X / ptr = %X / base = %X\n", i, cxy, ptr, base);
 
         cxy = GET_CXY( chdev_dir.nic_tx[i] );
         ptr = GET_PTR( chdev_dir.nic_tx[i] );
-        base = (uint32_t)hal_remote_lwd( XPTR( cxy , &ptr->base ) );
+        base = (uint32_t)hal_remote_l64( XPTR( cxy , &ptr->base ) );
         nolock_printk("  - nic_tx[%d] : cxy = %X / ptr = %X / base = %X\n", i, cxy, ptr, base);
     }
 
     // release lock
-    remote_spinlock_unlock_busy( lock_xp , save_sr );
+    remote_busylock_release( lock_xp );
 
 }  // end chdev_dir_display()
@@ -546 +590 @@
     hal_remote_strcpy( XPTR( local_cxy , name ), XPTR( chdev_cxy , chdev_ptr->name ) );
 
+    // get pointers on TXT0 chdev
+    xptr_t    txt0_xp  = chdev_dir.txt_tx[0];
+    cxy_t     txt0_cxy = GET_CXY( txt0_xp );
+    chdev_t * txt0_ptr = GET_PTR( txt0_xp );
+
+    // get extended pointer on TXT0 lock
+    xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+
+    // get TXT0 lock 
+    remote_busylock_acquire( lock_xp );
+
     // check queue empty
     if( xlist_is_empty( root_xp ) )
     {
-        printk("\n***** Waiting queue empty for chdev %s\n", name ); 
+        nolock_printk("\n***** Waiting queue empty for chdev %s\n", name ); 
     }
     else
     {
-        printk("\n***** Waiting queue for chdev %s\n", name ); 
+        nolock_printk("\n***** Waiting queue for chdev %s\n", name ); 
 
         // scan the waiting queue
@@ -561 +616 @@
             thread_cxy = GET_CXY( thread_xp );
             thread_ptr = GET_PTR( thread_xp );
-            trdid      = hal_remote_lw ( XPTR( thread_cxy , &thread_ptr->trdid   ) );
+            trdid      = hal_remote_l32 ( XPTR( thread_cxy , &thread_ptr->trdid   ) );
             process    = hal_remote_lpt( XPTR( thread_cxy , &thread_ptr->process ) );
-                        pid        = hal_remote_lw ( XPTR( thread_cxy , &process->pid        ) );
-
-            printk("- thread %X / cluster %X / trdid %X / pid %X\n",
+                        pid        = hal_remote_l32 ( XPTR( thread_cxy , &process->pid        ) );
+
+            nolock_printk("- thread %X / cluster %X / trdid %X / pid %X\n",
             thread_ptr, thread_cxy, trdid, pid );
         }
     }
+
+    // release TXT0 lock 
+    remote_busylock_release( lock_xp );
+
 }  // end chdev_queue_display()
 

trunk/kernel/kern/chdev.h

@@ -28 +28 @@
 #include <hal_kernel_types.h>
 #include <xlist.h>
-#include <remote_spinlock.h>
+#include <remote_busylock.h>
 #include <dev_iob.h>
 #include <dev_ioc.h>
@@ -43 +43 @@
  * ALMOS-MKH supports multi-channels peripherals, and defines one separated chdev 
  * descriptor for each channel (and for each RX/TX direction for the NIC and TXT devices).
- * Each chdev contains a waiting queue, registering the "client threads" requests,
+ * Each chdev contains a trans-clusters waiting queue, registering the "client threads",
  * and an associated "server thread", handling these requests.
  * These descriptors are physically distributed on all clusters to minimize contention.
@@ -116 +116 @@
  * of client threads is associated to each chdev descriptor (not for ICU, PIC, IOB).
  * For each device type ***, the specific extension is defined in the "dev_***.h" file.
+ *
+ * NOTE : For most chdevs, the busylock is used to protect the waiting queue changes,
+ *        when a thread register in this queue, or is removed after service.
+ *        This busylock is also used to protect direct access to the kernel TXT0 terminal
+ *        (without using the server thread).
  *****************************************************************************************/
 
@@ -136 +141 @@
     uint32_t             irq_id;      /*! associated IRQ index in local ICU              */
 
-        remote_spinlock_t    wait_lock;   /*! lock protecting exclusive access to queue      */
-    xlist_entry_t        wait_root;   /*! root of waiting threads queue                  */
+        xlist_entry_t        wait_root;   /*! root of client threads waiting queue           */
+    remote_busylock_t    wait_lock;   /*! lock protecting waiting queue                  */
 
     union

trunk/kernel/kern/cluster.c

@@ -29 +29 @@
 #include <hal_special.h>
 #include <hal_ppm.h>
+#include <hal_macros.h>
 #include <remote_fifo.h>
 #include <printk.h>
 #include <errno.h>
-#include <spinlock.h>
+#include <queuelock.h>
 #include <core.h>
 #include <chdev.h>
@@ -45 +46 @@
 #include <process.h>
 #include <dqdt.h>
-#include <cluster_info.h>
 
 /////////////////////////////////////////////////////////////////////////////////////
@@ -51 +51 @@
 /////////////////////////////////////////////////////////////////////////////////////
 
-extern process_t           process_zero;     // allocated in kernel_init.c file
-extern chdev_directory_t   chdev_dir;        // allocated in kernel_init.c file
-
-///////////////////////////////////////////////n
-error_t cluster_init( struct boot_info_s * info )
-{
-    error_t         error;
-    lpid_t          lpid;     // local process_index
-    lid_t           lid;      // local core index
-    uint32_t        i;        // index in loop on external peripherals
+extern process_t           process_zero;     // allocated in kernel_init.c
+extern chdev_directory_t   chdev_dir;        // allocated in kernel_init.c
+
+
+
+///////////////////////////////////////////////////
+void cluster_info_init( struct boot_info_s * info )
+{
     boot_device_t * dev;      // pointer on external peripheral
     uint32_t        func;     // external peripheral functionnal type
+    uint32_t        x;
+    uint32_t        y;
+    uint32_t        i;   
 
         cluster_t * cluster = LOCAL_CLUSTER;
@@ -75 +76 @@
 
     // initialize the cluster_info[][] array
-    int x;
-    int y;
-    for (x = 0; x < CONFIG_MAX_CLUSTERS_X; x++) {
-        for (y = 0; y < CONFIG_MAX_CLUSTERS_Y;y++) {
+    for (x = 0; x < CONFIG_MAX_CLUSTERS_X; x++) 
+    {
+        for (y = 0; y < CONFIG_MAX_CLUSTERS_Y;y++) 
+        {
             cluster->cluster_info[x][y] = info->cluster_info[x][y];
         }
     }
+
     // initialize external peripherals channels
     for( i = 0 ; i < info->ext_dev_nr ; i++ )
@@ -93 +95 @@
     }
 
-    // initialize cluster local parameters
-        cluster->cores_nr        = info->cores_nr;
+    // initialize number of cores
+        cluster->cores_nr  = info->cores_nr;
+
+}  // end cluster_info_init()
+
+/////////////////////////////////////////////////////////
+error_t cluster_manager_init( struct boot_info_s * info )
+{
+    error_t         error;
+    lpid_t          lpid;     // local process_index
+    lid_t           lid;      // local core index
+
+        cluster_t * cluster = LOCAL_CLUSTER;
 
     // initialize the lock protecting the embedded kcm allocator
-        spinlock_init( &cluster->kcm_lock );
+        busylock_init( &cluster->kcm_lock , LOCK_CLUSTER_KCM );
 
 #if DEBUG_CLUSTER_INIT
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_CLUSTER_INIT < cycle )
-printk("\n[DBG] %s : thread %x enters for cluster %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , local_cxy , cycle );
+printk("\n[DBG] %s : thread %x in process %x enters for cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, local_cxy , cycle );
 #endif
 
     // initialises DQDT
     cluster->dqdt_root_level = dqdt_init( info->x_size,
-                                          info->y_size,
-                                          info->y_width ) - 1;
+                                          info->y_size ) - 1;
+
+#if( DEBUG_CLUSTER_INIT & 1 )
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_CLUSTER_INIT < cycle )
+printk("\n[DBG] %s : DQDT initialized in cluster %x / cycle %d\n",
+__FUNCTION__ , local_cxy , cycle );
+#endif
 
     // initialises embedded PPM
@@ -166 +185 @@
         for( lid = 0 ; lid < cluster->cores_nr; lid++ )
     {
-            local_fifo_init( &cluster->rpc_fifo[lid] );
+            remote_fifo_init( &cluster->rpc_fifo[lid] );
         cluster->rpc_threads[lid] = 0;
     }
@@ -178 +197 @@
 
     // initialise pref_tbl[] in process manager
-        spinlock_init( &cluster->pmgr.pref_lock );
+        queuelock_init( &cluster->pmgr.pref_lock , LOCK_CLUSTER_PREFTBL );
     cluster->pmgr.pref_nr = 0;
     cluster->pmgr.pref_tbl[0] = XPTR( local_cxy , &process_zero );
@@ -187 +206 @@
 
     // initialise local_list in process manager
-        remote_spinlock_init( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
     xlist_root_init( XPTR( local_cxy , &cluster->pmgr.local_root ) );
     cluster->pmgr.local_nr = 0;
+        remote_queuelock_init( XPTR( local_cxy , &cluster->pmgr.local_lock ) ,
+                           LOCK_CLUSTER_LOCALS );
 
     // initialise copies_lists in process manager
     for( lpid = 0 ; lpid < CONFIG_MAX_PROCESS_PER_CLUSTER ; lpid++ )
     {
-            remote_spinlock_init( XPTR( local_cxy , &cluster->pmgr.copies_lock[lpid] ) );
         cluster->pmgr.copies_nr[lpid] = 0;
         xlist_root_init( XPTR( local_cxy , &cluster->pmgr.copies_root[lpid] ) );
+            remote_queuelock_init( XPTR( local_cxy , &cluster->pmgr.copies_lock[lpid] ),
+                               LOCK_CLUSTER_COPIES );
     }
 
@@ -202 +223 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_CLUSTER_INIT < cycle )
-printk("\n[DBG] %s , thread %x exit for cluster %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , local_cxy , cycle );
+printk("\n[DBG] %s : thread %x in process %x exit for cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid , local_cxy , cycle );
 #endif
 
@@ -209 +230 @@
 
         return 0;
-} // end cluster_init()
-
-/////////////////////////////////
+} // end cluster_manager_init()
+
+///////////////////////////////////
 cxy_t cluster_random_select( void )
 {
-    uint32_t  x_size;
-    uint32_t  y_size;
-    uint32_t  y_width;
     uint32_t  index;
-    uint32_t  x;
+    uint32_t  x;    
     uint32_t  y;
-
-    do {
-        x_size     = LOCAL_CLUSTER->x_size;
-        y_size     = LOCAL_CLUSTER->y_size;
-        y_width   = LOCAL_CLUSTER->y_width;
+    cxy_t     cxy;
+
+    uint32_t  x_size    = LOCAL_CLUSTER->x_size;
+    uint32_t  y_size    = LOCAL_CLUSTER->y_size;
+
+    do 
+    {
         index     = ( hal_get_cycles() + hal_get_gid() ) % (x_size * y_size);
         x         = index / y_size;
         y         = index % y_size;
-    } while ( cluster_info_is_active( LOCAL_CLUSTER->cluster_info[x][y] ) == 0 );
-
-    return (x<<y_width) + y;
+        cxy       = HAL_CXY_FROM_XY( x , y );
+    }
+    while ( cluster_is_active( cxy ) == false );
+
+    return ( cxy );
 }
 
@@ -236 +258 @@
 bool_t cluster_is_undefined( cxy_t cxy )
 {
-    cluster_t * cluster = LOCAL_CLUSTER;
-
-    uint32_t y_width = cluster->y_width;
-
-    uint32_t x = cxy >> y_width;
-    uint32_t y = cxy & ((1<<y_width)-1);
-
-    if( x >= cluster->x_size ) return true;
-    if( y >= cluster->y_size ) return true;
+    uint32_t  x_size = LOCAL_CLUSTER->x_size;
+    uint32_t  y_size = LOCAL_CLUSTER->y_size;
+
+    uint32_t  x      = HAL_X_FROM_CXY( cxy );
+    uint32_t  y      = HAL_Y_FROM_CXY( cxy );
+
+    if( x >= x_size ) return true;
+    if( y >= y_size ) return true;
 
     return false;
+}
+
+//////////////////////////////////////
+bool_t cluster_is_active ( cxy_t cxy )
+{
+    uint32_t x = HAL_X_FROM_CXY( cxy );
+    uint32_t y = HAL_Y_FROM_CXY( cxy );
+
+    return ( LOCAL_CLUSTER->cluster_info[x][y] != 0 );
 }
 
@@ -304 +334 @@
 
     // take the lock protecting the list of processes
-    remote_spinlock_lock( lock_xp );
+    remote_queuelock_acquire( lock_xp );
 
     // scan list of processes
@@ -320 +350 @@
 
     // release the lock protecting the list of processes
-    remote_spinlock_unlock( lock_xp );
+    remote_queuelock_release( lock_xp );
 
     // return extended pointer on process descriptor in owner cluster
@@ -350 +380 @@
 
     // take the lock protecting the list of processes
-    remote_spinlock_lock( lock_xp );
+    remote_queuelock_acquire( lock_xp );
 
     // scan list of processes in owner cluster
@@ -358 +388 @@
         current_xp  = XLIST_ELEMENT( iter_xp , process_t , local_list );
         current_ptr = GET_PTR( current_xp );
-        current_pid = hal_remote_lw( XPTR( owner_cxy , &current_ptr->pid ) );
+        current_pid = hal_remote_l32( XPTR( owner_cxy , &current_ptr->pid ) );
 
         if( current_pid == pid )
@@ -368 +398 @@
 
     // release the lock protecting the list of processes
-    remote_spinlock_unlock( lock_xp );
+    remote_queuelock_release( lock_xp );
 
     // return extended pointer on process descriptor in owner cluster
@@ -397 +427 @@
     else                              // use a remote_lwd to access owner cluster
     {
-        ref_xp = (xptr_t)hal_remote_lwd( XPTR( owner_cxy , &cluster->pmgr.pref_tbl[lpid] ) );
+        ref_xp = (xptr_t)hal_remote_l64( XPTR( owner_cxy , &cluster->pmgr.pref_tbl[lpid] ) );
     }
 
@@ -419 +449 @@
     pmgr_t    * pm         = &LOCAL_CLUSTER->pmgr;
 
-    // get the process manager lock
-    spinlock_lock( &pm->pref_lock );
+    // get the lock protecting pref_tbl
+    queuelock_acquire( &pm->pref_lock );
 
     // search an empty slot
@@ -443 +473 @@
 
         // release the processs_manager lock
-        spinlock_unlock( &pm->pref_lock );
+        queuelock_release( &pm->pref_lock );
 
         return 0;
@@ -449 +479 @@
     else
     {
-        // release the processs_manager lock
-        spinlock_unlock( &pm->pref_lock );
-
-        return -1;
+        // release the lock
+        queuelock_release( &pm->pref_lock );
+
+        return 0xFFFFFFFF;
     }
 
@@ -488 +518 @@
     "local_cluster %x !=  owner_cluster %x" , local_cxy , owner_cxy );
 
-    // get the process manager lock
-    spinlock_lock( &pm->pref_lock );
+    // get the lock protecting pref_tbl
+    queuelock_acquire( &pm->pref_lock );
 
     // remove process from pref_tbl[]
@@ -496 +526 @@
 
     // release the processs_manager lock
-    spinlock_unlock( &pm->pref_lock );
+    queuelock_release( &pm->pref_lock );
 
 #if DEBUG_CLUSTER_PID_RELEASE
@@ -538 +568 @@
 void cluster_process_local_link( process_t * process )
 {
-    reg_t    save_sr;
-
     pmgr_t * pm = &LOCAL_CLUSTER->pmgr;
 
@@ -546 +574 @@
     xptr_t lock_xp = XPTR( local_cxy , &pm->local_lock );
 
-    // get lock protecting the process manager local list
-    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    // get lock protecting the local list
+    remote_queuelock_acquire( lock_xp );
 
     // register process in local list
@@ -553 +581 @@
     pm->local_nr++;
 
-    // release lock protecting the process manager local list
-    remote_spinlock_unlock_busy( lock_xp , save_sr );
+    // release lock protecting the local list
+    remote_queuelock_release( lock_xp );
 }
 
@@ -560 +588 @@
 void cluster_process_local_unlink( process_t * process )
 {
-    reg_t save_sr;
-
     pmgr_t * pm = &LOCAL_CLUSTER->pmgr;
 
@@ -567 +593 @@
     xptr_t lock_xp = XPTR( local_cxy , &pm->local_lock );
 
-    // get lock protecting the process manager local list
-    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    // get lock protecting the local list
+    remote_queuelock_acquire( lock_xp );
 
     // remove process from local list
@@ -574 +600 @@
     pm->local_nr--;
 
-    // release lock protecting the process manager local list
-    remote_spinlock_unlock_busy( lock_xp , save_sr );
+    // release lock protecting the local list
+    remote_queuelock_release( lock_xp );
 }
 
@@ -581 +607 @@
 void cluster_process_copies_link( process_t * process )
 {
-    reg_t    irq_state;
     pmgr_t * pm = &LOCAL_CLUSTER->pmgr;
 
@@ -606 +631 @@
 
     // get lock protecting copies_list[lpid]
-    remote_spinlock_lock_busy( copies_lock , &irq_state );
+    remote_queuelock_acquire( copies_lock );
 
     // add copy to copies_list
@@ -613 +638 @@
 
     // release lock protecting copies_list[lpid]
-    remote_spinlock_unlock_busy( copies_lock , irq_state );
+    remote_queuelock_release( copies_lock );
 
 #if DEBUG_CLUSTER_PROCESS_COPIES
@@ -627 +652 @@
 void cluster_process_copies_unlink( process_t * process )
 {
-    uint32_t irq_state;
     pmgr_t * pm = &LOCAL_CLUSTER->pmgr;
 
@@ -649 +673 @@
 
     // get lock protecting copies_list[lpid]
-    remote_spinlock_lock_busy( copies_lock , &irq_state );
+    remote_queuelock_acquire( copies_lock );
 
     // remove copy from copies_list
@@ -656 +680 @@
 
     // release lock protecting copies_list[lpid]
-    remote_spinlock_unlock_busy( copies_lock , irq_state );
+    remote_queuelock_release( copies_lock );
 
 #if DEBUG_CLUSTER_PROCESS_COPIES
@@ -678 +702 @@
     xptr_t        txt0_xp;
     xptr_t        txt0_lock_xp;
-    reg_t         txt0_save_sr;     // save SR to take TXT0 lock in busy mode      
 
     assert( (cluster_is_undefined( cxy ) == false),
@@ -696 +719 @@
 
     // get lock on local process list 
-    remote_spinlock_lock( lock_xp );
-
-    // get TXT0 lock in busy waiting mode
-    remote_spinlock_lock_busy( txt0_lock_xp , &txt0_save_sr );
+    remote_queuelock_acquire( lock_xp );
+
+    // get TXT0 lock
+    remote_busylock_acquire( txt0_lock_xp );
      
     // display header
@@ -712 +735 @@
     }
 
-    // release TXT0 lock in busy waiting mode
-    remote_spinlock_unlock_busy( txt0_lock_xp , txt0_save_sr );
+    // release TXT0 lock 
+    remote_busylock_release( txt0_lock_xp );
 
     // release lock on local process list
-    remote_spinlock_unlock( lock_xp );
+    remote_queuelock_release( lock_xp );
 
 }  // end cluster_processes_display() 

trunk/kernel/kern/cluster.h

@@ -30 +30 @@
 #include <hal_kernel_types.h>
 #include <bits.h>
-#include <spinlock.h>
-#include <readlock.h>
-#include <remote_barrier.h>
+#include <queuelock.h>
+#include <remote_queuelock.h>
 #include <list.h>
 #include <xlist.h>
@@ -68 +67 @@
  * 2) The local_root is the root of the local list of all process descriptors in cluster K.
  *    A process descriptor P is present in K, as soon as P has a thread in cluster K.
+ *    We use an xlist, because this list can be traversed by remote threads.
  *
  * 3) The copies_root[] array is indexed by lpid. There is one entry per owned process,
  *    and each each entry contains the root of the xlist of copies for this process.
+ $    We use an xlist, because process copies are distributed in all clusters. 
  ******************************************************************************************/
 
 typedef struct process_manager_s
 {
-        xptr_t            pref_tbl[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! reference  process   */
-        spinlock_t        pref_lock;              /*! lock protecting lpid allocation/release */
-    uint32_t          pref_nr;                /*! number of processes owned by cluster    */
-
-    xlist_entry_t     local_root;             /*! root of list of process in cluster      */
-    remote_spinlock_t local_lock;             /*! lock protecting access to local list    */
-    uint32_t          local_nr;               /*! number of process in cluster            */
-
-    xlist_entry_t     copies_root[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! roots of lists    */
-    remote_spinlock_t copies_lock[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! one lock per list */
-    uint32_t          copies_nr[CONFIG_MAX_PROCESS_PER_CLUSTER];    /*! number of copies  */
+        xptr_t             pref_tbl[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! owned  processes    */
+        queuelock_t        pref_lock;              /*! lock protecting pref_tbl               */
+    uint32_t           pref_nr;                /*! number of processes owned by cluster   */
+
+    xlist_entry_t      local_root;            /*! root of list of process in cluster      */
+    remote_queuelock_t local_lock;            /*! lock protecting local list              */
+    uint32_t           local_nr;              /*! number of process in cluster            */
+
+    xlist_entry_t      copies_root[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! roots of lists   */
+    remote_queuelock_t copies_lock[CONFIG_MAX_PROCESS_PER_CLUSTER];  /*! one  per list    */
+    uint32_t           copies_nr[CONFIG_MAX_PROCESS_PER_CLUSTER];    /*! number of copie  */
 }
 pmgr_t;
@@ -97 +98 @@
 typedef struct cluster_s
 {
-        spinlock_t      kcm_lock;          /*! local, protect creation of KCM allocators      */
 
     // global parameters
-        uint32_t        paddr_width;       /*! numer of bits in physical address              */
+    uint32_t        paddr_width;       /*! numer of bits in physical address              */
     uint32_t        x_width;           /*! number of bits to code x_size  (can be 0)      */
     uint32_t        y_width;           /*! number of bits to code y_size  (can be 0)      */
-        uint32_t        x_size;            /*! number of clusters in a row    (can be 1)      */
-        uint32_t        y_size;            /*! number of clusters in a column (can be 1)      */
-    uint32_t        cluster_info[CONFIG_MAX_CLUSTERS_X][CONFIG_MAX_CLUSTERS_Y];
-        cxy_t           io_cxy;            /*! io cluster identifier                          */
+    uint32_t        x_size;            /*! number of clusters in a row    (can be 1)      */
+    uint32_t        y_size;            /*! number of clusters in a column (can be 1)      */
+    cxy_t           io_cxy;            /*! io cluster identifier                          */
     uint32_t        dqdt_root_level;   /*! index of root node in dqdt_tbl[]               */
     uint32_t        nb_txt_channels;   /*! number of TXT channels                         */
@@ -113 +112 @@
     uint32_t        nb_fbf_channels;   /*! number of FBF channels                         */
 
+    char            cluster_info[CONFIG_MAX_CLUSTERS_X][CONFIG_MAX_CLUSTERS_Y];
+
     // local parameters
-        uint32_t        cores_nr;          /*! actual number of cores in cluster              */
+    uint32_t        cores_nr;          /*! actual number of cores in cluster              */
     uint32_t        ram_size;          /*! physical memory size                           */
     uint32_t        ram_base;          /*! physical memory base (local address)           */
@@ -120 +121 @@
         core_t          core_tbl[CONFIG_MAX_LOCAL_CORES];    /*! embedded cores               */
 
-        list_entry_t    dev_root;          /*! root of list of devices in cluster             */
+    list_entry_t    dev_root;          /*! root of list of devices in cluster             */
 
     // memory allocators
-        ppm_t           ppm;               /*! embedded kernel page manager                   */
-        khm_t           khm;               /*! embedded kernel heap manager                   */
-        kcm_t           kcm;               /*! embedded kernel KCMs manager                   */
+    ppm_t           ppm;               /*! embedded kernel page manager                   */
+    khm_t           khm;               /*! embedded kernel heap manager                   */
+    kcm_t           kcm;               /*! embedded kernel KCMs manager                   */
 
     kcm_t         * kcm_tbl[KMEM_TYPES_NR];              /*! pointers on allocated KCMs   */
+    busylock_t      kcm_lock;                            /*! protect kcm_tbl[] updates    */
 
     // RPC
-        remote_fifo_t   rpc_fifo[CONFIG_MAX_LOCAL_CORES];    /*! one RPC FIFO per core        */
+    remote_fifo_t   rpc_fifo[CONFIG_MAX_LOCAL_CORES];    /*! one RPC FIFO per core        */
     uint32_t        rpc_threads[CONFIG_MAX_LOCAL_CORES]; /*! RPC threads per core         */
 
     // DQDT
-        dqdt_node_t     dqdt_tbl[CONFIG_DQDT_LEVELS_NR];     /*! embedded DQDT nodes          */
+    dqdt_node_t     dqdt_tbl[CONFIG_DQDT_LEVELS_NR];     /*! embedded DQDT nodes          */
 
     // Local process manager
@@ -158 +160 @@
 
 /******************************************************************************************
- * This generic function initialises the local cluster manager from information found
- * in the local boot-info structure. It initializes the following local resources:
- * - the global platform parameters,
- * - the specific cluster parameters,
- * - the lock protecting KCM creation,
- * - the local DQDT nodes,
- * - the PPM, KHM, and KCM allocators,
- * - the local core descriptors,
- * - the local RPC FIFO,
- * - the process manager.
- * It does NOT initialise the local device descriptors.
+ * These two functions initialise the local cluster manager from information found
+ * in the local boot-info structure <info> build by the boot-loader.
+ * 1) the cluster_info_init() function is called first, to initialize the structural
+ *    constants, and cannot use the TXT0 kernel terminal.
+ * 2) the cluster_manager_init() function initialize various complex structures:
+ *    - the local DQDT nodes,
+ *    - the PPM, KHM, and KCM allocators,
+ *    - the local core descriptors,
+ *    - the local RPC FIFO,
+ *    - the process manager.
+ *    It does NOT initialise the local device descriptors.
+ *    It can use the TXT0 kernel terminal.
  ******************************************************************************************
  * @ info : pointer on the local boot_info_t structure build by the bootloader.
  *****************************************************************************************/
-error_t cluster_init( boot_info_t * info );
-
-/****************************************************************************************** 
- * This function randomly selects a cluster.
- ******************************************************************************************
- * @ returns the selected cluster identifier.
- *****************************************************************************************/
-cxy_t cluster_random_select( void );
+void    cluster_info_init( boot_info_t * info );
+error_t cluster_manager_init( boot_info_t * info );
 
 /******************************************************************************************
@@ -189 +186 @@
 bool_t cluster_is_undefined( cxy_t cxy );
 
-
-/*****************************************************************************************/
-/***************   Process Management Operations   ***************************************/
-/*****************************************************************************************/
+/******************************************************************************************
+ * This function uses the local cluster_info[][] array in cluster descriptor,
+ * and returns true when the cluster identified by the <cxy> argument is active.
+ ******************************************************************************************
+ * @ cxy   : cluster identifier.
+ * @ return true if cluster contains a kernel instance.
+ *****************************************************************************************/
+bool_t cluster_is_active( cxy_t  cxy );
+
+/****************************************************************************************** 
+ * This function (pseudo) randomly selects a valid cluster.
+ * It is called by the vfs_cluster_lookup() function to place a new (missing) inode.
+ * It is called by the vmm_page_allocate() function to place a distributed vseg page.
+ ******************************************************************************************
+ * @ returns the selected cluster identifier.
+ *****************************************************************************************/
+cxy_t cluster_random_select( void );
 
 /******************************************************************************************
@@ -290 +300 @@
 void cluster_process_copies_unlink( struct process_s * process );
 
-/*********************************************************************************************
+/******************************************************************************************
  * This function displays on the kernel terminal TXT0 all user processes registered
  * in the cluster defined by the <cxy> argument.
  * It can be called by a thread running in any cluster, because is use remote accesses
  * to scan the xlist of registered processes.
- *********************************************************************************************
+ ******************************************************************************************
  * @ cxy   : cluster identifier.
- ********************************************************************************************/
+ *****************************************************************************************/
 void cluster_processes_display( cxy_t cxy );
 
-
-
-/*****************************************************************************************/
-/***************   Cores Management Operations   *****************************************/
-/*****************************************************************************************/
-
-/******************************************************************************************
- * This function returns the core local index that has the lowest usage in local cluster.
+/******************************************************************************************
+ * This function uses the local boot_inforeturns the core local index that has the lowest usage in local cluster.
  *****************************************************************************************/
 lid_t cluster_select_local_core( void );
 
+             
 #endif  /* _CLUSTER_H_ */
+

trunk/kernel/kern/core.c

@@ -3 +3 @@
  *
  * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
- *         Alain Greiner (2016,2017)
+ *         Alain Greiner (2016,2017,2018)
  *
  * Copyright (c) UPMC Sorbonne Universites

trunk/kernel/kern/core.h

@@ -3 +3 @@
  *
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
- *          Alain Greiner (2016,2017)
+ *          Alain Greiner (2016,2017,2018)
  *
  * Copyright (c) UPMC Sorbonne Universites

trunk/kernel/kern/dqdt.c

@@ -40 +40 @@
 extern chdev_directory_t  chdev_dir;  // defined in chdev.h / allocated in kernel_init.c
 
-
+/*
 ///////////////////////////////////////////////////////////////////////////////////////////
 // This static recursive function traverse the DQDT quad-tree from root to bottom.
@@ -65 +65 @@
     }
 }
-
-///////////////////
+*/
+
+/////////////////////////
 void dqdt_display( void )
 {
-    /*
-    reg_t   save_sr;
-
+    return;
+
+/*
     // build extended pointer on DQDT root node
         cluster_t * cluster = LOCAL_CLUSTER;
@@ -82 +83 @@
     chdev_t * txt0_ptr = GET_PTR( txt0_xp );
 
-    // get extended pointer on remote TXT0 chdev lock
+    // get extended pointer on remote TXT0 lock
     xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
 
-    // get TXT0 lock in busy waiting mode
-    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    // get TXT0 lock
+    remote_busylock_acquire( lock_xp );
 
     // print header
@@ -95 +96 @@
 
     // release lock
-    remote_spinlock_unlock_busy( lock_xp , save_sr );
-    */
+    remote_busylock_release( lock_xp );
+*/
+
 }
 
 ////////////////////////////////////
 uint32_t dqdt_init( uint32_t x_size,
-                    uint32_t y_size,
-                    uint32_t y_width )
+                    uint32_t y_size )
 {
     assert( ((x_size <= 32) && (y_size <= 32)) , "illegal mesh size\n");
-
+ 
+    // compute level_max
+    uint32_t  x_size_ext = POW2_ROUNDUP( x_size );
+    uint32_t  y_size_ext = POW2_ROUNDUP( y_size );
+    uint32_t  size_ext   = MAX(x_size_ext , y_size_ext);
+    uint32_t  level_max  = (bits_log2(size_ext * size_ext) >> 1) + 1;
+
+return level_max;
+
+/*
         dqdt_node_t * node;
     cxy_t         p_cxy;         // cluster coordinates for parent node
@@ -114 +124 @@
     cluster_t   * cluster;       // pointer on local cluster
 
-    cluster = LOCAL_CLUSTER;
-
-    // compute level_max
-    uint32_t  x_size_ext = POW2_ROUNDUP( x_size );
-    uint32_t  y_size_ext = POW2_ROUNDUP( y_size );
-    uint32_t  size_ext   = MAX(x_size_ext , y_size_ext);
-    uint32_t  level_max  = (bits_log2(size_ext * size_ext) >> 1) + 1;
-
-    return level_max;
-
-    /*
+    cluster_t   * cluster = LOCAL_CLUSTER;
+
     // get cluster coordinates
-    uint32_t    x       = local_cxy >> y_width;
-    uint32_t    y       = local_cxy & ((1<<y_width)-1);
+    uint32_t    x       = HAL_X_FROM_CXY( local_cxy );
+    uint32_t    y       = HAL_Y_FROM_CXY( local_cxy );
 
     // loop on local dqdt nodes (at most one node per level)
@@ -154 +155 @@
         {
             // set parent extended pointer
-            p_cxy = ((x & ~pmask)<<y_width) + (y & ~pmask);
+            p_cxy = HAL_CXY_FROM_XY( (x & ~pmask) , (y & ~pmask) );
             node->parent = XPTR( p_cxy , &cluster->dqdt_tbl[level+1] );
 
@@ -168 +169 @@
             if ( (level > 0) && ((y + (1<<(level-1))) < y_size) )
             {
-                c_cxy = local_cxy + (1<<(level-1));
+                c_cxy = local_cxy + HAL_CXY_FROM_XY( 0 , (1<<(level-1) );
                 node->children[1] = XPTR( c_cxy , &cluster->dqdt_tbl[level-1] );
                 node->arity++;
@@ -176 +177 @@
             if ( (level > 0) && ((x + (1<<(level-1))) < x_size) )
             {
-                c_cxy = local_cxy + ((1<<(level-1))<<y_width);
+                c_cxy = local_cxy + HAL_CXY_FROM_XY( (1<<(level-1)) , 0 );
                 node->children[2] = XPTR( c_cxy , &cluster->dqdt_tbl[level-1]);
                 node->arity++;
@@ -186 +187 @@
                  ((y + (1<<(level-1))) < y_size) )
             {
-                c_cxy = local_cxy + ((1<<(level-1))<<y_width) + (1<<(level-1));
+                c_cxy = local_cxy + HAL_CXY_FROM_XY( (1<<(level-1)) , (1<<(level-1) );
                 node->children[3] = XPTR( c_cxy , &cluster->dqdt_tbl[level-1]);
                 node->arity++;
@@ -194 +195 @@
 
     return level_max;
-    */
+*/
 
 } // end dqdt_init()
 
+/*
 ///////////////////////////////////////////////////////////////////////////
 // This recursive function is called by the dqdt_update_threads() function.
@@ -216 +218 @@
 
     // get extended pointer on parent node
-    xptr_t parent = (xptr_t)hal_remote_lwd( XPTR( cxy , &ptr->parent ) );
+    xptr_t parent = (xptr_t)hal_remote_l64( XPTR( cxy , &ptr->parent ) );
 
     // propagate if required
     if ( parent != XPTR_NULL ) dqdt_propagate_threads( parent, increment );
 }
-
+*/
+
+/*
 ///////////////////////////////////////////////////////////////////////////
 // This recursive function is called by the dqdt_update_pages() function.
@@ -240 +244 @@
 
     // get extended pointer on parent node
-    xptr_t parent = (xptr_t)hal_remote_lwd( XPTR( cxy , &ptr->parent ) );
+    xptr_t parent = (xptr_t)hal_remote_l64( XPTR( cxy , &ptr->parent ) );
 
     // propagate if required
     if ( parent != XPTR_NULL ) dqdt_propagate_pages( parent, increment );
 }
+*/
 
 /////////////////////////////////////////////
-void dqdt_update_threads( int32_t increment )
-{
-    return;
-    /*
+void dqdt_update_threads( int32_t increment __attribute__ ((__unused__)) )
+{
+
+return;
+
+/*
         cluster_t   * cluster = LOCAL_CLUSTER;
     dqdt_node_t * node    = &cluster->dqdt_tbl[0];
@@ -259 +266 @@
     // propagate to DQDT upper levels
     if( node->parent != XPTR_NULL ) dqdt_propagate_threads( node->parent , increment );
-    */
+*/
+
 }
 
 ///////////////////////////////////////////
-void dqdt_update_pages( int32_t increment )
-{
-    return;
-    /*
+void dqdt_update_pages( int32_t increment  __attribute__ ((__unused__)) )
+{
+
+return;
+
+/*
         cluster_t   * cluster = LOCAL_CLUSTER;
     dqdt_node_t * node    = &cluster->dqdt_tbl[0];
@@ -275 +285 @@
     // propagate to DQDT upper levels
     if( node->parent != XPTR_NULL ) dqdt_propagate_pages( node->parent , increment );
-    */
-}
-
-
+*/
+
+}
+
+/*
 ////////////////////////////////////////////////////////////////////////////////
 // This recursive function is called by both the dqdt_get_cluster_for_process()
@@ -313 +324 @@
             cxy  = (cxy_t)GET_CXY( child );
             ptr  = (dqdt_node_t *)GET_PTR( child );
-            if( for_memory ) load = hal_remote_lw( XPTR( cxy , &ptr->pages ) );
-            else             load = hal_remote_lw( XPTR( cxy , &ptr->threads ) );
+            if( for_memory ) load = hal_remote_l32( XPTR( cxy , &ptr->pages ) );
+            else             load = hal_remote_l32( XPTR( cxy , &ptr->threads ) );
             if( load < load_min )
             {
@@ -326 +337 @@
     return dqdt_select_cluster( node_copy.children[select], for_memory );
 }
-
-////////////////////////////////////
+*/
+
+//////////////////////////////////////////
 cxy_t dqdt_get_cluster_for_process( void )
 {
-    return cluster_random_select();
-    /*
+
+return cluster_random_select();
+
+/*
     // build extended pointer on DQDT root node
         cluster_t * cluster = LOCAL_CLUSTER;
@@ -339 +353 @@
     // call recursive function
     return dqdt_select_cluster( root_xp , false );
-    */
-}
-
-////////////////////////////////////
+*/
+
+}
+
+/////////////////////////////////////////
 cxy_t dqdt_get_cluster_for_memory( void )
 {
-    return cluster_random_select();
-    /*
+
+return cluster_random_select();
+ 
+/*
     // build extended pointer on DQDT root node
         cluster_t * cluster = LOCAL_CLUSTER;
@@ -354 +371 @@
     // call recursive function
     return dqdt_select_cluster( root_xp , true );
-    */
-}
-
+*/
+
+}
+

trunk/kernel/kern/dqdt.h

@@ -37 +37 @@
  *   quad-tree covering this one-dimensionnal vector. If the number of clusters
  *   is not a power of 4, the tree is truncated as required.
+ *
  *   TODO : the mapping for the one dimensionnal topology is not implemented yet [AG].
  *
@@ -55 +56 @@
  *   . Level 4 nodes exist when both X and Y coordinates are multiple of 16
  *   . Level 5 nodes exist when both X and Y coordinates are multiple of 32
+ *
+ *   TODO : the cluster_info[x][y] array is not taken into account [AG].
  ***************************************************************************************/
 
@@ -85 +88 @@
  * @ x_size   : number of clusters (containing memory and CPUs) in a row
  * @ y_size   : number of clusters (containing memory and CPUs) in a column
- * @ y_width  : number of LSB used to code the Y value in CXY
  * @ return the number of levels in quad-tree.
  ***************************************************************************************/
 uint32_t dqdt_init( uint32_t x_size,
-                    uint32_t y_size,
-                    uint32_t y_width );
+                    uint32_t y_size );
 
 /****************************************************************************************

trunk/kernel/kern/kernel_init.c

@@ -24 +24 @@
 
 #include <kernel_config.h>
-#include <hard_config.h> // for the USE_TXT_XXX macros
 #include <errno.h>
 #include <hal_kernel_types.h>
@@ -30 +29 @@
 #include <hal_context.h>
 #include <hal_irqmask.h>
+#include <hal_macros.h>
 #include <hal_ppm.h>
 #include <barrier.h>
-#include <remote_barrier.h>
+#include <xbarrier.h>
 #include <remote_fifo.h>
 #include <core.h>
@@ -59 +59 @@
 #include <devfs.h>
 #include <mapper.h>
-#include <cluster_info.h>
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -86 +85 @@
 cluster_t            cluster_manager                         CONFIG_CACHE_LINE_ALIGNED;
 
-// This variable defines the TXT0 kernel terminal (TX only)
+// This variable defines the TXT_TX[0] chdev
 __attribute__((section(".kdata")))
-chdev_t              txt0_chdev                              CONFIG_CACHE_LINE_ALIGNED;
-
-// This variable defines the TXT0 lock for writing characters to MTY0
+chdev_t              txt0_tx_chdev                           CONFIG_CACHE_LINE_ALIGNED;
+
+// This variable defines the TXT_RX[0] chdev
 __attribute__((section(".kdata")))
-spinlock_t           txt0_lock                               CONFIG_CACHE_LINE_ALIGNED;
+chdev_t              txt0_rx_chdev                           CONFIG_CACHE_LINE_ALIGNED;
 
 // This variables define the kernel process0 descriptor
@@ -116 +115 @@
 // This variable is used for CP0 cores synchronisation in kernel_init()
 __attribute__((section(".kdata")))
-remote_barrier_t     global_barrier                          CONFIG_CACHE_LINE_ALIGNED;
+xbarrier_t           global_barrier                          CONFIG_CACHE_LINE_ALIGNED;
 
 // This variable is used for local cores synchronisation in kernel_init()
@@ -127 +126 @@
 
 // kernel_init is the entry point defined in hal/tsar_mips32/kernel.ld
-// It will be used by the bootloader.
+// It is used by the bootloader.
 extern void kernel_init( boot_info_t * info );
 
-// these debug variables are used to analyse the sys_read() syscall timing
+// This array is used for debug, and describes the kernel locks usage,
+// It must be kept consistent with the defines in kernel_config.h file.
+char * lock_type_str[] =
+{
+    "unused_0",              //  0
+
+    "CLUSTER_KCM",           //  1
+    "PPM_FREE",              //  2
+    "SCHED_STATE",           //  3
+    "VMM_STACK",             //  4
+    "VMM_MMAP",              //  5
+    "VFS_CTX",               //  6
+    "KCM_STATE",             //  7
+    "KHM_STATE",             //  8
+    "HTAB_STATE",            //  9
+
+    "THREAD_JOIN",           // 10
+    "VFS_MAIN",              // 11
+    "CHDEV_QUEUE",           // 12
+    "CHDEV_TXT0",            // 13
+    "CHDEV_TXTLIST",         // 14
+    "PAGE_STATE",            // 15
+    "MUTEX_STATE",           // 16
+    "CONDVAR_STATE",         // 17
+    "SEM_STATE",             // 18
+    "XHTAB_STATE",           // 19
+
+    "unused_20",             // 20
+
+    "CLUSTER_PREFTBL",       // 21
+    "PPM_DIRTY",             // 22
+
+    "CLUSTER_LOCALS",        // 23
+    "CLUSTER_COPIES",        // 24
+    "PROCESS_CHILDREN",      // 25
+    "PROCESS_USERSYNC",      // 26
+    "PROCESS_FDARRAY",       // 27
+
+    "MAPPER_STATE",          // 28
+    "PROCESS_THTBL",         // 29
+
+    "PROCESS_CWD",           // 30
+    "VFS_INODE",             // 31
+    "VFS_FILE",              // 32
+    "VMM_VSL",               // 33
+};        
+
+// these debug variables are used to analyse the sys_read() and sys_write() syscalls timing
 
 #if DEBUG_SYS_READ
@@ -179 +225 @@
 uint32_t   exit_tty_isr_write;
 #endif
+
+// intrumentation variables : cumulated costs per syscall type in cluster
+uint32_t   syscalls_cumul_cost[SYSCALLS_NR];
+
+// intrumentation variables : number of syscalls per syscal type in cluster
+uint32_t   syscalls_occurences[SYSCALLS_NR];
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -201 +253 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////
-// This function initializes the TXT0 chdev descriptor, that is the "kernel terminal", 
-// shared by all kernel instances for debug messages. 
-// It is a global variable (replicated in all clusters), because this terminal is used
-// before the kmem allocator initialisation, but only the instance in cluster containing
-// the calling core is registered in the "chdev_dir" directory.
+// This function initializes the TXT_TX[0] and TXT_RX[0] chdev descriptors, implementing
+// the "kernel terminal", shared by all kernel instances for debug messages. 
+// These chdev are implemented as global variables (replicated in all clusters),
+// because this terminal is used before the kmem allocator initialisation, but only 
+// the chdevs in cluster 0 are registered in the "chdev_dir" directory.
 // As this TXT0 chdev supports only the TXT_SYNC_WRITE command, we don't create
 // a server thread, we don't allocate a WTI, and we don't initialize the waiting queue.
+// Note: The TXT_RX[0] chdev is created, but is not used by ALMOS-MKH (september 2018).
 ///////////////////////////////////////////////////////////////////////////////////////////
 // @ info    : pointer on the local boot-info structure.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static void txt0_device_init( boot_info_t * info )
+static void __attribute__ ((noinline)) txt0_device_init( boot_info_t * info )
 {
     boot_device_t * dev_tbl;         // pointer on array of devices in boot_info
@@ -237 +290 @@
         if (func == DEV_FUNC_TXT )
         {
-            assert( (channels > 0) , "number of TXT channels cannot be 0\n");
-
-            // initializes TXT_TX[0] chdev
-            txt0_chdev.func    = func;
-            txt0_chdev.impl    = impl;
-            txt0_chdev.channel = 0;
-            txt0_chdev.base    = base;
-            txt0_chdev.is_rx   = false;
-
-            // initializes lock
-            remote_spinlock_init( XPTR( local_cxy , &txt0_chdev.wait_lock ) );
+            // initialize TXT_TX[0] chdev
+            txt0_tx_chdev.func    = func;
+            txt0_tx_chdev.impl    = impl;
+            txt0_tx_chdev.channel = 0;
+            txt0_tx_chdev.base    = base;
+            txt0_tx_chdev.is_rx   = false;
+            remote_busylock_init( XPTR( local_cxy , &txt0_tx_chdev.wait_lock ),
+                                  LOCK_CHDEV_TXT0 );
             
-            // TXT specific initialisation:
-            // no server thread & no IRQ routing for channel 0
-            dev_txt_init( &txt0_chdev );                 
-
-            // register the TXT0 in all chdev_dir[x][y] structures
+            // initialize TXT_RX[0] chdev
+            txt0_rx_chdev.func    = func;
+            txt0_rx_chdev.impl    = impl;
+            txt0_rx_chdev.channel = 0;
+            txt0_rx_chdev.base    = base;
+            txt0_rx_chdev.is_rx   = true;
+            remote_busylock_init( XPTR( local_cxy , &txt0_rx_chdev.wait_lock ),
+                                  LOCK_CHDEV_TXT0 );
+            
+            // make TXT specific initialisations 
+            dev_txt_init( &txt0_tx_chdev );                 
+            dev_txt_init( &txt0_rx_chdev );
+
+            // register TXT_TX[0] & TXT_RX[0] in chdev_dir[x][y]
+            // for all valid clusters             
             for( x = 0 ; x < info->x_size ; x++ )
             {
-                for( y = 0 ; y < info->y_size; y++ ) // [FIXME]
+                for( y = 0 ; y < info->y_size ; y++ )
                 {
-                    if (cluster_info_is_active(info->cluster_info[x][y])) {
-                        cxy_t  cxy = (x<<info->y_width) + y;
-                        hal_remote_swd( XPTR( cxy , &chdev_dir.txt_tx[0] ) ,
-                                        XPTR( local_cxy , &txt0_chdev ) );
+                    cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+                    if( cluster_is_active( cxy ) )
+                    {
+                        hal_remote_s64( XPTR( cxy , &chdev_dir.txt_tx[0] ) ,
+                                        XPTR( local_cxy , &txt0_tx_chdev ) );
+                        hal_remote_s64( XPTR( cxy , &chdev_dir.txt_rx[0] ) ,
+                                        XPTR( local_cxy , &txt0_rx_chdev ) );
                     }
                 }
             }
+
+            hal_fence();
         }
         } // end loop on devices
 }  // end txt0_device_init()
-
-///////////////////////////////////////////////////////////////////////////////////////////
-// This function is the same as txt0_device_init() but uses the internal multi_tty device
-// attached to cluster (0,0) instead of the external tty_tsar.
-// This function is used instead of txt0_device_init() only for TSAR LETI.
-///////////////////////////////////////////////////////////////////////////////////////////
-// @ info    : pointer on the local boot-info structure.
-///////////////////////////////////////////////////////////////////////////////////////////
-static void mtty0_device_init( boot_info_t * info)
-{
-    boot_device_t * dev_tbl;         // pointer on array of devices in boot_info
-    uint32_t        dev_nr;          // actual number of devices in this cluster
-    xptr_t          base;            // remote pointer on segment base
-    uint32_t        func;            // device functional index
-    uint32_t        impl;            // device implementation index
-    uint32_t        i;               // device index in dev_tbl
-    uint32_t        x;               // X cluster coordinate
-    uint32_t        y;               // Y cluster coordinate
-
-    dev_nr = info->int_dev_nr;
-    dev_tbl = info->int_dev;
-
-    // Initialize spinlock for writing to MTY0
-    spinlock_init(&txt0_lock);
-    
-    // Loop on internal peripherals of cluster (0,0) to find MTY0
-    for ( i = 0; i < dev_nr; i++ )
-    {
-        base = dev_tbl[i].base;
-        func = FUNC_FROM_TYPE( dev_tbl[i].type );
-        impl = IMPL_FROM_TYPE( dev_tbl[i].type );
-
-        if ( func == DEV_FUNC_TXT )
-        {
-            txt0_chdev.func     = func;
-            txt0_chdev.impl     = impl;
-            txt0_chdev.channel  = 0;
-            txt0_chdev.base     = base;
-            txt0_chdev.is_rx    = false;
-
-            // Initialize MTY0 chdev lock
-            remote_spinlock_init( XPTR( local_cxy, &txt0_chdev.wait_lock ) );
-
-            // MTY specific initialization
-            dev_txt_init( &txt0_chdev );
-
-            // register the MTY in all chdev_dir[x][y] structures
-            for( x = 0 ; x < info->x_size ; x++ )
-            {
-                for( y = 0 ; y < info->y_size; y++ ) // [FIXME]
-                {
-                    if (cluster_info_is_active(info->cluster_info[x][y])) {
-                        cxy_t  cxy = (x<<info->y_width) + y;
-                        hal_remote_swd( XPTR( cxy , &chdev_dir.txt_tx[0] ) ,
-                                        XPTR( local_cxy , &txt0_chdev ) );
-                    }
-                }
-            }
-        }
-    } // end loop on internal devices
-} // end mty0_device_init()
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -338 +343 @@
 // @ info    : pointer on the local boot-info structure.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static void internal_devices_init( boot_info_t * info )
+static void __attribute__ ((noinline)) internal_devices_init( boot_info_t * info )
 {
     boot_device_t * dev_tbl;         // pointer on array of internaldevices in boot_info
@@ -367 +372 @@
         if( func == DEV_FUNC_MMC )  
         {
-            assert( (channels == 1) , "MMC device must be single channel\n" );
+
+            // check channels
+            if( channels != 1 )
+            printk("\n[PANIC] in %s : MMC device must be single channel\n", __FUNCTION__ );
 
             // create chdev in local cluster
@@ -376 +384 @@
                                       base );
 
-            assert( (chdev_ptr != NULL) ,
-                    "cannot allocate memory for MMC chdev\n" );
+            // check memory
+            if( chdev_ptr == NULL )
+            printk("\n[PANIC] in %s : cannot create MMC chdev\n", __FUNCTION__ );
             
             // make MMC specific initialisation
@@ -385 +394 @@
             for( x = 0 ; x < info->x_size ; x++ )
             {
-                for( y = 0 ; y < info->y_size; y++ ) // [FIXME]
+                for( y = 0 ; y < info->y_size ; y++ )
                 {
-                    if (cluster_info_is_active(info->cluster_info[x][y])) {
-                        cxy_t  cxy = (x<<info->y_width) + y;
-                        hal_remote_swd( XPTR( cxy , &chdev_dir.mmc[local_cxy] ), 
+                    cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+                    if( cluster_is_active( cxy ) )
+                    {
+                        hal_remote_s64( XPTR( cxy , &chdev_dir.mmc[local_cxy] ), 
                                         XPTR( local_cxy , chdev_ptr ) );
                     }
@@ -414 +425 @@
                                           base );
 
-                assert( (chdev_ptr != NULL) , "cannot allocate memory for DMA chdev" );
-
+                // check memory
+                if( chdev_ptr == NULL )
+                printk("\n[PANIC] in %s : cannot create DMA chdev\n", __FUNCTION__ );
+            
                 // make DMA specific initialisation
                 dev_dma_init( chdev_ptr );     
@@ -430 +443 @@
             }
         }
-
-        ///////////////////////////////
-        else if ( func == DEV_FUNC_TXT && USE_TXT_MTY == 1 )
-        {
-            assert(impl == IMPL_TXT_MTY,
-                "Internal TTYs should have MTY implementation\n");
-
-            for ( channel = 0; channel < channels; channel++ )
-            {
-                int rx;
-                for ( rx = 0; rx <= 1; rx++ )
-                {
-                    // skip MTY0_TX since it has already been initialized
-                    if ( channel == 0 && rx == 0 ) continue;
-
-                    // create chdev in local cluster
-                    chdev_ptr = chdev_create( func,
-                                              impl,
-                                              channel,
-                                              rx,
-                                              base );
-
-                    assert( (chdev_ptr != NULL) ,
-                        "cannot allocate memory for MTY chdev" );
-
-                    // make MTY specific initialization
-                    dev_txt_init( chdev_ptr );
-
-                    // set the MTY fields in all clusters
-                    xptr_t *chdev_entry;
-                    if ( rx == 1 ) {
-                        chdev_entry = &chdev_dir.txt_rx[channel];
-                    } else {
-                        chdev_entry = &chdev_dir.txt_tx[channel];
-                    }
-                    for ( x = 0; x < info->x_size; x++ )
-                    {
-                        for ( y = 0; y < info->y_size; y++ )
-                        {
-                            if (cluster_info_is_active(info->cluster_info[x][y])) {
-                                cxy_t cxy = (x<<info->y_width) + y;
-                                hal_remote_swd( XPTR( cxy, chdev_entry ),
-                                                XPTR( local_cxy, chdev_ptr ) );
-                            }
-                        }
-                    }
-#if( DEBUG_KERNEL_INIT & 0x1 )
-if( hal_time_stamp() > DEBUG_KERNEL_INIT )
-printk("\n[DBG] %s : created MTY[%d] in cluster %x / chdev = %x\n",
-__FUNCTION__ , channel , local_cxy , chdev_ptr );
-#endif
-                }
-            }
-        }
-
-        ///////////////////////////////
-        else if ( func == DEV_FUNC_IOC )
-        {
-            assert(impl == IMPL_IOC_SPI, __FUNCTION__,
-                "Internal IOC should have SPI implementation\n");
-
-            for ( channel = 0; channel < channels; channel++ )
-            {
-                // create chdev in local cluster
-                chdev_ptr = chdev_create( func,
-                                          impl,
-                                          channel,
-                                          0,
-                                          base );
-
-                assert( (chdev_ptr != NULL) , __FUNCTION__ , 
-                    "cannot allocate memory for IOC chdev" );
-                
-                // make IOC specific initialization
-                dev_ioc_init( chdev_ptr );
-
-                // set the IOC fields in all clusters
-                xptr_t *chdev_entry = &chdev_dir.ioc[channel];
-                for ( x = 0; x < info->x_size; x++ )
-                {
-                    for ( y = 0; y < info->y_size; y++ )
-                    {
-                        if (cluster_info_is_active(info->cluster_info[x][y])) {
-                            cxy_t cxy = (x<<info->y_width) + y;
-                            hal_remote_swd( XPTR( cxy, chdev_entry ),
-                                            XPTR( local_cxy, chdev_ptr ) );
-                        }
-                    }
-    }
-#if( DEBUG_KERNEL_INIT & 0x1 )
-if( hal_time_stamp() > DEBUG_KERNEL_INIT )
-printk("\n[DBG] %s : created IOC[%d] in cluster %x / chdev = %x\n",
-__FUNCTION__ , channel , local_cxy , chdev_ptr );
-#endif
-            }
-        }
-
     }
 }  // end internal_devices_init()
@@ -586 +502 @@
 
         // check PIC device initialized
-        assert( (chdev_dir.pic != XPTR_NULL ) ,
-              "PIC device must be initialized before other devices\n" );
+        if( chdev_dir.pic == XPTR_NULL )
+        printk("\n[PANIC] in %s : PIC device must be initialized first\n", __FUNCTION__ );
 
         // check external device functionnal type
-        assert( ( (func == DEV_FUNC_IOB) ||
-                  (func == DEV_FUNC_IOC) ||
-                  (func == DEV_FUNC_TXT) ||
-                  (func == DEV_FUNC_NIC) ||
-                  (func == DEV_FUNC_FBF) ) ,
-                  "undefined external peripheral type\n" );
+        if( (func != DEV_FUNC_IOB) && (func != DEV_FUNC_IOC) && (func != DEV_FUNC_TXT) &&
+            (func != DEV_FUNC_NIC) && (func != DEV_FUNC_FBF) )
+        printk("\n[PANIC] in %s : undefined peripheral type\n", __FUNCTION__ );
 
         // loops on channels
@@ -603 +516 @@
             for( rx = 0 ; rx < directions ; rx++ )
             {
-                // skip TXT_TX[0] chdev that has already been created & registered
-                if( USE_TXT_MTY == 0 && (func == DEV_FUNC_TXT) && (channel == 0) && (rx == 0) )
+                // skip TXT0 that has already been initialized
+                if( (func == DEV_FUNC_TXT) && (channel == 0) ) continue;
+
+                // all kernel instances compute the target cluster for all chdevs,
+                // computing the global index ext_chdev_gid[func,channel,direction]
+                cxy_t target_cxy;
+                while( 1 )
                 {
-                    continue;
+                    uint32_t offset     = ext_chdev_gid % ( info->x_size * info->y_size );
+                    uint32_t x          = offset / info->y_size;
+                    uint32_t y          = offset % info->y_size;
+
+                    target_cxy = HAL_CXY_FROM_XY( x , y );
+
+                    // exit loop if target cluster is active
+                    if( cluster_is_active( target_cxy ) ) break;
+                
+                    // increment global index otherwise
+                    ext_chdev_gid++;
                 }
 
-                // skip TXT chdevs because they are initialized in internal_devices_init()
-                if ( USE_TXT_MTY == 1 && func == DEV_FUNC_TXT )
-                {
-                    continue;
-                }
-
-                if ( func == DEV_FUNC_IOC && impl == IMPL_IOC_SPI )
-                {
-                    continue;
-                }
-
-                // compute target cluster for chdev[func,channel,direction]
-                uint32_t offset;
-                uint32_t cx;
-                uint32_t cy;
-                uint32_t target_cxy;
-                while (1) {
-                    offset     = ext_chdev_gid % ( info->x_size * (info->y_size) );
-                    cx         = offset / (info->y_size);
-                    cy         = offset % (info->y_size);
-                    target_cxy = (cx<<info->y_width) + cy;
-                    // ext_chdev_gid that results in empty target clusters are skipped
-                    if ( cluster_info_is_active( LOCAL_CLUSTER->cluster_info[cx][cy] ) == 0 ) {
-                        ext_chdev_gid++;
-                    } else { // The ext_chdev_gid resulted in a full target cluster
-                        break;
-                    }
-                }
                 // allocate and initialize a local chdev
                 // when local cluster matches target cluster
@@ -647 +547 @@
                                           base );
 
-                    assert( (chdev != NULL),
-                            "cannot allocate external device" );
+                    if( chdev == NULL )
+                    printk("\n[PANIC] in %s : cannot allocate chdev for external device\n",
+                    __FUNCTION__ );
 
                     // make device type specific initialisation
@@ -672 +573 @@
                     for( x = 0 ; x < info->x_size ; x++ )
                     {
-                        for ( y = 0; y < info->y_size; y++ )
+                        for( y = 0 ; y < info->y_size ; y++ )
                         {
-                            if (cluster_info_is_active(info->cluster_info[x][y])) {
-                                cxy_t  cxy = (x<<info->y_width) + y;
-                                hal_remote_swd( XPTR( cxy , entry ),
+                            cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+                            if( cluster_is_active( cxy ) )
+                            {
+                                hal_remote_s64( XPTR( cxy , entry ),
                                                 XPTR( local_cxy , chdev ) );
                             }
@@ -706 +609 @@
 // @ info    : pointer on the local boot-info structure.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static void iopic_init( boot_info_t * info )
+static void __attribute__ ((noinline)) iopic_init( boot_info_t * info )
 {
     boot_device_t * dev_tbl;         // pointer on boot_info external devices array
@@ -723 +626 @@
     dev_tbl     = info->ext_dev;
 
+    // avoid GCC warning
+    base        = XPTR_NULL;
+    impl        = 0;
+
     // loop on external peripherals to get the IOPIC  
         for( i = 0 , found = false ; i < dev_nr ; i++ )
@@ -737 +644 @@
     }
 
-    assert( found , "PIC device not found\n" );
+    // check PIC existence
+    if( found == false )
+    printk("\n[PANIC] in %s : PIC device not found\n", __FUNCTION__ );
 
     // allocate and initialize the PIC chdev in cluster 0
@@ -746 +655 @@
                           base );
 
-    assert( (chdev != NULL), "no memory for PIC chdev\n" );
+    // check memory
+    if( chdev == NULL )
+    printk("\n[PANIC] in %s : no memory for PIC chdev\n", __FUNCTION__ );
 
     // make PIC device type specific initialisation
@@ -757 +668 @@
     for( x = 0 ; x < info->x_size ; x++ )
     {
-        for ( y = 0; y < info->y_size; y++ )
+        for( y = 0 ; y < info->y_size ; y++ )
         {
-            if (cluster_info_is_active(info->cluster_info[x][y])) {
-                cxy_t  cxy = (x<<info->y_width) + y;
-                hal_remote_swd( XPTR( cxy , entry ) , 
+            cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+            if( cluster_is_active( cxy ) )
+            {
+                hal_remote_s64( XPTR( cxy , entry ) , 
                                 XPTR( local_cxy , chdev ) );
             }
@@ -773 +686 @@
     for( x = 0 ; x < info->x_size ; x++ )
     {
-        for ( y = 0; y < info->y_size; y++ )
+        for( y = 0 ; y < info->y_size ; y++ )
         {
-            if (cluster_info_is_active(info->cluster_info[x][y])) {
-                cxy_t  cxy = (x<<info->y_width) + y;
-                hal_remote_memset( XPTR( cxy , &iopic_input ) , 0xFF , sizeof(iopic_input_t) );
+            cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+            if( cluster_is_active( cxy ) )
+            {
+                hal_remote_memset( XPTR( cxy , &iopic_input ), 
+                                   0xFF , sizeof(iopic_input_t) );
             }
         }
@@ -807 +723 @@
             else if((func == DEV_FUNC_NIC) && (is_rx != 0)) ptr = &iopic_input.nic_rx[channel];
             else if( func == DEV_FUNC_IOB )                 ptr = &iopic_input.iob;
-            else     assert( false , "illegal source device for IOPIC input" );
+            else     printk("\n[PANIC] in %s : illegal source device for IOPIC input" );
 
             // set one entry in all "iopic_input" structures
             for( x = 0 ; x < info->x_size ; x++ )
             {
-                for ( y = 0; y < info->y_size; y++ )
+                for( y = 0 ; y < info->y_size ; y++ )
                 {
-                    if (cluster_info_is_active(info->cluster_info[x][y])) {
-                        cxy_t  cxy = (x<<info->y_width) + y;
-                        hal_remote_swd( XPTR( cxy , ptr ) , id ); 
+                    cxy_t cxy = HAL_CXY_FROM_XY( x , y );
+
+                    if( cluster_is_active( cxy ) )
+                    {
+                        hal_remote_s64( XPTR( cxy , ptr ) , id ); 
                     }
                 }
@@ -824 +742 @@
 
 #if( DEBUG_KERNEL_INIT & 0x1 )
-if( hal_time_stamp() > DEBUG_KERNEL_INIT )
+if( hal_tim_stamp() > DEBUG_KERNEL_INIT )
 {
     printk("\n[DBG] %s created PIC chdev in cluster %x at cycle %d\n",
@@ -843 +761 @@
 // @ info    : pointer on the local boot-info structure.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static void lapic_init( boot_info_t * info )
+static void __attribute__ ((noinline)) lapic_init( boot_info_t * info )
 {
     boot_device_t * dev_tbl;      // pointer on boot_info internal devices array
@@ -896 +814 @@
                 if     ( func == DEV_FUNC_MMC ) lapic_input.mmc = id;
                 else if( func == DEV_FUNC_DMA ) lapic_input.dma[channel] = id;
-                else if( func == DEV_FUNC_TXT ) lapic_input.mtty = id;
-                else if( func == DEV_FUNC_IOC ) lapic_input.sdcard = id;
-                else assert( false , "illegal source device for LAPIC input" );
+                else     printk("\n[PANIC] in %s : illegal source device for LAPIC input" );
             }
         }
@@ -913 +829 @@
 // @ return 0 if success / return EINVAL if not found.
 ///////////////////////////////////////////////////////////////////////////////////////////
-static error_t get_core_identifiers( boot_info_t * info,
-                                     lid_t       * lid,
-                                     cxy_t       * cxy,
-                                     gid_t       * gid )
+static error_t __attribute__ ((noinline)) get_core_identifiers( boot_info_t * info,
+                                                                lid_t       * lid,
+                                                                cxy_t       * cxy,
+                                                                gid_t       * gid )
 {
     uint32_t   i;
@@ -989 +905 @@
     thread->core = &LOCAL_CLUSTER->core_tbl[core_lid];
 
-    // each core initializes the idle thread lists of locks
-    list_root_init( &thread->locks_root );
-    xlist_root_init( XPTR( local_cxy , &thread->xlocks_root ) );
-    thread->local_locks = 0;
-    thread->remote_locks = 0;
-
-    // CP0 in cluster 0 initializes TXT0 chdev descriptor
-    if( core_cxy == 0 && core_lid == 0 ) // [MODIF]
-    {
-        if( USE_TXT_MTY == 1 ) {
-            mtty0_device_init( info );
-        } else {
-            txt0_device_init( info );
-        }
-    }
-
-    /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    // each core initializes the idle thread locks counters
+    thread->busylocks = 0;
+
+#if DEBUG_BUSYLOCK
+    // each core initialise the idle thread list of busylocks
+    xlist_root_init( XPTR( local_cxy , &thread->busylocks_root ) );
+#endif
+
+    // CP0 initializes cluster info
+    if( core_lid == 0 ) cluster_info_init( info );
+
+    // CP0 in cluster 0 initialises TXT0 chdev descriptor
+    if( (core_lid == 0) && (core_cxy == 0) ) txt0_device_init( info );
+
+    /////////////////////////////////////////////////////////////////////////////////
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
 
 #if DEBUG_KERNEL_INIT
-if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 0 : TXT0 initialized / cycle %d\n",
-__FUNCTION__, (uint32_t)hal_get_cycles() );
+// if( (core_lid ==  0) & (local_cxy == 0) ) 
+printk("\n[DBG] %s : exit barrier 0 : TXT0 initialized / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1025 +939 @@
     // all cores check identifiers
     if( error )
-    {
-        assert( false ,
-        "illegal core identifiers gid = %x / cxy = %x / lid = %d",
-        core_lid , core_cxy , core_lid );
-    }
-
-    // CP0 initializes cluster manager
+    printk("\n[PANIC] in %s : illegal core : gid %x / cxy %x / lid %d",
+    __FUNCTION__, core_lid, core_cxy, core_lid );
+
+    // CP0 initializes cluster manager complex structures
     if( core_lid == 0 )
     {
-        error = cluster_init( info );
+        error = cluster_manager_init( info );
 
         if( error )
-        {
-            assert( false ,
-            "cannot initialise cluster %x", local_cxy );
-        }
+        printk("\n[PANIC] in %s : cannot initialize cluster manager in cluster %x\n",
+        __FUNCTION__, local_cxy );
     }
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1051 +960 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 1 : clusters initialised / cycle %d\n",
-__FUNCTION__, (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 1 : clusters initialised / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1071 +980 @@
     
     ////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     ////////////////////////////////////////////////////////////////////////////////
@@ -1078 +987 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 2 : PIC initialised / cycle %d\n",
-__FUNCTION__, (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 2 : PIC initialised / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1104 +1013 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1111 +1020 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 3 : all chdev initialised / cycle %d\n",
-__FUNCTION__, (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 3 : all chdev initialised / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1127 +1036 @@
     /////////////////////////////////////////////////////////////////////////////////
 
-    // All cores enable the shared IPI channel
+    // All cores enable IPI 
     dev_pic_enable_ipi();
     hal_enable_irq( &status );
-
-#if DEBUG_KERNEL_INIT
-printk("\n[DBG] %s: IPI enabled for core %d cluster %d\n", __FUNCTION__,
-  core_lid, local_cxy);
-#endif
 
     // all cores initialize the idle thread descriptor
@@ -1163 +1067 @@
             fatfs_ctx_t * fatfs_ctx = fatfs_ctx_alloc();
 
-            assert( (fatfs_ctx != NULL) ,
-                    "cannot create FATFS context in cluster 0\n" );
+            if( fatfs_ctx == NULL )
+            printk("\n[PANIC] in %s : cannot create FATFS context in cluster 0\n",
+            __FUNCTION__ );
 
             // 2. access boot device to initialize FATFS context
@@ -1175 +1080 @@
             uint32_t total_clusters   = fatfs_ctx->fat_sectors_count << 7;
  
-            // 4. create VFS root inode in cluster 0
+            // 4. initialize the FATFS entry in the vfs_context[] array 
+            vfs_ctx_init( FS_TYPE_FATFS,                               // fs type
+                          0,                                           // attributes: unused 
+                              total_clusters,                
+                              cluster_size,
+                              vfs_root_inode_xp,                           // VFS root
+                          fatfs_ctx );                                 // extend
+
+            // 5. create VFS root inode in cluster 0
             error = vfs_inode_create( XPTR_NULL,                           // dentry_xp
                                       FS_TYPE_FATFS,                       // fs_type
@@ -1185 +1098 @@
                                       0,                                   // gid
                                       &vfs_root_inode_xp );                // return
-
-            assert( (error == 0) ,
-                    "cannot create VFS root inode\n" );
-
-            // 5. initialize VFS context for FAT in cluster 0
-            vfs_ctx_init( FS_TYPE_FATFS,                 // file system type
-                          0,                             // attributes 
-                              total_clusters,                
-                              cluster_size,
-                              vfs_root_inode_xp,             // VFS root
-                          fatfs_ctx );                   // extend
-
-            // 6. check initialisation
+            if( error )
+            printk("\n[PANIC] in %s : cannot create VFS root inode in cluster 0\n",
+            __FUNCTION__ );
+
+            // 6. update the FATFS entry in vfs_context[] array
+            fs_context[FS_TYPE_FATFS].vfs_root_xp = vfs_root_inode_xp;
+
+            // 7. check FATFS initialization
             vfs_ctx_t   * vfs_ctx = &fs_context[FS_TYPE_FATFS];
-            assert( (((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster == 8),
-             "illegal value for FATFS context in cluster %x\n", local_cxy );
+
+            if( ((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster != 8 )
+            printk("\n[PANIC] in %s : illegal FATFS context in cluster 0\n",
+            __FUNCTION__ );
         }
         else
         {
-            assert( false ,
-            "root FS must be FATFS" );
+            printk("\n[PANIC] in %s : unsupported VFS type in cluster 0\n",
+            __FUNCTION__ );
         }
 
@@ -1214 +1124 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1221 +1131 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 4 : VFS_root = %l in cluster 0 / cycle %d\n",
-__FUNCTION__, vfs_root_inode_xp , (uint32_t)hal_get_cycles());
+printk("\n[DBG] %s : exit barrier 4 : VFS root initialized in cluster 0 / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1241 +1151 @@
             fatfs_ctx_t * local_fatfs_ctx = fatfs_ctx_alloc();
 
-            assert( (local_fatfs_ctx != NULL) ,
-            "cannot create FATFS context in cluster %x\n", local_cxy );
+            // check memory
+            if( local_fatfs_ctx == NULL )
+            printk("\n[PANIC] in %s : cannot create FATFS context in cluster %x\n",
+            __FUNCTION__ , local_cxy );
 
             // 2. get local pointer on VFS context for FATFS
@@ -1261 +1173 @@
             vfs_ctx->extend = local_fatfs_ctx;
 
-            // 7. check initialisation
-            assert( (((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster == 8),
-            "illegal value for FATFS context in cluster %x\n", local_cxy );
+            if( ((fatfs_ctx_t *)vfs_ctx->extend)->sectors_per_cluster != 8 )
+            printk("\n[PANIC] in %s : illegal FATFS context in cluster %x\n",
+            __FUNCTION__ , local_cxy );
         }
 
         // get extended pointer on VFS root inode from cluster 0
-        vfs_root_inode_xp = hal_remote_lwd( XPTR( 0 , &process_zero.vfs_root_xp ) );
+        vfs_root_inode_xp = hal_remote_l64( XPTR( 0 , &process_zero.vfs_root_xp ) );
 
         // update local process_zero descriptor
@@ -1275 +1187 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
 
 #if DEBUG_KERNEL_INIT
-if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 5 : VFS_root = %l in cluster 0 / cycle %d\n",
-__FUNCTION__, vfs_root_inode_xp , (uint32_t)hal_get_cycles());
-#endif
-
-    /////////////////////////////////////////////////////////////////////////////////
-    // STEP 6 : CP0 in cluster IO makes the global DEVFS tree initialisation:
-    //          It creates the DEVFS directory "dev", and the DEVFS "external"
-    //          directory in cluster IO and mount these inodes into VFS.
-    /////////////////////////////////////////////////////////////////////////////////
-
-    if( (core_lid ==  0) && (local_cxy == 0) )  // [FIXME]
+if( (core_lid ==  0) & (local_cxy == 1) ) 
+printk("\n[DBG] %s : exit barrier 5 : VFS root initialized in cluster 1 / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
+#endif
+
+    /////////////////////////////////////////////////////////////////////////////////
+    // STEP 6 : CP0 in cluster 0 makes the global DEVFS tree initialisation:
+    //          It initializes the DEVFS context, and creates the DEVFS
+    //          "dev" and "external" inodes in cluster 0.
+    /////////////////////////////////////////////////////////////////////////////////
+
+    if( (core_lid ==  0) && (local_cxy == 0) ) 
     {
-        // create "dev" and "external" directories.
+        // 1. allocate memory for DEVFS context extension in cluster 0
+        devfs_ctx_t * devfs_ctx = devfs_ctx_alloc();
+
+        if( devfs_ctx == NULL )
+        printk("\n[PANIC] in %s : cannot create DEVFS context in cluster 0\n",
+        __FUNCTION__ , local_cxy );
+
+        // 2. initialize the DEVFS entry in the vfs_context[] array 
+        vfs_ctx_init( FS_TYPE_DEVFS,                                // fs type
+                      0,                                            // attributes: unused
+                          0,                                            // total_clusters: unused
+                          0,                                            // cluster_size: unused 
+                          vfs_root_inode_xp,                            // VFS root
+                      devfs_ctx );                                  // extend
+
+        // 3. create "dev" and "external" inodes (directories)
         devfs_global_init( process_zero.vfs_root_xp,
                            &devfs_dev_inode_xp,
                            &devfs_external_inode_xp );
 
-        // creates the DEVFS context in cluster IO
-        devfs_ctx_t * devfs_ctx = devfs_ctx_alloc();
-
-        assert( (devfs_ctx != NULL) ,
-                "cannot create DEVFS context in cluster IO\n");
-
-        // register DEVFS root and external directories
-        devfs_ctx_init( devfs_ctx, devfs_dev_inode_xp, devfs_external_inode_xp );
+        // 4. initializes DEVFS context extension
+        devfs_ctx_init( devfs_ctx,
+                        devfs_dev_inode_xp,
+                        devfs_external_inode_xp );
     }    
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1317 +1240 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 6 : dev_root = %l in cluster 0 / cycle %d\n",
-__FUNCTION__, devfs_dev_inode_xp , (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 6 : DEVFS root initialized in cluster 0 / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1324 +1247 @@
     // STEP 7 : All CP0s complete in parallel the DEVFS tree initialization.
     //          Each CP0 get the "dev" and "external" extended pointers from
-    //          values stored in cluster IO. 
-    //          Then each CP0 in cluster(i) creates the DEVFS "internal directory, 
+    //          values stored in cluster 0. 
+    //          Then each CP0 in cluster(i) creates the DEVFS "internal" directory, 
     //          and creates the pseudo-files for all chdevs in cluster (i).
     /////////////////////////////////////////////////////////////////////////////////
@@ -1331 +1254 @@
     if( core_lid == 0 )
     {
-        // get extended pointer on "extend" field of VFS context for DEVFS in cluster IO
-        xptr_t  extend_xp = XPTR( 0 , &fs_context[FS_TYPE_DEVFS].extend ); // [FIXME]
+        // get extended pointer on "extend" field of VFS context for DEVFS in cluster 0
+        xptr_t  extend_xp = XPTR( 0 , &fs_context[FS_TYPE_DEVFS].extend );
 
         // get pointer on DEVFS context in cluster 0
         devfs_ctx_t * devfs_ctx = hal_remote_lpt( extend_xp );
         
-        devfs_dev_inode_xp      = hal_remote_lwd( XPTR( 0 , &devfs_ctx->dev_inode_xp ) );
-        devfs_external_inode_xp = hal_remote_lwd( XPTR( 0 , &devfs_ctx->external_inode_xp ) );
+        devfs_dev_inode_xp      = hal_remote_l64( XPTR( 0 , &devfs_ctx->dev_inode_xp ) );
+        devfs_external_inode_xp = hal_remote_l64( XPTR( 0 , &devfs_ctx->external_inode_xp ) );
 
         // populate DEVFS in all clusters
@@ -1347 +1270 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ), 
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1354 +1277 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 7 : dev_root = %l in cluster 0 / cycle %d\n",
-__FUNCTION__, devfs_dev_inode_xp , (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 7 : DEV initialized in cluster 0 / sr %x / cycle %d\n",
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1373 +1296 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), // [FIXME]
-                                        cluster_info_nb_actives(info->cluster_info) );
+    if( core_lid == 0 ) xbarrier_wait( XPTR( 0 , &global_barrier ),
+                                        (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
     /////////////////////////////////////////////////////////////////////////////////
@@ -1380 +1303 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 8 : process init created / cycle %d\n", 
-__FUNCTION__ , (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 8 : process init created / sr %x / cycle %d\n", 
+__FUNCTION__, (uint32_t)hal_get_sr(), (uint32_t)hal_get_cycles() );
 #endif
 
 #if (DEBUG_KERNEL_INIT & 1)
-if( (core_lid ==  0) /*& (local_cxy == 0)*/ ) 
+if( (core_lid ==  0) & (local_cxy == 0) ) 
 sched_display( 0 );
 #endif
@@ -1393 +1316 @@
     /////////////////////////////////////////////////////////////////////////////////
     
-    if( (core_lid ==  0) && (local_cxy == 0) ) // [FIXME]
+    if( (core_lid == 0) && (local_cxy == 0) ) 
     {
         print_banner( (info->x_size * info->y_size) , info->cores_nr );
@@ -1415 +1338 @@
                    " - list item          : %d bytes\n"
                    " - xlist item         : %d bytes\n"
-                   " - spinlock           : %d bytes\n"
-                   " - remote spinlock    : %d bytes\n"
+                   " - busylock           : %d bytes\n"
+                   " - remote busylock    : %d bytes\n"
+                   " - queuelock          : %d bytes\n"
+                   " - remote queuelock   : %d bytes\n"
                    " - rwlock             : %d bytes\n"
                    " - remote rwlock      : %d bytes\n",
-                   sizeof( thread_t          ),
-                   sizeof( process_t         ),
-                   sizeof( cluster_t         ),
-                   sizeof( chdev_t           ),
-                   sizeof( core_t            ),
-                   sizeof( scheduler_t       ),
-                   sizeof( remote_fifo_t     ),
-                   sizeof( page_t            ),
-                   sizeof( mapper_t          ),
-                   sizeof( ppm_t             ),
-                   sizeof( kcm_t             ),
-                   sizeof( khm_t             ),
-                   sizeof( vmm_t             ),
-                   sizeof( gpt_t             ),
-                   sizeof( list_entry_t      ),
-                   sizeof( xlist_entry_t     ),
-                   sizeof( spinlock_t        ),
-                   sizeof( remote_spinlock_t ),
-                   sizeof( rwlock_t          ),
-                   sizeof( remote_rwlock_t   ));
+                   sizeof( thread_t           ),
+                   sizeof( process_t          ),
+                   sizeof( cluster_t          ),
+                   sizeof( chdev_t            ),
+                   sizeof( core_t             ),
+                   sizeof( scheduler_t        ),
+                   sizeof( remote_fifo_t      ),
+                   sizeof( page_t             ),
+                   sizeof( mapper_t           ),
+                   sizeof( ppm_t              ),
+                   sizeof( kcm_t              ),
+                   sizeof( khm_t              ),
+                   sizeof( vmm_t              ),
+                   sizeof( gpt_t              ),
+                   sizeof( list_entry_t       ),
+                   sizeof( xlist_entry_t      ),
+                   sizeof( busylock_t         ),
+                   sizeof( remote_busylock_t  ),
+                   sizeof( queuelock_t        ),
+                   sizeof( remote_queuelock_t ),
+                   sizeof( rwlock_t           ),
+                   sizeof( remote_rwlock_t    ));
 #endif
 

trunk/kernel/kern/printk.c

@@ -26 +26 @@
 #include <hal_special.h>
 #include <dev_txt.h>
-#include <remote_spinlock.h>
+#include <remote_busylock.h>
 #include <cluster.h>
 #include <thread.h>
@@ -201 +201 @@
 // @ args      : va_list of arguments.
 //////////////////////////////////////////////////////////////////////////////////////
-static void kernel_printf( char     * format, 
-                           va_list  * args ) 
+static void kernel_printf( const char * format, 
+                           va_list    * args ) 
 {
 
@@ -352 +352 @@
 {
     va_list       args;
-    reg_t         save_sr;
 
     // get pointers on TXT0 chdev
@@ -359 +358 @@
     chdev_t * txt0_ptr = GET_PTR( txt0_xp );
 
-    // get extended pointer on remote TXT0 chdev lock
+    // get extended pointer on remote TXT0 lock
     xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
 
-    // get TXT0 lock in busy waiting mode
-    remote_spinlock_lock_busy( lock_xp , &save_sr );
-
-    // call kernel_printf on TXT0, in busy waiting mode
+    // get TXT0 lock
+    remote_busylock_acquire( lock_xp );
+
+    // display format on TXT0 in busy waiting mode
     va_start( args , format );
     kernel_printf( format , &args );
     va_end( args );
 
-    // release lock
-    remote_spinlock_unlock_busy( lock_xp , save_sr );
+    // release TXT0 lock
+    remote_busylock_release( lock_xp );
 }
 
@@ -386 +385 @@
 
 ////////////////////////////////////
-void __panic( const char * file_name,
-              const char * function_name,
-              uint32_t     line,
-              cycle_t      cycle,
-              const char * format,
-              ... )
+void panic( const char * file_name,
+            const char * function_name,
+            uint32_t     line,
+            cycle_t      cycle,
+            const char * format,
+            ... )
 {
     // get pointers on TXT0 chdev
@@ -399 +398 @@
 
     // get extended pointer on remote TXT0 lock
-    xptr_t lock_txt0_xp = XPTR(txt0_cxy, &txt0_ptr->wait_lock);
-
-    // get TXT0 lock in busy waiting mode
-    {
-        uint32_t save_sr;
-        remote_spinlock_lock_busy(lock_txt0_xp, &save_sr);
-
-        thread_t *current = CURRENT_THREAD;
-        nolock_printk(
-            "\n[PANIC] in %s: line %d | funct %s | cycle %d\n"
-            "core[%x,%d] | thread %x in process %x\n"
-            "            | thread_ptr %x | procress_ptr %x\n",
+    xptr_t lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
+
+    // get TXT0 lock 
+    remote_busylock_acquire( lock_xp );
+
+    // get calling thread
+    thread_t * current = CURRENT_THREAD;
+
+    // print generic infos
+    nolock_printk(
+            "\n[PANIC] in %s: line %d | function %s | cycle %d\n"
+            "core[%x,%d] | thread %x (%x) in process %x (%x)\n",
             file_name, line, function_name, (uint32_t) cycle,
-            local_cxy, current->core->lid, current->trdid, current->process->pid,
-            current, current->process);
-
-        // call kernel_printf on TXT0, in busy waiting to print format
-        va_list args;
-        va_start(args, format);
-        kernel_printf(format, &args);
-        va_end(args);
-
-        // release TXT0 lock
-        remote_spinlock_unlock_busy(lock_txt0_xp, save_sr);
-    }
+            local_cxy, current->core->lid, 
+            current->trdid, current,
+            current->process->pid, current->process );
+
+    // call kernel_printf to print format
+    va_list args;
+    va_start(args, format);
+    kernel_printf(format, &args);
+    va_end(args);
+
+    // release TXT0 lock
+    remote_busylock_release( lock_xp );
 
     // suicide
@@ -432 +431 @@
 void puts( char * string ) 
 {
-    uint32_t   save_sr;
     uint32_t   n = 0;
 
@@ -443 +441 @@
     chdev_t * txt0_ptr = GET_PTR( txt0_xp );
 
-    // get extended pointer on remote TXT0 chdev lock
+    // get extended pointer on remote TXT0 lock
     xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
 
-    // get TXT0 lock in busy waiting mode
-    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    // get TXT0 lock 
+    remote_busylock_acquire( lock_xp );
 
     // display string on TTY0
     dev_txt_sync_write( string , n );
 
-    // release TXT0 lock in busy waiting mode
-    remote_spinlock_unlock_busy( lock_xp , save_sr );
+    // release TXT0 lock
+    remote_busylock_release( lock_xp );
 }
 
@@ -464 +462 @@
     char      buf[10];
     uint32_t  c;
-    uint32_t  save_sr;
 
     buf[0] = '0';
@@ -484 +481 @@
     xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
 
-    // get TXT0 lock in busy waiting mode
-    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    // get TXT0 lock 
+    remote_busylock_acquire( lock_xp );
 
     // display string on TTY0
     dev_txt_sync_write( buf , 10 );
 
-    // release TXT0 lock in busy waiting mode
-    remote_spinlock_unlock_busy( lock_xp , save_sr );
+    // release TXT0 lock
+    remote_busylock_release( lock_xp );
 }
 
@@ -501 +498 @@
     char      buf[18];
     uint32_t  c;
-    uint32_t  save_sr;
 
     buf[0] = '0';
@@ -521 +517 @@
     xptr_t  lock_xp = XPTR( txt0_cxy , &txt0_ptr->wait_lock );
 
-    // get TXT0 lock in busy waiting mode
-    remote_spinlock_lock_busy( lock_xp , &save_sr );
+    // get TXT0 lock 
+    remote_busylock_acquire( lock_xp );
 
     // display string on TTY0
     dev_txt_sync_write( buf , 18 );
 
-    // release TXT0 lock in busy waiting mode
-    remote_spinlock_unlock_busy( lock_xp , save_sr );
+    // release TXT0 lock
+    remote_busylock_release( lock_xp );
 }
 

trunk/kernel/kern/printk.h

@@ -28 +28 @@
 // - The printk() function displays kernel messages on the kernel terminal TXT0,
 //   using a busy waiting policy: It calls directly the relevant TXT driver,
-//   after taking the TXT0 chdev lock for exclusive access to the TXT0 terminal.
+//   after taking the TXT0 busylock for exclusive access to the TXT0 terminal.
 // - The user_printk() function displays messages on the calling thread private
 //   terminal, using a descheduling policy: it register the request in the selected
@@ -67 +67 @@
 /**********************************************************************************
  * This function displays a formatted string on the kernel terminal TXT0,
- * using a busy waiting policy: It calls directly the relevant TXT driver,
  * after taking the TXT0 lock.
+ * It uses a busy waiting policy, calling directly the relevant TXT driver,
  **********************************************************************************
  * @ format     : formatted string.
@@ -76 +76 @@
 /**********************************************************************************
  * This function displays a formatted string on the kernel terminal TXT0,
- * using a busy waiting policy: It calls directly the relevant TXT driver,
  * without taking the TXT0 lock.
+ * It uses a busy waiting policy, calling directly the relevant TXT driver,
  **********************************************************************************
  * @ format     : formatted string.
@@ -85 +85 @@
 
 /**********************************************************************************
- * Private function designed to be called by the assert macro (below)
+ * This function is called in case of kernel panic. It printt a detailed message
+ * on the TXT0 terminal after taking the TXT0 lock, and call the hal_core_sleep()
+ * function to block the calling core.  It is used by the assert macro (below).
  **********************************************************************************
  * @ file_name     : File where the assert macro was invoked
@@ -96 +98 @@
  * See assert macro documentation for information about printed information.
  *********************************************************************************/
-void __panic( const char * file_name,
-              const char * function_name,
-              uint32_t     line,
-              cycle_t      cycle,
-              const char * format,
-              ... )
-__attribute__((__noreturn__));
+void panic( const char * file_name,
+            const char * function_name,
+            uint32_t     line,
+            cycle_t      cycle,
+            const char * format,
+            ... ) __attribute__((__noreturn__));
 
 /**********************************************************************************
@@ -134 +135 @@
  * @ format        : formatted string
  *********************************************************************************/
-#define assert( expr, format, ... ) { uint32_t __line_at_expansion = __LINE__;    \
-  const volatile cycle_t __assert_cycle = hal_get_cycles();                       \
-  if ( ( expr ) == false ) {                                                      \
-    __panic( __FILE__, __FUNCTION__,                                              \
-             __line_at_expansion, __assert_cycle,                                 \
-             ( format ), ##__VA_ARGS__ );                                         \
-  }                                                                               \
+#define assert( expr, format, ... )                                               \
+{                                                                                 \
+    uint32_t __line_at_expansion = __LINE__;                                      \
+    const volatile cycle_t __assert_cycle = hal_get_cycles();                     \
+    if ( ( expr ) == false )                                                      \
+    {                                                                             \
+        panic( __FILE__, __FUNCTION__,                                            \
+               __line_at_expansion, __assert_cycle,                               \
+               ( format ), ##__VA_ARGS__ );                                       \
+    }                                                                             \
 }
 
@@ -168 +172 @@
 
 
-
-/*  deprecated march 2018 [AG]
-
-#if CONFIG_CHDEV_DEBUG
-#define chdev_dmsg(...)   if(hal_time_stamp() > CONFIG_CHDEV_DEBUG) printk(__VA_ARGS__)
-#else
-#define chdev_dmsg(...)
-#endif
-
-#if CONFIG_CLUSTER_DEBUG
-#define cluster_dmsg(...)   if(hal_time_stamp() > CONFIG_CLUSTER_DEBUG) printk(__VA_ARGS__)
-#else
-#define cluster_dmsg(...)
-#endif
-
-#if CONFIG_CONTEXT_DEBUG
-#define context_dmsg(...)   if(hal_time_stamp() > CONFIG_CONTEXT_DEBUG) printk(__VA_ARGS__)
-#else
-#define context_dmsg(...)
-#endif
-
-#if CONFIG_CORE_DEBUG
-#define core_dmsg(...)   if(hal_time_stamp() > CONFIG_CORE_DEBUG) printk(__VA_ARGS__)
-#else
-#define core_dmsg(...)
-#endif
-
-#if CONFIG_DEVFS_DEBUG
-#define devfs_dmsg(...)   if(hal_time_stamp() > CONFIG_DEVFS_DEBUG) printk(__VA_ARGS__)
-#else
-#define devfs_dmsg(...)
-#endif
-
-#if CONFIG_DMA_DEBUG
-#define dma_dmsg(...)   if(hal_time_stamp() > CONFIG_DMA_DEBUG) printk(__VA_ARGS__)
-#else
-#define dma_dmsg(...)
-#endif
-
-#if CONFIG_DQDT_DEBUG
-#define dqdt_dmsg(...)   if(hal_time_stamp() > CONFIG_DQDT_DEBUG) printk(__VA_ARGS__)
-#else
-#define dqdt_dmsg(...)
-#endif
-
-#if CONFIG_ELF_DEBUG
-#define elf_dmsg(...)   if(hal_time_stamp() > CONFIG_ELF_DEBUG) printk(__VA_ARGS__)
-#else
-#define elf_dmsg(...)
-#endif
-
-#if CONFIG_EXEC_DEBUG
-#define exec_dmsg(...)   if(hal_time_stamp() > CONFIG_EXEC_DEBUG) printk(__VA_ARGS__)
-#else
-#define exec_dmsg(...)
-#endif
-
-#if CONFIG_EXCP_DEBUG
-#define excp_dmsg(...)   if(hal_time_stamp() > CONFIG_EXCP_DEBUG) printk(__VA_ARGS__)
-#else
-#define excp_dmsg(...)
-#endif
-
-#if CONFIG_FATFS_DEBUG
-#define fatfs_dmsg(...)   if(hal_time_stamp() > CONFIG_FATFS_DEBUG) printk(__VA_ARGS__)
-#else
-#define fatfs_dmsg(...)
-#endif
-
-#if CONFIG_FBF_DEBUG
-#define fbf_dmsg(...)   if(hal_time_stamp() > CONFIG_FBF_DEBUG) printk(__VA_ARGS__)
-#else
-#define fbf_dmsg(...)
-#endif
-
-#if CONFIG_FORK_DEBUG
-#define fork_dmsg(...)   if(hal_time_stamp() > CONFIG_FORK_DEBUG) printk(__VA_ARGS__)
-#else
-#define fork_dmsg(...)
-#endif
-
-#if CONFIG_GPT_DEBUG
-#define gpt_dmsg(...)   if(hal_time_stamp() > CONFIG_GPT_DEBUG) printk(__VA_ARGS__)
-#else
-#define gpt_dmsg(...)
-#endif
-
-#if CONFIG_GRPC_DEBUG
-#define grpc_dmsg(...)   if(hal_time_stamp() > CONFIG_GRPC_DEBUG) printk(__VA_ARGS__)
-#else
-#define grpc_dmsg(...)
-#endif
-
-#if CONFIG_IDLE_DEBUG
-#define idle_dmsg(...)   if(hal_time_stamp() > CONFIG_IDLE_DEBUG) printk(__VA_ARGS__)
-#else
-#define idle_dmsg(...)
-#endif
-
-#if CONFIG_IOC_DEBUG
-#define ioc_dmsg(...)   if(hal_time_stamp() > CONFIG_IOC_DEBUG) printk(__VA_ARGS__)
-#else
-#define ioc_dmsg(...)
-#endif
-
-#if CONFIG_IRQ_DEBUG
-#define irq_dmsg(...)   if(hal_time_stamp() > CONFIG_IRQ_DEBUG) printk(__VA_ARGS__)
-#else
-#define irq_dmsg(...)
-#endif
-
-#if CONFIG_KCM_DEBUG
-#define kcm_dmsg(...)   if(hal_time_stamp() > CONFIG_KCM_DEBUG) printk(__VA_ARGS__)
-#else
-#define kcm_dmsg(...)
-#endif
-
-#if CONFIG_KHM_DEBUG
-#define khm_dmsg(...)   if(hal_time_stamp() > CONFIG_KHM_DEBUG) printk(__VA_ARGS__)
-#else
-#define khm_dmsg(...)
-#endif
-
-#if CONFIG_KILL_DEBUG
-#define kill_dmsg(...)   if(hal_time_stamp() > CONFIG_KILL_DEBUG) printk(__VA_ARGS__)
-#else
-#define kill_dmsg(...)
-#endif
-
-#if CONFIG_KINIT_DEBUG
-#define kinit_dmsg(...)   if(hal_time_stamp() > CONFIG_KINIT_DEBUG) printk(__VA_ARGS__)
-#else
-#define kinit_dmsg(...)
-#endif
-
-#if CONFIG_KMEM_DEBUG
-#define kmem_dmsg(...)   if(hal_time_stamp() > CONFIG_KMEM_DEBUG) printk(__VA_ARGS__)
-#else
-#define kmem_dmsg(...)
-#endif
-
-#if CONFIG_MAPPER_DEBUG
-#define mapper_dmsg(...)   if(hal_time_stamp() > CONFIG_MAPPER_DEBUG) printk(__VA_ARGS__)
-#else
-#define mapper_dmsg(...)
-#endif
-
-#if CONFIG_MMAP_DEBUG
-#define mmap_dmsg(...)   if(hal_time_stamp() > CONFIG_MMAP_DEBUG) printk(__VA_ARGS__)
-#else
-#define mmap_dmsg(...)
-#endif
-
-#if CONFIG_MMC_DEBUG
-#define mmc_dmsg(...)   if(hal_time_stamp() > CONFIG_MMC_DEBUG) printk(__VA_ARGS__)
-#else
-#define mmc_dmsg(...)
-#endif
-
-#if CONFIG_NIC_DEBUG
-#define nic_dmsg(...)   if(hal_time_stamp() > CONFIG_NIC_DEBUG) printk(__VA_ARGS__)
-#else
-#define nic_dmsg(...)
-#endif
-
-#if CONFIG_PIC_DEBUG
-#define pic_dmsg(...)   if(hal_time_stamp() > CONFIG_PIC_DEBUG) printk(__VA_ARGS__)
-#else
-#define pic_dmsg(...)
-#endif
-
-#if CONFIG_PPM_DEBUG
-#define ppm_dmsg(...)   if(hal_time_stamp() > CONFIG_PPM_DEBUG) printk(__VA_ARGS__)
-#else
-#define ppm_dmsg(...)
-#endif
-
-#if CONFIG_PROCESS_DEBUG
-#define process_dmsg(...)   if(hal_time_stamp() > CONFIG_PROCESS_DEBUG) printk(__VA_ARGS__)
-#else
-#define process_dmsg(...)
-#endif
-
-#if CONFIG_READ_DEBUG
-#define read_dmsg(...)   if(hal_time_stamp() > CONFIG_READ_DEBUG) printk(__VA_ARGS__)
-#else
-#define read_dmsg(...)
-#endif
-
-#if CONFIG_RPC_DEBUG
-#define rpc_dmsg(...)   if(hal_time_stamp() > CONFIG_RPC_DEBUG) printk(__VA_ARGS__)
-#else
-#define rpc_dmsg(...)
-#endif
-
-#if CONFIG_SCHED_DEBUG
-#define sched_dmsg(...)   if(hal_time_stamp() > CONFIG_SCHED_DEBUG) printk(__VA_ARGS__)
-#else
-#define sched_dmsg(...)
-#endif
-
-#if CONFIG_SIGACTION_DEBUG
-#define sigaction_dmsg(...)   if(hal_time_stamp() > CONFIG_SIGACTION_DEBUG) printk(__VA_ARGS__)
-#else
-#define sigaction_dmsg(...)
-#endif
-
-#if CONFIG_SYSCALL_DEBUG
-#define syscall_dmsg(...)   if(hal_time_stamp() > CONFIG_SYSCALL_DEBUG) printk(__VA_ARGS__)
-#else
-#define syscall_dmsg(...)
-#endif
-
-#if CONFIG_THREAD_DEBUG
-#define thread_dmsg(...)   if(hal_time_stamp() > CONFIG_THREAD_DEBUG) printk(__VA_ARGS__)
-#else
-#define thread_dmsg(...)
-#endif
-
-#if CONFIG_TXT_DEBUG
-#define txt_dmsg(...)   if(hal_time_stamp() > CONFIG_TXT_DEBUG) printk(__VA_ARGS__)
-#else
-#define txt_dmsg(...)
-#endif
-
-#if CONFIG_VFS_DEBUG
-#define vfs_dmsg(...)   if(hal_time_stamp() > CONFIG_VFS_DEBUG) printk(__VA_ARGS__)
-#else
-#define vfs_dmsg(...)
-#endif
-
-#if CONFIG_VMM_DEBUG
-#define vmm_dmsg(...)   if(hal_time_stamp() > CONFIG_VMM_DEBUG) printk(__VA_ARGS__)
-#else
-#define vmm_dmsg(...)
-#endif
-
-#if CONFIG_WRITE_DEBUG
-#define write_dmsg(...)   if(hal_time_stamp() > CONFIG_WRITE_DEBUG) printk(__VA_ARGS__)
-#else
-#define write_dmsg(...)
-#endif
-
-*/
-
 #endif  // _PRINTK_H
 

trunk/kernel/kern/process.c

@@ -1 +1 @@
 /*
- * process.c - process related management
+ * process.c - process related functions definition.
  *
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
@@ -43 +43 @@
 #include <string.h>
 #include <scheduler.h>
-#include <remote_spinlock.h>
+#include <busylock.h>
+#include <queuelock.h>
+#include <remote_queuelock.h>
+#include <rwlock.h>
+#include <remote_rwlock.h>
 #include <dqdt.h>
 #include <cluster.h>
@@ -114 +118 @@
 
     // get parent_pid
-    parent_pid = hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid ) );
+    parent_pid = hal_remote_l32( XPTR( parent_cxy , &parent_ptr->pid ) );
 
 #if DEBUG_PROCESS_REFERENCE_INIT
@@ -132 +136 @@
     // initialize vmm as empty 
     error = vmm_init( process );
-    assert( (error == 0) , "cannot initialize VMM\n" );
+
+assert( (error == 0) , "cannot initialize VMM\n" );
  
 #if (DEBUG_PROCESS_REFERENCE_INIT & 1)
@@ -138 +143 @@
 if( DEBUG_PROCESS_REFERENCE_INIT )
 printk("\n[DBG] %s : thread %x in process %x / vmm empty for process %x / cycle %d\n", 
-__FUNCTION__, CURRENT_THREAD->trdid, parent_pid , cycle );
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid , pid, cycle );
 #endif
 
@@ -160 +165 @@
 __FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, txt_id, cycle );
 #endif
-
-
-
         // build path to TXT_RX[i] and TXT_TX[i] chdevs
         snprintf( rx_path , 40 , "/dev/external/txt%d_rx", txt_id );
@@ -175 +177 @@
                            &stdin_id );
 
-        assert( (error == 0) , "cannot open stdin pseudo file" );
-        assert( (stdin_id == 0) , "stdin index must be 0" );
+assert( (error == 0) , "cannot open stdin pseudo file" );
+assert( (stdin_id == 0) , "stdin index must be 0" );
 
 #if (DEBUG_PROCESS_REFERENCE_INIT & 1)
@@ -225 +227 @@
     {
         // get extended pointer on stdin pseudo file in parent process
-        file_xp = (xptr_t)hal_remote_lwd( XPTR( parent_cxy , &parent_ptr->fd_array.array[0] ) );
+        file_xp = (xptr_t)hal_remote_l64( XPTR( parent_cxy , &parent_ptr->fd_array.array[0] ) );
 
         // get extended pointer on parent process TXT chdev
@@ -234 +236 @@
         chdev_ptr = GET_PTR( chdev_xp );
  
-        // get TXT terminal index
-        txt_id = hal_remote_lw( XPTR( chdev_cxy , &chdev_ptr->channel ) );
-
-        // attach process to TXT[txt_id]
+        // get parent process TXT terminal index
+        txt_id = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->channel ) );
+
+        // attach child process to parent process TXT terminal
         process_txt_attach( process , txt_id ); 
 
@@ -246 +248 @@
 
     // initialize specific inodes root and cwd
-    process->vfs_root_xp = (xptr_t)hal_remote_lwd( XPTR( parent_cxy,
+    process->vfs_root_xp = (xptr_t)hal_remote_l64( XPTR( parent_cxy,
                                                          &parent_ptr->vfs_root_xp ) );
-    process->vfs_cwd_xp  = (xptr_t)hal_remote_lwd( XPTR( parent_cxy,
+    process->vfs_cwd_xp  = (xptr_t)hal_remote_l64( XPTR( parent_cxy,
                                                          &parent_ptr->vfs_cwd_xp ) );
     vfs_inode_remote_up( process->vfs_root_xp );
     vfs_inode_remote_up( process->vfs_cwd_xp );
 
-    remote_rwlock_init( XPTR( local_cxy , &process->cwd_lock ) );
+    remote_rwlock_init( XPTR( local_cxy , &process->cwd_lock ), LOCK_PROCESS_CWD );
 
 #if (DEBUG_PROCESS_REFERENCE_INIT & 1)
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
-printk("\n[DBG] %s : thread %x / fd_array for process %x / cycle %d\n", 
-__FUNCTION__ , CURRENT_THREAD , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x / set fd_array for process %x / cycle %d\n", 
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid , cycle );
 #endif
 
@@ -265 +267 @@
     xlist_root_init( XPTR( local_cxy , &process->children_root ) );
     process->children_nr     = 0;
-    remote_spinlock_init( XPTR( local_cxy , &process->children_lock ) );
+    remote_queuelock_init( XPTR( local_cxy , &process->children_lock ), LOCK_PROCESS_CHILDREN );
 
     // reset semaphore / mutex / barrier / condvar list roots 
@@ -272 +274 @@
     xlist_root_init( XPTR( local_cxy , &process->barrier_root ) );
     xlist_root_init( XPTR( local_cxy , &process->condvar_root ) );
-    remote_spinlock_init( XPTR( local_cxy , &process->sync_lock ) );
+    remote_queuelock_init( XPTR( local_cxy , &process->sync_lock ), LOCK_PROCESS_USERSYNC );
 
     // register new process in the local cluster manager pref_tbl[]
@@ -284 +286 @@
     cluster_process_copies_link( process );
 
-    // reset th_tbl[] array as empty in process descriptor
+    // initialize th_tbl[] array and associated threads
     uint32_t i;
-    for( i = 0 ; i < CONFIG_THREAD_MAX_PER_CLUSTER ; i++ )
+
+    for( i = 0 ; i < CONFIG_THREADS_MAX_PER_CLUSTER ; i++ )
         {
         process->th_tbl[i] = NULL;
     }
     process->th_nr  = 0;
-    spinlock_init( &process->th_lock );
+    rwlock_init( &process->th_lock , LOCK_PROCESS_THTBL );
 
         hal_fence();
@@ -298 +301 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
-printk("\n[DBG] %s : thread %x exit / process %x / cycle %d\n", 
-__FUNCTION__ , CURRENT_THREAD , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x exit for process %x / cycle %d\n", 
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
 #endif
 
@@ -315 +318 @@
 
     // initialize PID, REF_XP, PARENT_XP, and STATE
-    local_process->pid        = hal_remote_lw(  XPTR( ref_cxy , &ref_ptr->pid ) );
-    local_process->parent_xp  = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->parent_xp ) );
+    local_process->pid        = hal_remote_l32(  XPTR( ref_cxy , &ref_ptr->pid ) );
+    local_process->parent_xp  = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->parent_xp ) );
     local_process->ref_xp     = reference_process_xp;
     local_process->owner_xp   = reference_process_xp;
     local_process->term_state = 0;
 
-#if DEBUG_PROCESS_COPY_INIT 
+#if DEBUG_PROCESS_COPY_INIT
+thread_t * this = CURRET_THREAD;  
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_COPY_INIT )
-printk("\n[DBG] %s : thread %x enter for process %x\n",
-__FUNCTION__ , CURRENT_THREAD , local_process->pid );
-#endif
+printk("\n[DBG] %s : thread %x in process %x enter for process %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, local_process->pid, cycle );
+#endif
+
+// check user process
+assert( (local_process->pid != 0), "PID cannot be 0" );
 
     // reset local process vmm
@@ -336 +343 @@
 
     // reset vfs_root_xp / vfs_bin_xp / vfs_cwd_xp fields
-    local_process->vfs_root_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_root_xp ) );
-    local_process->vfs_bin_xp  = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_bin_xp ) );
+    local_process->vfs_root_xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->vfs_root_xp ) );
+    local_process->vfs_bin_xp  = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->vfs_bin_xp ) );
     local_process->vfs_cwd_xp  = XPTR_NULL;
 
@@ -343 +350 @@
     xlist_root_init( XPTR( local_cxy , &local_process->children_root ) );
     local_process->children_nr   = 0;
-    remote_spinlock_init( XPTR( local_cxy , &local_process->children_lock ) );
+    remote_queuelock_init( XPTR( local_cxy , &local_process->children_lock ),
+                           LOCK_PROCESS_CHILDREN );
 
     // reset children_list (not used in a process descriptor copy)
@@ -354 +362 @@
     xlist_root_init( XPTR( local_cxy , &local_process->condvar_root ) );
 
-    // reset th_tbl[] array as empty
+    // initialize th_tbl[] array and associated fields
     uint32_t i;
-    for( i = 0 ; i < CONFIG_THREAD_MAX_PER_CLUSTER ; i++ )
+    for( i = 0 ; i < CONFIG_THREADS_MAX_PER_CLUSTER ; i++ )
         {
         local_process->th_tbl[i] = NULL;
     }
     local_process->th_nr  = 0;
-    spinlock_init( &local_process->th_lock );
+    rwlock_init( &local_process->th_lock , LOCK_PROCESS_THTBL );
+
 
     // register new process descriptor in local cluster manager local_list
@@ -374 +383 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_COPY_INIT )
-printk("\n[DBG] %s : thread %x exit for process %x\n",
-__FUNCTION__ , CURRENT_THREAD , local_process->pid );
+printk("\n[DBG] %s : thread %x in process %x exit for process %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, local_process->pid, cycle );
 #endif
 
@@ -399 +408 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_DESTROY )
-printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , pid , local_cxy , cycle );
+printk("\n[DBG] %s : thread %x in process %x enter for process %x in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, pid, local_cxy, cycle );
 #endif
 
@@ -423 +432 @@
 
         // remove process from children_list
-        remote_spinlock_lock( children_lock_xp );
+        remote_queuelock_acquire( children_lock_xp );
         xlist_unlink( XPTR( local_cxy , &process->children_list ) );
             hal_remote_atomic_add( children_nr_xp , -1 );
-        remote_spinlock_unlock( children_lock_xp );
-
-    // release the process PID to cluster manager
-    cluster_pid_release( pid );
-
-    }
-
-    // FIXME close all open files and update dirty [AG]
+        remote_queuelock_release( children_lock_xp );
+
+        // release the process PID to cluster manager
+        cluster_pid_release( pid );
+    }
+
+    // FIXME close all open files and synchronize dirty [AG]
 
     // decrease refcount for bin file, root file and cwd file
@@ -449 +457 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_DESTROY )
-printk("\n[DBG] %s : thread %x exit / destroyed process %x in cluster %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , pid, local_cxy, cycle );
+printk("\n[DBG] %s : thread %x in process %x exit / process %x in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, pid, local_cxy, cycle );
 #endif
 
@@ -491 +499 @@
     remote_nr = 0;
 
+// check calling thread can yield
+assert( (client->busylocks == 0),
+"cannot yield : busylocks = %d\n", client->busylocks );
+
 #if DEBUG_PROCESS_SIGACTION
 uint32_t cycle = (uint32_t)hal_get_cycles();
@@ -517 +529 @@
 
     // The client thread send parallel RPCs to all remote clusters containing
-    // target process copies, wait all responses, and then handles directly the
-    // threads in local cluster, when required.
+    // target process copies, wait all responses, and then handles directly 
+    // the threads in local cluster, when required.
     // The client thread allocates a - shared - RPC descriptor in the stack,
     // because all parallel, non-blocking, server threads use the same input 
@@ -529 +541 @@
     thread_block( client_xp , THREAD_BLOCKED_RPC );
 
-    // take the lock protecting the copies
-    remote_spinlock_lock( lock_xp );
+    // take the lock protecting process copies
+    remote_queuelock_acquire( lock_xp );
 
     // initialize shared RPC descriptor
@@ -573 +585 @@
 
     // release the lock protecting process copies
-    remote_spinlock_unlock( lock_xp );
+    remote_queuelock_release( lock_xp );
 
     // restore IRQs
@@ -620 +632 @@
     thread_t          * target;         // pointer on target thread 
     thread_t          * this;           // pointer on calling thread 
-    uint32_t            ltid;           // index in process th_tbl
+    uint32_t            ltid;           // index in process th_tbl[]
     cxy_t               owner_cxy;      // target process owner cluster
     uint32_t            count;          // requests counter
@@ -628 +640 @@
     this = CURRENT_THREAD;
 
+#if DEBUG_PROCESS_SIGACTION
+pid_t pid = process->pid;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x in process %x enter for process %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, pid, local_cxy , cycle );
+#endif
+
+// check target process is an user process
+assert( ( process->pid != 0 ),
+"target process must be an user process" );
+
     // get target process owner cluster
     owner_cxy = CXY_FROM_PID( process->pid );
 
-#if DEBUG_PROCESS_SIGACTION
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_SIGACTION < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
-__FUNCTION__ , this , process->pid , local_cxy , cycle );
-#endif
-
     // get lock protecting process th_tbl[]
-    spinlock_lock( &process->th_lock );
+    rwlock_rd_acquire( &process->th_lock );
 
     // loop on target process local threads 
@@ -680 +697 @@
 
     // release lock protecting process th_tbl[]
-    spinlock_unlock( &process->th_lock );
-
-    // wait acknowledges 
+    rwlock_rd_release( &process->th_lock );
+
+    // busy waiting acknowledges 
+    // TODO this could be improved...
     while( 1 )
     {
@@ -695 +713 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_SIGACTION < cycle )
-printk("\n[DBG] %s : thread %x exit for process %x in cluster %x / cycle %d\n",
-__FUNCTION__ , this , process->pid , local_cxy , cycle );
+printk("\n[DBG] %s : thread %x in process %x exit for process %x in cluster %x / cycle %d\n",
+__FUNCTION__, this, this->process->pid, pid, local_cxy , cycle );
 #endif
 
@@ -719 +737 @@
 
 #if DEBUG_PROCESS_SIGACTION
+pid_t pid = process->pid;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_SIGACTION < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
-__FUNCTION__ , this , process->pid , local_cxy , cycle );
-#endif
+printk("\n[DBG] %s : thread %x n process %x enter for process %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, pid, local_cxy , cycle );
+#endif
+
+// check target process is an user process
+assert( ( process->pid != 0 ),
+"target process must be an user process" );
 
     // get lock protecting process th_tbl[]
-    spinlock_lock( &process->th_lock );
+    rwlock_rd_acquire( &process->th_lock );
 
     // loop on target process local threads                       
@@ -739 +762 @@
             target_xp = XPTR( local_cxy , target );
 
-            // main thread and client thread should not be blocked
+            // main thread and client thread should not be deleted
             if( ((ltid != 0) || (owner_cxy != local_cxy)) &&         // not main thread
                 (client_xp) != target_xp )                           // not client thread
@@ -750 +773 @@
 
     // release lock protecting process th_tbl[]
-    spinlock_unlock( &process->th_lock );
+    rwlock_rd_release( &process->th_lock );
 
 #if DEBUG_PROCESS_SIGACTION
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_SIGACTION < cycle )
-printk("\n[DBG] %s : thread %x exit for process %x in cluster %x / cycle %d\n",
-__FUNCTION__ , this , process->pid , local_cxy , cycle );
+printk("\n[DBG] %s : thread %x in process %x exit for process %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, pid, local_cxy , cycle );
 #endif
 
@@ -773 +796 @@
 
 #if DEBUG_PROCESS_SIGACTION
+pid_t pid = process->pid;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_SIGACTION < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
-__FUNCTION__ , this , process->pid , local_cxy , cycle );
-#endif
+printk("\n[DBG] %s : thread %x in process %x enter for process %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, pid, local_cxy , cycle );
+#endif
+
+// check target process is an user process
+assert( ( process->pid != 0 ),
+"target process must be an user process" );
 
     // get lock protecting process th_tbl[]
-    spinlock_lock( &process->th_lock );
+    rwlock_rd_acquire( &process->th_lock );
 
     // loop on process threads to unblock all threads
@@ -798 +826 @@
 
     // release lock protecting process th_tbl[]
-    spinlock_unlock( &process->th_lock );
+    rwlock_rd_release( &process->th_lock );
 
 #if DEBUG_PROCESS_SIGACTION
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_SIGACTION < cycle )
-printk("\n[DBG] %s : thread %x exit for process %x in cluster %x / cycle %d\n",
-__FUNCTION__ , this , process->pid , local_cxy , cycle );
+printk("\n[DBG] %s : thread %x in process %x exit for process %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, pid, local_cxy, cycle );
 #endif
 
@@ -818 +846 @@
     cluster_t * cluster = LOCAL_CLUSTER;
 
+#if DEBUG_PROCESS_GET_LOCAL_COPY
+thread_t * this = CURRENT_THREAD;
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_GET_LOCAL_COPY < cycle )
+printk("\n[DBG] %s : thread %x in cluster %x enter for process %x in cluster %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, pid, local_cxy, cycle );
+#endif
+
     // get lock protecting local list of processes
-    remote_spinlock_lock( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
+    remote_queuelock_acquire( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
 
     // scan the local list of process descriptors to find the process
@@ -836 +872 @@
 
     // release lock protecting local list of processes
-    remote_spinlock_unlock( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
+    remote_queuelock_release( XPTR( local_cxy , &cluster->pmgr.local_lock ) );
 
     // allocate memory for a new local process descriptor
@@ -859 +895 @@
 
 #if DEBUG_PROCESS_GET_LOCAL_COPY
-uint32_t cycle = (uint32_t)hal_get_cycles();
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_GET_LOCAL_COPY < cycle )
-printk("\n[DBG] %s : enter in cluster %x / pid %x / process %x / cycle %d\n",
-__FUNCTION__ , local_cxy , pid , process_ptr , cycle );
+printk("\n[DBG] %s : thread %x in cluster %x exit in cluster %x / process %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, local_cxy, process_ptr, cycle );
 #endif
 
@@ -883 +919 @@
 
     // get pointers on parent process
-    parent_xp  = (xptr_t)hal_remote_lwd( XPTR( process_cxy , &process_ptr->parent_xp ) );
+    parent_xp  = (xptr_t)hal_remote_l64( XPTR( process_cxy , &process_ptr->parent_xp ) );
     parent_cxy = GET_CXY( parent_xp );
     parent_ptr = GET_PTR( parent_xp );
 
-    return hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid ) );
+    return hal_remote_l32( XPTR( parent_cxy , &parent_ptr->pid ) );
 }
 
@@ -899 +935 @@
     uint32_t fd;
 
-    remote_spinlock_init( XPTR( local_cxy , &process->fd_array.lock ) );
+    remote_queuelock_init( XPTR( local_cxy , &process->fd_array.lock ), LOCK_PROCESS_FDARRAY );
 
     process->fd_array.current = 0;
@@ -909 +945 @@
     }
 }
-
-//////////////////////////////
-bool_t process_fd_array_full( void )
-{
-    // get extended pointer on reference process
-    xptr_t ref_xp = CURRENT_THREAD->process->ref_xp;
-
-    // get reference process cluster and local pointer
-    process_t * ref_ptr = GET_PTR( ref_xp );
-    cxy_t       ref_cxy = GET_CXY( ref_xp );
-
-    // get number of open file descriptors from reference fd_array
-    uint32_t current = hal_remote_lw( XPTR( ref_cxy , &ref_ptr->fd_array.current ) );
-
-        return ( current >= CONFIG_PROCESS_FILE_MAX_NR );
-}
-
 /////////////////////////////////////////////////
 error_t process_fd_register( process_t * process,
@@ -933 +952 @@
     bool_t    found;
     uint32_t  id;
+    uint32_t  count;
     xptr_t    xp;
 
@@ -941 +961 @@
 
     // take lock protecting reference fd_array
-        remote_spinlock_lock( XPTR( ref_cxy , &ref_ptr->fd_array.lock ) );
+        remote_queuelock_acquire( XPTR( ref_cxy , &ref_ptr->fd_array.lock ) );
 
     found   = false;
@@ -947 +967 @@
     for ( id = 0; id < CONFIG_PROCESS_FILE_MAX_NR ; id++ )
     {
-        xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->fd_array.array[id] ) );
+        xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->fd_array.array[id] ) );
         if ( xp == XPTR_NULL )
         {
+            // update reference fd_array
+            hal_remote_s64( XPTR( ref_cxy , &ref_ptr->fd_array.array[id] ) , file_xp );
+                count = hal_remote_l32( XPTR( ref_cxy , &ref_ptr->fd_array.current ) ) + 1;
+            hal_remote_s32( XPTR( ref_cxy , &ref_ptr->fd_array.current ) , count );
+
+            // update local fd_array copy if required
+            if( ref_cxy != local_cxy )
+            {
+                process->fd_array.array[id] = file_xp;
+                process->fd_array.current   = count;
+            }
+
+            // exit
+                        *fdid = id;
             found = true;
-            hal_remote_swd( XPTR( ref_cxy , &ref_ptr->fd_array.array[id] ) , file_xp );
-                hal_remote_atomic_add( XPTR( ref_cxy , &ref_ptr->fd_array.current ) , 1 );
-                        *fdid = id;
             break;
         }
@@ -959 +990 @@
 
     // release lock protecting reference fd_array
-        remote_spinlock_unlock( XPTR( ref_cxy , &ref_ptr->fd_array.lock ) );
+        remote_queuelock_release( XPTR( ref_cxy , &ref_ptr->fd_array.lock ) );
 
     if ( !found ) return -1;
@@ -970 +1001 @@
 {
     xptr_t  file_xp;
+    xptr_t  lock_xp;
 
     // access local copy of process descriptor
@@ -981 +1013 @@
         process_t * ref_ptr = GET_PTR( ref_xp );
 
+        // build extended pointer on lock protecting reference fd_array
+        lock_xp = XPTR( ref_cxy , &ref_ptr->fd_array.lock );
+
+        // take lock protecting reference fd_array
+            remote_queuelock_acquire( lock_xp );
+
         // access reference process descriptor
-        file_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->fd_array.array[fdid] ) );
+        file_xp = hal_remote_l64( XPTR( ref_cxy , &ref_ptr->fd_array.array[fdid] ) );
 
         // update local fd_array if found
-        if( file_xp != XPTR_NULL )
-        {
-            process->fd_array.array[fdid] = file_xp;
-        }
+        if( file_xp != XPTR_NULL )  process->fd_array.array[fdid] = file_xp;
+        
+        // release lock protecting reference fd_array
+            remote_queuelock_release( lock_xp );
     }
 
@@ -1011 +1049 @@
 
     // get the remote lock protecting the src fd_array
-        remote_spinlock_lock( XPTR( src_cxy , &src_ptr->lock ) );
+        remote_queuelock_acquire( XPTR( src_cxy , &src_ptr->lock ) );
 
     // loop on all fd_array entries
     for( fd = 0 ; fd < CONFIG_PROCESS_FILE_MAX_NR ; fd++ )
         {
-                entry = (xptr_t)hal_remote_lwd( XPTR( src_cxy , &src_ptr->array[fd] ) );
+                entry = (xptr_t)hal_remote_l64( XPTR( src_cxy , &src_ptr->array[fd] ) );
 
                 if( entry != XPTR_NULL )
@@ -1024 +1062 @@
 
                         // copy entry in destination process fd_array
-                        hal_remote_swd( XPTR( dst_cxy , &dst_ptr->array[fd] ) , entry );
+                        hal_remote_s64( XPTR( dst_cxy , &dst_ptr->array[fd] ) , entry );
                 }
         }
 
     // release lock on source process fd_array
-        remote_spinlock_unlock( XPTR( src_cxy , &src_ptr->lock ) );
+        remote_queuelock_release( XPTR( src_cxy , &src_ptr->lock ) );
 
 }  // end process_fd_remote_copy()
+
+
+////////////////////////////////////
+bool_t process_fd_array_full( void )
+{
+    // get extended pointer on reference process
+    xptr_t ref_xp = CURRENT_THREAD->process->ref_xp;
+
+    // get reference process cluster and local pointer
+    process_t * ref_ptr = GET_PTR( ref_xp );
+    cxy_t       ref_cxy = GET_CXY( ref_xp );
+
+    // get number of open file descriptors from reference fd_array
+    uint32_t current = hal_remote_l32( XPTR( ref_cxy , &ref_ptr->fd_array.current ) );
+
+        return ( current >= CONFIG_PROCESS_FILE_MAX_NR );
+}
+
 
 ////////////////////////////////////////////////////////////////////////////////////
@@ -1043 +1099 @@
 {
     ltid_t         ltid;
-    reg_t          save_sr;
     bool_t         found = false;
  
-
-    assert( (process != NULL) , "process argument is NULL" );
-
-    assert( (thread != NULL) , "thread argument is NULL" );
-
-    // take lock protecting th_tbl, depending on thread type:
-    // we don't want to use a descheduling policy for idle thread initialisation
-    if ( thread->type == THREAD_IDLE ) {
-        spinlock_lock_busy( &process->th_lock , &save_sr );
-    } else {
-        spinlock_lock( &process->th_lock );
-    }
-
-    // search a free slot in th_tbl[] 
-    for( ltid = 0 ; ltid < CONFIG_THREAD_MAX_PER_CLUSTER ; ltid++ )
+// check arguments
+assert( (process != NULL) , "process argument is NULL" );
+assert( (thread != NULL) , "thread argument is NULL" );
+
+    // get the lock protecting th_tbl for all threads
+    // but the idle thread executing kernel_init (cannot yield)
+    if( thread->type != THREAD_IDLE ) rwlock_wr_acquire( &process->th_lock );
+
+    // scan kth_tbl
+    for( ltid = 0 ; ltid < CONFIG_THREADS_MAX_PER_CLUSTER ; ltid++ )
     {
         if( process->th_tbl[ltid] == NULL )
@@ -1079 +1129 @@
     }
 
-    // release lock protecting th_tbl
-    hal_fence();
-    if( thread->type == THREAD_IDLE ) {
-        spinlock_unlock_busy( &process->th_lock , save_sr );
-    } else {
-        spinlock_unlock( &process->th_lock );
-    }
-
-    return (found) ? 0 : ENOMEM;
+    // get the lock protecting th_tbl for all threads
+    // but the idle thread executing kernel_init (cannot yield)
+    if( thread->type != THREAD_IDLE ) rwlock_wr_release( &process->th_lock );
+
+    return (found) ? 0 : 0xFFFFFFFF;
 
 }  // end process_register_thread()
@@ -1096 +1142 @@
     uint32_t count;  // number of threads in local process descriptor
 
-    assert( (thread != NULL) , "thread argument is NULL" );
+// check argument
+assert( (thread != NULL) , "thread argument is NULL" );
 
     process_t * process = thread->process;
@@ -1102 +1149 @@
     // get thread local index
     ltid_t  ltid = LTID_FROM_TRDID( thread->trdid );
-
-    // take lock protecting th_tbl
-    spinlock_lock( &process->th_lock );
-
+    
+    // the lock depends on thread user/kernel type, because we cannot
+    // use a descheduling policy for the lock protecting the kth_tbl
+
+    // get the lock protecting th_tbl[]
+    rwlock_wr_acquire( &process->th_lock );
+
+    // get number of kernel threads
     count = process->th_nr;
 
-    assert( (count > 0) , "process th_nr cannot be 0\n" );
+// check th_nr value
+assert( (count > 0) , "process kth_nr cannot be 0\n" );
 
     // remove thread from th_tbl[]
@@ -1114 +1166 @@
     process->th_nr = count-1;
 
-    // release lock protecting th_tbl
-    hal_fence();
-    spinlock_unlock( &process->th_lock );
+    // release lock protecting kth_tbl
+    rwlock_wr_release( &process->th_lock );
 
     return (count == 1);
@@ -1141 +1192 @@
 
     // get parent process PID and extended pointer on .elf file
-    parent_pid = hal_remote_lw (XPTR( parent_process_cxy , &parent_process_ptr->pid));
-    vfs_bin_xp = hal_remote_lwd(XPTR( parent_process_cxy , &parent_process_ptr->vfs_bin_xp));
-
-    // check parent process is the reference process
-    ref_xp = hal_remote_lwd( XPTR( parent_process_cxy , &parent_process_ptr->ref_xp ) );
-
-    assert( (parent_process_xp == ref_xp ) ,
-    "parent process must be the reference process\n" );
+    parent_pid = hal_remote_l32 (XPTR( parent_process_cxy , &parent_process_ptr->pid));
+    vfs_bin_xp = hal_remote_l64(XPTR( parent_process_cxy , &parent_process_ptr->vfs_bin_xp));
+
+    // get extended pointer on reference process
+    ref_xp = hal_remote_l64( XPTR( parent_process_cxy , &parent_process_ptr->ref_xp ) );
+
+// check parent process is the reference process
+assert( (parent_process_xp == ref_xp ) ,
+"parent process must be the reference process\n" );
 
 #if DEBUG_PROCESS_MAKE_FORK
@@ -1195 +1247 @@
 #endif
 
-    // give TXT ownership to child process
-    process_txt_set_ownership( XPTR( local_cxy , process ) );
 
     // copy VMM from parent descriptor to child descriptor
@@ -1218 +1268 @@
 #endif
 
-    // parent process gives TXT ownership to child process if required
-    if( process_txt_is_owner(parent_process_xp) ) 
+    // if parent_process is INIT, or if parent_process is the TXT owner,
+    // the child_process becomes the owner of its TXT terminal
+    if( (parent_pid == 1) || process_txt_is_owner( parent_process_xp ) )
     {
         process_txt_set_ownership( XPTR( local_cxy , process ) );
@@ -1226 +1277 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
-printk("\n[DBG] %s : thread %x in process %x gives TXT from parent %x to child %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
-parent_pid, new_pid, cycle );
+printk("\n[DBG] %s : thread %x in process %x / child takes TXT ownership / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
 #endif
 
@@ -1249 +1299 @@
     }
 
-    // check main thread LTID
-    assert( (LTID_FROM_TRDID(thread->trdid) == 0) ,
-    "main thread must have LTID == 0\n" );
-
-//#if( DEBUG_PROCESS_MAKE_FORK & 1 )
-#if DEBUG_PROCESS_MAKE_FORK 
+// check main thread LTID
+assert( (LTID_FROM_TRDID(thread->trdid) == 0) ,
+"main thread must have LTID == 0\n" );
+
+#if( DEBUG_PROCESS_MAKE_FORK & 1 )
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
@@ -1289 +1338 @@
 
     // register process in parent children list
-    remote_spinlock_lock( children_lock_xp );
+    remote_queuelock_acquire( children_lock_xp );
         xlist_add_last( children_root_xp , XPTR( local_cxy , &process->children_list ) );
         hal_remote_atomic_add( children_nr_xp , 1 );
-    remote_spinlock_unlock( children_lock_xp );
+    remote_queuelock_release( children_lock_xp );
 
     // return success
@@ -1341 +1390 @@
     // open the file identified by <path>
     file_xp = XPTR_NULL;
-    file_id = -1;
+    file_id = 0xFFFFFFFF;
         error   = vfs_open( process,
                             path,
@@ -1442 +1491 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_ZERO_CREATE < cycle )
-printk("\n[DBG] %s : thread %x enter / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : enter / cluster %x / cycle %d\n",
+__FUNCTION__, local_cxy, cycle );
 #endif
 
@@ -1452 +1502 @@
     process->term_state = 0;
 
-    // reset th_tbl[] array as empty
+    // reset th_tbl[] array and associated fields
     uint32_t i;
-    for( i = 0 ; i < CONFIG_THREAD_MAX_PER_CLUSTER ; i++ )
+    for( i = 0 ; i < CONFIG_THREADS_MAX_PER_CLUSTER ; i++ )
         {
         process->th_tbl[i] = NULL;
     }
     process->th_nr  = 0;
-    spinlock_init( &process->th_lock );
+    rwlock_init( &process->th_lock , LOCK_PROCESS_THTBL );
+
 
     // reset children list as empty
     xlist_root_init( XPTR( local_cxy , &process->children_root ) );
-    remote_spinlock_init( XPTR( local_cxy , &process->children_lock ) );
     process->children_nr = 0;
+    remote_queuelock_init( XPTR( local_cxy , &process->children_lock ),
+                           LOCK_PROCESS_CHILDREN );
 
         hal_fence();
@@ -1471 +1523 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_ZERO_CREATE < cycle )
-printk("\n[DBG] %s : thread %x exit / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : exit / cluster %x / cycle %d\n",
+__FUNCTION__, local_cxy, cycle );
 #endif
 
 }  // end process_zero_init()
 
-//////////////////////////
+////////////////////////////////
 void process_init_create( void )
 {
@@ -1498 +1551 @@
         process = process_alloc(); 
         
-    assert( (process != NULL),
-    "no memory for process descriptor in cluster %x\n", local_cxy  );
+// check memory allocator
+assert( (process != NULL),
+"no memory for process descriptor in cluster %x\n", local_cxy  );
 
     // get PID from local cluster
     error = cluster_pid_alloc( process , &pid );
 
-    assert( (error == 0),
-    "cannot allocate PID in cluster %x\n", local_cxy );
-
-    assert( (pid == 1) ,
-    "process INIT must be first process in cluster 0\n" );
+// check PID allocator 
+assert( (error == 0),
+"cannot allocate PID in cluster %x\n", local_cxy );
+
+// check PID value
+assert( (pid == 1) ,
+"process INIT must be first process in cluster 0\n" );
 
     // initialize process descriptor / parent is local process_zero
@@ -1514 +1570 @@
                             pid,
                             XPTR( local_cxy , &process_zero ) );  
+
+#if(DEBUG_PROCESS_INIT_CREATE & 1)
+if( DEBUG_PROCESS_INIT_CREATE < cycle )
+printk("\n[DBG] %s : thread %x in process %x initialized process descriptor\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid );
+#endif
 
     // open the file identified by CONFIG_PROCESS_INIT_PATH
@@ -1525 +1587 @@
                             &file_id );
 
-        assert( (error == 0),
-    "failed to open file <%s>\n", CONFIG_PROCESS_INIT_PATH );
-
-    // register "code" and "data" vsegs as well as entry-point
+assert( (error == 0),
+"failed to open file <%s>\n", CONFIG_PROCESS_INIT_PATH );
+
+#if(DEBUG_PROCESS_INIT_CREATE & 1)
+if( DEBUG_PROCESS_INIT_CREATE < cycle )
+printk("\n[DBG] %s : thread %x in process %x open .elf file decriptor\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid );
+#endif
+
+   // register "code" and "data" vsegs as well as entry-point
     // in process VMM, using information contained in the elf file.
         error = elf_load_process( file_xp , process );
 
-        assert( (error == 0),
-    "cannot access .elf file <%s>\n", CONFIG_PROCESS_INIT_PATH );
+assert( (error == 0),
+"cannot access .elf file <%s>\n", CONFIG_PROCESS_INIT_PATH );
+
+#if(DEBUG_PROCESS_INIT_CREATE & 1)
+if( DEBUG_PROCESS_INIT_CREATE < cycle )
+printk("\n[DBG] %s : thread %x in process %x registered code/data vsegs in VMM\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid );
+#endif
 
     // get extended pointers on process_zero children_root, children_lock
@@ -1539 +1613 @@
     xptr_t children_lock_xp = XPTR( local_cxy , &process_zero.children_lock );
 
+    // take lock protecting kernel process children list
+    remote_queuelock_acquire( children_lock_xp );
+
     // register process INIT in parent local process_zero 
-    remote_spinlock_lock( children_lock_xp );
         xlist_add_last( children_root_xp , XPTR( local_cxy , &process->children_list ) );
         hal_atomic_add( &process_zero.children_nr , 1 );
-    remote_spinlock_unlock( children_lock_xp );
+
+    // release lock protecting kernel process children list
+    remote_queuelock_release( children_lock_xp );
+
+#if(DEBUG_PROCESS_INIT_CREATE & 1)
+if( DEBUG_PROCESS_INIT_CREATE < cycle )
+printk("\n[DBG] %s : thread %x in process %x registered init process in parent\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid );
+#endif
 
     // select a core in local cluster to execute the main thread
@@ -1560 +1644 @@
                                 &thread );
 
-        assert( (error == 0),
-    "cannot create main thread for <%s>\n", CONFIG_PROCESS_INIT_PATH );
-
-    assert( (thread->trdid == 0),
-    "main thread must have index 0 for <%s>\n", CONFIG_PROCESS_INIT_PATH );
+assert( (error == 0),
+"cannot create main thread for <%s>\n", CONFIG_PROCESS_INIT_PATH );
+
+assert( (thread->trdid == 0),
+"main thread must have index 0 for <%s>\n", CONFIG_PROCESS_INIT_PATH );
+
+#if(DEBUG_PROCESS_INIT_CREATE & 1)
+if( DEBUG_PROCESS_INIT_CREATE < cycle )
+printk("\n[DBG] %s : thread %x in process %x created main thread\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid );
+#endif
 
     // activate thread
@@ -1618 +1708 @@
 
     // get PID and state
-    pid   = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
-    state = hal_remote_lw( XPTR( process_cxy , &process_ptr->term_state ) );
+    pid   = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
+    state = hal_remote_l32( XPTR( process_cxy , &process_ptr->term_state ) );
 
     // get PPID
-    parent_xp  = hal_remote_lwd( XPTR( process_cxy , &process_ptr->parent_xp ) );
+    parent_xp  = hal_remote_l64( XPTR( process_cxy , &process_ptr->parent_xp ) );
     parent_cxy = GET_CXY( parent_xp );
     parent_ptr = GET_PTR( parent_xp );
-    ppid       = hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid ) );
+    ppid       = hal_remote_l32( XPTR( parent_cxy , &parent_ptr->pid ) );
 
     // get number of threads
-    th_nr      = hal_remote_lw( XPTR( process_cxy , &process_ptr->th_nr ) );
+    th_nr      = hal_remote_l32( XPTR( process_cxy , &process_ptr->th_nr ) );
 
     // get pointers on owner process descriptor
-    owner_xp  = hal_remote_lwd( XPTR( process_cxy , &process_ptr->owner_xp ) );
+    owner_xp  = hal_remote_l64( XPTR( process_cxy , &process_ptr->owner_xp ) );
     owner_cxy = GET_CXY( owner_xp );
     owner_ptr = GET_PTR( owner_xp );
 
     // get extended pointer on TXT_RX file descriptor attached to process
-    txt_file_xp = hal_remote_lwd( XPTR( owner_cxy , &owner_ptr->fd_array.array[0] ) );
+    txt_file_xp = hal_remote_l64( XPTR( owner_cxy , &owner_ptr->fd_array.array[0] ) );
 
     assert( (txt_file_xp != XPTR_NULL) ,
@@ -1650 +1740 @@
                        XPTR( txt_chdev_cxy , txt_chdev_ptr->name ) );
     
-    txt_owner_xp = (xptr_t)hal_remote_lwd( XPTR( txt_chdev_cxy, 
+    txt_owner_xp = (xptr_t)hal_remote_l64( XPTR( txt_chdev_cxy, 
                                                  &txt_chdev_ptr->ext.txt.owner_xp ) );
     
     // get process .elf name
-    elf_file_xp   = hal_remote_lwd( XPTR( process_cxy , &process_ptr->vfs_bin_xp ) );
+    elf_file_xp   = hal_remote_l64( XPTR( process_cxy , &process_ptr->vfs_bin_xp ) );
     elf_file_cxy  = GET_CXY( elf_file_xp );
     elf_file_ptr  = (vfs_file_t *)GET_PTR( elf_file_xp );
@@ -1718 +1808 @@
     xptr_t      lock_xp;      // extended pointer on list lock in chdev
 
-    // check process is in owner cluster
-    assert( (CXY_FROM_PID( process->pid ) == local_cxy) ,
-    "process descriptor not in owner cluster" );
-
-    // check terminal index
-    assert( (txt_id < LOCAL_CLUSTER->nb_txt_channels) ,
-    "illegal TXT terminal index" );
+// check process is in owner cluster
+assert( (CXY_FROM_PID( process->pid ) == local_cxy) ,
+"process descriptor not in owner cluster" );
+
+// check terminal index
+assert( (txt_id < LOCAL_CLUSTER->nb_txt_channels) ,
+"illegal TXT terminal index" );
 
     // get pointers on TXT_RX[txt_id] chdev
@@ -1735 +1825 @@
     lock_xp = XPTR( chdev_cxy , &chdev_ptr->ext.txt.lock );
 
+    // get lock protecting list of processes attached to TXT
+    remote_busylock_acquire( lock_xp );
+
     // insert process in attached process list
-    remote_spinlock_lock( lock_xp );
     xlist_add_last( root_xp , XPTR( local_cxy , &process->txt_list ) );
-    remote_spinlock_unlock( lock_xp );
+
+    // release lock protecting list of processes attached to TXT
+    remote_busylock_release( lock_xp );
 
 #if DEBUG_PROCESS_TXT
@@ -1765 +1859 @@
     process_cxy = GET_CXY( process_xp );
     process_ptr = GET_PTR( process_xp );
-
-    // check process descriptor in owner cluster
-    process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
-    assert( (CXY_FROM_PID( process_pid ) == process_cxy ) ,
-    "process descriptor not in owner cluster" );
+    process_pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
+
+// check process descriptor in owner cluster
+assert( (CXY_FROM_PID( process_pid ) == process_cxy ) ,
+"process descriptor not in owner cluster" );
 
     // release TXT ownership (does nothing if not TXT owner)
@@ -1775 +1869 @@
 
     // get extended pointer on process stdin file
-    file_xp = (xptr_t)hal_remote_lwd( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
+    file_xp = (xptr_t)hal_remote_l64( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
 
     // get pointers on TXT_RX chdev
@@ -1785 +1879 @@
     lock_xp = XPTR( chdev_cxy , &chdev_ptr->ext.txt.lock );
 
+    // get lock protecting list of processes attached to TXT
+    remote_busylock_acquire( lock_xp );
+
     // unlink process from attached process list
-    remote_spinlock_lock( lock_xp );
     xlist_unlink( XPTR( process_cxy , &process_ptr->txt_list ) );
-    remote_spinlock_unlock( lock_xp );
+
+    // release lock protecting list of processes attached to TXT
+    remote_busylock_release( lock_xp );
 
 #if DEBUG_PROCESS_TXT
 uint32_t cycle  = (uint32_t)hal_get_cycles();
-uint32_t txt_id = hal_remote_lw( XPTR( chdev_cxy , &chdev_ptr->channel ) );
+uint32_t txt_id = hal_remote_l32( XPTR( chdev_cxy , &chdev_ptr->channel ) );
 if( DEBUG_PROCESS_TXT < cycle )
 printk("\n[DBG] %s : thread %x in process %x detached process %x from TXT %d / cycle %d\n",
@@ -1815 +1913 @@
     process_cxy = GET_CXY( process_xp );
     process_ptr = GET_PTR( process_xp );
-    process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
+    process_pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
 
     // check owner cluster
@@ -1822 +1920 @@
 
     // get extended pointer on stdin pseudo file
-    file_xp = hal_remote_lwd( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
+    file_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
 
     // get pointers on TXT chdev
@@ -1830 +1928 @@
 
     // set owner field in TXT chdev
-    hal_remote_swd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , process_xp );
+    hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , process_xp );
 
 #if DEBUG_PROCESS_TXT
 uint32_t cycle  = (uint32_t)hal_get_cycles();
-uint32_t txt_id = hal_remote_lw( XPTR( txt_cxy , &txt_ptr->channel ) );
+uint32_t txt_id = hal_remote_l32( XPTR( txt_cxy , &txt_ptr->channel ) );
 if( DEBUG_PROCESS_TXT < cycle )
 printk("\n[DBG] %s : thread %x in process %x give TXT %d to process %x / cycle %d\n",
@@ -1868 +1966 @@
     process_cxy = GET_CXY( process_xp );
     process_ptr = GET_PTR( process_xp );
-    process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
+    process_pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
 
     // check owner cluster
@@ -1875 +1973 @@
 
     // get extended pointer on stdin pseudo file
-    file_xp = hal_remote_lwd( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
+    file_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
 
     // get pointers on TXT chdev
@@ -1883 +1981 @@
 
     // get extended pointer on TXT_RX owner and TXT channel
-    owner_xp = hal_remote_lwd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) );
-    txt_id   = hal_remote_lw ( XPTR( txt_cxy , &txt_ptr->channel ) );
+    owner_xp = hal_remote_l64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) );
+    txt_id   = hal_remote_l32 ( XPTR( txt_cxy , &txt_ptr->channel ) );
 
     // transfer ownership only if process is the TXT owner
@@ -1894 +1992 @@
 
         // get lock
-        remote_spinlock_lock( lock_xp );
+        remote_busylock_acquire( lock_xp );
 
         if( process_get_ppid( process_xp ) != 1 )           // process is not KSH
@@ -1908 +2006 @@
                 {
                     // release lock
-                    remote_spinlock_unlock( lock_xp );
+                    remote_busylock_release( lock_xp );
 
                     // set owner field in TXT chdev 
-                    hal_remote_swd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , current_xp );
+                    hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , current_xp );
 
 #if DEBUG_PROCESS_TXT
 cycle   = (uint32_t)hal_get_cycles();
-uint32_t ksh_pid = hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) );
+uint32_t ksh_pid = hal_remote_l32( XPTR( current_cxy , &current_ptr->pid ) );
 if( DEBUG_PROCESS_TXT < cycle )
 printk("\n[DBG] %s : thread %x in process %x release TXT %d to KSH %x / cycle %d\n",
@@ -1926 +2024 @@
  
             // release lock
-            remote_spinlock_unlock( lock_xp );
+            remote_busylock_release( lock_xp );
 
             // PANIC if KSH not found
@@ -1945 +2043 @@
                 {
                     // release lock
-                    remote_spinlock_unlock( lock_xp );
+                    remote_busylock_release( lock_xp );
 
                     // set owner field in TXT chdev 
-                    hal_remote_swd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , current_xp );
+                    hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , current_xp );
 
 #if DEBUG_PROCESS_TXT
 cycle   = (uint32_t)hal_get_cycles();
-uint32_t new_pid = hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) );
+uint32_t new_pid = hal_remote_l32( XPTR( current_cxy , &current_ptr->pid ) );
 if( DEBUG_PROCESS_TXT < cycle )
 printk("\n[DBG] %s : thread %x in process %x release TXT %d to process %x / cycle %d\n",
@@ -1963 +2061 @@
 
             // release lock
-            remote_spinlock_unlock( lock_xp );
+            remote_busylock_release( lock_xp );
 
             // no more owner for TXT if no other process found
-            hal_remote_swd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , XPTR_NULL );
+            hal_remote_s64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) , XPTR_NULL );
 
 #if DEBUG_PROCESS_TXT
@@ -1993 +2091 @@
 
 
-//////////////////////////////////////////////////
-uint32_t process_txt_is_owner( xptr_t process_xp )
+////////////////////////////////////////////////
+bool_t process_txt_is_owner( xptr_t process_xp )
 {
     // get local pointer and cluster of process in owner cluster
@@ -2000 +2098 @@
     process_t * process_ptr = GET_PTR( process_xp );
 
-    // check owner cluster
-    pid_t process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
-    assert( (process_cxy == CXY_FROM_PID( process_pid )) ,
-    "process descriptor not in owner cluster\n" );
+// check calling thread execute in target process owner cluster
+pid_t process_pid = hal_remote_l32( XPTR( process_cxy , &process_ptr->pid ) );
+assert( (process_cxy == CXY_FROM_PID( process_pid )) ,
+"process descriptor not in owner cluster\n" );
 
     // get extended pointer on stdin pseudo file
-    xptr_t file_xp = hal_remote_lwd( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
+    xptr_t file_xp = hal_remote_l64( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
 
     // get pointers on TXT chdev
@@ -2014 +2112 @@
 
     // get extended pointer on TXT_RX owner process 
-    xptr_t owner_xp = hal_remote_lwd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) );
+    xptr_t owner_xp = hal_remote_l64( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) );
 
     return (process_xp == owner_xp);
@@ -2027 +2125 @@
     chdev_t *   txt_rx_ptr = GET_PTR( txt_rx_xp );
 
-    return (xptr_t)hal_remote_lwd( XPTR( txt_rx_cxy , &txt_rx_ptr->ext.txt.owner_xp ) );
+    return (xptr_t)hal_remote_l64( XPTR( txt_rx_cxy , &txt_rx_ptr->ext.txt.owner_xp ) );
 
 }  // end process_txt_get_owner()
@@ -2045 +2143 @@
     xptr_t      txt0_xp;
     xptr_t      txt0_lock_xp;
-    reg_t       txt0_save_sr;    // save SR to take TXT0 lock in busy mode
     
     assert( (txt_id < LOCAL_CLUSTER->nb_txt_channels) ,
@@ -2068 +2165 @@
 
     // get lock on attached process list
-    remote_spinlock_lock( lock_xp );
+    remote_busylock_acquire( lock_xp );
 
     // get TXT0 lock in busy waiting mode
-    remote_spinlock_lock_busy( txt0_lock_xp , &txt0_save_sr );
+    remote_busylock_acquire( txt0_lock_xp );
 
     // display header
@@ -2085 +2182 @@
 
     // release TXT0 lock in busy waiting mode
-    remote_spinlock_unlock_busy( txt0_lock_xp , txt0_save_sr );
+    remote_busylock_release( txt0_lock_xp );
 
     // release lock on attached process list
-    remote_spinlock_unlock( lock_xp );
+    remote_busylock_release( lock_xp );
 
 }  // end process_txt_display

trunk/kernel/kern/process.h

@@ -1 +1 @@
 /*
- * process.h - process related management functions
+ * process.h - process related functions definition.
  *
  * Authors  Ghassan Almaless (2008,2009,2010,2011,2012)
@@ -33 +33 @@
 #include <xlist.h>
 #include <bits.h>
-#include <spinlock.h>
+#include <busylock.h>
+#include <queuelock.h>
+#include <remote_queuelock.h>
+#include <remote_rwlock.h>
 #include <hal_atomic.h>
 #include <vmm.h>
@@ -69 +72 @@
  * A free entry in this array contains the XPTR_NULL value.
  * The array size is defined by a the CONFIG_PROCESS_FILE_MAX_NR parameter.
- * All modifications (open/close) in this structure must be done by the reference cluster,
- * and reported in process copies.
+ *
+ * NOTE: - Only the fd_array[] in the reference process contains a complete list of open
+ *         files, and is protected by the lock against concurrent access.
+ *       - the fd_array[] in a process copy is simply a cache containing a subset of the
+ *         open files to speed the fdid to xptr translation, but the "lock" and "current
+ *         fields should not be used.
+ *       - all modifications made by the process_fd_remove() are done in reference cluster
+ *         and reported in all process_copies.
  ********************************************************************************************/
 
 typedef struct fd_array_s
 {
-        remote_spinlock_t lock;                               /*! lock protecting fd_array      */
-    uint32_t          current;                            /*! current number of open files  */
-        xptr_t            array[CONFIG_PROCESS_FILE_MAX_NR];  /*! xptr on open file descriptors */
+        remote_queuelock_t lock;                              /*! lock protecting fd_array      */
+    uint32_t           current;                           /*! current number of open files  */
+        xptr_t             array[CONFIG_PROCESS_FILE_MAX_NR]; /*! open file descriptors         */
 }
 fd_array_t;
@@ -100 +109 @@
  *    complete in the reference process cluster, other copies are read-only caches.
  * 4) The <sem_root>, <mutex_root>, <barrier_root>, <condvar_root>, and the associated
- *    <sync_lock>, that are dynamically allocated, are only defined in the reference cluster.
+ *    <sync_lock>, dynamically allocated, are only defined in the reference cluster.
  * 5) The <children_root>, <children_nr>, <children_list>, and <txt_list> fields are only
  *    defined in the reference cluster, and are undefined in other clusters.
- * 6) The <local_list>, <copies_list>, <th_tbl>, <th_nr>, <th_lock> fields
- *    are defined in all process descriptors copies.
+ * 6) The <local_list>, <copies_list>, <th_tbl>, <th_nr>, <u_th_lock> or <k_th_lock> fields
+ *    are specific n each cluster, and are defined in all process descriptors copies.
  * 7) The termination <flags> and <exit_status> are only defined in the reference cluster.
- *    The term_state format is defined in the shared_syscalls.h file.
+ *    (The term_state format is defined in the shared_syscalls.h file ).
  ********************************************************************************************/
 
 typedef struct process_s
 {
-        vmm_t             vmm;              /*! embedded virtual memory manager                 */
-
-        fd_array_t        fd_array;         /*! embedded open file descriptors array            */
-
-        xptr_t            vfs_root_xp;      /*! extended pointer on current VFS root inode      */
-        xptr_t            vfs_bin_xp;       /*! extended pointer on .elf file descriptor        */
-        pid_t             pid;              /*! process identifier                              */
-    xptr_t            ref_xp;           /*! extended pointer on reference process           */
-    xptr_t            owner_xp;         /*! extended pointer on owner process               */
-    xptr_t            parent_xp;        /*! extended pointer on parent process              */
-
-        xptr_t            vfs_cwd_xp;       /*! extended pointer on current working dir inode   */
-        remote_rwlock_t   cwd_lock;         /*! lock protecting working directory changes       */
-
-        xlist_entry_t     children_root;    /*! root of the children process xlist              */
-    remote_spinlock_t children_lock;    /*! lock protecting children process xlist          */
-    uint32_t          children_nr;      /*! number of children processes                    */
-
-        xlist_entry_t     children_list;    /*! member of list of children of same parent       */
-    xlist_entry_t     local_list;       /*! member of list of process in same cluster       */
-    xlist_entry_t     copies_list;      /*! member of list of copies of same process        */
-    xlist_entry_t     txt_list;         /*! member of list of processes sharing same TXT    */
-
-        spinlock_t        th_lock;          /*! lock protecting th_tbl[] concurrent access      */
-        uint32_t          th_nr;            /*! number of threads in this cluster               */
-
-        struct thread_s * th_tbl[CONFIG_THREAD_MAX_PER_CLUSTER]; /*! pointers on local threads  */
-
-    xlist_entry_t     sem_root;         /*! root of the process semaphore list              */
-    xlist_entry_t     mutex_root;       /*! root of the process mutex list                  */
-    xlist_entry_t     barrier_root;     /*! root of the process barrier list                */
-    xlist_entry_t     condvar_root;     /*! root of the process condvar list                */
-    remote_spinlock_t sync_lock;        /*! lock protecting sem,mutex,barrier,condvar lists */
-
-    uint32_t          term_state;       /*! termination status (flags & exit status)        */
+        vmm_t              vmm;              /*! embedded virtual memory manager                 */
+
+        fd_array_t         fd_array;         /*! embedded open file descriptors array            */
+
+        xptr_t             vfs_root_xp;      /*! extended pointer on current VFS root inode      */
+        xptr_t             vfs_bin_xp;       /*! extended pointer on .elf file descriptor        */
+        pid_t              pid;              /*! process identifier                              */
+    xptr_t             ref_xp;           /*! extended pointer on reference process           */
+    xptr_t             owner_xp;         /*! extended pointer on owner process               */
+    xptr_t             parent_xp;        /*! extended pointer on parent process              */
+
+        xptr_t             vfs_cwd_xp;       /*! extended pointer on current working dir inode   */
+        remote_rwlock_t    cwd_lock;         /*! lock protecting working directory changes       */
+
+        xlist_entry_t      children_root;    /*! root of the children process xlist              */
+    remote_queuelock_t children_lock;    /*! lock protecting children process xlist          */
+    uint32_t           children_nr;      /*! number of children processes                    */
+
+        xlist_entry_t      children_list;    /*! member of list of children of same parent       */
+    xlist_entry_t      local_list;       /*! member of list of process in same cluster       */
+    xlist_entry_t      copies_list;      /*! member of list of copies of same process        */
+    xlist_entry_t      txt_list;         /*! member of list of processes sharing same TXT    */
+
+        struct thread_s  * th_tbl[CONFIG_THREADS_MAX_PER_CLUSTER];       /*! local threads       */
+        uint32_t           th_nr;            /*! number of threads in this cluster               */
+    rwlock_t           th_lock;          /*! lock protecting th_tbl[]  i                     */ 
+
+    xlist_entry_t      sem_root;         /*! root of the user definedsemaphore list          */
+    xlist_entry_t      mutex_root;       /*! root of the user defined mutex list             */
+    xlist_entry_t      barrier_root;     /*! root of the user defined barrier list           */
+    xlist_entry_t      condvar_root;     /*! root of the user defined condvar list           */
+    remote_queuelock_t sync_lock;        /*! lock protecting user defined synchro lists      */
+
+    uint32_t           term_state;       /*! termination status (flags & exit status)        */
 }
 process_t;
@@ -210 +218 @@
 
 /*********************************************************************************************
- * This function initializes a local, reference, user process descriptor from another process
- * descriptor, defined by the <parent_xp> argument. The <process> and <pid> arguments must
- * be previously allocated by the caller. This function can be called by two functions:
+ * This function initializes a reference, user process descriptor from another process
+ * descriptor, defined by the <parent_xp> argument. The <process> and <pid> arguments 
+ * are previously allocated by the caller. This function can be called by two functions:
  * 1) process_init_create() : process is the INIT process; parent is process-zero.
  * 2) process_make_fork() : the parent process descriptor is generally remote.
@@ -411 +419 @@
 
 /*********************************************************************************************
- * This function uses as many remote accesses as required, to reset an entry in fd_array[],
- * in all clusters containing a copy. The entry is identified by the <fdid> argument.
- * This function must be executed by a thread running reference cluster, that contains
- * the complete list of process descriptors copies.
- *********************************************************************************************
- * @ process  : pointer on the local process descriptor.
- * @ fdid     : file descriptor index in the fd_array.
- ********************************************************************************************/
-void process_fd_remove( process_t * process,
-                        uint32_t    fdid );
-
-/*********************************************************************************************
- * This function returns an extended pointer on a file descriptor identified by its index
- * in fd_array. It can be called by any thread running in any cluster.
- * It accesses first the local process descriptor. In case of local miss, it uses remote
- * access to access the reference process descriptor.
- * It updates the local fd_array when the file descriptor exists in reference cluster.
- * The file descriptor refcount is not incremented.
- *********************************************************************************************
- * @ process  : pointer on the local process descriptor.
- * @ fdid     : file descriptor index in the fd_array.
- * @ return extended pointer on file descriptor if success / return XPTR_NULL if not found.
- ********************************************************************************************/
-xptr_t process_fd_get_xptr( process_t * process,
-                            uint32_t    fdid );
-
-/*********************************************************************************************
- * This function checks the number of open files for a given process.
- * It can be called by any thread in any cluster, because it uses portable remote access
- * primitives to access the reference process descriptor.
- *********************************************************************************************
- * @ returns true if file descriptor array full.
- ********************************************************************************************/
-bool_t process_fd_array_full( void );
-
-/*********************************************************************************************
  * This function allocates a free slot in the fd_array of the reference process,
  * register the <file_xp> argument in the allocated slot, and return the slot index.
  * It can be called by any thread in any cluster, because it uses portable remote access
  * primitives to access the reference process descriptor.
+ * It takes the lock protecting the reference fd_array against concurrent accesses.
  *********************************************************************************************
  * @ file_xp  : extended pointer on the file descriptor to be registered.
@@ -459 +432 @@
                              xptr_t      file_xp,
                              uint32_t  * fdid );
+
+/*********************************************************************************************
+ * This function uses as many remote accesses as required, to reset an entry in fd_array[],
+ * in all clusters containing a copy. The entry is identified by the <fdid> argument.
+ * This function must be executed by a thread running in reference cluster, that contains
+ * the complete list of process descriptors copies.
+ * It takes the lock protecting the reference fd_array against concurrent accesses.
+ * TODO this function is not implemented yet.
+ *********************************************************************************************
+ * @ process  : pointer on the local process descriptor.
+ * @ fdid     : file descriptor index in the fd_array.
+ ********************************************************************************************/
+void process_fd_remove( process_t * process,
+                        uint32_t    fdid );
+
+/*********************************************************************************************
+ * This function returns an extended pointer on a file descriptor identified by its index
+ * in fd_array. It can be called by any thread running in any cluster.
+ * It accesses first the local process descriptor. In case of local miss, it takes
+ * the lock protecting the reference fd_array, and access the reference process descriptor.
+ * It updates the local fd_array when the file descriptor exists in reference cluster.
+ * It takes the lock protecting the reference fd_array against concurrent accesses.
+ * The file descriptor refcount is not incremented.
+ *********************************************************************************************
+ * @ process  : pointer on the local process descriptor.
+ * @ fdid     : file descriptor index in the fd_array.
+ * @ return extended pointer on file descriptor if success / return XPTR_NULL if not found.
+ ********************************************************************************************/
+xptr_t process_fd_get_xptr( process_t * process,
+                            uint32_t    fdid );
 
 /*********************************************************************************************
@@ -465 +468 @@
  * <dst_xp> fd_array, embedded in another process descriptor. 
  * The calling thread can be running in any cluster.
- * It takes the remote lock protecting the <src_xp> fd_array during the copy.
+ * It takes the lock protecting the reference fd_array against concurrent accesses.
  * For each involved file descriptor, the refcount is incremented.
  *********************************************************************************************
@@ -474 +477 @@
                              xptr_t src_xp );
 
+/*********************************************************************************************
+ * This function checks the current number of open files for a given process.
+ * It can be called by any thread in any cluster, because it uses portable remote access
+ * primitives to access the reference process descriptor.
+ * It does not take the lock protecting the reference fd_array.
+ *********************************************************************************************
+ * @ returns true if file descriptor array full.
+ ********************************************************************************************/
+bool_t process_fd_array_full( void );
+
 
 
@@ -479 +492 @@
 
 /*********************************************************************************************
- * This function registers a new thread in the local process descriptor.
- * It checks that there is an available slot in the local th_tbl[] array,
- * allocates a new LTID, and registers the new thread in the th_tbl[].
- * It takes the lock protecting exclusive access to the th_tbl[].
+ * This function atomically registers a new thread in the local process descriptor.
+ * It checks that there is an available slot in the local th_tbl[] array, and allocates
+ * a new LTID using the relevant lock depending on the kernel/user type.
  *********************************************************************************************
  * @ process  : pointer on the local process descriptor.
@@ -494 +506 @@
 
 /*********************************************************************************************
- * This function removes a thread registration from the local process descriptor.
- * It takes the lock protecting exclusive access to the th_tbl[].
+ * This function atomically removes a thread registration from the local process descriptor
+ * th_tbl[] array, using the relevant lock, depending on the kernel/user type.
  *********************************************************************************************
  * @ thread   : local pointer on thread to be removed.
@@ -541 +553 @@
 
 /*********************************************************************************************
- * This function gives the TXT ownership to a process identified by the <process_xp> argument.
+ * This function gives a process identified by the <process_xp> argument the exclusive
+ * ownership of its attached TXT_RX terminal (i.e. put the process in foreground).
  * It can be called by a thread running in any cluster, but the <process_xp> must be the
  * owner cluster process descriptor. 
@@ -568 +581 @@
  * process_xp must be the owner cluster process descriptor. 
  *********************************************************************************************
- * @ return a non-zero value if target process is TXT owner.
- ********************************************************************************************/
-uint32_t process_txt_is_owner( xptr_t process_xp );
+ * @ returns true if target process is TXT owner.
+ ********************************************************************************************/
+bool_t process_txt_is_owner( xptr_t process_xp );
 
 /*********************************************************************************************

trunk/kernel/kern/rpc.c

@@ -43 +43 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-//      array of function pointers  (must be consistent with enum in rpc.h) 
+// Array of function pointers and array of printable strings.
+// These arrays must be kept consistent with enum in rpc.h file. 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -82 +83 @@
 };
 
-//////////////////////////////////////////////
+char * rpc_str[RPC_MAX_INDEX] =
+{
+    "PMEM_GET_PAGES",         // 0
+    "PMEM_RELEASE_PAGES",     // 1
+    "undefined",              // 2
+    "PROCESS_MAKE_FORK",      // 3
+    "undefined",              // 4
+    "undefined",              // 5
+    "THREAD_USER_CREATE",     // 6
+    "THREAD_KERNEL_CREATE",   // 7
+    "undefined",              // 8
+    "PROCESS_SIGACTION",      // 9
+
+    "VFS_INODE_CREATE",       // 10
+    "VFS_INODE_DESTROY",      // 11
+    "VFS_DENTRY_CREATE",      // 12
+    "VFS_DENTRY_DESTROY",     // 13
+    "VFS_FILE_CREATE",        // 14
+    "VFS_FILE_DESTROY",       // 15
+    "VFS_INODE_LOAD",         // 16
+    "VFS_MAPPER_LOAD_ALL",    // 17
+    "FATFS_GET_CLUSTER",      // 18
+    "undefined",              // 19
+
+    "GET_VSEG",               // 20
+    "GET_PTE",                // 21
+    "KCM_ALLOC",              // 22
+    "KCM_FREE",               // 23
+    "MAPPER_MOVE_BUFFER",     // 24
+    "MAPPER_GET_PAGE",        // 25
+    "VMM_CREATE_VSEG",        // 26
+    "undefined",              // 27
+    "VMM_SET_COW",            // 28
+    "VMM_DISPLAY",            // 29
+};
+
+//////////////////////////////////////////////////////////////////////////////////
 void __attribute__((noinline)) rpc_undefined( xptr_t xp __attribute__ ((unused)) )
 {
@@ -105 +142 @@
     client_core_lid = this->core->lid;
 
+// check calling thread can yield when it is not the idle thread
+assert( (this->busylocks == 0) || (this->type == THREAD_IDLE),
+"cannot yield : busylocks = %d\n", this->busylocks );
+
 #if DEBUG_RPC_CLIENT_GENERIC
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x enter for rpc[%d] / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
+printk("\n[DBG] %s : thread %x in process %x enter for rpc %s / server_cxy %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], server_cxy, cycle );
 #endif
 
     // select a server_core : use client core index if possible / core 0 otherwise
-    if( client_core_lid < hal_remote_lw( XPTR( server_cxy , &LOCAL_CLUSTER->cores_nr ) ) )
+    if( client_core_lid < hal_remote_l32( XPTR( server_cxy , &LOCAL_CLUSTER->cores_nr ) ) )
     {
         server_core_lid = client_core_lid;
@@ -130 +171 @@
 
     // get local pointer on rpc_fifo in remote cluster,
-    remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo[server_core_lid];
-
-        // post RPC in remote fifo / deschedule and retry if fifo full
+    remote_fifo_t * rpc_fifo    = &LOCAL_CLUSTER->rpc_fifo[server_core_lid];
+    xptr_t          rpc_fifo_xp = XPTR( server_cxy , rpc_fifo );
+
+        // post RPC in remote fifo / deschedule without blocking if fifo full
     do
     { 
-        full = remote_fifo_put_item( XPTR( server_cxy , rpc_fifo ), (uint64_t )desc_xp );
+        full = remote_fifo_put_item( rpc_fifo_xp , (uint64_t )desc_xp );
+
             if ( full ) 
         {
@@ -151 +194 @@
 #if DEBUG_RPC_CLIENT_GENERIC
 cycle = (uint32_t)hal_get_cycles();
+uint32_t items = remote_fifo_items( rpc_fifo_xp );
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x / rpc[%d] / rpc_ptr %x / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc->index, rpc, cycle );
+printk("\n[DBG] %s : thread %x in process %x / rpc %s / items %d / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], items, cycle );
 #endif
         
@@ -159 +203 @@
    dev_pic_send_ipi( server_cxy , server_core_lid );
 
-    // wait RPC completion before returning if blocking RPC
-    // - busy waiting policy during kernel_init, or if threads cannot yield
-    // - block and deschedule in all other cases
+    // wait RPC completion before returning if blocking RPC :
+    // - descheduling without blocking if thread idle (in lernel init)
+    // - block and deschedule policy for any other thread
     if ( rpc->blocking )
     {
-        if( (this->type == THREAD_IDLE) || (thread_can_yield() == false) ) // busy waiting
+        if( this->type == THREAD_IDLE )  // deschedule without blocking policy
         {
-
+  
 #if DEBUG_RPC_CLIENT_GENERIC
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x busy waiting for rpc[%d] / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc->index , cycle );
-#endif
-
-            while( rpc->responses ) hal_fixed_delay( 100 );
+printk("\n[DBG] %s : thread %x in process %x enter waiting loop for rpc %s / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], cycle );
+#endif
+
+             while( rpc->responses ) sched_yield( "busy waiting on RPC");
     
 #if DEBUG_RPC_CLIENT_GENERIC
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x resumes for rpc[%d] / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
-#endif
-        } 
-        else                                                         // block & deschedule
+printk("\n[DBG] %s : thread %x in process %x received response for rpc %s / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], cycle );
+#endif
+ 
+        }
+        else                            // block and deschedule policy
         {
 
@@ -189 +234 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x blocks & deschedules for rpc[%d] / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc->index , cycle );
-#endif
-            thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_RPC );
-            sched_yield("blocked on RPC");
+printk("\n[DBG] %s : thread %x in process %x blocks & deschedules for rpc %s / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], cycle );
+#endif
+
+        // block client thread
+        thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_RPC );
+
+        // deschedule
+        sched_yield("blocked on RPC");
 
 #if DEBUG_RPC_CLIENT_GENERIC
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x resumes for rpc[%d] / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
+printk("\n[DBG] %s : thread %x in process %x resumes for rpc %s / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], cycle );
 #endif
         }
 
-        // check response available
-        assert( (rpc->responses == 0) , "illegal RPC response\n" );
+// response must be available for a blocking RPC
+assert( (rpc->responses == 0) , "illegal response for RPC %s\n", rpc_str[rpc->index] );
+
     }
-    else  // non blocking RPC
+    else       // non blocking RPC
     {
 
@@ -212 +262 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in process %x returns for non blocking rpc[%d] / cycle %d\n",
-__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
+printk("\n[DBG] %s : thread %x in process %x returns for non blocking rpc %s / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc_str[rpc->index], cycle );
 #endif
 
@@ -224 +274 @@
 /***************************************************************************************/
 
-////////////////
-void rpc_check( void )
-{
-    error_t         error;
-    thread_t      * thread;  
-    uint32_t        sr_save;
-
-#if DEBUG_RPC_SERVER_GENERIC
-uint32_t cycle;
-#endif
-
-    bool_t          found    = false;
-        thread_t      * this     = CURRENT_THREAD;
-    core_t        * core     = this->core;
-    scheduler_t   * sched    = &core->scheduler;
-        remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo[core->lid];
-
-    // interrupted thread not preemptable during RPC chek
-        hal_disable_irq( &sr_save );
-
-    // activate (or create) RPC thread if RPC FIFO not empty and no acive RPC thread  
-        if( (rpc_fifo->owner == 0) && (local_fifo_is_empty(rpc_fifo) == false) )
-    {
-
-#if DEBUG_RPC_SERVER_GENERIC
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : RPC FIFO non empty for core[%x,%d] / cycle %d\n",
-__FUNCTION__, local_cxy, core->lid, cycle );
-#endif
-
-        // search one IDLE RPC thread associated to the selected core   
-        list_entry_t * iter;
-        LIST_FOREACH( &sched->k_root , iter )
-        {
-            thread = LIST_ELEMENT( iter , thread_t , sched_list );
-            if( (thread->type == THREAD_RPC) && (thread->blocked == THREAD_BLOCKED_IDLE ) ) 
-            {
-                // unblock found RPC thread
-                thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_IDLE );
-
-                // exit loop
-                found = true;
-                break;
-            }
-        }
-
-        // create new RPC thread for the selected core if not found    
-        if( found == false )                    
-        {
-            error = thread_kernel_create( &thread,
-                                          THREAD_RPC, 
-                                                      &rpc_thread_func, 
-                                          NULL,
-                                                      core->lid );
-                 
-            assert( (error == 0),
-            "no memory to allocate a new RPC thread in cluster %x", local_cxy );
-
-            // unblock created RPC thread
-            thread->blocked = 0;
-
-            // update RRPC threads counter  
-            hal_atomic_add( &LOCAL_CLUSTER->rpc_threads[core->lid] , 1 );
-
-#if DEBUG_RPC_SERVER_GENERIC
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : new RPC thread %x created for core[%x,%d] / cycle %d\n",
-__FUNCTION__, thread, local_cxy, core->lid, cycle );
-#endif
-        }
-    }
-
-#if DEBUG_RPC_SERVER_GENERIC
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : interrupted thread %x deschedules on core[%x,%d] / cycle %d\n",
-__FUNCTION__, this, local_cxy, core->lid, cycle );
-#endif
-
-    // interrupted thread always deschedule          
-        sched_yield("IPI received");
-
-#if DEBUG_RPC_SERVER_GENERIC
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : interrupted thread %x resumes on core[%x,%d] / cycle %d\n",
-__FUNCTION__, this, local_cxy, core->lid, cycle );
-#endif
-
-    // interrupted thread restore IRQs after resume 
-        hal_restore_irq( sr_save );
-
-} // end rpc_check()
-
-
-//////////////////////
+////////////////////////////
 void rpc_thread_func( void )
 {
@@ -345 +298 @@
         rpc_fifo        = &LOCAL_CLUSTER->rpc_fifo[server_core_lid];
 
-    // two embedded loops:
-    // - external loop : "infinite" RPC thread
-    // - internal loop : handle one RPC request per iteration
- 
-        while(1)  // infinite loop
+    // "infinite" RPC thread loop
+        while(1)
         {
         // try to take RPC_FIFO ownership
-        if( hal_atomic_test_set( &rpc_fifo->owner , server_ptr->trdid ) )
+        if( hal_atomic_test_set( &rpc_fifo->owner , server_ptr->trdid ) ) 
         {
 
@@ -358 +308 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : RPC thread %x in cluster %x takes RPC fifo ownership / cycle %d\n",
-__FUNCTION__, server_ptr, local_cxy, cycle );
-#endif
-                while( 1 )  //  one RPC request per iteration 
+printk("\n[DBG] %s : RPC thread %x on core[%d] takes RPC_FIFO ownership / cycle %d\n",
+__FUNCTION__, server_ptr->trdid, server_core_lid, cycle );
+#endif
+                // try to consume one RPC request  
+                empty = remote_fifo_get_item( rpc_fifo , (uint64_t *)&desc_xp );
+
+            // release RPC_FIFO ownership
+            rpc_fifo->owner = 0;
+
+            // handle RPC request if success
+                if ( empty == 0 )   
             {
-                    empty = local_fifo_get_item( rpc_fifo , (uint64_t *)&desc_xp );
-
-                // exit when FIFO empty or FIFO ownership lost (in case of descheduling)
-                    if ( (empty == 0) && (rpc_fifo->owner == server_ptr->trdid) )
+                // get client cluster and pointer on RPC descriptor
+                desc_cxy = GET_CXY( desc_xp );
+                desc_ptr = GET_PTR( desc_xp );
+
+                    index    = hal_remote_l32( XPTR( desc_cxy , &desc_ptr->index ) );
+                blocking = hal_remote_l32( XPTR( desc_cxy , &desc_ptr->blocking ) );
+
+#if DEBUG_RPC_SERVER_GENERIC
+cycle = (uint32_t)hal_get_cycles();
+uint32_t items = remote_fifo_items( XPTR( local_cxy , rpc_fifo ) );
+if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
+printk("\n[DBG] %s : RPC thread %x got rpc %s / client_cxy %x / items %d / cycle %d\n",
+__FUNCTION__, server_ptr->trdid, rpc_str[index], desc_cxy, items, cycle );
+#endif
+                // call the relevant server function
+                rpc_server[index]( desc_xp );
+
+#if DEBUG_RPC_SERVER_GENERIC
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
+printk("\n[DBG] %s : RPC thread %x completes rpc %s / client_cxy %x / cycle %d\n",
+__FUNCTION__, server_ptr->trdid, rpc_str[index], desc_cxy, cycle );
+#endif
+                // decrement response counter in RPC descriptor if blocking RPC
+                if( blocking )
                 {
-                    // get client cluster and pointer on RPC descriptor
-                    desc_cxy = GET_CXY( desc_xp );
-                    desc_ptr = GET_PTR( desc_xp );
-
-                        index    = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->index ) );
-                    blocking = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->blocking ) );
+                    // decrement responses counter in RPC descriptor
+                    hal_remote_atomic_add( XPTR( desc_cxy, &desc_ptr->responses ), -1 );
+
+                    // get client thread pointer and client core lid from RPC descriptor
+                    client_ptr      = hal_remote_lpt( XPTR( desc_cxy , &desc_ptr->thread ) );
+                    client_core_lid = hal_remote_l32 ( XPTR( desc_cxy , &desc_ptr->lid ) );
+
+                    // unblock client thread
+                    thread_unblock( XPTR( desc_cxy , client_ptr ) , THREAD_BLOCKED_RPC );
+
+                    hal_fence();
 
 #if DEBUG_RPC_SERVER_GENERIC
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : RPC thread %x in cluster %x got rpc[%d] / rpc_cxy %x / rpc_ptr %x\n",
-__FUNCTION__, server_ptr, local_cxy, index, desc_cxy, desc_ptr );
-#endif
-                    // call the relevant server function
-                    rpc_server[index]( desc_xp );
-
-#if DEBUG_RPC_SERVER_GENERIC
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : RPC thread %x in cluster %x completes rpc[%d] / rpc_ptr %x / cycle %d\n",
-__FUNCTION__, server_ptr, local_cxy, index, desc_ptr, cycle );
-#endif
-                    // decrement response counter in RPC descriptor if blocking
-                    if( blocking )
-                    {
-                        // decrement responses counter in RPC descriptor
-                        hal_remote_atomic_add( XPTR( desc_cxy, &desc_ptr->responses ), -1 );
-
-                        // get client thread pointer and client core lid from RPC descriptor
-                        client_ptr      = hal_remote_lpt( XPTR( desc_cxy , &desc_ptr->thread ) );
-                        client_core_lid = hal_remote_lw ( XPTR( desc_cxy , &desc_ptr->lid ) );
-
-                        // unblock client thread
-                        thread_unblock( XPTR( desc_cxy , client_ptr ) , THREAD_BLOCKED_RPC );
-
-                        hal_fence();
-
-#if DEBUG_RPC_SERVER_GENERIC
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : RPC thread %x (cluster %x) unblocked client thread %x (cluster %x)\n",
-__FUNCTION__, server_ptr, local_cxy, client_ptr, desc_cxy, cycle );
-#endif
-                        // send IPI to client core
-                            // dev_pic_send_ipi( desc_cxy , client_core_lid );
-                    }
-                        }
-                else
-                {
-                    break;
-                }
-                } // end internal loop
-
-            // release rpc_fifo ownership if not lost
-            if( rpc_fifo->owner == server_ptr->trdid ) rpc_fifo->owner = 0;
-
-        }  // end if RPC fifo
-
-        // RPC thread blocks on IDLE 
-        thread_block( server_xp , THREAD_BLOCKED_IDLE );
-
-        // sucide if too many RPC threads / simply deschedule otherwise
+printk("\n[DBG] %s : RPC thread %x unblocked client thread %x / cycle %d\n",
+__FUNCTION__, server_ptr->trdid, client_ptr->trdid, cycle );
+#endif
+                    // send IPI to client core
+                    dev_pic_send_ipi( desc_cxy , client_core_lid );
+
+                }  // end if blocking RPC
+            }  // end RPC handling if fifo non empty
+        }  // end if RPC_fIFO ownership successfully taken and released
+
+        // sucide if too many RPC threads 
         if( LOCAL_CLUSTER->rpc_threads[server_core_lid] >= CONFIG_RPC_THREADS_MAX )
             {
@@ -436 +378 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : RPC thread %x in cluster %x suicides / cycle %d\n",
-__FUNCTION__, server_ptr, local_cxy, cycle );
+printk("\n[DBG] %s : RPC thread %x suicides / cycle %d\n",
+__FUNCTION__, server_ptr->trdid, cycle );
 #endif
             // update RPC threads counter
-                hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , -1 );
+                hal_atomic_add( &LOCAL_CLUSTER->rpc_threads[server_core_lid] , -1 );
 
             // RPC thread blocks on GLOBAL
@@ -448 +390 @@
             hal_remote_atomic_or( server_xp , THREAD_FLAG_REQ_DELETE );
             }
+        // block and deschedule otherwise
         else
         {
@@ -454 +397 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : RPC thread %x in cluster %x block & deschedules / cycle %d\n",
-__FUNCTION__, server_ptr, local_cxy, cycle );
-#endif
+printk("\n[DBG] %s : RPC thread %x block IDLE & deschedules / cycle %d\n",
+__FUNCTION__, server_ptr->trdid, cycle );
+#endif
+            // RPC thread blocks on IDLE 
+            thread_block( server_xp , THREAD_BLOCKED_IDLE );
 
             // RPC thread deschedules
-            assert( thread_can_yield() , "illegal sched_yield\n" );
-            sched_yield("RPC fifo empty");
+            sched_yield("RPC_FIFO empty");
         }
-
         } // end infinite loop
-
 } // end rpc_thread_func()
 
@@ -478 +420 @@
 {
 #if DEBUG_RPC_PMEM_GET_PAGES
+thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PMEM_GET_PAGES )
-printk("\n[DBG] %s : thread %x enter on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , local_cxy, CURRENT_THREAD->core->lid , cycle );
+printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
 #endif
 
@@ -504 +447 @@
 cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PMEM_GET_PAGES )
-printk("\n[DBG] %s : thread %x exit / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , cycle );
+printk("\n[DBG] %s : thread %x in process %x on core %d exit / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, this->core->lid, cycle );
 #endif
 }
@@ -513 +456 @@
 {
 #if DEBUG_RPC_PMEM_GET_PAGES
+thread_t * this = CURRENT_THREAD;
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( cycle > DEBUG_RPC_PMEM_GET_PAGES )
-printk("\n[DBG] %s : thread %x enter on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , local_cxy, CURRENT_THREAD->core->lid , cycle );
+printk("\n[DBG] %s : thread %x in process %x on core %d enter / cycle %d\n",