For the purposes of IEEE Std 1003.1-2001, the terms and definitions given in Definitions apply.

Note:

No shading to denote extensions or options occurs in this chapter. Where the terms and definitions given in this chapter are
used elsewhere in text related to extensions and options, they are shaded as appropriate.

An implementation-defined mechanism that is layered upon the access control mechanisms defined here, but which do not grant
permissions beyond those defined herein, although they may further restrict them.

To cause the user's terminal to give some audible or visual indication that an error or some other event has occurred. When the
standard output is directed to a terminal device, the method for alerting the terminal user is unspecified. When the standard
output is not directed to a terminal device, the alert is accomplished by writing the <alert> to standard output (unless the
utility description indicates that the use of standard output produces undefined results in this case).

A character that in the output stream should cause a terminal to alert its user via a visual or audible notification. It is the
character designated by '\a' in the C language. It is unspecified whether this character is the exact sequence transmitted
to an output device by the system to accomplish the alert function.

An implementation-defined mechanism that is independent of the access control mechanisms defined herein, and which if enabled on
a file may either restrict or extend the permissions of a given user. IEEE Std 1003.1-2001 defines when such mechanisms
can be enabled and when they are disabled.

Memory associated with a thread, established upon request by the implementation for a thread, separate from the thread signal
stack, in which signal handlers responding to signals sent to that thread may be executed.

Protocol-specific, local system-specific, or optional information. The information can be both local or end-to-end significant,
header information, part of a data portion, protocol-specific, and implementation or system-specific.

The characters '<' (left-angle-bracket) and '>' (right-angle-bracket). When used in the phrase
"enclosed in angle brackets", the symbol '<' immediately precedes the object to be enclosed, and '>'
immediately follows it. When describing these characters in the portable character set, the names <less-than-sign> and
<greater-than-sign> are used.

An implementation-defined means of associating privileges with a process with regard to the function calls, function call
options, and the commands that need special privileges. There may be zero or more such means. These means (or lack thereof) are
described in the conformance document.

Note:

Function calls are defined in the System Interfaces volume of IEEE Std 1003.1-2001, and commands are defined in the
Shell and Utilities volume of IEEE Std 1003.1-2001.

In the shell command language, a parameter passed to a utility as the equivalent of a single string in the argv array
created by one of the exec functions. An argument is one of the options, option-arguments, or operands following the command
name.

A signal that is not attributable to a specific thread. Examples are signals sent via kill(), signals sent from the keyboard, and signals delivered to process groups. Being
asynchronous is a property of how the signal was generated and not a property of the signal number. All signals may be generated
asynchronously.

Note:

The kill() function is defined in detail in the System Interfaces volume of
IEEE Std 1003.1-2001.

A character that, in the output stream, should cause printing (or displaying) to occur one column position previous to the
position about to be printed. If the position about to be printed is at the beginning of the current line, the behavior is
unspecified. It is the character designated by '\b' in the C language. It is unspecified whether this character is the
exact sequence transmitted to an output device by the system to accomplish the backspace function. The <backspace> defined
here is not necessarily the ERASE special character.

One of the set of characters defined in the Latin alphabet. In Western European languages other than English, these characters
are commonly used with diacritical marks (accents, cedilla, and so on) to extend the range of characters in an alphabet.

The batch server in a batch system to which a batch job should be sent for processing.

Acceptance of a batch job at a batch destination is the responsibility of a receiving batch server. A batch destination may
consist of a batch server-specific portion, a network-wide portion, or both. The batch server-specific portion is referred to as
the "batch queue". The network-wide portion is referred to as a "batch server name".

Once created, a batch job may be executing or pending execution. A batch job that is executing has an associated session leader
(a process) that initiates and monitors the computational tasks of the batch job.

An attribute of a batch job which determines the types of requests that the batch server that manages the batch job can accept
for the batch job. Valid states include QUEUED, RUNNING, HELD, WAITING, EXITING, and TRANSITING.

A manageable object that represents a set of batch jobs and is managed by a single batch server.

