The 2003 Edition of IEEE Std 1003.1 (known as "POSIX.1") has been jointly developed by the IEEE and The Open Group. It is simultaneously an IEEE Standard, an ISO/IEC Standard, and an Open Group Technical Standard.
The developers of this standard represent a cross section of hardware manufacturers, vendors of operating systems and other software development tools, software designers, consultants, academics, authors, applications programmers, and others.
Conceptually, this standard describes a set of fundamental services needed for the efficient construction of application programs. Access to these services has been provided by defining an interface, using the C programming language, a command interpreter, and common utility programs that establish standard semantics and syntax. Since this interface enables application writers to write portable applications-it was developed with that goal in mind-it has been designated POSIX,1 an acronym for Portable Operating System Interface.
Although originated to refer to the original IEEE Std 1003.1-1988, the name POSIX more correctly refers to a family of related standards: IEEE Std 1003.n and the parts of ISO/IEC 9945. In earlier editions of the IEEE standard, the term POSIX was used as a synonym for IEEE Std 1003.1-1988. A preferred term, POSIX.1, emerged. This maintained the advantages of readability of the symbol ``POSIX'' without being ambiguous with the POSIX family of standards.
The intended audience for this standard is all persons concerned with an industry-wide standard operating system based on the UNIX system. This includes at least four groups of people:
Persons buying hardware and software systems
Persons managing companies that are deciding on future corporate computing directions
Persons implementing operating systems, and especially
Persons developing applications where portability is an objective
Several principles guided the development of this standard:
The basic goal was to promote portability of application programs across UNIX system environments by developing a clear, consistent, and unambiguous standard for the interface specification of a portable operating system based on the UNIX system documentation. This standard codifies the common, existing definition of the UNIX system.
Interface, Not Implementation
This standard defines an interface, not an implementation. No distinction is made between library functions and system calls;
both are referred to as functions. No details of the implementation of any function are given (although historical practice is
sometimes indicated in the RATIONALE section). Symbolic names are given for constants (such as signals and error numbers) rather
Source, Not Object, Portability
This standard has been written so that a program written and translated for execution on one conforming implementation may also be translated for execution on another conforming implementation. This standard does not guarantee that executable (object or binary) code will execute under a different conforming implementation than that for which it was translated, even if the underlying hardware is identical.
The C Language
The system interfaces and header definitions are written in terms of the standard C language as specified in the ISO C standard.
No Superuser, No System Administration
There was no intention to specify all aspects of an operating system. System administration facilities and functions are excluded from this standard, and functions usable only by the superuser have not been included. Still, an implementation of the standard interface may also implement features not in this standard. This standard is also not concerned with hardware constraints or system maintenance.
Minimal Interface, Minimally Defined
In keeping with the historical design principles of the UNIX system, the mandatory core facilities of this standard have been kept as minimal as possible. Additional capabilities have been added as optional extensions.
The developers of this standard endeavored to make all specified functions implementable across a wide range of existing and potential systems, including:
All of the current major systems that are ultimately derived from the original UNIX system code (Version 7 or later)
Compatible systems that are not derived from the original UNIX system code
Emulations hosted on entirely different operating systems
Systems running on a broad range of hardware
No direct references to this goal appear in this standard, but some results of it are mentioned in the Rationale (Informative) volume.
Minimal Changes to Historical Implementations
When the original version of IEEE Std 1003.1 was published, there were no known historical implementations that did not have to change. However, there was a broad consensus on a set of functions, types, definitions, and concepts that formed an interface that was common to most historical implementations.
The adoption of the 1988 and 1990 IEEE system interface standards, the 1992 IEEE shell and utilities standard, the various Open Group (formerly X/Open) specifications, and the subsequent revisions and addenda to all of them have consolidated this consensus, and this revision reflects the significantly increased level of consensus arrived at since the original versions. The earlier standards and their modifications specified a number of areas where consensus had not been reached before, and these are now reflected in this revision. The authors of the original versions tried, as much as possible, to follow the principles below when creating new specifications:
By standardizing an interface like one in an historical implementation; for example, directories
By specifying an interface that is readily implementable in terms of, and backwards-compatible with, historical implementations, such as the extended tar format defined in the pax utility
By specifying an interface that, when added to an historical implementation, will not conflict with it; for example, the sigaction() function
This revision tries to minimize the number of changes required to implementations which conform to the earlier versions of the approved standards to bring them into conformance with the current standard. Specifically, the scope of this work excluded doing any ``new'' work, but rather collecting into a single document what had been spread across a number of documents, and presenting it in what had been proven in practice to be a more effective way. Some changes to prior conforming implementations were unavoidable, primarily as a consequence of resolving conflicts found in prior revisions, or which became apparent when bringing the various pieces together.
However, since it references the 1999 version of the ISO C standard, and no longer supports ``Common Usage C'', there are a number of unavoidable changes. Applications portability is similarly affected.
This standard is specifically not a codification of a particular vendor's product.
It should be noted that implementations will have different kinds of extensions. Some will reflect ``historical usage'' and will be preserved for execution of pre-existing applications. These functions should be considered ``obsolescent'' and the standard functions used for new applications. Some extensions will represent functions beyond the scope of this standard. These need to be used with careful management to be able to adapt to future extensions of this standard and/or port to implementations that provide these services in a different manner.
Minimal Changes to Existing Application Code
A goal of this standard was to minimize additional work for the developers of applications. However, because every known historical implementation will have to change at least slightly to conform, some applications will have to change.