NAME

limits.h — implementation-defined constants

SYNOPSIS

#include <limits.h>

DESCRIPTION

^[CX] Some of the functionality described on this reference page extends the ISO C standard. Applications shall define the appropriate feature test macro (see XSH 2.2 The Compilation Environment) to enable the visibility of these symbols in this header.

Many of the symbols listed here are not defined by the ISO C standard. Such symbols are not shown as CX shaded, except under the heading "Numerical Limits".

The <limits.h> header shall define macros and symbolic constants for various limits. Different categories of limits are described below, representing various limits on resources that the implementation imposes on applications. All macros and symbolic constants defined in this header shall be suitable for use in #if preprocessing directives.

Implementations may choose any appropriate value for each limit, provided it is not more restrictive than the Minimum Acceptable Values listed below. Symbolic constant names beginning with _POSIX may be found in <unistd.h>.

Applications should not assume any particular value for a limit. To achieve maximum portability, an application should not require more resource than the Minimum Acceptable Value quantity. However, an application wishing to avail itself of the full amount of a resource available on an implementation may make use of the value given in <limits.h> on that particular implementation, by using the macros and symbolic constants listed below. It should be noted, however, that many of the listed limits are not invariant, and at runtime, the value of the limit may differ from those given in this header, for the following reasons:

• The limit is pathname-dependent.

• The limit differs between the compile and runtime machines.

• The limit has been changed at runtime by an application (see setrlimit()).

For these reasons, an application can use the fpathconf(), getrlimit(), pathconf(), and sysconf() functions to determine the actual value of a limit at runtime.

The items in the list ending in _MIN give the most negative values that the mathematical types are guaranteed to be capable of representing. Numbers of a more negative value may be supported on some implementations, as indicated by the <limits.h> header on the implementation, but applications requiring such numbers are not guaranteed to be portable to all implementations. For positive constants ending in _MIN, this indicates the minimum acceptable value.

Runtime Invariant Values (Possibly Indeterminate)

A definition of one of the symbolic constants in the following list shall be omitted from <limits.h> on specific implementations where the corresponding value is equal to or greater than the stated minimum, but is unspecified.

This indetermination might depend on the amount of available memory space on a specific instance of a specific implementation. The actual value supported by a specific instance shall be provided by the sysconf() function.

{AIO_LISTIO_MAX}

Maximum number of I/O operations in a single list I/O call supported by the implementation.
Minimum Acceptable Value: {_POSIX_AIO_LISTIO_MAX}

{AIO_MAX}

Maximum number of outstanding asynchronous I/O operations supported by the implementation.
Minimum Acceptable Value: {_POSIX_AIO_MAX}

{AIO_PRIO_DELTA_MAX}

The maximum amount by which a process can decrease its asynchronous I/O priority level from its own scheduling priority.
Minimum Acceptable Value: 0

{ARG_MAX}

Maximum length of argument to the exec functions including environment data.
Minimum Acceptable Value: {_POSIX_ARG_MAX}

{ATEXIT_MAX}

Maximum number of functions that can be registered with atexit() or at_quick_exit(). The limit shall apply independently to each function.
Minimum Acceptable Value: 32

{CHILD_MAX}

Maximum number of simultaneous processes per real user ID.
Minimum Acceptable Value: {_POSIX_CHILD_MAX}

{DELAYTIMER_MAX}

Maximum number of timer expiration overruns.
Minimum Acceptable Value: {_POSIX_DELAYTIMER_MAX}

{HOST_NAME_MAX}

Maximum length of a host name (not including the terminating null) as returned from the gethostname() function.
Minimum Acceptable Value: {_POSIX_HOST_NAME_MAX}

{IOV_MAX}

^[XSI]
Maximum number of iovec structures that one process has available for use with readv() or writev().
Minimum Acceptable Value: {_XOPEN_IOV_MAX}

{LOGIN_NAME_MAX}

Maximum length of a login name.
Minimum Acceptable Value: {_POSIX_LOGIN_NAME_MAX}

{MQ_OPEN_MAX}

^[MSG]
The maximum number of open message queue descriptors a process may hold.
Minimum Acceptable Value: {_POSIX_MQ_OPEN_MAX}