Note:

A set of batch jobs is called a batch queue largely for historical reasons. Jobs are selected from the batch queue for
execution based on attributes such as priority, resource requirements, and hold conditions.

A file that refers to a device. A block special file is normally distinguished from a character special file by providing access
to the device in a manner such that the hardware characteristics of the device are not visible.

The characters '{' (left brace) and '}' (right brace), also known as curly braces. When used in the phrase
"enclosed in (curly) braces" the symbol '{' immediately precedes the object to be enclosed, and '}' immediately
follows it. When describing these characters in the portable character set, the names <left-brace> and <right-brace>
are used.

The characters '[' (left-bracket) and ']' (right-bracket), also known as square brackets. When used in the
phrase "enclosed in (square) brackets" the symbol '[' immediately precedes the object to be enclosed, and ']'
immediately follows it. When describing these characters in the portable character set, the names <left-square-bracket> and
<right-square-bracket> are used.

A utility implemented within a shell. The utilities referred to as special built-ins have special qualities. Unless qualified,
the term "built-in" includes the special built-in utilities. Regular built-ins are not required to be actually built into the
shell on the implementation, but they do have special command-search qualities.

An individually addressable unit of data storage that is exactly an octet, used to store a character or a portion of a
character; see also Character. A byte is composed of a contiguous sequence of 8 bits. The least
significant bit is called the "low-order" bit; the most significant is called the "high-order" bit.

Note:

The definition of byte from the ISO C standard is broader than the above and might accommodate hardware architectures with
different sized addressable units than octets.

A character that in the output stream indicates that printing should start at the beginning of the same physical line in which
the <carriage-return> occurred. It is the character designated by '\r' in the C language. It is unspecified whether
this character is the exact sequence transmitted to an output device by the system to accomplish the movement to the beginning of
the line.

A sequence of one or more bytes representing a single graphic symbol or control code.

Note:

This term corresponds to the ISO C standard term multi-byte character, where a single-byte character is a special case of
a multi-byte character. Unlike the usage in the ISO C standard, character here has no necessary relationship with
storage space, and byte is used when storage space is discussed.

See the definition of the portable character set in Portable Character Set for a
further explanation of the graphical representations of (abstract) characters, as opposed to character encodings.

A named set of characters sharing an attribute associated with the name of the class. The classes and the characters that they
contain are dependent on the value of the LC_CTYPE category in the current locale.

The result of applying rules that map a numeric code value to each element of a character set. An element of a character set may
be related to more than one numeric code value but the reverse is not true. However, for state-dependent encodings the relationship
between numeric code values and elements of a character set may be further controlled by state information. The character set may
contain fewer elements than the total number of possible numeric code values; that is, some code values may be unassigned.

The smallest entity used to determine the logical ordering of character or wide-character strings; see also Collation Sequence. A collating element consists of either a single character, or two or more characters
collating as a single entity. The value of the LC_COLLATE category in the current locale determines the current set of
collating elements.

The logical ordering of character or wide-character strings according to defined precedence rules. These rules identify a
collation sequence between the collating elements, and such additional rules that can be used to order strings consisting of
multiple collating elements.

The relative order of collating elements as determined by the setting of the LC_COLLATE category in the current locale.
The collation sequence is used for sorting and is determined from the collating weights assigned to each collating element. In the
absence of weights, the collation sequence is the order in which collating elements are specified between order_start and
order_end keywords in the LC_COLLATE category.

Multi-level sorting is accomplished by assigning elements one or more collation weights, up to the limit {COLL_WEIGHTS_MAX}. On
each level, elements may be given the same weight (at the primary level, called an equivalence class; see also Equivalence Class) or be omitted from the sequence. Strings that collate equally using the first assigned weight
(primary ordering) are then compared using the next assigned weight (secondary ordering), and so on.

It is assumed that each character in a character set has an intrinsic column width independent of any output device. Each
printable character in the portable character set has a column width of one. The standard utilities, when used as described in
IEEE Std 1003.1-2001, assume that all characters have integral column widths. The column width of a character is not
necessarily related to the internal representation of the character (numbers of bits or bytes).

