Changeset 457 for trunk/kernel/kern

Timestamp:

Aug 2, 2018, 11:47:13 AM (6 years ago)

Author:

alain

Message:

This version modifies the exec syscall and fixes a large number of small bugs.
The version number has been updated (0.1)

Location:

trunk/kernel/kern

Files:

• chdev.c (modified) (6 diffs)
• chdev.h (modified) (1 diff)
• cluster.c (modified) (2 diffs)
• cluster.h (modified) (1 diff)
• core.c (modified) (1 diff)
• core.h (modified) (2 diffs)
• do_interrupt.c (modified) (1 diff)
• do_interrupt.h (modified) (1 diff)
• do_syscall.c (modified) (3 diffs)
• do_syscall.h (modified) (1 diff)
• dqdt.c (modified) (1 diff)
• dqdt.h (modified) (1 diff)
• kernel_init.c (modified) (19 diffs)
• printk.c (modified) (1 diff)
• printk.h (modified) (1 diff)
• process.c (modified) (47 diffs)
• process.h (modified) (7 diffs)
• rpc.c (modified) (17 diffs)
• rpc.h (modified) (1 diff)
• scheduler.c (modified) (1 diff)
• scheduler.h (modified) (1 diff)
• signal.c (modified) (1 diff)
• signal.h (modified) (1 diff)
• thread.c (modified) (15 diffs)
• thread.h (modified) (6 diffs)

trunk/kernel/kern/chdev.c

@@ -23 +23 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_special.h>
 #include <hal_remote.h>
@@ -127 +127 @@
     xptr_t     server_xp;     // extended pointer on server thread
     core_t   * core_ptr;      // local pointer on core running the server thread
-    uint32_t   lid;           // core running the server thread local index
+    uint32_t   server_lid;    // core running the server thread local index
     xptr_t     lock_xp;       // extended pointer on lock protecting the chdev queue
-    uint32_t   different;     // non zero if server thread core != client thread core
     uint32_t   save_sr;       // for critical section
 
@@ -154 +153 @@
 
     // get server core local index
-    lid = hal_remote_lw( XPTR( chdev_cxy , &core_ptr->lid ) );
+    server_lid = hal_remote_lw( XPTR( chdev_cxy , &core_ptr->lid ) );
 
 #if (DEBUG_CHDEV_CMD_RX || DEBUG_CHDEV_CMD_TX)
@@ -210 +209 @@
 #endif
 
+#if (DEBUG_CHDEV_CMD_RX & 1)
+if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
+printk("\n[DBG] in %s : client thread %x blocked\n", __FUNCTION__, this );
+#endif
+
     // unblock server thread if required
     if( hal_remote_lw( blocked_xp ) & THREAD_BLOCKED_IDLE )
@@ -216 +220 @@
 #if (DEBUG_CHDEV_CMD_TX & 1)
 if( (is_rx == 0) && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
-{
-printk("\n[DBG] in %s : server thread %x unblocked\n", __FUNCTION__, server_ptr );
-chdev_queue_display( chdev_xp );
-}
+printk("\n[DBG] in %s : TX server thread %x unblocked\n", __FUNCTION__, server_ptr );
+#endif
+
+#if (DEBUG_CHDEV_CMD_RX & 1)
+if( (is_rx) && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
+printk("\n[DBG] in %s : RX server thread %x unblocked\n", __FUNCTION__, server_ptr );
 #endif
 
@@ -227 +233 @@
 #if (DEBUG_CHDEV_CMD_TX & 1)
 if( (is_rx == 0)  && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
-{
 printk("\n[DBG] in %s : thread %x registered write request in chdev\n", __FUNCTION__, this );
-chdev_queue_display( chdev_xp );
-}
+#endif
+ 
+#if (DEBUG_CHDEV_CMD_RX & 1)
+if( (is_rx)  && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
+printk("\n[DBG] in %s : thread %x registered read request in chdev\n", __FUNCTION__, this );
 #endif
  
     // send IPI to core running the server thread when server != client
-    different = (lid != this->core->lid) || (local_cxy != chdev_cxy);
-    if( different )
-    {
-        dev_pic_send_ipi( chdev_cxy , lid ); 
-    
+    if( (server_lid != this->core->lid) || (local_cxy != chdev_cxy) )
+    {
+        dev_pic_send_ipi( chdev_cxy , server_lid ); 
+
 #if (DEBUG_CHDEV_CMD_TX & 1)
 if( (is_rx == 0)  && (DEBUG_CHDEV_CMD_TX < tx_cycle) )
-printk("\n[DBG] in %s : client thread %x sent IPI to server thread %x\n",
+printk("\n[DBG] in %s : client thread %x sent IPI to TX server thread %x\n",
+__FUNCTION__, this, server_ptr );
+#endif
+
+#if (DEBUG_CHDEV_CMD_RX & 1)
+if( (is_rx)  && (DEBUG_CHDEV_CMD_RX < rx_cycle) )
+printk("\n[DBG] in %s : client thread %x sent IPI to RX server thread %x\n",
 __FUNCTION__, this, server_ptr );
 #endif

trunk/kernel/kern/chdev.h

@@ -26 +26 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <xlist.h>
 #include <remote_spinlock.h>

trunk/kernel/kern/cluster.c

@@ -123 +123 @@
 
 #if( DEBUG_CLUSTER_INIT & 1 )
-uint32_t cycle = (uint32_t)hal_get_cycles();
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_CLUSTER_INIT < cycle )
 printk("\n[DBG] %s : KHM initialized in cluster %x at cycle %d\n",
@@ -133 +133 @@
 
 #if( DEBUG_CLUSTER_INIT & 1 )
-uint32_t cycle = (uint32_t)hal_get_cycles();
+cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_CLUSTER_INIT < cycle )
 printk("\n[DBG] %s : KCM initialized in cluster %x at cycle %d\n",

trunk/kernel/kern/cluster.h

@@ -28 +28 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <bits.h>
 #include <spinlock.h>

trunk/kernel/kern/core.c

@@ -24 +24 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_special.h>
 #include <errno.h>

trunk/kernel/kern/core.h

@@ -27 +27 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <list.h>
 #include <rpc.h>
@@ -65 +65 @@
 }
 core_t;
-
-/****************************************************************************************
- * This macro returns a pointer on the calling core descriptor.
- ***************************************************************************************/
-
-#define CURRENT_CORE  (CURRENT_THREAD->core)
 
 /***************************************************************************************

trunk/kernel/kern/do_interrupt.c

@@ -22 +22 @@
  */
 
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <kernel_config.h>
 #include <thread.h>

trunk/kernel/kern/do_interrupt.h

@@ -27 +27 @@
 #define _DO_INTERRUPT_H_
 
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <thread.h>
 

trunk/kernel/kern/do_syscall.c

@@ -22 +22 @@
  */
 
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_irqmask.h>
 #include <do_syscall.h>
@@ -102 +102 @@
     sys_trace,              // 47
     sys_fg,                 // 48
-    sys_undefined,          // 49
+    sys_is_fg,              // 49
 };
 
@@ -160 +160 @@
         else if( index == SYS_TRACE          ) return "TRACE";            // 47
         else if( index == SYS_FG             ) return "FG";               // 48
+        else if( index == SYS_IS_FG          ) return "IS_FG";            // 49
 
     else                                   return "undefined";    

trunk/kernel/kern/do_syscall.h

@@ -27 +27 @@
 #define _D0_SYSCALL_H_
 
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <thread.h>
 

trunk/kernel/kern/dqdt.c

@@ -23 +23 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_special.h>
 #include <hal_atomic.h>

trunk/kernel/kern/dqdt.h

@@ -26 +26 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_atomic.h>
 

trunk/kernel/kern/kernel_init.c

@@ -25 +25 @@
 #include <kernel_config.h>
 #include <errno.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_special.h>
 #include <hal_context.h>
@@ -186 +186 @@
            "    /_/        \\_\\ |______| |_|    |_|   \\_____/  |______/        |_|    |_|  |_|  \\_\\ |_|   |_|  \n"
            "\n\n\t\t Advanced Locality Management Operating System / Multi Kernel Hybrid\n"
-           "\n\n\t\t Version 0.0 / %d cluster(s) / %d core(s) per cluster / cycle %d\n\n",
-           nclusters , ncores , hal_time_stamp() );
+           "\n\n\t\t %s / %d cluster(s) / %d core(s) per cluster\n\n",
+           CONFIG_ALMOS_VERSION , nclusters , ncores );
 }
 
@@ -761 +761 @@
     reg_t        status;                    // running core status register
 
-    cxy_t        io_cxy = info->io_cxy;
-
-    assert( (io_cxy == ((info->x_size - 1)<<(info->y_width)) + (info->y_size - 1)) ,
-    __FUNCTION__ , "illegal IO cluter identifier\n" );
-
     /////////////////////////////////////////////////////////////////////////////////
     // STEP 0 : Each core get its core identifier from boot_info, and makes 
@@ -796 +791 @@
     thread->remote_locks = 0;
 
-    // CP0 in I/O cluster initialises TXT0 chdev descriptor
-    if( (core_lid == 0) && (core_cxy == io_cxy) ) txt0_device_init( info );
-
-    /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ), 
+    // CP0 in cluster 0 initialises TXT0 chdev descriptor
+    if( (core_lid == 0) && (core_cxy == 0) ) txt0_device_init( info );
+
+    /////////////////////////////////////////////////////////////////////////////////
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), 
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
@@ -838 +833 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ), 
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), 
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
@@ -865 +860 @@
     
     ////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ), 
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), 
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
@@ -898 +893 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ), 
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), 
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
@@ -926 +921 @@
 
     // all cores initialize the idle thread descriptor