{MQ_PRIO_MAX}

^[MSG]
The maximum number of message priorities supported by the implementation.
Minimum Acceptable Value: {_POSIX_MQ_PRIO_MAX}

{OPEN_MAX}

A value one greater than the maximum value that the system may assign to a newly-created file descriptor.
Minimum Acceptable Value: {_POSIX_OPEN_MAX}

{PAGESIZE}

Size in bytes of a page.
Minimum Acceptable Value: 1

{PAGE_SIZE}

^[XSI]
Equivalent to {PAGESIZE}. If either {PAGESIZE} or {PAGE_SIZE} is defined, the other is defined with the same value.

{PTHREAD_DESTRUCTOR_ITERATIONS}

Maximum number of attempts made to destroy a thread's thread-specific data values on thread exit.
Minimum Acceptable Value: {_POSIX_THREAD_DESTRUCTOR_ITERATIONS}

{PTHREAD_KEYS_MAX}

Maximum number of data keys that can be created by a process.
Minimum Acceptable Value: {_POSIX_THREAD_KEYS_MAX}

{PTHREAD_STACK_MIN}

Minimum size in bytes of thread stack storage.
Minimum Acceptable Value: 0

{PTHREAD_THREADS_MAX}

Maximum number of threads that can be created per process.
Minimum Acceptable Value: {_POSIX_THREAD_THREADS_MAX}

{RTSIG_MAX}

Maximum number of realtime signals reserved for application use in this implementation.
Minimum Acceptable Value: {_POSIX_RTSIG_MAX}

{SEM_NSEMS_MAX}

Maximum number of semaphores that a process may have.
Minimum Acceptable Value: {_POSIX_SEM_NSEMS_MAX}

{SEM_VALUE_MAX}

The maximum value a semaphore may have.
Minimum Acceptable Value: {_POSIX_SEM_VALUE_MAX}

{SIGQUEUE_MAX}

Maximum number of queued signals that a process may send and have pending at the receiver(s) at any time.
Minimum Acceptable Value: {_POSIX_SIGQUEUE_MAX}

{SS_REPL_MAX}

^[SS|TSP]
The maximum number of replenishment operations that may be simultaneously pending for a particular sporadic server scheduler.
Minimum Acceptable Value: {_POSIX_SS_REPL_MAX}

{STREAM_MAX}

Maximum number of streams that one process can have open at one time. If defined, it has the same value as {FOPEN_MAX} (see <stdio.h>).
Minimum Acceptable Value: {_POSIX_STREAM_MAX}

{SYMLOOP_MAX}

Maximum number of symbolic links that can be reliably traversed in the resolution of a pathname in the absence of a loop.
Minimum Acceptable Value: {_POSIX_SYMLOOP_MAX}

{TIMER_MAX}

Maximum number of timers per process supported by the implementation.
Minimum Acceptable Value: {_POSIX_TIMER_MAX}

{TTY_NAME_MAX}

Maximum length of terminal device name.
Minimum Acceptable Value: {_POSIX_TTY_NAME_MAX}

{TZNAME_MAX}

Maximum number of bytes supported for the name of a timezone (not of the TZ variable).
Minimum Acceptable Value: {_POSIX_TZNAME_MAX}

Note:

The length given by {TZNAME_MAX} does not include the quoting characters mentioned in 8.3 Other Environment Variables.

Pathname Variable Values

The values in the following list may be constants within an implementation or may vary from one pathname to another. For example, file systems or directories may have different characteristics.

A definition of one of the symbolic constants in the following list shall be omitted from the <limits.h> header on specific implementations where the corresponding value is equal to or greater than the stated minimum, but where the value can vary depending on the file to which it is applied. The actual value supported for a specific pathname shall be provided by the pathconf() function.

{FILESIZEBITS}

Minimum number of bits needed to represent, as a signed integer value, the maximum size of a regular file allowed in the specified directory.
Minimum Acceptable Value: 32

{LINK_MAX}

Maximum number of links to a single file.
Minimum Acceptable Value: {_POSIX_LINK_MAX}

{MAX_CANON}

Maximum number of bytes in a terminal canonical input line.
Minimum Acceptable Value: {_POSIX_MAX_CANON}

{MAX_INPUT}

