Index: trunk/kernel/kern/rpc.h
===================================================================
--- trunk/kernel/kern/rpc.h	(revision 409)
+++ trunk/kernel/kern/rpc.h	(revision 416)
@@ -109,7 +109,8 @@
 {
 	rpc_index_t         index;       /*! index of requested RPC service           */
-	volatile uint32_t   response;    /*! response valid when 0                    */
+	volatile uint32_t   response;    /*! all responses received when 0            */
     struct thread_s   * thread;      /*! local pointer on client thread           */
     uint32_t            lid;         /*! index of core running the calling thread */ 
+    bool_t              blocking;    /*! blocking RPC when true                   */
     uint64_t            args[10];    /*! input/output arguments buffer            */
 } 
@@ -127,8 +128,8 @@
  * 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. 
+ * - When the RPC <blocking> field 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
+ * - When the <blocking> field 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.
@@ -136,9 +137,7 @@
  * @ cxy   : server cluster identifier
  * @ desc  : local pointer on RPC descriptor in client cluster
- * @ block : boolean true when blocking behaviour is required.
  **********************************************************************************/
 void rpc_send( cxy_t        cxy,    
-               rpc_desc_t * desc,
-               bool_t       block );
+               rpc_desc_t * desc );
 
 
@@ -252,12 +251,12 @@
 /***********************************************************************************
  * [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.
+ * cluster to execute the process_make_exit() function for the target process.
+ ***********************************************************************************
+ * @ cxy      : owner cluster identifier.
+ * @ pid      : target process identifier.
  * @ status   : calling process exit status.
  **********************************************************************************/
 void rpc_process_make_exit_client( cxy_t              cxy,
-                                   struct process_s * process,
+                                   pid_t              pid,
                                    uint32_t           status );
 
@@ -268,10 +267,10 @@
  * 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.
+ * @ cxy      : owner cluster identifier.
+ * @ pid      : target process identifier.
  * @ seg_id   : signal type (only SIGKILL / SIGSTOP / SIGCONT are supported).
  **********************************************************************************/
 void rpc_process_make_kill_client( cxy_t              cxy,
-                                   struct process_s * process,
+                                   pid_t              pid,
                                    uint32_t           seg_id );
 
@@ -339,19 +338,17 @@
  *
  * 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.
+ * in parallel to all process copies. The rpc descriptor is allocated in the client
+ * thread stack by the process_sigaction() function. The various server threads 
+ * must decrement the responses counter defined in the rsp descriptor, and the last
+ * server thread unblock the client thread that blocked (after sending all RPC
+ * requests) in the process_sigaction() function.
+ * - The first RPC argument is the sigaction type (BLOCK / UNBLOCK / DELETE).
+ * - The second RPC argument is the local pointer on target process.
  ***********************************************************************************
  * @ 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 );
+ * @ rpc_ptr   : [in]  local pointer on rpc descriptor in client cluster.
+ **********************************************************************************/
+void rpc_process_sigaction_client( cxy_t        cxy,
+                                   rpc_desc_t * rpc_ptr );
                              
 void rpc_process_sigaction_server( xptr_t xp );
