1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
//===--- LockFileManager.cpp - File-level Locking Utility------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/Support/LockFileManager.h"
#include "llvm/Support/FileSystem.h"
#include "llvm/Support/raw_ostream.h"
#include <fstream>
#include <sys/stat.h>
#include <sys/types.h>
#if LLVM_ON_WIN32
#include <windows.h>
#endif
#if LLVM_ON_UNIX
#include <unistd.h>
#endif
using namespace llvm;
/// \brief Attempt to read the lock file with the given name, if it exists.
///
/// \param LockFileName The name of the lock file to read.
///
/// \returns The process ID of the process that owns this lock file
Optional<std::pair<std::string, int> >
LockFileManager::readLockFile(StringRef LockFileName) {
// Check whether the lock file exists. If not, clearly there's nothing
// to read, so we just return.
bool Exists = false;
if (sys::fs::exists(LockFileName, Exists) || !Exists)
return Optional<std::pair<std::string, int> >();
// Read the owning host and PID out of the lock file. If it appears that the
// owning process is dead, the lock file is invalid.
int PID = 0;
std::string Hostname;
std::ifstream Input(LockFileName.str().c_str());
if (Input >> Hostname >> PID && PID > 0 &&
processStillExecuting(Hostname, PID))
return std::make_pair(Hostname, PID);
// Delete the lock file. It's invalid anyway.
bool Existed;
sys::fs::remove(LockFileName, Existed);
return Optional<std::pair<std::string, int> >();
}
bool LockFileManager::processStillExecuting(StringRef Hostname, int PID) {
#if LLVM_ON_UNIX && !defined(__ANDROID__)
char MyHostname[256];
MyHostname[255] = 0;
MyHostname[0] = 0;
gethostname(MyHostname, 255);
// Check whether the process is dead. If so, we're done.
if (MyHostname == Hostname && getsid(PID) == -1 && errno == ESRCH)
return false;
#endif
return true;
}
LockFileManager::LockFileManager(StringRef FileName)
{
this->FileName = FileName;
LockFileName = 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 (error_code EC
= sys::fs::unique_file(UniqueLockFileName.str(),
UniqueLockFileID,
UniqueLockFileName,
/*makeAbsolute=*/false)) {
Error = EC;
return;
}
// Write our process ID to our unique lock file.
{
raw_fd_ostream Out(UniqueLockFileID, /*shouldClose=*/true);
#if LLVM_ON_UNIX
// FIXME: move getpid() call into LLVM
char hostname[256];
hostname[255] = 0;
hostname[0] = 0;
gethostname(hostname, 255);
Out << hostname << ' ' << getpid();
#else
Out << "localhost 1";
#endif
Out.close();
if (Out.has_error()) {
// We failed to write out PID, so make up an excuse, remove the
// unique lock file, and fail.
Error = make_error_code(errc::no_space_on_device);
bool Existed;
sys::fs::remove(UniqueLockFileName.c_str(), Existed);
return;
}
}
// Create a hard link from the lock file name. If this succeeds, we're done.
error_code EC
= sys::fs::create_hard_link(UniqueLockFileName.str(),
LockFileName.str());
if (EC == errc::success)
return;
// Creating the hard link failed.
#ifdef LLVM_ON_UNIX
// The creation of the hard link may appear to fail, but if stat'ing the
// unique file returns a link count of 2, then we can still declare success.
struct stat StatBuf;
if (stat(UniqueLockFileName.c_str(), &StatBuf) == 0 &&
StatBuf.st_nlink == 2)
return;
#endif
// Someone else managed to create the lock file first. Wipe out our unique
// lock file (it's useless now) and read the process ID from the lock file.
bool Existed;
sys::fs::remove(UniqueLockFileName.str(), Existed);
if ((Owner = readLockFile(LockFileName)))
return;
// There is a lock file that nobody owns; try to clean it up and report
// an error.
sys::fs::remove(LockFileName.str(), Existed);
Error = EC;
}
LockFileManager::LockFileState LockFileManager::getState() const {
if (Owner)
return LFS_Shared;
if (Error)
return LFS_Error;
return LFS_Owned;
}
LockFileManager::~LockFileManager() {
if (getState() != LFS_Owned)
return;
// Since we own the lock, remove the lock file and our own unique lock file.
bool Existed;
sys::fs::remove(LockFileName.str(), Existed);
sys::fs::remove(UniqueLockFileName.str(), Existed);
}
void LockFileManager::waitForUnlock() {
if (getState() != LFS_Shared)
return;
#if LLVM_ON_WIN32
unsigned long Interval = 1;
#else
struct timespec Interval;
Interval.tv_sec = 0;
Interval.tv_nsec = 1000000;
#endif
// Don't wait more than an hour for the file to appear.
const unsigned MaxSeconds = 3600;
bool LockFileGone = false;
do {
// Sleep for the designated interval, to allow the owning process time to
// finish up and remove the lock file.
// FIXME: Should we hook in to system APIs to get a notification when the
// lock file is deleted?
#if LLVM_ON_WIN32
Sleep(Interval);
#else
nanosleep(&Interval, NULL);
#endif
// If the lock file no longer exists, wait for the actual file.
bool Exists = false;
if (!LockFileGone) {
if (!sys::fs::exists(LockFileName.str(), Exists) && !Exists) {
LockFileGone = true;
Exists = false;
}
}
if (LockFileGone) {
if (!sys::fs::exists(FileName.str(), Exists) && Exists)
return;
}
if (!processStillExecuting((*Owner).first, (*Owner).second))
return;
// Exponentially increase the time we wait for the lock to be removed.
#if LLVM_ON_WIN32
Interval *= 2;
#else
Interval.tv_sec *= 2;
Interval.tv_nsec *= 2;
if (Interval.tv_nsec >= 1000000000) {
++Interval.tv_sec;
Interval.tv_nsec -= 1000000000;
}
#endif
} while (
#if LLVM_ON_WIN32
Interval < MaxSeconds * 1000
#else
Interval.tv_sec < (time_t)MaxSeconds
#endif
);
// Give up.
}
|