The column position of a character in a line is defined as one plus the sum of the column widths of the preceding characters in
the line. Column positions are numbered starting from 1.

An interface that interprets sequences of text input as commands. It may operate on an input stream or it may interactively
prompt and read commands from a terminal. It is possible for applications to invoke utilities through a number of interfaces, which
are collectively considered to act as command interpreters. The most obvious of these are the sh utility and the system() function, although popen() and the various forms of exec may also be considered to behave as
interpreters.

Note:

The sh utility is defined in detail in the Shell and Utilities volume of
IEEE Std 1003.1-2001.

The system(), popen(), and
exec functions are defined in detail in the System Interfaces volume of IEEE Std 1003.1-2001.

A synchronization object which allows a thread to suspend execution, repeatedly, until some associated predicate becomes true. A
thread whose execution is suspended on a condition variable is said to be blocked on the condition variable.

The session leader that established the connection to the controlling terminal. If the terminal subsequently ceases to be a
controlling terminal for this session, the session leader ceases to be the controlling process.

A terminal that is associated with a session. Each session may have at most one controlling terminal associated with it, and a
controlling terminal is associated with exactly one session. Certain input sequences from the controlling terminal cause signals to
be sent to all processes in the process group associated with the controlling terminal.

The time spent executing a process or thread, including the time spent executing system services on behalf of that process or
thread. If the Threads option is supported, then the value of the CPU-time clock for a process is implementation-defined. With this
definition the sum of all the execution times of all the threads in a process might not equal the process execution time, even in a
single-threaded process, because implementations may differ in how they account for time during context switches or for other
reasons.

Drivers are traditionally written to be a part of the system implementation, although they are frequently written separately
from the writing of the implementation. A driver may contain processor-specific code, and therefore be non-portable.

The ability of a software component to process 8-bit characters without modifying or utilizing any part of the character in a
way that is inconsistent with the rules of the current coded character set.

A directory that contains, at most, directory entries for dot and dot-dot, and has exactly one link to it, in dot-dot. No other
links to the directory may exist. It is unspecified whether an implementation can ever consider the root directory to be empty.

A regular file acceptable as a new process image file by the equivalent of the exec family of functions, and thus usable
as one form of a utility. The standard utilities described as compilers can produce executable files, but other unspecified methods
of producing executable files may also be provided. The internal format of an executable file is unspecified, but a conforming
application cannot assume an executable file is a text file.

Implementation-defined security controls allowed by the file access permission and appropriate privilege (see also Appropriate Privileges) mechanisms, through which an implementation can support different security policies from
those described in IEEE Std 1003.1-2001.

In the shell command language, a unit of text that is the result of parameter expansion, arithmetic expansion, command
substitution, or field splitting. During command processing, the resulting fields are used as the command name and its arguments.

An object that can be written to, or read from, or both. A file has certain attributes, including access permissions and type.
File types include regular file, character special file, block special file, FIFO special file, symbolic link, socket, and
directory. Other types of files may be supported by the implementation.

A per-process unique, non-negative integer used to identify an open file for the purpose of file access. The value of a file
descriptor is from zero to {OPEN_MAX}. A process can have no more than {OPEN_MAX} file descriptors open simultaneously. File
descriptors may also be used to implement message catalog descriptors and directory streams; see also Open
File Description.

The property of a file indicating access permissions for a process related to the group identification of a process. A process
is in the file group class of a file if the process is not in the file owner class and if the effective group ID or one of the
supplementary group IDs of the process matches the group ID associated with the file. Other members of the class may be
implementation-defined.

A name consisting of 1 to {NAME_MAX} bytes used to name a file. The characters composing the name may be selected from the set
of all character values excluding the slash character and the null byte. The filenames dot and dot-dot have special meaning. A
filename is sometimes referred to as a "pathname component".

