rtems_status_code rtems_message_queue_broadcast(
rtems_id id,
const void *buffer,
size_t size,
uint32_t *count
)
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status core_status;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !count )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
core_status = _CORE_message_queue_Broadcast(
&the_message_queue->message_queue,
buffer,
size,
id,
#if defined(RTEMS_MULTIPROCESSING)
_Message_queue_Core_message_queue_mp_support,
#else
NULL,
#endif
count
);
_Thread_Enable_dispatch();
return
_Message_queue_Translate_core_message_queue_return_code( core_status );
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
_Thread_Executing->Wait.return_argument = count;
return
_Message_queue_MP_Send_request_packet(
MESSAGE_QUEUE_MP_BROADCAST_REQUEST,
id,
buffer,
&size,
0, /* option_set not used */
MPCI_DEFAULT_TIMEOUT
);
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
epos_status_code epos_message_queue_send(
epos_id id,
const void *buffer,
size_t size
)
{
register Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status status;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
status = _CORE_message_queue_Send(
&the_message_queue->message_queue,
buffer,
size,
id,
MESSAGE_QUEUE_MP_HANDLER,
false, /* sender does not block */
0 /* no timeout */
);
_Thread_Enable_dispatch();
/*
* Since this API does not allow for blocking sends, we can directly
* return the returned status.
*/
return _Message_queue_Translate_core_message_queue_return_code(status);
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
return _Message_queue_MP_Send_request_packet(
MESSAGE_QUEUE_MP_SEND_REQUEST,
id,
buffer,
&size,
0, /* option_set */
MPCI_DEFAULT_TIMEOUT
);
break;
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
static rtems_status_code rtems_message_queue_send_timeout(
rtems_id id,
void *buffer,
uint32_t size,
rtems_interval timeout)
{
Message_queue_Control *the_message_queue;
Objects_Locations location;
CORE_message_queue_Status msg_status;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location )
{
case OBJECTS_ERROR:
return RTEMS_INVALID_ID;
case OBJECTS_LOCAL:
msg_status = _CORE_message_queue_Send(
&the_message_queue->message_queue,
buffer,
size,
id,
NULL,
1,
timeout
);
_Thread_Enable_dispatch();
/*
* If we had to block, then this is where the task returns
* after it wakes up. The returned status is correct for
* non-blocking operations but if we blocked, then we need
* to look at the status in our TCB.
*/
if ( msg_status == CORE_MESSAGE_QUEUE_STATUS_UNSATISFIED_WAIT )
msg_status = _Thread_Executing->Wait.return_code;
return _Message_queue_Translate_core_message_queue_return_code( msg_status );
}
return RTEMS_INTERNAL_ERROR; /* unreached - only to remove warnings */
}
rtems_status_code rtems_message_queue_receive(
rtems_id id,
void *buffer,
size_t *size,
rtems_option option_set,
rtems_interval timeout
)
{
Message_queue_Control *the_message_queue;
Objects_Locations location;
bool wait;
Thread_Control *executing;
if ( !buffer )
return RTEMS_INVALID_ADDRESS;
if ( !size )
return RTEMS_INVALID_ADDRESS;
the_message_queue = _Message_queue_Get( id, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( _Options_Is_no_wait( option_set ) )
wait = false;
else
wait = true;
executing = _Thread_Executing;
_CORE_message_queue_Seize(
&the_message_queue->message_queue,
executing,
the_message_queue->Object.id,
buffer,
size,
wait,
timeout
);
_Objects_Put( &the_message_queue->Object );
return _Message_queue_Translate_core_message_queue_return_code(
executing->Wait.return_code
);
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
return _Message_queue_MP_Send_request_packet(
MESSAGE_QUEUE_MP_RECEIVE_REQUEST,
id,
buffer,
size,
option_set,
timeout
);
#endif
case OBJECTS_ERROR:
break;
}
return RTEMS_INVALID_ID;
}