Minimum number of bytes for which space is available in a terminal input queue; therefore, the maximum number of bytes a conforming application may require to be typed as input before reading them.
Minimum Acceptable Value: {_POSIX_MAX_INPUT}

{NAME_MAX}

Maximum number of bytes in a filename (not including the terminating null of a filename string).
Minimum Acceptable Value: {_POSIX_NAME_MAX}
^[XSI] Minimum Acceptable Value: {_XOPEN_NAME_MAX}

{PATH_MAX}

Maximum number of bytes the implementation stores as a pathname in a user-supplied buffer of unspecified size, including the terminating null character. Minimum number the implementation shall accept as the maximum number of bytes in a pathname.
Minimum Acceptable Value: {_POSIX_PATH_MAX}
^[XSI] Minimum Acceptable Value: {_XOPEN_PATH_MAX}

{PIPE_BUF}

Maximum number of bytes that is guaranteed to be atomic when writing to a pipe.
Minimum Acceptable Value: {_POSIX_PIPE_BUF}

{POSIX_ALLOC_SIZE_MIN}

^[ADV]
Minimum number of bytes of storage actually allocated for any portion of a file.
Minimum Acceptable Value: Not specified.

{POSIX_REC_INCR_XFER_SIZE}

^[ADV]
Recommended increment for file transfer sizes between the {POSIX_REC_MIN_XFER_SIZE} and {POSIX_REC_MAX_XFER_SIZE} values.
Minimum Acceptable Value: Not specified.

{POSIX_REC_MAX_XFER_SIZE}

^[ADV]
Maximum recommended file transfer size.
Minimum Acceptable Value: Not specified.

{POSIX_REC_MIN_XFER_SIZE}

^[ADV]
Minimum recommended file transfer size.
Minimum Acceptable Value: Not specified.

{POSIX_REC_XFER_ALIGN}

^[ADV]
Recommended file transfer buffer alignment.
Minimum Acceptable Value: Not specified.

{SYMLINK_MAX}

Maximum number of bytes in a symbolic link.
Minimum Acceptable Value: {_POSIX_SYMLINK_MAX}

{TEXTDOMAIN_MAX}

Maximum length of a text domain name, not including the terminating null byte.
Minimum Acceptable Value: {_POSIX_NAME_MAX} - 3
^[XSI] Minimum Acceptable Value: {_XOPEN_NAME_MAX} - 3

Runtime Increasable Values

The magnitude limitations in the following list shall be fixed by specific implementations. An application should assume that the value of the symbolic constant defined by <limits.h> in a specific implementation is the minimum that pertains whenever the application is run under that implementation. A specific instance of a specific implementation may increase the value relative to that supplied by <limits.h> for that implementation. The actual value supported by a specific instance shall be provided by the sysconf() function.

{BC_BASE_MAX}

Maximum obase values allowed by the bc utility.
Minimum Acceptable Value: {_POSIX2_BC_BASE_MAX}

{BC_DIM_MAX}

Maximum number of elements permitted in an array by the bc utility.
Minimum Acceptable Value: {_POSIX2_BC_DIM_MAX}

{BC_SCALE_MAX}

Maximum scale value allowed by the bc utility.
Minimum Acceptable Value: {_POSIX2_BC_SCALE_MAX}

{BC_STRING_MAX}

Maximum length of a string constant accepted by the bc utility.
Minimum Acceptable Value: {_POSIX2_BC_STRING_MAX}

{CHARCLASS_NAME_MAX}

Maximum number of bytes in a character class name.
Minimum Acceptable Value: {_POSIX2_CHARCLASS_NAME_MAX}

{COLL_WEIGHTS_MAX}

Maximum number of weights that can be assigned to an entry of the LC_COLLATE order keyword in the locale definition file; see 7. Locale.
Minimum Acceptable Value: {_POSIX2_COLL_WEIGHTS_MAX}

{EXPR_NEST_MAX}

Maximum number of expressions that can be nested within parentheses by the expr utility.
Minimum Acceptable Value: {_POSIX2_EXPR_NEST_MAX}

{LINE_MAX}

Unless otherwise noted, the maximum length, in bytes, of a utility's input line (either standard input or another file), when the utility is described as processing text files. The length includes room for the trailing <newline>.
Minimum Acceptable Value: {_POSIX2_LINE_MAX}

