[PATCH 5/5] score: Move thread queue MP callout to context

Sebastian Huber sebastian.huber at embedded-brains.de
Tue May 24 12:07:15 UTC 2016


Drop the multiprocessing (MP) dependent callout parameter from the
thread queue extract, dequeue, flush and unblock methods.  Merge this
parameter with the lock context into new structure Thread_queue_Context.
This helps to gets rid of the conditionally compiled method call
helpers.
---
 cpukit/libnetworking/rtems/rtems_glue.c            |  15 +-
 cpukit/posix/include/rtems/posix/barrierimpl.h     |   7 +-
 cpukit/posix/include/rtems/posix/condimpl.h        |  15 +-
 cpukit/posix/include/rtems/posix/mqueueimpl.h      |  14 +-
 cpukit/posix/include/rtems/posix/muteximpl.h       |   4 +-
 cpukit/posix/include/rtems/posix/posixapi.h        |   8 +-
 cpukit/posix/include/rtems/posix/rwlockimpl.h      |   4 +-
 cpukit/posix/include/rtems/posix/semaphoreimpl.h   |   9 +-
 cpukit/posix/src/conddestroy.c                     |  10 +-
 cpukit/posix/src/condget.c                         |   6 +-
 cpukit/posix/src/condsignalsupp.c                  |  11 +-
 cpukit/posix/src/condwaitsupp.c                    |  21 +-
 cpukit/posix/src/mqueueclose.c                     |  10 +-
 cpukit/posix/src/mqueuedeletesupp.c                |  10 +-
 cpukit/posix/src/mqueuegetattr.c                   |  10 +-
 cpukit/posix/src/mqueuenotify.c                    |  16 +-
 cpukit/posix/src/mqueuerecvsupp.c                  |  14 +-
 cpukit/posix/src/mqueuesendsupp.c                  |  13 +-
 cpukit/posix/src/mqueuesetattr.c                   |  10 +-
 cpukit/posix/src/mqueueunlink.c                    |   6 +-
 cpukit/posix/src/mutexdestroy.c                    |  14 +-
 cpukit/posix/src/mutexget.c                        |   6 +-
 cpukit/posix/src/mutexgetprioceiling.c             |  10 +-
 cpukit/posix/src/mutexlocksupp.c                   |  10 +-
 cpukit/posix/src/mutexsetprioceiling.c             |   7 +-
 cpukit/posix/src/mutexunlock.c                     |  14 +-
 cpukit/posix/src/pbarrierdestroy.c                 |  10 +-
 cpukit/posix/src/pbarrierwait.c                    |   7 +-
 cpukit/posix/src/prwlockdestroy.c                  |  10 +-
 cpukit/posix/src/prwlockinit.c                     |   6 +-
 cpukit/posix/src/prwlockrdlock.c                   |   6 +-
 cpukit/posix/src/prwlocktimedrdlock.c              |   6 +-
 cpukit/posix/src/prwlocktimedwrlock.c              |   6 +-
 cpukit/posix/src/prwlocktryrdlock.c                |   6 +-
 cpukit/posix/src/prwlocktrywrlock.c                |   6 +-
 cpukit/posix/src/prwlockunlock.c                   |   6 +-
 cpukit/posix/src/prwlockwrlock.c                   |   6 +-
 cpukit/posix/src/semaphoredeletesupp.c             |  10 +-
 cpukit/posix/src/semaphorewaitsupp.c               |   6 +-
 cpukit/posix/src/semclose.c                        |   8 +-
 cpukit/posix/src/semdestroy.c                      |  10 +-
 cpukit/posix/src/semgetvalue.c                     |  15 +-
 cpukit/posix/src/sempost.c                         |   7 +-
 cpukit/posix/src/semunlink.c                       |   8 +-
 cpukit/rtems/include/rtems/rtems/barrierimpl.h     |   7 +-
 cpukit/rtems/include/rtems/rtems/messageimpl.h     |  21 +-
 cpukit/rtems/include/rtems/rtems/semimpl.h         |  21 +-
 cpukit/rtems/src/barrierdelete.c                   |  10 +-
 cpukit/rtems/src/barrierrelease.c                  |  11 +-
 cpukit/rtems/src/barrierwait.c                     |  11 +-
 cpukit/rtems/src/msgmp.c                           |  12 +-
 cpukit/rtems/src/msgqbroadcast.c                   |  11 +-
 cpukit/rtems/src/msgqdelete.c                      |  13 +-
 cpukit/rtems/src/msgqflush.c                       |   6 +-
 cpukit/rtems/src/msgqgetnumberpending.c            |   8 +-
 cpukit/rtems/src/msgqreceive.c                     |   8 +-
 cpukit/rtems/src/msgqsend.c                        |  13 +-
 cpukit/rtems/src/msgqurgent.c                      |  13 +-
 cpukit/rtems/src/semdelete.c                       |  30 +-
 cpukit/rtems/src/semflush.c                        |  24 +-
 cpukit/rtems/src/semobtain.c                       |  18 +-
 cpukit/rtems/src/semrelease.c                      |  16 +-
 cpukit/rtems/src/semsetpriority.c                  |  28 +-
 cpukit/score/include/rtems/score/corebarrierimpl.h | 150 +++------
 cpukit/score/include/rtems/score/coremsg.h         |   2 +-
 cpukit/score/include/rtems/score/coremsgimpl.h     | 341 ++++++---------------
 cpukit/score/include/rtems/score/coremuteximpl.h   | 135 ++++----
 cpukit/score/include/rtems/score/corerwlockimpl.h  |  42 +--
 cpukit/score/include/rtems/score/coresemimpl.h     | 166 +++++-----
 cpukit/score/include/rtems/score/mrspimpl.h        |  97 +++---
 cpukit/score/include/rtems/score/threadq.h         |  12 +
 cpukit/score/include/rtems/score/threadqimpl.h     | 191 +++++-------
 cpukit/score/src/apimutexlock.c                    |   9 +-
 cpukit/score/src/apimutexunlock.c                  |  15 +-
 cpukit/score/src/condition.c                       |  36 +--
 cpukit/score/src/corebarrier.c                     |   6 +-
 cpukit/score/src/corebarrierrelease.c              |  10 +-
 cpukit/score/src/corebarrierwait.c                 |  21 +-
 cpukit/score/src/coremsgbroadcast.c                |  18 +-
 cpukit/score/src/coremsgclose.c                    |  16 +-
 cpukit/score/src/coremsgflush.c                    |   6 +-
 cpukit/score/src/coremsgseize.c                    |  14 +-
 cpukit/score/src/coremsgsubmit.c                   |  26 +-
 cpukit/score/src/coremutex.c                       |  12 +-
 cpukit/score/src/coremutexsurrender.c              |  27 +-
 cpukit/score/src/corerwlockobtainread.c            |  20 +-
 cpukit/score/src/corerwlockobtainwrite.c           |  18 +-
 cpukit/score/src/corerwlockrelease.c               |  19 +-
 cpukit/score/src/coresem.c                         |  12 +-
 cpukit/score/src/futex.c                           |  31 +-
 cpukit/score/src/mpci.c                            |  19 +-
 cpukit/score/src/mutex.c                           |  49 +--
 cpukit/score/src/semaphore.c                       |  14 +-
 cpukit/score/src/threadqenqueue.c                  |  51 +--
 cpukit/score/src/threadqflush.c                    |  27 +-
 cpukit/score/src/threadrestart.c                   |  31 +-
 testsuites/sptests/spintrcritical22/init.c         |   6 +-
 testsuites/tmtests/tm26/task1.c                    |  11 +-
 98 files changed, 1048 insertions(+), 1306 deletions(-)

