Changeset 407 for trunk/kernel/kern

Timestamp:

Nov 7, 2017, 3:08:12 PM (7 years ago)

Author:

alain

Message:

First implementation of fork/exec.

Location:

trunk/kernel/kern

Files:

• chdev.c (modified) (6 diffs)
• chdev.h (modified) (5 diffs)
• cluster.c (modified) (17 diffs)
• cluster.h (modified) (4 diffs)
• core.c (modified) (1 diff)
• do_exec.c (deleted)
• do_syscall.c (modified) (9 diffs)
• do_syscall.h (modified) (2 diffs)
• kernel_init.c (modified) (31 diffs)
• printk.c (modified) (15 diffs)
• printk.h (modified) (6 diffs)
• process.c (modified) (31 diffs)
• process.h (modified) (7 diffs)
• rpc.c (modified) (107 diffs)
• rpc.h (modified) (10 diffs)
• scheduler.c (modified) (17 diffs)
• scheduler.h (modified) (3 diffs)
• signal.c (modified) (2 diffs)
• thread.c (modified) (22 diffs)
• thread.h (modified) (16 diffs)
• time.h (deleted)

trunk/kernel/kern/chdev.c

@@ -25 +25 @@
 #include <hal_types.h>
 #include <hal_special.h>
+#include <hal_irqmask.h>
 #include <printk.h>
 #include <boot_info.h>
 #include <xlist.h>
 #include <kmem.h>
+#include <scheduler.h>
 #include <thread.h>
 #include <rpc.h>
@@ -37 +39 @@
 extern chdev_directory_t    chdev_dir;   // allocated in kernel_init.c
 
+#if CONFIG_READ_DEBUG
+extern uint32_t enter_chdev_cmd;
+extern uint32_t exit_chdev_cmd;
+extern uint32_t enter_chdev_server;
+extern uint32_t exit_chdev_server;
+#endif
 
 ////////////////////////////////////////////
@@ -105 +113 @@
 }
 
-////////////////////////////////////////////////
-void chdev_register_command( xptr_t     chdev_xp,
-                             thread_t * thread )
-{
-    thread_t * thread_ptr = CURRENT_THREAD;
+//////////////////////////////////////////////////
+void chdev_register_command( xptr_t     chdev_xp )
+{
+    thread_t * server_ptr;    // local pointer on server thread associated to chdev
+    core_t   * core_ptr;      // local pointer on core running the server thread
+    uint32_t   lid;           // core running the server thread local index
+    xptr_t     lock_xp;       // extended pointer on lock protecting the chdev queue
+    uint32_t   modified;      // non zero if the server thread state was modified
+    uint32_t   save_sr;       // for critical section
+
+    thread_t * this = CURRENT_THREAD;
+
+chdev_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) enter / cycle %d\n",
+__FUNCTION__, local_cxy, this->core->lid, thread_type_str(this->type) , hal_time_stamp() );
 
     // get device descriptor cluster and local pointer
@@ -116 +133 @@
 
     // build extended pointers on client thread xlist and device root
-    xptr_t  xp_list = XPTR( local_cxy , &thread_ptr->wait_list );
-    xptr_t  xp_root = XPTR( chdev_cxy , &chdev_ptr->wait_root );
-
-    // get lock protecting queue
-    remote_spinlock_lock( XPTR( chdev_cxy , &chdev_ptr->wait_lock ) );
+    xptr_t  list_xp = XPTR( local_cxy , &this->wait_list );
+    xptr_t  root_xp = XPTR( chdev_cxy , &chdev_ptr->wait_root );
+
+    // get local pointer on server thread
+    server_ptr = (thread_t *)hal_remote_lpt( XPTR( chdev_cxy , &chdev_ptr->server) );
+
+chdev_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) / server_cxy %x / server_ptr %x / server_type %\n",
+__FUNCTION__, local_cxy, this->core->lid, server_cxy, server_ptr,
+thread_type_str( hal_remote_lw( XPTR( server_cxy , &server_ptr->type) ) ) );
+
+    // build extended pointer on chdev lock protecting queue
+    lock_xp = XPTR( chdev_cxy , &chdev_ptr->wait_lock );
+
+    // get local pointer on core running the server thread
+    core_ptr = (core_t *)hal_remote_lpt( XPTR( chdev_cxy , &server_ptr->core ) );
+
+    // get core local index
+    lid = hal_remote_lw( XPTR( chdev_cxy , &core_ptr->lid ) );
+
+    // enter critical section
+    hal_disable_irq( &save_sr );
 
     // register client thread in waiting queue 
-    xlist_add_last( xp_root , xp_list );
+    remote_spinlock_lock( lock_xp );
+    xlist_add_last( root_xp , list_xp );
+    remote_spinlock_unlock( lock_xp );
 
     // unblock server thread
-    thread_unblock( XPTR( chdev_cxy , &chdev_ptr->server ) , THREAD_BLOCKED_DEV_QUEUE );
-
-    // release lock
-    remote_spinlock_unlock( XPTR( chdev_cxy , &chdev_ptr->wait_lock ) );
-
-    // client thread goes to blocked state and deschedule
-    thread_block( thread_ptr , THREAD_BLOCKED_IO );
-    sched_yield( NULL );
+    modified = thread_unblock( XPTR( chdev_cxy , server_ptr ), THREAD_BLOCKED_DEV_QUEUE );
+
+    // send IPI to core running the server thread
+    if( modified ) dev_pic_send_ipi( chdev_cxy , lid ); 
+    
+    // block client thread 
+    assert( thread_can_yield( this ) , __FUNCTION__ , "illegal sched_yield\n" );
+
+chdev_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) deschedules / cycle %d\n",
+__FUNCTION__, local_cxy, this->core->lid, thread_type_str(this->type) , hal_time_stamp() );
+
+    thread_block( CURRENT_THREAD , THREAD_BLOCKED_IO );
+    sched_yield();
+
+chdev_dmsg("\n[DBG] %s : core[%x,%d] (thread %s) resumes / cycle %d\n",
+__FUNCTION__, local_cxy, this->core->lid, thread_type_str(this->type) , hal_time_stamp() );
+
+    // exit critical section
+    hal_restore_irq( save_sr );
 
 }  // end chdev_register_command()
@@ -143 +189 @@
     cxy_t           client_cxy;   // cluster of client thread
     thread_t      * client_ptr;   // local pointer on client thread
-    thread_t      * server;       // local pointer on this thread
+    thread_t      * server;       // local pointer on server thread
     xptr_t          root_xp;      // extended pointer on device waiting queue root
+    xptr_t          lock_xp;      // extended pointer on lock ptotecting chdev queue
 
     server = CURRENT_THREAD;
 
+chdev_dmsg("\n[DBG] %s : enter / server = %x / chdev = %x / cycle %d\n",
+__FUNCTION__ , server , chdev , hal_time_stamp() );
+
     root_xp = XPTR( local_cxy , &chdev->wait_root );
-
-    // take the lock protecting the chdev waiting queue, before entering the
-        // infinite loop handling commands registered in this queue.
-    // In the loop, the lock is released during the handling of one command.
-
-    remote_spinlock_lock( XPTR( local_cxy , &chdev->wait_lock ) );
-
+    lock_xp = XPTR( local_cxy , &chdev->wait_lock );
+
+        // This infinite loop is executed by the DEV thread
+    // to handle commands registered in the chdev queue.
     while( 1 )
     {
+        // get the lock protecting the waiting queue
+        remote_spinlock_lock( lock_xp );
+
         // check waiting queue state
-        if( xlist_is_empty( root_xp ) ) // block and deschedule if waiting queue empty 
+        if( xlist_is_empty( root_xp ) ) // waiting queue empty 
         {
             // release lock 
-            remote_spinlock_unlock( XPTR( local_cxy , &chdev->wait_lock ) );
+            remote_spinlock_unlock( lock_xp );
+
+chdev_dmsg("\n[DBG] %s : thread %x deschedule /cycle %d\n",
+__FUNCTION__ , server , hal_time_stamp() );
 
             // block and deschedule
             thread_block( server , THREAD_BLOCKED_DEV_QUEUE );
-            sched_yield( NULL );
+            sched_yield();
+
+chdev_dmsg("\n[DBG] %s : thread %x resume /cycle %d\n",
+__FUNCTION__ , server , hal_time_stamp() );
+
         } 
-        else
+        else                            // waiting queue not empty
         {
+
+#if CONFIG_READ_DEBUG
+enter_chdev_server = hal_time_stamp();
+#endif
             // release lock 
-            remote_spinlock_unlock( XPTR( local_cxy , &chdev->wait_lock ) );
+            remote_spinlock_unlock( lock_xp );
+
+            // get extended pointer on first client thread
+            client_xp = XLIST_FIRST_ELEMENT( root_xp , thread_t , wait_list );
+
+            // get client thread cluster, local pointer, and identifier 
+            client_cxy = GET_CXY( client_xp );
+            client_ptr = (thread_t *)GET_PTR( client_xp );
+
+            // call driver command function to execute I/O operation
+            chdev->cmd( client_xp );
+        
+            // remove the client thread from waiting queue
+            remote_spinlock_lock( lock_xp );
+            xlist_unlink( XPTR( client_cxy , &client_ptr->wait_list ) );
+            remote_spinlock_unlock( lock_xp );
+
+chdev_dmsg("\n[DBG] %s : thread %x complete operation for client %x / cycle %d\n",
+__FUNCTION__ , server , client_ptr , hal_time_stamp() );
+
+#if CONFIG_READ_DEBUG
+exit_chdev_server = hal_time_stamp();
+#endif
+
         }
-
-        // get extended pointer on first client thread
-        client_xp = XLIST_FIRST_ELEMENT( root_xp , thread_t , wait_list );
-
-        // call driver command function to execute I/O operation
-        chdev->cmd( client_xp );
-        
-        // get client thread cluster and local pointer
-        client_cxy = GET_CXY( client_xp );
-        client_ptr = (thread_t *)GET_PTR( client_xp );
-
-        // take the lock, and remove the client thread from waiting queue
-        remote_spinlock_lock( XPTR( local_cxy , &chdev->wait_lock ) );
-        xlist_unlink( XPTR( client_cxy , &client_ptr->wait_list ) );
-
     }  // end while
-
 }  // end chdev_sequencial_server()
 
@@ -197 +265 @@
     cxy_t     iob_cxy  = GET_CXY( chdev_dir.iob );
     chdev_t * iob_ptr  = (chdev_t *)GET_PTR( chdev_dir.iob );
-    xptr_t    iob_base = hal_remote_lwd( XPTR( iob_cxy , &iob_ptr->base ) );
+    uint32_t  iob_base = (uint32_t)hal_remote_lwd( XPTR( iob_cxy , &iob_ptr->base ) );
 
     cxy_t     pic_cxy  = GET_CXY( chdev_dir.pic );
     chdev_t * pic_ptr  = (chdev_t *)GET_PTR( chdev_dir.pic );
-    xptr_t    pic_base = hal_remote_lwd( XPTR( pic_cxy , &pic_ptr->base ) );
-
-    cxy_t     txt0_cxy  = GET_CXY( chdev_dir.txt[0] );
-    chdev_t * txt0_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt[0] );
-    xptr_t    txt0_base = hal_remote_lwd( XPTR( txt0_cxy , &txt0_ptr->base ) );
-
-    cxy_t     txt1_cxy  = GET_CXY( chdev_dir.txt[1] );
-    chdev_t * txt1_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt[1] );
-    xptr_t    txt1_base = hal_remote_lwd( XPTR( txt1_cxy , &txt1_ptr->base ) );
-
-    cxy_t     txt2_cxy  = GET_CXY( chdev_dir.txt[2] );
-    chdev_t * txt2_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt[2] );
-    xptr_t    txt2_base = hal_remote_lwd( XPTR( txt2_cxy , &txt2_ptr->base ) );
+    uint32_t  pic_base = (uint32_t)hal_remote_lwd( XPTR( pic_cxy , &pic_ptr->base ) );
+
+    cxy_t     txt0_tx_cxy  = GET_CXY( chdev_dir.txt_tx[0] );
+    chdev_t * txt0_tx_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt_tx[0] );
+    uint32_t  txt0_tx_base = (uint32_t)hal_remote_lwd( XPTR( txt0_tx_cxy , &txt0_tx_ptr->base ) );
+
+    cxy_t     txt0_rx_cxy  = GET_CXY( chdev_dir.txt_rx[0] );
+    chdev_t * txt0_rx_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt_rx[0] );
+    uint32_t  txt0_rx_base = (uint32_t)hal_remote_lwd( XPTR( txt0_rx_cxy , &txt0_rx_ptr->base ) );
+
+    cxy_t     txt1_tx_cxy  = GET_CXY( chdev_dir.txt_tx[1] );
+    chdev_t * txt1_tx_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt_tx[1] );
+    uint32_t  txt1_tx_base = (uint32_t)hal_remote_lwd( XPTR( txt1_tx_cxy , &txt1_tx_ptr->base ) );
+
+    cxy_t     txt1_rx_cxy  = GET_CXY( chdev_dir.txt_rx[1] );
+    chdev_t * txt1_rx_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt_rx[1] );
+    uint32_t  txt1_rx_base = (uint32_t)hal_remote_lwd( XPTR( txt1_rx_cxy , &txt1_rx_ptr->base ) );
+
+    cxy_t     txt2_tx_cxy  = GET_CXY( chdev_dir.txt_tx[2] );
+    chdev_t * txt2_tx_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt_tx[2] );
+    uint32_t  txt2_tx_base = (uint32_t)hal_remote_lwd( XPTR( txt2_tx_cxy , &txt2_tx_ptr->base ) );
+
+    cxy_t     txt2_rx_cxy  = GET_CXY( chdev_dir.txt_rx[2] );
+    chdev_t * txt2_rx_ptr  = (chdev_t *)GET_PTR( chdev_dir.txt_rx[2] );
+    uint32_t  txt2_rx_base = (uint32_t)hal_remote_lwd( XPTR( txt2_rx_cxy , &txt2_rx_ptr->base ) );
 
     cxy_t     ioc_cxy  = GET_CXY( chdev_dir.ioc[0] );
     chdev_t * ioc_ptr  = (chdev_t *)GET_PTR( chdev_dir.ioc[0] );
-    xptr_t    ioc_base = hal_remote_lwd( XPTR( ioc_cxy , &ioc_ptr->base ) );
+    uint32_t  ioc_base = (uint32_t)hal_remote_lwd( XPTR( ioc_cxy , &ioc_ptr->base ) );
 
     cxy_t     fbf_cxy  = GET_CXY( chdev_dir.fbf[0] );
     chdev_t * fbf_ptr  = (chdev_t *)GET_PTR( chdev_dir.fbf[0] );
-    xptr_t    fbf_base = hal_remote_lwd( XPTR( fbf_cxy , &fbf_ptr->base ) );
-
-    cxy_t     nic_rx_cxy  = GET_CXY( chdev_dir.nic_rx[0] );
-    chdev_t * nic_rx_ptr  = (chdev_t *)GET_PTR( chdev_dir.nic_rx[0] );
-    xptr_t    nic_rx_base = hal_remote_lwd( XPTR( nic_rx_cxy , &nic_rx_ptr->base ) );
-
-    cxy_t     nic_tx_cxy  = GET_CXY( chdev_dir.nic_tx[0] );
-    chdev_t * nic_tx_ptr  = (chdev_t *)GET_PTR( chdev_dir.nic_tx[0] );
-    xptr_t    nic_tx_base = hal_remote_lwd( XPTR( nic_tx_cxy , &nic_tx_ptr->base ) );
+    uint32_t  fbf_base = (uint32_t)hal_remote_lwd( XPTR( fbf_cxy , &fbf_ptr->base ) );
+
+    cxy_t     nic0_rx_cxy  = GET_CXY( chdev_dir.nic_rx[0] );
+    chdev_t * nic0_rx_ptr  = (chdev_t *)GET_PTR( chdev_dir.nic_rx[0] );
+    uint32_t  nic0_rx_base = (uint32_t)hal_remote_lwd( XPTR( nic0_rx_cxy , &nic0_rx_ptr->base ) );
+
+    cxy_t     nic0_tx_cxy  = GET_CXY( chdev_dir.nic_tx[0] );
+    chdev_t * nic0_tx_ptr  = (chdev_t *)GET_PTR( chdev_dir.nic_tx[0] );
+    uint32_t  nic0_tx_base = (uint32_t)hal_remote_lwd( XPTR( nic0_tx_cxy , &nic0_tx_ptr->base ) );
 
     printk("\n***** external chdev directory in cluster %x\n"
-           "  - iob       = %l / base = %l\n"
-           "  - pic       = %l / base = %l\n"
-           "  - txt[0]    = %l / base = %l\n"
-           "  - txt[1]    = %l / base = %l\n"
-           "  - txt[2]    = %l / base = %l\n"
-           "  - ioc[0]    = %l / base = %l\n"
-           "  - fbf[0]    = %l / base = %l\n"
-           "  - nic_rx[0] = %l / base = %l\n"
-           "  - nic_tx[0] = %l / base = %l\n",
+           "  - iob       : cxy = %X / ptr = %X / base = %X\n"
+           "  - pic       : cxy = %X / ptr = %X / base = %X\n"
+           "  - ioc       : cxy = %X / ptr = %X / base = %X\n"
+           "  - fbf       : cxy = %X / ptr = %X / base = %X\n"
+           "  - txt_rx[0] : cxy = %X / ptr = %X / base = %X\n"
+           "  - txt_tx[0] : cxy = %X / ptr = %X / base = %X\n"
+           "  - txt_rx[1] : cxy = %X / ptr = %X / base = %X\n"
+           "  - txt_tx[1] : cxy = %X / ptr = %X / base = %X\n"
+           "  - txt_rx[2] : cxy = %X / ptr = %X / base = %X\n"
+           "  - txt_tx[2] : cxy = %X / ptr = %X / base = %X\n"
+           "  - nic_rx[0] : cxy = %X / ptr = %X / base = %X\n"
+           "  - nic_tx[0] : cxy = %X / ptr = %X / base = %X\n",
            local_cxy,
-           chdev_dir.iob, iob_base,
-           chdev_dir.pic, pic_base,
-           chdev_dir.txt[0], txt0_base,
-           chdev_dir.txt[1], txt1_base,
-           chdev_dir.txt[2], txt2_base,
-           chdev_dir.ioc[0], ioc_base,
-           chdev_dir.fbf[0], fbf_base,
-           chdev_dir.nic_rx[0], nic_rx_base,
-           chdev_dir.nic_tx[0], nic_tx_base );
+           iob_cxy , iob_ptr , iob_base ,
+           pic_cxy , pic_ptr , pic_base ,
+           ioc_cxy , ioc_ptr , ioc_base ,
+           fbf_cxy , fbf_ptr , fbf_base ,
+           txt0_rx_cxy , txt0_rx_ptr , txt0_rx_base ,
+           txt0_tx_cxy , txt0_tx_ptr , txt0_tx_base ,
+           txt1_rx_cxy , txt1_rx_ptr , txt1_rx_base ,
+           txt1_tx_cxy , txt1_tx_ptr , txt1_tx_base ,
+           txt2_rx_cxy , txt2_rx_ptr , txt2_rx_base ,
+           txt2_tx_cxy , txt2_tx_ptr , txt2_tx_base ,
+           nic0_rx_cxy , nic0_rx_ptr , nic0_rx_base ,
+           nic0_tx_cxy , nic0_tx_ptr , nic0_tx_base );
 
 }  // end chdev_dir_display()

trunk/kernel/kern/chdev.h

@@ -66 +66 @@
 
 /******************************************************************************************
- * This define the generic prototypes for the two functions that must be defined
- * by all drivers implementing a generic device:
- * - "cmd"     : start an I/O operation.
+ * This define the generic prototypes for the three functions that must be defined
+ * by the drivers implementing a generic device:
+ * - "cmd"     : start a blocking I/O operation.
  * - "isr"     : complete an I/O operation.
- * The "cmd" and "isr" are registered in the generic chdev descriptor at kernel init,
- * and are called to start and complete an I/O operation.  
+ * - "aux"     : not for all drivers (implement special functions)
+ * The "cmd", "isr", and "aux" driver functions are registered in the generic chdev
+ * descriptor at kernel init, and are called to start and complete an I/O operation.  
 *****************************************************************************************/
 
@@ -77 +78 @@
 typedef void (dev_cmd_t) ( xptr_t thread );  
 typedef void (dev_isr_t) ( struct chdev_s * dev );  
+typedef void (dev_aux_t) ( void * args );  
 
 /******************************************************************************************
@@ -121 +123 @@
         uint32_t             impl;        /*! peripheral inplementation subtype              */
     uint32_t             channel;     /*! channel index                                  */
-    bool_t               is_rx;       /*! relevant for NIC peripheral channels only      */
+    bool_t               is_rx;       /*! relevant for NIC and TXT peripherals           */
         xptr_t               base;        /*! extended pointer on channel device segment     */
     char                 name[16];    /*! name (required by DEVFS)                       */
 
-    dev_cmd_t          * cmd;         /*! local pointer on driver command function       */
-    dev_isr_t          * isr;         /*! local pointer on driver ISR function           */  
+    dev_cmd_t          * cmd;         /*! local pointer on driver CMD function           */
+    dev_isr_t          * isr;         /*! local pointer on driver ISR function           */
+    dev_aux_t          * aux;         /*! local pointer on driver AUX function           */
+
     struct thread_s    * server;      /*! local pointer on associated server thread      */
 
@@ -165 +169 @@
     xptr_t   pic;                                // external / single channel / shared
 
-    xptr_t   txt[CONFIG_MAX_TXT_CHANNELS];       // external / multi-channels / shared
     xptr_t   ioc[CONFIG_MAX_IOC_CHANNELS];       // external / multi-channels / shared
     xptr_t   fbf[CONFIG_MAX_FBF_CHANNELS];       // external / multi-channels / shared
