1 //===--- LockFileManager.cpp - File-level Locking Utility------------------===// 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 9 #include "llvm/Support/LockFileManager.h" 10 #include "llvm/ADT/SmallVector.h" 11 #include "llvm/ADT/StringExtras.h" 12 #include "llvm/Config/llvm-config.h" // for LLVM_ON_UNIX 13 #include "llvm/Support/Errc.h" 14 #include "llvm/Support/ErrorOr.h" 15 #include "llvm/Support/ExponentialBackoff.h" 16 #include "llvm/Support/FileSystem.h" 17 #include "llvm/Support/MemoryBuffer.h" 18 #include "llvm/Support/Process.h" 19 #include "llvm/Support/Signals.h" 20 #include "llvm/Support/raw_ostream.h" 21 #include <cerrno> 22 #include <chrono> 23 #include <ctime> 24 #include <memory> 25 #include <system_error> 26 #include <tuple> 27 28 #ifdef _WIN32 29 #include <windows.h> 30 #endif 31 #if LLVM_ON_UNIX 32 #include <unistd.h> 33 #endif 34 35 #if defined(__APPLE__) && defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ > 1050) 36 #define USE_OSX_GETHOSTUUID 1 37 #else 38 #define USE_OSX_GETHOSTUUID 0 39 #endif 40 41 #if USE_OSX_GETHOSTUUID 42 #include <uuid/uuid.h> 43 #endif 44 45 using namespace llvm; 46 47 /// Attempt to read the lock file with the given name, if it exists. 48 /// 49 /// \param LockFileName The name of the lock file to read. 50 /// 51 /// \returns The process ID of the process that owns this lock file 52 std::optional<LockFileManager::OwnedByAnother> 53 LockFileManager::readLockFile(StringRef LockFileName) { 54 // Read the owning host and PID out of the lock file. If it appears that the 55 // owning process is dead, the lock file is invalid. 56 ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = 57 MemoryBuffer::getFile(LockFileName); 58 if (!MBOrErr) { 59 sys::fs::remove(LockFileName); 60 return std::nullopt; 61 } 62 MemoryBuffer &MB = *MBOrErr.get(); 63 64 StringRef Hostname; 65 StringRef PIDStr; 66 std::tie(Hostname, PIDStr) = getToken(MB.getBuffer(), " "); 67 PIDStr = PIDStr.substr(PIDStr.find_first_not_of(' ')); 68 int PID; 69 if (!PIDStr.getAsInteger(10, PID)) { 70 OwnedByAnother Owner; 71 Owner.OwnerHostName = Hostname; 72 Owner.OwnerPID = PID; 73 if (processStillExecuting(Owner.OwnerHostName, Owner.OwnerPID)) 74 return Owner; 75 } 76 77 // Delete the lock file. It's invalid anyway. 78 sys::fs::remove(LockFileName); 79 return std::nullopt; 80 } 81 82 static std::error_code getHostID(SmallVectorImpl<char> &HostID) { 83 HostID.clear(); 84 85 #if USE_OSX_GETHOSTUUID 86 // On OS X, use the more stable hardware UUID instead of hostname. 87 struct timespec wait = {1, 0}; // 1 second. 88 uuid_t uuid; 89 if (gethostuuid(uuid, &wait) != 0) 90 return errnoAsErrorCode(); 91 92 uuid_string_t UUIDStr; 93 uuid_unparse(uuid, UUIDStr); 94 StringRef UUIDRef(UUIDStr); 95 HostID.append(UUIDRef.begin(), UUIDRef.end()); 96 97 #elif LLVM_ON_UNIX 98 char HostName[256]; 99 HostName[255] = 0; 100 HostName[0] = 0; 101 gethostname(HostName, 255); 102 StringRef HostNameRef(HostName); 103 HostID.append(HostNameRef.begin(), HostNameRef.end()); 104 105 #else 106 StringRef Dummy("localhost"); 107 HostID.append(Dummy.begin(), Dummy.end()); 108 #endif 109 110 return std::error_code(); 111 } 112 113 bool LockFileManager::processStillExecuting(StringRef HostID, int PID) { 114 #if LLVM_ON_UNIX && !defined(__ANDROID__) 115 SmallString<256> StoredHostID; 116 if (getHostID(StoredHostID)) 117 return true; // Conservatively assume it's executing on error. 118 119 // Check whether the process is dead. If so, we're done. 120 if (StoredHostID == HostID && getsid(PID) == -1 && errno == ESRCH) 121 return false; 122 #endif 123 124 return true; 125 } 126 127 namespace { 128 129 /// An RAII helper object ensure that the unique lock file is removed. 130 /// 131 /// Ensures that if there is an error or a signal before we finish acquiring the 132 /// lock, the unique file will be removed. And if we successfully take the lock, 133 /// the signal handler is left in place so that signals while the lock is held 134 /// will remove the unique lock file. The caller should ensure there is a 135 /// matching call to sys::DontRemoveFileOnSignal when the lock is released. 136 class RemoveUniqueLockFileOnSignal { 137 StringRef Filename; 138 bool RemoveImmediately; 139 public: 140 RemoveUniqueLockFileOnSignal(StringRef Name) 141 : Filename(Name), RemoveImmediately(true) { 142 sys::RemoveFileOnSignal(Filename, nullptr); 143 } 144 145 ~RemoveUniqueLockFileOnSignal() { 146 if (!RemoveImmediately) { 147 // Leave the signal handler enabled. It will be removed when the lock is 148 // released. 149 return; 150 } 151 sys::fs::remove(Filename); 152 sys::DontRemoveFileOnSignal(Filename); 153 } 154 155 void lockAcquired() { RemoveImmediately = false; } 156 }; 157 158 } // end anonymous namespace 159 160 LockFileManager::LockFileManager(StringRef FileName) 161 : FileName(FileName), Owner(OwnerUnknown{}) {} 162 163 Expected<bool> LockFileManager::tryLock() { 164 assert(std::holds_alternative<OwnerUnknown>(Owner) && 165 "lock has already been attempted"); 166 167 SmallString<128> AbsoluteFileName(FileName); 168 if (std::error_code EC = sys::fs::make_absolute(AbsoluteFileName)) 169 return createStringError(EC, "failed to obtain absolute path for " + 170 AbsoluteFileName); 171 LockFileName = AbsoluteFileName; 172 LockFileName += ".lock"; 173 174 // If the lock file already exists, don't bother to try to create our own 175 // lock file; it won't work anyway. Just figure out who owns this lock file. 176 if (auto LockFileOwner = readLockFile(LockFileName)) { 177 Owner = std::move(*LockFileOwner); 178 return false; 179 } 180 181 // Create a lock file that is unique to this instance. 182 UniqueLockFileName = LockFileName; 183 UniqueLockFileName += "-%%%%%%%%"; 184 int UniqueLockFileID; 185 if (std::error_code EC = sys::fs::createUniqueFile( 186 UniqueLockFileName, UniqueLockFileID, UniqueLockFileName)) 187 return createStringError(EC, "failed to create unique file " + 188 UniqueLockFileName); 189 190 // Clean up the unique file on signal or scope exit. 191 RemoveUniqueLockFileOnSignal RemoveUniqueFile(UniqueLockFileName); 192 193 // Write our process ID to our unique lock file. 194 { 195 SmallString<256> HostID; 196 if (auto EC = getHostID(HostID)) 197 return createStringError(EC, "failed to get host id"); 198 199 raw_fd_ostream Out(UniqueLockFileID, /*shouldClose=*/true); 200 Out << HostID << ' ' << sys::Process::getProcessId(); 201 Out.close(); 202 203 if (Out.has_error()) { 204 // We failed to write out PID, so report the error and fail. 205 Error Err = createStringError(Out.error(), 206 "failed to write to " + UniqueLockFileName); 207 // Don't call report_fatal_error. 208 Out.clear_error(); 209 return std::move(Err); 210 } 211 } 212 213 while (true) { 214 // Create a link from the lock file name. If this succeeds, we're done. 215 std::error_code EC = 216 sys::fs::create_link(UniqueLockFileName, LockFileName); 217 if (!EC) { 218 RemoveUniqueFile.lockAcquired(); 219 Owner = OwnedByUs{}; 220 return true; 221 } 222 223 if (EC != errc::file_exists) 224 return createStringError(EC, "failed to create link " + LockFileName + 225 " to " + UniqueLockFileName); 226 227 // Someone else managed to create the lock file first. Read the process ID 228 // from the lock file. 229 if (auto LockFileOwner = readLockFile(LockFileName)) { 230 Owner = std::move(*LockFileOwner); 231 return false; 232 } 233 234 if (!sys::fs::exists(LockFileName)) { 235 // The previous owner released the lock file before we could read it. 236 // Try to get ownership again. 237 continue; 238 } 239 240 // There is a lock file that nobody owns; try to clean it up and get 241 // ownership. 242 if ((EC = sys::fs::remove(LockFileName))) 243 return createStringError(EC, "failed to remove lockfile " + 244 UniqueLockFileName); 245 } 246 } 247 248 LockFileManager::~LockFileManager() { 249 if (!std::holds_alternative<OwnedByUs>(Owner)) 250 return; 251 252 // Since we own the lock, remove the lock file and our own unique lock file. 253 sys::fs::remove(LockFileName); 254 sys::fs::remove(UniqueLockFileName); 255 // The unique file is now gone, so remove it from the signal handler. This 256 // matches a sys::RemoveFileOnSignal() in LockFileManager(). 257 sys::DontRemoveFileOnSignal(UniqueLockFileName); 258 } 259 260 WaitForUnlockResult 261 LockFileManager::waitForUnlockFor(std::chrono::seconds MaxSeconds) { 262 auto *LockFileOwner = std::get_if<OwnedByAnother>(&Owner); 263 assert(LockFileOwner && 264 "waiting for lock to be unlocked without knowing the owner"); 265 266 // Since we don't yet have an event-based method to wait for the lock file, 267 // use randomized exponential backoff, similar to Ethernet collision 268 // algorithm. This improves performance on machines with high core counts 269 // when the file lock is heavily contended by multiple clang processes 270 using namespace std::chrono_literals; 271 ExponentialBackoff Backoff(MaxSeconds, 10ms, 500ms); 272 273 // Wait first as this is only called when the lock is known to be held. 274 while (Backoff.waitForNextAttempt()) { 275 // FIXME: implement event-based waiting 276 if (sys::fs::access(LockFileName.c_str(), sys::fs::AccessMode::Exist) == 277 errc::no_such_file_or_directory) 278 return WaitForUnlockResult::Success; 279 280 // If the process owning the lock died without cleaning up, just bail out. 281 if (!processStillExecuting(LockFileOwner->OwnerHostName, 282 LockFileOwner->OwnerPID)) 283 return WaitForUnlockResult::OwnerDied; 284 } 285 286 // Give up. 287 return WaitForUnlockResult::Timeout; 288 } 289 290 std::error_code LockFileManager::unsafeMaybeUnlock() { 291 return sys::fs::remove(LockFileName); 292 } 293