Changeset 416 for trunk/kernel/kern

Timestamp:

Jan 4, 2018, 10:05:47 AM (7 years ago)

Author:

alain

Message:

Improve sys_exec.

Location:

trunk/kernel/kern

Files:

• cluster.c (modified) (4 diffs)
• cluster.h (modified) (1 diff)
• process.c (modified) (24 diffs)
• process.h (modified) (4 diffs)
• rpc.c (modified) (69 diffs)
• rpc.h (modified) (6 diffs)
• scheduler.c (modified) (8 diffs)
• scheduler.h (modified) (4 diffs)
• thread.c (modified) (8 diffs)
• thread.h (modified) (5 diffs)

trunk/kernel/kern/cluster.c

@@ -228 +228 @@
 }
 
-////////////////////////////////////////////////
-error_t cluster_pid_alloc( xptr_t    process_xp,
-                           pid_t   * pid )
-{
-    error_t     error;
+///////////////////////////////////////////////
+error_t cluster_pid_alloc( process_t * process,
+                           pid_t     * pid )
+{
     lpid_t      lpid;
     bool_t      found;
@@ -255 +254 @@
     {
         // register process in pref_tbl[]
-        pm->pref_tbl[lpid] = process_xp;
+        pm->pref_tbl[lpid] = XPTR( local_cxy , process );
         pm->pref_nr++;
 
@@ -261 +260 @@
         *pid = PID( local_cxy , lpid );
 
-        error = 0;
+        // release the processs_manager lock
+        spinlock_unlock( &pm->pref_lock );
+
+        return 0;
     }
     else
     {
-        error = EAGAIN;
-    }
-
-    // release the processs_manager lock
-    spinlock_unlock( &pm->pref_lock );
-
-    return error;
+        // release the processs_manager lock
+        spinlock_unlock( &pm->pref_lock );
+
+        return -1;
+    }
 
 } // end cluster_pid_alloc()
@@ -286 +286 @@
     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

@@ -197 +197 @@
  * It registers the process descriptor extended pointer in the local processs manager
  * pref_tbl[] array. This function is called by the process_make_fork() function, 
- * or by the process_init_create() function.
- ******************************************************************************************
- * @ process    : [in]  extended pointer on the process descriptor.
+ * by the process_make_exec() function, and by the process_init_create() function.
+ ******************************************************************************************
+ * @ process    : pointer on process descriptor.
  * @ pid        : [out] allocated PID.
