QNX® Software Development Platform 6.6
QNX® SDK for Apps and Media 1.0
QNX® CAR Platform for Infotainment 2.1

Content
Search Results
Index
Loading, please wait ...

Loading

  • QNX Momentics IDE User's Guide
    • Overview of the IDE
      • Get to know Eclipse
      • Starting the IDE
      • Setting IDE Preferences
      • Where files are stored
      • Environment variables
      • Version coexistence
      • Utilities used by the IDE
    • Preparing Your Target
      • Creating a QNX Target System Project
      • Moving files between the host and target
        • Moving files from the host to the target
        • Moving files from the target to the host
      • Host-target communications
        • IP communications
        • Serial communications
        • qconn over Qnet
        • Securing qconn
        • Installing the qconn update
          • Copying a new version of qconn to a target system
        • Configuring target connections
      • Networking QNX Neutrino using PPP
        • Verifying a serial connection
        • Preparing an embedded system for a Windows target
        • QNX Neutrino networking
        • Linking an embedded system running QNX Neutrino to a Windows network connection
        • Verifying a network connection
    • Managing Projects
      • Supported project types in the IDE
        • Considerations for project development
        • How the IDE characterizes projects using natures
      • Creating a project in the IDE
        • Scenarios for creating a project for the first time
        • New Project wizard
        • Creating a project for a C or C++ application
          • Projects tab
        • Creating a Makefile project with existing code
        • Creating an empty Makefile project
        • Allowing a Makefile project to be launched outside the IDE
        • QNX C/C++ container projects
          • Creating a container project
          • Setting up a build configuration
          • Editing using project properties
          • Editing using Build Container Configuration
          • Building a container project
      • Converting projects
        • Converting a QNX project to a Managed project
        • Converting a regular project to a C/C++ Project
        • Converting a non-QNX project to a QNX project
        • Making a converted project into a working QNX project
      • Sharing projects
      • Importing projects
        • Importing an existing container project into a workspace
        • Importing a QNX BSP
        • Importing a QNX mkifs Buildfile
        • Projects within projects
          • Step 1: Create a project for your source code
          • Step 2: Create a new project for each existing project or component in your source tree
          • Step 3: Link the projects to a directory in the source tree
          • Step 4: Build the component project in the linked folder
      • Opening header files
        • Setting the include paths and define directives
      • Project properties reference
        • Properties for all project types
          • Resource panel
          • Builders panel
          • C/C++ Build panel
          • Discovery options panel
          • Environment panel
          • Settings panel
          • Indexer panel
        • QNX C/C++ Project properties
          • Options tab
          • Build Variants tab
          • Library tab
          • General tab
          • Compiler tab
          • Linker tab
          • Make Builder tab
          • Error Parsers tab
    • Writing Code in the C/C++ Perspective
      • Building projects
      • Configuring automated builds
      • Adding a use message
        • Adding a use message for a QNX C/C++ project
        • Adding a use message for a Makefile project
    • Preparing to Run or Debug Projects
      • Launch configurations
        • Launch configuration types
          • Launch Group
      • Creating a launch configuration
      • Importing launch configurations
      • Launch configuration options
        • Main tab
        • Arguments tab
        • Environment tab
        • Upload tab
        • Debugger tab
        • Source tab
        • Common tab
        • Tools tab
    • Debugging a Program in the IDE
      • Building an executable for debugging
      • Launching a program with the debugger attached
        • Debug perspective controls
      • Debugging a child process
      • Seeing debug symbols for libraries
      • Interacting with GDB
      • Supported debugging frameworks
    • Using Code Coverage
      • Enabling Code Coverage for QNX C/C++ projects
      • Enabling Code Coverage for Makefile projects
      • Launching a coverage-enabled project
      • Viewing code coverage results
        • Examining coverage data line by line
      • Saving code coverage data to an XML file
      • Generating a code coverage report
      • Combining code coverage sessions
      • Importing GCC coverage data
    • Getting System Information
      • What the QNX System Information perspective reveals
        • Associated views
      • Controlling and interacting with your target system
      • Examining your target system's attributes
        • System Specifications pane
        • System Memory pane
        • Processes panes
      • Managing processes
        • Thread Details pane
        • Environment Variables pane
        • Process Properties pane
      • Examining target system memory
      • Tracking heap usage
        • Overview history
        • Outstanding allocations
        • Allocation deltas
        • Deallocation deltas
        • Outstanding allocation deltas
      • Examining process signals
      • Getting channel information
      • Tracking file descriptors
      • Tracking resource usage
      • Tracking the use of adaptive partitions
    • Using JTAG Debugging
      • JTAG: Using the Abatron BDI2000 Debugger with a QNX Neutrino kernel image
        • Prerequisites
        • Connecting the Abatron BDI2000 Debugger to your host
        • Updating the Abatron firmware
        • Connecting the Abatron BDI2000 Debugger to your target
        • Building a system image
        • Creating a launch configuration
        • Debugging the startup binary
      • JTAG: Using the Lauterbach Trace32 In-Circuit Debugger with a QNX Neutrino kernel image
        • Prerequisites
        • Installing the Lauterbach Trace32 In-Circuit Debugger software
        • Installing the Lauterbach Trace32 Eclipse plugin software
        • Connecting the Lauterbach Trace32 In-Circuit Debugger
        • Configuring the Lauterbach Trace32 In-Circuit Debugger
        • Creating a launch configuration for the Lauterbach hardware
        • Creating a startup script for the Lauterbach Trace32 In-Circuit Debugger
          • Create multicore launch configurations
        • Using the Lauterbach debugger
      • JTAG: Using the Macraigor Usb2Demon Debugger with a QNX Neutrino kernel image
        • Prerequisites
        • Installing the Macraigor hardware support package
        • Connecting the Macraigor Usb2Demon Debugger to your host
        • Connecting the Macraigor Usb2Demon Debugger to your target
        • Starting the OCDremote
        • Building a system image
        • Creating a launch configuration
        • Debugging the startup binary
    • Maximizing Performance with Profiling
      • Profiling an application
        • Sampling execution position and counting function calls
        • Measuring function runtimes for a single application
        • Profiling system activity while measuring function runtimes
        • Postmortem profiling: Running an instrumented binary from the command line
          • Environment variables for controlling profiling
        • Attaching Application Profiler to a running process
        • Application Profiler tab
      • Interpreting profiling data
        • Profiler Sessions view
          • Pausing or resuming a profiling session
          • Taking a snapshot of an active session
          • Comparing profiling session results
          • Creating a sample profiling session
          • Importing profiling data
          • Exporting profiling data
        • Execution Time view
          • Interpreting differences in session results
          • Showing call sequence information
          • Duplicating the view
          • Navigating the view history
          • Grouping data
          • Copying data to the clipboard
          • Filters
          • Search
        • Debug view
        • Annotated source editor
        • Properties view
    • Analyzing Your System with Kernel Event Tracing
      • Running the instrumented kernel
        • Kernel event data logging process
      • Generating a log file with kernel event trace data
        • Running a kernel event trace from the IDE
          • Kernel event trace log configuration
        • Controlling kernel event tracing outside of the IDE
      • Viewing and interpreting the captured data
        • Interpreting trace data in the IDE
          • System Profiler editor
          • Client/Server CPU Statistics
          • Condition Statistics
          • Event Owner Statistics
          • Filters
          • Full Trace Event Log
          • General Statistics
          • Raw Event Data
          • Thread Call Stack
          • Thread State Snapshot
          • Timeline State Colors
          • Why Running?
        • Interpreting trace data outside of the IDE
      • System Profiler use cases
        • Analyzing multiprocessor systems
        • Analyzing systems with Adaptive Partitioning scheduling
        • Locate sources of high CPU usage
        • Isolate client CPU load from server CPU load
        • Examine interrupt latency
        • Locate events of interest
        • Importing part of a kernel trace into the Application Profiler
    • Analyzing Memory Usage and Finding Errors
      • Memory optimization
        • Inspecting process memory
          • Inspecting process memory with the QNX System Information perspective
        • Enabling heap memory profiling
        • Optimizing heap memory
          • Shortening the lifecycle of heap objects
          • Reducing allocation overhead
            • Estimating the average allocation size
          • Tuning the allocator
        • Optimizing static and stack memory
      • Finding memory errors and leaks
        • Testing for memory leaks using the System Information tool
        • Using the Memory Analysis tool
          • Memory leaks
            • Enabling leak detection
            • Detecting leaks on demand
            • Interpreting leaks
          • Memory errors
            • Enabling memory error detection
            • Interpreting memory errors
          • Interpreting Memory Analysis results
            • Illegal deallocation of memory
            • NULL pointer dereference
            • Buffer overflow
            • Use of freed memory
            • Reading of uninitialized memory
            • Memory leaks
            • Summary of Memory Analysis errors
        • Using Mudflap
          • Configuring Mudflap to find errors
          • Options for Mudflap
          • Mudflap Violations view
          • Interpreting Mudflap output
      • The Memory Analysis tool
        • Launching your program with Memory Analysis
          • Configuring Memory Analysis sessions
          • Launching from the command line with Memory Analysis
          • Performing a postmortem analysis
          • Attaching to a running process
          • Tool options and environment variables
          • Tooling API
        • Viewing Memory Analysis data
          • Memory Analysis editor
            • Allocations tab
            • Bins tab
            • Bands tab
            • Usage tab
            • Settings tab
          • Memory Problems view
            • Memory Problems filter
            • Viewing statistics for memory problems
          • Memory Events view
            • Memory Events Filter
            • Viewing statistics for memory events
          • Memory Backtrace view
            • Inspecting outstanding allocations
        • Managing Memory Analysis sessions: The Session View
          • Opening a session
          • Deleting sessions
          • Closing a session
          • Filtering information for a session
          • Showing information about a session
          • Renaming a session
        • Importing Memory Analysis data
        • Exporting Memory Analysis data
          • CSV results file format
    • Building OS and Flash Images
      • QNX System Builder
      • Buildfiles
      • Overview of images
        • Components of an image, in order of booting
        • Types of images you can create
          • BSP filename conventions
          • OS image (.ifs file)
          • Flash filesystem image (.efs file)
          • Combined image
          • Padding after the IPL
        • Project layout
      • Workflow of OS image development
        • Creating a QNX System Builder project
          • Image combination details
        • Modifying a QNX System Builder project
        • Building a QNX System Builder project
        • Downloading an image to your target
          • Downloading using the Terminal view
            • Communicating with your target over a serial connection
            • Transferring an image over a serial connection
          • Downloading using TFTP
            • Transferring an image file
            • Transferring files that aren't in Images
          • Downloading using other methods
    • Tutorials
      • Before you start
      • Tutorial 1: Create a C/C++ project
      • Tutorial 2: Create a QNX C/C++ project
      • Tutorial 3: Import an existing project into the IDE
      • Tutorial 4: Import a QNX BSP into the IDE
    • Migrating from Earlier Releases
      • Migration considerations
        • Coexistence
        • Compiler versions
        • Binary compatibility
        • CDT impact on the IDE
        • Default workspace location
        • Old launch configurations don't switch perspectives automatically
        • Missing features in context menus
        • System Builder Console doesn't come to front
        • Reverting to an older version of the IDE
      • Migrate your projects
      • Migrate from IDE 4.5, IDE 4.6 or IDE 4.7 to IDE 5.0 (SDP 6.6.0)
      • Migrate from IDE 4.0.1 to IDE 5.0 (SDP 6.6.0)
    • Troubleshooting the IDE
    • Glossary
  • QNX Software Development Platform
    • Quickstart Guide
      • 1. Requirements
      • 2. Installing QNX SDP on the development host
      • 3. Installing the QNX Neutrino RTOS on the target system
      • 4. Networking with the QNX Neutrino RTOS
      • 5. Creating a program project
      • 6. Communicating with the QNX Neutrino RTOS
      • 7. Compiling and linking
      • 8. Preparing to launch the program
      • 9. Starting and debugging
      • 10. Making the program your own
    • OS Core Components
      • Adaptive Partitioning User's Guide
        • What is Adaptive Partitioning?
          • What are partitions and what is adaptive partitioning?
          • System and user requirements
          • The thread scheduler
        • Quickstart: Adaptive Partitioning Thread Scheduler
        • Using the Thread Scheduler
          • Keeping track of CPU time
          • How is CPU time divided between partitions?
            • Underload
            • Free time
            • Full Load
            • Summary of scheduling behavior
          • Partition inheritance
          • Critical threads
            • Bankruptcy
          • Adaptive partitioning thread scheduler and other thread schedulers
          • Using the thread scheduler and multicore together
        • Setting Up and Using the Adaptive Partitioning Thread Scheduler
          • Building an image
          • Creating scheduler partitions
          • Launching a process in a partition
          • Viewing partition use
        • Controlling Resources Using the Thread Scheduler
        • Considerations for the Thread Scheduler
          • Determining the number of scheduler partitions and their contents
          • Choosing the percentage of CPU for each partition
            • Setting budgets to zero
            • Setting budgets for resource managers
          • Choosing the window size
            • Accuracy
            • Delays compared to priority scheduling
          • Practical limits
          • Uncontrolled interactions between scheduler partitions
        • Security for Scheduler Partitions
        • Testing and Debugging
          • Instrumented kernel trace events
          • Using the IDE (trace events)
          • Using other methods
          • Emergency access to the system
        • Sample Buildfile
        • Frequently Asked Questions: Adaptive Partitioning Thread Scheduler
          • Scheduling behavior
          • Microbilling
          • Averaging window
          • Scheduling algorithm
          • Overhead
          • Critical threads and bankruptcy
          • Inheritance
          • Budgets
          • Joining a partition
          • QNX Neutrino system considerations
        • Glossary
      • Building Embedded Systems
        • Overview of Building Embedded Systems
          • Introduction
            • The role of the IPL
              • Warm-start and cold-start IPL
            • The role of the startup program
            • Startup's responsibilities
              • Copying and decompressing the image
              • Configuring the hardware
              • Determining system configuration
              • Establishing callouts
              • Starting the OS
              • The startup library
            • The role of the QNX Neutrino RTOS
          • Hardware aspects
            • Choice of processor
            • Source of initialization and configuration
            • Choice of filesystems
              • No additional storage required
              • Additional read-only storage required
              • Additional read/write nonpersistent storage required
              • Additional read/write persistent storage required
            • I/O devices
              • Character I/O devices
              • Special/custom devices
          • Getting started
            • Hardware design
            • Customizing the software
              • Customizing the source
        • Working with a BSP
          • Using BSPs in the IDE
          • Using BSPs on the command line
            • Structure of a BSP
              • prebuilt subdirectory
              • install subdirectory
              • src subdirectory
            • Building source from the command line
            • Supporting additional devices
          • Transferring an OS image onto your board
            • Transferring an OS image
            • Working with a flash filesystem
              • Raw partitions
              • Flash filesystem partitions
              • Flash filesystem source
              • How do I create a partition?
          • Testing QNX Neutrino on your board
          • Where do I go from here?
          • Filename conventions
        • Making an OS Image
          • Images, images, images
          • What is an OS image?
          • The OS image as a filesystem
          • Configuring an OS image
            • A simple buildfile
              • Inline files
            • The bootstrap file
              • Compressing the image
            • The script file
              • Bound multiprocessing attributes
              • The script file on the target
            • Plain ordinary lists of files
              • Including files from different places
              • Modifying the search path
              • Specifying the pathname explicitly
              • Creating the contents of the file in line
              • Specifying file ownership and permissions
              • Including a whole whack of files
            • Generating the image
            • Listing the contents of an image
          • Building a flash filesystem image
            • Using mkefs
              • mkefs buildfile
              • Block size
              • Spare blocks
            • Compressing files
              • Abstraction layer
              • Two sizes
            • Compression rules
              • The exception
          • Embedding an image
            • Combining image files using mkimage
              • Combining image files using the IDE
            • Converting images using mkrec
            • Transferring an image to flash
          • System configuration
            • Establishing an output device
              • A simple desktop example
            • Running drivers/filesystems
              • Disk drivers
              • Flash filesystems
              • Network drivers
              • Network filesystems
            • Running applications
          • Debugging an embedded system
            • pdebug software debugging agent
            • Hardware debuggers and QNX Neutrino
            • Producing debug symbol information for IPL and startup
              • Generating IPL debug symbols
              • Generating startup debug symbols
        • Writing an IPL Program
          • Initial program loader (IPL)
            • Responsibilities of the IPL
              • Linearly mapped images
              • Bank-switched images
              • Processors & configurations
            • Booting from a bank-switched device
            • Booting from a linear device
            • "Warm" vs "cold" start
              • Warm-start IPL
              • Cold-start IPL
            • Loading the image
              • If the source is a linearly mapped device
              • If the source is a bank-switched device
              • ROM devices
              • Network boot
              • Using a BOOTP server
              • Serial port
              • Traditional disk
              • None of the above?
            • Transferring control to the startup program
          • Customizing IPLs
            • Initialize hardware
            • Loading the image into RAM
            • Structure of the boot header
              • signature
              • version
              • flags1 and flags2
              • header_size
              • machine
              • startup_vaddr
              • paddr_bias
              • image_paddr
              • ram_paddr
              • ram_size
              • startup_size
              • stored_size
              • imagefs_paddr
              • imagefs_size
              • preboot_size
              • zero and zero0
              • info
              • struct startup_info_skip
              • struct startup_info_mem and startup_info_mem_extended
              • struct startup_info_disk
              • struct startup_info_time
              • struct startup_info_box
            • Relationship of struct startup_header fields
              • Linear ROM execute-in-place boot image
              • Linear ROM compressed boot image
              • ROM non-XIP image
              • Disk/network image (x86 BIOS)
              • Disk/network compressed image
            • IPL structure
              • IPL source directory structure
              • IPL code structure
              • An example
            • Creating a new IPL
          • The IPL library
            • enable_cache
            • image_download_8250()
            • image_scan()
            • image_scan_ext()
            • image_setup()
            • image_setup_ext()
            • image_start()
            • image_start_ext()
            • int15_copy()
            • print_byte()
            • print_char()
            • print_long()
            • print_sl()
            • print_string()
            • print_var()
            • print_word()
            • protected_mode()
            • uart_hex8
            • uart_hex16
            • uart_hex32
            • uart_init
            • uart_put
            • uart_string
            • uart32_hex8
            • uart32_hex16
            • uart32_hex32
            • uart32_init
            • uart32_put
            • uart32_string
        • Customizing Image Startup Programs
          • Anatomy of a startup program
            • Structure of a startup program
            • Creating a new startup program
          • Structure of the system page
            • size
            • total_size
            • type
            • num_cpu
            • system_private
            • asinfo
              • The attr field
              • Address space trees
            • hwinfo
              • Tags
              • Items
              • Device trees
              • Building the section
              • Other functions
              • Defaults
              • Predefined items and tags
              • Group item
              • Bus item
              • Device item
              • location tag
              • irq tag
              • diskgeometry tag
              • pad tag
            • cpuinfo
            • syspage_entry cacheattr
            • syspage_entry qtime
            • callout
            • callin
            • typed_strings
            • strings
            • intrinfo
              • The cpu_intr_base member
              • The flags member
              • config return values
            • syspage_entry union un
            • un.x86
            • un.x86.smpinfo (deprecated)
            • un.arm
            • smp
            • pminfo
          • Callout information
            • Debug interface
            • Clock/timer interface
            • Interrupt controller interface
            • Cache controller interface
            • System reset callout
            • Power management callout
          • The startup library
            • add_cache()
            • add_callout()
            • add_callout_array()
            • add_interrupt()
            • add_interrupt_array()
            • add_ram()
            • add_string()
            • add_typed_string()
            • alloc_qtime()
            • alloc_ram()
            • armv_cache
            • armv_chip
            • armv_chip_detect()
            • armv_pte
            • armv_setup_v7()
            • as_add()
            • as_add_containing()
            • as_default()
            • as_find()
            • as_find_containing()
            • as_info2off()
            • as_off2info()
            • as_set_checker()
            • as_set_priority()
            • avoid_ram()
            • calc_time_t()
            • calloc_ram()
            • callout_io_map(), callout_io_map_indirect()
            • callout_memory_map(), callout_memory_map_indirect()
            • callout_register_data()
            • chip_access()
            • chip_done()
            • chip_read8()
            • chip_read16()
            • chip_read32()
            • chip_write8()
            • chip_write16()
            • chip_write32()
            • copy_memory()
            • del_typed_string()
            • falcon_init_l2_cache()
            • falcon_init_raminfo()
            • falcon_system_clock()
            • find_startup_info()
            • find_typed_string()
            • handle_common_option()
            • hwi_add_device()
            • hwi_add_inputclk()
            • hwi_add_irq()
            • hwi_add_location()
            • hwi_add_nicaddr()
            • hwi_add_rtc()
            • hwi_alloc_item()
            • hwi_alloc_tag()
            • hwi_find_as()
            • hwi_find_item()
            • hwi_find_tag()
            • hwi_off2tag()
            • hwi_tag2off()
            • init_asinfo()
            • init_cacheattr()
            • init_cpuinfo()
            • init_hwinfo()
            • init_intrinfo()
            • init_mmu()
            • init_pminfo()
            • init_qtime()
            • init_qtime_sa1100()
            • init_raminfo()
            • init_smp()
            • init_syspage_memory() (deprecated)
            • init_system_private()
            • jtag_reserve_memory()
            • kprintf()
            • pcnet_reset()
            • print_syspage()
            • rtc_time()
            • startup_io_map()
            • startup_io_unmap()
            • startup_memory_map()
            • startup_memory_unmap()
            • tulip_reset()
            • uncompress()
            • x86_cpuid_string()
            • x86_cputype()
            • x86_enable_a20()
            • x86_fputype()
            • x86_init_pcbios()
            • x86_pcbios_shadow_rom()
            • x86_scanmem()
          • Writing your own kernel callout
            • Find out who's gone before
            • Why are they in assembly language?
            • Starting off
            • "Patching" the callout code
            • Getting some R/W storage
            • The exception that proves the rule
        • Customizing the Flash Filesystem
          • Introduction
          • Driver structure
            • resmgr and iofunc layers
            • Flash filesystem component
            • Socket services component
            • Flash services component
            • Probe routine component
          • Building your flash filesystem driver
            • The source tree
            • The Makefile
            • Making the driver
            • The main() function
              • f3s_init()
              • f3s_start()
            • Socket services interface
              • f3s_open()
              • f3s_page()
              • f3s_status()
              • f3s_close()
            • Options parsing
              • f3s_socket_option()
              • f3s_socket_syspage()
            • Flash services interface
              • f3s_ident()
              • f3s_reset()
              • f3s_v2read()
              • f3s_v2write()
              • f3s_v2erase()
              • f3s_v2suspend()
              • f3s_v2resume()
              • f3s_v2sync()
              • f3s_v2islock()
              • f3s_v2lock()
              • f3s_v2unlock()
              • f3s_v2unlockall()
            • Choosing the right routines
          • Example: The devf-ram driver
            • main()
            • f3s_ram_open()
            • f3s_ram_page()
        • System Design Considerations
          • Before you design your system
          • Other design considerations
            • EPROM/Flash filesystem considerations
            • IPL location
            • Graphics cards
            • A20 gate
            • External ISA bus slots
            • PCI bus slots
            • External clocks
            • Interrupts & controllers
            • Serial and parallel ports
            • Parallel port considerations
          • Avoid Non-Maskable Interrupts (NMIs)
          • Design do's and don'ts
        • Sample Buildfiles
          • Generic examples
            • Shared libraries
            • Running executables more than once
            • Multiple consoles
              • Starting other programs on consoles
              • Redirection
              • /tmp
            • Complete example — minimal configuration
            • Complete example — flash filesystem
            • Complete example — disk filesystem
            • Complete example — TCP/IP with network filesystem
          • Processor-specific notes
        • Glossary
      • Core Networking Stack User's Guide
        • Overview
          • Architecture of io-pkt
          • Threading model
          • Threading priorities
          • Components of core networking
        • Packet Filtering
          • Packet Filter interface
            • Packet Filter (pf) module: firewalls and NAT
          • Berkeley Packet Filter
        • IP Security and Hardware Encryption
          • Setting up an IPsec connection: examples
            • Between two boxes manually
            • With authentication using the preshared-key method
          • IPsec tools
          • OpenSSL support
          • Hardware-accelerated crypto
        • Wi-Fi Configuration Using WPA and WEP
          • NetBSD 802.11 layer
            • Device management
            • Nodes
            • Crypto support
          • Using Wi-Fi with io-pkt
          • Connecting to a wireless network
            • Using no encryption
            • Using WEP (Wired Equivalent Privacy) for authentication and encryption
            • Using WPA/WPA2 for authentication and encryption
              • WPA utilities
              • Connecting with WPA or WPA2
              • Personal-level authentication and Enterprise-level authentication
              • Using wpa_supplicant to manage your wireless network connections
          • Using a Wireless Access Point (WAP)
            • Creating A WAP
              • Acting as a gateway
              • Acting as a bridge
            • WEP access point
            • WPA access point
          • TCP/IP configuration in a wireless network
            • Client in infrastructure or ad hoc mode
            • DHCP server on WAP acting as a gateway
            • Launching the DHCP server on your gateway
            • Configuring an access point as a router
        • Transparent Distributed Processing
          • Using TDP over IP
        • Network Drivers
          • Types of network drivers
            • Differences between ported NetBSD drivers and native drivers
            • Differences between io-net drivers and other drivers
          • Loading and unloading a driver
          • Troubleshooting a driver
          • Problems with shared interrupts
          • Writing a new driver
          • Debugging a driver using gdb
          • Dumping 802.11 debugging information
          • Jumbo packets and hardware checksumming
          • Padding Ethernet packets
          • Transmit Segmentation Offload (TSO)
        • Utilities, Managers, and Configuration Files
        • Writing Network Drivers for io-pkt
        • A Hardware-Independent Sample Driver: sam.c
        • Additional information
        • Glossary
      • Device Publishers Developer's Guide
        • Device Publishers
          • Running a device publisher
          • Role of device drivers and mcd
          • PPS object types
          • Plugins
            • Plugin ratings
        • The usblauncher Service
          • Support for USB On-The-Go (OTG)
          • Device object
          • Device control object
          • Driver object
          • Mount object
          • Command line for usblauncher
            • Using usblauncher to mount filesystems
          • Configuration files
            • Starting USB stack in host and device modes
            • USB matching rules
            • USB descriptors
            • Supported third-party applications and protocols
        • The mmcsdpub Publisher
          • Device object
          • Driver object
          • Mount object
          • Command line for mmcsdpub
        • The cdpub Publisher
          • Device object
          • Device control object
          • Driver object
          • Mount object
          • Command line for cdpub
      • High Availability Framework Developer's Guide
        • Introduction
          • Where's the problem?
          • A software foundation for HA
        • What's in the High Availability Framework?
        • The QNX Neutrino Approach to HA
          • The reset "solution"
            • Traditional RTOS architecture
          • Modularity means granularity
            • Intrinsic HA
        • Using the High Availability Manager
          • HAM hierarchy
            • Entities
            • Conditions
            • Actions
            • Action Fail actions
            • Multistaged recovery
          • State of the HAM
            • Example of the view shown in /proc/ham
          • HAM API
            • Connect/disconnect functions
            • Attach/detach functions
              • For self-attached entities
              • Code snippet using self-attach/detach calls
              • For attaching/detaching all other entities
              • Code snippet using attach/detach calls
            • Entity functions
            • Condition functions
              • Condition types
              • Condition flags
            • Action functions
            • Action fail functions
              • Example to monitor inetd
              • Example to monitor fs-nfs2
            • Functions to operate on handles
          • A client example
          • Starting and stopping a HAM
            • Stopping a HAM
            • Control functions
            • Verbosity control
            • Publishing autonomously detected conditions
            • Publish state transitions
            • Publish other conditions
            • Subscribing to autonomously published conditions
            • Trigger based on state transitions
            • Trigger based on specific published condition
        • Using the Client Recovery Library
          • MsgSend*() functions
          • Other covers and convenience functions
            • HA-awareness functions
            • I/O covers
            • Convenience functions
          • A simple example
          • State-reconstruction example
        • HAM API Reference
          • ham_action_control()
          • ham_action_execute()
          • ham_action_fail_execute()
          • ham_action_fail_log()
          • ham_action_fail_notify_pulse(), ham_action_fail_notify_pulse_node()
          • ham_action_fail_notify_signal(), ham_action_fail_notify_signal_node()
          • ham_action_fail_waitfor()
          • ham_action_handle(), ham_action_handle_node()
          • ham_action_handle_free()
          • ham_action_heartbeat_healthy()
          • ham_action_log()
          • ham_action_notify_pulse(), ham_action_notify_pulse_node()
          • ham_action_notify_signal(), ham_action_notify_signal_node()
          • ham_action_remove()
          • ham_action_restart()
          • ham_action_waitfor()
          • ham_attach(), ham_attach_node()
          • ham_attach_self()
          • ham_condition()
          • ham_condition_control()
          • ham_condition_handle(), ham_condition_handle_node()
          • ham_condition_handle_free()
          • ham_condition_raise()
          • ham_condition_remove()
          • ham_condition_state()
          • ham_connect(), ham_connect_nd(), ham_connect_node()
          • ham_detach()
          • ham_detach_name(), ham_detach_name_node()
          • ham_detach_self()
          • ham_disconnect(), ham_disconnect_nd(), ham_disconnect_node()
          • ham_entity(), ham_entity_node()
          • ham_entity_condition_raise()
          • ham_entity_condition_state()
          • ham_entity_control()
          • ham_entity_handle(), ham_entity_handle_node()
          • ham_entity_handle_free()
          • ham_heartbeat()
          • ham_stop(), ham_stop_nd(), ham_stop_node()
          • ham_verbose()
        • Client Recovery Library Reference
          • ha_attach()
          • ha_close()
          • ha_connection_ctrl()
          • ha_ConnectAttach(), ha_ConnectAttach_r()
          • ha_ConnectDetach(), ha_ConnectDetach_r()
          • ha_creat(), ha_creat64()
          • ha_detach()
          • ha_dup()
          • ha_fclose()
          • ha_fopen()
          • ha_open(), ha_open64()
          • ha_ReConnectAttach()
          • ha_reopen()
        • Examples
          • Simple restart
          • Compound restart
          • Death/condition notification
          • Heartbeating clients (liveness detection)
            • The process is made to heartbeat
          • Process starvation
            • Thread 2 is made to heartbeat
        • Glossary
      • Instant Device Activation
        • Using Minidrivers for Instant Device Activation
          • The minidriver basics
          • The minidriver architecture
          • How does the minidriver work?
            • Seamless transition
            • Running multiple handler functions
        • Writing a Minidriver
          • Timing requirements
          • Data storage
          • Handler function
            • Hardware access
            • Debugging from within the minidriver
          • Customizing the startup program to include your minidriver
          • Making the transition to a full driver
          • Making a boot image that includes your minidriver
        • Sample Minidriver
          • The minidriver handler function
          • Adding your minidriver to the system
          • Test application: mini-peeker.c
          • Transition from minidriver to full driver
        • APIs and Datatypes
          • mdriver_add()
          • mdriver_entry
          • mdriver_max
        • Hardware Interaction Within the Minidriver
      • Multicore Processing User's Guide
        • What is Multicore Processing?
        • A Quick Introduction to Multicore Processing
          • Setting up the OS image
          • Trying symmetric multiprocessing
          • Trying bound multiprocessing
        • Developing Multicore Systems
          • Building a multicore image
          • The impact of multicore
            • To multicore or not to multicore
            • Thread affinity
            • Multicore and synchronization primitives
            • Multicore and FIFO scheduling
            • Multicore and interrupts
            • Multicore and atomic operations
            • Adaptive partitioning
          • Designing with multiprocessing in mind
            • Use the multicore primitives
            • Assume that threads really do run concurrently
            • Break the problem down
        • Glossary
      • Persistent Publish/Subscribe Developer's Guide
        • QNX Neutrino PPS Service
          • Running PPS
        • Objects and Their Attributes
          • Object files
            • Special objects
            • Object and directory sizes
          • Change notification
          • Object syntax
          • Attribute syntax
        • Persistence
          • Persistent storage
          • Saving objects
          • Loading objects
        • Publishing
          • Creating, modifying, and deleting objects and attributes
          • Multiple publishers
        • Subscribing
          • Waiting for data on a file descriptor
          • Subscription modes
            • Full mode
            • Delta mode
          • Subscribing to multiple objects
            • Subscribe to all objects in a directory
            • Notification groups
              • Creating notification groups
              • Using notification groups
        • Options and Qualifiers
          • Pathname open options
            • The critical option
            • Filtering notifications
          • Object and attribute qualifiers
            • Nonpersistence qualifier
            • Item qualifier
          • Reading and writing from the command line
          • Access Control List configuration file
            • ACL configuration file format
        • Server Objects
          • Working with server objects
            • Sending messages through PPS server objects
              • Sending a message
              • Replying to a message
              • Supporting cancellation of requests
        • PPS Encoding and Decoding API
          • Encoding PPS data
          • Decoding PPS data
            • Handling unknown data
            • Dealing with errors
          • Other features of PPS
        • PPS API reference
          • pps_attrib_flags_t
          • pps_attrib_t
          • pps_decoder_cleanup()
          • pps_decoder_dump_tree()
          • pps_decoder_error_t
          • pps_decoder_flags()
          • pps_decoder_get_bool()
          • pps_decoder_get_double()
          • pps_decoder_get_int()
          • pps_decoder_get_int64()
          • pps_decoder_get_state()
          • pps_decoder_get_string()
          • pps_decoder_goto_index()
          • pps_decoder_initialize()
          • pps_decoder_is_integer()
          • pps_decoder_length()
          • pps_decoder_name()
          • pps_decoder_next()
          • pps_decoder_parse_json_str()
          • pps_decoder_parse_pps_str()
          • pps_decoder_pop()
          • pps_decoder_push()
          • pps_decoder_push_array()
          • pps_decoder_push_object()
          • pps_decoder_reset()
          • pps_decoder_set_position()
          • pps_decoder_set_state()
          • pps_decoder_state_t
          • pps_decoder_status()
          • pps_decoder_t
          • pps_decoder_type()
          • pps_encoder_add_bool()
          • pps_encoder_add_double()
          • pps_encoder_add_from_decoder()
          • pps_encoder_add_int()
          • pps_encoder_add_int64()
          • pps_encoder_add_json()
          • pps_encoder_add_null()
          • pps_encoder_add_string()
          • pps_encoder_buffer()
          • pps_encoder_cleanup()
          • pps_encoder_delete_attribute()
          • pps_encoder_end_array()
          • pps_encoder_end_object()
          • pps_encoder_error_t
          • pps_encoder_initialize()
          • pps_encoder_length()
          • pps_encoder_reset()
          • pps_encoder_start_array()
          • pps_encoder_start_object()
          • pps_encoder_t
          • pps_node_type_t
          • pps_options_t
          • pps_status_t
          • ppsparse()
        • Examples
          • Publishers
          • Subscribers
      • QDB Developer's Guide
        • Getting Started with QDB
          • Starting the QDB server
          • Loading QDB databases
          • Unloading QDB databases
          • PPS configuration path
          • Database configuration objects
          • Database storage
          • Schema files
          • Summary of database files
        • QDB Command Line
          • Temporary storage filesystem
          • Database integrity testing
          • Sharing connections between clients
          • Shared caching
            • Advantages of shared caching
          • Database recovery
          • Busy timeout
          • Handling corrupt databases
        • QDB Client
          • Backing up and restoring databases
        • QDB Example
          • Connecting to a database
            • Using asynchronous mode
          • Executing a statement
          • Getting the result of a query
          • Using a result
          • Disconnecting from the server
          • Sample program
        • Datatypes in QDB
          • Storage classes
          • Column affinity
            • Determination of column affinity
            • Column affinity example
          • Comparison expressions
            • Comparison example
          • Operators
          • Sorting, grouping and compound SELECT statements
          • Other affinity modes
          • User-defined collation sequences
            • Assigning collation sequences from SQL
            • Collation sequences example
        • QDB Virtual Machine Opcodes
          • Instruction format and execution
          • Virtual machine features
          • Viewing programs generated by QDB
          • The opcodes
        • Writing User-Defined Functions
          • User scalar/aggregate functions
          • User collation routines
          • Collation algorithm example
          • SQLite C/C++ API
            • sqlite3_result_*
            • sqlite3_value_*
            • sqlite3_user_data
        • QDB API Reference
          • qdb_backup()
          • qdb_binding_t
          • qdb_bkcancel()
          • qdb_cell()
          • qdb_cell_length()
          • qdb_cell_type()
          • qdb_collation()
          • qdb_column_decltype()
          • qdb_column_index()
          • qdb_column_name()
          • qdb_columns()
          • qdb_connect()
          • qdb_data_source()
          • qdb_disconnect()
          • qdb_freeresult()
          • qdb_getdbsize()
          • qdb_geterrcode()
          • qdb_geterrmsg()
          • qdb_getoption()
          • qdb_getresult()
          • qdb_gettransstate()
          • qdb_interrupt()
          • qdb_last_insert_rowid()
          • qdb_mprintf()
          • qdb_parameters()
          • qdb_printmsg()
          • qdb_query()
          • qdb_rowchanges()
          • qdb_rows()
          • qdb_setbusytimeout()
          • qdb_setoption()
          • qdb_snprintf()
          • qdb_statement()
          • qdb_stmt_decltypes()
          • qdb_stmt_exec()
          • qdb_stmt_free()
          • qdb_stmt_init()
          • qdb_vacuum()
          • qdb_vmprintf()
        • QDB SQL Reference
          • Row ID and Autoincrement
          • Comments
          • Expressions
          • Keywords
          • Statements
            • ALTER TABLE
            • ANALYZE
            • ATTACH DATABASE
            • CREATE INDEX
            • CREATE TABLE
            • CREATE TRIGGER
            • CREATE VIEW
            • DELETE
            • DETACH DATABASE
            • DROP INDEX
            • DROP TABLE
            • DROP TRIGGER
            • DROP VIEW
            • EXPLAIN
            • INSERT
            • ON CONFLICT
            • PRAGMA
            • REINDEX
            • REPLACE
            • SELECT
            • TRANSACTION
            • UPDATE
            • VACUUM
        • fileset Reference
      • QNX SDP 6.6.0 BSPs
        • Overview of a BSP
        • Before you begin
        • What's new with QNX SDP 6.6 BSPs
          • Structure and contents of a QNX SDP 6.6 BSP
          • Preparing a bootable SD card
            • Preparing a bootable SD card (Windows 7)
            • Preparing a bootable SD card (Linux Ubuntu)
        • Process to update a BSP to QNX SDP 6.6
          • Prerequisites
          • Download, extract, and build an existing BSP
          • Interpret initial results and remove unnecessary files
          • Rebuild the BSP
          • Update the startup and IPL library source
          • Update BSPs containing prebuilt kernels and other OS components
        • Clean Up Remaining Warnings
      • System Analysis Toolkit (SAT) User's Guide
        • Introduction
          • What can the SAT do for you?
          • Components of the SAT
        • Events and the Kernel
          • Generating events: a typical scenario
            • Multithreaded example
            • Thread context-switch time
            • Restarting threads
          • Simple and combine events
          • Fast and wide modes
          • Classes and events
            • Communication class: _NTO_TRACE_COMM
            • Control class: _NTO_TRACE_CONTROL
            • Interrupt classes: _NTO_TRACE_INTENTER, _NTO_TRACE_INTEXIT,_NTO_TRACE_INT_HANDLER_ENTER, and _NTO_TRACE_INT_HANDLER_EXIT
            • Kernel-call classes: _NTO_TRACE_KERCALLENTER, _NTO_TRACE_KERCALLEXIT, and _NTO_TRACE_KERCALLINT
            • Process class: _NTO_TRACE_PROCESS
            • System class: _NTO_TRACE_SYSTEM
            • Thread class: _NTO_TRACE_THREAD
            • User class: _NTO_TRACE_USER
            • Virtual thread class: _NTO_TRACE_VTHREAD
        • Kernel Buffer Management
          • Ring buffer size
          • Full buffers and the high-water mark
          • Buffer overruns
        • Capturing Trace Data
          • Using tracelogger to control tracing
            • Managing trace buffers
            • tracelogger's modes of operation
            • Choosing between wide and fast modes
            • Filtering events
            • Specifying where to send the output
          • Using TraceEvent() to control tracing
            • Managing trace buffers
            • Modes of operation
            • Filtering events
            • Choosing between wide and fast modes
            • Inserting trace events
        • Filtering
          • The static rules filter
          • The dynamic rules filter
            • Setting up a dynamic rules filter
            • Event handler
            • Removing event handlers
          • The post-processing facility
        • Interpreting Trace Data
          • Using traceprinter and interpreting the output
          • Building your own parser
            • The traceparser library
            • Simple and combine events, event buffer slots, and the traceevent_t structure
            • Event interlacing
            • Timestamps
        • Tutorials
          • The instrex.h header file
          • Gathering all events from all classes
          • Gathering all events from one class
          • Gathering five events from four classes
          • Gathering kernel calls
          • Event handling - simple
          • Inserting a user simple event
        • Sample programs
          • Data-capture program
          • Parser
        • Current Trace Events and Data
          • Interpreting the table
          • Table of events
      • System Architecture
        • The Philosophy of the QNX Neutrino RTOS
          • An embeddable POSIX OS?
          • Product scaling
          • Why POSIX for embedded systems?
          • Why QNX Neutrino for embedded systems?
          • Microkernel architecture
            • The OS as a team of processes
            • A true kernel
            • System processes
          • Interprocess communication
            • QNX Neutrino as a message-passing operating system
          • Network distribution of kernels
            • Single-computer model
            • Flexible networking
        • The QNX Neutrino Microkernel
          • The implementation of the QNX Neutrino RTOS
            • POSIX realtime and thread extensions
          • System services
          • Threads and processes
            • Thread attributes
            • Thread life cycle
          • Thread scheduling
            • Scheduling priority
            • Scheduling policies
              • FIFO scheduling
              • Round-robin scheduling
              • Sporadic scheduling
              • Manipulating priority and scheduling policies
            • IPC issues
            • Thread complexity issues
          • Synchronization services
            • Mutexes: mutual exclusion locks
              • Priority inheritance and mutexes
            • Condvars: condition variables
            • Barriers
            • Sleepon locks
            • Reader/writer locks
            • Semaphores
            • Synchronization via scheduling policy
            • Synchronization via message passing
            • Synchronization via atomic operations
            • Synchronization services implementation
          • Clock and timer services
            • Time correction
            • Timers
          • Interrupt handling
            • Interrupt latency
            • Scheduling latency
            • Nested interrupts
            • Interrupt calls
        • Interprocess Communication (IPC)
          • Synchronous message passing
          • Message copying
          • Simple messages
          • Channels and connections
          • Pulses
          • Priority inheritance and messages
            • Server boost
          • Message-passing API
          • Robust implementations with Send/Receive/Reply
          • Events
            • I/O notification
          • Signals
            • Special signals
            • Summary of signals
          • POSIX message queues
          • Shared memory
            • Shared memory with message passing
            • Creating a shared-memory object
            • mmap()
            • Initializing allocated memory
          • Typed memory
            • Implementation-defined behavior
              • Seeding of typed memory regions
              • Naming of typed memory regions
              • Pathname space and typed memory
              • mmap() allocation flags and typed memory objects
              • Permissions and typed memory objects
              • Object length and offset definitions
              • Interaction with other POSIX APIs
            • Practical examples
          • Pipes and FIFOs
        • The Instrumented Microkernel
          • Instrumentation at a glance
          • Event control
            • Modes of emission
            • Ring buffer
          • Data interpretation
            • System analysis with the IDE
          • Proactive tracing
        • Multicore Processing
          • Asymmetric multiprocessing (AMP)
          • Symmetric multiprocessing (SMP)
            • The QNX Neutrino RTOS's microkernel approach
            • Booting an x86 SMP system
            • How the SMP microkernel works
            • Critical sections
          • Bound multiprocessing (BMP)
            • A viable migration strategy
          • Choosing between AMP, SMP, and BMP
        • Process Manager
          • Process management
            • Process primitives
              • posix_spawn()
              • spawn()
              • fork()
              • exec*()
            • Process loading
          • Memory management
            • Memory Management Units (MMUs)
            • Memory protection at run time
              • Software watchdog
            • Quality control
            • Full-protection model
              • Private virtual memory
            • Variable page size
            • Locking memory
            • Defragmenting physical memory
              • Automatically marking memory as unmovable
          • Pathname management
            • Resolving pathnames
            • Symbolic prefixes
              • Creating special device names
              • Relative pathnames
              • Network root
              • A note about cd
            • File descriptor namespace
              • Open control blocks
        • Dynamic Linking
          • How shared objects are used
            • Memory layout for a typical process
            • Runtime linker
            • Loading a shared library at runtime
            • Symbol name resolution
        • Resource Managers
          • What is a resource manager?
            • Why write a resource manager?
            • The types of resource managers
              • Device resource managers
              • Filesystem resource managers
            • Communication via native IPC
          • Resource manager architecture
            • Message types
            • The resource manager shared library
              • Automatic default message handling
              • open(), dup(), and close()
              • Multiple thread handling
              • Dispatch functions
              • Combine messages
              • Second-level default message handling
          • Summary
        • Filesystems
          • Filesystems and pathname resolution
          • Filesystem classes
            • Filesystems as shared libraries
            • io-blk
              • Builtin RAM disk
              • Partitions
              • Buffer cache
            • Filesystem limitations
          • Image filesystem
          • RAM "filesystem"
          • Embedded transaction filesystem (ETFS)
          • QNX 4 filesystem
          • Power-Safe filesystem
            • Problems with existing disk filesystems
            • Copy-on-write filesystem
            • Performance
            • Encryption
          • DOS Filesystem
          • CD-ROM filesystem
          • FFS3 filesystem
          • NFS filesystem
          • CIFS filesystem
          • Linux Ext2 filesystem
          • Universal Disk Format (UDF) filesystem
          • Apple Macintosh HFS and HFS Plus
          • Windows NT filesystem
          • Inflator pass-through filesystem
          • Filesystem events
        • PPS
          • Persistence
          • PPS objects
          • Publishing
          • Subscribing
        • Character I/O
          • Driver/io-char communication
          • Device control
          • Input modes
            • Raw input mode
            • Edited input mode
          • Device subsystem performance
          • Console devices
          • Serial devices
          • Parallel devices
          • Pseudo terminal devices (ptys)
        • Networking Architecture
          • Network manager (io-pkt*)
          • Threading model
          • Protocol module
          • Driver module
        • Native Networking (Qnet)
          • QNX Neutrino distributed
          • Name resolution and lookup
            • File descriptor (connection ID)
            • Behind a simple open()
            • Global Name Service (GNS)
            • Network naming
              • Resolvers
          • Redundant Qnet: Quality of Service (QoS) and multiple paths
            • QoS policies
            • Specifying QoS policies
            • Symbolic links
          • Examples
        • TCP/IP Networking
          • Structure of the TCP/IP manager
          • Socket API
            • Database routines
          • Multiple stacks
          • IP filtering and NAT
          • NTP
          • Dynamic host configuration
            • AutoIP
          • PPP over Ethernet
          • /etc/autoconnect
        • High Availability
          • An OS for HA
            • Inherent HA
            • HA-specific modules
          • Custom hardware support
          • Client library
            • Recovery example
          • High Availability Manager
            • HAM and the Guardian
            • HAM hierarchy
              • Entities
              • Conditions
              • Actions
            • Publishing autonomously detected conditions
              • State transitions
              • Other conditions
            • Subscribing to autonomously published conditions
            • HAM as a "filesystem"
            • Multistage recovery
            • HAM API
        • Adaptive Partitioning
          • Why adaptive?
          • Benefits of adaptive partitioning
            • Engineering product performance
            • Dealing with design complexity
            • Providing security
            • Debugging
          • Adaptive partitioning thread scheduler
        • What is Real Time and Why Do I Need It?
        • Glossary
      • Technotes
        • Writing a DVFS Driver
          • dvfs_fini()
          • dvfs_init()
          • dvfs_pre_init()
          • dvfs_therm_init()
          • get_cpu_freq()
          • get_cpu_temperature()
          • get_cpu_voltage()
          • get_pwr_levels_count()
          • get_pwr_lvl_freq()
          • get_pwr_lvl_volt()
          • post_pwr_lvl_config()
          • set_cpu_freq()
          • set_cpu_voltage()
          • update_boundaries()
        • IP Tunneling (Generic Routing Encapsulation)
        • PPPOE and Path MTU Discovery
        • Making Multiple Images
        • QNX Neutrino and QNX 4 bootloader partitions
          • Encountering the .altboot message
          • Booting or rebooting using a partition bootloader
          • Resolving problems with bootloader partitions
        • POSIX Message Queues: Two Implementations
        • Choosing the Correct MTD Routine for the Flash Filesystem
        • Reading a Kernel Dump
        • I2C (Inter-Integrated Circuit) Framework
          • Hardware interface
            • Function table
              • version_info function
              • init function
              • fini function
              • send function
              • recv function
              • abort function
              • set_slave_addr function
              • set_bus_speed function
              • driver_info function
              • ctl function
            • Access function
            • Sample calls
          • Application interfaces
            • Shared-library interface
            • Resource manager interface
              • Supporting data types
              • DCMD_I2C_DRIVER_INFO
              • DCMD_I2C_MASTER_RECV (deprecated)
              • DCMD_I2C_MASTER_SEND (deprecated)
              • DCMD_I2C_RECV
              • DCMD_I2C_SEND
              • DCMD_I2C_SENDRECV
              • DCMD_I2C_SET_BUS_SPEED
              • DCMD_I2C_SET_SLAVE_ADDR (deprecated)
              • DCMD_I2C_STATUS
          • Resource manager design
        • SPI (Serial Peripheral Interface) Framework
          • Hardware interface
            • Function table
            • Low-level module handle structure
            • init function
            • fini function
            • drvinfo function
            • devinfo function
            • setcfg function
            • xfer function
            • dma_xfer function
          • API library
            • spi_open()
            • spi_close()
            • spi_setcfg()
            • spi_getdevinfo()
            • spi_getdrvinfo()
            • spi_read()
            • spi_write()
            • spi_xchange()
            • spi_cmdread()
            • spi_dma_xchange()
        • Fine-tuning your network drivers
        • Backtraces
          • API
          • Examples
            • Obtaining and printing a memory map
            • Backtracing a thread in another process
            • Backtracing another thread within the same process
            • Backtracing the current thread
            • Doing a BT_SELF backtrace in a signal handler
            • Backtracing a collection of threads
        • Reloadable Image Filesystems
          • Command-line options
          • Examples
          • Minidriver support
          • Performance measurements
          • Manually mounting an IFS
          • Sample script to combine IPL with boot image for the EDOSK7780
          • Commands to burn a new IPL/Boot image for the EDOSK7780
        • Filesystems and Power Failures
          • Guidelines for using hard drives in an environment subject to abrupt power failures
          • Recipe for creating hard drive corruption
          • How to limit the possible hard drive corruption
          • How to repair hard disk corruption
          • Power failures while writing
        • Customizing language sort orders for libqdb_cldr.so
          • Standard language sort order files
          • Sort order algorithm
            • Contractions and expansions
            • Locale data files
          • Adding a new sort order locale
          • Tailoring a sort order algorithm
      • User's Guide
        • Getting to Know the OS
          • QNX Neutrino compared with Unix
          • QNX Neutrino compared with Microsoft Windows
          • How QNX Neutrino is unique
            • Resource managers
        • Logging In, Logging Out, and Shutting Down
          • root or non-root?
          • Logging in
          • Once you've logged in
          • Logging out
          • Shutting down and rebooting
        • Managing User Accounts
          • What does a user account do?
            • User accounts vs user IDs: login, lookup, and permissions
            • What happens when you log in?
          • Account database
            • /etc/passwd
            • /etc/group
            • /etc/shadow
            • /etc/.pwlock
          • Managing your own account
            • Changing your password
            • Forgot your password?
          • Managing other accounts
            • Adding users
            • Removing accounts
            • Defining groups
              • Creating a new group
              • Modifying an existing group
          • Troubleshooting
        • Using the Command Line
          • Processing a command
          • Character-device drivers
            • Input modes
            • Terminal support
            • Telnet
            • The keyboard at a glance
            • Physical and virtual consoles
          • Shell
            • Editing the command line
            • Command and filename completion
            • Reserved words
            • Entering multiple commands
            • Aliases
            • Substitutions
            • Redirecting input and output
            • Pipes
            • Quoting special characters
            • History: recalling commands
            • Shell scripts
          • Utilities
            • Understanding command syntax
            • Displaying online usage messages
            • Executing commands on another node or tty
            • Priorities
          • Basic commands
          • QNX Neutrino for MS-DOS users
            • DOS commands and their QNX Neutrino equivalents
            • MS-DOS local command-interpreter variables
          • Troubleshooting
        • Working with Files
          • Types of files
          • Filenames and pathnames
            • Absolute and relative pathnames
            • Dot and dot-dot directories
            • No drive letters
            • Pathnames that begin with a dot
            • Extensions
            • Pathname-space mapping
            • Filename rules
          • Where everything is stored
          • File ownership and permissions
            • Setuid and setgid
            • Sticky bit
            • Default file permissions
            • Access Control Lists (ACLs)
          • Filename extensions
          • Troubleshooting
        • Using Editors
          • Supported editors
          • Specifying the default editor
        • Configuring Your Environment
          • What happens when you log in?
          • Customizing your home
          • Configuring your shell
            • /etc/profile
            • $HOME/.profile
            • ksh's startup file
          • Environment variables
            • Setting PATH and LD_LIBRARY_PATH
          • Configuration strings
          • Setting the time zone
            • Examples
            • Programming with time zones
          • Terminal types
          • Troubleshooting
        • Writing Shell Scripts
          • Available shells
          • Running a shell script
          • The first line
            • Arguments to a ksh script
            • Arguments to a gawk script
            • Arguments to a perl script
          • Example of a Korn shell script
          • Efficiency
          • Caveat scriptor
        • Working with Filesystems
          • Setting up, starting, and stopping a block filesystem
          • Mounting and unmounting filesystems
          • Image filesystem
          • /dev/shmem RAM "filesystem"
          • QNX 4 filesystem
            • Extents
            • Filenames
            • Links and inodes
            • Removing links
            • Directory links
            • Symbolic links
            • Filesystem robustness
          • Power-Safe filesystem
            • Booting
            • Snapshots
          • DOS filesystem
          • CD-ROM filesystem
          • Linux Ext2 filesystem
          • Flash filesystems
          • CIFS filesystem
          • NFS filesystem
            • Setting up NFS
            • NFS server
            • NFS client
          • Universal Disk Format (UDF) filesystem
          • Apple Macintosh HFS and HFS Plus
          • Windows NT filesystem
          • Inflator filesystem
          • Troubleshooting
        • Using Qnet for Transparent Distributed Processing
          • When should you use Qnet?
          • Conventions for naming nodes
          • Software components for Qnet networking
          • Starting Qnet
          • Checking out the neighborhood
            • Populating /net
          • Troubleshooting
            • Is Qnet running?
            • Are io-pkt* and the drivers running?
            • Is the network card functional?
            • How do I get diagnostic information?
            • Is the hostname unique?
            • Are the nodes in the same domain?
        • TCP/IP Networking
          • Overview of TCP/IP
          • Software components for TCP/IP networking
          • Running the Internet daemons
          • Running multiple instances of the TCP/IP stack
          • Dynamically assigned TCP/IP parameters
            • Using PPPoE
            • Using DHCP
            • Using AutoIP
          • Troubleshooting
            • Are io-pkt* and the drivers running?
            • What is the name server information?
            • How do I map hostnames to IP addresses?
            • How do I get the network status?
            • How do I make sure I'm connected to other hosts?
            • How do I display information about an interface controller?
        • Printing
          • Printing with lpr
            • User interface
              • lpd—printer daemon
              • lpr—start a print job
              • lprq—show printer queue
              • lprrm—remove jobs from a queue
              • lprc—printer-control program
            • Spooling directories
            • Access control
            • Network manager
            • Printer capabilities: /etc/printcap
              • A typical setup
              • Printers on serial lines
              • Remote printers
              • Filters
            • Some /etc/printcap examples
              • USB printer
              • Single printer
              • Multiple printers
              • Local and remote printers
            • Remote printing to a printer on another network
            • Remote printing to a TCP/IP-enabled printer using lpr
          • Printing with spooler
            • Setting up spooler
            • Printing on a USB printer
            • Remote printing over Qnet
            • Remote printing over TCP/IP
          • Troubleshooting
            • Understanding lpr error messages
              • lpr error messages
              • lprq error messages
              • lprrm error messages
              • lprc error messages
              • lpd error messages
            • Troubleshooting remote printing problems
        • Connecting Hardware
          • PCI/AGP devices
          • CD-ROMs and DVDs
          • Hard disks
            • EIDE
              • Troubleshooting for devb-eide
            • SCSI devices
            • SCSI RAID
          • RAM disks
          • Audio cards
            • ISA cards
            • PCI Cards
          • PCCARD and PCMCIA cards
          • USB devices
            • Printers
            • Ethernet adapters
            • Mass-storage devices
              • Troubleshooting
          • Character devices
            • General serial adapters
            • Multiport serial adapters
            • Parallel ports
            • Terminals
            • I/O attributes
          • Network adapters
            • Identify your NIC
            • Start the driver
            • Make sure the driver is communicating properly with the hardware
              • Physical Node ID
              • Current Physical Node ID
              • Current Operation Rate
              • Active Interface Type
              • Active PHY Address
              • Power Management State
              • Maximum Transmittable data Unit (MTU)
              • Maximum Receivable data Unit (MRU)
              • Receive Checksumming Enabled, Transmit Checksumming Enabled
              • Hardware Interrupt
              • DMA Channel
              • I/O Aperture
              • Memory Aperture
              • ROM Aperture
              • Promiscuous Mode
              • Multicast Support
              • Packets Transmitted OK
              • Bytes Transmitted OK
              • Total Packets Transmitted Bad
              • Broadcast Packets Transmitted OK
              • Multicast Packets Transmitted OK
              • Memory Allocation Failures on Transmit
              • Packets Received OK
              • Bytes Received OK
              • Single Collisions on Transmit
              • Multiple Collisions on Transmit
              • Deferred Transmits
              • Late Collision on Transmit errors
              • Transmits aborted (excessive collisions)
              • Transmits aborted (excessive deferrals)
              • Transmit Underruns
              • No Carrier on Transmit
              • Jabber detected
              • Receive Alignment errors
              • Received packets with CRC errors
              • Packets Dropped on receive
              • Ethernet Headers out of range
              • Oversized Packets received
              • Frames with Dribble Bits
              • Total Frames experiencing Collision(s)
          • Modems
            • Internal modems
              • ISA non-PnP
              • ISA PnP
            • PCI-based modems
            • External modems
            • Testing modems
            • Troubleshooting modems
        • Setting Up an Embedded Web Server
          • Where should you put the files?
          • Running Slinger
          • Dynamic HTML
            • CGI method
            • SSI method
              • Syntax for SSI Commands
            • Data server method
          • Security precautions
          • Examples
            • Configuration
            • Script
              • rand_images.c
              • rand_images.pl
        • Backing Up and Recovering Data
          • Backup strategies
            • Choosing backup storage media and location
            • Choosing a backup format
            • Controlling your backup
          • QNX 4 disk structure
            • Partition components
              • Loader block
              • Root block
              • Bitmap blocks
              • Root directory
            • Directories
            • Links
            • Extent blocks
            • Files
          • File-maintenance utilities
            • fdisk
            • dinit
            • chkfsys
            • dcheck
            • zap
              • Recovering a zapped file
            • spatch
          • Recovering disks and files
            • Using chkfsys
              • When to run chkfsys
              • Using chkfsys on a live system
            • Recovering from a bad block in the middle of a file
          • What to do if your system will no longer boot
            • If the mount fails…
            • If the disk is unrecoverable
            • If the filesystem is intact
        • Securing Your System
          • General OS security
            • Remote and local attacks
              • Remote exploits
              • Local exploits
            • Effects of attacks
            • Viruses
            • QNX Neutrino security in general
          • QNX Neutrino-specific security issues
            • Message passing
            • pdebug
            • qconn
            • Qnet
            • IPSec
          • Setting up a firewall
        • Fine-Tuning Your System
          • Getting the system's status
          • Improving performance
          • Filesystems and block I/O (devb-*) drivers
            • Performance and robustness
            • Metadata updates
              • Ordering the updates to metadata
            • Throughput
            • Configuration
              • Block I/O commit level
              • Record size
              • Double buffering
              • File descriptor vs standard I/O
              • Pregrowing a file
            • Fine-tuning USB storage devices
        • Understanding System Limits
          • Configurable limits
          • Filesystem limits
            • Querying filesystem limits
            • QNX 4 filesystem
            • Power-Safe (fs-qnx6.so) filesystem
            • Ext2 filesystem
            • DOS FAT12/16/32 filesystem
            • CD-ROM (ISO9660) filesystem
            • NFS2 and NFS3 filesystem
            • CIFS filesystem
            • Embedded (flash) filesystem
            • Embedded Transaction filesystem (ETFS)
            • UDF filesystem
            • Apple Macintosh HFS and HFS Plus
            • Windows NT filesystem
          • Other system limits
            • File descriptors
            • Synchronization primitives
            • TCP/IP limits
            • Shared memory
            • Message queues
            • Platform-specific limits
        • Technical Support
        • Glossary
        • Examples
          • Buildfile for an NFS-mounting target
          • Sample buildfile
          • .profile
          • .kshrc
          • Configuration files for spooler
            • Using lpr
            • Using NCFTP
            • Using SAMBA
          • PPP with CHAP authentication between two QNX Neutrino boxes
    • Audio & Graphics API
      • Audio Developer's Guide
        • Audio Architecture
          • QNX Sound Architecture
          • QSA with QNX Acoustics Management Platform
          • Cards and devices
          • Control device
          • Mixer devices
          • Pulse Code Modulation (PCM) devices
            • Data formats
            • PCM state machine
            • PCM software mixer
            • PCM input splitter
            • PCM plugin converters
        • Playing and Capturing Audio Data
          • Handling PCM devices
            • Opening your PCM device
            • Configuring the PCM device
            • Controlling voice conversion
            • Preparing the PCM subchannel
            • Closing the PCM subchannel
          • Playing audio data
            • Playback states
            • Sending data to the PCM subchannel
            • If the PCM subchannel stops during playback
            • Stopping the playback
            • Synchronizing with the PCM subchannel
          • Capturing audio data
            • Selecting what to capture
            • Capture states
            • Receiving data from the PCM subchannel
            • If the PCM subchannel stops during capture
            • Stopping the capture
            • Synchronizing with the PCM subchannel
        • Mixer Architecture
          • Opening the mixer device
          • Controlling a mixer group
          • The best mixer group with respect to your PCM subchannel
          • Finding all mixer groups
          • Mixer event notification
          • Closing the mixer device
        • Optimizing Audio
        • Audio Library
          • snd_afm_close()
          • snd_afm_file_descriptor()
          • snd_afm_get_ap_data()
          • snd_afm_get_audio_mode()
          • snd_afm_get_vin_list()
          • snd_afm_get_vin_list_count()
          • snd_afm_load_ap_dataset()
          • snd_afm_open()
          • snd_afm_open_name()
          • snd_afm_set_ap_data()
          • snd_afm_set_audio_mode()
          • snd_afm_set_path()
          • snd_afm_set_vin_stream()
          • snd_afm_start()
          • snd_afm_stop()
          • snd_card_get_longname()
          • snd_card_get_name()
          • snd_card_name()
          • snd_cards()
          • snd_cards_list()
          • snd_ctl_callbacks_t
          • snd_ctl_close()
          • snd_ctl_file_descriptor()
          • snd_ctl_hw_info()
          • snd_ctl_hw_info_t
          • snd_ctl_mixer_switch_list()
          • snd_ctl_mixer_switch_read()
          • snd_ctl_mixer_switch_write()
          • snd_ctl_open()
          • snd_ctl_pcm_channel_info()
          • snd_ctl_pcm_info()
          • snd_ctl_read()
          • snd_mixer_callbacks_t
          • snd_mixer_close()
          • snd_mixer_eid_t
          • snd_mixer_element_read()
          • snd_mixer_element_t
          • snd_mixer_element_write()
          • snd_mixer_elements()
          • snd_mixer_elements_t
          • snd_mixer_file_descriptor()
          • snd_mixer_filter_t
          • snd_mixer_get_bit()
          • snd_mixer_get_filter()
          • snd_mixer_gid_t
          • snd_mixer_group_read()
          • snd_mixer_group_t
          • snd_mixer_group_write()
          • snd_mixer_groups()
          • snd_mixer_groups_t
          • snd_mixer_info()
          • snd_mixer_info_t
          • snd_mixer_open()
          • snd_mixer_open_name()
          • snd_mixer_read()
          • snd_mixer_routes()
          • snd_mixer_routes_t
          • snd_mixer_set_bit()
          • snd_mixer_set_filter()
          • snd_mixer_sort_eid_table()
          • snd_mixer_sort_gid_table()
          • snd_mixer_weight_entry_t
          • snd_pcm_build_linear_format()
          • snd_pcm_capture_flush()
          • snd_pcm_capture_go()
          • snd_pcm_capture_pause()
          • snd_pcm_capture_prepare()
          • snd_pcm_capture_resume()
          • snd_pcm_channel_flush()
          • snd_pcm_channel_go()
          • snd_pcm_channel_info()
          • snd_pcm_channel_info_t
          • snd_pcm_channel_params()
          • snd_pcm_channel_params_t
          • snd_pcm_channel_pause()
          • snd_pcm_channel_prepare()
          • snd_pcm_channel_resume()
          • snd_pcm_channel_setup()
          • snd_pcm_channel_setup_t
          • snd_pcm_channel_status()
          • snd_pcm_channel_status_t
          • snd_pcm_chmap_query_t
          • snd_pcm_chmap_t
          • snd_pcm_close()
          • snd_pcm_file_descriptor()
          • snd_pcm_find()
          • snd_pcm_format_big_endian()
          • snd_pcm_format_linear()
          • snd_pcm_format_little_endian()
          • snd_pcm_format_signed()
          • snd_pcm_format_size()
          • snd_pcm_format_t
          • snd_pcm_format_unsigned()
          • snd_pcm_format_width()
          • snd_pcm_free_chmaps()
          • snd_pcm_get_audioman_handle()
          • snd_pcm_get_chmap()
          • snd_pcm_get_format_name()
          • snd_pcm_info()
          • snd_pcm_info_t
          • snd_pcm_link()
          • snd_pcm_nonblock_mode()
          • snd_pcm_open()
          • snd_pcm_open_name()
          • snd_pcm_open_preferred()
          • snd_pcm_playback_drain()
          • snd_pcm_playback_flush()
          • snd_pcm_playback_go()
          • snd_pcm_playback_pause()
          • snd_pcm_playback_prepare()
          • snd_pcm_playback_resume()
          • snd_pcm_plugin_flush()
          • snd_pcm_plugin_get_voice_conversion()
          • snd_pcm_plugin_info()
          • snd_pcm_plugin_params()
          • snd_pcm_plugin_playback_drain()
          • snd_pcm_plugin_prepare()
          • snd_pcm_query_channel_map()
          • snd_pcm_query_chmaps()
          • snd_pcm_plugin_read()
          • snd_pcm_plugin_set_disable()
          • snd_pcm_plugin_set_enable()
          • snd_pcm_plugin_set_src_method()
          • snd_pcm_plugin_set_src_mode()
          • snd_pcm_plugin_set_voice_conversion()
          • snd_pcm_plugin_setup()
          • snd_pcm_plugin_src_max_frag()
          • snd_pcm_plugin_status()
          • snd_pcm_plugin_update_src()
          • snd_pcm_plugin_write()
          • snd_pcm_read()
          • snd_pcm_set_audioman_handle()
          • snd_pcm_set_chmap()
          • snd_pcm_t
          • snd_pcm_unlink()
          • snd_pcm_voice_conversion_t
          • snd_pcm_write()
          • snd_strerror()
          • snd_switch_t
        • Audio Utilities
          • afm_ctl
          • io-audio
          • mix_ctl
          • pcm_logger
        • afm_ctl.c example
        • wave.c example
        • waverec.c example
        • mix_ctl.c example
        • ALSA and libasound.so
        • What's New in This Release?
          • What's new in QNX Software Development Platform 6.6 io-audio patch (patch ID 4687)
          • What's new in QNX Software Development Platform 6.6 io-audio patch (patch ID 4510)
          • What's new in QNX Neutrino 6.6
          • What's new in QNX Neutrino 6.5.0 Service Pack 1
          • What's new in QNX Neutrino 6.5.0
          • What's new in QNX Neutrino 6.4
          • What's new in QNX Neutrino 6.3
          • What's new in QNX Neutrino 6.2
          • What's new in QNX Neutrino 6.1
        • Glossary
      • Audio Manager Library Reference
        • Audio Manager Overview
        • Audio Manager Routing Priority
        • Audio Stream Routing Priorities by Type
        • Linking with Audio Manager
        • Audio Manager Configuration File
          • Device attributes
          • Audio status list attributes
          • Routing rules
          • Ducking rules
        • Audio Manager API
          • Audio Concurrency (audio_manager_concurrency.h)
            • Data types in audio_manager_concurrency.h
              • audio_manager_attenuation_extra_option_t
              • audio_manager_attenuation_params_t
              • audio_manager_attenuation_type_t
              • audio_manager_concurrency_t
            • Functions in audio_manager_concurrency.h
              • audio_manager_get_audio_type_concurrency_status()
              • audio_manager_get_current_audio_handle_concurrency_status()
              • audio_manager_set_handle_attenuation()
          • Audio Devices (audio_manager_device.h)
            • Constants in audio_manager_device.h
              • Definitions in audio_manager_device.h
            • Data types in audio_manager_device.h
              • audio_manager_channel_t
              • audio_manager_channel_config_t
              • audio_manager_device_t
              • audio_manager_device_audio_config_t
              • audio_manager_device_capabilities_t
              • audio_manager_device_capability_t
              • audio_manager_device_headset_button_t
              • audio_manager_device_volume_control_t
              • audio_manager_headset_button_state_t
            • Functions in audio_manager_device.h
              • audio_manager_get_default_device()
              • audio_manager_get_default_input_device()
              • audio_manager_get_device_audio_capabilities()
              • audio_manager_get_device_audio_config()
              • audio_manager_get_device_audio_public()
              • audio_manager_get_device_button_states()
              • audio_manager_get_device_capability()
              • audio_manager_get_device_dependency()
              • audio_manager_get_device_from_name()
              • audio_manager_get_device_name()
              • audio_manager_get_device_volume_control()
              • audio_manager_get_preferred_audio_input_path()
              • audio_manager_get_preferred_audio_output_path()
              • audio_manager_is_device_connected()
              • audio_manager_is_device_kept_alive()
              • audio_manager_is_device_supported()
              • audio_manager_is_device_suspended()
              • audio_manager_is_hdmi_in_mirror_mode()
              • audio_manager_set_device_connected()
              • audio_manager_set_device_suspended()
              • audio_manager_set_hdmi_mirror_mode()
          • Audio Events (audio_manager_event.h)
            • Data types in audio_manager_event.h
              • audio_manager_concurrency_change_t
              • audio_manager_device_button_change_t
              • audio_manager_device_change_t
              • audio_manager_event_context_t
              • audio_manager_event_type_t
              • audio_manager_routing_change_t
              • audio_manager_stat_change_t
              • audio_manager_status_headphone_boost_change_t
              • audio_manager_status_headphone_output_volume_regulation_change_t
              • audio_manager_status_headphone_unsafe_zone_change_t
              • audio_manager_status_volume_change_t
              • audio_manager_voice_audio_option_change_t
              • audio_manager_voice_service_change_t
              • audio_manager_voice_status_volume_change_t
            • Functions in audio_manager_event.h
              • audio_manager_add_concurrency_change_event()
              • audio_manager_add_device_button_change_event()
              • audio_manager_add_device_change_event()
              • audio_manager_add_routing_change_event()
              • audio_manager_add_stat_change_event()
              • audio_manager_add_status_hp_boost_change_event()
              • audio_manager_add_status_hp_output_volume_regulation_change_event()
              • audio_manager_add_status_hp_unsafe_zone_change_event()
              • audio_manager_add_voice_audio_option_change_event()
              • audio_manager_add_voice_service_change_event()
              • audio_manager_add_voice_volume_change_event()
              • audio_manager_add_volume_change_event()
              • audio_manager_dispatch_event()
              • audio_manager_get_event()
              • audio_manager_get_event_context()
              • audio_manager_get_event_fd()
              • audio_manager_peek_event()
              • audio_manager_release_event_context()
              • audio_manager_remove_concurrency_change_event()
              • audio_manager_remove_device_button_change_event()
              • audio_manager_remove_device_change_event()
              • audio_manager_remove_routing_change_event()
              • audio_manager_remove_stat_change_event()
              • audio_manager_remove_status_hp_boost_change_event()
              • audio_manager_remove_status_hp_unsafe_zone_change_event()
              • audio_manager_remove_voice_audio_option_change_event()
              • audio_manager_remove_voice_service_change_event()
              • audio_manager_remove_voice_volume_change_event()
              • audio_manager_remove_volume_change_event()
              • audio_manager_wait_for_initialization()
          • Audio Routing (audio_manager_routing.h)
            • Constants in audio_manager_routing.h
              • Definitions in audio_manager_routing.h
            • Data types in audio_manager_routing.h
              • audio_manager_audio_type_t
              • audio_manager_runtime_t
              • audio_manager_settings_reset_condition_t
            • Functions in audio_manager_routing.h
              • audio_manager_activate_bound_handle()
              • audio_manager_activate_handle()
              • audio_manager_check_autopause()
              • audio_manager_free_handle()
              • audio_manager_get_alias_handle()
              • audio_manager_get_handle()
              • audio_manager_get_handle_for_runtime()
              • audio_manager_get_handle_status()
              • audio_manager_get_handle_type()
              • audio_manager_get_name_from_type()
              • audio_manager_get_name_from_runtime()
              • audio_manager_get_runtime_from_name()
              • audio_manager_get_type_from_name()
              • audio_manager_set_handle_routing_conditions()
              • audio_manager_set_handle_keep_alive()
              • audio_manager_set_handle_type()
              • audio_manager_snd_pcm_open()
              • audio_manager_snd_pcm_open_name()
              • audio_manager_snd_pcm_open_preferred()
              • audio_manager_suspend_bound_handle()
              • audio_manager_suspend_handle()
          • Audio Voice Services (audio_manager_voice_service.h)
            • Constants in audio_manager_voice_service.h
              • Definitions in audio_manager_voice_service.h
            • Data types in audio_manager_voice_service.h
              • audio_manager_voice_option_t
              • audio_manager_voice_service_t
              • audio_manager_voice_service_status_t
            • Functions in audio_manager_voice_service.h
              • audio_manager_get_redirector_id()
              • audio_manager_get_voice_service_from_name()
              • audio_manager_get_voice_service_name()
              • audio_manager_get_voice_service_option()
              • audio_manager_get_voice_service_option_from_name()
              • audio_manager_get_voice_service_option_name()
              • audio_manager_get_voice_service_status()
              • audio_manager_get_voice_service_status_from_name()
              • audio_manager_get_voice_service_status_name()
              • audio_manager_get_voice_service_status_with_codec_settings()
              • audio_manager_set_voice_service_option()
              • audio_manager_set_voice_service_status()
              • audio_manager_set_voice_service_status_with_codec_settings()
          • Audio Volume (audio_manager_volume.h)
            • Constants in audio_manager_volume.h
              • Definitions in audio_manager_volume.h
            • Data types in audio_manager_volume.h
              • audio_manager_headphone_output_regulation_t
              • audio_manager_headphone_volume_override_status_t
            • Functions in audio_manager_volume.h
              • audio_manager_adjust_input_level()
              • audio_manager_adjust_output_level()
              • audio_manager_adjust_voice_output_level()
              • audio_manager_clear_stat_counter()
              • audio_manager_decrease_output_level()
              • audio_manager_decrease_voice_output_level()
              • audio_manager_get_headphone_boost_status()
              • audio_manager_get_headphone_output_level_regulation_status()
              • audio_manager_get_headphone_unsafe_zone_status()
              • audio_manager_get_input_level()
              • audio_manager_get_input_mute()
              • audio_manager_get_modem_output_mute()
              • audio_manager_get_output_level()
              • audio_manager_get_output_mute()
              • audio_manager_get_output_volume_steps()
              • audio_manager_get_stat_counter()
              • audio_manager_get_voice_input_mute()
              • audio_manager_get_voice_output_level()
              • audio_manager_get_voice_output_mute()
              • audio_manager_get_voice_output_volume_steps()
              • audio_manager_increase_output_level()
              • audio_manager_increase_voice_output_level()
              • audio_manager_set_headphone_volume_boost()
              • audio_manager_set_headphone_volume_unsafe_zone()
              • audio_manager_set_input_level()
              • audio_manager_set_input_mute()
              • audio_manager_set_modem_output_mute()
              • audio_manager_set_output_level()
              • audio_manager_set_output_mute()
              • audio_manager_set_voice_input_mute()
              • audio_manager_set_voice_output_level()
              • audio_manager_set_voice_output_mute()
              • audio_manager_toggle_input_mute()
              • audio_manager_toggle_output_mute()
              • audio_manager_toggle_voice_output_mute()
      • Gestures Library Reference
        • Gestures Library Overview
        • Gesture Recognition
        • User defined gestures
        • Gesture Tutorials
          • Tutorial: Create a gesture-handling application
            • Example: Code snippets of a gesture-handling application
          • Tutorial: Create a custom gesture
            • Example: Code snippets of a defining a custom gesture
        • Gestures Library Reference
          • Gesture Buckets (bucket.h)
            • Definitions in bucket.h
            • gestures_bucket_add()
            • gestures_bucket_clear()
            • gestures_bucket_count()
            • gestures_bucket_del()
            • gestures_bucket_get()
            • gestures_bucket_init()
            • gestures_bucket_t
          • Global Settings (defaults.h)
            • Definitions in defaults.h
          • Double Tap (double_tap.h)
            • double_tap_gesture_alloc()
            • double_tap_gesture_default_params()
            • double_tap_params_t
            • double_tap_state_e
            • gesture_double_tap_t
          • Event Lists (event_list.h)
            • event_list_add()
            • event_list_alloc()
            • event_list_alloc_copy()
            • event_list_clear()
            • event_list_copy()
            • event_list_free()
            • event_list_get_first()
            • event_list_item
            • event_list_item_t
          • Long Press (long_press.h)
            • gesture_long_press_t
            • long_press_gesture_alloc()
            • long_press_gesture_default_params()
            • long_press_params_t
          • Pinch Gestures (pinch.h)
            • gesture_pinch_t
            • pinch_gesture_alloc()
            • pinch_gesture_default_params()
            • pinch_params_t
          • Press and Tap (press_and_tap.h)
            • gesture_pt_t
            • pt_gesture_alloc()
            • pt_gesture_default_params()
            • pt_params_t
          • Rotate Gesture (rotate.h)
            • gesture_rotate_t
            • rotate_gesture_alloc()
            • rotate_gesture_default_params()
            • rotate_params_t
          • Gesture Sets (set.h)
            • gestures_set_add()
            • gestures_set_alloc()
            • gestures_set_fail_f
            • gestures_set_free()
            • gestures_set_process_event()
            • gestures_set_process_event_list()
            • gestures_set_register_fail_cb()
          • Swipe Gesture (swipe.h)
            • gesture_swipe_t
            • swipe_gesture_default_params()
            • swipe_params_t
          • Tap Gesture (tap.h)
            • gesture_tap_t
            • tap_gesture_alloc()
            • tap_gesture_default_params()
            • tap_params_t
          • Gesture Timers (timer.h)
            • gesture_timer_callback_t
            • gesture_timer_clear()
            • gesture_timer_create()
            • gesture_timer_destroy()
            • gesture_timer_query()
            • gesture_timer_set_event()
            • gesture_timer_set_ms()
            • gesture_timer_set_now()
          • Triple Tap (triple_tap.h)
            • gesture_triple_tap_t
            • triple_tap_gesture_alloc()
            • triple_tap_gesture_default_params()
            • triple_tap_params_t
            • triple_tap_state_e
          • Two Finger Pan (two_finger_pan.h)
            • gesture_tfpan_t
            • tfpan_gesture_alloc()
            • tfpan_gesture_default_params()
            • tfpan_params_t
          • Two Finger Tap (two_finger_tap.h)
            • gesture_tft_t
            • tft_gesture_alloc()
            • tft_gesture_default_params()
            • tft_params_t
          • Data Types and Helper Functions (types.h)
            • Definitions in types.h
            • diff_time_ms()
            • gesture_add_mustfail()
            • gesture_base
            • gesture_base_init()
            • gesture_base_t
            • gesture_callback_f
            • gesture_coords_t
            • gesture_e
            • gesture_funcs_t
            • gesture_state_e
            • map_contact_id()
            • max_displacement_abs()
            • save_coords()
      • Image Library Reference
        • Working with Images
          • Attaching to the image library
          • Load an image
        • Image API
          • img_cfg_read()
          • img_codec_get_criteria()
          • img_codec_list()
          • img_codec_list_byext()
          • img_codec_list_bymime()
          • img_convert_data()
          • img_convert_getfunc()
          • img_crop()
          • img_decode_begin()
          • img_decode_callouts_t
          • img_decode_finish()
          • img_decode_frame()
          • img_decode_validate()
          • img_dtransform()
          • img_dtransform_apply()
          • img_dtransform_create()
          • img_dtransform_free()
          • img_encode_begin()
          • img_encode_callouts_t
          • img_encode_finish()
          • img_encode_frame()
          • img_expand_getfunc()
          • IMG_FMT_BPL()
          • IMG_FMT_BPP()
          • img_format_t
          • img_lib_attach()
          • img_lib_detach()
          • img_load()
          • img_load_file()
          • img_load_resize()
          • img_load_resize_file()
          • img_resize_fs()
          • img_rotate_ortho()
          • img_write()
          • img_write_file()
          • img_t
          • io_close()
          • io_open()
      • Input Events Library Reference
        • Writing a Touch Driver
          • Provide the callback functions
          • Connect to the Input Events library
          • Provide initialization and cleanup callback functions
          • Communicate with the hardware
          • Disconnect from the Input Events library
        • Input Events Library Overview
          • Event types (event_types.h)
            • Data types in event_types.h
              • contact_type_e
              • input_class_e
              • input_event_e
              • mtouch_event
              • mtouch_event_t
          • Driver (mtouch_driver.h)
            • Constants in mtouch_driver.h
              • Definitions in mtouch_driver.h
            • Data types in mtouch_driver.h
              • mtouch_driver_funcs_t
              • Driver test result types
            • Functions in mtouch_driver.h
              • mtouch_driver_attach()
              • mtouch_driver_detach()
              • mtouch_driver_process_packet()
              • mtouch_test_bist()
              • mtouch_test_fini()
              • mtouch_test_init()
              • mtouch_test_read_firmware_version()
              • mtouch_test_read_product_id()
              • mtouch_test_read_serial_id()
              • mtouch_test_read_supplier_id()
          • Log (mtouch_log.h)
            • Constants in mtouch_log.h
              • Definitions in mtouch_log.h
            • Functions in mtouch_log.h
              • mtouch_log()
          • Parameters (mtouch_params.h)
            • Constants in mtouch_params.h
              • Definitions in mtouch_params.h
            • Data types in mtouch_param.h
              • mtouch_driver_params
              • mtouch_driver_params_t
              • mtouch_filter_config
              • mtouch_filter_config_t
              • mtouch_client_params
              • mtouch_client_params_t
          • Parse options (parseopts.h)
            • Functions in parseopts.h
              • input_parseopts()
              • input_parse_bool()
              • input_parse_double()
              • input_parse_signed()
              • input_parse_string()
              • input_parse_unsigned()
          • Screen helpers (screen_helpers.h)
            • Functions in screen_helpers.h
              • screen_get_mtouch_event()
      • OpenWF Configuration Developer's Guide
        • Before you begin
        • Introduction to the Wfdcfg library
        • Getting the source code
        • Setting timing parameters
        • Updating Wfdcfg source (adding extensions)
        • Building the Wfdcfg library
        • Updating your target
        • Configuring Screen for your display
        • OpenWF Display Configuration Library Reference
          • Definitions in wfdcfg.h
          • WFDCFG_FNPTR(FN, TYP)
          • wfdcfg_device
          • wfdcfg_device_create()
          • wfdcfg_device_destroy()
          • wfdcfg_device_get_extension()
          • wfdcfg_ext_fn_set_power_mode_t
          • wfdcfg_flags
          • wfdcfg_keyval
          • wfdcfg_mode_get_extension()
          • wfdcfg_mode_list
          • wfdcfg_mode_list_create()
          • wfdcfg_mode_list_destroy()
          • wfdcfg_mode_list_get_next()
          • wfdcfg_port
          • wfdcfg_port_create()
          • wfdcfg_port_destroy()
          • wfdcfg_port_get_extension()
          • wfdcfg_power_mode
          • wfdcfg_timing
      • Screen Graphics Subsystem Developer's Guide
        • Overview of Screen
        • Understanding composition
        • Screen API
        • Contexts
          • Create a context
          • Context types
          • Set a context property
        • Windows
          • Window types
          • Window properties
          • Window parenting and positioning
          • Create a window
          • Create a child window
          • Pixel formats
        • Displays
          • Multiple displays
            • Complete sample: Using multiple displays
        • Event Types
        • Screen utilities
          • drm-intel
          • drm-probe-displays
          • screen
          • screeninfo
          • vcapture-test
        • Screen Tutorials
          • Tutorial: Draw and perform vsync operations using windows
            • Create the background window
            • Create the child windows
            • Create the main() function
            • Complete sample: A vsync application using windows
          • Tutorial: Draw and perform vsync operations using blits, pixmaps, and buffers
            • Create a context and initialize a window
            • Create buffers and a pixmap
            • Combine buffers with blit functions and properties
            • Complete sample: A vsync application using blits, pixmaps, and buffers
          • Tutorial: Write an application using OpenGL ES
            • Use OpenGL ES in a windowed vsync application
            • Complete sample: A windowed vsync application using OpenGL ES
          • Tutorial: Screenshots
            • Capture a window screenshot
            • Complete sample: a window screenshot example
            • Capture a display screenshot
            • Complete sample: A display screenshot example
          • Tutorial: Rendering text with FreeType and OpenGL ES
            • Using FreeType library and OpenGL ES to render text
            • Complete sample: Rendering text with FreeType and OpenGL ES
          • Tutorial: Screen events
            • Injecting a Screen event
            • Complete sample: Injecting a Screen event
            • Injecting a Screen mtouch event
            • Complete sample: Injecting a screen event
        • Screen Configuration
          • Configure Screen
            • Configure khronos section
              • Configure egl display
              • Configuration parameters for egl display
              • Configure wfd device
            • Configure winmgr section
              • Configure globals
              • Configuration parameters for globals
              • Configure display display_id
              • Configuration parameters for display
              • Configure class
              • Configuration parameters for class
              • Configure mtouch
              • Configuration parameters for mtouch
              • Configuring mtouch filter
              • Configuration parameters for filter
            • Apply your Screen configuration
            • Troubleshooting
              • Sample /dev/screen/0/dpy-1 file
              • Sample /dev/screen/0/win-0/win-0 file
              • Sample /dev/screen/<pid>/win-1/win-1 file
        • Screen Library Reference
          • Function safety
          • Function execution types
            • Apply execution
            • Delayed execution
            • Flushing execution
            • Immediate execution
            • Function types
          • General (screen.h)
            • Definitions in screen.h
            • _screen_mode
            • Screen CBABC mode types
            • Screen alpha mode types
            • Screen color space types
            • Screen flushing types
            • Screen idle mode types
            • Screen mirror types
            • Screen mouse button types
            • Screen object types
            • Screen pixel format types
            • Screen power mode types
            • Screen property types
            • Screen scaling quality types
            • Screen sensitivity masks
            • Screen sensitivity types
            • Screen touch types
            • Screen transparency types
            • Screen usage flag types
          • Blits (screen.h)
            • Screen blit types
            • screen_blit()
            • screen_fill()
            • screen_flush_blits()
          • Buffers (screen.h)
            • Screen buffer properties
            • screen_buffer_t
            • screen_create_buffer()
            • screen_destroy_buffer()
            • screen_get_buffer_property_cv()
            • screen_get_buffer_property_iv()
            • screen_get_buffer_property_llv()
            • screen_get_buffer_property_pv()
            • screen_set_buffer_property_cv()
            • screen_set_buffer_property_iv()
            • screen_set_buffer_property_llv()
            • screen_set_buffer_property_pv()
          • Contexts (screen.h)
            • Screen context properties
            • Screen notification types
            • screen_context_t
            • Screen context types
            • screen_create_context()
            • screen_destroy_context()
            • screen_flush_context()
            • screen_get_context_property_cv()
            • screen_get_context_property_iv()
            • screen_get_context_property_llv()
            • screen_get_context_property_pv()
            • screen_notify()
            • screen_set_context_property_cv()
            • screen_set_context_property_iv()
            • screen_set_context_property_llv()
            • screen_set_context_property_pv()
          • Debugging (screen.h)
            • Screen debug graph types
            • Screen packet types
            • screen_print_packet()
          • Devices (screen.h)
            • Screen device metric counts
            • Screen device properties
            • Screen game button types
            • screen_device_t
            • screen_create_device_type()
            • screen_destroy_device()
            • screen_get_device_property_cv()
            • screen_get_device_property_iv()
            • screen_get_device_property_llv()
            • screen_get_device_property_pv()
            • screen_set_device_property_cv()
            • screen_set_device_property_iv()
            • screen_set_device_property_llv()
            • screen_set_device_property_pv()
          • Displays (screen.h)
            • Screen display metric counts
            • Screen display mode types
            • Screen display properties
            • Screen display technology types
            • Screen display types
            • screen_display_mode_t
            • screen_display_t
            • screen_get_display_modes()
            • screen_get_display_property_cv()
            • screen_get_display_property_iv()
            • screen_get_display_property_llv()
            • screen_get_display_property_pv()
            • screen_read_display()
            • screen_set_display_property_cv()
            • screen_set_display_property_iv()
            • screen_set_display_property_llv()
            • screen_set_display_property_pv()
            • screen_share_display_buffers()
            • screen_wait_vsync()
          • Events (screen.h)
            • Screen event properties
            • Screen event types
            • screen_create_event()
            • screen_destroy_event()
            • screen_event_t
            • screen_get_event()
            • screen_get_event_property_cv()
            • screen_get_event_property_iv()
            • screen_get_event_property_llv()
            • screen_get_event_property_pv()
            • screen_inject_event()
            • screen_send_event()
            • screen_set_event_property_cv()
            • screen_set_event_property_iv()
            • screen_set_event_property_llv()
            • screen_set_event_property_pv()
          • Groups (screen.h)
            • Screen group properties
            • screen_create_group()
            • screen_destroy_group()
            • screen_get_group_property_cv()
            • screen_get_group_property_iv()
            • screen_get_group_property_llv()
            • screen_get_group_property_pv()
            • screen_group_t
            • screen_set_group_property_cv()
            • screen_set_group_property_iv()
            • screen_set_group_property_llv()
            • screen_set_group_property_pv()
          • Pixmaps (screen.h)
            • Screen pixmap metric counts
            • Screen pixmap properties
            • screen_attach_pixmap_buffer()
            • screen_create_pixmap()
            • screen_create_pixmap_buffer()
            • screen_destroy_pixmap()
            • screen_destroy_pixmap_buffer()
            • screen_get_pixmap_property_cv()
            • screen_get_pixmap_property_iv()
            • screen_get_pixmap_property_llv()
            • screen_get_pixmap_property_pv()
            • screen_join_pixmap_group()
            • screen_leave_pixmap_group()
            • screen_pixmap_t
            • screen_ref_pixmap()
            • screen_set_pixmap_property_cv()
            • screen_set_pixmap_property_iv()
            • screen_set_pixmap_property_llv()
            • screen_set_pixmap_property_pv()
            • screen_unref_pixmap()
          • Windows (screen.h)
            • Screen window metric counts
            • Screen window properties
            • Screen window types
            • screen_attach_window_buffers()
            • screen_create_window()
            • screen_create_window_buffers()
            • screen_create_window_group()
            • screen_create_window_type()
            • screen_destroy_window()
            • screen_destroy_window_buffers()
            • screen_discard_window_regions()
            • screen_get_window_property_cv()
            • screen_get_window_property_iv()
            • screen_get_window_property_llv()
            • screen_get_window_property_pv()
            • screen_join_window_group()
            • screen_leave_window_group()
            • screen_post_window()
            • screen_read_window()
            • screen_ref_window()
            • screen_set_window_property_cv()
            • screen_set_window_property_iv()
            • screen_set_window_property_llv()
            • screen_set_window_property_pv()
            • screen_share_window_buffers()
            • screen_unref_window()
            • screen_wait_post()
            • screen_window_t
      • Video Capture Library Reference
        • Video Capture Developer's Guide
          • Header files and libraries
          • Implementing video capture
          • Sample video capture program
          • Properties applied to arrays
          • Contexts
          • Buffers
          • Platform-specific considerations
        • Video Capture Library API Reference (capture.h)
          • Properties
            • Driver and device properties
            • Data bus, and clock and data lane properties
            • I2C decoder path and slave address
            • Video standards
            • Polarity
            • Deinterlacing properties and enumerated values
            • Source buffer properties
            • Destination buffer properties
            • Frame properties
            • External source properties
            • Helper macros
          • capture_context_t
          • capture_create_buffers()
          • capture_create_context()
          • capture_destroy_context()
          • capture_get_frame()
          • capture_get_free_buffer()
          • capture_get_property_i()
          • capture_get_property_p()
          • capture_is_property()
          • capture_put_buffer()
          • capture_release_frame()
          • capture_set_property_i()
          • capture_set_property_p()
          • capture_update()
    • Programming
      • Getting Started with QNX Neutrino
        • Foreword to the First Edition by Peter van der Veen
        • Preface to the First Edition by Rob Krten
          • A little history
          • Who this book is for
          • What's in this book?
          • About Rob Krten
          • Acknowledgments
        • Processes and Threads
          • Process and thread fundamentals
            • A process as a house
            • The occupants as threads
            • Back to processes and threads
            • Mutual exclusion
            • Priorities
            • Semaphores
            • A semaphore as a mutex
          • The kernel's role
            • Single CPU
            • Multiple CPU (SMP)
            • The kernel as arbiter
              • Prioritization
              • Scheduling policies
              • FIFO
              • Round Robin
              • The rules
            • Kernel states
              • Kernel states, the complete list
          • Threads and processes
            • Why processes?
            • Starting a process
              • Starting a process from the command line
              • Starting a process from within a program
                • Starting a process with the system() call
                • Starting a process with the exec() and spawn() calls
                • Starting a process with the fork() call
                • Using fork() in a multithreaded process
                • Starting a process with the posix_spawn() call
                • So what should you use?
            • Starting a thread
              • The thread attributes structure
                • Thread attribute administration
                • The "flags" thread attribute
                • The "stack" thread attributes
                • The "scheduling" thread attributes
              • A few examples
              • Where a thread is a good idea
              • Threads in mathematical operations
                • Coding for SMP or single processor
                • Synchronizing to the termination of a thread
                • Joining
                • Using a barrier
                • Multiple threads on a single CPU
                • Things to watch out for when using SMP
              • Threads in independent situations
                • Multiple processes
                • Multiple processes with shared memory
                • Multiple threads
                • Comparisons
          • More on synchronization
            • Readers/writer locks
            • Sleepon locks
            • Condition variables
              • Signal versus broadcast
              • Sleepons versus condvars
            • Additional OS services
            • Pools of threads
              • Controlling the number of threads
              • The thread pool functions
            • An example of synchronization
          • Scheduling and the real world
            • Rescheduling: hardware interrupts
            • Rescheduling: kernel calls
            • Rescheduling: exceptions
            • Summary
        • Message Passing
          • A small microkernel and message passing
          • Message passing and client/server
          • Network-distributed message passing
          • What it means for you
          • Multiple threads
            • Server/subserver
            • Some examples
          • Using message passing
            • Architecture & structure
            • The client
              • Establishing a connection
              • Sending messages
            • The server
              • Creating the channel
              • Message handling
              • Server framework
            • The send-hierarchy
            • Receive IDs, channels, and other parameters
              • More about channels
              • Who sent the message?
              • The receive ID (a.k.a. the client cookie)
              • Replying to the client
              • Not replying to the client
              • Replying with no data, or an errno
              • Finding the server's ND/PID/CHID
              • What about priorities?
              • Reading and writing data
            • Multipart messages
              • What about the other versions?
              • Implementation
          • Pulses
            • Receiving a pulse message
              • What's in a pulse?
              • The MsgReceivePulse() function
            • The MsgDeliverEvent() function
            • Channel flags
              • _NTO_CHF_UNBLOCK
                • Synchronization problem
                • Using the _NTO_MI_UNBLOCK_REQ
          • Message passing over a network
            • Networked message passing differences
            • Some notes on NDs
          • Priority inheritance
            • So what's the trick?
            • Summary
        • Clocks, Timers, and Getting a Kick Every So Often
          • Clocks and timers
            • Operating periodically
            • Clock interrupt sources
            • Base timing resolution
            • Timing jitter
            • Types of timers
            • Notification schemes
              • How to fill in the struct sigevent
              • Pulse notification
              • Signal notification
          • Using timers
            • Creating a timer
            • Signal, pulse, or thread?
            • What kind of timer?
            • A server with periodic pulses
              • Server-maintained timeouts
                • Declarations
                • main()
                • setupPulseAndTimer()
                • gotAPulse()
                • gotAMessage()
              • Notes
              • Periodic server maintenance cycles
            • Timers delivering signals
            • Timers creating threads
            • Getting and setting the realtime clock and more
          • Advanced topics
            • Other clock sources
              • CLOCK_MONOTONIC
              • So what does CLOCK_SOFTTIME do?
              • Using different clock sources
            • Kernel timeouts
              • Kernel timeouts with pthread_join()
              • Kernel timeouts with message passing
            • Summary
        • Interrupts
          • QNX Neutrino and interrupts
            • Interrupt service routine
              • Clearing the interrupt source
              • Telling a thread to do something
            • Level-sensitivity versus edge-sensitivity
          • Writing interrupt handlers
            • Attaching an interrupt handler
            • Now that you've attached an interrupt
            • Detaching an interrupt handler
            • The flags parameter
            • The interrupt service routine
              • Using InterruptAttach()
              • Using InterruptAttachEvent()
              • InterruptAttach() versus InterruptAttachEvent()
              • The tradeoffs
            • ISR functions
          • Summary
        • Resource Managers
          • What is a resource manager?
            • Examples of resource managers
            • Characteristics of resource managers
          • The client's view
            • Finding the server
            • Finding the process manager
            • Handling directories
            • Unioned filesystems
            • Client summary
          • The resource manager's view
            • Registering a pathname
            • Handling messages
              • Connect messages
              • I/O messages
              • Three groups, really
          • The resource manager library
            • The library really does what we just talked about
            • Behind the scenes at the library
              • The base layer
              • The POSIX layer
          • Writing a resource manager
            • Data structures
              • resmgr_attr_t control structure
                • The other_func message handler
                • The data structure sizing parameters
                • The flags parameter
              • resmgr_connect_funcs_t connect table
              • resmgr_io_funcs_t I/O table
              • The resmgr_context_t internal context block
            • Resource manager structure
              • The resmgr_attach() function and its parameters
              • Putting in your own functions
              • The general flow of a resource manager
              • Messages that should be connect messages but aren't
              • Combine messages
            • POSIX-layer data structures
              • The iofunc_ocb_t OCB structure
                • The strange case of the offset member
              • The iofunc_attr_t attributes structure
              • The iofunc_mount_t mount structure
                • Of device numbers, inodes, and our friend rdev
          • Handler routines
            • General notes
              • Locking, unlocking, and combine message handling
            • Connect functions notes
              • Internal use part
              • End-user parameter part
          • Alphabetical listing of connect and I/O functions
            • io_acl()
            • io_chmod()
            • io_chown()
            • io_close_dup()
            • io_close_ocb()
            • io_devctl()
            • io_dup()
            • io_fdinfo()
            • io_link()
            • io_lock()
            • io_lock_ocb()
            • io_lseek()
            • io_mknod()
            • io_mmap()
            • io_mount()
            • io_msg()
            • io_notify()
            • io_open()
            • io_openfd()
            • io_pathconf()
            • io_power()
            • io_read()
            • io_readlink()
            • io_rename()
            • io_shutdown()
            • io_space()
            • io_stat()
            • io_sync()
            • io_unblock() [CONNECT]
            • io_unblock() [I/O]
            • io_unlink()
            • io_unlock_ocb()
            • io_utime()
            • io_write()
          • Examples
            • The basic skeleton of a resource manager
            • A simple io_read() example
              • The code
              • Effective use of other messaging functions
            • A simple io_write() example
            • A simple io_devctl() example
            • An io_devctl() example that deals with data
          • Advanced topics
            • Extending the OCB
            • Extending the attributes structure
            • Blocking within the resource manager
            • Returning directory entries
              • Generally speaking...
              • The struct dirent structure and friends
                • Offsets
                • Contents
              • Example
                • main() and declarations
                • my_open()
                • my_read()
                • my_read_dir()
                • my_read_file()
                • dirent_size()
                • dirent_fill()
          • Summary
        • QNX 4 to QNX Neutrino
          • Similarities
          • Improvements
            • Embeddability
            • Thread support
            • Message passing
              • Pulses and events
            • Device driver model
            • ARM support
            • SMP support
          • Porting philosophy
            • Message passing considerations
              • Client/server using the global namespace
                • Translating messages to standard file-descriptor-based POSIX calls
                • Translating messages to devctl() or _IO_MSG
              • Client/Server using an I/O manager
              • Proxies
                • Proxies for their IDs
                • Proxies for their contents
            • Interrupt service routines
          • Summary
        • Calling 911
          • Read the manuals
          • Contact technical support
            • Describe the problem
            • Precise information
            • Versions
            • If you're using a beta…
            • Reproduce the problem
            • Narrow it down
          • Training
        • Sample Programs
          • atoz.c
          • time1.c
          • tp1.c
          • tt1.c
        • Glossary
      • Programmer's Guide
        • Compiling and Debugging
          • Choosing the version of the OS
          • Making your code more portable
            • Conforming to standards
            • Including OS-specific code
          • Cross-development
            • Cross-development with network filesystem
            • Cross-development with debugger
            • Cross-development, deeply embedded
          • Using libraries
          • Linking your modules
            • Creating shared objects
              • Specifying an internal name
          • Optimizing the runtime linker
            • Lazy binding
            • RTLD_LAZY
            • Lazy loading
            • Diagnostics and debugging
            • Environment variables
          • Debugging in a cross-development environment
            • The GNU debugger (gdb)
            • The process-level debug agent
              • Serial connection
              • TCP/IP connection
          • A simple debug session
          • Debugging using libmudflap
        • Programming Overview
          • An application as a set of processes
          • Some definitions
          • Priorities and scheduling
            • Priority range
            • BLOCKED and READY states
            • The ready queue
            • Rescheduling a running thread
          • Scheduling policies
            • FIFO scheduling
            • Round-robin scheduling
            • Sporadic scheduling
          • Why threads?
          • Talking to hardware
          • Summary
        • Processes
          • Starting processes: two methods
          • Process creation
            • Concurrency
            • Inheriting file descriptors
          • Process termination
          • Detecting process termination
            • Using the High Availability Framework
            • Detecting termination from a starter process
            • Sample parent process using wait()
            • Sample parent process using sigwaitinfo()
            • Detecting dumped processes
            • Detecting the termination of daemons
            • Detecting client termination
          • Stack allocation
          • Process privileges
            • Privilege separation
              • Thread I/O privileges
            • Procmgr abilities
              • Ability domains
              • Ability ranges
              • Locking an ability
              • Dropping an ability
              • Ability inheritance
                • Basic inheritance
                • Locking and inheritance
              • Creating abilities
            • An example of privilege separation
            • Resource constraint thresholds
          • Controlling processes via the /proc filesystem
            • Establishing a connection
            • Reading and writing the process's address space
              • Determining the offset
              • Determining accessibility
            • Manipulating a process or thread
              • Selecting a thread for further operations
              • Starting/stopping processes and threads
              • Setting breakpoints
              • Examining process and thread attributes
            • Thread information
            • DCMD_PROC_BREAK
            • DCMD_PROC_CHANNELS
            • DCMD_PROC_CLEAR_FLAG
            • DCMD_PROC_CURTHREAD
            • DCMD_PROC_EVENT
            • DCMD_PROC_FREEZETHREAD
            • DCMD_PROC_GETALTREG
            • DCMD_PROC_GETFPREG
            • DCMD_PROC_GETGREG
            • DCMD_PROC_GETREGSET
            • DCMD_PROC_GET_BREAKLIST
            • DCMD_PROC_INFO
            • DCMD_PROC_IRQS
            • DCMD_PROC_MAPDEBUG
            • DCMD_PROC_MAPDEBUG_BASE
            • DCMD_PROC_MAPINFO
            • DCMD_PROC_PAGEDATA
            • DCMD_PROC_PTINFO
            • DCMD_PROC_RUN
            • DCMD_PROC_SETALTREG
            • DCMD_PROC_SETFPREG
            • DCMD_PROC_SETGREG
            • DCMD_PROC_SETREGSET
            • DCMD_PROC_SET_FLAG
            • DCMD_PROC_SIGNAL
            • DCMD_PROC_STATUS
            • DCMD_PROC_STOP
            • DCMD_PROC_SYSINFO
            • DCMD_PROC_THAWTHREAD
            • DCMD_PROC_THREADCTL
            • DCMD_PROC_TIDSTATUS
            • DCMD_PROC_TIMERS
            • DCMD_PROC_WAITSTOP
        • Working with Access Control Lists (ACLs)
          • ACL formats
          • ACL storage management
          • Manipulating ACL entries in working storage
          • Manipulating permissions in an ACL entry
          • Manipulating the tag type and qualifier in an ACL entry
          • Manipulating ACLs on a file or directory
          • Example
        • Tick, Tock: Understanding the Microkernel's Concept of Time
          • Short delays
          • Oversleeping: errors in delays
          • Another hiccup with hardware timers
          • What time is it?
          • Clocks, timers, and power management
          • Monitoring execution times
        • Transparent Distributed Processing Using Qnet
          • Benefits of Qnet
          • How does it work?
          • Locating services using GNS
          • Quality of Service (QoS) and multiple paths
          • Designing a system using Qnet
          • Autodiscovery vs static
          • When should you use Qnet, TCP/IP, or NFS?
          • Drivers for Qnet
          • Low-level discussion of Qnet principles
          • Details of Qnet data communication
          • Node descriptors
          • Forcing retransmission
        • Writing an Interrupt Handler
          • Interrupts on multicore systems
          • Attaching and detaching interrupts
          • Interrupt Service Routine (ISR)
            • Determining the source of the interrupt
            • Servicing the hardware
              • Safe functions
            • Updating common data structures
            • Notifying the application code
              • Using InterruptAttach()
              • Using InterruptAttachEvent()
          • Running out of interrupt events
          • Problems with shared interrupts
          • Advanced topics
            • Interrupt environment
            • Ordering of shared interrupts
            • Interrupt latency
            • Atomic operations
            • Interrupts and power management
        • Heap Analysis
          • Memory management in QNX Neutrino
          • Dynamic memory management
          • Heap corruption
          • Detecting and reporting errors
            • Using the librcheck library
            • Controlling the level of checking
            • Forcing verification
            • Specifying an error handler
            • Caveats
          • Manual checking (bounds checking)
          • Memory leaks
          • C++ issues
        • Freedom from Hardware and Platform Dependencies
          • Common problems
            • I/O space vs memory-mapped
            • Big-endian vs little-endian
            • Alignment and structure packing
            • Atomic operations
          • Solutions
            • Determining endianness
            • Swapping data if required
            • Accessing unaligned data
            • Examples
              • Mixed-endian accesses
              • Accessing hardware with dual-ported memory
            • Accessing I/O ports
        • Conventions for Recursive Makefiles and Directories
          • Structure of a multiplatform source tree
            • Makefile structure
            • The recurse.mk file
            • Macros
              • The EARLY_DIRS and LATE_DIRS macros
              • The LIST macro
              • The MAKEFILE macro
              • The CHECKFORCE macro
            • Directory levels
              • Project level
              • Section level (optional)
              • OS level
              • CPU level
              • Variant level
          • Specifying options
            • The common.mk file
            • The variant-level makefile
            • Recognized variant names
          • Using the standard macros and include files
            • The qconfig.mk include file
              • Preset macros
              • Postset macros
              • qconfig.mk macros
            • The qrules.mk include file
            • The qtargets.mk include file
          • Advanced topics
            • Collapsing unnecessary directory levels
            • Performing partial builds
            • Performing parallel builds
            • More uses for LIST
            • GNU configure
              • hook_preconfigure()
              • hook_postconfigure()
              • hook_premake()
              • hook_postmake()
              • hook_pinfo()
          • Examples of creating Makefiles
            • A single application
            • A library and an application
        • POSIX Conformance
          • Conformance statement
            • System interfaces: general attributes
              • Supported features
              • Optional features
              • Float, standard I/O, and limit values
              • Error conditions
              • Mathematical interfaces
            • File handling
            • Internationalized system interfaces
            • Threads: Cancellation points
            • Realtime: Prioritized I/O
            • Realtime threads
            • C-language compilation environment
          • POSIX Conformance Document (PCD)
            • Base Definitions
              • 3. Definitions
              • 4. General Concepts
              • 6. Character Set
              • 7. Locale
              • 8. Environment Variables
              • 13. Headers
            • System Interfaces
              • 2.3. Error Numbers
              • 2.4. Signal Concepts
              • 2.5. Standard I/O Streams
              • 2.8. Realtime
              • 2.11. Tracing
              • 3. System Interfaces
          • Non-POSIX functions with POSIX-sounding names
        • Using GDB
          • QNX Neutrino-specific extensions
          • A quick overview of starting the debugger
          • GDB commands
            • Command syntax
            • Command completion
            • Getting help
          • Running programs under GDB
            • Compiling for debugging
            • Setting the target
            • Starting your program
            • Your program's arguments
            • Your program's environment
            • Your program's input and output
            • Debugging an already-running process
            • Killing the process being debugged
            • Debugging programs with multiple threads
            • Debugging programs with multiple processes
          • Stopping and continuing
            • Breakpoints, watchpoints, and exceptions
              • Setting breakpoints
              • Setting watchpoints
              • Breakpoints and exceptions
              • Deleting breakpoints
              • Disabling breakpoints
              • Break conditions
              • Breakpoint command lists
              • Breakpoint menus
            • Continuing and stepping
            • Signals
            • Stopping and starting multithreaded programs
          • Examining the stack
            • Stack frames
            • Backtraces
            • Selecting a frame
            • Information about a frame
          • Examining source files
            • Printing source lines
            • Searching source files
            • Specifying source directories
            • Source and machine code
            • Shared libraries
          • Examining data
            • Expressions
            • Program variables
            • Artificial arrays
            • Output formats
            • Examining memory
            • Automatic display
            • Print settings
            • Value history
            • Convenience variables
            • Registers
            • Floating point hardware
          • Examining the symbol table
          • Altering execution
            • Assignment to variables
            • Continuing at a different address
            • Giving your program a signal
            • Returning from a function
            • Calling program functions
            • Patching programs
        • Glossary
      • The QNX Neutrino Cookbook: Recipes for Programmers
        • Foreword to the First Edition by Brian Stecher
        • Preface to the First Edition by Rob Krten
          • What's in this book?
          • Philosophy
          • Recipes
          • References
          • What's not in this book?
          • Other references
          • Thanks!
        • The Basics
          • In the beginning...
            • The main() function
            • Command-line processing — optproc()
            • Common globals
            • Usage messages
          • Threaded resource managers
        • High Availability
          • Terminology
          • Lies, damn lies, and statistics
          • Increasing availability
            • Increasing the MTBF
            • Decreasing the MTTR
            • Parallel versus serial
              • Series calculations
              • Parallel calculations
              • Aggregate calculations
          • Failure modes and recovery models
            • Cascade failures
              • System startup and HA
            • Overlords, or Big Brother is watching you
            • Cold, warm, and hot standby
              • Achieving cold standby
              • Achieving warm standby
              • Achieving hot standby
              • Problems
            • Detecting failure
              • Obituaries
            • Graceful fail-over
            • Using shadows
            • In-service upgrades
            • Policies
          • Implementing HA
          • RK drones on about his home systems again
          • Other HA systems
        • Design Philosophy
          • Decoupling design in a message-passing environment
            • Door-lock actuators
            • At this point...
          • Managing message flow
            • Swipe-card readers
              • Control program sends to the swipe-card reader
              • Swipe-card reader sends to control program
              • Using a keypad challenge — control program sends to the swipe-card reader
              • Using a keypad challenge — swipe-card reader sends to control program
          • Scalability
            • Distributed processing
          • Summary
        • Web Counter Resource Manager
          • Requirements
            • Using the web counter resource manager
          • Design
            • Generating the graphical image
          • The code — phase 1
            • Operation
              • Generating the graphical image
            • Step-by-step code walkthrough
              • Include files and data structures
              • Source files
              • The code
                • The execute_resmgr() function
                • The io_open() function
                • The io_read() function
                • The io_close_ocb() function
                • The render_7segment() function
                • The encode_image() function
          • The code — phase 2
            • Persistent count file
            • Font selection
            • Plain text rendering
            • Writing to the resource
              • Adding the io_write() handler
              • The io_write() function
              • The io_close_ocb() function
          • The code — phase 3
            • Filename processing tricks
            • Changes
              • Globals
              • The new-and-improved execute_resmgr()
              • Option processing
              • Handling io_read()
                • Operating on a file
                • Operating on a directory
                • The persistent counter file
          • Enhancements
          • References
        • ADIOS — Analog/Digital I/O Server
          • Requirements
          • Design
            • Driver Design
              • DIO-144
              • ISO-813
              • PCL-711
            • Shared Memory Design
            • Tags database design
          • The Driver Code
            • Theory of operation
            • Code walkthrough
              • main() and friends
              • The resource manager modules
              • The card interface modules
                • Card configuration
                • Analog input
                • Analog output
                • Digital input
                • Digital output
          • The ADIOS server code
            • The usual stuff
            • The shared memory region
              • Calculating the sizes of data structures
              • Open and check the shared memory
              • Truncate and map shared memory
            • Acquiring data
          • The showsamp and tag utilities
            • The showsamp utility
            • The tag utility
          • References
        • RAM-disk Filesystem
          • Requirements
            • Connect functions
            • I/O functions
            • Missing functions
          • Design
          • The code
            • The extended attributes structure
            • The io_read() function
            • The io_write() function
            • The c_open() function
              • Finding the target
                • The pathwalk() function
                • The connect_msg_to_attr() function
              • Fun with symlinks
              • Analyze the mode flag
              • Bind the OCB and attributes structure
              • Finally, the c_open() code walkthrough
              • Walkthrough
              • The redirect_symlink() function
            • The c_readlink() function
            • The c_link() function
            • The c_rename() function
            • The c_mknod() function
            • The c_unlink() function
            • The io_close_ocb() function
            • The io_devctl() function
              • Mounting options
              • Filesystem statistics
            • The c_mount() function
          • References
        • TAR Filesystem
          • Requirements
          • Design
            • Creating a .tar file
          • The code
            • The structures
            • The functions
              • The c_mount() function
              • The analyze_tar_file() function
              • The add_tar_entry() function
              • The io_read() function and related utilities
            • The mount helper program
          • Variations on a theme
            • Virtual filesystem for USENET news (VFNews)
              • How does USENET news work?
              • So why is this a problem?
              • How can this possibly be made better?
              • Operation
            • Strange and unusual filesystems
              • Indexed filesystem
              • Executing commands
            • Secure filesystem
            • Line-based filesystem
          • References
        • Filesystems
          • What is a filesystem?
            • Hierarchical arrangement
            • Data elements
            • The mount point and the root
          • What does a filesystem do?
          • Filesystems and QNX Neutrino
          • How does a filesystem work?
            • Mount point management
              • Unnamed mount registration
              • Special device registration
              • Mount point registration
            • Pathname resolution
            • Directory management
            • Data element content management
          • References
        • The /proc Filesystem
          • The /proc/boot directory
          • The /proc/mount directory
          • The /proc by-process-ID directories
            • Operations on the as entry
              • Discontiguous address space
              • Someone else's virtual address space
            • Finding a particular process
              • Iterating through the list of processes
            • Finding out information about the process
            • DCMD_PROC_INFO
              • Process information
              • Memory information
              • Signal information
              • CPU usage information
              • Miscellaneous
            • DCMD_PROC_MAPINFO and DCMD_PROC_PAGEDATA
            • DCMD_PROC_TIMERS
            • DCMD_PROC_IRQS
            • Finding out information about the threads
              • The DCMD_PROC_TIDSTATUS command
              • Blocked thread information
              • The DCMD_PROC_GETGREG and DCMD_PROC_GETFPREG commands
          • References
        • Sample Programs
          • Web-Counter resource manager
          • ADIOS — Analog / Digital I/O Server
          • RAM-disk and tar filesystem managers
          • The /proc filesystem
        • Glossary
      • Writing a Resource Manager
        • What Is a Resource Manager?
          • Why write a resource manager?
          • The types of resource managers
          • Communication via native IPC
          • Examples of resource managers
            • Transparent Distributed Processing (Qnet) statistics
            • Robot arm
            • GPS devices
            • Database example
            • I2C (Inter-Integrated Circuit) driver
          • When not to use a resource manager
        • The Bones of a Resource Manager
          • Under the covers
            • Under the client's covers
            • Under the resource manager's covers
          • Layers in a resource manager
          • Simple examples of device resource managers
            • Single-threaded device resource manager
              • Initialize the dispatch interface
              • Initialize the resource manager attributes
              • Initialize functions used to handle messages
              • Initialize the attribute structure used by the device
              • Put a name into the namespace
              • Allocate the context structure
              • Start the resource manager message loop
            • Multithreaded device resource manager
              • Define THREAD_POOL_PARAM_T
              • Initialize thread pool attributes
              • Allocate a thread pool handle
              • Start the threads
        • Fleshing Out the Skeleton
          • Message types
            • Connect messages
            • I/O messages
            • Default message handling
            • open(), dup(), and close()
          • Setting resource manager attributes
          • Ways of adding functionality to the resource manager
            • Using the default functions
            • Using the helper functions
            • Writing the entire function yourself
          • Security
        • POSIX-Layer Data Structures
          • The iofunc_ocb_t (Open Control Block) structure
          • The iofunc_attr_t (attribute) structure
          • The optional iofunc_mount_t (mount) structure
        • Handling Read and Write Messages
          • Handling the _IO_READ message
            • Sample code for handling _IO_READ messages
          • Handling the _IO_WRITE message
            • Sample code for handling _IO_WRITE messages
          • Methods of returning and replying
          • Handling other read/write details
            • Handling the xtype member
              • If you aren't expecting extended types (xtype)
            • Handling pread*() and pwrite*()
              • Sample code for handling _IO_READ messages in pread*()
              • Sample code for handling _IO_WRITE messages in pwrite*()
            • Handling readcond()
          • Updating the time for reads and writes
        • Combine Messages
          • Where combine messages are used
          • The library's combine-message handling
            • Component responses
            • Component data access
            • Locking and unlocking the attribute structure
            • Connect message types
        • Extending the POSIX-Layer Data Structures
          • Extending the OCB and attribute structures
          • Extending the mount structure
        • Handling Other Messages
          • Custom messages
          • Handling devctl() messages
            • Sample code for handling _IO_DEVCTL messages
          • Handling ionotify() and select()
            • Sample code for handling _IO_NOTIFY messages
          • Handling out-of-band (_IO_MSG) messages
          • Handling private messages and pulses
          • Handling open(), dup(), and close() messages
          • Handling mount()
            • mount() function call
            • Mount in the resource manager
            • mount utility
          • Handling stat()
          • Handling lseek()
        • Unblocking Clients and Handling Interrupts
          • Handling client unblocking due to signals or timeouts
          • Unblocking if someone closes a file descriptor
          • Handling interrupts
            • Sample code for handling interrupts
        • Multithreaded Resource Managers
          • Multithreaded resource manager example
          • Thread pool attributes
          • Thread pool functions
        • Filesystem Resource Managers
          • Considerations for filesystem resource managers
          • Taking over more than one device
          • Handling directories
            • Matching at or below a mountpoint
            • The _IO_OPEN message for filesystems
            • Returning directory entries from _IO_READ
              • Returning information associated with a directory structure
        • Glossary
    • Utilities & Libraries
      • Addon Interfaces Library Reference
        • Overview
          • An example
        • Addon Interfaces Library Reference
          • AOICtrl_t
          • AOInterface_t
          • AoAdd()
          • AoAddDirectory()
          • AoAddStatic()
          • AoAddUnloadSignal()
          • AoGetInterface()
          • AoHold()
          • AoIterate()
          • AoIterateHoldGet()
          • AoRelease()
          • AoRemove()
          • AoFindExt()
          • AoFindFormats()
          • AoFindMime()
          • AoFindName()
          • AoFindStreams()
          • AoOpenFilespec()
        • Implemented Interfaces
          • Built-in Interfaces
          • AODeConstructor
            • Create()
            • Destroy()
          • AOExtInspector
            • RateExtension()
          • AOFormatInspector
            • RateFormat()
          • AOMimetypeInspector
            • RateMimetype()
          • AOStreamer
            • Open()
            • Close()
            • Sniff()
            • Read()
            • Write()
            • Seek()
            • Tell()
            • Length()
            • SideInfo()
          • AOStreamInspector
            • RateStream()
          • AOResourceAccess
            • GetResources()
            • SetResource()
          • Built-in interfaces
            • Unloading and InitializeInterface
            • Name
        • Using Addon Resources
          • An Example
          • Using addon resources in your application
        • Defined Structures
          • AOIStream_t
          • AOMimeInfo_t
          • AOResource_t
          • AOAudioFormat_t
          • ImageFormat_t
          • MediaFormat_t
          • VideoFormat_t
      • Devctl and Ioctl Commands
        • CAN_DEVCTL_*
          • CAN_DEVCTL_DEBUG_INFO
          • CAN_DEVCTL_DEBUG_INFO2
          • CAN_DEVCTL_ERROR
          • CAN_DEVCTL_GET_MFILTER
          • CAN_DEVCTL_GET_MID
          • CAN_DEVCTL_GET_PRIO
          • CAN_DEVCTL_GET_TIMESTAMP
          • CAN_DEVCTL_READ_CANMSG_EXT
          • CAN_DEVCTL_SET_MFILTER
          • CAN_DEVCTL_SET_MID
          • CAN_DEVCTL_SET_PRIO
          • CAN_DEVCTL_SET_TIMESTAMP
        • DCMD_ALL_*
          • DCMD_ALL_FADVISE
          • DCMD_ALL_GETFLAGS
          • DCMD_ALL_GETMOUNTFLAGS
          • DCMD_ALL_GETOWN
          • DCMD_ALL_SETFLAGS
          • DCMD_ALL_SETOWN
        • DCMD_BLK_*
          • DCMD_BLK_FORCE_RELEARN, DCMD_FSYS_FORCE_RELEARN
          • DCMD_BLK_PART_DESCRIPTION
          • DCMD_BLK_PARTENTRY
        • DCMD_BT_*
          • DCMD_BT_ISOC_DISABLE
          • DCMD_BT_ISOC_ENABLE
        • DCMD_CHR_*
          • DCMD_CHR_DISABLE_LOGGING
          • DCMD_CHR_ENABLE_LOGGING
          • DCMD_CHR_FLUSH_LOG
          • DCMD_CHR_FORCE_RTS
          • DCMD_CHR_GETOBAND
          • DCMD_CHR_GETSIZE
          • DCMD_CHR_GETVERBOSITY
          • DCMD_CHR_IDLE
          • DCMD_CHR_ISATTY
          • DCMD_CHR_ISCHARS
          • DCMD_CHR_ISSIZE
          • DCMD_CHR_LINESTATUS
          • DCMD_CHR_OSCHARS
          • DCMD_CHR_OSSIZE
          • DCMD_CHR_PARCTL
          • DCMD_CHR_PNPTEXT
          • DCMD_CHR_PUTOBAND
          • DCMD_CHR_RESET
          • DCMD_CHR_RESUME
          • DCMD_CHR_SERCTL
          • DCMD_CHR_SET_LOGGING_DIR
          • DCMD_CHR_SETSIZE
          • DCMD_CHR_SETVERBOSITY
          • DCMD_CHR_TCDRAIN
          • DCMD_CHR_TCFLOW
          • DCMD_CHR_TCFLUSH
          • DCMD_CHR_TCGETATTR
          • DCMD_CHR_TCGETPGRP
          • DCMD_CHR_TCGETSID
          • DCMD_CHR_TCINJECTC, DCMD_CHR_TCINJECTR
          • DCMD_CHR_TCSETATTR, DCMD_CHR_TCSETATTRD, DCMD_CHR_TCSETATTRF
          • DCMD_CHR_TCSETPGRP
          • DCMD_CHR_TCSETSID
          • DCMD_CHR_TTYINFO
          • DCMD_CHR_WAITINFO
        • DCMD_DUMPER_*
          • DCMD_DUMPER_NOTIFYEVENT
          • DCMD_DUMPER_REMOVEALL
          • DCMD_DUMPER_REMOVEEVENT
        • DCMD_ETFS_*
          • DCMD_ETFS_DEFRAG
          • DCMD_ETFS_ERASE
          • DCMD_ETFS_ERASE_RANGE
          • DCMD_ETFS_FLUSH_COUNT
          • DCMD_ETFS_FORMAT
          • DCMD_ETFS_INFO
          • DCMD_ETFS_START
          • DCMD_ETFS_STOP
        • DCMD_F3S_*
          • DCMD_F3S_ARRAYINFO
          • DCMD_F3S_CLRCMP
          • DCMD_F3S_ERASE
          • DCMD_F3S_EXIT
          • DCMD_F3S_FORMAT
          • DCMD_F3S_GEOINFO
          • DCMD_F3S_GETCMP
          • DCMD_F3S_LOCKSSR
          • DCMD_F3S_LOCK
          • DCMD_F3S_MOUNT
          • DCMD_F3S_PARTINFO
          • DCMD_F3S_READSSR
          • DCMD_F3S_RECLAIMCTL
          • DCMD_F3S_RECLAIM
          • DCMD_F3S_SETCMP
          • DCMD_F3S_UMOUNT
          • DCMD_F3S_UNITINFO
          • DCMD_F3S_UNLOCKALL
          • DCMD_F3S_UNLOCK
          • DCMD_F3S_WRITESSR
        • DCMD_FSEVMGR_*
          • DCMD_FSEVMGR_AUTHORIZE
          • DCMD_FSEVMGR_CHECK
          • DCMD_FSEVMGR_FILTER_ADD
          • DCMD_FSEVMGR_FILTER_REM
          • DCMD_FSEVMGR_QNX_EXT
          • DCMD_FSEVMGR_STATS
          • DCMD_FSEVMGR_WRITER
        • DCMD_FSYS_*
          • DCMD_FSYS_CRYPTO
          • DCMD_FSYS_DIRECT_IO
          • DCMD_FSYS_ERRNOTIFY
          • DCMD_FSYS_FILE_FLAGS
          • DCMD_FSYS_FILTER_DETACH
          • DCMD_FSYS_FSEVMGR_CHECK
          • DCMD_FSYS_FSNOTIFY
          • DCMD_FSYS_HOOK_CTL
          • DCMD_FSYS_LABEL, DCMD_FSYS_LABEL_RAW
          • DCMD_FSYS_MAP_OFFSET
          • DCMD_FSYS_MOUNTED_AT, DCMD_FSYS_MOUNTED_BY, DCMD_FSYS_MOUNTED_ON
          • DCMD_FSYS_OPTIONS
          • DCMD_FSYS_PREGROW_FILE
          • DCMD_FSYS_STATISTICS, DCMD_FSYS_STATISTICS_CLR
          • DCMD_FSYS_STATVFS
        • DCMD_IP_*
          • DCMD_IP_FDINFO
          • DCMD_IP_GDESTADDR
          • DCMD_IP_GSRCADDR
          • DCMD_IP_LISTEN
          • DCMD_IP_SDESTADDR
          • DCMD_IP_SHUTDOWN
          • DCMD_IP_SSRCADDR
        • DCMD_MEMMGR_*
        • DCMD_MISC_*
          • DCMD_MISC_MQGETATTR
          • DCMD_MISC_MQSETATTR
          • DCMD_MISC_MQSETCLOSEMSG
        • DCMD_MMCSD_*
          • DCMD_MMCSD_CARD_REGISTER
          • DCMD_MMCSD_ERASE
          • DCMD_MMCSD_ERASED_VAL
          • DCMD_MMCSD_GET_CID
          • DCMD_MMCSD_GET_CID_RAW
          • DCMD_MMCSD_GET_CSD
          • DCMD_MMCSD_RPMB_RW_FRAME
          • DCMD_MMCSD_RPMB_SIZE
          • DCMD_MMCSD_VUC_CMD
          • DCMD_MMCSD_WRITE_PROTECT
        • DCMD_PROC_*
        • DCMD_PROF_*
          • DCMD_PROF_ATTACH
          • DCMD_PROF_DETACH
          • DCMD_PROF_MAPPING_ADD
          • DCMD_PROF_MAPPING_REM
          • DCMD_PROF_QUERY
        • DCMD_SDIO_*
          • DCMD_SDIO_ATTACH_DEVICE
          • DCMD_SDIO_CFG_IOMEM
          • DCMD_SDIO_CLR_IOREG
          • DCMD_SDIO_DETACH_DEVICE
          • DCMD_SDIO_DEV_START
          • DCMD_SDIO_DEV_STOP
          • DCMD_SDIO_GET_HCCAP
          • DCMD_SDIO_INTR_DISABLE
          • DCMD_SDIO_INTR_ENABLE
          • DCMD_SDIO_READ_IOREG
          • DCMD_SDIO_SET_IOREG
          • DCMD_SDIO_SHMEM_FINI
          • DCMD_SDIO_SHMEM_INIT
          • DCMD_SDIO_VENDOR
          • DCMD_SDIO_WRITE_IOREG
        • DCMD_SDMMC_*
          • DCMD_SDMMC_ASSD_APDU
          • DCMD_SDMMC_ASSD_CONTROL
          • DCMD_SDMMC_ASSD_PROPERTIES
          • DCMD_SDMMC_ASSD_STATUS
          • DCMD_SDMMC_CARD_REGISTER
          • DCMD_SDMMC_DEVICE_HEALTH
          • DCMD_SDMMC_DEVICE_INFO
          • DCMD_SDMMC_ERASE
          • DCMD_SDMMC_LOCK_UNLOCK
          • DCMD_SDMMC_PART_INFO
          • DCMD_SDMMC_PWR_MGNT
          • DCMD_SDMMC_WRITE_PROTECT
        • DCMD_SPI_*
        • FIO*
          • FIOASYNC
          • FIOCLEX
          • FIOGETOWN
          • FIONBIO
          • FIONCLEX
          • FIONREAD
          • FIONSPACE
          • FIONWRITE
          • FIOSETOWN
        • TC*
          • TCFLSH
          • TCGETA
          • TCGETS
          • TCSBRK
          • TCSETA, TCSETAF, TCSETAW
          • TCSETS, TCSETSF, TCSETSW
          • TCXONC
        • TIOC*
          • TIOCCBRK
          • TIOCCDTR
          • TIOCDRAIN
          • TIOCEXCL, TIOCSINUSE
          • TIOCFLUSH
          • TIOCGETA
          • TIOCGETC
          • TIOCGETP
          • TIOCGLTC
          • TIOCGETPGRP, TIOCGPGRP
          • TIOCGSIZE, TIOCGWINSZ
          • TIOCHPCL
          • TIOCLGET
          • TIOCLSET
          • TIOCMBIC
          • TIOCMBIS
          • TIOCMGET
          • TIOCMSET
          • TIOCNOTTY
          • TIOCNXCL
          • TIOCOUTQ
          • TIOCPKT
          • TIOCSCTTY
          • TIOCSDTR
          • TIOCSETA, TIOCSETAF, TIOCSETAW
          • TIOCSETC
          • TIOCSETN, TIOCSETP
          • TIOCSLTC
          • TIOCSETPGRP, TIOCSPGRP
          • TIOCSTART
          • TIOCSTI
          • TIOCSTOP
          • TIOCSSIZE, TIOCSWINSZ
      • Dinkum C/C++ Libraries
        • Dinkum C++11 Libraries
          • C++ Library Overview
          • C Library Overview
          • Characters
          • Files and Streams
          • Formatted Output
          • Formatted Input
          • Locale Definitions
          • STL Conventions
          • STL Container
          • Random Number Generators
          • Regular Expressions
          • Thread Safety
          • Dinkum Allocators Library
          • Dinkum Conversions Library
            • Multibyte Conversions
          • Dinkum Threads Library
            • C Interface
            • C++ Interface
          • <algorithm>
          • "allocators"
          • <array>
          • <assert.h>
          • <atomic>
          • <bitset>
          • <cassert>
          • <ccomplex>
          • <cctype>
          • <cerrno>
          • <cfenv>
          • <cfloat>
          • <chrono>
          • <cinttypes>
          • <ciso646>
          • <climits>
          • <clocale>
          • <cmath>
          • <codecvt>
          • <complex>
          • <complex.h>
          • "condition"
          • <condition_variable>
          • <csetjmp>
          • <csignal>
          • <cstdalign>
          • <cstdarg>
          • <cstdbool>
          • <cstddef>
          • <cstdint>
          • <cstdio>
          • <cstdlib>
          • <cstring>
          • <ctgmath>
          • <ctime>
          • <ctype.h>
          • <cuchar>
          • <cwchar>
          • <cwctype>
          • <deque>
          • <errno.h>
          • <exception>
          • "exceptions"
          • <fenv.h>
          • "fixed.h"
          • <float.h>
          • <forward_list>
          • <fstream>
          • <functional>
          • <future>
          • <hardware>
          • <hash_map>
          • <hash_set>
          • <initializer_list>
          • <inttypes.h>
          • <iohw.h>
          • <iomanip>
          • <ios>
          • <iosfwd>
          • <iostream>
          • <iso646.h>
          • <istream>
          • <iterator>
          • <limits>
          • <limits.h>
          • <list>
          • <locale>
          • <locale.h>
          • <map>
          • <math.h>
          • <memory>
          • "mutex"
          • <mutex>
          • <new>
          • <numeric>
          • "once"
          • <ostream>
          • <queue>
          • <random>
          • <ratio>
          • "recursive_mutex"
          • <regex>
          • <scoped_allocator>
          • <set>
          • <setjmp.h>
          • <signal.h>
          • <slist>
          • <sstream>
          • <stack>
          • <stdalign.h>
          • <stdarg.h>
          • <stdbool.h>
          • <stddef.h>
          • <stdexcept>
          • <stdfix.h>
          • <stdint.h>
          • <stdio.h>
          • <stdlib.h>
          • <streambuf>
          • <string>
          • <string.h>
          • <strstream>
          • <system_error>
          • <tgmath.h>
          • <thread>
          • "threads.h"
          • <time.h>
          • "tss"
          • <tuple>
          • <typeindex>
          • <typeinfo>
          • <type_traits>
          • <uchar.h>
          • <unordered_map>
          • <unordered_set>
          • <utility>
          • <valarray>
          • <vector>
          • "wbuffer.h"
          • <wchar.h>
          • <wctype.h>
          • "wstring"
          • "xtime"
          • "xtimec.h"
          • Expressions
          • Functions
          • Preprocessing
          • Index
      • QNX Neutrino C Library Reference
        • What's in a Function Description?
        • Manifests
        • A
          • abort()
          • abs()
          • accept()
          • access()
          • acl_add_perm()
          • acl_calc_mask()
          • acl_clear_perms()
          • acl_copy_entry()
          • acl_copy_ext()
          • acl_copy_int()
          • acl_create_entry()
          • acl_delete_entry()
          • acl_delete_perm()
          • acl_dup()
          • acl_free()
          • acl_from_text()
          • acl_get_entry()
          • acl_get_fd()
          • acl_get_file()
          • acl_get_permset()
          • acl_get_qualifier()
          • acl_get_tag_type()
          • acl_init()
          • acl_set_fd()
          • acl_set_file()
          • acl_set_permset()
          • acl_set_qualifier()
          • acl_set_tag_type()
          • acl_size()
          • acl_to_text()
          • acl_valid()
          • acos(), acosf(), acosl()
          • acosh(), acoshf(), acoshl()
          • addrinfo
          • aio_cancel()
          • aio_error()
          • aio_fsync()
          • aio_read(), aio_read64()
          • aio_return()
          • aio_suspend()
          • aio_write(), aio_write64()
          • aiocb, aiocb64
          • alarm()
          • alloca()
          • alphasort()
          • _amblksiz
          • _argc
          • _argv
          • asctime(), asctime_r()
          • asin(), asinf(), asinl()
          • asinh(), asinhf(), asinhl()
          • assert()
          • atan(), atanf(), atanl()
          • atan2(), atan2f()
          • atanh(), atanhf(), atanhl()
          • atexit()
          • atof()
          • atoh()
          • atoi()
          • atol(), atoll()
          • atomic_add()
          • atomic_add_value()
          • atomic_clr()
          • atomic_clr_value()
          • atomic_set()
          • atomic_set_value()
          • atomic_sub()
          • atomic_sub_value()
          • atomic_toggle()
          • atomic_toggle_value()
          • _auxv
        • B
          • basename()
          • bcmp()
          • bcopy()
          • bind()
          • bindresvport()
          • bsearch()
          • bt_get_backtrace()
          • bt_init_accessor()
          • bt_load_memmap()
          • bt_release_accessor()
          • bt_set_flags()
          • bt_sprn_memmap()
          • bt_sprnf_addrs()
          • bt_translate_addrs()
          • bt_unload_memmap()
          • _btext
          • btowc()
          • bzero()
        • C
          • _cred_info
          • cabs(), cabsf(), cabsl()
          • cache_fini()
          • CACHE_FLUSH()
          • cache_init()
          • CACHE_INVAL()
          • calloc()
          • cbrt(), cbrtf()
          • ceil(), ceilf()
          • cfgetispeed()
          • cfgetospeed()
          • cfgopen()
          • cfmakeraw()
          • cfree()
          • cfsetispeed()
          • cfsetospeed()
          • ChannelCreate(), ChannelCreate_r()
          • ChannelDestroy(), ChannelDestroy_r()
          • chdir()
          • chmod()
          • chown()
          • chroot()
          • chsize()
          • clearenv()
          • clearerr()
          • ClientInfoExtFree()
          • clock()
          • clock_getcpuclockid()
          • clock_getres()
          • clock_gettime()
          • clock_nanosleep()
          • clock_settime()
          • ClockAdjust(), ClockAdjust_r()
          • ClockCycles()
          • ClockId(), ClockId_r()
          • ClockPeriod(), ClockPeriod_r()
          • ClockTime(), ClockTime_r()
          • close()
          • closedir()
          • closelog()
          • _cmdfd()
          • _cmdname()
          • confstr()
          • connect()
          • ConnectAttach(), ConnectAttach_r()
          • ConnectClientInfo(), ConnectClientInfo_r()
          • ConnectClientInfoAble()
          • ConnectClientInfoExt()
          • ConnectDetach(), ConnectDetach_r()
          • ConnectFlags(), ConnectFlags_r()
          • ConnectServerInfo(), ConnectServerInfo_r()
          • copysign(), copysignf()
          • cos(), cosf(), cosl()
          • cosh(), coshf(), coshl()
          • creat(), creat64()
          • crypt()
          • ctermid()
          • ctime(), ctime_r()
        • D
          • daemon()
          • daylight
          • DebugBreak()
          • DebugKDBreak()
          • DebugKDOutput()
          • delay()
          • devctl(),devctlv()
          • dhcpctl*()
          • difftime()
          • dircntl()
          • dirent, dirent64
          • dirname()
          • dispatch_block()
          • dispatch_context_alloc()
          • dispatch_context_free()
          • dispatch_create()
          • dispatch_create_channel()
          • dispatch_destroy()
          • dispatch_handler()
          • dispatch_timeout()
          • dispatch_unblock()
          • div()
          • dl_iterate_phdr()
          • dladdr()
          • dlclose()
          • dlerror()
          • dlopen()
          • dlsym()
          • dn_comp()
          • dn_expand()
          • drand48()
          • ds_clear()
          • ds_create()
          • ds_deregister()
          • ds_flags()
          • ds_get()
          • ds_register()
          • ds_set()
          • dup()
          • dup2()
        • E
          • eaccess()
          • _edata
          • encrypt()
          • _end
          • endfsent()
          • endgrent()
          • endhostent()
          • ENDIAN_BE16()
          • ENDIAN_BE32()
          • ENDIAN_BE64()
          • ENDIAN_LE16()
          • ENDIAN_LE32()
          • ENDIAN_LE64()
          • ENDIAN_RET16()
          • ENDIAN_RET32()
          • ENDIAN_RET64()
          • ENDIAN_SWAP16()
          • ENDIAN_SWAP32()
          • ENDIAN_SWAP64()
          • endnetent()
          • endprotoent()
          • endpwent()
          • endservent()
          • endspent()
          • endutent()
          • environ
          • eof()
          • erand48()
          • erf(), erff()
          • erfc(), erfcf(), erfcl()
          • err(), errx()
          • errno
          • _etext
          • execl()
          • execle()
          • execlp()
          • execlpe()
          • execv()
          • execve()
          • execvp()
          • execvpe()
          • _exit()
          • exit()
          • exp(), expf(), expl()
          • expm1(), expm1f()
        • F
          • fabs(), fabsf()
          • fcfgopen()
          • fchdir()
          • fchmod()
          • fchown()
          • fclose()
          • fcloseall()
          • fcntl()
          • fdatasync()
          • fdistrusted()
          • fdopen()
          • feof()
          • ferror()
          • fflush()
          • ffs()
          • fgetc()
          • fgetchar()
          • fgetpos()
          • fgets()
          • fgetspent()
          • fgetwc()
          • fgetws()
          • fileno()
          • flink()
          • flock()
          • flockfile()
          • floor(), floorf()
          • flushall()
          • fmod(), fmodf(), fmodl()
          • fnmatch()
          • fopen(), fopen64()
          • fork()
          • forkpty()
          • fp_exception_mask()
          • fp_exception_value()
          • fp_precision()
          • fp_rounding()
          • forksafe_mutex_destroy()
          • forksafe_mutex_init()
          • forksafe_mutex_lock()
          • forksafe_mutex_trylock()
          • forksafe_mutex_unlock()
          • fpathconf()
          • fprintf()
          • fputc()
          • fputchar()
          • fputs()
          • fputwc()
          • fputws()
          • fread()
          • free()
          • freeaddrinfo()
          • freeifaddrs()
          • freopen(), freopen64()
          • frexp(), frexpf()
          • fs_crypto_check()
          • fs_crypto_domain_add()
          • fs_crypto_domain_key_change()
          • fs_crypto_domain_key_check()
          • fs_crypto_domain_key_size()
          • fs_crypto_domain_lock()
          • fs_crypto_domain_query()
          • fs_crypto_domain_remove()
          • fs_crypto_domain_unlock()
          • fs_crypto_enable()
          • fs_crypto_enable_option()
          • fs_crypto_file_get_domain()
          • fs_crypto_file_set_domain()
          • fs_crypto_key_gen()
          • fs_crypto_migrate_control()
          • fs_crypto_migrate_path()
          • fs_crypto_migrate_status()
          • fs_crypto_migrate_tag()
          • fs_crypto_set_logging()
          • fscanf()
          • fsev_t, FSE*()
          • fseek(), fseeko(), fseeko64()
          • fsetpos()
          • fstat(), fstat64()
          • fstatvfs(), fstatvfs64()
          • fsync()
          • ftell(), ftello(), ftello64()
          • ftime()
          • ftruncate(), ftruncate64()
          • ftrylockfile()
          • ftw(), ftw64()
          • funlockfile()
          • futime()
          • fwide()
          • fwprintf()
          • fwrite()
          • fwscanf()
        • G
          • gai_strerror()
          • gamma(), gamma_r(), gammaf(), gammaf_r()
          • getaddrinfo()
          • getc()
          • getc_unlocked()
          • getchar()
          • getchar_unlocked()
          • getcwd()
          • getdomainname()
          • getdtablesize()
          • getegid()
          • getenv()
          • geteuid()
          • getfsfile()
          • getfsent()
          • getfsspec()
          • getgid()
          • getgrent()
          • getgrgid()
          • getgrgid_r()
          • getgrnam()
          • getgrnam_r()
          • getgrouplist()
          • getgroups()
          • gethostbyaddr()
          • gethostbyaddr_r()
          • gethostbyname(), gethostbyname2()
          • gethostbyname_r()
          • gethostent()
          • gethostent_r()
          • gethostname()
          • getifaddrs()
          • GETIOVBASE()
          • GETIOVLEN()
          • getitimer()
          • getlogin()
          • getlogin_r()
          • getnameinfo()
          • getnetbyaddr()
          • getnetbyname()
          • getnetent()
          • getopt()
          • getpagesize()
          • getpagesizes(), getpagesizes64()
          • getpass()
          • getpeereid()
          • getpeername()
          • getpgid()
          • getpgrp()
          • getpid()
          • getppid()
          • getprio()
          • getprotobyname()
          • getprotobynumber()
          • getprotoent()
          • getpwent()
          • getpwent_r()
          • getpwnam()
          • getpwnam_r()
          • getpwuid()
          • getpwuid_r()
          • getrlimit(), getrlimit64()
          • getrusage()
          • gets()
          • getservbyname()
          • getservbyport()
          • getservent()
          • getsid()
          • getsockname()
          • getsockopt()
          • getspent(), getspent_r()
          • getspnam(), getspnam_r()
          • getsubopt()
          • gettid()
          • gettimeofday()
          • getuid()
          • getutent()
          • getutid()
          • getutline()
          • getw()
          • getwc()
          • getwchar()
          • getwd()
          • glob()
          • globfree()
          • gmtime()
          • gmtime_r()
          • grantpt()
        • H
          • h_errno
          • hcreate()
          • hdestroy()
          • herror()
          • hostent
          • hsearch()
          • hstrerror()
          • htonl()
          • htons()
          • hwi_find()
          • hwi_find_bus()
          • hwi_find_device()
          • hwi_find_devicebus()
          • hwi_find_item()
          • hwi_find_num_units()
          • hwi_find_tag()
          • hwi_find_unit()
          • hwi_next_item()
          • hwi_next_tag()
          • hwi_off2tag()
          • hwi_tag2off()
          • hwi_tag_find()
          • hwiattr_get(), hwiattr_get_*()
          • hwitag_find_busattr()
          • hwitag_find_clkfreq()
          • hwitag_find_errata()
          • hwitag_find_ivec()
          • hwitag_find_nicaddr()
          • hwitag_find_phyaddr()
          • hypot(), hypotf()
        • I
          • ICMP
          • ICMP6
          • if_freenameindex()
          • if_indextoname()
          • if_nameindex()
          • if_nametoindex()
          • ifaddrs
          • ilogb(), ilogbf()
          • in8()
          • in8s()
          • in16(), inbe16(), inle16()
          • in16s()
          • in32(), inbe32(), inle32()
          • in32s()
          • index()
          • inet_addr()
          • inet_aton()
          • inet_lnaof()
          • inet_makeaddr()
          • inet_net_ntop()
          • inet_netof()
          • inet_net_pton()
          • inet_network()
          • inet_ntoa()
          • inet_ntoa_r()
          • inet_ntop()
          • inet_pton()
          • INET6
          • inet6_option_alloc()
          • inet6_option_append()
          • inet6_option_find()
          • inet6_option_init()
          • inet6_option_next()
          • inet6_option_space()
          • inet6_rthdr_add()
          • inet6_rthdr_getaddr()
          • inet6_rthdr_getflags()
          • inet6_rthdr_init()
          • inet6_rthdr_lasthop()
          • inet6_rthdr_reverse()
          • inet6_rthdr_segments()
          • inet6_rthdr_space()
          • initgroups()
          • initstate()
          • inotify_add_watch()
          • inotify_event
          • inotify_init()
          • inotify_rm_watch()
          • input_line()
          • insque()
          • InterruptAttach(), InterruptAttach_r()
          • InterruptAttachEvent(), InterruptAttachEvent_r()
          • InterruptCharacteristic(), InterruptCharacteristic_r()
          • InterruptDetach(), InterruptDetach_r()
          • InterruptDisable()
          • InterruptEnable()
          • InterruptHookIdle2()
          • InterruptHookTrace()
          • InterruptLock()
          • InterruptMask()
          • InterruptStatus()
          • InterruptUnlock()
          • InterruptUnmask()
          • InterruptWait(), InterruptWait_r()
          • _intr_v86()
          • _io_connect
          • _io_connect_ftype_reply
          • _io_connect_link_reply
          • ioctl(), ioctl_socket()
          • iofdinfo()
          • iofunc_ability_check()
          • iofunc_acl()
          • iofunc_acl_default()
          • iofunc_attr_init()
          • iofunc_attr_lock()
          • iofunc_attr_t
          • iofunc_attr_trylock()
          • iofunc_attr_unlock()
          • iofunc_check_access()
          • iofunc_chmod()
          • iofunc_chmod_default()
          • iofunc_chown()
          • iofunc_chown_default()
          • iofunc_client_info_able()
          • iofunc_client_info_ext()
          • iofunc_client_info_ext_free()
          • iofunc_close_dup()
          • iofunc_close_dup_default()
          • iofunc_close_ocb()
          • iofunc_close_ocb_default()
          • iofunc_devctl()
          • iofunc_devctl_default()
          • iofunc_devctl_verify()
          • iofunc_fdinfo()
          • iofunc_fdinfo_default()
          • iofunc_func_init()
          • iofunc_link()
          • iofunc_lock()
          • iofunc_lock_calloc()
          • iofunc_lock_default()
          • iofunc_lock_free()
          • iofunc_lock_ocb_default()
          • iofunc_lseek()
          • iofunc_lseek_default()
          • iofunc_mknod()
          • iofunc_mmap()
          • iofunc_mmap_default()
          • iofunc_notify()
          • iofunc_notify_remove(), iofunc_notify_remove_strict()
          • iofunc_notify_trigger(), iofunc_notify_trigger_strict()
          • iofunc_ocb_attach()
          • iofunc_ocb_calloc()
          • iofunc_ocb_detach()
          • iofunc_ocb_free()
          • iofunc_ocb_t
          • iofunc_open()
          • iofunc_open_default()
          • iofunc_openfd()
          • iofunc_openfd_default()
          • iofunc_pathconf()
          • iofunc_pathconf_default()
          • iofunc_read_default()
          • iofunc_read_verify()
          • iofunc_readlink()
          • iofunc_rename()
          • iofunc_space_verify()
          • iofunc_stat()
          • iofunc_stat_default()
          • iofunc_sync()
          • iofunc_sync_default()
          • iofunc_sync_verify()
          • iofunc_time_update()
          • iofunc_unblock()
          • iofunc_unblock_default()
          • iofunc_unlink()
          • iofunc_unlock_ocb_default()
          • iofunc_utime()
          • iofunc_utime_default()
          • iofunc_write_default()
          • iofunc_write_verify()
          • ionotify()
          • IP
          • IPsec
          • ipsec_dump_policy()
          • ipsec_get_policylen()
          • ipsec_set_policy()
          • ipsec_strerror()
          • IPv6
          • iruserok(), iruserok_sa()
          • isalnum()
          • isalpha()
          • isascii()
          • isatty()
          • isblank()
          • iscntrl()
          • isdigit()
          • isfdtype()
          • isfinite()
          • isgraph()
          • isinf()
          • islower()
          • isnan()
          • isprint()
          • ispunct()
          • isspace()
          • isupper()
          • iswalnum()
          • iswalpha()
          • iswblank()
          • iswcntrl()
          • iswctype()
          • iswdigit()
          • iswgraph()
          • iswlower()
          • iswprint()
          • iswpunct()
          • iswspace()
          • iswupper()
          • iswxdigit()
          • isxdigit()
          • itoa()
        • J
          • j0(), j0f()
          • j1(), j1f()
          • jn(), jnf()
          • jrand48()
        • K
          • kill()
          • killpg()
        • L
          • labs()
          • lchown()
          • lcong48()
          • ldexp(), ldexpf(), ldexpl()
          • ldiv(), lldiv()
          • lfind()
          • lgamma(), lgamma_r(), lgammaf(), lgammaf_r()
          • link()
          • lio_listio(), lio_listio64()
          • listen()
          • llabs()
          • localeconv()
          • localtime()
          • localtime_r()
          • lockf(), lockf64()
          • log(), logf(), logl()
          • log10(), log10f(), log10l()
          • log1p(), log1pf(), log1pl()
          • logb(), logbf()
          • login_tty()
          • longjmp()
          • lrand48()
          • lsearch()
          • lseek(), lseek64()
          • lstat(), lstat64()
          • ltoa(), lltoa()
          • ltrunc()
        • M
          • main()
          • mallinfo()
          • malloc()
          • mallopt()
          • max()
          • mblen()
          • mbrlen()
          • mbrtowc()
          • mbsinit()
          • mbsrtowcs()
          • mbstowcs()
          • mbtowc()
          • mcheck()
          • mem_offset(), mem_offset64()
          • memalign()
          • memccpy()
          • memchr()
          • memcmp()
          • memcpy()
          • memcpyv()
          • memicmp()
          • memmove()
          • memset()
          • memset_s()
          • message_attach()
          • message_connect()
          • message_detach()
          • min()
          • mkdir()
          • mkfifo()
          • mknod()
          • mkstemp()
          • mktemp()
          • mktime()
          • mlock()
          • mlockall()
          • mmap(), mmap64()
          • mmap_device_io()
          • mmap_device_memory()
          • modem_open()
          • modem_read()
          • modem_script()
          • modem_write()
          • modf(), modff()
          • mount()
          • mount_parse_generic_args()
          • mprobe()
          • mprotect()
          • mq_close()
          • mq_getattr()
          • mq_notify()
          • mq_open()
          • mq_receive()
          • mq_send()
          • mq_setattr()
          • mq_timedreceive(), mq_timedreceive_monotonic()
          • mq_timedsend(), mq_timedsend_monotonic()
          • mq_unlink()
          • mrand48()
          • _msg_info
          • MsgCurrent(), MsgCurrent_r()
          • MsgDeliverEvent(), MsgDeliverEvent_r()
          • MsgError(), MsgError_r()
          • MsgInfo(), MsgInfo_r()
          • MsgKeyData(), MsgKeyData_r()
          • MsgPause(), MsgPause_r()
          • MsgRead(), MsgRead_r()
          • MsgReadv(), MsgReadv_r()
          • MsgReceive(), MsgReceive_r()
          • MsgReceivePulse(), MsgReceivePulse_r()
          • MsgReceivePulsev(), MsgReceivePulsev_r()
          • MsgReceivev(), MsgReceivev_r()
          • MsgReply(), MsgReply_r()
          • MsgReplyv(), MsgReplyv_r()
          • MsgSend(), MsgSend_r()
          • MsgSendnc(), MsgSendnc_r()
          • MsgSendPulse(), MsgSendPulse_r()
          • MsgSendsv(), MsgSendsv_r()
          • MsgSendsvnc(), MsgSendsvnc_r()
          • MsgSendv(), MsgSendv_r()
          • MsgSendvnc(), MsgSendvnc_r()
          • MsgSendvs(), MsgSendvs_r()
          • MsgSendvsnc(), MsgSendvsnc_r()
          • MsgVerifyEvent(), MsgVerifyEvent_r()
          • MsgWrite(), MsgWrite_r()
          • MsgWritev(), MsgWritev_r()
          • msync()
          • munlock()
          • munlockall()
          • munmap()
          • munmap_device_io()
          • munmap_device_memory()
          • munmap_flags()
        • N
          • name_attach()
          • name_close()
          • name_detach()
          • name_open()
          • nanosleep()
          • nanospin()
          • nanospin_calibrate()
          • nanospin_count()
          • nanospin_ns()
          • nanospin_ns_to_count()
          • nap()
          • napms()
          • nbaconnect()
          • nbaconnect_result()
          • ncurses
          • ND_NODE_CMP()
          • netent
          • netmgr_ndtostr()
          • netmgr_remote_nd()
          • netmgr_strtond()
          • nextafter(), nextafterf()
          • nftw(), nftw64()
          • nice()
          • nrand48()
          • nsec2timespec()
          • _NTO_TRACE_GET*(), _NTO_TRACE_SET*()
          • ntohl()
          • ntohs()
        • O
          • offsetof()
          • OMAPI
          • open(), open64()
          • opendir()
          • openfd()
          • openlog()
          • openpty()
          • out8()
          • out8s()
          • out16(), outbe16(), outle16()
          • out16s()
          • out32(), outbe32(), outle32()
          • out32s()
        • P
          • pathconf()
          • pathfind(), pathfind_r()
          • pathmgr_link()
          • pathmgr_symlink()
          • pathmgr_unlink()
          • pause()
          • pccard_arm()
          • pccard_attach()
          • pccard_detach()
          • pccard_info()
          • pccard_lock()
          • pccard_raw_read()
          • pccard_unlock()
          • pci_attach()
          • pci_attach_device()
          • pci_detach()
          • pci_detach_device()
          • pci_find_class()
          • pci_find_device()
          • pci_irq_routing_options()
          • pci_map_irq()
          • pci_present()
          • pci_read_config()
          • pci_read_config8()
          • pci_read_config16()
          • pci_read_config32()
          • pci_rescan_bus()
          • pci_write_config()
          • pci_write_config8()
          • pci_write_config16()
          • pci_write_config32()
          • pclose()
          • perror()
          • pipe()
          • poll()
          • popen()
          • posix_fadvise(), posix_fadvise64()
          • posix_fallocate(), posix_fallocate64()
          • posix_madvise()
          • posix_mem_offset(), posix_mem_offset64()
          • posix_memalign()
          • posix_openpt()
          • posix_spawn(), posix_spawnp()
          • posix_spawn_file_actions_addclose()
          • posix_spawn_file_actions_adddup2()
          • posix_spawn_file_actions_destroy()
          • posix_spawn_file_actions_init()
          • posix_spawnattr_addpartid()
          • posix_spawnattr_addpartition()
          • posix_spawnattr_destroy()
          • posix_spawnattr_getcred()
          • posix_spawnattr_getflags()
          • posix_spawnattr_getnode()
          • posix_spawnattr_getpartid()
          • posix_spawnattr_getpgroup()
          • posix_spawnattr_getrunmask()
          • posix_spawnattr_getschedparam()
          • posix_spawnattr_getschedpolicy()
          • posix_spawnattr_getsigdefault()
          • posix_spawnattr_getsigignore()
          • posix_spawnattr_getsigmask()
          • posix_spawnattr_getstackmax()
          • posix_spawnattr_getxflags()
          • posix_spawnattr_init()
          • posix_spawnattr_setcred()
          • posix_spawnattr_setflags()
          • posix_spawnattr_setnode()
          • posix_spawnattr_setpgroup()
          • posix_spawnattr_setrunmask()
          • posix_spawnattr_setschedparam()
          • posix_spawnattr_setschedpolicy()
          • posix_spawnattr_setsigdefault()
          • posix_spawnattr_setsigignore()
          • posix_spawnattr_setsigmask()
          • posix_spawnattr_setstackmax()
          • posix_spawnattr_setxflags()
          • posix_typed_mem_get_info()
          • posix_typed_mem_open()
          • pow(), powf(), powl()
          • pread(), pread64()
          • printf()
          • procmgr_ability()
          • procmgr_ability_create()
          • procmgr_ability_lookup()
          • procmgr_daemon()
          • procmgr_event_notify()
          • procmgr_event_notify_add()
          • procmgr_event_notify_delete()
          • procmgr_event_trigger(), procmgr_event_trigger_updateable()
          • procmgr_guardian()
          • procmgr_session()
          • procmgr_timer_tolerance()
          • procmgr_value_current()
          • procmgr_value_notify_add()
          • __progname
          • protoent
          • pthread_abort()
          • pthread_atfork()
          • pthread_attr_destroy()
          • pthread_attr_getdetachstate()
          • pthread_attr_getguardsize()
          • pthread_attr_getinheritsched()
          • pthread_attr_getschedparam()
          • pthread_attr_getschedpolicy()
          • pthread_attr_getscope()
          • pthread_attr_getstack()
          • pthread_attr_getstackaddr()
          • pthread_attr_getstacklazy()
          • pthread_attr_getstackprealloc()
          • pthread_attr_getstacksize()
          • pthread_attr_init()
          • pthread_attr_setdetachstate()
          • pthread_attr_setguardsize()
          • pthread_attr_setinheritsched()
          • pthread_attr_setschedparam()
          • pthread_attr_setschedpolicy()
          • pthread_attr_setscope()
          • pthread_attr_setstack()
          • pthread_attr_setstackaddr()
          • pthread_attr_setstacklazy()
          • pthread_attr_setstackprealloc()
          • pthread_attr_setstacksize()
          • pthread_barrier_destroy()
          • pthread_barrier_init()
          • pthread_barrier_wait()
          • pthread_barrierattr_destroy()
          • pthread_barrierattr_getpshared()
          • pthread_barrierattr_init()
          • pthread_barrierattr_setpshared()
          • pthread_cancel()
          • pthread_cleanup_pop()
          • pthread_cleanup_push()
          • pthread_cond_broadcast()
          • pthread_cond_destroy()
          • pthread_cond_init()
          • pthread_cond_signal()
          • pthread_cond_timedwait()
          • pthread_cond_wait()
          • pthread_condattr_destroy()
          • pthread_condattr_getclock()
          • pthread_condattr_getpshared()
          • pthread_condattr_init()
          • pthread_condattr_setclock()
          • pthread_condattr_setpshared()
          • pthread_create()
          • pthread_detach()
          • pthread_equal()
          • pthread_exit()
          • pthread_getconcurrency()
          • pthread_getcpuclockid()
          • pthread_getname_np()
          • pthread_getschedparam()
          • pthread_getspecific()
          • pthread_join()
          • pthread_key_create()
          • pthread_key_delete()
          • pthread_kill()
          • pthread_mutex_destroy()
          • pthread_mutex_getprioceiling()
          • pthread_mutex_init()
          • pthread_mutex_lock()
          • pthread_mutex_setprioceiling()
          • pthread_mutex_timedlock(), pthread_mutex_timedlock_monotonic()
          • pthread_mutex_trylock()
          • pthread_mutex_unlock()
          • pthread_mutex_wakeup_np()
          • pthread_mutexattr_destroy()
          • pthread_mutexattr_getprioceiling()
          • pthread_mutexattr_getprotocol()
          • pthread_mutexattr_getpshared()
          • pthread_mutexattr_getrecursive()
          • pthread_mutexattr_gettype()
          • pthread_mutexattr_getwakeup_np()
          • pthread_mutexattr_init()
          • pthread_mutexattr_setprioceiling()
          • pthread_mutexattr_setprotocol()
          • pthread_mutexattr_setpshared()
          • pthread_mutexattr_setrecursive()
          • pthread_mutexattr_settype()
          • pthread_mutexattr_setwakeup_np()
          • pthread_once()
          • pthread_rwlock_destroy()
          • pthread_rwlock_init()
          • pthread_rwlock_rdlock()
          • pthread_rwlock_timedrdlock()
          • pthread_rwlock_timedwrlock()
          • pthread_rwlock_tryrdlock()
          • pthread_rwlock_trywrlock()
          • pthread_rwlock_unlock()
          • pthread_rwlock_wrlock()
          • pthread_rwlockattr_destroy()
          • pthread_rwlockattr_getpshared()
          • pthread_rwlockattr_init()
          • pthread_rwlockattr_setpshared()
          • pthread_self()
          • pthread_setcancelstate()
          • pthread_setcanceltype()
          • pthread_setconcurrency()
          • pthread_setname_np()
          • pthread_setschedparam()
          • pthread_setschedprio()
          • pthread_setspecific()
          • pthread_sigmask()
          • pthread_sleepon_broadcast()
          • pthread_sleepon_lock()
          • pthread_sleepon_signal()
          • pthread_sleepon_timedwait()
          • pthread_sleepon_unlock()
          • pthread_sleepon_wait()
          • pthread_spin_destroy()
          • pthread_spin_init()
          • pthread_spin_lock()
          • pthread_spin_trylock()
          • pthread_spin_unlock()
          • pthread_testcancel()
          • pthread_timedjoin(), pthread_timedjoin_monotonic()
          • ptsname()
          • ptsname_r()
          • _pulse
          • pulse_attach()
          • pulse_detach()
          • putc()
          • putc_unlocked()
          • putchar()
          • putchar_unlocked()
          • putenv()
          • puts()
          • putspent()
          • pututline()
          • putw()
          • putwc()
          • putwchar()
          • pwrite(), pwrite64()
        • Q
          • qnx_crypt()
          • qsort()
        • R
          • Raccept()
          • raise()
          • rand()
          • rand_r()
          • random()
          • Rbind()
          • rcmd(), rcmd_af()
          • Rconnect()
          • rdchk()
          • re_comp()
          • re_exec()
          • read()
          • readblock()
          • readcond()
          • readdir(), readdir64()
          • _readdir_r()
          • readdir_r()
          • readlink()
          • readv()
          • realloc()
          • realpath()
          • recv()
          • recvfrom()
          • recvmsg()
          • regcomp()
          • regerror()
          • regexec()
          • regfree()
          • remainder(), remainderf(), remainderl()
          • remove()
          • remque()
          • rename()
          • res_init()
          • res_mkquery()
          • res_query()
          • res_querydomain()
          • res_search()
          • res_send()
          • resmgr_attach()
          • resmgr_block()
          • resmgr_connect_funcs_t
          • resmgr_context_alloc()
          • resmgr_context_free()
          • resmgr_context_t
          • resmgr_detach()
          • resmgr_devino()
          • resmgr_handle_grow()
          • resmgr_handle_tune()
          • resmgr_handler()
          • resmgr_io_funcs_t
          • resmgr_iofuncs()
          • resmgr_msg_again()
          • resmgr_msgread()
          • resmgr_msgreadv()
          • resmgr_msgreply()
          • resmgr_msgreplyv()
          • resmgr_msgwrite()
          • resmgr_msgwritev()
          • _RESMGR_NPARTS()
          • resmgr_ocb()
          • resmgr_open_bind()
          • resmgr_pathname()
          • _RESMGR_PTR()
          • _RESMGR_STATUS()
          • resmgr_unbind()
          • rewind()
          • rewinddir()
          • Rgetsockname()
          • rindex()
          • rint(), rintf(), rintl()
          • Rlisten()
          • rmdir()
          • round(), roundf(), roundl()
          • ROUTE
          • Rrcmd()
          • rresvport(), rresvport_af()
          • Rselect()
          • rsrcdbmgr_attach()
          • rsrcdbmgr_create()
          • rsrcdbmgr_destroy()
          • rsrcdbmgr_detach()
          • rsrcdbmgr_devno_attach()
          • rsrcdbmgr_devno_detach()
          • rsrcdbmgr_query_name()
          • ruserok()
        • S
          • scalb()
          • scalbn(), scalbnf()
          • _scalloc()
          • scandir()
          • scanf()
          • sched_getparam()
          • sched_get_priority_adjust()
          • sched_get_priority_max()
          • sched_get_priority_min()
          • sched_getscheduler()
          • sched_param
          • sched_rr_get_interval()
          • sched_setparam()
          • sched_setscheduler()
          • sched_yield()
          • SchedCtl(), SchedCtl_r()
          • SchedGet(), SchedGet_r()
          • SchedInfo(), SchedInfo_r()