score: _CORE_mutex_Check_dispatch_for_seize()

Move the safety check performed by
_CORE_mutex_Check_dispatch_for_seize() out of the performance critical
path and generalize it.  Blocking on a thread queue with an unexpected
thread dispatch disabled level is illegal in all system states.

Add the expected thread dispatch disable level (which may be 1 or 2
depending on the operation) to Thread_queue_Context and use it in
_Thread_queue_Enqueue_critical().

1 files changed, 14 insertions, 12 deletions

diff --git a/cpukit/posix/src/pthreadjoin.c b/cpukit/posix/src/pthreadjoin.c
index f4a0676d6b..86b805132a 100644
--- a/cpukit/posix/src/pthreadjoin.c
+++ b/cpukit/posix/src/pthreadjoin.c
@@ -32,13 +32,15 @@
 
 static int _POSIX_Threads_Join( pthread_t thread, void **value_ptr )
 {
-  Thread_Control    *the_thread;
-  ISR_lock_Context   lock_context;
-  Per_CPU_Control   *cpu_self;
-  Thread_Control    *executing;
-  void              *value;
+  Thread_Control       *the_thread;
+  Thread_queue_Context  queue_context;
+  Per_CPU_Control      *cpu_self;
+  Thread_Control       *executing;
+  void                 *value;
 
-  the_thread = _Thread_Get( thread, &lock_context );
+  _Thread_queue_Context_initialize( &queue_context );
+  _Thread_queue_Context_set_expected_level( &queue_context, 1 );
+  the_thread = _Thread_Get( thread, &queue_context.Lock_context );
 
   if ( the_thread == NULL ) {
     return ESRCH;
@@ -48,29 +50,29 @@ static int _POSIX_Threads_Join( pthread_t thread, void **value_ptr )
   executing = _Per_CPU_Get_executing( cpu_self );
 
   if ( executing == the_thread ) {
-    _ISR_lock_ISR_enable( &lock_context );
+    _ISR_lock_ISR_enable( &queue_context.Lock_context );
     return EDEADLK;
   }
 
-  _Thread_State_acquire_critical( the_thread, &lock_context );
+  _Thread_State_acquire_critical( the_thread, &queue_context.Lock_context );
 
   if ( !_Thread_Is_joinable( the_thread ) ) {
-    _Thread_State_release( the_thread, &lock_context );
+    _Thread_State_release( the_thread, &queue_context.Lock_context );
     return EINVAL;
   }
 
   if ( _States_Is_waiting_for_join_at_exit( the_thread->current_state ) ) {
     value = the_thread->Life.exit_value;
     _Thread_Clear_state_locked( the_thread, STATES_WAITING_FOR_JOIN_AT_EXIT );
-    _Thread_Dispatch_disable_with_CPU( cpu_self, &lock_context );
-    _Thread_State_release( the_thread, &lock_context );
+    _Thread_Dispatch_disable_with_CPU( cpu_self, &queue_context.Lock_context );
+    _Thread_State_release( the_thread, &queue_context.Lock_context );
     _Thread_Dispatch_enable( cpu_self );
   } else {
     _Thread_Join(
       the_thread,
       STATES_INTERRUPTIBLE_BY_SIGNAL | STATES_WAITING_FOR_JOIN,
       executing,
-      &lock_context
+      &queue_context
     );
 
     if ( _POSIX_Get_error_after_wait( executing ) != 0 ) {