{NGROUPS_MAX}

Maximum number of simultaneous supplementary group IDs per process.
Minimum Acceptable Value: {_POSIX_NGROUPS_MAX}

{RE_DUP_MAX}

Maximum number of repeated occurrences of a BRE or ERE interval expression; see 9.3.6 BREs Matching Multiple Characters and 9.4.6 EREs Matching Multiple Characters.
Minimum Acceptable Value: {_POSIX_RE_DUP_MAX}

Maximum Values

The <limits.h> header shall define the following symbolic constants with the values shown. These are the most restrictive values for certain features on an implementation. A conforming implementation shall provide values no larger than these values. A conforming application shall not require a smaller value for correct operation.

{_POSIX_CLOCKRES_MIN}

The resolution of the CLOCK_REALTIME and CLOCK_MONOTONIC clocks, in nanoseconds.
Value: 20 000 000

Minimum Values

The <limits.h> header shall define the following symbolic constants with the values shown. These are the most restrictive values for certain features on an implementation conforming to this volume of POSIX.1-2024. Related symbolic constants are defined elsewhere in this volume of POSIX.1-2024 which reflect the actual implementation and which need not be as restrictive. For each of these limits, a conforming implementation shall provide a value at least this large or shall have no limit. A strictly conforming application shall not require a larger value for correct operation.

{_POSIX_AIO_LISTIO_MAX}

The number of I/O operations that can be specified in a list I/O call.
Value: 2

{_POSIX_AIO_MAX}

The number of outstanding asynchronous I/O operations.
Value: 1

{_POSIX_ARG_MAX}

Maximum length of argument to the exec functions including environment data.
Value: 4 096

{_POSIX_CHILD_MAX}

Maximum number of simultaneous processes per real user ID.
Value: 25

{_POSIX_DELAYTIMER_MAX}

The number of timer expiration overruns.
Value: 32

{_POSIX_HOST_NAME_MAX}

Maximum length of a host name (not including the terminating null) as returned from the gethostname() function.
Value: 255

{_POSIX_LINK_MAX}

Maximum number of links to a single file.
Value: 8

{_POSIX_LOGIN_NAME_MAX}

The size of the storage required for a login name, in bytes (including the terminating null).
Value: 9

{_POSIX_MAX_CANON}

Maximum number of bytes in a terminal canonical input queue.
Value: 255

{_POSIX_MAX_INPUT}

Maximum number of bytes allowed in a terminal input queue.
Value: 255

{_POSIX_MQ_OPEN_MAX}

^[MSG]
The number of message queues that can be open for a single process.
Value: 8

{_POSIX_MQ_PRIO_MAX}

^[MSG]
The maximum number of message priorities supported by the implementation.
Value: 32

{_POSIX_NAME_MAX}

Maximum number of bytes in a filename (not including the terminating null of a filename string).
Value: 14

{_POSIX_NGROUPS_MAX}

Maximum number of simultaneous supplementary group IDs per process.
Value: 8

{_POSIX_OPEN_MAX}

A value one greater than the maximum value that the system may assign to a newly-created file descriptor.
Value: 20

{_POSIX_PATH_MAX}

Minimum number the implementation shall accept as the maximum number of bytes in a pathname.
Value: 256

{_POSIX_PIPE_BUF}

Maximum number of bytes that is guaranteed to be atomic when writing to a pipe.
Value: 512

{_POSIX_RE_DUP_MAX}

Maximum number of repeated occurrences of a BRE or ERE interval expression; see 9.3.6 BREs Matching Multiple Characters and 9.4.6 EREs Matching Multiple Characters.
Value: 255

{_POSIX_RTSIG_MAX}

The number of realtime signal numbers reserved for application use.
Value: 8

{_POSIX_SEM_NSEMS_MAX}

The number of semaphores that a process may have.
Value: 256

{_POSIX_SEM_VALUE_MAX}

The maximum value a semaphore may have.
Value: 32 767

{_POSIX_SIGQUEUE_MAX}

The number of queued signals that a process may send and have pending at the receiver(s) at any time.
Value: 32

