MsgRead(), MsgRead_r()
Read data from a message
Synopsis:
#include <sys/neutrino.h>
ssize_t MsgRead( rcvid_t rcvid,
void* msg,
size_t bytes,
size_t offset );
ssize_t MsgRead_r( rcvid_t rcvid,
void* msg,
size_t bytes,
size_t offset );
Arguments:
- rcvid
- The value returned by MsgReceive*() when you received the message.
- msg
- A pointer to a buffer where the function can store the data.
- bytes
- The number of bytes that you want to read.
This number must not exceed SSIZE_MAX, or the function will behave unpredictably.
These functions don't let you read past the end of the thread's message; they return the number of bytes actually read.
- 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.
Description:
The MsgRead() and MsgRead_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. The state of the sending thread doesn't change. 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.
If the sending and calling threads are on the same node,
the data transfer occurs immediately and the calling thread doesn't block (see Blocking states,
below).
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 call MsgRead() one or more times to read data directly into the required buffer(s).
- 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 MsgRead() 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 MsgRead() to read the message in small pieces, and use MsgWrite*() to write the messages in small pieces.
When you're finished using MsgRead(), you must use MsgReply*() to ready the REPLY-blocked process and complete the message exchange.
Blocking states
None.
Returns:
The only difference between these functions is the way they indicate errors:
- MsgRead()
- If successful, this function returns the number of bytes read. If an error occurs, it returns -1 and sets errno.
- MsgRead_r()
- If succesful, this function returns the number of bytes read. If an error occurs, it may return the negative of any value from the Errors section. This function does NOT set errno, even on success.
The bytes copied will be the smaller of the data available on the client side (message size - offset) and the server side (bytes). If the offset is past the end of the client's buffer, this function will copy 0 bytes and return 0.
Errors:
- EDEADLK
- A deadlock occurred. You can avoid a deadlock by setting the _NTO_CHF_MSG_PAUSING flag when you create a channel; for more information, see ChannelCreate() and MsgPause().
- EFAULT
- A fault occurred when the kernel tried to access the buffers provided by the client.
- ESRCH
- The thread indicated by rcvid doesn't exist, is no longer REPLY-blocked on the channel, or the connection was detached.
- ESRVRFAULT
- A fault occurred in a server's address space when the kernel tried to access the server's message buffers.
Classification:
| Safety: | |
|---|---|
| Cancellation point | No |
| Signal handler | Yes |
| Thread | Yes |