+    xptr_t   txt_rx[CONFIG_MAX_TXT_CHANNELS];    // external / multi-channels / shared
+    xptr_t   txt_tx[CONFIG_MAX_TXT_CHANNELS];    // external / multi-channels / shared
     xptr_t   nic_rx[CONFIG_MAX_NIC_CHANNELS];    // external / multi-channels / shared
     xptr_t   nic_tx[CONFIG_MAX_NIC_CHANNELS];    // external / multi-channels / shared
@@ -211 +216 @@
 
 /******************************************************************************************
- * This function registers a local client thread in the waiting queue of a remote 
+ * This function registers the calling thread in the waiting queue of a remote 
  * chdev descriptor, activates (i.e. unblock) the server thread associated to chdev,
  * and blocks itself on the THREAD_BLOCKED_IO condition.
  ******************************************************************************************
  * @ chdev_xp  : extended pointer on remote chdev descriptor.
- * @ thread    : local pointer on client thread.
- *****************************************************************************************/
-void chdev_register_command( xptr_t            chdev_xp,
-                             struct thread_s * thread );
+ *****************************************************************************************/
+void chdev_register_command( xptr_t chdev_xp );
 
 /******************************************************************************************

trunk/kernel/kern/cluster.c

@@ -29 +29 @@
 #include <hal_special.h>
 #include <hal_ppm.h>
+#include <remote_fifo.h>
 #include <printk.h>
 #include <errno.h>
@@ -77 +78 @@
     // initialize cluster local parameters
         cluster->cores_nr        = info->cores_nr;
-    cluster->cores_in_kernel = 0;
 
     // initialize the lock protecting the embedded kcm allocator
         spinlock_init( &cluster->kcm_lock );
 
-    cluster_dmsg("\n[DMSG] %s for cluster %x enters\n",
-                 __FUNCTION__ , local_cxy );
+cluster_dmsg("\n[DBG] %s for cluster %x enters\n",
+__FUNCTION__ , local_cxy );
 
     // initialises DQDT
@@ -102 +102 @@
     }
 
-    cluster_dmsg("\n[DMSG] %s : PPM initialized in cluster %x at cycle %d\n",
-                 __FUNCTION__ , local_cxy , hal_get_cycles() );
+cluster_dmsg("\n[DBG] %s : PPM initialized in cluster %x at cycle %d\n",
+__FUNCTION__ , local_cxy , hal_get_cycles() );
 
     // initialises embedded KHM
         khm_init( &cluster->khm );
 
-    cluster_dmsg("\n[DMSG] %s : KHM initialized in cluster %x at cycle %d\n",
+    cluster_dmsg("\n[DBG] %s : KHM initialized in cluster %x at cycle %d\n",
                  __FUNCTION__ , local_cxy , hal_get_cycles() );
 
@@ -114 +114 @@
         kcm_init( &cluster->kcm , KMEM_KCM );
 
-    cluster_dmsg("\n[DMSG] %s : KCM initialized in cluster %x at cycle %d\n",
+    cluster_dmsg("\n[DBG] %s : KCM initialized in cluster %x at cycle %d\n",
                  __FUNCTION__ , local_cxy , hal_get_cycles() );
 
@@ -125 +125 @@
         }
 
-    cluster_dmsg("\n[DMSG] %s : cores initialized in cluster %x at cycle %d\n",
-                 __FUNCTION__ , local_cxy , hal_get_cycles() );
+cluster_dmsg("\n[DBG] %s : cores initialized in cluster %x at cycle %d\n",
+__FUNCTION__ , local_cxy , hal_get_cycles() );
 
     // initialises RPC fifo
-        rpc_fifo_init( &cluster->rpc_fifo );
+        local_fifo_init( &cluster->rpc_fifo );
     cluster->rpc_threads = 0;
 
-    cluster_dmsg("\n[DMSG] %s : RPC fifo inialized in cluster %x at cycle %d\n",
-                 __FUNCTION__ , local_cxy , hal_get_cycles() );
+cluster_dmsg("\n[DBG] %s : RPC fifo inialized in cluster %x at cycle %d\n",
+__FUNCTION__ , local_cxy , hal_get_cycles() );
 
     // initialise pref_tbl[] in process manager
@@ -157 +157 @@
     }
 
-    cluster_dmsg("\n[DMSG] %s Process Manager initialized in cluster %x at cycle %d\n",
-                 __FUNCTION__ , local_cxy , hal_get_cycles() );
+cluster_dmsg("\n[DBG] %s Process Manager initialized in cluster %x at cycle %d\n",
+__FUNCTION__ , local_cxy , hal_get_cycles() );
 
     hal_fence();
@@ -184 +184 @@
 //  Cores related functions
 ////////////////////////////////////////////////////////////////////////////////////
-
-////////////////////////////////
-void cluster_core_kernel_enter()
-{
-    cluster_t * cluster = LOCAL_CLUSTER;
-        hal_atomic_add( &cluster->cores_in_kernel , 1 );
-}
-
-///////////////////////////////
-void cluster_core_kernel_exit()
-{
-    cluster_t * cluster = LOCAL_CLUSTER;
-        hal_atomic_add( &cluster->cores_in_kernel , -1 );
-}
 
 /////////////////////////////////
@@ -353 +339 @@
 void cluster_process_local_link( process_t * process )
 {
+    uint32_t irq_state;
     pmgr_t * pm = &LOCAL_CLUSTER->pmgr;
 
     // get lock protecting the process manager local list
-    remote_spinlock_lock( XPTR( local_cxy , &pm->local_lock ) );
+    remote_spinlock_lock_busy( XPTR( local_cxy , &pm->local_lock ) , & irq_state );
 
     xlist_add_first( XPTR( local_cxy , &pm->local_root ),
@@ -363 +350 @@
 
     // release lock protecting the process manager local list
-    remote_spinlock_unlock( XPTR( local_cxy , &pm->local_lock ) );
+    remote_spinlock_unlock_busy( XPTR( local_cxy , &pm->local_lock ) , irq_state );
 }
 
@@ -369 +356 @@
 void cluster_process_local_unlink( process_t * process )
 {
+    uint32_t irq_state;
     pmgr_t * pm = &LOCAL_CLUSTER->pmgr;
 
     // get lock protecting the process manager local list
-    remote_spinlock_lock( XPTR( local_cxy , &pm->local_lock ) );
+    remote_spinlock_lock_busy( XPTR( local_cxy , &pm->local_lock ) , &irq_state );
 
     xlist_unlink( XPTR( local_cxy , &process->local_list ) );
@@ -378 +366 @@
 
     // release lock protecting the process manager local list
-    remote_spinlock_unlock( XPTR( local_cxy , &pm->local_lock ) );
+    remote_spinlock_unlock_busy( XPTR( local_cxy , &pm->local_lock ) , irq_state );
 }
 
@@ -384 +372 @@
 void cluster_process_copies_link( process_t * process )
 {
+    uint32_t irq_state;
     pmgr_t * pm = &LOCAL_CLUSTER->pmgr;
 
@@ -401 +390 @@
 
     // get lock protecting copies_list[lpid]
-    remote_spinlock_lock( copies_lock );
+    remote_spinlock_lock_busy( copies_lock , &irq_state );
 
     xlist_add_first( copies_root , copies_entry );
@@ -407 +396 @@
 
     // release lock protecting copies_list[lpid]
-    remote_spinlock_unlock( copies_lock );
+    remote_spinlock_unlock_busy( copies_lock , irq_state );
 }
 
@@ -413 +402 @@
 void cluster_process_copies_unlink( process_t * process )
 {
+    uint32_t irq_state;
     pmgr_t * pm = &LOCAL_CLUSTER->pmgr;
 
@@ -427 +417 @@
 
     // get lock protecting copies_list[lpid]
-    remote_spinlock_lock( copies_lock );
+    remote_spinlock_lock_busy( copies_lock , &irq_state );
 
     xlist_unlink( copies_entry );
@@ -433 +423 @@
 
     // release lock protecting copies_list[lpid]
-    remote_spinlock_unlock( copies_lock );
+    remote_spinlock_unlock_busy( copies_lock , irq_state );
 }
 

trunk/kernel/kern/cluster.h

@@ -108 +108 @@
 
     // local parameters
-        uint32_t          cores_nr;        /*! number of cores in cluster                     */
-    uint32_t          cores_in_kernel; /*! number of cores currently in kernel mode       */
-
+        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)           */
@@ -125 +123 @@
 
     // RPC
-        rpc_fifo_t        rpc_fifo;        /*! RPC fifo                                       */
-    uint32_t          rpc_threads;     /*! current number of RPC threads                  */
+        remote_fifo_t     rpc_fifo;        /*! RPC fifo (one per cluster)                     */
+    uint32_t          rpc_threads;     /*! current number of RPC threads in cluster       */
 
     // DQDT
@@ -173 +171 @@
 
 /******************************************************************************************
- * This function checks the validity of a cluster identifier. TODO useful ??? [AG]
+ * This function checks the validity of a cluster identifier. 
  ******************************************************************************************
  * @ cxy    : cluster identifier to be checked.
@@ -179 +177 @@
  *****************************************************************************************/
 bool_t cluster_is_undefined( cxy_t cxy );
-
-/******************************************************************************************
- * This function register sysfs information in cluster TODO ???  [AG]
- *****************************************************************************************/
-void cluster_sysfs_register();
 
 

trunk/kernel/kern/core.c

@@ -107 +107 @@
         ticks = core->ticks_nr++;
 
-        // handle pending alarms TODO ??? [AG]
-        // alarm_clock( &core->alarm_mgr , ticks );
+    // handle signals for all threads executing on this core
+    sched_handle_signals( core );
 
         // handle scheduler
-        if( (ticks % CONFIG_SCHED_TICKS_PER_QUANTUM) == 0 ) sched_yield( NULL );
+        if( (ticks % CONFIG_SCHED_TICKS_PER_QUANTUM) == 0 ) sched_yield();
 
         // update DQDT 

trunk/kernel/kern/do_syscall.c

@@ -31 +31 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////////
+// This ƒonction should never be called...
 /////////////////////////////////////////////////////////////////////////////////////////////
-static inline int sys_undefined()
+static int sys_undefined()
 {
     panic("undefined system call");
@@ -40 +41 @@
 /////////////////////////////////////////////////////////////////////////////////////////////
 // This array of pointers define the kernel functions implementing the syscalls.
-// It must be kept consistent with the enum in syscalls.h
+// It must be kept consistent with the enum in "shared_syscalls.h" file.
 /////////////////////////////////////////////////////////////////////////////////////////////
 
@@ -48 +49 @@
 {
     sys_thread_exit,        // 0
-    sys_mmap,               // 1
+    sys_thread_yield,       // 1 
     sys_thread_create,      // 2
     sys_thread_join,        // 3
     sys_thread_detach,      // 4
-    sys_thread_yield,       // 5
+    sys_undefined,          // 5
     sys_sem,                // 6
     sys_condvar,            // 7
     sys_barrier,            // 8
     sys_mutex,              // 9
-    sys_thread_sleep,       // 10
-    sys_thread_wakeup,      // 11
+
+    sys_undefined,          // 10
+    sys_munmap,             // 11
     sys_open,               // 12
-    sys_creat,              // 13
+    sys_mmap,               // 13
     sys_read,               // 14
     sys_write,              // 15
@@ -67 +69 @@
     sys_unlink,             // 18
     sys_pipe,               // 19
+
     sys_chdir,              // 20
     sys_mkdir,              // 21
@@ -74 +77 @@
     sys_closedir,           // 25
     sys_getcwd,             // 26
-    sys_clock,              // 27
+    sys_undefined,          // 27  
     sys_alarm,              // 28
     sys_rmdir,              // 29
+
     sys_utls,               // 30
     sys_chmod,              // 31
@@ -87 +91 @@
     sys_stat,               // 38
     sys_trace,              // 39
+
+    sys_get_config,         // 40
+    sys_get_core,           // 41
+    sys_get_cycle,          // 42
+    sys_get_sched,          // 43
+    sys_panic,              // 44
+    sys_thread_sleep,       // 45
+    sys_thread_wakeup,      // 46
 };
 
@@ -102 +114 @@
         thread_user_time_update( this );
 
-    // enable IRQs
+    // enable interrupts
         hal_enable_irq( NULL );
   
@@ -116 +128 @@
         }
 
-        syscall_dmsg("\n[DMSG] %s : pid = %x / trdid = %x / service #%d\n"
-                 "         arg0 = %x / arg1 = %x / arg2 = %x / arg3 = %x\n",
-                         __FUNCTION__ , this->process->pid , this->trdid , service_num ,
-                         arg0 , arg1 , arg2 , arg3 );
+#if( CONFIG_SYSCALL_DEBUG & 0x1)
+printk("\n[DBG] %s : pid = %x / trdid = %x / service #%d\n"
+"      arg0 = %x / arg1 = %x / arg2 = %x / arg3 = %x\n",
+__FUNCTION__ , this->process->pid , this->trdid , service_num , arg0 , arg1 , arg2 , arg3 );
+#endif
 
     // reset errno
@@ -127 +140 @@
         error = syscall_tbl[service_num] ( arg0 , arg1 , arg2 , arg3 );
 
-    // handle pending signals for the calling thread
-    thread_signals_handle( this );
-
-        // disable IRQs
+    // disable interrupt
         hal_disable_irq( NULL );
 

trunk/kernel/kern/do_syscall.h

