Index: cpukit/posix/include/rtems/posix/mqueueimpl.h
===================================================================
--- cpukit/posix/include/rtems/posix/mqueueimpl.h	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/posix/include/rtems/posix/mqueueimpl.h	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -251,4 +251,19 @@
   );
 }
+
+RTEMS_INLINE_ROUTINE POSIX_Message_queue_Control_fd *
+_POSIX_Message_queue_Get_fd_interrupt_disable(
+  mqd_t              id,
+  Objects_Locations *location,
+  ISR_lock_Context  *lock_context
+)
+{
+  return (POSIX_Message_queue_Control_fd *) _Objects_Get_isr_disable(
+    &_POSIX_Message_queue_Information_fds,
+    (Objects_Id)id,
+    location,
+    lock_context
+  );
+}
  
 /**
Index: cpukit/posix/src/mqueuerecvsupp.c
===================================================================
--- cpukit/posix/src/mqueuerecvsupp.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/posix/src/mqueuerecvsupp.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -55,11 +55,16 @@
   bool                             do_wait;
   Thread_Control                  *executing;
+  ISR_lock_Context                 lock_context;
 
-  the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
+  the_mq_fd = _POSIX_Message_queue_Get_fd_interrupt_disable(
+    mqdes,
+    &location,
+    &lock_context
+  );
   switch ( location ) {
 
     case OBJECTS_LOCAL:
       if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
-        _Objects_Put( &the_mq_fd->Object );
+        _ISR_lock_ISR_enable( &lock_context );
         rtems_set_errno_and_return_minus_one( EBADF );
       }
@@ -68,5 +73,5 @@
 
       if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
-        _Objects_Put( &the_mq_fd->Object );
+        _ISR_lock_ISR_enable( &lock_context );
         rtems_set_errno_and_return_minus_one( EMSGSIZE );
       }
@@ -98,8 +103,8 @@
         &length_out,
         do_wait,
-        timeout
+        timeout,
+        &lock_context
       );
 
-      _Objects_Put( &the_mq_fd->Object );
       if (msg_prio) {
         *msg_prio = _POSIX_Message_queue_Priority_from_core(
Index: cpukit/posix/src/mqueuesendsupp.c
===================================================================
--- cpukit/posix/src/mqueuesendsupp.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/posix/src/mqueuesendsupp.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -65,4 +65,5 @@
   bool                            do_wait;
   Thread_Control                 *executing;
+  ISR_lock_Context                lock_context;
 
   /*
@@ -74,10 +75,14 @@
     rtems_set_errno_and_return_minus_one( EINVAL );
 
-  the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
+  the_mq_fd = _POSIX_Message_queue_Get_fd_interrupt_disable(
+    mqdes,
+    &location,
+    &lock_context
+  );
   switch ( location ) {
 
     case OBJECTS_LOCAL:
       if ( (the_mq_fd->oflag & O_ACCMODE) == O_RDONLY ) {
-        _Objects_Put( &the_mq_fd->Object );
+        _ISR_lock_ISR_enable( &lock_context );
         rtems_set_errno_and_return_minus_one( EBADF );
       }
@@ -106,8 +111,7 @@
         _POSIX_Message_queue_Priority_to_core( msg_prio ),
         do_wait,
-        timeout    /* no timeout */
+        timeout,   /* no timeout */
+        &lock_context
       );
