MsgWritev(), MsgWritev_r()

Write a reply


#include <sys/neutrino.h>

int MsgWritev( int rcvid,
               const iov_t* iov,
               int parts,
               int offset );

int MsgWritev_r( int rcvid,
                 const iov_t* iov,
                 int parts,
                 int offset );


The value returned by MsgReceive*() when you received the message.
An array of buffers that contains the data you want to write.
The number of elements in the array. These functions don't let you write past the end of the sender's buffer; they return the number of bytes actually written.
An offset into the sender's buffer that indicates where you want to start writing the data.



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


The MsgWritev() and MsgWritev_r() kernel calls write data to the reply buffer of a thread identified by rcvid. The thread being written to must be in the REPLY-blocked state. Any thread in the receiving process is free to write to the reply message.

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

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

You'll use this function in one of these situations:

  • The data arrives over time and is quite large. Rather than buffer all the data, you can use MsgWritev() to write it into the destination thread's reply message buffer, as it arrives.
  • Messages are received that are larger than available buffer space. Perhaps the process is an agent between two processes and simply filters the data and passes it on. You can use MsgRead*() to read messages in small pieces, and use MsgWritev() to write messages in small pieces.

To complete a message exchange, you must call MsgReply*(). The reply doesn't need to contain any data. If it does contain data, then the data is always written at offset zero in the destination thread's reply message buffer. This is a convenient way of writing the header once all of the information has been gathered.

A single call to MsgReply*() is always more efficient than calls to MsgWritev() followed by a call to MsgReply*().

Blocking states

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


The only difference between the MsgWritev() and MsgWritev_r() functions is the way they indicate errors:

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


A fault occurred in the sender's address space when a server tried to access the sender's return message buffer.
The thread indicated by rcvid doesn't exist or its connection was detached.
A fault occurred when the kernel tried to access the buffers provided.


QNX Neutrino

Cancellation point No
Interrupt handler No
Signal handler Yes
Thread Yes