1 // Copyright (c) 2011-2016 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.
8 #include "utilstrencodings.h"
12 #include <boost/foreach.hpp>
13 #include <boost/thread.hpp>
15 #ifdef DEBUG_LOCKCONTENTION
16 void PrintLockContention(const char* pszName
, const char* pszFile
, int nLine
)
18 LogPrintf("LOCKCONTENTION: %s\n", pszName
);
19 LogPrintf("Locker: %s:%d\n", pszFile
, nLine
);
21 #endif /* DEBUG_LOCKCONTENTION */
23 #ifdef DEBUG_LOCKORDER
25 // Early deadlock detection.
26 // Problem being solved:
27 // Thread 1 locks A, then B, then C
28 // Thread 2 locks D, then C, then A
29 // --> may result in deadlock between the two threads, depending on when they run.
30 // Solution implemented here:
31 // Keep track of pairs of locks: (A before B), (A before C), etc.
32 // Complain if any thread tries to lock in a different order.
35 struct CLockLocation
{
36 CLockLocation(const char* pszName
, const char* pszFile
, int nLine
, bool fTryIn
)
44 std::string
ToString() const
46 return mutexName
+ " " + sourceFile
+ ":" + itostr(sourceLine
) + (fTry
? " (TRY)" : "");
49 std::string
MutexName() const { return mutexName
; }
53 std::string mutexName
;
54 std::string sourceFile
;
58 typedef std::vector
<std::pair
<void*, CLockLocation
> > LockStack
;
59 typedef std::map
<std::pair
<void*, void*>, LockStack
> LockOrders
;
60 typedef std::set
<std::pair
<void*, void*> > InvLockOrders
;
63 // Very ugly hack: as the global constructs and destructors run single
64 // threaded, we use this boolean to know whether LockData still exists,
65 // as DeleteLock can get called by global CCriticalSection destructors
66 // after LockData disappears.
68 LockData() : available(true) {}
69 ~LockData() { available
= false; }
71 LockOrders lockorders
;
72 InvLockOrders invlockorders
;
73 boost::mutex dd_mutex
;
76 boost::thread_specific_ptr
<LockStack
> lockstack
;
78 static void potential_deadlock_detected(const std::pair
<void*, void*>& mismatch
, const LockStack
& s1
, const LockStack
& s2
)
80 LogPrintf("POTENTIAL DEADLOCK DETECTED\n");
81 LogPrintf("Previous lock order was:\n");
82 BOOST_FOREACH (const PAIRTYPE(void*, CLockLocation
) & i
, s2
) {
83 if (i
.first
== mismatch
.first
) {
86 if (i
.first
== mismatch
.second
) {
89 LogPrintf(" %s\n", i
.second
.ToString());
91 LogPrintf("Current lock order is:\n");
92 BOOST_FOREACH (const PAIRTYPE(void*, CLockLocation
) & i
, s1
) {
93 if (i
.first
== mismatch
.first
) {
96 if (i
.first
== mismatch
.second
) {
99 LogPrintf(" %s\n", i
.second
.ToString());
104 static void push_lock(void* c
, const CLockLocation
& locklocation
, bool fTry
)
106 if (lockstack
.get() == NULL
)
107 lockstack
.reset(new LockStack
);
109 boost::unique_lock
<boost::mutex
> lock(lockdata
.dd_mutex
);
111 (*lockstack
).push_back(std::make_pair(c
, locklocation
));
113 BOOST_FOREACH (const PAIRTYPE(void*, CLockLocation
) & i
, (*lockstack
)) {
117 std::pair
<void*, void*> p1
= std::make_pair(i
.first
, c
);
118 if (lockdata
.lockorders
.count(p1
))
120 lockdata
.lockorders
[p1
] = (*lockstack
);
122 std::pair
<void*, void*> p2
= std::make_pair(c
, i
.first
);
123 lockdata
.invlockorders
.insert(p2
);
124 if (lockdata
.lockorders
.count(p2
))
125 potential_deadlock_detected(p1
, lockdata
.lockorders
[p2
], lockdata
.lockorders
[p1
]);
129 static void pop_lock()
131 (*lockstack
).pop_back();
134 void EnterCritical(const char* pszName
, const char* pszFile
, int nLine
, void* cs
, bool fTry
)
136 push_lock(cs
, CLockLocation(pszName
, pszFile
, nLine
, fTry
), fTry
);
144 std::string
LocksHeld()
147 BOOST_FOREACH (const PAIRTYPE(void*, CLockLocation
) & i
, *lockstack
)
148 result
+= i
.second
.ToString() + std::string("\n");
152 void AssertLockHeldInternal(const char* pszName
, const char* pszFile
, int nLine
, void* cs
)
154 BOOST_FOREACH (const PAIRTYPE(void*, CLockLocation
) & i
, *lockstack
)
157 fprintf(stderr
, "Assertion failed: lock %s not held in %s:%i; locks held:\n%s", pszName
, pszFile
, nLine
, LocksHeld().c_str());
161 void DeleteLock(void* cs
)
163 if (!lockdata
.available
) {
164 // We're already shutting down.
167 boost::unique_lock
<boost::mutex
> lock(lockdata
.dd_mutex
);
168 std::pair
<void*, void*> item
= std::make_pair(cs
, (void*)0);
169 LockOrders::iterator it
= lockdata
.lockorders
.lower_bound(item
);
170 while (it
!= lockdata
.lockorders
.end() && it
->first
.first
== cs
) {
171 std::pair
<void*, void*> invitem
= std::make_pair(it
->first
.second
, it
->first
.first
);
172 lockdata
.invlockorders
.erase(invitem
);
173 lockdata
.lockorders
.erase(it
++);
175 InvLockOrders::iterator invit
= lockdata
.invlockorders
.lower_bound(item
);
176 while (invit
!= lockdata
.invlockorders
.end() && invit
->first
== cs
) {
177 std::pair
<void*, void*> invinvitem
= std::make_pair(invit
->second
, invit
->first
);
178 lockdata
.lockorders
.erase(invinvitem
);
179 lockdata
.invlockorders
.erase(invit
++);
183 #endif /* DEBUG_LOCKORDER */