score: Thread life cycle re-implementation

The thread deletion is now supported on SMP.

This change fixes the following PRs:

PR1814: SMP race condition between stack free and dispatch

PR2035: psxcancel reveals NULL pointer access in _Thread_queue_Extract()

The POSIX cleanup handler are now called in the right context (should be
called in the context of the terminating thread).

http://pubs.opengroup.org/onlinepubs/009695399/functions/xsh_chap02_09.html

Add a user extension the reflects a thread termination event.  This is
used to reclaim the Newlib reentrancy structure (may use file
operations), the POSIX cleanup handlers and the POSIX key destructors.

4 files changed, 62 insertions, 70 deletions

diff --git a/cpukit/posix/include/rtems/posix/pthreadimpl.h b/cpukit/posix/include/rtems/posix/pthreadimpl.h
index af68990d6b..02d8bca0f5 100644
--- a/cpukit/posix/include/rtems/posix/pthreadimpl.h
+++ b/cpukit/posix/include/rtems/posix/pthreadimpl.h
@@ -23,7 +23,7 @@
 #include <rtems/posix/config.h>
 #include <rtems/posix/threadsup.h>
 #include <rtems/score/objectimpl.h>
-#include <rtems/score/thread.h>
+#include <rtems/score/threadimpl.h>
 #include <rtems/score/assert.h>
 
 #ifdef __cplusplus
@@ -217,6 +217,8 @@ int rtems_pthread_attribute_compare(
 
 RTEMS_INLINE_ROUTINE Thread_Control *_POSIX_Threads_Allocate( void )
 {
+  _Thread_Kill_zombies();
+
   return (Thread_Control *) _Objects_Allocate( &_POSIX_Threads_Information );
 }
 
diff --git a/cpukit/posix/src/keyrundestructors.c b/cpukit/posix/src/keyrundestructors.c
index 762e2e6f85..96147a539d 100644
--- a/cpukit/posix/src/keyrundestructors.c
+++ b/cpukit/posix/src/keyrundestructors.c
@@ -7,7 +7,7 @@
 
 /*
  * Copyright (c) 2012 Zhongwei Yao.
- * Copyright (c) 2010 embedded brains GmbH.
+ * Copyright (c) 2010-2014 embedded brains GmbH.
  *
  * COPYRIGHT (c) 1989-2014.
  * On-Line Applications Research Corporation (OAR).
@@ -22,6 +22,7 @@
 #endif
 
 #include <rtems/posix/keyimpl.h>
+#include <rtems/score/assert.h>
 #include <rtems/score/chainimpl.h>
 #include <rtems/score/thread.h>
 
@@ -44,14 +45,15 @@ void _POSIX_Keys_Run_destructors(
   POSIX_Keys_Control *the_key;
   Objects_Locations location;
 
-  _Thread_Disable_dispatch();
-
   chain = &thread->Key_Chain;
   iter = (POSIX_Keys_Key_value_pair *) _Chain_First( chain );
   while ( !_Chain_Is_tail( chain, &iter->Key_values_per_thread_node ) ) {
     next = (POSIX_Keys_Key_value_pair *)
       _Chain_Next( &iter->Key_values_per_thread_node );
 
+    the_key = _POSIX_Keys_Get( iter->key, &location );
+    _Assert( location == OBJECTS_LOCAL );
+
     /**
      * remove key from rbtree and chain.
      * here Chain_Node *iter can be convert to POSIX_Keys_Key_value_pair *,
@@ -64,21 +66,19 @@ void _POSIX_Keys_Run_destructors(
     );
     _Chain_Extract_unprotected( &iter->Key_values_per_thread_node );
 
-    /**
-     * run key value's destructor if destructor and value are both non-null.
-     */
-    the_key = _POSIX_Keys_Get( iter->key, &location );
     destructor = the_key->destructor;
     value = iter->value;
-    if ( destructor != NULL && value != NULL )
-      (*destructor)( value );
+
+    _POSIX_Keys_Key_value_pair_free( iter );
 
     _Objects_Put( &the_key->Object );
 
-    _POSIX_Keys_Key_value_pair_free( iter );
+    /**
+     * run key value's destructor if destructor and value are both non-null.
+     */
+    if ( destructor != NULL && value != NULL )
+      (*destructor)( value );
 
     iter = next;
   }
-
-  _Thread_Enable_dispatch();
 }