- * @ return 0 if success / return EAGAIN if no PID slot available
- *****************************************************************************************/
-error_t cluster_pid_alloc( xptr_t    process_xp,
-                           pid_t   * pid );
+ * @ return 0 if success / return -1 if no PID slot available.
+ *****************************************************************************************/
+error_t cluster_pid_alloc( struct process_s * process,
+                           pid_t            * pid );
 
 /******************************************************************************************

trunk/kernel/kern/process.c

@@ -337 +337 @@
     pmgr_t * pmgr = &LOCAL_CLUSTER->pmgr;
 
-    // get the lock protecting the list of local process descriptors
+    // remove the process descriptor from local_list in cluster manager
     remote_spinlock_lock( XPTR( local_cxy , &pmgr->local_lock ) );
-
-    // remove the process descriptor from local_list in local cluster manager
     xlist_unlink( XPTR( local_cxy , &process->local_list ) );
-
-    // release the lock protecting the list of local process descriptors
     remote_spinlock_unlock( XPTR( local_cxy , &pmgr->local_lock ) );
 
@@ -356 +352 @@
     remote_spinlock_unlock( copies_lock );
 
+    // release the process PID to cluster manager
+    cluster_pid_release( process->pid );
+
         hal_fence();
 
@@ -370 +369 @@
     vmm_destroy( process );
 
-        process_dmsg("\n[DBG] %s for pid %d / page_faults = %d\n",
-                 __FUNCTION__ , process->pid, process->vmm.pgfault_nr );
+    // release memory allocated to process descriptor
+    process_free( process );
 
 }  // end process_destroy()
@@ -393 +392 @@
     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
-
-sigaction_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 );
+    uint32_t           responses;         // number of remote process copies
+    uint32_t           rsp_count;         // used to assert number of copies
+
+    rpc_desc_t         rpc;               // rpc descriptor allocated in stack
+
+sigaction_dmsg("\n[DBG] %s : enter to %s process %x in cluster %x\n",
+__FUNCTION__ , process_action_str( action_type ) , process->pid , local_cxy );
+
+    thread_t         * client = CURRENT_THREAD;
+    xptr_t             client_xp = XPTR( local_cxy , client );
+
+    // get local pointer on local cluster manager
+    cluster = LOCAL_CLUSTER;
 
     // get owner cluster identifier and process lpid
@@ -414 +414 @@
     lpid      = LPID_FROM_PID( process->pid );
 
-    assert( (owner_cxy == local_cxy) , __FUNCTION__ , "illegal cluster\n" ); 
+    // check owner cluster
+    assert( (owner_cxy == local_cxy) , __FUNCTION__ ,
+    "must be executed in the owner cluster\n" ); 
    
-    // get local pointer on local cluster manager
-    cluster = LOCAL_CLUSTER;
+    // get number of remote copies
+    responses = cluster->pmgr.copies_nr[lpid] - 1;
+    rsp_count = 0;
+
+    // check action type
+    assert( ((action_type == DELETE_ALL_THREADS ) ||
+             (action_type == BLOCK_ALL_THREADS )  ||
+             (action_type == UNBLOCK_ALL_THREADS )),
+             __FUNCTION__ , "illegal action type" );
+             
+    // initialise rpc descriptor
+    rpc.index    = RPC_PROCESS_SIGACTION;
+    rpc.response = responses;
+    rpc.blocking = false;
+    rpc.thread   = client;
 
     // get extended pointers on copies root, copies lock, and number of copies
@@ -423 +438 @@
     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
+    // send RPCs to remote clusters
     XLIST_FOREACH( root_xp , iter_xp )
     {
@@ -436 +448 @@
         process_ptr = (process_t *)GET_PTR( process_xp );
 
-sigaction_dmsg("\n[DBG] %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 );
+        // send RPC to remote clusters
+        if( process_cxy != local_cxy )  
+        {
+
+sigaction_dmsg("\n[DBG] %s : send RPC to remote cluster %x\n",
+__FUNCTION__ , process_cxy );
+
+            rpc.args[0] = (uint64_t)action_type;
+            rpc.args[1] = (uint64_t)(intptr_t)process_ptr;
+            rpc_process_sigaction_client( process_cxy , &rpc );
+            rsp_count++;
+        }
     }
    
@@ -449 +465 @@
     remote_spinlock_unlock( lock_xp );
 
-    // block and deschedule to wait response
-    thread_block( CURRENT_THREAD , THREAD_BLOCKED_RPC );
-    sched_yield("BLOCKED on RPC");
-
-sigaction_dmsg("\n[DBG] %s : exit for signal %s to process %x in cluster %x\n",
-__FUNCTION__ , process_action_str( action_type ) , process , local_cxy );
+    // check number of copies...
+    assert( (rsp_count == responses) , __FUNCTION__ ,
+    "unconsistent number of process copies : rsp_count = %d / responses = %d",
+    rsp_count , responses );
+
+    // block and deschedule to wait RPC responses if required
+    if( responses )
+    {   
+        thread_block( CURRENT_THREAD , THREAD_BLOCKED_RPC );
+        sched_yield("BLOCKED on RPC_PROCESS_SIGACTION");
+    }
+
+sigaction_dmsg("\n[DBG] %s : make action in owner cluster %x\n",
+__FUNCTION__ , local_cxy );
+
+
+    // call directly the relevant function in local owner cluster
+    if      (action_type == DELETE_ALL_THREADS  ) process_delete ( process , client_xp ); 
+    else if (action_type == BLOCK_ALL_THREADS   ) process_block  ( process , client_xp ); 
+    else if (action_type == UNBLOCK_ALL_THREADS ) process_unblock( process             );
+
+sigaction_dmsg("\n[DBG] %s : exit after %s process %x in cluster %x\n",
+__FUNCTION__ , process_action_str( action_type ) , process->pid , local_cxy );
 
 }  // end process_sigaction()
@@ -460 +493 @@
 ////////////////////////////////////////
 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
+    thread_t          * requester;      // requesting 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;
+    volatile uint32_t   rsp_count;      // responses counter
+
+    // get calling thread pointer
+    requester = CURRENT_THREAD;
 
 sigaction_dmsg("\n[DBG] %s : enter for process %x in cluster %x\n",
@@ -482 +511 @@
 
     // initialize local responses counter 
-    sig_rsp_count = process->th_nr;
+    rsp_count = process->th_nr;
 
     // loop on process threads to block and deschedule all threads in cluster
@@ -494 +523 @@
             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 )
+            // - if the target thread is the client thread, we do nothing,
+            //   and simply decrement the responses counter.
+            // - if the calling thread and the target thread are on the same core,
+            //   we block the target thread, we don't ask ask anything to the scheduler,
+            //   and simply decrement the responses counter.
+            // - if the calling thread and the target thread are not running on the same
+            //   core, we ask the target scheduler to acknowlege the blocking
+            //   to be sure that the target thread is not running.
+            
+            if( XPTR( local_cxy , target ) == client_xp )
             {
+                // decrement responses counter
+                hal_atomic_add( (void *)&rsp_count , -1 );
+            }
+            else if( requester->core->lid == target->core->lid )
+            {
+                // set the global blocked bit in target thread descriptor.
+                thread_block( target , THREAD_BLOCKED_GLOBAL );
+
+                // decrement responses counter
+                hal_atomic_add( (void *)&rsp_count , -1 );
+            }
+            else
+            {
+                // set the global blocked bit in target thread descriptor.
+                thread_block( target , THREAD_BLOCKED_GLOBAL );
+
+                // set FLAG_REQ_ACK and &ack_rsp_count in target descriptor
+                thread_set_req_ack( target , (void *)&rsp_count );
+
+                // force scheduling on target thread
                 dev_pic_send_ipi( local_cxy , target->core->lid );
             }
-            else                                                         
-            {
-                hal_atomic_add( (void *)&sig_rsp_count , -1 );
-            }
         }
     }
 
-    // poll the reponses counter 
+    // get lock protecting process th_tbl[]
+    spinlock_unlock( &process->th_lock );
+
+    // wait all responses from schedulers 
     while( 1 )
     {
-        // exit loop when all responses received
-        if ( sig_rsp_count == 0 ) break;
+        // exit loop when all local responses received
+        if ( rsp_count == 0 ) break;
     
         // wait 1000 cycles before retry
@@ -526 +572 @@
     }
 
-    // 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 );
-    }
-
 sigaction_dmsg("\n[DBG] %s : exit for process %x in cluster %x / %d threads blocked\n",
 __FUNCTION__ , process->pid , local_cxy , count );
@@ -541 +577 @@
 }  // end process_block()
 
-//////////////////////////////////////////
-void process_unblock( process_t * process,
-                      xptr_t      rsp_xp,
-                      xptr_t      client_xp )
+///////////////////////////////////////////
+void process_unblock( process_t * process )
 {
     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;
+    uint32_t            count;         // requests counter
 
 sigaction_dmsg("\n[DBG] %s : enter for process %x in cluster %x\n",
@@ -564 +591 @@
 
     // 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++ )
+    // 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];
@@ -573 +598 @@
         if( target != NULL )             // thread found
         {
-            req_count++;
+            count++;
 
             // reset the global blocked bit in target thread descriptor.
@@ -580 +605 @@
     }
 
-    // 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 );
-    }
+    // get lock protecting process th_tbl[]
+    spinlock_unlock( &process->th_lock );
 
 sigaction_dmsg("\n[DBG] %s : exit for process %x in cluster %x / %d threads blocked\n",
-__FUNCTION__ , process->pid , local_cxy , req_count );
+__FUNCTION__ , process->pid , local_cxy , count );
 
 }  // end process_unblock()
@@ -597 +615 @@
 /////////////////////////////////////////
 void process_delete( process_t * process,
-                     xptr_t      rsp_xp,
                      xptr_t      client_xp )
 {
-    thread_t          * thread;        // pointer on target thread 
+    thread_t          * target;        // 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;
+    thread_t          * requester;     // pointer on calling thread 
 
 sigaction_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
+__FUNCTION__ , process->pid , local_cxy , (uint32_t)hal_get_cycles() );
+
+    // get calling thread pointer
+    requester = CURRENT_THREAD;
+
+    // get lock protecting process th_tbl[]
+    spinlock_lock( &process->th_lock );
+
+    // loop on threads to set the REQ_DELETE flag
+    // we use both "ltid" and "count" because it can exist "holes" in th_tbl
     for( ltid = 0 , count = 0  ; count < process->th_nr ; ltid++ )
     {
-        thread = process->th_tbl[ltid];
-
-        if( thread != NULL )             // thread found
+        target = process->th_tbl[ltid];
+
+        if( target != NULL )             // thread found
         {
             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 );
+            // delete only if the target is not the client
+            if( XPTR( local_cxy , target ) != client_xp ) 
+            { 
+                hal_atomic_or( &target->flags , THREAD_FLAG_REQ_DELETE );
+            }
         }
     }
 
-    // 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 );
-    }
+    // get lock protecting process th_tbl[]
+    spinlock_unlock( &process->th_lock );
 
 sigaction_dmsg("\n[DBG] %s : exit for process %x in cluster %x at cycle %d\n",
-__FUNCTION__ , pid , local_cxy , (uint32_t)hal_get_cycles() );
+__FUNCTION__ , process->pid , local_cxy , (uint32_t)hal_get_cycles() );
 
 }  // end process_delete()
@@ -951 +951 @@
 
     // allocate a child PID from local cluster
-    error = cluster_pid_alloc( XPTR( local_cxy , process ) , &new_pid );
+    error = cluster_pid_alloc( process , &new_pid );
     if( (error != 0) || (new_pid == 0) )
     {
@@ -1037 +1037 @@
     return 0;
 
-}  // end process_make_fork()
-
-/*  deprecated because we don't wand to destroy the existing process descriptor
+}   // end process_make_fork()
+
 
 /////////////////////////////////////////////////////
@@ -1045 +1044 @@
 {
     char           * path;                    // pathname to .elf file
-    process_t      * old;                     // local pointer on old process
-    process_t      * new;                     // local pointer on new process
-    pid_t            pid;                     // old process identifier
-    thread_t       * thread;                  // pointer on new thread
+    process_t      * old_process;             // local pointer on old process
+    process_t      * new_process;             // local pointer on new process
+    pid_t            old_pid;                 // old process identifier
+    pid_t            new_pid;                 // new (temporary) process identifier
+    thread_t       * old_thread;              // pointer on new thread
+    thread_t       * new_thread;              // pointer on new thread
     pthread_attr_t   attr;                    // main thread attributes
     lid_t            lid;                     // selected core local index
@@ -1054 +1055 @@
 
         // 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 );
+        path     = exec_info->path;
+    old_pid  = exec_info->pid;
+
+    // this function must be executed by a thread running in owner cluster
+    assert( (CXY_FROM_PID( old_pid ) == local_cxy), __FUNCTION__,
+    "local cluster %x is not owner for process %x\n", local_cxy, old_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 old process local pointer
-    old = (process_t *)cluster_get_local_process_from_pid( pid );
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, old_pid , path );
+
+    // get old process and thread local pointers
+    old_process = (process_t *)cluster_get_local_process_from_pid( old_pid );
+    old_thread  = CURRENT_THREAD;
     
-    assert( (old != NULL ) , __FUNCTION__ , 
-    "process %x not found in cluster %x\n", pid , local_cxy ); 
+    if( old_process == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot get old process descriptor\n", __FUNCTION__ );
+        return -1;
+    }
 
     // allocate memory for new process descriptor
-    new = process_alloc();
+    new_process = process_alloc();
+
+    if( new_process == NULL )
+    {
+        printk("\n[ERROR] in %s : cannot allocate new process descriptor\n", __FUNCTION__ );
+        return -1;
+    }
+
+    // get a (temporary) PID for new process
+    error = cluster_pid_alloc( new_process , &new_pid );
+
+    if( error )
+    {
+        printk("\n[ERROR] in %s : cannot allocate a temporary PID\n", __FUNCTION__ );
+        process_destroy( new_process );
+        return -1;
+    }
 
     // initialize new process descriptor
-    process_reference_init( new,
-                            old->pid,                   // same as old
-                            old->ppid,                  // same as old
-                            XPTR( local_cxy , old ) );
+    process_reference_init( new_process,
+                            new_pid,                            // temporary PID
+                            old_process->ppid,                  // same parent
+                            XPTR( local_cxy , old_process ) );
 
 exec_dmsg("\n[DBG] %s : core[%x,%d] created new process %x / path = %s\n",
-__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid, path );
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, new_pid, path );
 
     // register "code" and "data" vsegs as well as entry-point
     // in new process VMM, using information contained in the elf file.
-        if( elf_load_process( path , new ) )
+        if( elf_load_process( path , new_process ) )
         {
                 printk("\n[ERROR] in %s : failed to access .elf file for process %x / path = %s\n",
-                __FUNCTION__, pid , path );
-        process_destroy( new );
+                __FUNCTION__, new_pid , path );
+        cluster_pid_release( new_pid );
+        process_destroy( new_process );
         return -1;
         }
@@ -1104 +1126 @@
 
     // create and initialize thread descriptor
-        error = thread_user_create( pid,
-                                (void *)new->vmm.entry_point,
+        error = thread_user_create( new_pid,
+                                (void *)new_process->vmm.entry_point,
                                 exec_info->args_pointers,
                                 &attr,
-                                &thread );
+                                &new_thread );
         if( error )
         {
                 printk("\n[ERROR] in %s : cannot create thread for process %x / path = %s\n",
-                       __FUNCTION__, pid , path );
-        process_destroy( new );
+            __FUNCTION__, new_pid , path );
+        cluster_pid_release( new_pid );
+        process_destroy( new_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 );
-
-    // update children list (rooted in parent process)
-        xlist_replace( XPTR( local_cxy , &old->brothers_list ) ,
-                   XPTR( local_cxy , &new->brothers_list ) );
-
-    // request destruction of old process copies and threads in all clusters
-    process_sigaction( old , SIGKILL );
-
+exec_dmsg("\n[DBG] %s : core[%x,%d] created main thread %x\n",
+__FUNCTION__ , local_cxy, CURRENT_THREAD->core->lid, new_thread->trdid );
+
+    // update children list rooted in parent process
+        xlist_replace( XPTR( local_cxy , &old_process->brothers_list ) ,
+                   XPTR( local_cxy , &new_process->brothers_list ) );
+
+    // request blocking for all threads in old process (but the calling thread)
+    process_sigaction( old_process , BLOCK_ALL_THREADS );
+
+    // request destruction for all threads in old process (but the calling thread)
+    process_sigaction( old_process , DELETE_ALL_THREADS );
+
+    // update PID for both processes 
+    new_process->pid = old_pid;
+    old_process->pid = 0xFFFFFFFF;
+
+    // release temporary PID
+    cluster_pid_release( new_pid );
+    
     // activate new thread
-        thread_unblock( XPTR( local_cxy , thread ) , THREAD_BLOCKED_GLOBAL );
+        thread_unblock( XPTR( local_cxy , new_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  );
 
+    // set BLOCKED_GLOBAL bit
+    thread_block( old_thread , THREAD_BLOCKED_GLOBAL );
+
+    // set REQ_DELETE flag
+    hal_atomic_or( &old_thread->flags , THREAD_FLAG_REQ_DELETE );
+
+    // deschedule
+    sched_yield("suicide after exec"); 
+
+    // never executed but required by compiler
         return 0;
 
 }  // 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 );
-
-    // initialize VMM 
-    error = vmm_init( process );
-        {
-                printk("\n[ERROR] in %s : cannot initialize VMM for process %x / path = %s\n",
-                __FUNCTION__, pid , path );
-        process_destroy( process );
-        return -1;
-        }
-
-    if( error )
-
-    // register "code" and "data" vsegs as well as entry-point and vfs_bin_xp
-    // in VMM, using information contained in the elf file.
-        error = elf_load_process( path , process );
-
-    if( error )
-        {
-                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 )
+///////////////////////////////////////
+void process_make_kill( pid_t      pid,
+                        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__ ,
+    assert( (CXY_FROM_PID( pid ) == local_cxy) , __FUNCTION__ ,
     "must execute in owner cluster" );
+
+kill_dmsg("\n[DBG] %s : core[%x,%d] enter / process %x / sig %d\n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid , sig_id );
+
+    // get pointer on local process descriptor
+    process_t * process = process_get_local_copy( pid );
+
+    // does nothing if process does not exist
+    if( process == NULL )
+    {
+        printk("\n[WARNING] %s : process %x does not exist => do nothing\n",
+        __FUNCTION__ , pid );
+        return;
+    }
 
     // analyse signal type
     switch( sig_id )
     {
-        case SIGSTOP:     // block all threads
+        case SIGSTOP:     // block all threads in all clusters
         {
             process_sigaction( process , BLOCK_ALL_THREADS );
         }
         break;
-        case SIGCONT:     // unblock all threads
+        case SIGCONT:     // unblock all threads in all clusters
         {
             process_sigaction( process , UNBLOCK_ALL_THREADS );
@@ -1273 +1217 @@
         case SIGKILL:  // block all threads, then delete all threads
         {
+            // block all threads (but the calling thread)
             process_sigaction( process , BLOCK_ALL_THREADS );
+
+            // delete all threads (but the calling thread)
             process_sigaction( process , DELETE_ALL_THREADS );
-            process_destroy( process );
+
+            // delete the calling thread if required
+            thread_t * this = CURRENT_THREAD;
+
+            if( this->process == process )
+            {
+                // set REQ_DELETE flag
+                hal_atomic_or( &this->flags , THREAD_FLAG_REQ_DELETE );
+
+                // deschedule
+                sched_yield( "suicide after kill" ); 
+            }
         }
         break;
     }
+
+//@@@
+sched_display( 0 );
+//@@@
+
+kill_dmsg("\n[DBG] %s : core[%x,%d] exit / process %x / sig %d \n",
+__FUNCTION__, local_cxy, CURRENT_THREAD->core->lid, pid , sig_id );
+
 }  // end process_make_kill()
 
-////////////////////////////////////////////
-void process_make_exit( process_t * process,
+/////////////////////////////////////////
+void process_make_exit( pid_t       pid,
                         uint32_t    status )
 {
     // this function must be executed by a thread running in owner cluster
-    assert( (CXY_FROM_PID( process->pid ) == local_cxy) , __FUNCTION__ ,
+    assert( (CXY_FROM_PID( pid ) == local_cxy) , __FUNCTION__ ,
     "must execute in owner cluster" );
 
-    // block all threads in all clusters
+    // get pointer on local process descriptor
+    process_t * process = process_get_local_copy( pid );
+
+    // does nothing if process does not exist
+    if( process == NULL )
+    {
+        printk("\n[WARNING] %s : process %x does not exist => do nothing\n",
+        __FUNCTION__ , pid );
+        return;
+    }
+
+    // block all threads in all clusters (but the calling thread)
     process_sigaction( process , BLOCK_ALL_THREADS );
 
-    // delete all threads in all clusters
+    // delete all threads in all clusters (but the calling thread)
     process_sigaction( process , DELETE_ALL_THREADS );
 
-    // delete local process descriptor
-    process_destroy( process ); 
+    // delete the calling thread 
+    hal_atomic_or( &CURRENT_THREAD->flags , THREAD_FLAG_REQ_DELETE );
+
+    // deschedule
+    sched_yield( "suicide after exit" ); 
 
 }  // end process_make_exit()
@@ -1322 +1302 @@
 
     // get PID from local cluster
-    error = cluster_pid_alloc( XPTR( local_cxy , process ) , &pid );
+    error = cluster_pid_alloc( process , &pid );
     if( error )
     {

trunk/kernel/kern/process.h

@@ -267 +267 @@
 
 /*********************************************************************************************
- * 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.
- * @ action_type   : BLOCK_ALL_THREADS / UNBLOCK_ALL_THREADS / DELETE_ALL_THREADS
+ * This function allows a client thread running in the owner cluster of a process identified
+ * by the <process> argument to block, unblock or delete all threads of the target process,
+ * depending on the <action_type> argument.  The scenario is the following:
+ * - It uses the multicast, non blocking rpc_process_sigaction_client() function to send
+ *   parallel requests to all remote clusters containing a process copy. Then it blocks
+ $   and deschedule to wait completion of these parrallel requests.
+ * - In each remote cluster, the rpc_process_sigaction_server() function, calls directly
+ *   the relevant process_block(), process_unblock(), or process_delete() function, and
+ *   decrement the responses counter to signal completion. The last server unblock
+ *   the client thread.
+ * - Finally, the client thread calls directly the process_block(), process_unblock(), or
+ *   process_delete() function in the owner cluster.
+ * It is used by the sys_kill() & sys_exit() functions to handle the "kill" & "exit" syscalls.
+ * It is also used by the process_make_exec() function to handle the "exec" syscall.
+ * WARNING : the DELETE and the BLOCK actions are NOT executed on the client thread.
+ *********************************************************************************************
+ * @ process     : pointer on the process descriptor in owner cluster.
+ * @ action_type : BLOCK_ALL_THREADS / UNBLOCK_ALL_THREADS / DELETE_ALL_THREADS
  ********************************************************************************************/
 void process_sigaction( process_t * process,
@@ -287 +291 @@
 /*********************************************************************************************
  * 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.
+ * It loops on all local threads of the process, set the THREAD_BLOCKED_GLOBAL bit, 
+ * and request the relevant schedulers to acknowledge the blocking, using IPI if required. 
+ * The threads are not detached from the scheduler, and not detached from the local process.
+ * This function returns only when all blockable threads in cluster are actually blocked.
+ * WARNING : the client thread defined by the <client_xp> argument is NOT blocked.
  *********************************************************************************************
  * @ process     : pointer on the target process descriptor.
- * @ rsp_xp      : extended pointer on the response counter. 
- * # client_xp   : extended pointer on client thread descriptor.
+ * @ client_xp   : extended pointer on the client thread, that should not be blocked.
  ********************************************************************************************/
 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.
+ ********************************************************************************************/
+void process_unblock( process_t * process );
+
+/*********************************************************************************************
+ * This function delete all threads, of a given user process in a given cluster.
+ * It loops on all local threads of the process, and set the THREAD_FLAG_REQ_DELETE bit.
+ * For each marked thread, the following actions will be done by the scheduler at the next
+ * scheduling point: 
+ * - the thread will be detached from the scheduler.
+ * - the thread will be detached from the local process descriptor.
+ * - the thread will be detached from parent if required.
+ * - the memory allocated to the thread descriptor is released.
+ * - the memory allocated to the process descriptor is released, if it is the last thread.
+ * WARNING : the client thread defined by the <client_xp> argument is NOT deleted.
  *********************************************************************************************
  * @ process     : pointer on the process descriptor.
- * @ rsp_xp      : extended pointer on the response counter. 
- * # client_xp   : extended pointer on client thread descriptor.
+ * @ client_xp   : extended pointer on the client thread, that should not be deleted.
  ********************************************************************************************/
 void process_delete( process_t * process,
-                     xptr_t      rsp_xp,
                      xptr_t      client_xp );
 
@@ -392 +385 @@
  * 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.
+ * in all clusters, and then delete all threads and process descriptors.
+ *********************************************************************************************
+ * @ pid      : process identifier.
  * @ status   : exit return value.
  ********************************************************************************************/
-void process_make_exit( process_t * process,
+void process_make_exit( pid_t       pid,
                         uint32_t    status );
 
@@ -408 +401 @@
  * 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 );
+ * @ pid     : process identifier.
+ * @ sig_id  : signal type.
+ ********************************************************************************************/
+void process_make_kill( pid_t     pid,
+                        uint32_t  sig_id );
 
 

trunk/kernel/kern/rpc.c

@@ -94 +94 @@
 ///////////////////////////////////////
 void rpc_send( cxy_t        server_cxy, 
-               rpc_desc_t * rpc,
-               bool_t       block )
+               rpc_desc_t * rpc )
 {
     error_t    error;
@@ -106 +105 @@
     rpc->lid       = core->lid;
 
-printk("\n   @@@ enter %s : rpc_desc_cxy = %x / rpc_desc_ptr = %x / index = %d / &index = %x\n",
-__FUNCTION__ , local_cxy , rpc , rpc->index , &rpc->index);
- 
     // build an extended pointer on the RPC descriptor
         xptr_t   desc_xp = XPTR( local_cxy , rpc );
@@ -137 +133 @@
         dev_pic_send_ipi( server_cxy , core->lid );
 
-    // wait RPC completion if blocking
+    // wait RPC completion before returning if blocking RPC
     // - busy waiting policy during kernel_init, or if threads cannot yield
     // - block and deschedule in all other cases
-    if ( block )
+    if ( rpc->blocking )
     {
         if( (this->type == THREAD_IDLE) || (thread_can_yield() == false) ) // busy waiting
@@ -178 +174 @@
         dev_pic_ack_ipi();
     }
-    
-printk("\n   @@@ exit %s : rpc_desc_cxy = %x / rpc_desc_ptr = %x / index = %d / &index = %x\n",
-__FUNCTION__ , local_cxy , rpc , rpc->index , &rpc->index);
- 
 }  // end rpc_send()
 
