Changeset 409 for trunk/kernel/kern

Timestamp:

Dec 20, 2017, 4:51:09 PM (7 years ago)

Author:

alain

Message:

Fix bugs in exec

Location:

trunk/kernel/kern

Files:

• cluster.c (modified) (1 diff)
• cluster.h (modified) (1 diff)
• core.c (modified) (1 diff)
• core.h (modified) (1 diff)
• do_syscall.c (modified) (3 diffs)
• kernel_init.c (modified) (1 diff)
• printk.h (modified) (1 diff)
• process.c (modified) (26 diffs)
• process.h (modified) (12 diffs)
• rpc.c (modified) (66 diffs)
• rpc.h (modified) (9 diffs)
• scheduler.c (modified) (12 diffs)
• scheduler.h (modified) (4 diffs)
• signal.c (modified) (2 diffs)
• signal.h (modified) (1 diff)
• thread.c (modified) (11 diffs)
• thread.h (modified) (9 diffs)

trunk/kernel/kern/cluster.c

@@ -281 +281 @@
     lpid_t lpid       = LPID_FROM_PID( pid );
 
+    pmgr_t  * pm = &LOCAL_CLUSTER->pmgr;
+
     // check pid argument
-    if( (lpid >= CONFIG_MAX_PROCESS_PER_CLUSTER) || (owner_cxy != local_cxy) )
-    {
-        panic("illegal PID");
-    }
-
-    pmgr_t  * pm = &LOCAL_CLUSTER->pmgr;
+    assert( (lpid < CONFIG_MAX_PROCESS_PER_CLUSTER) && (owner_cxy == local_cxy) ,
+    __FUNCTION__ , "illegal PID" );
+
+    // check number of copies
+    assert( (pm->copies_nr[lpid] == 0) ,
+    __FUNCTION__ , "number of copies must be 0" );  
 
     // get the process manager lock

trunk/kernel/kern/cluster.h

@@ -130 +130 @@
     int32_t           threads_var;     /*! threads number increment from last DQDT update */
 
-        dqdt_node_t       dqdt_tbl[CONFIG_MAX_DQDT_DEPTH];     /*! embedded DQDT nodes        */
+        dqdt_node_t       dqdt_tbl[CONFIG_DQDT_LEVELS_NR]; /*! embedded DQDT nodes in cluster */
 
     // Local process manager

trunk/kernel/kern/core.c

@@ -107 +107 @@
         ticks = core->ticks_nr++;
 
-    // handle signals for all threads executing on this core
-    sched_handle_signals( core );
-
-        // handle scheduler
+        // handle scheduler
         if( (ticks % CONFIG_SCHED_TICKS_PER_QUANTUM) == 0 ) sched_yield( "TICK");
 

trunk/kernel/kern/core.h

@@ -60 +60 @@
         struct thread_s   * fpu_owner;      /*! pointer on current FPU owner thread        */
     uint32_t            rand_last;      /*! last computed random value                 */
+
         scheduler_t         scheduler;      /*! embedded private scheduler                 */
 

trunk/kernel/kern/do_syscall.c

@@ -54 +54 @@
     sys_thread_join,        // 3
     sys_thread_detach,      // 4
-    sys_undefined,          // 5
+    sys_thread_cancel,      // 5
     sys_sem,                // 6
     sys_condvar,            // 7
@@ -110 +110 @@
         else if( index == SYS_THREAD_JOIN    ) return "THREAD_JOIN";      // 3
         else if( index == SYS_THREAD_DETACH  ) return "THREAD_DETACH";    // 4
+        else if( index == SYS_THREAD_CANCEL  ) return "THREAD_CANCEL";    // 5
         else if( index == SYS_SEM            ) return "SEM";              // 6
         else if( index == SYS_CONDVAR        ) return "CONDVAR";          // 7
@@ -189 +190 @@
         error = syscall_tbl[service_num] ( arg0 , arg1 , arg2 , arg3 );
 
+    // check kernel stack overflow
+    assert( (this->signature == THREAD_SIGNATURE), __FUNCTION__, "kernel stack overflow\n" );
+
     // update kernel time
         thread_kernel_time_update( this );

trunk/kernel/kern/kernel_init.c

@@ -770 +770 @@
     thread->core = &LOCAL_CLUSTER->core_tbl[core_lid];
 
-    // each core initializes locks_root" and "xlocks_root" in idle thread descriptor
+#if CONFIG_LOCKS_DEBUG
     list_root_init( &thread->locks_root );
     xlist_root_init( XPTR( local_cxy , &thread->xlocks_root ) );
+#endif
 
     // CP0 in I/O cluster initialises TXT0 chdev descriptor

trunk/kernel/kern/printk.h

@@ -253 +253 @@
 #endif
 
+#if CONFIG_KILL_DEBUG
+#define kill_dmsg(...)   if(hal_time_stamp() > CONFIG_KILL_DEBUG) printk(__VA_ARGS__)
+#else
+#define kill_dmsg(...)
+#endif
+
 #if CONFIG_KINIT_DEBUG
 #define kinit_dmsg(...)   if(hal_time_stamp() > CONFIG_KINIT_DEBUG) printk(__VA_ARGS__)

trunk/kernel/kern/process.c

@@ -8 +8 @@
  * Copyright (c) UPMC Sorbonne Universites
  *
- * This file is part of ALMOS-MKH..
+ * This file is part of ALMOS-MKH.
  *
  * ALMOS-MKH is free software; you can redistribute it and/or modify it
@@ -28 +28 @@
 #include <hal_remote.h>
 #include <hal_uspace.h>
+#include <hal_irqmask.h>
 #include <errno.h>
 #include <printk.h>
@@ -49 +50 @@
 #include <elf.h>
 #include <syscalls.h>
+#include <signal.h>
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -124 +126 @@
     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 );
+process_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x / ppid = %x\n",
+__FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid , ppid );
 
     // get model process cluster and local pointer
@@ -136 +138 @@
     process->ref_xp = XPTR( local_cxy , process );
 
-    // initialize vmm 
+    // initialize vmm as empty 
     vmm_init( process );
 
@@ -142 +144 @@
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
 
-    // initialize fd_array (not for kernel)
+    // initialize fd_array as empty
     process_fd_init( process );
 
     // create stdin / stdout / stderr pseudo-files
-    if( ppid == 0 )                                        // process_init
+    if( ppid == 0 )                                       // process_init
     {
         error1 = vfs_open( process,
@@ -169 +171 @@
                            &stderr_id );
     }
-    else                                                  // other user process
+    else                                                  // any other process
     {
         error1 = vfs_open( process,
@@ -199 +201 @@
     "bad indexes : stdin %d / stdout %d / stderr %d \n", stdin_id , stdout_id , stderr_id );
 
-    // initialize specific files, cwd_lock, and 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_bin_xp  = (xptr_t)hal_remote_lwd( XPTR( model_cxy,
-                                                         &model_ptr->vfs_bin_xp ) );
-    vfs_file_count_up( process->vfs_root_xp );
-    vfs_file_count_up( process->vfs_cwd_xp );
-    vfs_file_count_up( process->vfs_bin_xp );
-
+    vfs_inode_remote_up( process->vfs_root_xp );
+    vfs_inode_remote_up( process->vfs_cwd_xp );
+
+    remote_rwlock_init( XPTR( local_cxy , &process->cwd_lock ) );
+
+    // copy all open file descriptors (other than stdin / stdout / stderr) 
     process_fd_remote_copy( XPTR( local_cxy , &process->fd_array ),
                             XPTR( model_cxy , &model_ptr->fd_array ) );
 
-    remote_rwlock_init( XPTR( local_cxy , &process->cwd_lock ) );
-
-process_dmsg("\n[DBG] %s : core[%x,%d] / fd array initialised for process %x\n", 
+process_dmsg("\n[DBG] %s : core[%x,%d] / fd array for process %x\n", 
 __FUNCTION__ , local_cxy , CURRENT_THREAD->core->lid , pid );
 
@@ -352 +352 @@
     remote_spinlock_unlock( copies_lock );
 
-    // synchronize memory
         hal_fence();
 
     // From this point, the process descriptor is unreachable
 
-    // close all open files and update dirty TODO [AG]
-
-    // release signal manager TODO [AG]
+    // FIXME close all open files and update dirty [AG]
 
     // Decrease refcount for bin file, root file and cwd file
@@ -374 +371 @@
 }  // end process_destroy()
 
+/////////////////////////////////////////////////
+char * process_action_str( uint32_t action_type )
+{
+    if     ( action_type == BLOCK_ALL_THREADS   ) return "BLOCK";
+    else if( action_type == UNBLOCK_ALL_THREADS ) return "UNBLOCK";
+    else if( action_type == DELETE_ALL_THREADS  ) return "DELETE";
+    else                                          return "undefined";
+}
+
+////////////////////////////////////////////
+void process_sigaction( process_t * process,
+                        uint32_t    action_type )
+{
+    cxy_t              owner_cxy;         // owner cluster identifier
+    lpid_t             lpid;              // process index in owner cluster
+    cluster_t        * cluster;           // pointer on cluster manager
+    xptr_t             root_xp;           // extended pointer on root of copies
+    xptr_t             lock_xp;           // extended pointer on lock protecting copies
+    xptr_t             client_xp;         // extended pointer on client thread
+    uint32_t           rsp_count;         // number of expected responses
+    xptr_t             rsp_xp;            // extended pointer on responses counter
+    xptr_t             iter_xp;           // iterator on copies list
+    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
+
+signal_dmsg("\n[DBG] %s : enter for signal %s to process %x in cluster %x\n",
+__FUNCTION__ , process_action_str( action_type ) , process , local_cxy );
+
+    thread_t         * this = CURRENT_THREAD;
+
+    // get extended pointer on client thread and response counter
+    client_xp = XPTR( local_cxy , this );
+    rsp_xp    = XPTR( local_cxy , &rsp_count );
+
+    // get owner cluster identifier and process lpid
+    owner_cxy = CXY_FROM_PID( process->pid );
+    lpid      = LPID_FROM_PID( process->pid );
+
+    assert( (owner_cxy == local_cxy) , __FUNCTION__ , "illegal cluster\n" ); 
+   
+    // get local pointer on local cluster manager
+    cluster = LOCAL_CLUSTER;
+
+    // get extended pointers on copies root, copies lock, and number of copies
+    root_xp   = XPTR( local_cxy , &cluster->pmgr.copies_root[lpid] );
+    lock_xp   = XPTR( local_cxy , &cluster->pmgr.copies_lock[lpid] );
+
+    // initialize responses number 
+    rsp_count = cluster->pmgr.copies_nr[lpid];
+
+    // take the lock protecting the copies
+    remote_spinlock_lock( lock_xp );
+
+    // send RPCs to all process copies
+    XLIST_FOREACH( root_xp , iter_xp )
+    {
+        process_xp  = XLIST_ELEMENT( iter_xp , process_t , copies_list );
+        process_cxy = GET_CXY( process_xp );
+        process_ptr = (process_t *)GET_PTR( process_xp );
+
+printk("\n    @@@ %s : process = %x / pid = %x / ppid = %x\n",
+__FUNCTION__ , process_ptr , process_ptr->pid , process_ptr->ppid );
+
+        rpc_process_sigaction_client( process_cxy, 
+                                      process_ptr,
+                                      action_type,
+                                      rsp_xp,
+                                      client_xp );
+    }
+   
+    // release the lock protecting process copies
+    remote_spinlock_unlock( lock_xp );
+
+    // block and deschedule to wait response
+    thread_block( CURRENT_THREAD , THREAD_BLOCKED_RPC );
+    sched_yield("BLOCKED on RPC");
+
+signal_dmsg("\n[DBG] %s : exit for signal %s to process %x in cluster %x\n",
+__FUNCTION__ , process_action_str( action_type ) , process , local_cxy );
+
+}  // end process_sigaction()
+
 ////////////////////////////////////////