-    error = thread_idle_init( thread,
-                              THREAD_IDLE,
-                              &thread_idle_func,
-                              NULL,
-                              core_lid );
-    if( error )
-    {
-        assert( false , __FUNCTION__ ,
-        "core[%x][%d] cannot initialize idle thread", local_cxy , core_lid );
-    }
+    thread_idle_init( thread,
+                      THREAD_IDLE,
+                      &thread_idle_func,
+                      NULL,
+                      core_lid );
 
     // all cores unblock idle thread, and register it in scheduler
@@ -1008 +998 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ), 
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), 
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
@@ -1069 +1059 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ), 
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), 
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
@@ -1076 +1066 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 5 : VFS_root = %l in cluster %x / cycle %d\n",
-__FUNCTION__, vfs_root_inode_xp , io_cxy , (uint32_t)hal_get_cycles());
+printk("\n[DBG] %s : exit barrier 5 : VFS_root = %l in cluster 0 / cycle %d\n",
+__FUNCTION__, vfs_root_inode_xp , (uint32_t)hal_get_cycles());
 #endif
 
@@ -1086 +1076 @@
     /////////////////////////////////////////////////////////////////////////////////
 
-    if( (core_lid ==  0) && (local_cxy == io_cxy) ) 
+    if( (core_lid ==  0) && (local_cxy == 0) ) 
     {
         // create "dev" and "external" directories.
@@ -1104 +1094 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ), 
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), 
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
@@ -1111 +1101 @@
 #if DEBUG_KERNEL_INIT
 if( (core_lid ==  0) & (local_cxy == 0) ) 
-printk("\n[DBG] %s : exit barrier 6 : dev_root = %l in cluster %x / cycle %d\n",
-__FUNCTION__, devfs_dev_inode_xp , io_cxy , (uint32_t)hal_get_cycles() );
+printk("\n[DBG] %s : exit barrier 6 : dev_root = %l in cluster 0 / cycle %d\n",
+__FUNCTION__, devfs_dev_inode_xp , (uint32_t)hal_get_cycles() );
 #endif
 
@@ -1125 +1115 @@
     if( core_lid == 0 )
     {
-        // get extended pointer on "extend" field of VFS context for DEVFS in cluster IO
-        xptr_t  extend_xp = XPTR( io_cxy , &fs_context[FS_TYPE_DEVFS].extend );
-
-        // get pointer on DEVFS context in cluster IO
+        // get extended pointer on "extend" field of VFS context for DEVFS in cluster 0
+        xptr_t  extend_xp = XPTR( 0 , &fs_context[FS_TYPE_DEVFS].extend );
+
+        // get pointer on DEVFS context in cluster 0
         devfs_ctx_t * devfs_ctx = hal_remote_lpt( extend_xp );
         
-        devfs_dev_inode_xp      = hal_remote_lwd( XPTR( io_cxy ,
-                                                        &devfs_ctx->dev_inode_xp ) );
-        devfs_external_inode_xp = hal_remote_lwd( XPTR( io_cxy , 
-                                                        &devfs_ctx->external_inode_xp ) );
+        devfs_dev_inode_xp      = hal_remote_lwd( XPTR( 0 , &devfs_ctx->dev_inode_xp ) );
+        devfs_external_inode_xp = hal_remote_lwd( XPTR( 0 , &devfs_ctx->external_inode_xp ) );
 
         // populate DEVFS in all clusters
@@ -1143 +1131 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ), 
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ), 
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
@@ -1158 +1146 @@
     /////////////////////////////////////////////////////////////////////////////////
 
-    if( (core_lid ==  0) && (local_cxy == 0) ) 
+    if( (core_lid == 0) && (local_cxy == 0) ) 
     {
 
@@ -1169 +1157 @@
 
     /////////////////////////////////////////////////////////////////////////////////
-    if( core_lid == 0 ) remote_barrier( XPTR( io_cxy , &global_barrier ),
+    if( core_lid == 0 ) remote_barrier( XPTR( 0 , &global_barrier ),
                                         (info->x_size * info->y_size) );
     barrier_wait( &local_barrier , info->cores_nr );
@@ -1189 +1177 @@
     /////////////////////////////////////////////////////////////////////////////////
     
-    if( (core_lid ==  0) && (local_cxy == io_cxy) ) 
+    if( (core_lid == 0) && (local_cxy == 0) ) 
     {
         print_banner( (info->x_size * info->y_size) , info->cores_nr );

trunk/kernel/kern/printk.c

@@ -22 +22 @@
  */
 
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_irqmask.h>
 #include <hal_special.h>

trunk/kernel/kern/printk.h

@@ -41 +41 @@
 #define _PRINTK_H
 
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <stdarg.h>
 

trunk/kernel/kern/process.c

@@ -25 +25 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_remote.h>
 #include <hal_uspace.h>
@@ -89 +89 @@
 void process_reference_init( process_t * process,
                              pid_t       pid,
-                             xptr_t      parent_xp,
-                             xptr_t      model_xp )
+                             xptr_t      parent_xp )
 {
     cxy_t       parent_cxy;
     process_t * parent_ptr;
-    cxy_t       model_cxy;
-    process_t * model_ptr;
     xptr_t      stdin_xp;
     xptr_t      stdout_xp;
@@ -110 +107 @@
     chdev_t *   chdev_ptr;
     cxy_t       chdev_cxy;
-    pid_t       model_pid;
     pid_t       parent_pid;
-
-    // get model process cluster and local pointer
-    model_cxy = GET_CXY( model_xp );
-    model_ptr = GET_PTR( model_xp );
 
     // get parent process cluster and local pointer
@@ -121 +113 @@
     parent_ptr = GET_PTR( parent_xp );
 
-    // get model_pid and parent_pid
+    // get parent_pid
     parent_pid = hal_remote_lw( XPTR( parent_cxy , &parent_ptr->pid ) );
-    model_pid  = hal_remote_lw( XPTR( model_cxy  , &model_ptr->pid ) );
 
 #if DEBUG_PROCESS_REFERENCE_INIT
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
-printk("\n[DBG] %s : thread %x enter / pid = %x / ppid = %x / model_pid = %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , pid , parent_pid , model_pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x enter to initalialize process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid , pid , cycle );
 #endif
 
@@ -146 +137 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
-printk("\n[DBG] %s : thread %x / vmm empty for process %x / cycle %d\n", 
-__FUNCTION__ , CURRENT_THREAD , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x / vmm empty for process %x / cycle %d\n", 
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid , cycle );
 #endif
 
@@ -154 +145 @@
 
     // define the stdin/stdout/stderr pseudo files <=> select a TXT terminal.
-    // - if INIT (pid == 1)         => link to kernel TXT[0] 
-    // - if KSH[i] (model_pid == 1) => allocate a free TXT[i] 
-    // - if USER process            => same terminal as model
-
-    if( (pid == 1) || (model_pid == 1)) // INIT or KSH process
-    {
-        if (pid == 1 )  txt_id = 0;                    // INIT
-        else            txt_id = process_txt_alloc();  // KSH[i]
-
-        // attach process to TXT[txt_id]
+    if( (pid == 1) || (parent_pid == 1)) // INIT or KSH process
+    {
+        // allocate a TXT channel
+        if( pid == 1 )  txt_id = 0;                     // INIT
+        else            txt_id = process_txt_alloc();   // KSH
+
+        // attach process to TXT
         process_txt_attach( process , txt_id ); 
+
+#if (DEBUG_PROCESS_REFERENCE_INIT & 1)
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_REFERENCE_INIT )
+printk("\n[DBG] %s : thread %x in process %x / process %x attached to TXT%d / cycle %d\n", 
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, txt_id, cycle );
+#endif
+
+
 
         // build path to TXT_RX[i] and TXT_TX[i] chdevs
@@ -184 +181 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
-printk("\n[DBG] %s : thread %x / stdin open for process %x / cycle %d\n", 
-__FUNCTION__ , CURRENT_THREAD , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x / stdin open for process %x / cycle %d\n", 
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
 #endif
 
@@ -202 +199 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
-printk("\n[DBG] %s : thread %x / stdout open for process %x / cycle %d\n", 
-__FUNCTION__ , CURRENT_THREAD , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x / stdout open for process %x / cycle %d\n", 
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
 #endif
 
@@ -220 +217 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_REFERENCE_INIT )
-printk("\n[DBG] %s : thread %x / stderr open for process %x / cycle %d\n", 
-__FUNCTION__ , CURRENT_THREAD , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x / stderr open for process %x / cycle %d\n", 
+__FUNCTION__, CURRENT_THREAD->trdid, parent_pid, pid, cycle );
 #endif
 
@@ -227 +224 @@
     else                                            // normal user process 
     {
-        // get extended pointer on stdin pseudo file in model process
-        file_xp = (xptr_t)hal_remote_lwd( XPTR( model_cxy , &model_ptr->fd_array.array[0] ) );
-
-        // get extended pointer on model process TXT chdev
+        // get extended pointer on stdin pseudo file in parent process
+        file_xp = (xptr_t)hal_remote_lwd( XPTR( parent_cxy , &parent_ptr->fd_array.array[0] ) );
+
+        // get extended pointer on parent process TXT chdev
         chdev_xp = chdev_from_file( file_xp );
  
@@ -243 +240 @@
         process_txt_attach( process , txt_id ); 
 
-        // copy all open files from model process fd_array to this process
+        // copy all open files from parent process fd_array to this process
         process_fd_remote_copy( XPTR( local_cxy , &process->fd_array ),
-                                XPTR( model_cxy , &model_ptr->fd_array ) );
+                                XPTR( parent_cxy , &parent_ptr->fd_array ) );
     }
 
     // initialize specific inodes root and cwd
-    process->vfs_root_xp = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
-                                                         &model_ptr->vfs_root_xp ) );
-    process->vfs_cwd_xp  = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
-                                                         &model_ptr->vfs_cwd_xp ) );
+    process->vfs_root_xp = (xptr_t)hal_remote_lwd( XPTR( parent_cxy,
+                                                         &parent_ptr->vfs_root_xp ) );
+    process->vfs_cwd_xp  = (xptr_t)hal_remote_lwd( XPTR( parent_cxy,
+                                                         &parent_ptr->vfs_cwd_xp ) );
     vfs_inode_remote_up( process->vfs_root_xp );
     vfs_inode_remote_up( process->vfs_cwd_xp );
@@ -469 +466 @@
 ////////////////////////////////////////
 void process_sigaction( pid_t       pid,
-                        uint32_t    action_type )
+                        uint32_t    type )
 {
     cxy_t              owner_cxy;         // owner cluster identifier
@@ -479 +476 @@
     xptr_t             process_xp;        // extended pointer on process copy
     cxy_t              process_cxy;       // process copy cluster identifier
+    process_t        * process_ptr;       // local pointer on process copy
     reg_t              save_sr;           // for critical section
     rpc_desc_t         rpc;               // shared RPC descriptor
-
-    thread_t * client = CURRENT_THREAD;
+    thread_t         * client;            // pointer on client thread
+    xptr_t             client_xp;         // extended pointer on client thread
+    process_t        * local;             // pointer on process copy in local cluster
+    uint32_t           remote_nr;         // number of remote process copies
+
+    client    = CURRENT_THREAD;
+    client_xp = XPTR( local_cxy , client );
+    local     = NULL;
+    remote_nr = 0;
 
 #if DEBUG_PROCESS_SIGACTION
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_SIGACTION < cycle )
-printk("\n[DBG] %s : thread %x enter to %s process %x / cycle %d\n",
-__FUNCTION__ , client, process_action_str( action_type ) , pid , cycle );
+printk("\n[DBG] %s : thread %x in process %x enter to %s process %x / cycle %d\n",
+__FUNCTION__ , client->trdid, client->process->pid,
+process_action_str( type ) , pid , cycle );
 #endif
 
