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 QNX Neutrino 7.1.
Programming
Programmer's Guide
The QNX Neutrino Programmer's Guide covers a variety of topics that might interest developers who are building applications that will run under the QNX Neutrino RTOS.
Processes
As we stated in the Overview chapter, the architecture of the QNX Neutrino RTOS consists of a small microkernel and some number of cooperating processes. We also pointed out that your applications should be written the same way—as a set of cooperating processes.
Controlling processes via the /proc filesystem
Implemented by the Process Manager component of procnto, the /proc virtual filesystem lets you access and control the processes and threads running in the system.
Manipulating a process or thread
Once you have a file descriptor to a particular process's /proc/pid/ctl file, you can get information about and control that process and its associated threads.

QNX Momentics IDE User's Guide
This User's Guide describes version 7.1 of the Integrated Development Environment (IDE) that's part of the QNX Momentics 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 QNX Neutrino 7.1.
- Quickstart Guide
- OS Components & Operations
- Audio & Graphics API
- Multimedia
- Networking Middleware
- Programming
  - Getting Started with QNX Neutrino
    Getting Started with QNX Neutrino: A Guide for Realtime Programmers is intended to introduce you to the QNX Neutrino RTOS and help you develop applications and resource managers for it.
  - Programmer's Guide
    The QNX Neutrino Programmer's Guide covers a variety of topics that might interest developers who are building applications that will run under the QNX Neutrino RTOS.
    - Compiling and Debugging
    - Programming Overview
    - Processes
      As we stated in the Overview chapter, the architecture of the QNX Neutrino RTOS consists of a small microkernel and some number of cooperating processes. We also pointed out that your applications should be written the same way—as a set of cooperating processes.
      - Starting processes: two methods
        In embedded applications, there are two typical approaches to starting your processes at boot time.
      - Process creation
        The process manager component of procnto is responsible for process creation. If a process wants to create another process, it makes a call to one of the process-creation functions, which then effectively sends a message to the process manager.
      - Process termination
      - Detecting process termination
        In an embedded application, it's often important to detect if any process terminates prematurely and, if so, to handle it.
      - Stack allocation
        Each thread has its own stack that you can allocate yourself or have the system manage.
      - Process privileges
        In systems where security is important, applications should run with the fewest privileges possible. This practice helps reduce the impact of possible compromises and can also help lower the privilege escalation attack surface of the device.
      - Controlling processes via the /proc filesystem
        Implemented by the Process Manager component of procnto, the /proc virtual filesystem lets you access and control the processes and threads running in the system.
        Reading and writing the process's address space
        If you have the appropriate permissions, you can access a process's address space. Since threads exist in the context of a process and have access to everything within a process, there's no need to consider threads in this discussion.
        Manipulating a process or thread
        Once you have a file descriptor to a particular process's /proc/pid/ctl file, you can get information about and control that process and its associated threads.
        Thread information
        Several of the devctl() commands use a procfs_status structure (which is the same as debug_thread_t), so let's look at this structure before going into the commands themselves.
        DCMD_PROC_ABILITIES
        Return all the abilities and ability ranges of a specified process
        DCMD_PROC_BREAK
        Set or remove a breakpoint or watchpoint in the process that's associated with the file descriptor.
        DCMD_PROC_CHANNELS
        Get information about the channels owned by the specified process.
        DCMD_PROC_CLEAR_FLAG
        Clear specific debug flags with the values provided for the process associated with the file descriptor.
        DCMD_PROC_CURTHREAD
        Switch to another thread.
        DCMD_PROC_EVENT
        Define an event to be delivered when the process associated with the file descriptor reaches a point of interest.
        DCMD_PROC_GETALTREG
        Get the information stored in the alternate register set for the process associated with the file descriptor.
        DCMD_PROC_GETFPREG
        Get the information stored in the Floating Point Data registers for the process associated with the file descriptor.
        DCMD_PROC_GETGREG
        Get the information stored in the CPU registers based on the current thread of the process associated with the file descriptor.
        DCMD_PROC_GETREGSET
        Read the given register set.
        DCMD_PROC_GET_BREAKLIST
        Get a list of the active breakpoints for the process associated with the file descriptor.
        DCMD_PROC_INFO
        Obtain information about the process associated with the file descriptor.
        DCMD_PROC_IRQS
        Get the interrupt handlers owned by the process associated with the file descriptor.
        DCMD_PROC_MAPDEBUG
        Get the best guess to the ELF object on the host machine.
        DCMD_PROC_MAPDEBUG_BASE
        Get information about the path for the process associated with the file descriptor.
        DCMD_PROC_MAPINFO
        Obtain segment-specific information about mapped memory segments in the process associated with the file descriptor. This call matches the corresponding mmap() calls.
        DCMD_PROC_PAGEDATA
        Obtain page data about mapped memory segments in the process associated with the file descriptor. This call matches the corresponding mmap() calls.
        DCMD_PROC_PTINFO
        Return the pagetable mapping information for a memory segment
        DCMD_PROC_RUN
        Resume the process that's associated with the file descriptor, if it has previously been stopped.
        DCMD_PROC_SETALTREG
        Set the alternate register set with the values provided for the process associated with the file descriptor.
        DCMD_PROC_SETFPREG
        Set the Floating Point Data registers with the values provided for the process associated with the file descriptor.
        DCMD_PROC_SETGREG
        Set the CPU registers with the values provided for the process associated with the file descriptor.
        DCMD_PROC_SETREGSET
        Set the given register set.
        DCMD_PROC_SET_FLAG
        Set specific debug flags with the values provided for the process associated with the file descriptor.
        DCMD_PROC_SIGNAL
        Drop a signal on the process that's associated with the file descriptor. This is a way for a debugger to artificially generate signals as if they came from the system.
        DCMD_PROC_STATUS
        Get the current status of the current thread in the process associated with the file descriptor.
        DCMD_PROC_STOP
        Stop the process that's associated with the file descriptor.
        DCMD_PROC_SYSINFO
        Obtain information stored in the system page.
        DCMD_PROC_THREADCTL
        Perform a ThreadCtl() on another process/thread.
        DCMD_PROC_TIDSTATUS
        Get the current status of a thread in the process associated with the file descriptor.
        DCMD_PROC_TIMERS
        Get the timers owned by the process associated with the file descriptor.
        DCMD_PROC_WAITSTOP
        Hold off the calling process until the process that's associated with the file descriptor reaches a point of interest.
    - Multicore Processing
    - Working with Access Control Lists (ACLs)
      Some filesystems, such as the Power-Safe (fs-qnx6.so) filesystem, extend file permissions with Access Control Lists, which are based on the withdrawn IEEE POSIX 1003.1e and 1003.2c draft standards.
    - Understanding the Microkernel's Concept of Time
      Whether you're working with timers or simply getting the time of day, it's important that you understand how the OS works with time.
    - Transparent Distributed Processing Using Qnet
      Transparent Distributed Processing (TDP) allows you to leverage the processing power of your entire network by sharing resources and services transparently over the network. TDP uses the QNX Neutrino native network protocol, Qnet, to link the devices in your network.
    - Writing an Interrupt Handler
    - 32- and 64-Bit Architectures
      QNX Neutrino 7.1 or later supports 32- and 64-bit versions of ARM (armle-v7 and aarch64le) and 64-bit versions of x86 (x86_64).
    - Working with Memory
      (or The Persistence of Memory, with a nod to Salvador Dali)
    - Power Management
      A major contributor to the power consumption of a CPU is the frequency at which it is clocked. The power-management API allows you to manage this.
    - Freedom from Hardware and Platform Dependencies
    - Conventions for Recursive Makefiles and Directories
      In this chapter, we'll take a look at the supplementary files used in the QNX Neutrino development environment. Although we use the standard make command to create libraries and executables, you'll notice we use some of our own conventions in the Makefile syntax.
    - Glossary
  - The QNX Neutrino Cookbook: Recipes for Programmers
  - Writing a Resource Manager