Filenames should be constructed from the portable filename character set because the use of other characters can be confusing or
ambiguous in certain contexts. (For example, the use of a colon ( ':' ) in a pathname could cause ambiguity if that
pathname were included in a PATH definition.)

The byte position in the file where the next I/O operation begins. Each open file description associated with a regular file,
block special file, or directory has a file offset. A character special file that does not refer to a terminal device may have a
file offset. There is no file offset specified for a pipe or FIFO.

The property of a file indicating access permissions for a process related to the user and group identification of a process. A
process is in the file other class of a file if the process is not in the file owner class or file group class.

The property of a file indicating access permissions for a process related to the user identification of a process. A process is
in the file owner class of a file if the effective user ID of the process matches the user ID of the file.

Information about a file that is used, along with other information, to determine whether a process has read, write, or
execute/search permission to a file. The bits are divided into three parts: owner, group, and other. Each part is used with the
corresponding file class of processes. These bits are contained in the file mode.

A command whose operation consists of reading data from standard input or a list of input files and writing data to standard
output. Typically, its function is to perform some transformation on the data stream.

A process group whose member processes have certain privileges, denied to processes in background process groups, when accessing
their controlling terminal. Each session that has established a connection with a controlling terminal has at most one process
group of the session as the foreground process group of that controlling terminal.

A character that in the output stream indicates that printing should start on the next page of an output device. It is the
character designated by '\f' in the C language. If the <form-feed> is not the first character of an output line, the
result is unspecified. It is unspecified whether this character is the exact sequence transmitted to an output device by the system
to accomplish the movement to the next page.

A non-negative integer, which can be contained in an object of type gid_t, that is used to identify a group of system
users. Each system user is a member of at least one group. When the identity of a group is associated with a process, a group ID
value is referred to as a real group ID, an effective group ID, one of the supplementary group IDs, or a saved set-group-ID.

A string that is used to identify a group; see also Group Database. To be portable across conforming
systems, the value is composed of characters from the portable filename character set. The hyphen should not be used as the first
character of a portable group name.

The relationship between two directory entries that represent the same file; see also Directory Entry (or
Link). The result of an execution of the ln utility (without the -s option)
or the link() function. This term is contrasted against symbolic link; see also Symbolic Link.

The arrangement of bytes in any integer type when using a specific machine architecture.

Note:

Two common methods of byte ordering are big-endian and little-endian. Big-endian is a format for storage of binary data in
which the most significant byte is placed first, with the rest in descending order. Little-endian is a format for storage or
transmission of binary data in which the least significant byte is placed first, with the rest in ascending order. See also Host and Network Byte Orders.

An application that contains at least one call to the trace point function posix_trace_event(). Each process of an instrumented application has a mapping of
trace event names to trace event type identifiers. This mapping is used by the trace stream that is created for that process.

A facility that allows users selectively to stop (suspend) the execution of processes and continue (resume) their execution at a
later point. The user typically employs this facility via the interactive interface jointly supplied by the terminal I/O driver and
a command interpreter.

To create an association between a page-aligned range of the address space of a process and some memory object, such that a
reference to an address in that range of the address space results in a reference to the associated memory object. The mapped
memory object is not necessarily memory-resident.

A state applying to a sequence of zero or more characters when the characters in the sequence correspond to a sequence of
characters defined by a basic regular expression or extended regular expression pattern.

In the context of programmatic message passing, information that can be transferred between processes or threads by being added
to and removed from a message queue. A message consists of a fixed-size message buffer.

In the context of providing natural language messages to the user, a file or storage area containing program messages, command
prompts, and responses to prompts for a particular native language, territory, and codeset.

In the context of providing natural language messages to the user, a per-process unique value used to identify an open message
catalog. A message catalog descriptor may be implemented using a file descriptor.

A sequence of two or more characters that collate as an entity. For example, in some coded character sets, an accented character
is represented by a non-spacing accent, followed by the letter. Other examples are the Spanish elements ch and
ll.

A synchronization object used to allow multiple threads to serialize their access to shared data. The name derives from the
capability it provides; namely, mutual-exclusion. The thread that has locked a mutex becomes its owner and remains the owner until
that same thread unlocks the mutex.

