ER trcv_msg(
T_MSG **ppk_msg,
ID mbxid,
TMO tmout
)
{
register ITRON_Mailbox_Control *the_mailbox;
Watchdog_Interval interval;
bool wait;
Objects_Locations location;
size_t size;
if (!ppk_msg)
return E_PAR;
interval = 0;
if ( tmout == TMO_POL ) {
wait = false;
} else {
wait = true;
if ( tmout != TMO_FEVR )
interval = TOD_MILLISECONDS_TO_TICKS(tmout);
}
if ( wait && _ITRON_Is_in_non_task_state() )
return E_CTX;
the_mailbox = _ITRON_Mailbox_Get( mbxid, &location );
switch ( location ) {
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
#endif
case OBJECTS_ERROR:
return _ITRON_Mailbox_Clarify_get_id_error( mbxid );
case OBJECTS_LOCAL:
_CORE_message_queue_Seize(
&the_mailbox->message_queue,
the_mailbox->Object.id,
ppk_msg,
&size,
wait,
interval
);
break;
}
_ITRON_return_errorno(
_ITRON_Mailbox_Translate_core_message_queue_return_code(
_Thread_Executing->Wait.return_code ) );
}
ssize_t _POSIX_Message_queue_Receive_support(
mqd_t mqdes,
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
POSIX_Message_queue_Control *the_mq;
POSIX_Message_queue_Control_fd *the_mq_fd;
Objects_Locations location;
size_t length_out;
bool do_wait;
the_mq_fd = _POSIX_Message_queue_Get_fd( mqdes, &location );
switch ( location ) {
case OBJECTS_LOCAL:
if ( (the_mq_fd->oflag & O_ACCMODE) == O_WRONLY ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EBADF );
}
the_mq = the_mq_fd->Queue;
if ( msg_len < the_mq->Message_queue.maximum_message_size ) {
_Thread_Enable_dispatch();
rtems_set_errno_and_return_minus_one( EMSGSIZE );
}
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait )
do_wait = (the_mq_fd->oflag & O_NONBLOCK) ? false : true;
else
do_wait = wait;
/*
* Now perform the actual message receive
*/
_CORE_message_queue_Seize(
&the_mq->Message_queue,
mqdes,
msg_ptr,
&length_out,
do_wait,
timeout
);
_Thread_Enable_dispatch();
if (msg_prio) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
_Thread_Executing->Wait.count
);
}
if ( !_Thread_Executing->Wait.return_code )
return length_out;
rtems_set_errno_and_return_minus_one(
_POSIX_Message_queue_Translate_core_message_queue_return_code(
_Thread_Executing->Wait.return_code
)
);
#if defined(RTEMS_MULTIPROCESSING)
case OBJECTS_REMOTE:
#endif
case OBJECTS_ERROR:
break;
}
rtems_set_errno_and_return_minus_one( EBADF );
}
ssize_t _POSIX_Message_queue_Receive_support(
mqd_t mqdes,
char *msg_ptr,
size_t msg_len,
unsigned int *msg_prio,
bool wait,
Watchdog_Interval timeout
)
{
POSIX_Message_queue_Control *the_mq;
Thread_queue_Context queue_context;
size_t length_out;
bool do_wait;
Thread_Control *executing;
Status_Control status;
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( &queue_context.Lock_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( &queue_context.Lock_context.Lock_context );
rtems_set_errno_and_return_minus_one( EMSGSIZE );
}
/*
* Now if something goes wrong, we return a "length" of -1
* to indicate an error.
*/
length_out = -1;
/*
* A timed receive with a bad time will do a poll regardless.
*/
if ( wait ) {
do_wait = ( the_mq->oflag & O_NONBLOCK ) == 0;
} else {
do_wait = wait;
}
_CORE_message_queue_Acquire_critical(
&the_mq->Message_queue,
&queue_context
);
if ( the_mq->open_count == 0 ) {
_CORE_message_queue_Release( &the_mq->Message_queue, &queue_context );
rtems_set_errno_and_return_minus_one( EBADF );
}
/*
* Now perform the actual message receive
*/
executing = _Thread_Executing;
_Thread_queue_Context_set_relative_timeout( &queue_context, timeout );
status = _CORE_message_queue_Seize(
&the_mq->Message_queue,
executing,
msg_ptr,
&length_out,
do_wait,
&queue_context
);
if ( msg_prio != NULL ) {
*msg_prio = _POSIX_Message_queue_Priority_from_core(
executing->Wait.count
);
}
if ( status != STATUS_SUCCESSFUL ) {
rtems_set_errno_and_return_minus_one( _POSIX_Get_error( status ) );
}
return length_out;
}
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;
}
