Close open file linux
This section describes the primitives for opening and closing files using file descriptors. The open and creat functions are declared in the header file fcntl.h , while close is declared in unistd.h .
Function: int open (const char * filename , int flags [, mode_t mode ]) ¶
Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | See POSIX Safety Concepts.
The open function creates and returns a new file descriptor for the file named by filename . Initially, the file position indicator for the file is at the beginning of the file. The argument mode (see The Mode Bits for Access Permission) is used only when a file is created, but it doesn’t hurt to supply the argument in any case.
The flags argument controls how the file is to be opened. This is a bit mask; you create the value by the bitwise OR of the appropriate parameters (using the ‘ | ’ operator in C). See File Status Flags, for the parameters available.
The normal return value from open is a non-negative integer file descriptor. In the case of an error, a value of -1 is returned instead. In addition to the usual file name errors (see File Name Errors), the following errno error conditions are defined for this function:
The file exists but is not readable/writable as requested by the flags argument, or the file does not exist and the directory is unwritable so it cannot be created.
Both O_CREAT and O_EXCL are set, and the named file already exists.
The open operation was interrupted by a signal. See Primitives Interrupted by Signals.
The flags argument specified write access, and the file is a directory.
The process has too many files open. The maximum number of file descriptors is controlled by the RLIMIT_NOFILE resource limit; see Limiting Resource Usage.
The entire system, or perhaps the file system which contains the directory, cannot support any additional open files at the moment. (This problem cannot happen on GNU/Hurd systems.)
The named file does not exist, and O_CREAT is not specified.
The directory or file system that would contain the new file cannot be extended, because there is no disk space left.
O_NONBLOCK and O_WRONLY are both set in the flags argument, the file named by filename is a FIFO (see Pipes and FIFOs), and no process has the file open for reading.
The file resides on a read-only file system and any of O_WRONLY , O_RDWR , and O_TRUNC are set in the flags argument, or O_CREAT is set and the file does not already exist.
If on a 32 bit machine the sources are translated with _FILE_OFFSET_BITS == 64 the function open returns a file descriptor opened in the large file mode which enables the file handling functions to use files up to 2^63 bytes in size and offset from -2^63 to 2^63. This happens transparently for the user since all of the low-level file handling functions are equally replaced.
This function is a cancellation point in multi-threaded programs. This is a problem if the thread allocates some resources (like memory, file descriptors, semaphores or whatever) at the time open is called. If the thread gets canceled these resources stay allocated until the program ends. To avoid this calls to open should be protected using cancellation handlers.
The open function is the underlying primitive for the fopen and freopen functions, that create streams.
Function: int open64 (const char * filename , int flags [, mode_t mode ]) ¶
Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | See POSIX Safety Concepts.
This function is similar to open . It returns a file descriptor which can be used to access the file named by filename . The only difference is that on 32 bit systems the file is opened in the large file mode. I.e., file length and file offsets can exceed 31 bits.
When the sources are translated with _FILE_OFFSET_BITS == 64 this function is actually available under the name open . I.e., the new, extended API using 64 bit file sizes and offsets transparently replaces the old API.
Obsolete function: int creat (const char * filename , mode_t mode ) ¶
Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | See POSIX Safety Concepts.
This function is obsolete. The call:
open (filename, O_WRONLY | O_CREAT | O_TRUNC, mode)
If on a 32 bit machine the sources are translated with _FILE_OFFSET_BITS == 64 the function creat returns a file descriptor opened in the large file mode which enables the file handling functions to use files up to 2^63 in size and offset from -2^63 to 2^63. This happens transparently for the user since all of the low-level file handling functions are equally replaced.
Obsolete function: int creat64 (const char * filename , mode_t mode ) ¶
Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | See POSIX Safety Concepts.
This function is similar to creat . It returns a file descriptor which can be used to access the file named by filename . The only difference is that on 32 bit systems the file is opened in the large file mode. I.e., file length and file offsets can exceed 31 bits.
To use this file descriptor one must not use the normal operations but instead the counterparts named *64 , e.g., read64 .
When the sources are translated with _FILE_OFFSET_BITS == 64 this function is actually available under the name open . I.e., the new, extended API using 64 bit file sizes and offsets transparently replaces the old API.
Function: int close (int filedes ) ¶
Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | See POSIX Safety Concepts.
The function close closes the file descriptor filedes . Closing a file has the following consequences:
- The file descriptor is deallocated.
- Any record locks owned by the process on the file are unlocked.
- When all file descriptors associated with a pipe or FIFO have been closed, any unread data is discarded.
This function is a cancellation point in multi-threaded programs. This is a problem if the thread allocates some resources (like memory, file descriptors, semaphores or whatever) at the time close is called. If the thread gets canceled these resources stay allocated until the program ends. To avoid this, calls to close should be protected using cancellation handlers.
The normal return value from close is 0; a value of -1 is returned in case of failure. The following errno error conditions are defined for this function:
The filedes argument is not a valid file descriptor.
The close call was interrupted by a signal. See Primitives Interrupted by Signals. Here is an example of how to handle EINTR properly:
TEMP_FAILURE_RETRY (close (desc));
When the file is accessed by NFS, these errors from write can sometimes not be detected until close . See Input and Output Primitives, for details on their meaning.
Please note that there is no separate close64 function. This is not necessary since this function does not determine nor depend on the mode of the file. The kernel which performs the close operation knows which mode the descriptor is used for and can handle this situation.
To close a stream, call fclose (see Closing Streams) instead of trying to close its underlying file descriptor with close . This flushes any buffered output and updates the stream object to indicate that it is closed.
Function: int close_range (unsigned int lowfd , unsigned int maxfd , int flags ) ¶
Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | See POSIX Safety Concepts.
The function close_range closes the file descriptor from lowfd to maxfd (inclusive). This function is similar to call close in specified file descriptor range depending on the flags .
This is function is only supported on recent Linux versions and the GNU C Library does not provide any fallback (the application will need to handle possible ENOSYS ).
The flags add options on how the files are closes. Linux currently supports:
Unshare the file descriptor table before closing file descriptors.
Set the FD_CLOEXEC bit instead of closing the file descriptor.
The normal return value from close_range is 0; a value of -1 is returned in case of failure. The following errno error conditions are defined for this function:
The lowfd value is larger than maxfd or an unsupported flags is used.
Either there is not enough memory for the operation, or the process is out of address space. It can only happnes when CLOSE_RANGE_UNSHARED flag is used.
The process has too many files open and it can only happens when CLOSE_RANGE_UNSHARED flag is used. The maximum number of file descriptors is controlled by the RLIMIT_NOFILE resource limit; see Limiting Resource Usage.
The kernel does not implement the required functionality.
Function: void closefrom (int lowfd ) ¶
Preliminary: | MT-Safe | AS-Safe | AC-Safe fd | See POSIX Safety Concepts.
The function closefrom closes all file descriptors greater than or equal to lowfd . This function is similar to calling close for all open file descriptors not less than lowfd .
Already closed file descriptors are ignored.
close(2) — Linux man page
close() closes a file descriptor, so that it no longer refers to any file and may be reused. Any record locks (see fcntl(2)) held on the file it was associated with, and owned by the process, are removed (regardless of the file descriptor that was used to obtain the lock).
If fd is the last file descriptor referring to the underlying open file description (see open(2)), the resources associated with the open file description are freed; if the descriptor was the last reference to a file which has been removed using unlink(2) the file is deleted.
Return Value
Errors
EBADF fd isn’t a valid open file descriptor. EINTR The close() call was interrupted by a signal; see signal(7). EIO An I/O error occurred.
Conforming to
Notes
Not checking the return value of close() is a common but nevertheless serious programming error. It is quite possible that errors on a previous write(2) operation are first reported at the final close(). Not checking the return value when closing the file may lead to silent loss of data. This can especially be observed with NFS and with disk quota.
A successful close does not guarantee that the data has been successfully saved to disk, as the kernel defers writes. It is not common for a file system to flush the buffers when the stream is closed. If you need to be sure that the data is physically stored use fsync(2). (It will depend on the disk hardware at this point.)
It is probably unwise to close file descriptors while they may be in use by system calls in other threads in the same process. Since a file descriptor may be reused, there are some obscure race conditions that may cause unintended side effects.