diff --git a/cpukit/libnetworking/rtems/rtems_glue.c b/cpukit/libnetworking/rtems/rtems_glue.c
index 9ece2b1..edf551e 100644
--- a/cpukit/libnetworking/rtems/rtems_glue.c
+++ b/cpukit/libnetworking/rtems/rtems_glue.c
@@ -371,18 +371,19 @@ void
 rtems_bsdnet_semaphore_obtain (void)
 {
 #ifdef RTEMS_FAST_MUTEX
-	ISR_lock_Context lock_context;
+	Thread_queue_Context queue_context;
 	Thread_Control *executing;
-	_ISR_lock_ISR_disable(&lock_context);
 	if (!the_networkSemaphore)
 		rtems_panic ("rtems-net: network sema obtain: network not initialised\n");
+	_Thread_queue_Context_initialize(&queue_context, NULL);
+	_ISR_lock_ISR_disable(&queue_context.Lock_context);
 	executing = _Thread_Executing;
 	_CORE_mutex_Seize (
 		&the_networkSemaphore->Core_control.mutex,
 		executing,
 		1,		/* wait */
 		0,		/* forever */
-		&lock_context
+		&queue_context
 		);
 	if (executing->Wait.return_code)
 		rtems_panic ("rtems-net: can't obtain network sema: %d\n",
@@ -404,16 +405,16 @@ void
 rtems_bsdnet_semaphore_release (void)
 {
 #ifdef RTEMS_FAST_MUTEX
-        ISR_lock_Context lock_context;
+	Thread_queue_Context queue_context;
 	CORE_mutex_Status status;
 
 	if (!the_networkSemaphore)
 		rtems_panic ("rtems-net: network sema obtain: network not initialised\n");
-        _ISR_lock_ISR_disable(&lock_context);
+	_Thread_queue_Context_initialize(&queue_context, NULL);
+	_ISR_lock_ISR_disable(&queue_context.Lock_context);
 	status = _CORE_mutex_Surrender (
 		&the_networkSemaphore->Core_control.mutex,
-		NULL,
-                &lock_context
+		&queue_context
 		);
 	if (status != CORE_MUTEX_STATUS_SUCCESSFUL)
 		rtems_panic ("rtems-net: can't release network sema: %i\n");
diff --git a/cpukit/posix/include/rtems/posix/barrierimpl.h b/cpukit/posix/include/rtems/posix/barrierimpl.h
index 5173531..e04f135 100644
--- a/cpukit/posix/include/rtems/posix/barrierimpl.h
+++ b/cpukit/posix/include/rtems/posix/barrierimpl.h
@@ -77,14 +77,15 @@ RTEMS_INLINE_ROUTINE void _POSIX_Barrier_Free (
   _Objects_Free( &_POSIX_Barrier_Information, &the_barrier->Object );
 }
 
-RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get (
+RTEMS_INLINE_ROUTINE POSIX_Barrier_Control *_POSIX_Barrier_Get(
   const pthread_barrier_t *barrier,
-  ISR_lock_Context        *lock_context
+  Thread_queue_Context    *queue_context
 )
 {
+  _Thread_queue_Context_initialize( queue_context, NULL );
   return (POSIX_Barrier_Control *) _Objects_Get(
     (Objects_Id) *barrier,
-    lock_context,
+    &queue_context->Lock_context,
     &_POSIX_Barrier_Information
   );
 }
diff --git a/cpukit/posix/include/rtems/posix/condimpl.h b/cpukit/posix/include/rtems/posix/condimpl.h
index b178869..736f06b 100644
--- a/cpukit/posix/include/rtems/posix/condimpl.h
+++ b/cpukit/posix/include/rtems/posix/condimpl.h
@@ -63,18 +63,21 @@ RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Destroy(
 
 RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Acquire_critical(
   POSIX_Condition_variables_Control *the_cond,
-  ISR_lock_Context                  *lock_context
+  Thread_queue_Context              *queue_context
 )
 {
-  _Thread_queue_Acquire_critical( &the_cond->Wait_queue, lock_context );
+  _Thread_queue_Acquire_critical(
+    &the_cond->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
 RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Release(
   POSIX_Condition_variables_Control *the_cond,
-  ISR_lock_Context                  *lock_context
+  Thread_queue_Context              *queue_context
 )
 {
-  _Thread_queue_Release( &the_cond->Wait_queue, lock_context );
+  _Thread_queue_Release( &the_cond->Wait_queue, &queue_context->Lock_context );
 }
 
 /**
@@ -107,8 +110,8 @@ RTEMS_INLINE_ROUTINE void _POSIX_Condition_variables_Free (
 }
 
 POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get(
-  pthread_cond_t   *cond,
-  ISR_lock_Context *lock_context
+  pthread_cond_t       *cond,
+  Thread_queue_Context *queue_context
 );
 
 /**
diff --git a/cpukit/posix/include/rtems/posix/mqueueimpl.h b/cpukit/posix/include/rtems/posix/mqueueimpl.h
index 3185970..2317358 100644
--- a/cpukit/posix/include/rtems/posix/mqueueimpl.h
+++ b/cpukit/posix/include/rtems/posix/mqueueimpl.h
@@ -43,7 +43,7 @@ extern Objects_Information _POSIX_Message_queue_Information;
  */
 void _POSIX_Message_queue_Delete(
   POSIX_Message_queue_Control *the_mq,
-  ISR_lock_Context            *lock_context
+  Thread_queue_Context        *queue_context
 );
 
 /*@
@@ -107,12 +107,16 @@ RTEMS_INLINE_ROUTINE void _POSIX_Message_queue_Free(
 
 
 RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control *_POSIX_Message_queue_Get(
-  Objects_Id        id,
-  ISR_lock_Context *lock_context
+  Objects_Id            id,
+  Thread_queue_Context *queue_context
 )
 {
-  return (POSIX_Message_queue_Control *)
-    _Objects_Get( id, lock_context, &_POSIX_Message_queue_Information );
+  _Thread_queue_Context_initialize( queue_context, NULL );
+  return (POSIX_Message_queue_Control *) _Objects_Get(
+    id,
+    &queue_context->Lock_context,
+    &_POSIX_Message_queue_Information
+  );
 }
 
 /*
diff --git a/cpukit/posix/include/rtems/posix/muteximpl.h b/cpukit/posix/include/rtems/posix/muteximpl.h
index 7627d3d..4c7852b 100644
--- a/cpukit/posix/include/rtems/posix/muteximpl.h
+++ b/cpukit/posix/include/rtems/posix/muteximpl.h
@@ -127,8 +127,8 @@ RTEMS_INLINE_ROUTINE int _POSIX_Mutex_Translate_core_mutex_return_code(
  *  @note: This version of the method uses an interrupt critical section.
  */
 POSIX_Mutex_Control *_POSIX_Mutex_Get(
-  pthread_mutex_t  *mutex,
-  ISR_lock_Context *lock_context
+  pthread_mutex_t      *mutex,
+  Thread_queue_Context *queue_context
 );
 
 RTEMS_INLINE_ROUTINE POSIX_Mutex_Control *_POSIX_Mutex_Get_no_protection(
diff --git a/cpukit/posix/include/rtems/posix/posixapi.h b/cpukit/posix/include/rtems/posix/posixapi.h
index a16b6ad..a5afe92 100644
--- a/cpukit/posix/include/rtems/posix/posixapi.h
+++ b/cpukit/posix/include/rtems/posix/posixapi.h
@@ -71,7 +71,7 @@ RTEMS_INLINE_ROUTINE int _POSIX_Get_by_name_error(
 #define _POSIX_Get_object_body( \
   type, \
   id, \
-  lock_context, \
+  queue_context, \
   info, \
   initializer, \
   init \
@@ -80,14 +80,16 @@ RTEMS_INLINE_ROUTINE int _POSIX_Get_by_name_error(
   if ( id == NULL ) { \
     return NULL; \
   } \
-  the_object = _Objects_Get( (Objects_Id) *id, lock_context, info ); \
+  the_object = \
+    _Objects_Get( (Objects_Id) *id, &queue_context->Lock_context, info ); \
   if ( the_object == NULL ) { \
     _Once_Lock(); \
     if ( *id == initializer ) { \
       init( id, NULL ); \
     } \
     _Once_Unlock(); \
-    the_object = _Objects_Get( (Objects_Id) *id, lock_context, info ); \
+    the_object = \
+      _Objects_Get( (Objects_Id) *id, &queue_context->Lock_context, info ); \
   } \
   return (type *) the_object
 
diff --git a/cpukit/posix/include/rtems/posix/rwlockimpl.h b/cpukit/posix/include/rtems/posix/rwlockimpl.h
index 6f3088e..4ab9395 100644
--- a/cpukit/posix/include/rtems/posix/rwlockimpl.h
+++ b/cpukit/posix/include/rtems/posix/rwlockimpl.h
@@ -87,8 +87,8 @@ RTEMS_INLINE_ROUTINE void _POSIX_RWLock_Free (
 }
 
 POSIX_RWLock_Control *_POSIX_RWLock_Get(
-  pthread_rwlock_t *rwlock,
-  ISR_lock_Context *lock_context
+  pthread_rwlock_t     *rwlock,
+  Thread_queue_Context *queue_context
 );
 
 #ifdef __cplusplus
diff --git a/cpukit/posix/include/rtems/posix/semaphoreimpl.h b/cpukit/posix/include/rtems/posix/semaphoreimpl.h
index 402329a..10d7cee 100644
--- a/cpukit/posix/include/rtems/posix/semaphoreimpl.h
+++ b/cpukit/posix/include/rtems/posix/semaphoreimpl.h
@@ -61,13 +61,14 @@ RTEMS_INLINE_ROUTINE void _POSIX_Semaphore_Free (
 }
 
 RTEMS_INLINE_ROUTINE POSIX_Semaphore_Control *_POSIX_Semaphore_Get(
-  const sem_t       *id,
-  ISR_lock_Context  *lock_context
+  const sem_t          *id,
+  Thread_queue_Context *queue_context
 )
 {
+  _Thread_queue_Context_initialize( queue_context, NULL );
   return (POSIX_Semaphore_Control *) _Objects_Get(
     (Objects_Id) *id,
-    lock_context,
+    &queue_context->Lock_context,
     &_POSIX_Semaphore_Information
   );
 }
@@ -93,7 +94,7 @@ int _POSIX_Semaphore_Create_support(
  */
 void _POSIX_Semaphore_Delete(
   POSIX_Semaphore_Control *the_semaphore,
-  ISR_lock_Context        *lock_context
+  Thread_queue_Context    *queue_context
 );
 
 /**
diff --git a/cpukit/posix/src/conddestroy.c b/cpukit/posix/src/conddestroy.c
index d47c6b2..a2c8dc1 100644
--- a/cpukit/posix/src/conddestroy.c
+++ b/cpukit/posix/src/conddestroy.c
@@ -29,20 +29,20 @@ int pthread_cond_destroy(
 )
 {
   POSIX_Condition_variables_Control *the_cond;
-  ISR_lock_Context                   lock_context;
+  Thread_queue_Context               queue_context;
 
   _Objects_Allocator_lock();
-  the_cond = _POSIX_Condition_variables_Get( cond, &lock_context );
+  the_cond = _POSIX_Condition_variables_Get( cond, &queue_context );
 
   if ( the_cond == NULL ) {
     _Objects_Allocator_unlock();
     return EINVAL;
   }
 
-  _POSIX_Condition_variables_Acquire_critical( the_cond, &lock_context );
+  _POSIX_Condition_variables_Acquire_critical( the_cond, &queue_context );
 
   if ( !_Thread_queue_Is_empty( &the_cond->Wait_queue.Queue ) ) {
-    _POSIX_Condition_variables_Release( the_cond, &lock_context );
+    _POSIX_Condition_variables_Release( the_cond, &queue_context );
     _Objects_Allocator_unlock();
     return EBUSY;
   }
@@ -51,7 +51,7 @@ int pthread_cond_destroy(
     &_POSIX_Condition_variables_Information,
     &the_cond->Object
   );
-  _POSIX_Condition_variables_Release( the_cond, &lock_context );
+  _POSIX_Condition_variables_Release( the_cond, &queue_context );
   _POSIX_Condition_variables_Destroy( the_cond );
   _POSIX_Condition_variables_Free( the_cond );
   _Objects_Allocator_unlock();
diff --git a/cpukit/posix/src/condget.c b/cpukit/posix/src/condget.c
index 5676de8..5b086ef 100644
--- a/cpukit/posix/src/condget.c
+++ b/cpukit/posix/src/condget.c
@@ -15,14 +15,14 @@
 #include <rtems/posix/posixapi.h>
 
 POSIX_Condition_variables_Control *_POSIX_Condition_variables_Get(
-  pthread_cond_t   *cond,
-  ISR_lock_Context *lock_context
+  pthread_cond_t       *cond,
+  Thread_queue_Context *queue_context
 )
 {
   _POSIX_Get_object_body(
     POSIX_Condition_variables_Control,
     cond,
-    lock_context,
+    queue_context,
     &_POSIX_Condition_variables_Information,
     PTHREAD_COND_INITIALIZER,
     pthread_cond_init
diff --git a/cpukit/posix/src/condsignalsupp.c b/cpukit/posix/src/condsignalsupp.c
index 38aa053..e42476e 100644
--- a/cpukit/posix/src/condsignalsupp.c
+++ b/cpukit/posix/src/condsignalsupp.c
@@ -36,15 +36,15 @@ int _POSIX_Condition_variables_Signal_support(
 
   do {
     POSIX_Condition_variables_Control *the_cond;
-    ISR_lock_Context                   lock_context;
+    Thread_queue_Context               queue_context;
 
-    the_cond = _POSIX_Condition_variables_Get( cond, &lock_context );
+    the_cond = _POSIX_Condition_variables_Get( cond, &queue_context );
 
     if ( the_cond == NULL ) {
       return EINVAL;
     }
 
-    _POSIX_Condition_variables_Acquire_critical( the_cond, &lock_context );
+    _POSIX_Condition_variables_Acquire_critical( the_cond, &queue_context );
 
     the_thread = _Thread_queue_First_locked(
       &the_cond->Wait_queue,
@@ -56,12 +56,11 @@ int _POSIX_Condition_variables_Signal_support(
         &the_cond->Wait_queue.Queue,
         POSIX_CONDITION_VARIABLES_TQ_OPERATIONS,
         the_thread,
-        NULL,
-        &lock_context
+        &queue_context
       );
     } else {
       the_cond->mutex = POSIX_CONDITION_VARIABLES_NO_MUTEX;
-      _POSIX_Condition_variables_Release( the_cond, &lock_context );
+      _POSIX_Condition_variables_Release( the_cond, &queue_context );
     }
   } while ( is_broadcast && the_thread != NULL );
 
diff --git a/cpukit/posix/src/condwaitsupp.c b/cpukit/posix/src/condwaitsupp.c
index 11b0587..4e89ef0 100644
--- a/cpukit/posix/src/condwaitsupp.c
+++ b/cpukit/posix/src/condwaitsupp.c
@@ -35,7 +35,7 @@ int _POSIX_Condition_variables_Wait_support(
 {
   POSIX_Condition_variables_Control *the_cond;
   POSIX_Mutex_Control               *the_mutex;
-  ISR_lock_Context                   lock_context;
+  Thread_queue_Context               queue_context;
   int                                status;
   int                                mutex_status;
   CORE_mutex_Status                  core_mutex_status;
@@ -46,25 +46,25 @@ int _POSIX_Condition_variables_Wait_support(
     return EINVAL;
   }
 
-  the_cond = _POSIX_Condition_variables_Get( cond, &lock_context );
+  the_cond = _POSIX_Condition_variables_Get( cond, &queue_context );
 
   if ( the_cond == NULL ) {
     return EINVAL;
   }
 
-  _POSIX_Condition_variables_Acquire_critical( the_cond, &lock_context );
+  _POSIX_Condition_variables_Acquire_critical( the_cond, &queue_context );
 
   if (
     the_cond->mutex != POSIX_CONDITION_VARIABLES_NO_MUTEX
       && the_cond->mutex != *mutex
   ) {
-    _POSIX_Condition_variables_Release( the_cond, &lock_context );
+    _POSIX_Condition_variables_Release( the_cond, &queue_context );
     return EINVAL;
   }
 
   the_cond->mutex = *mutex;
 
-  cpu_self = _Thread_Dispatch_disable_critical( &lock_context );
+  cpu_self = _Thread_Dispatch_disable_critical( &queue_context.Lock_context );
   executing = _Per_CPU_Get_executing( cpu_self );
 
   /*
@@ -78,7 +78,7 @@ int _POSIX_Condition_variables_Wait_support(
     the_mutex == NULL
       || !_CORE_mutex_Is_owner( &the_mutex->Mutex, executing )
   ) {
-    _POSIX_Condition_variables_Release( the_cond, &lock_context );
+    _POSIX_Condition_variables_Release( the_cond, &queue_context );
     _Thread_Dispatch_enable( cpu_self );
     return EPERM;
   }
@@ -92,18 +92,17 @@ int _POSIX_Condition_variables_Wait_support(
       STATES_WAITING_FOR_CONDITION_VARIABLE,
       timeout,
       ETIMEDOUT,
-      &lock_context
+      &queue_context.Lock_context
     );
   } else {
-    _POSIX_Condition_variables_Release( the_cond, &lock_context );
+    _POSIX_Condition_variables_Release( the_cond, &queue_context );
     executing->Wait.return_code = ETIMEDOUT;
   }
 
-  _ISR_lock_ISR_disable( &lock_context );
+  _ISR_lock_ISR_disable( &queue_context.Lock_context );
   core_mutex_status = _CORE_mutex_Surrender(
     &the_mutex->Mutex,
-    NULL,
-    &lock_context
+    &queue_context
   );
   _Assert( core_mutex_status == CORE_MUTEX_STATUS_SUCCESSFUL );
   (void) core_mutex_status;
diff --git a/cpukit/posix/src/mqueueclose.c b/cpukit/posix/src/mqueueclose.c
index 28a7d16..60d3ce3 100644
--- a/cpukit/posix/src/mqueueclose.c
+++ b/cpukit/posix/src/mqueueclose.c
@@ -42,10 +42,10 @@ int mq_close(
 )
 {
   POSIX_Message_queue_Control *the_mq;
-  ISR_lock_Context             lock_context;
+  Thread_queue_Context         queue_context;
 
   _Objects_Allocator_lock();
-  the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context );
+  the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
 
   if ( the_mq == NULL ) {
     _Objects_Allocator_unlock();
@@ -54,17 +54,17 @@ int mq_close(
 
   _CORE_message_queue_Acquire_critical(
     &the_mq->Message_queue,
-    &lock_context
+    &queue_context
   );
 
   if ( the_mq->open_count == 0 ) {
-    _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context );
+    _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
     _Objects_Allocator_unlock();
     rtems_set_errno_and_return_minus_one( EBADF );
   }
 
   the_mq->open_count -= 1;
-  _POSIX_Message_queue_Delete( the_mq, &lock_context );
+  _POSIX_Message_queue_Delete( the_mq, &queue_context );
 
   _Objects_Allocator_unlock();
   return 0;
diff --git a/cpukit/posix/src/mqueuedeletesupp.c b/cpukit/posix/src/mqueuedeletesupp.c
index 485136c..850707a 100644
--- a/cpukit/posix/src/mqueuedeletesupp.c
+++ b/cpukit/posix/src/mqueuedeletesupp.c
@@ -22,17 +22,13 @@
 
 void _POSIX_Message_queue_Delete(
   POSIX_Message_queue_Control *the_mq,
-  ISR_lock_Context            *lock_context
+  Thread_queue_Context        *queue_context
 )
 {
   if ( !the_mq->linked && the_mq->open_count == 0 ) {
-    _CORE_message_queue_Close(
-      &the_mq->Message_queue,
-      NULL,        /* no MP support */
-      lock_context
-    );
+    _CORE_message_queue_Close( &the_mq->Message_queue, queue_context );
     _POSIX_Message_queue_Free( the_mq );
   } else {
-    _CORE_message_queue_Release( &the_mq->Message_queue, lock_context );
+    _CORE_message_queue_Release( &the_mq->Message_queue, queue_context );
   }
 }
diff --git a/cpukit/posix/src/mqueuegetattr.c b/cpukit/posix/src/mqueuegetattr.c
index dae14e3..5efcc0b 100644
--- a/cpukit/posix/src/mqueuegetattr.c
+++ b/cpukit/posix/src/mqueuegetattr.c
@@ -42,13 +42,13 @@ int mq_getattr(
 )
 {
   POSIX_Message_queue_Control *the_mq;
-  ISR_lock_Context             lock_context;
+  Thread_queue_Context         queue_context;
 
   if ( mqstat == NULL ) {
     rtems_set_errno_and_return_minus_one( EINVAL );
   }
 
-  the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context );
+  the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
 
   if ( the_mq == NULL ) {
     rtems_set_errno_and_return_minus_one( EBADF );
@@ -56,11 +56,11 @@ int mq_getattr(
 
   _CORE_message_queue_Acquire_critical(
     &the_mq->Message_queue,
-    &lock_context
+    &queue_context
   );
 
   if ( the_mq->open_count == 0 ) {
-    _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context );
+    _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
     rtems_set_errno_and_return_minus_one( EBADF );
   }
 
@@ -72,6 +72,6 @@ int mq_getattr(
   mqstat->mq_maxmsg  = the_mq->Message_queue.maximum_pending_messages;
   mqstat->mq_curmsgs = the_mq->Message_queue.number_of_pending_messages;
 
-  _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context );
+  _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
   return 0;
 }
diff --git a/cpukit/posix/src/mqueuenotify.c b/cpukit/posix/src/mqueuenotify.c
index adcfdcb..a1f9a08 100644
--- a/cpukit/posix/src/mqueuenotify.c
+++ b/cpukit/posix/src/mqueuenotify.c
@@ -24,7 +24,7 @@
 
 static void _POSIX_Message_queue_Notify_handler(
   CORE_message_queue_Control *the_message_queue,
-  ISR_lock_Context           *lock_context
+  Thread_queue_Context       *queue_context
 )
 {
   POSIX_Message_queue_Control *the_mq;
@@ -38,7 +38,7 @@ static void _POSIX_Message_queue_Notify_handler(
 
   signo = the_mq->notification.sigev_signo;
   _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL );
-  _CORE_message_queue_Release( &the_mq->Message_queue, lock_context );
+  _CORE_message_queue_Release( &the_mq->Message_queue, queue_context );
 
   kill( getpid(), signo );
 }
@@ -49,9 +49,9 @@ int mq_notify(
 )
 {
   POSIX_Message_queue_Control *the_mq;
-  ISR_lock_Context             lock_context;
+  Thread_queue_Context         queue_context;
 
-  the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context );
+  the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
 
   if ( the_mq == NULL ) {
     rtems_set_errno_and_return_minus_one( EBADF );
@@ -59,17 +59,17 @@ int mq_notify(
 
   _CORE_message_queue_Acquire_critical(
     &the_mq->Message_queue,
-    &lock_context
+    &queue_context
   );
 
   if ( the_mq->open_count == 0 ) {
-    _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context );
+    _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
     rtems_set_errno_and_return_minus_one( EBADF );
   }
 
   if ( notification != NULL ) {
     if ( _CORE_message_queue_Is_notify_enabled( &the_mq->Message_queue ) ) {
-      _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context );
+      _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
       rtems_set_errno_and_return_minus_one( EBUSY );
     }
 
@@ -83,6 +83,6 @@ int mq_notify(
     _CORE_message_queue_Set_notify( &the_mq->Message_queue, NULL );
   }
 
-  _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context );
+  _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
   return 0;
 }
diff --git a/cpukit/posix/src/mqueuerecvsupp.c b/cpukit/posix/src/mqueuerecvsupp.c
index b5a790a..541786a 100644
--- a/cpukit/posix/src/mqueuerecvsupp.c
+++ b/cpukit/posix/src/mqueuerecvsupp.c
@@ -44,24 +44,24 @@ ssize_t _POSIX_Message_queue_Receive_support(
 )
 {
   POSIX_Message_queue_Control *the_mq;
-  ISR_lock_Context             lock_context;
+  Thread_queue_Context         queue_context;
   size_t                       length_out;
   bool                         do_wait;
   Thread_Control              *executing;
 
-  the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context );
+  the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
 
   if ( the_mq == NULL ) {
     rtems_set_errno_and_return_minus_one( EBADF );
   }
 
   if ( ( the_mq->oflag & O_ACCMODE ) == O_WRONLY ) {
-    _ISR_lock_ISR_enable( &lock_context );
+    _ISR_lock_ISR_enable( &queue_context.Lock_context );
     rtems_set_errno_and_return_minus_one( EBADF );
   }
 
   if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
-    _ISR_lock_ISR_enable( &lock_context );
+    _ISR_lock_ISR_enable( &queue_context.Lock_context );
     rtems_set_errno_and_return_minus_one( EMSGSIZE );
   }
 
@@ -83,11 +83,11 @@ ssize_t _POSIX_Message_queue_Receive_support(
 
   _CORE_message_queue_Acquire_critical(
     &the_mq->Message_queue,
-    &lock_context
+    &queue_context
   );
 
   if ( the_mq->open_count == 0 ) {
-    _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context );
+    _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
     rtems_set_errno_and_return_minus_one( EBADF );
   }
 
@@ -102,7 +102,7 @@ ssize_t _POSIX_Message_queue_Receive_support(
     &length_out,
     do_wait,
     timeout,
-    &lock_context
+    &queue_context
   );
 
   if ( msg_prio != NULL ) {
diff --git a/cpukit/posix/src/mqueuesendsupp.c b/cpukit/posix/src/mqueuesendsupp.c
index 1053df9..e9848c2 100644
--- a/cpukit/posix/src/mqueuesendsupp.c
+++ b/cpukit/posix/src/mqueuesendsupp.c
@@ -44,7 +44,7 @@ int _POSIX_Message_queue_Send_support(
 )
 {
   POSIX_Message_queue_Control *the_mq;
-  ISR_lock_Context             lock_context;
+  Thread_queue_Context         queue_context;
   CORE_message_queue_Status    msg_status;
   bool                         do_wait;
   Thread_Control              *executing;
@@ -58,14 +58,14 @@ int _POSIX_Message_queue_Send_support(
     rtems_set_errno_and_return_minus_one( EINVAL );
   }
 
-  the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context );
+  the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
 
   if ( the_mq == NULL ) {
     rtems_set_errno_and_return_minus_one( EBADF );
   }
 
   if ( ( the_mq->oflag & O_ACCMODE ) == O_RDONLY ) {
-    _ISR_lock_ISR_enable( &lock_context );
+    _ISR_lock_ISR_enable( &queue_context.Lock_context );
     rtems_set_errno_and_return_minus_one( EBADF );
   }
 
@@ -80,11 +80,11 @@ int _POSIX_Message_queue_Send_support(
 
   _CORE_message_queue_Acquire_critical(
     &the_mq->Message_queue,
-    &lock_context
+    &queue_context
   );
 
   if ( the_mq->open_count == 0 ) {
-    _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context );
+    _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
     rtems_set_errno_and_return_minus_one( EBADF );
   }
 
@@ -97,11 +97,10 @@ int _POSIX_Message_queue_Send_support(
     executing,
     msg_ptr,
     msg_len,
-    NULL,
     _POSIX_Message_queue_Priority_to_core( msg_prio ),
     do_wait,
     timeout,
-    &lock_context
+    &queue_context
   );
 
   /*
diff --git a/cpukit/posix/src/mqueuesetattr.c b/cpukit/posix/src/mqueuesetattr.c
index dfd9bab..fc9fc75 100644
--- a/cpukit/posix/src/mqueuesetattr.c
+++ b/cpukit/posix/src/mqueuesetattr.c
@@ -27,13 +27,13 @@ int mq_setattr(
 )
 {
   POSIX_Message_queue_Control *the_mq;
-  ISR_lock_Context             lock_context;
+  Thread_queue_Context         queue_context;
 
   if ( mqstat == NULL ) {
     rtems_set_errno_and_return_minus_one( EINVAL );
   }
 
-  the_mq = _POSIX_Message_queue_Get( mqdes, &lock_context );
+  the_mq = _POSIX_Message_queue_Get( mqdes, &queue_context );
 
   if ( the_mq == NULL ) {
     rtems_set_errno_and_return_minus_one( EBADF );
@@ -41,11 +41,11 @@ int mq_setattr(
 
   _CORE_message_queue_Acquire_critical(
     &the_mq->Message_queue,
-    &lock_context
+    &queue_context
   );
 
   if ( the_mq->open_count == 0 ) {
-    _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context );
+    _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
     rtems_set_errno_and_return_minus_one( EBADF );
   }
 
@@ -62,6 +62,6 @@ int mq_setattr(
 
   the_mq->oflag = mqstat->mq_flags;
 
-  _CORE_message_queue_Release( &the_mq->Message_queue, &lock_context );
+  _CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
   return 0;
 }
diff --git a/cpukit/posix/src/mqueueunlink.c b/cpukit/posix/src/mqueueunlink.c
index dc485ba..812f249 100644
--- a/cpukit/posix/src/mqueueunlink.c
+++ b/cpukit/posix/src/mqueueunlink.c
@@ -30,7 +30,7 @@ int mq_unlink(
 {
   POSIX_Message_queue_Control *the_mq;
   Objects_Get_by_name_error    error;
-  ISR_lock_Context             lock_context;
+  Thread_queue_Context         queue_context;
 
   _Objects_Allocator_lock();
 
@@ -42,10 +42,10 @@ int mq_unlink(
 
   _POSIX_Message_queue_Namespace_remove( the_mq );
 
-  _CORE_message_queue_Acquire( &the_mq->Message_queue, &lock_context );
+  _CORE_message_queue_Acquire( &the_mq->Message_queue, &queue_context );
 
   the_mq->linked = false;
-  _POSIX_Message_queue_Delete( the_mq, &lock_context );
+  _POSIX_Message_queue_Delete( the_mq, &queue_context );
 
   _Objects_Allocator_unlock();
   return 0;
diff --git a/cpukit/posix/src/mutexdestroy.c b/cpukit/posix/src/mutexdestroy.c
index 640acc0..7fda7d3 100644
--- a/cpukit/posix/src/mutexdestroy.c
+++ b/cpukit/posix/src/mutexdestroy.c
@@ -28,16 +28,16 @@ int pthread_mutex_destroy(
   pthread_mutex_t           *mutex
 )
 {
-  POSIX_Mutex_Control *the_mutex;
-  ISR_lock_Context     lock_context;
-  int                  eno;
+  POSIX_Mutex_Control  *the_mutex;
+  Thread_queue_Context  queue_context;
+  int                   eno;
 
   _Objects_Allocator_lock();
 
-  the_mutex = _POSIX_Mutex_Get( mutex, &lock_context );
+  the_mutex = _POSIX_Mutex_Get( mutex, &queue_context );
 
   if ( the_mutex != NULL ) {
-    _CORE_mutex_Acquire_critical( &the_mutex->Mutex, &lock_context );
+    _CORE_mutex_Acquire_critical( &the_mutex->Mutex, &queue_context );
 
     /*
      * XXX: There is an error for the mutex being locked
@@ -46,12 +46,12 @@ int pthread_mutex_destroy(
 
     if ( !_CORE_mutex_Is_locked( &the_mutex->Mutex ) ) {
       _Objects_Close( &_POSIX_Mutex_Information, &the_mutex->Object );
-      _CORE_mutex_Release( &the_mutex->Mutex, &lock_context );
+      _CORE_mutex_Release( &the_mutex->Mutex, &queue_context );
       _CORE_mutex_Destroy( &the_mutex->Mutex );
       _POSIX_Mutex_Free( the_mutex );
       eno = 0;
     } else {
-      _CORE_mutex_Release( &the_mutex->Mutex, &lock_context );
+      _CORE_mutex_Release( &the_mutex->Mutex, &queue_context );
       eno = EBUSY;
     }
   } else {
diff --git a/cpukit/posix/src/mutexget.c b/cpukit/posix/src/mutexget.c
index f8f0033..e90c41c 100644
--- a/cpukit/posix/src/mutexget.c
+++ b/cpukit/posix/src/mutexget.c
@@ -22,14 +22,14 @@
 #include <rtems/posix/posixapi.h>
 
 POSIX_Mutex_Control *_POSIX_Mutex_Get(
-  pthread_mutex_t  *mutex,
-  ISR_lock_Context *lock_context
+  pthread_mutex_t      *mutex,
+  Thread_queue_Context *queue_context
 )
 {
   _POSIX_Get_object_body(
     POSIX_Mutex_Control,
     mutex,
-    lock_context,
+    queue_context,
     &_POSIX_Mutex_Information,
     PTHREAD_MUTEX_INITIALIZER,
     pthread_mutex_init
diff --git a/cpukit/posix/src/mutexgetprioceiling.c b/cpukit/posix/src/mutexgetprioceiling.c
index 232b2e2..268457a 100644
--- a/cpukit/posix/src/mutexgetprioceiling.c
+++ b/cpukit/posix/src/mutexgetprioceiling.c
@@ -30,26 +30,26 @@ int pthread_mutex_getprioceiling(
   int               *prioceiling
 )
 {
-  POSIX_Mutex_Control *the_mutex;
-  ISR_lock_Context     lock_context;
+  POSIX_Mutex_Control  *the_mutex;
+  Thread_queue_Context  queue_context;
 
   if ( prioceiling == NULL ) {
     return EINVAL;
   }
 
-  the_mutex = _POSIX_Mutex_Get( mutex, &lock_context );
+  the_mutex = _POSIX_Mutex_Get( mutex, &queue_context );
 
   if ( the_mutex == NULL ) {
     return EINVAL;
   }
 
-  _CORE_mutex_Acquire_critical( &the_mutex->Mutex, &lock_context );
+  _CORE_mutex_Acquire_critical( &the_mutex->Mutex, &queue_context );
 
   *prioceiling = _POSIX_Priority_From_core(
     the_mutex->Mutex.Attributes.priority_ceiling
   );
 
-  _CORE_mutex_Release( &the_mutex->Mutex, &lock_context );
+  _CORE_mutex_Release( &the_mutex->Mutex, &queue_context );
 
   return 0;
 }
diff --git a/cpukit/posix/src/mutexlocksupp.c b/cpukit/posix/src/mutexlocksupp.c
index 0c70cf0..f17269b 100644
--- a/cpukit/posix/src/mutexlocksupp.c
+++ b/cpukit/posix/src/mutexlocksupp.c
@@ -28,11 +28,11 @@ int _POSIX_Mutex_Lock_support(
   Watchdog_Interval  timeout
 )
 {
-  POSIX_Mutex_Control *the_mutex;
-  ISR_lock_Context     lock_context;
-  Thread_Control      *executing;
+  POSIX_Mutex_Control  *the_mutex;
+  Thread_queue_Context  queue_context;
+  Thread_Control       *executing;
 
-  the_mutex = _POSIX_Mutex_Get( mutex, &lock_context );
+  the_mutex = _POSIX_Mutex_Get( mutex, &queue_context );
 
   if ( the_mutex == NULL ) {
     return EINVAL;
@@ -44,7 +44,7 @@ int _POSIX_Mutex_Lock_support(
     executing,
     blocking,
     timeout,
-    &lock_context
+    &queue_context
   );
   return _POSIX_Mutex_Translate_core_mutex_return_code(
     (CORE_mutex_Status) executing->Wait.return_code
diff --git a/cpukit/posix/src/mutexsetprioceiling.c b/cpukit/posix/src/mutexsetprioceiling.c
index f29c0ad..09554f8 100644
--- a/cpukit/posix/src/mutexsetprioceiling.c
+++ b/cpukit/posix/src/mutexsetprioceiling.c
@@ -33,7 +33,7 @@ int pthread_mutex_setprioceiling(
 {
   register POSIX_Mutex_Control *the_mutex;
   Priority_Control              the_priority;
-  ISR_lock_Context              lock_context;
+  Thread_queue_Context          queue_context;
 
   if ( !old_ceiling )
     return EINVAL;
@@ -57,7 +57,7 @@ int pthread_mutex_setprioceiling(
    *  NOTE: This makes it easier to get 100% binary coverage since the
    *        bad Id case is handled by the switch.
    */
-  the_mutex = _POSIX_Mutex_Get( mutex, &lock_context );
+  the_mutex = _POSIX_Mutex_Get( mutex, &queue_context );
 
   if ( the_mutex == NULL ) {
     return EINVAL;
@@ -73,8 +73,7 @@ int pthread_mutex_setprioceiling(
    */
   _CORE_mutex_Surrender(
     &the_mutex->Mutex,
-    NULL,
-    &lock_context
+    &queue_context
   );
   return 0;
 }
diff --git a/cpukit/posix/src/mutexunlock.c b/cpukit/posix/src/mutexunlock.c
index 94fcc63..ff7fc1c 100644
--- a/cpukit/posix/src/mutexunlock.c
+++ b/cpukit/posix/src/mutexunlock.c
@@ -30,20 +30,16 @@ int pthread_mutex_unlock(
   pthread_mutex_t           *mutex
 )
 {
-  POSIX_Mutex_Control *the_mutex;
-  CORE_mutex_Status    status;
-  ISR_lock_Context     lock_context;
+  POSIX_Mutex_Control  *the_mutex;
+  CORE_mutex_Status     status;
+  Thread_queue_Context  queue_context;
 
-  the_mutex = _POSIX_Mutex_Get( mutex, &lock_context );
+  the_mutex = _POSIX_Mutex_Get( mutex, &queue_context );
 
   if ( the_mutex == NULL ) {
     return EINVAL;
   }
 
-  status = _CORE_mutex_Surrender(
-    &the_mutex->Mutex,
-    NULL,
-    &lock_context
-  );
+  status = _CORE_mutex_Surrender( &the_mutex->Mutex, &queue_context );
   return _POSIX_Mutex_Translate_core_mutex_return_code( status );
 }
diff --git a/cpukit/posix/src/pbarrierdestroy.c b/cpukit/posix/src/pbarrierdestroy.c
index 709644b..8f85762 100644
--- a/cpukit/posix/src/pbarrierdestroy.c
+++ b/cpukit/posix/src/pbarrierdestroy.c
@@ -36,30 +36,30 @@ int pthread_barrier_destroy(
 )
 {
   POSIX_Barrier_Control *the_barrier;
-  ISR_lock_Context       lock_context;
+  Thread_queue_Context   queue_context;
 
   if ( barrier == NULL ) {
     return EINVAL;
   }
 
   _Objects_Allocator_lock();
-  the_barrier = _POSIX_Barrier_Get( barrier, &lock_context );
+  the_barrier = _POSIX_Barrier_Get( barrier, &queue_context );
 
   if ( the_barrier == NULL ) {
     _Objects_Allocator_unlock();
     return EINVAL;
   }
 
-  _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &lock_context );
+  _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &queue_context );
 
   if ( the_barrier->Barrier.number_of_waiting_threads != 0 ) {
-    _CORE_barrier_Release( &the_barrier->Barrier, &lock_context );
+    _CORE_barrier_Release( &the_barrier->Barrier, &queue_context );
     _Objects_Allocator_unlock();
     return EBUSY;
   }
 
   _Objects_Close( &_POSIX_Barrier_Information, &the_barrier->Object );
-  _CORE_barrier_Release( &the_barrier->Barrier, &lock_context );
+  _CORE_barrier_Release( &the_barrier->Barrier, &queue_context );
   _POSIX_Barrier_Free( the_barrier );
   _Objects_Allocator_unlock();
   return 0;
diff --git a/cpukit/posix/src/pbarrierwait.c b/cpukit/posix/src/pbarrierwait.c
index adfd40d..522c18e 100644
--- a/cpukit/posix/src/pbarrierwait.c
+++ b/cpukit/posix/src/pbarrierwait.c
@@ -37,14 +37,14 @@ int pthread_barrier_wait(
 )
 {
   POSIX_Barrier_Control *the_barrier;
-  ISR_lock_Context       lock_context;
+  Thread_queue_Context   queue_context;
   Thread_Control        *executing;
 
   if ( barrier == NULL ) {
     return EINVAL;
   }
 
-  the_barrier = _POSIX_Barrier_Get( barrier, &lock_context );
+  the_barrier = _POSIX_Barrier_Get( barrier, &queue_context );
 
   if ( the_barrier == NULL ) {
     return EINVAL;
@@ -56,8 +56,7 @@ int pthread_barrier_wait(
     executing,
     true,
     0,
-    NULL,
-    &lock_context
+    &queue_context
   );
   return _POSIX_Barrier_Translate_core_barrier_return_code(
     executing->Wait.return_code
diff --git a/cpukit/posix/src/prwlockdestroy.c b/cpukit/posix/src/prwlockdestroy.c
index 6f9eec8..0ced556 100644
--- a/cpukit/posix/src/prwlockdestroy.c
+++ b/cpukit/posix/src/prwlockdestroy.c
@@ -24,24 +24,24 @@ int pthread_rwlock_destroy(
 )
 {
   POSIX_RWLock_Control *the_rwlock;
-  ISR_lock_Context      lock_context;
+  Thread_queue_Context  queue_context;
 
   _Objects_Allocator_lock();
-  the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context );
+  the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context );
 
   if ( the_rwlock == NULL ) {
     _Objects_Allocator_unlock();
     return EINVAL;
   }
 
-  _CORE_RWLock_Acquire_critical( &the_rwlock->RWLock, &lock_context );
+  _CORE_RWLock_Acquire_critical( &the_rwlock->RWLock, &queue_context );
 
   /*
    *  If there is at least one thread waiting, then do not delete it.
    */
 
   if ( !_Thread_queue_Is_empty( &the_rwlock->RWLock.Wait_queue.Queue ) ) {
-    _CORE_RWLock_Release( &the_rwlock->RWLock, &lock_context );
+    _CORE_RWLock_Release( &the_rwlock->RWLock, &queue_context );
     _Objects_Allocator_unlock();
     return EBUSY;
   }
@@ -51,7 +51,7 @@ int pthread_rwlock_destroy(
    */
 
   _Objects_Close( &_POSIX_RWLock_Information, &the_rwlock->Object );
-  _CORE_RWLock_Release( &the_rwlock->RWLock, &lock_context );
+  _CORE_RWLock_Release( &the_rwlock->RWLock, &queue_context );
   _POSIX_RWLock_Free( the_rwlock );
   _Objects_Allocator_unlock();
   return 0;
diff --git a/cpukit/posix/src/prwlockinit.c b/cpukit/posix/src/prwlockinit.c
index fcf4e29..34ab1ae 100644
--- a/cpukit/posix/src/prwlockinit.c
+++ b/cpukit/posix/src/prwlockinit.c
@@ -24,14 +24,14 @@
 #include <rtems/posix/posixapi.h>
 
 POSIX_RWLock_Control *_POSIX_RWLock_Get(
-  pthread_rwlock_t *rwlock,
-  ISR_lock_Context *lock_context
+  pthread_rwlock_t     *rwlock,
+  Thread_queue_Context *queue_context
 )
 {
   _POSIX_Get_object_body(
     POSIX_RWLock_Control,
     rwlock,
-    lock_context,
+    queue_context,
     &_POSIX_RWLock_Information,
     PTHREAD_RWLOCK_INITIALIZER,
     pthread_rwlock_init
diff --git a/cpukit/posix/src/prwlockrdlock.c b/cpukit/posix/src/prwlockrdlock.c
index 3459399..e59aaf9 100644
--- a/cpukit/posix/src/prwlockrdlock.c
+++ b/cpukit/posix/src/prwlockrdlock.c
@@ -25,10 +25,10 @@ int pthread_rwlock_rdlock(
 )
 {
   POSIX_RWLock_Control *the_rwlock;
-  ISR_lock_Context      lock_context;
+  Thread_queue_Context  queue_context;
   Thread_Control       *executing;
 
-  the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context );
+  the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context );
 
   if ( the_rwlock == NULL ) {
     return EINVAL;
@@ -40,7 +40,7 @@ int pthread_rwlock_rdlock(
     executing,
     true,                 /* we are willing to wait forever */
     0,
-    &lock_context
+    &queue_context
   );
   return _POSIX_RWLock_Translate_core_RWLock_return_code(
     (CORE_RWLock_Status) executing->Wait.return_code
diff --git a/cpukit/posix/src/prwlocktimedrdlock.c b/cpukit/posix/src/prwlocktimedrdlock.c
index 829e169..9e84943 100644
--- a/cpukit/posix/src/prwlocktimedrdlock.c
+++ b/cpukit/posix/src/prwlocktimedrdlock.c
@@ -27,7 +27,7 @@ int pthread_rwlock_timedrdlock(
 )
 {
   POSIX_RWLock_Control                    *the_rwlock;
-  ISR_lock_Context                         lock_context;
+  Thread_queue_Context                     queue_context;
   Watchdog_Interval                        ticks;
   bool                                     do_wait;
   TOD_Absolute_timeout_conversion_results  status;
@@ -49,7 +49,7 @@ int pthread_rwlock_timedrdlock(
   status = _TOD_Absolute_timeout_to_ticks( abstime, &ticks );
   do_wait = ( status == TOD_ABSOLUTE_TIMEOUT_IS_IN_FUTURE );
 
-  the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context );
+  the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context );
 
   if ( the_rwlock == NULL ) {
     return EINVAL;
@@ -61,7 +61,7 @@ int pthread_rwlock_timedrdlock(
     executing,
     do_wait,
     ticks,
-    &lock_context
+    &queue_context
   );
 
   if (
diff --git a/cpukit/posix/src/prwlocktimedwrlock.c b/cpukit/posix/src/prwlocktimedwrlock.c
index 1258c2b..6be8397 100644
--- a/cpukit/posix/src/prwlocktimedwrlock.c
+++ b/cpukit/posix/src/prwlocktimedwrlock.c
@@ -29,7 +29,7 @@ int pthread_rwlock_timedwrlock(
 )
 {
   POSIX_RWLock_Control                    *the_rwlock;
-  ISR_lock_Context                         lock_context;
+  Thread_queue_Context                     queue_context;
   Watchdog_Interval                        ticks;
   bool                                     do_wait;
   TOD_Absolute_timeout_conversion_results  status;
@@ -51,7 +51,7 @@ int pthread_rwlock_timedwrlock(
   status = _TOD_Absolute_timeout_to_ticks( abstime, &ticks );
   do_wait = ( status == TOD_ABSOLUTE_TIMEOUT_IS_IN_FUTURE );
 
-  the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context );
+  the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context );
 
   if ( the_rwlock == NULL ) {
     return EINVAL;
@@ -63,7 +63,7 @@ int pthread_rwlock_timedwrlock(
     executing,
     do_wait,
     ticks,
-    &lock_context
+    &queue_context
   );
 
   if (
diff --git a/cpukit/posix/src/prwlocktryrdlock.c b/cpukit/posix/src/prwlocktryrdlock.c
index a73d122..1a7cf9e 100644
--- a/cpukit/posix/src/prwlocktryrdlock.c
+++ b/cpukit/posix/src/prwlocktryrdlock.c
@@ -25,10 +25,10 @@ int pthread_rwlock_tryrdlock(
 )
 {
   POSIX_RWLock_Control *the_rwlock;
-  ISR_lock_Context      lock_context;
+  Thread_queue_Context  queue_context;
   Thread_Control       *executing;
 
-  the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context );
+  the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context );
 
   if ( the_rwlock == NULL ) {
     return EINVAL;
@@ -40,7 +40,7 @@ int pthread_rwlock_tryrdlock(
     executing,
     false,                  /* do not wait for the rwlock */
     0,
-    &lock_context
+    &queue_context
   );
   return _POSIX_RWLock_Translate_core_RWLock_return_code(
     (CORE_RWLock_Status) executing->Wait.return_code
diff --git a/cpukit/posix/src/prwlocktrywrlock.c b/cpukit/posix/src/prwlocktrywrlock.c
index a44a54f..b6031f9 100644
--- a/cpukit/posix/src/prwlocktrywrlock.c
+++ b/cpukit/posix/src/prwlocktrywrlock.c
@@ -25,10 +25,10 @@ int pthread_rwlock_trywrlock(
 )
 {
   POSIX_RWLock_Control *the_rwlock;
-  ISR_lock_Context      lock_context;
+  Thread_queue_Context  queue_context;
   Thread_Control       *executing;
 
-  the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context );
+  the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context );
 
   if ( the_rwlock == NULL ) {
     return EINVAL;
@@ -40,7 +40,7 @@ int pthread_rwlock_trywrlock(
     executing,
     false,                 /* we are not willing to wait */
     0,
-    &lock_context
+    &queue_context
   );
   return _POSIX_RWLock_Translate_core_RWLock_return_code(
     (CORE_RWLock_Status) executing->Wait.return_code
diff --git a/cpukit/posix/src/prwlockunlock.c b/cpukit/posix/src/prwlockunlock.c
index bf6b4de..dd4337d 100644
--- a/cpukit/posix/src/prwlockunlock.c
+++ b/cpukit/posix/src/prwlockunlock.c
@@ -27,15 +27,15 @@ int pthread_rwlock_unlock(
 )
 {
   POSIX_RWLock_Control *the_rwlock;
-  ISR_lock_Context      lock_context;
+  Thread_queue_Context  queue_context;
   CORE_RWLock_Status    status;
 
-  the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context );
+  the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context );
 
   if ( the_rwlock == NULL ) {
     return EINVAL;
   }
 
-  status = _CORE_RWLock_Surrender( &the_rwlock->RWLock, &lock_context );
+  status = _CORE_RWLock_Surrender( &the_rwlock->RWLock, &queue_context );
   return _POSIX_RWLock_Translate_core_RWLock_return_code( status );
 }
diff --git a/cpukit/posix/src/prwlockwrlock.c b/cpukit/posix/src/prwlockwrlock.c
index 5683163..84a4e0f 100644
--- a/cpukit/posix/src/prwlockwrlock.c
+++ b/cpukit/posix/src/prwlockwrlock.c
@@ -32,10 +32,10 @@ int pthread_rwlock_wrlock(
 )
 {
   POSIX_RWLock_Control *the_rwlock;
-  ISR_lock_Context      lock_context;
+  Thread_queue_Context  queue_context;
   Thread_Control       *executing;
 
-  the_rwlock = _POSIX_RWLock_Get( rwlock, &lock_context );
+  the_rwlock = _POSIX_RWLock_Get( rwlock, &queue_context );
 
   if ( the_rwlock == NULL ) {
     return EINVAL;
@@ -47,7 +47,7 @@ int pthread_rwlock_wrlock(
     executing,
     true,          /* do not timeout -- wait forever */
     0,
-    &lock_context
+    &queue_context
   );
   return _POSIX_RWLock_Translate_core_RWLock_return_code(
     (CORE_RWLock_Status) executing->Wait.return_code
diff --git a/cpukit/posix/src/semaphoredeletesupp.c b/cpukit/posix/src/semaphoredeletesupp.c
index c205b12..2d39b2a 100644
--- a/cpukit/posix/src/semaphoredeletesupp.c
+++ b/cpukit/posix/src/semaphoredeletesupp.c
@@ -22,18 +22,14 @@
 
 void _POSIX_Semaphore_Delete(
   POSIX_Semaphore_Control *the_semaphore,
-  ISR_lock_Context        *lock_context
+  Thread_queue_Context    *queue_context
 )
 {
   if ( !the_semaphore->linked && !the_semaphore->open_count ) {
     _Objects_Close( &_POSIX_Semaphore_Information, &the_semaphore->Object );
-    _CORE_semaphore_Destroy(
-      &the_semaphore->Semaphore,
-      NULL,
-      lock_context
-    );
+    _CORE_semaphore_Destroy( &the_semaphore->Semaphore, queue_context );
     _POSIX_Semaphore_Free( the_semaphore );
   } else {
-    _CORE_semaphore_Release( &the_semaphore->Semaphore, lock_context );
+    _CORE_semaphore_Release( &the_semaphore->Semaphore, queue_context );
   }
 }
diff --git a/cpukit/posix/src/semaphorewaitsupp.c b/cpukit/posix/src/semaphorewaitsupp.c
index f08efa8..9382107 100644
--- a/cpukit/posix/src/semaphorewaitsupp.c
+++ b/cpukit/posix/src/semaphorewaitsupp.c
@@ -32,9 +32,9 @@ int _POSIX_Semaphore_Wait_support(
 {
   POSIX_Semaphore_Control *the_semaphore;
   Thread_Control          *executing;
-  ISR_lock_Context         lock_context;
+  Thread_queue_Context     queue_context;
 
-  the_semaphore = _POSIX_Semaphore_Get( sem, &lock_context );
+  the_semaphore = _POSIX_Semaphore_Get( sem, &queue_context );
 
   if ( the_semaphore == NULL ) {
     rtems_set_errno_and_return_minus_one( EINVAL );
@@ -47,7 +47,7 @@ int _POSIX_Semaphore_Wait_support(
     executing,
     blocking,
     timeout,
-    &lock_context
+    &queue_context
   );
 
   if ( executing->Wait.return_code == CORE_SEMAPHORE_STATUS_SUCCESSFUL ) {
diff --git a/cpukit/posix/src/semclose.c b/cpukit/posix/src/semclose.c
index 3f18ff1..ebcf7a2 100644
--- a/cpukit/posix/src/semclose.c
+++ b/cpukit/posix/src/semclose.c
@@ -27,10 +27,10 @@ int sem_close(
 )
 {
   POSIX_Semaphore_Control *the_semaphore;
-  ISR_lock_Context         lock_context;
+  Thread_queue_Context     queue_context;
 
   _Objects_Allocator_lock();
-  the_semaphore = _POSIX_Semaphore_Get( sem, &lock_context );
+  the_semaphore = _POSIX_Semaphore_Get( sem, &queue_context );
 
   if ( the_semaphore == NULL ) {
     _Objects_Allocator_unlock();
@@ -39,10 +39,10 @@ int sem_close(
 
   _CORE_semaphore_Acquire_critical(
     &the_semaphore->Semaphore,
-    &lock_context
+    &queue_context
   );
   the_semaphore->open_count -= 1;
-  _POSIX_Semaphore_Delete( the_semaphore, &lock_context );
+  _POSIX_Semaphore_Delete( the_semaphore, &queue_context );
 
   _Objects_Allocator_unlock();
   return 0;
diff --git a/cpukit/posix/src/semdestroy.c b/cpukit/posix/src/semdestroy.c
index 5264472..8b81470 100644
--- a/cpukit/posix/src/semdestroy.c
+++ b/cpukit/posix/src/semdestroy.c
@@ -27,10 +27,10 @@ int sem_destroy(
 )
 {
   POSIX_Semaphore_Control *the_semaphore;
-  ISR_lock_Context         lock_context;
+  Thread_queue_Context     queue_context;
 
   _Objects_Allocator_lock();
-  the_semaphore = _POSIX_Semaphore_Get( sem, &lock_context );
+  the_semaphore = _POSIX_Semaphore_Get( sem, &queue_context );
 
   if ( the_semaphore == NULL ) {
     _Objects_Allocator_unlock();
@@ -39,17 +39,17 @@ int sem_destroy(
 
   _CORE_semaphore_Acquire_critical(
     &the_semaphore->Semaphore,
-    &lock_context
+    &queue_context
   );
 
   if ( the_semaphore->named ) {
     /* Undefined operation on a named semaphore */
-    _CORE_semaphore_Release( &the_semaphore->Semaphore, &lock_context );
+    _CORE_semaphore_Release( &the_semaphore->Semaphore, &queue_context );
     _Objects_Allocator_unlock();
     rtems_set_errno_and_return_minus_one( EINVAL );
   }
 
-  _POSIX_Semaphore_Delete( the_semaphore, &lock_context );
+  _POSIX_Semaphore_Delete( the_semaphore, &queue_context );
 
   _Objects_Allocator_unlock();
   return 0;
diff --git a/cpukit/posix/src/semgetvalue.c b/cpukit/posix/src/semgetvalue.c
index 63e3823..1b75294 100644
--- a/cpukit/posix/src/semgetvalue.c
+++ b/cpukit/posix/src/semgetvalue.c
@@ -28,20 +28,21 @@ int sem_getvalue(
 )
 {
   POSIX_Semaphore_Control *the_semaphore;
-  ISR_lock_Context         lock_context;
+  Thread_queue_Context     queue_context;
 
-  the_semaphore = _POSIX_Semaphore_Get( sem, &lock_context );
+  the_semaphore = _POSIX_Semaphore_Get( sem, &queue_context );
 
   if ( the_semaphore == NULL ) {
     rtems_set_errno_and_return_minus_one( EINVAL );
   }
 
-  /*
-   * Assume a relaxed atomic load of the value on SMP configurations.
-   * Thus, there is no need to acquire a lock.
-   */
+  _CORE_semaphore_Acquire_critical(
+    &the_semaphore->Semaphore,
+    &queue_context
+  );
+
   *sval = _CORE_semaphore_Get_count( &the_semaphore->Semaphore );
 
-  _ISR_lock_ISR_enable( &lock_context );
+  _CORE_semaphore_Release( &the_semaphore->Semaphore, &queue_context );
   return 0;
 }
diff --git a/cpukit/posix/src/sempost.c b/cpukit/posix/src/sempost.c
index 313ff3c..86d2f5a 100644
--- a/cpukit/posix/src/sempost.c
+++ b/cpukit/posix/src/sempost.c
@@ -27,9 +27,9 @@ int sem_post(
 )
 {
   POSIX_Semaphore_Control *the_semaphore;
-  ISR_lock_Context         lock_context;
+  Thread_queue_Context     queue_context;
 
-  the_semaphore = _POSIX_Semaphore_Get( sem, &lock_context );
+  the_semaphore = _POSIX_Semaphore_Get( sem, &queue_context );
 
   if ( the_semaphore == NULL ) {
     rtems_set_errno_and_return_minus_one( EINVAL );
@@ -37,8 +37,7 @@ int sem_post(
 
   _CORE_semaphore_Surrender(
     &the_semaphore->Semaphore,
-    NULL,
-    &lock_context
+    &queue_context
   );
   return 0;
 }
diff --git a/cpukit/posix/src/semunlink.c b/cpukit/posix/src/semunlink.c
index 665aa73..6ba1df1 100644
--- a/cpukit/posix/src/semunlink.c
+++ b/cpukit/posix/src/semunlink.c
@@ -28,7 +28,7 @@ int sem_unlink(
 {
   POSIX_Semaphore_Control   *the_semaphore;
   Objects_Get_by_name_error  error;
-  ISR_lock_Context           lock_context;
+  Thread_queue_Context       queue_context;
 
   _Objects_Allocator_lock();
 
@@ -40,10 +40,10 @@ int sem_unlink(
 
   _POSIX_Semaphore_Namespace_remove( the_semaphore );
 
-  _ISR_lock_ISR_disable( &lock_context );
-  _CORE_semaphore_Acquire_critical( &the_semaphore->Semaphore, &lock_context );
+  _ISR_lock_ISR_disable( &queue_context.Lock_context );
+  _CORE_semaphore_Acquire_critical( &the_semaphore->Semaphore, &queue_context );
   the_semaphore->linked = false;
-  _POSIX_Semaphore_Delete( the_semaphore, &lock_context );
+  _POSIX_Semaphore_Delete( the_semaphore, &queue_context );
 
   _Objects_Allocator_unlock();
   return 0;
diff --git a/cpukit/rtems/include/rtems/rtems/barrierimpl.h b/cpukit/rtems/include/rtems/rtems/barrierimpl.h
index 39632fc..0eaadfc 100644
--- a/cpukit/rtems/include/rtems/rtems/barrierimpl.h
+++ b/cpukit/rtems/include/rtems/rtems/barrierimpl.h
@@ -70,12 +70,13 @@ RTEMS_INLINE_ROUTINE void _Barrier_Free (
 }
 
 RTEMS_INLINE_ROUTINE Barrier_Control *_Barrier_Get(
-  Objects_Id        id,
-  ISR_lock_Context *lock_context
+  Objects_Id            id,
+  Thread_queue_Context *queue_context
 )
 {
+  _Thread_queue_Context_initialize( queue_context, NULL );
   return (Barrier_Control *)
-    _Objects_Get( id, lock_context, &_Barrier_Information );
+    _Objects_Get( id, &queue_context->Lock_context, &_Barrier_Information );
 }
 
 /**
diff --git a/cpukit/rtems/include/rtems/rtems/messageimpl.h b/cpukit/rtems/include/rtems/rtems/messageimpl.h
index 199af1c..d6217f1 100644
--- a/cpukit/rtems/include/rtems/rtems/messageimpl.h
+++ b/cpukit/rtems/include/rtems/rtems/messageimpl.h
@@ -101,18 +101,31 @@ RTEMS_INLINE_ROUTINE void _Message_queue_Free (
   _Objects_Free( &_Message_queue_Information, &the_message_queue->Object );
 }
 
-RTEMS_INLINE_ROUTINE Message_queue_Control * _Message_queue_Get(
-  Objects_Id         id,
-  ISR_lock_Context  *lock_context
+RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Do_get(
+  Objects_Id               id,
+  Thread_queue_Context    *queue_context
+#if defined(RTEMS_MULTIPROCESSING)
+  ,
+  Thread_queue_MP_callout  mp_callout
+#endif
 )
 {
+  _Thread_queue_Context_initialize( queue_context, mp_callout );
   return (Message_queue_Control *) _Objects_Get(
     id,
-    lock_context,
+    &queue_context->Lock_context,
     &_Message_queue_Information
   );
 }
 
+#if defined(RTEMS_MULTIPROCESSING)
+  #define _Message_queue_Get( id, queue_context, mp_callout ) \
+    _Message_queue_Do_get( id, queue_context, mp_callout )
+#else
+  #define _Message_queue_Get( id, queue_context, mp_callout ) \
+    _Message_queue_Do_get( id, queue_context )
+#endif
+
 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Allocate( void )
 {
   return (Message_queue_Control *)
diff --git a/cpukit/rtems/include/rtems/rtems/semimpl.h b/cpukit/rtems/include/rtems/rtems/semimpl.h
index ac55bc7..c23bef9 100644
--- a/cpukit/rtems/include/rtems/rtems/semimpl.h
+++ b/cpukit/rtems/include/rtems/rtems/semimpl.h
@@ -134,18 +134,31 @@ RTEMS_INLINE_ROUTINE void _Semaphore_Free (
   _Objects_Free( &_Semaphore_Information, &the_semaphore->Object );
 }
 
-RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Get(
-  Objects_Id         id,
-  ISR_lock_Context  *lock_context
+RTEMS_INLINE_ROUTINE Semaphore_Control *_Semaphore_Do_get(
+  Objects_Id               id,
+  Thread_queue_Context    *queue_context
+#if defined(RTEMS_MULTIPROCESSING)
+  ,
+  Thread_queue_MP_callout  mp_callout
+#endif
 )
 {
+  _Thread_queue_Context_initialize( queue_context, mp_callout );
   return (Semaphore_Control *) _Objects_Get(
     id,
-    lock_context,
+    &queue_context->Lock_context,
     &_Semaphore_Information
   );
 }
 
+#if defined(RTEMS_MULTIPROCESSING)
+  #define _Semaphore_Get( id, queue_context, mp_callout ) \
+    _Semaphore_Do_get( id, queue_context, mp_callout )
+#else
+  #define _Semaphore_Get( id, queue_context, mp_callout ) \
+    _Semaphore_Do_get( id, queue_context )
+#endif
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/cpukit/rtems/src/barrierdelete.c b/cpukit/rtems/src/barrierdelete.c
index 05d6a3f..3d57908 100644
--- a/cpukit/rtems/src/barrierdelete.c
+++ b/cpukit/rtems/src/barrierdelete.c
@@ -24,20 +24,20 @@ rtems_status_code rtems_barrier_delete(
   rtems_id   id
 )
 {
-  Barrier_Control  *the_barrier;
-  ISR_lock_Context  lock_context;
+  Barrier_Control      *the_barrier;
+  Thread_queue_Context  queue_context;
 
   _Objects_Allocator_lock();
-  the_barrier = _Barrier_Get( id, &lock_context );
+  the_barrier = _Barrier_Get( id, &queue_context );
 
   if ( the_barrier == NULL ) {
     _Objects_Allocator_unlock();
     return RTEMS_INVALID_ID;
   }
 
-  _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &lock_context );
+  _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &queue_context );
   _Objects_Close( &_Barrier_Information, &the_barrier->Object );
-  _CORE_barrier_Flush( &the_barrier->Barrier, NULL, &lock_context );
+  _CORE_barrier_Flush( &the_barrier->Barrier, &queue_context );
   _Barrier_Free( the_barrier );
   _Objects_Allocator_unlock();
   return RTEMS_SUCCESSFUL;
diff --git a/cpukit/rtems/src/barrierrelease.c b/cpukit/rtems/src/barrierrelease.c
index 2c7d222..2c7f72d 100644
--- a/cpukit/rtems/src/barrierrelease.c
+++ b/cpukit/rtems/src/barrierrelease.c
@@ -25,24 +25,23 @@ rtems_status_code rtems_barrier_release(
   uint32_t         *released
 )
 {
-  Barrier_Control  *the_barrier;
-  ISR_lock_Context  lock_context;
+  Barrier_Control      *the_barrier;
+  Thread_queue_Context  queue_context;
 
   if ( released == NULL ) {
     return RTEMS_INVALID_ADDRESS;
   }
 
-  the_barrier = _Barrier_Get( id, &lock_context );
+  the_barrier = _Barrier_Get( id, &queue_context );
 
   if ( the_barrier == NULL ) {
     return RTEMS_INVALID_ID;
   }
 
-  _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &lock_context );
+  _CORE_barrier_Acquire_critical( &the_barrier->Barrier, &queue_context );
   *released = _CORE_barrier_Surrender(
     &the_barrier->Barrier,
-    NULL,
-    &lock_context
+    &queue_context
   );
   return RTEMS_SUCCESSFUL;
 }
diff --git a/cpukit/rtems/src/barrierwait.c b/cpukit/rtems/src/barrierwait.c
index 7f463aa..6e13375 100644
--- a/cpukit/rtems/src/barrierwait.c
+++ b/cpukit/rtems/src/barrierwait.c
@@ -27,11 +27,11 @@ rtems_status_code rtems_barrier_wait(
   rtems_interval  timeout
 )
 {
-  Barrier_Control  *the_barrier;
-  ISR_lock_Context  lock_context;
-  Thread_Control   *executing;
+  Barrier_Control      *the_barrier;
+  Thread_queue_Context  queue_context;
+  Thread_Control       *executing;
 
-  the_barrier = _Barrier_Get( id, &lock_context );
+  the_barrier = _Barrier_Get( id, &queue_context );
 
   if ( the_barrier == NULL ) {
     return RTEMS_INVALID_ID;
@@ -43,8 +43,7 @@ rtems_status_code rtems_barrier_wait(
     executing,
     true,
     timeout,
-    NULL,
-    &lock_context
+    &queue_context
   );
   return _Barrier_Translate_core_barrier_return_code(
     executing->Wait.return_code
diff --git a/cpukit/rtems/src/msgmp.c b/cpukit/rtems/src/msgmp.c
index c336ba4..d8077a7 100644
--- a/cpukit/rtems/src/msgmp.c
+++ b/cpukit/rtems/src/msgmp.c
@@ -576,17 +576,7 @@ void _Message_queue_MP_Send_extract_proxy (
   );
 }
 
-/*
- *  _Message_queue_Core_message_queue_mp_support
- *
- *  Input parameters:
- *    the_thread - the remote thread the message was submitted to
- *    id         - id of the message queue
- *
- *  Output parameters: NONE
- */
-
-void  _Message_queue_Core_message_queue_mp_support (
+void  _Message_queue_Core_message_queue_mp_support(
   Thread_Control *the_thread,
   Objects_Id      id
 )
diff --git a/cpukit/rtems/src/msgqbroadcast.c b/cpukit/rtems/src/msgqbroadcast.c
index 45d9097..75f9d60 100644
--- a/cpukit/rtems/src/msgqbroadcast.c
+++ b/cpukit/rtems/src/msgqbroadcast.c
@@ -28,7 +28,7 @@ rtems_status_code rtems_message_queue_broadcast(
 )
 {
   Message_queue_Control     *the_message_queue;
-  ISR_lock_Context           lock_context;
+  Thread_queue_Context       queue_context;
   CORE_message_queue_Status  status;
 
   if ( buffer == NULL ) {
@@ -39,7 +39,11 @@ rtems_status_code rtems_message_queue_broadcast(
     return RTEMS_INVALID_ADDRESS;
   }
 
-  the_message_queue = _Message_queue_Get( id, &lock_context );
+  the_message_queue = _Message_queue_Get(
+    id,
+    &queue_context,
+    _Message_queue_Core_message_queue_mp_support
+  );
 
   if ( the_message_queue == NULL ) {
 #if defined(RTEMS_MULTIPROCESSING)
@@ -53,9 +57,8 @@ rtems_status_code rtems_message_queue_broadcast(
     &the_message_queue->message_queue,
     buffer,
     size,
-    _Message_queue_Core_message_queue_mp_support,
     count,
-    &lock_context
+    &queue_context
   );
   return _Message_queue_Translate_core_message_queue_return_code( status );
 }
diff --git a/cpukit/rtems/src/msgqdelete.c b/cpukit/rtems/src/msgqdelete.c
index c39cfea..94175e6 100644
--- a/cpukit/rtems/src/msgqdelete.c
+++ b/cpukit/rtems/src/msgqdelete.c
@@ -26,10 +26,14 @@ rtems_status_code rtems_message_queue_delete(
 )
 {
   Message_queue_Control *the_message_queue;
-  ISR_lock_Context       lock_context;
+  Thread_queue_Context   queue_context;
 
   _Objects_Allocator_lock();
-  the_message_queue = _Message_queue_Get( id, &lock_context );
+  the_message_queue = _Message_queue_Get(
+    id,
+    &queue_context,
+    _Message_queue_MP_Send_object_was_deleted
+  );
 
   if ( the_message_queue == NULL ) {
     _Objects_Allocator_unlock();
@@ -45,15 +49,14 @@ rtems_status_code rtems_message_queue_delete(
 
   _CORE_message_queue_Acquire_critical(
     &the_message_queue->message_queue,
-    &lock_context
+    &queue_context
   );
 
   _Objects_Close( &_Message_queue_Information, &the_message_queue->Object );
 
   _CORE_message_queue_Close(
     &the_message_queue->message_queue,
-    _Message_queue_MP_Send_object_was_deleted,
-    &lock_context
+    &queue_context
   );
 
 #if defined(RTEMS_MULTIPROCESSING)
diff --git a/cpukit/rtems/src/msgqflush.c b/cpukit/rtems/src/msgqflush.c
index baca176..b4419d1 100644
--- a/cpukit/rtems/src/msgqflush.c
+++ b/cpukit/rtems/src/msgqflush.c
@@ -26,13 +26,13 @@ rtems_status_code rtems_message_queue_flush(
 )
 {
   Message_queue_Control *the_message_queue;
-  ISR_lock_Context       lock_context;
+  Thread_queue_Context   queue_context;
 
   if ( count == NULL ) {
     return RTEMS_INVALID_ADDRESS;
   }
 
-  the_message_queue = _Message_queue_Get( id, &lock_context );
+  the_message_queue = _Message_queue_Get( id, &queue_context, NULL );
 
   if ( the_message_queue == NULL ) {
 #if defined(RTEMS_MULTIPROCESSING)
@@ -44,7 +44,7 @@ rtems_status_code rtems_message_queue_flush(
 
   *count = _CORE_message_queue_Flush(
     &the_message_queue->message_queue,
-    &lock_context
+    &queue_context
   );
   return RTEMS_SUCCESSFUL;
 }
diff --git a/cpukit/rtems/src/msgqgetnumberpending.c b/cpukit/rtems/src/msgqgetnumberpending.c
index f655c0b..d2f7820 100644
--- a/cpukit/rtems/src/msgqgetnumberpending.c
+++ b/cpukit/rtems/src/msgqgetnumberpending.c
@@ -26,13 +26,13 @@ rtems_status_code rtems_message_queue_get_number_pending(
 )
 {
   Message_queue_Control *the_message_queue;
-  ISR_lock_Context       lock_context;
+  Thread_queue_Context   queue_context;
 
   if ( count == NULL ) {
     return RTEMS_INVALID_ADDRESS;
   }
 
-  the_message_queue = _Message_queue_Get( id, &lock_context );
+  the_message_queue = _Message_queue_Get( id, &queue_context, NULL );
 
   if ( the_message_queue == NULL ) {
 #if defined(RTEMS_MULTIPROCESSING)
@@ -44,12 +44,12 @@ rtems_status_code rtems_message_queue_get_number_pending(
 
   _CORE_message_queue_Acquire_critical(
     &the_message_queue->message_queue,
-    &lock_context
+    &queue_context
   );
   *count = the_message_queue->message_queue.number_of_pending_messages;
   _CORE_message_queue_Release(
     &the_message_queue->message_queue,
-    &lock_context
+    &queue_context
   );
   return RTEMS_SUCCESSFUL;
 }
diff --git a/cpukit/rtems/src/msgqreceive.c b/cpukit/rtems/src/msgqreceive.c
index dada8df..6ed3d25 100644
--- a/cpukit/rtems/src/msgqreceive.c
+++ b/cpukit/rtems/src/msgqreceive.c
@@ -32,7 +32,7 @@ rtems_status_code rtems_message_queue_receive(
 )
 {
   Message_queue_Control *the_message_queue;
-  ISR_lock_Context       lock_context;
+  Thread_queue_Context   queue_context;
   Thread_Control        *executing;
 
   if ( buffer == NULL ) {
@@ -43,7 +43,7 @@ rtems_status_code rtems_message_queue_receive(
     return RTEMS_INVALID_ADDRESS;
   }
 
-  the_message_queue = _Message_queue_Get( id, &lock_context );
+  the_message_queue = _Message_queue_Get( id, &queue_context, NULL );
 
   if ( the_message_queue == NULL ) {
 #if defined(RTEMS_MULTIPROCESSING)
@@ -55,7 +55,7 @@ rtems_status_code rtems_message_queue_receive(
 
   _CORE_message_queue_Acquire_critical(
     &the_message_queue->message_queue,
-    &lock_context
+    &queue_context
   );
 
   executing = _Thread_Executing;
@@ -66,7 +66,7 @@ rtems_status_code rtems_message_queue_receive(
     size,
     !_Options_Is_no_wait( option_set ),
     timeout,
-    &lock_context
+    &queue_context
   );
   return _Message_queue_Translate_core_message_queue_return_code(
     executing->Wait.return_code
diff --git a/cpukit/rtems/src/msgqsend.c b/cpukit/rtems/src/msgqsend.c
index c306deb..c5bde9d 100644
--- a/cpukit/rtems/src/msgqsend.c
+++ b/cpukit/rtems/src/msgqsend.c
@@ -27,14 +27,18 @@ rtems_status_code rtems_message_queue_send(
 )
 {
   Message_queue_Control     *the_message_queue;
-  ISR_lock_Context           lock_context;
+  Thread_queue_Context       queue_context;
   CORE_message_queue_Status  status;
 
   if ( buffer == NULL ) {
     return RTEMS_INVALID_ADDRESS;
   }
 
-  the_message_queue = _Message_queue_Get( id, &lock_context );
+  the_message_queue = _Message_queue_Get(
+    id,
+    &queue_context,
+    _Message_queue_Core_message_queue_mp_support
+  );
 
   if ( the_message_queue == NULL ) {
 #if defined(RTEMS_MULTIPROCESSING)
@@ -46,16 +50,15 @@ rtems_status_code rtems_message_queue_send(
 
   _CORE_message_queue_Acquire_critical(
     &the_message_queue->message_queue,
-    &lock_context
+    &queue_context
   );
   status = _CORE_message_queue_Send(
     &the_message_queue->message_queue,
     buffer,
     size,
-    _Message_queue_Core_message_queue_mp_support,
     false,   /* sender does not block */
     0,       /* no timeout */
-    &lock_context
+    &queue_context
   );
 
   /*
diff --git a/cpukit/rtems/src/msgqurgent.c b/cpukit/rtems/src/msgqurgent.c
index 56522a1..add5f09 100644
--- a/cpukit/rtems/src/msgqurgent.c
+++ b/cpukit/rtems/src/msgqurgent.c
@@ -27,14 +27,18 @@ rtems_status_code rtems_message_queue_urgent(
 )
 {
   Message_queue_Control     *the_message_queue;
-  ISR_lock_Context           lock_context;
+  Thread_queue_Context       queue_context;
   CORE_message_queue_Status  status;
 
   if ( buffer == NULL ) {
     return RTEMS_INVALID_ADDRESS;
   }
 
-  the_message_queue = _Message_queue_Get( id, &lock_context );
+  the_message_queue = _Message_queue_Get(
+    id,
+    &queue_context,
+    _Message_queue_Core_message_queue_mp_support
+  );
 
   if ( the_message_queue == NULL ) {
 #if defined(RTEMS_MULTIPROCESSING)
@@ -46,16 +50,15 @@ rtems_status_code rtems_message_queue_urgent(
 
   _CORE_message_queue_Acquire_critical(
     &the_message_queue->message_queue,
-    &lock_context
+    &queue_context
   );
   status = _CORE_message_queue_Urgent(
     &the_message_queue->message_queue,
     buffer,
     size,
-    _Message_queue_Core_message_queue_mp_support,
     false,   /* sender does not block */
     0,       /* no timeout */
-    &lock_context
+    &queue_context
   );
 
   /*
diff --git a/cpukit/rtems/src/semdelete.c b/cpukit/rtems/src/semdelete.c
index cf22838..023a57c 100644
--- a/cpukit/rtems/src/semdelete.c
+++ b/cpukit/rtems/src/semdelete.c
@@ -25,12 +25,16 @@ rtems_status_code rtems_semaphore_delete(
   rtems_id   id
 )
 {
-  Semaphore_Control *the_semaphore;
-  ISR_lock_Context   lock_context;
-  rtems_attribute    attribute_set;
+  Semaphore_Control    *the_semaphore;
+  Thread_queue_Context  queue_context;
+  rtems_attribute       attribute_set;
 
   _Objects_Allocator_lock();
-  the_semaphore = _Semaphore_Get( id, &lock_context );
+  the_semaphore = _Semaphore_Get(
+    id,
+    &queue_context,
+    _Semaphore_MP_Send_object_was_deleted
+  );
 
   if ( the_semaphore == NULL ) {
     _Objects_Allocator_unlock();
@@ -52,13 +56,13 @@ rtems_status_code rtems_semaphore_delete(
 
     _MRSP_Acquire_critical(
       &the_semaphore->Core_control.mrsp,
-      &lock_context
+      &queue_context
     );
     mrsp_status = _MRSP_Can_destroy( &the_semaphore->Core_control.mrsp );
     if ( mrsp_status != MRSP_SUCCESSFUL ) {
       _MRSP_Release(
         &the_semaphore->Core_control.mrsp,
-        &lock_context
+        &queue_context
       );
       _Objects_Allocator_unlock();
       return _Semaphore_Translate_MRSP_status_code( mrsp_status );
@@ -68,7 +72,7 @@ rtems_status_code rtems_semaphore_delete(
   if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
     _CORE_mutex_Acquire_critical(
       &the_semaphore->Core_control.mutex,
-      &lock_context
+      &queue_context
     );
 
     if (
@@ -77,7 +81,7 @@ rtems_status_code rtems_semaphore_delete(
     ) {
       _CORE_mutex_Release(
         &the_semaphore->Core_control.mutex,
-        &lock_context
+        &queue_context
       );
       _Objects_Allocator_unlock();
       return RTEMS_RESOURCE_IN_USE;
@@ -85,7 +89,7 @@ rtems_status_code rtems_semaphore_delete(
   } else {
     _CORE_semaphore_Acquire_critical(
       &the_semaphore->Core_control.semaphore,
-      &lock_context
+      &queue_context
     );
   }
 
@@ -93,22 +97,20 @@ rtems_status_code rtems_semaphore_delete(
 
 #if defined(RTEMS_SMP)
   if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
-    _MRSP_Destroy( &the_semaphore->Core_control.mrsp, &lock_context );
+    _MRSP_Destroy( &the_semaphore->Core_control.mrsp, &queue_context );
   } else
 #endif
   if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
     _CORE_mutex_Flush(
       &the_semaphore->Core_control.mutex,
       _CORE_mutex_Was_deleted,
-      _Semaphore_MP_Send_object_was_deleted,
-      &lock_context
+      &queue_context
     );
     _CORE_mutex_Destroy( &the_semaphore->Core_control.mutex );
   } else {
     _CORE_semaphore_Destroy(
       &the_semaphore->Core_control.semaphore,
-      _Semaphore_MP_Send_object_was_deleted,
-      &lock_context
+      &queue_context
     );
   }
 
diff --git a/cpukit/rtems/src/semflush.c b/cpukit/rtems/src/semflush.c
index 73e9ad0..b18de6d 100644
--- a/cpukit/rtems/src/semflush.c
+++ b/cpukit/rtems/src/semflush.c
@@ -23,11 +23,15 @@
 
 rtems_status_code rtems_semaphore_flush( rtems_id id )
 {
-  Semaphore_Control *the_semaphore;
-  ISR_lock_Context   lock_context;
-  rtems_attribute    attribute_set;
+  Semaphore_Control    *the_semaphore;
+  Thread_queue_Context  queue_context;
+  rtems_attribute       attribute_set;
 
-  the_semaphore = _Semaphore_Get( id, &lock_context );
+  the_semaphore = _Semaphore_Get(
+    id,
+    &queue_context,
+    _Semaphore_MP_Send_object_was_deleted
+  );
 
   if ( the_semaphore == NULL ) {
 #if defined(RTEMS_MULTIPROCESSING)
@@ -43,30 +47,28 @@ rtems_status_code rtems_semaphore_flush( rtems_id id )
 
 #if defined(RTEMS_SMP)
   if ( _Attributes_Is_multiprocessor_resource_sharing( attribute_set ) ) {
-    _ISR_lock_ISR_enable( &lock_context );
+    _ISR_lock_ISR_enable( &queue_context.Lock_context );
     return RTEMS_NOT_DEFINED;
   } else
 #endif
   if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
     _CORE_mutex_Acquire_critical(
       &the_semaphore->Core_control.mutex,
-      &lock_context
+      &queue_context
     );
     _CORE_mutex_Flush(
       &the_semaphore->Core_control.mutex,
       _CORE_mutex_Unsatisfied_nowait,
-      _Semaphore_MP_Send_object_was_deleted,
-      &lock_context
+      &queue_context
     );
   } else {
     _CORE_semaphore_Acquire_critical(
       &the_semaphore->Core_control.semaphore,
-      &lock_context
+      &queue_context
     );
     _CORE_semaphore_Flush(
       &the_semaphore->Core_control.semaphore,
-      _Semaphore_MP_Send_object_was_deleted,
-      &lock_context
+      &queue_context
     );
   }
   return RTEMS_SUCCESSFUL;
diff --git a/cpukit/rtems/src/semobtain.c b/cpukit/rtems/src/semobtain.c
index 3cf780a..6d994f4 100644
--- a/cpukit/rtems/src/semobtain.c
+++ b/cpukit/rtems/src/semobtain.c
@@ -38,13 +38,13 @@ rtems_status_code rtems_semaphore_obtain(
   rtems_interval  timeout
 )
 {
-  Semaphore_Control *the_semaphore;
-  ISR_lock_Context   lock_context;
-  Thread_Control    *executing;
-  rtems_attribute    attribute_set;
-  bool               wait;
+  Semaphore_Control    *the_semaphore;
+  Thread_queue_Context  queue_context;
+  Thread_Control       *executing;
+  rtems_attribute       attribute_set;
+  bool                  wait;
 
-  the_semaphore = _Semaphore_Get( id, &lock_context );
+  the_semaphore = _Semaphore_Get( id, &queue_context, NULL );
 
   if ( the_semaphore == NULL ) {
 #if defined(RTEMS_MULTIPROCESSING)
@@ -66,7 +66,7 @@ rtems_status_code rtems_semaphore_obtain(
       executing,
       wait,
       timeout,
-      &lock_context
+      &queue_context
     );
     return _Semaphore_Translate_MRSP_status_code( mrsp_status );
   } else
@@ -77,7 +77,7 @@ rtems_status_code rtems_semaphore_obtain(
       executing,
       wait,
       timeout,
-      &lock_context
+      &queue_context
     );
     return _Semaphore_Translate_core_mutex_return_code(
       executing->Wait.return_code
@@ -90,7 +90,7 @@ rtems_status_code rtems_semaphore_obtain(
     executing,
     wait,
     timeout,
-    &lock_context
+    &queue_context
   );
   return _Semaphore_Translate_core_semaphore_return_code(
     executing->Wait.return_code
diff --git a/cpukit/rtems/src/semrelease.c b/cpukit/rtems/src/semrelease.c
index c39455c..197e4d8 100644
--- a/cpukit/rtems/src/semrelease.c
+++ b/cpukit/rtems/src/semrelease.c
@@ -30,9 +30,13 @@ rtems_status_code rtems_semaphore_release( rtems_id id )
   CORE_mutex_Status      mutex_status;
   CORE_semaphore_Status  semaphore_status;
   rtems_attribute        attribute_set;
-  ISR_lock_Context       lock_context;
+  Thread_queue_Context   queue_context;
 
-  the_semaphore = _Semaphore_Get( id, &lock_context );
+  the_semaphore = _Semaphore_Get(
+    id,
+    &queue_context,
+    _Semaphore_Core_mutex_mp_support
+  );
 
   if ( the_semaphore == NULL ) {
 #if defined(RTEMS_MULTIPROCESSING)
@@ -50,7 +54,7 @@ rtems_status_code rtems_semaphore_release( rtems_id id )
     mrsp_status = _MRSP_Surrender(
       &the_semaphore->Core_control.mrsp,
       _Thread_Executing,
-      &lock_context
+      &queue_context
     );
     return _Semaphore_Translate_MRSP_status_code( mrsp_status );
   } else
@@ -58,15 +62,13 @@ rtems_status_code rtems_semaphore_release( rtems_id id )
   if ( !_Attributes_Is_counting_semaphore( attribute_set ) ) {
     mutex_status = _CORE_mutex_Surrender(
       &the_semaphore->Core_control.mutex,
-      _Semaphore_Core_mutex_mp_support,
-      &lock_context
+      &queue_context
     );
     return _Semaphore_Translate_core_mutex_return_code( mutex_status );
   } else {
     semaphore_status = _CORE_semaphore_Surrender(
       &the_semaphore->Core_control.semaphore,
-      _Semaphore_Core_mutex_mp_support,
-      &lock_context
+      &queue_context
     );
     return _Semaphore_Translate_core_semaphore_return_code( semaphore_status );
   }
diff --git a/cpukit/rtems/src/semsetpriority.c b/cpukit/rtems/src/semsetpriority.c
index 18fb66a..4deee3d 100644
--- a/cpukit/rtems/src/semsetpriority.c
+++ b/cpukit/rtems/src/semsetpriority.c
@@ -22,11 +22,11 @@
 #include <rtems/score/schedulerimpl.h>
 
 static rtems_status_code _Semaphore_Set_priority(
-  Semaphore_Control   *the_semaphore,
-  rtems_id             scheduler_id,
-  rtems_task_priority  new_priority,
-  rtems_task_priority *old_priority_p,
-  ISR_lock_Context    *lock_context
+  Semaphore_Control    *the_semaphore,
+  rtems_id              scheduler_id,
+  rtems_task_priority   new_priority,
+  rtems_task_priority  *old_priority_p,
+  Thread_queue_Context *queue_context
 )
 {
   rtems_status_code   sc;
@@ -40,7 +40,7 @@ static rtems_status_code _Semaphore_Set_priority(
     MRSP_Control *mrsp = &the_semaphore->Core_control.mrsp;
     uint32_t scheduler_index = _Scheduler_Get_index_by_id( scheduler_id );
 
-    _MRSP_Acquire_critical( mrsp, lock_context );
+    _MRSP_Acquire_critical( mrsp, queue_context );
 
     old_priority = _MRSP_Get_ceiling_priority( mrsp, scheduler_index );
 
@@ -48,7 +48,7 @@ static rtems_status_code _Semaphore_Set_priority(
       _MRSP_Set_ceiling_priority( mrsp, scheduler_index, new_priority );
     }
 
-    _MRSP_Release( mrsp, lock_context );
+    _MRSP_Release( mrsp, queue_context );
 
     sc = RTEMS_SUCCESSFUL;
   } else
@@ -56,7 +56,7 @@ static rtems_status_code _Semaphore_Set_priority(
   if ( _Attributes_Is_priority_ceiling( attribute_set ) ) {
     CORE_mutex_Control *mutex = &the_semaphore->Core_control.mutex;
 
-    _CORE_mutex_Acquire_critical( mutex, lock_context );
+    _CORE_mutex_Acquire_critical( mutex, queue_context );
 
     old_priority = mutex->Attributes.priority_ceiling;
 
@@ -64,11 +64,11 @@ static rtems_status_code _Semaphore_Set_priority(
       mutex->Attributes.priority_ceiling = new_priority;
     }
 
-    _CORE_mutex_Release( mutex, lock_context );
+    _CORE_mutex_Release( mutex, queue_context );
 
     sc = RTEMS_SUCCESSFUL;
   } else {
-    _ISR_lock_ISR_enable( lock_context );
+    _ISR_lock_ISR_enable( &queue_context->Lock_context );
 
     old_priority = 0;
 
@@ -87,8 +87,8 @@ rtems_status_code rtems_semaphore_set_priority(
   rtems_task_priority *old_priority
 )
 {
-  Semaphore_Control *the_semaphore;
-  ISR_lock_Context   lock_context;
+  Semaphore_Control    *the_semaphore;
+  Thread_queue_Context  queue_context;
 
   if ( new_priority != RTEMS_CURRENT_PRIORITY &&
        !_RTEMS_tasks_Priority_is_valid( new_priority ) ) {
@@ -103,7 +103,7 @@ rtems_status_code rtems_semaphore_set_priority(
     return RTEMS_INVALID_ID;
   }
 
-  the_semaphore = _Semaphore_Get( semaphore_id, &lock_context );
+  the_semaphore = _Semaphore_Get( semaphore_id, &queue_context, NULL );
 
   if ( the_semaphore == NULL ) {
 #if defined(RTEMS_MULTIPROCESSING)
@@ -120,6 +120,6 @@ rtems_status_code rtems_semaphore_set_priority(
     scheduler_id,
     new_priority,
     old_priority,
-    &lock_context
+    &queue_context
   );
 }
diff --git a/cpukit/score/include/rtems/score/corebarrierimpl.h b/cpukit/score/include/rtems/score/corebarrierimpl.h
index d5133cd..051990e 100644
--- a/cpukit/score/include/rtems/score/corebarrierimpl.h
+++ b/cpukit/score/include/rtems/score/corebarrierimpl.h
@@ -84,31 +84,26 @@ RTEMS_INLINE_ROUTINE void _CORE_barrier_Destroy(
 
 RTEMS_INLINE_ROUTINE void _CORE_barrier_Acquire_critical(
   CORE_barrier_Control *the_barrier,
-  ISR_lock_Context     *lock_context
+  Thread_queue_Context *queue_context
 )
 {
-  _Thread_queue_Acquire_critical( &the_barrier->Wait_queue, lock_context );
+  _Thread_queue_Acquire_critical(
+    &the_barrier->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
 RTEMS_INLINE_ROUTINE void _CORE_barrier_Release(
   CORE_barrier_Control *the_barrier,
-  ISR_lock_Context     *lock_context
+  Thread_queue_Context *queue_context
 )
 {
-  _Thread_queue_Release( &the_barrier->Wait_queue, lock_context );
+  _Thread_queue_Release(
+    &the_barrier->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
-void _CORE_barrier_Do_seize(
-  CORE_barrier_Control    *the_barrier,
-  Thread_Control          *executing,
-  bool                     wait,
-  Watchdog_Interval        timeout,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout  mp_callout,
-#endif
-  ISR_lock_Context        *lock_context
-);
-
 /**
  *  @brief Wait for the barrier.
  *
@@ -127,48 +122,18 @@ void _CORE_barrier_Do_seize(
  *
  * @note Status is returned via the thread control block.
  */
-#if defined(RTEMS_MULTIPROCESSING)
-  #define _CORE_barrier_Seize( \
-    the_barrier, \
-    executing, \
-    wait, \
-    timeout, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_barrier_Do_seize( \
-      the_barrier, \
-      executing, \
-      wait, \
-      timeout, \
-      mp_callout, \
-      lock_context \
-    )
-#else
-  #define _CORE_barrier_Seize( \
-    the_barrier, \
-    executing, \
-    wait, \
-    timeout, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_barrier_Do_seize( \
-      the_barrier, \
-      executing, \
-      wait, \
-      timeout, \
-      lock_context \
-    )
-#endif
+void _CORE_barrier_Seize(
+  CORE_barrier_Control *the_barrier,
+  Thread_Control       *executing,
+  bool                  wait,
+  Watchdog_Interval     timeout,
+  Thread_queue_Context *queue_context
+);
 
-uint32_t _CORE_barrier_Do_surrender(
+uint32_t _CORE_barrier_Do_flush(
   CORE_barrier_Control      *the_barrier,
   Thread_queue_Flush_filter  filter,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout    mp_callout,
-#endif
-  ISR_lock_Context          *lock_context
+  Thread_queue_Context      *queue_context
 );
 
 /**
@@ -183,62 +148,35 @@ uint32_t _CORE_barrier_Do_surrender(
  *
  *  @retval the number of unblocked threads
  */
-#if defined(RTEMS_MULTIPROCESSING)
-  #define _CORE_barrier_Surrender( \
-    the_barrier, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_barrier_Do_surrender( \
-      the_barrier, \
-      _Thread_queue_Flush_default_filter, \
-      mp_callout, \
-      lock_context \
-    )
-#else
-  #define _CORE_barrier_Surrender( \
-    the_barrier, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_barrier_Do_surrender( \
-      the_barrier, \
-      _Thread_queue_Flush_default_filter, \
-      lock_context \
-    )
-#endif
+RTEMS_INLINE_ROUTINE uint32_t _CORE_barrier_Surrender(
+  CORE_barrier_Control *the_barrier,
+  Thread_queue_Context *queue_context
+)
+{
+  return _CORE_barrier_Do_flush(
+    the_barrier,
+    _Thread_queue_Flush_default_filter,
+    queue_context
+  );
+}
 
 Thread_Control *_CORE_barrier_Was_deleted(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 );
 
-/* Must be a macro due to the multiprocessing dependent parameters */
-#if defined(RTEMS_MULTIPROCESSING)
-  #define _CORE_barrier_Flush( \
-    the_barrier, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_barrier_Do_surrender( \
-      the_barrier, \
-      _CORE_barrier_Was_deleted, \
-      mp_callout, \
-      lock_context \
-    )
-#else
-  #define _CORE_barrier_Flush( \
-    the_barrier, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_barrier_Do_surrender( \
-      the_barrier, \
-      _CORE_barrier_Was_deleted, \
-      lock_context \
-    )
-#endif
+RTEMS_INLINE_ROUTINE void _CORE_barrier_Flush(
+  CORE_barrier_Control *the_barrier,
+  Thread_queue_Context *queue_context
+)
+{
+  _CORE_barrier_Do_flush(
+    the_barrier,
+    _CORE_barrier_Was_deleted,
+    queue_context
+  );
+}
 
 /**
  * This function returns true if the automatic release attribute is
diff --git a/cpukit/score/include/rtems/score/coremsg.h b/cpukit/score/include/rtems/score/coremsg.h
index af42e7d..8d25529 100644
--- a/cpukit/score/include/rtems/score/coremsg.h
+++ b/cpukit/score/include/rtems/score/coremsg.h
@@ -122,7 +122,7 @@ typedef enum {
    */
   typedef void (*CORE_message_queue_Notify_Handler)(
     CORE_message_queue_Control *,
-    ISR_lock_Context *
+    Thread_queue_Context *
   );
 #endif
 
diff --git a/cpukit/score/include/rtems/score/coremsgimpl.h b/cpukit/score/include/rtems/score/coremsgimpl.h
index a93da03..c90cb72 100644
--- a/cpukit/score/include/rtems/score/coremsgimpl.h
+++ b/cpukit/score/include/rtems/score/coremsgimpl.h
@@ -128,14 +128,6 @@ bool _CORE_message_queue_Initialize(
   size_t                          maximum_message_size
 );
 
-void _CORE_message_queue_Do_close(
-  CORE_message_queue_Control *the_message_queue,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout     mp_callout,
-#endif
-  ISR_lock_Context           *lock_context
-);
-
 /**
  *  @brief Close a message queue.
  *
@@ -147,33 +139,13 @@ void _CORE_message_queue_Do_close(
  *  flushing @a the_message_queue's task wait queue.
  *
  *  @param[in] the_message_queue points to the message queue to close
- *  @param[in] mp_callout is the routine to call for each thread
- *         that is extracted from the set of waiting threads
- *  @param[in] lock_context The lock context of the
+ *  @param[in] queue_context The thread queue context used for
  *    _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
  */
-#if defined(RTEMS_MULTIPROCESSING)
-  #define _CORE_message_queue_Close( \
-    the_message_queue, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_message_queue_Do_close( \
-      the_message_queue, \
-      mp_callout, \
-      lock_context \
-    )
-#else
-  #define _CORE_message_queue_Close( \
-    the_message_queue, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_message_queue_Do_close( \
-      the_message_queue, \
-      lock_context \
-    )
-#endif
+void _CORE_message_queue_Close(
+  CORE_message_queue_Control *the_message_queue,
+  Thread_queue_Context       *queue_context
+);
 
 /**
  *  @brief Flush pending messages.
@@ -186,13 +158,13 @@ void _CORE_message_queue_Do_close(
  *  number of messages flushed from the queue is returned.
  *
  *  @param[in] the_message_queue points to the message queue to flush
- *  @param[in] lock_context The lock context of the interrupt disable.
+ *  @param[in] queue_context The thread queue context with interrupts disabled.
  *
  *  @retval This method returns the number of message pending messages flushed.
  */
 uint32_t   _CORE_message_queue_Flush(
   CORE_message_queue_Control *the_message_queue,
-  ISR_lock_Context           *lock_context
+  Thread_queue_Context       *queue_context
 );
 
 #if defined(FUNCTIONALITY_NOT_CURRENTLY_USED_BY_ANY_API)
@@ -212,17 +184,6 @@ uint32_t   _CORE_message_queue_Flush(
   );
 #endif
 
-CORE_message_queue_Status _CORE_message_queue_Do_broadcast(
-  CORE_message_queue_Control *the_message_queue,
-  const void                 *buffer,
-  size_t                      size,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout     mp_callout,
-#endif
-  uint32_t                   *count,
-  ISR_lock_Context           *lock_context
-);
-
 /**
  *  @brief Broadcast a message to the message queue.
  *
@@ -236,61 +197,19 @@ CORE_message_queue_Status _CORE_message_queue_Do_broadcast(
  *  @param[in] the_message_queue points to the message queue
  *  @param[in] buffer is the starting address of the message to broadcast
  *  @param[in] size is the size of the message being broadcast
- *  @param[in] mp_callout is the routine to invoke if
- *         a thread that is unblocked is actually a remote thread.
  *  @param[out] count points to the variable that will contain the
  *         number of tasks that are sent this message
- *  @param[in] lock_context The lock context of the interrupt disable.
+ *  @param[in] queue_context The thread queue context used for
+ *    _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
  *  @retval @a *count will contain the number of messages sent
  *  @retval indication of the successful completion or reason for failure
  */
-#if defined(RTEMS_MULTIPROCESSING)
-  #define _CORE_message_queue_Broadcast( \
-    the_message_queue, \
-    buffer, \
-    size, \
-    mp_callout, \
-    count, \
-    lock_context \
-  ) \
-    _CORE_message_queue_Do_broadcast( \
-      the_message_queue, \
-      buffer, \
-      size, \
-      mp_callout, \
-      count, \
-      lock_context \
-    )
-#else
-  #define _CORE_message_queue_Broadcast( \
-    the_message_queue, \
-    buffer, \
-    size, \
-    mp_callout, \
-    count, \
-    lock_context \
-  ) \
-    _CORE_message_queue_Do_broadcast( \
-      the_message_queue, \
-      buffer, \
-      size, \
-      count, \
-      lock_context \
-    )
-#endif
-
-CORE_message_queue_Status _CORE_message_queue_Do_submit(
-  CORE_message_queue_Control       *the_message_queue,
-  Thread_Control                   *executing,
-  const void                       *buffer,
-  size_t                            size,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout           mp_callout,
-#endif
-  CORE_message_queue_Submit_types   submit_type,
-  bool                              wait,
-  Watchdog_Interval                 timeout,
-  ISR_lock_Context                 *lock_context
+CORE_message_queue_Status _CORE_message_queue_Broadcast(
+  CORE_message_queue_Control *the_message_queue,
+  const void                 *buffer,
+  size_t                      size,
+  uint32_t                   *count,
+  Thread_queue_Context       *queue_context
 );
 
 /**
@@ -306,63 +225,26 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit(
  *  @param[in] the_message_queue points to the message queue
  *  @param[in] buffer is the starting address of the message to send
  *  @param[in] size is the size of the message being send
- *  @param[in] mp_callout is the routine to invoke if
- *         a thread that is unblocked is actually a remote thread.
  *  @param[in] submit_type determines whether the message is prepended,
  *         appended, or enqueued in priority order.
  *  @param[in] wait indicates whether the calling thread is willing to block
  *         if the message queue is full.
  *  @param[in] timeout is the maximum number of clock ticks that the calling
  *         thread is willing to block if the message queue is full.
- *  @param[in] lock_context The lock context of the interrupt disable.
+ *  @param[in] queue_context The thread queue context used for
+ *    _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
  *  @retval indication of the successful completion or reason for failure
  */
-#if defined(RTEMS_MULTIPROCESSING)
-  #define _CORE_message_queue_Submit( \
-    the_message_queue, \
-    executing, \
-    buffer, \
-    size, \
-    mp_callout, \
-    submit_type, \
-    wait, \
-    timeout, \
-    lock_context \
-  ) \
-    _CORE_message_queue_Do_submit( \
-      the_message_queue, \
-      executing, \
-      buffer, \
-      size, \
-      mp_callout, \
-      submit_type, \
-      wait, \
-      timeout, \
-      lock_context \
-    )
-#else
-  #define _CORE_message_queue_Submit( \
-    the_message_queue, \
-    executing, \
-    buffer, \
-    size, \
-    mp_callout, \
-    submit_type, \
-    wait, \
-    timeout, \
-    lock_context \
-  ) \
-    _CORE_message_queue_Do_submit( \
-      the_message_queue, \
-      executing, \
-      buffer, \
-      size, \
-      submit_type, \
-      wait, \
-      timeout, \
-      lock_context \
-    )
-#endif
+CORE_message_queue_Status _CORE_message_queue_Submit(
+  CORE_message_queue_Control       *the_message_queue,
+  Thread_Control                   *executing,
+  const void                       *buffer,
+  size_t                            size,
+  CORE_message_queue_Submit_types   submit_type,
+  bool                              wait,
+  Watchdog_Interval                 timeout,
+  Thread_queue_Context             *queue_context
+);
 
 /**
  *  @brief Size a message from the message queue.
@@ -385,7 +267,8 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit(
  *         if the message queue is empty.
  *  @param[in] timeout is the maximum number of clock ticks that the calling
  *         thread is willing to block if the message queue is empty.
- *  @param[in] lock_context The lock context of the interrupt disable.
+ *  @param[in] queue_context The thread queue context used for
+ *    _CORE_message_queue_Acquire() or _CORE_message_queue_Acquire_critical().
  *
  *  @retval indication of the successful completion or reason for failure.
  *          On success, the location pointed to @a size_p will contain the
@@ -398,13 +281,13 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit(
  *    + wait
  */
 void _CORE_message_queue_Seize(
-  CORE_message_queue_Control      *the_message_queue,
-  Thread_Control                  *executing,
-  void                            *buffer,
-  size_t                          *size_p,
-  bool                             wait,
-  Watchdog_Interval                timeout,
-  ISR_lock_Context                *lock_context
+  CORE_message_queue_Control *the_message_queue,
+  Thread_Control             *executing,
+  void                       *buffer,
+  size_t                     *size_p,
+  bool                        wait,
+  Watchdog_Interval           timeout,
+  Thread_queue_Context       *queue_context
 );
 
 /**
@@ -428,76 +311,79 @@ void _CORE_message_queue_Insert_message(
   CORE_message_queue_Submit_types    submit_type
 );
 
-/**
- * This routine sends a message to the end of the specified message queue.
- */
-#define _CORE_message_queue_Send( \
-  the_message_queue, \
-  buffer, \
-  size, \
-  mp_callout, \
-  wait, \
-  timeout, \
-  lock_context \
-) \
-  _CORE_message_queue_Submit( \
-    the_message_queue, \
-    _Thread_Executing, \
-    buffer, \
-    size, \
-    mp_callout, \
-    CORE_MESSAGE_QUEUE_SEND_REQUEST, \
-    wait, \
-    timeout, \
-    lock_context \
-  )
+RTEMS_INLINE_ROUTINE CORE_message_queue_Status _CORE_message_queue_Send(
+  CORE_message_queue_Control       *the_message_queue,
+  const void                       *buffer,
+  size_t                            size,
+  bool                              wait,
+  Watchdog_Interval                 timeout,
+  Thread_queue_Context             *queue_context
+)
+{
+  return _CORE_message_queue_Submit(
+    the_message_queue,
+    _Thread_Executing,
+    buffer,
+    size,
+    CORE_MESSAGE_QUEUE_SEND_REQUEST,
+    wait,
+    timeout,
+    queue_context
+  );
+}
 
-/**
- * This routine sends a message to the front of the specified message queue.
- */
-#define _CORE_message_queue_Urgent( \
-  the_message_queue, \
-  buffer, \
-  size, \
-  mp_callout, \
-  wait, \
-  timeout, \
-  lock_context \
-) \
-  _CORE_message_queue_Submit( \
-    the_message_queue, \
-    _Thread_Executing, \
-    buffer, \
-    size, \
-    mp_callout, \
-    CORE_MESSAGE_QUEUE_URGENT_REQUEST, \
-    wait,\
-    timeout, \
-    lock_context \
- )
+RTEMS_INLINE_ROUTINE CORE_message_queue_Status _CORE_message_queue_Urgent(
+  CORE_message_queue_Control       *the_message_queue,
+  const void                       *buffer,
+  size_t                            size,
+  bool                              wait,
+  Watchdog_Interval                 timeout,
+  Thread_queue_Context             *queue_context
+)
+{
+  return _CORE_message_queue_Submit(
+    the_message_queue,
+    _Thread_Executing,
+    buffer,
+    size,
+    CORE_MESSAGE_QUEUE_URGENT_REQUEST,
+    wait,
+    timeout,
+    queue_context
+  );
+}
 
 RTEMS_INLINE_ROUTINE void _CORE_message_queue_Acquire(
   CORE_message_queue_Control *the_message_queue,
-  ISR_lock_Context           *lock_context
+  Thread_queue_Context       *queue_context
 )
 {
-  _Thread_queue_Acquire( &the_message_queue->Wait_queue, lock_context );
+  _Thread_queue_Acquire(
+    &the_message_queue->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
 RTEMS_INLINE_ROUTINE void _CORE_message_queue_Acquire_critical(
   CORE_message_queue_Control *the_message_queue,
-  ISR_lock_Context           *lock_context
+  Thread_queue_Context       *queue_context
 )
 {
-  _Thread_queue_Acquire_critical( &the_message_queue->Wait_queue, lock_context );
+  _Thread_queue_Acquire_critical(
+    &the_message_queue->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
 RTEMS_INLINE_ROUTINE void _CORE_message_queue_Release(
   CORE_message_queue_Control *the_message_queue,
-  ISR_lock_Context           *lock_context
+  Thread_queue_Context       *queue_context
 )
 {
-  _Thread_queue_Release( &the_message_queue->Wait_queue, lock_context );
+  _Thread_queue_Release(
+    &the_message_queue->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
 /**
@@ -599,15 +485,12 @@ RTEMS_INLINE_ROUTINE
     do { } while ( 0 )
 #endif
 
-RTEMS_INLINE_ROUTINE Thread_Control *_CORE_message_queue_Do_dequeue_receiver(
+RTEMS_INLINE_ROUTINE Thread_Control *_CORE_message_queue_Dequeue_receiver(
   CORE_message_queue_Control      *the_message_queue,
   const void                      *buffer,
   size_t                           size,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout          mp_callout,
-#endif
   CORE_message_queue_Submit_types  submit_type,
-  ISR_lock_Context                *lock_context
+  Thread_queue_Context            *queue_context
 )
 {
   Thread_Control *the_thread;
@@ -649,48 +532,12 @@ RTEMS_INLINE_ROUTINE Thread_Control *_CORE_message_queue_Do_dequeue_receiver(
     &the_message_queue->Wait_queue.Queue,
     the_message_queue->operations,
     the_thread,
-    mp_callout,
-    lock_context
+    queue_context
   );
 
   return the_thread;
 }
 
-#if defined(RTEMS_MULTIPROCESSING)
-  #define _CORE_message_queue_Dequeue_receiver( \
-    the_message_queue, \
-    buffer, \
-    size, \
-    mp_callout, \
-    submit_type, \
-    lock_context \
-  ) \
-    _CORE_message_queue_Do_dequeue_receiver( \
-      the_message_queue, \
-      buffer, \
-      size, \
-      mp_callout, \
-      submit_type, \
-      lock_context \
-    )
-#else
-  #define _CORE_message_queue_Dequeue_receiver( \
-    the_message_queue, \
-    buffer, \
-    size, \
-    mp_callout, \
-    submit_type, \
-    lock_context \
-  ) \
-    _CORE_message_queue_Do_dequeue_receiver( \
-      the_message_queue, \
-      buffer, \
-      size, \
-      submit_type, \
-      lock_context \
-    )
-#endif
-
 /** @} */
 
 #ifdef __cplusplus
diff --git a/cpukit/score/include/rtems/score/coremuteximpl.h b/cpukit/score/include/rtems/score/coremuteximpl.h
index 4531e46..a32022a 100644
--- a/cpukit/score/include/rtems/score/coremuteximpl.h
+++ b/cpukit/score/include/rtems/score/coremuteximpl.h
@@ -107,19 +107,25 @@ RTEMS_INLINE_ROUTINE void _CORE_mutex_Destroy( CORE_mutex_Control *the_mutex )
 }
 
 RTEMS_INLINE_ROUTINE void _CORE_mutex_Acquire_critical(
-  CORE_mutex_Control *the_mutex,
-  ISR_lock_Context   *lock_context
+  CORE_mutex_Control   *the_mutex,
+  Thread_queue_Context *queue_context
 )
 {
-  _Thread_queue_Acquire_critical( &the_mutex->Wait_queue, lock_context );
+  _Thread_queue_Acquire_critical(
+    &the_mutex->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
 RTEMS_INLINE_ROUTINE void _CORE_mutex_Release(
-  CORE_mutex_Control *the_mutex,
-  ISR_lock_Context   *lock_context
+  CORE_mutex_Control   *the_mutex,
+  Thread_queue_Context *queue_context
 )
 {
-  _Thread_queue_Release( &the_mutex->Wait_queue, lock_context );
+  _Thread_queue_Release(
+    &the_mutex->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
 /**
@@ -219,7 +225,7 @@ RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_priority_ceiling(
  *
  *  @param[in,out] executing The currently executing thread.
  *  @param[in,out] the_mutex is the mutex to attempt to lock
- *  @param[in] lock_context is the interrupt level
+ *  @param[in] queue_context is the interrupt level
  *
  *  @retval This routine returns 0 if "trylock" can resolve whether or not
  *  the mutex is immediately obtained or there was an error attempting to
@@ -227,9 +233,9 @@ RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_priority_ceiling(
  *  the mutex and will have to block to do so.
  */
 RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock(
-  CORE_mutex_Control  *the_mutex,
-  Thread_Control      *executing,
-  ISR_lock_Context    *lock_context
+  CORE_mutex_Control   *the_mutex,
+  Thread_Control       *executing,
+  Thread_queue_Context *queue_context
 )
 {
   /* disabled when you get here */
@@ -244,7 +250,7 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock(
     }
 
     if ( !_CORE_mutex_Is_priority_ceiling( &the_mutex->Attributes ) ) {
-      _CORE_mutex_Release( the_mutex, lock_context );
+      _CORE_mutex_Release( the_mutex, queue_context );
       return 0;
     } /* else must be CORE_MUTEX_DISCIPLINES_PRIORITY_CEILING
        *
@@ -258,15 +264,17 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock(
       ceiling = the_mutex->Attributes.priority_ceiling;
       current = executing->current_priority;
       if ( current == ceiling ) {
-        _CORE_mutex_Release( the_mutex, lock_context );
+        _CORE_mutex_Release( the_mutex, queue_context );
         return 0;
       }
 
       if ( current > ceiling ) {
         Per_CPU_Control *cpu_self;
 
-        cpu_self = _Thread_Dispatch_disable_critical( lock_context );
-        _CORE_mutex_Release( the_mutex, lock_context );
+        cpu_self = _Thread_Dispatch_disable_critical(
+          &queue_context->Lock_context
+        );
+        _CORE_mutex_Release( the_mutex, queue_context );
         _Thread_Raise_priority( executing, ceiling );
         _Thread_Dispatch_enable( cpu_self );
         return 0;
@@ -276,7 +284,7 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock(
         the_mutex->holder = NULL;
         the_mutex->nest_count = 0;     /* undo locking above */
         executing->resource_count--;   /* undo locking above */
-        _CORE_mutex_Release( the_mutex, lock_context );
+        _CORE_mutex_Release( the_mutex, queue_context );
         return 0;
       }
     }
@@ -292,12 +300,12 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock(
     switch ( the_mutex->Attributes.lock_nesting_behavior ) {
       case CORE_MUTEX_NESTING_ACQUIRES:
         the_mutex->nest_count++;
-        _CORE_mutex_Release( the_mutex, lock_context );
+        _CORE_mutex_Release( the_mutex, queue_context );
         return 0;
       #if defined(RTEMS_POSIX_API)
         case CORE_MUTEX_NESTING_IS_ERROR:
           executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
-          _CORE_mutex_Release( the_mutex, lock_context );
+          _CORE_mutex_Release( the_mutex, queue_context );
           return 0;
       #endif
       case CORE_MUTEX_NESTING_BLOCKS:
@@ -322,7 +330,7 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock(
  *  @param[in] the_mutex is the mutex to attempt to lock
  *  @param[in] wait is true if the thread is willing to wait
  *  @param[in] timeout is the maximum number of ticks to block
- *  @param[in] lock_context is a temporary variable used to contain the ISR
+ *  @param[in] queue_context is a temporary variable used to contain the ISR
  *         disable level cookie
  *
  *  @note If the mutex is called from an interrupt service routine,
@@ -339,11 +347,11 @@ RTEMS_INLINE_ROUTINE int _CORE_mutex_Seize_interrupt_trylock(
  *      then they are blocked.
  */
 RTEMS_INLINE_ROUTINE void _CORE_mutex_Seize(
-  CORE_mutex_Control  *the_mutex,
-  Thread_Control      *executing,
-  bool                 wait,
-  Watchdog_Interval    timeout,
-  ISR_lock_Context    *lock_context
+  CORE_mutex_Control   *the_mutex,
+  Thread_Control       *executing,
+  bool                  wait,
+  Watchdog_Interval     timeout,
+  Thread_queue_Context *queue_context
 )
 {
   if ( _CORE_mutex_Check_dispatch_for_seize( wait ) ) {
@@ -353,10 +361,12 @@ RTEMS_INLINE_ROUTINE void _CORE_mutex_Seize(
       INTERNAL_ERROR_MUTEX_OBTAIN_FROM_BAD_STATE
     );
   }
-  _CORE_mutex_Acquire_critical( the_mutex, lock_context );
-  if ( _CORE_mutex_Seize_interrupt_trylock( the_mutex, executing, lock_context ) ) {
+  _CORE_mutex_Acquire_critical( the_mutex, queue_context );
+  if (
+    _CORE_mutex_Seize_interrupt_trylock( the_mutex, executing, queue_context )
+  ) {
     if ( !wait ) {
-      _CORE_mutex_Release( the_mutex, lock_context );
+      _CORE_mutex_Release( the_mutex, queue_context );
       executing->Wait.return_code =
         CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT;
     } else {
@@ -364,69 +374,42 @@ RTEMS_INLINE_ROUTINE void _CORE_mutex_Seize(
         the_mutex,
         executing,
         timeout,
-        lock_context
+        &queue_context->Lock_context
       );
     }
   }
 }
 
-CORE_mutex_Status _CORE_mutex_Do_surrender(
-  CORE_mutex_Control      *the_mutex,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout  mp_callout,
-#endif
-  ISR_lock_Context        *lock_context
+CORE_mutex_Status _CORE_mutex_Surrender(
+  CORE_mutex_Control   *the_mutex,
+  Thread_queue_Context *queue_context
 );
 
-#if defined(RTEMS_MULTIPROCESSING)
-  #define _CORE_mutex_Surrender( \
-    the_mutex, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_mutex_Do_surrender( \
-      the_mutex, \
-      mp_callout, \
-      lock_context \
-    )
-#else
-  #define _CORE_mutex_Surrender( \
-    the_mutex, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_mutex_Do_surrender( \
-      the_mutex, \
-      lock_context \
-    )
-#endif
-
 Thread_Control *_CORE_mutex_Was_deleted(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 );
 
 Thread_Control *_CORE_mutex_Unsatisfied_nowait(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 );
 
-/* Must be a macro due to the multiprocessing dependent parameters */
-#define _CORE_mutex_Flush( \
-  the_mutex, \
-  filter, \
-  mp_callout, \
-  lock_context \
-) \
-  _Thread_queue_Flush_critical( \
-    &( the_mutex )->Wait_queue.Queue, \
-    ( the_mutex )->operations, \
-    filter, \
-    mp_callout, \
-    lock_context \
-  )
+RTEMS_INLINE_ROUTINE void _CORE_mutex_Flush(
+  CORE_mutex_Control        *the_mutex,
+  Thread_queue_Flush_filter  filter,
+  Thread_queue_Context      *queue_context
+)
+{
+  _Thread_queue_Flush_critical(
+    &the_mutex->Wait_queue.Queue,
+    the_mutex->operations,
+    filter,
+    queue_context
+  );
+}
 
 RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_owner(
   const CORE_mutex_Control *the_mutex,
diff --git a/cpukit/score/include/rtems/score/corerwlockimpl.h b/cpukit/score/include/rtems/score/corerwlockimpl.h
index ed59d69..67084c1 100644
--- a/cpukit/score/include/rtems/score/corerwlockimpl.h
+++ b/cpukit/score/include/rtems/score/corerwlockimpl.h
@@ -87,19 +87,25 @@ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Destroy(
 }
 
 RTEMS_INLINE_ROUTINE void _CORE_RWLock_Acquire_critical(
-  CORE_RWLock_Control *the_rwlock,
-  ISR_lock_Context    *lock_context
+  CORE_RWLock_Control  *the_rwlock,
+  Thread_queue_Context *queue_context
 )
 {
-  _Thread_queue_Acquire_critical( &the_rwlock->Wait_queue, lock_context );
+  _Thread_queue_Acquire_critical(
+    &the_rwlock->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
 RTEMS_INLINE_ROUTINE void _CORE_RWLock_Release(
-  CORE_RWLock_Control *the_rwlock,
-  ISR_lock_Context    *lock_context
+  CORE_RWLock_Control  *the_rwlock,
+  Thread_queue_Context *queue_context
 )
 {
-  _Thread_queue_Release( &the_rwlock->Wait_queue, lock_context );
+  _Thread_queue_Release(
+    &the_rwlock->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
 /**
@@ -116,11 +122,11 @@ RTEMS_INLINE_ROUTINE void _CORE_RWLock_Release(
  */
 
 void _CORE_RWLock_Seize_for_reading(
-  CORE_RWLock_Control *the_rwlock,
-  Thread_Control      *executing,
-  bool                 wait,
-  Watchdog_Interval    timeout,
-  ISR_lock_Context    *lock_context
+  CORE_RWLock_Control  *the_rwlock,
+  Thread_Control       *executing,
+  bool                  wait,
+  Watchdog_Interval     timeout,
+  Thread_queue_Context *queue_context
 );
 
 /**
@@ -136,11 +142,11 @@ void _CORE_RWLock_Seize_for_reading(
  * @note Status is returned via the thread control block.
  */
 void _CORE_RWLock_Seize_for_writing(
-  CORE_RWLock_Control *the_rwlock,
-  Thread_Control      *executing,
-  bool                 wait,
-  Watchdog_Interval    timeout,
-  ISR_lock_Context    *lock_context
+  CORE_RWLock_Control  *the_rwlock,
+  Thread_Control       *executing,
+  bool                  wait,
+  Watchdog_Interval     timeout,
+  Thread_queue_Context *queue_context
 );
 
 /**
@@ -154,8 +160,8 @@ void _CORE_RWLock_Seize_for_writing(
  *  @retval Status is returned to indicate successful or failure.
  */
 CORE_RWLock_Status _CORE_RWLock_Surrender(
-  CORE_RWLock_Control *the_rwlock,
-  ISR_lock_Context    *lock_context
+  CORE_RWLock_Control  *the_rwlock,
+  Thread_queue_Context *queue_context
 );
 
 /** @} */
diff --git a/cpukit/score/include/rtems/score/coresemimpl.h b/cpukit/score/include/rtems/score/coresemimpl.h
index 0e04cc9..1660c1d 100644
--- a/cpukit/score/include/rtems/score/coresemimpl.h
+++ b/cpukit/score/include/rtems/score/coresemimpl.h
@@ -88,54 +88,68 @@ void _CORE_semaphore_Initialize(
 
 RTEMS_INLINE_ROUTINE void _CORE_semaphore_Acquire_critical(
   CORE_semaphore_Control *the_semaphore,
-  ISR_lock_Context       *lock_context
+  Thread_queue_Context   *queue_context
 )
 {
-  _Thread_queue_Acquire_critical( &the_semaphore->Wait_queue, lock_context );
+  _Thread_queue_Acquire_critical(
+    &the_semaphore->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
 RTEMS_INLINE_ROUTINE void _CORE_semaphore_Release(
   CORE_semaphore_Control *the_semaphore,
-  ISR_lock_Context       *lock_context
+  Thread_queue_Context   *queue_context
 )
 {
-  _Thread_queue_Release( &the_semaphore->Wait_queue, lock_context );
+  _Thread_queue_Release(
+    &the_semaphore->Wait_queue,
+    &queue_context->Lock_context
+  );
 }
 
 Thread_Control *_CORE_semaphore_Was_deleted(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 );
 
 Thread_Control *_CORE_semaphore_Unsatisfied_nowait(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 );
 
-#define _CORE_semaphore_Destroy( \
-  the_semaphore, \
-  mp_callout, \
-  lock_context \
-) \
-  do { \
-    _Thread_queue_Flush_critical( \
-      &( the_semaphore )->Wait_queue.Queue, \
-      ( the_semaphore )->operations, \
-      _CORE_semaphore_Was_deleted, \
-      mp_callout, \
-      lock_context \
-    ); \
-    _Thread_queue_Destroy( &( the_semaphore )->Wait_queue ); \
-  } while ( 0 )
+RTEMS_INLINE_ROUTINE void _CORE_semaphore_Destroy(
+  CORE_semaphore_Control *the_semaphore,
+  Thread_queue_Context   *queue_context
+)
+{
+  _Thread_queue_Flush_critical(
+    &the_semaphore->Wait_queue.Queue,
+    the_semaphore->operations,
+    _CORE_semaphore_Was_deleted,
+    queue_context
+  );
+  _Thread_queue_Destroy( &the_semaphore->Wait_queue );
+}
 
-RTEMS_INLINE_ROUTINE CORE_semaphore_Status _CORE_semaphore_Do_surrender(
+/**
+ *  @brief Surrender a unit to a semaphore.
+ *
+ *  This routine frees a unit to the semaphore.  If a task was blocked waiting
+ *  for a unit from this semaphore, then that task will be readied and the unit
+ *  given to that task.  Otherwise, the unit will be returned to the semaphore.
+ *
+ *  @param[in] the_semaphore is the semaphore to surrender
+ *  @param[in] queue_context is a temporary variable used to contain the ISR
+ *        disable level cookie
+ *
+ *  @retval an indication of whether the routine succeeded or failed
+ */
+RTEMS_INLINE_ROUTINE CORE_semaphore_Status _CORE_semaphore_Surrender(
   CORE_semaphore_Control  *the_semaphore,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout  mp_callout,
-#endif
-  ISR_lock_Context        *lock_context
+  Thread_queue_Context    *queue_context
 )
 {
   Thread_Control *the_thread;
@@ -143,7 +157,7 @@ RTEMS_INLINE_ROUTINE CORE_semaphore_Status _CORE_semaphore_Do_surrender(
 
   status = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
 
-  _CORE_semaphore_Acquire_critical( the_semaphore, lock_context );
+  _CORE_semaphore_Acquire_critical( the_semaphore, queue_context );
 
   the_thread = _Thread_queue_First_locked(
     &the_semaphore->Wait_queue,
@@ -154,8 +168,7 @@ RTEMS_INLINE_ROUTINE CORE_semaphore_Status _CORE_semaphore_Do_surrender(
       &the_semaphore->Wait_queue.Queue,
       the_semaphore->operations,
       the_thread,
-      mp_callout,
-      lock_context
+      queue_context
     );
   } else {
     if ( the_semaphore->count < UINT32_MAX )
@@ -163,65 +176,24 @@ RTEMS_INLINE_ROUTINE CORE_semaphore_Status _CORE_semaphore_Do_surrender(
     else
       status = CORE_SEMAPHORE_MAXIMUM_COUNT_EXCEEDED;
 
-    _CORE_semaphore_Release( the_semaphore, lock_context );
+    _CORE_semaphore_Release( the_semaphore, queue_context );
   }
 
   return status;
 }
 
-/**
- *  @brief Surrender a unit to a semaphore.
- *
- *  This routine frees a unit to the semaphore.  If a task was blocked waiting
- *  for a unit from this semaphore, then that task will be readied and the unit
- *  given to that task.  Otherwise, the unit will be returned to the semaphore.
- *
- *  @param[in] the_semaphore is the semaphore to surrender
- *  @param[in] mp_callout is the routine to invoke if the
- *         thread unblocked is remote
- *  @param[in] lock_context is a temporary variable used to contain the ISR
- *        disable level cookie
- *
- *  @retval an indication of whether the routine succeeded or failed
- */
-#if defined(RTEMS_MULTIPROCESSING)
-  #define _CORE_semaphore_Surrender( \
-    the_semaphore, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_semaphore_Do_surrender( \
-      the_semaphore, \
-      mp_callout, \
-      lock_context \
-    )
-#else
-  #define _CORE_semaphore_Surrender( \
-    the_semaphore, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _CORE_semaphore_Do_surrender( \
-      the_semaphore, \
-      lock_context \
-    )
-#endif
-
-/* Must be a macro due to the multiprocessing dependent parameters */
-#define _CORE_semaphore_Flush( \
-  the_semaphore, \
-  mp_callout, \
-  lock_context \
-) \
-  do { \
-    _Thread_queue_Flush_critical( \
-      &( the_semaphore )->Wait_queue.Queue, \
-      ( the_semaphore )->operations, \
-      _CORE_semaphore_Unsatisfied_nowait, \
-      mp_callout, \
-      lock_context \
-    ); \
-  } while ( 0 )
+RTEMS_INLINE_ROUTINE void _CORE_semaphore_Flush(
+  CORE_semaphore_Control *the_semaphore,
+  Thread_queue_Context   *queue_context
+)
+{
+  _Thread_queue_Flush_critical(
+    &the_semaphore->Wait_queue.Queue,
+    the_semaphore->operations,
+    _CORE_semaphore_Unsatisfied_nowait,
+    queue_context
+  );
+}
 
 /**
  * This routine returns the current count associated with the semaphore.
@@ -247,31 +219,31 @@ RTEMS_INLINE_ROUTINE uint32_t  _CORE_semaphore_Get_count(
  * @param[in,out] executing The currently executing thread.
  * @param[in] wait is true if the thread is willing to wait
  * @param[in] timeout is the maximum number of ticks to block
- * @param[in] lock_context is a temporary variable used to contain the ISR
+ * @param[in] queue_context is a temporary variable used to contain the ISR
  *        disable level cookie
  *
  * @note There is currently no MACRO version of this routine.
  */
 RTEMS_INLINE_ROUTINE void _CORE_semaphore_Seize(
-  CORE_semaphore_Control  *the_semaphore,
-  Thread_Control          *executing,
-  bool                     wait,
-  Watchdog_Interval        timeout,
-  ISR_lock_Context        *lock_context
+  CORE_semaphore_Control *the_semaphore,
+  Thread_Control         *executing,
+  bool                    wait,
+  Watchdog_Interval       timeout,
+  Thread_queue_Context   *queue_context
 )
 {
   /* disabled when you get here */
 
   executing->Wait.return_code = CORE_SEMAPHORE_STATUS_SUCCESSFUL;
-  _CORE_semaphore_Acquire_critical( the_semaphore, lock_context );
+  _CORE_semaphore_Acquire_critical( the_semaphore, queue_context );
   if ( the_semaphore->count != 0 ) {
     the_semaphore->count -= 1;
-    _CORE_semaphore_Release( the_semaphore, lock_context );
+    _CORE_semaphore_Release( the_semaphore, queue_context );
     return;
   }
 
   if ( !wait ) {
-    _CORE_semaphore_Release( the_semaphore, lock_context );
+    _CORE_semaphore_Release( the_semaphore, queue_context );
     executing->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
     return;
   }
@@ -283,7 +255,7 @@ RTEMS_INLINE_ROUTINE void _CORE_semaphore_Seize(
     STATES_WAITING_FOR_SEMAPHORE,
     timeout,
     CORE_SEMAPHORE_TIMEOUT,
-    lock_context
+    &queue_context->Lock_context
   );
 }
 
diff --git a/cpukit/score/include/rtems/score/mrspimpl.h b/cpukit/score/include/rtems/score/mrspimpl.h
index d5cf55d..5173343 100644
--- a/cpukit/score/include/rtems/score/mrspimpl.h
+++ b/cpukit/score/include/rtems/score/mrspimpl.h
@@ -54,19 +54,19 @@ RTEMS_INLINE_ROUTINE void _MRSP_Giant_release( ISR_lock_Context *lock_context )
 }
 
 RTEMS_INLINE_ROUTINE void _MRSP_Acquire_critical(
-  MRSP_Control     *mrsp,
-  ISR_lock_Context *lock_context
+  MRSP_Control         *mrsp,
+  Thread_queue_Context *queue_context
 )
 {
-  _ISR_lock_Acquire( &mrsp->Lock, lock_context );
+  _ISR_lock_Acquire( &mrsp->Lock, &queue_context->Lock_context );
 }
 
 RTEMS_INLINE_ROUTINE void _MRSP_Release(
-  MRSP_Control     *mrsp,
-  ISR_lock_Context *lock_context
+  MRSP_Control         *mrsp,
+  Thread_queue_Context *queue_context
 )
 {
-  _ISR_lock_Release_and_ISR_enable( &mrsp->Lock, lock_context );
+  _ISR_lock_Release_and_ISR_enable( &mrsp->Lock, &queue_context->Lock_context );
 }
 
 RTEMS_INLINE_ROUTINE bool _MRSP_Restore_priority_filter(
@@ -104,11 +104,11 @@ RTEMS_INLINE_ROUTINE void _MRSP_Restore_priority(
 }
 
 RTEMS_INLINE_ROUTINE void _MRSP_Claim_ownership(
-  MRSP_Control     *mrsp,
-  Thread_Control   *new_owner,
-  Priority_Control  initial_priority,
-  Priority_Control  ceiling_priority,
-  ISR_lock_Context *lock_context
+  MRSP_Control         *mrsp,
+  Thread_Control       *new_owner,
+  Priority_Control      initial_priority,
+  Priority_Control      ceiling_priority,
+  Thread_queue_Context *queue_context
 )
 {
   Per_CPU_Control *cpu_self;
@@ -118,8 +118,8 @@ RTEMS_INLINE_ROUTINE void _MRSP_Claim_ownership(
   mrsp->initial_priority_of_owner = initial_priority;
   _Scheduler_Thread_change_help_state( new_owner, SCHEDULER_HELP_ACTIVE_OWNER );
 
-  cpu_self = _Thread_Dispatch_disable_critical( lock_context );
-  _MRSP_Release( mrsp, lock_context );
+  cpu_self = _Thread_Dispatch_disable_critical( &queue_context->Lock_context );
+  _MRSP_Release( mrsp, queue_context );
 
   _Thread_Raise_priority( new_owner, ceiling_priority );
 
@@ -180,10 +180,11 @@ RTEMS_INLINE_ROUTINE void _MRSP_Timeout( Watchdog_Control *watchdog )
   MRSP_Rival *rival = RTEMS_CONTAINER_OF( watchdog, MRSP_Rival, Watchdog );
   MRSP_Control *mrsp = rival->resource;
   Thread_Control *thread = rival->thread;
-  ISR_lock_Context lock_context;
+  Thread_queue_Context queue_context;
 
-  _ISR_lock_ISR_disable( &lock_context );
-  _MRSP_Acquire_critical( mrsp, &lock_context );
+  _Thread_queue_Context_initialize( &queue_context, NULL );
+  _ISR_lock_ISR_disable( &queue_context.Lock_context );
+  _MRSP_Acquire_critical( mrsp, &queue_context );
 
   if ( rival->status == MRSP_WAIT_FOR_OWNERSHIP ) {
     ISR_lock_Context giant_lock_context;
@@ -200,20 +201,20 @@ RTEMS_INLINE_ROUTINE void _MRSP_Timeout( Watchdog_Control *watchdog )
 
     rival->status = MRSP_TIMEOUT;
 
-    _MRSP_Release( mrsp, &lock_context );
+    _MRSP_Release( mrsp, &queue_context );
   } else {
-    _MRSP_Release( mrsp, &lock_context );
+    _MRSP_Release( mrsp, &queue_context );
   }
 }
 
 RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Wait_for_ownership(
-  MRSP_Control      *mrsp,
-  Resource_Node     *owner,
-  Thread_Control    *executing,
-  Priority_Control   initial_priority,
-  Priority_Control   ceiling_priority,
-  Watchdog_Interval  timeout,
-  ISR_lock_Context  *lock_context
+  MRSP_Control         *mrsp,
+  Resource_Node        *owner,
+  Thread_Control       *executing,
+  Priority_Control      initial_priority,
+  Priority_Control      ceiling_priority,
+  Watchdog_Interval     timeout,
+  Thread_queue_Context *queue_context
 )
 {
   MRSP_Status status;
@@ -243,8 +244,8 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Wait_for_ownership(
 
   _MRSP_Giant_release( &giant_lock_context );
 
-  cpu_self = _Thread_Dispatch_disable_critical( lock_context );
-  _MRSP_Release( mrsp, lock_context );
+  cpu_self = _Thread_Dispatch_disable_critical( &queue_context->Lock_context );
+  _MRSP_Release( mrsp, queue_context );
 
   _Thread_Raise_priority( executing, ceiling_priority );
 
@@ -286,11 +287,11 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Wait_for_ownership(
 }
 
 RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Seize(
-  MRSP_Control      *mrsp,
-  Thread_Control    *executing,
-  bool               wait,
-  Watchdog_Interval  timeout,
-  ISR_lock_Context  *lock_context
+  MRSP_Control         *mrsp,
+  Thread_Control       *executing,
+  bool                  wait,
+  Watchdog_Interval     timeout,
+  Thread_queue_Context *queue_context
 )
 {
   MRSP_Status status;
@@ -306,11 +307,11 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Seize(
   Resource_Node *owner;
 
   if ( !priority_ok) {
-    _ISR_lock_ISR_enable( lock_context );
+    _ISR_lock_ISR_enable( &queue_context->Lock_context );
     return MRSP_INVALID_PRIORITY;
   }
 
-  _MRSP_Acquire_critical( mrsp, lock_context );
+  _MRSP_Acquire_critical( mrsp, queue_context );
   owner = _Resource_Get_owner( &mrsp->Resource );
   if ( owner == NULL ) {
     _MRSP_Claim_ownership(
@@ -318,7 +319,7 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Seize(
       executing,
       initial_priority,
       ceiling_priority,
-      lock_context
+      queue_context
     );
     status = MRSP_SUCCESSFUL;
   } else if (
@@ -332,10 +333,10 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Seize(
       initial_priority,
       ceiling_priority,
       timeout,
-      lock_context
+      queue_context
     );
   } else {
-    _MRSP_Release( mrsp, lock_context );
+    _MRSP_Release( mrsp, queue_context );
     /* Not available, nested access or deadlock */
     status = MRSP_UNSATISFIED;
   }
@@ -344,9 +345,9 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Seize(
 }
 
 RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Surrender(
-  MRSP_Control     *mrsp,
-  Thread_Control   *executing,
-  ISR_lock_Context *lock_context
+  MRSP_Control         *mrsp,
+  Thread_Control       *executing,
+  Thread_queue_Context *queue_context
 )
 {
   Priority_Control initial_priority;
@@ -354,7 +355,7 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Surrender(
   ISR_lock_Context giant_lock_context;
 
   if ( _Resource_Get_owner( &mrsp->Resource ) != &executing->Resource_node ) {
-    _ISR_lock_ISR_enable( lock_context );
+    _ISR_lock_ISR_enable( &queue_context->Lock_context );
     return MRSP_NOT_OWNER_OF_RESOURCE;
   }
 
@@ -364,13 +365,13 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Surrender(
       &executing->Resource_node
     )
   ) {
-    _ISR_lock_ISR_enable( lock_context );
+    _ISR_lock_ISR_enable( &queue_context->Lock_context );
     return MRSP_INCORRECT_STATE;
   }
 
   initial_priority = mrsp->initial_priority_of_owner;
 
-  _MRSP_Acquire_critical( mrsp, lock_context );
+  _MRSP_Acquire_critical( mrsp, queue_context );
 
   _MRSP_Giant_acquire( &giant_lock_context );
 
@@ -405,8 +406,8 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Surrender(
 
   _MRSP_Giant_release( &giant_lock_context );
 
-  cpu_self = _Thread_Dispatch_disable_critical( lock_context );
-  _MRSP_Release( mrsp, lock_context );
+  cpu_self = _Thread_Dispatch_disable_critical( &queue_context->Lock_context );
+  _MRSP_Release( mrsp, queue_context );
 
   _MRSP_Restore_priority( executing, initial_priority );
 
@@ -425,11 +426,11 @@ RTEMS_INLINE_ROUTINE MRSP_Status _MRSP_Can_destroy( MRSP_Control *mrsp )
 }
 
 RTEMS_INLINE_ROUTINE void _MRSP_Destroy(
-  MRSP_Control     *mrsp,
-  ISR_lock_Context *lock_context
+  MRSP_Control         *mrsp,
+  Thread_queue_Context *queue_context
 )
 {
-  _MRSP_Release( mrsp, lock_context );
+  _MRSP_Release( mrsp, queue_context );
   _ISR_lock_Destroy( &mrsp->Lock );
   _Workspace_Free( mrsp->ceiling_priorities );
 }
diff --git a/cpukit/score/include/rtems/score/threadq.h b/cpukit/score/include/rtems/score/threadq.h
index 7ada3fc..27af89f 100644
--- a/cpukit/score/include/rtems/score/threadq.h
+++ b/cpukit/score/include/rtems/score/threadq.h
@@ -58,6 +58,18 @@ typedef void ( *Thread_queue_MP_callout )(
 #endif
 
 /**
+ * @brief Thread queue context for the thread queue methods.
+ *
+ * @see _Thread_queue_Context_initialize().
+ */
+typedef struct {
+  ISR_lock_Context Lock_context;
+#if defined(RTEMS_MULTIPROCESSING)
+  Thread_queue_MP_callout mp_callout;
+#endif
+} Thread_queue_Context;
+
+/**
  * @brief Thread priority queue.
  */
 typedef struct {
diff --git a/cpukit/score/include/rtems/score/threadqimpl.h b/cpukit/score/include/rtems/score/threadqimpl.h
index 011c410..752e13e 100644
--- a/cpukit/score/include/rtems/score/threadqimpl.h
+++ b/cpukit/score/include/rtems/score/threadqimpl.h
@@ -53,6 +53,49 @@ typedef struct {
 #endif
 } Thread_queue_Syslock_queue;
 
+RTEMS_INLINE_ROUTINE void _Thread_queue_Do_context_initialize(
+  Thread_queue_Context    *queue_context
+#if defined(RTEMS_MULTIPROCESSING)
+  ,
+  Thread_queue_MP_callout  mp_callout
+#endif
+)
+{
+#if defined(RTEMS_MULTIPROCESSING)
+  queue_context->mp_callout = mp_callout;
+#else
+  (void) queue_context;
+#endif
+}
+
+/**
+ * @brief Initializes a thread queue context.
+ *
+ * @param queue_context The thread queue context to initialize.
+ * @param mp_callout Callout to unblock the thread in case it is actually a
+ *   thread proxy.  This parameter is only used on multiprocessing
+ *   configurations.  Used by thread queue extract and unblock methods for
+ *   objects with multiprocessing (MP) support.
+ */
+#if defined(RTEMS_MULTIPROCESSING)
+  #define _Thread_queue_Context_initialize( \
+    queue_context, \
+    mp_callout \
+  ) \
+    _Thread_queue_Do_context_initialize( \
+      queue_context, \
+      mp_callout \
+    )
+#else
+  #define _Thread_queue_Context_initialize( \
+    queue_context, \
+    mp_callout \
+  ) \
+    _Thread_queue_Do_context_initialize( \
+      queue_context \
+    )
+#endif
+
 RTEMS_INLINE_ROUTINE void _Thread_queue_Heads_initialize(
   Thread_queue_Heads *heads
 )
@@ -344,7 +387,7 @@ bool _Thread_queue_Do_extract_locked(
   Thread_Control                *the_thread
 #if defined(RTEMS_MULTIPROCESSING)
   ,
-  Thread_queue_MP_callout        mp_callout
+  const Thread_queue_Context    *queue_context
 #endif
 );
 
@@ -358,9 +401,8 @@ bool _Thread_queue_Do_extract_locked(
  * @param[in] queue The actual thread queue.
  * @param[in] operations The thread queue operations.
  * @param[in] the_thread The thread to extract.
- * @param[in] mp_callout Callout to unblock the thread in case it is actually a
- *   thread proxy.  This parameter is only used on multiprocessing
- *   configurations.
+ * @param[in] queue_context The thread queue context.  This parameter is only
+ *   used on multiprocessing configurations.
  *
  * @return Returns the unblock indicator for _Thread_queue_Unblock_critical().
  * True indicates, that this thread must be unblocked by the scheduler later in
@@ -375,20 +417,20 @@ bool _Thread_queue_Do_extract_locked(
     unblock, \
     queue, \
     the_thread, \
-    mp_callout \
+    queue_context \
   ) \
     _Thread_queue_Do_extract_locked( \
       unblock, \
       queue, \
       the_thread, \
-      mp_callout \
+      queue_context \
     )
 #else
   #define _Thread_queue_Extract_locked( \
     unblock, \
     queue, \
     the_thread, \
-    mp_callout \
+    queue_context \
   ) \
     _Thread_queue_Do_extract_locked( \
       unblock, \
@@ -418,16 +460,6 @@ void _Thread_queue_Unblock_critical(
   ISR_lock_Context   *lock_context
 );
 
-void _Thread_queue_Do_extract_critical(
-  Thread_queue_Queue            *queue,
-  const Thread_queue_Operations *operations,
-  Thread_Control                *the_thread,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout        mp_callout,
-#endif
-  ISR_lock_Context              *lock_context
-);
-
 /**
  * @brief Extracts the thread from the thread queue and unblocks it.
  *
@@ -450,10 +482,11 @@ void _Thread_queue_Do_extract_critical(
  *
  * void _Mutex_Release( Mutex *mutex )
  * {
- *   ISR_lock_Context  lock_context;
- *   Thread_Control   *first;
+ *   Thread_queue_Context  queue_context;
+ *   Thread_Control       *first;
  *
- *   _Thread_queue_Acquire( &mutex->Queue, &lock_context );
+ *   _Thread_queue_Context_initialize( &queue_context, NULL );
+ *   _Thread_queue_Acquire( &mutex->Queue, &queue_context.Lock_context );
  *
  *   first = _Thread_queue_First_locked( &mutex->Queue );
  *   mutex->owner = first;
@@ -463,9 +496,7 @@ void _Thread_queue_Do_extract_critical(
  *       &mutex->Queue.Queue,
  *       mutex->Queue.operations,
  *       first,
- *       NULL,
- *       0,
- *       &lock_context
+ *       &queue_context
  *   );
  * }
  * @endcode
@@ -473,41 +504,14 @@ void _Thread_queue_Do_extract_critical(
  * @param[in] queue The actual thread queue.
  * @param[in] operations The thread queue operations.
  * @param[in] the_thread The thread to extract.
- * @param[in] mp_callout Callout to unblock the thread in case it is actually a
- *   thread proxy.  This parameter is only used on multiprocessing
- *   configurations.
- * @param[in] lock_context The lock context of the lock acquire.
+ * @param[in] queue_context The thread queue context of the lock acquire.
  */
-#if defined(RTEMS_MULTIPROCESSING)
-  #define _Thread_queue_Extract_critical( \
-    queue, \
-    operations, \
-    the_thread, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _Thread_queue_Do_extract_critical( \
-      queue, \
-      operations, \
-      the_thread, \
-      mp_callout, \
-      lock_context \
-    )
-#else
-  #define _Thread_queue_Extract_critical( \
-    queue, \
-    operations, \
-    the_thread, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _Thread_queue_Do_extract_critical( \
-      queue, \
-      operations, \
-      the_thread, \
-      lock_context \
-    )
-#endif
+void _Thread_queue_Extract_critical(
+  Thread_queue_Queue            *queue,
+  const Thread_queue_Operations *operations,
+  Thread_Control                *the_thread,
+  Thread_queue_Context          *queue_context
+);
 
 /**
  *  @brief Extracts thread from thread queue.
@@ -592,9 +596,10 @@ Thread_Control *_Thread_queue_First(
  *   optimize for architectures that use the same register for the first
  *   parameter and the return value.
  * @param queue The actual thread queue.
- * @param lock_context The lock context of the lock acquire.  May be used to
- *   pass additional data to the filter function via an overlay structure.  The
- *   filter function should not release or acquire the thread queue lock.
+ * @param queue_context The thread queue context of the lock acquire.  May be
+ *   used to pass additional data to the filter function via an overlay
+ *   structure.  The filter function should not release or acquire the thread
+ *   queue lock.
  *
  * @retval the_thread Extract this thread.
  * @retval NULL Do not extract this thread and stop the thread queue flush
@@ -602,9 +607,9 @@ Thread_Control *_Thread_queue_First(
  *   operation.
  */
 typedef Thread_Control *( *Thread_queue_Flush_filter )(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 );
 
 /**
@@ -612,24 +617,14 @@ typedef Thread_Control *( *Thread_queue_Flush_filter )(
  *
  * @param the_thread The thread to extract.
  * @param queue Unused.
- * @param lock_context Unused.
+ * @param queue_context Unused.
  *
  * @retval the_thread Extract this thread.
  */
 Thread_Control *_Thread_queue_Flush_default_filter(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
-);
-
-size_t _Thread_queue_Do_flush_critical(
-  Thread_queue_Queue            *queue,
-  const Thread_queue_Operations *operations,
-  Thread_queue_Flush_filter      filter,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout        mp_callout,
-#endif
-  ISR_lock_Context              *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 );
 
 /**
@@ -647,41 +642,19 @@ size_t _Thread_queue_Do_flush_critical(
  *   the thread queue lock, for example to set the thread wait return code.
  *   The return value of the filter function controls if the thread queue flush
  *   operation should stop or continue.
- * @param mp_callout Callout to extract the proxy of a remote thread.  This
- *   parameter is only used on multiprocessing configurations.
+ * @param queue_context The thread queue context of the lock acquire.  May be
+ *   used to pass additional data to the filter function via an overlay
+ *   structure.  The filter function should not release or acquire the thread
+ *   queue lock.
  *
  * @return The count of extracted threads.
  */
-#if defined(RTEMS_MULTIPROCESSING)
-  #define _Thread_queue_Flush_critical( \
-    queue, \
-    operations, \
-    filter, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _Thread_queue_Do_flush_critical( \
-      queue, \
-      operations, \
-      filter, \
-      mp_callout, \
-      lock_context \
-    )
-#else
-  #define _Thread_queue_Flush_critical( \
-    queue, \
-    operations, \
-    filter, \
-    mp_callout, \
-    lock_context \
-  ) \
-    _Thread_queue_Do_flush_critical( \
-      queue, \
-      operations, \
-      filter, \
-      lock_context \
-    )
-#endif
+size_t _Thread_queue_Flush_critical(
+  Thread_queue_Queue            *queue,
+  const Thread_queue_Operations *operations,
+  Thread_queue_Flush_filter      filter,
+  Thread_queue_Context          *queue_context
+);
 
 void _Thread_queue_Initialize( Thread_queue_Control *the_thread_queue );
 
diff --git a/cpukit/score/src/apimutexlock.c b/cpukit/score/src/apimutexlock.c
index 79729d4..11d12c5 100644
--- a/cpukit/score/src/apimutexlock.c
+++ b/cpukit/score/src/apimutexlock.c
@@ -25,20 +25,21 @@
 
 void _API_Mutex_Lock( API_Mutex_Control *the_mutex )
 {
-  Thread_Life_state previous_thread_life_state;
-  ISR_lock_Context  lock_context;
+  Thread_Life_state    previous_thread_life_state;
+  Thread_queue_Context queue_context;
 
   previous_thread_life_state =
     _Thread_Set_life_protection( THREAD_LIFE_PROTECTED );
 
-  _ISR_lock_ISR_disable( &lock_context );
+  _Thread_queue_Context_initialize( &queue_context, NULL );
+  _ISR_lock_ISR_disable( &queue_context.Lock_context );
 
   _CORE_mutex_Seize(
     &the_mutex->Mutex,
     _Thread_Executing,
     true,
     0,
-    &lock_context
+    &queue_context
   );
 
   if ( the_mutex->Mutex.nest_count == 1 ) {
diff --git a/cpukit/score/src/apimutexunlock.c b/cpukit/score/src/apimutexunlock.c
index 082961f..f0f114e 100644
--- a/cpukit/score/src/apimutexunlock.c
+++ b/cpukit/score/src/apimutexunlock.c
@@ -24,19 +24,16 @@
 
 void _API_Mutex_Unlock( API_Mutex_Control *the_mutex )
 {
-  ISR_lock_Context  lock_context;
-  Thread_Life_state previous_thread_life_state;
-  bool              restore_thread_life_protection;
+  Thread_queue_Context queue_context;
+  Thread_Life_state    previous_thread_life_state;
+  bool                 restore_thread_life_protection;
 
   previous_thread_life_state = the_mutex->previous_thread_life_state;
   restore_thread_life_protection = the_mutex->Mutex.nest_count == 1;
 
-  _ISR_lock_ISR_disable( &lock_context );
-  _CORE_mutex_Surrender(
-    &the_mutex->Mutex,
-    NULL,
-    &lock_context
-  );
+  _Thread_queue_Context_initialize( &queue_context, NULL );
+  _ISR_lock_ISR_disable( &queue_context.Lock_context );
+  _CORE_mutex_Surrender( &the_mutex->Mutex, &queue_context );
 
   if ( restore_thread_life_protection ) {
     _Thread_Set_life_protection( previous_thread_life_state );
diff --git a/cpukit/score/src/condition.c b/cpukit/score/src/condition.c
index fcd93b2..c0320b2 100644
--- a/cpukit/score/src/condition.c
+++ b/cpukit/score/src/condition.c
@@ -220,54 +220,54 @@ int _Condition_Wait_recursive_timed(
 }
 
 typedef struct {
-  ISR_lock_Context Base;
-  int              count;
-} Condition_Lock_context;
+  Thread_queue_Context Base;
+  int                  count;
+} Condition_Context;
 
 static Thread_Control *_Condition_Flush_filter(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 )
 {
-  Condition_Lock_context *condition_lock_context;
+  Condition_Context *context;
 
-  condition_lock_context = (Condition_Lock_context *) lock_context;
+  context = (Condition_Context *) queue_context;
 
-  if ( condition_lock_context->count <= 0 ) {
+  if ( context->count <= 0 ) {
     return NULL;
   }
 
-  --condition_lock_context->count;
+  --context->count;
 
   return the_thread;
 }
 
 static void _Condition_Wake( struct _Condition_Control *_condition, int count )
 {
-  Condition_Control      *condition;
-  Condition_Lock_context  lock_context;
+  Condition_Control *condition;
+  Condition_Context  context;
 
   condition = _Condition_Get( _condition );
-  _ISR_lock_ISR_disable( &lock_context.Base );
-  _Condition_Queue_acquire_critical( condition, &lock_context.Base );
+  _Thread_queue_Context_initialize( &context.Base, NULL );
+  _ISR_lock_ISR_disable( &context.Base.Lock_context );
+  _Condition_Queue_acquire_critical( condition, &context.Base.Lock_context );
 
   /*
    * In common uses cases of condition variables there are normally no threads
    * on the queue, so check this condition early.
    */
   if ( __predict_true( _Thread_queue_Is_empty( &condition->Queue.Queue ) ) ) {
-    _Condition_Queue_release( condition, &lock_context.Base );
+    _Condition_Queue_release( condition, &context.Base.Lock_context );
     return;
   }
 
-  lock_context.count = count;
+  context.count = count;
   _Thread_queue_Flush_critical(
     &condition->Queue.Queue,
     CONDITION_TQ_OPERATIONS,
     _Condition_Flush_filter,
-    NULL,
-    &lock_context.Base
+    &context.Base
   );
 }
 
diff --git a/cpukit/score/src/corebarrier.c b/cpukit/score/src/corebarrier.c
index 3cb7906..a32f88c 100644
--- a/cpukit/score/src/corebarrier.c
+++ b/cpukit/score/src/corebarrier.c
@@ -33,9 +33,9 @@ void _CORE_barrier_Initialize(
 }
 
 Thread_Control *_CORE_barrier_Was_deleted(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 )
 {
   the_thread->Wait.return_code = CORE_BARRIER_WAS_DELETED;
diff --git a/cpukit/score/src/corebarrierrelease.c b/cpukit/score/src/corebarrierrelease.c
index c9c80f4..8a23856 100644
--- a/cpukit/score/src/corebarrierrelease.c
+++ b/cpukit/score/src/corebarrierrelease.c
@@ -21,13 +21,10 @@
 
 #include <rtems/score/corebarrierimpl.h>
 
-uint32_t _CORE_barrier_Do_surrender(
+uint32_t _CORE_barrier_Do_flush(
   CORE_barrier_Control      *the_barrier,
   Thread_queue_Flush_filter  filter,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout    mp_callout,
-#endif
-  ISR_lock_Context          *lock_context
+  Thread_queue_Context      *queue_context
 )
 {
   the_barrier->number_of_waiting_threads = 0;
@@ -35,7 +32,6 @@ uint32_t _CORE_barrier_Do_surrender(
     &the_barrier->Wait_queue.Queue,
     CORE_BARRIER_TQ_OPERATIONS,
     filter,
-    mp_callout,
-    lock_context
+    queue_context
   );
 }
diff --git a/cpukit/score/src/corebarrierwait.c b/cpukit/score/src/corebarrierwait.c
index 54e9096..33f1718 100644
--- a/cpukit/score/src/corebarrierwait.c
+++ b/cpukit/score/src/corebarrierwait.c
@@ -21,22 +21,19 @@
 #include <rtems/score/corebarrierimpl.h>
 #include <rtems/score/statesimpl.h>
 
-void _CORE_barrier_Do_seize(
-  CORE_barrier_Control    *the_barrier,
-  Thread_Control          *executing,
-  bool                     wait,
-  Watchdog_Interval        timeout,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout  mp_callout,
-#endif
-  ISR_lock_Context        *lock_context
+void _CORE_barrier_Seize(
+  CORE_barrier_Control *the_barrier,
+  Thread_Control       *executing,
+  bool                  wait,
+  Watchdog_Interval     timeout,
+  Thread_queue_Context *queue_context
 )
 {
   uint32_t number_of_waiting_threads;
 
   executing->Wait.return_code = CORE_BARRIER_STATUS_SUCCESSFUL;
 
-  _CORE_barrier_Acquire_critical( the_barrier, lock_context );
+  _CORE_barrier_Acquire_critical( the_barrier, queue_context );
 
   number_of_waiting_threads = the_barrier->number_of_waiting_threads;
   ++number_of_waiting_threads;
@@ -46,7 +43,7 @@ void _CORE_barrier_Do_seize(
       && number_of_waiting_threads == the_barrier->Attributes.maximum_count
   ) {
     executing->Wait.return_code = CORE_BARRIER_STATUS_AUTOMATICALLY_RELEASED;
-    _CORE_barrier_Surrender( the_barrier, mp_callout, lock_context );
+    _CORE_barrier_Surrender( the_barrier, queue_context );
   } else {
     the_barrier->number_of_waiting_threads = number_of_waiting_threads;
     _Thread_queue_Enqueue_critical(
@@ -56,7 +53,7 @@ void _CORE_barrier_Do_seize(
       STATES_WAITING_FOR_BARRIER,
       timeout,
       CORE_BARRIER_TIMEOUT,
-      lock_context
+      &queue_context->Lock_context
     );
   }
 }
diff --git a/cpukit/score/src/coremsgbroadcast.c b/cpukit/score/src/coremsgbroadcast.c
index a7a962f..23dd343 100644
--- a/cpukit/score/src/coremsgbroadcast.c
+++ b/cpukit/score/src/coremsgbroadcast.c
@@ -21,28 +21,25 @@
 #include <rtems/score/coremsgimpl.h>
 #include <rtems/score/objectimpl.h>
 
-CORE_message_queue_Status _CORE_message_queue_Do_broadcast(
+CORE_message_queue_Status _CORE_message_queue_Broadcast(
   CORE_message_queue_Control *the_message_queue,
   const void                 *buffer,
   size_t                      size,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout     mp_callout,
-#endif
   uint32_t                   *count,
-  ISR_lock_Context           *lock_context
+  Thread_queue_Context       *queue_context
 )
 {
   Thread_Control             *the_thread;
   uint32_t                    number_broadcasted;
 
   if ( size > the_message_queue->maximum_message_size ) {
-    _ISR_lock_ISR_enable( lock_context );
+    _ISR_lock_ISR_enable( &queue_context->Lock_context );
     return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
   }
 
   number_broadcasted = 0;
 
-  _CORE_message_queue_Acquire_critical( the_message_queue, lock_context );
+  _CORE_message_queue_Acquire_critical( the_message_queue, queue_context );
 
   while (
     ( the_thread =
@@ -50,18 +47,17 @@ CORE_message_queue_Status _CORE_message_queue_Do_broadcast(
         the_message_queue,
         buffer,
         size,
-        mp_callout,
         0,
-        lock_context
+        queue_context
       )
     )
   ) {
     number_broadcasted += 1;
 
-    _CORE_message_queue_Acquire( the_message_queue, lock_context );
+    _CORE_message_queue_Acquire( the_message_queue, queue_context );
   }
 
-  _CORE_message_queue_Release( the_message_queue, lock_context );
+  _CORE_message_queue_Release( the_message_queue, queue_context );
 
   *count = number_broadcasted;
   return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
diff --git a/cpukit/score/src/coremsgclose.c b/cpukit/score/src/coremsgclose.c
index 1951e9f..e24d756 100644
--- a/cpukit/score/src/coremsgclose.c
+++ b/cpukit/score/src/coremsgclose.c
@@ -22,9 +22,9 @@
 #include <rtems/score/wkspace.h>
 
 static Thread_Control *_CORE_message_queue_Was_deleted(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 )
 {
   the_thread->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_WAS_DELETED;
@@ -32,12 +32,9 @@ static Thread_Control *_CORE_message_queue_Was_deleted(
   return the_thread;
 }
 
-void _CORE_message_queue_Do_close(
+void _CORE_message_queue_Close(
   CORE_message_queue_Control *the_message_queue,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout     mp_callout,
-#endif
-  ISR_lock_Context           *lock_context
+  Thread_queue_Context       *queue_context
 )
 {
 
@@ -50,8 +47,7 @@ void _CORE_message_queue_Do_close(
     &the_message_queue->Wait_queue.Queue,
     the_message_queue->operations,
     _CORE_message_queue_Was_deleted,
-    mp_callout,
-    lock_context
+    queue_context
   );
 
   (void) _Workspace_Free( the_message_queue->message_buffers );
diff --git a/cpukit/score/src/coremsgflush.c b/cpukit/score/src/coremsgflush.c
index 38f26b7..e5b51f9 100644
--- a/cpukit/score/src/coremsgflush.c
+++ b/cpukit/score/src/coremsgflush.c
@@ -23,7 +23,7 @@
 
 uint32_t   _CORE_message_queue_Flush(
   CORE_message_queue_Control *the_message_queue,
-  ISR_lock_Context           *lock_context
+  Thread_queue_Context       *queue_context
 )
 {
   Chain_Node *inactive_head;
@@ -59,7 +59,7 @@ uint32_t   _CORE_message_queue_Flush(
    *  fixed execution time that only deals with pending messages.
    */
 
-  _CORE_message_queue_Acquire_critical( the_message_queue, lock_context );
+  _CORE_message_queue_Acquire_critical( the_message_queue, queue_context );
 
   count = the_message_queue->number_of_pending_messages;
   if ( count != 0 ) {
@@ -78,6 +78,6 @@ uint32_t   _CORE_message_queue_Flush(
     _Chain_Initialize_empty( &the_message_queue->Pending_messages );
   }
 
-  _CORE_message_queue_Release( the_message_queue, lock_context );
+  _CORE_message_queue_Release( the_message_queue, queue_context );
   return count;
 }
diff --git a/cpukit/score/src/coremsgseize.c b/cpukit/score/src/coremsgseize.c
index fcc95a7..b05ddd6 100644
--- a/cpukit/score/src/coremsgseize.c
+++ b/cpukit/score/src/coremsgseize.c
@@ -24,7 +24,6 @@
 #include <rtems/score/coremsgimpl.h>
 #include <rtems/score/thread.h>
 #include <rtems/score/statesimpl.h>
-#include <rtems/score/wkspace.h>
 
 void _CORE_message_queue_Seize(
   CORE_message_queue_Control *the_message_queue,
@@ -33,7 +32,7 @@ void _CORE_message_queue_Seize(
   size_t                     *size_p,
   bool                        wait,
   Watchdog_Interval           timeout,
-  ISR_lock_Context           *lock_context
+  Thread_queue_Context       *queue_context
 )
 {
   CORE_message_queue_Buffer_control *the_message;
@@ -58,7 +57,7 @@ void _CORE_message_queue_Seize(
        *  So return immediately.
        */
       _CORE_message_queue_Free_message_buffer(the_message_queue, the_message);
-      _CORE_message_queue_Release( the_message_queue, lock_context );
+      _CORE_message_queue_Release( the_message_queue, queue_context );
       return;
     #else
     {
@@ -80,7 +79,7 @@ void _CORE_message_queue_Seize(
           the_message_queue,
           the_message
         );
-        _CORE_message_queue_Release( the_message_queue, lock_context );
+        _CORE_message_queue_Release( the_message_queue, queue_context );
         return;
       }
 
@@ -100,8 +99,7 @@ void _CORE_message_queue_Seize(
         &the_message_queue->Wait_queue.Queue,
         the_message_queue->operations,
         the_thread,
-        NULL,
-        lock_context
+        queue_context
       );
       return;
     }
@@ -109,7 +107,7 @@ void _CORE_message_queue_Seize(
   }
 
   if ( !wait ) {
-    _CORE_message_queue_Release( the_message_queue, lock_context );
+    _CORE_message_queue_Release( the_message_queue, queue_context );
     executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
     return;
   }
@@ -125,6 +123,6 @@ void _CORE_message_queue_Seize(
     STATES_WAITING_FOR_MESSAGE,
     timeout,
     CORE_MESSAGE_QUEUE_STATUS_TIMEOUT,
-    lock_context
+    &queue_context->Lock_context
   );
 }
diff --git a/cpukit/score/src/coremsgsubmit.c b/cpukit/score/src/coremsgsubmit.c
index 82cfa1a..06fd698 100644
--- a/cpukit/score/src/coremsgsubmit.c
+++ b/cpukit/score/src/coremsgsubmit.c
@@ -25,25 +25,22 @@
 #include <rtems/score/statesimpl.h>
 #include <rtems/score/wkspace.h>
 
-CORE_message_queue_Status _CORE_message_queue_Do_submit(
+CORE_message_queue_Status _CORE_message_queue_Submit(
   CORE_message_queue_Control       *the_message_queue,
   Thread_Control                   *executing,
   const void                       *buffer,
   size_t                            size,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout           mp_callout,
-#endif
   CORE_message_queue_Submit_types   submit_type,
   bool                              wait,
   Watchdog_Interval                 timeout,
-  ISR_lock_Context                 *lock_context
+  Thread_queue_Context             *queue_context
 )
 {
   CORE_message_queue_Buffer_control *the_message;
   Thread_Control                    *the_thread;
 
   if ( size > the_message_queue->maximum_message_size ) {
-    _CORE_message_queue_Release( the_message_queue, lock_context );
+    _CORE_message_queue_Release( the_message_queue, queue_context );
     return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
   }
 
@@ -55,9 +52,8 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit(
     the_message_queue,
     buffer,
     size,
-    mp_callout,
     submit_type,
-    lock_context
+    queue_context
   );
   if ( the_thread != NULL ) {
     return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
@@ -90,20 +86,20 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit(
     ) {
       ( *the_message_queue->notify_handler )(
         the_message_queue,
-        lock_context
+        queue_context
       );
     } else {
-      _CORE_message_queue_Release( the_message_queue, lock_context );
+      _CORE_message_queue_Release( the_message_queue, queue_context );
     }
 #else
-    _CORE_message_queue_Release( the_message_queue, lock_context );
+    _CORE_message_queue_Release( the_message_queue, queue_context );
 #endif
 
     return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
   }
 
   #if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND)
-    _CORE_message_queue_Release( the_message_queue, lock_context );
+    _CORE_message_queue_Release( the_message_queue, queue_context );
     return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
   #else
     /*
@@ -112,7 +108,7 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit(
      *  on the queue.
      */
     if ( !wait ) {
-      _CORE_message_queue_Release( the_message_queue, lock_context );
+      _CORE_message_queue_Release( the_message_queue, queue_context );
       return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
     }
 
@@ -121,7 +117,7 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit(
      *  deadly to block in an ISR.
      */
     if ( _ISR_Is_in_progress() ) {
-      _CORE_message_queue_Release( the_message_queue, lock_context );
+      _CORE_message_queue_Release( the_message_queue, queue_context );
       return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
     }
 
@@ -142,7 +138,7 @@ CORE_message_queue_Status _CORE_message_queue_Do_submit(
       STATES_WAITING_FOR_MESSAGE,
       timeout,
       CORE_MESSAGE_QUEUE_STATUS_TIMEOUT,
-      lock_context
+      &queue_context->Lock_context
     );
     return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
   #endif
diff --git a/cpukit/score/src/coremutex.c b/cpukit/score/src/coremutex.c
index ea5e759..ecca244 100644
--- a/cpukit/score/src/coremutex.c
+++ b/cpukit/score/src/coremutex.c
@@ -92,9 +92,9 @@ CORE_mutex_Status _CORE_mutex_Initialize(
 }
 
 Thread_Control *_CORE_mutex_Was_deleted(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 )
 {
   the_thread->Wait.return_code = CORE_MUTEX_WAS_DELETED;
@@ -103,9 +103,9 @@ Thread_Control *_CORE_mutex_Was_deleted(
 }
 
 Thread_Control *_CORE_mutex_Unsatisfied_nowait(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 )
 {
   the_thread->Wait.return_code = CORE_MUTEX_STATUS_UNSATISFIED_NOWAIT;
diff --git a/cpukit/score/src/coremutexsurrender.c b/cpukit/score/src/coremutexsurrender.c
index 746fee1..040a580 100644
--- a/cpukit/score/src/coremutexsurrender.c
+++ b/cpukit/score/src/coremutexsurrender.c
@@ -23,12 +23,9 @@
 #include <rtems/score/coremuteximpl.h>
 #include <rtems/score/thread.h>
 
-CORE_mutex_Status _CORE_mutex_Do_surrender(
-  CORE_mutex_Control      *the_mutex,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout  mp_callout,
-#endif
-  ISR_lock_Context        *lock_context
+CORE_mutex_Status _CORE_mutex_Surrender(
+  CORE_mutex_Control   *the_mutex,
+  Thread_queue_Context *queue_context
 )
 {
   Thread_Control *the_thread;
@@ -46,17 +43,17 @@ CORE_mutex_Status _CORE_mutex_Do_surrender(
 
   if ( the_mutex->Attributes.only_owner_release ) {
     if ( !_Thread_Is_executing( holder ) ) {
-      _ISR_lock_ISR_enable( lock_context );
+      _ISR_lock_ISR_enable( &queue_context->Lock_context );
       return CORE_MUTEX_STATUS_NOT_OWNER_OF_RESOURCE;
     }
   }
 
-  _Thread_queue_Acquire_critical( &the_mutex->Wait_queue, lock_context );
+  _CORE_mutex_Acquire_critical( the_mutex, queue_context );
 
   /* XXX already unlocked -- not right status */
 
   if ( !the_mutex->nest_count ) {
-    _Thread_queue_Release( &the_mutex->Wait_queue, lock_context );
+    _CORE_mutex_Release( the_mutex, queue_context );
     return CORE_MUTEX_STATUS_SUCCESSFUL;
   }
 
@@ -71,12 +68,12 @@ CORE_mutex_Status _CORE_mutex_Do_surrender(
     #if defined(RTEMS_DEBUG)
       switch ( the_mutex->Attributes.lock_nesting_behavior ) {
         case CORE_MUTEX_NESTING_ACQUIRES:
-          _Thread_queue_Release( &the_mutex->Wait_queue, lock_context );
+          _CORE_mutex_Release( the_mutex, queue_context );
           return CORE_MUTEX_STATUS_SUCCESSFUL;
         #if defined(RTEMS_POSIX_API)
           case CORE_MUTEX_NESTING_IS_ERROR:
             /* should never occur */
-            _Thread_queue_Release( &the_mutex->Wait_queue, lock_context );
+            _CORE_mutex_Release( the_mutex, queue_context );
             return CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
         #endif
         case CORE_MUTEX_NESTING_BLOCKS:
@@ -84,7 +81,7 @@ CORE_mutex_Status _CORE_mutex_Do_surrender(
           break;
       }
     #else
-      _Thread_queue_Release( &the_mutex->Wait_queue, lock_context );
+      _CORE_mutex_Release( the_mutex, queue_context );
       /* must be CORE_MUTEX_NESTING_ACQUIRES or we wouldn't be here */
       return CORE_MUTEX_STATUS_SUCCESSFUL;
     #endif
@@ -126,7 +123,7 @@ CORE_mutex_Status _CORE_mutex_Do_surrender(
       &the_mutex->Wait_queue.Queue,
       the_mutex->operations,
       the_thread,
-      mp_callout
+      queue_context
     );
 
 #if defined(RTEMS_MULTIPROCESSING)
@@ -155,10 +152,10 @@ CORE_mutex_Status _CORE_mutex_Do_surrender(
       unblock,
       &the_mutex->Wait_queue.Queue,
       the_thread,
-      lock_context
+      &queue_context->Lock_context
     );
   } else {
-    _Thread_queue_Release( &the_mutex->Wait_queue, lock_context );
+    _CORE_mutex_Release( the_mutex, queue_context );
   }
 
   /*
diff --git a/cpukit/score/src/corerwlockobtainread.c b/cpukit/score/src/corerwlockobtainread.c
index fcbaf4a..639ea70 100644
--- a/cpukit/score/src/corerwlockobtainread.c
+++ b/cpukit/score/src/corerwlockobtainread.c
@@ -24,11 +24,11 @@
 #include <rtems/score/watchdog.h>
 
 void _CORE_RWLock_Seize_for_reading(
-  CORE_RWLock_Control *the_rwlock,
-  Thread_Control      *executing,
-  bool                 wait,
-  Watchdog_Interval    timeout,
-  ISR_lock_Context    *lock_context
+  CORE_RWLock_Control  *the_rwlock,
+  Thread_Control       *executing,
+  bool                  wait,
+  Watchdog_Interval     timeout,
+  Thread_queue_Context *queue_context
 )
 {
   /*
@@ -37,13 +37,13 @@ void _CORE_RWLock_Seize_for_reading(
    *  If any thread is waiting, then we wait.
    */
 
-  _CORE_RWLock_Acquire_critical( the_rwlock, lock_context );
+  _CORE_RWLock_Acquire_critical( the_rwlock, queue_context );
 
   switch ( the_rwlock->current_state ) {
     case CORE_RWLOCK_UNLOCKED:
       the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_READING;
       the_rwlock->number_of_readers += 1;
-      _CORE_RWLock_Release( the_rwlock, lock_context );
+      _CORE_RWLock_Release( the_rwlock, queue_context );
       executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
       return;
 
@@ -55,7 +55,7 @@ void _CORE_RWLock_Seize_for_reading(
       );
       if ( !waiter ) {
         the_rwlock->number_of_readers += 1;
-        _CORE_RWLock_Release( the_rwlock, lock_context );
+        _CORE_RWLock_Release( the_rwlock, queue_context );
         executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
         return;
       }
@@ -70,7 +70,7 @@ void _CORE_RWLock_Seize_for_reading(
    */
 
   if ( !wait ) {
-    _CORE_RWLock_Release( the_rwlock, lock_context );
+    _CORE_RWLock_Release( the_rwlock, queue_context );
     executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
     return;
   }
@@ -89,6 +89,6 @@ void _CORE_RWLock_Seize_for_reading(
      STATES_WAITING_FOR_RWLOCK,
      timeout,
      CORE_RWLOCK_TIMEOUT,
-     lock_context
+     &queue_context->Lock_context
   );
 }
diff --git a/cpukit/score/src/corerwlockobtainwrite.c b/cpukit/score/src/corerwlockobtainwrite.c
index e1bb1bd..a7d1bb1 100644
--- a/cpukit/score/src/corerwlockobtainwrite.c
+++ b/cpukit/score/src/corerwlockobtainwrite.c
@@ -24,11 +24,11 @@
 #include <rtems/score/watchdog.h>
 
 void _CORE_RWLock_Seize_for_writing(
-  CORE_RWLock_Control *the_rwlock,
-  Thread_Control      *executing,
-  bool                 wait,
-  Watchdog_Interval    timeout,
-  ISR_lock_Context    *lock_context
+  CORE_RWLock_Control  *the_rwlock,
+  Thread_Control       *executing,
+  bool                  wait,
+  Watchdog_Interval     timeout,
+  Thread_queue_Context *queue_context
 )
 {
   /*
@@ -38,12 +38,12 @@ void _CORE_RWLock_Seize_for_writing(
    *  If any thread is waiting, then we wait.
    */
 
-  _CORE_RWLock_Acquire_critical( the_rwlock, lock_context );
+  _CORE_RWLock_Acquire_critical( the_rwlock, queue_context );
 
   switch ( the_rwlock->current_state ) {
     case CORE_RWLOCK_UNLOCKED:
       the_rwlock->current_state = CORE_RWLOCK_LOCKED_FOR_WRITING;
-      _CORE_RWLock_Release( the_rwlock, lock_context );
+      _CORE_RWLock_Release( the_rwlock, queue_context );
       executing->Wait.return_code = CORE_RWLOCK_SUCCESSFUL;
       return;
 
@@ -57,7 +57,7 @@ void _CORE_RWLock_Seize_for_writing(
    */
 
   if ( !wait ) {
-    _CORE_RWLock_Release( the_rwlock, lock_context );
+    _CORE_RWLock_Release( the_rwlock, queue_context );
     executing->Wait.return_code = CORE_RWLOCK_UNAVAILABLE;
     return;
   }
@@ -76,6 +76,6 @@ void _CORE_RWLock_Seize_for_writing(
      STATES_WAITING_FOR_RWLOCK,
      timeout,
      CORE_RWLOCK_TIMEOUT,
-     lock_context
+     &queue_context->Lock_context
   );
 }
diff --git a/cpukit/score/src/corerwlockrelease.c b/cpukit/score/src/corerwlockrelease.c
index 6f76aad..81e01d1 100644
--- a/cpukit/score/src/corerwlockrelease.c
+++ b/cpukit/score/src/corerwlockrelease.c
@@ -35,9 +35,9 @@ static bool _CORE_RWLock_Is_waiting_for_reading(
 }
 
 static Thread_Control *_CORE_RWLock_Flush_filter(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 )
 {
   CORE_RWLock_Control *the_rwlock;
@@ -74,8 +74,8 @@ static Thread_Control *_CORE_RWLock_Flush_filter(
 }
 
 CORE_RWLock_Status _CORE_RWLock_Surrender(
-  CORE_RWLock_Control *the_rwlock,
-  ISR_lock_Context    *lock_context
+  CORE_RWLock_Control  *the_rwlock,
+  Thread_queue_Context *queue_context
 )
 {
   /*
@@ -85,11 +85,11 @@ CORE_RWLock_Status _CORE_RWLock_Surrender(
    *  If any thread is waiting, then we wait.
    */
 
-  _CORE_RWLock_Acquire_critical( the_rwlock, lock_context );
+  _CORE_RWLock_Acquire_critical( the_rwlock, queue_context );
 
   if ( the_rwlock->current_state == CORE_RWLOCK_UNLOCKED){
     /* This is an error at the caller site */
-    _CORE_RWLock_Release( the_rwlock, lock_context );
+    _CORE_RWLock_Release( the_rwlock, queue_context );
     return CORE_RWLOCK_SUCCESSFUL;
   }
 
@@ -98,7 +98,7 @@ CORE_RWLock_Status _CORE_RWLock_Surrender(
 
     if ( the_rwlock->number_of_readers != 0 ) {
       /* must be unlocked again */
-      _CORE_RWLock_Release( the_rwlock, lock_context );
+      _CORE_RWLock_Release( the_rwlock, queue_context );
       return CORE_RWLOCK_SUCCESSFUL;
     }
   }
@@ -119,8 +119,7 @@ CORE_RWLock_Status _CORE_RWLock_Surrender(
     &the_rwlock->Wait_queue.Queue,
     CORE_RWLOCK_TQ_OPERATIONS,
     _CORE_RWLock_Flush_filter,
-    NULL,
-    lock_context
+    queue_context
   );
   return CORE_RWLOCK_SUCCESSFUL;
 }
diff --git a/cpukit/score/src/coresem.c b/cpukit/score/src/coresem.c
index 02a3837..c94f2b7 100644
--- a/cpukit/score/src/coresem.c
+++ b/cpukit/score/src/coresem.c
@@ -38,9 +38,9 @@ void _CORE_semaphore_Initialize(
 }
 
 Thread_Control *_CORE_semaphore_Was_deleted(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 )
 {
   the_thread->Wait.return_code = CORE_SEMAPHORE_WAS_DELETED;
@@ -49,9 +49,9 @@ Thread_Control *_CORE_semaphore_Was_deleted(
 }
 
 Thread_Control *_CORE_semaphore_Unsatisfied_nowait(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 )
 {
   the_thread->Wait.return_code = CORE_SEMAPHORE_STATUS_UNSATISFIED_NOWAIT;
diff --git a/cpukit/score/src/futex.c b/cpukit/score/src/futex.c
index 66085a8..d7945d1 100644
--- a/cpukit/score/src/futex.c
+++ b/cpukit/score/src/futex.c
@@ -104,25 +104,25 @@ int _Futex_Wait( struct _Futex_Control *_futex, int *uaddr, int val )
 }
 
 typedef struct {
-  ISR_lock_Context Base;
-  int              count;
-} Futex_Lock_context;
+  Thread_queue_Context Base;
+  int                  count;
+} Futex_Context;
 
 static Thread_Control *_Futex_Flush_filter(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 )
 {
-  Futex_Lock_context *futex_lock_context;
+  Futex_Context *context;
 
-  futex_lock_context = (Futex_Lock_context *) lock_context;
+  context = (Futex_Context *) queue_context;
 
-  if ( futex_lock_context->count <= 0 ) {
+  if ( context->count <= 0 ) {
     return NULL;
   }
 
-  --futex_lock_context->count;
+  --context->count;
 
   return the_thread;
 }
@@ -130,10 +130,10 @@ static Thread_Control *_Futex_Flush_filter(
 int _Futex_Wake( struct _Futex_Control *_futex, int count )
 {
   Futex_Control      *futex;
-  Futex_Lock_context  lock_context;
+  Futex_Context  context;
 
   futex = _Futex_Get( _futex );
-  _Futex_Queue_acquire( futex, &lock_context.Base );
+  _Futex_Queue_acquire( futex, &context.Base.Lock_context );
 
   /*
    * For some synchronization objects like barriers the _Futex_Wake() must be
@@ -141,17 +141,16 @@ int _Futex_Wake( struct _Futex_Control *_futex, int count )
    * check this condition early.
    */
   if ( __predict_true( _Thread_queue_Is_empty( &futex->Queue.Queue ) ) ) {
-    _Futex_Queue_release( futex, &lock_context.Base );
+    _Futex_Queue_release( futex, &context.Base.Lock_context );
     return 0;
   }
 
-  lock_context.count = count;
+  context.count = count;
   return (int) _Thread_queue_Flush_critical(
     &futex->Queue.Queue,
     FUTEX_TQ_OPERATIONS,
     _Futex_Flush_filter,
-    NULL,
-    &lock_context.Base
+    &context.Base
   );
 }
 
diff --git a/cpukit/score/src/mpci.c b/cpukit/score/src/mpci.c
index 0b51e38..4022a80 100644
--- a/cpukit/score/src/mpci.c
+++ b/cpukit/score/src/mpci.c
@@ -321,24 +321,25 @@ void _MPCI_Receive_server(
 )
 {
 
-  MP_packet_Prefix         *the_packet;
-  MPCI_Packet_processor     the_function;
-  Thread_Control           *executing;
-  ISR_lock_Context          lock_context;
+  MP_packet_Prefix      *the_packet;
+  MPCI_Packet_processor  the_function;
+  Thread_Control        *executing;
+  Thread_queue_Context   queue_context;
 
   executing = _Thread_Get_executing();
+  _Thread_queue_Context_initialize( &queue_context, NULL );
 
   for ( ; ; ) {
 
     executing->receive_packet = NULL;
 
-    _ISR_lock_ISR_disable( &lock_context );
+    _ISR_lock_ISR_disable( &queue_context.Lock_context );
     _CORE_semaphore_Seize(
       &_MPCI_Semaphore,
       executing,
       true,
       WATCHDOG_NO_TIMEOUT,
-      &lock_context
+      &queue_context
     );
 
     for ( ; ; ) {
@@ -370,10 +371,10 @@ void _MPCI_Receive_server(
 
 void _MPCI_Announce ( void )
 {
-  ISR_lock_Context lock_context;
+  Thread_queue_Context queue_context;
 
-  _ISR_lock_ISR_disable( &lock_context );
-  (void) _CORE_semaphore_Surrender( &_MPCI_Semaphore, 0, &lock_context );
+  _ISR_lock_ISR_disable( &queue_context.Lock_context );
+  (void) _CORE_semaphore_Surrender( &_MPCI_Semaphore, &queue_context );
 }
 
 void _MPCI_Internal_packets_Send_process_packet (
diff --git a/cpukit/score/src/mutex.c b/cpukit/score/src/mutex.c
index e27075e..0b12232 100644
--- a/cpukit/score/src/mutex.c
+++ b/cpukit/score/src/mutex.c
@@ -125,11 +125,11 @@ static void _Mutex_Acquire_slow(
 }
 
 static void _Mutex_Release_slow(
-  Mutex_Control      *mutex,
-  Thread_Control     *executing,
-  Thread_queue_Heads *heads,
-  bool                keep_priority,
-  ISR_lock_Context   *lock_context
+  Mutex_Control        *mutex,
+  Thread_Control       *executing,
+  Thread_queue_Heads   *heads,
+  bool                  keep_priority,
+  Thread_queue_Context *queue_context
 )
 {
   if (heads != NULL) {
@@ -146,17 +146,17 @@ static void _Mutex_Release_slow(
       &mutex->Queue.Queue,
       operations,
       first,
-      NULL
+      queue_context
     );
     _Thread_queue_Boost_priority( &mutex->Queue.Queue, first );
     _Thread_queue_Unblock_critical(
       unblock,
       &mutex->Queue.Queue,
       first,
-      lock_context
+      &queue_context->Lock_context
     );
   } else {
-    _Mutex_Queue_release( mutex, lock_context);
+    _Mutex_Queue_release( mutex, &queue_context->Lock_context );
   }
 
   if ( !keep_priority ) {
@@ -169,9 +169,9 @@ static void _Mutex_Release_slow(
 }
 
 static void _Mutex_Release_critical(
-  Mutex_Control *mutex,
-  Thread_Control *executing,
-  ISR_lock_Context *lock_context
+  Mutex_Control        *mutex,
+  Thread_Control       *executing,
+  Thread_queue_Context *queue_context
 )
 {
   Thread_queue_Heads *heads;
@@ -193,14 +193,14 @@ static void _Mutex_Release_critical(
     || !executing->priority_restore_hint;
 
   if ( __predict_true( heads == NULL && keep_priority ) ) {
-    _Mutex_Queue_release( mutex, lock_context );
+    _Mutex_Queue_release( mutex, &queue_context->Lock_context );
   } else {
     _Mutex_Release_slow(
       mutex,
       executing,
       heads,
       keep_priority,
-      lock_context
+      queue_context
     );
   }
 }
@@ -297,16 +297,17 @@ int _Mutex_Try_acquire( struct _Mutex_Control *_mutex )
 
 void _Mutex_Release( struct _Mutex_Control *_mutex )
 {
-  Mutex_Control    *mutex;
-  ISR_lock_Context  lock_context;
-  Thread_Control   *executing;
+  Mutex_Control        *mutex;
+  Thread_queue_Context  queue_context;
+  Thread_Control       *executing;
 
   mutex = _Mutex_Get( _mutex );
-  executing = _Mutex_Queue_acquire( mutex, &lock_context );
+  _Thread_queue_Context_initialize( &queue_context, NULL );
+  executing = _Mutex_Queue_acquire( mutex, &queue_context.Lock_context );
 
   _Assert( mutex->owner == executing );
 
-  _Mutex_Release_critical( mutex, executing, &lock_context );
+  _Mutex_Release_critical( mutex, executing, &queue_context );
 }
 
 static Mutex_recursive_Control *_Mutex_recursive_Get(
@@ -426,23 +427,27 @@ int _Mutex_recursive_Try_acquire( struct _Mutex_recursive_Control *_mutex )
 void _Mutex_recursive_Release( struct _Mutex_recursive_Control *_mutex )
 {
   Mutex_recursive_Control *mutex;
-  ISR_lock_Context         lock_context;
+  Thread_queue_Context     queue_context;
   Thread_Control          *executing;
   unsigned int             nest_level;
 
   mutex = _Mutex_recursive_Get( _mutex );
-  executing = _Mutex_Queue_acquire( &mutex->Mutex, &lock_context );
+  _Thread_queue_Context_initialize( &queue_context, NULL );
+  executing = _Mutex_Queue_acquire(
+    &mutex->Mutex,
+    &queue_context.Lock_context
+  );
 
   _Assert( mutex->Mutex.owner == executing );
 
   nest_level = mutex->nest_level;
 
   if ( __predict_true( nest_level == 0 ) ) {
-    _Mutex_Release_critical( &mutex->Mutex, executing, &lock_context );
+    _Mutex_Release_critical( &mutex->Mutex, executing, &queue_context );
   } else {
     mutex->nest_level = nest_level - 1;
 
-    _Mutex_Queue_release( &mutex->Mutex, &lock_context );
+    _Mutex_Queue_release( &mutex->Mutex, &queue_context.Lock_context );
   }
 }
 
diff --git a/cpukit/score/src/semaphore.c b/cpukit/score/src/semaphore.c
index 4e70b79..3d0d5f5 100644
--- a/cpukit/score/src/semaphore.c
+++ b/cpukit/score/src/semaphore.c
@@ -110,18 +110,19 @@ void _Semaphore_Wait( struct _Semaphore_Control *_sem )
 
 void _Semaphore_Post( struct _Semaphore_Control *_sem )
 {
-  Semaphore_Control  *sem;
-  ISR_lock_Context    lock_context;
-  Thread_queue_Heads *heads;
+  Semaphore_Control    *sem;
+  Thread_queue_Context  queue_context;
+  Thread_queue_Heads   *heads;
 
   sem = _Semaphore_Get( _sem );
-  _Semaphore_Queue_acquire( sem, &lock_context );
+  _Thread_queue_Context_initialize( &queue_context, NULL );
+  _Semaphore_Queue_acquire( sem, &queue_context.Lock_context );
 
   heads = sem->Queue.Queue.heads;
   if ( heads == NULL ) {
     _Assert( sem->count < UINT_MAX );
     ++sem->count;
-    _Semaphore_Queue_release( sem, &lock_context );
+    _Semaphore_Queue_release( sem, &queue_context.Lock_context );
   } else {
     const Thread_queue_Operations *operations;
     Thread_Control *first;
@@ -133,8 +134,7 @@ void _Semaphore_Post( struct _Semaphore_Control *_sem )
       &sem->Queue.Queue,
       operations,
       first,
-      NULL,
-      &lock_context
+      &queue_context
     );
   }
 }
diff --git a/cpukit/score/src/threadqenqueue.c b/cpukit/score/src/threadqenqueue.c
index cda7c86..a1a37e1 100644
--- a/cpukit/score/src/threadqenqueue.c
+++ b/cpukit/score/src/threadqenqueue.c
@@ -99,7 +99,7 @@ bool _Thread_queue_Do_extract_locked(
   Thread_Control                *the_thread
 #if defined(RTEMS_MULTIPROCESSING)
   ,
-  Thread_queue_MP_callout        mp_callout
+  const Thread_queue_Context    *queue_context
 #endif
 )
 {
@@ -108,12 +108,13 @@ bool _Thread_queue_Do_extract_locked(
 
 #if defined(RTEMS_MULTIPROCESSING)
   if ( !_Objects_Is_local_id( the_thread->Object.id ) ) {
-    Thread_Proxy_control *the_proxy;
-
-    _Assert( mp_callout != NULL );
+    Thread_Proxy_control    *the_proxy;
+    Thread_queue_MP_callout  mp_callout;
 
     the_proxy = (Thread_Proxy_control *) the_thread;
-    the_proxy->thread_queue_callout = mp_callout;
+    mp_callout = queue_context->mp_callout;
+    _Assert( mp_callout != NULL );
+    the_proxy->thread_queue_callout = queue_context->mp_callout;
   }
 #endif
 
@@ -164,14 +165,11 @@ void _Thread_queue_Unblock_critical(
   }
 }
 
-void _Thread_queue_Do_extract_critical(
+void _Thread_queue_Extract_critical(
   Thread_queue_Queue            *queue,
   const Thread_queue_Operations *operations,
   Thread_Control                *the_thread,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout        mp_callout,
-#endif
-  ISR_lock_Context              *lock_context
+  Thread_queue_Context          *queue_context
 )
 {
   bool unblock;
@@ -180,24 +178,28 @@ void _Thread_queue_Do_extract_critical(
     queue,
     operations,
     the_thread,
-    mp_callout
+    queue_context
   );
 
   _Thread_queue_Unblock_critical(
     unblock,
     queue,
     the_thread,
-    lock_context
+    &queue_context->Lock_context
   );
 }
 
 void _Thread_queue_Extract( Thread_Control *the_thread )
 {
-  ISR_lock_Context    lock_context;
-  void               *lock;
-  Thread_queue_Queue *queue;
+  Thread_queue_Context  queue_context;
+  void                 *lock;
+  Thread_queue_Queue   *queue;
 
-  lock = _Thread_Lock_acquire( the_thread, &lock_context );
+  _Thread_queue_Context_initialize(
+    &queue_context,
+    _Thread_queue_MP_callout_do_nothing
+  );
+  lock = _Thread_Lock_acquire( the_thread, &queue_context.Lock_context );
 
   queue = the_thread->Wait.queue;
 
@@ -208,11 +210,10 @@ void _Thread_queue_Extract( Thread_Control *the_thread )
       queue,
       the_thread->Wait.operations,
       the_thread,
-      _Thread_queue_MP_callout_do_nothing,
-      &lock_context
+      &queue_context
     );
   } else {
-    _Thread_Lock_release( lock, &lock_context );
+    _Thread_Lock_release( lock, &queue_context.Lock_context );
   }
 }
 
@@ -225,10 +226,11 @@ Thread_Control *_Thread_queue_Do_dequeue(
 #endif
 )
 {
-  ISR_lock_Context  lock_context;
-  Thread_Control   *the_thread;
+  Thread_queue_Context  queue_context;
+  Thread_Control       *the_thread;
 
-  _Thread_queue_Acquire( the_thread_queue, &lock_context );
+  _Thread_queue_Context_initialize( &queue_context, mp_callout );
+  _Thread_queue_Acquire( the_thread_queue, &queue_context.Lock_context );
 
   the_thread = _Thread_queue_First_locked( the_thread_queue, operations );
 
@@ -239,11 +241,10 @@ Thread_Control *_Thread_queue_Do_dequeue(
       &the_thread_queue->Queue,
       operations,
       the_thread,
-      mp_callout,
-      &lock_context
+      &queue_context
     );
   } else {
-    _Thread_queue_Release( the_thread_queue, &lock_context );
+    _Thread_queue_Release( the_thread_queue, &queue_context.Lock_context );
   }
 
   return the_thread;
diff --git a/cpukit/score/src/threadqflush.c b/cpukit/score/src/threadqflush.c
index 0413388..8b23194 100644
--- a/cpukit/score/src/threadqflush.c
+++ b/cpukit/score/src/threadqflush.c
@@ -21,24 +21,21 @@
 #include <rtems/score/threadimpl.h>
 
 Thread_Control *_Thread_queue_Flush_default_filter(
-  Thread_Control     *the_thread,
-  Thread_queue_Queue *queue,
-  ISR_lock_Context   *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 )
 {
   (void) queue;
-  (void) lock_context;
+  (void) queue_context;
   return the_thread;
 }
 
-size_t _Thread_queue_Do_flush_critical(
+size_t _Thread_queue_Flush_critical(
   Thread_queue_Queue            *queue,
   const Thread_queue_Operations *operations,
   Thread_queue_Flush_filter      filter,
-#if defined(RTEMS_MULTIPROCESSING)
-  Thread_queue_MP_callout        mp_callout,
-#endif
-  ISR_lock_Context              *lock_context
+  Thread_queue_Context          *queue_context
 )
 {
   size_t         flushed;
@@ -60,7 +57,7 @@ size_t _Thread_queue_Do_flush_critical(
     }
 
     first = ( *operations->first )( heads );
-    first = ( *filter )( first, queue, lock_context );
+    first = ( *filter )( first, queue, queue_context );
     if ( first == NULL ) {
       break;
     }
@@ -69,7 +66,7 @@ size_t _Thread_queue_Do_flush_critical(
       queue,
       operations,
       first,
-      mp_callout
+      queue_context
     );
     if ( do_unblock ) {
       _Chain_Append_unprotected( &unblock, &first->Wait.Node.Chain );
@@ -84,8 +81,10 @@ size_t _Thread_queue_Do_flush_critical(
   if ( node != tail ) {
     Per_CPU_Control *cpu_self;
 
-    cpu_self = _Thread_Dispatch_disable_critical( lock_context );
-    _Thread_queue_Queue_release( queue, lock_context );
+    cpu_self = _Thread_Dispatch_disable_critical(
+      &queue_context->Lock_context
+    );
+    _Thread_queue_Queue_release( queue, &queue_context->Lock_context );
 
     do {
       Thread_Control *the_thread;
@@ -100,7 +99,7 @@ size_t _Thread_queue_Do_flush_critical(
 
     _Thread_Dispatch_enable( cpu_self );
   } else {
-    _Thread_queue_Queue_release( queue, lock_context );
+    _Thread_queue_Queue_release( queue, &queue_context->Lock_context );
   }
 
   return flushed;
diff --git a/cpukit/score/src/threadrestart.c b/cpukit/score/src/threadrestart.c
index 30536f7..52d68de 100644
--- a/cpukit/score/src/threadrestart.c
+++ b/cpukit/score/src/threadrestart.c
@@ -87,24 +87,24 @@ static void _Thread_Raise_real_priority(
 }
 
 typedef struct {
-  ISR_lock_Context  Base;
+  Thread_queue_Context  Base;
 #if defined(RTEMS_POSIX_API)
-  void             *exit_value;
+  void                 *exit_value;
 #endif
-} Thread_Join_lock_context;
+} Thread_Join_context;
 
 #if defined(RTEMS_POSIX_API)
 static Thread_Control *_Thread_Join_flush_filter(
-  Thread_Control      *the_thread,
-  Thread_queue_Queue  *queue,
-  ISR_lock_Context    *lock_context
+  Thread_Control       *the_thread,
+  Thread_queue_Queue   *queue,
+  Thread_queue_Context *queue_context
 )
 {
-  Thread_Join_lock_context *join_lock_context;
+  Thread_Join_context *join_context;
 
-  join_lock_context = (Thread_Join_lock_context *) lock_context;
+  join_context = (Thread_Join_context *) queue_context;
 
-  the_thread->Wait.return_argument = join_lock_context->exit_value;
+  the_thread->Wait.return_argument = join_context->exit_value;
 
   return the_thread;
 }
@@ -112,13 +112,17 @@ static Thread_Control *_Thread_Join_flush_filter(
 
 static void _Thread_Wake_up_joining_threads( Thread_Control *the_thread )
 {
-  Thread_Join_lock_context join_lock_context;
+  Thread_Join_context join_context;
 
 #if defined(RTEMS_POSIX_API)
-  join_lock_context.exit_value = the_thread->Life.exit_value;
+  join_context.exit_value = the_thread->Life.exit_value;
 #endif
 
-  _Thread_State_acquire( the_thread, &join_lock_context.Base );
+  _Thread_queue_Context_initialize( &join_context.Base, NULL );
+  _Thread_queue_Acquire(
+    &the_thread->Join_queue,
+    &join_context.Base.Lock_context
+  );
   _Thread_queue_Flush_critical(
     &the_thread->Join_queue.Queue,
     THREAD_JOIN_TQ_OPERATIONS,
@@ -127,8 +131,7 @@ static void _Thread_Wake_up_joining_threads( Thread_Control *the_thread )
 #else
     _Thread_queue_Flush_default_filter,
 #endif
-    NULL,
-    &join_lock_context.Base
+    &join_context.Base
   );
 }
 
diff --git a/testsuites/sptests/spintrcritical22/init.c b/testsuites/sptests/spintrcritical22/init.c
index b5044d9..3670d1a 100644
--- a/testsuites/sptests/spintrcritical22/init.c
+++ b/testsuites/sptests/spintrcritical22/init.c
@@ -33,12 +33,12 @@ static test_context ctx_instance;
 
 static Semaphore_Control *get_semaphore_control(rtems_id id)
 {
-  ISR_lock_Context lock_context;
+  Thread_queue_Context queue_context;
   Semaphore_Control *sem;
 
-  sem = _Semaphore_Get(id, &lock_context);
+  sem = _Semaphore_Get(id, &queue_context, NULL);
   rtems_test_assert(sem != NULL);
-  _ISR_lock_ISR_enable(&lock_context);
+  _ISR_lock_ISR_enable(&queue_context.Lock_context);
 
   return sem;
 }
diff --git a/testsuites/tmtests/tm26/task1.c b/testsuites/tmtests/tm26/task1.c
index da37eee..68cb246 100644
--- a/testsuites/tmtests/tm26/task1.c
+++ b/testsuites/tmtests/tm26/task1.c
@@ -477,9 +477,10 @@ rtems_task Floating_point_task_2(
 
 void complete_test( void )
 {
-  uint32_t         index;
-  rtems_id         task_id;
-  ISR_lock_Context lock_context;
+  uint32_t             index;
+  rtems_id             task_id;
+  ISR_lock_Context     lock_context;
+  Thread_queue_Context queue_context;
 
   benchmark_timer_initialize();
     thread_resume( Middle_tcb );
@@ -513,8 +514,8 @@ void complete_test( void )
 
   benchmark_timer_initialize();
     for ( index=1 ; index <= OPERATION_COUNT ; index++ ) {
-      (void) _Semaphore_Get( Semaphore_id, &lock_context );
-      _ISR_lock_ISR_enable( &lock_context );
+      (void) _Semaphore_Get( Semaphore_id, &queue_context, NULL );
+      _ISR_lock_ISR_enable( &queue_context.Lock_context );
     }
   semaphore_get_time = benchmark_timer_read();
 
-- 
1.8.4.5





More information about the devel mailing list