1 //===--- LockFileManager.cpp - File-level Locking Utility------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "llvm/Support/LockFileManager.h"
11 #include "llvm/ADT/None.h"
12 #include "llvm/ADT/SmallVector.h"
13 #include "llvm/ADT/StringExtras.h"
14 #include "llvm/Support/Errc.h"
15 #include "llvm/Support/ErrorOr.h"
16 #include "llvm/Support/FileSystem.h"
17 #include "llvm/Support/MemoryBuffer.h"
18 #include "llvm/Support/Signals.h"
19 #include "llvm/Support/raw_ostream.h"
20 #include <cerrno>
21 #include <ctime>
22 #include <memory>
23 #include <sys/stat.h>
24 #include <sys/types.h>
25 #include <system_error>
26 #include <tuple>
27 #if LLVM_ON_WIN32
28 #include <windows.h>
29 #endif
30 #if LLVM_ON_UNIX
31 #include <unistd.h>
32 #endif
33 
34 #if defined(__APPLE__) && defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && (__MAC_OS_X_VERSION_MIN_REQUIRED > 1050)
35 #define USE_OSX_GETHOSTUUID 1
36 #else
37 #define USE_OSX_GETHOSTUUID 0
38 #endif
39 
40 #if USE_OSX_GETHOSTUUID
41 #include <uuid/uuid.h>
42 #endif
43 
44 using namespace llvm;
45 
46 /// \brief Attempt to read the lock file with the given name, if it exists.
47 ///
48 /// \param LockFileName The name of the lock file to read.
49 ///
50 /// \returns The process ID of the process that owns this lock file
51 Optional<std::pair<std::string, int> >
52 LockFileManager::readLockFile(StringRef LockFileName) {
53   // Read the owning host and PID out of the lock file. If it appears that the
54   // owning process is dead, the lock file is invalid.
55   ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
56       MemoryBuffer::getFile(LockFileName);
57   if (!MBOrErr) {
58     sys::fs::remove(LockFileName);
59     return None;
60   }
61   MemoryBuffer &MB = *MBOrErr.get();
62 
63   StringRef Hostname;
64   StringRef PIDStr;
65   std::tie(Hostname, PIDStr) = getToken(MB.getBuffer(), " ");
66   PIDStr = PIDStr.substr(PIDStr.find_first_not_of(" "));
67   int PID;
68   if (!PIDStr.getAsInteger(10, PID)) {
69     auto Owner = std::make_pair(std::string(Hostname), PID);
70     if (processStillExecuting(Owner.first, Owner.second))
71       return Owner;
72   }
73 
74   // Delete the lock file. It's invalid anyway.
75   sys::fs::remove(LockFileName);
76   return None;
77 }
78 
79 static std::error_code getHostID(SmallVectorImpl<char> &HostID) {
80   HostID.clear();
81 
82 #if USE_OSX_GETHOSTUUID
83   // On OS X, use the more stable hardware UUID instead of hostname.
84   struct timespec wait = {1, 0}; // 1 second.
85   uuid_t uuid;
86   if (gethostuuid(uuid, &wait) != 0)
87     return std::error_code(errno, std::system_category());
88 
89   uuid_string_t UUIDStr;
90   uuid_unparse(uuid, UUIDStr);
91   StringRef UUIDRef(UUIDStr);
92   HostID.append(UUIDRef.begin(), UUIDRef.end());
93 
94 #elif LLVM_ON_UNIX
95   char HostName[256];
96   HostName[255] = 0;
97   HostName[0] = 0;
98   gethostname(HostName, 255);
99   StringRef HostNameRef(HostName);
100   HostID.append(HostNameRef.begin(), HostNameRef.end());
101 
102 #else
103   StringRef Dummy("localhost");
104   HostID.append(Dummy.begin(), Dummy.end());
105 #endif
106 
107   return std::error_code();
108 }
109 
110 bool LockFileManager::processStillExecuting(StringRef HostID, int PID) {
111 #if LLVM_ON_UNIX && !defined(__ANDROID__)
112   SmallString<256> StoredHostID;
113   if (getHostID(StoredHostID))
114     return true; // Conservatively assume it's executing on error.
115 
116   // Check whether the process is dead. If so, we're done.
117   if (StoredHostID == HostID && getsid(PID) == -1 && errno == ESRCH)
118     return false;
119 #endif
120 
121   return true;
122 }
123 
124 namespace {
125 
126 /// An RAII helper object for cleanups.
127 class RAIICleanup {
128   std::function<void()> Fn;
129   bool Canceled = false;
130 
131 public:
132   RAIICleanup(std::function<void()> Fn) : Fn(Fn) {}
133 
134   ~RAIICleanup() {
135     if (Canceled)
136       return;
137     Fn();
138   }
139 
140   void cancel() { Canceled = true; }
141 };
142 
143 } // end anonymous namespace
144 
145 LockFileManager::LockFileManager(StringRef FileName)
146 {
147   this->FileName = FileName;
148   if (std::error_code EC = sys::fs::make_absolute(this->FileName)) {
149     std::string S("failed to obtain absolute path for ");
150     S.append(this->FileName.str());
151     setError(EC, S);
152     return;
153   }
154   LockFileName = this->FileName;
155   LockFileName += ".lock";
156 
157   // If the lock file already exists, don't bother to try to create our own
158   // lock file; it won't work anyway. Just figure out who owns this lock file.
159   if ((Owner = readLockFile(LockFileName)))
160     return;
161 
162   // Create a lock file that is unique to this instance.
163   Expected<sys::fs::TempFile> Temp =
164       sys::fs::TempFile::create(LockFileName + "-%%%%%%%%");
165   if (!Temp) {
166     std::error_code EC = errorToErrorCode(Temp.takeError());
167     std::string S("failed to create unique file with prefix ");
168     S.append(LockFileName.str());
169     setError(EC, S);
170     return;
171   }
172   UniqueLockFile = std::move(*Temp);
173 
174   // Make sure we discard the temporary file on exit.
175   RAIICleanup RemoveTempFile([&]() {
176     if (Error E = UniqueLockFile->discard())
177       setError(errorToErrorCode(std::move(E)));
178   });
179 
180   // Write our process ID to our unique lock file.
181   {
182     SmallString<256> HostID;
183     if (auto EC = getHostID(HostID)) {
184       setError(EC, "failed to get host id");
185       return;
186     }
187 
188     raw_fd_ostream Out(UniqueLockFile->FD, /*shouldClose=*/false);
189     Out << HostID << ' ';
190 #if LLVM_ON_UNIX
191     Out << getpid();
192 #else
193     Out << "1";
194 #endif
195     Out.flush();
196 
197     if (Out.has_error()) {
198       // We failed to write out PID, so report the error, remove the
199       // unique lock file, and fail.
200       std::string S("failed to write to ");
201       S.append(UniqueLockFile->TmpName);
202       setError(Out.error(), S);
203       return;
204     }
205   }
206 
207   while (true) {
208     // Create a link from the lock file name. If this succeeds, we're done.
209     std::error_code EC =
210         sys::fs::create_link(UniqueLockFile->TmpName, LockFileName);
211     if (!EC) {
212       RemoveTempFile.cancel();
213       return;
214     }
215 
216     if (EC != errc::file_exists) {
217       std::string S("failed to create link ");
218       raw_string_ostream OSS(S);
219       OSS << LockFileName.str() << " to " << UniqueLockFile->TmpName;
220       setError(EC, OSS.str());
221       return;
222     }
223 
224     // Someone else managed to create the lock file first. Read the process ID
225     // from the lock file.
226     if ((Owner = readLockFile(LockFileName)))
227       return; // RemoveTempFile will delete out our unique lock file.
228 
229     if (!sys::fs::exists(LockFileName)) {
230       // The previous owner released the lock file before we could read it.
231       // Try to get ownership again.
232       continue;
233     }
234 
235     // There is a lock file that nobody owns; try to clean it up and get
236     // ownership.
237     if ((EC = sys::fs::remove(LockFileName))) {
238       std::string S("failed to remove lockfile ");
239       S.append(LockFileName.str());
240       setError(EC, S);
241       return;
242     }
243   }
244 }
245 
246 LockFileManager::LockFileState LockFileManager::getState() const {
247   if (Owner)
248     return LFS_Shared;
249 
250   if (ErrorCode)
251     return LFS_Error;
252 
253   return LFS_Owned;
254 }
255 
256 std::string LockFileManager::getErrorMessage() const {
257   if (ErrorCode) {
258     std::string Str(ErrorDiagMsg);
259     std::string ErrCodeMsg = ErrorCode.message();
260     raw_string_ostream OSS(Str);
261     if (!ErrCodeMsg.empty())
262       OSS << ": " << ErrCodeMsg;
263     return OSS.str();
264   }
265   return "";
266 }
267 
268 LockFileManager::~LockFileManager() {
269   if (getState() != LFS_Owned)
270     return;
271 
272   // Since we own the lock, remove the lock file and our own unique lock file.
273   sys::fs::remove(LockFileName);
274   consumeError(UniqueLockFile->discard());
275 }
276 
277 LockFileManager::WaitForUnlockResult LockFileManager::waitForUnlock() {
278   if (getState() != LFS_Shared)
279     return Res_Success;
280 
281 #if LLVM_ON_WIN32
282   unsigned long Interval = 1;
283 #else
284   struct timespec Interval;
285   Interval.tv_sec = 0;
286   Interval.tv_nsec = 1000000;
287 #endif
288   // Don't wait more than 40s per iteration. Total timeout for the file
289   // to appear is ~1.5 minutes.
290   const unsigned MaxSeconds = 40;
291   do {
292     // Sleep for the designated interval, to allow the owning process time to
293     // finish up and remove the lock file.
294     // FIXME: Should we hook in to system APIs to get a notification when the
295     // lock file is deleted?
296 #if LLVM_ON_WIN32
297     Sleep(Interval);
298 #else
299     nanosleep(&Interval, nullptr);
300 #endif
301 
302     if (sys::fs::access(LockFileName.c_str(), sys::fs::AccessMode::Exist) ==
303         errc::no_such_file_or_directory) {
304       // If the original file wasn't created, somone thought the lock was dead.
305       if (!sys::fs::exists(FileName))
306         return Res_OwnerDied;
307       return Res_Success;
308     }
309 
310     // If the process owning the lock died without cleaning up, just bail out.
311     if (!processStillExecuting((*Owner).first, (*Owner).second))
312       return Res_OwnerDied;
313 
314     // Exponentially increase the time we wait for the lock to be removed.
315 #if LLVM_ON_WIN32
316     Interval *= 2;
317 #else
318     Interval.tv_sec *= 2;
319     Interval.tv_nsec *= 2;
320     if (Interval.tv_nsec >= 1000000000) {
321       ++Interval.tv_sec;
322       Interval.tv_nsec -= 1000000000;
323     }
324 #endif
325   } while (
326 #if LLVM_ON_WIN32
327            Interval < MaxSeconds * 1000
328 #else
329            Interval.tv_sec < (time_t)MaxSeconds
330 #endif
331            );
332 
333   // Give up.
334   return Res_Timeout;
335 }
336 
337 std::error_code LockFileManager::unsafeRemoveLockFile() {
338   return sys::fs::remove(LockFileName);
339 }
340