-void process_kill( process_t * process )
-{
-    thread_t     * thread;    // pointer on current thead descriptor
-    uint32_t       ltid;      // index in process th_tbl
-    uint32_t       count;     // thread counter
-
-printk("\n[@@@] %s enter\n", __FUNCTION__ );
-
-    // get lock protecting th_tbl[]
+void process_block( process_t * process,
+                    xptr_t      rsp_xp,
+                    xptr_t      client_xp )
+{
+    thread_t          * target;         // pointer on target thread 
+    uint32_t            ltid;           // index in process th_tbl
+    thread_t          * killer;         // killer thread pointer
+    uint32_t            count;          // requests counter
+    volatile uint32_t   sig_rsp_count;  // responses counter
+    cxy_t               client_cxy;     // client thread cluster identifier
+    thread_t          * client_ptr;     // client thread pointer
+    core_t            * client_core;    // client thread core pointer
+
+    // get local killer thread pointer
+    killer = CURRENT_THREAD;
+
+signal_dmsg("\n[DBG] %s : enter for process %x in cluster %x\n",
+__FUNCTION__ , process->pid , local_cxy );
+
+    // get lock protecting process th_tbl[]
     spinlock_lock( &process->th_lock );
 
-    // first loop on threads to send the THREAD_SIG_KILL signal to all process threads
-    // we use both "ltid" and "count" indexes, because it can exist "holes" in th_tbl
-    for( ltid = 0 , count = 0  ;
-         (ltid < CONFIG_THREAD_MAX_PER_CLUSTER) && (count < process->th_nr) ;
+    // initialize local responses counter 
+    sig_rsp_count = process->th_nr;
+
+    // loop on process threads to block and deschedule all threads in cluster
+    // we use both "ltid" and "count" because it can exist "holes" in th_tbl
+    for( ltid = 0 , count = 0 ; count < process->th_nr ; ltid++ )
+    {
+        target = process->th_tbl[ltid];
+
+        if( target != NULL )             // thread found
+        {
+            count++;
+
+            // set signal in target thread descriptor
+            thread_set_signal( target , (uint32_t *)sig_rsp_count );
+
+            // set the global blocked bit in target thread descriptor.
+            thread_block( target , THREAD_BLOCKED_GLOBAL );
+
+            // - if the killer thread and the target thread are not on the same core
+            //   we want the scheduler of target thread to acknowlege the signal
+            //   to be sure that the target thread is descheduled
+            // - if the killer thread and the target thread are on the same core
+            //   we simply decrement the response counter.
+            if( killer->core->lid != target->core->lid )
+            {
+                dev_pic_send_ipi( local_cxy , target->core->lid );
+            }
+            else                                                         
+            {
+                hal_atomic_add( (void *)&sig_rsp_count , -1 );
+            }
+        }
+    }
+
+    // poll the reponses counter 
+    while( 1 )
+    {
+        // exit loop when all responses received
+        if ( sig_rsp_count == 0 ) break;
+    
+        // wait 1000 cycles before retry
+        hal_fixed_delay( 1000 );
+    }
+
+    // acknowledge client thread & unblock client thread if last response
+    client_cxy  = GET_CXY( client_xp );
+    client_ptr  = (thread_t *)GET_PTR( client_xp );
+    client_core = (core_t *)hal_remote_lpt( XPTR( client_cxy , &client_ptr->core ) );
+    if( hal_remote_atomic_add( rsp_xp , -1 ) == 1 ) 
+    {
+        thread_unblock( client_xp , THREAD_BLOCKED_RPC);
+        dev_pic_send_ipi( client_cxy , client_core->lid );
+    }
+
+signal_dmsg("\n[DBG] %s : exit for process %x in cluster %x / %d threads blocked\n",
+__FUNCTION__ , process->pid , local_cxy , count );
+
+}  // end process_block()
+
+//////////////////////////////////////////
+void process_unblock( process_t * process,
+                      xptr_t      rsp_xp,
+                      xptr_t      client_xp )
+{
+    thread_t          * target;        // pointer on target thead 
+    uint32_t            ltid;          // index in process th_tbl
+    thread_t          * killer;        // killer thread pointer
+    uint32_t            req_count;     // requests counter
+    cxy_t               client_cxy;    // client thread cluster identifier
+    thread_t          * client_ptr;    // client thread pointer
+    core_t            * client_core;   // client thread core pointer
+
+    // get local killer thread pointer
+    killer = CURRENT_THREAD;
+
+signal_dmsg("\n[DBG] %s : enter for process %x in cluster %x\n",
+__FUNCTION__ , process->pid , local_cxy );
+
+    // get lock protecting process th_tbl[]
+    spinlock_lock( &process->th_lock );
+
+    // loop on process threads to unblock all threads in cluster
+    // we use both "ltid" and "req_count" because it can exist "holes" in th_tbl
+    for( ltid = 0 , req_count = 0 ;
+         req_count < process->th_nr ;
          ltid++ )
     {
+        target = process->th_tbl[ltid];
+
+        if( target != NULL )             // thread found
+        {
+            req_count++;
+
+            // reset the global blocked bit in target thread descriptor.
+            thread_unblock( XPTR( local_cxy , target ) , THREAD_BLOCKED_GLOBAL );
+        }
+    }
+
+    // acknowledge client thread & unblock client thread if last response
+    client_cxy  = GET_CXY( client_xp );
+    client_ptr  = (thread_t *)GET_PTR( client_xp );
+    client_core = (core_t *)hal_remote_lpt( XPTR( client_cxy , &client_ptr->core ) );
+    if( hal_remote_atomic_add( rsp_xp , -1 ) == 1 ) 
+    {
+        thread_unblock( client_xp , THREAD_BLOCKED_RPC);
+        dev_pic_send_ipi( client_cxy , client_core->lid );
+    }
+
+signal_dmsg("\n[DBG] %s : exit for process %x in cluster %x / %d threads blocked\n",
+__FUNCTION__ , process->pid , local_cxy , req_count );
+
+}  // end process_unblock()
+
+/////////////////////////////////////////
+void process_delete( process_t * process,
+                     xptr_t      rsp_xp,
+                     xptr_t      client_xp )
+{
+    thread_t          * thread;        // pointer on target thread 
+    uint32_t            ltid;          // index in process th_tbl
+    uint32_t            count;         // request counter
+    pid_t               pid;           // process PID
+    cxy_t               client_cxy;    // client thread cluster identifier
+    thread_t          * client_ptr;    // client thread pointer
+    core_t            * client_core;   // client thread core pointer
+
+    // get process PID
+    pid = process->pid;
+
+signal_dmsg("\n[DBG] %s : enter for process %x in cluster %x at cycle %d\n",
+__FUNCTION__ , pid , local_cxy , (uint32_t)hal_get_cycles() );
+
+    // loop on threads to release memory allocated to threads
+    for( ltid = 0 , count = 0  ; count < process->th_nr ; ltid++ )
+    {
         thread = process->th_tbl[ltid];
 
-        if( thread != NULL )
+        if( thread != NULL )             // thread found
         {
-            thread_kill( thread );
             count++;
+
+            // detach thread from parent if attached
+            if( (thread->flags & THREAD_FLAG_DETACHED) == 0 ) 
+            thread_child_parent_unlink( thread->parent , XPTR( local_cxy , thread ) );
+
+            // detach thread from process
+            process_remove_thread( thread );
+
+            // remove thread from scheduler
+            sched_remove_thread( thread );
+
+            // release memory allocated to thread
+            thread_destroy( thread );
         }
     }
 
-printk("\n[@@@] %s : %d signal(s) sent\n", __FUNCTION__, count );
-
-    // second loop on threads to wait acknowledge from scheduler,
-    // unlink thread from process and parent thread, and release thread descriptor
-    for( ltid = 0 , count = 0  ;
-         (ltid < CONFIG_THREAD_MAX_PER_CLUSTER) && (count < process->th_nr) ;
-         ltid++ )
-    {
-        thread = process->th_tbl[ltid];
-
-        if( thread != NULL )
-        {
-
-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
-            process_remove_thread( thread );
-
-            // release memory for thread descriptor
-            thread_destroy( thread );
-
-            count++;
-        }
-    }
-
-printk("\n[@@@] %s : %d ack(s) received\n", __FUNCTION__, count );
-
-    // release lock protecting th_tbl[]
-    spinlock_unlock( &process->th_lock );
-
-    // release memory allocated for process descriptor
-    process_destroy( process );
-
-printk("\n[DBG] %s : core[%x,%d] exit\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid );
-
-}  // end process_kill()
+    // release memory allocated to process descriptors
+    // for all clusters other than the owner cluster 
+    if( local_cxy != CXY_FROM_PID( process->pid ) ) process_destroy( process );
+
+    // acknowledge client thread & unblock client thread if last response
+    client_cxy  = GET_CXY( client_xp );
+    client_ptr  = (thread_t *)GET_PTR( client_xp );
+    client_core = (core_t *)hal_remote_lpt( XPTR( client_cxy , &client_ptr->core ) );
+    if( hal_remote_atomic_add( rsp_xp , -1 ) == 1 ) 
+    {
+        thread_unblock( client_xp , THREAD_BLOCKED_RPC);
+        dev_pic_send_ipi( client_cxy , client_core->lid );
+    }
+
+signal_dmsg("\n[DBG] %s : exit for process %x in cluster %x at cycle %d\n",
+__FUNCTION__ , pid , local_cxy , (uint32_t)hal_get_cycles() );
+
+}  // end process_delete()
 
 ///////////////////////////////////////////////
@@ -496 +701 @@
 
     return process_ptr;
-}
+
+}  // end process_get_local_copy()
 
 //////////////////////////////////////////////////////////////////////////////////////////
@@ -621 +827 @@
         remote_spinlock_lock( XPTR( src_cxy , &src_ptr->lock ) );
 
-    // loop on all entries in source process fd_array
-    for( fd = 0 ; fd < CONFIG_PROCESS_FILE_MAX_NR ; fd++ )
+    // loop on all entries other than
+    // the three first entries: stdin/stdout/stderr
+    for( fd = 3 ; fd < CONFIG_PROCESS_FILE_MAX_NR ; fd++ )
         {
                 entry = (xptr_t)hal_remote_lwd( XPTR( src_cxy , &src_ptr->array[fd] ) );
@@ -724 +931 @@
     "parent process must be the reference process\n" );
 
