aboutsummaryrefslogtreecommitdiff
path: root/src/libstore/pathlocks.cc
diff options
context:
space:
mode:
Diffstat (limited to 'src/libstore/pathlocks.cc')
-rw-r--r--src/libstore/pathlocks.cc128
1 files changed, 44 insertions, 84 deletions
diff --git a/src/libstore/pathlocks.cc b/src/libstore/pathlocks.cc
index 08d1efdbe..2635e3940 100644
--- a/src/libstore/pathlocks.cc
+++ b/src/libstore/pathlocks.cc
@@ -5,9 +5,10 @@
#include <cerrno>
#include <cstdlib>
+#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
-#include <fcntl.h>
+#include <sys/file.h>
namespace nix {
@@ -40,17 +41,14 @@ void deleteLockFile(const Path & path, int fd)
bool lockFile(int fd, LockType lockType, bool wait)
{
- struct flock lock;
- if (lockType == ltRead) lock.l_type = F_RDLCK;
- else if (lockType == ltWrite) lock.l_type = F_WRLCK;
- else if (lockType == ltNone) lock.l_type = F_UNLCK;
+ int type;
+ if (lockType == ltRead) type = LOCK_SH;
+ else if (lockType == ltWrite) type = LOCK_EX;
+ else if (lockType == ltNone) type = LOCK_UN;
else abort();
- lock.l_whence = SEEK_SET;
- lock.l_start = 0;
- lock.l_len = 0; /* entire file */
if (wait) {
- while (fcntl(fd, F_SETLKW, &lock) != 0) {
+ while (flock(fd, type) != 0) {
checkInterrupt();
if (errno != EINTR)
throw SysError(format("acquiring/releasing lock"));
@@ -58,9 +56,9 @@ bool lockFile(int fd, LockType lockType, bool wait)
return false;
}
} else {
- while (fcntl(fd, F_SETLK, &lock) != 0) {
+ while (flock(fd, type | LOCK_NB) != 0) {
checkInterrupt();
- if (errno == EACCES || errno == EAGAIN) return false;
+ if (errno == EWOULDBLOCK) return false;
if (errno != EINTR)
throw SysError(format("acquiring/releasing lock"));
}
@@ -70,14 +68,6 @@ bool lockFile(int fd, LockType lockType, bool wait)
}
-/* This enables us to check whether are not already holding a lock on
- a file ourselves. POSIX locks (fcntl) suck in this respect: if we
- close a descriptor, the previous lock will be closed as well. And
- there is no way to query whether we already have a lock (F_GETLK
- only works on locks held by other processes). */
-static Sync<StringSet> lockedPaths_;
-
-
PathLocks::PathLocks()
: deletePaths(false)
{
@@ -91,7 +81,7 @@ PathLocks::PathLocks(const PathSet & paths, const string & waitMsg)
}
-bool PathLocks::lockPaths(const PathSet & _paths,
+bool PathLocks::lockPaths(const PathSet & paths,
const string & waitMsg, bool wait)
{
assert(fds.empty());
@@ -99,75 +89,54 @@ bool PathLocks::lockPaths(const PathSet & _paths,
/* Note that `fds' is built incrementally so that the destructor
will only release those locks that we have already acquired. */
- /* Sort the paths. This assures that locks are always acquired in
- the same order, thus preventing deadlocks. */
- Paths paths(_paths.begin(), _paths.end());
- paths.sort();
-
- /* Acquire the lock for each path. */
+ /* Acquire the lock for each path in sorted order. This ensures
+ that locks are always acquired in the same order, thus
+ preventing deadlocks. */
for (auto & path : paths) {
checkInterrupt();
Path lockPath = path + ".lock";
debug(format("locking path '%1%'") % path);
- {
- auto lockedPaths(lockedPaths_.lock());
- if (lockedPaths->count(lockPath)) {
- if (!wait) return false;
- throw AlreadyLocked("deadlock: trying to re-acquire self-held lock '%s'", lockPath);
- }
- lockedPaths->insert(lockPath);
- }
-
- try {
-
- AutoCloseFD fd;
+ AutoCloseFD fd;
- while (1) {
+ while (1) {
- /* Open/create the lock file. */
- fd = openLockFile(lockPath, true);
+ /* Open/create the lock file. */
+ fd = openLockFile(lockPath, true);
- /* Acquire an exclusive lock. */
- if (!lockFile(fd.get(), ltWrite, false)) {
- if (wait) {
- if (waitMsg != "") printError(waitMsg);
- lockFile(fd.get(), ltWrite, true);
- } else {
- /* Failed to lock this path; release all other
- locks. */
- unlock();
- lockedPaths_.lock()->erase(lockPath);
- return false;
- }
+ /* Acquire an exclusive lock. */
+ if (!lockFile(fd.get(), ltWrite, false)) {
+ if (wait) {
+ if (waitMsg != "") printError(waitMsg);
+ lockFile(fd.get(), ltWrite, true);
+ } else {
+ /* Failed to lock this path; release all other
+ locks. */
+ unlock();
+ return false;
}
-
- debug(format("lock acquired on '%1%'") % lockPath);
-
- /* Check that the lock file hasn't become stale (i.e.,
- hasn't been unlinked). */
- struct stat st;
- if (fstat(fd.get(), &st) == -1)
- throw SysError(format("statting lock file '%1%'") % lockPath);
- if (st.st_size != 0)
- /* This lock file has been unlinked, so we're holding
- a lock on a deleted file. This means that other
- processes may create and acquire a lock on
- `lockPath', and proceed. So we must retry. */
- debug(format("open lock file '%1%' has become stale") % lockPath);
- else
- break;
}
- /* Use borrow so that the descriptor isn't closed. */
- fds.push_back(FDPair(fd.release(), lockPath));
-
- } catch (...) {
- lockedPaths_.lock()->erase(lockPath);
- throw;
+ debug(format("lock acquired on '%1%'") % lockPath);
+
+ /* Check that the lock file hasn't become stale (i.e.,
+ hasn't been unlinked). */
+ struct stat st;
+ if (fstat(fd.get(), &st) == -1)
+ throw SysError(format("statting lock file '%1%'") % lockPath);
+ if (st.st_size != 0)
+ /* This lock file has been unlinked, so we're holding
+ a lock on a deleted file. This means that other
+ processes may create and acquire a lock on
+ `lockPath', and proceed. So we must retry. */
+ debug(format("open lock file '%1%' has become stale") % lockPath);
+ else
+ break;
}
+ /* Use borrow so that the descriptor isn't closed. */
+ fds.push_back(FDPair(fd.release(), lockPath));
}
return true;
@@ -189,8 +158,6 @@ void PathLocks::unlock()
for (auto & i : fds) {
if (deletePaths) deleteLockFile(i.second, i.first);
- lockedPaths_.lock()->erase(i.second);
-
if (close(i.first) == -1)
printError(
format("error (ignored): cannot close lock file on '%1%'") % i.second);
@@ -208,11 +175,4 @@ void PathLocks::setDeletion(bool deletePaths)
}
-bool pathIsLockedByMe(const Path & path)
-{
- Path lockPath = path + ".lock";
- return lockedPaths_.lock()->count(lockPath);
-}
-
-
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 14:33:06 +0000