{_POSIX_SSIZE_MAX}

The value that can be stored in an object of type ssize_t.
Value: 32 767

{_POSIX_SS_REPL_MAX}

^[SS|TSP]
The number of replenishment operations that may be simultaneously pending for a particular sporadic server scheduler.
Value: 4

{_POSIX_STREAM_MAX}

The number of streams that one process can have open at one time.
Value: 8

{_POSIX_SYMLINK_MAX}

The number of bytes in a symbolic link.
Value: 255

{_POSIX_SYMLOOP_MAX}

The number of symbolic links that can be traversed in the resolution of a pathname in the absence of a loop.
Value: 8

{_POSIX_THREAD_DESTRUCTOR_ITERATIONS}

The number of attempts made to destroy a thread's thread-specific data values on thread exit.
Value: 4

{_POSIX_THREAD_KEYS_MAX}

The number of data keys per process.
Value: 128

{_POSIX_THREAD_THREADS_MAX}

The number of threads per process.
Value: 64

{_POSIX_TIMER_MAX}

The per-process number of timers.
Value: 32

{_POSIX_TTY_NAME_MAX}

The size of the storage required for a terminal device name, in bytes (including the terminating null).
Value: 9

{_POSIX_TZNAME_MAX}

Maximum number of bytes supported for the name of a timezone (not of the TZ variable).
Value: 6

Note:

The length given by {_POSIX_TZNAME_MAX} does not include the quoting characters mentioned in 8.3 Other Environment Variables.

{_POSIX2_BC_BASE_MAX}

Maximum obase values allowed by the bc utility.
Value: 99

{_POSIX2_BC_DIM_MAX}

Maximum number of elements permitted in an array by the bc utility.
Value: 2 048

{_POSIX2_BC_SCALE_MAX}

Maximum scale value allowed by the bc utility.
Value: 99

{_POSIX2_BC_STRING_MAX}

Maximum length of a string constant accepted by the bc utility.
Value: 1 000

{_POSIX2_CHARCLASS_NAME_MAX}

Maximum number of bytes in a character class name.
Value: 14

{_POSIX2_COLL_WEIGHTS_MAX}

Maximum number of weights that can be assigned to an entry of the LC_COLLATE order keyword in the locale definition file; see 7. Locale.
Value: 2

{_POSIX2_EXPR_NEST_MAX}

Maximum number of expressions that can be nested within parentheses by the expr utility.
Value: 32

{_POSIX2_LINE_MAX}

Unless otherwise noted, the maximum length, in bytes, of a utility's input line (either standard input or another file), when the utility is described as processing text files. The length includes room for the trailing <newline>.
Value: 2 048

{_POSIX2_RE_DUP_MAX}

Maximum number of repeated occurrences of a BRE or ERE interval expression; see 9.3.6 BREs Matching Multiple Characters and 9.4.6 EREs Matching Multiple Characters.
Value: 255

{_XOPEN_IOV_MAX}

^[XSI]
Maximum number of iovec structures that one process has available for use with readv() or writev().
Value: 16

{_XOPEN_NAME_MAX}

^[XSI]
Maximum number of bytes in a filename (not including the terminating null of a filename string).
Value: 255

{_XOPEN_PATH_MAX}

^[XSI]
Minimum number the implementation shall accept as the maximum number of bytes in a pathname.
Value: 1024

Numerical Limits

The <limits.h> header shall define the following macros and, except for {CHAR_BIT}, {LONG_BIT}, {MB_LEN_MAX}, and {WORD_BIT}, they shall be replaced by expressions that have the same type as would an expression that is an object of the corresponding type converted according to the integer promotions.

If an object of type char can hold negative values, the value of {CHAR_MIN} shall be the same as that of {SCHAR_MIN} and the value of {CHAR_MAX} shall be the same as that of {SCHAR_MAX}. Otherwise, the value of {CHAR_MIN} shall be 0 and the value of {CHAR_MAX} shall be the same as that of {UCHAR_MAX}.

{CHAR_BIT}

Number of bits in a type char.
^[CX] Value: 8

{CHAR_MAX}

Maximum value for an object of type char.
Value: {UCHAR_MAX} or {SCHAR_MAX}

{CHAR_MIN}

