Content
Search Results
Index
Loading, please wait ...

Loading

  • QNX Momentics IDE 7.0 User's Guide
    • Working with QNX Momentics IDE
      • Get to know Eclipse
      • What's new in the IDE?
      • Starting the IDE
      • Preparing your target
      • Creating a target connection
    • Developing Projects with the IDE
      • Creating a QNX project
      • Writing code
      • Adding libraries
      • Building a QNX project
      • Running an application
    • Debugging Applications
      • Selecting a tool for debugging
      • Launching an application with the debugger attached
        • Debug perspective controls
      • Attaching the debugger to a running process
      • Debugging a core file
      • Debugging a child process
      • Debugging libraries
      • Debugging over a serial connection
      • Debugging non-IDE code
    • Unit Testing
      • Writing and building test programs
      • Running test programs
      • Measuring code coverage
        • Combining results from multiple sessions
      • Importing Code Coverage results
      • Exporting Code Coverage results
    • Analyzing Memory Usage and Finding Memory Problems
      • Monitoring memory and resource consumption
        • Monitoring memory consumption at the system level
        • Monitoring memory consumption at the process level
        • Monitoring resource usage for a process
      • Analyzing heap memory usage
        • Analyzing heap memory usage with System Information and the debugger
        • Analyzing heap memory usage with Memory Analysis
        • Analyzing heap memory usage with Valgrind Massif
        • Analyzing heap memory usage with Application Profiler
        • Analyzing heap memory usage with libc allocator API
      • Finding improper memory usage
        • Finding memory corruption with Valgrind Memcheck
        • Finding memory corruption with Memory Analysis
        • Finding thread synchronization problems with Valgrind Helgrind
      • Finding memory leaks
        • Finding memory leaks with Memory Analysis
        • Finding memory leaks with Valgrind Memcheck
        • Finding unused memory with Valgrind Massif
      • Optimizing an application after analysis
      • Configuring shared library support
      • Running memory-analyzing tools from the command line
      • Attaching Memory Analysis to a running process
      • Controlling librcheck
        • Controlling librcheck through signals
        • Controlling librcheck through API calls
      • Importing results from memory-analyzing sessions
        • Importing Memory Analysis data
        • Importing Valgrind logs
      • Exporting results from memory-analyzing sessions
        • Exporting Memory Analysis data
        • Exporting Valgrind logs
    • Analyzing Performance
      • Monitoring performance
        • Monitoring performance of processes
        • Monitoring performance of threads
      • Profiling applications
        • Sampling execution position and counting function calls
        • Measuring function runtimes
        • Profiling system activity with function instrumentation enabled
        • Attaching Application Profiler to a running process
        • Comparing profiling session results
      • Investigating performance bottlenecks
        • Analyzing cache usage with Valgrind Cachegrind
      • Configuring shared library support
      • Measuring application performance from the command line
      • Controlling profiling at runtime
        • Controlling profiling through signals
        • Controlling profiling through API calls
      • Importing performance analysis results
        • Importing Application Profiler data
      • Exporting performance analysis results
        • Exporting Application Profiler data
    • Analyzing System Behavior
      • Analyzing kernel activity with the System Profiler
        • Running a kernel event trace
        • Interpreting trace data in the System Profiler
          • Locating sources of high CPU usage
          • Isolating client and server CPU loads
          • Examining interrupt handling times
          • Detecting priority inversion
        • Interpreting trace data outside of the IDE
      • Controlling kernel event tracing
        • Controlling kernel event tracing through API calls
      • Importing and exporting kernel event trace results
    • Building QNX OS Images
      • Overview of OS images
        • Types of images you can create
        • Project layout
        • BSP filename conventions
      • Creating a QNX System Builder project
      • Modifying an OS image
      • Building an OS image
      • Downloading an image to your target
    • Reference
      • Switching between SDKs
      • Host-target communications
        • IP communications
          • Securing qconn
          • Configuring target connections
        • Serial communications
      • QNX C/C++ Project properties
      • QNX perspectives
      • Editors
      • Build configurations
      • Adding debug symbols and instrumentation code to binaries
      • Managing launch configurations
        • Creating a launch configuration
          • Launch modes
          • QNX launch configuration types
          • QNX launch configuration properties
        • Editing a launch configuration
        • Importing launch configurations
      • Integrated tools
        • Application Profiler
        • Code Coverage
        • Memory Analysis
        • System Information
          • APS View
          • Connection Information
          • Malloc Information
          • Memory Information
          • Process Information
          • Signal Information
          • System Resources
          • System Summary
          • Target File System Navigator
          • Target Navigator
        • System Profiler
          • How kernel event tracing works
            • Kernel event trace log configuration
          • System Profiler editor
          • Client/Server CPU Statistics
          • Condition Statistics
          • Event Data
          • Event Owner Statistics
          • Filters
          • General Statistics
          • Thread Call Stack
          • Thread State Snapshot
          • Timeline State Colors
          • Trace Event Log
          • Why Running?
    • JTAG: Debugging with Lauterbach TRACE32
      • Prerequisites
      • Installing the Lauterbach TRACE32 In-Circuit Debugger software
      • Installing the Target Communication Framework (TCF) in the IDE
      • Installing the TRACE32 TCF Eclipse plugin
      • Building applications and an OS image for TRACE32-ICD debugging
      • Creating a TRACE32 startup script
      • Creating a launch configuration for debugging an OS image
      • Starting a TRACE32-ICD debugging session
  • QNX Software Development Platform 7.0
    • Quickstart Guide
      • Requirements
      • 1. Installing QNX SDP on the development host
      • 2. Installing the QNX Neutrino RTOS on the target system
      • 3. Networking with the QNX Neutrino RTOS
      • 4. Creating a program project
      • 5. Communicating with the QNX Neutrino RTOS
      • 6. Compiling and linking
      • 7. Launching and debugging the program
      • Making the program your own
    • OS Core Components
      • Adaptive Partitioning User's Guide
        • What is Adaptive Partitioning?
          • System and user requirements
          • The thread scheduler
        • Quickstart: Adaptive Partitioning Thread Scheduler
        • Thread Scheduler Details
          • 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
        • 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
        • Glossary
      • Boot Optimization Guide
        • About the system startup sequence
        • Optimize the Loading and Launching of the OS
          • Optimize the bootloader
          • Use the optimized image scan functions
          • Generic techniques to reduce the size of the IFS
          • Reduce the size of the startup program
          • Remove unnecessary debug printing
          • Optimize use of system and secondary disks
          • Use compression strategies
        • Optimize the Platform Application Stack
          • Reorder the startup program
          • Make careful use of the default boot script
          • Consider the placement of waitfor statements
        • Measuring Boot Times
          • Using timestamp to measure startup times
          • Measuring the time to copy from flash to RAM
        • Optimizing Screen Startup Times
          • Screen Startup Optimizations at a Glance
          • Configure a Primary and Secondary IFS on the System
            • Example for the NXP i.MX6 SABRE for Smart Devices Platform board
          • Optimize the Screen Configuration File
          • Optimize the Boot Script
          • A minimalist buildfile
          • Optimize the Splash Screen Application
            • Choose how to render to a display
            • Avoid using a framebuffer
            • Optimizing the usage of APIs
            • Optimize the usage of windows from Screen
            • Use multiple threads
            • Use statically linked libraries
          • Other Techniques and Troubleshooting
      • Building Embedded Systems
        • About This Document
          • Copyright and patent notice
        • Overview
          • The boot process
          • BSP components
            • Initial Program Loader (IPL)
            • Image filesystem (IFS)
            • Startup programs
            • Build scripts
            • Drivers
          • Other components
        • Working with QNX BSPs
          • Getting and extracting a BSP
          • BSP structure and contents
          • The BSP Makefile
          • Building a BSP
          • Transferring an IFS to a target platform
          • Transferring an OS image to an x86_64 target platform
          • Booting QNX Neutrino
        • Initial Program Loaders (IPLs)
          • From reset to startup
          • x86 disk boot IPLs
          • ARM IPLs
          • Image storage
            • Image storage methods
          • The startup header
            • The info member
          • Customizing an IPL
          • Optimizing an IPL
        • Startup Programs
          • Startup tasks
            • Hardware initialization
            • Other startup tasks
          • Source code directories
          • Source code structure
          • Modifying the startup
        • Kernel Callouts
          • Kernel callout categories
            • Kernel debug
            • Interrupt controller
            • Timer and clock
            • System reset
            • Cache control
            • Custom
          • Writing a kernel callout
            • Kernel callout start and end macros
            • Patching the kernel callout code
            • Allocating read/write storage
            • interrupt_id_*() and interrupt_eoi_*()
        • System Page
          • system_private
          • asinfo
          • hwinfo
            • Tags
            • Items
            • Building the hwinfo section
          • cpuinfo
          • cacheattr
          • qtime
          • intrinfo
          • smp
          • un
        • OS Images
          • Deciding what goes on the target
          • Building an OS image
          • Building a flash filesystem image
            • Sockets and partitions
            • mkefs and its buildfile
            • File compression
          • Creating a new filesystem on your target
          • Combining multiple image files
        • OS Image Buildfiles
          • Buildfile syntax
          • Buildfile structure and contents
          • The bootstrap file
          • Scripts
          • Environment variables
          • The rest of the buildfile
          • Specifying board-specific information
          • Including files in the image
            • Changing where mkifs looks for files
            • Including many files
            • Location of files on the target
          • File ownership and permissions
          • System configuration
        • IPL Library
          • enable_cache()
          • image_download_8250()
          • image_download_ser()
          • image_scan(), image_scan_2(), image_scan_ext()
          • image_setup(), image_setup_2(),image_setup_ext()
          • image_start(), image_start_2(), image_start_ext()
          • init_8250()
          • int15_copy()
          • jump()
          • 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
        • 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_read*()
          • chip_write*()
          • copy_memory()
          • del_typed_string()
          • 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()
          • init_asinfo()
          • init_cacheattr()
          • init_cpuinfo()
          • init_hwinfo()
          • init_intrinfo()
          • init_mmu()
          • init_nanospin()
          • init_qtime()
          • 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()
          • timer_diff()
          • timer_ns2tick()
          • timer_start()
          • timer_tick2ns()
          • tulip_reset()
          • uncompress()
          • x86_64_cpuid_string(), x86_cpuid_string()
          • x86_64_cputype(), x86_cputype()
          • x86_64_fputype(), x86_fputype()
          • x86_scanmem()
        • Debugging a QNX Embedded System
          • Generating IPL debug symbols
          • Generating startup debug symbols
        • Sample Buildfiles
          • Shared libraries
          • Using multiple consoles
          • Creating a temporary directory (/tmp)
          • Minimal configuration
          • Flash filesystem
          • Disk filesystem
          • TCP/IP with network filesystem
        • Glossary
      • Core Networking Stack User's Guide
        • Overview
          • Architecture of io-pkt
          • Threading model
          • Threading priorities
          • Components of core networking
          • Process manager abilities
        • 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 Wi-Fi with io-pkt
          • Connecting to a wireless network (Station mode)
            • Using no encryption
            • Using WEP (Wired Equivalent Privacy) for authentication and encryption
            • Using WPA/WPA2 for authentication and encryption
              • Connecting with WPA or WPA2
              • Personal-level authentication and Enterprise-level authentication
          • Using a Wireless Access Point (WAP; AP mode)
            • Creating A WAP
              • Acting as a gateway
              • Acting as a bridge
            • WEP access point
            • WPA access point
          • WPA utilities
            • Using wpa_supplicant to manage your wireless network connections
          • 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
          • 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
      • Customizing a BSP
        • Prerequisites
        • The development process
        • OS Image Buildfiles
        • Startup
        • Graphics
        • I2C
          • 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_BUS_RESET
              • 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
        • Networking
        • Generic serial port
        • SPI
      • Device Publishers Developer's Guide
        • Device Publishers
          • Running a device publisher
          • Role of device drivers
          • PPS object types
          • Plugins
            • Plugin ratings
        • The USB Launcher Service
          • Command line for USB launcher service (usblauncher_otg)
          • Device control object
          • Device object
          • Driver object
          • Mount object
          • Mounting filesystems
          • Configuration files
            • USB matching rules
          • USB hubs
          • Supported third-party applications and protocols
        • The mmcsdpub Publisher
          • Command line for mmcsdpub
          • Device object
          • Driver object
          • Mount object
        • The cdpub Publisher
          • Command line for cdpub
          • Device control object
          • Device object
          • Driver object
          • Mount object
      • 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
      • Migrating to QNX SDP 7
        • Planning Your Migration
        • Migration Guidelines
          • Development hosts
          • Board Support Packages
          • Buildfiles
          • Kernel and process manager
          • Graphics
          • PCI
          • Filesystems
          • Audio
          • Development tools
          • C applications
          • C++ applications
          • QNX Momentics IDE
        • 64-Bit Architecture
          • Sizes of data types
          • New kernel calls and macros for sigvals
          • Large file support
          • sigevents
          • TimerInfo()
          • struct stat
          • Communicating with processes of different architectures
          • I/O messages
          • iofunc support for ns-resolution timestamps
          • DCMD_PROC_* and the /proc filesystem
          • Trace events
          • Other tips for programming
      • 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_clear_option()
          • 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_set_option()
          • 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 files
          • Schema files
          • Summary of database files
        • QDB Command Line
          • Temporary storage filesystem
          • Database integrity testing
          • Sharing connections between clients
          • Shared caching
          • Database recovery
          • Busy timeout
          • Handling corrupt databases
        • QDB Client
          • Backing up and restoring databases
        • QDB Application Example
          • Connecting to a database
            • Using asynchronous mode
          • Executing an SQL statement
          • Getting the result of a query
          • Using a result
          • Disconnecting from the database
          • Sample program
        • Datatypes in QDB
          • Storage classes
          • Column affinity
            • How column affinity is determined
            • Column affinity example
          • Comparison expressions
            • Comparison example
          • Operators: Column affinities
          • Sorting, grouping and compound SELECT statements
          • Other affinity modes
          • Collation sequences: Use in comparison operations
            • Assigning collation sequences from SQL
            • Collation sequences: Examples
        • QDB Virtual Machine Opcodes
          • Instruction format and execution
          • Virtual machine features
          • Viewing programs generated by QDB
          • The opcodes
        • Writing User-Defined Functions
          • Scalar and aggregate functions
          • Collation routines
          • Loading user-defined functions
          • 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_collation_ext()
          • qdb_column_decltype()
          • qdb_column_index()
          • qdb_column_name()
          • qdb_columns()
          • qdb_connect()
          • qdb_data_source()
          • qdb_disconnect()
          • qdb_freeresult()
          • qdb_getdbsize()
          • qdb_getdbsize_bytes()
          • qdb_geterrcode()
          • qdb_geterrmsg()
          • qdb_getoption()
          • qdb_getresult()
          • qdb_getresultoption()
          • qdb_gettransstate()
          • qdb_interrupt()
          • qdb_last_insert_rowid()
          • qdb_logmemstats()
          • 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
      • Security Developer's Guide
        • Best Practices
        • Threat Models
        • Rootless Execution
        • Identification and Authentication Control
        • Secure Boot
        • Sandboxing
        • Security Policy and Mandatory Access Control
        • Levels of Security for Embedded Systems
        • Tutorial: Build a system that uses a security policy
          • Setting up a system to use security types
          • Booting the system for the first time
          • The generated security policy
          • Compiling the security policy
          • Booting securely
          • Developing systems with a security policy
          • The error file
          • System monitoring using secpolgenerate
          • Security policy maintenance
          • Reviewing for unnecessary rules
          • procmgr_ability() calls and the security policy
          • Event and state files
          • Troubleshooting and frequently asked questions
          • Frequently asked questions
        • The devcrypto plugin API (devcrypto_plugin.h)
          • Definitions in devcrypto_plugin.h
          • devcrypto_aead_cipher_op_decrypt
          • devcrypto_aead_cipher_op_encrypt
          • devcrypto_aead_cipher_op_init
          • devcrypto_aead_cipher_ops_t
          • devcrypto_aead_cipher_params_t
          • devcrypto_aead_cipher_t
          • devcrypto_algorithm_op_init
          • devcrypto_algorithm_op_uninit
          • devcrypto_algorithm_t
          • devcrypto_algorithm_type_t
          • devcrypto_cipher_op_decrypt
          • devcrypto_cipher_op_encrypt
          • devcrypto_cipher_op_init
          • devcrypto_cipher_ops_t
          • devcrypto_cipher_params_t
          • devcrypto_cipher_t
          • devcrypto_digest_op_copy
          • devcrypto_digest_op_final
          • devcrypto_digest_op_init
          • devcrypto_digest_op_update
          • devcrypto_digest_ops_t
          • devcrypto_digest_params_t
          • devcrypto_digest_t
          • devcrypto_mac_op_final
          • devcrypto_mac_op_init
          • devcrypto_mac_op_update
          • devcrypto_mac_ops_t
          • devcrypto_mac_params_t
          • devcrypto_mac_t
          • devcrypto_plugin_op_init
          • devcrypto_plugin_op_uninit
          • devcrypto_plugin_ops_t
          • devcrypto_plugin_register_algorithm()
          • devcrypto_state_ctx_t
        • Example devcrypto plugin: openssl_digest.c
        • The devcrypto I/O command API (cryptodev.h)
          • General definitions in cryptodev.h
          • Cryptography device algorithms
          • Cryptography device operations
          • Cryptography device CIOCCRYPT command flags
          • cphash_op_t
          • cryptodev_crypt_auth_op_t
          • cryptodev_crypt_op_t
          • cryptodev_session_op_t
        • The libsecpol API (secpol.h)
          • Specifying the security policy file handle
          • Customizing permissions using a security policy
          • Definitions in secpol.h
          • secpol_check_permission()
          • secpol_close()
          • secpol_file_t
          • secpol_flags_e
          • secpol_get_permission()
          • secpol_get_permission_flags_e
          • secpol_get_type_id()
          • secpol_get_type_name()
          • secpol_open()
          • secpol_open_flags_e
          • secpol_permission_t
          • secpol_posix_spawnattr_settypeid()
          • secpol_resolve_name()
          • secpol_transition_type()
          • secpol_type_id()
      • SMMUMAN User's Guide
        • Architecture
          • Isolation of DMA devices
          • SMMUMAN components
          • SMMUMAN in a QNX Hypervisor guest
        • smmuman
          • Installation
          • Starting and stopping smmuman
          • Configuring smmuman
            • Global options
            • Options for ARM SMMUs
            • Options for Renesas R-Car IPMMUs
            • Options for x86 IOMMUs (VT-ds)
          • Mapping DMA devices and memory regions
          • Startup mappings
          • SMMUMAN in a QNX Hypervisor system
        • SMMUMAN Client API Reference
          • smmu_* data structures
          • Enumerated values and constants
          • smmu_device_add_generic()
          • smmu_device_add_mmio()
          • smmu_device_add_pci()
          • smmu_device_report_reserved()
          • smmu_fini()
          • smmu_init()
          • smmu_mapping_add()
          • smmu_obj_create()
          • smmu_obj_destroy()
          • smmu_safety()
          • smmu_xfer_notify()
          • smmu_xfer_status()
        • Example program
        • Terminology
      • 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
            • Security class: _NTO_TRACE_SEC
            • 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
            • Condvars: condition variables
            • Barriers
            • Sleepon locks
            • Reader/writer locks
            • Safely sharing mutexes, barriers, and reader/writer locks between processes
            • 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()
          • 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)
            • 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
            • Locking memory
          • Pathname management
            • Resolving pathnames
            • Symbolic prefixes
              • Creating special device names
              • Relative pathnames
              • Network root
            • 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)
          • Power-Safe filesystem
            • Problems with existing disk filesystems
            • Copy-on-write filesystem
            • Performance
            • Encryption
          • DOS 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
          • QNX Trusted Disk
          • Merkle 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
          • 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
        • Cryptography Support
        • 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
        • Compiling OpenVPN for QNX Neutrino
        • IP Tunneling (Generic Routing Encapsulation)
        • PPPOE and Path MTU Discovery
        • Making Multiple Images
        • POSIX Message Queues: Two Implementations
        • Choosing the Correct MTD Routine for the Flash Filesystem
        • Reading a Kernel Dump
        • 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()
            • spi_dma_xfer()
        • 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
        • 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
          • 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”
          • Power-Safe filesystem
            • Links and inodes
            • Booting
            • Snapshots
          • DOS filesystem
          • Linux Ext2 filesystem
          • Flash filesystems
          • CIFS filesystem
          • NFS filesystem
          • 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?
        • Backing Up Data
          • Backup strategies
            • Choosing backup storage media and location
            • Choosing a backup format
            • Controlling your backup
        • 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
          • Fine-tuning USB storage devices
        • Understanding System Limits
          • Configurable limits
          • Filesystem limits
            • Querying filesystem limits
            • Power-Safe (fs-qnx6.so) filesystem
            • Linux Ext2 filesystem
            • DOS FAT12/16/32 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
          • 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
            • Control events
          • Mixer devices
          • Pulse Code Modulation (PCM) devices
            • Data formats
            • PCM state machine
            • PCM software mixer
            • PCM input splitter
            • PCM plugin converters
            • PCM events
            • PCM thread priorities
        • 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
        • Audio Concurrency Management
          • Understanding audio ducking
            • Understanding the mix policy when using multiple audio types with the same priority
            • Understanding how multiple ducking levels cumulate
          • Understanding volume ramping
            • Volume ramping example
          • Understanding preemption
          • Understanding audio type volume controls
          • Syntax of the audio policy configuration file
        • Optimizing Audio
        • Audio Library
          • snd_afm_close()
          • snd_afm_file_descriptor()
          • snd_afm_get_ap_data()
          • snd_afm_get_audio_mode()
          • snd_afm_get_param()
          • snd_afm_get_vin_list()
          • snd_afm_get_vin_list_count()
          • snd_afm_info()
          • snd_afm_info_t
          • 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_param()
          • snd_afm_set_vin_stream()
          • snd_afm_start()
          • snd_afm_status()
          • snd_afm_status_t
          • 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_ducking_read()
          • snd_ctl_ducking_status_read()
          • snd_ctl_get_filter()
          • 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_ctl_set_filter()
          • snd_ducking_status_t
          • snd_ducking_type_status_t
          • snd_mixer_callbacks_t
          • snd_mixer_close()
          • snd_mixer_eid_t
          • snd_mixer_element_info()
          • snd_mixer_element_info_build()
          • snd_mixer_element_info_free()
          • snd_mixer_element_info_t
          • snd_mixer_element_read()
          • snd_mixer_element_t
          • snd_mixer_element_write()
          • snd_mixer_elements()
          • snd_mixer_elements_t
          • snd_mixer_element_volume1_range_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_audio_ducking()
          • 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_read_event()
          • 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_event_t
          • snd_pcm_file_descriptor()
          • snd_pcm_filter_t
          • 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_apx_data()
          • snd_pcm_get_chmap()
          • snd_pcm_get_filter()
          • snd_pcm_get_format_name()
          • snd_pcm_info()
          • snd_pcm_info_t
          • snd_pcm_link()
          • snd_pcm_link_mode()
          • snd_pcm_link_transition ()
          • snd_pcm_load_apx_dataset()
          • snd_pcm_mute_event_t
          • snd_pcm_nonblock_mode()
          • snd_pcm_open()
          • snd_pcm_open_name()
          • snd_pcm_open_preferred()
          • snd_pcm_outputclass_event_t
          • 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_plugin_reset_voice_conversion()
          • 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_status()
          • snd_pcm_plugin_update_src()
          • snd_pcm_plugin_write()
          • snd_pcm_query_channel_map()
          • snd_pcm_query_chmaps()
          • snd_pcm_read()
          • snd_pcm_set_apx_data()
          • snd_pcm_set_apx_external_volume()
          • snd_pcm_set_apx_user_volume()
          • snd_pcm_set_chmap()
          • snd_pcm_set_filter()
          • snd_pcm_set_output_class()
          • snd_pcm_status_event_t
          • snd_pcm_t
          • snd_pcm_unlink()
          • snd_pcm_voice_conversion_t
          • snd_pcm_write()
          • snd_strerror()
          • snd_switch_t
        • afm_ctl.c example
        • apx_ctl.c example
        • wave.c example
        • waverec.c example
        • mix_ctl.c example
        • audiomgmt_monitor.c example
        • ALSA and libasound.so
        • Glossary
      • 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
          • Two Finger Double Tap (two_finger_double_tap.h)
            • gesture_two_finger_double_tap_t
            • two_finger_double_tap_gesture_alloc()
            • two_finger_double_tap_gesture_default_params()
            • two_finger_double_tap_params_t
            • two_finger_double_tap_state_e
          • 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)
            • contact_type_e
            • input_class_e
            • input_event_e
            • mtouch_event
            • mtouch_event_t
          • Driver (mtouch_driver.h)
            • Definitions in mtouch_driver.h
            • Driver test result types
            • mtouch_driver_attach()
            • mtouch_driver_detach()
            • mtouch_driver_funcs_t
            • 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)
            • Definitions in mtouch_log.h
            • mtouch_log()
          • Parameters (mtouch_params.h)
            • Definitions in mtouch_params.h
            • mtouch_client_params
            • mtouch_client_params_t
            • mtouch_driver_params
            • mtouch_driver_params_t
            • mtouch_filter_config
            • mtouch_filter_config_t
          • Parse options (parseopts.h)
            • input_parseopts()
            • input_parse_bool()
            • input_parse_double()
            • input_parse_signed()
            • input_parse_string()
            • input_parse_unsigned()
          • Screen helpers (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()
          • wfdcfg_device
          • wfdcfg_device_create()
          • wfdcfg_device_destroy()
          • wfdcfg_device_get_extension()
          • wfdcfg_ext_fn_port_init1_t
          • wfdcfg_ext_fn_port_set_mode2_t
          • wfdcfg_ext_fn_port_uninit1_t
          • 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
        • Application Development
          • Getting started
          • Function execution types
            • Apply execution
            • Delayed execution
            • Flushing execution
            • Immediate execution
        • Buffers
        • Rendering
          • Render Targets
          • Software Rendering
          • Hardware Rendering
            • Khronos rendering APIs
            • Blitting
          • Hybrid Rendering
          • Font Rendering
        • Windowing
          • Window Groups
          • Window Geometry
            • Window types
            • Window properties
            • Window rotation
          • Window Management
          • Tutorials
            • Create a window
            • Create a child window
            • Zooming with windows
              • Displaying in fullscreen mode
              • Zooming in (from the window's parent)
              • Zooming in (from the owner of a window)
              • Zooming out (from a window's parent)
              • Zooming out (from the owner of a window)
              • Using a source clip rectangle
        • Resource Sharing
          • Cloning
            • Windows
            • Streams
            • Displays
            • Tutorial: Screenshots
              • Using screen_read_window()
              • Using screen_read_display()
          • Using Streams
            • Producer
            • Consumer
            • Multiple Consumers and Producers
            • External Composition
        • Displaying the contents of windows
          • Targeting your displays
          • Display Geometry
            • Display rotation
          • Composition
        • Input
          • Input Events
          • Windows
          • Sessions
            • Session properties
            • Keyboard sessions
            • Multitouch (touch) sessions
            • Pointer sessions
            • Joystick, gamepad, and jog sessions
        • Event Handling
        • Asynchronous Notifications
          • Tutorial: Using screen_notify()
        • Permissions and Privileges
        • Utilities and binaries
          • calib-touch
          • display-image
          • dpy-vsync
          • drm-intel
          • drm-probe-displays
          • egl-configs
          • events
          • font-freetype
          • gles1-gears
          • gles1-vsync
          • gles2-gears
          • gles3-gears
          • mtouch
            • Calibrating touch
            • Scaling configuration file
            • Touch configuration file
            • Touch filters
          • screen-gles2-tools
          • screen
          • screencmd
          • screeninfo
          • screenshot
          • sharewin
          • sw-vsync
          • vcapture-demo
          • vg-tiger
          • win-vsync
        • Debugging
          • At initialization
          • At runtime
        • Screen library reference
          • Function safety
          • Function types
          • General (screen.h)
            • Definitions in screen.h
            • _screen_mode
            • Screen CBABC mode types
            • Screen alpha mode types
            • Screen color space types
            • Screen cursor shapes
            • Screen flushing types
            • Screen gesture 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 scale types
            • Screen sensitivity masks
            • Screen sensitivity types
            • Screen status 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 acquire buffer flags
            • screen_acquire_buffer()
            • screen_release_buffer()
            • 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_t
            • Screen context types
            • Screen notification 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_register_window_manager()
            • screen_set_context_property_cv()
            • screen_set_context_property_iv()
            • screen_set_context_property_llv()
            • screen_set_context_property_pv()
            • screen_unregister_window_manager()
          • Debugging (screen.h)
            • Screen debug graph types
          • Devices (screen.h)
            • Screen device metric counts
            • Screen device types
            • Screen game button types
            • Screen input mode 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 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_wait_vsync()
          • Events (screen.h)
            • Screen event flags
            • Screen event types
            • Screen input control events
            • 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_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_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()
          • Sessions (screen.h)
            • Screen session metric counts
            • Screen input mode types
            • Screen session types
            • screen_create_session_type()
            • screen_destroy_session()
            • screen_get_session_property_cv()
            • screen_get_session_property_iv()
            • screen_get_session_property_llv()
            • screen_get_session_property_pv()
            • screen_session_t
            • screen_set_session_property_cv()
            • screen_set_session_property_iv()
            • screen_set_session_property_llv()
            • screen_set_session_property_pv()
          • Streams (screen.h)
            • Screen stream metric counts
            • Screen stream mode types
            • screen_attach_stream_buffers()
            • screen_consume_stream_buffers()
            • screen_create_stream()
            • screen_create_stream_buffers()
            • screen_destroy_stream()
            • screen_destroy_stream_buffers()
            • screen_get_stream_property_cv()
            • screen_get_stream_property_iv()
            • screen_get_stream_property_llv()
            • screen_get_stream_property_pv()
            • screen_post_stream()
            • screen_ref_stream()
            • screen_stream_t
            • screen_set_stream_property_cv()
            • screen_set_stream_property_iv()
            • screen_set_stream_property_llv()
            • screen_set_stream_property_pv()
            • screen_share_stream_buffers()
            • screen_unref_stream()
          • Windows (screen.h)
            • Screen window metric counts
            • Screen permission masks
            • Screen window types
            • screen_window_t
            • screen_attach_window_buffers()
            • screen_create_window()
            • screen_create_window_buffers()
            • screen_create_window_from_class()
            • 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_manage_window()
            • 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_display_buffers()
            • screen_share_stream_buffers()
            • screen_share_window_buffers()
            • screen_unref_window()
            • screen_wait_post()
        • Configuring Screen
          • Configure khronos section
            • Configure egl display subsection
            • Configure wfd device subsection
          • Configure winmgr section
            • Configure globals subsection
            • Configure display subsection
            • Configure class subsection
          • Apply your Screen configuration
        • Glossary
      • Video Capture Developer's Guide
        • Using Video Capture
          • Header files and libraries
          • Implementing video capture
          • Sample video capture program
          • Properties applied to arrays
          • Contexts
          • Buffers
          • Platform-specific considerations
        • Video Capture API (capture.h)
          • Properties
            • Data bus, data lane, and clock
            • Debugging
            • Deinterlacing
              • Capture deinterlacing mode types
              • Definitions
            • Destination buffer
            • Driver and device
              • Capture no signal mode types
              • Definitions
            • External source
            • Interface, threads, and offsets
              • Capture interface type
              • Definitions
            • I2C decoder path and slave address
            • Polarity
            • Source
              • capture_color_space
              • Definitions
            • Video capture behavior
            • Video standards
            • Video frame
          • 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()
          • Helper macros
    • Networking Middleware
      • Networking Middleware Architecture Guide
        • Architecture
        • Deployment Model
      • Networking Middleware C API Reference
        • Networking Middleware C API
          • qwf_interface.h
            • qwf_Cleanup()
            • qwf_Context_t
            • qwf_Init()
            • qwf_ProcessEvents()
            • qwf_QueryActiveService()
            • qwf_ReturnStatus_e
            • qwf_Service_e
          • qwf_net.h
            • Network Manager service constants
            • qwf_net_Connect()
            • qwf_net_ConnectData_t
            • qwf_net_Disconnect()
            • qwf_net_Event_t
            • qwf_net_EventClientCallback_t
            • qwf_net_EventCode_e
            • qwf_net_GetAvailableInterfaces()
            • qwf_net_GetDefaultInterface()
            • qwf_net_GetInterfaceData()
            • qwf_net_GetPriorityList()
            • qwf_net_IfaceList_t
            • qwf_net_IfName_t
            • qwf_net_IfType_e
            • qwf_net_InterfaceData_t
            • qwf_net_IpAddrStr_t
            • qwf_net_IpConfigMethod_e
            • qwf_net_RegisterCallback()
            • qwf_net_Results_e
          • qwf_wifi.h
            • Wi-Fi Manager service constants
            • qwf_wifi_AccessPointModeState_e
            • qwf_wifi_ApModeStatusData_t
            • qwf_wifi_ApProfileData_t
            • qwf_wifi_BgScanInfo_t
            • qwf_wifi_BgScanMode_e
            • qwf_wifi_ConnectionStatus_e
            • qwf_wifi_ConnectSavedNetwork()
            • qwf_wifi_ConnectToAccessPoint()
            • qwf_wifi_CreateSavedNetwork()
            • qwf_wifi_DeleteSavedNetwork()
            • qwf_wifi_DisableSavedNetwork()
            • qwf_wifi_DisableWlanInterface()
            • qwf_wifi_Disconnect()
            • qwf_wifi_EapMethod_e
            • qwf_wifi_EnableSavedNetwork()
            • qwf_wifi_EnableWlanInterface()
            • qwf_wifi_Event_t
            • qwf_wifi_EventClientCallback_t
            • qwf_wifi_EventCode_e
            • qwf_wifi_FrequencyBand_e
            • qwf_wifi_GetAccessPointProfile()
            • qwf_wifi_GetApStatus()
            • qwf_wifi_GetClientStatus()
            • qwf_wifi_GetConnectedSavedNetworkId()
            • qwf_wifi_GetConnectedSSID()
            • qwf_wifi_GetSavedNetworks()
            • qwf_wifi_GetScanResults()
            • qwf_wifi_InterfaceSetting_e
            • qwf_wifi_RegisterCallback()
            • qwf_wifi_Results_e
            • qwf_wifi_ResumeAccessPoint()
            • qwf_wifi_SavedNetwork_t
            • qwf_wifi_ScanResult_t
            • qwf_wifi_SecurityProtocol_e
            • qwf_wifi_SetBgScanMode()
            • qwf_wifi_SetEnterpriseCredentials()
            • qwf_wifi_SetHostapdOptions()
            • qwf_wifi_SetPassphrase()
            • qwf_wifi_SetWepKey()
            • qwf_wifi_Ssid_t
            • qwf_wifi_Standard_e
            • qwf_wifi_StartAccessPoint()
            • qwf_wifi_StartScan()
            • qwf_wifi_StationModeStatusData_t
            • qwf_wifi_StopAccessPoint()
            • qwf_wifi_UpdateAccessPoint()
            • qwf_wifi_UpdateSavedNetwork()
            • qwf_wifi_VhtOperChanWidth_e
            • qwf_wifi_WifiRole_e
        • Code Examples
          • Network Manager service
          • Wi-Fi Manager service
      • Networking Middleware Services Reference
        • Network Manager (net_pps)
        • Packet Filter Control
        • Tether Manager (tetherman)
        • Wi-Fi Configuration (wpa_pps)
        • Wi-Fi Protected Access (WPA) Supplicant
    • 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
              • Tuning a thread pool
            • 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
            • Identifying messages
            • 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
            • Access control list I/O function handler
            • Change file mode I/O function handler
            • Change ownership I/O function handler
            • Change timestamps I/O function handler
            • Close duplicate OCB I/O function handler
            • Close OCB I/O function handler
            • Create file link connect function handler
            • Device control I/O function handler
            • Duplicate a file descriptor I/O function handler
            • File descriptor information I/O function handler
            • File locking I/O function handler
            • Flush data I/O function handler
            • Lock OCB I/O function handler
            • Make filesystem node connect function handler
            • Map memory I/O function handler
            • Mount connect function handler
            • Open connect function handler
            • Open file descriptor I/O function handler
            • pathconf I/O function handler
            • Power I/O function handler
            • Read I/O function handler
            • Read link connect function handler
            • Rename connect function handler
            • Register for notification I/O function handler
            • Resize file I/O function handler
            • Set file position I/O function handler
            • Shutdown I/O function handler
            • stat I/O function handler
            • Unblock connect function handler
            • Unblock I/O function handler
            • Unlink connect function handler
            • Unlock OCB I/O function handler
            • User-defined message I/O function handler
            • Write I/O function handler
          • Examples
            • The basic skeleton of a resource manager
            • A simple read I/O function handler example
              • The code
              • Effective use of other messaging functions
            • A simple write I/O function handler example
            • A simple device control I/O function handler example
          • Advanced topics
            • Extending the OCB
            • Locking in the resource manager
            • 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
      • PCI Server User's Guide
        • Overview
          • Environment variables
          • Configuration files
        • Design Details
          • Module loading
          • Configuration space access
          • The PCI server
          • Hardware-dependent modules
          • Capability modules
          • The “Strings” module
        • API Reference
          • pci_bdf()
          • pci_bdf_t
          • pci_chassis_slot_bridge()
          • pci_chassis_slot_device()
          • pci_device_attach()
          • pci_device_cfg_cap_disable(), pci_device_cfg_cap_enable()
          • pci_device_cfg_cap_isenabled()
          • pci_device_cfg_rd*()
          • pci_device_cfg_wr*()
          • pci_device_chassis_slot()
          • pci_device_detach()
          • pci_device_find()
          • pci_device_find_capid()
          • pci_device_is_multi_func()
          • pci_device_map_as()
          • pci_device_read_*()
          • pci_device_read_ba()
          • pci_device_read_cap()
          • pci_device_read_capid()
          • pci_device_read_irq()
          • pci_device_reset()
          • pci_device_rom_disable(), pci_device_rom_enable()
          • pci_device_write_cmd(), pci_device_write_status()
          • pci_strerror()
        • Capability Modules and APIs
          • Capability ID 0x10 (PCI Express)
          • Capability ID 0x5 (MSI)
          • Capability ID 0x11 (MSI-X)
        • Example
      • 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
        • 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 or of all processes
            • 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
              • Creating abilities
            • An example of privilege separation
            • Resource constraint thresholds
          • Controlling processes via the /proc filesystem
            • Reading and writing the process's address space
            • Manipulating a process or thread
            • Thread information
            • DCMD_PROC_BREAK
            • DCMD_PROC_CHANNELS
            • DCMD_PROC_CLEAR_FLAG
            • DCMD_PROC_CURTHREAD
            • DCMD_PROC_EVENT
            • 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_THREADCTL
            • DCMD_PROC_TIDSTATUS
            • DCMD_PROC_TIMERS
            • DCMD_PROC_WAITSTOP
        • Multicore Processing
          • The impact of multicore
            • Thread affinity
            • Multicore and...
          • Designing with multiprocessing in mind
        • 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
        • 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
          • Tolerant and high-resolution timers
          • 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
        • 32- and 64-Bit Architectures
          • Sizes of data types
          • Kernel calls and macros for sigvals
          • Large file support
          • sigevents
          • TimerInfo()
          • struct stat
          • Communicating with processes of different architectures
          • I/O messages
          • iofunc support for ns-resolution timestamps
          • DCMD_PROC_* and the /proc filesystem
          • Trace events
          • Other tips for programming
        • 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
        • 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(), poll(), 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
      • 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_perm_np()
          • 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()
          • alignas, __alignas_is_defined
          • aligned_alloc()
          • alignof(), __alignof_is_defined
          • alloca()
          • alphasort()
          • _amblksiz
          • _argc
          • _argv
          • asctime(), asctime_r()
          • asin(), asinf(), asinl()
          • asinh(), asinhf(), asinhl()
          • assert()
          • at_quick_exit()
          • atan(), atanf(), atanl()
          • atan2(), atan2f(), atan2l()
          • atanh(), atanhf(), atanhl()
          • atexit()
          • atof()
          • atoi()
          • atol(), atoll()
          • ATOMIC_*_LOCK_FREE
          • atomic_*
          • atomic_add()
          • atomic_add_value()
          • atomic_clr()
          • atomic_clr_value()
          • atomic_compare_exchange_strong(), atomic_compare_exchange_strong_explicit(), atomic_compare_exchange_weak(), atomic_compare_exchange_weak_explicit(),
          • atomic_exchange(), atomic_exchange_explicit()
          • atomic_fetch_add(), atomic_fetch_add_explicit()
          • atomic_fetch_and(), atomic_fetch_and_explicit()
          • atomic_fetch_or(), atomic_fetch_or_explicit()
          • atomic_fetch_sub(), atomic_fetch_sub_explicit()
          • atomic_fetch_xor(), atomic_fetch_xor_explicit()
          • atomic_flag_clear(), atomic_flag_clear_explicit()
          • atomic_flag_test_and_set(), atomic_flag_test_and_set_explicit()
          • atomic_init()
          • atomic_is_lock_free()
          • atomic_load(), atomic_load_explicit()
          • atomic_set()
          • atomic_set_value()
          • atomic_signal_fence()
          • atomic_store(), atomic_store_explicit()
          • atomic_sub()
          • atomic_sub_value()
          • atomic_thread_fence()
          • 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
          • c16rtomb(), c32rtomb()
          • _cred_info
          • cabs(), cabsf(), cabsl()
          • cache_fini()
          • CACHE_FLUSH()
          • cache_init()
          • CACHE_INVAL()
          • cacos(), cacosf(), cacosl()
          • cacosh(), cacoshf(), cacoshl()
          • call_once()
          • calloc()
          • carg(), cargf(), cargl()
          • casin(), casinf(), casinl()
          • casinh(), casinhf(), casinhl()
          • catan(), catanf(), catanl()
          • catanh(), catanhf(), catanhl()
          • cbrt(), cbrtf(), cbrtl()
          • ccos(), ccosf(), ccosl()
          • ccosh(), ccoshf(), ccoshl()
          • ceil(), ceilf(), ceill()
          • cexp(), cexpf(), cexpl()
          • cfgetispeed()
          • cfgetospeed()
          • cfgopen()
          • cfmakeraw()
          • cfree()
          • cfsetispeed()
          • cfsetospeed()
          • ChannelCreate(), ChannelCreate_r()
          • ChannelDestroy(), ChannelDestroy_r()
          • chdir()
          • chmod()
          • chown()
          • chroot()
          • cimag(), cimagf(), cimagl()
          • 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()
          • clog(), clogf(), clogl()
          • close()
          • closedir()
          • closelog()
          • _cmdname()
          • CMPLX(), CMPLXF(), CMPLXL()
          • cnd_broadcast()
          • cnd_destroy()
          • cnd_init()
          • cnd_signal()
          • cnd_timedwait()
          • cnd_wait()
          • confstr()
          • conj(), conjf(), conjl()
          • connect()
          • ConnectAttach(), ConnectAttach_r()
          • ConnectClientInfo(), ConnectClientInfo_r()
          • ConnectClientInfoAble()
          • ConnectClientInfoExt()
          • ConnectDetach(), ConnectDetach_r()
          • ConnectFlags(), ConnectFlags_r()
          • ConnectServerInfo(), ConnectServerInfo_r()
          • copysign(), copysignf(), copysignl()
          • cos(), cosf(), cosl()
          • cosh(), coshf(), coshl()
          • cpow(), cpowf(), cpowl()
          • cproj(), cprojf(), cprojl()
          • creal(), crealf(), creall()
          • creat(), creat64()
          • crypt()
          • csin(), csinf(), csinl()
          • csinh(), csinhf(), csinhl()
          • csqrt(), csqrtf(), csqrtl()
          • ctan(), ctanf(), ctanl()
          • ctanh(), ctanhf(), ctanhl()
          • 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()
          • 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
          • erand48()
          • erf(), erff(), erfl()
          • erfc(), erfcf(), erfcl()
          • err(), errx()
          • errno
          • _etext
          • execl()
          • execle()
          • execlp()
          • execlpe()
          • execv()
          • execve()
          • execvp()
          • execvpe()
          • _exit()
          • exit()
          • exp(), expf(), expl()
          • exp2(), exp2f(), exp2l()
          • expm1(), expm1f(), expm1l()
        • F
          • fabs(), fabsf(), fabsl()
          • fcfgopen()
          • fchdir()
          • fchmod()
          • fchown()
          • fclose()
          • fcloseall()
          • fcntl()
          • fdatasync()
          • fdim(), fdimf(), fdiml()
          • fdistrusted()
          • fdopen()
          • feclearexcept()
          • fedisableexcept()
          • feenableexcept()
          • fegetenv()
          • fegetexceptflag()
          • fegetprec()
          • fegetround()
          • feholdexcept()
          • feof()
          • feraiseexcept()
          • ferror()
          • fesetenv()
          • fesetexceptflag()
          • fesetprec()
          • fesetround()
          • fetestexcept()
          • feupdateenv()
          • fflush()
          • ffs()
          • fgetc()
          • fgetpos()
          • fgets()
          • fgetspent()
          • fgetwc()
          • fgetws()
          • fileno()
          • flink()
          • flock()
          • flockfile()
          • floor(), floorf(), floorl()
          • fma(), fmaf(), fmal()
          • fmax(), fmaxf(), fmaxl()
          • fmin(), fminf(), fminl()
          • fmod(), fmodf(), fmodl()
          • fnmatch(), _fnmatchv()
          • fopen(), fopen64()
          • fork()
          • forkpty()
          • forksafe_mutex_destroy()
          • forksafe_mutex_init()
          • forksafe_mutex_lock()
          • forksafe_mutex_trylock()
          • forksafe_mutex_unlock()
          • fpathconf()
          • fpclassify()
          • fprintf()
          • fputc()
          • fputs()
          • fputwc()
          • fputws()
          • fread()
          • free()
          • freeaddrinfo()
          • freeifaddrs()
          • freopen(), freopen64()
          • frexp(), frexpf(), frexpl()
          • fs_crypto_check()
          • fs_crypto_domain_add()
          • fs_crypto_domain_add_dynamic()
          • fs_crypto_domain_add_flags()
          • fs_crypto_domain_hard_lock()
          • fs_crypto_domain_key_change()
          • fs_crypto_domain_key_check()
          • fs_crypto_domain_key_size()
          • fs_crypto_domain_lock()
          • fs_crypto_domain_lock_dynamic()
          • fs_crypto_domain_query()
          • fs_crypto_domain_remove()
          • fs_crypto_domain_remove_dynamic()
          • fs_crypto_domain_unlock()
          • fs_crypto_domain_unlock_dynamic()
          • fs_crypto_domain_whitelist_configure()
          • fs_crypto_domain_whitelist_ctrl()
          • fs_crypto_domain_whitelist_ctrl_access_grant()
          • fs_crypto_domain_whitelist_ctrl_access_revoke()
          • fs_crypto_domain_whitelist_get_flags()
          • fs_crypto_domain_whitelist_set_flags()
          • 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()
          • fstatat(), fstatat64()
          • fstatvfs(), fstatvfs64()
          • fsync()
          • ftell(), ftello(), ftello64()
          • ftime()
          • ftruncate(), ftruncate64()
          • ftrylockfile()
          • ftw(), ftw64()
          • funlockfile()
          • futime()
          • futimens()
          • fwide()
          • fwprintf()
          • fwrite()
          • fwscanf()
        • G
          • gai_strerror()
          • getaddrinfo()
          • getc()
          • getc_unlocked()
          • getchar()
          • getchar_unlocked()
          • getcwd()
          • getdomainname()
          • getdtablesize()
          • getegid()
          • getenv()
          • geteuid()
          • getfsent()
          • getfsfile()
          • 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()
          • getopt_long(), getopt_long_only()
          • getpagesize()
          • getpagesizes(), getpagesizes64()
          • getpass()
          • getpeereid()
          • getpeername()
          • getpgid()
          • getpgrp()
          • getpid()
          • getppid()
          • 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_compatible()
          • 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(), hypotl()
        • I
          • ICMP
          • ICMP6
          • if_freenameindex()
          • if_indextoname()
          • if_nameindex()
          • if_nametoindex()
          • ifaddrs
          • ilogb(), ilogbf(), ilogbl()
          • 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()
          • inotify_qnx_ext()
          • insque()
          • InterruptAttach(), InterruptAttach_r()
          • InterruptAttachArray(), InterruptAttachArray_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(), vioctl()
          • iofdinfo()
          • iofunc_ability_check()
          • iofunc_acl()
          • iofunc_acl_default()
          • iofunc_attr_init(), iofunc_attr_init_sized()
          • 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_mount_fini()
          • iofunc_mount_init()
          • iofunc_mount_set_time()
          • iofunc_mount_t
          • 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_format()
          • 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()
          • isgreater()
          • isgreaterequal()
          • isinf()
          • isless()
          • islessequal()
          • islessgreater()
          • islower()
          • isnan()
          • isnormal()
          • isprint()
          • ispunct()
          • isspace()
          • isunordered()
          • 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(), lgammal(), lgammal_r()
          • link()
          • lio_listio(), lio_listio64()
          • listen()
          • llabs()
          • llrint(), llrintf(), llrintl()
          • llround(), llroundf(), llroundl()
          • localeconv()
          • localtime()
          • localtime_r()
          • lockf(), lockf64()
          • log(), logf(), logl()
          • log10(), log10f(), log10l()
          • log1p(), log1pf(), log1pl()
          • log2(), log2f(), log2l()
          • logb(), logbf(), logbl()
          • login_tty()
          • longjmp()
          • lrand48()
          • lrint(), lrintf(), lrintl()
          • lround(), lroundf(), lroundl()
          • lsearch()
          • lseek(), lseek64()
          • lstat(), lstat64()
          • ltoa(), lltoa()
          • ltrunc()
        • M
          • main()
          • mallinfo()
          • malloc()
          • mallopt()
          • max()
          • max_align_t
          • mblen()
          • mbrlen()
          • mbrtoc16(), mbrtoc32()
          • mbrtowc()
          • mbsinit()
          • mbsrtowcs()
          • mbstowcs()
          • mbtowc()
          • mcheck()
          • mem_offset(), mem_offset64()
          • memalign()
          • memccpy()
          • memchr(), memchr_isr()
          • memcmp(), memcmp_isr()
          • memcpy(), memcpy_isr()
          • memcpyv()
          • memicmp()
          • memmove()
          • memory_order
          • memset(), memset_isr()
          • memset_s()
          • message_attach()
          • message_connect()
          • message_detach()
          • min()
          • mkdir()
          • mkdtemp()
          • mkfifo()
          • mknod()
          • mkostemp(), mkostemps()
          • mkstemp(), mkstemps()
          • mktemp()
          • mktime()
          • mlock()
          • mlockall()
          • mmap(), mmap64()
          • mmap_device_io()
          • mmap_device_memory()
          • mmap_peer(), mmap64_peer()
          • modem_open()
          • modem_read()
          • modem_script()
          • modem_write()
          • modf(), modff(), modfl()
          • 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()
          • MsgRegisterEvent(), MsgRegisterEvent_r()
          • MsgReply(), MsgReply_r()
          • MsgReplyv(), MsgReplyv_r()
          • MsgSend(), MsgSend_r()
          • MsgSendnc(), MsgSendnc_r()
          • MsgSendPulse(), MsgSendPulse_r()
          • MsgSendPulsePtr(), MsgSendPulsePtr_r()
          • MsgSendsv(), MsgSendsv_r()
          • MsgSendsvnc(), MsgSendsvnc_r()
          • MsgSendv(), MsgSendv_r()
          • MsgSendvnc(), MsgSendvnc_r()
          • MsgSendvs(), MsgSendvs_r()
          • MsgSendvsnc(), MsgSendvsnc_r()
          • MsgUnregisterEvent(), MsgUnregisterEvent_r()
          • MsgVerifyEvent(), MsgVerifyEvent_r()
          • MsgWrite(), MsgWrite_r()
          • MsgWritev(), MsgWritev_r()
          • msync()
          • mtx_destroy()
          • mtx_init()
          • mtx_lock()
          • mtx_timedlock()
          • mtx_trylock()
          • mtx_unlock()
          • munlock()
          • munlockall()
          • munmap()
          • munmap_device_io()
          • munmap_device_memory()
          • munmap_flags()
          • munmap_peer()
        • N
          • name_attach()
          • name_close()
          • name_detach()
          • name_open()
          • nan(), nanf(), nanl()
          • nanosleep()
          • nanospin()
          • nanospin_calibrate()
          • nanospin_count()
          • nanospin_ns()
          • nanospin_ns_to_count()
          • nap()
          • napms()
          • nbaconnect()
          • nbaconnect_result()
          • ncurses
          • ND_NODE_CMP()
          • nearbyint(), nearbyintf(), nearbyintl()
          • netent
          • netmgr_ndtostr()
          • netmgr_remote_nd()
          • netmgr_strtond()
          • nextafter(), nextafterf(), nextafterl()
          • nexttoward(), nexttowardf(), nexttowardl()
          • 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()
          • pci_*()
          • 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_addopen()
          • posix_spawn_file_actions_destroy()
          • posix_spawn_file_actions_init()
          • posix_spawnattr_destroy()
          • posix_spawnattr_getcred()
          • posix_spawnattr_getflags()
          • posix_spawnattr_getnode()
          • 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_gettypeid()
          • posix_spawnattr_getxflags()
          • posix_spawnattr_init()
          • posix_spawnattr_setasid()
          • 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_settypeid()
          • 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_session_ext()
          • procmgr_set_type_id()
          • 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_getsuspendstate_np()
          • 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_attr_setsuspendstate_np()
          • 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_consistent()
          • 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_getrobust()
          • pthread_mutexattr_gettype()
          • pthread_mutexattr_getwakeup_np()
          • pthread_mutexattr_init()
          • pthread_mutexattr_setprioceiling()
          • pthread_mutexattr_setprotocol()
          • pthread_mutexattr_setpshared()
          • pthread_mutexattr_setrecursive()
          • pthread_mutexattr_setrobust()
          • 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_getclock()
          • pthread_rwlockattr_getpshared()
          • pthread_rwlockattr_init()
          • pthread_rwlockattr_setclock()
          • 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()
          • quick_exit()
        • R
          • Raccept()
          • raise()
          • rand()
          • rand_r()
          • random()
          • Rbind()
          • rcmd(), rcmd_af()
          • Rconnect()
          • rdchk()
          • re_comp()
          • re_exec()
          • read()
          • readblock()
          • readcond()
          • readdir(), readdir64()
          • _readdir_r(), _readdir64_r()
          • readdir_r(), readdir64_r()
          • readlink()
          • readv()
          • realloc()
          • realpath()
          • recv()
          • recvfrom()
          • recvmmsg()
          • recvmsg()
          • regcomp()
          • regerror()
          • regexec()
          • regfree()
          • _register_ioctl_handler()
          • remainder(), remainderf(), remainderl()
          • remove()
          • remque()
          • remquo(), remquof(), remquol()
          • 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_detach_ctp()
          • 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
          • sandbox_attach()
          • sandbox_create()
          • sandbox_delete()
          • scalb()
          • scalbln(), scalblnf(), scalblnl()
          • scalbn(), scalbnf(), scalbnl()
          • _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()
          • SchedGetCpuNum()
          • SchedInfo(), SchedInfo_r()
          • SchedSet(), SchedSet_r()
          • SchedYield(), SchedYield_r()
          • searchenv()
          • seed48()
          • seekdir()
          • select(), pselect()
          • select_attach()
          • select_detach()
          • select_query()
          • sem_close()
          • sem_destroy()
          • sem_getvalue()
          • sem_init()
          • sem_open()
          • sem_post()
          • sem_timedwait(), sem_timedwait_monotonic()
          • sem_trywait()
          • sem_unlink()
          • sem_wait()
          • send()
          • sendmmsg()
          • sendmsg()
          • sendto()
          • servent
          • set_ids_from_arg()
          • set_lowest_fd()
          • setbuf()
          • setbuffer()
          • setdomainname()
          • setegid()
          • setenv()
          • seteuid()
          • setgid()
          • setfsent()
          • setgrent()
          • setgroups()
          • sethostent()
          • sethostname()
          • SETIOV()
          • setitimer()
          • setjmp()
          • setkey()
          • setlinebuf()
          • setlocale()
          • setlogmask()
          • setnetent()
          • setpgid()
          • setpgrp()
          • setprotoent()
          • setpwent()
          • setregid()
          • setreuid()
          • setrlimit(), setrlimit64()
          • setservent()
          • setsid()
          • setsockopt()
          • setspent()
          • setstate()
          • settimeofday()
          • setuid()
          • setutent()
          • setvbuf()
          • _sfree()
          • shm_ctl(), shm_ctl_special()
          • shm_open()
          • shm_unlink()
          • shutdown()
          • shutdown_system(), shutdown_system_with_reason()
          • sigaction()
          • struct sigaction
          • sigaddset()
          • sigblock()
          • sigdelset()
          • sigemptyset()
          • sigevent
          • sigfillset()
          • siginfo_t
          • sigismember()
          • siglongjmp()
          • sigmask()
          • signal()
          • SignalAction(), SignalAction_r()
          • SignalKill(), SignalKill_r()
          • SignalKillSigval(), SignalKillSigval_r()
          • SignalProcmask(), SignalProcmask_r()
          • SignalSuspend(), SignalSuspend_r()
          • SignalWaitinfo(), SignalWaitinfo_r()
          • SignalWaitinfoMask(), SignalWaitinfoMask_r()
          • signbit()
          • sigpause()
          • sigpending()
          • sigprocmask()
          • sigqueue()
          • sigsetjmp()
          • sigsetmask()
          • sigsuspend()
          • sigtimedwait()
          • sigunblock()
          • sigwait()
          • sigwaitinfo()
          • sin(), sinf(), sinl()
          • sinh(), sinhf(), sinhl()
          • sleep()
          • _sleepon_broadcast()
          • _sleepon_destroy()
          • _sleepon_init()
          • _sleepon_lock()
          • _sleepon_signal()
          • _sleepon_unlock()
          • _sleepon_wait()
          • slog2_close_log()
          • slog2_dump_logs_to_file()
          • slog2_find_buffer()
          • slog2_get_buffer_info()
          • slog2_get_log_info()
          • slog2_get_verbosity()
          • slog2_hash()
          • slog2_obfuscate()
          • slog2_open_log()
          • slog2_packet_cmp()
          • slog2_packet_info_t
          • slog2_parse_all()
          • slog2_parse_dynamic_buffer(), slog2_parse_static_buffer()
          • slog2_register()
          • slog2_reset()
          • slog2_set_default_buffer()
          • slog2_set_verbosity()
          • slog2c()
          • slog2f()
          • slog2fa()
          • slogb()
          • slogf()
          • slogi()
          • _smalloc()
          • snprintf()
          • sockatmark()
          • socket()
          • socketpair()
          • SOCKSinit()
          • sopen()
          • sopenfd()
          • spawn()
          • spawnl()
          • spawnle()
          • spawnlp()
          • spawnlpe()
          • spawnp()
          • spawnv()
          • spawnve()
          • spawnvp()
          • spawnvpe()
          • sprintf()
          • sqrt(), sqrtf(), sqrtl()
          • srand()
          • srand48()
          • srandom()
          • _srealloc()
          • sscanf()
          • stat(), stat64()
          • struct stat
          • stat_convert_form()
          • static_assert()
          • statvfs(), statvfs64()
          • stderr
          • stdin
          • stdout
          • stpcpy()
          • stpncpy()
          • straddstr()
          • strcasecmp()
          • strcasestr()
          • strcat()
          • strchr(), strchr_isr()
          • strcmp()
          • strcoll()
          • strcpy(), strcpy_isr()
          • strcspn()
          • strdup()
          • strerror()
          • strerror_r()
          • strftime()
          • strlcat(), strlcpy()
          • strlen(), strlen_isr()
          • strlwr()
          • strncasecmp()
          • strncat()
          • strncmp()
          • strncpy()
          • strnlen()
          • strpbrk()
          • strptime()
          • strrchr()
          • strrev()
          • strsep()
          • strsignal()
          • strspn()
          • strstr()
          • strtod(), strtof(), strtold()
          • strtoimax(), strtoumax()
          • strtok()
          • strtok_r()
          • strtol(), strtoll()
          • strtoul(), strtoull()
          • strupr()
          • strxfrm()
          • swab()
          • swprintf()
          • swscanf()
          • symlink()
          • sync()
          • SyncCondvarSignal(), SyncCondvarSignal_r()
          • SyncCondvarWait(), SyncCondvarWait_r()
          • SyncCtl(), SyncCtl_r()
          • SyncDestroy(), SyncDestroy_r()
          • SyncMutexEvent(), SyncMutexEvent_r()
          • SyncMutexLock(), SyncMutexLock_r()
          • SyncMutexRevive(), SyncMutexRevive_r()
          • SyncMutexUnlock(), SyncMutexUnlock_r()
          • SyncSemPost(), SyncSemPost_r()
          • SyncSemWait(), SyncSemWait_r()
          • SyncTypeCreate(), SyncTypeCreate_r()
          • sysconf()
          • sysctl(), sysctlbyname()
          • syslog()
          • sysmgr_reboot()
          • sysmgr_runstate(), sysmgr_runstate_dynamic()
          • sysmgr_runstate_burst()
          • SYSPAGE_CPU_ENTRY()
          • SYSPAGE_ENTRY()
          • _syspage_ptr
          • SysSrandom(), SysSrandom_r()
          • system()
        • T
          • tan(), tanf(), tanl()
          • tanh(), tanhf(), tanhl()
          • tcdrain()
          • tcdropline()
          • tcflow()
          • tcflush()
          • tcgetattr()
          • tcgetpgrp()
          • tcgetsid()
          • tcgetsize()
          • tcinject()
          • tcischars()
          • TCP
          • tcsendbreak()
          • tcsetattr()
          • tcsetpgrp()
          • tcsetsid()
          • tcsetsize()
          • telldir()
          • tempnam()
          • termios
          • tgamma(), tgammaf(), tgammal()
          • thrd_create()
          • thrd_current()
          • thrd_detach()
          • thrd_equal()
          • thrd_exit()
          • thrd_join()
          • thrd_sleep()
          • thrd_yield()
          • thread_pool_control()
          • thread_pool_create()
          • thread_pool_destroy()
          • thread_pool_limits()
          • thread_pool_start()
          • ThreadCancel(), ThreadCancel_r()
          • ThreadCreate(), ThreadCreate_r()
          • ThreadCtl(), ThreadCtl_r(), ThreadCtlExt(), ThreadCtlExt_r()
          • ThreadDestroy(), ThreadDestroy_r()
          • ThreadDetach(), ThreadDetach_r()
          • ThreadJoin(), ThreadJoin_r()
          • time()
          • timer_create()
          • timer_delete()
          • timer_getexpstatus()
          • timer_getoverrun()
          • timer_gettime()
          • timer_settime()
          • timer_timeout(), timer_timeout_r()
          • TimerAlarm(), TimerAlarm_r()
          • TimerCreate(), TimerCreate_r()
          • TimerDestroy(), TimerDestroy_r()
          • TimerInfo(), TimerInfo_r()
          • TimerSettime(), TimerSettime_r()
          • TimerTimeout(), TimerTimeout_r()
          • times()
          • timespec
          • timespec_get()
          • timespec2nsec()
          • timezone
          • tm
          • tmpfile(), tmpfile64()
          • tmpnam()
          • tolower()
          • toupper()
          • towctrans()
          • towlower()
          • towupper()
          • trace_func_enter()
          • trace_func_exit()
          • _TRACE_GET_STRUCT()
          • trace_here()
          • trace_logb()
          • trace_logbc()
          • trace_logf()
          • trace_logi()
          • trace_nlogf()
          • trace_vnlogf()
          • TraceEvent()
          • traceparser()
          • traceparser_cs()
          • traceparser_cs_range()
          • traceparser_debug()
          • traceparser_destroy()
          • traceparser_get_info()
          • traceparser_init()
          • trunc(), truncf(), truncl()
          • truncate(), truncate64()
          • tss_create()
          • tss_delete()
          • tss_get()
          • tss_set()
          • ttyname()
          • ttyname_r()
          • tzname
          • tzset()
        • U
          • ualarm()
          • UDP
          • ultoa(), ulltoa()
          • umask()
          • umount()
          • UNALIGNED_PUT16()
          • UNALIGNED_PUT32()
          • UNALIGNED_PUT64()
          • UNALIGNED_RET16()
          • UNALIGNED_RET32()
          • UNALIGNED_RET64()
          • uname()
          • ungetc()
          • ungetwc()
          • _unregister_ioctl_handler()
          • UNIX
          • unlink()
          • unlockpt()
          • unsetenv()
          • usleep()
          • utime()
          • utimensat()
          • utimes()
          • utmp
          • utmpname()
          • utoa()
        • V
          • va_arg()
          • va_copy()
          • va_end()
          • va_start()
          • valloc()
          • verr(), verrx()
          • vfork()
          • vfprintf()
          • vfscanf()
          • vfwprintf()
          • vfwscanf()
          • vprintf()
          • vscanf()
          • vslog2f()
          • vslog2fa()
          • vslogf()
          • vsnprintf()
          • vsprintf()
          • vsscanf()
          • vswprintf()
          • vswscanf()
          • vsyslog()
          • vwarn(), vwarnx()
          • vwprintf()
          • vwscanf()
        • W
          • wait()
          • wait3()
          • wait4()
          • waitfor()
          • waitid()
          • waitpid()
          • warn(), warnx()
          • wcrtomb()
          • wcscat()
          • wcschr()
          • wcscmp()
          • wcscoll()
          • wcscpy()
          • wcscspn()
          • wcsftime()
          • wcslen()
          • wcsncat()
          • wcsncmp()
          • wcsncpy()
          • wcspbrk()
          • wcsrchr()
          • wcsrtombs()
          • wcsspn()
          • wcsstr()
          • wcstod(), wcstof(), wcstold()
          • wcstoimax(), wcstoumax()
          • wcstok()
          • wcstol(), wcstoll()
          • wcstombs()
          • wcstoul(), wcstoull()
          • wcsxfrm()
          • wctob()
          • wctomb()
          • wctrans()
          • wctype()
          • wmemchr()
          • wmemcmp()
          • wmemcpy()
          • wmemmove()
          • wmemset()
          • wordexp()
          • wordfree()
          • wprintf()
          • write()
          • writeblock()
          • writev()
          • wscanf()
        • X
        • Y
          • y0(), y0f()
          • y1(), y1f()
          • yn(), ynf()
        • Z
        • SOCKS — A Basic Firewall
          • How to SOCKSify a client
          • What SOCKS expects
        • Full Safety Information
          • A
          • B
          • C
          • D
          • E
          • F
          • G
          • H
          • I
          • J
          • K
          • L
          • M
          • N
          • O
          • P
          • Q
          • R
          • S
          • T
          • U
          • V
          • W
          • Y
        • Glossary
      • Devctl and Ioctl Commands
        • CAN_DEVCTL_*
          • CAN_DEVCTL_DEBUG_INFO
          • CAN_DEVCTL_DEBUG_INFO2
          • CAN_DEVCTL_ERROR
          • CAN_DEVCTL_GET_INFO
          • CAN_DEVCTL_GET_MFILTER
          • CAN_DEVCTL_GET_MID
          • CAN_DEVCTL_GET_PRIO
          • CAN_DEVCTL_GET_STATS
          • CAN_DEVCTL_GET_TIMESTAMP
          • CAN_DEVCTL_READ_CANMSG_EXT
          • CAN_DEVCTL_RX_FRAME_RAW_BLOCK
          • CAN_DEVCTL_RX_FRAME_RAW_NOBLOCK
          • CAN_DEVCTL_SET_MFILTER
          • CAN_DEVCTL_SET_MID
          • CAN_DEVCTL_SET_PRIO
          • CAN_DEVCTL_SET_TIMESTAMP
          • CAN_DEVCTL_TX_FRAME_RAW
          • CAN_DEVCTL_WRITE_CANMSG_EXT
        • 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_GETOBAND_EXTENDED
          • 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_GETPATH
          • 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_STATSSR
          • 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_DBGLEVEL
          • DCMD_FSEVMGR_FILTER_ADD
          • DCMD_FSEVMGR_FILTER_REM
          • DCMD_FSEVMGR_FSEVENTCHID
          • DCMD_FSEVMGR_INOTIFYCHID
          • DCMD_FSEVMGR_MB_RESTORE
          • DCMD_FSEVMGR_MB_STATE
          • DCMD_FSEVMGR_QNX_EXT
          • DCMD_FSEVMGR_RFILTER_ADD
          • DCMD_FSEVMGR_STATE
          • 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_FSNOTIFY_SAVE
          • 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_PGCACHE_CTL
          • 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_PTPD_*
          • DCMD_PTPD_DELAYMS
          • DCMD_PTPD_DELAYSM
          • DCMD_PTPD_GET_PDELAY_INTERVAL
          • DCMD_PTPD_GET_TAI_UTC_OFFSET
          • DCMD_PTPD_GET_TIME
          • DCMD_PTPD_INFO
          • DCMD_PTPD_SEND_SIGNALING_MSG
          • DCMD_PTPD_SET_PDELAY_INTERVAL
          • DCMD_PTPD_STATUS
        • 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
      • JSON Library Reference
        • Overview
          • Decoding JSON data
          • Encoding JSON data
        • JSON Decoding and Encoding API
          • JSON decoder functionality
            • json_decoder_t
            • json_decoder_cleanup()
            • json_decoder_create()
            • json_decoder_destroy()
            • json_decoder_dump_tree()
            • json_decoder_error_t
            • json_decoder_free_state()
            • json_decoder_get_bool()
            • json_decoder_get_data_version()
            • json_decoder_get_double()
            • json_decoder_get_encoder()
            • json_decoder_get_int()
            • json_decoder_get_int_ll()
            • json_decoder_get_offset()
            • json_decoder_get_parse_error()
            • json_decoder_get_state()
            • json_decoder_get_status()
            • json_decoder_get_string()
            • json_decoder_index()
            • json_decoder_is_integer()
            • json_decoder_length()
            • json_decoder_name()
            • json_decoder_next()
            • json_decoder_parse_error_t
            • json_decoder_parse_file()
            • json_decoder_parse_json_str()
            • json_decoder_pop()
            • json_decoder_position_index()
            • json_decoder_position_property()
            • json_decoder_previous()
            • json_decoder_push_array()
            • json_decoder_push_object()
            • json_decoder_remove_node()
            • json_decoder_reset()
            • json_decoder_set_data_version()
            • json_decoder_set_state()
            • json_decoder_set_status()
            • json_decoder_state_t
            • json_decoder_type()
            • json_node_type_t
          • JSON encoder functionality
            • json_encoder_t
            • json_encoder_access_buffer()
            • json_encoder_add_bool()
            • json_encoder_add_double()
            • json_encoder_add_from_decoder()
            • json_encoder_add_int()
            • json_encoder_add_int_ll()
            • json_encoder_add_json()
            • json_encoder_add_null()
            • json_encoder_add_property_name()
            • json_encoder_add_string()
            • json_encoder_add_whitespace()
            • json_encoder_buffer()
            • json_encoder_cleanup()
            • json_encoder_clear_option()
            • json_encoder_create()
            • json_encoder_destroy()
            • json_encoder_end_array()
            • json_encoder_end_object()
            • json_encoder_error_t
            • json_encoder_format_t
            • json_encoder_get_state()
            • json_encoder_get_status()
            • json_encoder_length()
            • json_encoder_nesting_level()
            • json_encoder_option_t
            • json_encoder_reserve_space()
            • json_encoder_reset()
            • json_encoder_set_format()
            • json_encoder_set_option()
            • json_encoder_set_state()
            • json_encoder_set_status()
            • json_encoder_start_array()
            • json_encoder_start_object()
            • json_encoder_state_t
          • JSON utility functions
            • jsnprintf()
            • vjsnprintf()
      • PAM Reference
        • PAM Modules
          • pam_deny
          • pam_echo
          • pam_exec
          • pam_ftpusers
          • pam_group
          • pam_mac
          • pam_permit
          • pam_qnx
          • pam_radius
          • pam_rootok
          • pam_self
      • Utilities Reference
        • Utility Conventions
        • A
          • ability
          • addr2line
          • addvariant
          • afm_ctl
          • apx_ctl
          • aps
          • ar
          • arp
          • as
          • /etc/autoconnect
          • autoipd
        • B
          • basename
          • bc
          • bison
          • bootpd
          • /etc/bootptab
          • brconfig
          • bunzip2
          • bzcat
          • bzip2
          • bzip2recover
        • C
          • c++filt
          • cam-cdrom.so
          • cam-disk.so
          • cam-optical.so
          • canctl
          • cat
          • cfgopen
          • chat
          • chattr
          • chgrp
          • chkdosfs
          • chkqnx6fs
          • chmod
          • chown
          • cksum
          • clear
          • cmp
          • comm
          • confstr
          • coreinfo
          • cp
          • cpio
          • cpufreq
          • cron
          • crontab
          • csplit
          • cut
        • D
          • date
          • D-Bus
          • dcheck
          • dd
          • deflate
          • deva-ctrl-a2dp.so
          • deva-ctrl-audiopci.so
          • deva-ctrl-intel_hda.so
          • deva-ctrl-usb.so
          • deva-ctrl-usb_btsco.so
          • deva-mixer-ac97.so
          • deva-mixer-ak4531.so
          • deva-mixer-hda.so
          • deva-util-restore.so
          • devb-ahci
          • devb-eide
          • devb-loopback
          • devb-nvme
          • devb-ram
          • devb-sdmmc-*
          • devb-umass
          • devb-ustor
          • devb-virtio
          • devc-con, devc-con-hid
          • devc-pty
          • devc-ser* options
          • devc-ser8250
          • devc-serpci
          • devc-serusb
          • devc-serusb_dcd
          • devc-virtio
          • devcrypto
          • devf-generic
          • devf-ram
          • devh-egalax.so
          • devh-microtouch.so
          • devh-ps2ser.so
          • devh-touchintl.so
          • devh-usb.so
          • devi-hid
          • devnp-asix.so
          • devnp-e1000.so
          • devnp-ecm.so
          • devnp-ecmplus.so
          • devnp-ixgbe.so
          • devnp-ncm.so
          • devnp-rtl8169.so
          • devnp-smsc9500.so
          • devnp-speedo.so
          • devnp-usbdnet.so
          • devnp-usbnet.so
          • devnp-virtio.so
          • devnp-vmxnet3.so
          • devu-hcd-ehci.so
          • devu-hcd-ohci.so
          • devu-hcd-uhci.so
          • devu-hcd-xhci.so
          • devu-umass_client-block
          • df
          • dhclient
          • dhclient-script
          • dhclient.conf, dhclient-dhcpv6.conf
          • dhclient.leases, dhclient6.leases
          • DHCP Conditional Evaluation
          • DHCP Options
          • dhcp.client
          • dhcpd
          • dhcpd.conf, dhcpd-dhcpv6.conf
          • dhcpd.leases, dhcpd6.leases
          • dhcrelay
          • diff
          • dig
          • dirname
          • diskimage
          • diskimage configuration file
          • dloader
          • dns-sd
          • dnssec-dsfromkey
          • dnssec-keyfromlabel
          • dnssec-keygen
          • dnssec-signzone
          • du
          • dumpefs
          • dumper
          • dumpifs
          • dvfs_client
          • dvfsmgr-*
        • E
          • echo
          • ed
          • egrep
          • elfnote
          • elvis
          • env
          • errno
          • esh
          • etfsctl
          • expand
          • /etc/exports
          • expr
        • F
          • false
          • fcat
          • fdisk
          • fesh
          • fgrep
          • file
          • find
          • flashctl
          • flex
          • fmt
          • fold
          • fpemu.so
          • freeze
          • fs-cifs
          • fs-dos.so
          • fs-etfs-ram
          • fs-ext2.so
          • fs-mac.so
          • fsf-merkle.so
          • fs-nfs2
          • fs-nfs3
          • fs-nt.so
          • fs-qnx6.so
          • fs-qtd.so
          • fs-udf.so
          • fsencrypt
          • fsevmgr
          • fsysinfo
          • /etc/fstab
          • ftp
          • /etc/ftpchroot
          • ftpd
          • /etc/ftpd.conf
          • /etc/ftpusers
          • fullpath
        • G
          • g++, gcc
          • /etc/gateways
          • gawk
          • gcov
          • gdb
          • genmac-random
          • getconf
          • getfacl
          • getty
          • gns
          • gprof
          • grep
          • gunzip
          • gzip
        • H
          • ham
          • hamctrl
          • hd
          • head
          • hidview
          • hogs
          • host
          • hostapd-version
          • hostapd_cli-version
          • hostname
          • /etc/hosts
          • /etc/hosts.equiv
        • I
          • id
          • if_up
          • ifconfig
          • ifmcstat
          • ifwatchd
          • indent
          • inetd
          • /etc/inetd.conf
          • inflator
          • infocmp
          • io
          • io-audio
          • io-blk.so
          • io-hid
          • io-pkt-v4-hc, io-pkt-v6-hc
          • io-usb-otg
          • iperf2
          • iperf3
          • isend
          • isendrecv
        • J
          • join
        • K
          • kill
          • ksh
        • L
          • ld
          • ldd
          • less
          • libcam.so
          • link
          • ln
          • ln-w
          • location_manager
          • logger
          • login
          • logout
          • ls
          • lsm-llmcast.so
          • lsm-pf-v4.so, lsm-pf-v6.so
          • lsm-qnet.so
          • lsm-slip.so
          • lwresd
          • lzcat, lzma
          • lzmadec
          • lzmainfo
        • M
          • m4
          • /usr/share/misc/magic
          • make
          • mdnsd
          • melt
          • mesg
          • mix_ctl
          • mkasmoff
          • mkbuild
          • mkcldr
          • mkdir
          • mkdosfs
          • mkefs
          • mketfs
          • mkfatfsimg
          • mkfifo
          • mki
          • mkifs
          • mkimage
          • mkmerklefs
          • mkqfs
          • mkqnx6fs
          • mkqnx6fsimg
          • mkrec
          • mktemp
          • mkxfs
          • /etc/moduli
          • more
          • mount
          • mount_ifs
          • mq
          • mqueue
          • mrouted
          • mv
        • N
          • named
          • named-checkconf
          • named-checkzone, named-compilezone
          • /etc/named.conf
          • ndp
          • netstat
          • /etc/networks
          • newgrp
          • nfsd
          • /etc/nfsstart
          • nice
          • nicinfo
          • nm
          • nohup
          • nslookup
          • /etc/nsswitch.conf
          • nsupdate
          • ntp-keygen
          • ntpd
          • ntpdate
          • ntpdc
          • ntpq
          • ntptrace
        • O
          • objcopy
          • objdump
          • od
          • omshell
          • on
          • op
          • openssl
        • P
          • passwd
          • paste
          • pathtrust
          • pax
          • pci-server
          • pci-tool
          • pcm_logger
          • pcnfsd
          • /etc/pcnfsd.conf
          • pdebug
          • pf
          • /etc/pf.conf
          • pfctl
          • pidin
          • ping
          • ping6
          • pipe
          • plainrsa_gen
          • pppd
          • pppoectl
          • pps
          • pr
          • printf
          • procnto*
          • /etc/protocols
          • ps
          • pted
          • ptpd, ptpd-avb
          • pwd
          • python
        • Q
          • qad
          • q++, qcc
          • qconfig
          • qconn
          • qcp
          • qtalk
        • R
          • racoon
          • /etc/racoon/racoon.conf
          • racoonctl
          • random
          • ranlib
          • rcp
          • readelf
          • renice
          • restart
          • /etc/resolv.conf
          • resvanonport
          • ~/.rhosts
          • rlogin
          • rlogind
          • rm
          • rmdir
          • rndc
          • rndc-confgen
          • rndc.conf
          • route
          • route6d
          • routed
          • /etc/rpc
          • rpcbind
          • rpcgen
          • rpcinfo
          • rsh
          • rshd
          • rsrcdb_query
          • rtadvd
          • /etc/rtadvd.conf
          • rtc
          • rtquery
          • rtsold
          • ruptime
          • rwho
          • rwhod
        • S
          • scp
          • script
          • secpol
          • secpolcompile
          • secpolgenerate
          • secpolmonitor
          • secpolpush
          • sed
          • seedres
          • sendnto
          • server-monitor
          • /etc/services
          • setconf
          • setfacl
          • setkey
          • sftp
          • sftp-server
          • sh
          • showmount
          • shutdown
          • size
          • slattach
          • slay
          • sleep
          • slm
          • slogger2
          • slog2info
          • sntp
          • /etc/socks.conf
          • sockstat
          • sort
          • spatch
          • split
          • ssh
          • ssh-add
          • ssh-agent
          • ~/.ssh/ssh_config, /etc/ssh/ssh_config
          • ssh-keygen
          • ssh-keyscan
          • ssh-keysign
          • sshd
          • /etc/ssh/sshd_config
          • startup-* options
          • startup-apic, startup-apic-32
          • startup-uefi, startup-uefi-32
          • startup-x86, startup-x86-32
          • strings
          • strip
          • stty
          • su
          • sync
          • sysctl
          • /etc/syslog.conf
          • syslogd
        • T
          • tail
          • tar
          • tcpdump
          • tee
          • telnet
          • telnetd
          • termdef
          • textto
          • tftp
          • tftpd
          • tic
          • time
          • timestamp
          • tinit
          • top
          • touch
          • tr
          • tracelogger
          • traceprinter
          • traceroute
          • traceroute6
          • true
          • tsort
          • tty
        • U
          • uesh
          • ulink_ctrl
          • umask
          • umount
          • uname
          • unexpand
          • unifdef
          • uniq
          • unlink
          • unxz, unlzma
          • unzip
          • uptime
          • usb
          • use
          • usemsg
          • uud
          • uudecode
          • uue
          • uuencode
        • V
          • valgrind
          • vi
          • view
        • W
          • waitfor
          • wave
          • waverec
          • wc
          • wdtkick
          • which
          • wpa_cli-version
          • wpa_passphrase-version
          • wpa_supplicant-version
        • X
          • xargs
          • xz
          • xzcat
          • xzdec, lzmadec
        • Y
        • Z
          • zcat
          • zip
        • Commonly Used Environment Variables
        • Selecting the Target System
          • Target selection
          • Architecture selection
          • Linker emulation selection
        • Glossary
  • QNX Hypervisor
    • QNX Hypervisor for Safety 2.0 User's Guide
      • Understanding QNX Virtual Environments
        • A note about nomenclature
        • Supported architectures, hardware, and guest OSs
        • Architecture
        • Virtual machines
        • Memory
        • Devices
          • Physical devices
          • Virtual devices
        • Scheduling
        • Interrupts
        • Time
        • Sharing resources
      • QNX Hypervisor for Safety
        • Protecting the hypervisor and its guests
        • Design Safe States
        • QHS components
        • Checking the guest's environment and the hypervisor's safety status
        • DMA device containment (smmuman)
        • Watchdogs
        • Handling a qvm termination
      • Configuration
        • Configuring the hypervisor host
        • Assembling and configuring VMs
          • VM configuration syntax
          • VM configuration file example
          • ACPI tables and FDTs
        • Configuring guests
      • Building a Hypervisor System
        • Supported development hosts
        • Getting the host
        • Building the host
        • Building guests
          • Building QNX guests
          • Building Linux and Android guests
        • The HHBSP framework
          • Configuring an HHBSP build
          • Building in the HHBSP
        • Hypervisor disk images
        • Preparing your target board
        • Transferring the disk image
      • Booting and Shutting Down
        • Booting the host
        • Viewing hypervisor activity
        • Shutting down a QNX hypervisor
        • Starting VMs
        • Starting and using guests
        • Shutting down guests
      • Using a QNX Hypervisor System
        • Networking
          • Guest-to-guest
          • Guest-to-host
          • Guest-to-world
          • Bridge and tap interfaces
        • Memory sharing
          • Factory and control pages
          • Configuring the VMs
          • Using the shared memory vdev
          • Virtual registers (guest_shm.h)
        • Discovering and connecting VirtIO devices
      • Monitoring and Troubleshooting
        • Using a GNU debugger (GDB)
        • Getting hypervisor trace information
          • Hypervisor trace events
          • Comparing guest and host timelines
          • Updating hypervisor event trace descriptions (optional)
        • OS-VM configuration mismatch
        • Finding the current time drift
        • Getting a guest dump
        • qvm exit codes
      • Performance Tuning
        • Guest exits
        • Guest-triggered exits
        • Guest IPIs
        • vCPUs and hypervisor performance
        • Interrupts
        • VirtIO
      • VM Configuration Reference
        • cmdline
        • cpu
        • debug
        • dump
        • gdb
        • generate
        • load
        • logger
        • pass
        • ram
        • reserve
        • rom
        • safety
        • set
        • suppress
        • system
        • tolerance
        • unsupported
        • user
        • vdev
      • Virtual Device Reference
        • vdev 8259
        • vdev gic
        • vdev hpet
        • vdev ioapic
        • vdev mc146818
        • vdev pci-dummy
        • vdev pci-host-bridge
        • vdev pckeyboard
        • vdev pl011
        • vdev progress
        • vdev ser8250
        • vdev shmem
        • vdev smmu
        • vdev timer8254
        • vdev virtio-blk
        • vdev virtio-console
        • vdev virtio-entropy
        • vdev virtio-net
        • vdev wdt-ib700
        • vdev wdt-sp805
      • Utilities and Drivers Reference
        • devnp-vdevpeer.so
        • devnp-vdevpeer-net.so
        • kdserver
        • qvm-check
      • Terminology
    • QNX Hypervisor for Safety 2.0 Virtual Device Developer's Guide
      • About Writing Vdevs
        • Prerequisites
        • Designing a vdev
        • Implementing a vdev
        • Lifecycle of a vdev
        • Guest memory regions
        • Reading and writing in a vdev
        • Terminating qvm process instances and guests
        • Debugging a vdev
      • The Basics: vdev trace
        • Defining and registering (vdev trace)
        • The running vdev (vdev trace)
      • Advanced Topics
        • Emulating hardware (vdev wdt-sp805)
        • Running a watchdog vdev (vdev wdt-sp805)
        • A watchdog vdev for x86 (vdev wdt-ip700)
        • A guest-host hardware device intermediary (vdev ser8250)
        • Para-virtualized vdevs (virtio-entropy)
    • QNX Hypervisor for Safety 2.0 Virtual Device Developer's API Reference
      • Function Safety
      • abi.h
        • Definitions in abi.h
      • cdev.h
        • Definitions in cdev.h
        • cdev_control()
        • cdev_input_available()
        • cdev_input_num_available()
        • cdev_input_receive()
        • CDEV_OPT_*
        • cdev_output_busy()
        • cdev_output_empty()
        • cdev_output_full()
        • cdev_output_num_pending()
        • cdev_read()
        • cdev_setup()
        • cdev_state
        • cdev_write()
        • cdev_write_buffer()
      • firmware.h
        • gacpi_add_table()
        • gacpi_register_ioapic()
        • gfdt_add_vdev()
        • gfdt_get_clock()
        • gfdt_get_phandle()
        • gfdt_intr_spec()
        • gfdt_update_interrupts()
        • gfdt_update_node()
        • gfdt_update_phandle()
        • gfdt_update_prop_cells()
        • gfdt_update_prop_string()
        • gfdt_update_prop_strings()
        • gfdt_update_property()
        • gfdt_update_reg()
      • gasp.h
        • Definitions in gasp.h
        • gasp_anonymous_enum
        • gasp_find_free()
        • gasp_find_free_range()
        • gasp_lock()
        • gasp_map_contig()
        • gasp_map_sys()
        • gasp_map_vdma()
        • gasp_region_info()
        • gasp_region_set()
        • gasp_region_set_soft()
        • gasp_unlock()
        • gasp_unmap()
        • gasp_walk_count()
        • gasp_walk_init()
        • gasp_walk_next()
        • gasp_walk_state
        • gasp_walk_state_flags
        • gram_find_free()
        • gram_find_free_range()
        • gram_reserve()
      • guest.h
        • Guest termination types
        • guest_button_register()
        • guest_button_type
        • guest_clock_start()
        • guest_clock_stop()
        • guest_cpu_read()
        • guest_cpu_write()
        • guest_instr_callback_func_t()
        • guest_instr_register()
        • guest_instr_type
        • guest_intr_assign()
        • guest_intr_level()
        • guest_intr_notify()
        • guest_intr_num_pins()
        • guest_intr_signal()
        • guest_intr_string()
        • guest_msi_deliver_func_t
        • guest_msi_register()
        • guest_msi_signal()
        • guest_power_state_callback_func_t
        • guest_power_state_cmd
        • guest_power_state_current()
        • guest_power_state_notify_create()
        • guest_power_state_notify_delete()
        • guest_power_state_notify_register()
        • guest_terminate()
        • guest_termination_cause_t
        • guest_timer_create()
        • guest_timer_data
        • guest_timer_notify()
        • guest_timer_state()
        • guest_write_all_ones()
        • guest_write_core_file()
        • guest_xfer_flags
      • hpci.h
        • hpci_device_attach()
        • hpci_device_detach()
        • hpci_rd_cfg8()
        • hpci_rd_cfg16()
        • hpci_rd_cfg32()
        • hpci_rd_cfg64()
      • hw_pci.h
        • Definitions in hw_pci.h
          • MSI message control
          • PCI addresses
          • PCI capabilities
          • PCI classes
          • PCI commands
          • PCI enable
          • PCI extended capabilities
          • PCI registers
          • PCI status
        • _pci_bridge_config_regs
        • _pci_capability_agp
        • _pci_capability_hot_plug
        • _pci_capability_msi32
        • _pci_capability_msi32_PVM
        • _pci_capability_msi64
        • _pci_capability_msi64_PVM
        • _pci_capability_msix
        • _pci_capability_pci_express
        • _pci_capability_pcix
        • _pci_capability_pcix_bridge
        • _pci_capability_power
        • _pci_capability_slot_numbering
        • _pci_capability_vpd
        • _pci_cardbus_config_regs
        • _pci_config_regs
        • _pci_msix_table
      • outpipe.h
        • Definitions in outpipe.h
        • qvm_outattr()
        • qvm_outf()
        • qvm_outff()
        • qvm_outlbl
        • qvm_outrc
        • qvm_outrs
        • qvm_voutf()
        • qvm_report()
      • types.h
        • Definitions in types.h
        • gasp_region
        • gasp_region_flags
        • guest_intr
        • guest_intr_notifications
        • guest_intr_state
        • guest_intr_assign_type
        • guest_table_spec_component
        • qvm_sched_info
        • qvm_state_block
        • qvm_state_flags
        • qvm_state_types
      • utils.h
        • Definitions in utils.h
        • next_pow2()
        • qvm_block_string()
        • qvm_block_type_name()
        • qvm_callback
        • qvm_callback_func_t
        • qvm_callback_pulse()
        • qvm_channel()
        • qvm_make_non_safety()
        • qvm_msgblock_oneshot()
        • qvm_msgblock_start()
        • qvm_msgblock_stop()
        • qvm_overlap()
        • qvm_parse_block()
        • qvm_parse_intr()
        • qvm_parse_num()
        • qvm_parse_num_flags
        • qvm_register_setvar()
        • qvm_safety_env()
        • qvm_setvar_context
        • qvm_setvar_info
        • qvm_setvar_type
        • qvm_setvar_value
        • qvm_slice()
        • qvm_slice_descriptor
        • qvm_slice_result
        • qvm_slice_store()
        • qvm_unique()
      • vdev.h
        • Definitions in vdev.h
      • vdev-core.h
        • Definitions in vdev-core.h
        • guest_cpu_to_vrs()
        • vdev_ctrl_assign_flags
        • vdev_factory
        • vdev_factory_flags
        • vdev_get_vdevpeer()
        • vdev_path()
        • vdev_pic_functions
        • vdev_pulse()
        • vdev_ref_status
        • vdev_register_factory()
        • vdev_register_for_system_pulse()
        • vdev_s
        • VDEV_SAFETY_*
        • vdev_string()
        • vdev_thread_create()
        • vdev_thread_setname()
        • vdev_verify_unique()
      • vio.h
        • Definitions in vio.h
        • vio_append_iov()
        • vio_config_update()
        • vio_ctrl_pci_bars()
        • vio_description
        • vio_device_status()
        • vio_get_iov()
        • vio_init()
        • vio_init_queue()
        • vio_iov
        • vio_iov_flags
        • vio_iov_set_flags()
        • vio_notify_t
        • vio_prepare_iov()
        • vio_put_iov()
        • vio_queue_info
        • vio_read()
        • vio_reset()
        • vio_setup_queues()
        • vio_state
        • vio_version
        • vio_write()
      • vpci.h
        • Definitions in vpci.h
        • vpci_bar
        • vpci_bar_base()
        • vpci_bar_writable()
        • vpci_cfg_read()
        • vpci_cfg_write()
        • vpci_ctrl_pci_bars()
        • vpci_init_rw()
        • vpci_region_update()
        • vpci_rw_state
        • vpci_update_bars()
      • wdog.h
        • Definitions in wdog.h
        • Enumerated values in wdog.h
        • wdog_bite()
        • wdog_control()
        • wdog_state
      • x86_64/apic.h
        • apic_func_t
        • apic_next_id()
        • apic_register()
        • apic_signal()
    • QNX Hypervisor 2.0 User's Guide
      • QNX Virtual Environments
        • A note about nomenclature
        • Architecture
        • Virtual machines
        • Memory
        • Devices
          • Physical devices
          • Virtual devices
        • Priority-based scheduling
        • Time
        • Sharing resources
      • Getting Started
        • Preparing your board
          • Intel Broadwell NUC 5i5
          • Intel Gordon Ridge MRB
          • Renesas R-Car H3
        • Transferring the disk image
        • Booting the hypervisor
        • Viewing hypervisor activity
        • Starting and using guests
        • Shutting down guests and the hypervisor
      • Assembling a Hypervisor System and Its Components
        • Supported build environments
        • Getting the host components
        • Configuring the hypervisor build
        • The HHBSP
        • Building in the HHBSP
        • Building the guests
          • Building QNX guests
          • Using non-QNX (Linux, Android) guests
        • Creating and transferring a hypervisor disk image
        • Using your own board-specific BSP for the host
      • Configuration
        • Configuring the hypervisor host
        • Configuring guests
        • Assembling and configuring VMs
          • VM configuration syntax
          • Starting VMs
          • Example VM configuration file
        • Configuring VM components
        • Configuring vdevs
        • Configuring pass-through
      • Using Your Hypervisor System
        • Networking
          • Guest-to-guest
          • Guest-to-host
          • Guest-to-world
          • Bridge and tap interfaces
        • Memory sharing
        • DMA device containment (smmuman)
        • Watchdogs
      • Monitoring, Troubleshooting, and Tuning
        • Using a GNU debugger (GDB)
        • Getting hypervisor trace information
          • Hypervisor trace events
          • Comparing guest and host timelines
          • Updating hypervisor event trace descriptions (optional)
        • Problems mounting a disk image or partitions
        • OS-VM configuration mismatch
        • Finding the current time drift
      • Utilities and Drivers Reference
        • devnp-vdevpeer.so
        • kdserver
        • smmuman
        • wdtkick
      • Terminology
  • QNX Platform for ADAS 2.0
    • Getting Started Overview
      • Getting Started with the QNX Platform for ADAS
        • Packaging in this product
        • Feature availability by hardware platform
      • Understanding Reference Images
        • Working with reference images
          • Mount file system to an image
        • Reference images available
        • Reference image sensor support
        • Reference image vision-processing support
      • Getting Started with the ASRock Beebox
        • About the QNX Platform for ADAS
          • Supported hardware configurations
          • Supported vision algorithms
        • Install and Boot a Reference Image
          • Get a reference image
          • Prepare removable media with an image
          • Configure hardware and boot a reference image
        • Use the Reference Image
          • Connect to reference image
          • Run Sample Applications
            • ADAS example
            • Camera example
            • Camera MUX 2x2
            • Publish and Subscribe example
            • Robot OS example
              • Installing ROS
            • Sensor example
          • Connect cameras and sensors
          • Configure sensors and cameras on the reference image
          • Modify the system to run a custom application
        • Troubleshoot Common Issues
      • Getting Started with the Intel Car Creek (Denverton) MRB
        • About the QNX Platform for ADAS
          • Supported hardware configurations
          • Supported vision algorithms
        • Install and Boot a Reference Image
          • Get a reference image
          • Prepare removable media with an image
          • Configure hardware and boot a reference image
        • Use the Reference Image
          • Connect to reference image
          • Run Sample Applications
            • Publish and Subscribe example
            • Robot OS example
              • Installing ROS
            • Sensor example
          • Connect cameras and sensors
          • Configure sensors and cameras on the reference image
          • Modify the system to start a custom application
        • Troubleshoot Common Issues
      • Getting Started with the NXP S32V234
        • About the QNX Platform for ADAS
          • Supported hardware configurations
          • Supported vision algorithms
        • Install and Boot a Reference Image
          • Get a reference image
          • Prepare an SD card with an image
          • Configure hardware and boot a reference image
        • Use the Reference Image
          • Connect to reference image
          • Run Sample Applications
            • Camera example
            • Camera MUX 2x2
            • Publish and Subscribe example
            • Robot OS example
              • Installing ROS
            • Sensor example
          • Connect cameras
          • Configure cameras on the reference image
          • Modify the system to run a custom application
      • Getting Started with the Renesas R-Car H3 Starter Kit Premier
        • About the QNX Platform for ADAS
          • Supported hardware configurations
          • Supported vision algorithms
        • Install and Boot a Reference Image
          • Get a reference image
          • Prepare a microSD card with an image
          • Configure hardware and boot a reference image
        • Use the Reference Image
          • Connect to reference image
          • Run Sample Applications
            • ADAS example
            • Camera example
            • Camera MUX 2x2
            • Publish and Subscribe example
            • Robot OS example
              • Installing ROS
            • Sensor example
          • Connect cameras and sensors
          • Configure sensors and cameras on the reference image
          • Modify the system to run a custom application
        • Troubleshoot Common Issues
      • Getting Started with the Renesas R-Car V3M Starter Kit
        • About the QNX Platform for ADAS
          • Supported hardware configurations
          • Supported vision algorithms
        • Install and Boot a Reference Image
          • Get a reference image
          • Configure hardware and boot a reference image
        • Use the Reference Image
          • Connect to reference image
          • Run Sample Applications
            • Camera example
            • Camera MUX 2x2
            • Publish and Subscribe example
            • Robot OS example
              • Installing ROS
            • Sensor example
          • Connect cameras and sensors
          • Configure sensors and cameras on the reference image
          • Modify the system to run a custom application
        • Troubleshoot Common Issues
    • Architecture
      • Architecture Overview
      • Sensor Framework
      • Networking
      • Open Source components
      • Third-party SDKs
      • QNX SDP and QNX OS for Safety
      • Board Support
      • Ecosystem
      • Applications for the QNX Platform for ADAS
    • Sensor Framework
      • ADAS Library Developer's Guide
        • ADAS Library Overview
        • Configuring ADAS Library
          • Algorithm
          • Camera Layout
          • Display
          • Input
          • Overlay Layout
          • Viewer
          • Viewer Sequence
        • Using Custom Algorithms
        • ADAS Library Reference
          • adas_api.h
            • adas_algorithm_t
            • adas_configure_viewer()
            • adas_destroy()
            • adas_error_t
            • adas_get_num_viewers()
            • adas_get_supported_views()
            • adas_get_viewer_configuration()
            • adas_get_viewer_info()
            • adas_initialize()
            • adas_record_start()
            • adas_record_stop()
            • adas_set_viewer_visibility()
            • adas_start_viewer_sequence()
            • adas_stop_viewer_sequence()
            • adas_view_t
            • adas_viewer_type_t
            • adas_viewer_info_t
          • adas_defs.h
            • adas_chained_rotations_3d_t
            • adas_coordinates_range_t
            • adas_pixel_buffer_handle_t
            • adas_pixel_buffer_type_internal_t
            • adas_pixel_format_t
            • adas_space_t
            • adas_cube_t
            • adas_dimensions_3d_t
            • adas_dimensions_t
            • adas_pixel_buffer
            • adas_position_3d_t
            • adas_position_t
            • adas_rect_t
            • adas_rgba_color_t
            • adas_vertex_coords_t
          • adas_external_algo.h
            • adas_algo_scaling_factor()
            • adas_ext_algorithm_t
            • adas_fusion_create_buffer_from_tracking()
            • adas_profile_init()
            • adas_profile_print()
            • adas_ext_algorithm
          • adas_fusion_defs.h
            • Definitions in adas_fusion_defs.h
            • adas_fusion_algo_close_t
            • adas_fusion_algo_handle_t
            • adas_fusion_algo_open_t
            • adas_fusion_algo_probe_t
            • adas_fusion_algo_process_sensor_buffer_t
            • adas_fusion_buffer_type_t
            • adas_fusion_distance_flag_t
            • adas_fusion_metrics_flag_t
            • adas_fusion_object_type_t
            • adas_fusion_object_data_t
            • adas_fusion_algo_preferences_t
            • adas_fusion_buffer_t
            • adas_fusion_navigation_data_t
          • adas_log.h
            • Definitions in adas_log.h
            • adas_log_print()
            • adas_strerror()
          • adas_opencv.h
            • adas_opencv_create_mat_from_pixel_buffer()
            • adas_opencv_draw_overlay_tracks()
            • adas_opencv_generate_fusion_tracks_from_rect()
            • adas_opencv_generate_rect_from_fusion_tracks()
            • adas_opencv_get_conversion_format()
          • adas_sensor_defs.h
            • adas_sensor_buffer_type_t
            • adas_sensor_buffer_t
            • adas_sensor_orientation_t
            • adas_sensor_source_t
            • adas_sensor_type_t
            • adas_focal_properties_t
            • adas_sensor_properties_t
            • adas_vertex_coords_t
      • Camera Developer's Guide
        • Camera Library Overview
        • Viewfinder Mode
        • Settings on the Camera
        • Image Buffer Access
          • Using callback mode
          • Using event mode
          • Using stream mode
        • Resource Management
        • Using external camera drivers
        • Use the Camera library API
          • Open the camera
          • Set the viewfinder mode for camera
          • Use Screen with the Camera API
          • Start viewfinder and configure camera settings
          • Use Screen to show the viewfinder window
          • Stop viewfinder and close camera
          • Record video
            • Understanding the camera roll
            • Synchronized recording from multiple cameras
          • Use streams
          • Encode video from a camera
          • Example: Show Viewfinder window
        • Camera Library Reference
          • camera_api.h
            • Definitions in camera_api.h
            • Camera access mode flags
            • camera_analog_video_standard_t
            • camera_audiocodec_t
            • camera_bayerformat_t
            • camera_bayerjustify_t
            • camera_buffer_t
            • camera_devstatus_t
            • camera_error_t
            • camera_eventkey_t
            • camera_eventmode_t
            • camera_exposuremode_t
            • camera_feature_t
            • camera_focusmode_t
            • camera_framedesc_t
            • camera_frametype_t
            • camera_frame_bayer_t
            • camera_frame_crycby_t
            • camera_frame_cbycry_t
            • camera_frame_compressedaudio_t
            • camera_frame_compressedvideo_t
            • camera_frame_gray8_t
            • camera_frame_jpeg_t
            • camera_frame_meta_t
            • camera_frame_nv12_t
            • camera_frame_rgb565_t
            • camera_frame_rgb8888_t
            • camera_frame_rgb888_t
            • camera_frame_roi_t
            • camera_frame_ycbcr420p_t
            • camera_frame_ycbycr_t
            • camera_frame_ycrycb_t
            • camera_frame_unspecified_t
            • camera_imgprop_t
            • camera_handle_t
            • camera_is_roll_format_supported()
            • camera_location_prop_t
            • camera_physprop_t
            • camera_powerdownreason_t
            • camera_region_t
            • camera_res_t
            • camera_roll_video_fmt_t
            • camera_unit_t
            • camera_vfmode_t
            • camera_videocodec_t
            • camera_video_group_id_t
            • camera_add_video_group_entry()
            • camera_can_feature()
            • camera_close()
            • camera_create_video_group()
            • camera_deregister_resource()
            • camera_destroy_video_group()
            • camera_disable_event()
            • camera_enable_status_event()
            • camera_enable_status_event()
            • camera_enable_video_event()
            • camera_enable_viewfinder_event()
            • camera_find_capable()
            • camera_force_video_keyframe()
            • camera_get_analog_video_standard()
            • camera_get_api_version()
            • camera_get_brightness()
            • camera_get_capture_property()
            • camera_get_contrast()
            • camera_get_filename()
            • camera_get_hue()
            • camera_get_location_property()
            • camera_get_physical_property()
            • camera_get_saturation()
            • camera_get_screen_buffer()
            • camera_get_sharpness()
            • camera_get_specified_vf_resolutions()
            • camera_get_specified_vf_framerates()
            • camera_get_status_details()
            • camera_get_supported_brightness()
            • camera_get_supported_cameras()
            • camera_get_supported_contrast()
            • camera_get_supported_hue()
            • camera_get_supported_saturation()
            • camera_get_supported_sharpness()
            • camera_get_supported_vf_frame_types()
            • camera_get_supported_vf_framerates()
            • camera_get_supported_vf_modes()
            • camera_get_supported_vf_resolutions()
            • camera_get_supported_vf_rotations()
            • camera_get_vf_mode()
            • camera_get_vf_property()
            • camera_get_video_buffers()
            • camera_get_video_frame_types()
            • camera_get_video_output_resolutions()
            • camera_get_video_property()
            • camera_get_video_rotations()
            • camera_get_viewfinder_buffers()
            • camera_get_zoom_limits()
            • camera_get_zoom_ratio_from_zoom_level()
            • camera_has_feature()
            • camera_init_video_encoder()
            • camera_is_audiocodec_supported()
            • camera_is_create_window_supported()
            • camera_is_videocodec_supported()
            • camera_open()
            • camera_register_resource()
            • camera_remove_video_group_entry()
            • camera_return_buffer()
            • camera_roll_available_video()
            • camera_roll_close_video()
            • camera_roll_get_path()
            • camera_roll_open_video()
            • camera_roll_set_path()
            • camera_roll_set_filename_suffix()
            • camera_set_analog_video_standard()
            • camera_set_brightness()
            • camera_set_capture_property()
            • camera_set_contrast()
            • camera_set_filename()
            • camera_set_hue()
            • camera_set_saturation()
            • camera_set_sharpness()
            • camera_set_vf_mode()
            • camera_set_vf_property()
            • camera_set_video_filesize_warning()
            • camera_set_video_filesize_limit()
            • camera_set_video_property()
            • camera_start_encode()
            • camera_start_video()
            • camera_start_video_group()
            • camera_start_viewfinder()
            • camera_stop_encode()
            • camera_stop_video()
            • camera_stop_video_group()
            • camera_stop_viewfinder()
          • camera_encoder.h
            • camera_get_supported_videoencoder_parameter_values()
            • camera_private_set_videoencoder_parameter()
            • camera_private_get_videoencoder_parameter()
            • camera_get_videoencoder_parameter()
            • camera_set_videoencoder_parameter()
          • camera_h264avc.h
            • camera_h264avc_entropycoding_t
            • camera_h264avc_level_t
            • camera_h264avc_parameters_t
            • camera_h264avc_profile_t
            • camera_h264avc_ratecontrol_t
            • camera_h264avc_slicetype_t
          • camera_3a.h
            • camera_3a_t
            • camera_exposuremode_t
            • camera_focusmode_t
            • camera_focusstate_t
            • camera_whitebalancemode_t
            • camera_get_3a_lock_modes()
            • camera_get_ev_offset()
            • camera_get_exposure_mode()
            • camera_get_exposure_modes()
            • camera_get_exposure_regions()
            • camera_get_focus_mode()
            • camera_get_focus_modes()
            • camera_get_focus_regions()
            • camera_get_focus_state()
            • camera_get_manual_aperture()
            • camera_get_manual_focus_step()
            • camera_get_manual_iso()
            • camera_get_manual_shutter_speed()
            • camera_get_manual_white_balance()
            • camera_get_manual_white_balance_rb_gain()
            • camera_get_supported_ev_offsets()
            • camera_get_supported_manual_aperture_values()
            • camera_get_supported_manual_iso_values()
            • camera_get_supported_manual_shutter_speeds()
            • camera_get_supported_manual_white_balance_values()
            • camera_get_supported_manual_white_balance_rb_gain()
            • camera_get_whitebalance_mode()
            • camera_get_whitebalance_modes()
            • camera_get_whitebalance_regions()
            • camera_set_3a_lock()
            • camera_set_ev_offset()
            • camera_set_exposure_mode()
            • camera_set_exposure_regions()
            • camera_set_manual_aperture()
            • camera_set_manual_focus_step()
            • camera_set_manual_iso()
            • camera_set_manual_shutter_speed()
            • camera_set_manual_white_balance()
            • camera_set_manual_white_balance_rb_gain()
            • camera_set_whitebalance_mode()
            • camera_set_whitebalance_regions()
          • external_camera_api.h
            • camera_buffer_list_t
            • camera_preview_frame_flags_t
            • camera_preview_params_t
            • camera_vf_framerate_min_max_index_t
            • camera_external_camera_t
            • close_external_camera_func_t
            • deinit_camera_func_t
            • init_camera_func_t
            • get_framerate_func_t
            • get_preview_frame_func_t
            • get_preview_num_buffers_func_t
            • get_supported_vf_framerates_func_t
            • get_supported_vf_frametypes_func_t
            • get_supported_vf_resolutions_func_t
            • get_time_func_t
            • open_external_camera_func_t
            • parse_config_func_t
            • set_framerate_func_t
            • start_preview_func_t
            • stop_preview_func_t
      • Sensor Developer's Guide
        • Sensor Library Overview
        • Opening and closing a connection to a sensor unit
        • Starting and stopping a sensor unit
        • Opening and closing a connection to an interim data unit
        • Starting an interim data unit
        • Accessing sensor data and status
          • Using callback mode
          • Using event mode
        • Publishing interim data
        • Subscribing to interim data
        • Recording data from a sensor
        • Querying sensor information
        • Using external clocks
        • Using external sensor drivers
        • Sensor Library Reference
          • sensor_api.h
            • Definitions in sensor_api.h
            • sensor_access_mode_t
            • sensor_buffer_t
            • sensor_close()
            • sensor_coord_system_t
            • sensor_data_callback_t
            • sensor_devstatus_t
            • sensor_disable_data_callback()
            • sensor_disable_event()
            • sensor_disable_status_callback()
            • sensor_enable_event()
            • sensor_error_t
            • sensor_event_t
            • sensor_eventkey_t
            • sensor_eventmode_t
            • sensor_feed_input_metadata()
            • sensor_flag_radar_track_spherical_t
            • sensor_flag_radar_track_polar_t
            • sensor_flag_lidar_spherical_t
            • sensor_flag_lidar_polar_t
            • sensor_flag_lidar_point_cloud_t
            • sensor_flag_imu_format_t
            • sensor_flag_gps_format_t
            • sensor_format_data_t
            • sensor_format_info_t
            • sensor_format_t
            • sensor_format_unspecified_t
            • sensor_format_user_data_t
            • sensor_format_video_cbycry_t
            • sensor_format_video_compressed_t
            • sensor_format_video_packed_t
            • sensor_format_video_planar_t
            • sensor_format_video_roi_t
            • sensor_format_video_semiplanar_t
            • sensor_get_buffer()
            • sensor_get_location_property()
            • sensor_get_location_property_internal()
            • sensor_get_metadata_limits()
            • sensor_get_physical_property()
            • sensor_get_physical_property_internal()
            • sensor_get_screen_buffer()
            • sensor_get_status_details()
            • sensor_get_streaming_property()
            • sensor_get_streaming_property_internal()
            • sensor_get_supported_sensors()
            • sensor_get_unit()
            • sensor_gps_fix_t
            • sensor_gps_format_t
            • sensor_handle_t
            • sensor_imu_format_t
            • sensor_input_metadata_t
            • sensor_lidar_flag_t
            • sensor_lidar_point_cloud_t
            • sensor_lidar_polar_t
            • sensor_lidar_spherical_t
            • sensor_location_prop_t
            • sensor_metadata_type_t
            • sensor_metadata_limits_t
            • sensor_open()
            • sensor_physprop_t
            • sensor_playback_group_t
            • sensor_radar_track_flags_t
            • sensor_radar_track_polar_t
            • sensor_radar_track_spherical_t
            • sensor_register_data_callback()
            • sensor_register_status_callback()
            • sensor_return_buffer()
            • sensor_roll_close_file()
            • sensor_roll_format_t
            • sensor_roll_get_path()
            • sensor_roll_open_file()
            • sensor_roll_set_filename_suffix()
            • sensor_roll_set_path()
            • sensor_speed_metadata_t
            • sensor_speed_metadata_limits_t
            • sensor_speed_yaw_metadata_t
            • sensor_speed_yaw_metadata_limits_t
            • sensor_start()
            • sensor_start_recording()
            • sensor_status_callback_t
            • sensor_stop()
            • sensor_stop_recording()
            • sensor_streamprop_t
            • sensor_type_t
            • sensor_unit_t
            • sensor_utc_status_t
            • sensor_utc_time_t
            • sensor_vehicle_direction_t
            • sensor_videocodec_t
            • supported_sensor_info_t
          • sensor_interim_data.h
            • sensor_interim_data_alloc()
            • sensor_interim_data_close()
            • sensor_get_supported_interim_data()
            • sensor_interim_data_open()
            • sensor_interim_data_publish()
            • sensor_interim_data_start()
            • sensor_interim_data_unit_t
            • sensor_interim_data_info_t
          • external_sensor_api.h
            • close_external_sensor_func_t
            • deinit_sensor_func_t
            • fill_format_info_func_t
            • get_buffer_requirements_func_t
            • get_metadata_limits_func_t
            • get_packet_func_t
            • get_time_func_t
            • init_sensor_func_t
            • parse_config_func_t
            • open_external_sensor_func_t
            • sensor_ext_reference_clock_t
            • sensor_external_sensor_t
            • sensor_flags_t
            • sensor_streaming_params_t
            • set_sensor_metadata_func_t
            • start_streaming_func_t
            • stop_streaming_func_t
        • Glossary
    • System Services
      • Publishing Sensor Data
        • Robot Operating System (ROS)
          • Installing ROS
          • Using ROS
          • Building and using the ROS sensor publisher node
        • Platform-independent Publish Subscribe (PiPS)
          • pips_pubsub
      • Using Mathworks MATLAB
        • Processing Sensor Data
        • Using ROS with MATLAB
      • Synchronizing Sensor Timestamps
      • Sensor (sensor)
        • Sensor configuration file
          • Example: Sensor configuration file for USB camera
          • Example: Sensor configuration file for two USB cameras
          • Example: Sensor configuration file for GigE network camera
          • Example: Sensor configuration for file camera
          • Example: Sensor configuration file for file data
          • Example: Sensor configuration file for radar
          • Example: Sensor configuration file for lidar
          • Example: Sensor configuration file for lidar (Leddartech)
          • Example: Sensor configuration file for GPS (XSens)
          • Example: Sensor configuration file for ONVIF cameras
        • Interim Data configuration file
          • Example: Interim data configuration file for an interim data sensor unit
        • Debugging
        • Security considerations
      • System Launch and Monitor (slm)
    • Working with Target Images
      • Generating a Target Image
        • Prepare the work environment
        • Generate the image
      • Image Generation and Assembly
        • The mksysimage.py process
        • Artifacts
      • Modifying Content
        • Workspace directories
        • Configuration files
        • Content files, directories, and symbolic links
        • Users and groups
        • Filesets
        • Profiles
        • Search paths
      • Configuring Partitions and Images
        • Partition and image sizes
        • Build files
      • Utility Scripts
        • mksysimage.py
        • mkworkspace.py
        • qnx*-env
      • Troubleshooting
  • QNX Multimedia Suite
    • Adding Multimedia to Target Images
      • Modifying Buildfiles to Generate Multimedia Images
        • Script for launching multimedia services
        • OS image contents
      • Location of Multimedia Support Files on Target
        • Playback
        • Management
        • Encoding and casting
        • MTP support
    • Architecture Guide
      • Multimedia Architecture
      • Device detection and information retrieval
      • Metadata synchronization and retrieval
      • Media playback
    • Dictionary Object API
      • strm_dict_t
      • strm_dict_clone()
      • strm_dict_compare()
      • strm_dict_destroy()
      • strm_dict_find_index()
      • strm_dict_find_rstr()
      • strm_dict_find_value()
      • strm_dict_index_delete()
      • strm_dict_key_delete()
      • strm_dict_key_get()
      • strm_dict_key_rstr()
      • strm_dict_new()
      • strm_dict_set()
      • strm_dict_set_index()
      • strm_dict_set_index_rstr()
      • strm_dict_set_rstr()
      • strm_dict_size()
      • strm_dict_subtract()
      • strm_dict_value_get()
      • strm_dict_value_rstr()
      • strm_string_t
      • strm_string_alloc()
      • strm_string_clone()
      • strm_string_destroy()
      • strm_string_get()
      • strm_string_make()
      • strm_string_modify()
    • io-fs-media Reference
      • iofs-pfs.so Reference
    • Metadata Provider Library
      • Metadata Provider Overview
        • Architecture of libmd
        • Metadata providers
          • MDP ratings
          • Metadata extraction
          • Included MDPs
        • Metadata-extraction sessions
        • Extracting artwork
      • Configuring Metadata Providers
        • Configuration file
      • Metadata Provider API
        • Metadata provider constants
        • mmmd_errcode_t
        • mmmd_error_info()
        • mmmd_error_info_t
        • mmmd_error_str()
        • mmmd_flags_set()
        • mmmd_flags_t
        • mmmd_get()
        • mmmd_hdl_t
        • mmmd_init()
        • mmmd_mdps_list()
        • mmmd_session_close()
        • mmmd_session_open()
        • mmmd_session_params_set()
        • mmmd_terminate()
    • Multimedia Playlist Library
      • Multimedia Playlist Library Overview
        • Architecture of Playlist Library
        • Plugins
          • Plugin ratings
          • Included plugins
        • Playlist sessions
      • Configuration File
      • Multimedia Playlist API
        • Multimedia Playlist API constants
        • mmplaylist_close()
        • mmplaylist_current_pos_get()
        • mmplaylist_current_pos_set()
        • mmplaylist_entry_next_get()
        • mmplaylist_entry_next_get_raw()
        • mmplaylist_entry_release()
        • mmplaylist_entry_t
        • mmplaylist_entry_validated_t
        • mmplaylist_error_info_t
        • mmplaylist_error_type_t
        • mmplaylist_fmt_list_t
        • mmplaylist_init()
        • mmplaylist_last_error_get()
        • mmplaylist_num_entries_get()
        • mmplaylist_open()
        • mmplaylist_pl_validation_fn_t
        • mmplaylist_plps_list()
        • mmplaylist_props_get()
        • mmplaylist_props_t
        • mmplaylist_seek_offset_t
        • mmplaylist_supported_fmts_get()
        • mmplaylist_supported_fmts_release()
        • mmplaylist_t
        • mmplaylist_terminate()
        • mmplaylist_validation_fn_t
        • mmplaylist_validation_mode_t
    • Multimedia Renderer
      • Multimedia Renderer: Capabilities and Architecture
        • Playback model
        • Abstraction layers
      • Configuring and Starting mm-renderer
        • Configuration file for mm-renderer
        • Command line for mm-renderer
      • Playing and Recording Media Content
        • Working with contexts
          • Closing context handles
        • Playing audio content
        • Playing video content
          • Managing video windows
          • Playing video with subtitles
        • Playing playlists
        • Playing autolists
        • Switching tracks within an input file
        • Recording audio content
        • Defining parameters
      • Multimedia Renderer API
        • Connection management
          • mmr_connect()
          • mmr_connection_t
          • mmr_disconnect()
          • mmr_plugin_info()
        • Context management
          • mmr_command_send()
          • mmr_context_close()
          • mmr_context_create()
          • mmr_context_destroy()
          • mmr_context_open()
          • mmr_context_parameters()
          • mmr_context_t
        • Error information
          • mm_error_code_t
          • mmr_error_info()
          • mmr_error_info_t
        • Events
          • mmr_event_arm()
          • mmr_event_data_set()
          • mmr_event_get()
          • mmr_event_t
            • data
            • details
          • mmr_event_type_t
          • mmr_event_wait()
          • mmr_metadata_split()
          • mmr_state_t
        • Input configuration
          • mmr_input_attach()
          • mmr_input_detach()
          • mmr_input_parameters()
          • mmr_track_parameters()
        • Output configuration
          • mmr_output_attach()
          • mmr_output_detach()
          • mmr_output_parameters()
        • Playback control
          • mmr_list_change()
          • mmr_play()
          • mmr_seek()
          • mmr_speed_set()
          • mmr_stop()
    • Multimedia Streaming Server
      • Multimedia Streaming Server: Overview
        • Integration with other media services
        • Starting the mm-stream server
        • mm-stream-client utility
      • Configuring the mm-stream server
        • Configuration file examples
        • Configuration syntax
      • Multimedia Streaming Server API
        • mm-stream error codes
        • mmstream_connect()
        • mmstream_disable()
        • mmstream_disconnect()
        • mmstream_enable()
        • mmstream_get_configuration()
        • mmstream_get_status_information()
        • mmstream_instance_t
        • mmstream_set_configuration()
    • Multimedia Synchronizer
      • Multimedia Synchronization Overview
        • The synchronization process
          • Synchronizer selection
          • Synchronization passes
          • Mediastore filesystem traversal
          • Database cleanup
          • Optimization of synchronization for slow devices
        • Full versus directed synchronizations
      • Setting up the Multimedia Synchronizer Environment
        • mm-sync command line
        • mmsyncclient command utility
      • Working with Synchronizations
        • Synchronizing metadata from mediastores
          • Maintaining database persistence
        • Tracking synchronization progress
        • Setting a priority folder
        • Repairing database inconsistencies
      • Configuring Mediastore Synchronization
        • Configuration file contents
          • The <Configuration> element
          • The <Configuration>/<Database> element
          • The <Configuration>/<Database>/<Synchronization> element
          • The <Configuration>/<Database>/<Synchronization>/<ConfigurableMetadata> element
          • The <Configuration>/<Database>/<Synchronization>/<MSS> element
          • The <Configuration>/<Database>/<Synchronization>/<PLSS> element
          • The <Configuration>/<Database>/<Prune> element
          • The <Configuration>/<MD> element
        • Setting synchronization thread priorities
        • Skipping files based on their names
        • Filtering synchronization by file type
        • Prescanning for nonmedia items
        • Limiting the number of items read
        • Maintaining constant IDs for updated files and playlists
      • Multimedia Synchronizer API
        • Client interface
          • Client interface constants
          • mm_sync_cancel()
          • mm_sync_connect()
          • mm_sync_control()
          • mm_sync_debug_get()
          • mm_sync_debug_set()
          • mm_sync_disconnect()
          • mm_sync_resume()
          • mm_sync_start()
          • mm_sync_status_get()
          • mm_sync_status_get_bydbname()
          • mm_sync_status_get_byid()
          • mm_sync_status_get_dbname()
          • mm_sync_suspend()
          • mmsync_hdl_t
          • mmsync_status_t
        • Configuration constants
        • Media file categories
        • Event interface
          • mm_sync_events_get()
          • mm_sync_events_register()
          • mmsync_event_queue_size_t
          • mmsync_event_t
          • mmsync_event_type_t
          • mmsync_first_fid_data_t
          • mmsync_folder_sync_data_t
          • mmsync_ms_update_data_t
          • mmsync_pl_entries_sync_data_t
          • mmsync_reset_sync_data_t
          • mmsync_sync_data_t
        • Error information
          • mmsync_sync_error_t
          • mmsync_sync_error_type_t
    • Multimedia Test Utilities
      • Role of the Multimedia Test Utilities
        • Using the test utilities
      • mmcli
        • Using mmcli instead of other components
        • mmcli command line
        • mmcli language
          • mmcli test scripts
          • mmcli interactive sessions
        • Using mmcli to play media files
      • mmrplay
        • Using mmrplay instead of mm-renderer
        • mmrplay command line
        • Playback examples
    • OpenMAX AL Additions
      • QNX OpenMAX-Compliant Media Engine
      • Decoding audio to a QNX buffer queue
      • QNX OpenMAX AL API
        • Buffer data types
          • Buffer constants
          • XADataLocator_QNXBufferQueue
          • XAQNXBuffer
          • XAQNXBufferInfo
          • XAQNXBufferItem
        • XAQNXBufferQueueSourceItf
          • XAQNXBufferQueueSourceItf constants
          • XAQNXBufferQueueSourceItf
            • Clear()
            • Enqueue()
            • GetCallbackEventsMask()
            • RegisterCallback()
            • SetBufferInfo()
            • SetCallbackEventsMask()
          • xaQNXBufferQueueSourceCallback
        • XAQNXVideoBufferQueueSourceItf
          • XAQNXVideoBufferQueueSourceItf constants
          • XAQNXVideoBufferQueueSourceItf
            • Clear()
            • Enqueue()
            • GetCallbackEventsMask()
            • RegisterCallback()
            • SetBufferInfo()
            • SetCallbackEventsMask()
          • xaQNXVideoBufferQueueSourceCallback
        • XAQNXBufferQueueSinkItf
          • XAQNXBufferQueueSinkItf constants
          • XADataFormat_QNXEncoded
            • XAAudioStreamInformation_QNX
            • XAVideoStreamInformation_QNX
          • XADataLocator_QNXScreenBufferQueue
          • XAQNXBufferQueueSinkItf
            • Done()
            • Get()
            • GetAndWait()
            • GetFormat()
        • Logging function controls
          • openmaxal_logger_cb
          • openmaxal_set_logger()
        • QNX configuration extensions
          • Audio decoding parameters
          • Audio encoding parameters
          • Network parameters
          • Screen-writer parameters
          • Subtitle parameters
          • Thread priority parameters
          • Video decoding parameters
          • Video encoding parameters
            • XAQ_VideoEncoderCropping
  • QNX Web Browser Developer's Guide
    • Browser Architecture
      • Browser engine at a glance
      • Process models
        • Application process models
        • Renderer process models
    • Getting Started
      • Install the browser onto your development host
      • Prepare your target
    • Using the Browser Command Line
    • Setting Environment Variables
    • Using Gestures
    • Viewing User Settings and About Pages
    • Using Web Inspector
    • Managing the Browser Lifecycle
    • Launching and Controlling Applications
    • JavaScript PPS API
      • API at a glance
      • ppsService.clearWatch()
      • ppsService.close()
      • ppsService.open()
      • ppsService.read()
      • ppsService.removeWatch()
      • ppsService.watch()
      • ppsService.write()
      • ppsService.writeNativeData()
      • User callbacks for the JavaScript PPS API
        • dataListener()
        • errorListener()
    • Troubleshooting
  • Typographical Conventions, Support, and Licensing
    • Typographical conventions
    • Technical support
    • Licensing information