Appendix: POSIX Conformance

This appendix describes how QNX Neutrino conforms to POSIX. It's based on the documentation submitted for the QNX Neutrino certification of compliance as a PSE52 Realtime Controller 1003.13-2003 System. This appendix includes:

• Conformance statement
• POSIX Conformance Document (PCD)
• Non-POSIX functions with POSIX-sounding names

---

To set up an environment that conforms to POSIX, do the following: Specify the -m~b option to procnto in your buildfile, to make the kernel perform POSIX error checking for arguments to mapped file operations. Set the POSIXLY_CORRECT environment variable to 1. Explicitly configure the compiler for C99 compatibility. For example, with a gcc-4.2.1 compiler: qcc -V4.2.1,gcc_ntox86 -Wc,-std=c99

---

Conformance statement

This section is based on the Conformation Statement made for the certification and includes:

• System interfaces: general attributes
• File handling
• Internationalized system interfaces
• Threads
• Realtime
• Realtime threads
• C-language compilation environment

System interfaces: general attributes

• Supported features
• Optional features
• Float, standard I/O, and limit values
• Error conditions
• Mathematical interfaces

Supported features

The required features below are supported for all system configurations.

Optional features

QNX Neutrino doesn't implement the following optional features:

• _POSIX_TRACE
• _POSIX_TRACE_EVENT_LOG
• _POSIX_TRACE_LOG
• POSIX 1003.26-2003
• POSIX.5c Interfaces (Ada Language Option)

QNX Neutrino supports the following POSIX.1 options and POSIX.13 units of functionality not mandated by the PSE52 Realtime Controller 1003.13-2003 System Product Standard:

• _POSIX_ASYNCHRONOUS_IO
• _POSIX_BARRIERS
• _POSIX_CHOWN_RESTRICTED
• _POSIX_IPV6
• _POSIX_MEMORY_PROTECTION
• _POSIX_PRIORITIZED_IO
• _POSIX_RAW_SOCKETS
• _POSIX_SAVED_IDS
• _POSIX_SPORADIC_SERVER
• _POSIX_THREAD_PROCESS_SHARED
• _POSIX_TYPED_MEMORY_OBJECTS
• POSIX_C_LANG_WIDE_CHAR
• POSIX_DEVICE_SPECIFIC
• POSIX_EVENT_MGMT
• POSIX_FIFO
• POSIX_FILE_ATTRIBUTES
• POSIX_FILE_SYSTEM_EXT
• POSIX_JOB_CONTROL
• POSIX_MULTI_PROCESS
• POSIX_NETWORKING
• POSIX_PIPE
• POSIX_REGEXP
• POSIX_RW_LOCKS
• POSIX_SHELL_FUNCS
• POSIX_SIGNAL_JUMP
• POSIX_STRING_MATCHING
• POSIX_SYMBOLIC_LINKS
• POSIX_SYSTEM_DATABASE
• POSIX_USER_GROUPS
• POSIX_WIDE_CHAR_IO
• XSI_C_LANG_SUPPORT
• XSI_DEVICE_IO
• XSI_DYNAMIC_LINKING
• XSI_FD_MGMT
• XSI_FILE_SYSTEM
• XSI_JOB_CONTROL
• XSI_JUMP
• XSI_MULTI_PROCESS
• XSI_SINGLE_PROCESS
• XSI_SYSTEM_DATABASE
• XSI_SYSTEM_LOGGING
• XSI_TIMERS

Float, standard I/O, and limit values

The values associated with the constants specified in <float.h> are as follows:

