[next] Add change from upstream llvm#114098

Update the downstream code to use upstreamed content.

Author: cachemeifyoucan

llvm/include/llvm/Support/FileSystem.h

@@ -1176,6 +1176,12 @@ LLVM_ABI Expected<file_t>
 openNativeFileForRead(const Twine &Name, OpenFlags Flags = OF_None,
                       SmallVectorImpl<char> *RealPath = nullptr);
 
+/// An enumeration for the lock kind.
+enum class LockKind {
+  Exclusive, // Exclusive/writer lock
+  Shared     // Shared/reader lock
+};
+
 /// Try to locks the file during the specified time.
 ///
 /// This function implements advisory locking on entire file. If it returns
@@ -1189,6 +1195,7 @@ openNativeFileForRead(const Twine &Name, OpenFlags Flags = OF_None,
 /// @param Timeout Time in milliseconds that the process should wait before
 ///                reporting lock failure. Zero value means try to get lock only
 ///                once.
+/// @param Kind    The kind of the lock used (exclusive/shared).
 /// @returns errc::success if lock is successfully obtained,
 /// errc::no_lock_available if the file cannot be locked, or platform-specific
 /// error_code otherwise.
@@ -1200,7 +1207,7 @@ openNativeFileForRead(const Twine &Name, OpenFlags Flags = OF_None,
 LLVM_ABI std::error_code
 tryLockFile(int FD,
             std::chrono::milliseconds Timeout = std::chrono::milliseconds(0),
-            bool Exclusive = true);
+            LockKind Kind = LockKind::Exclusive);
 
 /// Get RealPath from file handle.
 ///
@@ -1214,9 +1221,8 @@ std::error_code getRealPathFromHandle(file_t Handle,
 ///
 /// This function acts as @ref tryLockFile but it waits infinitely.
 /// \param FD file descriptor to use for locking.
-/// \param Exclusive if \p true use exclusive/writer lock, otherwise use
-/// shared/reader lock.
-LLVM_ABI std::error_code lockFile(int FD, bool Exclusive = true);
+/// \param Kind of lock to used (exclusive/shared).
+LLVM_ABI std::error_code lockFile(int FD, LockKind Kind = LockKind::Exclusive);
 
 /// Unlock the file.
 ///

llvm/lib/CAS/MappedFileRegionBumpPtr.cpp

@@ -76,14 +76,13 @@ namespace {
 struct FileLockRAII {
   std::string Path;
   int FD;
-  enum LockKind { Shared, Exclusive };
-  std::optional<LockKind> Locked;
+  std::optional<sys::fs::LockKind> Locked;
 
   FileLockRAII(std::string Path, int FD) : Path(std::move(Path)), FD(FD) {}
   ~FileLockRAII() { consumeError(unlock()); }
 
-  Error lock(LockKind LK) {
-    if (std::error_code EC = lockFileThreadSafe(FD, LK == Exclusive))
+  Error lock(sys::fs::LockKind LK) {
+    if (std::error_code EC = lockFileThreadSafe(FD, LK))
       return createFileError(Path, EC);
     Locked = LK;
     return Error::success();
@@ -134,12 +133,12 @@ Expected<MappedFileRegionBumpPtr> MappedFileRegionBumpPtr::create(
   // Take shared/reader lock that will be held until we close the file; unlocked
   // by destroyImpl.
   if (std::error_code EC =
-          lockFileThreadSafe(SharedLockFD, /*Exclusive=*/false))
+          lockFileThreadSafe(SharedLockFD, sys::fs::LockKind::Shared))
     return createFileError(Path, EC);
 
   // Take shared/reader lock for initialization.
   FileLockRAII InitLock(Result.Path, FD);
-  if (Error E = InitLock.lock(FileLockRAII::Shared))
+  if (Error E = InitLock.lock(sys::fs::LockKind::Shared))
     return std::move(E);
 
   sys::fs::file_t File = sys::fs::convertFDToNativeFile(FD);
@@ -151,7 +150,7 @@ Expected<MappedFileRegionBumpPtr> MappedFileRegionBumpPtr::create(
     // Lock the file exclusively so only one process will do the initialization.
     if (Error E = InitLock.unlock())
       return std::move(E);
-    if (Error E = InitLock.lock(FileLockRAII::Exclusive))
+    if (Error E = InitLock.lock(sys::fs::LockKind::Exclusive))
       return std::move(E);
     // Retrieve the current size now that we have exclusive access.
     FileSize = FileSizeInfo::get(File);
@@ -166,7 +165,7 @@ Expected<MappedFileRegionBumpPtr> MappedFileRegionBumpPtr::create(
     // We are initializing the file; it may be empty, or may have been shrunk
     // during a previous close.
     // FIXME: Detect a case where someone opened it with a smaller capacity.
-    assert(InitLock.Locked == FileLockRAII::Exclusive);
+    assert(InitLock.Locked == sys::fs::LockKind::Exclusive);
     if (std::error_code EC = sys::fs::resize_file_sparse(FD, Capacity))
       return createFileError(Result.Path, EC);
 
@@ -189,7 +188,7 @@ Expected<MappedFileRegionBumpPtr> MappedFileRegionBumpPtr::create(
   }
 
   if (FileSize->Size == 0) {
-    assert(InitLock.Locked == FileLockRAII::Exclusive);
+    assert(InitLock.Locked == sys::fs::LockKind::Exclusive);
     // We are creating a new file; run the constructor.
     if (Error E = NewFileConstructor(Result))
       return std::move(E);
@@ -203,7 +202,7 @@ Expected<MappedFileRegionBumpPtr> MappedFileRegionBumpPtr::create(
     FileSize = FileSizeInfo::get(File);
     if (!FileSize)
       return createFileError(Result.Path, FileSize.getError());
-    assert(InitLock.Locked == FileLockRAII::Exclusive);
+    assert(InitLock.Locked == sys::fs::LockKind::Exclusive);
     Result.H->AllocatedSize.exchange(FileSize->AllocatedSize);
   }
 

llvm/lib/CAS/OnDiskCommon.cpp

@@ -63,14 +63,15 @@ void cas::ondisk::setMaxMappingSize(uint64_t Size) {
   OnDiskCASMaxMappingSize = Size;
 }
 
-std::error_code cas::ondisk::lockFileThreadSafe(int FD, bool Exclusive) {
+std::error_code cas::ondisk::lockFileThreadSafe(int FD,
+                                                sys::fs::LockKind Kind) {
 #if HAVE_FLOCK
-  if (flock(FD, Exclusive ? LOCK_EX : LOCK_SH) == 0)
+  if (flock(FD, Kind == sys::fs::LockKind::Exclusive ? LOCK_EX : LOCK_SH) == 0)
     return std::error_code();
   return std::error_code(errno, std::generic_category());
 #elif defined(_WIN32)
   // On Windows this implementation is thread-safe.
-  return sys::fs::lockFile(FD, Exclusive);
+  return sys::fs::lockFile(FD, Kind);
 #else
   return make_error_code(std::errc::no_lock_available);
 #endif
@@ -91,12 +92,13 @@ std::error_code cas::ondisk::unlockFileThreadSafe(int FD) {
 
 std::error_code
 cas::ondisk::tryLockFileThreadSafe(int FD, std::chrono::milliseconds Timeout,
-                                   bool Exclusive) {
+                                   sys::fs::LockKind Kind) {
 #if HAVE_FLOCK
   auto Start = std::chrono::steady_clock::now();
   auto End = Start + Timeout;
   do {
-    if (flock(FD, (Exclusive ? LOCK_EX : LOCK_SH) | LOCK_NB) == 0)
+    if (flock(FD, (Kind == sys::fs::LockKind::Exclusive ? LOCK_EX : LOCK_SH) |
+                      LOCK_NB) == 0)
       return std::error_code();
     int Error = errno;
     if (Error == EWOULDBLOCK) {
@@ -109,7 +111,7 @@ cas::ondisk::tryLockFileThreadSafe(int FD, std::chrono::milliseconds Timeout,
   return make_error_code(std::errc::no_lock_available);
 #elif defined(_WIN32)
   // On Windows this implementation is thread-safe.
-  return sys::fs::tryLockFile(FD, Timeout, Exclusive);
+  return sys::fs::tryLockFile(FD, Timeout, Kind);
 #else
   return make_error_code(std::errc::no_lock_available);
 #endif

llvm/lib/CAS/OnDiskCommon.h

@@ -10,6 +10,7 @@
 #define LLVM_LIB_CAS_ONDISKCOMMON_H
 
 #include "llvm/Support/Error.h"
+#include "llvm/Support/FileSystem.h"
 #include <chrono>
 #include <optional>
 
@@ -29,7 +30,8 @@ void setMaxMappingSize(uint64_t Size);
 /// Thread-safe alternative to \c sys::fs::lockFile. This does not support all
 /// the platforms that \c sys::fs::lockFile does, so keep it in the CAS library
 /// for now.
-std::error_code lockFileThreadSafe(int FD, bool Exclusive = true);
+std::error_code lockFileThreadSafe(
+    int FD, llvm::sys::fs::LockKind Kind = llvm::sys::fs::LockKind::Exclusive);
 
 /// Thread-safe alternative to \c sys::fs::unlockFile. This does not support all
 /// the platforms that \c sys::fs::lockFile does, so keep it in the CAS library
@@ -41,7 +43,7 @@ std::error_code unlockFileThreadSafe(int FD);
 /// library for now.
 std::error_code tryLockFileThreadSafe(
     int FD, std::chrono::milliseconds Timeout = std::chrono::milliseconds(0),
-    bool Exclusive = true);
+    llvm::sys::fs::LockKind Kind = llvm::sys::fs::LockKind::Exclusive);
 
 /// Allocate space for the file \p FD on disk, if the filesystem supports it.
 ///

llvm/lib/CAS/UnifiedOnDiskCache.cpp

@@ -348,7 +348,7 @@ UnifiedOnDiskCache::validateIfNeeded(StringRef RootPath, StringRef HashName,
   sys::fs::file_t File = sys::fs::convertFDToNativeFile(FD);
   auto CloseFile = make_scope_exit([&]() { sys::fs::closeFile(File); });
 
-  if (std::error_code EC = lockFileThreadSafe(FD, /*Exclusive=*/true))
+  if (std::error_code EC = lockFileThreadSafe(FD, sys::fs::LockKind::Exclusive))
     return createFileError(PathBuf, EC);
   auto UnlockFD = make_scope_exit([&]() { unlockFileThreadSafe(FD); });
 
@@ -490,7 +490,7 @@ UnifiedOnDiskCache::open(StringRef RootPath, std::optional<uint64_t> SizeLimit,
   // from creating a new chain (essentially while a \p UnifiedOnDiskCache
   // instance holds a shared lock the storage for the primary directory will
   // grow unrestricted).
-  if (std::error_code EC = lockFileThreadSafe(LockFD, /*Exclusive=*/false))
+  if (std::error_code EC = lockFileThreadSafe(LockFD, sys::fs::LockKind::Shared))
     return createFileError(PathBuf, EC);
 
   SmallVector<std::string, 4> DBDirs;
@@ -630,7 +630,7 @@ Error UnifiedOnDiskCache::close(bool CheckSizeLimit) {
   // this \p UnifiedOnDiskCache path is opened.
 
   if (std::error_code EC = tryLockFileThreadSafe(
-          LockFD, std::chrono::milliseconds(0), /*Exclusive=*/true)) {
+          LockFD, std::chrono::milliseconds(0), sys::fs::LockKind::Exclusive)) {
     if (EC == errc::no_lock_available)
       return Error::success(); // couldn't get exclusive lock, give up.
     return createFileError(RootPath, EC);

llvm/lib/Support/Unix/Path.inc

@@ -1265,13 +1265,21 @@ Expected<size_t> readNativeFileSlice(file_t FD, MutableArrayRef<char> Buf,
   return NumRead;
 }
 
-std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout, bool Exclusive) {
+std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout,
+                            LockKind Kind) {
   auto Start = std::chrono::steady_clock::now();
   auto End = Start + Timeout;
   do {
     struct flock Lock;
     memset(&Lock, 0, sizeof(Lock));
-    Lock.l_type = Exclusive ? F_WRLCK : F_RDLCK;
+    switch (Kind) {
+    case LockKind::Exclusive:
+      Lock.l_type = F_WRLCK;
+      break;
+    case LockKind::Shared:
+      Lock.l_type = F_RDLCK;
+      break;
+    }
     Lock.l_whence = SEEK_SET;
     Lock.l_start = 0;
     Lock.l_len = 0;
@@ -1287,10 +1295,17 @@ std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout, bool Excl
   return make_error_code(errc::no_lock_available);
 }
 
-std::error_code lockFile(int FD, bool Exclusive) {
+std::error_code lockFile(int FD, LockKind Kind) {
   struct flock Lock;
   memset(&Lock, 0, sizeof(Lock));
-  Lock.l_type = Exclusive ? F_WRLCK : F_RDLCK;
+  switch (Kind) {
+  case LockKind::Exclusive:
+    Lock.l_type = F_WRLCK;
+    break;
+  case LockKind::Shared:
+    Lock.l_type = F_RDLCK;
+    break;
+  }
   Lock.l_whence = SEEK_SET;
   Lock.l_start = 0;
   Lock.l_len = 0;

llvm/lib/Support/Windows/Path.inc

@@ -1371,8 +1371,9 @@ std::error_code getRealPathFromHandle(file_t Handle,
   return realPathFromHandle(Handle, RealPath);
 }
 
-std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout, bool Exclusive) {
-  DWORD Flags = Exclusive ? LOCKFILE_EXCLUSIVE_LOCK : 0;
+std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout,
+                            LockKind Kind) {
+  DWORD Flags = Kind == LockKind::Exclusive ? LOCKFILE_EXCLUSIVE_LOCK : 0;
   Flags |= LOCKFILE_FAIL_IMMEDIATELY;
   OVERLAPPED OV = {};
   file_t File = convertFDToNativeFile(FD);
@@ -1393,8 +1394,8 @@ std::error_code tryLockFile(int FD, std::chrono::milliseconds Timeout, bool Excl
   return mapWindowsError(ERROR_LOCK_VIOLATION);
 }
 
-std::error_code lockFile(int FD, bool Exclusive) {
-  DWORD Flags = Exclusive ? LOCKFILE_EXCLUSIVE_LOCK : 0;
+std::error_code lockFile(int FD, LockKind Kind) {
+  DWORD Flags = Kind == LockKind::Exclusive ? LOCKFILE_EXCLUSIVE_LOCK : 0;
   OVERLAPPED OV = {};
   file_t File = convertFDToNativeFile(FD);
   if (::LockFileEx(File, Flags, 0, MAXDWORD, MAXDWORD, &OV))

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"
@@ -573,6 +574,88 @@ 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));
+
+    // File should currently be non-exclusive locked by the main process, thus
+    // trying to acquire exclusive lock will fail and trying to acquire
+    // non-exclusive will succeed.
+    EXPECT_TRUE(
+        fs::tryLockFile(FD2, std::chrono::seconds(0), fs::LockKind::Exclusive));
+
+    EXPECT_FALSE(
+        fs::tryLockFile(FD2, std::chrono::seconds(0), fs::LockKind::Shared));
+
+    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::chrono::seconds(0), fs::LockKind::Exclusive));
+
+  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;