@@ -503 +509 @@
 
     // check action type
-    assert( ((action_type == DELETE_ALL_THREADS ) ||
-             (action_type == BLOCK_ALL_THREADS )  ||
-             (action_type == UNBLOCK_ALL_THREADS )), __FUNCTION__ , "illegal action type" );
+    assert( ((type == DELETE_ALL_THREADS ) ||
+             (type == BLOCK_ALL_THREADS )  ||
+             (type == UNBLOCK_ALL_THREADS )), __FUNCTION__ , "illegal action type" );
              
-    // allocate a - shared - RPC descriptor in client thread stack
-    // it can be shared because all parallel, non-blocking, server threads
-    // use the same input arguments, and use the shared RPC response field
-
-    // the client thread makes the following sequence:
-    // 1. mask interrupts
-    // 2. block itself
-    // 3. send RPC requests to all copies
-    // 4. unmask interrupts
-    // 5. deschedule
+
+    // The client thread send parallel RPCs to all remote clusters containing
+    // target process copies, wait all responses, and then handles directly the
+    // threads in local cluster, when required.
+    // The client thread allocates a - shared - RPC descriptor in the stack,
+    // because all parallel, non-blocking, server threads use the same input 
+    // arguments, and use the shared RPC response field
 
     // mask IRQs
     hal_disable_irq( &save_sr);
 
-    // client register blocking condition for itself
-    thread_block( XPTR( local_cxy , client ) , THREAD_BLOCKED_RPC );
+    // client thread blocks itself
+    thread_block( client_xp , THREAD_BLOCKED_RPC );
 
     // take the lock protecting the copies
@@ -533 +536 @@
     rpc.thread    = client;
     rpc.lid       = client->core->lid;
-    rpc.args[0]   = action_type;
+    rpc.args[0]   = type;
     rpc.args[1]   = pid;
 
-    // send RPCs to all clusters containing process copiess
+    // scan list of process copies
+    // to send RPCs to remote copies
     XLIST_FOREACH( root_xp , iter_xp )
     {
-        // atomically increment responses counter
-        hal_atomic_add( (void *)&rpc.responses , 1 );
-
+        // get extended pointers and cluster on process
         process_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
         process_cxy = GET_CXY( process_xp );
+        process_ptr = GET_PTR( process_xp );
+
+        if( process_cxy == local_cxy )    // process is local
+        { 
+            local = process_ptr;
+        }
+        else                              // process is remote
+        {
+            // update number of remote process copies
+            remote_nr++;
+
+            // atomically increment responses counter
+            hal_atomic_add( (void *)&rpc.responses , 1 );
 
 #if DEBUG_PROCESS_SIGACTION 
 if( DEBUG_PROCESS_SIGACTION < cycle )
-printk("\n[DBG] %s : send RPC to %s process %x in cluster %x\n",
-__FUNCTION__ , process_action_str( action_type ) , pid , process_cxy );
-#endif
-        // call RPC in target cluster
-        rpc_process_sigaction_client( process_cxy , &rpc );
-    }
-   
+printk("\n[DBG] %s : thread %x in process %x handles remote process %x in cluster %x\n",
+__FUNCTION__, client->trdid, client->process->pid, pid , process_cxy );
+#endif
+            // call RPC in target cluster
+            rpc_process_sigaction_client( process_cxy , &rpc );
+        }
+    }  // end list of copies
+
     // release the lock protecting process copies
     remote_spinlock_unlock( lock_xp );
@@ -560 +576 @@
     hal_restore_irq( save_sr);
 
-    // client thread deschedule : will be unblocked by the last RPC server thread 
-    sched_yield("blocked on rpc_process_sigaction");
+    // - if there is remote process copies, the client thread deschedules,
+    //   (it will be unblocked by the last RPC server thread). 
+    // - if there is no remote copies, the client thread unblock itself.
+    if( remote_nr )
+    {
+        sched_yield("blocked on rpc_process_sigaction");
+    } 
+    else
+    {
+        thread_unblock( client_xp , THREAD_BLOCKED_RPC );
+    }
+
+    // handle the local process copy if required
+    if( local != NULL )
+    {
+
+#if DEBUG_PROCESS_SIGACTION 
+if( DEBUG_PROCESS_SIGACTION < cycle )
+printk("\n[DBG] %s : thread %x in process %x handles local process %x in cluster %x\n",
+__FUNCTION__, client->trdid, client->process->pid, pid , local_cxy );
+#endif
+        if     (type == DELETE_ALL_THREADS  ) process_delete_threads ( local , client_xp ); 
+        else if(type == BLOCK_ALL_THREADS   ) process_block_threads  ( local , client_xp ); 
+        else if(type == UNBLOCK_ALL_THREADS ) process_unblock_threads( local );
+    }
 
 #if DEBUG_PROCESS_SIGACTION
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_SIGACTION < cycle )
-printk("\n[DBG] %s : thread %x exit after %s process %x in cluster %x / cycle %d\n",
-__FUNCTION__ , client, process_action_str( action_type ) , pid , local_cxy , cycle );
+printk("\n[DBG] %s : thread %x in process %x exit after %s process %x / cycle %d\n",
+__FUNCTION__, client->trdid, client->process->pid,
+process_action_str( type ), pid, cycle );
 #endif
 
@@ -1100 +1140 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x / cluster %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, parent_pid, local_cxy, cycle );
+printk("\n[DBG] %s : thread %x in process %x enter / cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, local_cxy, cycle );
 #endif
 
@@ -1123 +1163 @@
     }
 