The values associated with the following constants (optionally specified in <limits.h> are as follows:

The values associated with the following numerical constants specified in the <limits.h> header file are as follows:

The values associated with the numerical constants specified in the <stdio.h> header file are as follows:

Error conditions

The following table indicates which optional errors, (denoted by “may fail” within the specification), listed in the System Interfaces Volume are detected in the circumstances specified:

Mathematical interfaces

Most implementations support IEEE floating-point format either in hardware or software. Some implementations support other formats with different exponent and mantissa accuracy. QNX Neutrino supports IEEE 754 in hardware.

The fegetexceptflag(), feraiseexcept(), fesetexecptflag(), and fetestexecptflag() functions support the following floating-point exceptions:

• FE_DIVBYZERO
• FE_INEXACT
• FE_INVALID
• FE_OVERFLOW
• FE_UNDERFLOW

The fegetround() and fesetround() functions support the following floating-point rounding directions:

• FE_DOWNWARD
• FE_TONEAREST
• FE_TOWARDZERO
• FE_UPWARD

QNX Neutrino supports a non-stop floating-point exception mode.

File handling

• Access control
• Files and directories

Access control

QNX Neutrino provides standard access control.

Files and directories

QNX Neutrino doesn't implement any additional or alternate file access control mechanisms that could cause fstat() or stat() to fail.

Internationalized system interfaces

Coded character sets

QNX Neutrino supports the following coded character sets:

• ISO 8859-1:1987
• ISO 10646-1:2000

The underlying internal codeset is ISO 8859-1:1987.

Threads

Cancellation points

The POSIX functions listed below have cancellation points that occur when a thread is executing:

For a list of all the functions (including non-POSIX ones) that are cancellation points, see the Summary of Safety Information appendix in the QNX Neutrino Library Reference.

Realtime

Prioritized I/O

QNX Neutrino supports _POSIX_PRIORITIZED_IO on regular files.

Realtime threads

• Scheduling policies
• Scheduling contention scope
• Default scheduling contention scope
• Scheduling allocation domain

Scheduling policies

The scheduling policy associated with SCHED_OTHER is SCHED_RR.

Scheduling contention scope

QNX Neutrino supports the PTHREAD_SCOPE_SYSTEM scheduling contention scope.

Default scheduling contention scope

The default scheduling contention scope is PTHREAD_SCOPE_SYSTEM.

Scheduling allocation domain

The mechanism to configure the system so that the scheduling allocation domain has size one, so that the binding of threads to scheduling allocation domains remains static is as follows:

• For a multiprocessor system, the number of processors enabled is controlled by the BSP-specific startup program.
• The -P1 command-line argument to the startup program enables only one processor, creating a scheduling allocation domain of size one.

C-language compilation environment

QNX Neutrino provides the following C-language compilation environments:

• a C-language compilation environment with 32-bit int, long, pointer, and off_t types
• a C-language compilation environment with 32-bit int, long, and pointer types, and an off_t type using at least 64 bits

QNX Neutrino doesn't provide the following C-language compilation environments:

• a C-language compilation environment with 32-bit int, and 64-bit long, pointer, and off_t types
• a C-language compilation environment with int using at least 32-bits, and long, pointer, and off_t types using at least 64 bits

The Base Definitions Volume defines these four scenarios as possible C-language compilation environment offerings, but doesn't define which corresponding execution environments are supported. QNX Neutrino supports the same execution environments as it does compilation environments.

The largest type that can be stored in type off_t is long long The standard requires that off_t be able to store any value contained in type long.

POSIX Conformance Document (PCD)

This section describes the behavior of the implementation-defined features described in IEEE 1003.1-2004 as implemented by the QNX Neutrino RTOS 6.4 operating system for the PSE52 profile specified by IEEE 1003.13-2003. The section numbers and titles below are those from the standard itself.

• Base Definitions
• System Interfaces

Base Definitions

• 3. Definitions
• 4. General Concepts
• 6. Character Set
• 7. Locale
• 8. Environment Variables
• 13. Headers

3. Definitions

3.4. Additional File Access Control Mechanism

No additional file access control mechanisms are implemented.

3.12. Alternate File Access Control Mechanism

No alternative file access control mechanisms are implemented.

3.19. Appropriate Privileges

Appropriate privileges are provided by executing with a user ID equal to 0 (root).

3.97. Clock Tick

For CPU targets operating at less than 40 MHz, the default is 100 clock ticks per second.

For CPU targets operating at greater than 40 MHz, the default is 1000 clock ticks per second.

You can set the system clock's resolution by using the QNX-specific ClockPeriod() kernel call using the CLOCK_REALTIME clock.

3.159. Extended Security Controls

Extended security controls aren't implemented.

3.387. System Trace Event

The Trace (TRC) option isn't supported.

3.409. Trace Generation Version

The Trace (TRC) option isn't supported.

4. General Concepts

4.3. Extended Security Controls

No extended security controls are implemented.

4.9. Measurement of Execution Time

Process and thread execution time is measured by updating the running time on each clock tick. The running time of the active thread and process on each processor is incremented by the duration of the system clock tick.

The CPU time consumed by interrupt handlers is charged to the thread and process that is currently active on the CPU.

The CPU time consumed by kernel calls is charged to the thread and process performing the kernel call.

The CPU time consumed by system services not implemented by the kernel is charged to the thread in the server process that implements the system service.

4.11. Pathname Resolution

A pathname that begins with two successive slashes is treated as if it begins with a single slash.

4.14. Seconds Since the Epoch

The value of seconds since the Epoch is aligned with the current actual time by a 64-bit offset value that represents the offset, in nanoseconds, from the Epoch to the system boot time.

This offset value is initialised by the platform specific initialisation code within the board support package, for example, by reading RTC hardware if present.

A clock_settime() call using the CLOCK_REALTIME clock will set this offset to specified absolute time minus the current monotonic time since booting.

The offset from the Epoch can also be modified by the QNX specific ClockAdjust() kernel call. This applies a delta to the offset value on each system clock tick, for a specified number of ticks to perform a gradual adjustment of the offset value.

4.17. Tracing

The Trace (TRC) option isn't implemented.

4.18. Treatment of Error Conditions for Mathematical Functions

4.18.1 Domain Error

The return value for a domain error is NaN.

4.18.3 Range Error

• 4.18.3.2 Result Underflows:
  • The return value for a result that underflows is 0.0.
  • errno is set to ERANGE when (math_errhandling & MATH_ERRNO) is non-zero.
  • The "underflow" floating point exception is raised when (math_errhandling & MATH_ERREXCEPT) is non-zero.

6. Character Set

6.4. Character Set Description File

Applications can provide additional character set description files.

For single byte characters, the decimal, octal or hexadecimal constants are represented as a char value.

For multibyte characters, the decimal, octal or hexadecimal constants are represented as a wchar_t value, whose type is an unsigned 32-bit integer.

7. Locale

7.1. General

When the value of a locale environment variable doesn't begin with a slash, the value is interpreted as the name of a locale with the set of currently defined locales:

• The values C and POSIX identify the built-in POSIX locale.
• The value C-TRADITIONAL identifies the built-in locale that's equivalent to the C locale, except that it supports only single-byte characters.
• Any other value identifies a locale with that name within the set of currently defined locales.

7.2. POSIX Locale

The default locale is the POSIX locale.

7.3. Locale Definition

No additional locale categories beyond those specified are supported.

The values of the characters in the portable character set are those defined by the ASCII and ISO/IEC 8859-1 character sets.

8. Environment Variables

8.2. Internationalization Variables

There are no additional semantics for the following environment variables:

• LC_COLLATE
• LC_CTYPE
• LC_MESSAGES
• LC_MONETARY
• LC_NUMERIC
• LC_TIME

The default locale is the POSIX locale.

There are no additional criteria for determining valid locales.

8.3. Other Environment Variables

When the first character of the TZ variable is a colon, the colon is ignored and the following characters are handled as a normal time zone specification. For more information, see “Setting the time zone” in the Configuring Your Environment chapter of the QNX Neutrino User's Guide.

13. Headers

<fenv.h>

The default state of the FENV_ACCESS pragma is off. Note that gcc doesn't currently support this pragma.

<float.h>

The accuracy of of floating point operations and the library functions in <math.h> and <complex.h> is unknown.

The default rounding mode for floating-point addition (FLT_ROUNDS) is 1. No additional values beyond those specified are implemented.

The evaluation format mode (FLT_EVAL_METHOD) is -1 (indeterminable). There are no additional implementation-defined values beyond those specified.

The values of floating-point constants are as follows:

<limits.h>

The limit values in <limits.h> are implemented as follows:

<math.h>

If FLT_EVAL_METHOD has a value other than 0, 1 or 2, the type definitions for float_t and double_t are float and double, respectively.

No implementation-defined floating-point classification macros are defined.

The default state of the FP_CONTRACT pragma is off. Note that gcc doesn't currently support this pragma.

<signal.h>

Realtime signal behavior is supported for signals outside of the range SIGRTMIN through SIGRTMAX.

The following additional signals are defined in <signal.h>:

• SIGIOT
• SIGEMT
• SIGDEADLK
• SIGCLD (same signal number as SIGCHLD)
• SIGPWR
• SIGWINCH
• SIGIO (same signal number as SIGPOLL)

For more information, see “Summary of signals” in the Interprocess Communication (IPC) chapter of the System Architecture guide.

<stdint.h>

The limits for specified-width integer types are as follows:

The values of other integer types are as follows:

<sys/stat.h>

There are no additional implementation-defined bits that can be ORed into S_IRWXU, S_IRWXG, and S_IRWXO.

<time.h>

The maximum possible clock jump for the system-wide monotonic clock is the same as the system clock resolution:

• for CPU targets operating at less than 40 MHz, this is 10 milliseconds
• for CPU targets operating at more than 40 Mhz, this is 1 millisecond

The system clock resolution can be set using the QNX-specific ClockPeriod() kernel call using the CLOCK_REALTIME clock.

System Interfaces

• 2.3. Error Numbers
• 2.4. Signal Concepts
• 2.5. Standard I/O Streams
• 2.8. Realtime
• 2.11. Tracing
• 3. System Interfaces

2.3. Error Numbers

The <errno.h> header file defines the following additional error numbers:

See also errno in the QNX Neutrino Library Reference.

2.4. Signal Concepts

If a subsequent occurrence of a pending signal is generated, the signal is delivered or accepted more than once if a handler has been set for the signal with SA_SIGINFO set.

A SIGBUS signal may be generated for a misaligned memory access:

• a 16-bit access using a pointer that isn't 16-bit aligned
• a 32-bit access using a pointer that isn't 32-bit aligned

2.4.2. Realtime Signal Generation and Delivery

The signal mask for a thread created to invoke the sigev_notify_function function (see sigevent) inherits the signal mask of the thread to which the signal is delivered.

2.4.3. Signal Actions

For SIGILL signals generated by the execution of an illegal instruction, the si_code field may contain one of the following:

For SIGSEGV signals generated by an invalid memory access, the si_code field may contain one of the following:

For SIGBUS signals generated by an invalid memory access, the si_code field may contain one of the following:

For SIGTRAP signals generated by breakpoint or other debug traps, the si_code field may contain one of the following:

For SIGCLD signals generated during process termination or job control related events, the si_code field may contain one of the following:

For SIGFPE signals generated for floating-point exceptions, the si_code field may contain one of the following:

2.5. Standard I/O Streams

When a file is opened with append mode, the file position indicator is initially positioned at the beginning of the file.

The characteristics of unbuffered and fully buffered streams are supported.

Fully buffered streams use all bytes in the allocated buffer.

Line buffered streams are supported for all file types.

2.5.1. Interaction of File Descriptors and Standard I/O Streams

Input is seen exactly once provided the application follows the rules specified.

2.8. Realtime

2.8.3. Memory Management

Memory locking guarantees fixed translation between virtual addresses (as seen by the process) and physical addresses.

2.8.4. Processing Scheduling

No scheduling policies beyond those specified are implemented.

The resolution of the execution time clock for the SCHED_SPORADIC policy is the same as the system clock resolution:

• for CPU targets executing at less than 40 MHz, this is 10 milliseconds
• for CPU targets executing at more than 40 MHz, this is 1 millisecond

The system clock resolution can be set using the QNX-specific ClockPeriod() kernel call using the CLOCK_REALTIME clock.

The SCHED_OTHER policy behaves identically to the SCHED_RR policy.

2.8.5. Clocks and Timers

The maximum possible clock jump for the system-wide monotonic clock is the same as the system clock resolution:

• for CPU targets operating at less than 40 MHz, this is 10 milliseconds
• for CPU targets operating at more than 40 Mhz, this is 1 millisecond

The system clock resolution can be set using the QNX-specific ClockPeriod() kernel call using the CLOCK_REALTIME clock.

The resolution for time services based on a supported clock is the same as the resolution of that clock.

2.9.4. Thread Scheduling

The default scheduling contention scope is PTHREAD_SCOPE_SYSTEM.

The PTHREAD_SCOPE_PROCESS contention scope isn't supported.

The default value of the inheritsched attribute is PTHREAD_INHERIT_SCHED. This means the default schedpolicy and schedparam attributes are inherited from the parent thread.

The PTHREAD_SCOPE_PROCESS scheduling contention scope isn't supported.

The system determines the scheduling allocation domain size on a per-thread basis using the concept of a “runmask” that indicates the processors on which the thread can be scheduled.

The default runmask for a thread is set to allow scheduling on all processors.

You can set a thread's runmask in the following ways:

• You can use the QNX-specific slay utility to set the runmask for all threads in a specified process, or for a single specified thread in a process.
• You can use the QNX-specific ThreadCtl() kernel call to set the runmask for the calling thread.

For threads with scheduling allocation domains of size greater than one, the rules defined for SCHED_FIFO, SCHED_RR, and SCHED_SPORADIC are followed such that if the thread becomes the head of its thread list, the thread may become the runnable thread on any processor in its scheduling allocation domain if it has a higher priority than the running thread on one of those processors.

This may in turn result in the preempted thread's becoming the running thread on a different processor if that thread also has a scheduling allocation domain of size greater than one and its priority is higher than the running thread on one of the other processors in its scheduling allocation domain.

If a thread's scheduling allocation domain has a size greater than one, a runnable thread selects the processor on which it becomes the runnable thread as follows:

1. For each processor in the thread's scheduling allocation domain, find the processor whose running thread has the lowest priority that is less than this thread.
2. If the search identifies only one processor, select that processor and make the thread the running thread on that processor.
3. If the search identifies more than one processor, select the processor on which the thread previously ran before becoming a blocked thread.
4. If the thread hadn't run on any of the selected processors before becoming a blocked thread, select the first processor that was found in the search.

For more information, see the Multicore Processing User's Guide.

No scheduling policies beyond SCHED_OTHER, SCHED_FIFO, SCHED_RR and SCHED_SPORADIC are implemented.

2.11. Tracing

The Trace (TRC) option isn't supported.

3. System Interfaces

acos(), acosf(), and acosl()

For finite values not in the range [-1,1], acos(), acosf(), and acosl() return NaN. The return value for +/-Inf is NaN.

acosh(), acoshf(), acoshl()

For finite values of x < 1, acosh(), acoshf(), and acoshl() return NaN. The return value when x is -Inf is NaN.

asin(), asinf(), asinl()

For finite values not in the range [-1,1], asin(), asinf(), and asinl() return NaN. The return value for +/-Inf is NaN.

atan(), atanf(), atanhl()

For finite values of |x| > 1, atan(), atanf(), and atanhl() return NaN. The return value for +/-Inf is NaN.

calloc()

The calloc() function returns a unique pointer when the size of space requested is zero.

clock_getres(), clock_settime()

The resolution of all clocks, as returned by clock_getres(), is the same as the system clock resolution:

• for CPU targets executing at less than 40 MHz, the resolution is 10 milliseconds
• for CPU targets executing at more than 40 MHz, the resolution is 1 millisecond

The system clock resolution can be set using the QNX-specific ClockPeriod() kernel call using the CLOCK_REALTIME clock.

The clock_settime() function is supported only for the CLOCK_REALTIME clock.

Appropriate privileges for setting the CLOCK_REALTIME clock are obtained by executing with a user ID equal to 0.

cos(), cosf(), cosl()

When x is +/-Inf, cos(), cosf(), and cosl() return NaN.

erfc(), erfcf(), erfcl()

For a correct value that would cause an underflow, erfc(), erfcf(), and erfcl() return 0.0.

exp(), expf(), expl()

For a correct value that would cause an underflow, exp(), expf(), and expl() return 0.0.

exp2(), exp2f(), exp2l()

For a correct value that would cause an underflow, exp2(), exp2f(), and exp2l() return 0.0.

fclose()

The fclose() may give an EIO error under the following circumstances:

• An I/O error occurred when writing cached data to the underlying media.
• An I/O error occurred when updating metadata on the underlying media.
• The filesystem resides on a removable media device, and the media has been forcibly removed.

fcntl()

The following addition values for the cmd argument to fcntl() are defined:

fdim(), fdimf(), fdiml()

When x − y is positive and underflows, fdim(), fdimf(), and fdiml() return 0.0.

fegetexceptflag()

The representation of the floating-point status flags used by fegetexceptflag() depends on the CPU architecture. For x86 processors, the following values are used:

feraiseexcept()

The feraiseexcept() function doesn't raise the inexact floating-point exception whenever it raises the overflow or underflow floating point exception.

fflush()

The fflush() may return an EIO error under the following circumstances:

• an I/O error when writing cached data to the underlying media
• an I/O error when updating metadata on the underlying media
• the filesystem resides on a removable media device, and the media has been forcibly removed

fgetc()

The fgetc() function may return an EIO error if the filesystem resides on a removable media device, and the media has been forcibly removed.

fma(), fmaf(), fmal()

When x multiplied by y is an exact infinity, and z is also an infinity with the opposite sign, fma(), fmaf(), and fmal() return NaN.

The return value when one of x and y is infinite, the other is zero, and z isn't a NaN is NaN.

fmod(), fmodf(), fmodl()

For a correct value that would cause an underflow, fmod(), fmodf(), and fmodl() return 0.0. The return value when y is zero is NaN. The return value when x is infinite is NaN.

fpclassify()

There are no additional classification categories for the fpclassify() function, other than NaN, infinite, normal, subnormal and zero.

fprintf()

For the fprintf() function, the low-order digit rounding for numbers in double format is round-to-nearest.

For double arguments, the styles for representing infinity and NaN are as follows:

The value of a pointer for the p conversion specifier is converted to a sequence of hexadecimal digits. The sequence is padded with leading zeroes if the 0 flag is specified.

fputc()

The fputc() function may return an EIO error if the filesystem resides on a removable media device, and the media has been forcibly removed.

freopen()

The following mode changes are permitted for freopen():

• w to a
• a to w
• r+ to r
• r+ to w
• r+ to a
• r+ to w+
• r+ to a+
• w+ to r
• w+ to w
• w+ to a
• w+ to r+
• w+ to w+
• w+ to a+
• a+ to r
• a+ to w
• a+ to a
• a+ to r+
• a+ to w+

fscanf()

A - in the scanlist for fscanf() that isn't the first character, nor the second where the first character is a ^, nor the last character, defines a range of characters to be matched. This range consists of characters numerically greater than or equal to the character before the -, and numerically less than or equal to the character after the -.

The p conversion specifier matches a sequence of hexadecimal digits. If the sequence contains more than 8 digits, the conversion is performed only on the last 8 digits in the sequence.

fseeko()

The fseeko() function returns EOF on devices that are incapable of seeking. It sets errno to either ESPIPE or ENOSYS, depending on the implementation of the device or filesystem.

An EIO error may be returned if the filesystem resides on a removable media device, and the media has been forcibly removed.

fsetpos()

The fsetpos() function returns EOF on devices that are incapable of seeking. It sets errno to either ESPIPE or ENOSYS, depending on the implementation of the device or filesystem.

An EIO error may be returned if the filesystem resides on a removable media device, and the media has been forcibly removed.

fstat()

No additional or alternative file access control mechanisms are provided for the fstat() function.

fsync()

The fsync() function causes all buffered data for the file to be written to the storage device; the file modification times are updated.

kill()

No extended security controls are provided for the kill() function.

ldexp(), ldexpf(), ldexpl()

For a correct value that would cause an underflow, ldexp(), ldexpf(), and ldexpl() return 0.0.

log(), logf(), logl()

For finite values of x less than zero, log(), logf(), and logl() return NaN. The return value when x is -Inf is NaN.

log10(), log10f(), log10l()

For finite values of x less than zero, log10(), log10f(), and log10l() return NaN. The return value when x is -Inf is NaN.

log1p(), log1pf(), log1pl()

For finite values of x less than -1, log1p(), log1pf(), and log1pl() return NaN. The return value when x is -Inf is NaN.

log2(), log2f(), log2l()

For finite values of x less than 0, log2(), log2f(), and log2l() return NaN. The return value when x is -Inf is NaN.

lseek()

The lseek() function returns -1 on devices that are incapable of seeking. It sets errno to either ESPIPE or ENOSYS, depending on the implementation of the device or filesystem.

malloc()

The malloc() function returns a unique pointer when the size of space requested is zero.

mkdir()

In the mkdir() function, the following bits, in addition to file permission bits, behave as follows:

S_ISGID

Files and directories created within this directory have the group ID of this directory instead of the group ID of the process creating the file or directory.

S_ISVTX

Files can be removed or renamed only if one or more of the following is true:

• The user owns the file.
• The user owns the directory.
• The file is writable by the user.
• The user is privileged.

mlock()

There's no limit on the amount of memory that a process may lock by calling mlock(), other than the amount of physical memory in the system.

mlockall(), munlockall()

Locking implied by MCL_FUTURE in a call to mlockall() or munlockall() is performed during an mmap() operation. If this exceeds the amount of available physical memory, that mmap() call fails with an ENOMEM error.

There is no limit on the amount of memory that a process may lock other than the amount of physical memory in the system.

mmap()

The return value for a successful mmap() call is a pointer whose value is a valid address in the process virtual address space. This establishes translations from the virtual address range to the physical memory addresses corresponding to the specified section of the memory object.

The return value for an unsuccessful mmap() call is MAP_FAILED, whose value is ((void *) -1).

The implementation supports MAP_FIXED.

When MAP_FIXED isn't set, addr is used as a hint to derive the virtual address returned:

• If no mapping currently exists in the range [addr, addr + len), addr is used.
• Otherwise, the system searches for the first available unused area of the process's address space that's large enough to hold the specified size.

There are no limits on the number of memory regions that can be mapped other than the limit imposed on the process's virtual address space.

mq_open()

When the name argument doesn't begin with a slash, mq_open() creates or opens a message queue with the specified name relative to the current working directory of the calling process. This name appears in the file system and is visible to other functions that take pathnames as arguments.

When the name begins with a slash, the message queue name isn't visible in the filesystem.

Additional slash characters other than the leading slash simply form the name used to identify the message queue:

• If there's a leading slash, this forms a name that doesn't appear in the filesystem.
• If there's no leading slash, this forms a pathname relative to the current directory and the name appears in the filesystem. The intermediate directories correspond to each slash-separated component of name, and have only read and search permissions.

Any bits other file permission bits in the mode argument are ignored.

When mq_open() is called with mq_attr set to NULL, the default message queue attributes are set as follows:

mq_receive()

If the value of msg_len passed to mq_receive() is greater than SSIZE_MAX, the message is stored in the supplied buffer, and the length of the selected message is returned.

mq_setattr()

The mq_setattr() function doesn't OR any implementation-defined flags with O_NONBLOCK for the mq_flags member.

open()

The O_TRUNC flag for open() has no effect on file types other than regular files.

posix_trace_*()

The Trace (TRC) option isn't supported, so QNX Neutrino doesn't support the following:

• posix_trace_attr_getlogsize()
• posix_trace_attr_getmaxdatasize()
• posix_trace_attr_getlogstreamsize()
• posix_trace_create_withlog()
• posix_trace_flush,posix_trace_shutdown()
• posix_trace_eventset()
• posix_trace_getnext_event()
• posix_trace_trygetnext_event()
• posix_trace_timedgetnext_event()

pow(), powf(), powl()

For finite values of x less than 0 and finite non-integer values of y, pow(), powf(), and powl() return NaN. The return value for a correct value that would cause underflow is 0.0.

pthread_attr_destroy()

The QNX Neutrino implementation of pthread_attr_destroy() doesn't set an invalid value.

pthread_condattr_destroy(), pthread_condattr_init()

There are no additional implementation-defined condition variable attributes for pthread_condattr_destroy() and pthread_condattr_init() to destroy or initialize, and no additional functions for getting or setting such attributes.

pthread_getschedparam(), pthread_setschedparam()

The SCHED_OTHER policy is implemented identically to the SCHED_RR policy. The pthread_getschedparam() and pthread_setschedparam() functions affect only the priority scheduling parameter.

The pthread_setschedparam() function supports dynamically changing the policy to SCHED_SPORADIC.

pthread_rwlock_rdlock()

The Thread Execution Scheduling (TPS) option is supported, so a thread that calls pthread_rwlock_rdlock() doesn't acquire the lock if a writer holds the lock or there are writers blocked on the lock. The maximum number of simultaneous read locks is 2147483647.

pthread_rwlock_unlock()

The TPS option is supported, so if threads executing with the SCHED_FIFO, SCHED_RR, or SCHED_SPORADIC are waiting on a lock, they acquire the lock in priority order when a call to pthread_rwlock_unlock() means that the lock becomes available. For threads of equal priority, write locks take precedence over read locks.

pthread_rwlockattr_getpshared(), pthread_rwlockattr_setpshared()

There are no additional implementation-defined read-write lock attributes, so there are no functions in addition to pthread_rwlockattr_getpshared() and pthread_rwlockattr_setpshared() for getting or setting such attributes.

read()

For special device files, a subsequent read() request after the end-of-file condition has been reached results in 0 bytes being read.

When the value of nbyte is greater than SSIZE_MAX, the number of bytes read is limited to LONG_MAX − offset, where offset is the current file offset.

An EIO error may be returned if the filesystem resides on a removable media device, and the media has been forcibly removed.

remainder(), remainderf(), remainderl()

When x is infinite or y is zero and the other is non-NaN, remainder(), remainderf(), and remainderl() return NaN.

remquo(), remquof(), remquol()

For remquo(), remquof(), and remquol(), the value of n used to determine the magnitude of the result is 31. The return value when x is +/-Inf or y is zero and the other argument is non-NaN is NaN.

rint(), rintf(), rintl()

The current rounding mode used is determined by invoking the fegetround() function in the implementation of the rint(), rintf(), and rintl() functions.

scalbln(), scalblnf(), scalblnl(), scalbn(), scalbnf(), scalbnl()

When a correct value would cause an underflow, scalbln(), scalblnf(), scalblnl(), scalbn(), scalbnf(), and scalbnl() return 0.0.

sem_open()

When the name argument to sem_open() doesn't begin with a slash character, the semaphore is created with a name that consists of the specified name prepended with the current working directory.

Additional slash characters other than the leading slash character aren't interpreted, and the specified name, including these slash characters, is used to identify the semaphore.

setlocale()

Valid strings for the locale argument to setlocale() are:

• "C"
• "POSIX"
• "C-TRADITIONAL"
• ""
• the name of a locale in the set of currently defined locales

When the locale string is set to "", the default native environment is the POSIX locale.

shm_open()

When the name argument doesn't begin with a slash, shm_open() creates or opens a shared memory object with the specified name relative to the current working directory of the calling process. This name appears in the file system and is visible to other functions that take pathnames as arguments.

Additional slash characters in the name cause the shared memory object be created with a pathname equivalent to name:

• If there's an initial slash, this specifies an absolute pathname.
• If there's no initial slash, this specifies a pathname relative to the current working directory.

The intermediate directories corresponding to each slash-separated component have only read and search permissions.

sigaction()

When SA_SIGINFO isn't set in the sa_flags member of the sigaction structure passed to sigaction(), the disposition of subsequent occurrences of a pending signal aren't affected.

signal()

If you've used signal() to register a function to handle a signal, then when the signal occurs, it's blocked.

SIGBUS may be generated for a misaligned memory access:

• a 16-bit access using a pointer that isn't 16-bit aligned
• a 32-bit access using a pointer that isn't 32-bit aligned

sigwait()

When there are multiple pending instances of a single signal number prior to a call to sigwait(), all but one of the pending instances remain pending after a successful return of the sigwait() function.

sin(), sinf(), sinl()

If x is +/-Inf, sin(), sinf(), and sinl() return NaN.

sqrt(), sqrtf(), sqrtl()

For finite values of x < -0, sqrt(), sqrtf(), and sqrtl() return NaN. The return value when x is -Inf is NaN.

stat()

No additional or alternative file access control mechanisms are provided, so there are no implementation-defined reasons for stat() to fail.

strtod(), strtof(), strtold()

The strtod(), strtof(), and strtold() functions don't interpret an n-char sequence, and the result is equivalent to specifying nan or NAN without the n-char sequence.

No other subject sequences beyond those specified are accepted.

strtol(), strtoll()

The strtol() and strtoll() don't accept any other subject sequences beyond those specified.

strtoul(), strtoull()

The strtoul() and strtoull() functions don't accept any other subject sequences beyond those specified by the standard.

tan(), tanf(), tanl()

For a correct value that would cause an underflow, tan(), tanf(), and tanl() return 0.0. The return value when x is +/-Inf is NaN.

tgamma(), tgammaf(), tgammal()

When x is a negative integer, tgamma(), tgammaf(), and tgammal() return NaN. The return value when x is -Inf is NaN.

timer_create()

The timer_create() function fails if the clock ID corresponds to the CPU-time clock of a process or thread different from the process or thread invoking the function.

tmpnam()

After TMP_MAX names have been generated, tmpnam() reuses names that have been previously generated:

• If a file with the new name doesn't exist, the new name is returned.
• If a file with the new name does exist, a default pathname with a basename of 000000 is returned.

tzset()

If the TZ environment variable isn't set when you call tzset(), the value of the implementation-defined _CS_TIMEZONE confstr() string is used as the default time zone.

If no _CS_TIMEZONE string is set, the default timezone UTC0 is used.

uname()

The communications network for the nodename reported by uname() is primarily a TCP/IP network.

If the networking server has QNX Neutrino Transparent Distributed Processing (“Qnet”) enabled, the nodename is used to identify the node within the network of nodes that are able to communicate via the Qnet protocol.

Each member of the utsname structure is a 257-byte array:

---

The official product name of the OS is “QNX Neutrino”, not simply “QNX”.

---

write()

When the value of nbyte is greater than SSIZE_MAX, the number of bytes written by the write() function is limited to LONG_MAX − offset, where offset is the current file offset.

An EIO error may be returned if the filesystem resides on a removable media device, and the media has been forcibly removed.

Non-POSIX functions with POSIX-sounding names

The following functions have POSIX-sounding names, but aren't part of a POSIX standard. Some have a suffix of “_np”, which stands for for “non-POSIX.”

For more information about classification, see the Full Safety Information appendix in the HTML version of the QNX Neutrino Library Reference, as well as the entries for individual functions.