A STREAMS-based file descriptor that is attached to a name in the file system name space. All subsequent operations on the named
STREAM act on the STREAM that was associated with the file descriptor until the name is disassociated from the STREAM.

The way of representing any integer type such that, when transmitted over a network via a network endpoint, the int type
is transmitted as an appropriate number of octets with the most significant octet first, followed by any other octets in descending
order of significance.

A character that in the output stream indicates that printing should start at the beginning of the next line. It is the
character designated by '\n' in the C language. It is unspecified whether this character is the exact sequence transmitted
to an output device by the system to accomplish the movement to the next line.

A number used as advice to the system to alter process scheduling. Numerically smaller values give a process additional
preference when scheduling a process to run. Numerically larger values reduce the preference and make a process less likely to run.
Typically, a process with a smaller nice value runs to completion more quickly than an equivalent process with a higher nice value.
The symbol {NZERO} specifies the default nice value of the system.

A property of an open file description that causes function calls involving it to return without delay when it is detected that
the requested action associated with the function call cannot be completed without unknown delay.

Note:

The exact semantics are dependent on the type of file associated with the open file description. For data reads from devices
such as ttys and FIFOs, this property causes the read to return immediately when no data was available. Similarly, for writes, it
causes the call to return immediately when the thread would otherwise be delayed in the write operation; for example, because no
space was available. For networking, it causes functions not to await protocol events (for example, acknowledgements) to occur. See
also the System Interfaces volume of IEEE Std 1003.1-2001, Section
2.10.7, Socket I/O Mode.

A character, such as a character representing a diacritical mark in the ISO/IEC 6937:2001 standard coded character set,
which is used in combination with other characters to form composite graphic symbols.

The value that is obtained by converting the number 0 into a pointer; for example, (void *) 0. The C language
guarantees that this value does not match that of any legitimate pointer, so it is used by many functions that return pointers to
indicate an error.

A regular file containing the output of a compiler, formatted as input to a linkage editor for linking with other object files
into an executable form. The methods of linking are unspecified and may involve the dynamic linking of objects at runtime. The
internal format of an object file is unspecified, but a conforming application cannot assume an object file is a text file.

A record of how a process or group of processes is accessing a file. Each file descriptor refers to exactly one open file
description, but an open file description can be referred to by more than one file descriptor. The file offset, file status, and
file access modes are attributes of an open file description.

Physical memory and memory objects can be mapped into the address space of a process on page boundaries and in integral
multiples of pages. Process address space can be locked into memory (made memory-resident) on page boundaries and in integral
multiples of pages.

In the shell command language, an entity that stores values. There are three types of parameters: variables (named parameters),
positional parameters, and special parameters. Parameter expansion is accomplished by introducing a parameter with the '$'
character.

In the C language, an object declared as part of a function declaration or definition that acquires a value on entry to the
function, or an identifier following the macro name in a function-like macro definition.

An attribute of a new process identifying the parent of the process. The parent process ID of a process is the process ID of its
creator, for the lifetime of the creator. After the creator's lifetime has ended, the parent process ID is the process ID of an
implementation-defined system process.

A character string that is used to identify a file. In the context of IEEE Std 1003.1-2001, a pathname consists of, at
most, {PATH_MAX} bytes, including the terminating null byte. It has an optional beginning slash, followed by zero or more filenames
separated by slashes. A pathname may optionally contain one or more trailing slashes. Multiple successive slashes are considered to
be the same as one slash.

An object accessed by one of the pair of file descriptors created by the pipe()
function. Once created, the file descriptors can be used to manipulate it, and it behaves identically to a FIFO special file when
accessed in this way. It has no name in the file hierarchy.

Note:

The pipe() function is defined in detail in the System Interfaces volume of
IEEE Std 1003.1-2001.

The queuing order applied to normal priority STREAMS messages. High priority STREAMS messages are not grouped by priority bands.
The only differentiation made by the STREAMS mechanism is between zero and non-zero bands, but specific protocol modules may
differentiate between priority bands.