-process_dmsg("\n[DBG] %s : core[%x,%d] enter at cycle %d\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid , hal_get_cycles() );
+fork_dmsg("\n[DBG] %s : core[%x,%d] enter at cycle %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid , (uint32_t)hal_get_cycles() );
 
     // allocate a process descriptor
@@ -736 +943 @@
     }
 
-process_dmsg("\n[DBG] %s : core[%x,%d] child process descriptor allocated at cycle %d\n",
- __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
+fork_dmsg("\n[DBG] %s : core[%x,%d] child process descriptor allocated at cycle %d\n",
+ __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
 
     // allocate a child PID from local cluster
@@ -749 +956 @@
     }
 
-process_dmsg("\n[DBG] %s : core[%x, %d] child process PID allocated = %x at cycle %d\n",
- __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, new_pid , hal_get_cycles() );
+fork_dmsg("\n[DBG] %s : core[%x, %d] child process PID allocated = %x at cycle %d\n",
+ __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, new_pid , (uint32_t)hal_get_cycles() );
 
     // initializes child process descriptor from parent process descriptor 
@@ -758 +965 @@
                             parent_process_xp );
 
-process_dmsg("\n[DBG] %s : core[%x, %d] child process initialised at cycle %d\n",
+fork_dmsg("\n[DBG] %s : core[%x, %d] child process initialised at cycle %d\n",
 __FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
 
@@ -773 +980 @@
     }
 
-process_dmsg("\n[DBG] %s : core[%x, %d] child process VMM copied at cycle %d\n",
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
+fork_dmsg("\n[DBG] %s : core[%x, %d] child process VMM copied at cycle %d\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
 
     // create child thread descriptor from parent thread descriptor
@@ -789 +996 @@
     }
 
-process_dmsg("\n[DBG] %s : core[%x,%d] child thread created at cycle %d\n", 
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
+fork_dmsg("\n[DBG] %s : core[%x,%d] child thread created at cycle %d\n", 
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
 
     // update parent process GPT to set Copy_On_Write for shared data vsegs 
@@ -804 +1011 @@
     }
 
-process_dmsg("\n[DBG] %s : core[%x,%d] COW set in parent_process at cycle %d\n",
-__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, hal_get_cycles() );
+fork_dmsg("\n[DBG] %s : core[%x,%d] COW set in parent_process at cycle %d\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
 
     // update children list in parent process
@@ -821 +1028 @@
     *child_pid    = new_pid;
 
+fork_dmsg("\n[DBG] %s : core[%x,%d] exit at cycle %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, (uint32_t)hal_get_cycles() );
+
     return 0;
 
 }  // end process_make_fork()
+
+/*  deprecated because we don't wand to destroy the existing process descriptor
 
 /////////////////////////////////////////////////////
@@ -841 +1053 @@
     pid  = exec_info->pid;
 
-    // check local cluster is old process owner
+    // check local cluster is process owner
     assert( (CXY_FROM_PID( pid ) == local_cxy), __FUNCTION__,
     "local cluster %x is not owner for process %x\n", local_cxy, pid );
@@ -876 +1088 @@
         }
 
-exec_dmsg("\n[DBG] %s : core[%x,%d] registered code/data vsegs / process %x / path = %s\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid, path );
+exec_dmsg("\n[DBG] %s : core[%x,%d] vsegs registered / path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path );
 
     // select a core in local cluster to execute the main thread
@@ -908 +1120 @@
                    XPTR( local_cxy , &new->brothers_list ) );
 
-    // FIXME request destruction of old process copies and threads in all clusters
+    // request destruction of old process copies and threads in all clusters
+    process_sigaction( old , SIGKILL );
 
     // activate new thread
@@ -920 +1133 @@
 }  // end process_make_exec()
 
+*/
+
+/////////////////////////////////////////////////////
+error_t process_make_exec( exec_info_t  * exec_info )
+{
+    char           * path;                    // pathname to .elf file
+    process_t      * process;                 // local pointer on old process
+    pid_t            pid;                     // old process identifier
+    thread_t       * thread;                  // pointer on new main thread
+    pthread_attr_t   attr;                    // main thread attributes
+    lid_t            lid;                     // selected core local index
+        error_t          error;
+
+        // get .elf pathname and PID from exec_info
+        path = exec_info->path;
+    pid  = exec_info->pid;
+
+    // check local cluster is process owner
+    assert( (CXY_FROM_PID( pid ) == local_cxy), __FUNCTION__,
+    "local cluster %x is not owner for process %x\n", local_cxy, pid );
+
+exec_dmsg("\n[DBG] %s : core[%x,%d] enters for process %x / path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid , path );
+
+    // get process local pointer
+    process = (process_t *)cluster_get_local_process_from_pid( pid );
+    
+    assert( (process != NULL ) , __FUNCTION__ , 
+    "process %x not found in cluster %x\n", pid , local_cxy ); 
+
+    // reset the existing vmm
+    vmm_destroy( process );
+
+exec_dmsg("\n[DBG] %s : core[%x,%d] VMM cleared\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid );
+
+    // block all existing process threads
+    process_sigaction( process , BLOCK_ALL_THREADS );
+
+    // kill all existing threads and process descriptors (other than owner)
+    process_sigaction( process , DELETE_ALL_THREADS );
+
+    // check no threads
+    assert( (process->th_nr == 0) , __FUNCTION__ , "no threads at this point" );
+
+exec_dmsg("\n[DBG] %s : core[%x,%d] all threads deleted\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid );
+
+    // re-initialize VMM 
+    vmm_init( process );
+
+    // register "code" and "data" vsegs as well as entry-point and vfs_bin_xp
+    // in VMM, using information contained in the elf file.
+        if( elf_load_process( path , process ) )
+        {
+                printk("\n[ERROR] in %s : failed to access .elf file for process %x / path = %s\n",
+                __FUNCTION__, pid , path );
+        process_destroy( process );
+        return -1;
+        }
+
+exec_dmsg("\n[DBG] %s : core[%x,%d] new vsegs registered / path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path );
+
+// @@@
+vmm_display( process , true );
+// @@@
+
+    // select a core in local cluster to execute the new main thread
+    lid  = cluster_select_local_core();
+
+    // initialize pthread attributes for new 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 thread descriptor
+        error = thread_user_create( pid,
+                                (void *)process->vmm.entry_point,
+                                exec_info->args_pointers,
+                                &attr,
+                                &thread );
+        if( error )
+        {
+                printk("\n[ERROR] in %s : cannot create thread for process %x / path = %s\n",
+                       __FUNCTION__, pid , path );
+        process_destroy( process );
+        return -1;
+        }
+
+exec_dmsg("\n[DBG] %s : core[%x,%d] created main thread %x for new process %x\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, thread->trdid, pid );
+
+    // activate new thread
+        thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_GLOBAL );
+
+exec_dmsg("\n[DBG] %s : core[%x,%d] exit for path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, path  );
+
+        return 0;
+
+}  // end process_make_exec()
+
+////////////////////////////////////////////
+void process_make_kill( process_t * process,
+                        uint32_t    sig_id )
+{
+    // this function must be executed by a thread running in owner cluster
+    assert( (CXY_FROM_PID( process->pid ) == local_cxy) , __FUNCTION__ ,
+    "must execute in owner cluster" );
+
+    // analyse signal type
+    switch( sig_id )
+    {
+        case SIGSTOP:     // block all threads
+        {
+            process_sigaction( process , BLOCK_ALL_THREADS );
+        }
+        break;
+        case SIGCONT:     // unblock all threads
+        {
+            process_sigaction( process , UNBLOCK_ALL_THREADS );
+        }
+        break;
+        case SIGKILL:  // block all threads, then delete all threads
+        {
+            process_sigaction( process , BLOCK_ALL_THREADS );
+            process_sigaction( process , DELETE_ALL_THREADS );
+            process_destroy( process );
+        }
+        break;
+    }
+}  // end process_make_kill()
+
+////////////////////////////////////////////
+void process_make_exit( process_t * process,
+                        uint32_t    status )
+{
+    // this function must be executed by a thread running in owner cluster
+    assert( (CXY_FROM_PID( process->pid ) == local_cxy) , __FUNCTION__ ,
+    "must execute in owner cluster" );
+
+    // block all threads in all clusters
+    process_sigaction( process , BLOCK_ALL_THREADS );
+
+    // delete all threads in all clusters
+    process_sigaction( process , DELETE_ALL_THREADS );
+
+    // delete local process descriptor
+    process_destroy( process ); 
+
+}  // end process_make_exit()
+
 //////////////////////////
 void process_init_create()
 {
-    exec_info_t   exec_info;     // structure to be passed to process_make_exec()
-    process_t   * process;       // local pointer on process_init descriptor
-    pid_t         pid;           // process_init identifier
-    error_t       error;
-
-process_dmsg("\n[DBG] %s : enters in cluster %x\n", 
-__FUNCTION__ , local_cxy );
+    process_t      * process;       // local pointer on process_init descriptor
+    pid_t            pid;           // process_init identifier
+    thread_t       * thread;        // local pointer on main thread
+    pthread_attr_t   attr;          // main thread attributes
+    lid_t            lid;           // selected core local index for main thread
+    error_t          error;
+
+kinit_dmsg("\n[DBG] %s :  core[%x,%d] enters\n", 
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid );
 
     // allocates memory for process descriptor from local cluster
@@ -936 +1304 @@
     {
                 printk("\n[PANIC] in %s : no memory for process descriptor in cluster %x\n",
-                __FUNCTION__, local_cxy );
-    }
-
-    // get new PID from local cluster
+                __FUNCTION__, local_cxy  );
+    }
+
+    // get PID from local cluster
     error = cluster_pid_alloc( XPTR( local_cxy , process ) , &pid );
     if( error )
@@ -945 +1313 @@
                 printk("\n[PANIC] in %s : cannot allocate PID in cluster %x\n",
                 __FUNCTION__, local_cxy );
-    }
-
-    // initialise the process desciptor (parent is local kernel process)
-    process_reference_init( process, 
+        process_destroy( process );
+    }
+
+    assert( (LPID_FROM_PID(pid) == 1) , __FUNCTION__ , "LPID must be 1 for process_init" );
+
+    // initialize process descriptor / parent is local process_zero
+    process_reference_init( process,
                             pid,
-                            process_zero.pid, 
+                            0,
                             XPTR( local_cxy , &process_zero ) );
 
-    // initialize the exec_info structure
-    exec_info.pid          = pid;
-    exec_info.args_nr      = 0;
-    exec_info.envs_nr      = 0;
-    strcpy( exec_info.path , CONFIG_PROCESS_INIT_PATH );
-
-    // update process descriptor and create thread descriptor
-        error = process_make_exec( &exec_info );
-
+kinit_dmsg("\n[DBG] %s : core[%x,%d] / process initialised\n", 
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid );
+
+    // 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 );
+        }
+
+kinit_dmsg("\n[DBG] %s : core[%x,%d] vsegs registered / path = %s\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, CONFIG_PROCESS_INIT_PATH );
+
+    // 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 thread descriptor
+        error = thread_user_create( pid,
+                                (void *)process->vmm.entry_point,
+                                NULL,
+                                &attr,
+                                &thread );
         if( error )
-    { 
-                printk("\n[PANIC] in %s : cannot exec %s in cluster %x\n",
-                __FUNCTION__, CONFIG_PROCESS_INIT_PATH , local_cxy );
-    }
-
-process_dmsg("\n[DBG] %s : exit in cluster %x\n", 
-__FUNCTION__ , local_cxy );
-                
+        {
+                printk("\n[PANIC] in %s : cannot create main thread / path = %s\n",
+                __FUNCTION__, CONFIG_PROCESS_INIT_PATH );
+        process_destroy( process );
+        }
+
+    // activate thread
+        thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_GLOBAL );
+
     hal_fence();
 
+kinit_dmsg("\n[DBG] %s : core[%x,%d] exit / main thread = %x\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, thread );
+
 }  // end process_init_create()
 

trunk/kernel/kern/process.h

@@ -54 +54 @@
 
 /*********************************************************************************************
+ * This enum defines the actions that can be executed by the process_signal() function.
+ ********************************************************************************************/
+
+enum process_sigactions
+{
+    BLOCK_ALL_THREADS,
+    UNBLOCK_ALL_THREADS,
+    DELETE_ALL_THREADS,
+};
+
+/*********************************************************************************************
  * This structure defines an array of extended pointers on the open file descriptors
  * for a given process. We use an extended pointer because the open file descriptor
@@ -76 +87 @@
  * - The PID 16 LSB bits contain the LPID (Local Process Index)
  * - The PID 16 MSB bits contain the owner cluster CXY.
- * In each cluster, the process manager allocates LPID values for the process that are
- * allocated to this cluster.
- * The process descriptor for a PID process is replicated in all clusters containing
- * at least one thread of the PID process, with the following rules :
- *
+ * In each cluster, the process manager allocates  the LPID values for the process that
+ * are owned by this cluster.
+ * The process descriptor is replicated in all clusters containing at least one thread 
+ * of the PID process, with the following rules :
  * 1) The <pid>, <ppid>, <ref_xp>, <vfs_root_xp>, <vfs_bin_xp>  fields are defined
  *    in all process descriptor copies.
  * 2) The <vfs_cwd_xp> and associated <cwd_lock>, that can be dynamically modified,
  *    are only defined in the reference process descriptor.
- * 2) The <vmm>, containing the list of registered vsegs, and the page table, are only
- *    complete in the reference process cluster, other copies are read-only caches.
+ * 2) The <vmm>, containing the VSL (list of registered vsegs), and the GPT (generic
+ *    page table), are only complete in the reference process cluster, other copies 
+ *    are actually use as read-only caches.
  * 3) the <fd_array>, containing extended pointers on the open file descriptors, is only
  *    complete in the reference process cluster, other copies are read-only caches.
@@ -95 +106 @@
  * 6) The <brothers_list>, <local_list>, <copies_list>, <th_tbl>, <th_nr>, <th_lock> fields
  *    are defined in all process descriptors copies.
- * 7) The <sig_mgr> field is only defined in the reference cluster. TODO
  ********************************************************************************************/
 
@@ -130 +140 @@
 
     remote_spinlock_t sync_lock;        /*! lock protecting sem,mutex,barrier,condvar lists */
-
-        sig_mgr_t         sig_mgr;          /*! embedded signal manager TODO [AG]               */
 }
 process_t;
@@ -137 +145 @@
 /*********************************************************************************************
  * This structure defines the information required by the process_make_exec() function
- * to create a new reference process descriptor, and the associated main thread,
- * in the parent process owner cluster.
+ * to create a new reference process descriptor, and the associated main thread.
  ********************************************************************************************/
 
@@ -176 +183 @@
 /*********************************************************************************************
  * This function allocates memory and initializes the "process_init" descriptor and the
- * 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.
+ * associated "thread_init" descriptor. It is called once at the end of the kernel 
+ * initialisation procedure, by the kernel process in cluster_IO.
  * 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. 
- * Practically, it builds the exec_info structure, and calls the process_make_exec() 
- * function, that make the real job.
+ * pathname is defined by the CONFIG_PROCESS_INIT_PATH configuration variable. 
+ * The process_init streams are defined  by the CONFIG_INIT_[STDIN/STDOUT/STDERR] variables.
+ * Its local process identifier is 1, and parent process is the local kernel process_zero.
  ********************************************************************************************/
 void process_init_create();
@@ -200 +207 @@
  * descriptor, defined by the <model_xp> argument. The <process> descriptor, the <pid>, and
  * the <ppid> arguments must be previously defined by the caller.
- * It can be called by three functions, depending on the process type:
- * 1) if "process" is the user "process_init", the parent is the kernel process. It is
+ * It can be called by two functions, depending on the process type:
+ * 1) if "process" is the "process_init", the parent is the kernel process. It is
  *    called once, by the process_init_create() function in cluster[xmax-1][ymax-1].
  * 2) if the caller is the process_make_fork() function, the model is generally a remote
  *    process, that is also the parent process.
+
  * 3) if the caller is the process_make_exec() function, the model is always a local process,
- *    but the parent is the parent of the model process.
- *
+ *    and the parent is the parent of the model process. DEPRECATED [AG]
+
  * The following fields are initialised (for all process but process_zero).
  * - It set the pid / ppid / ref_xp fields.
- * - It initializes an empty VMM (no vsegs registered in VSL and GPT).
+ * - It initializes the VMM (register the kentry, args, envs vsegs in VSL)
  * - It initializes the FDT, defining the three pseudo files STDIN / STDOUT / STDERR.
  * - It set the root_xp, bin_xp, cwd_xp fields.
@@ -251 +259 @@
 
 /*********************************************************************************************
- * This function kills a user process in a given cluster.
- * It can be directly called in the reference cluster, or it can be called through the
- * PROCESS_KILL RPC.
- * - In a first loop, it set the THREAD_SIG_KILL signal to all threads of process.
- * - In a second loop, it wait, for each thread the reset of the THREAD_SIG_KILL signal
- *   by the scheduler, and completes the thread descriptor destruction.
+ * This function returns a printable string defining the action for process_signa().
+ *********************************************************************************************
+ * @ action_type   : BLOCK_ALL_THREADS / UNBLOCK_ALL_THREADS / DELETE_ALL_THREADS
+ * @ return a string pointer.
+ ********************************************************************************************/
+char * process_action_str( uint32_t action_type );
+
+/*********************************************************************************************
+ * This function allows any thread running in any cluster to block, unblock  or delete
+ * all threads of a given process identified by the <process> argument, dependig on the
+ * <acion_type> argument. 
+ * It can be called by the sys_kill() or sys_exit() functions to handle the "kill" & "exit"
+ * system calls, or by the process_make_exec() function to handle the "exec" system call.
+ * It must be executed in the owner cluster for the target process (using the relevant RPC
+ * (RPC_PROCESS_SIGNAL or RPC_PROCESS_EXEC) if the client thread in not running in the
+ * owner cluster.
+ * It uses the multicast, non blocking, RPC_PROCESS_KILL to send the signal to all process
+ * copies in parallel, block & deschedule when all signals have been sent, and finally
+ * returns only when all responses have been received and the operation is completed. 
  *********************************************************************************************
  * @ process     : pointer on the process descriptor.
- ********************************************************************************************/
-void process_kill( process_t * process );
+ * @ action_type   : BLOCK_ALL_THREADS / UNBLOCK_ALL_THREADS / DELETE_ALL_THREADS
+ ********************************************************************************************/
+void process_sigaction( process_t * process,
+                        uint32_t    action_type );
+
+/*********************************************************************************************
+ * This function blocks all threads of a given user process in a given cluster.
+ * It is always called by a local RPC thread, through the multicast RPC_PROCESS_KILL.
+ * It loop on all local threads of the process, requesting the relevant schedulers to
+ * block and deschedule these threads, using IPI if required. The threads are not detached 
+ * from the scheduler, and not detached from the local process.
+ * It acknowledges the client thread in the owner cluster only when all process threads
+ * are descheduled and blocked on the BLOCKED_GLOBAL condition, using the <rsp_xp> argument.
+ *********************************************************************************************
+ * @ process     : pointer on the target process descriptor.
+ * @ rsp_xp      : extended pointer on the response counter. 
+ * # client_xp   : extended pointer on client thread descriptor.
+ ********************************************************************************************/
+void process_block( process_t * process,
+                    xptr_t      rsp_xp,
+                    xptr_t      client_xp );
+
+/*********************************************************************************************
+ * This function unblocks all threads of a given user process in a given cluster.
+ * It is always called by a local RPC thread, through the multicast RPC_PROCESS_KILL.
+ * It loops on local threads of the process, to reset the BLOCKED_GLOBAL bit in all threads.
+ * It acknowledges directly the client thread in the owner cluster when this is done, 
+ * using the <rsp_xp> argument.
+ *********************************************************************************************
+ * @ process     : pointer on the process descriptor.
+ * @ rsp_xp      : extended pointer on the response counter. 
+ * # client_xp   : extended pointer on client thread descriptor.
+ ********************************************************************************************/
+void process_unblock( process_t * process,
+                      xptr_t      rsp_xp,
+                      xptr_t      client_xp );
+
+/*********************************************************************************************
+ * This function delete all threads descriptors, of given user process in a given cluster.
+ * It is always called by a local RPC thread, through the multicast RPC_PROCESS_KILL.
+ * It detach all process threads from the scheduler, detach the threads from the local
+ * process, and release the local memory allocated to threads descriptors (including the 
+ * associated structures such as CPU and FPU context). Finally, it release the memory
+ * allocated to the local process descriptor itself, but only when the local cluster
+ * is NOT the process owner, but only a copy.  It acknowledges directly the client thread 
+ * in the owner cluster, using ithe <rsp_xp> argument.
+ *********************************************************************************************
+ * @ process     : pointer on the process descriptor.
+ * @ rsp_xp      : extended pointer on the response counter. 
+ * # client_xp   : extended pointer on client thread descriptor.
+ ********************************************************************************************/
+void process_delete( process_t * process,
+                     xptr_t      rsp_xp,
+                     xptr_t      client_xp );
 
 /*********************************************************************************************
@@ -274 +347 @@
 
 /*********************************************************************************************
- * This function implements the exec() system call, and is called by the sys_exec() function.
- * It is also called by the process_init_create() function to build the "init" process.
+ * This function implements the "exec" system call, and is called by the sys_exec() function.
  * The "new" process keep the "old" process PID and PPID, all open files, and env variables,
  * the vfs_root and vfs_cwd, but build a brand new memory image (new VMM from the new .elf).
- * It actually creates a "new" reference process descriptor, saves all relevant information
- * from the "old" reference process descriptor to the "new" process descriptor.
+ * It actually creates a "new" reference process descriptor, and copies all relevant 
+ * information from the "old" process descriptor to the "new" process descriptor.
  * It completes the "new" process descriptor, from information found in the <exec_info> 
  * structure (defined in the process.h file), that must be built by the caller.
  * It creates and initializes the associated main thread. It finally destroys all copies 
- * of the "old" process in all clusters, and all the old associated threads.
+ * of the "old" process in all clusters, and destroys all old associated threads.
  * It is executed in the local cluster, that becomes both the "owner" and the "reference"
  * cluster for the "new" process.
@@ -293 +365 @@
 
 /*********************************************************************************************
- * This function implement the fork() system call, and is called by the sys_fork() function. 
+ * This function implements the "fork" system call, and is called by the sys_fork() function. 
  * It allocates memory and initializes a new "child" process descriptor, and the
  * associated "child" thread descriptor in the local cluster. This function can involve
  * up to three different clusters :
  * - the local (child) cluster can be any cluster defined by the sys_fork function.
- * - the parent cluster must be the reference clusterfor the parent process.
- * - the client cluster containing the thread requestingthe fork can be any cluster.
+ * - the parent cluster must be the reference cluster for the parent process.
+ * - the client cluster containing the thread requesting the fork can be any cluster.
  * The new "child" process descriptor is initialised from informations found in the "parent"
  * reference process descriptor, containing the complete process description.
@@ -315 +387 @@
                             pid_t            * child_pid, 
                             struct thread_s ** child_thread_ptr );
+
+/*********************************************************************************************
+ * This function implement the "exit" system call, and is called by the sys_exit() function.
+ * It must be executed by a thread running in the calling process owner cluster.
+ * It uses twice the multicast RPC_PROCESS_SIGNAL to first block all process threads
+ * in all clusters, and then delete all thread  and process descriptors.
+ *********************************************************************************************
+ * @ process  : pointer on process descriptor in owner cluster.
+ * @ status   : exit return value.
+ ********************************************************************************************/
+void process_make_exit( process_t * process,
+                        uint32_t    status );
+
+/*********************************************************************************************
+ * This function implement the "kill" system call, and is called by the sys_kill() function.
+ * It must be executed by a thread running in the target process owner cluster.
+ * Only the SIGKILL, SIGSTOP, and SIGCONT signals are supported.
+ * User defined handlers are not supported.
+ * It uses once or twice the multicast RPC_PROCESS_SIGNAL to block, unblock or delete
+ * all process threads in all clusters, and then delete process descriptors.
+ *********************************************************************************************
+ * @ process  : pointer on process descriptor in owner cluster.
+ * @ sig_id   : signal type.
+ ********************************************************************************************/
+void process_make_kill( process_t * process,
+                        uint32_t    sig_id );
+
 
 /********************   File Management Operations   ****************************************/
@@ -376 +475 @@
 
 /*********************************************************************************************
- * This function copies all non-zero entries from a remote <src_xp> fd_array,
- * embedded in a process descriptor, to another remote <dst_xp> fd_array, embedded
- * in another process descriptor. The calling thread can be running in any cluster.
+ * This function copies all non-zero entries (other than the three first stdin/stdout/stderr)
+ * from a remote <src_xp> fd_array, embedded in a process descriptor, to another remote 
+ * <dst_xp> fd_array, embedded in another process descriptor. 
+ * The calling thread can be running in any cluster.
  * It takes the remote lock protecting the <src_xp> fd_array during the copy.
  * For each involved file descriptor, the refcount is incremented.

trunk/kernel/kern/rpc.c

@@ -49 +49 @@
 {
     &rpc_pmem_get_pages_server,         // 0
-    &rpc_process_make_exec_server,      // 1
-    &rpc_process_make_fork_server,      // 2
-    &rpc_process_kill_server,           // 3
-    &rpc_thread_user_create_server,     // 4
-    &rpc_thread_kernel_create_server,   // 5
-    &rpc_signal_rise_server,            // 6                       
-    &rpc_undefined,                     // 7
-    &rpc_undefined,                     // 8
-    &rpc_undefined,                     // 9
+    &rpc_pmem_release_pages_server,     // 1
+    &rpc_process_make_exec_server,      // 2
+    &rpc_process_make_fork_server,      // 3
+    &rpc_process_make_exit_server,      // 4
+    &rpc_process_make_kill_server,      // 5
+    &rpc_thread_user_create_server,     // 6
+    &rpc_thread_kernel_create_server,   // 7
+    &rpc_thread_kill_server,            // 8                       
+    &rpc_process_sigaction_server,      // 9
 
     &rpc_vfs_inode_create_server,       // 10  
@@ -88 +88 @@
 }
 
-/////////////////////////////////////////////////////////////////////////////////////////
-// [0]           Marshaling functions attached to RPC_PMEM_GET_PAGES 
+/***************************************************************************************/
+/************ Generic functions supporting RPCs : client side **************************/
+/***************************************************************************************/
+
+///////////////////////////////////////
+void rpc_send( cxy_t        server_cxy, 
+               rpc_desc_t * rpc,
+               bool_t       block )
+{
+    error_t    error;
+
+    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 local pointers are identical in all clusters
+    remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
+
+        // try to post an item in remote fifo
+    // deschedule and retry if remote fifo full
+    do
+    { 
+        error = remote_fifo_put_item( XPTR( server_cxy , rpc_fifo ),
+                                      (uint64_t )desc_xp );
+            if ( error ) 
+        {
+            printk("\n[WARNING] %s : cluster %x cannot post RPC to cluster %x\n",
+            __FUNCTION__ , local_cxy , server_cxy );
+
+            if( thread_can_yield() ) sched_yield("RPC fifo full");
+        }
+    }
+    while( error );
+ 
+    hal_fence();
+        
+    // send IPI to the remote core corresponding to the client core
+        dev_pic_send_ipi( server_cxy , core->lid );
+
+    // wait RPC completion if blocking
+    // - busy waiting policy during kernel_init, or if threads cannot yield
+    // - block and deschedule in all other cases
+    if ( block )
+    {
+        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("BLOCKED on RPC");
+
+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()
+
+
+/***************************************************************************************/
+/************ Generic functions supporting RPCs : server side **************************/
+/***************************************************************************************/
+
+////////////////
+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("IPI received");
+
+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
+ 
+    // 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 ) )
+        {
+            // 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 );
+                    }
+                        }
+        
+                // 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_kill( this );
+            }
+
+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("RPC fifo empty or too much work");
+
+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()
+
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [0]           Marshaling functions attached to RPC_PMEM_GET_PAGES (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -97 +388 @@
                                 page_t  ** page )      // out 
 {
-    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() );
+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");
@@ -112 +403 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc  , true );
 
     // get output arguments from RPC descriptor
     *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() );
