[work in progress, don't commit]

[akhuang]

Summary

This reverts commit 881ba104656c40098d4bc90c52613c08136f0fe1.

llvm/include/llvm/Support/LockFileManager.h

 //===--- LockFileManager.h - File-level locking utility ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_SUPPORT_LOCKFILEMANAGER_H
 #define LLVM_SUPPORT_LOCKFILEMANAGER_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/Support/FileSystem.h"
 #include <system_error>
 #include <utility> // for std::pair
 
 namespace llvm {
 class StringRef;
 
 /// Class that manages the creation of a lock file to aid
 /// implicit coordination between different processes.
enum WaitForUnlockResult {
     Res_OwnerDied,
     /// Reached timeout while waiting for the owner to release the lock.
     Res_Timeout
   };
 
 private:
   SmallString<128> FileName;
   SmallString<128> LockFileName;
-  SmallString<128> UniqueLockFileName;
+  Optional<sys::fs::TempFile> UniqueLockFile;
 
   Optional<std::pair<std::string, int> > Owner;
   std::error_code ErrorCode;
   std::string ErrorDiagMsg;
 
   LockFileManager(const LockFileManager &) = delete;
   LockFileManager &operator=(const LockFileManager &) = delete;
 

llvm/lib/Support/LockFileManager.cpp

 //===--- LockFileManager.cpp - File-level Locking Utility------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Support/LockFileManager.h"
 #include "llvm/ADT/None.h"
+#include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Config/llvm-config.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cerrno>
#if LLVM_ON_UNIX && !defined(__ANDROID__)
   // Check whether the process is dead. If so, we're done.
   if (StoredHostID == HostID && getsid(PID) == -1 && errno == ESRCH)
     return false;
 #endif
 
   return true;
 }
 
-namespace {
-
-/// An RAII helper object ensure that the unique lock file is removed.
-///
-/// Ensures that if there is an error or a signal before we finish acquiring the
-/// lock, the unique file will be removed. And if we successfully take the lock,
-/// the signal handler is left in place so that signals while the lock is held
-/// will remove the unique lock file. The caller should ensure there is a
-/// matching call to sys::DontRemoveFileOnSignal when the lock is released.
-class RemoveUniqueLockFileOnSignal {
-  StringRef Filename;
-  bool RemoveImmediately;
-public:
-  RemoveUniqueLockFileOnSignal(StringRef Name)
-  : Filename(Name), RemoveImmediately(true) {
-    sys::RemoveFileOnSignal(Filename, nullptr);
-  }
-
-  ~RemoveUniqueLockFileOnSignal() {
-    if (!RemoveImmediately) {
-      // Leave the signal handler enabled. It will be removed when the lock is
-      // released.
-      return;
-    }
-    sys::fs::remove(Filename);
-    sys::DontRemoveFileOnSignal(Filename);
-  }
-
-  void lockAcquired() { RemoveImmediately = false; }
-};
-
-} // end anonymous namespace
-
 LockFileManager::LockFileManager(StringRef FileName)
 {
   this->FileName = FileName;
   if (std::error_code EC = sys::fs::make_absolute(this->FileName)) {
     std::string S("failed to obtain absolute path for ");
     S.append(std::string(this->FileName.str()));
     setError(EC, S);
     return;
   }
   LockFileName = this->FileName;
   LockFileName += ".lock";
 
   // If the lock file already exists, don't bother to try to create our own
   // lock file; it won't work anyway. Just figure out who owns this lock file.
   if ((Owner = readLockFile(LockFileName)))
     return;
 
   // Create a lock file that is unique to this instance.
-  UniqueLockFileName = LockFileName;
-  UniqueLockFileName += "-%%%%%%%%";
-  int UniqueLockFileID;
-  if (std::error_code EC = sys::fs::createUniqueFile(
-          UniqueLockFileName, UniqueLockFileID, UniqueLockFileName)) {
-    std::string S("failed to create unique file ");
-    S.append(std::string(UniqueLockFileName.str()));
+  // UniqueLockFile = LockFileName;
+  // UniqueLockFile += "-%%%%%%%%";
+  int UniqueLockFileID = 0;
+  Expected<sys::fs::TempFile> Temp =
+      sys::fs::TempFile::create(LockFileName + "-%%%%%%%%");
+  // if (std::error_code EC = sys::fs::createUniqueFile(
+  // UniqueLockFile, UniqueLockFileID, UniqueLockFile)) {
+  if (!Temp) {
+    std::error_code EC = errorToErrorCode(Temp.takeError());
+    std::string S("failed to create unique file with prefix ");
+    S.append(std::string(LockFileName.str()));
     setError(EC, S);
     return;
   }
+  UniqueLockFile = std::move(*Temp);
+
+  // Make sure we discard the temporary file on exit.
+  auto RemoveTempFile = llvm::make_scope_exit([&]() {
+    if (Error E = UniqueLockFile->discard())
+      setError(errorToErrorCode(std::move(E)));
+  });
 
   // Write our process ID to our unique lock file.
   {
     SmallString<256> HostID;
     if (auto EC = getHostID(HostID)) {
       setError(EC, "failed to get host id");
       return;
     }
 
     raw_fd_ostream Out(UniqueLockFileID, /*shouldClose=*/true);
     Out << HostID << ' ' << sys::Process::getProcessId();
     Out.close();
 
     if (Out.has_error()) {
       // We failed to write out PID, so report the error, remove the
       // unique lock file, and fail.
       std::string S("failed to write to ");
-      S.append(std::string(UniqueLockFileName.str()));
+      S.append(UniqueLockFile->TmpName);
       setError(Out.error(), S);
-      sys::fs::remove(UniqueLockFileName);
       return;
     }
   }
 
-  // Clean up the unique file on signal, which also releases the lock if it is
-  // held since the .lock symlink will point to a nonexistent file.
-  RemoveUniqueLockFileOnSignal RemoveUniqueFile(UniqueLockFileName);
-
   while (true) {
     // Create a link from the lock file name. If this succeeds, we're done.
     std::error_code EC =
-        sys::fs::create_link(UniqueLockFileName, LockFileName);
+        sys::fs::create_link(UniqueLockFile->TmpName, LockFileName);
     if (!EC) {
-      RemoveUniqueFile.lockAcquired();
+      RemoveTempFile.release();
       return;
     }
 
     if (EC != errc::file_exists) {
       std::string S("failed to create link ");
       raw_string_ostream OSS(S);
-      OSS << LockFileName.str() << " to " << UniqueLockFileName.str();
+      OSS << LockFileName.str() << " to " << UniqueLockFile->TmpName;
       setError(EC, OSS.str());
       return;
     }
 
     // Someone else managed to create the lock file first. Read the process ID
     // from the lock file.
-    if ((Owner = readLockFile(LockFileName))) {
-      // Wipe out our unique lock file (it's useless now)
-      sys::fs::remove(UniqueLockFileName);
-      return;
-    }
+    if ((Owner = readLockFile(LockFileName)))
+      return; // RemoveTempFile will delete out our unique lock file.
 
     if (!sys::fs::exists(LockFileName)) {
       // The previous owner released the lock file before we could read it.
       // Try to get ownership again.
       continue;
     }
 
     // There is a lock file that nobody owns; try to clean it up and get
     // ownership.
     if ((EC = sys::fs::remove(LockFileName))) {
       std::string S("failed to remove lockfile ");
-      S.append(std::string(UniqueLockFileName.str()));
+      S.append(UniqueLockFile->TmpName);
       setError(EC, S);
       return;
     }
   }
 }
 
 LockFileManager::LockFileState LockFileManager::getState() const {
   if (Owner)

 }
 
 LockFileManager::~LockFileManager() {
   if (getState() != LFS_Owned)
     return;
 
   // Since we own the lock, remove the lock file and our own unique lock file.
   sys::fs::remove(LockFileName);
-  sys::fs::remove(UniqueLockFileName);
-  // The unique file is now gone, so remove it from the signal handler. This
-  // matches a sys::RemoveFileOnSignal() in LockFileManager().
-  sys::DontRemoveFileOnSignal(UniqueLockFileName);
+  consumeError(UniqueLockFile->discard());
 }
 
 LockFileManager::WaitForUnlockResult
 LockFileManager::waitForUnlock(const unsigned MaxSeconds) {
   if (getState() != LFS_Shared)
     return Res_Success;
 
   // Since we don't yet have an event-based method to wait for the lock file,

llvm/lib/Support/Path.cpp

if (RenameEC ==
       std::error_code(ERROR_NOT_SAME_DEVICE, std::system_category())) {
       RenameEC = copy_file(TmpName, Name);
       setDeleteDisposition(H, true);
     }
   }
 
   // If we can't rename, discard the temporary file.
   if (RenameEC)
-    setDeleteDisposition(H, true);
+    removeFD(FD);
 #else
   std::error_code RenameEC = fs::rename(TmpName, Name);
   if (RenameEC) {
     // If we can't rename, try to copy to work around cross-device link issues.
     RenameEC = sys::fs::copy_file(TmpName, Name);
     // If we can't rename or copy, discard the temporary file.
     if (RenameEC)
       remove(TmpName);
#endif
   return errorCodeToError(RenameEC);
 }
 
 Error TempFile::keep() {
   assert(!Done);
   Done = true;
 
 #ifdef _WIN32
-  auto H = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
-  if (std::error_code EC = setDeleteDisposition(H, false))
+  if (std::error_code EC = cancelDeleteOnClose(FD))
     return errorCodeToError(EC);
 #else
   sys::DontRemoveFileOnSignal(TmpName);
 #endif
 
   TmpName = "";
 
   if (close(FD) == -1) {

llvm/lib/Support/Windows/Path.inc

static std::error_code setDeleteDisposition(HANDLE Handle, bool Delete) {
   // flag.
   Disposition.DeleteFile = true;
   if (!SetFileInformationByHandle(Handle, FileDispositionInfo, &Disposition,
                                   sizeof(Disposition)))
     return mapWindowsError(::GetLastError());
   return std::error_code();
 }
 
+std::error_code removeFD(int FD) {
+  HANDLE Handle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
+  return setDeleteDisposition(Handle, true);
+}
+
+static std::error_code cancelDeleteOnClose(int &FD) {
+  HANDLE Handle = reinterpret_cast<HANDLE>(_get_osfhandle(FD));
+  SmallVector<wchar_t, MAX_PATH> Name;
+  if (std::error_code EC = realPathFromHandle(Handle, Name))
+    return EC;
+  HANDLE NewHandle =
+      ::CreateFileW(Name.data(), GENERIC_READ | GENERIC_WRITE | DELETE,
+                    FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                    NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
+  if (NewHandle == INVALID_HANDLE_VALUE)
+    return mapWindowsError(::GetLastError());
+  if (close(FD))
+    return mapWindowsError(::GetLastError());
+
+  if (std::error_code EC = setDeleteDisposition(NewHandle, false))
+    return EC;
+
+  FD = ::_open_osfhandle(intptr_t(NewHandle), 0);
+  if (FD == -1) {
+    ::CloseHandle(NewHandle);
+    return mapWindowsError(ERROR_INVALID_HANDLE);
+  }
+  return std::error_code();
+}
+
 static std::error_code rename_internal(HANDLE FromHandle, const Twine &To,
                                        bool ReplaceIfExists) {
   SmallVector<wchar_t, 0> ToWide;
   if (auto EC = widenPath(To, ToWide))
     return EC;
 
   std::vector<char> RenameInfoBuf(sizeof(FILE_RENAME_INFO) - sizeof(wchar_t) +
                                   (ToWide.size() * sizeof(wchar_t)));