A condition in which a thread that is not voluntarily suspended (waiting for an event or time delay) is not running while a
lower priority thread is running. Such blocking of the higher priority thread is often caused by contention for a shared
resource.

An address space with one or more threads executing within that address space, and the required system resources for those
threads.

Note:

Many of the system resources defined by IEEE Std 1003.1-2001 are shared among all of the threads within a process.
These include the process ID, the parent process ID, process group ID, session membership, real, effective, and saved set-user-ID,
real, effective, and saved set-group-ID, supplementary group IDs, current working directory, root directory, file mode creation
mask, and file descriptors.

A collection of processes that permits the signaling of related processes. Each process in the system is a member of a process
group that is identified by a process group ID. A newly created process joins the process group of its creator.

A period of time that begins when a process group is created and ends when the last remaining process in the group leaves the
group, due either to the end of the last process' lifetime or to the last remaining process calling the setsid() or setpgid() functions.

Note:

The setsid() and setpgid()
functions are defined in detail in the System Interfaces volume of IEEE Std 1003.1-2001.

The period of time that begins when a process is created and ends when its process ID is returned to the system. After a process
is created by fork(), posix_spawn(),
posix_spawnp(), or vfork(), it is
considered active. At least one thread of control and address space exist until it terminates. It then enters an inactive state
where certain resources may be returned to the system, although some resources, such as the process ID, are still in use. When
another process executes a wait(), waitid(), or waitpid() function for an
inactive process, the remaining resources are returned to the system. The last resource to be returned to the system is the process
ID. At this time, the lifetime of the process ends.

A performance improvement facility to bind application programs into the high-performance random access memory of a computer
system. This avoids potential latencies introduced by the operating system in storing parts of a program that were not recently
referenced on secondary memory devices.

Normal termination occurs by a return from main(), when requested with the exit(), _exit(), or _Exit() functions; or when the last thread in the process terminates by returning from its
start function, by calling the pthread_exit() function, or through
cancellation.

Abnormal termination occurs when requested by the abort() function or when some
signals are received.

A prepared sequence of instructions to the system to accomplish a defined task. The term "program" in
IEEE Std 1003.1-2001 encompasses applications written in the Shell Command Language, complex utility input languages (for
example, awk, lex, sed, and so on), and high-level languages.

A facility that provides an interface that is identical to the terminal subsystem. A pseudo-terminal is composed of two devices:
the "master device" and a "slave device". The slave device provides processes with an interface that is identical to the
terminal interface, although there need not be hardware behind that interface. Anything written on the master device is presented
to the slave as an input and anything written on the slave device is presented as an input on the master side.

Multiple readers, single writer (read-write) locks allow many threads to have simultaneous read-only access to data while
allowing only one thread to have write access at any given time. They are typically used to protect data that is read-only more
frequently than it is changed.

Read-write locks can be used to synchronize threads in the current process and other processes if they are allocated in memory
that is writable and shared among the cooperating processes and have been initialized for this behavior.

A function whose effect, when called by two or more threads, is guaranteed to be as if the threads each executed the function
one after another in an undefined order, even if the actual execution is interleaved.

The process of connecting symbolic references with symbolic definitions. For example, when a program calls a function, the
associated call instruction transfers control to the proper destination address at execution.

A property of a thread that defines the set of threads against which that thread competes for resources.

For example, in a scheduling decision, threads sharing scheduling contention scope compete for processor resources. In
IEEE Std 1003.1-2001, a thread has scheduling contention scope of either PTHREAD_SCOPE_SYSTEM or
PTHREAD_SCOPE_PROCESS.

A collection of process groups established for job control purposes. Each process group is a member of a session. A process is
considered to be a member of the session of which its process group is a member. A newly created process joins the session of its
creator. A process can alter its session membership; see setsid(). There can be
multiple process groups in the same session.

Note:

The setsid() function is defined in detail in the System Interfaces volume of
IEEE Std 1003.1-2001.