-
-      _Objects_Put( &the_mq_fd->Object );
 
       /*
Index: cpukit/rtems/include/rtems/rtems/messageimpl.h
===================================================================
--- cpukit/rtems/include/rtems/rtems/messageimpl.h	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/rtems/include/rtems/rtems/messageimpl.h	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -140,4 +140,19 @@
 }
 
+RTEMS_INLINE_ROUTINE Message_queue_Control *
+_Message_queue_Get_interrupt_disable(
+  Objects_Id         id,
+  Objects_Locations *location,
+  ISR_lock_Context  *lock_context
+)
+{
+  return (Message_queue_Control *) _Objects_Get_isr_disable(
+    &_Message_queue_Information,
+    id,
+    location,
+    lock_context
+  );
+}
+
 RTEMS_INLINE_ROUTINE Message_queue_Control *_Message_queue_Allocate( void )
 {
Index: cpukit/rtems/src/msgqbroadcast.c
===================================================================
--- cpukit/rtems/src/msgqbroadcast.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/rtems/src/msgqbroadcast.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -41,4 +41,5 @@
   Objects_Locations               location;
   CORE_message_queue_Status       core_status;
+  ISR_lock_Context                lock_context;
 
   if ( !buffer )
@@ -48,5 +49,9 @@
     return RTEMS_INVALID_ADDRESS;
 
-  the_message_queue = _Message_queue_Get( id, &location );
+  the_message_queue = _Message_queue_Get_interrupt_disable(
+    id,
+    &location,
+    &lock_context
+  );
   switch ( location ) {
 
@@ -62,8 +67,7 @@
                         NULL,
                       #endif
-                      count
+                      count,
+                      &lock_context
                     );
-
-      _Objects_Put( &the_message_queue->Object );
       return
         _Message_queue_Translate_core_message_queue_return_code( core_status );
Index: cpukit/rtems/src/msgqflush.c
===================================================================
--- cpukit/rtems/src/msgqflush.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/rtems/src/msgqflush.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -55,14 +55,21 @@
   Message_queue_Control          *the_message_queue;
   Objects_Locations               location;
+  ISR_lock_Context                lock_context;
 
   if ( !count )
     return RTEMS_INVALID_ADDRESS;
 
-  the_message_queue = _Message_queue_Get( id, &location );
+  the_message_queue = _Message_queue_Get_interrupt_disable(
+    id,
+    &location,
+    &lock_context
+  );
   switch ( location ) {
 
     case OBJECTS_LOCAL:
-      *count = _CORE_message_queue_Flush( &the_message_queue->message_queue );
-      _Objects_Put( &the_message_queue->Object );
+      *count = _CORE_message_queue_Flush(
+        &the_message_queue->message_queue,
+        &lock_context
+      );
       return RTEMS_SUCCESSFUL;
 
Index: cpukit/rtems/src/msgqreceive.c
===================================================================
--- cpukit/rtems/src/msgqreceive.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/rtems/src/msgqreceive.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -43,4 +43,5 @@
   bool                            wait;
   Thread_Control                 *executing;
+  ISR_lock_Context                lock_context;
 
   if ( !buffer )
@@ -50,5 +51,9 @@
     return RTEMS_INVALID_ADDRESS;
 
-  the_message_queue = _Message_queue_Get( id, &location );
+  the_message_queue = _Message_queue_Get_interrupt_disable(
+    id,
+    &location,
+    &lock_context
+  );
   switch ( location ) {
 
@@ -67,7 +72,7 @@
         size,
         wait,
-        timeout
+        timeout,
+        &lock_context
       );
-      _Objects_Put( &the_message_queue->Object );
       return _Message_queue_Translate_core_message_queue_return_code(
         executing->Wait.return_code
Index: cpukit/rtems/src/msgqsend.c
===================================================================
--- cpukit/rtems/src/msgqsend.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/rtems/src/msgqsend.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -63,9 +63,14 @@
   Objects_Locations                location;
   CORE_message_queue_Status        status;
+  ISR_lock_Context                 lock_context;
 
   if ( !buffer )
     return RTEMS_INVALID_ADDRESS;
 
-  the_message_queue = _Message_queue_Get( id, &location );
+  the_message_queue = _Message_queue_Get_interrupt_disable(
+    id,
+    &location,
+    &lock_context
+  );
   switch ( location ) {
 
@@ -78,8 +83,7 @@
         MESSAGE_QUEUE_MP_HANDLER,
         false,   /* sender does not block */
-        0        /* no timeout */
+        0,       /* no timeout */
+        &lock_context
       );
-
-      _Objects_Put( &the_message_queue->Object );
 
       /*
Index: cpukit/rtems/src/msgqurgent.c
===================================================================
--- cpukit/rtems/src/msgqurgent.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/rtems/src/msgqurgent.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -46,9 +46,14 @@
   Objects_Locations                location;
   CORE_message_queue_Status        status;
+  ISR_lock_Context                 lock_context;
 
   if ( !buffer )
     return RTEMS_INVALID_ADDRESS;
 
-  the_message_queue = _Message_queue_Get( id, &location );
+  the_message_queue = _Message_queue_Get_interrupt_disable(
+    id,
+    &location,
+    &lock_context
+  );
   switch ( location ) {
 
@@ -61,7 +66,7 @@
         MESSAGE_QUEUE_MP_HANDLER,
         false,   /* sender does not block */