+#if DEBUG_PROCESS_MAKE_FORK
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_MAKE_FORK < cycle )
+printk("\n[DBG] %s : thread %x in process %x allocated process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, new_pid, cycle );
+#endif
+
     // initializes child process descriptor from parent process descriptor 
     process_reference_init( process,
                             new_pid,
-                            parent_process_xp,
                             parent_process_xp );
 
@@ -1132 +1178 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
-printk("\n[DBG] %s : thread %x created child_process %x / child_pid %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process, new_pid, cycle );
-#endif
+printk("\n[DBG] %s : thread %x in process %x initialized child_process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, new_pid, cycle );
+#endif
+
+    // give TXT ownership to child process
+    process_txt_set_ownership( XPTR( local_cxy , process ) );
 
     // copy VMM from parent descriptor to child descriptor
@@ -1151 +1200 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
-printk("\n[DBG] %s : thread %x copied VMM from parent %x to child %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , parent_pid, new_pid, cycle );
-#endif
+printk("\n[DBG] %s : thread %x in process %x copied VMM from parent %x to child %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, 
+parent_pid, new_pid, cycle );
+#endif
+
+    // parent process gives TXT ownership to child process if required
+    if( process_txt_is_owner(parent_process_xp) ) 
+    {
+        process_txt_set_ownership( XPTR( local_cxy , process ) );
+
+#if( DEBUG_PROCESS_MAKE_FORK & 1 )
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : thread %x in process %x gives TXT from parent %x to child %x / cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+parent_pid, new_pid, cycle );
+#endif
+
+    }
 
     // update extended pointer on .elf file
@@ -1178 +1243 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
-printk("\n[DBG] %s : thread %x created child thread %x on core[%x,%d] / cycle %d\n", 
-__FUNCTION__ , CURRENT_THREAD, thread, local_cxy, thread->core->lid, cycle );
+printk("\n[DBG] %s : thread %x in process %x created main thread %x on core[%x,%d] / cycle %d\n", 
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+thread, local_cxy, thread->core->lid, cycle );
 #endif
 
@@ -1200 +1266 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
-printk("\n[DBG] %s : thread %x set COW in parent and child / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : thread %x in process %x set COW in parent and child / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
 #endif
 
@@ -1222 +1288 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_FORK < cycle )
-printk("\n[DBG] %s : thread %x exit / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : thread %x in process %x exit / created process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, new_pid, cycle );
 #endif
 
@@ -1229 +1295 @@
 
 }   // end process_make_fork()
-
 
 /////////////////////////////////////////////////////
 error_t process_make_exec( exec_info_t  * exec_info )
 {
-    char           * path;                    // pathname to .elf file
-    pid_t            pid;                     // old_process PID, given to new_process
-    pid_t            temp_pid;                // temporary PID / given to old_process 
-    process_t      * old_process;             // local pointer on old process
-    thread_t       * old_thread;              // local pointer on old thread
-    process_t      * new_process;             // local pointer on new process
-    thread_t       * new_thread;              // local pointer on new thread
-    xptr_t           parent_xp;               // extended pointer on parent process
-    process_t      * parent_ptr;              // local pointer on parent process
-    cxy_t            parent_cxy;              // parent process cluster identifier
-    xptr_t           children_lock_xp;        // extended pointer on children lock in parent
-    xptr_t           children_root_xp;        // extended pointer on children root in parent
-    xptr_t           children_nr_xp;          // extended pointer on children number in parent
-    thread_t       * parent_main_ptr;         // local pointer on parent main thread
-    xptr_t           parent_main_xp;          // extended pointer on parent main thread
-    pthread_attr_t   attr;                    // new thread attributes
-    lid_t            lid;                     // selected core local index
+    thread_t       * thread;                  // local pointer on this thread
+    process_t      * process;                 // local pointer on this process
+    pid_t            pid;                     // this process identifier
         error_t          error;                   // value returned by called functions
-    
-    // get old_thread, old_process & PID 
-    old_thread  = CURRENT_THREAD;
-    old_process = old_thread->process;
-    pid         = old_process->pid;
-
-        // get .elf pathname from exec_info
-        path = exec_info->path;
-
-    // this function must be executed by a thread running in owner cluster
-    assert( (CXY_FROM_PID( pid ) == local_cxy), __FUNCTION__,
-    "local_cluster must be owner_cluster\n" );
-
-    assert( (LTID_FROM_TRDID( old_thread->trdid ) == 0) , __FUNCTION__,
-    "must be called by the main thread\n" );
- 
+    char           * path;                    // path to .elf file
+    xptr_t           file_xp;                 // extended pointer on .elf file descriptor
+    uint32_t         file_id;                 // file index in fd_array
+    uint32_t         args_nr;                 // number of main thread arguments
+    char          ** args_pointers;           // array of pointers on main thread arguments
+
+    // get thread, process & PID 
+    thread  = CURRENT_THREAD;
+    process = thread->process;
+    pid     = process->pid;
+
+        // get relevant infos from exec_info
+        path          = exec_info->path;
+    args_nr       = exec_info->args_nr;
+    args_pointers = exec_info->args_pointers;
+
 #if DEBUG_PROCESS_MAKE_EXEC
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
 printk("\n[DBG] %s : thread %x in process %x enters / path %s / cycle %d\n",
-__FUNCTION__, old_thread->trdid, pid, path, cycle );
-#endif
-
-    // get parent process pointers
-    parent_xp   = old_process->parent_xp;
-    parent_cxy  = GET_CXY( parent_xp );
-    parent_ptr  = GET_PTR( parent_xp );
-    
+__FUNCTION__, thread->trdid, pid, path, cycle );
+#endif
+
+    // open the file identified by <path>
+    file_xp = XPTR_NULL;
+    file_id = -1;
+        error   = vfs_open( process,
+                            path,
+                            O_RDONLY,
+                            0,
+                            &file_xp,
+                            &file_id );
+        if( error )
+        {
+                printk("\n[ERROR] in %s : failed to open file <%s>\n", __FUNCTION__ , path );
+                return -1;
+        }
+
 #if (DEBUG_PROCESS_MAKE_EXEC & 1)
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
-printk("\n[DBG] %s : thread %x in process %x get parent process %x in cluster %x\n",
-__FUNCTION__, old_thread->trdid, pid, parent_ptr, parent_cxy );
-#endif
-
-    // get extended pointers on parent children_root, children_lock and children_nr
-    children_root_xp = XPTR( parent_cxy , &parent_ptr->children_root );
-    children_lock_xp = XPTR( parent_cxy , &parent_ptr->children_lock );
-    children_nr_xp   = XPTR( parent_cxy , &parent_ptr->children_nr   );
-
-    // get pointers on the parent process main thread
-    parent_main_ptr = hal_remote_lpt( XPTR( parent_cxy , &parent_ptr->th_tbl[0] ) ); 
-    parent_main_xp  = XPTR( parent_cxy , parent_main_ptr );
-
-     // allocate memory for new_process descriptor
-    new_process = process_alloc();
-
-    if( new_process == NULL )
-    {
-        printk("\n[ERROR] in %s : cannot allocate process for %s\n", __FUNCTION__ , path );
+printk("\n[DBG] %s : open file <%s>\n", __FUNCTION__, path );
+#endif
+
+    // delete all threads other than this main thread in all clusters
+    process_sigaction( pid , DELETE_ALL_THREADS );
+
+    // reset local process VMM
+    vmm_destroy( process );
+
+#if( DEBUG_PROCESS_MAKE_EXEC & 1 )
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_PROCESS_MAKE_EXEC < cycle )
+printk("\n[DBG] %s : thread %x in process %x / reset VMM / cycle %d\n",
+__FUNCTION__, thread->trdid, pid, cycle );
+#endif
+
+    // re-initialize the VMM (kentry/args/envs vsegs registration)
+    error = vmm_init( process );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot initialise VMM for %s\n", __FUNCTION__ , path );
+        vfs_close( file_xp , file_id );
+        // FIXME restore old process VMM
         return -1;
     }
-
-    // get a temporary PID for old_process
-    error = cluster_pid_alloc( old_process , &temp_pid );
-    if( error ) 
-    {
-        printk("\n[ERROR] in %s : cannot get PID in cluster %x\n", 
-        __FUNCTION__ , local_cxy ); 
-        process_free( new_process );
-        return -1;
-    }
-
-    // set temporary PID to old_process 
-    old_process->pid = temp_pid;
-
-    // initialize new process descriptor
-    process_reference_init( new_process,
-                            pid,
-                            parent_xp,                          // parent_process_xp
-                            XPTR(local_cxy , old_process) );    // model_process
-
-    // give TXT ownership to new_process
-    process_txt_set_ownership( XPTR( local_cxy , new_process) );
-
+    
 #if( DEBUG_PROCESS_MAKE_EXEC & 1 )
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
-printk("\n[DBG] %s : thread %x in process %x created new process %x\n",
-__FUNCTION__ , old_thread->trdid, pid, new_process );
-#endif
-
-    // register code & data vsegs as well as entry-point in new process VMM,
+printk("\n[DBG] %s : thread %x in process %x / kentry/args/envs vsegs registered / cycle %d\n",
+__FUNCTION__, thread->trdid, pid, cycle );
+#endif
+
+    // register code & data vsegs as well as entry-point in process VMM,
     // and register extended pointer on .elf file in process descriptor
-        error = elf_load_process( path , new_process );
-
+        error = elf_load_process( file_xp , process );
     if( error )
         {
                 printk("\n[ERROR] in %s : failed to access <%s>\n", __FUNCTION__ , path );
-        process_txt_set_ownership( XPTR( local_cxy , old_process) );
-        process_txt_detach( XPTR( local_cxy , new_process) );
-        process_destroy( new_process );
-        old_process->pid = pid;
+        vfs_close( file_xp , file_id );
+        // FIXME restore old process VMM 
         return -1;
         }
@@ -1350 +1390 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_MAKE_EXEC < cycle )
-printk("\n[DBG] %s : thread %x registered code/data vsegs in new process %x / cycle %d\n",
-__FUNCTION__, old_thread , new_process->pid , cycle );
-#endif
-
-    // select a core in local cluster to execute the main thread
-    lid  = cluster_select_local_core();
-
-    // initialize pthread attributes for main thread
-    attr.attributes = PT_ATTR_DETACH | PT_ATTR_CLUSTER_DEFINED | PT_ATTR_CORE_DEFINED;
-    attr.cxy        = local_cxy;
-    attr.lid        = lid;
-
-    // create and initialize main thread in local cluster
-        error = thread_user_create( pid,
-                                (void *)new_process->vmm.entry_point,
-                                exec_info->args_pointers,
-                                &attr,
-                                &new_thread );
-        if( error )
-        {
-                printk("\n[ERROR] in %s : cannot create thread for %s\n", __FUNCTION__ , path );
-        process_txt_set_ownership( XPTR( local_cxy , old_process) );
-        process_txt_detach( XPTR( local_cxy , new_process) );
-        process_destroy( new_process );
-        old_process->pid = pid;
+printk("\n[DBG] %s : thread %x in process %x / code/data vsegs registered / cycle %d\n",
+__FUNCTION__, thread->trdid, pid, cycle );
+#endif
+
+    // update the existing main thread descriptor... and jump to user code 
+    error = thread_user_exec( (void *)process->vmm.entry_point,
+                              args_nr,
+                              args_pointers );
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot reset main thread for %s\n", __FUNCTION__ , path );
+        vfs_close( file_xp , file_id );
+        // FIXME restore old process VMM 
         return -1;
-        }
-
-    // check main thread LTID
-    assert( (LTID_FROM_TRDID(new_thread->trdid) == 0) , __FUNCTION__ ,
-    "main thread must have LTID == 0\n" );
-
-#if( DEBUG_PROCESS_MAKE_EXEC & 1 )
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_MAKE_EXEC < cycle )
-printk("\n[DBG] %s : thread %x created new_process main thread %x / cycle %d\n",
-__FUNCTION__ , old_thread , new_thread , cycle );
-#endif
-
-    // register new_process in parent children list
-    remote_spinlock_lock( children_lock_xp );
-        xlist_add_last( children_root_xp , XPTR( local_cxy , &new_process->children_list ) );
-        hal_remote_atomic_add( children_nr_xp , 1 );
-    remote_spinlock_unlock( children_lock_xp );
-
-    // activate new thread
-        thread_unblock( XPTR( local_cxy , new_thread ) , THREAD_BLOCKED_GLOBAL );
-
-    // detach old_process from TXT
-    process_txt_detach( XPTR( local_cxy , old_process ) );
-
-    // block old_thread 
-    thread_block( XPTR( local_cxy , old_thread ) , THREAD_BLOCKED_GLOBAL );
-
-    // atomically update old_process termination state
-    hal_atomic_or( &old_process->term_state , PROCESS_TERM_EXIT );
-
-    // take the children lock and unblock the parent process main thread 
-    remote_spinlock_lock( children_lock_xp );
-    thread_unblock( parent_main_xp , THREAD_BLOCKED_WAIT );
-    remote_spinlock_unlock( children_lock_xp );
-
-    hal_fence();
-
-#if DEBUG_PROCESS_MAKE_EXEC
-cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_MAKE_EXEC < cycle )
-printk("\n[DBG] %s : old thread %x blocked for delete / new thread %x activated / cycle %d\n",
-__FUNCTION__ , old_thread , new_thread , cycle );
-#endif
-   
+    }
+
+    assert( false, __FUNCTION__, "we should not execute this code");
+ 
         return 0;
 
 }  // end process_make_exec()
