READ THE CODE

Inside Bitcoin

The code behind the network, with room to understand it.

Stable release v32.1bitcoin/bitcoin · f0de87f04062 ↗3,020 source files · 47.5 MB stored on the server340 file guides

Release published 2026-10-28 · Snapshot fetched 2026-11-01. Latest stable release at fetch time; development branches and Git history are excluded. Only the selected code window and visible folders load here.

11,371 bytes · SHA-256 20319a70029d4ebc… · View upstream ↗

1// Copyright (c) 2011-present 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#include <sync.h>
6
7#include <logging/timer.h>
8#include <tinyformat.h>
9#include <util/log.h>
10#include <util/stdmutex.h>
11#include <util/strencodings.h>
12#include <util/threadnames.h>
13
14#include <map>
15#include <mutex>
16#include <set>
17#include <system_error>
18#include <thread>
19#include <type_traits>
20#include <unordered_map>
21#include <utility>
22#include <vector>
23
24#ifdef DEBUG_LOCKCONTENTION
25
26template <typename LockType>
27void ContendedLock(std::string_view name, std::string_view file, int nLine, LockType& lock)
28{
29    LOG_TIME_MICROS_WITH_CATEGORY(strprintf("lock contention %s, %s:%d", name, file, nLine), BCLog::LOCK);
30    lock.lock();
31}
32template void ContendedLock(std::string_view name, std::string_view file, int nLine, std::unique_lock<std::mutex>& lock);
33template void ContendedLock(std::string_view name, std::string_view file, int nLine, std::unique_lock<std::recursive_mutex>& lock);
34
35#endif
36
37#ifdef DEBUG_LOCKORDER
38//
39// Early deadlock detection.
40// Problem being solved:
41//    Thread 1 locks A, then B, then C
42//    Thread 2 locks D, then C, then A
43//     --> may result in deadlock between the two threads, depending on when they run.
44// Solution implemented here:
45// Keep track of pairs of locks: (A before B), (A before C), etc.
46// Complain if any thread tries to lock in a different order.
47//
48
49struct CLockLocation {
50    CLockLocation(
51        const char* pszName,
52        const char* pszFile,
53        int nLine,
54        bool fTryIn,
55        std::string&& thread_name)
56        : fTry(fTryIn),
57          mutexName(pszName),
58          sourceFile(pszFile),
59          m_thread_name(std::move(thread_name)),
60          sourceLine(nLine) {}
61
62    std::string ToString() const
63    {
64        return strprintf(
65            "'%s' in %s:%s%s (in thread '%s')",
66            mutexName, sourceFile, sourceLine, (fTry ? " (TRY)" : ""), m_thread_name);
67    }
68
69    std::string Name() const
70    {
71        return mutexName;
72    }
73
74private:
75    bool fTry;
76    std::string mutexName;
77    std::string sourceFile;
78    const std::string m_thread_name;
79    int sourceLine;
80};
81
82using LockStackItem = std::pair<void*, CLockLocation>;
83using LockStack = std::vector<LockStackItem>;
84using LockStacks = std::unordered_map<std::thread::id, LockStack>;
85
86using LockPair = std::pair<void*, void*>;
87using LockOrders = std::map<LockPair, LockStack>;
88using InvLockOrders = std::set<LockPair>;
89
90struct LockData {
91    LockStacks m_lock_stacks GUARDED_BY(dd_mutex);
92    LockOrders lockorders GUARDED_BY(dd_mutex);
93    InvLockOrders invlockorders GUARDED_BY(dd_mutex);
94    StdMutex dd_mutex;
95};
96
97LockData& GetLockData() {
98    // This approach guarantees that the object is not destroyed until after its last use.
99    // The operating system automatically reclaims all the memory in a program's heap when that program exits.
100    // Since the ~LockData() destructor is never called, the LockData class and all
101    // its subclasses must have implicitly-defined destructors.
102    static LockData& lock_data = *new LockData();
103    return lock_data;
104}
105
106static void potential_deadlock_detected(const LockPair& mismatch, const LockStack& s1, const LockStack& s2)
107{
108    LogError("POTENTIAL DEADLOCK DETECTED");
109    LogError("Previous lock order was:");
110    for (const LockStackItem& i : s1) {
111        std::string prefix{};
112        if (i.first == mismatch.first) {
113            prefix = " (1)";
114        }
115        if (i.first == mismatch.second) {
116            prefix = " (2)";
117        }
118        LogError("%s %s", prefix, i.second.ToString());
119    }
120
121    std::string mutex_a, mutex_b;
122    LogError("Current lock order is:");
123    for (const LockStackItem& i : s2) {
124        std::string prefix{};
125        if (i.first == mismatch.first) {
126            prefix = " (1)";
127            mutex_a = i.second.Name();
128        }
129        if (i.first == mismatch.second) {
130            prefix = " (2)";
131            mutex_b = i.second.Name();
132        }
133        LogError("%s %s", prefix, i.second.ToString());
134    }
135    if (g_debug_lockorder_abort) {
136        tfm::format(std::cerr, "Assertion failed: detected inconsistent lock order for %s, details in debug log.\n", s2.back().second.ToString());
137        abort();
138    }
139    throw std::logic_error(strprintf("potential deadlock detected: %s -> %s -> %s", mutex_b, mutex_a, mutex_b));
140}
141
142static void double_lock_detected(const void* mutex, const LockStack& lock_stack)
143{
144    LogError("DOUBLE LOCK DETECTED");
145    LogError("Lock order:");
146    for (const LockStackItem& i : lock_stack) {
147        std::string prefix{};
148        if (i.first == mutex) {
149            prefix = " (*)";
150        }
151        LogError("%s %s", prefix, i.second.ToString());
152    }
153    if (g_debug_lockorder_abort) {
154        tfm::format(std::cerr,
155                    "Assertion failed: detected double lock for %s, details in debug log.\n",
156                    lock_stack.back().second.ToString());
157        abort();
158    }
159    throw std::logic_error("double lock detected");
160}
161
162template <typename MutexType>
163static void push_lock(MutexType* c, const CLockLocation& locklocation)
164{
165    constexpr bool is_recursive_mutex =
166        std::is_base_of_v<RecursiveMutex, MutexType> ||
167        std::is_base_of_v<std::recursive_mutex, MutexType>;
168
169    LockData& lockdata = GetLockData();
170    STDLOCK(lockdata.dd_mutex);
171
172    LockStack& lock_stack = lockdata.m_lock_stacks[std::this_thread::get_id()];
173    lock_stack.emplace_back(c, locklocation);
174    for (size_t j = 0; j < lock_stack.size() - 1; ++j) {
175        const LockStackItem& i = lock_stack[j];
176        if (i.first == c) {
177            if (is_recursive_mutex) {
178                break;
179            }
180            // It is not a recursive mutex and it appears in the stack two times:
181            // at position `j` and at the end (which we added just before this loop).
182            // Can't allow locking the same (non-recursive) mutex two times from the
183            // same thread as that results in an undefined behavior.
184            auto lock_stack_copy = lock_stack;
185            lock_stack.pop_back();
186            double_lock_detected(c, lock_stack_copy);
187            // double_lock_detected() does not return.
188        }
189
190        const LockPair p1 = std::make_pair(i.first, c);
191        if (lockdata.lockorders.contains(p1))
192            continue;
193
194        const LockPair p2 = std::make_pair(c, i.first);
195        if (lockdata.lockorders.contains(p2)) {
196            auto lock_stack_copy = lock_stack;
197            lock_stack.pop_back();
198            potential_deadlock_detected(p1, lockdata.lockorders[p2], lock_stack_copy);
199            // potential_deadlock_detected() does not return.
200        }
201
202        lockdata.lockorders.emplace(p1, lock_stack);
203        lockdata.invlockorders.insert(p2);
204    }
205}
206
207static void pop_lock()
208{
209    LockData& lockdata = GetLockData();
210    STDLOCK(lockdata.dd_mutex);
211
212    LockStack& lock_stack = lockdata.m_lock_stacks[std::this_thread::get_id()];
213    lock_stack.pop_back();
214    if (lock_stack.empty()) {
215        lockdata.m_lock_stacks.erase(std::this_thread::get_id());
216    }
217}
218
219template <typename MutexType>
220void EnterCritical(const char* pszName, const char* pszFile, int nLine, MutexType* cs, bool fTry)
221{
222    push_lock(cs, CLockLocation(pszName, pszFile, nLine, fTry, util::ThreadGetInternalName()));
223}
224template void EnterCritical(const char*, const char*, int, std::mutex*, bool);
225template void EnterCritical(const char*, const char*, int, std::recursive_mutex*, bool);
226
227void CheckLastCritical(void* cs, std::string& lockname, const char* guardname, const char* file, int line)
228{
229    LockData& lockdata = GetLockData();
230    STDLOCK(lockdata.dd_mutex);
231
232    const LockStack& lock_stack = lockdata.m_lock_stacks[std::this_thread::get_id()];
233    if (!lock_stack.empty()) {
234        const auto& lastlock = lock_stack.back();
235        if (lastlock.first == cs) {
236            lockname = lastlock.second.Name();
237            return;
238        }
239    }
240
241    LogError("INCONSISTENT LOCK ORDER DETECTED");
242    LogError("Current lock order (least recent first) is:");
243    for (const LockStackItem& i : lock_stack) {
244        LogError(" %s", i.second.ToString());
245    }
246    if (g_debug_lockorder_abort) {
247        tfm::format(std::cerr, "%s:%s %s was not most recent critical section locked, details in debug log.\n", file, line, guardname);
248        abort();
249    }
250    throw std::logic_error(strprintf("%s was not most recent critical section locked", guardname));

src/wallet/receive.cpp

src/wallet/coinselection.cpp

src/consensus/validation.h

src/primitives/transaction.cpp

src/script/descriptor.cpp

src/bitcoin-cli.cpp

src/rpc/blockchain.cpp

src/rpc/rawtransaction.cpp

src/init.cpp

src/crypto/sha256.cpp

src/consensus/merkle.h

src/consensus/tx_check.h

src/consensus/tx_verify.h

src/policy/feerate.h

src/policy/feerate.cpp

src/primitives/transaction_identifier.h

src/chainparamsbase.h

src/chainparamsbase.cpp

src/util/moneystr.cpp

src/crypto/ripemd160.h

src/crypto/sha1.h

src/crypto/sha512.h

src/crypto/hmac_sha256.h

src/crypto/hmac_sha512.h

src/crypto/hmac_sha256.cpp

src/crypto/hmac_sha512.cpp

src/crypto/hkdf_sha256_32.h

src/crypto/hkdf_sha256_32.cpp

src/support/cleanse.h

src/support/cleanse.cpp

src/crypto/siphash.cpp

src/crypto/muhash.h

src/crypto/chacha20.h

src/crypto/poly1305.h

src/crypto/chacha20poly1305.h

src/crypto/chacha20poly1305.cpp

src/util/chaintype.cpp

src/util/obfuscation.h

src/util/byte_units.h

src/util/overflow.h

src/blockencodings.cpp

src/net_permissions.cpp

src/policy/packages.cpp

src/policy/rbf.cpp

src/policy/truc_policy.cpp

src/policy/ephemeral_policy.cpp

src/policy/settings.cpp

src/policy/policy.cpp

src/node/transaction.cpp

src/node/coin.cpp

src/rpc/client.cpp

src/rpc/external_signer.cpp

src/rpc/request.cpp

src/rpc/server_util.cpp

src/rpc/fees.cpp

src/rpc/output_script.cpp

src/rpc/rawtransaction_util.cpp

src/rpc/rawtransaction_util.h

src/rpc/register.h

src/rpc/request.h

src/rpc/server_util.h

src/rpc/protocol.h

src/rpc/server.h

src/rpc/signmessage.cpp

src/rpc/txoutproof.cpp

src/rpc/util.cpp

src/rpc/util.h

src/wallet/rpc/addresses.cpp

src/wallet/rpc/backup.cpp

src/wallet/rpc/coins.cpp

src/wallet/rpc/encrypt.cpp

src/wallet/rpc/signmessage.cpp

src/wallet/rpc/util.cpp

src/wallet/rpc/util.h

src/wallet/coincontrol.cpp

src/wallet/coincontrol.h

src/wallet/context.cpp

src/wallet/context.h

src/wallet/crypter.cpp

src/wallet/crypter.h

src/wallet/db.cpp

src/wallet/export.cpp

src/wallet/external_signer_scriptpubkeyman.cpp

src/wallet/rpc/spend.cpp

src/wallet/rpc/transactions.cpp

src/wallet/rpc/wallet.cpp

src/wallet/feebumper.cpp

src/wallet/feebumper.h

src/index/base.h

src/index/base.cpp

src/index/txindex.h

src/index/txindex.cpp

src/index/txindex_key.h

src/index/txospenderindex.h

src/index/txospenderindex.cpp

src/index/blockfilterindex.h

src/index/blockfilterindex.cpp

src/index/coinstatsindex.h

src/index/coinstatsindex.cpp

src/index/db_key.h

src/index/disktxpos.h

src/kernel/chain.cpp

src/kernel/chain.h

src/kernel/checks.cpp

src/kernel/checks.h

src/kernel/context.cpp

src/kernel/context.h

src/kernel/cs_main.cpp

src/kernel/cs_main.h

src/kernel/disconnected_transactions.cpp

src/kernel/disconnected_transactions.h

src/kernel/mempool_removal_reason.cpp

src/kernel/mempool_removal_reason.h

src/kernel/coinstats.cpp

src/kernel/coinstats.h

src/kernel/chainparams.cpp

src/kernel/chainparams.h

src/wallet/sqlite.cpp

src/wallet/sqlite.h

src/wallet/transaction.cpp

src/wallet/transaction.h

src/wallet/dump.cpp

src/wallet/dump.h

src/wallet/init.cpp

src/wallet/walletutil.cpp

src/wallet/walletutil.h

src/wallet/wallettool.cpp

src/wallet/wallettool.h

src/wallet/export.h

src/wallet/migrate.cpp

src/wallet/migrate.h

src/wallet/db.h

src/wallet/walletdb.cpp

src/wallet/interfaces.cpp

src/wallet/scriptpubkeyman.cpp

src/wallet/scriptpubkeyman.h

src/kernel/bitcoinkernel.cpp

src/kernel/bitcoinkernel.h

src/kernel/bitcoinkernel_wrapper.h

src/node/chainstate.cpp

src/node/chainstate.h

src/node/blockstorage.cpp

src/node/blockstorage.h

src/node/mempool_persist.cpp

src/node/mempool_persist.h

src/node/utxo_snapshot.cpp

src/node/utxo_snapshot.h

src/node/kernel_notifications.cpp

src/node/kernel_notifications.h

src/node/blockmanager_args.cpp

src/kernel/blockmanager_opts.h

src/util/expected.cpp

src/policy/settings.h

src/util/types.h

src/kernel/messagestartchars.h

src/kernel/warning.h

src/util/exception.h

src/common/license_info.h

src/node/coins_view_args.h

src/node/database_args.h

src/util/batchpriority.h

src/util/ui_change_type.h

src/node/coins_view_args.cpp

src/node/peerman_args.h

src/util/serfloat.h

src/node/blockmanager_args.h

src/node/database_args.cpp

src/util/overloaded.h

src/interfaces/types.h

src/node/chainstatemanager_args.h

src/node/minisketchwrapper.h

src/util/macros.h

src/util/syserror.h

src/common/run_command.h

src/util/bytevectorhash.cpp

src/node/mempool_persist_args.cpp

src/util/exec.h

src/util/rbf.h

src/crypto/hex_base.h

src/node/mempool_persist_args.h

src/interfaces/echo.h

src/util/any.h

src/util/batchpriority.cpp

src/util/threadnames.h

src/node/coin.h

src/node/mempool_args.h

src/util/asmap.h

src/util/bytevectorhash.h

src/node/context.cpp

src/util/insert.h

src/util/readwritefile.h

src/node/peerman_args.cpp

src/node/interface_ui.cpp

src/interfaces/handler.h

src/node/mining_args.h

src/util/hasher.cpp

src/common/init.h

src/kernel/mempool_limits.h

src/common/system.h

src/crypto/sha3.h

src/util/threadinterrupt.cpp

src/node/protocol_version.h

src/util/exception.cpp

src/common/messages.h

src/node/connection_types.cpp

src/util/bip32.h

src/common/license_info.cpp

src/util/stdmutex.h

src/common/run_command.cpp

src/util/check.cpp

src/util/golombrice.h

src/node/types.h

src/node/timeoffsets.h

src/util/readwritefile.cpp

src/util/fastrange.h

src/util/signalinterrupt.h

src/util/task_runner.h

src/util/syserror.cpp

src/common/interfaces.cpp

src/common/types.h

src/util/threadinterrupt.h

src/kernel/chainstatemanager_opts.h

src/node/psbt.h

src/policy/ephemeral_policy.h

src/util/trace.h

src/common/url.cpp

src/kernel/mempool_options.h

src/util/serfloat.cpp

src/kernel/notifications_interface.h

src/node/timeoffsets.cpp

src/node/warnings.cpp

src/util/hash_type.h

src/crypto/hex_base.cpp

src/node/eviction.h

src/util/tokenbucket.h

src/crypto/aes.h

src/common/pcp.h

src/util/feefrac.cpp

src/node/transaction.h

src/util/threadnames.cpp

src/common/signmessage.h

src/util/exec.cpp

src/util/signalinterrupt.cpp

Independent explanations by MyBitcoinExplorer. Not affiliated with or endorsed by Bitcoin Core. Guides are educational and do not replace the source or its tests.

Bitcoin Core source © its contributors, distributed under the MIT license. Original notices and bundled third-party licenses are retained in the source tree.