@@ -1 +1 @@
 /*
- * do_syscall.h - kernel service numbers asked by userland
+ * do_syscall.h - generic syscall handler.
  * 
  * Authors   Ghassan Almaless (2008,2009,2010,2011,2012)
@@ -32 +32 @@
 /********************************************************************************************
  * This function calls the kernel function defined by the <service_num> argument.
+ * The possible values for servic_num are defined in the syscalls/syscalls.h file.
  ********************************************************************************************
  * @ this        : pointer on calling thread descriptor

trunk/kernel/kern/kernel_init.c

@@ -32 +32 @@
 #include <barrier.h>
 #include <remote_barrier.h>
+#include <remote_fifo.h>
 #include <core.h>
 #include <list.h>
@@ -85 +86 @@
 cluster_t            cluster_manager                         CONFIG_CACHE_LINE_ALIGNED;
 
-// This variable defines the TXT0 kernel terminal 
+// This variable defines the TXT0 kernel terminal (TX only)
 __attribute__((section(".kdata")))
 chdev_t              txt0_chdev                              CONFIG_CACHE_LINE_ALIGNED;
@@ -121 +122 @@
 vfs_ctx_t            fs_context[FS_TYPES_NR]                 CONFIG_CACHE_LINE_ALIGNED;
 
+// These variables are used by the sched_yield function to save SR value
+__attribute__((section(".kdata")))
+uint32_t             switch_save_sr[CONFIG_MAX_LOCAL_CORES]  CONFIG_CACHE_LINE_ALIGNED;
+
+#if CONFIG_READ_DEBUG
+uint32_t   enter_sys_read;
+uint32_t   exit_sys_read;
+
+uint32_t   enter_devfs_move;
+uint32_t   exit_devfs_move;
+
+uint32_t   enter_txt_read;
+uint32_t   exit_txt_read;
+
+uint32_t   enter_chdev_cmd;
+uint32_t   exit_chdev_cmd;
+
+uint32_t   enter_chdev_server;
+uint32_t   exit_chdev_server;
+
+uint32_t   enter_tty_cmd;
+uint32_t   exit_tty_cmd;
+
+uint32_t   enter_tty_isr;
+uint32_t   exit_tty_isr;
+#endif
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -137 +164 @@
            "    /_/        \\_\\ |______| |_|    |_|   \\_____/  |______/        |_|    |_|  |_|  \\_\\ |_|   |_|  \n"
            "\n\n\t\t Advanced Locality Management Operating System / Multi Kernel Hybrid\n"
-           "\n\n\t\t\t Version 0.0 / %d cluster(s) / %d core(s) per cluster\n\n", nclusters , ncores );
+           "\n\n\t\t Version 0.0 / %d cluster(s) / %d core(s) per cluster / cycle %d\n\n",
+           nclusters , ncores , hal_time_stamp() );
 }
 
@@ -201 +229 @@
                 {
                     cxy_t  cxy = (x<<info->y_width) + y;
-                    hal_remote_swd( XPTR( cxy , &chdev_dir.txt[0] ) ,
+                    hal_remote_swd( XPTR( cxy , &chdev_dir.txt_tx[0] ) ,
                                     XPTR( local_cxy , &txt0_chdev ) );
                 }
@@ -273 +301 @@
             }
 
-#if( CONFIG_KINIT_DEBUG > 1 )
-printk("\n[DMSG] %s : created MMC in cluster %x / chdev = %x\n",
-__FUNCTION__ , channel , local_cxy , chdev_ptr );
+#if( CONFIG_KINIT_DEBUG & 0x1 )
+if( hal_time_stamp() > CONFIG_KINIT_DEBUG )
+printk("\n[DBG] %s : created MMC in cluster %x / chdev = %x\n",
+__FUNCTION__ , local_cxy , chdev_ptr );
 #endif
         }
@@ -301 +330 @@
                 chdev_dir.dma[channel] = XPTR( local_cxy , chdev_ptr );
 
-#if( CONFIG_KINIT_DEBUG > 1 )
-printk("\n[DMSG] %s : created DMA[%d] in cluster %x / chdev = %x\n",
+#if( CONFIG_KINIT_DEBUG & 0x1 )
+if( hal_time_stamp() > CONFIG_KINIT_DEBUG )
+printk("\n[DBG] %s : created DMA[%d] in cluster %x / chdev = %x\n",
 __FUNCTION__ , channel , local_cxy , chdev_ptr );
 #endif
@@ -355 +385 @@
         impl     = IMPL_FROM_TYPE( dev_tbl[i].type );
 
-        // There is one chdev per direction for NIC
-        if (func == DEV_FUNC_NIC) directions = 2;
-        else                      directions = 1;
+        // There is one chdev per direction for NIC and for TXT
+        if((func == DEV_FUNC_NIC) || (func == DEV_FUNC_TXT)) directions = 2;
+        else                                                 directions = 1;
 
         // The TXT0 chdev has already been created
@@ -363 +393 @@
         else                      first_channel = 0;
 
-        // do nothing for RO, that does not require a device descriptor.
+        // do nothing for ROM, that does not require a device descriptor.
         if( func == DEV_FUNC_ROM ) continue;
 
@@ -394 +424 @@
 
                 // allocate and initialize a local chdev
-                // if local cluster matches target cluster
+                // when local cluster matches target cluster
                 if( target_cxy == local_cxy )
                 {
@@ -420 +450 @@
                     if(func==DEV_FUNC_IOB             ) entry  = &chdev_dir.iob;
                     if(func==DEV_FUNC_IOC             ) entry  = &chdev_dir.ioc[channel];
-                    if(func==DEV_FUNC_TXT             ) entry  = &chdev_dir.txt[channel];
                     if(func==DEV_FUNC_FBF             ) entry  = &chdev_dir.fbf[channel];
+                    if((func==DEV_FUNC_TXT) && (rx==0)) entry  = &chdev_dir.txt_tx[channel];
+                    if((func==DEV_FUNC_TXT) && (rx==1)) entry  = &chdev_dir.txt_rx[channel];
                     if((func==DEV_FUNC_NIC) && (rx==0)) entry  = &chdev_dir.nic_tx[channel];
                     if((func==DEV_FUNC_NIC) && (rx==1)) entry  = &chdev_dir.nic_rx[channel];
@@ -435 +466 @@
                     }
 
-#if( CONFIG_KINIT_DEBUG > 1 )
-printk("\n[DMSG] %s : create chdev %s[%d] in cluster %x / chdev = %x\n",
-__FUNCTION__ , chdev_func_str( func ), channel , local_cxy , chdev );
+#if( CONFIG_KINIT_DEBUG & 0x1 )
+if( hal_time_stamp() > CONFIG_KINIT_DEBUG )
+printk("\n[DBG] %s : create chdev %s / channel = %d / rx = %d / cluster %x / chdev = %x\n",
+__FUNCTION__ , chdev_func_str( func ), channel , rx , local_cxy , chdev );
 #endif
                 }  // end if match
@@ -451 +483 @@
 ///////////////////////////////////////////////////////////////////////////////////////////
 // This function is called by CP0 in cluster 0 to allocate memory and initialize the PIC
-// device, namely the informations attached to the external IOPIC controller.
+// device, namely the informations attached to the external IOPIC controller, that
+// must be replicated in all clusters (struct iopic_input).
 // This initialisation must be done before other devices initialisation because the IRQ
-// routing infrastructure is required for internal and external devices initialisation.
+// routing infrastructure is required for both internal and external devices init.
 ///////////////////////////////////////////////////////////////////////////////////////////
 // @ info    : pointer on the local boot-info structure.
@@ -490 +523 @@
     assert( found , __FUNCTION__ , "PIC device not found\n" );
 
-    // allocate and initialize the PIC chdev in local cluster
-    chdev = chdev_create( func,
+    // allocate and initialize the PIC chdev in cluster 0
+    chdev = chdev_create( DEV_FUNC_PIC,
                           impl,
                           0,      // channel
@@ -502 +535 @@
     dev_pic_init( chdev );
 
-    // register extended pointer on PIC chdev in "chdev_dir" array in all clusters
+    // register, in all clusters, the extended pointer
+    // on PIC chdev in "chdev_dir" array
     xptr_t * entry = &chdev_dir.pic;    
                 
@@ -515 +549 @@
     }
 
-    // initialize the "iopic_input" structure
+    // initialize, in all clusters, the "iopic_input" structure
     // defining how external IRQs are connected to IOPIC 
-    uint32_t   id;
-    uint8_t    valid;
-    uint32_t   type;
-    uint8_t    channel;
-    uint8_t    is_rx;
+
+    // register default value for unused inputs 
+    for( x = 0 ; x < info->x_size ; x++ )
+    {
+        for( y = 0 ; y < info->y_size ; y++ )
+        {
+            cxy_t  cxy = (x<<info->y_width) + y;
+            hal_remote_memset( XPTR( cxy , &iopic_input ) , 0xFF , sizeof(iopic_input_t) );
+        }
+    }
+
+    // register input IRQ index for valid inputs 
+    uint32_t   id;         // input IRQ index
+    uint8_t    valid;      // input IRQ is connected
+    uint32_t   type;       // source device type
+    uint8_t    channel;    // source device channel
+    uint8_t    is_rx;      // source device direction
+    uint32_t * ptr;        // local pointer on one field in iopic_input stucture
 
     for( id = 0 ; id < CONFIG_MAX_EXTERNAL_IRQS ; id++ )
@@ -529 +576 @@
         channel = dev_tbl[i].irq[id].channel;
         is_rx   = dev_tbl[i].irq[id].is_rx;
-
-        if( valid )  // only valid inputs are registered
-        {
-            uint32_t * index;  // local pointer on one entry
-            uint16_t func = FUNC_FROM_TYPE( type );
-
-            if     ( func == DEV_FUNC_TXT ) 
-            index = &iopic_input.txt[channel];
-            else if( func == DEV_FUNC_IOC ) 
-            index = &iopic_input.ioc[channel]; 
-            else if( (func == DEV_FUNC_NIC) && (is_rx == 0) )
-            index = &iopic_input.nic_tx[channel]; 
-            else if( (func == DEV_FUNC_NIC) && (is_rx != 0) )
-            index = &iopic_input.nic_rx[channel]; 
-            else if( func == DEV_FUNC_IOB )
-            index = &iopic_input.iob; 
-            else
-            assert( false , __FUNCTION__ , "illegal source device for IOPIC input" );
-
-            // set entry in local structure
-            *index = id; 
+        func    = FUNC_FROM_TYPE( type );
+
+        // get pointer on relevant field in iopic_input
+        if( valid )
+        {
+            if     ( func == DEV_FUNC_IOC )                 ptr = &iopic_input.ioc[channel]; 
+            else if((func == DEV_FUNC_TXT) && (is_rx == 0)) ptr = &iopic_input.txt_tx[channel];
+            else if((func == DEV_FUNC_TXT) && (is_rx != 0)) ptr = &iopic_input.txt_rx[channel];
+            else if((func == DEV_FUNC_NIC) && (is_rx == 0)) ptr = &iopic_input.nic_tx[channel]; 
+            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     panic( "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++ )
+                {
+                    cxy_t  cxy = (x<<info->y_width) + y;
+                    hal_remote_swd( XPTR( cxy , ptr ) , id ); 
+                }
+            }
         }
     } 
 
-#if( CONFIG_KINIT_DEBUG > 1 )
-printk("\n[DMSG] %s created PIC chdev in cluster %x at cycle %d\n",
-__FUNCTION__ , local_cxy , (uint32_t)hal_time_stamp() );
+#if( CONFIG_KINIT_DEBUG & 0x1 )
+if( hal_time_stamp() > CONFIG_KINIT_DEBUG )
+{
+    printk("\n[DBG] %s created PIC chdev in cluster %x at cycle %d\n",
+    __FUNCTION__ , local_cxy , (uint32_t)hal_time_stamp() );
+    dev_pic_inputs_display();
+}
 #endif
     
@@ -715 +767 @@
     hal_set_current_thread( thread );
 
-    // each core initializes the idle thread "locks_root" and "xlocks_root" fields
+    // each core register core descriptor pointer in idle thread descriptor
+    thread->core = &LOCAL_CLUSTER->core_tbl[core_lid];
+
+    // each core initializes locks_root" and "xlocks_root" in idle thread descriptor
     list_root_init( &thread->locks_root );
     xlist_root_init( XPTR( local_cxy , &thread->xlocks_root ) );
@@ -728 +783 @@
 
     if( (core_lid ==  0) && (local_cxy == 0) ) 
-    printk("\n[KINIT] %s : exit barrier 0 : TXT0 initialized / cycle %d\n",
+    kinit_dmsg("\n[DBG] %s : exit barrier 0 : TXT0 initialized / cycle %d\n",
     __FUNCTION__, hal_time_stamp() );
 
     /////////////////////////////////////////////////////////////////////////////
-    // STEP 1 : all cores check its core identifier.
+    // STEP 1 : all cores check core identifier.
     //          CP0 initializes the local cluster manager.
     //          This includes the memory allocators.
@@ -762 +817 @@
 
     if( (core_lid ==  0) && (local_cxy == 0) ) 
-    printk("\n[KINIT] %s : exit barrier 1 : clusters initialised / cycle %d\n",
+    kinit_dmsg("\n[DBG] %s : exit barrier 1 : clusters initialised / cycle %d\n",
     __FUNCTION__, hal_time_stamp() );
 
     /////////////////////////////////////////////////////////////////////////////////
-    // STEP 2 : all CP0s initialize the process_zero descriptor.
+    // STEP 2 : CP0 initializes the process_zero descriptor.
     //          CP0 in cluster 0 initializes the IOPIC device.
     /////////////////////////////////////////////////////////////////////////////////
@@ -787 +842 @@
 
     if( (core_lid ==  0) && (local_cxy == 0) ) 
-    printk("\n[KINIT] %s : exit barrier 2 : PIC initialised / cycle %d\n",
+    kinit_dmsg("\n[DBG] %s : exit barrier 2 : PIC initialised / cycle %d\n",
     __FUNCTION__, hal_time_stamp() );
 
     ////////////////////////////////////////////////////////////////////////////////
-    // STEP 3 : all CP0s initialize the distibuted LAPIC descriptor.
-    //          all CP0s initialize the internal chdev descriptors
-    //          all CP0s initialize the local external chdev descriptors
+    // STEP 3 : CP0 initializes the distibuted LAPIC descriptor.
+    //          CP0 initializes the internal chdev descriptors
+    //          CP0 initialize the local external chdev descriptors
     ////////////////////////////////////////////////////////////////////////////////
 
@@ -818 +873 @@
 
     if( (core_lid ==  0) && (local_cxy == 0) ) 
-    printk("\n[KINIT] %s : exit barrier 3 : all chdev initialised / cycle %d\n",
+    kinit_dmsg("\n[DBG] %s : exit barrier 3 : all chdev initialised / cycle %d\n",
                __FUNCTION__, hal_time_stamp());
 
     /////////////////////////////////////////////////////////////////////////////////
     // STEP 4 : All cores enable IPI (Inter Procesor Interrupt),
-    //          All cores initialise specific core registers
     //          Alh cores initialize IDLE thread.
     //          Only CP0 in cluster 0 creates the VFS root inode.
@@ -837 +891 @@
     hal_enable_irq( &status );
 
-    // All cores initialize specific core registers
-    hal_core_init( info );
-
     // all cores initialize the idle thread descriptor
     error = thread_kernel_init( thread,
@@ -857 +908 @@
 
 #if CONFIG_KINIT_DEBUG
-sched_display();
+sched_display( core_lid );
 #endif
 
@@ -928 +979 @@
 
     if( (core_lid ==  0) && (local_cxy == 0) ) 
-    printk("\n[KINIT] %s : exit barrier 4 : VFS_root = %l in cluster 0 / cycle %d\n",
+    kinit_dmsg("\n[DBG] %s : exit barrier 4 : VFS_root = %l in cluster 0 / cycle %d\n",
                __FUNCTION__, vfs_root_inode_xp , hal_time_stamp());
 
@@ -987 +1038 @@
 
     if( (core_lid ==  0) && (local_cxy == 0) ) 
-    printk("\n[KINIT] %s : exit barrier 5 : VFS_root = %l in cluster IO / cycle %d\n",
+    kinit_dmsg("\n[DBG] %s : exit barrier 5 : VFS_root = %l in cluster IO / cycle %d\n",
     __FUNCTION__, vfs_root_inode_xp , hal_time_stamp() );
 
@@ -1020 +1071 @@
 
     if( (core_lid ==  0) && (local_cxy == 0) ) 
-    printk("\n[KINIT] %s : exit barrier 6 : dev_root = %l in cluster IO / cycle %d\n",
+    kinit_dmsg("\n[DBG] %s : exit barrier 6 : dev_root = %l in cluster IO / cycle %d\n",
     __FUNCTION__, devfs_dev_inode_xp , hal_time_stamp() );
 
@@ -1057 +1108 @@
 
     if( (core_lid ==  0) && (local_cxy == 0) ) 
-    printk("\n[KINIT] %s : exit barrier 7 : dev_root = %l in cluster 0 / cycle %d\n",
+    kinit_dmsg("\n[DBG] %s : exit barrier 7 : dev_root = %l in cluster 0 / cycle %d\n",
     __FUNCTION__, devfs_dev_inode_xp , hal_time_stamp() );
 
@@ -1075 +1126 @@
     /////////////////////////////////////////////////////////////////////////////////
 
+#if CONFIG_KINIT_DEBUG
+sched_display( core_lid );
+#endif
+
     if( (core_lid ==  0) && (local_cxy == 0) ) 
-    printk("\n[KINIT] %s : exit barrier 8 : process init created / cycle %d\n", 
+    kinit_dmsg("\n[DBG] %s : exit barrier 8 : process init created / cycle %d\n", 
     __FUNCTION__ , hal_time_stamp() );
 
@@ -1118 +1173 @@
                    sizeof( core_t            ),
                    sizeof( scheduler_t       ),
-                   sizeof( rpc_fifo_t        ),
+                   sizeof( remote_fifo_t     ),
                    sizeof( page_t            ),
                    sizeof( mapper_t          ),
@@ -1139 +1194 @@
     dev_pic_enable_timer( CONFIG_SCHED_TICK_MS_PERIOD );
 
-    // each core jump to idle thread
+    // each core jump to thread_idle_func
     thread_idle_func();
 }

trunk/kernel/kern/printk.c

@@ -190 +190 @@
         goto xprintf_text;
     }
-} // end xprintf()
-
-///////////////////////////////////////////////////////////////////////////////////
-// This static function is called by kernel_printf() to display a string on the
-// TXT channel defined by the <channel> argument. 
-// The access mode is defined by the <busy> argument:
-// - if <busy> is true, it uses the dev_txt_sync_write() function, that takes the
-//   TXT lock, and call directly the relevant TXT driver, without descheduling.
-// - if <busy is false, it uses the dev_txt_write() function, that register the
-//   write buffer in the relevant TXT chdev queue, and uses a descheduling policy.
-///////////////////////////////////////////////////////////////////////////////////
-// @ channel  : TXT channel.
-// @ busy     : TXT device acces mode (busy waiting if non zero).
-// @ buf      : buffer containing the characters.
-// @ nc       : number of characters.
-// return 0 if success / return -1 if TTY0 busy after 10000 retries.
-///////////////////////////////////////////////////////////////////////////////////
-static error_t txt_write( uint32_t  channel,
-                          uint32_t  busy,
-                          char    * buffer,
-                          uint32_t  count )
-{
-    if( busy ) return dev_txt_sync_write( channel , buffer , count );
-    else       return dev_txt_write( channel , buffer , count );
-}  
+} // end snprintf()
 
 //////////////////////////////////////////////////////////////////////////////////////
-// This static function is called by printk(), assert() and nolock_printk() to build
-// a formated string.
+// This static function is called by printk(), assert() and nolock_printk()
+// to display a formated string on TXT0, using a busy waiting policy.
 //////////////////////////////////////////////////////////////////////////////////////
-// @ channel   : channel index.
-// @ busy      : TXT device access mode (busy waiting if non zero).
 // @ format    : printf like format.
-// @ args      : format arguments.
+// @ args      : va_list of arguments.
 //////////////////////////////////////////////////////////////////////////////////////
-static void kernel_printf( uint32_t   channel,
-                           uint32_t   busy,
-                           char     * format, 
+static void kernel_printf( char     * format, 
                            va_list  * args ) 
 {
@@ -239 +211 @@
         if (i) 
         {
-            txt_write( channel, busy, format, i );
+            dev_txt_sync_write( format, i );
             format += i;
         }
@@ -276 +248 @@
                 {
                     val = -val;
-                    txt_write( channel, busy, "-" , 1 );
+                    dev_txt_sync_write( "-" , 1 );
                 }
                 for(i = 0; i < 10; i++) 
@@ -302 +274 @@
             {
                 uint32_t val = va_arg( *args , uint32_t );
-                txt_write( channel, busy, "0x" , 2 );
+                dev_txt_sync_write( "0x" , 2 );
                 for(i = 0; i < 8; i++) 
                 {
@@ -315 +287 @@
             {
                 uint32_t val = va_arg( *args , uint32_t );
-                txt_write( channel, busy, "0x" , 2 );
+                dev_txt_sync_write( "0x" , 2 );
                 for(i = 0; i < 8; i++) 
                 {
@@ -328 +300 @@
             {
                 unsigned long long val = va_arg( *args , unsigned long long );
-                txt_write( channel, busy, "0x" , 2 );
+                dev_txt_sync_write( "0x" , 2 );
                 for(i = 0; i < 16; i++) 
                 {
@@ -341 +313 @@
             {
                 unsigned long long val = va_arg( *args , unsigned long long );
-                txt_write( channel, busy, "0x" , 2 );
+                dev_txt_sync_write( "0x" , 2 );
                 for(i = 0; i < 16; i++) 
                 {
@@ -363 +335 @@
             default:
             {
-                txt_write( channel , busy,
-                           "\n[PANIC] in kernel_printf() : illegal format\n", 45 );
-            }
-        }
-
-        if( pbuf != NULL ) txt_write( channel, busy, pbuf, len );
+                dev_txt_sync_write( "\n[PANIC] in kernel_printf() : illegal format\n", 45 );
+            }
+        }
+
+        if( pbuf != NULL ) dev_txt_sync_write( pbuf, len );
         
         goto printf_text;
@@ -382 +353 @@
 
     // get pointers on TXT0 chdev
-    xptr_t    txt0_xp  = chdev_dir.txt[0];
+    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 );
@@ -394 +365 @@
     // call kernel_printf on TXT0, in busy waiting mode
     va_start( args , format );
-    kernel_printf( 0 , 1 , format , &args );
+    kernel_printf( format , &args );
     va_end( args );
 
@@ -408 +379 @@
     // call kernel_printf on TXT0, in busy waiting mode
     va_start( args , format );
-    kernel_printf( 0 , 1 , format , &args );
+    kernel_printf( format , &args );
     va_end( args );
 }
@@ -419 +390 @@
 
     // get pointers on TXT0 chdev
-    xptr_t    txt0_xp  = chdev_dir.txt[0];
+    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 );
@@ -431 +402 @@
     // call kernel_printf on TXT0, in busy waiting mode
     va_start( args , format );
-    kernel_printf( 0 , 1 , format , &args );
+    kernel_printf( format , &args );
     va_end( args );
 
@@ -456 +427 @@
     {
         // get pointers on TXT0 chdev
-        xptr_t    txt0_xp  = chdev_dir.txt[0];
+        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 );
@@ -471 +442 @@
         // call kernel_printf on TXT0, in busy waiting to print format
         va_start( args , format );
-        kernel_printf( 0 , 1 , format , &args );
+        kernel_printf( format , &args );
         va_end( args );
 

trunk/kernel/kern/printk.h

@@ -102 +102 @@
              char       * format , ... );
 
-#define panic(fmt, ...)     _panic("[PANIC] %s(): " fmt "\n", __func__, ##__VA_ARGS__)
+#define panic(fmt, ...)     _panic("\n[PANIC] %s(): " fmt "\n", __func__, ##__VA_ARGS__)
 
 ///////////////////////////////////////////////////////////////////////////////////
@@ -108 +108 @@
 ///////////////////////////////////////////////////////////////////////////////////
 
+#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__)
@@ -186 +192 @@
 #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__)
@@ -234 +246 @@
 #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__)
@@ -264 +282 @@
 #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__)
@@ -310 +334 @@
 #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
 

trunk/kernel/kern/process.c

@@ -39 +39 @@
 #include <thread.h>
 #include <list.h>
+#include <string.h>
 #include <scheduler.h>
 #include <remote_spinlock.h>
@@ -90 +91 @@
     pid_t       parent_pid;
 
-    process_dmsg("\n[DMSG] %s : core[%x,%d] enters for process %x\n",
-    __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
+        error_t     error1;
+        error_t     error2;
+        error_t     error3;
+    xptr_t      stdin_xp;
+    xptr_t      stdout_xp;
+    xptr_t      stderr_xp;
+    uint32_t    stdin_id;
+    uint32_t    stdout_id;
+    uint32_t    stderr_id;
+
+process_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
 
     // get parent process cluster, local pointer, and pid
-    // for all processes other than process_zero
-    if( process == &process_zero )
+    // for all processes other than kernel process
+    if( process == &process_zero )                   // kernel process
     {
         assert( (pid == 0) , __FUNCTION__ , "process_zero must have PID = 0\n");
@@ -101 +112 @@
         parent_cxy = 0;
         parent_ptr = NULL;
-        parent_pid = 0;      // process_zero is its own parent...
-    }
-    else
-    {
-        assert( (parent_xp != XPTR_NULL) , __FUNCTION__ , "parent_xp cannot be NULL\n");
-
+        parent_pid = 0;      
+    }
+    else                                             // user process
+    {
         parent_cxy = GET_CXY( parent_xp );
         parent_ptr = (process_t *)GET_PTR( parent_xp );
@@ -112 +121 @@
     }
 
-    // initialize PID and PPID
-        process->pid   = pid;
-    process->ppid  = parent_pid;
-
-    // initialize reference process vmm (not for kernel process)
-    if( pid ) vmm_init( process );
-
-    // reset reference process file descriptors array
-        process_fd_init( process );
-
-    // reset reference process files structures and cwd_lock
-        process->vfs_root_xp     = XPTR_NULL;
-        process->vfs_bin_xp      = XPTR_NULL;
-        process->vfs_cwd_xp      = XPTR_NULL;
-    remote_rwlock_init( XPTR( local_cxy , &process->cwd_lock ) );
-
-    // reset children list root
-    xlist_root_init( XPTR( local_cxy , &process->children_root ) );
-        process->children_nr     = 0;
-
-    // reset semaphore / mutex / barrier / condvar list roots
-    xlist_root_init( XPTR( local_cxy , &process->sem_root ) );
-    xlist_root_init( XPTR( local_cxy , &process->mutex_root ) );
-    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 ) );
-
-    // register new process in the parent children list (not for kernel process)
+    // initialize PID, PPID, and REF
+        process->pid    = pid;
+    process->ppid   = parent_pid;
+    process->ref_xp = XPTR( local_cxy , process );
+
+    // initialize vmm, fd array and others structures for user processes.
+    // These structures are not used by the kernel process.
     if( pid )
     {
+        // initialize vmm (not for kernel)
+        vmm_init( process );
+
+process_dmsg("\n[DBG] %s : core[%x,%d] / vmm initialised for process %x\n", 
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
+
+        // initialize fd_array (not for kernel)
+        process_fd_init( process );
+
+        // create stdin / stdout / stderr pseudo-files (not for kernel)
+        if( parent_pid == 0 )                                              // process_init
+        {
+            error1 = vfs_open( process,
+                               CONFIG_INIT_STDIN,
+                               O_RDONLY, 
+                               0,                // FIXME chmod
+                               &stdin_xp, 
+                               &stdin_id );
+
+            error2 = vfs_open( process,
+                               CONFIG_INIT_STDOUT,
+                               O_WRONLY, 
+                               0,                // FIXME chmod
+                               &stdout_xp, 
+                               &stdout_id );
+
+            error3 = vfs_open( process,
+                               CONFIG_INIT_STDERR,
+                               O_WRONLY, 
+                               0,                // FIXME chmod
+                               &stderr_xp, 
+                               &stderr_id );
+        }
+        else                                                               // user process
+        {
+            error1 = vfs_open( process,
+                               CONFIG_USER_STDIN,
+                               O_RDONLY, 
+                               0,                // FIXME chmod
+                               &stdin_xp, 
+                               &stdin_id );
+
+            error2 = vfs_open( process,
+                               CONFIG_USER_STDOUT,
+                               O_WRONLY, 
+                               0,                // FIXME chmod
+                               &stdout_xp, 
+                               &stdout_id );
+
+            error3 = vfs_open( process,
+                               CONFIG_USER_STDERR,
+                               O_WRONLY, 
+                               0,                // FIXME chmod
+                               &stderr_xp, 
+                               &stderr_id );
+        }
+
+        assert( ((error1 == 0) && (error2 == 0) && (error3 == 0)) , __FUNCTION__ ,
+        "cannot open stdin/stdout/stderr pseudo files\n");
+
+        assert( ((stdin_id == 0) && (stdout_id == 1) && (stderr_id == 2)) , __FUNCTION__ ,
+        "bad indexes : stdin %d / stdout %d / stderr %d \n", stdin_id , stdout_id , stderr_id );
+
+process_dmsg("\n[DBG] %s : core[%x,%d] / fd array initialised for process %x\n", 
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
+
+
+        // reset reference process files structures and cwd_lock (not for kernel)
+            process->vfs_root_xp     = XPTR_NULL;
+            process->vfs_bin_xp      = XPTR_NULL;
+            process->vfs_cwd_xp      = XPTR_NULL;
+        remote_rwlock_init( XPTR( local_cxy , &process->cwd_lock ) );
+
+        // reset children list root (not for kernel)
+        xlist_root_init( XPTR( local_cxy , &process->children_root ) );
+            process->children_nr     = 0;
+
+        // reset semaphore / mutex / barrier / condvar list roots (nor for kernel)
+        xlist_root_init( XPTR( local_cxy , &process->sem_root ) );
+        xlist_root_init( XPTR( local_cxy , &process->mutex_root ) );
+        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 ) );
+
+        // register new process in the parent children list (nor for kernel)
         xptr_t entry = XPTR( local_cxy  , &process->brothers_list );
         xptr_t root  = XPTR( parent_cxy , &parent_ptr->children_root );
@@ -156 +229 @@
     spinlock_init( &process->th_lock );
 
-    // set ref_xp field
-    process->ref_xp = XPTR( local_cxy , process );
-
     // register new process descriptor in local cluster manager local_list
     cluster_process_local_link( process );
@@ -169 +239 @@
         hal_fence();
 
-    process_dmsg("\n[DMSG] %s : exit for process %x in cluster %x\n",
-                 __FUNCTION__ , pid );
+process_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
 
 }  // process_reference init()
@@ -181 +251 @@
     cxy_t       ref_cxy = GET_CXY( reference_process_xp );
     process_t * ref_ptr = (process_t *)GET_PTR( reference_process_xp );
+
+    // set the pid, ppid, ref_xp fields in local process
+    local_process->pid    = hal_remote_lw( XPTR( ref_cxy , &ref_ptr->pid ) );
+    local_process->ppid   = hal_remote_lw( XPTR( ref_cxy , &ref_ptr->ppid ) );
+    local_process->ref_xp = reference_process_xp;
+
+process_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x in cluster %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , local_process->pid );
 
     // reset local process vmm
@@ -192 +270 @@
     local_process->vfs_bin_xp  = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->vfs_bin_xp ) );
     local_process->vfs_cwd_xp  = XPTR_NULL;
-
-    // set the pid, ppid, ref_xp fields
-    local_process->pid    = hal_remote_lw( XPTR( ref_cxy , &ref_ptr->pid ) );
-    local_process->ppid   = hal_remote_lw( XPTR( ref_cxy , &ref_ptr->ppid ) );
-    local_process->ref_xp = reference_process_xp;
-
-    process_dmsg("\n[DMSG] %s : enter for process %x in cluster %x\n",
-                 __FUNCTION__ , local_process->pid );
 
     // reset children list root (not used in a process descriptor copy)
@@ -233 +303 @@
         hal_fence();
 
-    process_dmsg("\n[DMSG] %s : exit for process %x in cluster %x\n",
-                 __FUNCTION__ , local_process->pid );
+process_dmsg("\n[DBG] %s : core[%x,%d] exit for process %x in cluster %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , local_process->pid );
 
     return 0;
@@ -288 +358 @@
     vmm_destroy( process );
 
-        process_dmsg("\n[DMSG] %s for pid %d / page_faults = %d\n",
+        process_dmsg("\n[DBG] %s for pid %d / page_faults = %d\n",
                  __FUNCTION__ , process->pid, process->vmm.pgfault_nr );
-}
+
+}  // end process_destroy()
 
 ////////////////////////////////////////
@@ -298 +369 @@
     uint32_t       ltid;      // index in process th_tbl
     uint32_t       count;     // thread counter
+
+printk("\n@@@ %s enter\n", __FUNCTION__ );
 
     // get lock protecting th_tbl[]
@@ -317 +390 @@
     }
 
-    volatile uint32_t ko;
+printk("\n@@@ %s : %d signal(s) sent\n", __FUNCTION__, count );
 
     // second loop on threads to wait acknowledge from scheduler,
@@ -329 +402 @@
         if( thread != NULL )
         {
-            // wait scheduler acknowledge
-            do { ko = (thread->signals & THREAD_SIG_KILL); } while( ko );
-
-            // unlink thread from brothers list if required
-            if( (thread->flags & THREAD_FLAG_DETACHED) == 0 )
-            xlist_unlink( XPTR( local_cxy , &thread->brothers_list ) );
+
+printk("\n@@@ %s start polling at cycle %d\n", __FUNCTION__ , hal_time_stamp() );
+
+            // poll the THREAD_SIG_KILL bit until reset
+            while( thread->signals & THREAD_SIG_KILL ) asm volatile( "nop" );
+
+printk("\n@@@ %s exit polling\n", __FUNCTION__ );
+
+            // detach target thread from parent if attached
+            if( (thread->flags & THREAD_FLAG_DETACHED) != 0 ) 
+            thread_child_parent_unlink( thread->parent , XPTR( local_cxy , thread ) );
 
             // unlink thread from process
@@ -346 +424 @@
     }
 
+printk("\n@@@ %s : %d ack(s) received\n", __FUNCTION__, count );
+
     // release lock protecting th_tbl[]
     spinlock_unlock( &process->th_lock );
@@ -351 +431 @@
     // release memory allocated for process descriptor
     process_destroy( process );
-}
+
+printk("\n[@@@] %s : core[%x,%d] exit\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid );
+
+}  // end process_kill()
 
 ///////////////////////////////////////////////
@@ -440 +524 @@
 
 /////////////////////////////////////////////////
-error_t process_fd_register(  xptr_t     file_xp,
-                              uint32_t * file_id )
+error_t process_fd_register( process_t * process,
+                             xptr_t      file_xp,
+                             uint32_t  * fdid )
 {
     bool_t    found;
@@ -447 +532 @@
     xptr_t    xp;
 
-    // get extended pointer on reference process
-    xptr_t ref_xp = CURRENT_THREAD->process->ref_xp;
-
     // get reference process cluster and local pointer
+    xptr_t ref_xp = process->ref_xp;
     process_t * ref_ptr = (process_t *)GET_PTR( ref_xp );
     cxy_t       ref_cxy = GET_CXY( ref_xp );
@@ -467 +550 @@
             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 );
-                        *file_id = id;
+                        *fdid = id;
             break;
         }
@@ -481 +564 @@
 ////////////////////////////////////////////////
 xptr_t process_fd_get_xptr( process_t * process,
-                            uint32_t    file_id )
+                            uint32_t    fdid )
 {
     xptr_t  file_xp;
 
     // access local copy of process descriptor
-    file_xp = process->fd_array.array[file_id];
+    file_xp = process->fd_array.array[fdid];
 
     if( file_xp == XPTR_NULL )
@@ -496 +579 @@
 
         // access reference process descriptor
-        file_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->fd_array.array[file_id] ) );
+        file_xp = hal_remote_lwd( XPTR( ref_cxy , &ref_ptr->fd_array.array[fdid] ) );
 
         // update local fd_array if found
         if( file_xp != XPTR_NULL )
         {
-            process->fd_array.array[file_id] = file_xp;
+            process->fd_array.array[fdid] = file_xp;
         }
     }
 
     return file_xp;
-}
+
+}  // end process_fd_get_xptr()
 
 ///////////////////////////////////////////
@@ -543 +627 @@
     // release lock on source process fd_array
         remote_spinlock_unlock( XPTR( src_cxy , &src_ptr->lock ) );
-}
+
+}  // end process_fd_remote_copy()
 
 ////////////////////////////////////////////////////////////////////////////////////
@@ -561 +646 @@
     assert( (thread != NULL) , __FUNCTION__ , "thread argument is NULL" );
 
-    // search a free slot in th_tbl[]
+    // search a free slot in th_tbl[] 
+    // 0 is not a valid ltid value
     found = false;
-    for( ltid = 0 ; ltid < CONFIG_THREAD_MAX_PER_CLUSTER ; ltid++ )
+    for( ltid = 1 ; ltid < CONFIG_THREAD_MAX_PER_CLUSTER ; ltid++ )
     {
         if( process->th_tbl[ltid] == NULL )
@@ -606 +692 @@
 {
     char           * path;                            // pathname to .elf file
+    bool_t           keep_pid;                        // new process keep parent PID if true
     process_t      * process;                         // local pointer on new process
     pid_t            pid;                             // new process pid
     xptr_t           parent_xp;                       // extended pointer on parent process
-    cxy_t            parent_cxy;
-    process_t      * parent_ptr;
-    uint32_t         parent_pid;
+    cxy_t            parent_cxy;                      // parent process local cluster
+    process_t      * parent_ptr;                      // local pointer on parent process
+    uint32_t         parent_pid;                      // parent process identifier
     thread_t       * thread;                          // pointer on new thread
     pthread_attr_t   attr;                            // main thread attributes
@@ -618 +705 @@
         error_t          error;
 
-        // get parent and .elf pathname from exec_info
+        // get .elf pathname, parent_xp, and keep_pid flag from exec_info
         path      = exec_info->path;
     parent_xp = exec_info->parent_xp;
+    keep_pid  = exec_info->keep_pid;
+
+process_dmsg("\n[DBG] %s : core[%x,%d] enters for path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path );
 
     // get parent process cluster and local pointer
@@ -627 +718 @@
     parent_pid = hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid ) );
 
-    exec_dmsg("\n[DMSG] %s : thread %x on core[%x,%d] enters for path = %s\n",
-    __FUNCTION__, CURRENT_THREAD->trdid, local_cxy, CURRENT_THREAD->core->lid , path );
-
-    // create new process descriptor
-    process = process_alloc();
-
-    if( process == NULL )
-    {
-        printk("\n[ERROR] in %s : no memory / cluster = %x / ppid = %x / path = %s\n",
-               __FUNCTION__ , local_cxy , parent_pid , path );
-        return ENOMEM;
-    }
-
-    // get a pid from the local cluster
-    error = cluster_pid_alloc( XPTR( local_cxy , process ) , &pid );
-
-    if( error )
-    {
-        printk("\n[ERROR] in %s : cannot get PID / cluster = %x / ppid = %x / path = %s\n",
-               __FUNCTION__ , local_cxy , parent_pid , path );
-        process_free( process );
-                return ENOMEM;
-    }
+    // allocates memory for process descriptor 
+        process = process_alloc(); 
+        if( process == NULL ) return -1;
+
+    // get PID
+    if( keep_pid )    // keep parent PID
+    {
+        pid = parent_pid;
+    }
+    else              // get new PID from local cluster
+    {
+        error = cluster_pid_alloc( XPTR( local_cxy , process ) , &pid );
+        if( error ) return -1;
+    }
+
+process_dmsg("\n[DBG] %s : core[%x,%d] created process %x for path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid, path );
 
     // initialize the process descriptor as the reference
     process_reference_init( process , pid , parent_xp );
 
-    exec_dmsg("\n[DMSG] %s : thread %x on core[%x,%d] created process %x / path = %s\n",
-    __FUNCTION__, CURRENT_THREAD->trdid, local_cxy, CURRENT_THREAD->core->lid, pid, path );
+process_dmsg("\n[DBG] %s : core[%x,%d] initialized process %x / path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid, path );
 
     // initialize vfs_root and vfs_cwd from parent process
@@ -670 +755 @@
                             XPTR( parent_cxy , &parent_ptr->fd_array) );
 
-    exec_dmsg("\n[DMSG] %s : fd_array copied from process %x to process %x\n",
-    __FUNCTION__, parent_pid , pid );
-
-        // initialize signal manager TODO ??? [AG]
-        // signal_manager_init( process );
+process_dmsg("\n[DBG] %s :  core[%x,%d] copied fd_array for process %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid );
 
     // register "code" and "data" vsegs as well as the process entry-point in VMM,
@@ -682 +764 @@
         if( error )
         {
-                printk("\n[ERROR] in %s : failed to access elf file for process %x / path = %s\n",
+                printk("\n[ERROR] in %s : failed to access .elf file for process %x / path = %s\n",
                        __FUNCTION__, pid , path );
         process_destroy( process );
@@ -688 +770 @@
         }
 
-    exec_dmsg("\n[DMSG] %s : code and data vsegs registered for process %x / path = %s\n",
-    __FUNCTION__ , pid , path );
+process_dmsg("\n[DBG] %s : core[%x,%d] registered code/data vsegs for process %x / path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid, path );
 
     // select a core in cluster
@@ -709 +791 @@
         {
                 printk("\n[ERROR] in %s : cannot create thread for process %x / path = %s\n",
-                       __FUNCTION__, pid );
+                       __FUNCTION__, pid , path );
         process_destroy( process );
         return error;
         }
 
-        exec_dmsg("\n[DMSG] %s : thread created for process %x on core %d in cluster %x\n",
-               __FUNCTION__ , pid , core->lid , local_cxy );
-
-#if CONFIG_EXEC_DEBUG
-if( hal_time_stamp() > CONFIG_EXEC_DEBUG )
-{
-    grdxt_print( &process->vmm.grdxt , GRDXT_TYPE_VSEG , process->pid );
-    hal_gpt_print( &process->vmm.gpt , process->pid ); 
-}
-#endif
+process_dmsg("\n[DBG] %s : core[%x,%d] created thread %x for process %x / path = %s\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, thread->trdid, pid, path  );
 
     // update children list in parent process
@@ -733 +807 @@
         thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_GLOBAL );
 
-    exec_dmsg("\n[DMSG] %s : exit for process %x\n",
-                __FUNCTION__, process->pid );
+process_dmsg("\n[DBG] %s : core[%x,%d] exit for path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path  );
 
         return 0;
 
-}  // end proces_make_exec()
+}  // end process_make_exec()
 
 //////////////////////////
@@ -744 +818 @@
 {
     exec_info_t   exec_info;     // structure to be passed to process_make_exec()
-
-        error_t   error1;
-        error_t   error2;
-        error_t   error3;
-    xptr_t    stdin_xp;
-    xptr_t    stdout_xp;
-    xptr_t    stderr_xp;
-    uint32_t  stdin_id;
-    uint32_t  stdout_id;
-    uint32_t  stderr_id;
-
-        process_dmsg("\n[DMSG] %s : enters in cluster %x\n", __FUNCTION__ , local_cxy );
-
-    // open stdin / stdout / stderr pseudo-files
-        error1 = vfs_open( XPTR_NULL, CONFIG_DEV_STDIN , O_RDONLY, 0, &stdin_xp , &stdin_id  );
-        error2 = vfs_open( XPTR_NULL, CONFIG_DEV_STDOUT, O_WRONLY, 0, &stdout_xp, &stdout_id );
-        error3 = vfs_open( XPTR_NULL, CONFIG_DEV_STDERR, O_WRONLY, 0, &stderr_xp, &stderr_id );
-
-        assert( ((error1 == 0) && (error2 == 0) && (error3 == 0)) , __FUNCTION__ ,
-            "cannot open stdin/stdout/stderr pseudo files\n");
-
-    assert( ((stdin_id == 0) && (stdout_id == 1) && (stderr_id == 2)) , __FUNCTION__ ,
-            "bad indexes for stdin/stdout/stderr\n");
+    xptr_t        parent_xp;     // extended pointer on parent process.
+    error_t       error;
+
+process_dmsg("\n[DBG] %s : enters in cluster %x\n", 
+__FUNCTION__ , local_cxy );
+
+    // parent process is local kernel process
+    parent_xp = XPTR( local_cxy , &process_zero );
 
     // initialize the exec_info structure
-    exec_info.parent_xp    = XPTR( local_cxy , &process_zero );
+    exec_info.keep_pid     = false;
+    exec_info.parent_xp    = parent_xp;
     strcpy( exec_info.path , CONFIG_PROCESS_INIT_PATH );
     exec_info.args_nr      = 0;
     exec_info.envs_nr      = 0;
 
-    // create process_init and thread_init
-        error1 = process_make_exec( &exec_info );
-
-        assert( (error1 == 0) , __FUNCTION__ , "cannot create process_init\n");
-
-        process_dmsg("\n[DMSG] %s : exit in cluster %x\n", __FUNCTION__ , local_cxy );
+    // initialize process_init and create thread_init
+        error = process_make_exec( &exec_info );
+
+        if( error ) panic("cannot initialize process_init in cluster %x", local_cxy );
+
+process_dmsg("\n[DBG] %s : exit in cluster %x\n", 
+__FUNCTION__ , local_cxy );
                 
     hal_fence();

trunk/kernel/kern/process.h

@@ -143 +143 @@
 {
     xptr_t             parent_xp;      /*! extended pointer on parent process descriptor    */