Minimum value for an object of type char.
Value: {SCHAR_MIN} or 0

{INT_MAX}

Maximum value for an object of type int.
^[CX] Minimum Acceptable Value: 2 147 483 647

{INT_MIN}

Minimum value for an object of type int.
^[CX] Maximum Acceptable Value: -2 147 483 648

{LLONG_MAX}

Maximum value for an object of type long long.
Minimum Acceptable Value: +9223372036854775807

{LLONG_MIN}

Minimum value for an object of type long long.
^[CX] Maximum Acceptable Value: -9223372036854775808

{LONG_BIT}

^[CX]
Number of bits in an object of type long.
Minimum Acceptable Value: 32

{LONG_MAX}

Maximum value for an object of type long.
Minimum Acceptable Value: +2 147 483 647

{LONG_MIN}

Minimum value for an object of type long.
^[CX] Maximum Acceptable Value: -2 147 483 648

{MB_LEN_MAX}

Maximum number of bytes in a character, for any supported locale.
Minimum Acceptable Value: 1

{SCHAR_MAX}

Maximum value for an object of type signed char.
^[CX] Value: +127

{SCHAR_MIN}

Minimum value for an object of type signed char.
^[CX] Value: -128

{SHRT_MAX}

Maximum value for an object of type short.
Minimum Acceptable Value: +32 767

{SHRT_MIN}

Minimum value for an object of type short.
^[CX] Maximum Acceptable Value: -32 768

{SSIZE_MAX}

^[CX]
Maximum value for an object of type ssize_t.
Minimum Acceptable Value: {_POSIX_SSIZE_MAX}

{UCHAR_MAX}

Maximum value for an object of type unsigned char.
^[CX] Value: 255

{UINT_MAX}

Maximum value for an object of type unsigned.
^[CX] Minimum Acceptable Value: 4 294 967 295

{ULLONG_MAX}

Maximum value for an object of type unsigned long long.
Minimum Acceptable Value: 18446744073709551615

{ULONG_MAX}

Maximum value for an object of type unsigned long.
Minimum Acceptable Value: 4 294 967 295

{USHRT_MAX}

Maximum value for an object of type unsigned short.
Minimum Acceptable Value: 65 535

{WORD_BIT}

^[CX]
Number of bits in an object of type int.
Minimum Acceptable Value: 32

Other Invariant Values

The <limits.h> header shall define the following symbolic constants:

{GETENTROPY_MAX}

The maximum value of the length argument in calls to the getentropy() function.
Minimum Acceptable Value: 256

{NL_ARGMAX}

Maximum value of n in conversion specifications using the "%n$" sequence in calls to the printf() and scanf() families of functions.
Minimum Acceptable Value: 9

{NL_LANGMAX}

^[XSI]
Maximum number of bytes in a LANG name.
Minimum Acceptable Value: 14

{NL_MSGMAX}

Maximum message number.
Minimum Acceptable Value: 32 767

{NL_SETMAX}

Maximum set number.
Minimum Acceptable Value: 255

{NL_TEXTMAX}

Maximum number of bytes in a message string.
Minimum Acceptable Value: {_POSIX2_LINE_MAX}

{NSIG_MAX}

Maximum possible return value of sysconf(_SC_NSIG). See XSH sysconf. The value of {NSIG_MAX} shall be no greater than the number of signals that the sigset_t type (see <signal.h>) is capable of representing, ignoring any restrictions imposed by sigfillset() or sigaddset().

{NZERO}

^[XSI]
Default process priority.
Minimum Acceptable Value: 20

APPLICATION USAGE

None.

RATIONALE

A request was made to reduce the value of {_POSIX_LINK_MAX} from the value of 8 specified for it in the POSIX.1-1990 standard to 2. The standard developers decided to deny this request for several reasons:

• They wanted to avoid making any changes to the standard that could break conforming applications, and the requested change could have that effect.

• The use of multiple hard links to a file cannot always be replaced with use of symbolic links. Symbolic links are semantically different from hard links in that they associate a pathname with another pathname rather than a pathname with a file. This has implications for access control, file permanence, and transparency.

• The original standard developers had considered the issue of allowing for implementations that did not in general support hard links, and decided that this would reduce consensus on the standard.

