Repository navigation
[FileSystem] Allow exclusive file lock - #114098
Merged
cachemeifyoucan merged 9 commits intoAug 20, 2025
Merged
cachemeifyoucan merged 9 commits into
cachemeifyoucan merged 9 commits into
Conversation
Created using spr 1.3.5 [skip ci]
Created using spr 1.3.5
Member
|
@llvm/pr-subscribers-llvm-support @llvm/pr-subscribers-platform-windows Author: Steven Wu (cachemeifyoucan) ChangesAdd parameter to file lock API to allow exclusive file lock. Both Unix Full diff: https://github.com/llvm/llvm-project/pull/114098.diff 4 Files Affected:
diff --git a/llvm/include/llvm/Support/FileSystem.h b/llvm/include/llvm/Support/FileSystem.h
index 9cf53360b4e9662..38ad0e712b32eda 100644
--- a/llvm/include/llvm/Support/FileSystem.h
+++ b/llvm/include/llvm/Support/FileSystem.h
@@ -1184,12 +1184,16 @@ openNativeFileForRead(const Twine &Name, OpenFlags Flags = OF_None,
/// descriptor.
std::error_code
tryLockFile(int FD,
- std::chrono::milliseconds Timeout = std::chrono::milliseconds(0));
+ std::chrono::milliseconds Timeout = std::chrono::milliseconds(0),
+ bool Exclusive = true);
/// Lock the file.
///
/// This function acts as @ref tryLockFile but it waits infinitely.
-std::error_code lockFile(int FD);
+/// \param FD file descriptor to use for locking.
+/// \param Exclusive if \p true use exclusive/writer lock, otherwise use
+/// shared/reader lock.
+std::error_code lockFile(int FD, bool Exclusive = true);
/// Unlock the file.
///
diff --git a/llvm/lib/Support/Unix/Path.inc b/llvm/lib/Support/Unix/Path.inc
index 44097bad7b46edc..9f6f15bbd05f2d8 100644
--- a/llvm/lib/Support/Unix/Path.inc
+++ b/llvm/lib/Support/Unix/Path.inc
@@ -1223,13 +1223,14 @@ Expected<size_t> readNativeFileSlice(file_t FD, MutableArrayRef<char> Buf,
return NumRead;
}
-std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout) {
+std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout,
+ bool Exclusive) {
auto Start = std::chrono::steady_clock::now();
auto End = Start + Timeout;
do {
struct flock Lock;
memset(&Lock, 0, sizeof(Lock));
- Lock.l_type = F_WRLCK;
+ Lock.l_type = Exclusive ? F_WRLCK : F_RDLCK;
Lock.l_whence = SEEK_SET;
Lock.l_start = 0;
Lock.l_len = 0;
@@ -1238,15 +1239,17 @@ std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout) {
int Error = errno;
if (Error != EACCES && Error != EAGAIN)
return std::error_code(Error, std::generic_category());
+ if (Timeout.count() == 0)
+ break;
usleep(1000);
} while (std::chrono::steady_clock::now() < End);
return make_error_code(errc::no_lock_available);
}
-std::error_code lockFile(int FD) {
+std::error_code lockFile(int FD, bool Exclusive) {
struct flock Lock;
memset(&Lock, 0, sizeof(Lock));
- Lock.l_type = F_WRLCK;
+ Lock.l_type = Exclusive ? F_WRLCK : F_RDLCK;
Lock.l_whence = SEEK_SET;
Lock.l_start = 0;
Lock.l_len = 0;
diff --git a/llvm/lib/Support/Windows/Path.inc b/llvm/lib/Support/Windows/Path.inc
index c4bd5e24723517a..07ee3d96be5ec6b 100644
--- a/llvm/lib/Support/Windows/Path.inc
+++ b/llvm/lib/Support/Windows/Path.inc
@@ -1327,8 +1327,10 @@ Expected<size_t> readNativeFileSlice(file_t FileHandle,
return readNativeFileImpl(FileHandle, Buf, &Overlapped);
}
-std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout) {
- DWORD Flags = LOCKFILE_EXCLUSIVE_LOCK | LOCKFILE_FAIL_IMMEDIATELY;
+std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout,
+ bool Exclusive) {
+ DWORD Flags = Exclusive ? LOCKFILE_EXCLUSIVE_LOCK : 0;
+ Flags |= LOCKFILE_FAIL_IMMEDIATELY;
OVERLAPPED OV = {};
file_t File = convertFDToNativeFile(FD);
auto Start = std::chrono::steady_clock::now();
@@ -1338,6 +1340,8 @@ std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout) {
return std::error_code();
DWORD Error = ::GetLastError();
if (Error == ERROR_LOCK_VIOLATION) {
+ if (Timeout.count() == 0)
+ break;
::Sleep(1);
continue;
}
@@ -1346,8 +1350,8 @@ std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout) {
return mapWindowsError(ERROR_LOCK_VIOLATION);
}
-std::error_code lockFile(int FD) {
- DWORD Flags = LOCKFILE_EXCLUSIVE_LOCK;
+std::error_code lockFile(int FD, bool Exclusive) {
+ DWORD Flags = Exclusive ? LOCKFILE_EXCLUSIVE_LOCK : 0;
OVERLAPPED OV = {};
file_t File = convertFDToNativeFile(FD);
if (::LockFileEx(File, Flags, 0, MAXDWORD, MAXDWORD, &OV))
diff --git a/llvm/unittests/Support/ProgramTest.cpp b/llvm/unittests/Support/ProgramTest.cpp
index b1b35eacd1f6187..93db38b47096671 100644
--- a/llvm/unittests/Support/ProgramTest.cpp
+++ b/llvm/unittests/Support/ProgramTest.cpp
@@ -10,6 +10,7 @@
#include "llvm/Config/llvm-config.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ConvertUTF.h"
+#include "llvm/Support/ExponentialBackoff.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Signals.h"
@@ -561,6 +562,81 @@ TEST_F(ProgramEnvTest, TestLockFile) {
sys::fs::remove(LockedFile);
}
+TEST_F(ProgramEnvTest, TestLockFileExclusive) {
+ using namespace llvm::sys;
+ using namespace std::chrono_literals;
+
+ if (const char *LockedFile = getenv("LLVM_PROGRAM_TEST_LOCKED_FILE")) {
+ // Child process.
+ int FD2;
+ ASSERT_NO_ERROR(fs::openFileForReadWrite(LockedFile, FD2,
+ fs::CD_OpenExisting, fs::OF_None));
+
+ std::error_code ErrC =
+ fs::tryLockFile(FD2, std::chrono::seconds(0), /*Exclusive=*/true);
+ EXPECT_TRUE(ErrC);
+ close(FD2);
+ // Write a file to indicate just finished.
+ std::string FinishFile = std::string(LockedFile) + "-finished";
+ int FD3;
+ ASSERT_NO_ERROR(fs::openFileForReadWrite(FinishFile, FD3, fs::CD_CreateNew,
+ fs::OF_None));
+ close(FD3);
+ exit(0);
+ }
+
+ // Create file that will be locked.
+ SmallString<64> LockedFile;
+ int FD1;
+ ASSERT_NO_ERROR(
+ fs::createUniqueDirectory("TestLockFileExclusive", LockedFile));
+ sys::path::append(LockedFile, "file");
+ ASSERT_NO_ERROR(
+ fs::openFileForReadWrite(LockedFile, FD1, fs::CD_CreateNew, fs::OF_None));
+
+ std::string Executable =
+ sys::fs::getMainExecutable(TestMainArgv0, &ProgramTestStringArg1);
+ StringRef argv[] = {Executable,
+ "--gtest_filter=ProgramEnvTest.TestLockFileExclusive"};
+
+ // Add LLVM_PROGRAM_TEST_LOCKED_FILE to the environment of the child.
+ std::string EnvVar = "LLVM_PROGRAM_TEST_LOCKED_FILE=";
+ EnvVar += LockedFile.str();
+ addEnvVar(EnvVar);
+
+ // Lock the file.
+ ASSERT_NO_ERROR(fs::tryLockFile(FD1));
+
+ std::string Error;
+ bool ExecutionFailed;
+ ProcessInfo PI2 = ExecuteNoWait(Executable, argv, getEnviron(), {}, 0, &Error,
+ &ExecutionFailed);
+ ASSERT_FALSE(ExecutionFailed) << Error;
+ ASSERT_TRUE(Error.empty());
+ ASSERT_NE(PI2.Pid, ProcessInfo::InvalidPid) << "Invalid process id";
+
+ std::string FinishFile = std::string(LockedFile) + "-finished";
+ // Wait till child process writes the file to indicate the job finished.
+ bool Finished = false;
+ ExponentialBackoff Backoff(5s); // timeout 5s.
+ do {
+ if (fs::exists(FinishFile)) {
+ Finished = true;
+ break;
+ }
+ } while (Backoff.waitForNextAttempt());
+
+ ASSERT_TRUE(Finished);
+ ASSERT_NO_ERROR(fs::unlockFile(FD1));
+ ProcessInfo WaitResult = llvm::sys::Wait(PI2, /*SecondsToWait=*/1, &Error);
+ ASSERT_TRUE(Error.empty());
+ ASSERT_EQ(0, WaitResult.ReturnCode);
+ ASSERT_EQ(WaitResult.Pid, PI2.Pid);
+ sys::fs::remove(LockedFile);
+ sys::fs::remove(FinishFile);
+ sys::fs::remove_directories(sys::path::parent_path(LockedFile));
+}
+
TEST_F(ProgramEnvTest, TestExecuteWithNoStacktraceHandler) {
using namespace llvm::sys;
|
This was referenced Oct 29, 2024
cachemeifyoucan
requested review from
adrian-prantl,
bogner,
dwblaikie,
ilovepi and
rastogishubham
August 12, 2025 17:32
cachemeifyoucan
changed the base branch from
users/cachemeifyoucan/spr/main.filesystem-allow-exclusive-file-lock
to
main
August 12, 2025 17:45
Created using spr 1.3.6
Contributor
Author
|
This is ready for review. A file lock API addition to allow on disk CAS implementation. |
ilovepi
reviewed
Aug 13, 2025
ilovepi
reviewed
Aug 13, 2025
Created using spr 1.3.6
Created using spr 1.3.6
…xclusive-file-lock
ilovepi
reviewed
Aug 15, 2025
Created using spr 1.3.6
adrian-prantl
approved these changes
Aug 18, 2025
Created using spr 1.3.6
Created using spr 1.3.6
cachemeifyoucan
deleted the
users/cachemeifyoucan/spr/filesystem-allow-exclusive-file-lock
branch
August 20, 2025 15:32
cachemeifyoucan
added a commit
to cachemeifyoucan/llvm-project
that referenced
this pull request
Aug 20, 2025
Update the downstream code to use upstreamed content.
cachemeifyoucan
added a commit
to swiftlang/llvm-project
that referenced
this pull request
Aug 20, 2025
Update the downstream code to use upstreamed content.
cachemeifyoucan
added a commit
to cachemeifyoucan/llvm-project
that referenced
this pull request
Apr 17, 2026
Update the downstream code to use upstreamed content.
cachemeifyoucan
added a commit
to cachemeifyoucan/llvm-project
that referenced
this pull request
Apr 17, 2026
Update the downstream code to use upstreamed content.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Add parameter to file lock API to allow exclusive file lock. Both Unix
and Windows support lock the file exclusively for write for one process
and LLVM OnDiskCAS uses exclusive file lock to coordinate CAS creation.