dotlockfile

dotlockfile [-r] path

path
    The path to the file or resource to be locked. The actual lock file will typically be created with a '.lock' suffix or as '.<pid>' within the same directory.

-r
    Release or remove the lock file associated with the specified path. If the lock is not held by the current process or doesn't exist, it may exit with an error or do nothing.

dotlockfile is a utility designed to create and manage "dot-lock" files, a common mechanism for implementing mutual exclusion (locking) on Unix-like file systems. It ensures that only one process can acquire a lock on a specific resource at a time, preventing race conditions and data corruption. This method is particularly crucial in environments where multiple processes might concurrently access shared files, such as mail spool directories or temporary file locations.

The "dot-lock" principle involves creating a unique temporary file (e.g., named with a process ID) and then atomically renaming it to a well-known lock file (e.g., .filename.lock). This atomic operation ensures that if the rename succeeds, the process has acquired the lock exclusively. If it fails, another process already holds the lock. dotlockfile abstracts these steps, making it easier for scripts and applications to implement robust file locking. It is often used in conjunction with mail delivery agents (MDAs) like procmail to lock mailboxes during delivery.

Not all Linux distributions include dotlockfile as a standard utility; its availability may depend on installed packages (e.g., procmail). The effectiveness of dot-locking relies heavily on specific filesystem semantics, particularly the atomicity of rename(2) and link(2) operations, which can vary across network file systems (NFS). Stale lock files (locks left behind by crashed processes) can occur, requiring manual intervention or a timeout mechanism (which dotlockfile itself might not provide).

Dot-locking primarily relies on the atomic nature of the rename(2) system call on POSIX-compliant filesystems. To acquire a lock for a file FOO, a process first creates a uniquely named temporary file (e.g., .<pid>.<hostname>) in the same directory. It then attempts to atomically rename this temporary file to the intended lock file name (e.g., .FOO.lock). If the rename succeeds, the process has acquired the lock. If the rename fails (because the target lock file already exists), another process has already acquired the lock, and the current process must wait or retry. This mechanism ensures that only one process can successfully claim the lock at any given moment, even under heavy contention.

The concept of 'dot-locking' originated in older Unix systems, particularly in the context of mail spool management (e.g., for sendmail and procmail) to prevent concurrent writes to user mailboxes. The dotlockfile utility, or scripts implementing similar logic, emerged as a robust way to ensure atomic acquisition of file locks in these shared environments. While more modern systems often rely on advisory locks (like flock(2) or fcntl(2)) or database-driven locking mechanisms, dot-locking remains a foundational concept, especially for simple, robust mutual exclusion on local filesystems.

lockfile(1), flock(1), procmail(1), sendmail(8), fcntl(2)