+    bool_t             keep_pid;       /*! keep parent PID if true / new PID if false       */
 
     char               path[CONFIG_VFS_MAX_PATH_LENGTH];   /*!  .elf file path              */
@@ -175 +176 @@
 /*********************************************************************************************
  * This function allocates memory and initializes the "process_init" descriptor and the
- * associated "thread_init" descriptor. It should be called once at the end of the kernel
- * initialisation procedure, by the kernel "process_zero".
+ * associated "thread_init" descriptor in the local cluster. It is called once at the end
+ * of the kernel initialisation procedure, by the local kernel process.
  * The "process_init" is the first user process, and all other user processes will be forked
  * from this process. The code executed by "process_init" is stored in a .elf file, whose
- * pathname is defined by the CONFIG_PROCESS_INIT_PATH argument. It uses fork/exec syscalls
- * to create the "shell" user process, and various other user daemon processes.
- * Practically, it builds the exec_info structure, registers the stdin / stdout / stderr
- * pseudo-file descriptors and the vfs_root and vfs_cwd in parent process_zero, and calls
- * the generic process_make_exec() function, that makes the real job.
+ * pathname is defined by the CONFIG_PROCESS_INIT_PATH argument. 
+ * Practically, it builds the exec_info structure, and calls the process_make_exec() 
+ * function, that make the real job.
  ********************************************************************************************/
 void process_init_create();
@@ -253 +252 @@
  * and the associated main thread, from information found in the <exec_info> structure
  * (defined in the process.h file), that must be built by the caller.
+ * - If the <keep_pid> field is true, the new process inherits its PID from the parent PID.
+ * - If the <keep_pid> field is false, a new PID is allocated from the local cluster manager.
  * The new process inherits from the parent process (i) the open file descriptors, (ii) the
  * vfs_root and the vfs_cwd inodes.
@@ -268 +269 @@
 
 
-/********************   Signal Management Operations   **************************************/
-
-/*********************************************************************************************
- * This function TODO [AG]
- ********************************************************************************************/
-void process_signal_handler( process_t * process );
-
-
 /********************   File Management Operations   ****************************************/
 
@@ -287 +280 @@
 /*********************************************************************************************
  * 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 <file_id> argument.
+ * 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.
- * @ file_id  : file descriptor index in the fd_array.
+ * @ fdid     : file descriptor index in the fd_array.
  ********************************************************************************************/
 void process_fd_remove( process_t * process,
-                        uint32_t    file_id );
+                        uint32_t    fdid );
 
 /*********************************************************************************************
@@ -306 +299 @@
  *********************************************************************************************
  * @ process  : pointer on the local process descriptor.
- * @ file_id  : file descriptor index in the fd_array.
+ * @ 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    file_id );
+                            uint32_t    fdid );
 
 /*********************************************************************************************
@@ -328 +321 @@
  *********************************************************************************************
  * @ file_xp  : extended pointer on the file descriptor to be registered.
- * @ file_id  : [out] buffer for fd_array slot index.
+ * @ fdid     : [out] buffer for fd_array slot index.
  * @ return 0 if success / return EMFILE if array full.
  ********************************************************************************************/