+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 +416 @@
 void rpc_pmem_get_pages_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() );
+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
@@ -134 +425 @@
 
     // get input arguments from client RPC descriptor
-    uint32_t order = hal_remote_lw( XPTR( cxy , &desc->args[0] ) );
+    uint32_t order = (uint32_t)hal_remote_lwd( XPTR( cxy , &desc->args[0] ) );
     
     // call local pmem allocator
@@ -142 +433 @@
     hal_remote_swd( XPTR( cxy , &desc->args[1] ) , (uint64_t)(intptr_t)page );
 
-    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() );
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [1]           Marshaling functions attached to RPC_PROCESS_MAKE_EXEC
+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() );
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [1]       Marshaling functions attached to RPC_PMEM_RELEASE_PAGES (blocking)
+/////////////////////////////////////////////////////////////////////////////////////////
+
+//////////////////////////////////////////////////
+void rpc_pmem_release_pages_client( cxy_t     cxy,
+                                    page_t  * page )      // out 
+{
+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_PMEM_RELEASE_PAGES;
+    rpc.response = 1;
+
+    // set input arguments in RPC descriptor 
+    rpc.args[0] = (uint64_t)(intptr_t)page;
+
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send( cxy , &rpc  , true );
+
+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_pmem_release_pages_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
+    page_t * page = (page_t *)(intptr_t)hal_remote_lwd( XPTR( cxy , &desc->args[0] ) );
+    
+    // release memory to local pmem 
+    kmem_req_t req;
+    req.type = KMEM_PAGE;
+    req.ptr  = page;
+    kmem_free( &req );
+
+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() );
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [2]           Marshaling functions attached to RPC_PROCESS_MAKE_EXEC (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -156 +502 @@
                                    error_t     * error )   // out
 {
-    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() );
+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");
@@ -171 +517 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc  , true );
 
     // get output arguments from RPC descriptor
     *error  = (error_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() );