diff --git a/cpukit/posix/src/pthread.c b/cpukit/posix/src/pthread.c
index 0416e28adf..8d1a8eb209 100644
--- a/cpukit/posix/src/pthread.c
+++ b/cpukit/posix/src/pthread.c
@@ -274,21 +274,30 @@ static void _POSIX_Threads_Delete_extension(
   Thread_Control *deleted
 )
 {
+  _Workspace_Free( deleted->API_Extensions[ THREAD_API_POSIX ] );
+}
+
+static void _POSIX_Threads_Terminate_extension(
+  Thread_Control *executing
+)
+{
   Thread_Control     *the_thread;
   POSIX_API_Control  *api;
   void              **value_ptr;
 
-  api = deleted->API_Extensions[ THREAD_API_POSIX ];
+  api = executing->API_Extensions[ THREAD_API_POSIX ];
 
   /*
    *  Run the POSIX cancellation handlers
    */
-  _POSIX_Threads_cancel_run( deleted );
+  _POSIX_Threads_cancel_run( executing );
+
+  _Thread_Disable_dispatch();
 
   /*
    *  Wakeup all the tasks which joined with this one
    */
-  value_ptr = (void **) deleted->Wait.return_argument;
+  value_ptr = (void **) executing->Wait.return_argument;
 
   while ( (the_thread = _Thread_queue_Dequeue( &api->Join_List )) )
       *(void **)the_thread->Wait.return_argument = value_ptr;
@@ -296,9 +305,7 @@ static void _POSIX_Threads_Delete_extension(
   if ( api->schedpolicy == SCHED_SPORADIC )
     (void) _Watchdog_Remove( &api->Sporadic_timer );
 
-  deleted->API_Extensions[ THREAD_API_POSIX ] = NULL;
-
-  _Workspace_Free( api );
+  _Thread_Enable_dispatch();
 }
 
 /*
@@ -350,7 +357,8 @@ User_extensions_Control _POSIX_Threads_User_extensions = {
     NULL,                                     /* switch */
     NULL,                                     /* begin */
     _POSIX_Threads_Exitted_extension,         /* exitted */
-    NULL                                      /* fatal */
+    NULL,                                     /* fatal */
+    _POSIX_Threads_Terminate_extension        /* terminate */
   }
 };
 
diff --git a/cpukit/posix/src/pthreadexit.c b/cpukit/posix/src/pthreadexit.c
index 8ffb54eb5a..40cd16023a 100644
--- a/cpukit/posix/src/pthreadexit.c
+++ b/cpukit/posix/src/pthreadexit.c
@@ -21,6 +21,7 @@
 #include <pthread.h>
 
 #include <rtems/posix/pthreadimpl.h>
+#include <rtems/score/assert.h>
 #include <rtems/score/apimutex.h>
 #include <rtems/score/threadimpl.h>
 #include <rtems/score/threadqimpl.h>
@@ -30,65 +31,46 @@ void _POSIX_Thread_Exit(
   void           *value_ptr
 )
 {
-  Objects_Information  *the_information;
-  Thread_Control       *unblocked;
-  POSIX_API_Control    *api;
-
-  the_information = _Objects_Get_information_id( the_thread->Object.id );
+  Thread_Control    *unblocked;
+  POSIX_API_Control *api;
+  bool               previous_life_protection;
 
   api = the_thread->API_Extensions[ THREAD_API_POSIX ];
 
+  _Assert( _Debug_Is_thread_dispatching_allowed() );
 
-  /*
-   * The_information has to be non-NULL.  Otherwise, we couldn't be
-   * running in a thread of this API and class.
-   *
-   * NOTE: Lock and unlock in different order so we do not throw a
-   *       fatal error when locking the allocator mutex.  And after
-   *       we unlock, we want to defer the context switch until we
-   *       are ready to be switched out.  Otherwise, an ISR could
-   *       occur and preempt us out while we still hold the
-   *       allocator mutex.
-   */
-
-  _RTEMS_Lock_allocator();
-    _Thread_Disable_dispatch();
-
-      the_thread->Wait.return_argument = value_ptr;
+  previous_life_protection = _Thread_Set_life_protection( true );
+  _Thread_Disable_dispatch();
 
-      /*
-       * Process join
-       */
-      if ( api->detachstate == PTHREAD_CREATE_JOINABLE ) {
-        unblocked = _Thread_queue_Dequeue( &api->Join_List );
-        if ( unblocked ) {
-          do {
-            *(void **)unblocked->Wait.return_argument = value_ptr;
-          } while ( (unblocked = _Thread_queue_Dequeue( &api->Join_List )) );
-        } else {
-          _Thread_Set_state(
-            the_thread,
-            STATES_WAITING_FOR_JOIN_AT_EXIT | STATES_TRANSIENT
-          );
-           /* FIXME: Lock order reversal */
-           _RTEMS_Unlock_allocator();
-          _Thread_Enable_dispatch();
-          /* now waiting for thread to arrive */
-          _RTEMS_Lock_allocator();
-          _Thread_Disable_dispatch();
-        }
-      }
+  the_thread->Wait.return_argument = value_ptr;
 
-      /*
-       *  Now shut down the thread
-       */
-      _Thread_Close( the_information, the_thread );
+  /*
+   * Process join
+   */
+  if ( api->detachstate == PTHREAD_CREATE_JOINABLE ) {
+    unblocked = _Thread_queue_Dequeue( &api->Join_List );
+    if ( unblocked ) {
+      do {
+        *(void **)unblocked->Wait.return_argument = value_ptr;
+      } while ( (unblocked = _Thread_queue_Dequeue( &api->Join_List )) );
+    } else {
+      _Thread_Set_state(
+        the_thread,
+        STATES_WAITING_FOR_JOIN_AT_EXIT | STATES_TRANSIENT
+      );
+      _Thread_Enable_dispatch();
+      /* now waiting for thread to arrive */
+      _Thread_Disable_dispatch();
+    }
+  }
 
-      _POSIX_Threads_Free( the_thread );
+  /*
+   *  Now shut down the thread
+   */
+  _Thread_Close( the_thread, _Thread_Executing );
 
-     /* FIXME: Lock order reversal */
-    _RTEMS_Unlock_allocator();
   _Thread_Enable_dispatch();
+  _Thread_Set_life_protection( previous_life_protection );
 }
 
 void pthread_exit(