@@ -244 +236 @@
                     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] creates a new RPC thread %x / trdid %x / cycle %d\n", 
+__FUNCTION__ , local_cxy , core->lid , thread , thread->trdid , hal_time_stamp() );
 
             }
         }
     }
-
-//@@@
-sched_display( 0 );
-//@@@
 
 grpc_dmsg("\n[DBG] %s : core[%x,%d] / interrupted thread %s deschedules / cycle %d\n", 
@@ -279 +267 @@
     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
+    bool_t       blocking;    // blocking RPC when true
  
     // makes RPC thread not preemptable
@@ -319 +307 @@
                     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 ) );
-
-printk("\n   @@@ in %s : rpc_desc_cxy = %x / rpc_desc_ptr = %x / index = %d / &index = %x\n",
-__FUNCTION__ , desc_cxy , desc_ptr , index , &desc_ptr->index );
- 
+                    // get RPC <index> & <blocking> fields from RPC descriptor
+                        index    = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->index ) );
+                    blocking = hal_remote_lw( XPTR( desc_cxy , &desc_ptr->blocking ) );
+
 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 , (uint32_t)hal_get_cycles() );
@@ -334 +320 @@
 __FUNCTION__ , local_cxy , this->core->lid , this->trdid , index , hal_time_stamp() );
 