+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() );
 }
 
@@ -184 +530 @@
 void rpc_process_make_exec_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() );
+
     exec_info_t * ptr;       // local pointer on remote exec_info structure
     exec_info_t   info;      // local copy of exec_info structure
     error_t       error;     // local error error status
-
-    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
@@ -210 +556 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[1] ) , (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() );
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [2]           Marshaling functions attached to RPC_PROCESS_MAKE_FORK 
+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() );
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [3]           Marshaling functions attached to RPC_PROCESS_MAKE_FORK (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -227 +573 @@
                                    error_t   * error )              // out
 {
-    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() );
+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");
@@ -243 +589 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc  , true );
 
     // get output arguments from RPC descriptor
@@ -250 +596 @@
     *error             = (error_t)rpc.args[4];     
 
-    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() );
+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() );
 }
 
@@ -258 +604 @@
 void rpc_process_make_fork_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() );
+
     xptr_t     ref_process_xp;     // extended pointer on reference parent process
     xptr_t     parent_thread_xp;   // extended pointer on parent thread
@@ -264 +614 @@
     error_t    error;              // local error status
 
-    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        client_cxy  = (cxy_t)GET_CXY( xp );
@@ -287 +633 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[4] ) , (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() );
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [3]           Marshaling functions attached to RPC_PROCESS_KILL 
+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() );
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [4]      Marshaling functions attached to RPC_PROCESS_MAKE_EXIT (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
 ///////////////////////////////////////////////////
-void rpc_process_kill_client( process_t * process ) 
-{
-    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() );
-
-    // only reference cluster can send this RPC
-    assert( (GET_CXY( process->ref_xp ) == local_cxy) , __FUNCTION__ ,
-            "caller must be reference process cluster\n");
-
-    // get local process index in reference cluster
-    lpid_t lpid = LPID_FROM_PID( process->pid );
-
-    // get local process manager pointer
-    pmgr_t * pmgr = &LOCAL_CLUSTER->pmgr;
-
-    // get number of copies
-    uint32_t copies = pmgr->copies_nr[lpid];
-
-    // initialise RPC descriptor 
-    rpc_desc_t  rpc;
-    rpc.index    = RPC_PROCESS_KILL;
-    rpc.response = copies;
-    rpc.args[0]  = (uint64_t)process->pid;
-
-    // loop on list of copies to send RPC
-    xptr_t  iter;
-    XLIST_FOREACH( XPTR( local_cxy , &pmgr->copies_root[lpid] ) , iter )
-    {
-        // get cluster_identifier for current copy
-        cxy_t  target_cxy = GET_CXY( iter );
-
-        // register RPC request in remote RPC fifo ... but the reference
-        if( target_cxy != local_cxy ) rpc_send_sync( target_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_process_make_exit_client( cxy_t       cxy,
+                                   process_t * process,
+                                   uint32_t    status ) 
+{
+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_PROCESS_MAKE_EXIT;
+    rpc.response = 1;
+
+    // set input arguments in RPC descriptor  
+    rpc.args[0] = (uint64_t)(intptr_t)process;
+    rpc.args[1] = (uint64_t)status;
+
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send( cxy , &rpc , true );
+
+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_process_kill_server( xptr_t xp )
-{
-    pid_t       pid;
-    process_t * process;  
-
-    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() );
+//////////////////////////////////////////////
+void rpc_process_make_exit_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() );
+
+    process_t * process;
+    uint32_t    status;  
 
     // get client cluster identifier and pointer on RPC descriptor
@@ -352 +684 @@
     rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
 
-    // get pid argument from RPC descriptor
-    pid = (pid_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
-
-    // get process pointer to call local kernel function
-    process = cluster_get_local_process_from_pid( pid );
-
-    if( process == NULL )  // process not found => do nothing
-    {
-        printk("\n[WARNING] in %s : process %x not found in cluster %x\n",
-               __FUNCTION__ , pid , local_cxy );
-    }
-    else                   // destroy process 
-    {
-        process_kill( process ); 
-    }
-
-    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() );
+    // get arguments from RPC descriptor
+    process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    status  = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+
+    // call local kernel function
+    process_make_exit( process , status ); 
+
+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() );
 } 
 
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [4]           Marshaling functions attached to RPC_THREAD_USER_CREATE               
+/////////////////////////////////////////////////////////////////////////////////////////
+// [5]      Marshaling functions attached to RPC_PROCESS_MAKE_KILL (blocking)
+/////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////
+void rpc_process_make_kill_client( cxy_t       cxy,
+                                   process_t * process,
+                                   uint32_t    sig_id ) 
+{
+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_PROCESS_MAKE_KILL;
+    rpc.response = 1;
+
+    // set input arguments in RPC descriptor  
+    rpc.args[0] = (uint64_t)(intptr_t)process;
+    rpc.args[1] = (uint64_t)sig_id;
+
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send( cxy , &rpc , true );
+
+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_process_make_kill_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() );
+
+    process_t * process;
+    uint32_t    sig_id;
+
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
+
+    // get arguments from RPC descriptor
+    process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    sig_id  = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+
+    // call local kernel function
+    process_make_exit( process , sig_id ); 
+
+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() );
+} 
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [6]           Marshaling functions attached to RPC_THREAD_USER_CREATE (blocking)               
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -387 +767 @@
                                     error_t        * error )      // out 
 {
-    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() );
+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");
@@ -404 +784 @@
     rpc.args[3] = (uint64_t)(intptr_t)attr;
 
-    // register RPC request in remote RPC fifo 
-    rpc_send_sync( cxy , &rpc );
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send( cxy , &rpc , true );
 
     // get output arguments from RPC descriptor
@@ -411 +791 @@
     *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() );
+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() );
 }
 
@@ -419 +799 @@
 void rpc_thread_user_create_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() );
+
     pthread_attr_t * attr_ptr;   // pointer on attributes structure in client cluster 
     pthread_attr_t   attr_copy;  // attributes structure  copy in server cluster
@@ -428 +812 @@
     void           * start_arg;
     error_t          error;
-
-    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
@@ -462 +842 @@
     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() );
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [5]           Marshaling functions attached to RPC_THREAD_KERNEL_CREATE
+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() );
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [7]           Marshaling functions attached to RPC_THREAD_KERNEL_CREATE (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -479 +859 @@
                                       error_t * error )      // out
 {
-    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() );
+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");
@@ -495 +875 @@
     rpc.args[2] = (uint64_t)(intptr_t)args;
     
-    // register RPC request in remote RPC fifo 
-    rpc_send_sync( cxy , &rpc );
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send( cxy , &rpc , true );
 
     // get output arguments from RPC descriptor
@@ -502 +882 @@
     *error     = (error_t)rpc.args[4];
 
-    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() );
+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() );
 }
 
@@ -510 +890 @@
 void rpc_thread_kernel_create_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() );
+
     thread_t       * thread_ptr;  // local pointer on thread descriptor
     xptr_t           thread_xp;   // extended pointer on thread descriptor
@@ -515 +899 @@
     error_t          error;    
 
-    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        client_cxy  = (cxy_t)GET_CXY( xp );
@@ -539 +919 @@
     hal_remote_swd( XPTR( client_cxy , &desc->args[2] ) , (uint64_t)thread_xp );
 
-    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() );
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [6]           Marshaling functions attached to RPC_SIGNAL_RISE
+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() );
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [8]           Marshaling functions attached to RPC_THREAD_KILL (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
 /////////////////////////////////////////////
-void rpc_signal_rise_client( cxy_t       cxy,
-                             process_t * process,    // in
-                             uint32_t    sig_id )    // in
-{
-    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_SIGNAL_RISE;
+void rpc_thread_kill_client( cxy_t       cxy,
+                             thread_t  * thread )    // in
+{
+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() );
+
+    // this RPC can be called in local cluster
+
+    // initialise RPC descriptor header 
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_THREAD_KILL;
     rpc.response = 1;
 
     // set input arguments in RPC descriptor 
-    rpc.args[0] = (uint64_t)(intptr_t)process;
-    rpc.args[1] = (uint64_t)sig_id;
+    rpc.args[0] = (uint64_t)(intptr_t)thread;
     
-    // register RPC request in remote RPC fifo 
-    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() );
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send( cxy , &rpc , true );
+
+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_signal_rise_server( xptr_t xp )
-{
-    process_t  * process;  // local pointer on process descriptor
-    uint32_t     sig_id;   // signal index
-
-    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() );
+void rpc_thread_kill_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() );
+
+    thread_t  * thread;  // local pointer on process descriptor
 
     // get client cluster identifier and pointer on RPC descriptor
@@ -591 +968 @@
 
     // get attributes from RPC descriptor
-    process = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
-    sig_id  = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+    thread = (thread_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
 
     // call local kernel function
-    signal_rise( process , sig_id );
-
-    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() );
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-// [10]          Marshaling functions attached to RPC_VFS_INODE_CREATE 
+    thread_kill( thread );
+
+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() );
+}
+
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [9]     Marshaling functions attached to RPC_PROCESS_KILL  (multicast / non blocking)
+/////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////
+void rpc_process_sigaction_client( cxy_t       cxy,
+                                   process_t * process,        // in
+                                   uint32_t    sigaction,      // in
+                                   xptr_t      rsp_xp,         // in
+                                   xptr_t      client_xp )     // in
+{
+signal_dmsg("\n[DBG] %s : enter for %s / thread %x on core[%x,%d] / cycle %d\n",
+__FUNCTION__ , process_action_str( sigaction ) , CURRENT_THREAD ,
+local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
+
+    // initialise RPC descriptor header 
+    rpc_desc_t  rpc;
+    rpc.index    = RPC_PROCESS_SIGACTION;
+
+    // set input arguments in RPC descriptor  
+    rpc.args[0] = (uint64_t)(intptr_t)process;
+    rpc.args[1] = (uint64_t)sigaction;
+    rpc.args[2] = (uint64_t)rsp_xp;
+    rpc.args[3] = (uint64_t)client_xp;
+
+    // register RPC request in remote RPC fifo (non blocking)
+    rpc_send( cxy , &rpc , false );
+
+signal_dmsg("\n[DBG] %s : exit for %s / thread %x on core[%x,%d] / cycle %d\n",
+__FUNCTION__ , process_action_str( sigaction ) , CURRENT_THREAD ,
+local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
+}  
+
+//////////////////////////////////////////////
+void rpc_process_sigaction_server( xptr_t xp )
+{
+    process_t * process;
+    uint32_t    action;  
+    xptr_t      rsp_xp;
+    xptr_t      client_xp;
+
+    // get client cluster identifier and pointer on RPC descriptor
+    cxy_t        client_cxy  = (cxy_t)GET_CXY( xp );
+    rpc_desc_t * desc        = (rpc_desc_t *)GET_PTR( xp );
+
+    // get arguments from RPC descriptor
+    process   = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &desc->args[0] ) );
+    action    = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &desc->args[1] ) );
+    rsp_xp    = (xptr_t)               hal_remote_lwd( XPTR( client_cxy , &desc->args[2] ) );
+    client_xp = (xptr_t)               hal_remote_lwd( XPTR( client_cxy , &desc->args[3] ) );
+    
+signal_dmsg("\n[DBG] %s : enter for %s / thread %x on core[%x,%d] / cycle %d\n",
+__FUNCTION__ , process_action_str( action ) , CURRENT_THREAD ,
+local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
+
+    // call relevant kernel function
+    if      (action == DELETE_ALL_THREADS  ) process_delete ( process , rsp_xp , client_xp ); 
+    else if (action == BLOCK_ALL_THREADS   ) process_block  ( process , rsp_xp , client_xp ); 
+    else if (action == UNBLOCK_ALL_THREADS ) process_unblock( process , rsp_xp , client_xp );
+
+signal_dmsg("\n[DBG] %s : exit for %s / thread %x on core[%x,%d] / cycle %d\n",
+__FUNCTION__ , process_action_str( action ) , CURRENT_THREAD ,
+local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
+} 
+
+/////////////////////////////////////////////////////////////////////////////////////////
+// [10]          Marshaling functions attached to RPC_VFS_INODE_CREATE  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -641 +1083 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     // get output values from RPC descriptor
@@ -705 +1147 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [11]          Marshaling functions attached to RPC_VFS_INODE_DESTROY 
+// [11]          Marshaling functions attached to RPC_VFS_INODE_DESTROY  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -727 +1169 @@
     
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -759 +1201 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [12]          Marshaling functions attached to RPC_VFS_DENTRY_CREATE
+// [12]          Marshaling functions attached to RPC_VFS_DENTRY_CREATE  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -787 +1229 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     // get output values from RPC descriptor
@@ -841 +1283 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [13]          Marshaling functions attached to RPC_VFS_DENTRY_DESTROY 
+// [13]          Marshaling functions attached to RPC_VFS_DENTRY_DESTROY  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -864 +1306 @@
     
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -897 +1339 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [14]          Marshaling functions attached to RPC_VFS_FILE_CREATE
+// [14]          Marshaling functions attached to RPC_VFS_FILE_CREATE  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -923 +1365 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     // get output values from RPC descriptor
@@ -969 +1411 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [15]          Marshaling functions attached to RPC_VFS_FILE_DESTROY 
+// [15]          Marshaling functions attached to RPC_VFS_FILE_DESTROY  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -991 +1433 @@
     
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -1023 +1465 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [16]          Marshaling functions attached to RPC_VFS_INODE_LOAD  
+// [16]          Marshaling functions attached to RPC_VFS_INODE_LOAD   (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1050 +1492 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     // get output values from RPC descriptor
@@ -1099 +1541 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [17]          Marshaling functions attached to RPC_VFS_MAPPER_LOAD_ALL
+// [17]          Marshaling functions attached to RPC_VFS_MAPPER_LOAD_ALL  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1122 +1564 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     // get output values from RPC descriptor
@@ -1161 +1603 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [18]          Marshaling functions attached to RPC_FATFS_GET_CLUSTER 
+// [18]          Marshaling functions attached to RPC_FATFS_GET_CLUSTER  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1189 +1631 @@
 
     // register RPC request in remote RPC fifo 
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     // get output argument from rpc descriptor
@@ -1235 +1677 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [20]          Marshaling functions attached to RPC_VMM_GET_VSEG
+// [20]          Marshaling functions attached to RPC_VMM_GET_VSEG  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1261 +1703 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     // get output argument from rpc descriptor
@@ -1308 +1750 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [21]          Marshaling functions attached to RPC_VMM_GET_PTE 
+// [21]          Marshaling functions attached to RPC_VMM_GET_PTE  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1337 +1779 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     // get output argument from rpc descriptor
@@ -1386 +1828 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [22]          Marshaling functions attached to RPC_KCM_ALLOC 
+// [22]          Marshaling functions attached to RPC_KCM_ALLOC  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1408 +1850 @@
     rpc.args[0] = (uint64_t)kmem_type;
 
-    // register RPC request in remote RPC fifo 
-    rpc_send_sync( cxy , &rpc );
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send( cxy , &rpc , true );
 
     // get output arguments from RPC descriptor
@@ -1449 +1891 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [23]          Marshaling functions attached to RPC_KCM_FREE 
+// [23]          Marshaling functions attached to RPC_KCM_FREE  (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1472 +1914 @@
     rpc.args[1] = (uint64_t)kmem_type;
 
-    // register RPC request in remote RPC fifo 
-    rpc_send_sync( cxy , &rpc );
+    // register RPC request in remote RPC fifo (blocking function)
+    rpc_send( cxy , &rpc , true );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -1540 +1982 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     // get output values from RPC descriptor
@@ -1608 +2050 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [25]          Marshaling functions attached to RPC_MAPPER_GET_PAGE
+// [25]          Marshaling functions attached to RPC_MAPPER_GET_PAGE (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1633 +2075 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     // get output values from RPC descriptor
@@ -1670 +2112 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [26]          Marshaling functions attached to RPC_VMM_CREATE_VSEG
+// [26]          Marshaling functions attached to RPC_VMM_CREATE_VSEG (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1707 +2149 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     // get output values from RPC descriptor
@@ -1757 +2199 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [27]          Marshaling functions attached to RPC_SCHED_DISPLAY
+// [27]          Marshaling functions attached to RPC_SCHED_DISPLAY (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1779 +2221 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -1809 +2251 @@
 
 /////////////////////////////////////////////////////////////////////////////////////////
-// [28]          Marshaling functions attached to RPC_VMM_SET_COW
+// [28]          Marshaling functions attached to RPC_VMM_SET_COW (blocking)
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -1831 +2273 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send_sync( cxy , &rpc );
+    rpc_send( cxy , &rpc , true );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -1862 +2304 @@
 }
 
