General description

The following file descriptor flags can be associated with a file:

FD_CLOEXEC

If this flag is 1, the file descriptor is closed if the process executes one of the exec function calls. If it is 0, the file remains open.

FD_CLOFORK

If this flag is 1 when a fork occurs, the file descriptor will be closed for the child process. If it is 0, the file remains open for the child.

The following file status flags can be associated with a file:

O_APPEND

Append mode. If this flag is 1, every write operation on the file begins at the end of the file.

O_ASYNCSIG

If this flag is 1, then asynchronous I/O will be used for the file.

O_NONBLOCK

No blocking. If this flag is 1, read and write operations on the file return with an error status if they cannot perform their I/O immediately. If this flag is 0, read and write operations on the file wait (or “block”) until the file is ready for I/O. For more details, see read() — Read from a file or socket and write() — Write data on a file or socket.

O_SYNC

Force synchronous update. If the flag is 1, every write() operation on the file is written to permanent storage. That is, the file system buffers are forced to permanent storage. (See fsync() — Write changes to direct-access storage.) If this flag is 0, update operations on the file will not be completed until the data has been written to permanent storage. On return from a function that performs a synchronous update, the program is assured that all data for the file has been written to permanent storage.

The following file access mode flags can be associated with a file:

O_RDONLY

The file is opened for reading only.

O_RDWR

The file is opened for reading and writing.

O_WRONLY

The file is opened for writing only.

Two masks can be used to extract flags:

O_ACCMODE

Extracts file access mode flags.

O_GETFL

Extracts file status flags and file access mode flags.

A structure that has the type struct flock (defined in the <fcntl.h> header file) controls locking operations. This structure has the following members:

short l_type

Indicates the type of lock, using one of the following symbols (defined in the <fcntl.h> header file):

F_RDLCK

Indicates a read lock, also called a shared lock. The process can read the locked part of the file, and other processes cannot obtain write locks for that part of the file in the meantime. More than one process can have a read lock on the same part of a file simultaneously.

To establish a read lock, a process must have the file accessed for reading.

F_WRLCK

Indicates a write lock, also called an exclusive lock. The process can write on the locked part of the file, and no other process can establish a read lock or write lock on that same part or on an overlapping part of the file. A process cannot put a write lock on part of a file if there is already a read lock on an overlapping part of the file. To establish a write lock, a process must have accessed the file for writing.

F_UNLCK

Unlocks a lock that was set previously. An unlock (F_UNLCK) request in which l_len is non-zero and the offset of the last byte of the requested segment is the maximum value for an object of type off_t, when the process has an existing lock in which l_len is 0 and which includes the last byte of the requested segment, is treated as a request to unlock from the start of the requested segment with an l_len equal to 0. Otherwise, an unlock (F_UNLCK) request attempts to unlock only the requested segment.

short l_whence

One of three symbols used to determine the part of the file that is affected by this lock. These symbols are defined in the <unistd.h> header file and are the same as symbols used by lseek():

SEEK_CUR

The current file offset in the file

SEEK_END

The end of the file

SEEK_SET

The start of the file.

off_t l_start

Gives the byte offset used to identify the part of the file that is affected by this lock. The part of the file affected by the lock begins at this offset from the location given by l_whence. For example, if l_whence is SEEK_SET and l_start is 10, the locked part of the file begins at an offset of 10 bytes from the beginning of the file.

off_t l_len

Gives the size of the locked part of the file in bytes. If l_len is 0, the locked part of the file begins at the position specified by l_whence and l_start, and extends to the end of the file. If l_len is positive, the area affected starts at l_start and end at l_start+ l_len-1. If l_len is negative, the area affected starts at l_start+ l_len and end at l_start-1. Locks may start and extend beyond the current end of a file, but cannot extend before the beginning of the file. A lock can be set to extend to the largest possible value of the file offset for that file by setting l_len to 0. If such a lock also has l_start set to 0 and l_whence is set to SEEK_SET, the whole file is locked.

pid_t l_pid

Specifies the process ID of the process that holds the lock. This is an output field used only with F_GETLK actions.

You can set locks by specifying F_SETLK as the action argument for fcntl(). Such a function call requires a third argument pointing to a struct flock structure, as in this example:

struct flock lock_it;
lock_it.l_type = F_RDLCK;
lock_it.l_whence = SEEK_SET;
lock_it.l_start = 0;
lock_it.l_len = 100;
fcntl(fildes,F_SETLK,&lock_it);

A process can determine locking information about a file by using F_GETLK as the action argument for fcntl(). In this case, the call to fcntl() should specify a third argument pointing to an flock structure. The structure should describe the lock operation you want. When fcntl() returns, the structure indicated by the flock pointer is changed to show the first lock that would prevent the proposed lock operation from taking place. The returned structure shows the type of lock that is set, the part of the file that is locked, and the process ID of the process that holds the lock. In the returned structure:

• l_whence is always SEEK_SET.
• l_start gives the offset of the locked portion from the beginning of the file.
• l_len is the length of the locked portion.

If there are no locks that prevent the proposed lock operation, the returned structure has F_UNLCK in l_type, and is otherwise unchanged.