View source for Open (system call)

{{Short description|System calls in some operating systems}}
{{lowercase}}
For most [[file system]]s, a [[Computer program|program]] initializes access to a [[Computer file|file]] in a [[file system]] using the '''open''' [[system call]]. This allocates resources associated to the file (the [[file descriptor]]), and returns a [[Smart pointer#Handles|handle]] that the [[Process (computing)|process]] will use to refer to that file.  In some cases, the open is performed by the first access.

The same file may be opened simultaneously by several processes, and even by the same process, resulting in several file descriptors for the same file; depending on the file organization and filesystem. Operations on the descriptors such as moving the [[FILE pointer|file pointer]] or closing it are independent{{Em dash}}they do not affect other descriptors for the same file.  Operations on the file, such as a [[Write (system call)|write]], can be seen by operations on the other descriptors: a later read can read the newly written data.

During the <code>open</code>, the filesystem may allocate memory for [[Data buffer|buffers]], or it may wait until the first operation.

The [[File path#Absolute and relative paths|absolute file path]] is resolved. This may include connecting to a remote host and notifying an operator that a removable medium is required. It may include the initialization of a communication device. At this point an error may be returned if the host or medium is not available. The first access to at least the [[Directory (computing)|directory]] within the filesystem is performed.  An error will usually be returned if the higher level components of the path ([[Directory (computing)|directories]]) cannot be located or accessed.  An error will be returned if the file is expected to exist and it does not or if the file should not already exist and it does.

If the file is expected to exist and it does, the file access, as restricted by [[File system permissions|permission flags]] within the file meta data or [[access control list]], is validated against the requested type of operations.  This usually requires an additional filesystem access although in some filesystems meta-flags may be part of the directory structure.

If the file is being created, the filesystem may allocate the default initial amount of storage or a specified amount depending on the file system capabilities.  If this fails an error will be returned. Updating the directory with the new entry may be performed or it may be delayed until the [[close (system call)|close]] is performed.

Various other errors which may occur during the open include directory update failures, un-permitted multiple connections, media failures, communication link failures and device failures.

The return value must always be examined and an error specific action taken.

In many cases programming language-specific run-time library opens may perform additional actions including initializing a run-time library structure related to the file.

As soon as a file is no longer needed, the program should close it. This will cause run-time library and filesystem buffers to be updated to the physical media and permit other processes to access the data if exclusive use had been required. Some run-time libraries may close a file if the program calls the run-time exit. Some filesystems may perform the necessary operations if the program terminates. Neither of these is likely to take place in the event of a kernel or power failure. This can cause damaged filesystem structures requiring the running of privileged and lengthy filesystem utilities during which the entire filesystem may be inaccessible.

==open call arguments==
#The [[pathname]] to the file,
#The kind of access requested on the file (read, write, append etc.),
#The initial file permission is requested using the third argument called <code>mode</code>. This argument is relevant only when a new file is being created.

After using the file, the process should close the file using [[close (system call)|close]] call, which takes the file descriptor of the file to be closed. Some filesystems include a disposition to permit releasing the file.

Some computer languages include run-time libraries which include additional functionality for particular filesystems. The open (or some auxiliary routine) may include specifications for key size, record size, connection speed. Some open routines include specification of the program code to be executed in the event of an error.

=== Perl language form ===
<syntaxhighlight lang="perl">
open FILEHANDLE,MODE[,EXPR]
</syntaxhighlight>

for example:

<syntaxhighlight lang="perl">
open(my $fh, ">", "output.txt");
</syntaxhighlight>

[[Perl]] also uses the <code>tie</code> function of the <code>Tie::File</code> module to associate an array with a 
file.<ref name=perlTieArray>{{cite web|url=http://perldoc.perl.org/Tie/File.html |title=Tie::File |publisher=perldoc.perl.org |access-date=2011-08-07}}</ref> The <code>tie::AnyDBM_File</code> function associates a hash with a file.<ref name=perlTieHash>{{cite web|url=http://perldoc.perl.org/AnyDBM_File.html |title=AnyDBM_File |publisher=perldoc.perl.org |access-date=2011-08-07}}</ref>

=== C library POSIX definition ===
The  [http://pubs.opengroup.org/onlinepubs/9699919799/functions/open.html open] call is standardized by the [[POSIX]] specification for [[C (programming language)|C language]]:

<syntaxhighlight lang="c">
int open(const char *path, int oflag, .../*,mode_t mode */);
int openat(int fd, const char *path, int oflag, ...);
int creat(const char *path, mode_t mode);
FILE *fopen(const char *restrict filename, const char *restrict mode);
</syntaxhighlight>

The value returned is a file descriptor which is a reference to a process specific  structure which contains, among other things, a position pointer that indicates which place in the file will be acted upon by the next operation.

Open may return [[−1]]<!-- Please, do not use <code> here. It is a value what the call returns, not a piece of code which is translated by a compiler into the same value --> indicating a failure with <code>errno</code> detailing the error.

The file system also updates a global table of all open files which is used for determining if a file is currently in use by any process.

==== path ====
The name of the file to open. It includes the [[file path]] defining where, in which file system, the file is found (or should be created).

<code>openat</code> expects a relative path.

==== oflag ====
This argument formed by [[Mask (computing)#Arguments to functions|OR'ing together]] optional parameters and  (from <[[fcntl.h]]>) one of:

{{block indent|<code>O_RDONLY</code>, <code>O_RDWR</code> and <code>O_WRONLY</code>}}

Option parameters include:

*<code>O_APPEND</code> data written will be appended to the end of the file. The file operations will always adjust the position pointer to the end of the file.
*<code>O_CREAT</code> Create the file if it does not exist; otherwise it has no effect except as noted under <code>O_EXCL</code> below.
*<code>O_EXCL</code> Used with <code>O_CREAT</code> if the file already exists, then fail, setting errno to EEXIST.
*<code>O_TRUNC</code> If the file already exists  then discard its previous contents, reducing it to an empty file. Not applicable for a device or named pipe.

Additional flags and errors are defined in [http://pubs.opengroup.org/onlinepubs/9699919799/functions/open.html open] call.

<code>creat()</code> is implemented as:

<syntaxhighlight lang="c">
int creat(const char *path, mode_t mode)
{
    return open(path, O_WRONLY|O_CREAT|O_TRUNC, mode);
}
</syntaxhighlight>

[http://pubs.opengroup.org/onlinepubs/9699919799/functions/fopen.html fopen] uses string flags such as <code>r</code>, <code>w</code>, <code>a</code> and <code>+</code> and returns a file pointer used with [http://pubs.opengroup.org/onlinepubs/9699919799/functions/fgets.html fgets], [http://pubs.opengroup.org/onlinepubs/9699919799/functions/fputs.html fputs] and [http://pubs.opengroup.org/onlinepubs/9699919799/functions/fclose.html fclose].

==== mode ====
Optional and relevant only when creating a new file, defines the
[[file permissions]]. These include  read, write or execute the file by the owner, group or all users. The mode is masked by the calling process's [[umask]]: bits set in the umask are cleared in the mode.

==See also==
* [[File descriptor]] – how it works and other functions related to <code>open</code>

==Notes==
{{reflist}}

==References==
* Advanced Programming in the UNIX Environment by W. Richard Stevens {{ISBN|81-7808-096-6}}
*UNIX concept & application by Sumitabh Das


{{Computer files}}

[[Category:C POSIX library]]
[[Category:System calls]]
[[Category:Articles with example C code]]