-/***************************************************************************************/
-/************ Generic functions supporting RPCs : client side **************************/
-/***************************************************************************************/
-
-////////////////////////////////////////////
-void rpc_send_sync( cxy_t        server_cxy, 
-                    rpc_desc_t * rpc )
-{
-    error_t    error;
-
-    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 local pointers are identical in all clusters
-    remote_fifo_t * rpc_fifo = &LOCAL_CLUSTER->rpc_fifo;
-
-        // try to post an item in remote fifo
-    // deschedule and retry if remote fifo full
-    do
-    { 
-        error = remote_fifo_put_item( XPTR( server_cxy , rpc_fifo ),
-                                      (uint64_t )desc_xp );
-            if ( error ) 
-        {
-            printk("\n[WARNING] %s : cluster %x cannot post RPC to cluster %x\n",
-            __FUNCTION__ , local_cxy , server_cxy );
-
-            if( thread_can_yield() ) sched_yield("RPC fifo full");
-        }
-    }
-    while( error );
- 
-    hal_fence();
-        
-    // 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("client blocked on RPC");
-
-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()
-
-
-
-/***************************************************************************************/
-/************ Generic functions supporting RPCs : server side **************************/
-/***************************************************************************************/
-
-////////////////
-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("IPI received");
-
-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
- 
-    // 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 ) )
-        {
-            // 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 );
-                    }
-                        }
-        
-                // 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("RPC fifo empty or too much work");
-
-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()
-
-
+

trunk/kernel/kern/rpc.h

@@ -32 +32 @@
 #include <vseg.h>
 #include <remote_fifo.h>
+#include <signal.h>
 
 /**** Forward declarations ****/
@@ -60 +61 @@
 {
     RPC_PMEM_GET_PAGES         = 0,
-    RPC_PROCESS_MAKE_EXEC      = 1,      
-    RPC_PROCESS_MAKE_FORK      = 2,
-    RPC_PROCESS_KILL           = 3,
-    RPC_THREAD_USER_CREATE     = 4,
-    RPC_THREAD_KERNEL_CREATE   = 5,
-    RPC_SIGNAL_RISE            = 6,
+    RPC_PMEM_RELEASE_PAGES     = 1,
+    RPC_PROCESS_MAKE_EXEC      = 2,      
+    RPC_PROCESS_MAKE_FORK      = 3,
+    RPC_PROCESS_MAKE_EXIT      = 4,
+    RPC_PROCESS_MAKE_KILL      = 5,
+    RPC_THREAD_USER_CREATE     = 6,
+    RPC_THREAD_KERNEL_CREATE   = 7,
+    RPC_THREAD_KILL            = 8,
+    RPC_PROCESS_SIGACTION      = 9,
 
     RPC_VFS_INODE_CREATE       = 10,
@@ -86 +90 @@
     RPC_SCHED_DISPLAY          = 27,
     RPC_VMM_SET_COW            = 28,
+
     RPC_MAX_INDEX              = 30,
 }
@@ -116 +121 @@
 
 /***********************************************************************************
- * This blocking function executes on the client core. 
- * It puts one RPC extended pointer in the remote fifo. 
- * It sends an IPI if fifo is empty, and waits until RPC response available.
- * The RPC descriptor must be allocated in the caller's stack
- * and initialised by the caller.  Exit with a Panic message if remote fifo 
- * is still full after (CONFIG_RPC_PUT_MAX_ITERATIONS) retries.
+ * This function is executed by the client thread in the client cluster. 
+ * It puts one RPC descriptor defined by the <desc> argument in the remote fifo
+ * defined by the <cxy> argument.  It sends an IPI to the server if fifo is empty.
+ * The RPC descriptor must be allocated in the caller's stack, and initialised by
+ * the caller. It exit with a Panic message if remote fifo is still full after 
+ * (CONFIG_RPC_PUT_MAX_ITERATIONS) retries. 
+ * - When the <block> argument is true, this function blocks and deschedule. 
+ *   It returns only when the server acknowledges the RPC by writing in the RPC
+ *   "response" field, and unblocks the client.
+ * - When the <block> argument is false, this function returns as soon as the RPC
+ *   has been registered in the FIFO, and the server thread must directly signal
+ *   completion to the client thread.
  ***********************************************************************************
  * @ cxy   : server cluster identifier
  * @ desc  : local pointer on RPC descriptor in client cluster
- **********************************************************************************/
-void rpc_send_sync( cxy_t        cxy,    
-                    rpc_desc_t * desc );
+ * @ block : boolean true when blocking behaviour is required.
+ **********************************************************************************/
+void rpc_send( cxy_t        cxy,    
+               rpc_desc_t * desc,
+               bool_t       block );
 
 
@@ -186 +199 @@
 
 /***********************************************************************************
- * [1] The RPC_PROCESS_MAKE_EXEC creates a new process descriptor, from an existing
+ * [1] The RPC_PMEM_RELEASE_PAGES release one or several pages to a remote cluster.
+ ***********************************************************************************
+ * @ cxy     : server cluster identifier
+ * @ page    : [in] local pointer on page descriptor to release.
+ **********************************************************************************/
+void rpc_pmem_release_pages_client( cxy_t            cxy,
+                                    struct page_s  * page );
+
+void rpc_pmem_release_pages_server( xptr_t xp );
+
+/***********************************************************************************
+ * [2] The RPC_PROCESS_MAKE_EXEC creates a new process descriptor, from an existing
  * process descriptor in a remote server cluster. This server cluster must be 
  * the owner cluster for the existing process. The new process descriptor is 
@@ -204 +228 @@
 
 /***********************************************************************************
- * [2] The RPC_PROCESS_MAKE_FORK creates a "child" process descriptor, and the
+ * [3] The RPC_PROCESS_MAKE_FORK creates a "child" process descriptor, and the
  * associated "child" thread descriptor in a target remote cluster that can be 
  * any cluster.  The child process is initialized from informations found in the 
@@ -227 +251 @@
 
 /***********************************************************************************
- * [3] The RPC_PROCESS_KILL is actually a multicast RPC sent by the reference cluster
- * to other clusters containing a process descriptor copy, to destroy these copies.
- ***********************************************************************************
- * @ process  : local pointer on target process.
- **********************************************************************************/
-void rpc_process_kill_client( struct process_s * process );
-
-void rpc_process_kill_server( xptr_t xp );
-
-/***********************************************************************************
- * [4] The RPC_THREAD_USER_CREATE creates an user thread in the server cluster,
+ * [4] The RPC_PROCESS_MAKE_EXIT can be called by any thread to request the owner
+ * cluster to execute the process_make_exit() function for a calling process.
+ ***********************************************************************************
+ * @ cxy      : server cluster identifier.
+ * @ process  : local pointer on calling process in owner cluster.
+ * @ status   : calling process exit status.
+ **********************************************************************************/
+void rpc_process_make_exit_client( cxy_t              cxy,
+                                   struct process_s * process,
+                                   uint32_t           status );
+
+void rpc_process_make_exit_server( xptr_t xp );
+
+/***********************************************************************************
+ * [5] The RPC_PROCESS_MAKE_KILL can be called by any thread to request the owner
+ * cluster to execute the process_make_kill() function for a target process.
+ ***********************************************************************************
+ * @ cxy      : server cluster identifier.
+ * @ process  : local pointer on target process in owner cluster.
+ * @ seg_id   : signal type (only SIGKILL / SIGSTOP / SIGCONT are supported).
+ **********************************************************************************/
+void rpc_process_make_kill_client( cxy_t              cxy,
+                                   struct process_s * process,
+                                   uint32_t           seg_id );
+
+void rpc_process_make_kill_server( xptr_t xp );
+
+/***********************************************************************************
+ * [6] The RPC_THREAD_USER_CREATE creates an user thread in the server cluster,
  * as specified by the arguments. It returns an extended pointer on the new
  * thread descriptor in server cluster, and an error code.
@@ -258 +300 @@
 
 /***********************************************************************************
- * [5] The RPC_THREAD_KERNEL_CREATE creates a kernel thread in the server cluster,
+ * [7] The RPC_THREAD_KERNEL_CREATE creates a kernel thread in the server cluster,
  * as specified by the type, func and args arguments. It returns the local pointer
  * on the thread descriptor in server cluster and an error code.
@@ -280 +322 @@
 
 /***********************************************************************************
- * [6] The RPC_SIGNAL_RISE ask a target cluster to register a given signal in
- * all threads descriptors of a given process. 
- * It is used by the sys_kill() function.
+ * [8] The RPC_THREAD_KILL ask a target cluster to kill a given thread descriptor.
+ * It is called by the sys_thread_cancel() function for a remote thread.
  ***********************************************************************************
  * @ cxy       : server cluster identifier.
- * @ process   : [in]  local pointer on target process descriptor in server.
- * @ sig_id    : [in]  signal index.
- **********************************************************************************/
-void rpc_signal_rise_client( cxy_t              cxy,
-                             struct process_s * process,
-                             uint32_t           sig_id );
+ * @ thread   : [in]  local pointer on target process descriptor in server.
+ **********************************************************************************/
+void rpc_thread_kill_client( cxy_t              cxy,
+                             struct thread_s  * thread );
                              