-error_t process_fd_register( xptr_t      file_xp,
-                             uint32_t  * file_id );
+error_t process_fd_register( process_t * process,
+                             xptr_t      file_xp,
+                             uint32_t  * fdid );
 
 /*********************************************************************************************

trunk/kernel/kern/rpc.c

@@ -76 +76 @@
     &rpc_mapper_move_buffer_server,     // 24
     &rpc_mapper_get_page_server,        // 25
-    &rpc_undefined,                     // 26
-    &rpc_undefined,                     // 27
+    &rpc_vmm_create_vseg_server,        // 26
+    &rpc_sched_display_server,          // 27
     &rpc_undefined,                     // 28
     &rpc_undefined,                     // 29
@@ -97 +97 @@
                                 page_t  ** page )      // out 
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -115 +115 @@
 
     // get output arguments from RPC descriptor
-    *page    = (page_t *)(intptr_t)rpc.args[1];
-
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    *page = (page_t *)(intptr_t)rpc.args[1];
+
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -125 +125 @@
 void rpc_pmem_get_pages_server( xptr_t xp )
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -142 +142 @@
     hal_remote_swd( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -157 +157 @@
                                    pid_t     * pid )     // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -178 +178 @@
     *error  = (error_t)rpc.args[2];     
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -190 +190 @@
     pid_t       pid;       // output : process identifier
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -209 +209 @@
     hal_remote_sw( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)pid );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -224 +224 @@
                               error_t     * error )   // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -244 +244 @@
     *error  = (error_t)rpc.args[1];     
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -256 +256 @@
     error_t       error;     // local error error status
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -278 +278 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -291 +291 @@
 void rpc_process_kill_client( process_t * process ) 
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -325 +325 @@
     }
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -336 +336 @@
     process_t * process;  
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -360 +360 @@
     }
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -379 +379 @@
                                     error_t        * error )      // out 
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -387 +387 @@
     // initialise RPC descriptor header 
     rpc_desc_t  rpc;
-    rpc.index    = RPC_THREAD_USER_CREATE;
-    rpc.response = 1;
+    rpc.index     = RPC_THREAD_USER_CREATE;
+    rpc.response  = 1;
 
     // set input arguments in RPC descriptor 
@@ -403 +403 @@
     *error     = (error_t)rpc.args[5];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -421 +421 @@
     error_t          error;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -442 +442 @@
                        sizeof(pthread_attr_t) );
     
-    assert( (attr_copy.cxy == local_cxy) , __FUNCTION__ , "bad target cluster\n" );
-
     // call kernel function
     error = thread_user_create( pid,
@@ -453 +451 @@
     // set output arguments
     thread_xp = XPTR( local_cxy , thread_ptr );
-    hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
-    hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)thread_xp );
-
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)thread_xp );
+    hal_remote_swd( XPTR( client_cxy , &desc->args[5] ) , (uint64_t)error );
+
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -473 +471 @@
                                       error_t * error )      // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -496 +494 @@
     *error     = (error_t)rpc.args[4];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -509 +507 @@
     error_t          error;    
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -533 +531 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)thread_xp );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -547 +545 @@
                              uint32_t    sig_id )    // in
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -565 +563 @@
     rpc_send_sync( cxy , &rpc );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -576 +574 @@
     uint32_t     sig_id;   // signal index
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -591 +589 @@
     signal_rise( process , sig_id );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -613 +611 @@
                                   error_t      * error )     // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -641 +639 @@
     *error    = (error_t)rpc.args[9];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -660 +658 @@
     error_t          error;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -693 +691 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[9] ) , (uint64_t)error );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -706 +704 @@
                                    struct vfs_inode_s * inode )
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -723 +721 @@
     rpc_send_sync( cxy , &rpc );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -733 +731 @@
     vfs_inode_t * inode;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -747 +745 @@
     vfs_inode_destroy( inode );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -764 +762 @@
                                    error_t              * error )       // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -787 +785 @@
     *error     = (error_t)rpc.args[4];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -803 +801 @@
     char          name_copy[CONFIG_VFS_MAX_NAME_LENGTH];
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -829 +827 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -843 +841 @@
                                     vfs_dentry_t * dentry )
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -860 +858 @@
     rpc_send_sync( cxy , &rpc );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -870 +868 @@
     vfs_dentry_t * dentry;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -884 +882 @@
     vfs_dentry_destroy( dentry );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -901 +899 @@
                                  error_t              * error )      // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -923 +921 @@
     *error   = (error_t)rpc.args[3];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -936 +934 @@
     error_t       error;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -957 +955 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -970 +968 @@
                                   vfs_file_t * file )
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -987 +985 @@
     rpc_send_sync( cxy , &rpc );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -997 +995 @@
     vfs_file_t * file;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1011 +1009 @@
     vfs_file_destroy( file );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1027 +1025 @@
                                 error_t     * error )          // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1049 +1047 @@
     *error   = (error_t)rpc.args[3];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1064 +1062 @@
     char          name_copy[CONFIG_VFS_MAX_NAME_LENGTH];
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1087 +1085 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1101 +1099 @@
                                      error_t     * error )     // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1121 +1119 @@
     *error   = (error_t)rpc.args[1];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1132 +1130 @@
     vfs_inode_t * inode;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1149 +1147 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)error );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1162 +1160 @@
                                    mapper_t * mapper,    // in
                                    uint32_t   first,     // in
-                                   uint32_t   page,      // in
+                                   uint32_t   index,     // in
                                    uint32_t * cluster,   // out
                                    error_t  * error )    // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1180 +1178 @@
     rpc.args[0] = (uint64_t)(intptr_t)mapper;
     rpc.args[1] = (uint64_t)first;
-    rpc.args[2] = (uint64_t)page;
+    rpc.args[2] = (uint64_t)index;
 
     // register RPC request in remote RPC fifo 
@@ -1189 +1187 @@
     *error   = (error_t)rpc.args[4];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1199 +1197 @@
     mapper_t    * mapper;
     uint32_t      first;
-    uint32_t      page;
+    uint32_t      index;
     uint32_t      cluster;
     error_t       error;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1214 +1212 @@
     mapper = (mapper_t *)(intptr_t)hal_remote_lpt( XPTR( client_cxy , &desc->args[0] ) );
     first  = (uint32_t)            hal_remote_lw ( XPTR( client_cxy , &desc->args[1] ) );
-    page   = (uint32_t)            hal_remote_lw ( XPTR( client_cxy , &desc->args[2] ) );
+    index  = (uint32_t)            hal_remote_lw ( XPTR( client_cxy , &desc->args[2] ) );
 
     // call the kernel function
-    error = fatfs_get_cluster( mapper , first , page , &cluster );
+    error = fatfs_get_cluster( mapper , first , index , &cluster );
 
     // set output argument
@@ -1223 +1221 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1239 +1237 @@
                               error_t   * error )      // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1261 +1259 @@
     *error   = (error_t)rpc.args[3];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1275 +1273 @@
     error_t       error;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1295 +1293 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)error );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1309 +1307 @@
                              process_t * process,  // in 
                              vpn_t       vpn,      // in 
+                             bool_t      cow,      // in
                              uint32_t  * attr,     // out
                              ppn_t     * ppn,      // out
                              error_t   * error )   // out 
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1327 +1326 @@
     rpc.args[0] = (uint64_t)(intptr_t)process;
     rpc.args[1] = (uint64_t)vpn;
+    rpc.args[2] = (uint64_t)cow;
 
     // register RPC request in remote RPC fifo (blocking function)
@@ -1332 +1332 @@
 
     // get output argument from rpc descriptor
-    *attr  = (uint32_t)rpc.args[2];
-    *ppn   = (ppn_t)rpc.args[3];
-    *error = (error_t)rpc.args[4];
-
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    *attr  = (uint32_t)rpc.args[3];
+    *ppn   = (ppn_t)rpc.args[4];
+    *error = (error_t)rpc.args[5];
+
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1346 +1346 @@
     process_t   * process;
     vpn_t         vpn;
+    bool_t        cow;
     uint32_t      attr;
     ppn_t         ppn;
     error_t       error;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1361 +1362 @@
     process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
     vpn     = (vpn_t)                hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+    cow     = (bool_t)               hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
     
     // call local kernel function
-    error = vmm_get_pte( process , vpn , &attr , &ppn ); 
+    error = vmm_get_pte( process , vpn , cow , &attr , &ppn ); 
 
     // set output argument "attr" & "ppn" to client RPC descriptor
-    hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)attr );
-    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)ppn );
-    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)error );
-
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    hal_remote_swd( XPTR( client_cxy , &desc->args[3] ) , (uint64_t)attr );
+    hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (uint64_t)ppn );
+    hal_remote_swd( XPTR( client_cxy , &desc->args[5] ) , (uint64_t)error );
+
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1384 +1386 @@
                            xptr_t *   buf_xp )     // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1404 +1406 @@
     *buf_xp = (xptr_t)rpc.args[1];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1412 +1414 @@
 void rpc_kcm_alloc_server( xptr_t xp )
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1433 +1435 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (uint64_t)buf_xp );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1447 +1449 @@
                           uint32_t   kmem_type )   // in
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1465 +1467 @@
     rpc_send_sync( cxy , &rpc );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1473 +1475 @@
 void rpc_kcm_free_server( xptr_t xp )
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1491 +1493 @@
     kmem_free( &req );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1510 +1512 @@
                                     error_t  * error )        // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1535 +1537 @@
     *error     = (error_t)rpc.args[6];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1552 +1554 @@
     error_t    error;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1592 +1594 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[6] ) , (uint64_t)error );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1607 +1609 @@
                                  page_t         ** page )      // out
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1628 +1630 @@
     *page = (page_t *)(intptr_t)rpc.args[2];
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1636 +1638 @@
 void rpc_mapper_get_page_server( xptr_t xp )
 {
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
     __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
     CURRENT_THREAD->core->lid , hal_time_stamp() );
@@ -1654 +1656 @@
     hal_remote_swd( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
 
-    rpc_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
-    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
-    CURRENT_THREAD->core->lid , hal_time_stamp() );
-}
-
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [26]          Marshaling functions attached to RPC_VMM_CREATE_VSEG
+/////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////
+void rpc_vmm_create_vseg_client( cxy_t              cxy,
+                                 struct process_s * process,
+                                 vseg_type_t        type,
+                                 intptr_t           base,
+                                 uint32_t           size,
+                                 uint32_t           file_offset,
+                                 uint32_t           file_size,
+                                 xptr_t             mapper_xp,
+                                 cxy_t              vseg_cxy,
+                                 struct vseg_s   ** vseg )
+{
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+
+    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
+
+    // initialise RPC descriptor header 
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_VMM_CREATE_VSEG;
+    rpc.response = 1;
+
+    // set input arguments in RPC descriptor 
+    rpc.args[0] = (uint64_t)(intptr_t)process;
+    rpc.args[1] = (uint64_t)type;
+    rpc.args[2] = (uint64_t)base;
+    rpc.args[3] = (uint64_t)size;
+    rpc.args[4] = (uint64_t)file_offset;
+    rpc.args[5] = (uint64_t)file_size;
+    rpc.args[6] = (uint64_t)mapper_xp;
+    rpc.args[7] = (uint64_t)vseg_cxy;
+
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send_sync( cxy , &rpc );
+
+    // get output values from RPC descriptor
+    *vseg = (vseg_t *)(intptr_t)rpc.args[8];
+
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+}
+
+////////////////////////////////////////////
+void rpc_vmm_create_vseg_server( xptr_t xp )
+{
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
+
+    // get input arguments from client RPC descriptor
+    process_t * process     = (process_t *)(intptr_t)hal_remote_lwd( XPTR(cxy , &desc->args[0]));
+    vseg_type_t type        = (vseg_type_t)(uint32_t)hal_remote_lwd( XPTR(cxy , &desc->args[1]));
+    intptr_t    base        = (intptr_t)             hal_remote_lwd( XPTR(cxy , &desc->args[2]));
+    uint32_t    size        = (uint32_t)             hal_remote_lwd( XPTR(cxy , &desc->args[3]));
+    uint32_t    file_offset = (uint32_t)             hal_remote_lwd( XPTR(cxy , &desc->args[4]));
+    uint32_t    file_size   = (uint32_t)             hal_remote_lwd( XPTR(cxy , &desc->args[5]));
+    xptr_t      mapper_xp   = (xptr_t)               hal_remote_lwd( XPTR(cxy , &desc->args[6]));
+    cxy_t       vseg_cxy    = (cxy_t)(uint32_t)      hal_remote_lwd( XPTR(cxy , &desc->args[7]));
+    
+    // call local kernel function
+    vseg_t * vseg = vmm_create_vseg( process,
+                                     type,
+                                     base,
+                                     size,
+                                     file_offset,
+                                     file_size,
+                                     mapper_xp,
+                                     vseg_cxy ); 
+
+    // set output arguments into client RPC descriptor
+    hal_remote_swd( XPTR( cxy , &desc->args[8] ) , (uint64_t)(intptr_t)vseg );
+
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [27]          Marshaling functions attached to RPC_SCHED_DISPLAY
+/////////////////////////////////////////////////////////////////////////////////////////
+
+////////////////////////////////////////////////////////
+void rpc_sched_display_client( cxy_t              cxy,
+                               lid_t              lid)
+{
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+
+    assert( (cxy != local_cxy) , __FUNCTION__ , "target cluster is not remote\n");
+
+    // initialise RPC descriptor header 
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_SCHED_DISPLAY;
+    rpc.response = 1;
+
+    // set input arguments in RPC descriptor 
+    rpc.args[0] = (uint64_t)lid;
+
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send_sync( cxy , &rpc );
+
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+}
+
+//////////////////////////////////////////
+void rpc_sched_display_server( xptr_t xp )
+{
+    rpc_dmsg("\n[DBG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc = (rpc_desc_t *)GET_PTR( xp );
+
+    // get input arguments from client RPC descriptor
+    lid_t lid = (lid_t)hal_remote_lw( XPTR(cxy , &desc->args[0]));
+    
+    // call local kernel function
+    sched_display( lid );
+
+    rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
+    __FUNCTION__ , CURRENT_THREAD->trdid , local_cxy, 
+    CURRENT_THREAD->core->lid , hal_time_stamp() );
+}
 
 /***************************************************************************************/
@@ -1668 +1808 @@
                     rpc_desc_t * rpc )
 {
-    uint32_t   cores;
     error_t    error;
-    bool_t     first;
-    reg_t      sr_save;
-
-    rpc_dmsg("\n[DMSG] %s : enter / client_cxy = %x / server_cxy = %x / cycle %d\n",
-    __FUNCTION__ , local_cxy , server_cxy , hal_time_stamp() );
-
-    // allocate and initialise an extended pointer on the RPC descriptor
+
+    thread_t * this = CURRENT_THREAD;
+    core_t   * core = this->core;
+
+    // register client thread pointer and core lid in RPC descriptor
+    rpc->thread    = this;
+    rpc->lid       = core->lid;
+
+    // build an extended pointer on the RPC descriptor
         xptr_t   desc_xp = XPTR( local_cxy , rpc );
 
     // get local pointer on rpc_fifo in remote cluster, with the 
-    // assumption that rpc_fifo pddresses are identical in all clusters
-    rpc_fifo_t * rf = &LOCAL_CLUSTER->rpc_fifo;
+    // assumption that local pointers are identical in all clusters
+    remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
 
         // try to post an item in remote fifo
@@ -1687 +1828 @@
     do
     { 
-        error = remote_fifo_put_item( XPTR( server_cxy , &rf->fifo ),
-                                      (uint64_t )desc_xp,
-                                      &first );
+        error = remote_fifo_put_item( XPTR( server_cxy , rpc_fifo ),
+                                      (uint64_t )desc_xp );
             if ( error ) 
         {
@@ -1695 +1835 @@
             __FUNCTION__ , local_cxy , server_cxy );
 
-            if( thread_can_yield() ) sched_yield( NULL );
+            if( thread_can_yield() ) sched_yield();
         }
     }
     while( error );
  
-    rpc_dmsg("\n[DMSG] %s : RPC %l registered / server_cxy = %x / cycle %d\n",
-    __FUNCTION__ , desc_xp , server_cxy , hal_time_stamp() );
+    hal_fence();
         
-    // send IPI to remote CP0, if this is the first RPC in remote FIFO,
-    // and there is no CPU is in kernel mode in server cluster.
-        if( first )
-        {
-        // get number of cores in kernel mode in server cluster
-        cores = hal_remote_lw( XPTR( server_cxy , &LOCAL_CLUSTER->cores_in_kernel ) );
-
-                if( cores == 0 ) // no core in kernel mode in server
-                {
-                    dev_pic_send_ipi( server_cxy , 0 );
-
-                    rpc_dmsg("\n[DMSG] %s : IPI sent / client_cxy = %x / server_cxy = %x\n",
-            __FUNCTION__, local_cxy , server_cxy );
-        }
-        }
-
-        // enable IRQs to allow incoming RPC and avoid deadlock
-        hal_enable_irq( &sr_save );
-
-    // the server thread poll the response slot until RPC completed
-    // TODO this could be replaced by a descheduling policy... [AG]
-    while( rpc->response ) asm volatile( "nop" );
-
-    // restore IRQs
-        hal_restore_irq( sr_save );
-
-    rpc_dmsg("\n[DMSG] %s : completed / client_cxy = %x / server_cxy = %x / cycle %d\n",
-    __FUNCTION__ , local_cxy , server_cxy , hal_time_stamp() );
-
+    // send IPI to the remote core corresponding to the client core
+        dev_pic_send_ipi( server_cxy , core->lid );
+
+    // wait RPC completion:
+    // - busy waiting policy during kernel_init, or if threads cannot yield
+    // - block and deschedule in all other cases
+
+    if( (this->type == THREAD_IDLE) || (thread_can_yield() == false) ) // busy waiting
+    {
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %s busy waiting after registering RPC\n"
+"        rpc = %d / server = %x / cycle %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , thread_type_str(this->type) ,
+rpc->index , server_cxy , hal_time_stamp() );
+
+        while( rpc->response ) hal_fixed_delay( 100 );
+    
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %s exit after RPC completion\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , thread_type_str(this->type) );
+
+    } 
+    else                                                              // block & deschedule
+    {
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %s deschedule after registering RPC\n"
+"        rpc = %d / server = %x / cycle %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , thread_type_str(this->type) ,
+rpc->index , server_cxy , hal_time_stamp() );
+
+        thread_block( this , THREAD_BLOCKED_RPC );
+        sched_yield();
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %s resumes after RPC completion\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , thread_type_str(this->type) );
+
+    }
+
+    // check response available
+    assert( (rpc->response == 0) , __FUNCTION__, "illegal RPC response\n" );
+
+    // acknowledge the IPI sent by the server
+    dev_pic_ack_ipi();
+    
 }  // end rpc_send_sync()
 
@@ -1740 +1893 @@
 /***************************************************************************************/
 
-///////////////////////////////////////////
-void rpc_fifo_init( rpc_fifo_t * rpc_fifo )
-{
-        rpc_fifo->count       = 0;
-        rpc_fifo->owner       = 0;
-        local_fifo_init( &rpc_fifo->fifo );
-}
-
-/////////////////////////////////////////////
-void rpc_execute_all( rpc_fifo_t * rpc_fifo )
-{
-        xptr_t         xp;             // extended pointer on RPC descriptor
-        uint32_t       count;          // handled RPC request counter
-        thread_t     * this;           // pointer on this RPC thread
-    core_t       * core;           // pointer on core running this thread
-    rpc_desc_t   * desc;           // pointer on RPC descriptor 
-    uint32_t       index;          // RPC index 
-    cxy_t          client_cxy;     // client cluster identifier
-        error_t        error;
-      
-        this  = CURRENT_THREAD; 
-    core  = this->core;   
-        count = 0;
-
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
-    __FUNCTION__, this->trdid, local_cxy, core->lid , hal_time_stamp() );
+////////////////
+void rpc_check()
+{
+    error_t         error;
+    thread_t      * thread;  
+    uint32_t        sr_save;
+
+    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;
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / interrupted thread %s / cycle %d\n",
+__FUNCTION__, local_cxy, core->lid, thread_type_str(this->type), hal_time_stamp() );
+
+    // interrupted thread not preemptable during RPC chek
+        hal_disable_irq( &sr_save );
+
+    // check RPC FIFO not empty and no RPC thread handling it  
+        if( (rpc_fifo->owner == 0) && (local_fifo_is_empty(rpc_fifo) == false) )
+    {
+        // search one non blocked RPC thread   
+        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 == 0 ) ) 
+            {
+                found = true;
+                break;
+            }
+        }
+
+        // create new RPC thread if not found    
+        if( found == false )                    
+        {
+            error = thread_kernel_create( &thread,
+                                          THREAD_RPC, 
+                                                      &rpc_thread_func, 
+                                          NULL,
+                                                      this->core->lid );
+                if( error ) 
+            {
+                printk("\n[WARNING] in %s : no memory for new RPC thread in cluster %x\n",
+                __FUNCTION__ , local_cxy );
+            }
+            else
+            {
+                // unblock created RPC thread
+                thread->blocked = 0;
+
+                // update core descriptor counter  
+                    hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , 1 );
+
+grpc_dmsg("\n[DBG] %s : core [%x,%d] creates a new RPC thread %x / cycle %d\n", 
+__FUNCTION__ , local_cxy , core->lid , thread->trdid , hal_time_stamp() );
+
+            }
+        }
+    }
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / interrupted thread %s deschedules / cycle %d\n", 
+__FUNCTION__, local_cxy, core->lid, thread_type_str(this->type), hal_time_stamp() );
+
+    // interrupted thread deschedule always           
+        sched_yield();
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / interrupted thread %s resume / cycle %d\n", 
+__FUNCTION__, local_cxy, core->lid, thread_type_str(this->type), hal_time_stamp() );
+
+    // interrupted thread restore IRQs after resume 
+        hal_restore_irq( sr_save );
+
+} // end rpc_check()
+
+
+//////////////////////
+void rpc_thread_func()
+{
+    uint32_t     count;       // handled RPC requests counter
+    error_t      empty;       // local RPC fifo state
+    xptr_t       desc_xp;     // extended pointer on RPC request
+    cxy_t        desc_cxy;    // RPC request cluster (client) 
+    rpc_desc_t * desc_ptr;    // RPC request local pointer 
+    uint32_t     index;       // RPC request index 
+    uint32_t     responses;   // number of responses received by client 
+    thread_t   * thread_ptr;  // local pointer on client thread
+    lid_t        core_lid;    // local index of client core
  
-    // handle up to CONFIG_RPC_PENDING_MAX requests before exit
-        do
-    {
-            error = local_fifo_get_item( &rpc_fifo->fifo, (uint64_t *)&xp );
-
-                if ( error == 0 )  // One RPC request successfully extracted from RPC_FIFO
+    // makes RPC thread not preemptable
+        hal_disable_irq( NULL );
+  
+        thread_t      * this     = CURRENT_THREAD;
+        remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
+
+    // two embedded loops:
+    // - external loop : "infinite" RPC thread
+    // - internal loop : handle up to CONFIG_RPC_PENDING_MAX RPC requests
+ 
+        while(1)  // external loop
+        {
+        // try to take RPC_FIFO ownership
+        if( hal_atomic_test_set( &rpc_fifo->owner , this->trdid ) )
         {
-            // get client cluster identifier and pointer on RPC descriptor
-            client_cxy = (cxy_t)GET_CXY( xp );
-            desc       = (rpc_desc_t *)GET_PTR( xp );
-
-            // get rpc index from RPC descriptor
-                index = hal_remote_lw( XPTR( client_cxy , &desc->index ) );
-
-            rpc_dmsg("\n[DMSG] %s : thread %x on core [%x,%d] / rpc = %d\n",
-                     __FUNCTION__ , this->trdid , core->lid , local_cxy , index );
-
-            // call the relevant server function
-            rpc_server[index]( xp );
-
-            // increment handled RPC counter
-                count++;
-
-            // notify RPC completion as required
-            hal_remote_atomic_add( XPTR( client_cxy , &desc->response ) , -1 );
-                }
+            // initializes RPC requests counter
+            count = 0;
+
+            // acknowledge local IPI 
+            dev_pic_ack_ipi();
+
+                    // exit internal loop in three cases:
+            // - RPC fifo is empty
+            // - ownership has been lost (because descheduling)
+            // - max number of RPCs is reached
+                while( 1 )  // internal loop
+            {
+                    empty = local_fifo_get_item( rpc_fifo , (uint64_t *)&desc_xp );
+
+                    if ( empty == 0 ) // one RPC request found
+                {
+                    // get client cluster and pointer on RPC descriptor
+                    desc_cxy = (cxy_t)GET_CXY( desc_xp );
+                    desc_ptr = (rpc_desc_t *)GET_PTR( desc_xp );
+
+                    // get rpc index from RPC descriptor
+                        index = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->index ) );
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / RPC thread %x / starts rpc %d / cycle %d\n",
+__FUNCTION__ , local_cxy , this->core->lid , this->trdid , index , hal_time_stamp() );
+
+                    // call the relevant server function
+                    rpc_server[index]( desc_xp );
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / RPC thread %x / completes rpc %d / cycle %d\n",
+__FUNCTION__ , local_cxy , this->core->lid , this->trdid , index , hal_time_stamp() );
+
+                    // increment handled RPC counter
+                        count++;
+
+                    // decrement response counter in RPC descriptor
+                    responses = hal_remote_atomic_add(XPTR( desc_cxy, &desc_ptr->response ), -1);
+
+                    // unblock client thread  and send IPI to client core if last response
+                    if( responses == 1 )
+                    { 
+                        // get pointer on client thread and unblock it
+                        thread_ptr = (thread_t *)hal_remote_lpt(XPTR(desc_cxy,&desc_ptr->thread));
+                        thread_unblock( XPTR(desc_cxy,thread_ptr) , THREAD_BLOCKED_RPC );
+
+                        hal_fence();
+
+                        // get client core lid and send IPI
+                        core_lid = hal_remote_lw(XPTR(desc_cxy, &desc_ptr->lid));
+                            dev_pic_send_ipi( desc_cxy , core_lid );
+                    }
+                        }
         
