Home
QNX Software Development Platform
QNX SDP is a cross-compiling and debugging environment, including an IDE and command-line tools, for building binary images and programs for target boards running the QNX OS 8.0.
System Architecture
The System Architecture guide accompanies the QNX OS and is intended for both application developers and end-users.
Interprocess Communication (IPC)
Interprocess Communication (IPC) plays a fundamental role in the transformation of the microkernel from an embedded realtime kernel into a full-scale POSIX operating system. As various service-providing processes are added to the microkernel, IPC is the glue that connects those components into a cohesive whole.
Priority inheritance and messages
QNX OS uses message-driven priority inheritance to avoid priority-inversion problems.
Server boost
Priority inheritance relies on deciding which server thread needs to be boosted when a high-priority client sends a message. If there are server threads available to receive a message (i.e., RECEIVE-blocked), then the thread that receives the message is the one that gets boosted. But if no server threads are available and, thus, the client is left SEND-blocked, it's not clear which thread should be boosted.

QNX Momentics IDE User's Guide
This User's Guide describes version 8.0 of the Integrated Development Environment (IDE) that's part of the QNX Tool Suite.
QNX Software Development Platform
QNX SDP is a cross-compiling and debugging environment, including an IDE and command-line tools, for building binary images and programs for target boards running the QNX OS 8.0.
- Quickstart Guide
- System Architecture
  The System Architecture guide accompanies the QNX OS and is intended for both application developers and end-users.
  - The Philosophy of the QNX OS
    The primary goal of the QNX OS is to deliver the open systems POSIX API in a robust, scalable form suitable for a wide range of systems—from tiny, resource-constrained embedded systems to high-end distributed computing environments. The OS supports several processor families, including x86 and ARM.
  - The QNX OS Microkernel
    The microkernel implements the core POSIX features used in embedded realtime systems, along with the fundamental QNX OS message-passing services.
  - Interprocess Communication (IPC)
    Interprocess Communication (IPC) plays a fundamental role in the transformation of the microkernel from an embedded realtime kernel into a full-scale POSIX operating system. As various service-providing processes are added to the microkernel, IPC is the glue that connects those components into a cohesive whole.
    - Synchronous message passing
      Synchronous messaging is the main form of IPC in the QNX OS.
    - Message copying
      Since our messaging services copy a message directly from the address space of one thread to another without intermediate buffering, the message-delivery performance approaches the memory bandwidth of the underlying hardware.
    - Simple messages
      For simple single-part messages, the OS provides functions that take a pointer directly to a buffer without the need for an IOV (input/output vector). In this case, the number of parts is replaced by the size of the message directly pointed to.
    - Channels and connections
      In the QNX OS, message passing is directed towards channels and connections, rather than targeted directly from thread to thread. A thread that wishes to receive messages first creates a channel; another thread that wishes to send a message to that thread must first make a connection by attaching to that channel.
    - Pulses
      In addition to the synchronous Send/Receive/Reply services, the OS also supports fixed-size, nonblocking messages. These are referred to as pulses and carry a small payload.
    - Priority inheritance and messages
      QNX OS uses message-driven priority inheritance to avoid priority-inversion problems.
      - Server boost
        Priority inheritance relies on deciding which server thread needs to be boosted when a high-priority client sends a message. If there are server threads available to receive a message (i.e., RECEIVE-blocked), then the thread that receives the message is the one that gets boosted. But if no server threads are available and, thus, the client is left SEND-blocked, it's not clear which thread should be boosted.
    - Message-passing API
      The message-passing API consists of the functions listed here.
    - Robust implementations with Send/Receive/Reply
      Architecting a QNX OS application as a team of cooperating threads and processes via Send/Receive/Reply results in a system that uses synchronous notification. IPC thus occurs at specified transitions within the system, rather than asynchronously.
    - Events
      A significant feature in the kernel design for QNX OS is its subsystem for handling events. POSIX and its realtime extensions define a number of asynchronous notification methods (e.g., UNIX signals that don't queue or pass data, POSIX realtime signals that may queue and pass data, etc.).
    - Signals
      The OS supports the 32 standard POSIX signals (as in UNIX) as well as the POSIX realtime signals, both numbered from a kernel-implemented set of 64 signals with uniform functionality.
    - POSIX message queues
      POSIX defines a set of nonblocking message-passing facilities known as message queues.
    - Shared memory
      Shared memory offers the highest bandwidth IPC available.
    - Typed memory
      POSIX typed memory provides an interface that lets you open named memory objects and perform mapping operations on them.
    - Pipes and FIFOs
      Pipes and FIFOs are both forms of queues that connect processes.
  - The Microkernel Instrumentation
    The microkernel (procnto-smp-instr) is equipped with a sophisticated tracing and profiling mechanism that lets you monitor your system's execution in real time. This instrumentation works on both single-CPU and SMP systems.
  - Process Manager
    The Process Manager can create and manage multiple POSIX processes, each of which may contain multiple POSIX threads.
  - Dynamic Linking
    In a typical system, a number of programs will be running. Each program relies on a number of functions, some of which will be standard C library functions, like printf(), malloc(), write(), etc.
  - Resource Managers
    To give the QNX OS a great degree of flexibility, to minimize the runtime memory requirements of the final system, and to cope with the wide variety of devices that may be found in a custom embedded system, the OS allows user-written processes to act as resource managers that can be started and stopped dynamically.
  - Filesystems
    The QNX OS provides a rich variety of filesystems. Like most service-providing processes in the OS, these filesystems execute outside the kernel; applications use them by communicating via messages generated by the shared-library implementation of the POSIX API.
  - Character I/O
    A key requirement of any realtime operating system is high-performance character I/O.
  - Networking Architecture
    As with other service-providing processes in the QNX OS, the networking services execute outside the kernel. Developers are presented with a single unified interface, regardless of the configuration and number of networks involved.
  - TCP/IP Networking
    Our TCP/IP stack is included in the io-sock networking stack and uses the common FreeBSD API.
  - High Availability
    The term High Availability (HA) is commonly used in telecommunications and other industries to describe a system's ability to remain up and running without interruption for extended periods of time.
  - What is Real Time and Why Do I Need It?
    Real time is an often misunderstood—and misapplied—property of operating systems. This appendix provides a summary of some of the critical elements of realtime computing and discusses a few design considerations and benefits.
  - Glossary
- OS Components & Operations
- Graphics
- Programming
- System Security Guide
  The QNX System Security Guide is intended for both system integrators who are responsible for the security of a QNX OS system and developers who want to create a QNX OS resource manager free from vulnerabilities.
- Utilities & Libraries
- Migrating to QNX OS 8.0
QNX Software in the Cloud
QNX Software in the Cloud enables developers to use the QNX OS in the Amazon cloud environment.
QNX Toolkit for Visual Studio Code
This User's Guide describes the QNX^® Toolkit for Visual Studio Code. The guide introduces you to the QNX Toolkit by explaining the QNX development environment and how to build, run, and debug your QNX^® Operating System (OS) applications and systems.
QNX Hypervisor User's Guide
This User's Guide explains the QNX hypervisor architecture and provides instructions for installing and running a QNX Hypervisor system, changing system components and configuration, and using hypervisor features such as virtual devices (vdevs).
Typographical Conventions, Support, and Licensing
This section describes the typographical conventions used throughout the documentation, explains how to obtain technical support, and provides some information about licensing.

Server boost

QNX SDP8.0System ArchitectureDeveloperUser

Priority inheritance relies on deciding which server thread needs to be boosted when a high-priority client sends a message. If there are server threads available to receive a message (i.e., RECEIVE-blocked), then the thread that receives the message is the one that gets boosted. But if no server threads are available and, thus, the client is left SEND-blocked, it's not clear which thread should be boosted.

Without a RECEIVE-blocked server thread, when a client sends a message or pulse, the kernel boosts the priority of one server thread that's associated with that channel. Priority inversion can still happen—this is a known limitation—but it won't prevent any threads from finishing their work and doing a receive.

Note:

This situation is considered to be a symptom of a poorly designed server. For a multi-threaded server, when a new client request is made, the server should always have at least one RECEIVE-blocked thread.

When a thread is boosted for the first time, its original priority is recorded. The thread may be boosted multiple times if multiple threads become SEND-blocked, but the kernel records only the priority before the initial boosting.

When a message is next received, the kernel reevaluates the situation. If there are still pulses or SEND-blocked threads, then some of the boosted threads may remain boosted (although potentially at a lower priority), while others may drop back to their original priority.

If there are no SEND-blocked threads, then all threads that were originally boosted return to their original priorities.

How a thread becomes associated with a channel

A thread is associated with a channel when it does a MsgReceive() on it. In the case of multiple channels, a thread is associated with the last channel it received from. After receiving a message, a thread can dissociate itself from the channel by calling MsgReceive() with a -1 for the channel ID.

Page updated: March 05, 2025