Getting Started with QNX Neutrino - QNX Software Systems

© 2009, QNX Software Systems GmbH & Co. KG. Using message passing
#include
ssize_t write (int fd, const void *buf, size_t nbytes)
{
io_write_t whdr;
iov_t iov [2];
// set up the IOV to point to both parts:
SETIOV (iov + 0, &whdr, sizeof (whdr));
SETIOV (iov + 1, buf, nbytes);
// fill in the io_write_t at the beginning
whdr.type = _IO_WRITE;
whdr.nbytes = nbytes;
// send the message to the server
return (MsgSendv (coid, iov, 2, iov, 1));
}
First of all, notice there’s no malloc() and no memcpy(). Next, notice the use of the
iov_t type. This is a structure that contains an address and length pair, and we’ve
allocated two of them (named iov).
The iov_t type definition is automatically included by , and is
defined as:
typedef struct iovec
{
void *iov_base;
size_t iov_len;
} iov_t;
Given this structure, we fill the address and length pairs with the write header (for the
first part) and the data from the client (in the second part). There’s a convenience
macro called SETIOV() that does the assignments for us. It’s formally defined as:
#include
#define SETIOV(_iov, _addr, _len) \
((_iov)->iov_base = (void *)(_addr), \
(_iov)->iov_len = (_len))
SETIOV() accepts an iov_t, and the address and length data to be stuffed into the
IOV.
Also notice that since we’re creating an IOV to point to the header, we can allocate the
header on the stack without using malloc(). This can be a blessing and a curse — it’s a
blessing when the header is quite small, because you avoid the headaches of dynamic
memory allocation, but it can be a curse when the header is huge, because it can
consume a fair chunk of stack space. Generally, the headers are quite small.
In any event, the important work is done by MsgSendv(), which takes almost the same
arguments as the MsgSend() function that we used in the previous example:
#include
int MsgSendv (int coid,
const iov_t *siov,
int sparts,
const iov_t *riov,
int rparts);
April 30, 2009 Chapter 2 • Message Passing 109