Getting Started with QNX Neutrino - QNX Software Systems

Using message passing
© 2009, QNX Software Systems GmbH & Co. KG.
Reading and writing data
Messages are always delivered in priority order.
If two processes send a message “simultaneously,” the entire message from the
higher-priority process is delivered to the server first.
If both processes are at the same priority, then the messages will be delivered in time
order (since there’s no such thing as absolutely simultaneous on a single-processor
machine — even on an SMP box there will be some ordering as the CPUs arbitrate
kernel access among themselves).
We’ll come back to some of the other subtleties introduced by this question when we
look at priority inversions later in this chapter.
So far you’ve seen the basic message-passing primitives. As I mentioned earlier, these
are all that you need. However, there are a few extra functions that make life much
easier.
Let’s consider an example using a client and server where we might need other
functions.
The client issues a MsgSend() to transfer some data to the server. After the client
issues the MsgSend() it blocks; it’s now waiting for the server to reply.
An interesting thing happens on the server side. The server has called MsgReceive() to
receive the message from the client. Depending on the design that you choose for your
messages, the server may or may not know how big the client’s message is. Why on
earth would the server not know how big the message is? Consider the filesystem
example that we’ve been using. Suppose the client does:
write (fd, buf, 16);
This works as expected if the server does a MsgReceive() and specifies a buffer size of,
say, 1024 bytes. Since our client sent only a tiny message (28 bytes), we have no
problems.
However, what if the client sends something bigger than 1024 bytes, say 1 megabyte?
write (fd, buf, 1000000);
How is the server going to gracefully handle this? We could, arbitrarily, say that the
client isn’t allowed to write more than n bytes. Then, in the client-side C library code
for write(), we could look at this requirement and split up the write request into several
requests of n bytes each. This is awkward.
The other problem with this example would be, “How big should n be?”
You can see that this approach has major disadvantages:
• All functions that use message transfer with a limited size will have to be modified
in the C library so that the function packetizes the requests. This in itself can be a
fair amount of work. Also, it can have unexpected side effects for multi-threaded
104 Chapter 2 • Message Passing April 30, 2009