-        0        /* no timeout */
+        0,       /* no timeout */
+        &lock_context
       );
-      _Objects_Put( &the_message_queue->Object );
 
       /*
Index: cpukit/score/include/rtems/score/coremsgimpl.h
===================================================================
--- cpukit/score/include/rtems/score/coremsgimpl.h	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/score/include/rtems/score/coremsgimpl.h	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -22,4 +22,5 @@
 #include <rtems/score/coremsg.h>
 #include <rtems/score/chainimpl.h>
+#include <rtems/score/threaddispatch.h>
 #include <rtems/score/threadqimpl.h>
 
@@ -173,9 +174,11 @@
  *
  *  @param[in] the_message_queue points to the message queue to flush
+ *  @param[in] lock_context The lock context of the interrupt disable.
  *
  *  @retval This method returns the number of message pending messages flushed.
  */
 uint32_t   _CORE_message_queue_Flush(
-  CORE_message_queue_Control *the_message_queue
+  CORE_message_queue_Control *the_message_queue,
+  ISR_lock_Context           *lock_context
 );
 
@@ -216,4 +219,5 @@
  *  @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.
  *  @retval @a *count will contain the number of messages sent
  *  @retval indication of the successful completion or reason for failure
@@ -225,5 +229,6 @@
   Objects_Id                                 id,
   CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support,
-  uint32_t                                  *count
+  uint32_t                                  *count,
+  ISR_lock_Context                          *lock_context
 );
 
@@ -251,4 +256,5 @@
  *  @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.
  *  @retval indication of the successful completion or reason for failure
  */
@@ -262,5 +268,6 @@
   CORE_message_queue_Submit_types            submit_type,
   bool                                       wait,
-  Watchdog_Interval                          timeout
+  Watchdog_Interval                          timeout,
+  ISR_lock_Context                          *lock_context
 );
 
@@ -288,4 +295,5 @@
  *  @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.
  *
  *  @retval indication of the successful completion or reason for failure.
@@ -306,5 +314,6 @@
   size_t                          *size_p,
   bool                             wait,
-  Watchdog_Interval                timeout
+  Watchdog_Interval                timeout,
+  ISR_lock_Context                *lock_context
 );
 
@@ -339,6 +348,7 @@
   Objects_Id                                 id,
   CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support,
-  bool                                    wait,
-  Watchdog_Interval                          timeout
+  bool                                       wait,
+  Watchdog_Interval                          timeout,
+  ISR_lock_Context                          *lock_context
 )
 {
@@ -352,5 +362,6 @@
     CORE_MESSAGE_QUEUE_SEND_REQUEST,
     wait,     /* sender may block */
-    timeout   /* timeout interval */
+    timeout,  /* timeout interval */
+    lock_context
   );
 }
@@ -365,6 +376,7 @@
   Objects_Id                                 id,
   CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support,
-  bool                                    wait,
-  Watchdog_Interval                          timeout
+  bool                                       wait,
+  Watchdog_Interval                          timeout,
+  ISR_lock_Context                          *lock_context
 )
 {
@@ -378,6 +390,42 @@
     CORE_MESSAGE_QUEUE_URGENT_REQUEST,
     wait,     /* sender may block */
-    timeout   /* timeout interval */
+    timeout,  /* timeout interval */
+    lock_context
  );