A file containing shell commands. If the file is made executable, it can be executed by specifying its name as a simple command.
Execution of a shell script causes a shell to execute the commands within the script. Alternatively, a shell can be requested to
execute the commands in a shell script by specifying the name of the shell script as the operand to the sh utility.

A mechanism by which a process or thread may be notified of, or affected by, an event occurring in the system. Examples of such
events include hardware exceptions and specific actions by processes. The term signal is also used to refer to the event
itself.

An address associated with a socket or remote endpoint, including an address family identifier and addressing information
specific to that address family. The address may include multiple parts, such as a network address associated with a host system
and an identifier for a specific endpoint.

The character defined in the portable character set as <space>. The <space> is a member of the space
character class of the current locale, but represents the single character, and not all of the possible members of the class; see
also White Space.

Appearing in lowercase, a stream is a file access object that allows access to an ordered sequence of characters, as described
by the ISO C standard. Such objects can be created by the fdopen(), fopen(), or popen() functions, and are associated
with a file descriptor. A stream provides the additional services of user-selectable buffering and formatted input and output; see
also STREAM.

Appearing in uppercase, STREAM refers to a full-duplex connection between a process and an open device or pseudo-device. It
optionally includes one or more intermediate processing modules that are interposed between the process end of the STREAM and the
device driver (or pseudo-device driver) end of the STREAM; see also Stream.

Note:

For further information, see the System Interfaces volume of IEEE Std 1003.1-2001, Section 2.6, STREAMS.

A driver with multiple STREAMS connected to it. Multiplexing with STREAMS connected above is referred to as N-to-1, or "upper
multiplexing". Multiplexing with STREAMS connected below is referred to as 1-to-N or "lower multiplexing".

For a write operation to a regular file, when the system ensures that all data written is readable on any subsequent open of the
file (even one that follows a system or power failure) in the absence of a failure of the physical storage medium.

For a read operation, when an image of the data on the physical storage medium is available to the requesting process.

An attribute of a process used in determining file access permissions. A process has up to {NGROUPS_MAX} supplementary group IDs
in addition to the effective group ID. The supplementary group IDs of a process are set to the supplementary group IDs of the
parent process when the process is created.

A job that has received a SIGSTOP, SIGTSTP, SIGTTIN, or SIGTTOU signal that caused the process group to stop. A suspended job is
a background job, but a background job is not necessarily a suspended job.

A type of file with the property that when the file is encountered during pathname resolution, a string stored by the file is
used to modify the pathname resolution. The stored string has a length of {SYMLINK_MAX} bytes or fewer.

A determinism and robustness improvement mechanism to enhance the data input and output mechanisms, so that an application can
ensure that the data being manipulated is physically present on secondary mass storage devices.

For read, when the operation has been completed or diagnosed if unsuccessful. The read is complete only when an image of the
data has been successfully transferred to the requesting process. If there were any pending write requests affecting the data to be
read at the time that the synchronized read operation was requested, these write requests are successfully transferred prior to
reading the data.

For write, when the operation has been completed or diagnosed if unsuccessful. The write is complete only when the data
specified in the write request is successfully transferred and all file system information required to retrieve the data is
successfully transferred.

File attributes that are not necessary for data retrieval (access time, modification time, status change time) need not be
successfully transferred prior to returning to the calling process.

Identical to a synchronized I/O data integrity completion with the addition that all file attributes relative to the I/O
operation (including access time, modification time, status change time) are successfully transferred prior to returning to the
calling process.

For example, a thread executing an illegal instruction or touching invalid memory causes a synchronously-generated signal. Being
synchronous is a property of how the signal was generated and not a property of the signal number.

An interval initiated by an unspecified circumstance that causes all processes (possibly other than special system processes) to
be terminated in an undefined manner, after which any changes to the state and contents of files created or written to by an
application prior to the interval are undefined, except as required elsewhere in IEEE Std 1003.1-2001.

An unspecified sequence of events that may result in the loss of transitory data; that is, data that is not saved in permanent
storage. For example, message queues, shared memory, semaphores, and processes.

