Branch data Line data Source code
1 : : // Copyright (c) 2011-2021 The Bitcoin Core developers
2 : : // Distributed under the MIT software license, see the accompanying
3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 : :
5 : : #if defined(HAVE_CONFIG_H)
6 : : #include <config/bitcoin-config.h>
7 : : #endif
8 : :
9 : : #include <sync.h>
10 : :
11 : : #include <logging.h>
12 : : #include <tinyformat.h>
13 : : #include <util/strencodings.h>
14 : : #include <util/threadnames.h>
15 : :
16 : : #include <map>
17 : : #include <mutex>
18 : : #include <set>
19 : : #include <system_error>
20 : : #include <thread>
21 : : #include <type_traits>
22 : : #include <unordered_map>
23 : : #include <utility>
24 : : #include <vector>
25 : :
26 : : #ifdef DEBUG_LOCKORDER
27 : : //
28 : : // Early deadlock detection.
29 : : // Problem being solved:
30 : : // Thread 1 locks A, then B, then C
31 : : // Thread 2 locks D, then C, then A
32 : : // --> may result in deadlock between the two threads, depending on when they run.
33 : : // Solution implemented here:
34 : : // Keep track of pairs of locks: (A before B), (A before C), etc.
35 : : // Complain if any thread tries to lock in a different order.
36 : : //
37 : :
38 : : struct CLockLocation {
39 : : CLockLocation(
40 : : const char* pszName,
41 : : const char* pszFile,
42 : : int nLine,
43 : : bool fTryIn,
44 : : const std::string& thread_name)
45 : : : fTry(fTryIn),
46 : : mutexName(pszName),
47 : : sourceFile(pszFile),
48 : : m_thread_name(thread_name),
49 : : sourceLine(nLine) {}
50 : :
51 : : std::string ToString() const
52 : : {
53 : : return strprintf(
54 : : "'%s' in %s:%s%s (in thread '%s')",
55 : : mutexName, sourceFile, sourceLine, (fTry ? " (TRY)" : ""), m_thread_name);
56 : : }
57 : :
58 : : std::string Name() const
59 : : {
60 : : return mutexName;
61 : : }
62 : :
63 : : private:
64 : : bool fTry;
65 : : std::string mutexName;
66 : : std::string sourceFile;
67 : : const std::string& m_thread_name;
68 : : int sourceLine;
69 : : };
70 : :
71 : : using LockStackItem = std::pair<void*, CLockLocation>;
72 : : using LockStack = std::vector<LockStackItem>;
73 : : using LockStacks = std::unordered_map<std::thread::id, LockStack>;
74 : 0 :
75 : : using LockPair = std::pair<void*, void*>;
76 : : using LockOrders = std::map<LockPair, LockStack>;
77 : : using InvLockOrders = std::set<LockPair>;
78 : :
79 : : struct LockData {
80 : : LockStacks m_lock_stacks;
81 : : LockOrders lockorders;
82 : : InvLockOrders invlockorders;
83 : : std::mutex dd_mutex;
84 : : };
85 : :
86 : : LockData& GetLockData() {
87 : : // This approach guarantees that the object is not destroyed until after its last use.
88 : : // The operating system automatically reclaims all the memory in a program's heap when that program exits.
89 : : // Since the ~LockData() destructor is never called, the LockData class and all
90 : : // its subclasses must have implicitly-defined destructors.
91 : : static LockData& lock_data = *new LockData();
92 : : return lock_data;
93 : : }
94 : :
95 : : static void potential_deadlock_detected(const LockPair& mismatch, const LockStack& s1, const LockStack& s2)
96 : : {
97 : : LogPrintf("POTENTIAL DEADLOCK DETECTED\n");
98 : : LogPrintf("Previous lock order was:\n");
99 : : for (const LockStackItem& i : s1) {
100 : : std::string prefix{};
101 : : if (i.first == mismatch.first) {
102 : : prefix = " (1)";
103 : : }
104 : : if (i.first == mismatch.second) {
105 : : prefix = " (2)";
106 : : }
107 : : LogPrintf("%s %s\n", prefix, i.second.ToString());
108 : : }
109 : :
110 : : std::string mutex_a, mutex_b;
111 : : LogPrintf("Current lock order is:\n");
112 : : for (const LockStackItem& i : s2) {
113 : : std::string prefix{};
114 : : if (i.first == mismatch.first) {
115 : : prefix = " (1)";
116 : : mutex_a = i.second.Name();
117 : : }
118 : : if (i.first == mismatch.second) {
119 : : prefix = " (2)";
120 : : mutex_b = i.second.Name();
121 : : }
122 : : LogPrintf("%s %s\n", prefix, i.second.ToString());
123 : : }
124 : : if (g_debug_lockorder_abort) {
125 : : tfm::format(std::cerr, "Assertion failed: detected inconsistent lock order for %s, details in debug log.\n", s2.back().second.ToString());
126 : : abort();
127 : : }
128 : : throw std::logic_error(strprintf("potential deadlock detected: %s -> %s -> %s", mutex_b, mutex_a, mutex_b));
129 : : }
130 : :
131 : : static void double_lock_detected(const void* mutex, const LockStack& lock_stack)
132 : : {
133 : : LogPrintf("DOUBLE LOCK DETECTED\n");
134 : : LogPrintf("Lock order:\n");
135 : : for (const LockStackItem& i : lock_stack) {
136 : : std::string prefix{};
137 : : if (i.first == mutex) {
138 : : prefix = " (*)";
139 : : }
140 : : LogPrintf("%s %s\n", prefix, i.second.ToString());
141 : : }
142 : : if (g_debug_lockorder_abort) {
143 : : tfm::format(std::cerr,
144 : : "Assertion failed: detected double lock for %s, details in debug log.\n",
145 : : lock_stack.back().second.ToString());
146 : : abort();
147 : : }
148 : : throw std::logic_error("double lock detected");
149 : : }
150 : :
151 : : template <typename MutexType>
152 : : static void push_lock(MutexType* c, const CLockLocation& locklocation)
153 : : {
154 : : constexpr bool is_recursive_mutex =
155 : : std::is_base_of<RecursiveMutex, MutexType>::value ||
156 : : std::is_base_of<std::recursive_mutex, MutexType>::value;
157 : :
158 : : LockData& lockdata = GetLockData();
159 : : std::lock_guard<std::mutex> lock(lockdata.dd_mutex);
160 : :
161 : : LockStack& lock_stack = lockdata.m_lock_stacks[std::this_thread::get_id()];
162 : : lock_stack.emplace_back(c, locklocation);
163 : : for (size_t j = 0; j < lock_stack.size() - 1; ++j) {
164 : : const LockStackItem& i = lock_stack[j];
165 : : if (i.first == c) {
166 : : if (is_recursive_mutex) {
167 : : break;
168 : : }
169 : : // It is not a recursive mutex and it appears in the stack two times:
170 : : // at position `j` and at the end (which we added just before this loop).
171 : : // Can't allow locking the same (non-recursive) mutex two times from the
172 : : // same thread as that results in an undefined behavior.
173 : : auto lock_stack_copy = lock_stack;
174 : : lock_stack.pop_back();
175 : : double_lock_detected(c, lock_stack_copy);
176 : : // double_lock_detected() does not return.
177 : : }
178 : :
179 : : const LockPair p1 = std::make_pair(i.first, c);
180 : : if (lockdata.lockorders.count(p1))
181 : : continue;
182 : :
183 : : const LockPair p2 = std::make_pair(c, i.first);
184 : : if (lockdata.lockorders.count(p2)) {
185 : : auto lock_stack_copy = lock_stack;
186 : : lock_stack.pop_back();
187 : : potential_deadlock_detected(p1, lockdata.lockorders[p2], lock_stack_copy);
188 : : // potential_deadlock_detected() does not return.
189 : : }
190 : :
191 : : lockdata.lockorders.emplace(p1, lock_stack);
192 : : lockdata.invlockorders.insert(p2);
193 : : }
194 : : }
195 : :
196 : : static void pop_lock()
197 : : {
198 : : LockData& lockdata = GetLockData();
199 : : std::lock_guard<std::mutex> lock(lockdata.dd_mutex);
200 : :
201 : : LockStack& lock_stack = lockdata.m_lock_stacks[std::this_thread::get_id()];
202 : : lock_stack.pop_back();
203 : : if (lock_stack.empty()) {
204 : : lockdata.m_lock_stacks.erase(std::this_thread::get_id());
205 : : }
206 : : }
207 : :
208 : : template <typename MutexType>
209 : : void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry)
210 : : {
211 : : push_lock(cs, CLockLocation(pszName, pszFile, nLine, fTry, util::ThreadGetInternalName()));
212 : : }
213 : : template void EnterCritical(const char*, const char*, int, Mutex*, bool);
214 : : template void EnterCritical(const char*, const char*, int, RecursiveMutex*, bool);
215 : : template void EnterCritical(const char*, const char*, int, std::mutex*, bool);
216 : : template void EnterCritical(const char*, const char*, int, std::recursive_mutex*, bool);
217 : :
218 : : void CheckLastCritical(void* cs, std::string& lockname, const char* guardname, const char* file, int line)
219 : : {
220 : : LockData& lockdata = GetLockData();
221 : : std::lock_guard<std::mutex> lock(lockdata.dd_mutex);
222 : :
223 : : const LockStack& lock_stack = lockdata.m_lock_stacks[std::this_thread::get_id()];
224 : : if (!lock_stack.empty()) {
225 : : const auto& lastlock = lock_stack.back();
226 : : if (lastlock.first == cs) {
227 : : lockname = lastlock.second.Name();
228 : : return;
229 : : }
230 : : }
231 : :
232 : : LogPrintf("INCONSISTENT LOCK ORDER DETECTED\n");
233 : : LogPrintf("Current lock order (least recent first) is:\n");
234 : : for (const LockStackItem& i : lock_stack) {
235 : : LogPrintf(" %s\n", i.second.ToString());
236 : : }
237 : : if (g_debug_lockorder_abort) {
238 : : tfm::format(std::cerr, "%s:%s %s was not most recent critical section locked, details in debug log.\n", file, line, guardname);
239 : : abort();
240 : : }
241 : : throw std::logic_error(strprintf("%s was not most recent critical section locked", guardname));
242 : : }
243 : :
244 : : void LeaveCritical()
245 : : {
246 : : pop_lock();
247 : : }
248 : :
249 : : std::string LocksHeld()
250 : : {
251 : : LockData& lockdata = GetLockData();
252 : : std::lock_guard<std::mutex> lock(lockdata.dd_mutex);
253 : :
254 : : const LockStack& lock_stack = lockdata.m_lock_stacks[std::this_thread::get_id()];
255 : : std::string result;
256 : : for (const LockStackItem& i : lock_stack)
257 : : result += i.second.ToString() + std::string("\n");
258 : : return result;
259 : : }
260 : :
261 : : static bool LockHeld(void* mutex)
262 : : {
263 : : LockData& lockdata = GetLockData();
264 : : std::lock_guard<std::mutex> lock(lockdata.dd_mutex);
265 : :
266 : : const LockStack& lock_stack = lockdata.m_lock_stacks[std::this_thread::get_id()];
267 : : for (const LockStackItem& i : lock_stack) {
268 : : if (i.first == mutex) return true;
269 : : }
270 : :
271 : : return false;
272 : : }
273 : :
274 : : template <typename MutexType>
275 : : void AssertLockHeldInternal(const char* pszName, const char* pszFile, int nLine, MutexType* cs)
276 : : {
277 : : if (LockHeld(cs)) return;
278 : : tfm::format(std::cerr, "Assertion failed: lock %s not held in %s:%i; locks held:\n%s", pszName, pszFile, nLine, LocksHeld());
279 : : abort();
280 : : }
281 : : template void AssertLockHeldInternal(const char*, const char*, int, Mutex*);
282 : : template void AssertLockHeldInternal(const char*, const char*, int, RecursiveMutex*);
283 : :
284 : : template <typename MutexType>
285 : : void AssertLockNotHeldInternal(const char* pszName, const char* pszFile, int nLine, MutexType* cs)
286 : : {
287 : : if (!LockHeld(cs)) return;
288 : : tfm::format(std::cerr, "Assertion failed: lock %s held in %s:%i; locks held:\n%s", pszName, pszFile, nLine, LocksHeld());
289 : : abort();
290 : : }
291 : : template void AssertLockNotHeldInternal(const char*, const char*, int, Mutex*);
292 : : template void AssertLockNotHeldInternal(const char*, const char*, int, RecursiveMutex*);
293 : :
294 : : void DeleteLock(void* cs)
295 : : {
296 : : LockData& lockdata = GetLockData();
297 : : std::lock_guard<std::mutex> lock(lockdata.dd_mutex);
298 : : const LockPair item = std::make_pair(cs, nullptr);
299 : : LockOrders::iterator it = lockdata.lockorders.lower_bound(item);
300 : : while (it != lockdata.lockorders.end() && it->first.first == cs) {
301 : : const LockPair invitem = std::make_pair(it->first.second, it->first.first);
302 : : lockdata.invlockorders.erase(invitem);
303 : : lockdata.lockorders.erase(it++);
304 : : }
305 : : InvLockOrders::iterator invit = lockdata.invlockorders.lower_bound(item);
306 : : while (invit != lockdata.invlockorders.end() && invit->first == cs) {
307 : : const LockPair invinvitem = std::make_pair(invit->second, invit->first);
308 : : lockdata.lockorders.erase(invinvitem);
309 : : lockdata.invlockorders.erase(invit++);
310 : : }
311 : : }
312 : :
313 : : bool LockStackEmpty()
314 : : {
315 : : LockData& lockdata = GetLockData();
316 : : std::lock_guard<std::mutex> lock(lockdata.dd_mutex);
317 : : const auto it = lockdata.m_lock_stacks.find(std::this_thread::get_id());
318 : : if (it == lockdata.m_lock_stacks.end()) {
319 : : return true;
320 : : }
321 : : return it->second.empty();
322 : : }
323 : :
324 : : bool g_debug_lockorder_abort = true;
325 : :
326 : : #endif /* DEBUG_LOCKORDER */
|
