Index: trunk/kernel/kern/thread.c
===================================================================
--- trunk/kernel/kern/thread.c	(revision 409)
+++ trunk/kernel/kern/thread.c	(revision 416)
@@ -696,27 +696,27 @@
 }  // 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,16 +725,16 @@
     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,11 +742,11 @@
       
     // 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,5 +755,5 @@
     hal_fence();
 
-}  // thread_reset_signal()
+}  // thread_reset_req_ack()
 
 ////////////////////////////////
@@ -809,9 +809,9 @@
 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,5 +824,5 @@
     {
         // 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,5 +833,5 @@
         {
             // exit when response received from scheduler
-            if( sig_rsp_count == 0 )  break;
+            if( rsp_count == 0 )  break;
 
             // deschedule without blocking
@@ -840,21 +840,8 @@
     }
 
-	// 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 );
 