A trace event that is generated by the implementation, in response either to a system-initiated action or to an
application-requested action, except for a call to posix_trace_event().
When supported by the implementation, a system-initiated action generates a process-independent system trace event and an
application-requested action generates a process-dependent system trace event. For a system trace event not defined by
IEEE Std 1003.1-2001, the associated trace event type identifier is derived from the implementation-defined name for this
trace event, and the associated data is of implementation-defined content and length.

A character that in the output stream indicates that printing or displaying should start at the next horizontal tabulation
position on the current line. It is the character designated by '\t' in the C language. If the current position is at or
past the last defined horizontal tabulation position, the behavior is unspecified. It is unspecified whether this character is the
exact sequence transmitted to an output device by the system to accomplish the tabulation.

A roughly rectangular block of characters capable of being laid out side-by-side next to other text columns on an output page or
terminal screen. The widths of text columns are measured in column positions.

A file that contains characters organized into one or more lines. The lines do not contain NUL characters and none can exceed
{LINE_MAX} bytes in length, including the <newline>. Although IEEE Std 1003.1-2001 does not distinguish between
text files and binary files (see the ISO C standard), many utilities only produce predictable or meaningful output when
operating on text files. The standard utilities that have such restrictions always specify "text files" in their STDIN or INPUT
FILES sections.

A single flow of control within a process. Each thread has its own thread ID, scheduling priority and policy, errno
value, thread-specific key/value bindings, and the required system resources to support a flow of control. Anything whose address
may be determined by a thread, including but not limited to static variables, storage obtained via malloc(), directly addressable storage obtained through implementation-defined functions, and
automatic variables, are accessible to all threads in the same process.

Note:

The malloc() function is defined in detail in the System Interfaces volume of
IEEE Std 1003.1-2001.

A function that may be safely invoked concurrently by multiple threads. Each function defined in the System Interfaces volume of
IEEE Std 1003.1-2001 is thread-safe unless explicitly stated otherwise. Examples are any "pure" function, a function
which holds a mutex locked while it is accessing static storage, or objects shared among threads.

A process global handle of type pthread_key_t which is used for naming thread-specific data.

Although the same key value may be used by different threads, the values bound to the key by pthread_setspecific() and accessed by pthread_getspecific() are maintained on a per-thread basis and persist for the
life of the calling thread.

A status that describes the state of an active trace stream. The tracing status of a trace stream can be retrieved from the
trace stream attributes. An active trace stream can be in one of two states: running or suspended.

A combination of a typed memory pool and a typed memory port. The entire contents of the pool are accessible from the port. The
typed memory object is identified through a name that belongs to the typed memory name space.

A non-negative integer that is used to identify a system user. When the identity of a user is associated with a process, a user
ID value is referred to as a real user ID, an effective user ID, or a saved set-user-ID.

A string that is used to identify a user; see also User Database. To be portable across systems
conforming to IEEE Std 1003.1-2001, the value is composed of characters from the portable filename character set. The
hyphen should not be used as the first character of a portable user name.

A character that in the output stream indicates that printing should start at the next vertical tabulation position. It is the
character designated by '\v' in the C language. If the current position is at or past the last defined vertical tabulation
position, the behavior is unspecified. It is unspecified whether this character is the exact sequence transmitted to an output
device by the system to accomplish the tabulation.

In the shell command language, a token other than an operator. In some cases a word is also a portion of a word token: in the
various forms of parameter expansion, such as ${name-word}, and variable assignment, such as name=word,
the word is the portion of the token depicted by word. The concept of a word is no longer applicable following word
expansions-only fields remain.

To output characters to a file, such as standard output or standard error. Unless otherwise stated, standard output is the
default output destination for all uses of the term "write''; see the distinction between display and write in Display.

The X/Open System Interface is the core application programming interface for C and sh
programming for systems conforming to the Single UNIX Specification. This is a superset of the mandatory requirements for
conformance to IEEE Std 1003.1-2001.