-                    // increment handled RPC counter
+                    // increment handled RPCs 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
+                    // decrement response counter in RPC descriptor if blocking
+                    if( blocking )
+                    {
+                        // decrement responses counter in RPC descriptor
+                        hal_remote_atomic_add(XPTR( desc_cxy, &desc_ptr->response ), -1);
+
+                        // unblock client thread
                         thread_ptr = (thread_t *)hal_remote_lpt(XPTR(desc_cxy,&desc_ptr->thread));
                         thread_unblock( XPTR(desc_cxy,thread_ptr) , THREAD_BLOCKED_RPC );
@@ -363 +349 @@
             // release rpc_fifo ownership if not lost
             if( rpc_fifo->owner == this->trdid ) rpc_fifo->owner = 0;
-        }
+
+        }  // end if RPC fifo
 
         // sucide if too many RPC threads in cluster
@@ -412 +399 @@
     rpc.index    = RPC_PMEM_GET_PAGES;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -417 +405 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc  , true );
+    rpc_send( cxy , &rpc );
 
     // get output arguments from RPC descriptor
@@ -470 +458 @@
     rpc.index    = RPC_PMEM_RELEASE_PAGES;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -475 +464 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc  , true );
+    rpc_send( cxy , &rpc );
 
 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -526 +515 @@
     rpc.index    = RPC_PROCESS_MAKE_EXEC;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor  