Systems that support historical versions of the development option of the ISO POSIX-2 standard retain the name {_POSIX2_RE_DUP_MAX} as an alias for {_POSIX_RE_DUP_MAX}.

{NSIG_MAX}

Some historical implementations provided compile-time constants NSIG or SIGMAX to define the maximum number of signals the implementation supported, but these values did not necessarily reflect the number of signals that could be handled using a sigset_t. With the addition of real-time signals and the desire by some applications to be able to allocate additional real-time signals at run-time, neither of these constants provided a useable, portable value. {NSIG_MAX} was added to the standard to allow applications to determine the maximum number of signals that an implementation will support based on the size of the sigset_t type (defined in <signal.h>).

{PATH_MAX}

IEEE PASC Interpretation 1003.1 #15 addressed the inconsistency in the standard with the definition of pathname and the description of {PATH_MAX}, allowing application developers to allocate either {PATH_MAX} or {PATH_MAX}+1 bytes. The inconsistency has been removed by correction to the {PATH_MAX} definition to include the null character. With this change, applications that previously allocated {PATH_MAX} bytes will continue to succeed.

{SYMLINK_MAX}

This symbol refers to space for data that is stored in the file system, as opposed to {PATH_MAX} which is the length of a name that can be passed to a function. In some existing implementations, the pathnames pointed to by symbolic links are stored in the inodes of the links, so it is important that {SYMLINK_MAX} not be constrained to be as large as {PATH_MAX}.

The maximum values for {SCHAR_MIN}, {SHRT_MIN}, {LONG_MIN} and {LLONG_MIN} differ from the ISO C standard because POSIX.1 requires two's complement representation for the corresponding integer types. The maximum value for {INT_MIN} differs both for that reason and because POSIX.1 requires that int has a width of at least 32 bits. See also the RATIONALE section for <stdint.h>.

FUTURE DIRECTIONS

None.

SEE ALSO

7. Locale, <stdint.h>, <stdio.h>, <unistd.h>

XSH 2.2 The Compilation Environment, fpathconf, getrlimit, sysconf

CHANGE HISTORY

First released in Issue 1.

Issue 5

The DESCRIPTION is updated for alignment with the POSIX Realtime Extension and the POSIX Threads Extension.

{FILESIZEBITS} is added for the Large File Summit extensions.

The minimum acceptable values for {INT_MAX}, {INT_MIN}, and {UINT_MAX} are changed to make 32-bit values the minimum requirement.

The entry is restructured to improve readability.

Issue 6

The Open Group Corrigendum U033/4 is applied. The wording is made clear for {CHAR_MIN}, {INT_MIN}, {LONG_MIN}, {SCHAR_MIN}, and {SHRT_MIN} that these are maximum acceptable values.

The following new requirements on POSIX implementations derive from alignment with the Single UNIX Specification:

• The minimum value for {CHILD_MAX} is 25. This is a FIPS requirement.

• The minimum value for {OPEN_MAX} is 20. This is a FIPS requirement.

• The minimum value for {NGROUPS_MAX} is 8. This is also a FIPS requirement.

Symbolic constants are added for {_POSIX_SYMLINK_MAX}, {_POSIX_SYMLOOP_MAX}, {_POSIX_RE_DUP_MAX}, {RE_DUP_MAX}, {SYMLOOP_MAX}, and {SYMLINK_MAX}.

The following values are added for alignment with IEEE Std 1003.1d-1999: {_POSIX_SS_REPL_MAX} {SS_REPL_MAX} {POSIX_ALLOC_SIZE_MIN} {POSIX_REC_INCR_XFER_SIZE} {POSIX_REC_MAX_XFER_SIZE} {POSIX_REC_MIN_XFER_SIZE} {POSIX_REC_XFER_ALIGN}

Reference to CLOCK_MONOTONIC is added in the description of {_POSIX_CLOCKRES_MIN} for alignment with IEEE Std 1003.1j-2000.

The constants {LLONG_MIN}, {LLONG_MAX}, and {ULLONG_MAX} are added for alignment with the ISO/IEC 9899:1999 standard.