+
 
 ///////////////////////////////////////////////
@@ -1474 +1462 @@
     pthread_attr_t   attr;          // main thread attributes
     lid_t            lid;           // selected core local index for main thread
+    xptr_t           file_xp;       // extended pointer on .elf file descriptor
+    uint32_t         file_id;       // file index in fd_array
     error_t          error;
 
@@ -1479 +1469 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_INIT_CREATE < cycle )
-printk("\n[DBG] %s : thread %x enter / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : thread %x in process %x enter / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
 #endif
 
     // allocates memory for process descriptor from local cluster
         process = process_alloc(); 
-        if( process == NULL )
-    {
-                printk("\n[PANIC] in %s : no memory for process descriptor in cluster %x\n",
-                __FUNCTION__, local_cxy  );
-    }
+        
+    assert( (process != NULL), __FUNCTION__,
+    "no memory for process descriptor in cluster %x\n", local_cxy  );
 
     // get PID from local cluster
     error = cluster_pid_alloc( process , &pid );
-    if( error )
-    {
-                printk("\n[PANIC] in %s : cannot allocate PID in cluster %x\n",
-                __FUNCTION__, local_cxy );
-        process_free( process );
-    }
-
-    // check allocated PID
-    assert( (pid == 1) , __FUNCTION__ , "process INIT must be first process in cluster 0\n" );
+
+    assert( (error == 0), __FUNCTION__,
+    "cannot allocate PID in cluster %x\n", local_cxy );
+
+    assert( (pid == 1) , __FUNCTION__,
+    "process INIT must be first process in cluster 0\n" );
 
     // initialize process descriptor / parent is local process_zero
     process_reference_init( process,
                             pid,
-                            XPTR( local_cxy , &process_zero ),     // parent
-                            XPTR( local_cxy , &process_zero ) );   // model
+                            XPTR( local_cxy , &process_zero ) );  
+
+    // open the file identified by CONFIG_PROCESS_INIT_PATH
+    file_xp = XPTR_NULL;
+    file_id = -1;
+        error   = vfs_open( process,
+                            CONFIG_PROCESS_INIT_PATH,
+                            O_RDONLY,
+                            0,
+                            &file_xp,
+                            &file_id );
+
+        assert( (error == 0), __FUNCTION__,
+    "failed to open file <%s>\n", CONFIG_PROCESS_INIT_PATH );
 
     // register "code" and "data" vsegs as well as entry-point
     // in process VMM, using information contained in the elf file.
-        if( elf_load_process( CONFIG_PROCESS_INIT_PATH , process ) )
-        {
-                printk("\n[PANIC] in %s : cannot access .elf file / path = %s\n",
-                __FUNCTION__, CONFIG_PROCESS_INIT_PATH );
-        process_destroy( process );
-        }
+        error = elf_load_process( file_xp , process );
+
+        assert( (error == 0), __FUNCTION__,
+    "cannot access .elf file <%s>\n", CONFIG_PROCESS_INIT_PATH );
 
     // get extended pointers on process_zero children_root, children_lock
@@ -1541 +1537 @@
                                 &attr,
                                 &thread );
-        if( error )
-        {
-                printk("\n[PANIC] in %s : cannot create main thread / path = %s\n",
-                __FUNCTION__, CONFIG_PROCESS_INIT_PATH );
-        process_destroy( process );
-        }
-
-    // check main thread index
-    assert( (thread->trdid == 0) , __FUNCTION__ , "main thread must have index 0\n" );
+
+        assert( (error == 0), __FUNCTION__,
+    "cannot create main thread for <%s>\n", CONFIG_PROCESS_INIT_PATH );
+
+    assert( (thread->trdid == 0), __FUNCTION__,
+    "main thread must have index 0 for <%s>\n", CONFIG_PROCESS_INIT_PATH );
 
     // activate thread
@@ -1559 +1552 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_INIT_CREATE < cycle )
-printk("\n[DBG] %s : thread %x exit / cycle %d\n", __FUNCTION__, CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : thread %x in process %x exit / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, cycle );
 #endif
 
@@ -1702 +1696 @@
     xptr_t      lock_xp;      // extended pointer on list lock in chdev
 
-#if DEBUG_PROCESS_TXT
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x / txt_id = %d  / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process->pid, txt_id, cycle );
-#endif
-
     // check process is in owner cluster
     assert( (CXY_FROM_PID( process->pid ) == local_cxy) , __FUNCTION__ ,
@@ -1732 +1719 @@
 
 #if DEBUG_PROCESS_TXT
-cycle = (uint32_t)hal_get_cycles();
+uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x exit for process %x / txt_id = %d / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process->pid, txt_id , cycle );
+printk("\n[DBG] %s : thread %x in process %x attached process %x to TXT %d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+process->pid, txt_id , cycle );
 #endif
 
@@ -1755 +1743 @@
     process_cxy = GET_CXY( process_xp );
     process_ptr = GET_PTR( process_xp );
+
+    // check process descriptor in owner cluster
     process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
-
-    // check process descriptor in owner cluster
     assert( (CXY_FROM_PID( process_pid ) == process_cxy ) , __FUNCTION__ ,
     "process descriptor not in owner cluster" );
-
-#if DEBUG_PROCESS_TXT
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
-#endif
 
     // release TXT ownership (does nothing if not TXT owner)
@@ -1788 +1769 @@
 
 #if DEBUG_PROCESS_TXT
-cycle  = (uint32_t)hal_get_cycles();
+uint32_t cycle  = (uint32_t)hal_get_cycles();
 uint32_t txt_id = hal_remote_lw( XPTR( chdev_cxy , &chdev_ptr->channel ) );
 if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x exit / process %x detached from TXT %d / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid, txt_id, cycle );
+printk("\n[DBG] %s : thread %x in process %x detached process %x from TXT %d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+process_pid, txt_id, cycle );
 #endif
 
@@ -1811 +1793 @@
     process_cxy = GET_CXY( process_xp );
     process_ptr = GET_PTR( process_xp );
-
-    // get process PID
     process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
 
@@ -1818 +1798 @@
     assert( (process_cxy == CXY_FROM_PID( process_pid )) , __FUNCTION__,
     "process descriptor not in owner cluster\n" );
-
-#if DEBUG_PROCESS_TXT
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
-#endif
 
     // get extended pointer on stdin pseudo file
@@ -1838 +1811 @@
 
 #if DEBUG_PROCESS_TXT
-cycle = (uint32_t)hal_get_cycles();
+uint32_t cycle  = (uint32_t)hal_get_cycles();
+uint32_t txt_id = hal_remote_lw( XPTR( txt_cxy , &txt_ptr->channel ) );
 if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x exit for process %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
+printk("\n[DBG] %s : thread %x in process %x give TXT %d to process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, process_pid, cycle );
 #endif
 
@@ -1865 +1839 @@
     cxy_t       current_cxy;     // cluster for current process
 
+#if DEBUG_PROCESS_TXT
+uint32_t cycle;
+#endif
+
     // get pointers on process in owner cluster
     process_cxy = GET_CXY( process_xp );
     process_ptr = GET_PTR( process_xp );
-
-    // get process PID
     process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
 
@@ -1875 +1851 @@
     assert( (process_cxy == CXY_FROM_PID( process_pid )) , __FUNCTION__,
     "process descriptor not in owner cluster\n" );
-
-#if DEBUG_PROCESS_TXT
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x enter / process %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
-#endif
 
     // get extended pointer on stdin pseudo file
@@ -1895 +1864 @@
     txt_id   = hal_remote_lw ( XPTR( txt_cxy , &txt_ptr->channel ) );
 
-#if( DEBUG_PROCESS_TXT & 1 )
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : file_ptr %x / txt_ptr %x / txt_id %d / owner_ptr = %x\n",
-__FUNCTION__, GET_PTR(file_xp), txt_ptr, txt_id, GET_PTR(owner_xp) );
-#endif
-
     // transfer ownership only if process is the TXT owner
     if( (owner_xp == process_xp) && (txt_id > 0) )  
@@ -1913 +1876 @@
         if( process_get_ppid( process_xp ) != 1 )           // process is not KSH
         {
-
-#if( DEBUG_PROCESS_TXT & 1 )
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : process is not the KSH process => search the KSH\n", __FUNCTION__ );
-#endif
             // scan attached process list to find KSH process
             XLIST_FOREACH( root_xp , iter_xp )
@@ -1934 +1892 @@
 
 #if DEBUG_PROCESS_TXT
-cycle = (uint32_t)hal_get_cycles();
+cycle   = (uint32_t)hal_get_cycles();
+uint32_t ksh_pid = hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) );
 if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x exit / process %x to KSH process %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid, 
-hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) ), cycle );
+printk("\n[DBG] %s : thread %x in process %x release TXT %d to KSH %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, ksh_pid, cycle );
+process_txt_display( txt_id );
 #endif
                      return;
@@ -1954 +1913 @@
         else                                               // process is KSH
         {
-
-#if( DEBUG_PROCESS_TXT & 1 )
-if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : process is the KSH process => search another\n", __FUNCTION__ );
-#endif
-
             // scan attached process list to find another process 
             XLIST_FOREACH( root_xp , iter_xp )
@@ -1976 +1929 @@
 
 #if DEBUG_PROCESS_TXT
-cycle = (uint32_t)hal_get_cycles();
+cycle   = (uint32_t)hal_get_cycles();
+uint32_t new_pid = hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) );
 if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x exit / KSH process %x to process %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid,
-hal_remote_lw( XPTR( current_cxy , &current_ptr->pid ) ), cycle );
+printk("\n[DBG] %s : thread %x in process %x release TXT %d to process %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, new_pid, cycle );
+process_txt_display( txt_id );
 #endif
                      return;
@@ -1995 +1949 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x exit / KSH process %x to nobody / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
+printk("\n[DBG] %s : thread %x in process %x release TXT %d to nobody / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid, txt_id, cycle );
+process_txt_display( txt_id );
 #endif
             return;
@@ -2007 +1962 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_PROCESS_TXT < cycle )
-printk("\n[DBG] %s : thread %x exit / process %x is not TXT owner / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, process_pid, cycle );
+printk("\n[DBG] %s : thread %x in process %d does nothing (not TXT owner) / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, process_pid, cycle );
+process_txt_display( txt_id );
 #endif
 
@@ -2014 +1970 @@
 }  // end process_txt_transfer_ownership()
 
+
+//////////////////////////////////////////////////
+uint32_t process_txt_is_owner( xptr_t process_xp )
+{
+    // get local pointer and cluster of process in owner cluster
+    cxy_t       process_cxy = GET_CXY( process_xp );
+    process_t * process_ptr = GET_PTR( process_xp );
+
+    // check owner cluster
+    pid_t process_pid = hal_remote_lw( XPTR( process_cxy , &process_ptr->pid ) );
+    assert( (process_cxy == CXY_FROM_PID( process_pid )) , __FUNCTION__,
+    "process descriptor not in owner cluster\n" );
+
+    // get extended pointer on stdin pseudo file
+    xptr_t file_xp = hal_remote_lwd( XPTR( process_cxy , &process_ptr->fd_array.array[0] ) );
+
+    // get pointers on TXT chdev
+    xptr_t    txt_xp  = chdev_from_file( file_xp );
+    cxy_t     txt_cxy = GET_CXY( txt_xp );
+    chdev_t * txt_ptr = GET_PTR( txt_xp );
+
+    // get extended pointer on TXT_RX owner process 
+    xptr_t owner_xp = hal_remote_lwd( XPTR( txt_cxy , &txt_ptr->ext.txt.owner_xp ) );
+
+    return (process_xp == owner_xp);
+
+}   // end process_txt_is_owner()
 
 ////////////////////////////////////////////////     
@@ -2023 +2006 @@
 
     return (xptr_t)hal_remote_lwd( XPTR( txt_rx_cxy , &txt_rx_ptr->ext.txt.owner_xp ) );
-}
+
+}  // end process_txt_get_owner()
 
 ///////////////////////////////////////////

trunk/kernel/kern/process.h

@@ -29 +29 @@
 #include <kernel_config.h>
 #include <errno.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <list.h>
 #include <xlist.h>
@@ -146 +146 @@
 
     uint32_t          term_state;       /*! termination status (flags & exit status)        */
-
-    bool_t            txt_owner;        /*! current TXT owner                               */
 }
 process_t;
@@ -213 +211 @@
 /*********************************************************************************************
  * This function initializes a local, reference, user process descriptor from another process
- * descriptor, defined by the <model_xp> argument. The <process> and <pid> arguments must
- * be previously allocated by he caller. This function can be called by three functions:
- * 1) process_init_create() : process is the reference INIT process / pid = 1 /
- *    the parent and model process descriptors are both the kernel process_zero.
- * 2) process_make_fork() : the model process descriptor is the (generally remote)
- *    parent process.
- * 3) process_make exec() : the model process is the local old_process, the new_process
- *    parent is the same as the old_process parent. 
+ * descriptor, defined by the <parent_xp> argument. The <process> and <pid> arguments must
+ * be previously allocated by the caller. This function can be called by two functions:
+ * 1) process_init_create() : process is the INIT process; parent is process-zero.
+ * 2) process_make_fork() : the parent process descriptor is generally remote.
  * The following fields are initialised :
  * - It set the pid / ppid / ref_xp / parent_xp / state fields.
  * - It initializes the VMM (register the kentry, args, envs vsegs in VSL)
  * - It initializes the FDT, defining the three pseudo files STDIN / STDOUT / STDERR.
+ *   . if INIT process     => link to kernel TXT[0].
+ *   . if KSH[i] process   => allocate a free TXT[i] and give TXT ownership.
+ *   . if USER process     => same TXT[i] as parent process and give TXT ownership.
  * - It set the root_xp, bin_xp, cwd_xp fields.
  * - It reset the children list as empty, but does NOT register it in parent children list.
@@ -236 +233 @@
  * @ pid          : [in] process identifier.
  * @ parent_xp    : [in] extended pointer on parent process descriptor.
- * @ model_xp     : [in] extended pointer on model process descriptor.
  ********************************************************************************************/
 void process_reference_init( process_t * process,
                              pid_t       pid,
-                             xptr_t      parent_xp,
-                             xptr_t      model_xp );
+                             xptr_t      parent_xp );
 
 /*********************************************************************************************
@@ -515 +510 @@
  * It is called only by the process_reference_init() function when creating a KSH process.
  * It makes a kernel panic if no free TXT terminal is found.
- * The allocated TXT terminal is only released if the KSH process is deleted,
- * which is a rare and abnormal event.
+ * The allocated TXT terminal is only released when the KSH process is deleted.
  *********************************************************************************************
  * @ return TXT terminal index if succes / kernel panic if no terminal found.
@@ -547 +541 @@
 
 /*********************************************************************************************
- * This function gives to a process identified by the <owner_xp> argument, and attached
- * to terminal TXT[i] the exclusive ownership of the TXT_RX[i] terminal.
- * The process descriptor must be in the process owner cluster.
+ * This function gives the TXT ownership to a process identified by the <process_xp> argument.
+ * It can be called by a thread running in any cluster, but the <process_xp> must be the
+ * owner cluster process descriptor. 
  *********************************************************************************************
  * @ owner_xp  : extended pointer on process descriptor in owner cluster.
  ********************************************************************************************/
-void process_txt_set_ownership( xptr_t owner_xp );
-
-/*********************************************************************************************
- * When the process dentified by the <owner_xp> argument has the exclusive ownership of
+void process_txt_set_ownership( xptr_t process_xp );
+
+/*********************************************************************************************
+ * When the process identified by the <owner_xp> argument has the exclusive ownership of
  * the TXT_RX terminal, this function transfer this ownership to another attached process.
  * The process descriptor must be the process owner.
@@ -565 +559 @@
  * - If there is no other attached process, the TXT has no more defined owner. 
  *********************************************************************************************
- * @ owner_xp  : extended pointer on process descriptor in owner cluster.
- ********************************************************************************************/
-void process_txt_transfer_ownership( xptr_t owner_xp );
-
-/*********************************************************************************************
- * This function returns the TXT owner process (foreground process)
- * for a given TXT terminal identified by its <channel> index.
- *********************************************************************************************
- * @ channel  : TXT terminal channel.
- * @ return extentded pointer on TXT owner process in owner cluster.
+ * @ process_xp  : extended pointer on process descriptor in owner cluster.
+ ********************************************************************************************/
+void process_txt_transfer_ownership( xptr_t process_xp );
+
+/*********************************************************************************************
+ * This function returns true if the  process identified by the <process_xp> argument
+ * is the TXT owner. It can be called by a thread running in any cluster, but the
+ * process_xp must be the owner cluster process descriptor. 
+ *********************************************************************************************
+ * @ return a non-zero value if target process is TXT owner.
+ ********************************************************************************************/
+uint32_t process_txt_is_owner( xptr_t process_xp );
+
+/*********************************************************************************************
+ * This function returns an extended ponter on the current TXT owner process, 
+ * for the TXT terminal identified by the <channel> index. 
+ *********************************************************************************************
+ * @ channel : TXT channel.
+ * @ return extended pointer on TXT owner process.
  ********************************************************************************************/
 xptr_t process_txt_get_owner( uint32_t channel );

trunk/kernel/kern/rpc.c

@@ -23 +23 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_atomic.h>
 #include <hal_remote.h>
@@ -100 +100 @@
     volatile error_t   full;
     thread_t         * this;
-    cluster_t        * cluster;
-
-#if DEBUG_RPC_CLIENT_GENERIC
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in cluster %x enter for rpc[%d] / rpc_ptr %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, rpc, cycle );
-#endif
 
     full            = 0;
     this            = CURRENT_THREAD;
