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.
Process Manager
The Process Manager can create and manage multiple POSIX processes, each of which may contain multiple POSIX threads.
Memory management
The virtual memory system implements the POSIX model for memory management along with some QNX OS extensions.
Memory accounting
Accounting for the memory used by your system and processes can be useful, especially when debugging. This section covers examples of how to read memory-related files and calculate reserved memory.
The pmap parameters
The pmap file provides details about memory mapping and other process information.

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.
  - 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.
    - Process management
      The first responsibility of procnto is to dynamically create new processes. These processes will then depend on procnto's other responsibilities of memory management and pathname management.
    - Memory management
      The virtual memory system implements the POSIX model for memory management along with some QNX OS extensions.
      - Memory accounting
        Accounting for the memory used by your system and processes can be useful, especially when debugging. This section covers examples of how to read memory-related files and calculate reserved memory.
        Calculating memory reserved by a process
        You can use vmstat files to get information about system and per-process memory usage. The pmap files are another source of per-process memory information. The use of shared objects must also be taken into consideration when measuring memory consumption.
        Using C library APIs to calculate memory reservations
        You can use the code snippets in this section to calculate how much private and shared memory your process is using.
        The vmstat files
        The vmstat files provide memory usage information for both the system and processes.
        The pmap parameters
        The pmap file provides details about memory mapping and other process information.
        The mappings file
        Detailed mapping information of each page in your process can be found in the mappings file.
    - Pathname management
      I/O resources aren't built into the microkernel, but are instead provided by resource manager processes that may be started dynamically at runtime. The procnto manager allows resource managers, through a standard API, to adopt a subset of the pathname space as a domain of authority to administer.
  - 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.

The pmap parameters

QNX SDP8.0System ArchitectureDeveloperUser

The pmap file provides details about memory mapping and other process information.

The pmap output includes the following parameters:

vaddr

Virtual memory address.

size

This is the size of the virtual address range that the region occupies (i.e., the region extends from vaddr to vaddr + size).

flags

Mapped memory flags. See mmap() for details on the flags.

prot

Page protection flags, right shifted by 8 bits. See mmap() for details on the flags.

maxprot

The maximum value that prot can have, right shifted by 8 bits.

dev

Device ID of mapped objects.

ino

Inode of mapped object.

offset

The offset from the start of the mapped object.

rsv

The amount of memory reserved for the region. Adheres to the following rules:

A non-lazy private region's rsv value should be equal to its size value. The flags parameter contains the MAP_PRIVATE flag, but not the MAP_LAZY flag.
A lazy region shows how much memory was referenced. The flags parameter contains the MAP_LAZY flag.
A shared region can have a zero (0) value for reasons including, but not limited to: being backed by a non-allocated, explicit physical address range, or being backed by a file or a shared object. The flags parameter may contain the MAP_PHYS flag.

guardsize

Mapping guard size.

refcnt

Number of references to each object.

mapcnt

Number of unique mappings to the object.

path

The name of the object that backs the mapping.

asinfo

The name of the asinfo entry that backs the mapping. For more information about the asinfo section of the system page, go to asinfo in the Building Embedded Systems guide.

For a discussion of how to use pmap information to find out how much memory is reserved by a process, go to Memory reservation from reading the pmap file.

Page updated: March 05, 2025