-                // exit loop in three cases:
-        // - fifo is empty
-        // - look has been released (because descheduling)
-        // - max number of RPCs has been reached
-                if( error || 
-            (rpc_fifo->owner != this->trdid) || 
-            (count > CONFIG_RPC_PENDING_MAX) ) break;
-        }
-    while( 1 );
-
-    // update RPC_FIFO global counter
-        rpc_fifo->count += count;
-
-}  // end rpc_execute_all()
+                // chek exit condition
+                        if( local_fifo_is_empty( rpc_fifo )  || 
+                    (rpc_fifo->owner != this->trdid) || 
+                    (count >= CONFIG_RPC_PENDING_MAX) ) break;
+                } // end internal loop
+
+            // release rpc_fifo ownership if not lost
+            if( rpc_fifo->owner == this->trdid ) rpc_fifo->owner = 0;
+        }
+
+        // sucide if too many RPC threads in cluster
+        if( LOCAL_CLUSTER->rpc_threads >= CONFIG_RPC_THREADS_MAX )
+            {
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] (RPC thread %x) suicide at cycle %d\n", 
+__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
+
+            // update RPC threads counter
+                hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , -1 );
+
+            // suicide
+                thread_exit();
+            }
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] (RPC thread %x) deschedules / cycle %d\n", 
+__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
+
+        // deschedule without blocking
+        sched_yield();
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] (RPC thread %x) resumes / cycle %d\n", 
+__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
+
+        } // end external loop
+
+} // end rpc_thread_func()
+
+
+
+
+
+
+
+
+
+/* deprecated [AG] 29/09/2017
 
 ////////////////////////////////////////////////////
-error_t rpc_activate_thread( rpc_fifo_t * rpc_fifo )
+error_t rpc_activate_thread( remote_fifo_t * rpc_fifo )
 {
         core_t      * core;
@@ -1827 +2116 @@
 
     assert( (this->trdid == rpc_fifo->owner) , __FUNCTION__ ,
-          "calling thread is not RPC_FIFO owner\n" );
+    "calling thread is not RPC_FIFO owner\n" );
 
     // makes the calling thread not preemptable
@@ -1833 +2122 @@
         hal_disable_irq( &sr_save );
 
-    // search a free RPC thread (must be in THREAD_BLOCKED_IDLE state)    
+grpc_dmsg("\n[DBG] %s : core[%x,%d] enter at cycle %d\n",
+__FUNCTION__ , local_cxy , core->lid , hal_time_stamp() );
+
+    // search one non blocked RPC thread   
     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 ) ) 
+        if( (thread->type == THREAD_RPC) && (thread->blocked == 0 ) ) 
         {
             found = true;
@@ -1845 +2137 @@
     }
 
-    if( found )                    // activate this idle RPC thread      
+    if( found == false )                    // create new RPC thread      
     {
-        // unblock it
-        thread->blocked = 0;
-
-        rpc_dmsg("\n[DMSG] %s : activate RPC thread %x on core [%x,%d] / cycle %d\n", 
-                          __FUNCTION__ , thread , core->gid , local_cxy , hal_time_stamp() );
-    }
-    else                           // create a new RPC thread
-    {
-        // create new thread
         error = thread_kernel_create( &thread,
                                       THREAD_RPC, 
@@ -1869 +2152 @@
         }
 
-        // unblock new thread
+        // unblock thread
         thread->blocked = 0;
 
@@ -1875 +2158 @@
             hal_atomic_add( &LOCAL_CLUSTER->rpc_threads , 1 );
 
-        rpc_dmsg("\n[DMSG] %s : create RPC thread %x on core [%x,%d] / cycle %d\n", 
-                          __FUNCTION__ , thread->trdid, local_cxy, core->lid, hal_time_stamp() );
+grpc_dmsg("\n[DBG] %s : core [%x,%d] creates RPC thread %x at cycle %d\n", 
+__FUNCTION__ , local_cxy , core->lid , thread->trdid , hal_time_stamp() );
+
     }
-
-    // update owner in rpc_fifo
+    else                           // create a new RPC thread
+    {
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] activates RPC thread %x at cycle %d\n", 
+__FUNCTION__ , local_cxy , core->lid , thread->trdid , hal_time_stamp() );
+
+    }
+
+    // update rpc_fifo owner
     rpc_fifo->owner = thread->trdid;
 
-    // current thread switch to RPC thread  
-        sched_yield( thread );
+    // current thread deschedule            
+        sched_yield();
 
     // restore IRQs for the calling thread 
@@ -1893 +2184 @@
 }  // end rpc_activate_thread()
 
-//////////////////
-bool_t rpc_check()
+////////////////
+void rpc_check()
 {
         thread_t   * this     = CURRENT_THREAD;
-        rpc_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
+        remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
     error_t      error;
 
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x / cluster %x / cycle %d\n",
-             __FUNCTION__ , this->trdid , local_cxy , hal_time_stamp() );
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / enter at cycle %d\n",
+__FUNCTION__ , local_cxy , this->core->lid , this->trdid , hal_time_stamp() );
 
     // calling thread does nothing if light lock already taken or FIFO empty  
         if( (rpc_fifo->owner != 0) || (local_fifo_is_empty( &rpc_fifo->fifo )) )
     {
-        rpc_dmsg("\n[DMSG] %s : exit do nothing / thread %x / cluster %x / cycle %d\n",
-                 __FUNCTION__ , this->trdid , local_cxy , hal_time_stamp() );
-
-        return false;
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / exit do nothing at cycle %d\n",
+__FUNCTION__ , local_cxy , this->core->lid , this->trdid , hal_time_stamp() );
+
+        return;
     }
 
@@ -1922 +2214 @@
 
             printk("\n[ERROR] in %s : no memory to create a RPC thread for core %d"
-                   " in cluster %x => do nothing\n",
-                   __FUNCTION__ , CURRENT_CORE->lid , local_cxy );
+            " in cluster %x => do nothing\n",
+            __FUNCTION__ , CURRENT_CORE->lid , local_cxy );
         }
 
-        rpc_dmsg("\n[DMSG] %s : exit after RPC thread activation / "
-                 "thread %x / cluster %x / cycle %d\n",
-                 __FUNCTION__ , this->trdid , local_cxy , hal_time_stamp() );
-
-        return true;
+        return;
     }
     else  // light lock taken by another thread
     {
-        rpc_dmsg("\n[DMSG] %s : exit do nothing / thread %x / cluster %x / cycle %d\n",
-                 __FUNCTION__ , this->trdid , local_cxy , hal_time_stamp() );
-
-        return false;
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / exit do nothing at cycle %d\n",
+__FUNCTION__ , local_cxy , this->core->lid , this->trdid , hal_time_stamp() );
+
+        return;
     }
 } // end rpc_check()
@@ -1949 +2238 @@
   
         thread_t   * this     = CURRENT_THREAD;
-        rpc_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
-
-    rpc_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d] / cycle %d\n",
-             __FUNCTION__, this->trdid, local_cxy, this->core->lid, hal_time_stamp() );
-
-    // this infinite loop is not preemptable
-    // the RPC thread deschedule only when the RPC_FIFO is empty
+        remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
+
         while(1)
         {
         // check fifo ownership (ownership should be given by rpc_activate()
-        if( this->trdid != rpc_fifo->owner )
-        {
-            panic("thread %x on core[%x,%d] not owner of RPC_FIFO",
-                  this->trdid, local_cxy, this->core->lid );
-        }
+        assert( (this->trdid == rpc_fifo->owner) , __FUNCTION__ ,
+        "thread %x on core[%x,%d] not owner of RPC_FIFO / owner = %x\n",
+        this->trdid, local_cxy, this->core->lid , rpc_fifo->owner );
  
         // executes pending RPC(s) 
         rpc_execute_all( rpc_fifo );
 
-        // release rpc_fifo ownership (can be lost during RPC execution)
+        // release rpc_fifo ownership if required
+        // (this ownership can be lost during RPC execution)
         if( rpc_fifo->owner == this->trdid ) rpc_fifo->owner = 0;
 
-
-        //  block and deschedule or sucide
-                if( LOCAL_CLUSTER->rpc_threads >= CONFIG_RPC_THREADS_MAX ) 
+        //  deschedule or sucide
+                if( LOCAL_CLUSTER->rpc_threads >= CONFIG_RPC_THREADS_MAX )  // suicide
                 {
-            rpc_dmsg("\n[DMSG] %s : RPC thread %x on core[%x,%d] suicide / cycle %d\n", 
-                    __FUNCTION__, this->trdid, local_cxy, this->core->lid, hal_time_stamp() );
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / suicide at cycle %d\n", 
+__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
 
             // update core descriptor counter
@@ -1984 +2267 @@
                         thread_exit();
                 }
-        else
+        else                                                       // deschedule
         {
-            rpc_dmsg("\n[DMSG] %s : RPC thread %x on core[%x,%d] blocks / cycle %d\n", 
-                        __FUNCTION__, this->trdid, local_cxy, this->core->lid, hal_time_stamp() ); 
-
-                    thread_block( this , THREAD_BLOCKED_IDLE );
-            sched_yield( NULL );
-
-                    rpc_dmsg("\n[DMSG] %s : RPC thread %x wake up on core[%x,%d] / cycle %d\n", 
-                __FUNCTION__, this->trdid, local_cxy, this->core->lid, hal_time_stamp() );
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / deschedule at cycle %d\n", 
+__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
+
+            sched_yield();
+
+grpc_dmsg("\n[DBG] %s : core[%x,%d] / thread %x / wake up at cycle %d\n", 
+__FUNCTION__, local_cxy, this->core->lid, this->trdid, hal_time_stamp() );
+
         }
         } // end while
 } // end rpc_thread_func()
 
+*/
+
+

trunk/kernel/kern/rpc.h

@@ -30 +30 @@
 #include <bits.h>
 #include <spinlock.h>
+#include <vseg.h>
 #include <remote_fifo.h>
 
@@ -82 +83 @@
     RPC_MAPPER_MOVE_BUFFER     = 24,
     RPC_MAPPER_GET_PAGE        = 25,
+    RPC_VMM_CREATE_VSEG        = 26,
+    RPC_SCHED_DISPLAY          = 27,
 
     RPC_MAX_INDEX              = 30,
@@ -100 +103 @@
 typedef struct rpc_desc_s
 {
-        rpc_index_t       index;       // index of requested RPC service
-        volatile uint32_t response;    // response valid when 0
-    uint64_t          args[10];    // input/output arguments buffer
+        rpc_index_t         index;       /*! index of requested RPC service           */
+        volatile uint32_t   response;    /*! response valid when 0                    */
+    struct thread_s   * thread;      /*! local pointer on client thread           */
+    uint32_t            lid;         /*! index of core running the calling thread */ 
+    uint64_t            args[10];    /*! input/output arguments buffer            */
 } 
 rpc_desc_t;
-
-/***********************************************************************************
- * This structure defines the RPC fifo, containing a remote_fifo, the owner RPC
- * thread TRDID (used as a light lock), and the intrumentation counter.
- *
- * Implementation note: the TRDID is a good owner identifier, because all
- * RPC threads in a given cluster belong to the same process_zero kernel process,
- * and RPC threads cannot have local index LTID = 0.
- **********************************************************************************/
-
-typedef struct rpc_fifo_s
-{
-        trdid_t           owner;       // owner thread / 0 if no owner
-        uint64_t          count;       // total number of received RPCs (instrumentation) 
-        remote_fifo_t     fifo;        // embedded remote fifo
-} 
-rpc_fifo_t;
-
 
 /**********************************************************************************/
@@ -149 +136 @@
 
 /***********************************************************************************
- * This function initialises the local RPC fifo and the lock protecting readers.
- * The number of slots is defined by the CONFIG_REMOTE_FIFO_SLOTS parameter.
- * Each slot contains an extended pointer on the RPC descriptor.
- ***********************************************************************************
- * @ rf     : pointer on the local RPC fifo.
- **********************************************************************************/ 
-void rpc_fifo_init( rpc_fifo_t * rf );
-
-/***********************************************************************************
  * This function is the entry point for RPC handling on the server side.
- * It is executed by a core receiving an IPI.
- * It checks the RPC fifo, try to take the light-lock and activates (or creates)
- * an RPC thread in case of success.
- ***********************************************************************************
- * @ returns true if success / false otherwise.
- **********************************************************************************/
-bool_t rpc_check();
+ * It is executed by a core receiving an IPI, and each time the core enters,
+ * or exit the kernel to handle .
+ * It does nothing and return if the RPC_FIFO is empty.
+ * The calling thread checks if it exist at least one non-blocked RPC thread,
+ * creates a new RPC if required, and deschedule to allow the RPC thead to execute.
+ **********************************************************************************/
+void rpc_check();
 
 /***********************************************************************************
  * This function contains the loop to execute all pending RPCs on the server side.
- * It should be called with irq disabled and after light lock acquisition.
+ * It is called by the rpc_thread_func() function with irq disabled, and after
+ * RPC_FIFO ownership acquisition.
  ***********************************************************************************
  * @ rpc_fifo  : pointer on the local RPC fifo
  **********************************************************************************/
-void rpc_execute_all( rpc_fifo_t * rpc_fifo );
-
-/**********************************************************************************
- * This function is called by any thread running on any core in any cluster,
- * that detected a non-empty RPC_FIFO and got the RPC_FIFO ownership.
- * It activates one RPC thread, and immediately switches to the RPC thread.
- * It gets the first free RPC thread from the core free-list, or creates a new one
- * when the core free-list is empty. 
- ***********************************************************************************
- * @ rpc_fifo : pointer on the non-empty RPC fifo.
- * @ return 0 if success / return ENOMEM if error.
- **********************************************************************************/
-error_t rpc_activate_thread( rpc_fifo_t * rpc_fifo );
-
-/***********************************************************************************
- * This function contains the infinite loop executed by each RPC thread.
+void rpc_execute_all( remote_fifo_t * rpc_fifo );
+
+/***********************************************************************************
+ * This function contains the infinite loop executed by a RPC thread.
  **********************************************************************************/
 void rpc_thread_func();
@@ -266 +233 @@
  ***********************************************************************************
  * @ cxy       : server cluster identifier.
- * @ attr      : [in]  pointer on pthread_attr_t in client cluster.
- * @ thread_xp : [out] pointer on buffer for thread extended pointer. 
+ * @ attr      : [in]  local pointer on pthread_attr_t in client cluster.
+ * @ thread_xp : [out] buffer for thread extended pointer. 
  * @ error     : [out] error status (0 if success).
  **********************************************************************************/
@@ -274 +241 @@
                                     void                  * start_func,
                                     void                  * start_arg,
-                                    struct pthread_attr_s * attr,
+                                    pthread_attr_t        * attr,
                                     xptr_t                * thread_xp,
                                     error_t               * error );
@@ -499 +466 @@
 
 /***********************************************************************************
- * [21] The RPC_VMM_GET_PTE returns in the "ppn" and "attr" arguments the PTE value
- * for a given VPN in a given process.
+ * [21] The RPC_VMM_GET_PTE returns in the <ppn> and <attr> arguments the PTE value
+ * for a given <vpn> in a given <process> (page_fault or copy_on_write event).
  * The server cluster is supposed to be the reference cluster, and the vseg
  * containing the VPN must be registered in the reference VMM.
- * It returns an error if physical memory cannot be allocated for the PTE2, 
+ * It returns an error if physical memory cannot be allocated for the missing PTE2, 
  * or for the missing page itself.
  ***********************************************************************************
@@ -509 +476 @@
  * @ process : [in]   pointer on process descriptor in server cluster. 
  * @ vaddr   : [in]   virtual address to be searched.
+ * @ cow     : [in]   "copy_on_write" event if true / "page_fault" event if false.
  * @ attr    : [out]  address of buffer for attributes.
  * @ ppn     : [out]  address of buffer for PPN.
@@ -516 +484 @@
                              struct process_s * process,
                              vpn_t              vpn,
+                             bool_t             cow,
                              uint32_t         * attr,
                              ppn_t            * ppn,
@@ -601 +570 @@
 void rpc_mapper_get_page_server( xptr_t xp );
 
+/***********************************************************************************
+ * [26] The RPC_VMM_CREATE_VSEG allows a client thread to request the remote 
+ * reference cluster of a given process to allocate and register in the reference
+ * process VMM a new vseg descriptor.
+ * On the server side, this RPC uses the vmm_create_vseg() function, and returns
+ * to the client the local pointer on the created vseg descriptor.
+ ***********************************************************************************
+ * @ cxy         : server cluster identifier.
+ * @ process     : [in]  local pointer on process descriptor in server.
+ * @ type        : [in]  vseg type.
+ * @ base        : [in]  base address (unused for dynamically allocated vsegs).
+ * @ size        : [in]  number of bytes.
+ * @ file_offset : [in]  offset in file (for CODE, DATA, FILE types).
+ * @ file_size   : [in]  can be smaller than size for DATA type.
+ * @ mapper_xp   : [in]  extended pointer on mapper (for CODE, DATA, FILE types).
+ * @ vseg_cxy    : [in]  target cluster for mapping (if not data type).
+ * @ vseg        : [out] local pointer on vseg descriptor / NULL if failure.
+ **********************************************************************************/
+void rpc_vmm_create_vseg_client( cxy_t              cxy,
+                                 struct process_s * process,
+                                 vseg_type_t        type,
+                                 intptr_t           base,
+                                 uint32_t           size,
+                                 uint32_t           file_offset,
+                                 uint32_t           file_size,
+                                 xptr_t             mapper_xp,
+                                 cxy_t              vseg_cxy,
+                                 struct vseg_s   ** vseg );
+
+void rpc_vmm_create_vseg_server( xptr_t xp );
+
+/***********************************************************************************
+ * [27] The RPC_SCHED_DISPLAY allows a client thread to request the display
+ * of a remote scheduler, identified by the <lid> argument.
+ ***********************************************************************************
+ * @ cxy         : server cluster identifier.
+ * @ lid         : [in]  local index of target core in client cluster.
+ **********************************************************************************/
+void rpc_sched_display_client( cxy_t              cxy,
+                               lid_t              lid );
+
+void rpc_sched_display_server( xptr_t xp );
+
 #endif

trunk/kernel/kern/scheduler.c

@@ -24 +24 @@
 #include <kernel_config.h>
 #include <hal_types.h>
+#include <hal_switch.h>
 #include <hal_irqmask.h>
 #include <hal_context.h>
@@ -38 +39 @@
 
 extern chdev_directory_t    chdev_dir;            // allocated in kernel_init.c file
-
+extern uint32_t             switch_save_sr[];     // allocated in kernel_init.c file
 
 ////////////////////////////////
@@ -127 +128 @@
 }  // end sched_remove()
 
-///////////////////////////////////////////
-void sched_kill_thread( thread_t * thread )
-{
-    // check thread locks
-    if( thread_can_yield() == false )
-    {
-        panic("thread %x in process %x on core[%x][%d]"
-              " did not released all locks",
-              thread->trdid , thread->process->pid, 
-              local_cxy , thread->core->lid ); 
-    }
-
-    // remove thread from scheduler
-    sched_remove_thread( thread );
-
-    // reset the THREAD_SIG_KILL signal
-    thread_reset_signal( thread , THREAD_SIG_KILL );
-
-}  // end sched_kill_thread()
-
 ////////////////////////////////////////
 thread_t * sched_select( core_t * core )
@@ -154 +135 @@
     scheduler_t * sched = &core->scheduler;
 
-    sched_dmsg("\n[DMSG] %s : enter core[%x,%d] / cycle %d\n",
-    __FUNCTION__ , local_cxy , core->lid , hal_time_stamp() );
-
     // take lock protecting sheduler lists
     spinlock_lock( &sched->lock );
@@ -163 +141 @@
     list_entry_t * last;
 
-    // first : scan the kernel threads list if not empty 
+    // first loop : scan the kernel threads list if not empty 
     if( list_is_empty( &sched->k_root ) == false )
     {
@@ -179 +157 @@
             thread = LIST_ELEMENT( current , thread_t , sched_list );
 
-            // return thread if not idle_thread and runnable 
-            if( (thread->type != THREAD_IDLE) && (thread->blocked == 0) ) 
+            // analyse kernel thread type
+            switch( thread->type )
             {
-                // release lock 
-                spinlock_unlock( &sched->lock );
-
-                sched_dmsg("\n[DMSG] %s : exit core[%x,%d] / k_thread = %x / cycle %d\n",
-                __FUNCTION__ , local_cxy , core->lid , thread->trdid , hal_time_stamp() );
-
-                return thread;
-            }
+                case THREAD_IDLE: // skip IDLE thread
+                break;
+
+                case THREAD_RPC:  // RPC thread if non blocked and FIFO non-empty
+                if( (thread->blocked == 0) && 
+                    (local_fifo_is_empty( &LOCAL_CLUSTER->rpc_fifo ) == 0) )
+                {
+                    spinlock_unlock( &sched->lock );
+                    return thread;
+                }
+                break;
+
+                default:          // DEV thread if non blocked
+                if( thread->blocked == 0 )
+                {
+                    spinlock_unlock( &sched->lock );
+                    return thread;
+                }
+                break;
+            }  // end switch type
         }
         while( current != last );
     }
 