+}
+
+RTEMS_INLINE_ROUTINE void _CORE_message_queue_Acquire(
+  CORE_message_queue_Control *the_message_queue,
+  ISR_lock_Context           *lock_context
+)
+{
+  _Thread_queue_Acquire( &the_message_queue->Wait_queue, 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_Acquire_critical( &the_message_queue->Wait_queue, lock_context );
+
+  #if defined(RTEMS_MULTIPROCESSING)
+    /*
+     * In case RTEMS_MULTIPROCESSING is enabled, then we have to prevent
+     * deletion of the executing thread after the thread queue operations.
+     */
+    _Thread_Dispatch_disable();
+  #endif
+}
+
+RTEMS_INLINE_ROUTINE void _CORE_message_queue_Release(
+  CORE_message_queue_Control *the_message_queue,
+  ISR_lock_Context           *lock_context
+)
+{
+  _Thread_queue_Release( &the_message_queue->Wait_queue, lock_context );
+  #if defined(RTEMS_MULTIPROCESSING)
+    _Thread_Dispatch_enable( _Per_CPU_Get() );
+  #endif
 }
 
@@ -405,5 +453,5 @@
 {
    return (CORE_message_queue_Buffer_control *)
-     _Chain_Get( &the_message_queue->Inactive_messages );
+     _Chain_Get_unprotected( &the_message_queue->Inactive_messages );
 }
 
@@ -417,5 +465,5 @@
 )
 {
-  _Chain_Append( &the_message_queue->Inactive_messages, &the_message->Node );
+  _Chain_Append_unprotected( &the_message_queue->Inactive_messages, &the_message->Node );
 }
 
@@ -511,4 +559,53 @@
 #endif
 
+RTEMS_INLINE_ROUTINE Thread_Control *_CORE_message_queue_Dequeue_receiver(
+  CORE_message_queue_Control      *the_message_queue,
+  const void                      *buffer,
+  size_t                           size,
+  CORE_message_queue_Submit_types  submit_type,
+  ISR_lock_Context                *lock_context
+)
+{
+  Thread_Control *the_thread;
+
+  /*
+   *  If there are pending messages, then there can't be threads
+   *  waiting for us to send them a message.
+   *
+   *  NOTE: This check is critical because threads can block on
+   *        send and receive and this ensures that we are broadcasting
+   *        the message to threads waiting to receive -- not to send.
+   */
+  if ( the_message_queue->number_of_pending_messages != 0 ) {
+    return NULL;
+  }
+
+  /*
+   *  There must be no pending messages if there is a thread waiting to
+   *  receive a message.
+   */
+  the_thread = _Thread_queue_First_locked( &the_message_queue->Wait_queue );
+  if ( the_thread == NULL ) {
+    return NULL;
+  }
+
+   *(size_t *) the_thread->Wait.return_argument = size;
+   the_thread->Wait.count = (uint32_t) submit_type;
+
+  _CORE_message_queue_Copy_buffer(
+    buffer,
+    the_thread->Wait.return_argument_second.mutable_object,
+    size
+  );
+
+  _Thread_queue_Extract_critical(
+    &the_message_queue->Wait_queue,
+    the_thread,
+    lock_context
+  );
+
+  return the_thread;
+}
+
 /** @} */
 
Index: cpukit/score/src/coremsgbroadcast.c
===================================================================
--- cpukit/score/src/coremsgbroadcast.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/score/src/coremsgbroadcast.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -21,5 +21,4 @@
 #include <rtems/score/coremsgimpl.h>
 #include <rtems/score/objectimpl.h>