The following values are added for alignment with IEEE Std 1003.1q-2000: {_POSIX_TRACE_EVENT_NAME_MAX} {_POSIX_TRACE_NAME_MAX} {_POSIX_TRACE_SYS_MAX} {_POSIX_TRACE_USER_EVENT_MAX} {TRACE_EVENT_NAME_MAX} {TRACE_NAME_MAX} {TRACE_SYS_MAX} {TRACE_USER_EVENT_MAX}

The new limits {_XOPEN_NAME_MAX} and {_XOPEN_PATH_MAX} are added as minimum values for {PATH_MAX} and {NAME_MAX} limits on XSI-conformant systems.

The LEGACY symbols {PASS_MAX} and {TMP_MAX} are removed.

The values for the limits {CHAR_BIT}, {SCHAR_MAX}, and {UCHAR_MAX} are now required to be 8, +127, and 255, respectively.

The value for the limit {CHAR_MAX} is now {UCHAR_MAX} or {SCHAR_MAX}.

The value for the limit {CHAR_MIN} is now {SCHAR_MIN} or zero.

IEEE Std 1003.1-2001/Cor 1-2002, item XBD/TC1/D6/10 is applied, correcting the value of {_POSIX_CHILD_MAX} from 6 to 25. This is for FIPS 151-2 alignment.

IEEE Std 1003.1-2001/Cor 2-2004, item XBD/TC2/D6/19 is applied, updating the values for {INT_MAX}, {UINT_MAX}, and {INT_MIN} to be CX extensions over the ISO C standard, and correcting {WORD_BIT} from 16 to 32.

IEEE Std 1003.1-2001/Cor 2-2004, item XBD/TC2/D6/20 is applied, removing {CHARCLASS_NAME_MAX} from the "Other Invariant Values" section (it also occurs under "Runtime Increasable Values").

Issue 7

Austin Group Interpretations 1003.1-2001 #143 and #160 are applied.

Austin Group Interpretation 1003.1-2001 #173 is applied, updating the descriptions of {TRACE_EVENT_NAME_MAX} and {TRACE_NAME_MAX} to not include the terminating null.

SD5-XBD-ERN-36 is applied, changing the description of {RE_DUP_MAX}.

SD5-XBD-ERN-90 is applied.

{NL_NMAX} is removed; it should have been removed in Issue 6.

The Trace option values are marked obsolescent.

The {ATEXIT_MAX}, {LONG_BIT}, {NL_MSGMAX}, {NL_SETMAX}, {NL_TEXTMAX}, and {WORD_BIT} values are moved from the XSI option to the Base.

The AIO_* and _POSIX_AIO_* values are moved from the Asynchronous Input and Output option to the Base.

The {_POSIX_RTSIG_MAX}, {_POSIX_SIGQUEUE_MAX}, {RTSIG_MAX}, and {SIGQUEUE_MAX} values are moved from the Realtime Signals Extension option to the Base.

Functionality relating to the Threads and Timers options is moved to the Base.

This reference page is clarified with respect to macros and symbolic constants.

POSIX.1-2008, Technical Corrigendum 1, XBD/TC1-2008/0052 [108], XBD/TC1-2008/0053 [291], XBD/TC1-2008/0054 [182,427], XBD/TC1-2008/0055 [291], XBD/TC1-2008/0056 [371], XBD/TC1-2008/0057 [291], XBD/TC1-2008/0058 [108], and XBD/TC1-2008/0059 [291] are applied.

POSIX.1-2008, Technical Corrigendum 2, XBD/TC2-2008/0061 [666] is applied.

Issue 8

Austin Group Defect 741 is applied, adding {NSIG_MAX}.

Austin Group Defect 1108 is applied, changing the maximum allowed value for all signed integer minimum limits.

Austin Group Defect 1122 is applied, adding {TEXTDOMAIN_MAX}.

Austin Group Defect 1134 is applied, adding {GETENTROPY_MAX}.

Austin Group Defect 1302 is applied, aligning this header with the ISO/IEC 9899:2018 standard.

Austin Group Defect 1330 is applied, removing obsolescent interfaces.

Austin Group Defect 1346 is applied, requiring support for Monotonic Clock.

Austin Group Defect 1446 is applied, changing the introductory paragraphs of the DESCRIPTION to include mention of setrlimit() and getrlimit().