-    cluster         = LOCAL_CLUSTER;
     client_core_lid = this->core->lid;
 
+#if DEBUG_RPC_CLIENT_GENERIC
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
+printk("\n[DBG] %s : thread %x in process %x enter for rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
+#endif
+
     // select a server_core : use client core index if possible / core 0 otherwise
-    if( client_core_lid < hal_remote_lw( XPTR( server_cxy , &cluster->cores_nr ) ) )
+    if( client_core_lid < hal_remote_lw( XPTR( server_cxy , &LOCAL_CLUSTER->cores_nr ) ) )
     {
         server_core_lid = client_core_lid;
@@ -150 +148 @@
  
     hal_fence();
+
+#if DEBUG_RPC_CLIENT_GENERIC
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
+printk("\n[DBG] %s : thread %x in process %x / rpc[%d] / rpc_ptr %x / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index, rpc, cycle );
+#endif
         
-    // send IPI to the selected server core
-        dev_pic_send_ipi( server_cxy , server_core_lid );
+   // send IPI to the selected server core
+   dev_pic_send_ipi( server_cxy , server_core_lid );
 
     // wait RPC completion before returning if blocking RPC
@@ -165 +170 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in cluster %x busy waiting / rpc[%d] / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index , cycle );
+printk("\n[DBG] %s : thread %x in process %x busy waiting for rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index , cycle );
 #endif
 
@@ -174 +179 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in cluster %x resumes / rpc[%d] / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, cycle );
+printk("\n[DBG] %s : thread %x in process %x resumes for rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
 #endif
         } 
@@ -184 +189 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in cluster %x blocks & deschedules / rpc[%d] / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index , cycle );
+printk("\n[DBG] %s : thread %x in process %x blocks & deschedules for rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index , cycle );
 #endif
             thread_block( XPTR( local_cxy , this ) , THREAD_BLOCKED_RPC );
@@ -193 +198 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x in cluster %x resumes / rpcr[%d] / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, local_cxy, rpc->index, cycle );
+printk("\n[DBG] %s : thread %x in process %x resumes for rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
 #endif
         }
@@ -207 +212 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_CLIENT_GENERIC < cycle ) 
-printk("\n[DBG] %s : non blocking rpc[%d] => thread %x return  / cycle %d\n",
-__FUNCTION__, rpc->index, CURRENT_THREAD, cycle );
+printk("\n[DBG] %s : thread %x in process %x returns for non blocking rpc[%d] / cycle %d\n",
+__FUNCTION__, this->trdid, this->process->pid, rpc->index, cycle );
 #endif
 
@@ -225 +230 @@
     thread_t      * thread;  
     uint32_t        sr_save;
+
+#if DEBUG_RPC_SERVER_GENERIC
+uint32_t cycle;
+#endif
 
     bool_t          found    = false;
@@ -232 +241 @@
         remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo[core->lid];
 
-#if DEBUG_RPC_SERVER_GENERIC
-uint32_t cycle = (uint32_t)hal_get_cycles();
-if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : thread %x interrupted in cluster %x / cycle %d\n",
-__FUNCTION__, this, local_cxy, cycle );
-#endif
-
     // interrupted thread not preemptable during RPC chek
         hal_disable_irq( &sr_save );
@@ -249 +251 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : RPC FIFO non empty in cluster %x / cycle %d\n",
-__FUNCTION__, local_cxy, cycle );
+printk("\n[DBG] %s : RPC FIFO non empty for core[%x,%d] / cycle %d\n",
+__FUNCTION__, local_cxy, core->lid, cycle );
 #endif
 
@@ -290 +292 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : create a new RPC thread %x in cluster %x / cycle %d\n",
-__FUNCTION__, thread, local_cxy, cycle );
+printk("\n[DBG] %s : new RPC thread %x created for core[%x,%d] / cycle %d\n",
+__FUNCTION__, thread, local_cxy, core->lid, cycle );
 #endif
         }
@@ -299 +301 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : interrupted thread %x deschedules in cluster %x / cycle %d\n",
-__FUNCTION__, this, local_cxy, cycle );
+printk("\n[DBG] %s : interrupted thread %x deschedules on core[%x,%d] / cycle %d\n",
+__FUNCTION__, this, local_cxy, core->lid, cycle );
 #endif
 
@@ -309 +311 @@
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_RPC_SERVER_GENERIC < cycle ) 
-printk("\n[DBG] %s : interrupted thread %x resumes in cluster %x / cycle %d\n",
-__FUNCTION__, this, local_cxy, cycle );
+printk("\n[DBG] %s : interrupted thread %x resumes on core[%x,%d] / cycle %d\n",
+__FUNCTION__, this, local_cxy, core->lid, cycle );
 #endif
 
@@ -410 +412 @@
 #endif
                         // send IPI to client core
-                            dev_pic_send_ipi( desc_cxy , client_core_lid );
+                            // dev_pic_send_ipi( desc_cxy , client_core_lid );
                     }
                         }
@@ -872 +874 @@
 pid_t     pid    = rpc->args[1];
 if( DEBUG_RPC_PROCESS_SIGACTION < cycle )
-printk("\n[DBG] %s : enter to %s process %x in cluster %x / cycle %d\n",
+printk("\n[DBG] %s : enter to request %s of process %x in cluster %x / cycle %d\n",
 __FUNCTION__ , process_action_str( action ) , pid , cxy , cycle );
 #endif
@@ -949 +951 @@
 
         // send an IPI to client core
-        dev_pic_send_ipi( client_cxy , client_lid );
+        // dev_pic_send_ipi( client_cxy , client_lid );
     }
 

trunk/kernel/kern/rpc.h

@@ -26 +26 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_atomic.h>
 #include <bits.h>

trunk/kernel/kern/scheduler.c

@@ -23 +23 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_switch.h>
 #include <hal_irqmask.h>

trunk/kernel/kern/scheduler.h

@@ -25 +25 @@
 #define _SCHEDULER_H_
 
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <list.h>
 #include <spinlock.h>

trunk/kernel/kern/signal.c

@@ -24 +24 @@
  */
 
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <printk.h>
 #include <signal.h>

trunk/kernel/kern/signal.h

@@ -27 +27 @@
 #define _SIGNAL_H_
 
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 
 

trunk/kernel/kern/thread.c

@@ -24 +24 @@
 
 #include <kernel_config.h>
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <hal_context.h>
 #include <hal_irqmask.h>
@@ -167 +167 @@
     thread->quantum         = 0;            // TODO
     thread->ticks_nr        = 0;            // TODO
-    thread->time_last_check = 0;
+    thread->time_last_check = 0;            // TODO
         thread->core            = &local_cluster->core_tbl[core_lid];
         thread->process         = process;
@@ -243 +243 @@
 uint32_t cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_THREAD_USER_CREATE < cycle )
