int lockf(fd, cmd, size) int fd, cmd; long size;
lockf() places, removes, and tests for exclusive locks on sections of files. These locks are either advisory or mandatory depending on the mode bits of the file. The lock is mandatory if the set-GID bit (S_ISGID) is set and the group execute bit (S_IXGRP) is clear (see stat.2v for information about mode bits). Otherwise, the lock is advisory.
If a process holds a mandatory exclusive lock on a segment of a file, both read and write operations block until the lock is removed (see WARNINGS).
An advisory lock does not affect read and write access to the locked segment. Advisory locks may be used by cooperating processes checking for locks using F_GETLCK and voluntarily observing the indicated read and write restrictions.
A locking call on an already locked file section fails, returning an error value or putting the call to sleep until that file section is unlocked. All the locks on a process are removed when that process terminates. See fcntl.2v for more information about record locking.
fd is an open file descriptor. It must have O_WRONLY or O_RDWR permission for a successful locking call.
is a control value which specifies the action to be taken.
The accepted values for
are defined in
#define F_ULOCK 0 /* Unlock a previously locked section */ #define F_LOCK 1 /* Lock a section for exclusive use */ #define F_TLOCK 2 /* Test and lock a section (non-blocking) */ #define F_TEST 3 /* Test section for other process' locks */
F_TEST returns -1 and sets errno to EACCES if a lock by another process already exists on the specified section. Otherwise, it returns 0. F_LOCK and F_TLOCK lock available file sections. F_ULOCK removes locks from file sections.
All other values of cmd are reserved for future applications and, until implemented, return an error.
size is the number of contiguous bytes to be locked or unlocked. The resource to be locked starts at the current offset in the file and extends forward size bytes if size is positive, and extends backward size bytes (the preceding bytes up to but not including the current offset) if size is negative. If size is zero, the section from the current offset through the largest file offset is locked (that is, from the current offset through the present or any future EOF). An area need not be allocated to the file to be locked, such a lock may exist after the EOF.
Sections locked with F_LOCK or F_TLOCK may contain all or part of an already locked section. They may also be partially or completely contained by an already locked section. Where these overlapping or adjacent locked sections occur, they are combined into a single section. If the table of active locks is full, a lock request requiring an additional table entry fails and an error value is returned.
F_LOCK and F_TLOCK differ only in their response to requests for unavailable resources. If a section is already locked, F_LOCK directs the calling process to sleep until the resource is available, F_TLOCK directs the function to return -1 and set errno to EACCES (see ERRORS).
When a F_ULOCK request releases part of a section with overlapping locks, the remaining section or sections retain the lock. If F_ULOCK removes the center of a locked section, the two separate locked sections remain, but an additional element is required in the table of active locks. If this table is full, errno is set to ENOLCK and the requested section is not released.
The danger of a deadlock exists when a process controlling a locked resource is put to sleep by requesting an unavailable resource. To avoid this danger, lockf() and fcntl() scan for this conflict before putting a locked resource to sleep. If a deadlock would result, an error value is returned.
The sleep process can be interrupted with any signal.
may be used to provide a timeout facility where needed.
Note: In future, lockf() may generate EAGAIN under these conditions, so applications testing for EACCES should also test for EAGAIN.
cmd is F_LOCK or F_TLOCK and the process does not have write permission on the file.
A child process does not inherit locks from its parent on fork.2v
lockf() locks do not interact in any way with locks granted by flock(), but are compatible with locks granted by fcntl().
Created by unroff & hp-tools. © by Hans-Peter Bischof. All Rights Reserved (1997).
Last modified 21/April/97