-    // second : scan the user threads list if not empty 
+    // second loop : scan the user threads list if not empty 
     if( list_is_empty( &sched->u_root ) == false )
     {
@@ -213 +203 @@
             if( thread->blocked == 0 )
             {
-                // release lock 
                 spinlock_unlock( &sched->lock );
-
-                sched_dmsg("\n[DMSG] %s : exit core[%x,%d] / u_thread = %x / cycle %d\n",
-                __FUNCTION__ , local_cxy , core->lid , thread->trdid , hal_time_stamp() );
                 return thread;
             }
@@ -224 +210 @@
     }
 
-    // release lock 
+    // third : return idle thread if no runnable thread
     spinlock_unlock( &sched->lock );
-
-    sched_dmsg("\n[DMSG] %s : exit core[%x,%d] / idle = %x / cycle %d\n",
-    __FUNCTION__ , local_cxy , core->lid , sched->idle->trdid , hal_time_stamp() );
-
-    // third : return idle thread if no runnable thread
     return sched->idle;
 
 }  // end sched_select()
+
+///////////////////////////////////////////
+void sched_kill_thread( thread_t * thread )
+{
+    // check locks
+    if( thread_can_yield() == false )
+    {
+        panic("locks not released for thread %x in process %x on core[%x][%d]",
+        thread->trdid , thread->process->pid, local_cxy , thread->core->lid ); 
+    }
+
+    // remove thread from scheduler
+    sched_remove_thread( thread );
+
+    // reset the THREAD_SIG_KILL signal
+    thread_reset_signal( thread , THREAD_SIG_KILL );
+
+    // detached thread can suicide
+    if( thread->signals & THREAD_SIG_SUICIDE ) 
+    {
+        assert( (thread->flags & THREAD_FLAG_DETACHED), __FUNCTION__,
+        "thread must be detached in case of suicide\n" );
+
+        // remove thread from process
+        process_remove_thread( thread );
+
+        // release memory for thread descriptor 
+        thread_destroy( thread );
+    }
+}  // end sched_kill_thread()
 
 //////////////////////////////////////////
@@ -242 +253 @@
     scheduler_t  * sched = &core->scheduler;
 
-    sched_dmsg("\n[DMSG] %s : enter / thread %x on core[%x,%d]\n",
-    __FUNCTION__, CURRENT_THREAD->trdid , local_cxy , core->lid );
-
     // take lock protecting threads lists
     spinlock_lock( &sched->lock );
@@ -252 +260 @@
     {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
-        if( thread->signals & THREAD_SIG_KILL )  sched_kill_thread( thread );
+        if( thread->signals ) sched_kill_thread( thread );
     }
 
@@ -259 +267 @@
     {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
-        if( thread->signals & THREAD_SIG_KILL )  sched_kill_thread( thread );
+        if( thread->signals ) sched_kill_thread( thread );
     }
 
@@ -265 +273 @@
     spinlock_unlock( &sched->lock );
 
-    sched_dmsg("\n[DMSG] %s : exit / thread %x on core[%x,%d]\n",
-    __FUNCTION__, CURRENT_THREAD->trdid , local_cxy , core->lid );
-
 } // end sched_handle_signals()
 
