POSIX message queues now include complete functionality including

blocking sends when the queue is full.  The SuperCore was enhanced
to support blocking on send.  The existing POSIX API was debugged
and numerous test cases were added to psxmsgq01 by Jennifer Averett.
SuperCore enhancements and resulting modifications to other APIs
were done by Joel.

There is one significant point of interpretation for the POSIX API.
What happens to threads already blocked on a message queue when the
mode of that same message queue is changed from blocking to non-blocking?
We decided to unblock all waiting tasks with an EAGAIN error just
as if a non-blocking version of the same operation had returned
unsatisfied.  This case is not discussed in the POSIX standard and
other implementations may have chosen differently.

4 files changed, 19 insertions, 19 deletions

diff --git a/cpukit/itron/src/cre_mbf.c b/cpukit/itron/src/cre_mbf.c
index ca139d53ae..0db738435e 100644
--- a/cpukit/itron/src/cre_mbf.c
+++ b/cpukit/itron/src/cre_mbf.c
@@ -25,7 +25,7 @@ ER cre_mbf(
   T_CMBF *pk_cmbf
 )
 {
-  CORE_message_queue_Attributes   the_message_queue_attributes;
+  CORE_message_queue_Attributes    the_msgq_attributes;
   ITRON_Message_buffer_Control    *the_message_buffer;
 
   /*
@@ -57,16 +57,14 @@ ER cre_mbf(
   }
 
   if ( pk_cmbf->mbfatr & TA_TPRI )
-    the_message_queue_attributes.discipline =
-        CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
+    the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_PRIORITY;
   else
-    the_message_queue_attributes.discipline =
-        CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
+    the_msgq_attributes.discipline = CORE_MESSAGE_QUEUE_DISCIPLINES_FIFO;
 
   _CORE_message_queue_Initialize(
     &the_message_buffer->message_queue,
     OBJECTS_ITRON_MESSAGE_BUFFERS,
-    &the_message_queue_attributes,
+    &the_msgq_attributes,
     pk_cmbf->bufsz / pk_cmbf->maxmsz,
     pk_cmbf->maxmsz,
     NULL                           /* Multiprocessing not supported */
diff --git a/cpukit/itron/src/snd_mbx.c b/cpukit/itron/src/snd_mbx.c
index f674583e7b..e02714465e 100644
--- a/cpukit/itron/src/snd_mbx.c
+++ b/cpukit/itron/src/snd_mbx.c
@@ -27,7 +27,6 @@ ER snd_msg(
 {
   register ITRON_Mailbox_Control *the_mailbox;
   Objects_Locations                location;
-  CORE_message_queue_Status        status = E_OK;
   unsigned32                       message_priority;
   void                            *message_contents;
 
@@ -47,17 +46,22 @@ ER snd_msg(
         message_priority = CORE_MESSAGE_QUEUE_SEND_REQUEST;
 
       message_contents = pk_msg;
-      status = _CORE_message_queue_Submit(
+      _CORE_message_queue_Submit(
         &the_mailbox->message_queue,
         &message_contents,
         sizeof(T_MSG *),
         the_mailbox->Object.id,
         NULL,          /* multiprocessing not supported */
-        message_priority
+        message_priority,
+        FALSE,     /* do not allow sender to block */
+        0          /* no timeout */
      );
      break;
   }
 
   _ITRON_return_errorno( 
-     _ITRON_Mailbox_Translate_core_message_queue_return_code(status) );
+     _ITRON_Mailbox_Translate_core_message_queue_return_code(
+          _Thread_Executing->Wait.return_code
+     )
+  );
 }
diff --git a/cpukit/itron/src/trcv_mbf.c b/cpukit/itron/src/trcv_mbf.c
index a63f2a6748..0b2b89e612 100644
--- a/cpukit/itron/src/trcv_mbf.c
+++ b/cpukit/itron/src/trcv_mbf.c
@@ -32,7 +32,6 @@ ER trcv_mbf(
   CORE_message_queue_Status       status;
   boolean                         wait;
   Watchdog_Interval               interval;
-  CORE_message_queue_Submit_types core_priority;
 
   interval = 0;
   if (tmout == TMO_POL) {
@@ -62,7 +61,6 @@ ER trcv_mbf(
           msg,
           p_msgsz,
           wait,
-          &core_priority,
           interval
       );
       _Thread_Enable_dispatch();
diff --git a/cpukit/itron/src/tsnd_mbf.c b/cpukit/itron/src/tsnd_mbf.c
index bc609dd298..0ed3b4f90e 100644
--- a/cpukit/itron/src/tsnd_mbf.c
+++ b/cpukit/itron/src/tsnd_mbf.c
@@ -33,7 +33,6 @@ ER tsnd_mbf(
   Objects_Locations              location;
   Watchdog_Interval              interval;
   boolean                        wait;
-  CORE_message_queue_Status      status;
 
   if (msgsz <= 0 || !msg)
     return E_PAR;
@@ -50,8 +49,6 @@ ER tsnd_mbf(
   if ( wait && _ITRON_Is_in_non_task_state() )
     return E_CTX;
 
-  assert( wait == FALSE );
-
   the_message_buffer = _ITRON_Message_buffer_Get(mbfid, &location);
   switch (location) {
     case OBJECTS_REMOTE:
@@ -60,17 +57,20 @@ ER tsnd_mbf(
 
     case OBJECTS_LOCAL:
       /* XXX Submit needs to take into account blocking */
-      status = _CORE_message_queue_Submit(
+      _CORE_message_queue_Submit(
         &the_message_buffer->message_queue,
         msg,
         msgsz,
         the_message_buffer->Object.id,
         NULL,
-        CORE_MESSAGE_QUEUE_SEND_REQUEST
+        CORE_MESSAGE_QUEUE_SEND_REQUEST,
+        wait,      /* sender may block */
+        interval   /* timeout interval */
       );
       _Thread_Enable_dispatch();
-      return
-        _ITRON_Message_buffer_Translate_core_message_buffer_return_code(status);
+      return _ITRON_Message_buffer_Translate_core_message_buffer_return_code(
+          _Thread_Executing->Wait.return_code
+      );
     }
 
     /*