Getting Started with QNX Neutrino - QNX Software Systems

Using message passing
© 2009, QNX Software Systems GmbH & Co. KG.
Multipart messages
Until now, we’ve shown only message transfers happening from one buffer in the
client’s address space into another buffer in the server’s address space. (And one
buffer in the server’s space into another buffer in the client’s space during the reply.)
While this approach is good enough for most applications, it can lead to inefficiencies.
Recall that our write() C library code took the buffer that you passed to it, and stuck a
small header on the front of it. Using what we’ve learned so far, you’d expect that the
C library would implement write() something like this (this isn’t the real source):
ssize_t write (int fd, const void *buf, size_t nbytes)
{
char *newbuf;
io_write_t *wptr;
int
nwritten;
}
newbuf = malloc (nbytes + sizeof (io_write_t));
// fill in the write_header at the beginning
wptr = (io_write_t *) newbuf;
wptr -> type = _IO_WRITE;
wptr -> nbytes = nbytes;
// store the actual data from the client
memcpy (newbuf + sizeof (io_write_t), buf, nbytes);
// send the message to the server
nwritten = MsgSend (fd,
newbuf,
nbytes + sizeof (io_write_t),
newbuf,
sizeof (io_write_t));
free (newbuf);
return (nwritten);
See what happened? A few bad things:
• The write() now has to be able to malloc() a buffer big enough for both the client
data (which can be fairly big) and the header. The size of the header isn’t the issue
— in this case, it was 12 bytes.
• We had to copy the data twice: once via the memcpy(), and then again during the
message transfer.
• We had to establish a pointer to the io_write_t type and point it to the beginning
of the buffer, rather than access it natively (this is a minor annoyance).
Since the kernel is going to copy the data anyway, it would be nice if we could tell it
that one part of the data (the header) is located at a certain address, and that the other
part (the data itself) is located somewhere else, without the need for us to manually
assemble the buffers and to copy the data.
As luck would have it, Neutrino implements a mechanism that lets us do just that! The
mechanism is something called an IOV, standing for “Input/Output Vector.”
Let’s look at some code first, then we’ll discuss what happens:
108 Chapter 2 • Message Passing April 30, 2009