Consisting of a microkernel and a team of optional modules, QNX® employs an efficient division of labor to handle all OS services. When you need a filesystem, a network, a GUI - whatever - simply run the modules you need.

As a true microkernel OS, QNX starts with a lean core of highly reliable code. It's small enough for ROMable embedded applications, yet powerful enough to run a distributed network of several hundred processors.

QNX is also easy to extend, giving you the ultimate in design flexibility. Use the multitude of modules QNX provides or extend the OS with your own modules. With QNX's robust protected-mode environment, you're always free to test your extensions and try new approaches. No matter what, your system stays up.

And QNX is fast. With its low OS overhead and executive-class speed, QNX lets you deliver low-cost PC-based products that often outperform costly high-end systems.

The QNX microkernel handles process creation, memory management, and timer control.

QNX's unique approach to transparent distributed processing lets you launch processes across the QNX network, allowing for full inheritance of the environment, including open files, current directory, file descriptors, and user ID. The microkernel also includes POSIX.1 (certified) and many POSIX.1b realtime services, as well as high-speed diagnostic event tracing.

Features include:

• POSIX.1b clocks and timers:

  • multiple timers per process

  • timers specified in nanosecond resolution

  • flexible timer control: timers can be synchronous or asynchronous; one-shot or repetitive

• fully nested interrupts

• dynamically attachable and removable interrupt handlers

• flexible primitives for shared memory

• built-in debug primitives for local and remote debugging from anywhere on the network

• user-configurable system limits and resources

• network-wide process-naming capability

• POSIX.1b realtime draft standard process scheduling:

  • 32 priority levels

  • preemptive, prioritized context switching

  • choice of scheduling algorithms: FIFO, round robin, adaptive; all selectable per process

  • servers can have their priority driven by the messages they receive from clients

  • fully preemptive message passing

Our suite of filesystems help you strike the right balance of size, functionality, and cost. QNX lets you run multiple filesystems at the same time. For example, if you're running the POSIX filesystem and need to talk to a Windows machine, you could simply start up the SMB filesystem manager.

POSIX filesystem

Our POSIX filesystem, Fsys, offers full POSIX.1 and UNIX semantics, extensive safeguards against data loss, and disk drivers that deliver near platter-speed performance. Since it provides all the services expected of a POSIX filesystem, Fsys is best suited for development servers and other conventional hard-disk-based applications. Nevertheless, you can size it to fit embedded applications that require UNIX semantics.


Fsys at a glance

• high-performance, extent-based POSIX filesystem

• robust: all sensitive filesystem information is written through to disk

• heuristic read-ahead and write-behind with elevator seeking

• on-disk "signatures" and special key information to allow fast data recovery in the event of disk damage

• full support for pipes and FIFOs (named pipes), both locally and transparently across the network

• user-configurable filesystem limits and resources

• 48-character filenames

Note that applications can bypass Fsys and talk directly to device drivers (for raw block I/O) or to your own custom filesystem.

Our embedded filesystem, Efsys, comes in several versions. Efsys supports various flash memory devices including PCMCIA flash cards, a variety of x86 reference designs from major chip vendors, and single-board computers and solid-state disks from several manufacturers.

If you want to use memory devices not currently supported by Efsys, you can easily create your own custom filesystems. We provide all the source and object code you need.

Efsys at a glance

• small executable (average 60K)

• optional compression to fit more files into the limited space of many flash, SRAM, and ROM devices

• network transparent - your embedded application can access data and programs throughout the QNX network

• support for many common system calls to give your application read/write functionality

• support for POSIX dates and long filenames

The SMB (Server Message Block) file sharing protocol is used by a number of different servers such as Windows NT, Windows 95, Windows for Workgroups, LAN Manager, and Samba. A handy tool for cross-development, our SMB filesystem, SMBfsys, provides transparent access to files on these types of servers.

SMBfsys implements this protocol using NetBIOS over TCP/IP. Once SMBfsys is running and a remote server has been mounted, the server's filesystem appears as a subtree in the local directory structure.

A popular network filesystem for enterprise-wide, heterogeneous networking, NFS lets you transparently access files on most UNIX systems and many non-UNIX systems, including Windows. For more info, see the description of TCP/IP for QNX.

With our DOS filesystem, Dosfsys, any QNX program on the QNX network can transparently create, read, write, and delete files that reside on DOS disks. Even if you don't have a DOS machine, it's likely that a platform you need to exchange data with will support a DOS filesystem. Having Dosfsys means you can exchange the data easily, using common QNX commands.

Dosfsys works with DOS floppies and all DOS partition types.

Our CD-ROM filesystem, Iso9660fsys, lets you transparently access CD-ROMs or any other media formatted according to the ISO 9660 specification. Besides supporting the ISO and High Sierra filesystems used on the vast majority of CD-ROMs, Iso9660fsys also supports the Rock Ridge interchange protocol. As a result, you can use POSIX filenames and symbolic links, and read UNIX distributions shipped on CD-ROM.

Our block filesystem, Blkfsys, implements the full driver and user interface of the POSIX filesystem, but for block special files only. That is, it supports raw partitions, tapes, and floppies, but not the QNX filesystem. If you're an embedded developer, Blkfsys gives you the flexibility to develop customized filesystem structures. Since it supports all the same devices as Fsys, but in less memory and for a lower price, Blkfsys is a cost-effective alternative for applications that need only raw block access to a block-oriented device. Blkfsys includes several utilities as well as our supported drivers for floppies, hard disks, CD-ROMs, and SCSI devices.

The QNX Device Manager, Dev, is a high-throughput, low-overhead server that provides the interface between all processes and terminal devices. Dev handles character devices with an architecturally lean design that can support 115Kbaud - even on slower 386 processors. Dev integrates a full complement of character-based devices, including ANSI terminals, keyboards, and serial and parallel I/O.

Features include:

• fully buffered writes

• input buffer per tty can be from 256 bytes to 64 Kbytes for high-speed protocol applications

• input requests can return on timeouts or on data-forwarding characters

• asynchronous I/O primitives

For any service an application might request of QNX, the actual code path through the OS is surprisingly short and executes very few instructions. QNX works smart, not hard, so the processor isn't burdened with supporting a complex, cumbersome OS and is free to concentrate on running your applications. QNX can deliver the peak physical performance of all peripherals in the system. Your applications can enjoy responsive disk, network, and video performance with minimal processor load.

QNX's lean, efficient architecture lets you build high-performance applications using standard PC-class hardware. Less OS overhead, less hardware, less development time. It all adds up to more performance with QNX.