@@ -531 +521 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc  , true );
+    rpc_send( cxy , &rpc );
 
     // get output arguments from RPC descriptor
@@ -597 +587 @@
     rpc.index    = RPC_PROCESS_MAKE_FORK;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor  
@@ -603 +594 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc  , true );
+    rpc_send( cxy , &rpc );
 
     // get output arguments from RPC descriptor
@@ -658 +649 @@
 ///////////////////////////////////////////////////
 void rpc_process_make_exit_client( cxy_t       cxy,
-                                   process_t * process,
+                                   pid_t       pid,
                                    uint32_t    status ) 
 {
@@ -671 +662 @@
     rpc.index    = RPC_PROCESS_MAKE_EXIT;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor  
-    rpc.args[0] = (uint64_t)(intptr_t)process;
+    rpc.args[0] = (uint64_t)pid;
     rpc.args[1] = (uint64_t)status;
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -691 +683 @@
 CURRENT_THREAD->core->lid , hal_time_stamp() );
 
-    process_t * process;
-    uint32_t    status;  
+    pid_t     pid;
+    uint32_t  status;  
 
     // get client cluster identifier and pointer on RPC descriptor
@@ -699 +691 @@
 
     // 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] ) );
+    pid    = (uint32_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 ); 
+    process_make_exit( pid , status ); 
 
 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -716 +708 @@
 ///////////////////////////////////////////////////
 void rpc_process_make_kill_client( cxy_t       cxy,
-                                   process_t * process,
+                                   pid_t       pid,
                                    uint32_t    sig_id ) 
 {
@@ -729 +721 @@
     rpc.index    = RPC_PROCESS_MAKE_KILL;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor  
-    rpc.args[0] = (uint64_t)(intptr_t)process;
+    rpc.args[0] = (uint64_t)pid;
     rpc.args[1] = (uint64_t)sig_id;
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -749 +742 @@
 CURRENT_THREAD->core->lid , hal_time_stamp() );
 
-    process_t * process;
+    pid_t       pid;
     uint32_t    sig_id;
 
@@ -757 +750 @@
 
     // 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] ) );
+    pid    = (uint32_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 ); 
+    process_make_exit( pid , sig_id ); 
 
 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -791 +784 @@
     rpc.index     = RPC_THREAD_USER_CREATE;
     rpc.response  = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -799 +793 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output arguments from RPC descriptor
@@ -883 +877 @@
     rpc.index    = RPC_THREAD_KERNEL_CREATE;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -890 +885 @@
     
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output arguments from RPC descriptor
@@ -956 +951 @@
     rpc.index    = RPC_THREAD_KILL;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -961 +957 @@
     
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
 rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -997 +993 @@
 /////////////////////////////////////////////////////////////////////////////////////////
 