-#include <rtems/score/thread.h>
 
 CORE_message_queue_Status _CORE_message_queue_Broadcast(
@@ -34,53 +33,43 @@
     CORE_message_queue_API_mp_support_callout  api_message_queue_mp_support __attribute__((unused)),
   #endif
-  uint32_t                                  *count
+  uint32_t                                  *count,
+  ISR_lock_Context                          *lock_context
 )
 {
-  Thread_Control          *the_thread;
-  uint32_t                 number_broadcasted;
-  Thread_Wait_information *waitp;
+  Thread_Control             *the_thread;
+  uint32_t                    number_broadcasted;
 
   if ( size > the_message_queue->maximum_message_size ) {
+    _ISR_lock_ISR_enable( lock_context );
     return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
   }
 
-  /*
-   *  If there are pending messages, then there can't be threads
-   *  waiting for us to send them a message.
-   *
-   *  NOTE: This check is critical because threads can block on
-   *        send and receive and this ensures that we are broadcasting
-   *        the message to threads waiting to receive -- not to send.
-   */
+  number_broadcasted = 0;
 
-  if ( the_message_queue->number_of_pending_messages != 0 ) {
-    *count = 0;
-    return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
+  _CORE_message_queue_Acquire_critical( the_message_queue, lock_context );
+
+  while (
+    ( the_thread =
+      _CORE_message_queue_Dequeue_receiver(
+        the_message_queue,
+        buffer,
+        size,
+        0,
+        lock_context
+      )
+    )
+  ) {
+    number_broadcasted += 1;
+
+#if defined(RTEMS_MULTIPROCESSING)
+    if ( !_Objects_Is_local_id( the_thread->Object.id ) )
+      (*api_message_queue_mp_support) ( the_thread, id );
+#endif
+
+    _CORE_message_queue_Acquire( the_message_queue, lock_context );
   }
 
-  /*
-   *  There must be no pending messages if there is a thread waiting to
-   *  receive a message.
-   */
-  number_broadcasted = 0;
-  while ((the_thread =
-          _Thread_queue_Dequeue(&the_message_queue->Wait_queue))) {
-    waitp = &the_thread->Wait;
-    number_broadcasted += 1;
+  _CORE_message_queue_Release( the_message_queue, lock_context );
 
-    _CORE_message_queue_Copy_buffer(
-      buffer,
-      waitp->return_argument_second.mutable_object,
-      size
-    );
-
-    *(size_t *) the_thread->Wait.return_argument = size;
-
-    #if defined(RTEMS_MULTIPROCESSING)
-      if ( !_Objects_Is_local_id( the_thread->Object.id ) )
-        (*api_message_queue_mp_support) ( the_thread, id );
-    #endif
-
-  }
   *count = number_broadcasted;
   return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
Index: cpukit/score/src/coremsgclose.c
===================================================================
--- cpukit/score/src/coremsgclose.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/score/src/coremsgclose.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -19,9 +19,5 @@
 #endif
 
-#include <rtems/system.h>
-#include <rtems/score/chain.h>
-#include <rtems/score/isr.h>
 #include <rtems/score/coremsgimpl.h>
-#include <rtems/score/thread.h>
 #include <rtems/score/wkspace.h>
 
@@ -32,4 +28,5 @@
 )
 {
+  ISR_lock_Context lock_context;
 
   /*
@@ -50,5 +47,6 @@
    */
 
-  (void) _CORE_message_queue_Flush( the_message_queue );
+  _ISR_lock_ISR_disable( &lock_context );
+  (void) _CORE_message_queue_Flush( the_message_queue, &lock_context );
 
   (void) _Workspace_Free( the_message_queue->message_buffers );
Index: cpukit/score/src/coremsgflush.c
===================================================================
--- cpukit/score/src/coremsgflush.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/score/src/coremsgflush.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -21,11 +21,10 @@
 
 #include <rtems/score/coremsgimpl.h>
-#include <rtems/score/isr.h>
 
 uint32_t   _CORE_message_queue_Flush(
-  CORE_message_queue_Control *the_message_queue
+  CORE_message_queue_Control *the_message_queue,
+  ISR_lock_Context           *lock_context
 )
 {
-  ISR_Level   level;
   Chain_Node *inactive_head;
   Chain_Node *inactive_first;
@@ -61,5 +60,5 @@
    */
 
-  _ISR_Disable( level );
+  _CORE_message_queue_Acquire_critical( the_message_queue, lock_context );
 
   count = the_message_queue->number_of_pending_messages;
@@ -80,5 +79,5 @@
   }
 
-  _ISR_Enable( level );
+  _CORE_message_queue_Release( the_message_queue, lock_context );
   return count;
 }
Index: cpukit/score/src/coremsginsert.c
===================================================================
--- cpukit/score/src/coremsginsert.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/score/src/coremsginsert.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -20,5 +20,4 @@
 
 #include <rtems/score/coremsgimpl.h>
-#include <rtems/score/isrlevel.h>
 
 #if defined(RTEMS_SCORE_COREMSG_ENABLE_MESSAGE_PRIORITY)
@@ -46,5 +45,4 @@
 {
   Chain_Control *pending_messages;
-  ISR_Level      level;
 #if defined(RTEMS_SCORE_COREMSG_ENABLE_NOTIFICATION)
   bool           notify;
@@ -53,6 +51,4 @@
   _CORE_message_queue_Set_message_priority( the_message, submit_type );
   pending_messages = &the_message_queue->Pending_messages;
-
-  _ISR_Disable( level );
 
 #if defined(RTEMS_SCORE_COREMSG_ENABLE_NOTIFICATION)
@@ -75,6 +71,4 @@
   }
 
-  _ISR_Enable( level );
-
   #if defined(RTEMS_SCORE_COREMSG_ENABLE_NOTIFICATION)
     /*
Index: cpukit/score/src/coremsgseize.c
===================================================================
--- cpukit/score/src/coremsgseize.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/score/src/coremsgseize.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -34,16 +34,15 @@
   size_t                          *size_p,
   bool                             wait,
-  Watchdog_Interval                timeout
+  Watchdog_Interval                timeout,
+  ISR_lock_Context                *lock_context
 )
 {
-  ISR_lock_Context                   lock_context;
   CORE_message_queue_Buffer_control *the_message;
 
   executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
-  _Thread_queue_Acquire( &the_message_queue->Wait_queue, &lock_context );
+  _CORE_message_queue_Acquire_critical( the_message_queue, lock_context );
   the_message = _CORE_message_queue_Get_pending_message( the_message_queue );
   if ( the_message != NULL ) {
     the_message_queue->number_of_pending_messages -= 1;
-    _Thread_queue_Release( &the_message_queue->Wait_queue, &lock_context );
 
     *size_p = the_message->Contents.size;
@@ -62,4 +61,5 @@
        */
       _CORE_message_queue_Free_message_buffer(the_message_queue, the_message);
+      _CORE_message_queue_Release( the_message_queue, lock_context );
       return;
     #else
@@ -74,10 +74,13 @@
        *  then we can avoid this dequeue.
        */
-      the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
-      if ( !the_thread ) {
+      the_thread = _Thread_queue_First_locked(
+        &the_message_queue->Wait_queue
+      );
+      if ( the_thread == NULL ) {
         _CORE_message_queue_Free_message_buffer(
           the_message_queue,
           the_message
         );
+        _CORE_message_queue_Release( the_message_queue, lock_context );
         return;
       }
@@ -104,4 +107,12 @@
          _CORE_message_queue_Get_message_priority( the_message )
       );
+      _Thread_queue_Extract_critical(
+        &the_message_queue->Wait_queue,
+        the_thread,
+        lock_context
+      );
+      #if defined(RTEMS_MULTIPROCESSING)
+        _Thread_Dispatch_enable( _Per_CPU_Get() );
+      #endif
       return;
     }
