Developer Resources
Technical Articles

QNX Technical Articles

QNX Software Development Platform 6.6: Release Notes

Date of this edition: February 3, 2017

Note: Changes to these notes since February 28, 2014 are highlighted below with this icon: New:

QNX SDP is a cross-compiling and debugging environment, including an IDE and command-line tools, for building binary images and programs for ARM v7 and x86 targets running the QNX Neutrino RTOS 6.6. You can install QNX SDP on the following development hosts:

  • Microsoft Windows 8 Professional 64-bit, Windows 7 Professional 64-bit, or XP Professional SP3
  • Linux Red Hat Enterprise Linux 6 64-bit or Ubuntu Workstation LTS 12.04 32- and 64-bit

We've validated the QNX Neutrino RTOS on the following ARM platforms:

  • Freescale i.MX6x SABRE AI/ARD
  • Freescale i.MX6Q SABRE Lite
  • TI Jacinto 4/5 EVM
  • TI Jacinto 5 ECO EVM
  • TI AM335x Beaglebone/Beaglebone Black
  • TI AM335x EVM
  • TI OMAP4430/OMAP4460
  • TI OMAP5432 uEVM ES2.0

The QNX Neutrino RTOS supports generic PCs, as well as these x86 chipsets:

  • Intel BloomField Hills (also known as Bay Trail - Atom E3800)
  • Intel CedarView (also known as Cedar Trail - Atom N2x00, D2700, D2550)
  • Intel Haswell (Q87, QM87)
  • Intel Ivybridge (Q77, QM77)
  • Intel Pineview (Atom N4xx, D510)
  • Intel SandyBridge (Q67, QM67)
  • Intel Tunnel Creek (Atom Z6xx)

  • New: In a future release of QNX SDP, mmap() will start enforcing the POSIX requirement that you specify either MAP_PRIVATE or MAP_SHARED. If you specify neither, mmap() will return MAP_FAILED and set errno to EINVAL; if you try to use the mapped-in object, you'll get a SIGSEGV.
  • If you installed an alpha version of this software, uninstall it before installing the production version.
  • Make sure that Plug and Play OS is disabled in the BIOS before you run QNX Neutrino on your target.

Throughout this document, you may see reference numbers associated with particular issues, changes, etc. When corresponding with our Technical Support staff about a given issue, please quote the relevant reference number. You might also find the reference numbers useful for tracking issues as they become fixed.

For the most up-to-date version of these release notes, go to our website, www.qnx.com, log in to your myQNX account, and then go to the Download area.

In the Download area, you'll also find an ISO image of a QNX Neutrino RTOS runtime system that you can install as a virtual machine on VMware Workstation, VMware Player, VMware Fusion, or Oracle VirtualBox.


What's new in the QNX Neutrino RTOS?

The main new features in this release include the following:

The new Screen Graphics Subsystem replaces the Photon microGUI, including PhAB, Phindows, and QNX Neutrino Advanced Graphics. Usually referred to simply as Screen, the Screen Graphics Subsystem allows off-screen rendering and can composite graphics from different rendering technologies, including HTML5, Elektrobit GUIDE, Crank Storyboard, Qt, and native (e.g., OpenGL ES) code. For more information, see the Screen Developer's Guide.
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.

The C library includes various acl_*() functions that work with access control lists; on the command line, you can use the getfacl and setfacl utilities to get and set the access control list for a file or files. For more information, see the QNX Neutrino User's Guide, the QNX Neutrino Programmer's Guide, as well as the C Library Reference and the Utilities Reference.

Process-manager abilities
Your applications can now retain certain abilities and then run as a user other than root, increasing your entire system's security.

New: For example, in order for a thread to run at a priority in the privileged range (see the -P option for procnto), it must either run as root or have the PROCMGR_AID_PRIORITY ability enabled.

For more information, see Process privileges in the QNX Neutrino Programmer's Guide and Security in Writing a Resource Manager, as well as the entry for procmgr_ability() in the C Library Reference and the entry for ability in the Utilities Reference.

Tickless mode
The kernel can now run in a tickless mode in order to reduce power consumption, but this is a bit of a misnomer. The system still has clock ticks, and everything runs as normal unless the system is idle. Only when the system goes completely idle does the kernel turn off clock ticks, and in reality what it does is slow down the clock so that the next tick interrupt occurs just after the next active timer is to fire, so that the timer will fire immediately.

If your timer doesn't have to be too precise, you can give it a tolerance value, to give the kernel more leeway for entering tickless mode. For more information, see Clocks, timers, and power management in the QNX Neutrino Programmer's Guide, and the entries for TimerSettime(), TimerTimeout(), timer_settime(), timer_timeout(), and procmgr_timer_tolerance() in the C Library Reference.

Lazy interrupts
In order to help the kernel save power, you can make an interrupt lazy by specifying an acceptable latency for it. Before putting the CPU to sleep, the kernel checks all the interrupt latency values and sees if it can guarantee that another interrupt (e.g., for a timer tick) will occur before the latency period has expired. If it can prove that another interrupt will occur first, the kernel masks the lazy interrupt before going to sleep. When any interrupt is received by the CPU, all the lazily masked interrupts are unmasked. For more information, see Interrupts and power management in the QNX Neutrino Programmer's Guide.
Dynamic Host Configuration Protocol
We now support DHCPv6; for more information, see the entries for dhclient, dhclient-script, dhclient.conf, and dhclient.leases in the Utilities Reference, and the dhcpctl*() entries in the C Library Reference. For information about our implementations of DHCPv4 and v6, see What's new: Networking, below.
Power-Safe (fs-qnx6.so) filesystem features
  • You can now encrypt all or part of the contents of a Power-Safe filesystem by dividing it into encryption domains that can contain any number of files and directories. For more information, see Encryption in the Filesystems chapter of the System Architecture guide, as well as the entry for fsencrypt in the Utilities Reference.

    New: The encryption libraries are available through the QNX Encrypted Filesystem Runtime Package (Patch ID 4277). Additional royalty costs are associated with runtime use of the Encrypted Filesystem. Please consult QNX Sales for details.

  • The Power-Safe filesystem now supports the TRIM command, a hint to the managed NAND device from the filesytem that certain sectors are no longer live and can be discarded.
Trusted filesystems
If a process with any privileged abilities enabled attempts to mark a region of memory as PROT_EXEC, any memory-mapped files in the region must be trusted or be from a trusted filesystem. For more information, see the entry for pathtrust in the Utilities Reference, and the entry for fdistrusted() in the C Library Reference.
Dinkum Libraries
We now ship the Dinkum C++11 library as libcpp.so.5. For backward compatibility, we continue to ship:
  • libcpp.so.4 — C++ library
  • libecpp.so.4 — Embedded C++ library
Filesystem images
You can now create images of Power-Safe (fs-qnx6.so) and FAT filesystems; see the entries for mkqnx6fsimg and mkfatfsimg in the Utilities Reference.
A system-logging framework that overcomes various limitations of the legacy slogger system. For more information, see the entries for slogger2 and slog2info in the Utilities Reference, and the entries for slog2*() in the C Library Reference.
QNX SDK for Apps and Media
This development platform (available as a separate product) replaces the QNX Aviage Multimedia Suite. It offers multimedia support, an application management framework, a chromeless browser, and an embedded browser.

For information about other changes, see the following sections:

What's new: Kernel

  • New: There's a new (and not yet documented) -S option that you can use to specify the number of bytes after and (optionally) before the stack pointer to include in a kernel dump. The syntax is:

    -S bytes_after[,bytes_before]

    The default values are 128 bytes after and 0 bytes before. In the stack portion of a kernel dump, the location of the stack pointer is indicated by a greater-than sign (>) in the output.

  • The -ae support for procnto for ARMv7 processors has been changed to allow misaligned accesses to be performed in hardware.

    This change means that ThreadCtl(_NTO_TCTL_ALIGN_FAULT, ...) no longer changes the alignment-fault behavior on a per-thread basis on these targets. (Ref# 77775, 77873, J169734)

  • New: You can append an s or S to the -P priority option if you want out-of-range priority requests to use the maximum allowed value (reach a maximum saturation point) instead of resulting in an error.
  • By 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.

    There's a new memory-manager option, -mc, that you can use to tell the kernel to zero memory when it's freed instead of waiting until the next time the memory is allocated. For example:

    Note: In a real buildfile, you can't use a backslash (\) to break a long line into shorter pieces, but we've done that here, just to make the buildfile easier to read.

    [virtual=shle,srec +compress] .boot = {
       ../../startup-msrp1 -v -Nrp1        -Dscif..38400
       PATH=/proc/boot:/bin:/sbin:/usr/bin:/usr/sbin: \ 
    /usr/nto/shle/usr/lib:/tmp \ 
        procnto -v -mc

    You can use the -m~c option to explicitly request the default behavior. (Ref# 77509, 77351, J169691)

  • The default umask used when creating the entries in /proc/pid/as is now 0066 instead of 0022.

    Note: 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.

    (Ref# 78922, 78924, 169797)

  • The /proc filesystem now includes /proc/pid/cmdline and /proc/pid/exefile files that contain the process's arguments (separated by null characters) and executable file, respectively.

What's new: Networking

By default, AutoIP no longer uses routes to direct the link-local network to use the routable IP address of the interface, nor does it route by default to the link-local IP address. If the old routing behavior is necessary, use the old option. Using routing this way was problematic depending on the peer configuration, as well as when multiple interfaces were present. The force option now has no effect unless you've also specified old. (Ref# 77436, 77649, J169717)
The documentation now explains that, in order to permanently enable forwarding, you need to set net.inet.ip.forwarding and/or net.inet6.ip6.forwarding to 1 in a file such as /etc/sysctl.conf, and then start sysctl using the -f option in your system's /etc/rc.d/rc.local file. (Ref# 78736, J382535)

Differences between our implementations of DHCPv4 and v6

There are a few key differences between our new and old implementations of DHCP that you should be aware of:

  • As an extension, we've added two new command-line options to dhclient:
    Write the resolver configuration to memory (using confstr) rather than to /etc/resolv.conf.
    Don't install the resolver configuration at all.
  • dhclient: All the local node configuration is taken care of by the dhclient-script, i.e. you're free to change and adapt this, which gives you a lot of flexibility. We install a default version of this script in /sbin.
  • The above -m and --no-resolve command-line options are implemented by simply passing environment variables RESOLV_TO_MEMORY and MODIFY_RESOLV respectively to the script, and the default script handles them.
  • The default dhclient-script overwrites the local resolver configuration; it doesn't attempt to merge it. This has the advantage that stale resolver configuration isn't kept around, but also has drawbacks (see below).
  • The old dhcp.client process would handle one interface; the new dhclient can handle several interfaces in one process (but the state machines are separate).
  • The new client, relay, and server support IPv6 (the old ones didn't).
  • The new client, relay, and server can be started in either IPv4 mode (default, -4 command-line option) or IPv6 mode (-6), but not both at the same time.
  • If two or more instances of dhclient run at the same time, there are potential races for any common configuration parameters they may both receive, and this should be handled by the dhclient-script. One example of such configuration parameters is the resolver configuration, and the solution in that particular case is to run one of the clients with the --no-resolve command-line option or change the default dhclient-script.
  • The ARP probing feature in old dhcp.client isn't implemented in the new dhclient; the place to invoke such functionality would be in the dhclient-script.
  • BUG: Failures of IPv6 Duplicate Address Detection aren't captured by dhclient. This should apparently be handled by the dhclient-script, but currently the script's return values aren't processed, so this won't work.
  • We've added support for DHCPv6 over PPP interfaces (and we hope to get ISC to officially support this patch).
  • dhclient will not clean up if it's simply killed. Instead, use the -r and -x options.
  • IAIDs are sequence numbers that start based on the MAC address for regular interfaces, but are simple sequence numbers starting at zero for PPP interfaces.
  • DHCPv6 uses DHCP Unique Identifiers (DUIDs), which just need to be unique per node, not per interface as you might think. A DUID is an opaque identifier to the peer, and the peer can use only it to compare equality (==).

    If a DUID is in the leases file, it'll be grabbed from there before trying to create it. You can't form it from PPP interfaces; instead our patch tries other interfaces (if they're specified on the command line). You can also set the DUID manually, as described in the entry for dhclient.conf.

  • DHCPv4 isn't expected to work on PPP; if you try it, you'll get an error message like this:
    Unsupported device type 23 for "ppp0"

The DHCP utilities have the dependencies listed below:

Has a dependency on the following libraries/binaries:
  • libcrypto.so
  • libsocket.so
  • libdhcpctl.so (built as part of io-pkt/services/dhcp)
  • io-pkt-v4, io-pkt-v4-hc, or io-pkt-v6-hc (depending on whether you're using IPv4 or IPv6)

Configuration files:

  • /etc/dhcpd6.conf (required, DHCPv6 config file; you can override it with -cf config_file on startup)
  • /etc/dhcpd.conf for IPv4 (DHCPv4) operation
  • /var/db/dhcpd6.leases (required, database and server ID, needs to be read/write; you can override it with -lf leases_file on startup)
  • /var/db/dhcpd.leases for IPv4

You should generally create an empty leases file.

Has a dependency on the following libraries/binaries:
  • libcrypto.so
  • libsocket.so
  • io-pkt-v4, io-pkt-v4-hc, or io-pkt-v6-hc (depending on whether you're using IPv4 or IPv6)
  • /sbin/dhclient-script (required; you can override it with -sf script-file on startup)

Configuration files:

  • /var/db/dhclient6.leases (optional; if not present, it will generate a new client ID on every startup; you can override it on startup)
  • /etc/dhclient6.conf (optional; defaults used if not present; you can override it on startup)
  • /etc/dhclient.conf for IPv4
  • dhclient6.leases
  • dhclient.leases for IPv4
Has a dependency on the following libraries/binaries:
  • ifconfig (which needs io-pkt-* and libsocket.so)
  • sh
  • route
  • hostname
  • getconf
  • setconf
  • cat
  • mv
  • If /etc/dhclient-enter-hooks and/or /etc/dhclient-exit-hooks exists, then dhclient-script will run them too.

Configuration files:

  • /etc/resolv.conf (optional, but needed to update the DNS server; must be read/write)
Has a dependency on the following libraries:
  • libcrypto.so
  • libsocket.so
  • io-pkt-v4, io-pkt-v4-hc, or io-pkt-v6-hc (depending on whether you're using IPv4 or IPv6)

All configuration is done from the startup command line.

What's new: Libraries and header files

The new functions and data structures in the QNX Neutrino libraries include:

Free the structure used for extended information about a client connection (Ref# 77731, 79485, J169855)
Store extended information about a client connection (Ref# 77731, 79485, J169855)
InterruptCharacteristic(), InterruptCharacteristic_r()
Get or set a characteristic associated with an interrupt (Ref# 75524, 78945)
New: Attach an idle interrupt handler. This kernel call replaces InterruptHookIdle() and is suitable for use on multiprocessor systems. Note that the arguments for the handler function have changed. For more information, see InterruptHookIdle2() in the online documentation.
Add or update a watch for filesystem events associated with a path (Ref# 104112, 114210)

Note: The inotify_*() functions use filesystem events, but the fsevmgr manager was inadvertently omitted from QNX SDP 6.6. You can get it from Technical Support.

Structure that describes a watched filesystem event (Ref# 104112, 114210)
Initialize the inode notify system (Ref# 104112, 114210)
Remove the watch associated with the given watch descriptor (Ref# 104112, 114210)
Store information about a client connection. This function is an extended version of iofunc_client_info()—which is now deprecated—that can handle more than NGROUPS_MAX supplementary groups. (Ref# 77731, 79485, J169855)
Free the structure used for information about a client connection (Ref# 77731, 79485, J169855)
Perform validation that's common to all handlers for _IO_DEVCTL messages (Ref# 81734, 263259, J194933)
Securely set memory to a given value (Ref# 116600, 163197, J173676, J181738)
Object Management Application Programming Interface (Ref# 101106, J172134)
New: This function is now correctly declared in <ppsparse.h> as stated in the documentation. (Ref# 168338, J182667)
Specify the lowest acceptable file descriptor (Ref# 122362, 170742, J174315, J183120)
Compute the length of a string, to a maximum number of bytes (Ref# 98975, 242696, J171922, J192427)
Ask the system to turn on dynamically offlined CPUs (Ref# 172224, 173649)

Other changes include:

New: The large-file support functions and data types now appear in the name space only if you define _LARGEFILE64_SOURCE when you compile your code. In earlier versions of the OS, these functions appeared in the default name space, but not in others such as POSIX_C_SOURCE.

These functions and data types support 64-bit file offsets. They're stopgap measures that you might need to use until the default file offsets are 64 bits long:

  • If you want to use 64-bit file offsets everywhere, set _FILE_OFFSET_BITS=64 when you compile, and then use off_t and the normal functions (e.g., open() instead of open64()). Use fseeko() and ftello() instead of fseek() and ftell().
  • If you need to use both 32- and 64-bit file offsets in a program, set _FILE_OFFSET_BITS=32 and define _LARGEFILE64_SOURCE when you compile, and then use the large-file support functions when you need to use 64-bit offsets.
  • If you're porting source that uses the large-file support functions, define _LARGEFILE64_SOURCE when you compile.

In header files and code, don't refer directly to _FILE_OFFSET_BITS or _LARGEFILE64_SOURCE; use __OFF_BITS__ and __EXT_LF64SRC instead.

There's a new _NTO_CHF_PRIVATE flag that you can use to mark the channel as being private. If another process calls ConnectAttach() to attach to your process's private channel, that call fails with an error code of EPERM. (Ref# 76018, 78892)
EALREADY is now defined as EALREADY_NEW, so that EALREADY and EBUSY have different values, as specified by POSIX. For more information, see Changes to EALREADY in the entry for errno in the C Library Reference.
This structure (defined in <fs/etfs.h>) is now larger; its size has increased by the size of an int.
As a convenience, you can specify a rcvid of 0 to target the event at the active thread. (Ref# 76137, 77519, J169706)
This function now supports the following flags:
  • UNMAP_CLEAN — clean the memory region when the unmapping is done, if possible.
  • UNMAP_NOCLEAN — don't clean the memory on unmapping, even if clean-on-unmapping is the default behavior.

These flags override the default behavior specified by the -mc or -m~c option to procnto. (Ref# 77509, 77351, J169691)

shm_ctl(), shm_ctl_special()
These functions now set errno to more explanatory values. For more information, see their entries in the C Library Reference. (Ref# 26440, J166020, J170273)
New: The location in the pathname space where shared objects appear has changed:
name Pathname space entry
entry /dev/shmem/CWD/entry
/entry /dev/shmem/entry

where CWD is the current working directory for the program at the point that it calls shm_open(). (Ref# 81464, J382570, J1555271)

  • On ARMv7 targets, the _NTO_TCTL_ALIGN_FAULT command is now ignored; you can no longer control the alignment-fault behavior on a per-thread basis on these targets. You can set the global behavior by using the -ad or -ae option to procnto*. (Ref# 77775, 77873, J169734)
  • On ARMv7 targets, the _NTO_TCTL_IO command no longer puts threads into system (privileged) execution mode. Drivers that need to run in this mode can use the new _NTO_TCTL_IO_PRIV command instead. These changes have been done so as to maintain binary compatibility with old drivers.

See also the What's New appendix in the QNX Neutrino C Library Reference.

What's new: Drivers

Audio device drivers (deva-*)

Sound driver for the VIA 8233 Audio controller

New: The QNX Sound Architecture now supports a maximum of 64 software subchannels for PCM devices.

Character drivers (devc-*)

Driver for USB-to-serial adaptors

Network drivers (devn-*, devnp-*)

The new drivers include:

Driver for the SMSC9500 USB Ethernet dongle
Driver for the ASIX AX88172, AX88172A, AX88178, AX88772, AX88772A, AX88772B USB Ethernet dongle; replaces devn-asix.so and devnp-axe.so
Driver for the CDC ECM/RMNET USB Ethernet control module
Driver for Intel 10 Gigabit Ethernet controllers
Driver for Intel 82557, 82558, and 82559 Fast Ethernet LAN adapters; replaces devn-speedo.so
Class Driver for USBDNET (USB Device Network Driver)

You must now link io-pkt-* drivers against libnetdrvr instead of libdrvr. (Ref# 328930, J352515)

USB drivers (devu-*)

Function driver for USB MASS storage devices
Driver for Extensible Host Controller Interface (XHCI) for USB 2.0. The devu-xhci.so stack doesn't currently support super speed.

What's new: I/O devices

In order to reduce the size of io-blk.so, we've moved the character sets for Japanese, traditional Chinese, and standard Chinese (code pages 932, 936, and 950) into a separate library called charset.so, which io-blk.so loads only if needs to mount a FAT volume, CD, or DVD that's formatted in one of these locales. If your system doesn't need these character sets, you can omit charset.so from your OS image.

What's new: Security

  • The pppoectl utility no longer runs as setuid root. (Ref# 275244, J475184)

What's new in the QNX Momentics tool suite?

The QNX Momentics Tool Suite 6.6 includes the following versions of the compiler and tools:

  • GCC 4.7 tool chain, including support for the Intel Advanced Vector Extensions (AVX)
  • GDB 7.5
  • New: Binutils 2.24
  • Python 2.7.5, as a host-side tool

For details about what's new in GCC 4.7, see:

Here are a few more tips, based on our experience:

  • GCC 4.7 brought in the use of more unaligned data accesses, which might mean that code still builds, but later faults due to assumptions about data alignment (bugs in their own right that are now just exposed).
  • It's also started using thumb instructions, which have a slightly different ABI when calling functions made with thumb. This is almost always transparent to application coders, but can be a problem if you're doing things such as startup or low-level code. The biggest issue is that thumb mode requires that the bottom bit of the PC register be set to indicate to the CPU that you're in thumb mode. In some cases, if you're doing things with function pointers, you have to be aware that you may need to set the bottom bit if the function you're calling is thumb-compiled.
  • We have PIE support, which could impact the ability to build code if it's enabled. When writing shared libraries, you generally want your code to be PIC, and a common problem is inline assembly not being written properly (e.g. making absolute address references to locations). In your main binary, that's never really an issue since it's always loaded in the same spot, but with a PIE binary, now it's like a shared library. Assumptions about where the binary is loaded, what's above or below, and so on are all invalid.
  • There are a few more warnings being brought up because the compiler is now more aggressive in checking (what used to be a things should work warning might now be considered highly likely to be incorrect). If you ask the compiler to error-out on warnings, some existing code might no longer compile.
  • New: We've changed <math.h> so that the gcc compiler math builtins may be used by default.

For information about other changes, see the following sections:

What's new: Compiler, tools, and utilities

There's a new -t option that you can use to specify the maximum number of worker threads. The default is 4. (Ref# 77417, 78036, J169746)
  • New: If you're logged in as root, ls no longer behaves by default as if you had specified the -a option.
  • If you run ls -l on a setgid file that isn't executable, the permissions now include an S instead of an L, in accordance with POSIX. (Ref# 103631, J381132)
mkefs, mketfs, mkifs
  • New: When you use mkefs, you must use the num_blocks attribute to specify the number of blocks in the flash device; you can now also use it to specify the minimum number of blocks to include in the image file:

    If you specify num_pad, then the image file is padded out to that number of blocks; otherwise the image file is padded to num_blocks blocks.

    To keep the image as small as possible (for faster programming of the NAND part), set num_blocks to the appropriate number and set num_pad to 0. Doing this will correctly set the size of the .counts file, so that wear-levelling will be done.

  • You can no longer specify a type=link attribute and specify only one path. (Ref# J587290)
  • These utilities now support arbitrarily long input lines. (Ref# 200543, J400635)
New: QNX SDP 6.6 includes version 1.0.1c of OpenSSL. The heartbeat option is disabled, so the Heartbleed Bug doesn't apply.
QCC, qcc
There's a new -save-temps option which saves intermediate files created during compilation. (Ref# 54630, 77819, J143234, J381127)
New: Your target system now needs to include libtracelog.so and libsocket.so.
New: If you run rm -f without specifying any paths, the utility now exits with a status of 0 and doesn't complain about the lack of arguments. This is in keeping with other implementations of rm and has been adopted by POSIX.
New options:
  • -m — use CLOCK_MONOTONIC instead of the default CLOCK_REALTIME as the clock source.
  • -u event_id — generate a user-string trace event, with the given event ID, for all messages received.
(Ref# 77106, 77332, J169690)

See also the What's New appendix in the Utilities Reference.

What's new: Integrated Development Environment

The QNX Momentics Tool Suite 6.6 includes version 5.0.1 of the IDE, which includes the following new features:

  • Eclipse 4.2.1
  • C Development Tools 8.2.0

The website for updates and maintenance releases — which you access via Help > Check for Updates in the IDE — is https://www.qnx.com/account/updates/ide/4.7/.

This version of the IDE includes the following fixes and new features:

  • The About dialog now displays license information. Choose Help > About QNX Momentics IDE, click Installation Details, go to the Configuration tab, and look for License Information in the information given. (Ref# 98011, J467224)
  • Managed Make C++ projects that are compiled as C++ GNU with exceptions no longer fail to run. (Ref# 259430, J400928)
  • New: The text at top of the System Profiler's Summary page is now displayed correctly. (Ref# 45814, J329116)
  • On Ubuntu 12.04.2 64-bit, the IDE now prompts you for the SVN Kit plugin after you've installed the Subversive SVN Team Provider and rebooted. (Ref# J438377)

For more information about changes to the IDE, see the What's New in the IDE appendix of the IDE User's Guide.

Debugging information for shipped binaries

We generate the QNX SDP binaries with debugging information (-g) and map files. With few exceptions, all binaries are available with debugging information, but this data as well as the .ident information are stripped and stored in a separate binaryName.sym file. These files are linked together, so gdb understands where to find the symbol data.

There's now no need for a separate debug version of all the binaries. There's a separate tar file containing all the .sym files that will be untarred alongside each binary. This file is available in the Download area of our website, as well as in the debugging_info directory on the QNX SDP DVD.

What it means to you:

  • The target binaries are now stripped.
  • The target binaries don't have any SRCVERSION information in them (i.e. use -s won't work).
  • All QNX Neutrino binaries are built with -g.
  • We now produce linker map files for all QNX Neutrino binaries.
  • The full debug symbols for a binary called some_binary (along with the SRCVERSION information) are stored in a file called some_binary-buildid.sym.
  • The binary and its associated symbol file are linked so gdb knows how to find the symbols.

These *-buildid.sym files are in CPU-specific tar files. The usage of these tar files is straightforward. Suppose you want to debug the ls command for x86. You could just add the entire set of debug files to your target (you need to be root, of course):

  1. Get the target-x86-debug-date.tgz file.
  2. cd $QNX_TARGET
  3. tar -zxf path/target-x86-debug-date.tgz

Then ntox86-gdb $QNX_TARGET/bin/ls would load the debugging symbols from the .sym file automatically. Since this is the full debugging information, you can point gdb at the location of source for ls.

You don't have to extract the entire tar file. In fact all that matters is that the .sym file be in the same directory as the binary. So you could simply copy $QNX_TARGET/x86/bin/ls and the x86/bin/ls-*.sym file (from the debug tar file) to your current directory, and then run gdb there.

In order to get a list of the source files used to build a binary (e.g. to determine the associated licensing), use the .sym file instead of the binary. So continuing with the example above, to get a list of the source files used in building ls, type:

use -s $QNX_TARGET/x86/bin/ls-*.sym

Discontinued items

We no longer support the following:

  • ARM9, ARM11, MIPS, PowerPC, or SH4 targets
  • asynchronous messaging (i.e., the asyncmsg_*() functions)
  • the Photon microGUI, including PhAB, Phindows, and QNX Neutrino Advanced Graphics—replaced by the Screen Graphics Subsystem
  • QNX Aviage Multimedia Suite
  • New: the Dinkum C++ and Embedded C++ libraries—replaced by the Dinkum C++11 library
  • New: libxml.a—replaced by libxml2; see http://xmlsoft.org/.
  • cvs
  • devn-asix.so — replaced by devnp-asix.so
  • devn-speedo.so — replaced by devnp-speedo.so
  • devnp-ath.so
  • devnp-axe.so — replaced by devnp-asix.so
  • devnp-bcm43xx.so
  • devnp-ral.so
  • devnp-rum.so
  • devnp-ural.so
  • dhcprelay — replaced by dhcrelay
  • diff3
  • diskboot
  • enum-devices
  • enum-usb — replaced by usblauncher (see the Device Publishers Developer's Guide)
  • finstall
  • New: fs-cd.so — use fs-udf.so instead.
  • New: libmalloc and libmalloc_g — replaced by librcheck
  • mksbp
  • patch
  • qbinaudit
  • qde — replaced by run-qde
  • qed
  • QWinCfgrun-qde sets up the development environment before starting the IDE
  • setupbsp
  • SNMP:
    • /etc/acl.conf
    • /etc/context.conf
    • /etc/mib.txt
    • mstrip
    • /etc/party.conf
    • smic
    • snmpbulkwalk
    • /etc/snmpd.conf
    • snmpd
    • snmpgetnext
    • snmpget
    • snmpnetstat
    • snmpset
    • snmpstatus
    • snmptest
    • snmptranslate
    • snmptrapd
    • snmptrap
    • snmpwalk
    • /etc/view.conf

    Use a third-party solution instead.

  • svn
  • sysinfo
  • who

We no longer ship a self-hosted version of QNX SDP (that is, you can no longer use the QNX Neutrino RTOS itself to develop programs). We also no longer ship a bootable x86 CD.

Deprecation notices

We've deprecated the following and will remove them in a future release:

  • New: fs-qnx4.so and related utilities: chkfsys, dcheck, dinit, and zap
  • New: dprepresize, dresize
  • New: fs-rcfs.so, mkrcfs, mkrcfsimg
  • New: System Information Logging in the IDE
  • New: support for Intel 486 systems
  • Support for Mudflap has been removed in the upstream FSF gcc, and therefore future releases of the QNX Neutrino version of gcc won't support it either.

Known issues

QNX SDP 6.6 contains known issues in the following areas:

Known issues: Installing and uninstalling

  • On Linux, if you installed an earlier version of the QNX Software Development Platform and you used the same QNX_CONFIGURATION directory when you installed QNX SDP 6.6, if you then uninstall the earlier version, its uninstaller removes that directory, including the licenses, licensing binaries, and so on. (Ref# 264895, J393519)

    Workaround: Don't uninstall the earlier version while QNX SDP 6.6 is still installed, or back up the directory identified by QNX_CONFIGURATION, uninstall the earlier QNX SDP, and then restore the directory.

  • If you install QNX SDP 6.6 on some Linux systems and you already have more than one version of QNX SDP installed, your PATH environment variable might contain the value of $QNX_HOST/usr/bin for an earlier version of QNX SDP. (Ref# 70745)

    Workaround: Manually update your PATH, so that it contains only the 6.6 version of $QNX_HOST/usr/bin.

  • In order to run the installer and the IDE on Ubuntu 64-bit, you need to install the 32-bit libraries:
    sudo apt-get install ia32-libs

    Answer yes to all the questions. (Ref# 70567)

  • In order to install QNX SDP on Linux or Windows, the QNX license file must be writable by everyone. If the installer stops and warns you that this file isn't writable, you can make it so as follows:
    • On Windows, right-click on C:\Program Files\QNX Software Systems\license and choose Properties. Make sure that the Read-only attribute isn't checked, click Apply, and then click OK.
    • On Linux, type the following:
      chmod a+rw /etc/.qnx/license/licenses

    (Ref# 62419)

  • On some Linux distributions, the installer incorrectly displays accented e characters as a square box in the French text of the Language section of the license agreements. (Ref# 61721)

    Workaround: To display the text correctly, open a web browser and view the license agreement .txt files located in base_dir/install/qnx-sdp/6.6, where base_dir is where you installed QNX SDP.

  • If you've installed both QNX Momentics 6.3.2 and QNX SDP 6.6 on Linux or Windows, and you then uninstall 6.3.2, the value of the QNX_CONFIGURATION environment variable will be incorrect, and you won't be able to use 6.6. (Ref# 58784)

    Workaround: Remove the extra qconfig string from the value of QNX_CONFIGURATION.

Known issues: Kernel

  • New: User-specified band configurations in the standard memory allocator may corrupt your application's memory, and may cause the application to crash. (Ref# 77776, J169726, 77811, J169727)

    Workaround: If you specify the band configuration, make sure that the bands are 4080 bytes or smaller, and that all band sizes are multiples of 8 bytes.

  • New: If you attach multiple handlers to the same interrupt source, the newest handler is supposed to be added to the front of the list, but it's currently added to the end of the list. (Ref# J645515)
  • If there's a continuously-running, regular, high-frequency hardware interrupt, it's possible for a kernel call to be continually interrupted and restarted. The precise definitions of continuously-running and high-frequency are application-specific, but any regular interrupt with an interval less than the clock interrupt interval, that persists for an extended period should be carefully analysed to ensure that it doesn't affect the operation of the application. One case where this continual restart can occur is when very large (e.g., 100 MB) messages are passed on slow processors. (Ref# 56741, 62212, 75921, J167989, J168503, J169537)
  • A priority inversion can occur as a result of creating a thread; the procnto thread tasked with allocating the stack can become blocked on a condvar that's waiting for a lower-priority (e.g. fs-nfs3) operation to finish. (Ref# 47811, 71196, 74700, J382440; Ticket ID 47811; Case# 00100888)
  • Some single-threaded resource managers (such as io-pkt and QDB) may become WAITPAGE-deadlocked if the system uses lazy page faulting.

    For example, the problem could occur when io-pkt replies to a client and becomes WAITPAGE-blocked because the client's memory isn't faulted in. The procnto thread that's dispatched to handle it then gets blocked waiting on the address space lock of the client process, which is currently owned by a procnto thread that was already trying to satisfy a page fault request that involved talking to NFS, which can't finish because io-pkt is blocked waiting for the lock to be released. (Ref# 62483, J382313)

    Workaround: Disable lazy page faulting by specifying the -mL option to procnto.

  • If you create a shared memory object, mmap() it with MAP_SHARED, create a synchronization object (e.g. a mutex) in it, and then mmap() with MAP_PRIVATE to the same offset in the shared object, then the application and some some programs such as pidin and shutdown may hang. (Ref# 63369, J168610)
  • Some calls to mmap() with MAP_ANON or MAP_LAZY may be slower with QNX Neutrino 6.6 than with earlier releases on certain platforms. The difference is more pronounced for small sizes (e.g. 4 KB). For larger sizes (more than 32 KB), performance may be the same or better with 6.6. It might take longer to start applications and create threads. In part, this is due to the virtual memory manager's more complete data structures. (Ref# 27831, J166330, 29341, J166681)
  • If you're in a directory on a remote machine, and you pipe the output of a command to xargs, and you redirect the output to a file, you get a cannot fork error. For example:
    cd /net/remote_machine/tmp
    find . -type f | xargs grep FAIL > report.txt
    /bin/sh: cannot fork - try again

    It seems to be a problem with permissions. Piping the output of xargs to less works. (Ref# 29834, J166762)

    Workaround: Log in as root.

  • If you have multiple memory mappings to files that use the same underlying resource manager, and these mappings are first referenced simultaneously (e.g. the first reference in a program), there is the potential for a deadlock if the number of simultaneous first references exceeds the number of threads in the underlying resource manager. (Ref# 29440, 30045, 62483, J166702, J382313)
  • Some older versions of VMware may show signs of instability. For example, you might get kernel faults that don't occur on real machines or with VMware 6.5. You might also see messages such as The CPU has been disabled by the guest operating system. (Ref# 57058, J382252)
  • When you use fork() to create a child process, the kernel clones the floating point register context from the parent to the child, but it doesn't clone contexts other than the CPU or FPU register sets. This isn't likely to affect your programs. (Ref# 71327, J169169)
Some multiprocessor systems, such as the ARM Cortex-A9 MPCORE, have an interrupt controller on each processor, but QNX Neutrino currently assumes there's only one controller. Unmasking an interrupt on one processor may leave it masked on other processors. (Ref# 60301, J382285)

Workaround: Bind all threads that mask and unmask interrupts so that the threads run only on CPU 0.

New: The QNX Neutrino User's Guide should say that the limit on system RAM on x86 targets is 32 GB. (Ref# 1564595)

Known issues: Libraries and header files

New: It isn't safe to call atexit() from a shared object that's meant to be dynamically opened using dlopen().

If you call atexit() from such a shared object, your application may receive an abort() when you call dlclose(), and the handler registered with atexit() won't get called when the shared object is unloaded.

Under certain circumstances, the abort() won't happen when (for example) the shared object calls atexit() and passes a function that's defined in another object that doesn't get unloaded with a subsequent dlclose(). In this case, the handler isn't called until the application exits. (Ref# J521222)

brk(), sbrk()
New: These functions don't do anything useful under QNX Neutrino; don't use them. (Ref# J166490, J191638, J743268)
This library causes some problems on x86 targets if it's compiled with gcc 4 with optimization above -O0. To avoid these problems, we've compiled the DLL with -O0 optimization for x86. (Ref# 55883)
The SIOCDARP, SIOCGARP, and SIOCSARP commands aren't implemented, but the return code is ENXIO instead of ENOTSUP. (Ref# J1589096)
New: This function doesn't work properly with addresses that are greater than 4 GB. We plan to remove it from the library in a future release. (Ref# J1571467)
MsgKeyData(), MsgKeyData_r()
These kernel calls don't work properly over Qnet; if the client and server are on different nodes, the verification step fails, even if the data is correct. (Ref# J418418)
New: POSIX says that this function should return 0 or an error code, but it currently returns 0 or -1, setting errno if an error occurs. (Ref# J1279909)
New: This function isn't fully implemented. It currently doesn't do anything, but the return code still indicates success. (Ref# J701207)
The ProcessInfo_t structure includes a field called class, so you can't use this header in a C++ program because class is a C++ keyword. (Ref# J175563)
This function doesn't check the priority range when PTHREAD_EXPLICIT_SCHED is set. For example, if you use the on command while logged in as a non-root user, and you specify a priority greater than 64, on still executes the command but at the priority of the calling shell. It should give an error saying you don't have permission to create at that priority. (Ref# 28763, J166539)

Known issues: Filesystems

dprepresize, dresize
New: We recommend that you not use these (deprecated) utilities on a running filesystem.
On ARM platforms, you can't use an io-fs-media share to store a directory structure with more than 16 MB of data. (Ref# 56601)
If you send a SIGTERM or SIGKILL signal to a devb-* driver, chkfsys might subsequently find errors on the filesystem. (Ref# 48741, 48764, 48765, J167473, J167474, J167475)
If you try to delete a linked file or directory in a Linux Ext2 filesystem, you get a Corrupted file system detected error. (Ref# 50264)
  • New: The FS_CRYPTO_TYPE_CBC encryption type isn't currently supported. (Ref# J858354)
  • The io-blk manager lets you mount a filesystem in a file. To do this, you basically create a normal file on a disk, and then format it (via dinit, mkqnx6fs, mkdosfs, etc.), as a filesystem. You can then run a command, such as:
    mount -tqnx4 /home/myfs.img /fs/test

    and you'll get a mountpoint called /fs/test, which is the size of the file and is formatted as a QNX 4 filesystem.

    If you used fs-qnx6.so as the real filesystem on the hardware, and then created a QNX 4 or DOS filesystem inside a file residing on the Power-Safe filesystem, the host filesystem formerly could become damaged by the modifications to the hosted filesystem. We've fixed that, but the host filesystem might not be able to confer full power-loss safety to the (by design) not power-loss-safe QNX 4 or DOS filesystem. (Ref# 74580, J169426)

New: This manager was inadvertently omitted from QNX SDP 6.6, but you can get it from Technical Support. For more information, see Filesystem events, below. (Ref# J779229)

Known issues: Startup

  • If you load an uncompressed OS image that's larger than 3 MB on an x86 target, some binaries (e.g. ftp) may crash. (Ref# 45838, J346829)

    Workaround: Specify this attribute in the mkifs buildfile:


Known issues: Adaptive partitioning

  • Overload detection isn't implemented.
  • SCHED_RR threads might not round robin in partitions whose portion of the averaging window is smaller then one timeslice. For example, when the timeslice is 4 ms (the default) and the adaptive partitioning scheduler's window size is 100 ms (the default), then SCHED_RR threads in a 4% partition may not round-robin correctly. (Ref# 28035, J166387)
  • If you use adaptive partitioning and bound multiprocessing (BMP), some combinations of budgets might not be met. (Ref# 29408, J166694)
  • Threads in a zero-budget partition should run only when all other nonzero-budget partitions are idle. However, on SMP machines, zero-budget partitions may incorrectly run when some other partitions are demanding time. However, at all times, all partitions' minimum budgets are still guaranteed, and zero-budget partitions will not run if all nonzero-budget partitions are ready to run. (Ref# 29434, J166701)
  • On ARM targets, the 10 window and 100 window averages, as reported by the aps show -v command, are sometimes garbled. However, these have no effect on scheduling. (Ref# 27552, J166243)

Known issues: Booting

  • If you install QNX Neutrino on a system that uses the Intel Express Q35 chipset, the OS won't boot. The ITE EIDE interface on this board isn't supported. (Ref# 61188)

    Workaround: Run the driver in PIO mode.

  • Fujitsu Coral cards don't support text mode, so on x86 systems, you need two video cards: one to use in text mode, and one for the Coral card.
  • Some Sony VAIO laptops don't assign an interrupt to a USB device; when you're booting QNX Neutrino, you'll see some InterruptAttachEvent failed messages. (Ref# 41237)

    Workaround: Contact Technical Support to get a customized utility that enables the interrupts.

  • On some Intel 3.2GHz D945G systems, the USB bus is reset by the host after rebooting, while the host is addressing the device. (Ref# 51935)

    Workaround: Disable legacy USB support in the BIOS.

  • The Dell Latitude D830 fails to boot QNX Neutrino 6.6 from USB mass-storage devices. (Ref# 61688, J348144)

Known issues: BSPs

Known issues: Compiler, tools, and utilities

  • New: Although you can install QNX SDP as a non-root user, on Linux you must run applypatch as root. On Red Hat 6.4, applypatch displays many errors but seems to install and uninstall patches correctly. (Ref# J681468)

    Workaround: Get the Applypatch Patch (Patch ID 4024) from the Download Center.

  • New: In order to run applypatch on Ubuntu 14.04, you need to install the 32-bit version of libssl 0.9.8 :
    sudo apt-get install libssl0.9.8:i386

    (Ref# J1267145)

New: If you use the -m option, you'll get an illegal option error. (Ref# J624167)
If you specify num_sectors=4m and sec_per_clus=64 (resulting in 65,528 clusters), you get a Fatal: Internal error: Failed to find appropriate FAT type error message. The FAT specs from Microsoft state:
NOTE: As is noted numerous times earlier, the world is full of FAT code that is wrong. There is a lot of FAT type code that is off by 1 or 2 or 8 or 10 or 16. For this reason, it is highly recommended that if you are formatting a FAT volume which has maximum compatibility with all existing FAT code, then you should avoid making volumes of any type that have close to 4,085 or 65,525 clusters. Stay at least 16 clusters on each side away from these cut-over cluster counts.

The mkfatfsimg utility shouldn't allow this cluster size at the given sector count, or at least issue a warning. (Ref# 616361)

New: The -f and -n options don't work if you specify the name of the local node. (Ref# J635472)
If the first page of a memory-mapped object is written to, pidin might display /dev/zero instead of the object's name. (Ref# 43050, J382175)
New:If your root account has a password, and you try to su to it from another user ID, you get this message:
*** stack smashing detected ***: su terminated
Abort (core dumped)
When a kernel call fails, the instrumentation records the errno value. However, if you use traceprinter on the .kev file in a cross-endian environment (e.g. the .kev file was generated on big-endian, and you're running traceprinter on little), the errno value that gets printed isn't swapped before being displayed. For example, an EFAULT is displayed as 0xe0000000 rather than 0xe. (Ref# 76429, J382506)
  • New: When usblauncher is configured to launch the USB stack, it doesn't log the -n name part of the command-line arguments when Host_Stack.path and/or Device_Stack.path is specified. (Ref# J601323)

    Workaround: Use pidin arg to confirm the command-line arguments to the stack started by usblauncher.

  • There's a small timing window where usblauncher could crash if you use either the port_power or toggle_port_power command at the same time as stopping the USB host stack with start_stack::none. (Ref# J616999)
  • The PPS device object created by usblauncher may incorrectly report the upstream port speed as Full, since the speed isn't known at the time the device object is published; it could change to High, but the PPS object isn't updated. (Ref# J601272)
  • New: If you specify both start and driver driver functions, and the driver function is specified after the start function, the start string is ignored and the driver is launched but not slain when the device is disconnected. The usblauncher only expects one function to be specified in a given rule, not multiple ones. (Ref# J600571)

    Workaround: Specify only the driver function, create a script that has the start rule contents in it, and then call exec at the end to launch the driver.

  • If you're using this utility to start the io-usb-dcd USB device stack, and you don't provide a value for Device_Stack.path, usblauncher crashes. (Ref# J615724)

    Workaround: Set the path to /dev/io-usb-dcd/io-usb, which is the default server path. For example:

    Device_Stack = {
     cmd = 'io-usb-dcd ...';
     path = '/dev/io-usb-dcd/io-usb';

Known issues: Device Publishers

  • New: The usblauncher section of the Device Publishers Developers Guide refers to Apples application for sending iPhone displays to an accessory system as iOS in the Car. Apple has recently renamed the application CarPlay.
  • New: The Description section of Command line for usblauncher states:
    You can prevent the launching of [the USB host stack] by using the -h option, if you plan to use your system as the USB device so it can service requests from third-party applications, such as iOS in the Car.

    Its incorrect to use the h option when you want to support iOS in the Car (or CarPlay) because you must first run the USB host stack (io-usb) to detect the iPhone and request that it switch USB stack modes. Only then can you run the USB device stack (io-usb-dcd) and use CarPlay. (Ref# J670190)

Known issues: Drivers

  • You might see a message such as Range check failed (MEM) - Dev 1b - Vend 168c - Class 20000 - Addr 0 - Size 10000 in the system log, but you can ignore it.

    The PCI server code allocates one byte low of PCI memory and one byte high of PCI memory and keeps these values as the range of low and high PCI memory. It does the same for I/O space. The server then scans all devices in PCI space and checks the I/O and memory ranges for each device against the stored range values to see whether they're valid or not. If a range check fails, the device is placed in the disabled state and is initialized when an application calls pci_attach_device(). The PCI server code is standard across all platforms and only the low-level, hardware specific portion changes, so there is a generic portion to all the drivers. (Ref# 50790)

  • We haven't fully tested the following drivers:
    • deva-ctrl-ess1938.so
    • deva-ctrl-geode.so
    • deva-ctrl-nmg6.so
    • deva-ctrl-sb.so
    • deva-ctrl-via8233.so
    • devc-serzscc
    • devh-touchintl.so
    • devn-el509.so
    • devn-pegasus.so
    • devn-rtl8150.so
    • devn-smc9000.so
    • devp-pccard

    (Ref# 61821)

Audio device drivers (deva-*)

  • The audio driver isn't initialized after you boot the target with QNX SDP 6.6 from the hard disk on a Kontron MicroETXexpress-PC module. (Ref# 74882, J350046)
  • Audio drivers included in BSPs that were released before QNX SDP 6.4.1 are incompatible with 6.4.1 and later. If you try to start them, you'll get some errors about unresolved symbols. If you have the source code, and you try to recompile it using gcc 4.2, you'll get some compile errors. (Ref# 59692)

    Workaround: Relink the driver binaries on QNX Neutrino 6.6. For updated source code, see Foundry 27 on our website, or contact Technical Support.

Block-oriented drivers (devb-*)

You can't restart this driver on IBM PPC405 boards. (Ref# 16018)
  • DMA modes don't work on these drives:
    • Hitachi-LG Data Storage DVD WRITABLE/CD-RW DRIVE, ROM VER.E111, May 2006
    • Toshiba Samsung Storage Technology TS-H352C/DELH, DE02, May 2006

    (Ref# 41600)

Human interface device drivers (devh-*)

  • Autorepeat doesn't currently work on ViewSonic 10191 USB keyboards. (Ref# 41118, J346419)
  • Pressing the space bar on a ViewSonic 10191 USB keyboard when the system displays the Press space bar to input boot options message doesn't work. You get the menu only after the EIDE enumeration is done.

    If you also have a Microsoft USB mouse connected, you get a devh-usb.so - Unable to attach to USB device 1 (10) message. (Ref# 41122)

Network drivers (devn-*, devnp-*)

New: When using the m_pkthdr_csum_data member in network driver code, make sure that you use only the bottom 16 bits. The top 16 bits may contain undefined data. (Ref# 44622, J473874)
devnp-asix.so, devnp-ecm.so, devnp-ecmplus.so, devnp-ncm.so
New: These drivers wait only one second before giving up when trying to connect to the USB host stack, not the documented 60 seconds. (Ref# J583790)

Workaround: Use the wait option to specify how many seconds to wait for.

The io-pkt driver for the Intel i82544 doesn't support dual-port cards (did=0x1010). (Ref# 44299, J473852)
New: This driver ignores the wait option, and might crash if you try to mount it when io-usb-dcd isn't running. (Ref# J631827)

USB drivers (devu-*)

  • The PCI-USBNEC101-5P-1 controller card won't allow at least the following boards to boot: SystemH, EDOSK7780, BCM1x80. (Ref# 29496)

Known issues: Flash filesystems & embedding

  • In previous versions of this software, a program that called umount() without the _MOUNT_FORCE flag would behave as if the flag was provided (i.e. the flash filesystem would be unconditionally unmounted regardless of any operations either pending or in progress on the filesystem).

    In this release, umount() sets errno to EBUSY if any pending or in-progress flash filesystem operations exist on the filesystem unless you specify _MOUNT_FORCE. The same applies for scripts that call the umount utility without the -f option. This has implications for applications that expect _MOUNT_FORCE behavior but don't specify it.

  • libfs-flash3 loses blocks with ftruncate(). (Ref# 25132)
  • If you create a 255-character filename using the 1.1.0 flash library (libfs-flash3) and the flash filesystem is subsequently mounted using an earlier version of libfs-flash3, the filename won't appear in the filesystem, but it is still present (i.e. if the filesystem is subsequently mounted again with the 1.1.0 libfs-flash3, the filename will reappear). This behavior applies only to forward compatibility whereby an older flash filesystem library is used to mount a newer filesystem. Backward compatibility (the ability of the new filesystem library to mount older filesystems) isn't affected.
  • During a power failure, the flash filesystem can be corrupted if the NOR device's power supply is in the indeterminate state. The solution is to design the hardware so that the NOR flash device enters RESET the moment the power supply drops below the proper operating range. (Ref# 24679)

Known issues: IDE

The IDE contains the issues listed below. See also the list of host-specific issues, later in these notes.

Known issues: General

  • New: Sometimes the IDE becomes unresponsive during indexing operations.

    Workaround: Restart the IDE.

  • New: Editing a file that's located (mapped) via PPS or other resource managers fails when done via the filesystem navigator. (Ref# J528053)

    Workaround: Edit the file on the device.

  • New: If you use Set Priority/Scheduling Algorithm in the Target Navigator to change a process's priority and scheduling algorithm, and then select this item again for the same process, the default settings might be displayed instead of the current ones, but if you press OK, the process's settings aren't changed back to the defaults. (Ref# J537153)
  • New: The New Editor item in the Window menu should be enabled only when you've selected an editor in your current perspective (so you can edit different parts of the same file), but sometimes it's enabled when it should be disabled, and vice versa. (Ref# J544678)
  • New: On Windows, if you create a project, select more than one build variant, and set up a run configuration, the IDE doesn't save the changes to the configuration. (Ref# J550247)

    Workaround: Build the project for only one target at a time.

  • The IDE no longer includes an Subversion plugin. You can install one such as Subversive or Subclipse.
  • New: The text in the IDE hover help is sometimes truncated or formatted incorrectly. (Ref# 259496, J393841)

    Workaround: Look up the function in the QNX Neutrino C Library Reference.

  • Shortcut keys don't work as expected in the IDE. Shortcut keys might not trigger the assigned functionality, new shortcut keys might not appear in the right-click menus, and conflicting key assignments might not be reported. (Ref# 255722, J393830)

    Workaround: Use the menu commands to perform operations in the IDE.

  • The sample projects are set up to compile only for x86 targets. (Ref# J438386)

    Workaround: Edit the project's Makefile and change:

            CFLAGS += -Vgcc_ntox86 -Wc,-Wall -p
            LDFLAGS += -Vgcc_ntox86 -p


            CFLAGS += -Vgcc_ntoarmv7le -Wc,-Wall -p
            LDFLAGS += -Vgcc_ntoarmv7le -p 
  • We pre-index our documentation, but the first time you search for anything in the IDE's Help system, it has to combine the indexes (and index any Eclipse documents that haven't been indexed). This should take less than a minute.
  • If you use Help > Search, links that go to the IDE User's Guide don't work. Links that go to other documents work. (Ref# 77552, J331149) Workaround: Use the search in Help > Contents.
  • You might see a message like this when you start the IDE:
      Subscription License Expired -
      Your QNX License could not be obtained, some QNX functionality will be

    This message appears only if QNX Software Systems has a contract with you to support server-based licenses. It indicates one of the following:

    • You need to configure your license server.
    • More users are trying to use the IDE at the same time than there are available licenses for.

    (Ref# 51688, J236666)

  • The Eclipse editor doesn't behave correctly on very long lines (more than 4500 characters). At the end of a long line, the cursor doesn't position itself properly between characters, selections and changes are very slow, and the column number is reported incorrectly. (Ref# 29586, 21053; Eclipse-CDT PR 68116)
  • Pressing F1 for context-sensitive help doesn't always give you much information. (Ref# 21034, J467095)
  • If the IDE can't open the browser to display the documentation, it may give you an error message of:
    An exception occurred while launching help. Refer to the log for more details.

    The problem could be that the IDE couldn't find your default browser. Check the web browser listed in your preferences (see Window > Preferences > General > Web browser) to make sure it's a browser that's installed on your system.

    If this doesn't fix the problem, check the log file; see Help > About QNX Momentics IDE > Configuration Details > View Error Log. If you've installed the Eclipse SDK, use the Error Log view. (Ref# 29971)

Known issues: Application Profiler perspective

  • New: If you attach to a running process for profiling, the IDE doesn't switch automatically to the Application Profiler perspective. (Ref# J534409)
  • New: If you go to Windows > Preferences > QNX > Application Profiler, select Sampling and Call Count Instrumentation in Profiling Method, and then press Restore Defaults, only the Profiling Method is restored to the defaults. (Ref# J548281)

    Workaround: After resetting, select Sampling and Call Count Instrumentation, and then select Function Instrumentation.

  • If you're using Sampling and Call Count Instrumentation, the Application Profiler checks the samples only for processor 0 on a multiprocessor system. (Ref# 77220, J393694)

    Workaround: If you're profiling an application on a multiprocessor system, bind all the threads so that they run on processor 0.

  • If you use Mudflap, disable it, and then enable application profiling, the output might still go to mudflap.output. (Ref# 67197, J393652)

    Workaround: When you disable Mudflap and enable Application Profiling in the Launch configuration, click Apply, then Close, and then run the application.

  • The Application Profiler can allocate CPU time to the wrong line if you're profiling code that has profiling and debugging information, and if you linked against a static library that doesn't have profiling and debugging information. (Ref# 21024)

    Workaround: Build everything with debugging information, or use -gdwarf-2 instead of -gstabs.

Known issues: System Profiler perspective

  • New: The System Profiler doesn't display slog2-formatted events as slog2info. (Ref# J1327440)

    Workaround: Use slog2info to correlate.

  • You can select some tabs in the System Profiler perspective only by clicking on the header, not the graph. (Ref# J550256)
  • Using the default KEV log configuration results in a log that contains Running events that don't include scheduling/priority information. By default, the type of Running events is set to Wide, but the resulting kev file doesn't reflect this setting. (Ref# J393921)

    Workaround: Select Event Specific on the Event Filters tab, then select the Process and Thread event tab. Select Running Wide (even if it already claims to be selected). Apply and then capture a log file. The resulting kev file should now include priority information.

  • The System Profiler > Display > Switch Pane item is initially inactive (greyed out) when you execute the SystemProfilerMissedDeadlines example's Timeline step. Once the Timeline is activated from the icon, the item is activated, and you can select items. (Ref# J438387)
  • The System Profiler requires a minimum color depth of 16 bits; otherwise, the timelines might appear to be blank. (Ref# 23763)
  • The System Profiler can take a very long time to load and parse a .kev generated by a target system that's running Neutrino 6.3.0 SP1. The parsing is much faster for .kev files from a system with a later version of QNX Neutrino. (Ref# 27221)

Known issues: Memory Analysis perspective

  • New: If you click on a memory problem and select Show backtrace, the Memory Backtrace tab doesn't display the file with the source code. (Ref# J443141)

    Workaround: Double-click on the error in the Memory Problems tab.

  • New: You can't successfully remove Memory Analysis sessions. (Ref# J460020)

    Workaround: Exit the IDE and restart it.

  • New: In the Memory Information view, Copy to Clipboard doesn't work if the Categorize option is turned off. (Ref# J485578)
  • New: In the Advanced Settings part of Run Configuration > Tools > Memory Analysis on Windows, the default path name might start with a backslash. (Ref# J500345)

    Workaround: Change the leading backslash to a forward slash.

  • New: If you enable Enable check on realloc()/free() arguments in the Memory Errors part of Window > Preference > QNX > Memory Analysis, click Apply, close the window and then open it again, this setting is no longer enabled. (Ref# J510803)

    Workaround: You can change this setting in the Run Configuration window's Memory analysis tool, under Memory errors.

  • The tool for detecting leaks doesn't detect any leaks while a program is running, although it does when the process exits. (Ref# J615803)

    Workaround: Go to the Tools tab in the launch configuration, select Memory Analysis, expand the Advanced Settings, and then turn on Create control thread. Add the environment variable MALLOC_CTHREAD = 1 in the Environment tab.

    Note: Turn on Create control thread only if you're trying to detect leaks, because the control thread isn't compatible with some other features.

  • If you make the period for performing memory snapshots too short, the Memory Analysis view might not show all the allocations and deallocations. (Ref# 577315)

    Workaround: Do the following:

    1. Run the program normally with IDE Run with MAT configuration.
    2. Use the IDE's target filesystem navigator to copy the /tmp/traces.rmat file from the target to the IDE workspace.
    3. In the IDE's Memory Analysis perspective, select File > Import > QNX > Memory Analysis Data to run the import wizard and import the traces.rmat file to a new MAT session.
  • If you use the Memory Analysis tool with the control thread enabled, no information will be returned for bins, bands, or usage. (Ref# 252156, J393820)

    Workaround: Disable the control thread.

  • When you request the termination of the Memory Analysis service, it might take longer than expected. (Ref# 46228)
  • In the Memory Analysis perspective, if a function causes a buffer overflow, memory leaks aren't detected correctly. (Ref# 42312)
  • You might see some allocations take place before your application's main() function starts. This is normal; some of the system libraries allocate space as they're initialized. (Ref# 29698)
  • If a process isn't running as root on the target machine, the Attach mode will not function properly. (Ref# 44762, J328853)

    Workaround: Run the process as the root. If the process is launched using qconn, then qconn should be run as root.

  • The Memory Analysis Tool changes the behavior of a program that uses fork. (Ref# 29032)

    Workaround: If your program uses fork, you must disable the control thread of the Memory Analysis Tool (from the Launch Configuration, select Memory Analysis > Target Settings and disable Create control thread).

    In addition, it is not possible to attach to this type of process because the Memory Analysis Tool needs to run a control thread.

Known issues: System Information perspective

  • New: If you have a lot of projects in your workspace, the Target File System Navigator correctly displays the directories on your target, but might not list all the files contained in the directories. The table doesn't even display the column headings. (Ref# 729298)

    Workaround: Click on the downward-pointing triangle icon to open the view menu, select Table Parameters, and then click OK.

  • New: If you add or remove columns in the Thread Details pane, you get an extra Process column in the table. (Ref# J484552)
  • In the Target file system navigator, if you open a telnet session to a target and mount a new filesystem:
    devf-ram s0,4m
    flashctl p /dev/fs0p0 e f m

    then click on the target name in the Catalogs tree, the new filesystem is displayed in the table, but not in the tree. If you then click the plus sign near the target name to collapse the tree, and then click it again to expand the list, the mounted filesystem isn't displayed in the catalogs tree. (Ref# J564078)

    Workaround: Right-click on the target and then select Refresh.

  • If you add a target while the System Resources view is open, you'll get a java.lang.NullPointerException error. (Ref# J611982)

    Workaround: Make sure that this view is closed before you add a target.

  • Setting the refresh interval to a large number (for example, 999999999) causes the information in the System Summary view to refresh constantly. (Ref# 252137, J393819)

    Workaround: Choose a smaller amount of time (tens of seconds) for the refresh interval.

Known issues: System Builder perspective

  • New: The IDE fails to open an EFS buildfile in the editor. (Ref# J863805)

    Workaround: Edit the buildfile by hand (select Open With... and then select Text editor).

  • New: If you create a new QNX Image Build File for a project, select a template, create a new build file again with the same name, and choose a different template, you'll get a null-pointer exception. (Ref# J541393)
  • New: If you close a System Builder project, it disappears from the System Builder Projects view. (Ref# J542569)

    Workaround: Reopen it in the Navigator view.

  • New: Due to known issues with System Builder, we recommend you use the mktar utility to build your software images. (Ref# 257415, J393834)
  • On Linux, after you import and build a BSP in the System Builder, the files in the prebuilt directory lose their executable bit. (Ref# 252984, J393824)

    Workaround: Change the permissions to add the executable bit before you add the files to the IFS image.

  • In the System Builder, having the same binary and directory name in the overrides can result in an incorrect path for the binary. (Ref# 40287)

Known issues: C/C++ development

  • New: The IDE fails to correctly parse makefiles that repeatedly use same macro (such as appending to CCFLAGS with different values), specifically when one of the values has a complex structure (such as quotes and escaped spaces). When this occurs, the IDE corrupts the common.mk file. (Ref# J817499)

    Workaround: Edit the makefile by hand.

  • New: If the C/C++ Indexer has highlighted a line of source code as having a syntax error, and you're using the default settings of Text as: squiggly line, then no other hover help is available for any of the highlighted lines. This may include multiple lines of source code, as the Indexer may incorrectly identify subsequent lines as also having syntax errors. (Ref# J331101)
  • If you create a sample project (File > New > Example), open the project properties, set the target CPU to ARM v7 - Little Endian, and then build the project, the IDE still builds the x86 binaries. (Ref# J589617)

    Workaround: Manually change the Makefile.

  • If you create a C/C++ managed project, edit its properties, and press Restore Default, the project will be built as a shared library instead of an executable. (Ref# J579384)
  • If you start a new IDE session with a new workspace, go to the C/C++ Projects perspective, add a target navigator, and then add a valid target, the target is shown as available and its name is as expected, but you don't get the expansion button to display the list of processes on the target. (Ref# J572145)

    Workaround: Click in another view, or switch to another perspective. When you return to the target navigator, the expansion button appears.

  • If you open several targets in the System Information perspective's target navigator, go to the C/C++ perspective's Project Explorer, and then restart the IDE, the first target is marked as disconnected. (Ref# 571724)

    Workaround: Press the refresh button, or switch to the System Information perspective.

  • If the Makefile for a regular C++ make project uses implicit rules such as the following:
    all : cc2
    cc2 : cc2.o
    cc2.o : cc2.cpp

    then the link stage doesn't work properly. (Ref# 62006)

    Workaround: To avoid this, use an explicit rule for linking:

    cc2 : cc2.o
            $(CXX) -o cc2 cc2.o -lang-c++
  • The IDE sometimes ignores an explicit build request for a project, such as those invoked by using the Build Project entry in the C/C++ Project view's right-click menu, if the project uses an externally built library. (Ref# 20966)

    Workaround: Use an explicit target in the make command.

Known issues: Debugging

  • New: Occasionally when you're debugging, the IDE doesn't show the backtrace correctly. It shows only one frame, and the rest of the frames are either not shown at all, or appear to be empty. When this happens, the warning Cannot access address XXX also appears on the gdb console. (Ref# J745518)

    Workaround: In the gdb console, type bt to see the backtrace.

  • New: C/C++ Developer (CDT) Postmortem debugging is enabled, but doesn't work. (Ref# J335470)

    Workaround: Use the QNX postmortem debugger instead.

  • New: If you use CDI debugging, there might be blank lines in the Modules View. (Ref# J500360)

    Workaround: Use the DSF framework instead of the deprecated CDI framework.

  • New: If you right-click on a core file and choose Debug, the IDE creates a qconn Debug Launch configuration, but it should create one for postmortem debugging. (Ref# J527718)
  • New: If you select the CDI debugging framework, the IDE doesn't display the properties of loaded shared libraries. (Ref# J518298)

    Workaround: Use the DSF framework instead of the deprecated CDI framework.

  • When you're debugging applications built for ARM, don't use watchpoints. Although the IDE lets you create a watchpoint, it won't work correctly and could cause instability with your debugging session. (Ref# J463656)
  • New: The Modules view might not show the most recent state of your loaded libraries during debugging. (Ref# J393844)

    Workaround: To force it to update to the latest state, refresh the view by using File > Refresh.

  • The Add Global Variables button in the Variables view isn't functional. (Ref# 259784, J393847)

    Workaround: Add global variables using the Expressions View.

  • The Modules view doesn't show information for the executable being debugged. (Ref# 259524, J393842)
  • Disconnecting from an executable while it is being debugged will cause it to terminate. (Ref# 259773, J393846)

    Workaround: Select Window > Preferences > C/C++ > Debug > GDB. Under Termination, clear the checkbox labeled Terminate GDB when last process exits.

  • To debug core files, use the C/C++ QNX Postmortem Debugging option in the launch configuration dialog of the QNX Momentics IDE. This option isn't currently mentioned in the IDE documentation. (Ref# 250509, J393818)
  • Watch points aren't supported for ARM. (Ref# 12136, 259564, J545820)
  • New: If you use the DSF framework, the console output loses focus and is cleared with every new message that's displayed. (Ref# J438391)

    Workaround: What's really happening is that there are four consoles associated with a debug session. The console that displays the printf() output is displayed, and then an empty console is displayed after every step (even if no output is visibly generated), making it seem that you've lost the output of your program. To fix this, pin the correct console (the one whose name includes the process ID).

  • Filtering breakpoints on multiple threads doesn't work as expected. For example, if there are five threads, and you filter to break on only odd threads, no breakpoint is hit. If you filter only on thread 2, it seems to break reliably. Various mutations of the five threads seem to be linked to thread 2's being one of the threads filtered, but not in all permutations. (Ref# 263994, J393857)
  • Disconnecting from an executable in a debug session causes the executable to terminated. (Ref# J393846)
  • Breakpoints set in .gdbinit don't show up in the user interface. (Ref# 55810, J393602)

Known issues: Code Coverage perspective

  • Qconn periodically sends a signal (SIGUSR2 by default) to the application being run with Code Coverage. When you build a program with Code Coverage enabled, some extra code is linked into it that (amongst other things) adds a handler for this signal; this handler passes dynamic coverage data to qconn as the program runs. The ramifications of this are:
    • If your program masks this signal, the Code Coverage tool can't provide dynamic coverage data.
    • Your program will be receiving signals that you might not be expecting. For example, if your program is blocked on a MsgReceive() call, and the code coverage signal is received, MsgReceive() would return -1, and errno would be set to EINTR, indicating that the function was interrupted by a signal. If this happens, you should execute the MsgReceive() call again. In general, your code should be defensive against this type of situation, but in this case, it's a requirement.

    (Ref# J430304)

  • The Code Coverage perspective gets stuck on Calculating coverage... and never displays the code-coverage information. (Ref# J470814)
  • The Code Coverage perspective doesn't show code coverage for C++ shared libraries. In addition, executables being examined with the Code Coverage tool might crash. (Ref# 259211, J393839)

Known issues: I/O devices

  • In some cases when unmounting DLLs and running the usb utility at the same time, some memory allocated by io-usb isn't freed. This is a rare situation. (Ref# 21716)
  • The io-usb server crashes if you repeatedly mount and umount and plug and unplug devices attached to the port. (Ref# 21556, J344839; Ticket ID 77965)
  • io-usb might crash with a SIGSEGV when you shut down the system and you don't have any USB devices inserted. (Ref# 29495, J345914)

Known issues: Networking

The commands:
ifconfig iface_name up
ifconfig iface_name scan

don't work individually for Wi-Fi drivers. (Ref# 61246, J393284)

Workaround: Combine the commands:

ifconfig iface_name up scan

  • Qnet might append the domain name to entries under /net, even for nodes in the same domain. (Ref# 75539, J474806)

    Workaround: Use the setconf _CS_DOMAIN command to change the domain name to something else, and then change it back to its original value.

  • The only supported bind= options for Qnet are bind=ethernet_interface and bind=ip. Other values for bind=X are still accepted (that is, no error is given), but Qnet may not work with them if the specified ethernet_interface doesn't appear. (Ref# 58234, J474325)
  • Qnet currently expects all packets to be received and sent as a single contiguous buffer. This can be a problem if you're using jumbo packets. (Ref# 47828, J473994)

    Workaround: When you're using Qnet with an Ethernet driver that's enabled to use jumbo packets, you should set the cluster size (the mclbytes option to io-pkt*) to be the same as the packet size (the ifconfig if_name mtu command for the driver). This ensures that the packet buffers that Qnet uses are contiguous in memory.

    If you specify a jumbo packet size larger than 4 KB (the default page size), you must additionally specify the pagesize=X option to io-pkt, with the same value as the mclbytes=X option. For example, to use 8100-byte packets with devnp-i82544.so, do the following:

    io-pkt-v4 -d i82544 -p tcpip pagesize=8192,mclbytes=8192
    ifconfig wm0 mtu 8100
    mount -T io-pkt lsm-qnet.so

    Note: Be sure to mount Qnet after you change the MTU of the interface with ifconfig.

    If you now type:

    cat /proc/qnetstats

    you can see that the Qnet L4 has an MTU of 8096, which it learned from the driver (remember the 4 bytes for the trailing CRC).

    Note: All the Qnets on your LAN must have exactly the same MTU.

    You can specify a particular MTU to Qnet (which can be the same or less than the driver-advertised value) with the mtu_en=X option.

  • Qnet treats the _CS_DOMAIN configuration string differently if it's undefined or set to a NULL string. If it's undefined, Qnet uses a domain of .net.intra; if it's set to a NULL string, Qnet applies that as the domain (for example hostname.). (Ref# 19676, J473190)
  • Qnet doesn't fully support communication between a big-endian machine and a little-endian machine. However, it does work between machines of different processor types (e.g. ARMLE, x86) that are of the same endian-ness. For more information, see the Advanced Qnet Topics chapter of the QNX Neutrino Programmer's Guide.
  • New: If you try to remount a CIFS filesystem, either with:

    mount -u cifs_mountpoint

    or by calling mount() with the _MOUNT_REMOUNT flag, the filesystem is unmounted. (Ref# 77893, J169740)

  • If you unlink() a file on a CIFS mount point, any open file descriptors for that file become invalid. (Ref# 38574, J473683)
  • fs-cifs doesn't support POSIX file-locking functions. (Ref# 38570, J473679)
  • fs-cifs incorrectly sets an errno of EPERM instead of EBADF if you attempt to write to a file opened as O_RDONLY or O_ACCMODE. (Ref# 38565, J473675)
  • If a component of a pathname supplied to a function isn't a directory, fs-cifs should return ENOTDIR. It currently returns ENOENT. (Ref# 38564, J473674)
  • PATH_MAX for CIFS (and thus fs-cifs) isn't 1024 as in POSIX. This is set by both Windows and the CIFS specification. The pathname length can be up to 255 characters. (Ref# 38566, J274605)
fs-nfs2, fs-nfs3
  • fs-nfs2 doesn't support files larger than 2 GB. (Ref# 39060, J473719)
  • fs-nfs2 doesn't correctly implement the options -w size=n and -w number=n as described in the fs-nfs2 usage message. Don't use them. (Ref# 39031, J473717)
  • New: If a path ends in a slash, it must be a directory. When you access a link that has a trailing slash, fs-nfs2 and fs-nfs3 immediately return EINVAL, instead of resolving the link and reporting errors such as EPERM (permission denied) or ENOTDIR (not a directory) before returning EINVAL (invalid argument). This behavior was seen as an optimization to reduce network traffic, because this kind of file access will ultimately fail, and it's consistent with the behavior on other OSs. (Ref# 20877, J473236)
  • fs-nfs2 doesn't support a -B option greater than 8096. (Ref# 39022, J473716)
  • fs-nfs2 lets you modify the on-disk binary file of an executable that is executing. It should return an error with errno set to EBUSY. (Ref# 38563, J473673)
  • The NFS clients don't distinguish between a pathname ending or not ending in / when passed as the argument to mkdir(). (Ref# 38484, J473667)
  • NFS is a connectionless protocol. If a server stops responding to the NFS client, it continues to try to reach the server to complete an operation until the server becomes available, or the user stops the operation. While the fs-nfs2 and fs-nfs3 clients are trying to reach the server, NFS operations are blocked until they're successful. This isn't an issue if the client is talking only to one server, but if an fs-nfs2 process has mounted multiple servers, the blocked operation also block the client's ability to talk to the other servers. (Ref# 39084, J473720)

    Workaround: Start separate client (fs-nfs2, fs-nfs3) processes for each server you wish to mount.

  • A gns daemon can't act as both a client and server at the same time. If a local service is registered with a GNS client, the client can forward that information to redundant or backup servers; a server can't forward the information. (Ref# 21037, J473239)
  • Currently, GNS (name_attach()) isn't compatible with the resource manager framework. (Ref# 20062, J473211)

    Workaround: Your resource manager must handle the raw QNX messages until this is corrected.

  • Accessing the resource manager of a remote io-pkt process via Qnet (SOCK=/net/xxxx) doesn't work if large (greater than 18 KB) message buffers are used. (Ref# J570218)
  • The stack might send zero-length mbufs to a driver for transmission. (Ref# 44621, J473873)

    Workaround: Drivers must accommodate for this by checking the length of the data in the mbuf and ignoring the mbuf if the length is zero.

nfsd lets you access files only up to 16 subdirectory levels deep within the directory exported in the /etc/exports file. Deeper directory levels and files aren't accessible. (Ref# 40104, J473747)
TCP/IP (part of io-pkt)
  • The TCP/IP stack doesn't maintain the statistics for outbound packets over VLAN interfaces. (Ref# 16684, J473010)
  • The TCP/IP stack doesn't maintain the statistics for the number of input and output bytes or packets if the packets are forwarded via the fast-forward feature. (Ref# 23041, J473311)
  • The TCP/IP stack doesn't maintain proper interface statistics for the link speed. (Ref# 27015, J473523)
  • If the default UDP socket receive-buffer size is set near its limit (for example sysctl -w net.inet.udp.recvspace=240000), UDP-based sockets become unreliable. (Ref# 27386, 159834, J181071)

Known issues: Graphics

New: Screen crashes when your application calls screen_blit() with NULL as the attrib parameter. (Ref# J1280722)

Workaround: Pass in a single-element array with SCREEN_BLIT_END as the only element as attrib instead of NULL. For example:

       int blit_attrib[] = {SCREEN_BLIT_END};
       screen_blit(screen_ctx, dest, src, blit_attrib);
The default graphics.conf for the Intel-DRM has the wrong setting for the blitter. (Ref# J617436)

Workaround: Edit graphics.conf and find these lines:

  begin class framebuffer
    display = 2
    pipeline = 1
    format = rgba8888
    usage = gles2
  end class

Change the usage line to this:

    usage = gles2blt
The total amount of contiguous memory that can be preallocated for the i.MX6 GPU is 248 MB, as specified by these lines in graphics.conf:
# GPU driver contiguous memory pool sizes in MB (2..248)
# Large values have better performance but longer startup time.
# Small values have a variety of performance impacts at run time.
   # gpu-contiguousMB   = 248
   gpu-contiguousMB   = 64      # recommended

If all 248 MB of contiguous memory is used, you'll start seeing graphics artifacts (due to failed memory allocations). (Ref# J608812)

Workaround: You can enable dynamic memory allocation to get additional memory, but this might create memory corruption (which is why it's disabled by default) and crash random processes or even lock the complete target. This will be addressed in a subsequent GPU patch.

To enable dynamic memory allocation add the following lines to the graphics.conf:

# Use only the contiguous memory pool (for debugging).
# true means no virtual memory allocations.
# false means that additional virtual memory will be allocated when
# the contiguous pool is full.
gpu-contiguousOnly = false

Known issues: Persistent Publish/Subscribe

  • New: If the directory for persistent storage (by default /var/pps) doesn't exist, then:
    • pps -l 0 (the default) runs, but your PPS data doesn't persist
    • pps -l 1 crashes
    • pps -l 2 crashes

    (Ref# J1417326)

  • The ppsparse() function sets the attr_index member of the pps_attrib_t structure only when a line contains both an attribute name and a value. When you're reading in delta mode, PPS sends a message such as -attr\n when an attribute is deleted. Since there's no value, the code sets attr_index to -1. (Ref# 77361, J169694)

Known issues: Host-specific

Windows hosts

The following issues apply to the Windows-hosted version of the IDE:
  • On Windows XP, the default path for the workspace directory contains spaces, causing problems with some command-line utilities. (Ref# 255721, J393829)

    Workaround: Change the default workspace directory to another path that doesn't contain spaces.

  • If the IDE window spans two monitors, and you lock and then unlock your computer, the window is restored to be the size of one monitor. This is a general problem on Windows. (Ref# 28653)
  • When you do a build, stdout and stderr sometimes overlap, resulting in misleading error and warning messages. This is a general problem on Windows. (Ref# 15106)
On Windows, the QNX-provided echo.exe interprets the Windows \ separator as an escape character. As a result, environment variable settings won't work if you use \ as a path separator; use / instead. (Ref# 19924, J142704)
Microsoft Visual Studio also uses the MAKEFLAGS environment variable, but in a much different way than QNX Neutrino does. The result is that Microsoft Visual Studio no longer works after you've installed QNX SDP.

Workaround: If you want to work with Microsoft Visual Studio (MSVS) after installing QNX SDP on the same system, do the following:

  1. Open a command window and run cmd.
  2. Type set.
  3. Find the value for MAKEFLAGS and save it.
  4. Type set MAKEFLAGS.
  5. Do your MSVS work.
  6. To work with QNX SDP again, type:

    set MAKEFLAGS=saved_makeflags_value

sh, ksh
Because of the way that the MSYS versions of the shell manipulate the environment variable, PATH doesn't appear to include $QNX_HOST/usr/bin, but it does. (Ref# 59412)
User Account Control (UAC)
Windows Vista and Windows 7 include an account policy, called User Account Control (UAC), that impacts various administrative features, such as being able to create and store files in a temporary directory (tmp). This directory is used by various applications, such as CVS and the split command. To successfully run these applications on a computer running Windows Vista or Windows 7, you must have administrator privileges and disable UAC. (Ref# 44027)

In order to install or use Automated License Management, you must have logged in as an administrator and disable UAC. (Ref# 77791)

Workaround: To disable UAC on your Windows Vista configuration:

  1. Launch MSCONFIG by from the Run menu. (When you click on the launch button — the one with the windows logo commonly in the bottom left corner — the Run menu is an editable text bar with the string Start Search. Type msconfig and then press Enter.)
  2. Click on the Tools tab. Scroll down until you find Disable UAC, and then click that line.
  3. Press the Launch button.
  4. A cmd window will open. When the command is done, you can close the window.
  5. Close msconfig, and then restart your computer.

You can reenable User Account Control by selecting the Enable UAC line and then clicking the Launch button.

Caution: Disabling UAC bypasses some security features.

For Windows XP, the location that the BSP file for the IDE installs into is $QNX_CONFIGURATION/qconfig_directory, and it is write-protected for a default user. Consequently, subsequent updates to BSPs aren't permitted in this location because of permission errors under Windows Vista configurations if the user doesn't have administrative permissions. (Ref# 44668)

Workaround: Modify your user permissions. For instructions about changing these permissions, see the steps in the workaround for the problem (Ref# 44027) above.

QNX utilities
The Windows installation includes various executables that have the same name as some QNX utilities, such as find, sort, and split. By default, Windows places the path to the Windows executables at the beginning of the Windows PATH environment variable, and the QNX executables appear afterward. This means that when you run these utilities from the command line, instead of using the QNX version, the PATH variable uses the Windows version. (Ref# 44457)

Workaround: If you want to use the QNX utilities for find, sort, and split from a command prompt or shell prompt, specify a fully qualified path to any of the QNX executables.

  • The current version of ctags is 5.5.4, and the documentation included with QNX doesn't accurately describe the features for this version. (Ref# 44457)

    Workaround: See the detailed documentation at http://ctags.sourceforge.net/ctags.html.

  • For Windows Vista, you receive the following error messages two times when using ctags because the Windows sort is being used instead of the sort utility included in QNX SDP.
    Input file specified
    ctags: cannot sort tag file : No error

    The ctags utility still generates tag files; however, they won't be sorted. (Ref# 43530)

    Workaround: Manually call the QNX sort on the tags file.

Linux hosts

  • The installers can't update the Gnome menu on some distributions of Linux. (Ref# 48770)
  • On some distributions, the activation dialog doesn't appear automatically. (Ref# 68599)

    Workaround: Set up the environment for command-line tools:

    source $USER_INSTALL_DIR$/qnx660-env.sh

    and then run the following command:

    "$QNX_CONFIGURATION$/bin/qnxactivate -d $QNX_CONFIGURATION$"
  • Many undefined symbol: menu_proxy_module_load messages might be displayed when you start the IDE from the command line. (Ref# J337353)

    Workaround: Execute this command:

    sudo apt-get install appmenu-gtk:i386
  • On Ubuntu 12.04.2 64-bit, the IDE fails to prompt you for the SVN Kit plugin after you've installed the Subversive SVN Team Provider and rebooted. (Ref# J438377)
  • On Linux, after you import and build a BSP in the System Builder, the files in the prebuilt directory lose their executable bit. (Ref# 252984, J393824)

    Workaround: Change the permissions to add the executable bit before you add the files to the IFS image.

  • If you try to use the IDE on some distributions of Linux (e.g., Ubuntu) to build for QNX Neutrino 6.4.1 targets, the license check for the tools fails. (Ref# 76136, J393506)

    Workaround: Back up your 6.4.1 licensing library, and then replace it with the 6.5.0 version. For example:

    cp /opt/qnx641/host/linux/x86/usr/lib/libqnxlic.so \ 
    cp /opt/qnx650/host/linux/x86/usr/lib/libqnxlic.so \ 
  • On Linux Ubuntu 9.04 64-bit, after you install, you'll notice that the QNX website doesn't open in the default browser, the Internal Web Browser view isn't functional when the IDE generates a Code Coverage report (Internal Browser > Default System Web Browser), and you'll receive this error message:
    someUser@ubu90464bit:~$ qde
    Gtk-Message: Failed to load module "canberra-gtk-module":
    /usr/lib/gtk-2.0/modules/libcanberra-gtk-module.so: wrong ELF class: ELFCLASS64

    (Ref# 71246, J330708)

    Workaround: In the IDE, select Preferences > General > Web Browser, and then specify an external browser.

  • The IDE won't run on some versions of Linux, such as Open SUSE 11 and Ubuntu 8.04. This is a bug in Eclipse; see bug 213194 at http://www.eclipse.org. (Ref# 66351, 66760)

    Workaround: Do the following:

    1. On Ubuntu, type:
      sudo apt-get install xulrunner
    2. Edit $QNX_HOST/usr/qde/eclipse/qde.ini and add this line after the -vmargs line:
  • The IDE may give some UnknownHost exceptions when you attempt to access a network on some 64-bit versions of Linux (e.g. Ubuntu 8.0.4 64-bit). This seems to be a problem with name resolution in the JRE on such hosts. (Ref# 70757)

    Workaround: Edit /etc/nsswitch.conf. On the hosts line, move dns from the end to between files and mdns4_minimal.

Filesystem events


Keeping up with a very live filesystem that changes often and quickly is a challenge for the programs that work with it. To help with this challenge, QNX Neutrino includes filesystem events.

These events let an application keep track of changesincluding the creation and deletion of files and directory, changes of ownership and permissions, mount and unmount operations, and morein a filesystem that's of interest. The management of filesystem events involves an event manager, an event mechanism, and client event handlers.

The event manager, fsevmgr, is a process that registers a fixed name in the system namespace (the default is /dev/fsevents) and receives the filesystem events, possibly from multiple io-blk.so instances, determines which clients need which events, and gives the events to those clients.

The event mechanism is part of io-blk.so, where any filesystem or parts of the block I/O system can easily use it. This gives the most flexibility since we can coordinate events coming into the filesystem at the system-call level, from within the filesystems, partitions, caching, and even the block device driver if needed.

The mechanism places events into a buffer to eventually be sent to the event manager. This mechanism is limited to an API that reports a locale where the event came from, a unique identifier indicating the event, and properties that further describe the event. The io-blk.so library is responsible for packaging each event and sending it to the event manager. The implemention uses a timer to ensure events aren't left sitting in this buffer for an extended period of time.

During startup, io-blk.so looks for the event manager. If it isn't loaded, the event mechanism is disabled. Three configuration parameters are added: One allowing the name of the event manager to be specified, one to change the size of the buffers holding events, and the maximum period of time to delay before sending events to the event manager.

During the loading of the event manager, a DCMD_FSYS_FSEVMGR_CHECK devctl command is sent to the various io-blk.so mountpoints to notify them that an event manager has been loaded.

Finally a client event handler may instantiate a thread that blocks on reads from /dev/fsevents or selects the file descriptor for notification once data is available.

Here's an overview of how the client typically interacts with the event manager:

FSE_DEFAULT_MANAGER_NAME (defined in <sys/fs_events.h>) describes the default path of the event manager. Keep in mind that it may be overridden by the event manager, and io-blk.so may also be changed to look for another event manager.

The client should generally open the event manager in O_RDONLY mode to simply read events. Write mode is necessary only if the client needs to send events. Set the O_NONBLOCK flag if the client is going to poll the event manager.

The client reads events from the Event Manager into an array of bytes. The byte array is filled up to the size required to store whole events. In other words, partial events aren't returned to readers. No assumptions can be made reguarding the alignment of events within the buffers.

FSE_READ_EVENT_S(pev, pbytes) is provided as a wrapper to memcpy() an event from the byte array into an aligned structure. From there, the client can use the other FSE_* accessor macros to interpret event characteristics.

While the event manager generally has a large queue to hold events, it will inevitably fill and begin to overwrite old events. If any event clients haven't kept up with the addition of new events, those readers will be placed into an overflow state. In other words, if the event manager has begun to overwrite events that a reader hasn't consumed, the next read from that descriptor indicate an error of EOVERFLOW. The subsequent read() returns the oldest event.

The event manager supports a limited seek functionality. Generally, a client starts reading from the head of the queue and immediately blocks waiting for new events. If a client must evaluate past events, it can use lseek().

A whence value of SEEK_SET and an offset of zero position the file descriptor to the oldest event in the queue. Be aware that this condition may cause an EOVERFLOW during a subsequent read().

A whence of SEEK_END and an offset of zero position the reader at the end of the queue to read new events.

The client can use event counts as the offset, with either SEEK_SET or SEEK_END, to index some count of events from the head or tail of the queue, respectively.

The client can use write() to send events to the event manager. The event manager checks the event data to ensure it's well-formed; on failure, the event manager aborts the writing of all events that were sent in a single write operation.
Once the file descriptor is no longer needed, it may be closed.

The <sys/fs_events.h> header file includes everything that's necessary to read and process events from the event manager. For more information, see FSE_*(), below.

fsevmgr—Filesystem event manager


fsevmgr [options] [command]

Runs on:

QNX Neutrino


Enable debugging output on stdout.
-k size
The size of each mailbox event queue, in kibibytes (default: 64 KB).
Allow multiple events to be returned per read().
-n fsevent_name
The name for fsevents to register (default: /dev/fsevents).
-s size
The size of the master event queue, in kibibytes (default: 100 KB).
-U uid:gid
Switch to the given user ID and group ID once running.
-w time
The number of milliseconds to delay before notifying io-blk instances.
Suppress the notification of the event manager load.


The fsevmgr manager helps the block I/O system send events to clients that want to be notified of changes to a filesystem. It registers these interfaces in the system namespace:

Used by the inode notify system as a source of inotify_event structures; see inotify_init() in the C Library Reference.
Used by clients to read events from, in fsev_t structures.

The fsevmgr manager receives the initial events, possibly from multiple io-blk.so instances, and then determines who needs what events and doles out the events to the clients. The event manager and/or clients carry the burden of matching events from filesystems to clients that are interested in specific information.

If you don't specify a command argument, fsevmgr runs in the background.

Commands complete a given operation, and then exit immediately. The commands include:

-c id,string
Insert an event into the event manager queue.
Display statistics.
Poll the event manager and display the output on standard output.
Display the primary event queue on standard output.
Notify filesystems to resynchronize themselves with the event manager.

fsev_t, FSE_*()—Structure and macros for filesystem events


#include <sys/fs_events.h>

typedef struct fse_event_s {
    uint32_t        signature;          /* Version and fixed identifier      */
    uint16_t        length;             /* Type and length of the event data */
    uint16_t        command;            /* Command / request information     */
    uint32_t        properties;         /* Classification of the event       */
    uint32_t        reserved;           /* Reserved for future use (zero)    */
    uint32_t        identity;           /* Locale and ID of the event        */
} fsev_t;


The <sys/fs_events.h> header file includes everything necessary to read and process events from the filesystem event manager, fsevmgr.

The fsev_t structure is a header that describes a filesystem event, including its origin, locale, and identity. It's followed by any data associated with the event. Generally the data is a path string, but depends on the type of event.

Events are organized into tuples that have a common header, a description of the event, and length of that event. The length field represents the entire length from the starting address of the tuple.

Note: Don't use sizeof() to determine the size of an event, because this header structure might be followed by a flexarray or be part of another structure.

You read an event from the event manager into an array of bytes, but there's no guarantee of alignment, so you should use this macro to copy the data into an fsev_t structure:

#define FSE_READ_EVENT_S(pev, pdata)

where pev is a pointer to a fsev_t structure, and pdata is a pointer to the array of bytes.

To access a tuple, use the following FSE_*() macros, which take as an argument a pointer to an fsev_t structure:

Get the command or request. The possible values include:
  • FSE_CMD_FILTER used by clients when they want to set a filter against a file descriptor.
  • FSE_CMD_POST used by the filesystem for sending data to the event manager.
  • FSE_CMD_REPORT not currently used.
Return the length of data that's attached to the tuple. The maximum length is given by FSE_MAX_EVENT_LENGTH. It accommodates at least two paths of 1024 bytes; some name-based operations may have three paths, consisting of a mountpoint and the two relative paths.

Note: Events with longer data might be lost.

Get a pointer to the event data.
Get the locale and ID of the event.
Return a nonzero value if the event concerns a directory.
Return the event ID.
Return a nonzero value if the event has a valid signature and is version 1. You should use this macro first, to make sure that the event is valid.
Get the length of the event data.
Return the locale of the event.
Return the event properites.
Get the event's signature.
Return the total size of the event tuple, which includes the fsev_t structure and its data.
Get the version of the filesystem event software.


Properties are boolean attributes of an event that help to describe its purpose, data, and/or impact to the system. An event can have multiple properties ORed together.

To assist in the filtering of events, properties are organized into a few groups: types, class, and data. FSE_TYPE_* properties indicate the purpose of an event; FSE_CLASS_* properties indicate the impact an event might have on a system; FSE_DATA_* properties describe attributes of the data attached to the event.

Properties of events aren't exclusive; some events may have two class properties.

Not currently used.
General purpose events are those that an event handler may be interested in. Most events have this property.
Reserved for tracking code execution.
Internal events are reserved for future use.
The event's data is a number of zero-byte terminated strings. Lack of this property suggests the event data is binary, but that depends on the specific event.
A change has resulted or may result from the event.
A change has resulted or may result from the event.
The event doesn't result in a change. For instance, a read from a file, or an open as read-only is an access class.
Events that are informational only (e.g., a stat() of a file).
Reserved for internal use only.


Locales indicate the source of the event. An event can have only a single locale. In general, event client handlers filter out those events that don't match the locale that they're monitoring.

Reserved for use by the block-level operations, cache, and partition level operations.
The source of the event was the event manager. This may be used for debugging purposes or for events that are injected directly through use of the fsevmgr itself.
The event came from somewhere outside the io-blk.so filesystem.
Not currently used.
Most notable public entry points to the filesystems will have this locale. Events with this locale are often generic and apply to any filesystem.
Not currently used. The VFS locale describes events generated by io-blk.so and which are specific to its implementation. These might include specific ioctl() commands or specific mount operations.

Event IDs

Event IDs indicate the cause of the event and the data associated with it. If the event data includes any strings, they're null-terminated.

ID Properties Description
FSE_ID_CHECK Used internally for testing.
FSE_ID_CHMOD FSE_TYPE_GENERAL, FSE_CLASS_UPDATE, FSE_DATA_ZSTRING Sent upon successful recording of a file's read, write, and execute modes. This event indicates only that a file mode bits might have changed. Mode information isn't available. The data consists of:
  • the mountpoint
  • the name of the file that changed
FSE_ID_CHOWN FSE_TYPE_GENERAL, FSE_CLASS_UPDATE, FSE_DATA_ZSTRING Sent on the successful recording of a file's ownership. Note this event indicates that the ownership information might have changed. Ownership information isn't available. The data consists of:
  • the mountpoint
  • the name of the file that changed
FSE_ID_CLOSE_OTHER Reserved for future use.
FSE_ID_CLOSE_UPDATE FSE_TYPE_GENERAL, FSE_CLASS_UPDATE, FSE_DATA_ZSTRING The last close of a file handle that has write access to the inode generates this event. Note that this may not be the same file name that was reported in an earlier FSE_OPEN_UPDATE event. The data consists of:
  • the mountpoint
  • the name of the file
FSE_ID_CREATE Reserved for future use.
FSE_ID_DEVCTL Reserved for future use.
FSE_ID_FDINFO Reserved for future use.
FSE_ID_FREE_SPACE FSE_TYPE_GENERAL, FSE_CLASS_UPDATE, FSE_DATA_ZSTRING The block I/O system attempts to estimate disk space usage based on IO_WRITE and IO_SPACE messages; when it estimates that a certain threshold has been crossed, it queries the filesystem for the real change. Once the real change is confirmed to be above a certain threshold, a FSE_ID_FREE_SPACE event is emitted. The data consists of:
  • the mountpoint
  • the amount of free space, in bytes (as a string converted from an unsigned 64-bit integer)
FSE_ID_LINK FSE_TYPE_GENERAL, FSE_CLASS_UPDATE, FSE_DATA_ZSTRING The link field indicates a filename has successfully been created and associated with an inode. The target file name is unknown. The data consists of:
  • the mountpoint
  • the name of the file that was created
FSE_ID_MKDIR FSE_TYPE_GENERAL, FSE_CLASS_UPDATE, FSE_DATA_ZSTRING A directory (or node) has been successfully created within the filesystem. The data consists of:
  • the mountpoint
  • the name of the new directory
FSE_ID_MOUNT FSE_TYPE_GENERAL, FSE_CLASS_INFO, FSE_DATA_ZSTRING A volume has been successfully mounted (e.g., mount /dev/umass0 /fs/usb0). The data consists of:
  • the block special device (e.g., /dev/hd0)
  • the mountpoint (e.g., /fs/dos)
FSE_ID_OPENFD Reserved for future use.
FSE_ID_OPEN_OTHER Reserved for future use.
FSE_ID_OPEN_UPDATE FSE_TYPE_GENERAL, FSE_CLASS_UPDATE, FSE_DATA_ZSTRING The open update event is a result of the first open of an inode which includes write access. Subsequent opens with write access of the inode (regardless of the source file name) aren't reported. Note that if the inode is opened again, but through a different link, there will be no additional event. The data consists of:
  • the mountpoint
  • the source file name
FSE_ID_READ Reserved for future use.
FSE_ID_READLINK Reserved for future use.
FSE_ID_RENAME FSE_TYPE_GENERAL, FSE_CLASS_UPDATE, FSE_DATA_ZSTRING Sent as a result of a successful renaming operation within a single filesystem. Renaming operations across filesystems are generally implemented as a copy and delete sequence. The data consists of:
  • the mountpoint
  • the original file name
  • the new file name
FSE_ID_SEEK Reserved for future use.
FSE_ID_STAT Reserved for future use.
FSE_ID_TRUNCATE FSE_TYPE_GENERAL, FSE_CLASS_UPDATE, FSE_DATA_ZSTRING Sent upon a truncate operation that results in a change to a file size. The data consists of:
  • the mountpoint
  • the name of the file whose size has changed
FSE_ID_UNLINK FSE_TYPE_GENERAL, FSE_CLASS_UPDATE, FSE_DATA_ZSTRING Sent as a result of a successful unlink operation. The data consists of:
  • the mountpoint
  • the file name that's been deleted
FSE_ID_UNMOUNT FSE_TYPE_GENERAL, FSE_CLASS_ACCESS, FSE_DATA_ZSTRING A volume has been successfully unmounted. The data consists of:
  • the block special device (e.g., /dev/hd0)
  • the mountpoint (e.g., /fs/dos)
FSE_ID_WRITE Reserved for future use.

Here's an example of extracting the information associated with an event:

char *data, *mntpath, *spacestr;
size_t len;
uint64_t freespace;

    data = FSE_DATA_PTR(event);
    len  = FSE_DATA_LEN(event);

    /*  Determine the starting buffer offsets for the mount path and freespace
        integer value.
    mntpath  = data;
    spacestr = data + strlen(mntpath) + 1;

    /*  If the path exceeds the data buffer, then there's no freespace value
    if (spacestr >= (data + len)) {
        LOG(LOG_ERROR, "freespace data exceeds event buffer length (%p >= %p)",
            spacestr, data+len);
    /*  Convert the freespace string to a 64-bit unsigned integer value.
    else if (sscanf(spacestr, "%" PRIu64, &freespace) != 1) {
        LOG(LOG_ERROR, "freespace data conversion failed");


There are several unique situations that clients of the event manager should be aware of:

  • It's possible and explicitly allowed to have a handle open to a file that's been deleted. For instance, an application can open a file and begin writing to it and during the write, unlink the file. Further reads and writes are allowed to the file, but when the last handle to the file is closed, the file will be freed from the filesystem. This means that it's possible to receive an FSE_EVENT_CLOSE_UPDATE on a file that no longer exists within the filesystem.
  • During updates to a file, it's possible to rename the file, resulting in an FSE_EVENT_CLOSE_UPDATE for a file name that appears to have been removed since the file was opened.

Initializing events

If your client application has opened the event manager's device for writing, you can inject events. You can initialize an event structure by using the FSE_INIT_EVENT() macro:

#define FSE_INIT_EVENT(p, cmd, loc, id, prop, len)...

The arguments are:

A pointer to the fsev_t structure that you want to initialize.
The command indicating the operation to complete (FSE_CMD_*).
An indicator of the source of the event (FSE_LOCALE_*).
A specific event identifier (FSE_ID_*).
Properties of this event (a bitwise OR of the appropriate FSE_TYPE_*, FSE_CLASS_*, and FSE_DATA_* bits).
The length, in bytes, of the data that's associated with this event.

The event manager checks the event data to ensure it's well-formed; if it isn't, the event manager aborts the writing of all events that were sent in the write operation.


QNX Neutrino

Cancellation point No
Interrupt handler No
Signal handler No
Thread Yes

Getting started with the documentation

After you've installed QNX SDP, you'll find an extensive set of HTML documentation in the Integrated Development Environment's help system. To start the IDE on Linux, use this command:


On Windows, use the desktop icon or run:


where base_directory is where you installed the software.

The roadmap page contains links to the various HTML booksets that accompany the OS. For a short tutorial that will help you get started, see the Quickstart Guide, then refer to the other documents (System Architecture, QNX Neutrino Programmer's Guide, C Library Reference, Utilities Reference, and so on).

You can install and work with multiple versions of QNX Neutrino. Whether you're using the command line or the IDE, you can choose which version of the OS to build programs for. For more information, see the IDE User's Guide or the QNX Neutrino Programmer's Guide.

For the most up-to-date version of the installation and release notes, go to our website, www.qnx.com, log in to your myQNX account, and then go to Downloads > QNX Software Development Platform 6.6.x.

Technical support

To obtain technical support for any QNX product, visit the Support area on our website (www.qnx.com). You'll find a wide range of support options, including community forums.

For questions about installing and using QNX SDP, see the Getting Started forum on our Foundry27 site, http://community.qnx.com. There are other forums for specific topics, including the QNX Neutrino RTOS, development tools, networking, Board Support Packages, and so on.