Home
QNX Software Development Platform
QNX SDP is a cross-compiling and debugging environment, including an IDE and command-line tools, for building binary images and programs for target boards running the QNX OS 8.0.
Programming
Writing a Resource Manager
Handling Other Messages
Your resource manager will likely need to handle messages for operations other than read and write. Here, we explain and demonstrate how to handle other common message types.
Handling mount()
mount utility

QNX Momentics IDE User's Guide
This User's Guide describes version 8.0 of the Integrated Development Environment (IDE) that's part of the QNX Tool Suite.
QNX Software Development Platform
QNX SDP is a cross-compiling and debugging environment, including an IDE and command-line tools, for building binary images and programs for target boards running the QNX OS 8.0.
- Quickstart Guide
- System Architecture
  The System Architecture guide accompanies the QNX OS and is intended for both application developers and end-users.
- OS Components & Operations
- Graphics
- Programming
  - Getting Started with the QNX OS
    Getting Started with the QNX OS: A Guide for Realtime Programmers is intended to introduce you to the QNX OS and help you develop applications and resource managers for it.
  - Programmer's Guide
    The QNX OS Programmer's Guide covers a variety of topics that might interest developers who are building applications that will run under the QNX OS.
  - Writing a Resource Manager
    - What Is a Resource Manager?
      In general terms, a resource manager is a process that registers a pathname in the filesystem namespace. Other processes use that pathname to communicate with the resource manager.
    - The Bones of a Resource Manager
      Let's start with the overall structure of a resource manager. First we'll look at what happens under the covers on both the client side and the server side. After that, we'll go into the layers in a resource manager and then look at some examples.
    - Fleshing Out the Skeleton
      It's time now to start adding some flesh to the basic bones of the resource manager. We'll look at the types of messages you might have to handle, how to set the resource manager's attributes, how to add functionality, and some security issues you should consider.
    - POSIX-Layer Data Structures
      The resource manager library defines (in <sys/iofunc.h>) several key structures that are related to the POSIX-layer support routines.
    - Handling Read and Write Messages
      A resource manager must define routines or handlers to process requests by the client to receive data (read) or send data to the underlying device (write). Here, we give detailed examples of such handlers.
    - Resource Managers that Handle Multiple Devices
      Resource managers can easily be adapted to handle multiple devices.
    - Combine Messages
      To conserve bandwidth and to support atomic operations, combine messages are supported. A combine message is constructed by the client's C library and consists of multiple I/O and/or connect messages packaged together into one.
    - Using the Receive Buffer as a Reply Buffer
      When building a response to a client request, you often need a temporary buffer in which to build this response.
    - Handling Other Messages
      Your resource manager will likely need to handle messages for operations other than read and write. Here, we explain and demonstrate how to handle other common message types.
    - Unblocking Clients and Handling Interrupts
      Your resource manager needs to avoid leaving clients blocked indefinitely, and it might need to handle interrupts.
    - Multithreaded Resource Managers
      When you create a multithreaded resource manager, you should design it so that there's always at least one RECEIVE-blocked thread.
    - Filesystem Resource Managers
      Some resource managers need to implement filesystems by responding to access requests for any pathname within a directory structure.
    - Glossary
- System Security Guide
  The QNX System Security Guide is intended for both system integrators who are responsible for the security of a QNX OS system and developers who want to create a QNX OS resource manager free from vulnerabilities.
- Utilities & Libraries
- Migrating to QNX OS 8.0
QNX Software in the Cloud
QNX Software in the Cloud enables developers to use the QNX OS in the Amazon cloud environment.
QNX Toolkit for Visual Studio Code
This User's Guide describes the QNX^® Toolkit for Visual Studio Code. The guide introduces you to the QNX Toolkit by explaining the QNX development environment and how to build, run, and debug your QNX^® Operating System (OS) applications and systems.
QNX Hypervisor User's Guide
This User's Guide explains the QNX hypervisor architecture and provides instructions for installing and running a QNX Hypervisor system, changing system components and configuration, and using hypervisor features such as virtual devices (vdevs).
Typographical Conventions, Support, and Licensing
This section describes the typographical conventions used throughout the documentation, explains how to obtain technical support, and provides some information about licensing.

mount utility

QNX SDP8.0Writing a Resource ManagerDeveloper

By covering the mount() library function and the operation in the resource manager, we've pretty well covered the mount utility.

However, if you're writing a mount handler, there may be occasions when you want to do custom parsing of arguments and provide your own data structure to your server. This is why the mount command will always first try to call out to a separate program named mount_XXX, where XXX is the type that you specified with the -t option of mount. To see just what would be called (in terms of options, etc.), you can use the -v option, which should provide you with the command line that would be exec()'ed.

Note:

For the full list of mount options, see the mount entry in the QNX OS Utilities Reference.

In order to help with the argument parsing, there's a utility function, mount_parse_generic_args(), that you can call to process the common options. The function is defined in <sys/mount.h> as:

char *mount_parse_generic_args(char *options, int *flags);

This function parses the given options, removes any options that it recognizes, and sets or clears the appropriate bits in flags. It either returns a pointer to the modified version of options containing any options that it didn't recognize, or returns NULL if it recognized all the options. You use mount_parse_generic_args() like this:

while ((c = getopt(argv, argc, "o:"))) {
   switch (c) {

      case 'o':

        if ((mysteryop = mount_parse_generic_args(optarg, &flags))) {

           /* You can do your own getsubopt-type processing here.
              The common options are removed from mysteryop. */
        }
        break;
    }
}

For more information about the stripped options and the corresponding flags, see the entry for mount_parse_generic_args(), in the QNX OS C Library Reference.

Page updated: March 05, 2025