-printk("\n[DBG] %s : thread %x enter for process %x in cluster %x / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, pid , local_cxy , cycle );
+printk("\n[DBG] %s : thread %x in process %x enter in cluster %x / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid, pid , local_cxy , cycle );
 #endif
 
@@ -301 +301 @@
     }
 
+#if( DEBUG_THREAD_USER_CREATE & 1)
+if( DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[DBG] %s : stack vseg created / vpn_base %x / %d pages\n",
+__FUNCTION__, vseg->vpn_base, vseg->vpn_size );
+#endif
+
     // allocate memory for thread descriptor
     thread = thread_alloc();
@@ -313 +319 @@
 #if( DEBUG_THREAD_USER_CREATE & 1)
 if( DEBUG_THREAD_USER_CREATE < cycle )
-printk("\n[DBG] %s : thread descriptor %x allocated\n",
+printk("\n[DBG] %s : new thread descriptor %x allocated\n",
 __FUNCTION__, thread );
 #endif
@@ -336 +342 @@
 #if( DEBUG_THREAD_USER_CREATE & 1)
 if( DEBUG_THREAD_USER_CREATE < cycle )
-printk("\n[DBG] %s : thread descriptor %x initialised / trdid = %x\n",
-__FUNCTION__, thread , thread->trdid );
+printk("\n[DBG] %s : new thread descriptor initialised / trdid %x\n",
+__FUNCTION__, thread->trdid );
 #endif
 
@@ -347 +353 @@
 
     // allocate & initialize CPU context
-        if( hal_cpu_context_create( thread ) )
+        if( hal_cpu_context_alloc( thread ) )
     {
             printk("\n[ERROR] in %s : cannot create CPU context\n", __FUNCTION__ );
@@ -354 +360 @@
         return ENOMEM;
     }
-
-    // allocate  FPU context
+    hal_cpu_context_init( thread );
+
+    // allocate & initialize FPU context
     if( hal_fpu_context_alloc( thread ) )
     {
@@ -363 +370 @@
         return ENOMEM;
     }
+    hal_fpu_context_init( thread );
+
+#if( DEBUG_THREAD_USER_CREATE & 1)
+if( DEBUG_THREAD_USER_CREATE < cycle )
+printk("\n[DBG] %s : CPU & FPU contexts created\n",
+__FUNCTION__, thread->trdid );
+vmm_display( process , true );
+#endif
 
 #if DEBUG_THREAD_USER_CREATE
 cycle = (uint32_t)hal_get_cycles();
 if( DEBUG_THREAD_USER_CREATE < cycle )
-printk("\n[DBG] %s : thread %x exit / new_thread %x in process %x / core %d / cycle %d\n",
-__FUNCTION__, CURRENT_THREAD, thread->trdid , pid , core_lid, cycle );
+printk("\n[DBG] %s : thread %x in process %x exit / new_thread %x / core %d / cycle %d\n",
+__FUNCTION__, CURRENT_THREAD->trdid , pid, thread->trdid, core_lid, cycle );
 #endif
 
@@ -554 +569 @@
 }  // end thread_user_fork()
 
+////////////////////////////////////////////////
+error_t thread_user_exec( void     * entry_func,
+                          uint32_t   argc,
+                          char    ** argv )
+{
+    thread_t  * thread  = CURRENT_THREAD;
+    process_t * process = thread->process;
+
+#if DEBUG_THREAD_USER_EXEC
+uint32_t cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_THREAD_USER_EXEC < cycle )
+printk("\n[DBG] %s : thread %x in process %x enter / cycle %d\n",
+__FUNCTION__, thread->trdid, process->pid, cycle );
+#endif
+
+        assert( (thread->type == THREAD_USER )          , __FUNCTION__, "bad type" );
+        assert( (thread->signature == THREAD_SIGNATURE) , __FUNCTION__, "bad signature" );
+        assert( (thread->local_locks == 0)              , __FUNCTION__, "bad local locks" );
+        assert( (thread->remote_locks == 0)             , __FUNCTION__, "bad remote locks" );
+
+        // re-initialize various thread descriptor fields
+    thread->quantum         = 0;            // TODO
+    thread->ticks_nr        = 0;            // TODO
+    thread->time_last_check = 0;            // TODO
+
+#if CONFIG_LOCKS_DEBUG 
+    list_root_init( &thread->locks_root );  
+    xlist_root_init( XPTR( local_cxy , &thread->xlocks_root ) );
+#endif
+
+    thread->entry_func      = entry_func;
+    thread->main_argc       = argc; 
+    thread->main_argv       = argv;
+
+    // the main thread is always detached
+    thread->flags           = THREAD_FLAG_DETACHED;
+    thread->blocked         = 0;
+    thread->errno           = 0;
+    thread->fork_user       = 0;    // not inherited
+    thread->fork_cxy        = 0;    // not inherited
+
+    // reset thread info
+    memset( &thread->info , 0 , sizeof(thread_info_t) );
+
+    // initialize join_lock
+    remote_spinlock_init( XPTR( local_cxy , &thread->join_lock ) );
+
+    // allocate an user stack vseg for main thread
+    vseg_t * 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 )
+    {
+            printk("\n[ERROR] in %s : cannot create stack vseg for main thread\n", __FUNCTION__ );
+                return -1;
+    }
+
+    // update user stack in stack descriptor
+    thread->u_stack_base = vseg->min;
+    thread->u_stack_size = vseg->max - vseg->min;
+    
+    // release FPU ownership if required
+    if( thread->core->fpu_owner == thread ) thread->core->fpu_owner = NULL;
+
+    // re-initialize  FPU context
+    hal_fpu_context_init( thread );
+
+#if DEBUG_THREAD_USER_EXEC
+cycle = (uint32_t)hal_get_cycles();
+if( DEBUG_THREAD_USER_EXEC < cycle )
+printk("\n[DBG] %s : thread %x in process %x set CPU context & jump to user code / cycle %d\n",
+__FUNCTION__, thread->trdid, process->pid, cycle );
+vmm_display( process , true );
+#endif
+
+    // re-initialize CPU context... and jump to user code
+        hal_cpu_context_exec( thread );
+
+    assert( false, __FUNCTION__, "we should execute this code");
+ 
+    return 0;
+
+}  // end thread_user_exec()
+
 /////////////////////////////////////////////////////////
 error_t thread_kernel_create( thread_t     ** new_thread,
@@ -594 +698 @@
     {
         thread_release( thread );
+        return ENOMEM;
+    }
+
+    // allocate & initialize CPU context
+        error = hal_cpu_context_alloc( thread );
+    if( error )
+    {
+        thread_release( thread );
         return EINVAL;
     }
-
-    // allocate & initialize CPU context
-        hal_cpu_context_create( thread );
+    hal_cpu_context_init( thread );
+
 
 #if DEBUG_THREAD_KERNEL_CREATE
@@ -612 +723 @@
 } // end thread_kernel_create()
 
-/////////////////////////////////////////////////
-error_t thread_idle_init( thread_t      * thread,
-                          thread_type_t   type,
-                          void          * func,
-                          void          * args,
-                                          lid_t           core_lid )
+//////////////////////////////////////////////
+void thread_idle_init( thread_t      * thread,
+                       thread_type_t   type,
+                       void          * func,
+                       void          * args,
+                           lid_t           core_lid )
 {
     assert( (type == THREAD_IDLE) , __FUNCTION__ , "illegal thread type" );
-
     assert( (core_lid < LOCAL_CLUSTER->cores_nr) , __FUNCTION__ , "illegal core index" );
 
+    // initialize thread descriptor
     error_t  error = thread_init( thread,
                                   &process_zero,
@@ -631 +742 @@
                                   0 , 0 );   // no user stack for a kernel thread
 
+    assert( (error == 0), __FUNCTION__, "cannot create thread idle" );
+
     // allocate & initialize CPU context if success
-    if( error == 0 ) hal_cpu_context_create( thread );
-
-    return error;
+    error = hal_cpu_context_alloc( thread );
+
+    assert( (error == 0), __FUNCTION__, "cannot allocate CPU context" );
+
+    hal_cpu_context_init( thread );
 
 }  // end thread_idle_init()
@@ -798 +913 @@
 
 #if DEBUG_THREAD_BLOCK
-uint32_t cycle = (uint32_t)hal_get_cycles();
+uint32_t    cycle   = (uint32_t)hal_get_cycles();
+process_t * process = hal_remote_lpt( XPTR( cxy , &ptr->process ) );
 if( DEBUG_THREAD_BLOCK < cycle )
-printk("\n[DBG] %s : thread %x  in cxy %x blocked thread %x in cxy %x / cause %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , local_cxy , ptr , cxy , cause , cycle );
+printk("\n[DBG] %s : thread %x in process %x blocked thread %x in process %x / cause %x\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+ptr->trdid, hal_remote_lw(XPTR( cxy , &process->pid )), cause );
 #endif
 
@@ -819 +936 @@
 
 #if DEBUG_THREAD_BLOCK
-uint32_t cycle = (uint32_t)hal_get_cycles();
+uint32_t    cycle   = (uint32_t)hal_get_cycles();
+process_t * process = hal_remote_lpt( XPTR( cxy , &ptr->process ) );
 if( DEBUG_THREAD_BLOCK < cycle )
-printk("\n[DBG] %s : thread %x  in cxy %x unblocked thread %x in cxy %x / cause %x / cycle %d\n",
-__FUNCTION__ , CURRENT_THREAD , local_cxy , ptr , cxy , cause , cycle );
+printk("\n[DBG] %s : thread %x in process %x unblocked thread %x in process %x / cause %x\n",
+__FUNCTION__, CURRENT_THREAD->trdid, CURRENT_THREAD->process->pid,
+ptr->trdid, hal_remote_lw(XPTR( cxy , &process->pid )), cause );
 #endif
 

trunk/kernel/kern/thread.h

@@ -26 +26 @@
 #define _THREAD_H_
 
-#include <hal_types.h>
+#include <hal_kernel_types.h>
 #include <shared_syscalls.h>
 #include <hal_special.h>
@@ -161 +161 @@
     void              * entry_func;      /*! pointer on entry function                */
     void              * entry_args;      /*! pointer on entry function arguments      */
+    uint32_t            main_argc;       /*! main thread number of arguments          */
+    char             ** main_argv;       /*! main thread array of strings arguments   */
 
     uint32_t            flags;           /*! bit vector of flags                      */
@@ -218 +220 @@
  * The CPU context is initialized from scratch. 
  * It is registered in the local process descriptor specified by the <pid> argument.
- * The THREAD_BLOCKED_GLOBAL bit is set => the thread must be activated to start.
+ * The THREAD_BLOCKED_GLOBAL bit is set => the thread must be activated by the caller
+ * to start at the next scheduling point.
  ***************************************************************************************
  * @ pid          : process identifier.
@@ -258 +261 @@
 
 /***************************************************************************************
+ * This function is called by the process_make_exec() function to re-initialise the
+ * thread descriptor of the calling thread (that will become the new process main
+ * thread), and immediately jump to user code without returning to kentry!!!
+ * It must be called by the main thread of the calling process.
+ * - A new user stack vseg is created and initialised.
+ * - The kernel stack (currently in use) is not modified.  
+ * - The function calls the hal_cpu_context_exec() to re-initialize the CPU context
+ *   an jump to user code.  
+ ***************************************************************************************
+ * @ entry_func : main thread entry point.
+ * @ argc       : number of main thread arguments.
+ * @ argv       : array of pointers on stringarguments.
+ * @ returns 0 if success / returns ENOMEM if error.
+ **************************************************************************************/
+error_t thread_user_exec( void     * entry_func,
+                          uint32_t   argc,
+                          char    ** argv);
+
+/***************************************************************************************
  * This function allocates memory for a kernel thread descriptor in the local cluster,
  * and initializes it from arguments values. 
@@ -281 +303 @@
  * descriptor from arguments values.
  * The THREAD_BLOCKED_GLOBAL bit is set, and the thread must be activated to start.
+ * It returns a kernel panic if failure.
  ***************************************************************************************
  * @ thread   : pointer on existing thread descriptor.
@@ -287 +310 @@
  * @ args     : function arguments.
  * @ core_lid : local core index.
- * @ returns 0 if success / returns EINVAL if error
- **************************************************************************************/
-error_t thread_idle_init( thread_t      * thread,
-                          thread_type_t   type,
-                          void          * func,
-                          void          * args,
-                          lid_t           core_lid );
+ **************************************************************************************/
+void thread_idle_init( thread_t      * thread,
+                       thread_type_t   type,
+                       void          * func,
+                       void          * args,
+                       lid_t           core_lid );
 
 /***************************************************************************************