- Sensor Framework
- System Security Guide
  The QNX System Security Guide is intended for both system integrators who are responsible for the security of a QNX Neutrino RTOS system and developers who want to create a QNX Neutrino resource manager free from vulnerabilities.
- Utilities & Libraries
QNX Hypervisor
The QNX Hypervisor allows you to run multiple OSs on a target system so you can separate critical and non-critical functions, support a wide variety of applications, and reduce hardware costs.
QNX Software in the Cloud
QNX Software in the Cloud enables developers to use the QNX software in Amazon Web Services (AWS) and Microsoft Azure (Azure).
QNX Advanced Virtualization Frameworks User's Guide
This User's Guide is aimed at all systems integrators and developers who want to design and build embedded systems using the QNX Advanced Virtualization Frameworks.
Typographical Conventions, Support, and Licensing
This section describes the typographical conventions used throughout the documentation and explains how to obtain technical support.

Manipulating a process or thread

Once you have a file descriptor to a particular process's /proc/pid/ctl file, you can get information about and control that process and its associated threads.

All of these functions are performed using the devctl() call as described in the sections that follow. To be able to use these devctl() calls, you'll need at least the following:

#include <devctl.h>
#include <sys/procfs.h>

Note:

There are 32- and 64-bit versions of some of the DCMD_PROC_* commands. For example:

#define DCMD_PROC_STATUS32  (__DIOF(_DCMD_PROC, __PROC_SUBCMD_PROCFS + 7, procfs_status32))
#define DCMD_PROC_STATUS64  (__DIOF(_DCMD_PROC, __PROC_SUBCMD_PROCFS + 7, procfs_status64))
#define DCMD_PROC_STATUS    (__DIOF(_DCMD_PROC, __PROC_SUBCMD_PROCFS + 7, procfs_status))

The first two forms are for specific sizes; the generic form (DCMD_PROC_STATUS) maps onto the 64-bit version, whether you compile for a 32- or 64-bit architecture. If you're compiling for a 32-bit architecture, and you want the generic version to map onto the 32-bit command, define WANT_OLD_DEVCTLS before you include <sys/procfs.h>. If you're compiling for a 64-bit architecture, the generic version always maps onto the 64-bit version of the command.

You can use the devctl() commands (described in the sections that follow) to do the following:

Select a thread for further operations. When you first perform the open() to a particular process, by default you're connected to the first thread (the thread that executed the main() function). If you wish to switch a different thread, use the DCMD_PROC_CURTHREAD command. To find out how many threads are available in the given process, see the DCMD_PROC_INFO command.
Start and stop processes and threads:
- DCMD_PROC_STOP
- DCMD_PROC_RUN
You must have opened the file descriptor for writing.
Set breakpoints:
You must have opened the file descriptor for writing.
Examine process and thread attributes:

Page updated: March 12, 2026