Branch data Line data Source code
1 : : // Copyright (c) 2012-2022 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 <dbwrapper.h>
6 : :
7 : : #include <logging.h>
8 : : #include <random.h>
9 : : #include <serialize.h>
10 : : #include <span.h>
11 : : #include <streams.h>
12 : : #include <util/fs.h>
13 : : #include <util/fs_helpers.h>
14 : : #include <util/strencodings.h>
15 : :
16 : : #include <algorithm>
17 : : #include <cassert>
18 : : #include <cstdarg>
19 : : #include <cstdint>
20 : : #include <cstdio>
21 : : #include <leveldb/cache.h>
22 : : #include <leveldb/db.h>
23 : : #include <leveldb/env.h>
24 : : #include <leveldb/filter_policy.h>
25 : : #include <leveldb/helpers/memenv/memenv.h>
26 : : #include <leveldb/iterator.h>
27 : : #include <leveldb/options.h>
28 : : #include <leveldb/slice.h>
29 : : #include <leveldb/status.h>
30 : : #include <leveldb/write_batch.h>
31 : : #include <memory>
32 : : #include <optional>
33 : : #include <utility>
34 : :
35 : 5824156 : static auto CharCast(const std::byte* data) { return reinterpret_cast<const char*>(data); }
36 : :
37 : 0 : bool DestroyDB(const std::string& path_str)
38 : : {
39 [ # # ]: 0 : return leveldb::DestroyDB(path_str, {}).ok();
40 : : }
41 : :
42 : : /** Handle database error by throwing dbwrapper_error exception.
43 : : */
44 : 232371 : static void HandleError(const leveldb::Status& status)
45 : : {
46 [ + - ]: 232371 : if (status.ok())
47 : 232371 : return;
48 [ # # ]: 0 : const std::string errmsg = "Fatal LevelDB error: " + status.ToString();
49 [ # # ]: 0 : LogPrintf("%s\n", errmsg);
50 [ # # ]: 0 : LogPrintf("You can use -debug=leveldb to get more complete diagnostic messages\n");
51 [ # # ]: 0 : throw dbwrapper_error(errmsg);
52 : 0 : }
53 : :
54 : 6905 : class CBitcoinLevelDBLogger : public leveldb::Logger {
55 : : public:
56 : : // This code is adapted from posix_logger.h, which is why it is using vsprintf.
57 : : // Please do not do this in normal code
58 : 7444 : void Logv(const char * format, va_list ap) override {
59 [ - + ]: 7444 : if (!LogAcceptCategory(BCLog::LEVELDB, BCLog::Level::Debug)) {
60 : : return;
61 : : }
62 : : char buffer[500];
63 [ # # ]: 0 : for (int iter = 0; iter < 2; iter++) {
64 : 0 : char* base;
65 : 0 : int bufsize;
66 [ # # ]: 0 : if (iter == 0) {
67 : : bufsize = sizeof(buffer);
68 : : base = buffer;
69 : : }
70 : : else {
71 : 0 : bufsize = 30000;
72 : 0 : base = new char[bufsize];
73 : : }
74 : 0 : char* p = base;
75 : 0 : char* limit = base + bufsize;
76 : :
77 : : // Print the message
78 [ # # ]: 0 : if (p < limit) {
79 : 0 : va_list backup_ap;
80 : 0 : va_copy(backup_ap, ap);
81 : : // Do not use vsnprintf elsewhere in bitcoin source code, see above.
82 : 0 : p += vsnprintf(p, limit - p, format, backup_ap);
83 : 0 : va_end(backup_ap);
84 : : }
85 : :
86 : : // Truncate to available space if necessary
87 [ # # ]: 0 : if (p >= limit) {
88 [ # # ]: 0 : if (iter == 0) {
89 : 0 : continue; // Try again with larger buffer
90 : : }
91 : : else {
92 : 0 : p = limit - 1;
93 : : }
94 : : }
95 : :
96 : : // Add newline if necessary
97 [ # # # # ]: 0 : if (p == base || p[-1] != '\n') {
98 : 0 : *p++ = '\n';
99 : : }
100 : :
101 [ # # ]: 0 : assert(p <= limit);
102 [ # # ]: 0 : base[std::min(bufsize - 1, (int)(p - base))] = '\0';
103 [ # # ]: 0 : LogDebug(BCLog::LEVELDB, "%s\n", util::RemoveSuffixView(base, "\n"));
104 [ # # ]: 0 : if (base != buffer) {
105 [ # # ]: 0 : delete[] base;
106 : : }
107 : : break;
108 : : }
109 : : }
110 : : };
111 : :
112 : 6905 : static void SetMaxOpenFiles(leveldb::Options *options) {
113 : : // On most platforms the default setting of max_open_files (which is 1000)
114 : : // is optimal. On Windows using a large file count is OK because the handles
115 : : // do not interfere with select() loops. On 64-bit Unix hosts this value is
116 : : // also OK, because up to that amount LevelDB will use an mmap
117 : : // implementation that does not use extra file descriptors (the fds are
118 : : // closed after being mmap'ed).
119 : : //
120 : : // Increasing the value beyond the default is dangerous because LevelDB will
121 : : // fall back to a non-mmap implementation when the file count is too large.
122 : : // On 32-bit Unix host we should decrease the value because the handles use
123 : : // up real fds, and we want to avoid fd exhaustion issues.
124 : : //
125 : : // See PR #12495 for further discussion.
126 : :
127 : 6905 : int default_open_files = options->max_open_files;
128 : : #ifndef WIN32
129 : 6905 : if (sizeof(void*) < 8) {
130 : : options->max_open_files = 64;
131 : : }
132 : : #endif
133 [ - + ]: 6905 : LogDebug(BCLog::LEVELDB, "LevelDB using max_open_files=%d (default=%d)\n",
134 : : options->max_open_files, default_open_files);
135 : 6905 : }
136 : :
137 : 6905 : static leveldb::Options GetOptions(size_t nCacheSize)
138 : : {
139 : 6905 : leveldb::Options options;
140 : 6905 : options.block_cache = leveldb::NewLRUCache(nCacheSize / 2);
141 : 6905 : options.write_buffer_size = nCacheSize / 4; // up to two write buffers may be held in memory simultaneously
142 : 6905 : options.filter_policy = leveldb::NewBloomFilterPolicy(10);
143 : 6905 : options.compression = leveldb::kNoCompression;
144 [ - + ]: 6905 : options.info_log = new CBitcoinLevelDBLogger();
145 : 6905 : if (leveldb::kMajorVersion > 1 || (leveldb::kMajorVersion == 1 && leveldb::kMinorVersion >= 16)) {
146 : : // LevelDB versions before 1.16 consider short writes to be corruption. Only trigger error
147 : : // on corruption in later versions.
148 : 6905 : options.paranoid_checks = true;
149 : : }
150 [ - + ]: 6905 : options.max_file_size = std::max(options.max_file_size, DBWRAPPER_MAX_FILE_SIZE);
151 : 6905 : SetMaxOpenFiles(&options);
152 : 6905 : return options;
153 : : }
154 : :
155 [ + - ]: 450932 : struct CDBBatch::WriteBatchImpl {
156 : : leveldb::WriteBatch batch;
157 : : };
158 : :
159 : 225466 : CDBBatch::CDBBatch(const CDBWrapper& _parent)
160 : 225466 : : parent{_parent},
161 : 225466 : m_impl_batch{std::make_unique<CDBBatch::WriteBatchImpl>()} {};
162 : :
163 : 225466 : CDBBatch::~CDBBatch() = default;
164 : :
165 : 0 : void CDBBatch::Clear()
166 : : {
167 : 0 : m_impl_batch->batch.Clear();
168 : 0 : size_estimate = 0;
169 : 0 : }
170 : :
171 : 1911566 : void CDBBatch::WriteImpl(Span<const std::byte> key, DataStream& ssValue)
172 : : {
173 : 1911566 : leveldb::Slice slKey(CharCast(key.data()), key.size());
174 : 1911566 : ssValue.Xor(dbwrapper_private::GetObfuscateKey(parent));
175 : 1911566 : leveldb::Slice slValue(CharCast(ssValue.data()), ssValue.size());
176 : 1911566 : m_impl_batch->batch.Put(slKey, slValue);
177 : : // LevelDB serializes writes as:
178 : : // - byte: header
179 : : // - varint: key length (1 byte up to 127B, 2 bytes up to 16383B, ...)
180 : : // - byte[]: key
181 : : // - varint: value length
182 : : // - byte[]: value
183 : : // The formula below assumes the key and value are both less than 16k.
184 [ + - ]: 1911566 : size_estimate += 3 + (slKey.size() > 127) + slKey.size() + (slValue.size() > 127) + slValue.size();
185 : 1911566 : }
186 : :
187 : 221605 : void CDBBatch::EraseImpl(Span<const std::byte> key)
188 : : {
189 : 221605 : leveldb::Slice slKey(CharCast(key.data()), key.size());
190 : 221605 : m_impl_batch->batch.Delete(slKey);
191 : : // LevelDB serializes erases as:
192 : : // - byte: header
193 : : // - varint: key length
194 : : // - byte[]: key
195 : : // The formula below assumes the key is less than 16kB.
196 [ + - ]: 221605 : size_estimate += 2 + (slKey.size() > 127) + slKey.size();
197 : 221605 : }
198 : :
199 : : struct LevelDBContext {
200 : : //! custom environment this database is using (may be nullptr in case of default environment)
201 : : leveldb::Env* penv;
202 : :
203 : : //! database options used
204 : : leveldb::Options options;
205 : :
206 : : //! options used when reading from the database
207 : : leveldb::ReadOptions readoptions;
208 : :
209 : : //! options used when iterating over values of the database
210 : : leveldb::ReadOptions iteroptions;
211 : :
212 : : //! options used when writing to the database
213 : : leveldb::WriteOptions writeoptions;
214 : :
215 : : //! options used when sync writing to the database
216 : : leveldb::WriteOptions syncoptions;
217 : :
218 : : //! the database itself
219 : : leveldb::DB* pdb;
220 : : };
221 : :
222 : 6905 : CDBWrapper::CDBWrapper(const DBParams& params)
223 [ + - + - : 34525 : : m_db_context{std::make_unique<LevelDBContext>()}, m_name{fs::PathToString(params.path.stem())}, m_path{params.path}, m_is_memory{params.memory_only}
+ - ]
224 : : {
225 [ + - ]: 6905 : DBContext().penv = nullptr;
226 [ + - ]: 6905 : DBContext().readoptions.verify_checksums = true;
227 [ + - ]: 6905 : DBContext().iteroptions.verify_checksums = true;
228 [ + - ]: 6905 : DBContext().iteroptions.fill_cache = false;
229 [ + - ]: 6905 : DBContext().syncoptions.sync = true;
230 [ + - + - ]: 6905 : DBContext().options = GetOptions(params.cache_bytes);
231 [ + - ]: 6905 : DBContext().options.create_if_missing = true;
232 [ + - ]: 6905 : if (params.memory_only) {
233 [ + - + - : 6905 : DBContext().penv = leveldb::NewMemEnv(leveldb::Env::Default());
+ - ]
234 [ + - + - ]: 6905 : DBContext().options.env = DBContext().penv;
235 : : } else {
236 [ # # ]: 0 : if (params.wipe_data) {
237 [ # # # # ]: 0 : LogPrintf("Wiping LevelDB in %s\n", fs::PathToString(params.path));
238 [ # # # # : 0 : leveldb::Status result = leveldb::DestroyDB(fs::PathToString(params.path), DBContext().options);
# # ]
239 [ # # ]: 0 : HandleError(result);
240 : 0 : }
241 [ # # ]: 0 : TryCreateDirectories(params.path);
242 [ # # # # ]: 0 : LogPrintf("Opening LevelDB in %s\n", fs::PathToString(params.path));
243 : : }
244 : : // PathToString() return value is safe to pass to leveldb open function,
245 : : // because on POSIX leveldb passes the byte string directly to ::open(), and
246 : : // on Windows it converts from UTF-8 to UTF-16 before calling ::CreateFileW
247 : : // (see env_posix.cc and env_windows.cc).
248 [ + - + - : 13810 : leveldb::Status status = leveldb::DB::Open(DBContext().options, fs::PathToString(params.path), &DBContext().pdb);
+ - + - ]
249 [ + - ]: 6905 : HandleError(status);
250 [ + - ]: 6905 : LogPrintf("Opened LevelDB successfully\n");
251 : :
252 [ - + ]: 6905 : if (params.options.force_compact) {
253 [ # # # # ]: 0 : LogPrintf("Starting database compaction of %s\n", fs::PathToString(params.path));
254 [ # # # # ]: 0 : DBContext().pdb->CompactRange(nullptr, nullptr);
255 [ # # # # ]: 0 : LogPrintf("Finished database compaction of %s\n", fs::PathToString(params.path));
256 : : }
257 : :
258 : : // The base-case obfuscation key, which is a noop.
259 [ + - + - ]: 6905 : obfuscate_key = std::vector<unsigned char>(OBFUSCATE_KEY_NUM_BYTES, '\000');
260 : :
261 [ + - ]: 6905 : bool key_exists = Read(OBFUSCATE_KEY_KEY, obfuscate_key);
262 : :
263 [ + - + + : 6905 : if (!key_exists && params.obfuscate && IsEmpty()) {
+ - + - ]
264 : : // Initialize non-degenerate obfuscation if it won't upset
265 : : // existing, non-obfuscated data.
266 [ + - ]: 2995 : std::vector<unsigned char> new_key = CreateObfuscateKey();
267 : :
268 : : // Write `new_key` so we don't obfuscate the key with itself
269 [ + - ]: 2995 : Write(OBFUSCATE_KEY_KEY, new_key);
270 [ + - ]: 2995 : obfuscate_key = new_key;
271 : :
272 [ + - + - : 8985 : LogPrintf("Wrote new obfuscate key for %s: %s\n", fs::PathToString(params.path), HexStr(obfuscate_key));
+ - ]
273 : 2995 : }
274 : :
275 [ + - + - : 20715 : LogPrintf("Using obfuscation key for %s: %s\n", fs::PathToString(params.path), HexStr(obfuscate_key));
+ - - + ]
276 : 6905 : }
277 : :
278 : 13810 : CDBWrapper::~CDBWrapper()
279 : : {
280 [ + - ]: 6905 : delete DBContext().pdb;
281 : 6905 : DBContext().pdb = nullptr;
282 [ + - ]: 6905 : delete DBContext().options.filter_policy;
283 : 6905 : DBContext().options.filter_policy = nullptr;
284 [ + - ]: 6905 : delete DBContext().options.info_log;
285 : 6905 : DBContext().options.info_log = nullptr;
286 [ + - ]: 6905 : delete DBContext().options.block_cache;
287 : 6905 : DBContext().options.block_cache = nullptr;
288 [ + - ]: 6905 : delete DBContext().penv;
289 : 6905 : DBContext().options.env = nullptr;
290 : 6905 : }
291 : :
292 : 225466 : bool CDBWrapper::WriteBatch(CDBBatch& batch, bool fSync)
293 : : {
294 : 225466 : const bool log_memory = LogAcceptCategory(BCLog::LEVELDB, BCLog::Level::Debug);
295 : 225466 : double mem_before = 0;
296 [ + + ]: 225466 : if (log_memory) {
297 : 124 : mem_before = DynamicMemoryUsage() / 1024.0 / 1024;
298 : : }
299 [ + + ]: 225466 : leveldb::Status status = DBContext().pdb->Write(fSync ? DBContext().syncoptions : DBContext().writeoptions, &batch.m_impl_batch->batch);
300 [ + - ]: 225466 : HandleError(status);
301 [ + + ]: 225466 : if (log_memory) {
302 [ + - ]: 124 : double mem_after = DynamicMemoryUsage() / 1024.0 / 1024;
303 [ + - + - : 124 : LogDebug(BCLog::LEVELDB, "WriteBatch memory usage: db=%s, before=%.1fMiB, after=%.1fMiB\n",
+ - ]
304 : : m_name, mem_before, mem_after);
305 : : }
306 [ - + ]: 225466 : return true;
307 : 225466 : }
308 : :
309 : 248 : size_t CDBWrapper::DynamicMemoryUsage() const
310 : : {
311 [ + - ]: 248 : std::string memory;
312 : 248 : std::optional<size_t> parsed;
313 [ + - + - : 248 : if (!DBContext().pdb->GetProperty("leveldb.approximate-memory-usage", &memory) || !(parsed = ToIntegral<size_t>(memory))) {
+ - - + ]
314 [ # # # # : 0 : LogDebug(BCLog::LEVELDB, "Failed to get approximate-memory-usage property\n");
# # ]
315 : 0 : return 0;
316 : : }
317 : 248 : return parsed.value();
318 : 248 : }
319 : :
320 : : // Prefixed with null character to avoid collisions with other keys
321 : : //
322 : : // We must use a string constructor which specifies length so that we copy
323 : : // past the null-terminator.
324 : : const std::string CDBWrapper::OBFUSCATE_KEY_KEY("\000obfuscate_key", 14);
325 : :
326 : : const unsigned int CDBWrapper::OBFUSCATE_KEY_NUM_BYTES = 8;
327 : :
328 : : /**
329 : : * Returns a string (consisting of 8 random bytes) suitable for use as an
330 : : * obfuscating XOR key.
331 : : */
332 : 2995 : std::vector<unsigned char> CDBWrapper::CreateObfuscateKey() const
333 : : {
334 : 2995 : std::vector<uint8_t> ret(OBFUSCATE_KEY_NUM_BYTES);
335 : 2995 : GetRandBytes(ret);
336 : 2995 : return ret;
337 : : }
338 : :
339 : 1446086 : std::optional<std::string> CDBWrapper::ReadImpl(Span<const std::byte> key) const
340 : : {
341 [ + - ]: 1446086 : leveldb::Slice slKey(CharCast(key.data()), key.size());
342 [ + - ]: 1446086 : std::string strValue;
343 [ + - + - : 1446086 : leveldb::Status status = DBContext().pdb->Get(DBContext().readoptions, slKey, &strValue);
+ - ]
344 [ + + ]: 1446086 : if (!status.ok()) {
345 [ + - ]: 1088392 : if (status.IsNotFound())
346 : 1088392 : return std::nullopt;
347 [ # # # # ]: 0 : LogPrintf("LevelDB read failure: %s\n", status.ToString());
348 [ # # ]: 0 : HandleError(status);
349 : : }
350 : 357694 : return strValue;
351 : 1446086 : }
352 : :
353 : 2658 : bool CDBWrapper::ExistsImpl(Span<const std::byte> key) const
354 : : {
355 [ + - ]: 2658 : leveldb::Slice slKey(CharCast(key.data()), key.size());
356 : :
357 [ + - ]: 2658 : std::string strValue;
358 [ + - + - : 2658 : leveldb::Status status = DBContext().pdb->Get(DBContext().readoptions, slKey, &strValue);
+ - ]
359 [ + + ]: 2658 : if (!status.ok()) {
360 [ - + ]: 2178 : if (status.IsNotFound())
361 : : return false;
362 [ # # # # ]: 0 : LogPrintf("LevelDB read failure: %s\n", status.ToString());
363 [ # # ]: 0 : HandleError(status);
364 : : }
365 : : return true;
366 : 2658 : }
367 : :
368 : 108932 : size_t CDBWrapper::EstimateSizeImpl(Span<const std::byte> key1, Span<const std::byte> key2) const
369 : : {
370 : 108932 : leveldb::Slice slKey1(CharCast(key1.data()), key1.size());
371 : 108932 : leveldb::Slice slKey2(CharCast(key2.data()), key2.size());
372 : 108932 : uint64_t size = 0;
373 : 108932 : leveldb::Range range(slKey1, slKey2);
374 : 108932 : DBContext().pdb->GetApproximateSizes(&range, 1, &size);
375 : 108932 : return size;
376 : : }
377 : :
378 : 2995 : bool CDBWrapper::IsEmpty()
379 : : {
380 [ + - ]: 2995 : std::unique_ptr<CDBIterator> it(NewIterator());
381 [ + - ]: 2995 : it->SeekToFirst();
382 [ + - ]: 5990 : return !(it->Valid());
383 : 2995 : }
384 : :
385 : 115806 : struct CDBIterator::IteratorImpl {
386 : : const std::unique_ptr<leveldb::Iterator> iter;
387 : :
388 : 115806 : explicit IteratorImpl(leveldb::Iterator* _iter) : iter{_iter} {}
389 : : };
390 : :
391 : 115806 : CDBIterator::CDBIterator(const CDBWrapper& _parent, std::unique_ptr<IteratorImpl> _piter) : parent(_parent),
392 : 115806 : m_impl_iter(std::move(_piter)) {}
393 : :
394 : 115806 : CDBIterator* CDBWrapper::NewIterator()
395 : : {
396 [ + - + - : 115806 : return new CDBIterator{*this, std::make_unique<CDBIterator::IteratorImpl>(DBContext().pdb->NewIterator(DBContext().iteroptions))};
+ - + - +
- ]
397 : : }
398 : :
399 : 112811 : void CDBIterator::SeekImpl(Span<const std::byte> key)
400 : : {
401 : 112811 : leveldb::Slice slKey(CharCast(key.data()), key.size());
402 : 112811 : m_impl_iter->iter->Seek(slKey);
403 : 112811 : }
404 : :
405 : 5848065 : Span<const std::byte> CDBIterator::GetKeyImpl() const
406 : : {
407 : 5848065 : return MakeByteSpan(m_impl_iter->iter->key());
408 : : }
409 : :
410 : 5847585 : Span<const std::byte> CDBIterator::GetValueImpl() const
411 : : {
412 : 5847585 : return MakeByteSpan(m_impl_iter->iter->value());
413 : : }
414 : :
415 : 115806 : CDBIterator::~CDBIterator() = default;
416 : 5963391 : bool CDBIterator::Valid() const { return m_impl_iter->iter->Valid(); }
417 : 2995 : void CDBIterator::SeekToFirst() { m_impl_iter->iter->SeekToFirst(); }
418 : 5847585 : void CDBIterator::Next() { m_impl_iter->iter->Next(); }
419 : :
420 : : namespace dbwrapper_private {
421 : :
422 : 7759151 : const std::vector<unsigned char>& GetObfuscateKey(const CDBWrapper &w)
423 : : {
424 : 7759151 : return w.obfuscate_key;
425 : : }
426 : :
427 : : } // namespace dbwrapper_private
|
