Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===--- LockFileManager.h - File-level locking utility ---------*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. #ifndef LLVM_SUPPORT_LOCKFILEMANAGER_H
  9. #define LLVM_SUPPORT_LOCKFILEMANAGER_H
  10.  
  11. #include "llvm/ADT/SmallString.h"
  12. #include <optional>
  13. #include <system_error>
  14. #include <utility> // for std::pair
  15.  
  16. namespace llvm {
  17. class StringRef;
  18.  
  19. /// Class that manages the creation of a lock file to aid
  20. /// implicit coordination between different processes.
  21. ///
  22. /// The implicit coordination works by creating a ".lock" file alongside
  23. /// the file that we're coordinating for, using the atomicity of the file
  24. /// system to ensure that only a single process can create that ".lock" file.
  25. /// When the lock file is removed, the owning process has finished the
  26. /// operation.
  27. class LockFileManager {
  28. public:
  29.   /// Describes the state of a lock file.
  30.   enum LockFileState {
  31.     /// The lock file has been created and is owned by this instance
  32.     /// of the object.
  33.     LFS_Owned,
  34.     /// The lock file already exists and is owned by some other
  35.     /// instance.
  36.     LFS_Shared,
  37.     /// An error occurred while trying to create or find the lock
  38.     /// file.
  39.     LFS_Error
  40.   };
  41.  
  42.   /// Describes the result of waiting for the owner to release the lock.
  43.   enum WaitForUnlockResult {
  44.     /// The lock was released successfully.
  45.     Res_Success,
  46.     /// Owner died while holding the lock.
  47.     Res_OwnerDied,
  48.     /// Reached timeout while waiting for the owner to release the lock.
  49.     Res_Timeout
  50.   };
  51.  
  52. private:
  53.   SmallString<128> FileName;
  54.   SmallString<128> LockFileName;
  55.   SmallString<128> UniqueLockFileName;
  56.  
  57.   std::optional<std::pair<std::string, int>> Owner;
  58.   std::error_code ErrorCode;
  59.   std::string ErrorDiagMsg;
  60.  
  61.   LockFileManager(const LockFileManager &) = delete;
  62.   LockFileManager &operator=(const LockFileManager &) = delete;
  63.  
  64.   static std::optional<std::pair<std::string, int>>
  65.   readLockFile(StringRef LockFileName);
  66.  
  67.   static bool processStillExecuting(StringRef Hostname, int PID);
  68.  
  69. public:
  70.  
  71.   LockFileManager(StringRef FileName);
  72.   ~LockFileManager();
  73.  
  74.   /// Determine the state of the lock file.
  75.   LockFileState getState() const;
  76.  
  77.   operator LockFileState() const { return getState(); }
  78.  
  79.   /// For a shared lock, wait until the owner releases the lock.
  80.   /// Total timeout for the file to appear is ~1.5 minutes.
  81.   /// \param MaxSeconds the maximum total wait time in seconds.
  82.   WaitForUnlockResult waitForUnlock(const unsigned MaxSeconds = 90);
  83.  
  84.   /// Remove the lock file.  This may delete a different lock file than
  85.   /// the one previously read if there is a race.
  86.   std::error_code unsafeRemoveLockFile();
  87.  
  88.   /// Get error message, or "" if there is no error.
  89.   std::string getErrorMessage() const;
  90.  
  91.   /// Set error and error message
  92.   void setError(const std::error_code &EC, StringRef ErrorMsg = "") {
  93.     ErrorCode = EC;
  94.     ErrorDiagMsg = ErrorMsg.str();
  95.   }
  96. };
  97.  
  98. } // end namespace llvm
  99.  
  100. #endif // LLVM_SUPPORT_LOCKFILEMANAGER_H
  101.