LCOV - code coverage report
Current view: top level - src - dbwrapper.cpp (source / functions) Coverage Total Hit
Test: total_coverage.info Lines: 79.5 % 195 155
Test Date: 2025-08-25 05:11:47 Functions: 96.7 % 30 29
Branches: 42.4 % 262 111

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

Generated by: LCOV version 2.0-1