Branch data Line data Source code
1 : : // Copyright (c) 2018-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 <index/blockfilterindex.h>
6 : :
7 : : #include <blockfilter.h>
8 : : #include <chain.h>
9 : : #include <common/args.h>
10 : : #include <dbwrapper.h>
11 : : #include <flatfile.h>
12 : : #include <hash.h>
13 : : #include <index/base.h>
14 : : #include <index/db_key.h>
15 : : #include <interfaces/chain.h>
16 : : #include <interfaces/types.h>
17 : : #include <serialize.h>
18 : : #include <streams.h>
19 : : #include <sync.h>
20 : : #include <uint256.h>
21 : : #include <util/check.h>
22 : : #include <util/byte_units.h>
23 : : #include <util/fs.h>
24 : : #include <util/hasher.h>
25 : : #include <util/log.h>
26 : : #include <util/syserror.h>
27 : :
28 : : #include <cerrno>
29 : : #include <exception>
30 : : #include <map>
31 : : #include <optional>
32 : : #include <stdexcept>
33 : : #include <string>
34 : : #include <tuple>
35 : : #include <utility>
36 : : #include <vector>
37 : :
38 : : /* The index database stores three items for each block: the disk location of the encoded filter,
39 : : * its dSHA256 hash, and the header. Those belonging to blocks on the active chain are indexed by
40 : : * height, and those belonging to blocks that have been reorganized out of the active chain are
41 : : * indexed by block hash. This ensures that filter data for any block that becomes part of the
42 : : * active chain can always be retrieved, alleviating timing concerns.
43 : : *
44 : : * The filters themselves are stored in flat files and referenced by the LevelDB entries. This
45 : : * minimizes the amount of data written to LevelDB and keeps the database values constant size. The
46 : : * disk location of the next block filter to be written (represented as a FlatFilePos) is stored
47 : : * under the DB_FILTER_POS key.
48 : : *
49 : : * The logic for keys is shared with other indexes, see index/db_key.h.
50 : : */
51 : : constexpr uint8_t DB_FILTER_POS{'P'};
52 : :
53 : : constexpr unsigned int MAX_FLTR_FILE_SIZE{16_MiB};
54 : : /** The pre-allocation chunk size for fltr?????.dat files */
55 : : constexpr unsigned int FLTR_FILE_CHUNK_SIZE{1_MiB};
56 : : /** Maximum size of the cfheaders cache
57 : : * We have a limit to prevent a bug in filling this cache
58 : : * potentially turning into an OOM. At 2000 entries, this cache
59 : : * is big enough for a 2,000,000 length block chain, which
60 : : * we should be enough until ~2047. */
61 : : constexpr size_t CF_HEADERS_CACHE_MAX_SZ{2000};
62 : :
63 : : namespace {
64 : :
65 : 0 : std::string BlockFilterThreadName(BlockFilterType filter_type)
66 : : {
67 [ # # # ]: 0 : switch (filter_type) {
68 : 0 : case BlockFilterType::BASIC: return "blkfltbscidx";
69 : 0 : case BlockFilterType::INVALID: return "";
70 : : } // no default case, so the compiler can warn about missing cases
71 : 0 : assert(false);
72 : : }
73 : :
74 : 0 : struct DBVal {
75 : : uint256 hash;
76 : : uint256 header;
77 : : FlatFilePos pos;
78 : :
79 : 0 : SERIALIZE_METHODS(DBVal, obj) { READWRITE(obj.hash, obj.header, obj.pos); }
80 : : };
81 : :
82 : : }; // namespace
83 : :
84 : : static std::map<BlockFilterType, BlockFilterIndex> g_filter_indexes;
85 : :
86 : 0 : BlockFilterIndex::BlockFilterIndex(std::unique_ptr<interfaces::Chain> chain, BlockFilterType filter_type,
87 : 0 : size_t n_cache_size, bool f_memory, bool f_wipe)
88 [ # # # # ]: 0 : : BaseIndex(std::move(chain), BlockFilterTypeName(filter_type) + " block filter index", BlockFilterThreadName(filter_type))
89 [ # # # # ]: 0 : , m_filter_type(filter_type)
90 : : {
91 [ # # ]: 0 : const std::string& filter_name = BlockFilterTypeName(filter_type);
92 [ # # # # ]: 0 : if (filter_name.empty()) throw std::invalid_argument("unknown filter_type");
93 : :
94 [ # # # # : 0 : fs::path path = gArgs.GetDataDirNet() / "indexes" / "blockfilter" / fs::u8path(filter_name);
# # # # #
# ]
95 [ # # ]: 0 : fs::create_directories(path);
96 : :
97 [ # # # # : 0 : m_db = std::make_unique<BaseIndex::DB>(path / "db", n_cache_size, f_memory, f_wipe);
# # ]
98 [ # # ]: 0 : m_filter_fileseq = std::make_unique<FlatFileSeq>(std::move(path), "fltr", FLTR_FILE_CHUNK_SIZE);
99 : 0 : }
100 : :
101 : 0 : interfaces::Chain::NotifyOptions BlockFilterIndex::CustomOptions()
102 : : {
103 : 0 : interfaces::Chain::NotifyOptions options;
104 : 0 : options.connect_undo_data = true;
105 : 0 : return options;
106 : : }
107 : :
108 : 0 : bool BlockFilterIndex::CustomInit(const std::optional<interfaces::BlockRef>& block)
109 : : {
110 [ # # ]: 0 : if (!m_db->Read(DB_FILTER_POS, m_next_filter_pos)) {
111 : : // Check that the cause of the read failure is that the key does not exist. Any other errors
112 : : // indicate database corruption or a disk failure, and starting the index would cause
113 : : // further corruption.
114 [ # # ]: 0 : if (m_db->Exists(DB_FILTER_POS)) {
115 : 0 : LogError("Cannot read current %s state; index may be corrupted",
116 : : GetName());
117 : 0 : return false;
118 : : }
119 : :
120 : : // If the DB_FILTER_POS is not set, then initialize to the first location.
121 : 0 : m_next_filter_pos.nFile = 0;
122 : 0 : m_next_filter_pos.nPos = 0;
123 : : }
124 : :
125 [ # # ]: 0 : if (block) {
126 : 0 : auto op_last_header = ReadFilterHeader(block->height, block->hash);
127 [ # # ]: 0 : if (!op_last_header) {
128 : 0 : LogError("Cannot read last block filter header; index may be corrupted");
129 : 0 : return false;
130 : : }
131 : 0 : m_last_header = *op_last_header;
132 : : }
133 : :
134 : : return true;
135 : : }
136 : :
137 : 0 : bool BlockFilterIndex::CustomCommit(CDBBatch& batch)
138 : : {
139 : 0 : const FlatFilePos& pos = m_next_filter_pos;
140 : :
141 : : // Flush current filter file to disk.
142 : 0 : AutoFile file{m_filter_fileseq->Open(pos)};
143 [ # # ]: 0 : if (file.IsNull()) {
144 [ # # ]: 0 : LogError("Failed to open filter file %d", pos.nFile);
145 : : return false;
146 : : }
147 [ # # # # ]: 0 : if (!file.Commit()) {
148 [ # # ]: 0 : LogError("Failed to commit filter file %d", pos.nFile);
149 [ # # ]: 0 : (void)file.fclose();
150 : : return false;
151 : : }
152 [ # # # # ]: 0 : if (file.fclose() != 0) {
153 [ # # # # ]: 0 : LogError("Failed to close filter file %d after commit: %s", pos.nFile, SysErrorString(errno));
154 : 0 : return false;
155 : : }
156 : :
157 [ # # ]: 0 : batch.Write(DB_FILTER_POS, pos);
158 : : return true;
159 : 0 : }
160 : :
161 : 0 : bool BlockFilterIndex::ReadFilterFromDisk(const FlatFilePos& pos, const uint256& hash, BlockFilter& filter) const
162 : : {
163 : 0 : AutoFile filein{m_filter_fileseq->Open(pos, true)};
164 [ # # ]: 0 : if (filein.IsNull()) {
165 : : return false;
166 : : }
167 : :
168 : : // Check that the hash of the encoded_filter matches the one stored in the db.
169 : 0 : uint256 block_hash;
170 : 0 : std::vector<uint8_t> encoded_filter;
171 : 0 : try {
172 [ # # # # ]: 0 : filein >> block_hash >> encoded_filter;
173 [ # # ]: 0 : if (Hash(encoded_filter) != hash) {
174 [ # # ]: 0 : LogError("Checksum mismatch in filter decode.");
175 : : return false;
176 : : }
177 [ # # ]: 0 : filter = BlockFilter(GetFilterType(), block_hash, std::move(encoded_filter), /*skip_decode_check=*/true);
178 : : }
179 [ - - ]: 0 : catch (const std::exception& e) {
180 [ - - ]: 0 : LogError("Failed to deserialize block filter from disk: %s", e.what());
181 : 0 : return false;
182 : 0 : }
183 : :
184 : 0 : return true;
185 : 0 : }
186 : :
187 : 0 : size_t BlockFilterIndex::WriteFilterToDisk(FlatFilePos& pos, const BlockFilter& filter)
188 : : {
189 [ # # ]: 0 : assert(filter.GetFilterType() == GetFilterType());
190 : :
191 : 0 : uint64_t data_size{
192 : 0 : GetSerializeSize(filter.GetBlockHash()) +
193 : 0 : GetSerializeSize(filter.GetEncodedFilter())};
194 : :
195 : : // If writing the filter would overflow the file, flush and move to the next one.
196 [ # # ]: 0 : if (pos.nPos + data_size > MAX_FLTR_FILE_SIZE) {
197 : 0 : AutoFile last_file{m_filter_fileseq->Open(pos)};
198 [ # # ]: 0 : if (last_file.IsNull()) {
199 [ # # ]: 0 : LogError("Failed to open filter file %d", pos.nFile);
200 : : return 0;
201 : : }
202 [ # # # # ]: 0 : if (!last_file.Truncate(pos.nPos)) {
203 [ # # ]: 0 : LogError("Failed to truncate filter file %d", pos.nFile);
204 : : return 0;
205 : : }
206 [ # # # # ]: 0 : if (!last_file.Commit()) {
207 [ # # ]: 0 : LogError("Failed to commit filter file %d", pos.nFile);
208 [ # # ]: 0 : (void)last_file.fclose();
209 : : return 0;
210 : : }
211 [ # # # # ]: 0 : if (last_file.fclose() != 0) {
212 [ # # # # ]: 0 : LogError("Failed to close filter file %d after commit: %s", pos.nFile, SysErrorString(errno));
213 : 0 : return 0;
214 : : }
215 : :
216 : 0 : pos.nFile++;
217 : 0 : pos.nPos = 0;
218 : 0 : }
219 : :
220 : : // Pre-allocate sufficient space for filter data.
221 : 0 : bool out_of_space;
222 : 0 : m_filter_fileseq->Allocate(pos, data_size, out_of_space);
223 [ # # ]: 0 : if (out_of_space) {
224 : 0 : LogError("out of disk space");
225 : 0 : return 0;
226 : : }
227 : :
228 : 0 : AutoFile fileout{m_filter_fileseq->Open(pos)};
229 [ # # ]: 0 : if (fileout.IsNull()) {
230 [ # # ]: 0 : LogError("Failed to open filter file %d", pos.nFile);
231 : : return 0;
232 : : }
233 : :
234 [ # # # # ]: 0 : fileout << filter.GetBlockHash() << filter.GetEncodedFilter();
235 : :
236 [ # # # # ]: 0 : if (fileout.fclose() != 0) {
237 [ # # # # ]: 0 : LogError("Failed to close filter file %d: %s", pos.nFile, SysErrorString(errno));
238 : 0 : return 0;
239 : : }
240 : :
241 : : return data_size;
242 : 0 : }
243 : :
244 : 0 : std::optional<uint256> BlockFilterIndex::ReadFilterHeader(int height, const uint256& expected_block_hash)
245 : : {
246 : 0 : std::pair<uint256, DBVal> read_out;
247 [ # # ]: 0 : if (!m_db->Read(index_util::DBHeightKey(height), read_out)) {
248 : 0 : return std::nullopt;
249 : : }
250 : :
251 [ # # ]: 0 : if (read_out.first != expected_block_hash) {
252 [ # # # # ]: 0 : LogError("previous block header belongs to unexpected block %s; expected %s",
253 : : read_out.first.ToString(), expected_block_hash.ToString());
254 : 0 : return std::nullopt;
255 : : }
256 : :
257 : 0 : return read_out.second.header;
258 : : }
259 : :
260 : 0 : bool BlockFilterIndex::CustomAppend(const interfaces::BlockInfo& block)
261 : : {
262 [ # # # # ]: 0 : BlockFilter filter(m_filter_type, *Assert(block.data), *Assert(block.undo_data));
263 [ # # ]: 0 : const uint256& header = filter.ComputeHeader(m_last_header);
264 [ # # ]: 0 : bool res = Write(filter, block.height, header);
265 [ # # ]: 0 : if (res) m_last_header = header; // update last header
266 : 0 : return res;
267 : 0 : }
268 : :
269 : 0 : bool BlockFilterIndex::Write(const BlockFilter& filter, uint32_t block_height, const uint256& filter_header)
270 : : {
271 : 0 : size_t bytes_written = WriteFilterToDisk(m_next_filter_pos, filter);
272 [ # # ]: 0 : if (bytes_written == 0) return false;
273 : :
274 : 0 : std::pair<uint256, DBVal> value;
275 : 0 : value.first = filter.GetBlockHash();
276 : 0 : value.second.hash = filter.GetHash();
277 : 0 : value.second.header = filter_header;
278 : 0 : value.second.pos = m_next_filter_pos;
279 : :
280 : 0 : m_db->Write(index_util::DBHeightKey(block_height), value);
281 : :
282 : 0 : m_next_filter_pos.nPos += bytes_written;
283 : 0 : return true;
284 : : }
285 : :
286 : 0 : bool BlockFilterIndex::CustomRemove(const interfaces::BlockInfo& block)
287 : : {
288 : 0 : CDBBatch batch(*m_db);
289 [ # # # # ]: 0 : std::unique_ptr<CDBIterator> db_it(m_db->NewIterator());
290 : :
291 : : // During a reorg, we need to copy block filter that is getting disconnected from the
292 : : // height index to the hash index so we can still find it when the height index entry
293 : : // is overwritten.
294 [ # # # # ]: 0 : if (!index_util::CopyHeightIndexToHashIndex<DBVal>(*db_it, batch, m_name, block.height)) {
295 : : return false;
296 : : }
297 : :
298 : : // The latest filter position gets written in Commit by the call to the BaseIndex::Rewind.
299 : : // But since this creates new references to the filter, the position should get updated here
300 : : // atomically as well in case Commit fails.
301 [ # # ]: 0 : batch.Write(DB_FILTER_POS, m_next_filter_pos);
302 [ # # ]: 0 : m_db->WriteBatch(batch);
303 : :
304 : : // Update cached header to the previous block hash
305 [ # # # # ]: 0 : m_last_header = *Assert(ReadFilterHeader(block.height - 1, *Assert(block.prev_hash)));
306 : 0 : return true;
307 : 0 : }
308 : :
309 : 0 : static bool LookupRange(CDBWrapper& db, const std::string& index_name, int start_height,
310 : : const CBlockIndex* stop_index, std::vector<DBVal>& results)
311 : : {
312 [ # # ]: 0 : if (start_height < 0) {
313 : 0 : LogError("start height (%d) is negative", start_height);
314 : 0 : return false;
315 : : }
316 [ # # ]: 0 : if (start_height > stop_index->nHeight) {
317 : 0 : LogError("start height (%d) is greater than stop height (%d)",
318 : : start_height, stop_index->nHeight);
319 : 0 : return false;
320 : : }
321 : :
322 : 0 : size_t results_size = static_cast<size_t>(stop_index->nHeight - start_height + 1);
323 : 0 : std::vector<std::pair<uint256, DBVal>> values(results_size);
324 : :
325 [ # # ]: 0 : index_util::DBHeightKey key(start_height);
326 [ # # # # ]: 0 : std::unique_ptr<CDBIterator> db_it(db.NewIterator());
327 [ # # ]: 0 : db_it->Seek(index_util::DBHeightKey(start_height));
328 [ # # ]: 0 : for (int height = start_height; height <= stop_index->nHeight; ++height) {
329 [ # # # # : 0 : if (!db_it->Valid() || !db_it->GetKey(key) || key.height != height) {
# # # # #
# ]
330 : 0 : return false;
331 : : }
332 : :
333 : 0 : size_t i = static_cast<size_t>(height - start_height);
334 [ # # # # ]: 0 : if (!db_it->GetValue(values[i])) {
335 [ # # ]: 0 : LogError("unable to read value in %s at key (%c, %d)",
336 : : index_name, index_util::DB_BLOCK_HEIGHT, height);
337 : : return false;
338 : : }
339 : :
340 [ # # ]: 0 : db_it->Next();
341 : : }
342 : :
343 [ # # ]: 0 : results.resize(results_size);
344 : :
345 : : // Iterate backwards through block indexes collecting results in order to access the block hash
346 : : // of each entry in case we need to look it up in the hash index.
347 : 0 : for (const CBlockIndex* block_index = stop_index;
348 [ # # # # ]: 0 : block_index && block_index->nHeight >= start_height;
349 : 0 : block_index = block_index->pprev) {
350 : 0 : uint256 block_hash = block_index->GetBlockHash();
351 : :
352 : 0 : size_t i = static_cast<size_t>(block_index->nHeight - start_height);
353 [ # # ]: 0 : if (block_hash == values[i].first) {
354 : 0 : results[i] = std::move(values[i].second);
355 : 0 : continue;
356 : : }
357 : :
358 [ # # # # ]: 0 : if (!db.Read(index_util::DBHashKey(block_hash), results[i])) {
359 [ # # # # ]: 0 : LogError("unable to read value in %s at key (%c, %s)",
360 : : index_name, index_util::DB_BLOCK_HASH, block_hash.ToString());
361 : 0 : return false;
362 : : }
363 : : }
364 : :
365 : : return true;
366 : 0 : }
367 : :
368 : 0 : bool BlockFilterIndex::LookupFilter(const CBlockIndex* block_index, BlockFilter& filter_out) const
369 : : {
370 : 0 : DBVal entry;
371 [ # # ]: 0 : if (!index_util::LookUpOne(*m_db, {block_index->GetBlockHash(), block_index->nHeight}, entry)) {
372 : : return false;
373 : : }
374 : :
375 : 0 : return ReadFilterFromDisk(entry.pos, entry.hash, filter_out);
376 : : }
377 : :
378 : 0 : bool BlockFilterIndex::LookupFilterHeader(const CBlockIndex* block_index, uint256& header_out)
379 : : {
380 : 0 : LOCK(m_cs_headers_cache);
381 : :
382 : 0 : bool is_checkpoint{block_index->nHeight % CFCHECKPT_INTERVAL == 0};
383 : :
384 [ # # ]: 0 : if (is_checkpoint) {
385 : : // Try to find the block in the headers cache if this is a checkpoint height.
386 : 0 : auto header = m_headers_cache.find(block_index->GetBlockHash());
387 [ # # ]: 0 : if (header != m_headers_cache.end()) {
388 : 0 : header_out = header->second;
389 : 0 : return true;
390 : : }
391 : : }
392 : :
393 : 0 : DBVal entry;
394 [ # # # # ]: 0 : if (!index_util::LookUpOne(*m_db, {block_index->GetBlockHash(), block_index->nHeight}, entry)) {
395 : : return false;
396 : : }
397 : :
398 [ # # # # ]: 0 : if (is_checkpoint &&
399 [ # # ]: 0 : m_headers_cache.size() < CF_HEADERS_CACHE_MAX_SZ) {
400 : : // Add to the headers cache if this is a checkpoint height.
401 [ # # ]: 0 : m_headers_cache.emplace(block_index->GetBlockHash(), entry.header);
402 : : }
403 : :
404 : 0 : header_out = entry.header;
405 : 0 : return true;
406 : 0 : }
407 : :
408 : 0 : bool BlockFilterIndex::LookupFilterRange(int start_height, const CBlockIndex* stop_index,
409 : : std::vector<BlockFilter>& filters_out) const
410 : : {
411 : 0 : std::vector<DBVal> entries;
412 [ # # # # ]: 0 : if (!LookupRange(*m_db, m_name, start_height, stop_index, entries)) {
413 : : return false;
414 : : }
415 : :
416 [ # # # # ]: 0 : filters_out.resize(entries.size());
417 : 0 : auto filter_pos_it = filters_out.begin();
418 [ # # ]: 0 : for (const auto& entry : entries) {
419 [ # # # # ]: 0 : if (!ReadFilterFromDisk(entry.pos, entry.hash, *filter_pos_it)) {
420 : : return false;
421 : : }
422 : 0 : ++filter_pos_it;
423 : : }
424 : :
425 : : return true;
426 : 0 : }
427 : :
428 : 0 : bool BlockFilterIndex::LookupFilterHashRange(int start_height, const CBlockIndex* stop_index,
429 : : std::vector<uint256>& hashes_out) const
430 : :
431 : : {
432 : 0 : std::vector<DBVal> entries;
433 [ # # # # ]: 0 : if (!LookupRange(*m_db, m_name, start_height, stop_index, entries)) {
434 : : return false;
435 : : }
436 : :
437 [ # # ]: 0 : hashes_out.clear();
438 [ # # # # ]: 0 : hashes_out.reserve(entries.size());
439 [ # # ]: 0 : for (const auto& entry : entries) {
440 [ # # ]: 0 : hashes_out.push_back(entry.hash);
441 : : }
442 : : return true;
443 : 0 : }
444 : :
445 : 3 : BlockFilterIndex* GetBlockFilterIndex(BlockFilterType filter_type)
446 : : {
447 : 3 : auto it = g_filter_indexes.find(filter_type);
448 [ - + ]: 3 : return it != g_filter_indexes.end() ? &it->second : nullptr;
449 : : }
450 : :
451 : 7 : void ForEachBlockFilterIndex(std::function<void (BlockFilterIndex&)> fn)
452 : : {
453 [ - + ]: 7 : for (auto& entry : g_filter_indexes) fn(entry.second);
454 : 7 : }
455 : :
456 : 0 : bool InitBlockFilterIndex(std::function<std::unique_ptr<interfaces::Chain>()> make_chain, BlockFilterType filter_type,
457 : : size_t n_cache_size, bool f_memory, bool f_wipe)
458 : : {
459 : 0 : auto result = g_filter_indexes.emplace(std::piecewise_construct,
460 [ # # ]: 0 : std::forward_as_tuple(filter_type),
461 [ # # ]: 0 : std::forward_as_tuple(make_chain(), filter_type,
462 : : n_cache_size, f_memory, f_wipe));
463 : 0 : return result.second;
464 : : }
465 : :
466 : 0 : bool DestroyBlockFilterIndex(BlockFilterType filter_type)
467 : : {
468 : 0 : return g_filter_indexes.erase(filter_type);
469 : : }
470 : :
471 : 0 : void DestroyAllBlockFilterIndexes()
472 : : {
473 : 0 : g_filter_indexes.clear();
474 : 0 : }
|