@@ -110,5 +121,5 @@
 
   if ( !wait ) {
-    _Thread_queue_Release( &the_message_queue->Wait_queue, &lock_context );
+    _CORE_message_queue_Release( the_message_queue, lock_context );
     executing->Wait.return_code = CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_NOWAIT;
     return;
@@ -126,5 +137,8 @@
     timeout,
     CORE_MESSAGE_QUEUE_STATUS_TIMEOUT,
-    &lock_context
+    lock_context
   );
+  #if defined(RTEMS_MULTIPROCESSING)
+    _Thread_Dispatch_enable( _Per_CPU_Get() );
+  #endif
 }
Index: cpukit/score/src/coremsgsubmit.c
===================================================================
--- cpukit/score/src/coremsgsubmit.c	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ cpukit/score/src/coremsgsubmit.c	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -39,34 +39,37 @@
   CORE_message_queue_Submit_types            submit_type,
   bool                                       wait,
-  Watchdog_Interval                          timeout
+  Watchdog_Interval                          timeout,
+  ISR_lock_Context                          *lock_context
 )
 {
-  CORE_message_queue_Buffer_control   *the_message;
-  Thread_Control                      *the_thread;
+  CORE_message_queue_Buffer_control *the_message;
+  Thread_Control                    *the_thread;
 
   if ( size > the_message_queue->maximum_message_size ) {
+    _ISR_lock_ISR_enable( lock_context );
     return CORE_MESSAGE_QUEUE_STATUS_INVALID_SIZE;
   }
+
+  _CORE_message_queue_Acquire_critical( the_message_queue, lock_context );
 
   /*
    *  Is there a thread currently waiting on this message queue?
    */
-  if ( the_message_queue->number_of_pending_messages == 0 ) {
-    the_thread = _Thread_queue_Dequeue( &the_message_queue->Wait_queue );
-    if ( the_thread ) {
-      _CORE_message_queue_Copy_buffer(
-        buffer,
-        the_thread->Wait.return_argument_second.mutable_object,
-        size
-      );
-      *(size_t *) the_thread->Wait.return_argument = size;
-      the_thread->Wait.count = (uint32_t) submit_type;
 
-      #if defined(RTEMS_MULTIPROCESSING)
-        if ( !_Objects_Is_local_id( the_thread->Object.id ) )
-          (*api_message_queue_mp_support) ( the_thread, id );
-      #endif
-      return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
-    }
+  the_thread = _CORE_message_queue_Dequeue_receiver(
+    the_message_queue,
+    buffer,
+    size,
+    submit_type,
+    lock_context
+  );
+  if ( the_thread != NULL ) {
+    #if defined(RTEMS_MULTIPROCESSING)
+      if ( !_Objects_Is_local_id( the_thread->Object.id ) )
+        (*api_message_queue_mp_support) ( the_thread, id );
+
+      _Thread_Dispatch_enable( _Per_CPU_Get() );
+    #endif
+    return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
   }
 
@@ -78,4 +81,6 @@
       _CORE_message_queue_Allocate_message_buffer( the_message_queue );
   if ( the_message ) {
+    the_message->Contents.size = size;
+    _CORE_message_queue_Set_message_priority( the_message, submit_type );
     _CORE_message_queue_Copy_buffer(
       buffer,
@@ -83,6 +88,4 @@
       size
     );
-    the_message->Contents.size = size;
-    _CORE_message_queue_Set_message_priority( the_message, submit_type );
 
     _CORE_message_queue_Insert_message(
@@ -91,8 +94,10 @@
        submit_type
     );
+    _CORE_message_queue_Release( the_message_queue, lock_context );
     return CORE_MESSAGE_QUEUE_STATUS_SUCCESSFUL;
   }
 
   #if !defined(RTEMS_SCORE_COREMSG_ENABLE_BLOCKING_SEND)
+    _CORE_message_queue_Release( the_message_queue, lock_context );
     return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
   #else
@@ -103,4 +108,5 @@
      */
     if ( !wait ) {
+      _CORE_message_queue_Release( the_message_queue, lock_context );
       return CORE_MESSAGE_QUEUE_STATUS_TOO_MANY;
     }
@@ -111,4 +117,5 @@
      */
     if ( _ISR_Is_in_progress() ) {
+      _CORE_message_queue_Release( the_message_queue, lock_context );
       return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED;
     }
@@ -120,18 +127,20 @@
      *  would be to use this variable prior to here.
      */
-    {
-      executing->Wait.id = id;
-      executing->Wait.return_argument_second.immutable_object = buffer;
-      executing->Wait.option = (uint32_t) size;
-      executing->Wait.count = submit_type;
+    executing->Wait.id = id;
+    executing->Wait.return_argument_second.immutable_object = buffer;
+    executing->Wait.option = (uint32_t) size;
+    executing->Wait.count = submit_type;
 
-      _Thread_queue_Enqueue(
-        &the_message_queue->Wait_queue,
-        executing,
-        STATES_WAITING_FOR_MESSAGE,
-        timeout,
-        CORE_MESSAGE_QUEUE_STATUS_TIMEOUT
-      );
-    }
+    _Thread_queue_Enqueue_critical(
+      &the_message_queue->Wait_queue,
+      executing,
+      STATES_WAITING_FOR_MESSAGE,
+      timeout,
+      CORE_MESSAGE_QUEUE_STATUS_TIMEOUT,
+      lock_context
+    );
+    #if defined(RTEMS_MULTIPROCESSING)
+      _Thread_Dispatch_enable( _Per_CPU_Get() );
+    #endif
 
     return CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT;
Index: doc/user/msg.t
===================================================================
--- doc/user/msg.t	(revision c654b52517c2d255aa98eed347edeba60dc854d0)
+++ doc/user/msg.t	(revision cc18d7bec7b3c5515cb9e6cd9771d4b94309b3bd)
@@ -51,5 +51,8 @@
 
 The maximum length message which can be sent is set
-on a per message queue basis.
+on a per message queue basis.  The message content must be copied in general
+to/from an internal buffer of the message queue or directly to a peer in
+certain cases.  This copy operation is performed with interrupts disabled.  So
+it is advisable to keep the messages as short as possible.
 
 @subsection Building a Message Queue Attribute Set
