Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.qnx.com/developers/docs/7.0.0/ below:

Loading, please wait ...

• 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