Sample parent process using sigwaitinfo()

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.
Programming
Programmer's Guide

The QNX OS Programmer's Guide covers a variety of topics that might interest developers who are building applications that will run under the QNX OS .
Processes

Your applications should be written in a way that reflects the architecture of the QNX OS —as a set of cooperating processes. In this chapter, we see how to start processes (also known as creating processes) from code, how to terminate them, and how to detect their 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.
Sample parent process using sigwaitinfo()

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.
- OS Components & Operations
- Graphics
- Programming
  - Getting Started with the QNX OS
    
    Getting Started with the QNX OS : A Guide for Realtime Programmers is intended to introduce you to the QNX OS and help you develop applications and resource managers for it.
  - Programmer's Guide
    
    The QNX OS Programmer's Guide covers a variety of topics that might interest developers who are building applications that will run under the QNX OS .
    - Compiling and Debugging
      
      Let's start by looking at some things you should consider when you start to write a program for the QNX OS .
    - QNX OS Architecture and Concepts
      
      The QNX OS architecture consists of the microkernel and several cooperating processes. These processes communicate with each other via various forms of interprocess communication (IPC). Message passing is the primary form of IPC in QNX OS .
    - Processes
      
      Your applications should be written in a way that reflects the architecture of the QNX OS —as a set of cooperating processes. In this chapter, we see how to start processes (also known as creating processes) from code, how to terminate them, and how to detect their termination.
      - 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.
        
        Using the High Availability Framework
        
        The High Availability Framework provides components not only for detecting when processes terminate, but also for recovering from such terminations.
        
        Detecting termination from a starter process
        
        If you've created a set of processes using a starter process, then all those processes are children of that process, with the exception of those that have called procmgr_daemon() .
        
        Sample parent process using wait()
        
        Sample parent process using sigwaitinfo()
        
        Detecting dumped processes
        
        As mentioned above, you can run dumper so that when a process dies, dumper writes the state of the process to a file. You can also write your own dumper-type process to run instead of, or as well as, dumper . This way the terminating process doesn't have to be a child of yours.
        
        Detecting the termination of daemons or of all processes
        
        What would happen if you've created some processes that subsequently made themselves daemons (i.e., called procmgr_daemon() )? As we mentioned above, the wait*() functions and sigwaitinfo() won't help.
        
        Detecting client termination
        
        The last scenario is where a server process wants to be notified of any clients that terminate so that it can clean up any resources that it had set aside for them.
      - 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.
    - Multicore Processing
      
      Multiprocessing systems, whether discrete or multicore, can greatly improve your applications' performance.
    - 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.
    - Handling Hardware Interrupts
      
      This chapter explains the QNX OS mechanisms for quickly reacting to hardware events.
    - Working with Memory
      
      (or The Persistence of Memory , with a nod to Salvador Dali) In the Process Manager chapter of the System Architecture guide, we looked at how the OS manages memory. This chapter describes how you can work with memory.
    - Freedom from Hardware and Platform Dependencies
      
      The QNX OS can run on many different hardware platforms. The way in which applications can access peripheral devices and how data is stored varies between platforms. This chapter explains our solutions for minimizing the impact of such platform dependencies.
    - Conventions for Recursive Makefiles and Directories
      
      In this chapter, we'll look at the supplementary files used in the QNX OS development environment. Although we use the standard make command to create libraries and executables, we also use some of our own conventions in the Makefile syntax.
    - Glossary
  - Writing a Resource Manager
- 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 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.
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 sigwaitinfo() function blocks, waiting until any signals that the caller tells it to wait for are set on the caller. If a child process terminates, then the SIGCHLD signal is set on the parent. So all the parent has to do is request that sigwaitinfo() return when SIGCHLD arrives. The following sample illustrates the use of sigwaitinfo() for waiting for child processes to terminate: * sigwaitchild.c * This is an example of a parent process that creates some child * processes and then waits for them to terminate. The waiting is * done using sigwaitinfo(). When a child process terminates, the * SIGCHLD signal is set on the parent. sigwaitinfo() will return * when the signal arrives. #include <errno.h> #include <spawn.h> #include <stdio.h> #include <string.h> #include <stdlib.h> #include <unistd.h> #include <sys/neutrino.h> void signal_handler(int signo) // do nothing int main(void) char *args[] = { "child", NULL }; int i; pid_t pid; sigset_t mask; siginfo_t info; struct inheritance inherit; struct sigaction action; // mask out the SIGCHLD signal so that it will not interrupt us, // (side note: the child inherits the parents mask) sigemptyset(&mask); sigaddset(&mask, SIGCHLD); sigprocmask(SIG_BLOCK, &mask, NULL); // by default, SIGCHLD is set to be ignored so unless we happen // to be blocked on sigwaitinfo() at the time that SIGCHLD // is set on us we will not get it. To fix this, we simply // register a signal handler. Since we've masked the signal // above, it will not affect us. At the same time we will make // it a queued signal so that if more than one are set on us, // sigwaitinfo() will get them all. action.sa_handler = signal_handler; sigemptyset(&action.sa_mask); action.sa_flags = SA_SIGINFO; // make it a queued signal sigaction(SIGCHLD, &action, NULL); // create 3 child processes for (i = 0; i < 3; i++) { inherit.flags = 0; if ((pid = spawn("child", 0, NULL, &inherit, args, environ)) == -1) perror("spawn() failed"); printf("spawned child, pid = %d\n", pid); while (1) { if (sigwaitinfo(&mask, &info) == -1) { perror("sigwaitinfo() failed"); continue; switch (info.si_signo) { case SIGCHLD: // info.si_pid is pid of terminated process, it is not POSIX printf("A child terminated; pid = %d\n", info.si_pid); break; default: // Should not get here since we asked only for SIGCHLD printf("Unexpected signal: %d\n", info.si_signo);