-///////////////////////////////////////////////////
-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
-{
-sigaction_dmsg("\n[DBG] %s : enter for %s (%d) / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , process_action_str( sigaction ) , 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 );
-
-sigaction_dmsg("\n[DBG] %s : exit for %s (%d) / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , process_action_str( sigaction ) , sigaction , CURRENT_THREAD ,
-local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
+////////////////////////////////////////////////////
+void rpc_process_sigaction_client( cxy_t        cxy,
+                                   rpc_desc_t * rpc_ptr )
+{
+sigaction_dmsg("\n[DBG] %s : enter to %s process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , process_action_str( (uint32_t)rpc_ptr->args[0] ) ,
+((process_t *)(intptr_t)rpc_ptr->args[1])->pid , cxy , (uint32_t)hal_get_cycles() );
+
+    // register RPC request in remote RPC fifo 
+    rpc_send( cxy , rpc_ptr );
+
+sigaction_dmsg("\n[DBG] %s : exit after %s process %x in cluster %x / cycle %d\n",
+__FUNCTION__ , process_action_str( (uint32_t)rpc_ptr->args[0] ) ,
+((process_t *)(intptr_t)rpc_ptr->args[1])->pid , cxy , (uint32_t)hal_get_cycles() );
 }  
 
@@ -1029 +1012 @@
 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 );
+    process_t  * process;          // pointer on local process descriptor
+    uint32_t     action;           // sigaction index
+    thread_t   * client_ptr;       // local pointer on client thread in client cluster
+    cxy_t        client_cxy;       // client cluster identifier
+    xptr_t       client_xp;        // extended pointer on client thread
+    core_t     * client_core;      // local pointer on core running the client thread
+    rpc_desc_t * rpc;              // local pointer on rpc descriptor in client cluster
+
+    // get client cluster identifier and pointer on RPC descriptor
+    client_cxy = (cxy_t)GET_CXY( xp );
+    rpc        = (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] ) );
-    
-sigaction_dmsg("\n[DBG] %s : enter for %s (%d) / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , process_action_str( action ) , action , CURRENT_THREAD ,
-local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
+    action      = (uint32_t)             hal_remote_lwd( XPTR( client_cxy , &rpc->args[0] ) );
+    process     = (process_t *)(intptr_t)hal_remote_lwd( XPTR( client_cxy , &rpc->args[1] ) );
+    client_ptr  = (thread_t *)hal_remote_lpt( XPTR( client_cxy , &rpc->thread ) );
+
+    // build extended pointer on client thread
+    client_xp = XPTR( client_cxy , client_ptr );
+
+sigaction_dmsg("\n[DBG] %s : enter to %s process %x / cycle %d\n",
+__FUNCTION__ , process_action_str( action ) , process->pid , (uint32_t)hal_get_cycles() );
 
     // 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 );
-
-sigaction_dmsg("\n[DBG] %s : exit for %s (%d) / thread %x on core[%x,%d] / cycle %d\n",
-__FUNCTION__ , process_action_str( action ) , action , CURRENT_THREAD ,
-local_cxy , CURRENT_THREAD->core->lid , hal_time_stamp() );
+    if      (action == DELETE_ALL_THREADS  ) process_delete ( process , client_xp ); 
+    else if (action == BLOCK_ALL_THREADS   ) process_block  ( process , client_xp ); 
+    else if (action == UNBLOCK_ALL_THREADS ) process_unblock( process             );
+
+    // decrement the responses counter in RPC descriptor,
+    // unblock the client thread only if it is the last response.
+    if( hal_remote_atomic_add( XPTR( client_cxy , &rpc->response ) , -1 ) == 1 ) 
+    {
+        client_core = (core_t *)hal_remote_lpt( XPTR( client_cxy , &client_ptr->core ) );
+        thread_unblock( client_xp , THREAD_BLOCKED_RPC );
+        dev_pic_send_ipi( client_cxy , client_core->lid );
+    }
+
+sigaction_dmsg("\n[DBG] %s : exit after %s process %x / cycle %d\n",
+__FUNCTION__ , process_action_str( action ) , process->pid , (uint32_t)hal_get_cycles() );
 } 
 
@@ -1085 +1080 @@
     rpc.index    = RPC_VFS_INODE_CREATE;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1097 +1093 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output values from RPC descriptor
@@ -1178 +1174 @@
     rpc.index    = RPC_VFS_INODE_DESTROY;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1183 +1180 @@
     
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -1236 +1233 @@
     rpc.index    = RPC_VFS_DENTRY_CREATE;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1243 +1241 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output values from RPC descriptor
@@ -1315 +1313 @@
     rpc.index    = RPC_VFS_DENTRY_DESTROY;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1320 +1319 @@
     
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -1373 +1372 @@
     rpc.index    = RPC_VFS_FILE_CREATE;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1379 +1379 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output values from RPC descriptor
@@ -1442 +1442 @@
     rpc.index    = RPC_VFS_FILE_DESTROY;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1447 +1448 @@
     
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -1499 +1500 @@
     rpc.index    = RPC_VFS_INODE_LOAD;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1506 +1508 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output values from RPC descriptor
@@ -1573 +1575 @@
     rpc.index    = RPC_VFS_MAPPER_LOAD_ALL;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1578 +1581 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output values from RPC descriptor
@@ -1638 +1641 @@
     rpc.index    = RPC_FATFS_GET_CLUSTER;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1645 +1649 @@
 
     // register RPC request in remote RPC fifo 
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output argument from rpc descriptor
@@ -1711 +1715 @@
     rpc.index    = RPC_VMM_GET_VSEG;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1717 +1722 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output argument from rpc descriptor
@@ -1786 +1791 @@
     rpc.index    = RPC_VMM_GET_PTE;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1793 +1799 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output argument from rpc descriptor
@@ -1860 +1866 @@
     rpc.index    = RPC_THREAD_USER_CREATE;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1865 +1872 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output arguments from RPC descriptor
@@ -1923 +1930 @@
     rpc.index    = RPC_THREAD_USER_CREATE;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1929 +1937 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -1986 +1994 @@
     rpc.index    = RPC_MAPPER_MOVE_BUFFER;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -1996 +2005 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output values from RPC descriptor
@@ -2083 +2092 @@
     rpc.index    = RPC_MAPPER_GET_PAGE;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -2089 +2099 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output values from RPC descriptor
@@ -2151 +2161 @@
     rpc.index    = RPC_VMM_CREATE_VSEG;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -2163 +2174 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     // get output values from RPC descriptor
@@ -2230 +2241 @@
     rpc.index    = RPC_SCHED_DISPLAY;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -2235 +2247 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",
@@ -2282 +2294 @@
     rpc.index    = RPC_VMM_SET_COW;
     rpc.response = 1;
+    rpc.blocking = true;
 
     // set input arguments in RPC descriptor 
@@ -2287 +2300 @@
 
     // register RPC request in remote RPC fifo (blocking function)