-///////////////////////////////////
-void sched_yield( thread_t * next )
-{
-    reg_t         sr_save;
-
+//////////////////////////////////////
+void sched_update( thread_t * current,
+                   thread_t * next )
+{
+    scheduler_t * sched = &current->core->scheduler;
+
+    if( current->type == THREAD_USER ) sched->u_last = &current->sched_list;
+    else                               sched->k_last = &current->sched_list;
+
+    sched->current = next;
+}
+
+//////////////////
+void sched_yield()
+{
+    thread_t    * next;
     thread_t    * current = CURRENT_THREAD;
-    core_t      * core    = current->core;
-    scheduler_t * sched   = &core->scheduler;
-
-    sched_dmsg("\n[DMSG] %s : thread %x on core[%x,%d] enter / cycle %d\n",
-    __FUNCTION__, current->trdid, local_cxy, core->lid, hal_time_stamp() );
+ 
+#if( CONFIG_SCHED_DEBUG & 0x1 )
+if( hal_time_stamp() > CONFIG_SCHED_DEBUG ) sched_display( current->core->lid );
+#endif
 
     // delay the yield if current thread has locks
-    if( thread_can_yield() == false )
+    if( (current->local_locks != 0) || (current->remote_locks != 0) )
     {
         current->flags |= THREAD_FLAG_SCHED;
@@ -289 +304 @@
     }
 
-    // first loop on all threads to handle pending signals
-    sched_handle_signals( core );
-
-    // second loop on threads to select next thread if required
-    if( next == NULL ) next = sched_select( core );
+    // loop on threads to select next thread 
+    next = sched_select( current->core );
 
     // check next thread attached to same core as the calling thread
-    assert( (next->core == current->core), __FUNCTION__ , "next core != current core\n");
-
-    // check next thread not blocked
-    assert( (next->blocked == 0), __FUNCTION__ , "next thread is blocked\n");
+    assert( (next->core == current->core), __FUNCTION__ , 
+    "next core != current core\n");
+
+    // check next thread not blocked when type != IDLE
+    assert( (next->blocked == 0) || (next->type = THREAD_IDLE) , __FUNCTION__ ,
+    "next thread %x (%s) is blocked on core[%x,%d]\n", 
+    next->trdid , thread_type_str(next->type) , local_cxy , current->core->lid );
 
     // switch contexts and update scheduler state if next != current
         if( next != current )
     {
-        sched_dmsg("\n[DMSG] %s : trd %x (%s) on core[%x,%d] => trd %x (%s) / cycle %d\n",
-        __FUNCTION__, current->trdid, thread_type_str(current->type), local_cxy, core->lid, 
-        next->trdid, thread_type_str(next->type), hal_time_stamp() );
-
-        // calling thread desactivate IRQs
-        hal_disable_irq( &sr_save );
+        // current thread desactivate IRQs
+        hal_disable_irq( &switch_save_sr[CURRENT_THREAD->core->lid] );
+
+sched_dmsg("\n[DBG] %s : core[%x,%d] / trd %x (%s) (%x,%x) => trd %x (%s) (%x,%x) / cycle %d\n",
+__FUNCTION__, local_cxy, current->core->lid, 
+current, thread_type_str(current->type), current->process->pid, current->trdid,
+next   , thread_type_str(next->type)   , next->process->pid   , next->trdid,
+hal_time_stamp() );
 
         // update scheduler 
-        if( current->type == THREAD_USER ) sched->u_last = &current->sched_list;
-        else                               sched->k_last = &current->sched_list;
-        sched->current = next;
-
-        // handle FPU
+        sched_update( current , next );
+
+        // handle FPU ownership
             if( next->type == THREAD_USER )
         {
-                if( next == core->fpu_owner )  hal_fpu_enable();
-                else                           hal_fpu_disable();
+                if( next == current->core->fpu_owner )  hal_fpu_enable();
+                else                                    hal_fpu_disable();
         }
 
-        // switch contexts 
-        hal_cpu_context_switch( current , next );
-
-        // restore IRQs when calling thread resume
-        hal_restore_irq( sr_save );
+        // switch CPU from calling thread context to new thread context
+        hal_do_cpu_switch( current->cpu_context, next->cpu_context );
+
+        // restore IRQs when next thread resume
+        hal_restore_irq( switch_save_sr[CURRENT_THREAD->core->lid] );
     }
     else
     {
-        sched_dmsg("\n[DMSG] %s : thread %x on core[%x,%d] continue / cycle %d\n",
-        __FUNCTION__, current->trdid, local_cxy, core->lid, hal_time_stamp() );
+
+sched_dmsg("\n[DBG] %s : core[%x,%d] / thread %x (%s) continue / cycle %d\n",
+__FUNCTION__, local_cxy, current->core->lid, current->trdid, 
+thread_type_str(current->type) ,hal_time_stamp() );
+
     }
 }  // end sched_yield()
 
-////////////////////
-void sched_display()
+
+///////////////////////////////
+void sched_display( lid_t lid )
 {
     list_entry_t * iter;
@@ -343 +362 @@
     uint32_t       save_sr;
 
-    thread_t     * current = CURRENT_THREAD;
-    core_t       * core    = current->core;
+    if( lid >= LOCAL_CLUSTER->cores_nr )
+    {
+        printk("\n[ERROR] in %s : illegal local index %d in cluster %x\n",
+        __FUNCTION__ , lid , local_cxy );
+        return;
+    }
+
+    core_t       * core    = &LOCAL_CLUSTER->core_tbl[lid];
     scheduler_t  * sched   = &core->scheduler;
     
     // get pointers on TXT0 chdev
-    xptr_t    txt0_xp  = chdev_dir.txt[0];
+    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 );
@@ -358 +383 @@
     remote_spinlock_lock_busy( lock_xp , &save_sr );
 
-    nolock_printk("\n***** scheduler state for core[%x,%d]\n"
-           "kernel_threads = %d / user_threads = %d / current = %x\n",
-            local_cxy , core->lid, 
-            sched->k_threads_nr, sched->u_threads_nr, sched->current->trdid );
+    nolock_printk("\n***** scheduler state for core[%x,%d] at cycle %d\n"
+           "kernel_threads = %d / user_threads = %d / current = %x / idle = %x\n",
+            local_cxy , core->lid, hal_time_stamp(),
+            sched->k_threads_nr, sched->u_threads_nr,
+            sched->current->trdid , sched->idle->trdid );
 
     // display kernel threads
@@ -367 +393 @@
     {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
-        nolock_printk(" - type = %s / trdid = %x / pid = %x / func = %x / blocked_vect = %x\n",
+        nolock_printk(" - type = %s / trdid = %X / pid = %X / func = %X / blocked = %X\n",
         thread_type_str( thread->type ), thread->trdid, thread->process->pid,
         thread->entry_func, thread->blocked );
@@ -376 +402 @@
     {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
-        nolock_printk(" - type = %s / trdid = %x / pid = %x / func = %x / blocked_vect = %x\n",
+        nolock_printk(" - type = %s / trdid = %X / pid = %X / func = %X / blocked = %X\n",
         thread_type_str( thread->type ), thread->trdid, thread->process->pid,
         thread->entry_func, thread->blocked );

trunk/kernel/kern/scheduler.h

@@ -74 +74 @@
 
 /********************************************************************************************* 
- * This function handles pending signals for all registered threads, and tries to make 
- * a context switch for the core running the calling thread.
- * - If the <next> argument is not NULL, this next thread starts execution.
- * - If <next> is NULL, it calls the sched_select() function. If there is a runable thread
- *   (other than current thread or idle thread), this selected thread starts execution.
- * - If there is no other runable thread, the calling thread continues execution.
- * - If there is no runable thread, the idle thread is executed.
- *********************************************************************************************
- * @ next  : local pointer on next thread to run / call sched_select() if NULL.
+ * This function handles pending signals for all registered threads, and calls the 
+ * sched_select() function to make a context switch for the core running the calling thread.
  ********************************************************************************************/
-void sched_yield( struct thread_s * next );
+void sched_yield();
 
 /*********************************************************************************************
@@ -96 +89 @@
 /********************************************************************************************* 
  * This function is used by the scheduler of a given core to actually kill a thread that has 
- * the SIG_KILL signal set (following a thread_exit() or a thread_kill() event).
+ * the SIG_KILL / SIG_SUICIDE signal set (following a thread_exit() or a thread_kill() event).
  * - It checks that the thread has released all locks => panic otherwise...
- * - It detach the thread from the local process descriptor.
  * - It removes the thread from the scheduler.
- * - It release physical memory allocated for thread descriptor.
+ * - It reset the SIG_KILL signal to acknoledge the killer.
+ * - In case of SIG_SUCIDE, it removes the detached thread from its process, and destroys it.
  *********************************************************************************************
  * @ thread  : local pointer on the thread descriptor.
@@ -121 +114 @@
 
 /********************************************************************************************* 
- * This function display the internal state of the calling core scheduler.
+ * This function display the internal state of the local core identified by its <lid>.
+ *********************************************************************************************
+ * @ lid      : local index of target core.
  ********************************************************************************************/
-void sched_display();
+void sched_display( lid_t lid );
 
 

trunk/kernel/kern/signal.c

@@ -44 +44 @@
                 hal_atomic_or( &thread->signals , (1 << sig_id) );
 
-        signal_dmsg("\n[DMSG] %s : thread %x in process %x received signal %d\n",
+        signal_dmsg("\n[DBG] %s : thread %x in process %x received signal %d\n",
                     __FUNCTION__, thread->trdid , process->pid , sig_id );
         }
@@ -59 +59 @@
         thread_s * this = CURRENT_THREAD;
 
-        printk("\n[DMSG] %s : threadReceived signal %d, pid %d, tid %x, core %d  [ KILLED ]\n",
+        printk("\n[DBG] %s : threadReceived signal %d, pid %d, tid %x, core %d  [ KILLED ]\n",
                sig,
                this->process->pid,

trunk/kernel/kern/thread.c

@@ -57 +57 @@
     else if( type == THREAD_RPC    ) return "RPC";
     else if( type == THREAD_DEV    ) return "DEV";
-    else if( type == THREAD_KERNEL ) return "KER";
     else if( type == THREAD_IDLE   ) return "IDL";
     else                             return "undefined";
@@ -153 +152 @@
     }
 
+    // compute thread descriptor size without kernel stack
+    uint32_t desc_size = (intptr_t)(&thread->signature) - (intptr_t)thread + 4; 
+
         // Initialize new thread descriptor
     thread->trdid           = trdid;
@@ -170 +172 @@
     thread->u_stack_base    = u_stack_base;
     thread->u_stack_size    = u_stack_size;
-    thread->k_stack_base    = (intptr_t)thread;
-    thread->k_stack_size    = CONFIG_THREAD_DESC_SIZE;
+    thread->k_stack_base    = (intptr_t)thread + desc_size;
+    thread->k_stack_size    = CONFIG_THREAD_DESC_SIZE - desc_size;
 
     thread->entry_func      = func;         // thread entry point
@@ -178 +180 @@
     thread->signals         = 0;            // no pending signal
     thread->errno           = 0;            // no error detected
-    thread->fork_user       = 0;            // no fork required
-    thread->fork_cxy        = 0;
+    thread->fork_user       = 0;            // no user defined placement for fork
+    thread->fork_cxy        = 0;            // user defined target cluster for fork
 
     // thread blocked
@@ -221 +223 @@
     vseg_t       * vseg;         // stack vseg
 
-    thread_dmsg("\n[DMSG] %s : enters for process %x\n", __FUNCTION__ , pid );
+    assert( (attr != NULL) , __FUNCTION__, "pthread attributes must be defined" );
 
     // get process descriptor local copy
@@ -234 +236 @@
 
     // select a target core in local cluster
-    if( attr->attributes & PT_ATTR_CORE_DEFINED ) core_lid = attr->lid;
-    else                                          core_lid = cluster_select_local_core();
-
-    // check core local index
-    if( core_lid >= LOCAL_CLUSTER->cores_nr )
-    {
-            printk("\n[ERROR] in %s : illegal core index attribute = %d\n",
-               __FUNCTION__ , core_lid );
-
-        return EINVAL;
+    if( attr->attributes & PT_ATTR_CORE_DEFINED )
+    {
+        core_lid = attr->lid;
+        if( core_lid >= LOCAL_CLUSTER->cores_nr )
+        {
+                printk("\n[ERROR] in %s : illegal core index attribute = %d\n",
+            __FUNCTION__ , core_lid );
+            return EINVAL;
+        }
+    }
+    else
+    {
+        core_lid = cluster_select_local_core();
     }
 
     // allocate a stack from local VMM
-    vseg = vmm_create_vseg( process, 0 , 0 , VSEG_TYPE_STACK );
+    vseg = vmm_create_vseg( process,
+                            VSEG_TYPE_STACK,
+                            0,                 // size unused
+                            0,                 // length unused
+                            0,                 // file_offset unused
+                            0,                 // file_size unused
+                            XPTR_NULL,         // mapper_xp unused
+                            local_cxy );
 
     if( vseg == NULL )
@@ -287 +299 @@
 
     // set DETACHED flag if required
-    if( attr->attributes & PT_ATTR_DETACH ) thread->flags |= THREAD_FLAG_DETACHED;
+    if( attr->attributes & PT_ATTR_DETACH ) 
+    {
+        thread->flags |= THREAD_FLAG_DETACHED;
+    }
 
     // allocate & initialize CPU context
-        error = hal_cpu_context_create( thread );
-
-    if( error )
+        if( hal_cpu_context_create( thread ) )
     {
             printk("\n[ERROR] in %s : cannot create CPU context\n", __FUNCTION__ );
@@ -300 +313 @@
     }
 
-    // allocate & initialize FPU context
-    error = hal_fpu_context_create( thread );
-
-    if( error )
+    // allocate  FPU context
+    if( hal_fpu_context_alloc( thread ) )
     {
             printk("\n[ERROR] in %s : cannot create FPU context\n", __FUNCTION__ );
@@ -311 +322 @@
     }
 
-    thread_dmsg("\n[DMSG] %s : exit / trdid = %x / process %x / core = %d\n",
-                __FUNCTION__ , thread->trdid , process->pid , core_lid );
+thread_dmsg("\n[DBG] %s : core[%x,%d] exit / trdid = %x / process %x / core = %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid,
+thread->trdid , process->pid , core_lid );
 
     *new_thread = thread;
@@ -319 +331 @@
 }  // end thread_user_create()
 
-//////////////////////////////////////////////
+////////////////////////////////////////////////////
 error_t thread_user_fork( process_t * process,
+                          intptr_t    stack_base,
+                          uint32_t    stack_size,
                           thread_t ** new_thread )
 {
     error_t        error;
-        thread_t     * thread;       // pointer on new thread descriptor
+        thread_t     * child;       // pointer on new thread descriptor
     lid_t          core_lid;     // selected core local index
-        vseg_t       * vseg;         // stack vseg
-
-    thread_dmsg("\n[DMSG] %s : enters\n", __FUNCTION__ );
-
-    // allocate a stack from local VMM
-    vseg = vmm_create_vseg( process, 0 , 0 , VSEG_TYPE_STACK );
-
-    if( vseg == NULL )
-    {
-            printk("\n[ERROR] in %s : cannot create stack vseg\n", __FUNCTION__ );
-                return ENOMEM;
-    }
+
+thread_dmsg("\n[DBG] %s : core[%x,%d] enters\n",
+__FUNCTION__ , local_cxy , core_lid );
 
     // select a target core in local cluster
     core_lid = cluster_select_local_core();
 
-    // get pointer on calling thread descriptor
-    thread_t * this = CURRENT_THREAD;
+    // get pointer on parent thread descriptor
+    thread_t * parent = CURRENT_THREAD;
 
     // allocate memory for new thread descriptor
-    thread = thread_alloc();
-
-    if( thread == NULL )
+    child = thread_alloc();
+
+    if( child == NULL )
     {
         printk("\n[ERROR] in %s : cannot allocate new thread\n", __FUNCTION__ );
-        vmm_remove_vseg( vseg );
         return ENOMEM;
     }
 
     // initialize thread descriptor
-    error = thread_init( thread,
+    error = thread_init( child,
                          process,
                          THREAD_USER,
-                         this->entry_func,
-                         this->entry_args,
+                         parent->entry_func,
+                         parent->entry_args,
                          core_lid,
-                         vseg->min,
-                         vseg->max - vseg->min );
+                         stack_base,
+                         stack_size );
 
     if( error )
     {
             printk("\n[ERROR] in %s : cannot initialize new thread\n", __FUNCTION__ );
-        vmm_remove_vseg( vseg );
-        thread_release( thread );
+        thread_release( child );
         return EINVAL;
     }
 
-    // set ATTACHED flag if set in this thread
-    if( this->flags & THREAD_FLAG_DETACHED ) thread->flags = THREAD_FLAG_DETACHED;
-
-    // allocate & initialize CPU context from calling thread
-        error = hal_cpu_context_copy( thread , this );
-
-    if( error )
-    {
-            printk("\n[ERROR] in %s : cannot create CPU context\n", __FUNCTION__ );
-        vmm_remove_vseg( vseg );
-        thread_release( thread );
+    // return child pointer
+    *new_thread = child;
+
+    // set DETACHED flag if required
+    if( parent->flags & THREAD_FLAG_DETACHED ) child->flags = THREAD_FLAG_DETACHED;
+
+    // allocate CPU context for child thread
+        if( hal_cpu_context_alloc( child ) )
+    {
+            printk("\n[ERROR] in %s : cannot allocate CPU context\n", __FUNCTION__ );
+        thread_release( child );
         return ENOMEM;
     }
 
-    // allocate & initialize FPU context from calling thread
-        error = hal_fpu_context_copy( thread , this );
-
-    if( error )
-    {
-            printk("\n[ERROR] in %s : cannot create CPU context\n", __FUNCTION__ );
-        vmm_remove_vseg( vseg );
-        thread_release( thread );
+    // allocate FPU context for child thread
+        if( hal_fpu_context_alloc( child ) )
+    {
+            printk("\n[ERROR] in %s : cannot allocate FPU context\n", __FUNCTION__ );
+        thread_release( child );
         return ENOMEM;
     }
 
-    thread_dmsg("\n[DMSG] %s : exit / thread %x for process %x on core %d in cluster %x\n",
-                 __FUNCTION__, thread->trdid, process->pid, core_lid, local_cxy );
-
-    *new_thread = thread;
+    // copy kernel stack content from parent to child thread descriptor
+    void * dst = (void *)(&child->signature) + 4;
+    void * src = (void *)(&parent->signature) + 4;
+    memcpy( dst , src , parent->k_stack_size );
+
+thread_dmsg("\n[DBG] %s : core[%x,%d] exit / created main thread %x for process %x\n",
+__FUNCTION__, local_cxy , core_lid , child->trdid , process->pid );
+
         return 0;
 
@@ -416 +420 @@
         thread_t     * thread;       // pointer on new thread descriptor
 
-    thread_dmsg("\n[DMSG] %s : enter / for type %s on core[%x,%d] / cycle %d\n",
-    __FUNCTION__ , thread_type_str( type ) , local_cxy , core_lid , hal_time_stamp() );
-
-    assert( ( (type == THREAD_KERNEL) || (type == THREAD_RPC) ||
-              (type == THREAD_IDLE)   || (type == THREAD_DEV) ) ,
-              __FUNCTION__ , "illegal thread type" );
+thread_dmsg("\n[DBG] %s : core[%x,%d] enters / type % / cycle %d\n",
+__FUNCTION__ , local_cxy , core_lid , thread_type_str( type ) , hal_time_stamp() );
+
+    assert( ( (type == THREAD_IDLE) || (type == THREAD_RPC) || (type == THREAD_DEV) ) ,
+    __FUNCTION__ , "illegal thread type" );
 
     assert( (core_lid < LOCAL_CLUSTER->cores_nr) ,
@@ -449 +452 @@
         hal_cpu_context_create( thread );
 
-    thread_dmsg("\n[DMSG] %s : exit / trdid = %x / type = %s / core = [%x,%d] / cycle %d\n",
-    __FUNCTION__ , thread->trdid , thread_type_str(type) , 
-    local_cxy , core_lid , hal_time_stamp() );
+thread_dmsg("\n[DBG] %s : core = [%x,%d] exit / trdid = %x / type %s / cycle %d\n",
+__FUNCTION__, local_cxy, core_lid, thread->trdid, thread_type_str(type), hal_time_stamp() );
 
     *new_thread = thread;
@@ -465 +467 @@
                                             lid_t           core_lid )
 {
-    assert( ( (type == THREAD_KERNEL) || (type == THREAD_RPC) ||
-              (type == THREAD_IDLE)   || (type == THREAD_DEV) ) ,
-              __FUNCTION__ , "illegal thread type" );
-
-    if( core_lid >= LOCAL_CLUSTER->cores_nr )
-    {
-        panic("illegal core_lid / cores = %d / lid = %d / cxy = %x",
-              LOCAL_CLUSTER->cores_nr , core_lid , local_cxy );
-    }
+    assert( (type == THREAD_IDLE) , __FUNCTION__ , "illegal thread type" );
+
+    assert( (core_lid < LOCAL_CLUSTER->cores_nr) , __FUNCTION__ , "illegal core index" );
 
     error_t  error = thread_init( thread,
@@ -487 +483 @@
 
     return error;
-}
+
+}  // end thread_kernel_init()
 
 ///////////////////////////////////////////////////////////////////////////////////////
@@ -502 +499 @@
     core_t     * core       = thread->core;
 
-    thread_dmsg("\n[DMSG] %s : enters for thread %x in process %x / type = %s\n",
+    thread_dmsg("\n[DBG] %s : enters for thread %x in process %x / type = %s\n",
                 __FUNCTION__ , thread->trdid , process->pid , thread_type_str( thread->type ) );
 
@@ -556 +553 @@
         tm_end = hal_get_cycles();
 
-        thread_dmsg("\n[DMSG] %s : exit for thread %x in process %x / duration = %d\n",
+        thread_dmsg("\n[DBG] %s : exit for thread %x in process %x / duration = %d\n",
                        __FUNCTION__, thread->trdid , process->pid , tm_end - tm_start );
-}
+
+}   // end thread_destroy()
 
 /////////////////////////////////////////////////
@@ -609 +607 @@
 {
     hal_atomic_or( &thread->signals , mask );
+    hal_fence();
 }
 
@@ -616 +615 @@
 {
     hal_atomic_and( &thread->signals , ~mask );
-}
-
-//////////////////////////////////
-inline bool_t thread_is_joinable()
-{
-    thread_t * this = CURRENT_THREAD;
-    return( (this->brothers_list.next != XPTR_NULL) &&
-            (this->brothers_list.pred != XPTR_NULL) );
-}
-
-//////////////////////////////////
-inline bool_t thread_is_runnable()
-{
-    thread_t * this = CURRENT_THREAD;
-    return( this->blocked == 0 );
+    hal_fence();
 }
 
@@ -650 +635 @@
     {
         this->flags &= ~THREAD_FLAG_SCHED;
-        sched_yield( NULL );
-    }
-}
+        sched_yield();
+    }
+
+}  // end thread_check_sched()
+
+/////////////////////////////////////
+void thread_block( thread_t * thread,
+                   uint32_t   cause )
+{
+    // set blocking cause
+    hal_atomic_or( &thread->blocked , cause );
+    hal_fence();
+
+} // end thread_block()
+
+/////////////////////////////////////////
+uint32_t thread_unblock( xptr_t   thread,
+                         uint32_t cause )
+{
+    // get thread cluster and local pointer
+    cxy_t      cxy = GET_CXY( thread );
+    thread_t * ptr = (thread_t *)GET_PTR( thread );
+
+    // reset blocking cause
+    uint32_t previous = hal_remote_atomic_and( XPTR( cxy , &ptr->blocked ) , ~cause );
+    hal_fence();
+
+    // return a non zero value if the cause bit is modified 
+    return( previous & cause );
+
+}  // end thread_unblock()
 
 /////////////////////
@@ -664 +677 @@
         if( !thread_can_yield() )
         {
-        printk("ERROR in %s : thread %x in process %x on core %d in cluster %x\n"
-               " did not released all locks\n",
-               __FUNCTION__ , this->trdid , this->process->pid ,
-               CURRENT_CORE->lid , local_cxy );
+        printk("ERROR in %s : locks not released for thread %x in process %x on core[%x,%d]\n",
+        __FUNCTION__, this->trdid, this->process->pid, local_cxy, this->core->lid );
         return EINVAL;
     }
@@ -686 +697 @@
 
     // deschedule
-    sched_yield( NULL );
+    sched_yield();
     return 0;
-}
-
-/////////////////////////////////////
-void thread_block( thread_t * thread,
-                   uint32_t   cause )
-{
-    // set blocking cause
-    hal_atomic_or( &thread->blocked , cause );
-}
-
-////////////////////////////////////
-void thread_unblock( xptr_t   thread,
-                    uint32_t cause )
-{
-    // get thread cluster and local pointer
-    cxy_t      cxy = GET_CXY( thread );
-    thread_t * ptr = (thread_t *)GET_PTR( thread );
-
-    // reset blocking cause
-    hal_remote_atomic_and( XPTR( cxy , &ptr->blocked ) , ~cause );
-}
+
+}  // end thread_exit()
 
 /////////////////////////////////////
@@ -721 +713 @@
     // send an IPI to schedule the target thread core.
     dev_pic_send_ipi( local_cxy , target->core->lid );
-}
+
+}  // end thread_kill()
 
 ///////////////////////
 void thread_idle_func()
 {
-#if CONFIG_IDLE_DEBUG
-    lid_t  lid = CURRENT_CORE->lid;
-#endif
-
     while( 1 )
     {
-        idle_dmsg("\n[DMSG] %s : core[%x][%d] goes to sleep at cycle %d\n",
-                    __FUNCTION__ , local_cxy , lid , hal_get_cycles() );
-
-        // force core to sleeping state
-        //hal_core_sleep();
-
-        idle_dmsg("\n[DMSG] %s : core[%x][%d] wake up at cycle %d\n",
-                    __FUNCTION__ , local_cxy , lid , hal_get_cycles() );
-
-        // force scheduling
-        sched_yield( NULL );
+        if( CONFIG_THREAD_IDLE_MODE_SLEEP ) // force core to low-power mode
+        {
+
+idle_dmsg("\n[DBG] %s : core[%x][%d] goes to sleep at cycle %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_get_cycles() );
+
+            hal_core_sleep();
+
+idle_dmsg("\n[DBG] %s : core[%x][%d] wake up at cycle %d\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , hal_get_cycles() );
+
+        }
+        else                                // yield each ~ 100000 cycles
+
+        {
+             hal_fixed_delay( 500000 );
+        }
+
+        // force scheduling at each iteration
+        sched_yield();
    }
-}
+}  // end thread_idle()
+
 
 /////////////////////////////////////////////////

trunk/kernel/kern/thread.h

@@ -27 +27 @@
 
 #include <hal_types.h>
+#include <shared_syscalls.h>
 #include <hal_special.h>
 #include <xlist.h>
@@ -51 +52 @@
 
 /***************************************************************************************
- * This defines the various pthread_attr_t attributes bit-vector.
- **************************************************************************************/
-
-/***************************************************************************************
- * This opaque structure contains the user defined attributes for a user thread.
- * It is passed as input argument to the thread_user_create() function.
- * It is set by the user application itself, using the pthread_attr_***() functions.
- * The currently supported attributes are defined below.
- **************************************************************************************/
-
-typedef struct pthread_attr_s
-{
-        uint32_t    attributes;      /*! user defined attributes bit vector               */
-        cxy_t       cxy;             /*! target cluster identifier                        */
-        lid_t       lid;             /*! target core index                                */
-}
-pthread_attr_t;
-
-typedef enum
-{
-    PT_ATTR_DETACH          = 0x0001,  /*! user defined not joinable                  */
-    PT_ATTR_CLUSTER_DEFINED = 0x0002,  /*! user defined target cluster                */
-    PT_ATTR_CORE_DEFINED    = 0x0004,  /*! user defined core index in cluster         */
-}
-pt_attributes_t;
-
-/***************************************************************************************
  * This enum defines the thread types.
  **************************************************************************************/
@@ -86 +60 @@
         THREAD_RPC     = 1,          /*! kernel thread executing pending RPCs             */
         THREAD_DEV     = 2,          /*! kernel thread executing I/O device commands      */
-        THREAD_KERNEL  = 3,          /*! other kernel thread                              */
-        THREAD_IDLE    = 4,          /*! kernel idle thread                               */
-        THREAD_TYPES_NR
+        THREAD_IDLE    = 3,          /*! kernel idle thread                               */
 }
 thread_type_t;
@@ -100 +72 @@
 #define THREAD_FLAG_JOIN         0x0004  /*! Parent thread made a join                */
 #define THREAD_FLAG_EXIT         0x0008  /*! This thread made an exit                 */
-#define THREAD_FLAG_SCHED        0x0010  /*! Descheduling required for this thread    */
+#define THREAD_FLAG_SCHED        0x0010  /*! Scheduling required for this thread      */
 
 /***************************************************************************************
@@ -106 +78 @@
  **************************************************************************************/
 
-#define THREAD_SIG_KILL          0x0001  /*! This thread must be destroyed ASAP       */
+#define THREAD_SIG_KILL          0x0001  /*! This thread killed by another thread     */
+#define THREAD_SIG_SUICIDE       0x0002  /*! This thread required exit                */
 
 /***************************************************************************************
@@ -116 +89 @@
 #define THREAD_BLOCKED_MAPPER    0x0004  /*! thread wait mapper                       */
 #define THREAD_BLOCKED_JOIN      0x0008  /*! thread blocked in join / wait exit       */
-#define THREAD_BLOCKED_EXIT      0x0010  /*! thread blocked in exit / wait join i     */
+#define THREAD_BLOCKED_EXIT      0x0010  /*! thread blocked in exit / wait join       */
 #define THREAD_BLOCKED_KILL      0x0020  /*! thread received kill signal              */
 #define THREAD_BLOCKED_SEM       0x0040  /*! thread wait semaphore                    */
 #define THREAD_BLOCKED_PAGE      0x0080  /*! thread wait page access                  */
 #define THREAD_BLOCKED_USERSYNC  0x0100  /*! thread wait POSIX (cond/mutex/barrier)   */
-
-#define THREAD_BLOCKED_IDLE      0x1000  /*! thread RPC wait activation               */
+#define THREAD_BLOCKED_RPC       0x0200  /*! thread wait RPC completion               */
+
 #define THREAD_BLOCKED_DEV_QUEUE 0x2000  /*! thread DEV wait queue                    */
 #define THREAD_BLOCKED_DEV_ISR   0x4000  /*! thread DEV wait ISR                      */
@@ -199 +172 @@
 
     uint32_t            flags;           /*! bit vector of flags                      */
-    uint32_t            blocked;         /*! bit vector of blocking causes            */
-    uint32_t            signals;         /*! bit vector of signals                    */
+    volatile uint32_t   blocked;         /*! bit vector of blocking causes            */
+    volatile uint32_t   signals;         /*! bit vector of (KILL / SUICIDE) signals   */
 
         error_t             errno;           /*! errno value set by last system call      */
@@ -212 +185 @@
     remote_spinlock_t * children_lock;   /*! lock protecting the children list        */
 
-    xlist_entry_t       brothers_list;   /*! member of threads with same parent       */
+    xlist_entry_t       brothers_list;   /*! list of attached threads to same parent  */
 
         list_entry_t        sched_list;      /*! member of threads attached to same core  */
@@ -273 +246 @@
 
 /***************************************************************************************
- * This function allocates memory for an user thread descriptor in the local cluster,
+ * This function is used by the fork() system call to create the child process main 
+ * thread. It allocates memory for an user thread descriptor in the local cluster,
  * and initializes it from information contained in the calling thread descriptor.
- * It is used by the fork() system call to create the child process main thread.
- * The new thread is attached to the core with the lowest load.
- * It is registered in the process descriptor defined by the "process" argument.
- * This new thread inherits its execution context from the calling thread,
- * and the "loadable" field is NOT set.
- * The THREAD_BLOCKED_GLOBAL bit is set, and the thread must be activated to start.
+ * The new thread is attached to the core that has the lowest load in local cluster.
+ * It is registered in the child process descriptor defined by the <process> argument.
+ * This new thread inherits its user stack from the parent thread, as it uses the
+ * Copy-On-Write mechanism to get a private stack when required.
+ * The content of the parent kernel stack is copied into the child kernel stack, as 
+ * the Copy-On-Write mechanism cannot be used for kernel segments (because kernel 
+ * uses physical addressing on some architectures).
+ * The CPU and FPU execution contexts are created and linked to the new thread,
+ * but the actual context copy is NOT done. The THREAD_BLOCKED_GLOBAL bit is set,
+ * and the thread must be explicitely unblocked later to make the new thread runable.
  ***************************************************************************************
  * @ process      : local pointer on owner process descriptor.
+ * @ stack_base   : user stack base address (from parent).
+ * @ stack_size   : user stack size (from parent).
  * @ new_thread   : [out] address of buffer for new thread descriptor pointer.
  * @ returns 0 if success / returns ENOMEM if error.
  **************************************************************************************/
 error_t thread_user_fork( process_t * process,
+                          intptr_t    stack_base,
+                          uint32_t    stack_size,
                           thread_t ** new_thread );
 
@@ -351 +333 @@
  * It does NOT take a lock, as this function is always called by the parent thread.
  ***************************************************************************************
- * @ xp_parent : extended pointer on the parent thread descriptor.
- * @ xp_child  : extended pointer on the child thread descriptor.
- **************************************************************************************/
-void thread_child_parent_link( xptr_t  xp_parent,
-                               xptr_t  xp_child );
+ * @ parent_xp : extended pointer on the parent thread descriptor.
+ * @ child_xp  : extended pointer on the child thread descriptor.
+ **************************************************************************************/
+void thread_child_parent_link( xptr_t  parent_xp,
+                               xptr_t  child_xp );
 
 /***************************************************************************************
@@ -361 +343 @@
  * of attached children threads.
  ***************************************************************************************
- * @ xp_parent : extended pointer on the parent thread descriptor.
- * @ xp_child  : extended pointer on the child thread descriptor.
- **************************************************************************************/
-void thread_child_parent_unlink( xptr_t xp_parent,
-                                 xptr_t xp_child );
+ * @ parent_xp : extended pointer on the parent thread descriptor.
+ * @ child_xp  : extended pointer on the child thread descriptor.
+ **************************************************************************************/
+void thread_child_parent_unlink( xptr_t parent_xp,
+                                 xptr_t child_xp );
 
 /***************************************************************************************
@@ -386 +368 @@
 
 /***************************************************************************************
- * This function returns true if the calling thread is attached to its parent thread.
- **************************************************************************************/
-inline bool_t thread_is_joinable();
-
-/***************************************************************************************
- * This function returns true if the calling thread is not blocked.
- **************************************************************************************/
-inline bool_t thread_is_runnable();
-
-/***************************************************************************************
  * This function checks if the calling thread can deschedule.
  ***************************************************************************************
@@ -403 +375 @@
 
 /***************************************************************************************
- * This function implements the delayed descheduling machanism : It is called  by 
+ * This function implements the delayed descheduling mechanism : It is called  by 
  * all lock release functions, and calls the sched_yield() function when all locks 
- * have beeen released and the THREAD_FLAG_SCHED flag is set. 
+ * have beeen released and the calling thread THREAD_FLAG_SCHED flag is set. 
  **************************************************************************************/
 void thread_check_sched();
 
 /***************************************************************************************
- * This function can be used by the calling thread to suicide.
- * All locks must be previously released.
- * The scenario depends on the attached/detached flag :
- * - if detached, it sets the SIG_KILL signal in the "signals" bit_vector, registers
- *   the BLOCKED_EXIT bit in the "blocked" bit_vector, and deschedule.
- * - if attached, it simply sets the BLOCKED_EXIT bit in the "blocked" bit vector
- *   and deschedule. The SIG_KILL signal will be set by the parent thread when
- *   executing the pthread_join().
+ * This function is used by the calling thread to suicide.
+ * All locks must be previously released. The scenario depends on the DETACHED flag.
+ * if detached :
+ * 1) the calling thread sets the SIG_SUICIDE bit in the "signals" bit_vector,
+ *    registers the BLOCKED_GLOBAL bit in the "blocked" bit_vector, and deschedule.
+ * 2) the scheduler, detecting the SIG_SUICIDE bit, remove the thread from the
+ *    scheduler list, remove the thread from its process, and destroys the thread.
+ * if attached :
+ * 1) the calling thread simply sets the BLOCKED_EXIT bit in the "blocked" bit vector
+ *    and deschedule. 
+ * 2) The SIG_KILL bit and BLOCKED_SIGNAL bits are set by the parent thread when
+ *    executing the pthread_join(), and detecting the BLOCKED_EXIT bit.
+ *    The scenario is a standard kill as described below.
  ***************************************************************************************
  * @ returns 0 if success / returns EINVAL if locks_count is not zero.
@@ -424 +401 @@
 
 /***************************************************************************************
+ * This function request to kill a local target thread, with the following scenario:
+ * 1. This function set the BLOCKED_GLOBAL bit in target thread "blocked" bit_vector,
+ *    set the SIG_KILL bit in target thread "signals" bit_vector, and send an IPI
+ *    to the target thread core to force scheduling.
+ * 2. The scheduler, detecting the SIG_KILL set, removes the thread from the scheduler
+ *    list, and reset the SIG_KILL bit to acknowledge the killer.
+ * 3. The caller of this function, (such as the process_kill() function), must poll
+ *    SIG_KILL bit until reset, detach the thread from its parent if the thread is
+ *    attached, remove the thread from its process, and destroys the thread.
+ * 
+ * NOTE: The third step must be done by the caller to allows the process_kill()
+ *       function to parallelize the work on all schedulers in a given cluster.
+ ***************************************************************************************
+ * @ thread   : local pointer on the target thread.
+ **************************************************************************************/
+void thread_kill( thread_t * thread );
+
+/***************************************************************************************
  * This function registers a blocking cause in the target thread "blocked" bit vector.
- * Warning : this function does not deschedule the calling thread.
- * The descheduling can be forced by a sched_yield().
- ***************************************************************************************
- * @ thread   : local pointer on target thread.
+ * Warning : this function does not deschedule the calling thread, and the descheduling
+ * must be explicitely forced by a sched_yield().
+ ***************************************************************************************
+ * @ thread   : local pointer on target thread descriptor.
  * @ cause    : mask defining the cause (one hot).
  **************************************************************************************/
@@ -436 +431 @@
 /***************************************************************************************
  * This function resets the bit identified by the cause argument in the "blocked"
- * bit vector of a remote thread descriptor.
+ * bit vector of a remote thread descriptor, using an atomic access.
  * We need an extended pointer, because the client thread of an I/O operation on a
  * given device is not in the same cluster as the associated device descriptor.
@@ -444 +439 @@
  * @ thread   : extended pointer on the remote thread.
  * @ cause    : mask defining the cause (one hot).
- **************************************************************************************/
-void thread_unblock( xptr_t   thread,
-                     uint32_t cause );
-
-/***************************************************************************************
- * This function kills a target thread, identified by its local pointer.
- * It is generally called by the local process_destroy() function.
- * - it forces the global blocked bit in target thread descriptor.
- * - it set the SIG_KILL signal in target thread.
- * - it send an IPI_SCHED_REQUEST to the target thread core.
- ***************************************************************************************
- * @ thread   : local pointer on the target thread.
- * @ returns 0 if success / returns EINVAL if locks_count is not zero.
- **************************************************************************************/
-void thread_kill( thread_t * thread );
+ * @ return non zero if the bit-vector was actually modified / return 0 otherwise
+ **************************************************************************************/
+uint32_t thread_unblock( xptr_t   thread,
+                         uint32_t cause );
 
 /***************************************************************************************