MsgReadv(), MsgReadv_r()

Read data from a message

Synopsis:

#include <sys/neutrino.h>

int MsgReadv( int rcvid,
              const iov_t* riov,
              int rparts,
              int offset );

int MsgReadv_r( int rcvid,
                const iov_t* riov,
                int rparts,
                int offset );

Arguments:

rcvid: The value returned by MsgReceive*() when you received the message.
riov: An array of buffers where the functions can store the data.
rparts: The number of elements in the riov array.
offset: An offset into the thread's send message that indicates where you want to start reading the data.

Library:

libc

Use the -l c option to qcc to link against this library. This library is usually included automatically.

The MsgReadv() and MsgReadv_r() kernel calls read data from a message sent by a thread identified by rcvid. The thread being read from must not have been replied to and will be in the REPLY-blocked state. Any thread in the receiving process is free to read the message.

These functions are identical except in the way they indicate errors. See the Returns section for details.

The data transfer occurs immediately and the thread doesn't block. The state of the sending thread doesn't change.

An attempt to read past the end of the thread's message results in fewer bytes returned than requested.

You'll use these functions in these situations:

A message is sent consisting of a fixed header and a variable amount of data. The header contains the byte count of the data. If the data is large and has to be inserted into one or more buffers (like a filesystem cache), rather than read the data into one large buffer and then copy it into several other buffers, MsgReceive() reads only the header, and you can build a custom iov_t list to let MsgReadv() read data directly into the required buffers.
A message is received but can't be handled at the present time. At some point in the future, an event will occur that will allow the message to be processed. Rather than saving the message until it can be processed (thus using memory resources), you can use MsgReadv() to reread the message, during which time the sending thread is still blocked.
Messages that are larger than available buffer space are received. Perhaps the process is an agent between two processes and simply filters the data and passes it on. You can use MsgReadv() to read the message in small pieces, and use MsgWrite*() to write the messages in small pieces.

When you're finished using MsgReadv(), you must use MsgReply*() to ready the REPLY-blocked process and complete the message exchange.

Blocking states

None. In the network case, lower priority threads may run.

Returns:

The only difference between the MsgReadv() and MsgReadv_r() functions is the way they indicate errors:

MsgReadv(): The number of bytes read. If an error occurs, -1 is returned and errno is set.
MsgReadv_r(): The number of bytes read. This function does NOT set errno. If an error occurs, the negative of a value from the Errors section is returned.

Errors:

EFAULT: A fault occurred in a server's address space when it tried to access the caller's message buffers.
ESRCH: The thread indicated by rcvid doesn't exist or has had its connection detached.
ESRVRFAULT: A fault occurred when the kernel tried to access the buffers provided.

Classification:

QNX Neutrino

Safety:
Cancellation point	No
Interrupt handler	No
Signal handler	Yes
Thread	Yes