Take the 2-minute tour ×

User A asks the system to read file foo and at the same time user B wants to save his or her data onto the same file. How is this situation handled on the filesystem level?

share|improve this question
add comment

3 Answers

up vote 13 down vote accepted

Most filesystems (but not all) use locking to guard concurrent access to the same file. The lock can be exclusive, so the first user to get the lock gets access - subsequent users get a "access denied" error. In your example scenario, user A will be able to read the file and gets the file lock, but user B will not be able to write while user A is reading.

Some filesystems (e.g. NTFS) allow the level of locking to be specified, to allow for example concurrent readers, but no writers. Byte-range locks are also possible.

Unlike databases, filesystems typically are not transactional, not atomic and changes from different users are not isolated (if changes can even be seen - locking may prohibit this.)

Using whole-file locks is a coarse grained approach, but it will guard against inconsistent updates. Not all filesystems support whole-file locks, and so it is common practice to use a lock file - a typically empty file whose presence indicates that its associated file is in use. (Creating a file is an atomic operation on most file systems.)

share|improve this answer
Does locking work on the whole file or on parts (blocks/inodes/whatever) of it too? –  Matteo Riva May 1 '10 at 22:30
The answer is filesystem specific (as you've no doubt gleaned from the other answers). Windows uses whole file locking for most cases, since that's part of the API for opening files (CreateFile). Byte-range locking is availalbe, but applications have to specially request a lock for a region of a file using a different API function (LockFile). –  mdma May 2 '10 at 1:57
add comment

For Linux, the short answer is you could get some strange information back from a file if there is a concurrent writer. The kernel does use locking internally to run each read() and write() operation serially. (Although, I forget whether the whole file is locked or if it's on a per-page granularity.) But if the application uses multiple write() calls to write information to the file, a read() could happen between any of those calls, so it could see inconsistent data. This is a atomicity violation in the operating system.

As mdma has mentioned, you could use file locking to make sure there is only one reader and one writer at a time. It sounds like NTFS uses mandatory locking, where if one program locks the file, all other programs get error messages when they try to access it.

Unix programs generally don't use locking at all, and when they do, the lock is usually advisory. An advisory lock only prevents other processes from getting an advisory lock on the same file; it doesn't actually prevent the read or write. (That is, it only locks the file for those who check the lock.)

share|improve this answer
add comment

Operating systems implement read/write locks to ensure that file system buffers against which a read is pending cannot be modified.

share|improve this answer
add comment

Your Answer