-void rpc_signal_rise_server( xptr_t xp );
+void rpc_thread_kill_server( xptr_t xp );
+
+/***********************************************************************************
+ * [9] The RPC_PROCESS_SIGACTION allows the owner cluster to request any other
+ * cluster to execute a given sigaction (BLOCK / UNBLOCK / DELETE) for all threads
+ * of a given process. 
+ *
+ * WARNING : It is implemented as a NON BLOCKING multicast RPC, that can be sent 
+ * in parallel to all process copies. The various server threads must decrement the
+ * responses counter defined by the <rsp_xp> argument, and the last server thread
+ * must unblock the <client_xp> thread.
+ ***********************************************************************************
+ * @ cxy       : server cluster identifier.
+ * @ process   : [in]  local pointer on target process in server cluster.
+ * @ sigaction : [in]  action type (BLOCK / UNBLOCK / DELETE).
+ * @ rsp_xp    : [in]  extended pointer on response counter.
+ * @ client_xp : [in]  extended pointer on client thread.
+ **********************************************************************************/
+void rpc_process_sigaction_client( cxy_t               cxy,
+                                   struct process_s  * process,
+                                   uint32_t            sigaction,
+                                   xptr_t              rsp_xp,
+                                   xptr_t              client_xp );
+                             
+void rpc_process_sigaction_server( xptr_t xp );
 
 /*********************************************************************************** 

trunk/kernel/kern/scheduler.c

@@ -58 +58 @@
     list_root_init( &sched->k_root );
 
+    sched->sig_pending    = false;            // no pending signal
+
 }  // end sched_init()
 
@@ -72 +74 @@
     if( type == THREAD_USER )
     {
-        // register thread in scheduler user list
         list_add_last( &sched->u_root , &thread->sched_list );
         sched->u_threads_nr++;
-
-        // initialize u_last field if first user thread
         if( sched->u_last == NULL ) sched->u_last = &thread->sched_list;
     }
     else // kernel thread
     {
-        // register thread in scheduler kernel list
         list_add_last( &sched->k_root , &thread->sched_list );
         sched->k_threads_nr++;
-
-        // initialize k_last field if first kernel thread
         if( sched->k_last == NULL ) sched->k_last = &thread->sched_list; 
     }
@@ -92 +88 @@
     spinlock_unlock( &sched->lock );
 
-}  // end sched_register()
+}  // end sched_register_thread()
 
 /////////////////////////////////////////////
 void sched_remove_thread( thread_t * thread )
 {
-    core_t       * core  = thread->core;
-    scheduler_t  * sched = &core->scheduler;
-    thread_type_t  type  = thread->type;
+    scheduler_t * sched = &thread->core->scheduler;
+    thread_type_t type  = thread->type;
 
     // take lock protecting sheduler lists
@@ -106 +101 @@
     if( type == THREAD_USER )
     {
-        // remove thread from user list
         list_unlink( &thread->sched_list );
         sched->u_threads_nr--;
-
-        // reset the u_last field if list empty
         if( sched->u_threads_nr == 0 ) sched->u_last = NULL;
     }
-    else // kernel thread 
-    {
-        // remove thread from kernel list
+    else // kernel thread
+    {
         list_unlink( &thread->sched_list );
         sched->k_threads_nr--;
-
-        // reset the k_last field if list empty
         if( sched->k_threads_nr == 0 ) sched->k_last = NULL;
     }
 
-    // release lock
+    // release lock 
     spinlock_unlock( &sched->lock );
 
-}  // end sched_remove()
+}  // end sched_remove_thread()
 
 //////////////////////////////////////////////
@@ -214 +203 @@
 }  // 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()
-
 //////////////////////////////////////////
 void sched_handle_signals( core_t * core )
@@ -249 +208 @@
     list_entry_t * iter;
     thread_t     * thread;
+
     scheduler_t  * sched = &core->scheduler;
-
-// signal_dmsg("\n@@@ %s enter at cycle %d\n",
-// __FUNCTION__ , hal_time_stamp() );
 
     // take lock protecting threads lists
@@ -261 +218 @@
     {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
-        if( thread->signals ) // sched_kill_thread( thread );
-        {
-            printk("\n[WARNING] %s : thread %x has signal %x at cycle %d\n",
-            __FUNCTION__, thread, thread->signals, hal_time_stamp() );
-        }
-    }
-
-    // handle kernel threads
-    LIST_FOREACH( &sched->k_root , iter )
-    {
-        thread = LIST_ELEMENT( iter , thread_t , sched_list );
-        if( thread->signals )  // sched_kill_thread( thread );
-        {
-            printk("\n[WARNING] %s : thread %x has signal %x at cycle %d\n",
-            __FUNCTION__, thread, thread->signals, hal_time_stamp() );
-
+
+        if( thread->flags & THREAD_FLAG_SIGNAL )  // thread has signal
+        {
+            // decrement response counter to acknowledge signal
+            hal_atomic_add( thread->sig_rsp_count , -1 );
+
+            // reset signal
+            thread_reset_signal( thread );
         }
     }
@@ -283 +232 @@
     spinlock_unlock( &sched->lock );
 
-// signal_dmsg("\n@@@ %s exit at cycle %d\n",
-// __FUNCTION__ , hal_time_stamp() );
-
 } // end sched_handle_signals()
 
@@ -293 +239 @@
     thread_t    * next;
     thread_t    * current = CURRENT_THREAD;
-    scheduler_t * sched   = &current->core->scheduler;
+    core_t      * core    = current->core;
+    scheduler_t * sched   = &core->scheduler;
  
 #if( CONFIG_SCHED_DEBUG & 0x1 )
-if( hal_time_stamp() > CONFIG_SCHED_DEBUG ) sched_display( current->core->lid );
+if( hal_time_stamp() > CONFIG_SCHED_DEBUG ) sched_display( core->lid );
 #endif
 
@@ -319 +266 @@
     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 );
+    next->trdid , thread_type_str(next->type) , local_cxy , core->lid );
 
     // switch contexts and update scheduler state if next != current
@@ -327 +274 @@
 sched_dmsg("\n[DBG] %s : core[%x,%d] / cause = %s\n"
 "      thread %x (%s) (%x,%x) => thread %x (%s) (%x,%x) / cycle %d\n",
-__FUNCTION__, local_cxy, current->core->lid, cause, 
+__FUNCTION__, local_cxy, core->lid, cause, 
 current, thread_type_str(current->type), current->process->pid, current->trdid,
 next   , thread_type_str(next->type)   , next->process->pid   , next->trdid,
@@ -352 +299 @@
 sched_dmsg("\n[DBG] %s : core[%x,%d] / cause = %s\n" 
 "      thread %x (%s) (%x,%x) continue / cycle %d\n",
-__FUNCTION__, local_cxy, current->core->lid, cause,
+__FUNCTION__, local_cxy, core->lid, cause,
 current, thread_type_str(current->type), current->process->pid, current->trdid, 
 (uint32_t)hal_get_cycles() );
 
     }
+
+    // handle signals for all threads executing on this core.
+    sched_handle_signals( core );
 
     // exit critical section / restore SR from next thread context

trunk/kernel/kern/scheduler.h

@@ -49 +49 @@
     struct thread_s * idle;         /*! pointer on idle thread                              */
     struct thread_s * current;      /*! pointer on current running thread                   */
+    bool_t            sig_pending;  /*! signal_handller must be called when true            */
 }
 scheduler_t;
@@ -66 +67 @@
                             struct thread_s * thread );
 
-/********************************************************************************************* 
- *  This function removes a thread from the set of threads attached to a given core.
+/*********************************************************************************************
+ * This function remove a thread from its scheduler.re scheduler.
  *********************************************************************************************
  * @ thread  : local pointer on the thread descriptor.
@@ -87 +88 @@
 /*********************************************************************************************
  * This function scan all threads attached to a given core scheduler, and executes
- * the relevant actions for pending signals, such as the THREAD_SIG_KILL signal.
+ * the relevant actions for pending KILL or EXIT signals.
+ * It is called in by the sched_yield() function, with IRQ disabled. 
  *********************************************************************************************
  * @ core    : local pointer on the core descriptor.
  ********************************************************************************************/
 void sched_handle_signals( struct core_s * core );
-
-/********************************************************************************************* 
- * This function is used by the scheduler of a given core to actually kill a thread that has 
- * 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 removes the thread from the scheduler.
- * - 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.
- ********************************************************************************************/
-void sched_kill_thread( struct thread_s * thread );
 
 /*********************************************************************************************
@@ -123 +113 @@
 
 /********************************************************************************************* 
+ * This function unlink a thread identified by the <thread> pointer from its process. 
+ * It is called by the sched_handle_signals() function when one EXIT or KILL signal is set,
+ * and it implement the first step of a thread destructionebut can also be directly called by a local killer thread signal.
+ * - It detach the thread from the scheduler.
+ * - It detach the thread from the process.
+ * - It detach the thread from the parent thread when the thread is attached.
+ * - It destroys the thread descriptor.
+ * - It acknowledge the killer thread if it's a kill signal
+ *********************************************************************************************
+ * @ thread   : pointer on thread to be killed.
+ ********************************************************************************************/
+void sched_kill_thread( struct thread_s * thread );
+
+/********************************************************************************************* 
  * This function display the internal state of the local core identified by its <lid>.
  *********************************************************************************************

trunk/kernel/kern/signal.c

@@ -2 +2 @@
  * signal.c - signal-management related operations implementation
  * 
- * Author  Alain Greiner    (2016,2017)
+ * Author  Ghassan Almaless (2008,2009,2010,2011,2012)
+ *         Mohamed Lamine Karaoui (2015) 
+ *         Alain Greiner    (2016,2017)
  *
  * Copyright (c) UPMC Sorbonne Universites
@@ -23 +25 @@
 
 #include <hal_types.h>
-#include <hal_atomic.h>
 #include <printk.h>
-#include <thread.h>
-#include <spinlock.h>
 #include <signal.h>
-
-//////////////////////////////////////
-void signal_rise( process_t * process, 
-                  uint32_t    sig_id )
-{
-    // get the lock protecting the set of local threads
-        spinlock_lock( &process->th_lock );
-
-    // loop on local threads
-        thread_t * thread;
-        uint32_t   i;
-        for( i = 0 ; i < process->th_nr ; i++ )
-        {
-                thread = process->th_tbl[i];
-                hal_atomic_or( &thread->signals , (1 << sig_id) );
-
-        signal_dmsg("\n[DBG] %s : thread %x in process %x received signal %d\n",
-                    __FUNCTION__, thread->trdid , process->pid , sig_id );
-        }
-
-    // release the lock
-        spinlock_unlock( &process->th_lock );
-
-}  // end signal_rise()
 
 /*

trunk/kernel/kern/signal.h

@@ -70 +70 @@
 
 #define SIG_DEFAULT_MASK         0xFFEEFFFF
-#define SIG_DEFAULT_STACK_SIZE   2048
+
 
 /****  Forward declarations  ****/

trunk/kernel/kern/thread.c

@@ -112 +112 @@
 /////////////////////////////////////////////////////////////////////////////////////
 // This static function initializes a thread descriptor (kernel or user).
-// It can be called by the four functions:
+// It can be called by the three functions:
 // - thread_user_create()
 // - thread_user_fork()
@@ -164 +164 @@
 
     thread->local_locks     = 0;
-    list_root_init( &thread->locks_root );
-
     thread->remote_locks    = 0;
+
+#if CONFIG_LOCKS_DEBUG 
+    list_root_init( &thread->locks_root );  
     xlist_root_init( XPTR( local_cxy , &thread->xlocks_root ) );
+#endif
 
     thread->u_stack_base    = u_stack_base;
@@ -177 +179 @@
     thread->entry_args      = args;         // thread function arguments
     thread->flags           = 0;            // all flags reset
-    thread->signals         = 0;            // no pending signal
     thread->errno           = 0;            // no error detected
     thread->fork_user       = 0;            // no user defined placement for fork
     thread->fork_cxy        = 0;            // user defined target cluster for fork
-
-    // thread blocked
-    thread->blocked = THREAD_BLOCKED_GLOBAL;
+    thread->blocked         = THREAD_BLOCKED_GLOBAL;
 
     // reset children list
@@ -195 +194 @@
     // reset thread info
     memset( &thread->info , 0 , sizeof(thread_info_t) );
+
+    // initializes join_lock
+    remote_spinlock_init( XPTR( local_cxy , &thread->join_lock ) );
 
     // initialise signature
@@ -296 +298 @@
         return EINVAL;
     }
-
-    // set LOADABLE flag
-    thread->flags = THREAD_FLAG_LOADABLE;
 
     // set DETACHED flag if required
@@ -593 +592 @@
         uint32_t     tm_start;
         uint32_t     tm_end;
-    reg_t        state;
+    reg_t        save_sr;
 
     process_t  * process    = thread->process;
@@ -614 +613 @@
     // release memory allocated for CPU context and FPU context
         hal_cpu_context_destroy( thread );
-        hal_fpu_context_destroy( thread );
+        if ( thread->type == THREAD_USER ) hal_fpu_context_destroy( thread );
         
     // release FPU if required
     // TODO This should be done before calling thread_destroy()
-        hal_disable_irq( &state );
+        hal_disable_irq( &save_sr );
         if( core->fpu_owner == thread )
         {
@@ -624 +623 @@
                 hal_fpu_disable();
         }
