QNX Neutrino microkernel and process manager (QNX Neutrino)


procnto* [-a d|e|s] [-c] [-e n|o] [-F number] [-fe]
         [-h] [-H size] [-mmemmgr_configuration]  
         [-P priority] [-p] [-T timeout] [-u umask] [-v]


Disable alignment fault emulation. The procnto manager doesn't attempt to make misaligned memory accesses work; they'll cause a SIGBUS signal for the offending thread.
Enable alignment fault emulation. The procnto manager attempts to make misaligned memory accesses work, although they'll be slow. This isn't guaranteed to work; offending threads may still get a SIGBUS signal.

On ARMv6 and ARMv7 processors, specifying this option allows misaligned accesses to be performed in hardware. On these targets, ThreadCtl(_NTO_TCTL_ALIGN_FAULT, ...) no longer changes the alignment-fault behavior on a per-thread basis.

Use the system default for alignment faults. This behavior depends on your platform:
-e n|o
Specify which value to use for EALREADY:
  • -eo — use the old value, which is the same as that of EBUSY.
  • -en — use the POSIX-compliant value.
The default is -eo; it will be -en in a later release.

For more information, see Changes to EALREADY in the entry for errno in the QNX Neutrino C Library Reference.

-F number
The maximum number of file descriptors that can be open at the same time. The minimum allowable value is 100. The default value is 1000, but might be constrained by the RLIMIT_NOFILE system resource.
Sockets, named semaphores, message queues, channel IDs (chids), and connection IDs (coids) all use file descriptors.

To determine the current limit, use the ksh builtin command, ulimit , or call getrlimit() (see the QNX Neutrino C Library Reference).

Disable CPU halting in idle thread. Some CPU and supporting chipsets can lock up if the CPU halts when idle; you'll notice the need for the -h option right away because your system will lock up after booting.
-H size
Sets the initial heap size for procnto. If more memory is required for procnto, it's dynamically obtained; however, by setting a properly calculated value this option can speed up boot time, and reduce the amount of physical memory fragmentation.

The size parameter indicates the number of bytes to grow the heap in advance. You can postfix this value with a multiplier character, such as k (kilobyte) or m (megabyte). For example:

1m == 1024k == 0x100000

If the number is less than 1024 and it isn't postfixed by a multiplier character, it's assumed to be in kilobytes. The default value is 64 KB if the -H option isn't specified.

-m memmgr_configuration
Control the behavior of the memory manager. The memmgr_configuration string is a sequence of characters that enable (or if preceded with a ~ character, disable) memory-manager aspects.
If you specify more than one -m option, procnto ignores all but the last one.

The configuration options are:

Enable backward compatibility (the default).
See the release notes for the current behavior.
Disable backward compatibility.
Clear memory when it's freed.
Don't clear memory when it's freed (the default). When memory is freed for later reuse, the contents of that memory remain untouched; whatever the application that owned the memory left behind is left intact until the next time that memory is allocated by another process. At that point, before the memory is handed to the next process, it's zeroed.
Make munmap() act as if UNMAP_INIT_REQUIRED were specified (i.e., POSIX initialization of the page to all zeroes is required the next time the underlying physical memory is allocated). This is the default.
Make munmap() act as if UNMAP_INIT_OPTIONAL were specified (i.e., initialization of the underlying physical memory to zeroes on its next allocation is optional). See Initializing allocated memory in the Interprocess Communication (IPC) chapter of the System Architecture guide.
l (el)
Lock all memory; act as if mlockall(MCL_CURRENT|MCL_FUTURE) were specified at the start of every program. For more information, see mlockall() in the in the QNX Neutrino C Library Reference.
Don't lock all memory (the default).
Superlock all memory; act as if ThreadCtl(_NTO_TCTL_IO,0) were specified at the start of every program (but only insofar as locking the memory; programs don't actually get I/O privileges).
Don't superlock all memory (the default).
If you enable both l and L, the L option takes priority.
Turn on full allocation of high memory for all processes. This is mostly useful only for testing.
Make sure that all anonymous allocation occurs below the 4 GB mark (the default).
Enable address space randomization. If you use this option, the kernel places certain items (e.g., the stack, libc) at different addresses every time you run a process. This can help prevent someone from hacking into a program.
Disable address space randomization (the default).
Enable variable page sizes (the default). This automatically allows for mapping to be performed with different page sizes to achieve better performance.
Disable variable page sizes.
Enable the PROT_EXEC flag for system-allocated threads (the default). This option allows gcc to generate code on the stack — which it does when taking the address of a nested function (a GCC extension).
Turn off PROT_EXEC for system-allocated stacks, which increases security but disallows taking the address of nested functions. You can still do this on a case-by-case basis by doing an mprotect() call that turns on PROT_EXEC for the required stacks.
-P priority
Set the lower end of the range of privileged priorities to the given priority; the upper end of the range is 255. Only processes with an effective user ID of 0 (i.e., root) or those with the PROCMGR_AID_PRIORITY ability enabled (see procmgr_ability() ) can use these priorities. Unprivileged (and privileged) processes can use priorities from 1 through priority − 1. The default value of priority is 64; the minimum permitted value is 10, and the maximum is 255.
Disable kernel preemption. This prevents threads running in kernel space from being preempted by a higher-priority thread. This can be useful when debugging a system with a frequent source of high-priority interrupts.
-T timeout
Specify the number of seconds to wait for a close() to succeed in the event of a process termination. Previously, this timeout was hard coded to be 30 seconds. The current default is also 30 seconds; however, the -T timeout option lets you set this value.

When a process terminates, any outstanding connections are closed. This means that an _IO_CLOSE message is synthesized and sent to the resource manager responsible for that connection.

Because it is not guaranteed that the server will reply in a reasonable amount of time, a TimerTimeout() call before the send guarantees that the termination process will proceed.

-u umask
Use the given file-creation mask when creating the entries in /proc/ pid /as. If you don't specify this option, procnto uses a mask of 0066.
Opening /proc/ pid /as for read-only access succeeds, even if the file permissions would normally say that it should fail with an EACESS. Instead the kernel marks the OCB as allowing only devctl() commands. This prevents unprivileged processes from examining a process's memory, but still allows a non-root pidin to display some useful information.

For more information about these files, see /proc filesystem, below.

Be verbose. Specifying more v characters increases the verbosity. If you specify this option, you'll get more useful information when a process is terminated by a signal.


The procnto system process contains the QNX Neutrino microkernel, process management, memory management and pathname management. It's required in all bootable images made using the mkifs utility. For more information, see the QNX Neutrino System Architecture guide.

To determine the release version of the kernel on your system, use the uname -a command.

There are different versions of procnto for different processors (see the Board Support Package for your board for specific information):

PowerPC 400 series processors.
PowerPC 800 series processors.
Power Book E SMP processors.
Other Power Book E processors.
Other supported PowerPC SMP processors, such as the 600 and 700 series.
Other supported PowerPC processors, such as the 600 and 700 series.
32-bit MIPS processors.
ARMv6 processors.
All other supported multicore processors.
All other supported processors.

There's also an instrumented version of each of the above (e.g., procnto-600-smp-instr) that you'll use for system analysis.

For self-hosted Neutrino systems, the default microkernel is procnto-instr or procnto-smp-instr.

If you're using an SMP version of procnto, you can use the appropriate startup-* command's -P option to specify the maximum number of CPUs to activate.

In addition, procnto manages named semaphores. Named semaphores appear in the pathname space under /dev/sem. The sem_* client functions handle named semaphores; for more information, see the QNX Neutrino C Library Reference.

/proc filesystem

The Process Manager component of procnto implements a /proc filesystem that includes the following:

/proc/ pid
Virtual directories that let you access and control every process and thread running within the system. For more information, see Controlling processes via the /proc filesystem in the Processes chapter of the QNX Neutrino Programmer's Guide.
The image filesystem that comprises the boot image.
A special entry that receives notification when a process terminates abnormally. The dumper utility watches this entry.
Pathname-space mountpoints.
If you list the contents of the /proc directory, /proc/mount doesn't show up, but you can list the contents of /proc/mount.
The address space for yourself (i.e., for the process that's making the query).


To disable preemption in kernel code:

procnto -p