-    rpc_send( cxy , &rpc , true );
+    rpc_send( cxy , &rpc );
 
     rpc_dmsg("\n[DBG] %s : exit / thread %x on core[%x,%d] / cycle %d\n",

trunk/kernel/kern/rpc.h

@@ -109 +109 @@
 {
         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 +128 @@
  * 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 +137 @@
  * @ 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 +251 @@
 /***********************************************************************************
  * [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 +267 @@
  * 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 +338 @@
  *
  * 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 );

trunk/kernel/kern/scheduler.c

@@ -58 +58 @@
     list_root_init( &sched->k_root );
 
-    sched->sig_pending    = false;            // no pending signal
+    sched->req_ack_pending = false;           // no pending request
 
 }  // end sched_init()
@@ -89 +89 @@
 
 }  // end sched_register_thread()
-
-/////////////////////////////////////////////
-void sched_remove_thread( thread_t * thread )
-{
-    scheduler_t * sched = &thread->core->scheduler;
-    thread_type_t type  = thread->type;
-
-    // take lock protecting sheduler lists
-    spinlock_lock( &sched->lock );
-
-    if( type == THREAD_USER )
-    {
-        list_unlink( &thread->sched_list );
-        sched->u_threads_nr--;
-        if( sched->u_threads_nr == 0 ) sched->u_last = NULL;
-    }
-    else // kernel thread
-    {
-        list_unlink( &thread->sched_list );
-        sched->k_threads_nr--;
-        if( sched->k_threads_nr == 0 ) sched->k_last = NULL;
-    }
-
-    // release lock 
-    spinlock_unlock( &sched->lock );
-
-}  // end sched_remove_thread()
 
 //////////////////////////////////////////////
@@ -203 +176 @@
 }  // end sched_select()
 
-//////////////////////////////////////////
-void sched_handle_signals( core_t * core )
+///////////////////////////////////////////
+void sched_handle_requests( core_t * core )
 {
     list_entry_t * iter;
     thread_t     * thread;
 
+// printk("\n@@@ %s : current thread %x enter at cycle %d\n",
+// __FUNCTION__ , CURRENT_THREAD , hal_time_stamp() );
+
     scheduler_t  * sched = &core->scheduler;
 
@@ -214 +190 @@
     spinlock_lock( &sched->lock );
 
-    // handle user threads
+    // scan all user threads
     LIST_FOREACH( &sched->u_root , iter )
     {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
 
-        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 );
+        // handle REQ_ACK 
+        if( thread->flags & THREAD_FLAG_REQ_ACK )
+        {
+            // check thread blocked
+            assert( (thread->blocked & THREAD_BLOCKED_GLOBAL) , 
+            __FUNCTION__ , "thread not blocked" );
+ 
+            // decrement response counter
+            hal_atomic_add( thread->ack_rsp_count , -1 );
+
+            // reset REQ_ACK in thread descriptor
+            thread_reset_req_ack( thread );
+        }
+
+        // handle REQ_DELETE
+        if( thread->flags & THREAD_FLAG_REQ_DELETE )
+        {
+
+sched_dmsg("\n[DBG] %s : current thread %x delete thread %x at cycle %d\n",
+__FUNCTION__ , CURRENT_THREAD , thread , hal_time_stamp() );
+
+                // release FPU if required
+                if( thread->core->fpu_owner == thread )  thread->core->fpu_owner = NULL;
+
+            // 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
+            list_unlink( &thread->sched_list );
+            sched->u_threads_nr--;
+            if( sched->u_threads_nr == 0 ) sched->u_last = NULL;
+
+            // release memory allocated to thread
+            thread_destroy( thread );
+
+            // destroy process descriptor if no more threads
+            if (thread->process->th_nr == 0) process_destroy( thread->process );
         }
     }
@@ -232 +242 @@
     spinlock_unlock( &sched->lock );
 
-} // end sched_handle_signals()
+// printk("\n@@@ %s : current thread %x exit at cycle %d\n",
+// __FUNCTION__ , CURRENT_THREAD , hal_time_stamp() );
+
+} // end sched_handle_requests()
 
 ////////////////////////////////
@@ -305 +318 @@
     }
 
-    // handle signals for all threads executing on this core.
-    sched_handle_signals( core );
+    // handle pending requests for all threads executing on this core.
+    sched_handle_requests( core );
 
     // exit critical section / restore SR from next thread context
@@ -354 +367 @@
         if (thread->type == THREAD_DEV) 
         {
-            nolock_printk(" - %s / pid %X / trdid %X / desc %X / blocked %X / %s\n",
+            nolock_printk(" - %s / pid %X / trdid %X / desc %X / block %X / flags %X / %s\n",
             thread_type_str( thread->type ), thread->process->pid, thread->trdid,
-            thread, thread->blocked , thread->chdev->name );
+            thread, thread->blocked, thread->flags, thread->chdev->name );
         }
         else
         {
-            nolock_printk(" - %s / pid %X / trdid %X / desc %X / blocked %X\n",
+            nolock_printk(" - %s / pid %X / trdid %X / desc %X / block %X / flags %X \n",
             thread_type_str( thread->type ), thread->process->pid, thread->trdid,
-            thread, thread->blocked );
+            thread, thread->blocked, thread->flags  );
         }
     }
@@ -370 +383 @@
     {
         thread = LIST_ELEMENT( iter , thread_t , sched_list );
-        nolock_printk(" - %s / pid %X / trdid %X / desc %X / blocked %X\n",
+        nolock_printk(" - %s / pid %X / trdid %X / desc %X / block %X / flags %X\n",
         thread_type_str( thread->type ), thread->process->pid, thread->trdid,
-        thread, thread->blocked );
+        thread, thread->blocked, thread->flags );
     }
 

trunk/kernel/kern/scheduler.h

@@ -40 +40 @@
 typedef struct scheduler_s
 {
-    spinlock_t        lock;         /*! readlock protecting lists of threads                */
-    uint16_t          u_threads_nr; /*! total numbre of attached user threads               */
-    uint16_t          k_threads_nr; /*! total number of attached kernel threads             */
-    list_entry_t      u_root;       /*! root of list of user threads for this scheduler     */
-    list_entry_t      k_root;       /*! root of list of kernel threads for this scheduler   */
-    list_entry_t    * u_last;       /*! pointer on list_entry for last executed k_thread    */
-    list_entry_t    * k_last;       /*! pointer on list entry for last executed u_thread    */
-    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            */
+    spinlock_t        lock;            /*! readlock protecting lists of threads             */
+    uint16_t          u_threads_nr;    /*! total number of attached user threads            */
+    uint16_t          k_threads_nr;    /*! total number of attached kernel threads          */
+    list_entry_t      u_root;          /*! root of list of user threads                     */
+    list_entry_t      k_root;          /*! root of list of kernel threads                   */
+    list_entry_t    * u_last;          /*! pointer on list_entry for last executed k_thread */
+    list_entry_t    * k_last;          /*! pointer on list entry for last executed u_thread */
+    struct thread_s * idle;            /*! pointer on idle thread                           */
+    struct thread_s * current;         /*! pointer on current running thread                */
+    bool_t            req_ack_pending; /*! signal_handller must be called when true         */
 }
 scheduler_t;
@@ -67 +67 @@
                             struct thread_s * thread );
 
-/*********************************************************************************************
- * This function remove a thread from its scheduler.re scheduler.
- *********************************************************************************************
- * @ thread  : local pointer on the thread descriptor.
- ********************************************************************************************/  
-void sched_remove_thread( struct thread_s * thread );
-
 /********************************************************************************************* 
  * This function is the only method to make a context switch. It is called in cas of TICK,
@@ -87 +80 @@
 
 /*********************************************************************************************
- * This function scan all threads attached to a given core scheduler, and executes
- * the relevant actions for pending KILL or EXIT signals.
- * It is called in by the sched_yield() function, with IRQ disabled. 
+ * This function scan all threads attached to a given scheduler, and executes the relevant
+ * actions for pending THREAD_FLAG_REQ_ACK or THREAD_FLAG_REQ_DELETE requests. 
+ * It is called in by the sched_yield() function, with IRQ disabled.
+ * - REQ_ACK : it checks that target thread is blocked, decrements the response counter
+ *   to acknowledge the client thread, and reset the pending request. 
+ * - REQ_DELETE : it detach the target thread from parent if attached, detach it from
+ *   the process, remove it from scheduler, release memory allocated to thread descriptor,
+ *   and destroy the process descriptor it the target thread was the last thread.
  *********************************************************************************************
  * @ core    : local pointer on the core descriptor.
  ********************************************************************************************/