-        hal_restore_irq( state );
+        hal_restore_irq( save_sr );
 
     // remove thread from process th_tbl[]
@@ -668 +667 @@
     xlist_add_first( root , entry );
     hal_remote_atomic_add( XPTR( parent_cxy , &parent_ptr->children_nr ) , 1 );
-}
+
+}  // end thread_child_parent_link()
 
 ///////////////////////////////////////////////////
@@ -693 +693 @@
     // release the lock
     remote_spinlock_unlock( lock );
-}
+
+}  // thread_child_parent_unlink()
 
 /////////////////////////////////////////////////
 inline void thread_set_signal( thread_t * thread,
-                               uint32_t   mask )
-{
-    hal_atomic_or( &thread->signals , mask );
+                               uint32_t * sig_rsp_count )
+{
+    reg_t    save_sr;   // for critical section
+
+    // get pointer on thread thread scheduler
+    scheduler_t * thread_sched = &thread->core->scheduler;
+
+    // wait scheduler ready to handle a new signal
+    while( thread_sched->sig_pending ) asm volatile( "nop" );
+    
+    // enter critical section
+    hal_disable_irq( &save_sr );
+      
+    // set signal in thread scheduler
+    thread_sched->sig_pending = true;
+
+    // set signal in thread thread "flags"
+    hal_atomic_or( &thread->flags , THREAD_FLAG_SIGNAL );
+
+    // set pointer on responses counter in thread thread
+    thread->sig_rsp_count = sig_rsp_count;
+    
+    // exit critical section
+    hal_restore_irq( save_sr );
+
     hal_fence();
-}
-
-///////////////////////////////////////////////////
-inline void thread_reset_signal( thread_t * thread,
-                                 uint32_t   mask )
-{
-    hal_atomic_and( &thread->signals , ~mask );
+
+}  // thread_set_signal()
+
+////////////////////////////////////////////////////
+inline void thread_reset_signal( thread_t * thread )
+{
+    reg_t    save_sr;   // for critical section
+
+    // get pointer on target thread scheduler
+    scheduler_t * sched = &thread->core->scheduler;
+
+    // check signal pending in scheduler
+    assert( sched->sig_pending , __FUNCTION__ , "no pending signal" );
+    
+    // enter critical section
+    hal_disable_irq( &save_sr );
+      
+    // reset signal in scheduler
+    sched->sig_pending = false;
+
+    // reset signal in thread "flags"
+    hal_atomic_and( &thread->flags , ~THREAD_FLAG_SIGNAL );
+
+    // reset pointer on responses counter 
+    thread->sig_rsp_count = NULL;
+    
+    // exit critical section
+    hal_restore_irq( save_sr );
+
     hal_fence();
-}
+
+}  // thread_reset_signal()
 
 ////////////////////////////////
@@ -760 +806 @@
 }  // end thread_unblock()
 
-/////////////////////
-error_t thread_exit()
-{
-    reg_t      sr_save;
-
-        thread_t * this = CURRENT_THREAD;
-
-    // test if this thread can be descheduled
-        if( !thread_can_yield() )
-        {
-        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;
-    }
-
-    if( this->flags & THREAD_FLAG_DETACHED )
-    {
-        // if detached set signal and set blocking cause atomically
-        hal_disable_irq( &sr_save );
-        thread_set_signal( this , THREAD_SIG_KILL );
-        thread_block( this , THREAD_BLOCKED_EXIT );
-        hal_restore_irq( sr_save );
-    }
-    else
-    {
-        // if attached, set blocking cause
-        thread_block( this , THREAD_BLOCKED_EXIT );
-    }
-
-    // deschedule
-    sched_yield( "exit" );
-    return 0;
-
-}  // end thread_exit()
-
 /////////////////////////////////////
 void thread_kill( thread_t * target )
 {
-    // set SIG_KILL signal in target thread descriptor
-    thread_set_signal( target , THREAD_SIG_KILL );
+    volatile uint32_t  sig_rsp_count = 1;     // responses counter
+
+    thread_t * killer = CURRENT_THREAD;
+
+kill_dmsg("\n[DBG] %s : killer thread %x enter for target thread %x\n",
+__FUNCTION__, local_cxy, killer->trdid , target trdid );
 
     // set the global blocked bit in target thread descriptor.
     thread_block( target , THREAD_BLOCKED_GLOBAL );
 
-    // send an IPI to schedule the target thread core.
-    dev_pic_send_ipi( local_cxy , target->core->lid );
+    // request target scheduler to deschedule the target thread
+    // when killer thread is not running on same core as target thread
+    if( killer->core->lid != target->core->lid )
+    {
+        // set signal in target thread descriptor and in target scheduler
+        thread_set_signal( target , (uint32_t *)(&sig_rsp_count) );
+
+        // send an IPI to the target thread core.
+        dev_pic_send_ipi( local_cxy , target->core->lid );
+
+        // poll the response
+        while( 1 )
+        {
+            // exit when response received from scheduler
+            if( sig_rsp_count == 0 )  break;
+
+            // deschedule without blocking
+            hal_fixed_delay( 1000 );
+        }
+    }
+
+        // release FPU if required
+        if( target->core->fpu_owner == target )  target->core->fpu_owner = NULL;
+
+    // detach thread from parent if attached
+    if( (target->flags & THREAD_FLAG_DETACHED) == 0 ) 
+    thread_child_parent_unlink( target->parent , XPTR( local_cxy , target ) );
+
+    // detach thread from process
+    process_remove_thread( target );
+
+    // remove thread from scheduler
+    sched_remove_thread( target );
+
+    // release memory allocated to target thread
+    thread_destroy( target );
+
+kill_dmsg("\n[DBG] %s : killer thread %x enter for target thread %x\n",
+__FUNCTION__, local_cxy, killer->trdid , target trdid );
 
 }  // end thread_kill()

trunk/kernel/kern/thread.h

@@ -44 +44 @@
 
 /***************************************************************************************
- * These macros are used to compose or decompose global thread identifier (TRDID)
+ * These macros are used to compose or decompose the global thread identifier (TRDID)
  * to or from cluster identifier / local thread index (CXY , LTID)
  **************************************************************************************/
@@ -69 +69 @@
  **************************************************************************************/
 
-#define THREAD_FLAG_LOADABLE     0x0001  /*! This thread has not been executed yet    */
-#define THREAD_FLAG_DETACHED     0x0002  /*! This thread is detached from parent      */
-#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  /*! Scheduling required for this thread      */
-
-/***************************************************************************************
- * This defines the masks associated to the thread signals.
- **************************************************************************************/
-
-#define THREAD_SIG_KILL          0x0001  /*! This thread killed by another thread     */
-#define THREAD_SIG_SUICIDE       0x0002  /*! This thread required exit                */
+#define THREAD_FLAG_DETACHED     0x0001  /*! This thread is detached from parent      */
+#define THREAD_FLAG_JOIN_DONE    0x0002  /*! Parent thread made a join                */
+#define THREAD_FLAG_SCHED        0x0004  /*! Scheduling required for this thread      */
+#define THREAD_FLAG_SIGNAL       0x0004  /*! Acknowledge of descheduling required     */
 
 /***************************************************************************************
@@ -89 +81 @@
 #define THREAD_BLOCKED_IO        0x0002  /*! thread wait IO operation completion      */
 #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       */
-#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_EXIT      0x0008  /*! thread blocked in join / wait exit       */
+#define THREAD_BLOCKED_JOIN      0x0010  /*! thread blocked in exit / wait join       */
+#define THREAD_BLOCKED_SEM       0x0020  /*! thread wait semaphore                    */
+#define THREAD_BLOCKED_PAGE      0x0040  /*! thread wait page access                  */
+#define THREAD_BLOCKED_USERSYNC  0x0100  /*! thread wait (cond/mutex/barrier)         */
 #define THREAD_BLOCKED_RPC       0x0200  /*! thread wait RPC completion               */
-
-#define THREAD_BLOCKED_DEV_ISR   0x4000  /*! thread DEV wait ISR                      */
+#define THREAD_BLOCKED_DEV_ISR   0x0400  /*! thread DEV wait ISR                      */
 
 /***************************************************************************************
@@ -156 +146 @@
     xptr_t              parent;          /*! extended pointer on parent thread        */
 
-    void              * exit_value;      /*! exit_value used in case of join          */
-
         uint32_t            local_locks;         /*! number of local locks owned by thread    */
-    list_entry_t        locks_root;      /*! root of local locks list                 */
-
-    remote_spinlock_t * flags_lock;      /*! lock protecting the flags                */
-
-        uint32_t            remote_locks;        /*! number of local locks owned by thread    */
-    xlist_entry_t       xlocks_root;     /*! root of remote locks list                */
+        uint32_t            remote_locks;        /*! number of remote locks owned by thread   */
+
+    remote_spinlock_t * join_lock;       /*! lock protecting the join/exit            */
+    void              * join_value;      /*! exit_value used in case of join          */
+    xptr_t              join_xp;         /*! extended pointer on joining thread       */
+
+    uint32_t          * sig_rsp_count;   /*! pointer on signal response counter       */
 
         intptr_t            u_stack_base;    /*! user stack base address                  */
@@ -173 +162 @@
 
     uint32_t            flags;           /*! bit vector of flags                      */
-    uint32_t            signals;         /*! bit vector of (KILL / SUICIDE) signals   */
     uint32_t            blocked;         /*! bit vector of blocking causes            */
 
@@ -203 +191 @@
 
     xlist_entry_t       wait_list;       /*! member of threads blocked on same cond   */
+
+#if CONFIG_LOCKS_DEBUG
+    list_entry_t        locks_root;      /*! root of list of locks taken              */
+    xlist_entry_t       xlocks_root;     /*! root of xlist of remote locks taken      */
+#endif
 
         thread_info_t       info;            /*! embedded thread_info_t                   */
@@ -311 +304 @@
 
 /***************************************************************************************
- * This function releases the physical memory allocated for a thread descriptor
- * in the local cluster. It can be used for both an user and a kernel thread.
- * The physical memory dynamically allocated in the HEAP or MMAP zones by an user
- * thread will be released when the process is killed, and the page table flushed.
+ * This function releases the physical memory allocated for a thread in a given cluster.
+ * This include the thread descriptor itself, the associated CPU and FPU context, and
+ * the physical memory allocated for an user thread local stack.
  ***************************************************************************************
  * @ thread  : pointer on the thread descriptor to release.
@@ -353 +345 @@
 
 /***************************************************************************************
- * This function atomically sets a signal in a thread descriptor.
+ * This function is used by a killer thread running in the same cluster as a target
+ * thread to request the scheduler of the target to call the thread_handle_signal()
+ * at the next context switch, to confirm that the target thread is blocked and
+ * not currently running. This function executes atomically the following actions :
+ * - it set the sig_pending flag in the target scheduler descriptor.
+ * - it set the SIG flag in the "flags" field of the target thread descriptor.
+ * - It registers the responses counter pointer in the target thread descriptor.
+ * The sig_pending flag is handled as a set/reset flip-flop by the killer thread
+ * and by the target scheduler. 
+ ***************************************************************************************
+ * @ target        : local pointer on target thread.
+ * @ sig_rsp_count : local pointer on responses counter.
+ **************************************************************************************/
+void thread_set_signal( thread_t * thread,
+                        uint32_t * sig_rsp_count );
+
+/***************************************************************************************
+ * This function is used by the sched_handle_signal() function executed by a scheduler
+ * to reset a pending signal in both a target <thread> descriptor, and in the target
+ * thread scheduler.
  ***************************************************************************************
  * @ thread    : local pointer on target thread.
- *s released all locks @ mask      : mask on selected signal.
- **************************************************************************************/
-inline void thread_set_signal( thread_t * thread,
-                               uint32_t   mask );
-
-/***************************************************************************************
- * This function resets a signal in a thread descriptor.
- ***************************************************************************************
- * @ thread    : local pointer on target thread.
- * @ mask      : mask on selected signal.
- **************************************************************************************/
-inline void thread_reset_signal( thread_t * thread,
-                                 uint32_t   mask );
+ **************************************************************************************/
+void thread_reset_signal( thread_t * thread );
 
 /***************************************************************************************
@@ -385 +385 @@
 
 /***************************************************************************************
- * 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.
- **************************************************************************************/
-error_t thread_exit();
-
-/***************************************************************************************
- * 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.
+ * This function is called to handle the "pthread_cancel" system call.
+ * It allows a killer thread to kill one single target thread.
+ * The killer thread must be running in the same cluster as the target thread.
+ * If not, the client thread must use the RPC_THREAD_KILL.
+ * - When the killer thread is running on the same core as the target thread,
+ *   This function simply detach the target thread from the scheduler,
+ *   detach it from the parent thread if it is attached, detach it from the 
+ *   local process descriptor, and rrleases all memory allocated to the thread.
+ * - When the killer thread is running on a different core than the target thread
+ *   The killer send a signal to the target thread scheduler requesting this
+ *   scheduler to confirm that the target thread is blocked and not running.
+ *   Then, it executes the same actions as described above.
  ***************************************************************************************
  * @ thread   : local pointer on the target thread.