Branch data Line data Source code
1 : : // Copyright (c) 2009-2010 Satoshi Nakamoto
2 : : // Copyright (c) 2009-2022 The Bitcoin Core developers
3 : : // Distributed under the MIT software license, see the accompanying
4 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
5 : :
6 : : #include <validationinterface.h>
7 : :
8 : : #include <chain.h>
9 : : #include <consensus/validation.h>
10 : : #include <kernel/chain.h>
11 : : #include <kernel/mempool_entry.h>
12 : : #include <logging.h>
13 : : #include <primitives/block.h>
14 : : #include <primitives/transaction.h>
15 : : #include <util/check.h>
16 : : #include <util/task_runner.h>
17 : :
18 : : #include <future>
19 : : #include <unordered_map>
20 : : #include <utility>
21 : :
22 : : std::string RemovalReasonToString(const MemPoolRemovalReason& r) noexcept;
23 : :
24 : : /**
25 : : * ValidationSignalsImpl manages a list of shared_ptr<CValidationInterface> callbacks.
26 : : *
27 : : * A std::unordered_map is used to track what callbacks are currently
28 : : * registered, and a std::list is used to store the callbacks that are
29 : : * currently registered as well as any callbacks that are just unregistered
30 : : * and about to be deleted when they are done executing.
31 : : */
32 : : class ValidationSignalsImpl
33 : : {
34 : : private:
35 : : Mutex m_mutex;
36 : : //! List entries consist of a callback pointer and reference count. The
37 : : //! count is equal to the number of current executions of that entry, plus 1
38 : : //! if it's registered. It cannot be 0 because that would imply it is
39 : : //! unregistered and also not being executed (so shouldn't exist).
40 : : struct ListEntry { std::shared_ptr<CValidationInterface> callbacks; int count = 1; };
41 : : std::list<ListEntry> m_list GUARDED_BY(m_mutex);
42 : : std::unordered_map<CValidationInterface*, std::list<ListEntry>::iterator> m_map GUARDED_BY(m_mutex);
43 : :
44 : : public:
45 : : std::unique_ptr<util::TaskRunnerInterface> m_task_runner;
46 : :
47 : 2055 : explicit ValidationSignalsImpl(std::unique_ptr<util::TaskRunnerInterface> task_runner)
48 [ + - ]: 2055 : : m_task_runner{std::move(Assert(task_runner))} {}
49 : :
50 : 280269 : void Register(std::shared_ptr<CValidationInterface> callbacks) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
51 : : {
52 : 280269 : LOCK(m_mutex);
53 [ + - ]: 280269 : auto inserted = m_map.emplace(callbacks.get(), m_list.end());
54 [ - + - + ]: 280269 : if (inserted.second) inserted.first->second = m_list.emplace(m_list.end());
55 : 280269 : inserted.first->second->callbacks = std::move(callbacks);
56 : 280269 : }
57 : :
58 : 280269 : void Unregister(CValidationInterface* callbacks) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
59 : : {
60 : 280269 : LOCK(m_mutex);
61 [ + - ]: 280269 : auto it = m_map.find(callbacks);
62 [ + - ]: 280269 : if (it != m_map.end()) {
63 [ + + ]: 280269 : if (!--it->second->count) m_list.erase(it->second);
64 [ + - ]: 280269 : m_map.erase(it);
65 : 280269 : }
66 : 280269 : }
67 : :
68 : : //! Clear unregisters every previously registered callback, erasing every
69 : : //! map entry. After this call, the list may still contain callbacks that
70 : : //! are currently executing, but it will be cleared when they are done
71 : : //! executing.
72 : 0 : void Clear() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
73 : : {
74 : 1 : LOCK(m_mutex);
75 [ # # ]: 0 : for (const auto& entry : m_map) {
76 [ # # ]: 0 : if (!--entry.second->count) m_list.erase(entry.second);
77 : 0 : }
78 : 0 : m_map.clear();
79 : 0 : }
80 : :
81 : 590813 : template<typename F> void Iterate(F&& f) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex)
82 : : {
83 : 590813 : WAIT_LOCK(m_mutex, lock);
84 [ + + # # : 938253 : for (auto it = m_list.begin(); it != m_list.end();) {
+ + + + +
+ + + + +
# # + + ]
85 : 347440 : ++it->count;
86 : : {
87 [ + - # # : 347440 : REVERSE_LOCK(lock);
+ - + - +
- + - + -
# # + - ]
88 [ + - # # : 347440 : f(*it->callbacks);
+ - + - +
- + - + -
# # + - ]
89 : 347440 : }
90 [ + - - + : 347440 : it = --it->count ? std::next(it) : m_list.erase(it);
# # # # +
+ - + + -
- + + - -
+ + + - +
+ + - + #
# # # + -
- + ]
91 : : }
92 : 590813 : }
93 : : };
94 : :
95 : 2055 : ValidationSignals::ValidationSignals(std::unique_ptr<util::TaskRunnerInterface> task_runner)
96 : 2055 : : m_internals{std::make_unique<ValidationSignalsImpl>(std::move(task_runner))} {}
97 : :
98 : 2073 : ValidationSignals::~ValidationSignals() {}
99 : :
100 : 2073 : void ValidationSignals::FlushBackgroundCallbacks()
101 : : {
102 : 2073 : m_internals->m_task_runner->flush();
103 : 2073 : }
104 : :
105 : 102828 : size_t ValidationSignals::CallbacksPending()
106 : : {
107 : 102828 : return m_internals->m_task_runner->size();
108 : : }
109 : :
110 : 280269 : void ValidationSignals::RegisterSharedValidationInterface(std::shared_ptr<CValidationInterface> callbacks)
111 : : {
112 : : // Each connection captures the shared_ptr to ensure that each callback is
113 : : // executed before the subscriber is destroyed. For more details see #18338.
114 [ + - ]: 280269 : m_internals->Register(std::move(callbacks));
115 : 280269 : }
116 : :
117 : 111917 : void ValidationSignals::RegisterValidationInterface(CValidationInterface* callbacks)
118 : : {
119 : : // Create a shared_ptr with a no-op deleter - CValidationInterface lifecycle
120 : : // is managed by the caller.
121 [ + - ]: 223834 : RegisterSharedValidationInterface({callbacks, [](CValidationInterface*){}});
122 : 111917 : }
123 : :
124 : 168352 : void ValidationSignals::UnregisterSharedValidationInterface(std::shared_ptr<CValidationInterface> callbacks)
125 : : {
126 : 168352 : UnregisterValidationInterface(callbacks.get());
127 : 168352 : }
128 : :
129 : 280269 : void ValidationSignals::UnregisterValidationInterface(CValidationInterface* callbacks)
130 : : {
131 : 280269 : m_internals->Unregister(callbacks);
132 : 280269 : }
133 : :
134 : 0 : void ValidationSignals::UnregisterAllValidationInterfaces()
135 : : {
136 : 0 : m_internals->Clear();
137 : 0 : }
138 : :
139 : 292931 : void ValidationSignals::CallFunctionInValidationInterfaceQueue(std::function<void()> func)
140 : : {
141 [ + - ]: 292931 : m_internals->m_task_runner->insert(std::move(func));
142 : 292931 : }
143 : :
144 : 292931 : void ValidationSignals::SyncWithValidationInterfaceQueue()
145 : : {
146 : 292931 : AssertLockNotHeld(cs_main);
147 : : // Block until the validation queue drains
148 : 292931 : std::promise<void> promise;
149 [ + - ]: 585862 : CallFunctionInValidationInterfaceQueue([&promise] {
150 : 292931 : promise.set_value();
151 : 292931 : });
152 [ + - - + ]: 292931 : promise.get_future().wait();
153 : 292931 : }
154 : :
155 : : // Use a macro instead of a function for conditional logging to prevent
156 : : // evaluating arguments when logging is not enabled.
157 : : //
158 : : // NOTE: The lambda captures all local variables by value.
159 : : #define ENQUEUE_AND_LOG_EVENT(event, fmt, name, ...) \
160 : : do { \
161 : : auto local_name = (name); \
162 : : LOG_EVENT("Enqueuing " fmt, local_name, __VA_ARGS__); \
163 : : m_internals->m_task_runner->insert([=] { \
164 : : LOG_EVENT(fmt, local_name, __VA_ARGS__); \
165 : : event(); \
166 : : }); \
167 : : } while (0)
168 : :
169 : : #define LOG_EVENT(fmt, ...) \
170 : : LogPrint(BCLog::VALIDATION, fmt "\n", __VA_ARGS__)
171 : :
172 : 85235 : void ValidationSignals::UpdatedBlockTip(const CBlockIndex *pindexNew, const CBlockIndex *pindexFork, bool fInitialDownload) {
173 : : // Dependencies exist that require UpdatedBlockTip events to be delivered in the order in which
174 : : // the chain actually updates. One way to ensure this is for the caller to invoke this signal
175 : : // in the same critical section where the chain is updated
176 : :
177 : 170470 : auto event = [pindexNew, pindexFork, fInitialDownload, this] {
178 : 130073 : m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.UpdatedBlockTip(pindexNew, pindexFork, fInitialDownload); });
179 : 85235 : };
180 [ + + + - : 170470 : ENQUEUE_AND_LOG_EVENT(event, "%s: new block hash=%s fork block hash=%s (in IBD=%s)", __func__,
+ - + - +
- + + + -
+ - - + +
- + + + +
# # # # +
- + + + -
+ - + - +
+ + - - +
+ - + + +
+ # # #
# ]
181 : : pindexNew->GetBlockHash().ToString(),
182 : : pindexFork ? pindexFork->GetBlockHash().ToString() : "null",
183 : : fInitialDownload);
184 : 85235 : }
185 : :
186 : 67092 : void ValidationSignals::TransactionAddedToMempool(const NewMempoolTransactionInfo& tx, uint64_t mempool_sequence)
187 : : {
188 : 134184 : auto event = [tx, mempool_sequence, this] {
189 : 97014 : m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.TransactionAddedToMempool(tx, mempool_sequence); });
190 : 67092 : };
191 [ + - + - : 134184 : ENQUEUE_AND_LOG_EVENT(event, "%s: txid=%s wtxid=%s", __func__,
# # # # #
# # # # #
# # # # +
- + - + -
# # # # #
# # # #
# ]
192 : : tx.info.m_tx->GetHash().ToString(),
193 : : tx.info.m_tx->GetWitnessHash().ToString());
194 : 67092 : }
195 : :
196 : 38579 : void ValidationSignals::TransactionRemovedFromMempool(const CTransactionRef& tx, MemPoolRemovalReason reason, uint64_t mempool_sequence) {
197 : 77158 : auto event = [tx, reason, mempool_sequence, this] {
198 : 57585 : m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.TransactionRemovedFromMempool(tx, reason, mempool_sequence); });
199 : 38579 : };
200 [ + - + - : 77158 : ENQUEUE_AND_LOG_EVENT(event, "%s: txid=%s wtxid=%s reason=%s", __func__,
# # # # #
# # # # #
# # # # +
- + - + -
# # # # #
# # # #
# ]
201 : : tx->GetHash().ToString(),
202 : : tx->GetWitnessHash().ToString(),
203 : : RemovalReasonToString(reason));
204 : 38579 : }
205 : :
206 : 85235 : void ValidationSignals::BlockConnected(ChainstateRole role, const std::shared_ptr<const CBlock> &pblock, const CBlockIndex *pindex) {
207 : 170470 : auto event = [role, pblock, pindex, this] {
208 : 146969 : m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.BlockConnected(role, pblock, pindex); });
209 : 85235 : };
210 [ + - + + : 170470 : ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s block height=%d", __func__,
+ - + - +
- + - - +
+ - + - +
+ + - + -
+ - + - -
+ ]
211 : : pblock->GetHash().ToString(),
212 : : pindex->nHeight);
213 : 85235 : }
214 : :
215 : 85235 : void ValidationSignals::MempoolTransactionsRemovedForBlock(const std::vector<RemovedMempoolTransactionInfo>& txs_removed_for_block, unsigned int nBlockHeight)
216 : : {
217 : 170470 : auto event = [txs_removed_for_block, nBlockHeight, this] {
218 : 164995 : m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.MempoolTransactionsRemovedForBlock(txs_removed_for_block, nBlockHeight); });
219 : 85235 : };
220 [ + - + + : 255705 : ENQUEUE_AND_LOG_EVENT(event, "%s: block height=%s txs removed=%s", __func__,
+ - + - -
+ + - + -
+ - + - +
+ + - + -
- + ]
221 : : nBlockHeight,
222 : : txs_removed_for_block.size());
223 : 85235 : }
224 : :
225 : 0 : void ValidationSignals::BlockDisconnected(const std::shared_ptr<const CBlock>& pblock, const CBlockIndex* pindex)
226 : : {
227 : 0 : auto event = [pblock, pindex, this] {
228 : 0 : m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.BlockDisconnected(pblock, pindex); });
229 : 0 : };
230 [ # # # # : 0 : ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s block height=%d", __func__,
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
231 : : pblock->GetHash().ToString(),
232 : : pindex->nHeight);
233 : 0 : }
234 : :
235 : 114473 : void ValidationSignals::ChainStateFlushed(ChainstateRole role, const CBlockLocator &locator) {
236 : 228946 : auto event = [role, locator, this] {
237 : 114680 : m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.ChainStateFlushed(role, locator); });
238 : 114473 : };
239 [ + - + + : 343419 : ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s", __func__,
+ - + - +
- + - # #
+ - - + +
- + - # #
# # + - +
- + - + -
+ + + - +
- + - # #
+ - - + +
- + - # #
# # ]
240 : : locator.IsNull() ? "null" : locator.vHave.front().ToString());
241 : 114473 : }
242 : :
243 : 114964 : void ValidationSignals::BlockChecked(const CBlock& block, const BlockValidationState& state) {
244 [ + + + - : 114964 : LOG_EVENT("%s: block hash=%s state=%s", __func__,
+ - + - +
- + - -
+ ]
245 : : block.GetHash().ToString(), state.ToString());
246 : 226937 : m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.BlockChecked(block, state); });
247 : 114964 : }
248 : :
249 : 0 : void ValidationSignals::NewPoWValidBlock(const CBlockIndex *pindex, const std::shared_ptr<const CBlock> &block) {
250 [ # # # # : 0 : LOG_EVENT("%s: block hash=%s", __func__, block->GetHash().ToString());
# # # # #
# # # ]
251 : 0 : m_internals->Iterate([&](CValidationInterface& callbacks) { callbacks.NewPoWValidBlock(pindex, block); });
252 : 0 : }
|