-void sched_handle_signals( struct core_s * core );
+void sched_handle_requests( struct core_s * core );
 
 /*********************************************************************************************
@@ -113 +111 @@
 
 /********************************************************************************************* 
- * 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/thread.c

@@ -696 +696 @@
 }  // thread_child_parent_unlink()
 
-/////////////////////////////////////////////////
-inline void thread_set_signal( thread_t * thread,
-                               uint32_t * sig_rsp_count )
+//////////////////////////////////////////////////
+inline void thread_set_req_ack( thread_t * target,
+                                uint32_t * 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" );
+    // get pointer on target thread scheduler
+    scheduler_t * sched = &target->core->scheduler;
+
+    // wait scheduler ready to handle a new request
+    while( sched->req_ack_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;
+    // set request in target thread scheduler
+    sched->req_ack_pending = true;
+
+    // set ack request in target thread "flags"
+    hal_atomic_or( &target->flags , THREAD_FLAG_REQ_ACK );
+
+    // set pointer on responses counter in target thread
+    target->ack_rsp_count = rsp_count;
     
     // exit critical section
@@ -725 +725 @@
     hal_fence();
 
-}  // thread_set_signal()
-
-////////////////////////////////////////////////////
-inline void thread_reset_signal( thread_t * thread )
+}  // thread_set_req_ack()
+
+/////////////////////////////////////////////////////
+inline void thread_reset_req_ack( thread_t * target )
 {
     reg_t    save_sr;   // for critical section
 
     // get pointer on target thread scheduler
-    scheduler_t * sched = &thread->core->scheduler;
+    scheduler_t * sched = &target->core->scheduler;
 
     // check signal pending in scheduler
-    assert( sched->sig_pending , __FUNCTION__ , "no pending signal" );
+    assert( sched->req_ack_pending , __FUNCTION__ , "no pending signal" );
     
     // enter critical section
@@ -742 +742 @@
       
     // reset signal in scheduler
-    sched->sig_pending = false;
+    sched->req_ack_pending = false;
 
     // reset signal in thread "flags"
-    hal_atomic_and( &thread->flags , ~THREAD_FLAG_SIGNAL );
+    hal_atomic_and( &target->flags , ~THREAD_FLAG_REQ_ACK );
 
     // reset pointer on responses counter 
-    thread->sig_rsp_count = NULL;
+    target->ack_rsp_count = NULL;
     
     // exit critical section
@@ -755 +755 @@
     hal_fence();
 
-}  // thread_reset_signal()
+}  // thread_reset_req_ack()
 
 ////////////////////////////////
@@ -809 +809 @@
 void thread_kill( thread_t * target )
 {
-    volatile uint32_t  sig_rsp_count = 1;     // responses counter
+    volatile uint32_t  rsp_count = 1;     // responses counter
 
     thread_t * killer = CURRENT_THREAD;
 
-kill_dmsg("\n[DBG] %s : killer thread %x enter for target thread %x\n",
+thread_dmsg("\n[DBG] %s : killer thread %x enter for target thread %x\n",
 __FUNCTION__, local_cxy, killer->trdid , target trdid );
 
@@ -824 +824 @@
     {
         // set signal in target thread descriptor and in target scheduler
-        thread_set_signal( target , (uint32_t *)(&sig_rsp_count) );
+        thread_set_req_ack( target , (void *)(&rsp_count) );
 
         // send an IPI to the target thread core.
@@ -833 +833 @@
         {
             // exit when response received from scheduler
-            if( sig_rsp_count == 0 )  break;
+            if( rsp_count == 0 )  break;
 
             // deschedule without blocking
@@ -840 +840 @@
     }
 
-        // 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",
+        // set REQ_DELETE flag
+        hal_atomic_or( &target->flags , THREAD_FLAG_REQ_DELETE );
+
+thread_dmsg("\n[DBG] %s : killer thread %x exit for target thread %x\n",
 __FUNCTION__, local_cxy, killer->trdid , target trdid );
 

trunk/kernel/kern/thread.h

@@ -72 +72 @@
 #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     */
+#define THREAD_FLAG_REQ_ACK      0x0008  /*! Acknowledge required from scheduler      */
+#define THREAD_FLAG_REQ_DELETE   0x0010  /*! Destruction required by scheduler        */
 
 /***************************************************************************************
@@ -119 +120 @@
  * - The TRDID 16 MSB bits contain the CXY of cluster containing the thread.
  * - The LTID is used to index the th_tbl[] array in the local process descriptor.
- * This TRDID is computed by the process_register_thread() function, when the user
+ _* This TRDID is computed by the process_register_thread() function, when the user
  * thread is registered in the local copy of the process descriptor.
  *
@@ -153 +154 @@
     xptr_t              join_xp;         /*! extended pointer on joining thread       */
 
-    uint32_t          * sig_rsp_count;   /*! pointer on signal response counter       */
+    uint32_t          * ack_rsp_count;   /*! pointer on acknowledge response counter  */
 
         intptr_t            u_stack_base;    /*! user stack base address                  */
@@ -345 +346 @@
 
 /***************************************************************************************
- * 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.
+ * This function is used by a "blocker" thread running in the same cluster as a "target"
+ * thread to request the scheduler of the target thread to acknowledge that the target
+ * thread is blocked and not running, at the next context switch.
+ * This function executes atomically the following actions :
+ * - it set the request_pending boolean in the target scheduler descriptor.
+ * - it set the REQ_ACK 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. 
+ * The request_pending flag is handled as a set/reset flip-flop by the "blocker" 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.
- **************************************************************************************/
-void thread_reset_signal( thread_t * thread );
+ * @ ack_rsp_count : local pointer on responses counter.
+ **************************************************************************************/
+void thread_set_req_ack( thread_t * target,
+                         uint32_t * ack_rsp_count );
+
+/***************************************************************************************
+ * This function is used by the sched_handle_signal() function executed by the 
+ * scheduler of a "target" thread to reset a "blocked not running" acknowledge request
+ * in both the target thread descriptor, and in the target  thread scheduler.
+ ***************************************************************************************
+ * @ target    : local pointer on target thread.
+ **************************************************************************************/
+void thread_reset_req_ack( thread_t * target );
 
 /***************************************************************************************
@@ -390 +391 @@
  * 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.
+ *   this function simply set the BLOCKED_ GLOBAL bit and the REQ_DELETE flag
+ *   in the target thread descriptor and return.
+ * - When the killer thread is running on a different core than the target thread,
+ *   the killer set the BLOCKED_GLOBAL bit and the REQ_ACK flag in target  thread,
+ *   to ask the scheduler to confirm that the target is blocked and not running.
+ *   Then, it set the REQ_DELETE flag in the target thread and return.
+ * In both cases, the actual target thread destruction is done by the scheduler
+ * at the next scheduling point.
  ***************************************************************************************
  * @ thread   : local pointer on the target thread.