Getting Started with QNX Neutrino - QNX Software Systems

© 2009, QNX Software Systems GmbH & Co. KG.
blocking
A means for threads to synchronize to other threads or events. In the blocking state (of
which there are about a dozen), a thread doesn’t consume any CPU — it’s waiting on a
list maintained within the kernel. When the event occurs that the thread was waiting
for, the thread is unblocked and is able to consume CPU again.
channel
An abstract object on which a server receives a message. This is the same object to
which a client creates a connection in order to send a message to the server. When
the channel is created via ChannelCreate(), a “channel ID” is returned. This channel
ID (or “chid” for short) is what a resource manager will advertise as part of its
registered mountpoint.
client
Neutrino’s message-passing architecture is structured around a client/server
relationship. In the case of the client, it’s the one that is requesting services of a
particular server. The client generally accesses these services using standard
file-descriptor-based function calls (e.g., lseek()), which are synchronous, in that the
client’s call doesn’t return until the request is completed by the server. A thread can
be both a client and a server at the same time.
condition variable
A synchronization object used between multiple threads, characterized by acting as a
rendezvous point where multiple threads can block, waiting for a signal (not to be
confused with a UNIX-style signal). When the signal is delivered, one or more of the
threads will unblock.
connection
The concept of a client being attached to a channel. A connection is established by
the client either directly by calling ConnectAttach() or on behalf of the client by the
client’s C library function open(). In either case, the connection ID returned is usable
as a handle for all communications between the client and the server.
connection ID
A “handle” returned by ConnectAttach() (on the client side) and used for all
communications between the client and the server. The connection ID is identical to
the traditional C library’s “file descriptor.” That is to say, when open() returns a file
descriptor, it’s really returning a connection ID.
deadlock
A failure condition reached when two threads are mutually blocked on each other,
with each thread waiting for the other to respond. This condition can be generated
quite easily; simply have two threads send each other a message — at this point, both
threads are waiting for the other thread to reply to the request. Since each thread is
blocked, it will not have a chance to reply, hence deadlock. To avoid deadlock, clients
328 Glossary April 30, 2009