Reading block files, undo records and pruning metadata

751{
752    FlatFilePos undo_pos_old(block_file, m_blockfile_info[block_file].nUndoSize);
753    if (!m_undo_file_seq.Flush(undo_pos_old, finalize)) {
754        m_opts.notifications.flushError(_("Flushing undo file to disk failed. This is likely the result of an I/O error."));
755        return false;
756    }
757    return true;
758}
759
760bool BlockManager::FlushBlockFile(int blockfile_num, bool fFinalize, bool finalize_undo)
761{
762    AssertLockHeld(::cs_main);
763    bool success = true;
764
765    if (m_blockfile_info.size() < 1) {
766        // Return if we haven't loaded any blockfiles yet. This happens during
767        // chainstate init, when we call ChainstateManager::MaybeRebalanceCaches() (which
768        // then calls FlushStateToDisk()), resulting in a call to this function before we
769        // have populated `m_blockfile_info` via LoadBlockIndexDB().
770        return true;
771    }
772    assert(static_cast<int>(m_blockfile_info.size()) > blockfile_num);
773
774    FlatFilePos block_pos_old(blockfile_num, m_blockfile_info[blockfile_num].nSize);
775    if (!m_block_file_seq.Flush(block_pos_old, fFinalize)) {
776        m_opts.notifications.flushError(_("Flushing block file to disk failed. This is likely the result of an I/O error."));
777        success = false;
778    }
779    // we do not always flush the undo file, as the chain tip may be lagging behind the incoming blocks,
780    // e.g. during IBD or a sync after a node going offline
781    if (!fFinalize || finalize_undo) {
782        if (!FlushUndoFile(blockfile_num, finalize_undo)) {
783            success = false;
784        }
785    }
786    return success;
787}
788
789BlockfileType BlockManager::BlockfileTypeForHeight(int height)
790{
791    if (!m_snapshot_height) {
792        return BlockfileType::NORMAL;
793    }
794    return (height >= *m_snapshot_height) ? BlockfileType::ASSUMED : BlockfileType::NORMAL;
795}
796
797bool BlockManager::FlushChainstateBlockFile(int tip_height)
798{
799    AssertLockHeld(::cs_main);
800    auto& cursor = m_blockfile_cursors[BlockfileTypeForHeight(tip_height)];
801    // If the cursor does not exist, it means an assumeutxo snapshot is loaded,
802    // but no blocks past the snapshot height have been written yet, so there
803    // is no data associated with the chainstate, and it is safe not to flush.
804    if (cursor) {
805        return FlushBlockFile(cursor->file_num, /*fFinalize=*/false, /*finalize_undo=*/false);
806    }
807    // No need to log warnings in this case.
808    return true;
809}
810
811uint64_t BlockManager::CalculateCurrentUsage()
812{
813    AssertLockHeld(::cs_main);
814    uint64_t retval = 0;
815    for (const CBlockFileInfo& file : m_blockfile_info) {
816        retval += file.nSize + file.nUndoSize;
817    }
818    return retval;
819}
820
821void BlockManager::UnlinkPrunedFiles(const std::set<int>& setFilesToPrune) const
822{
823    std::error_code ec;
824    for (std::set<int>::iterator it = setFilesToPrune.begin(); it != setFilesToPrune.end(); ++it) {
825        FlatFilePos pos(*it, 0);
826        const bool removed_blockfile{fs::remove(m_block_file_seq.FileName(pos), ec)};
827        const bool removed_undofile{fs::remove(m_undo_file_seq.FileName(pos), ec)};
828        if (removed_blockfile || removed_undofile) {
829            LogDebug(BCLog::BLOCKSTORAGE, "Prune: %s deleted blk/rev (%05u)\n", __func__, *it);
830        }
831    }
832}
833
834AutoFile BlockManager::OpenBlockFile(const FlatFilePos& pos, bool fReadOnly) const
835{
836    return AutoFile{m_block_file_seq.Open(pos, fReadOnly), m_obfuscation};
837}
838
839/** Open an undo file (rev?????.dat) */
840AutoFile BlockManager::OpenUndoFile(const FlatFilePos& pos, bool fReadOnly) const
841{
842    return AutoFile{m_undo_file_seq.Open(pos, fReadOnly), m_obfuscation};
843}
844
845fs::path BlockManager::GetBlockPosFilename(const FlatFilePos& pos) const
846{
847    return m_block_file_seq.FileName(pos);
848}
849
850FlatFilePos BlockManager::FindNextBlockPos(unsigned int nAddSize, unsigned int nHeight, uint64_t nTime)
851{
852    AssertLockHeld(::cs_main);
853    const BlockfileType chain_type = BlockfileTypeForHeight(nHeight);
854
855    if (!m_blockfile_cursors[chain_type]) {
856        // If a snapshot is loaded during runtime, we may not have initialized this cursor yet.
857        assert(chain_type == BlockfileType::ASSUMED);
858        const auto new_cursor = BlockfileCursor{this->MaxBlockfileNum() + 1};
859        m_blockfile_cursors[chain_type] = new_cursor;
860        LogDebug(BCLog::BLOCKSTORAGE, "[%s] initializing blockfile cursor to %s\n", chain_type, new_cursor);
861    }
862    const int last_blockfile = m_blockfile_cursors[chain_type]->file_num;
863
864    int nFile = last_blockfile;
865    if (static_cast<int>(m_blockfile_info.size()) <= nFile) {
866        m_blockfile_info.resize(nFile + 1);
867    }
868
869    bool finalize_undo = false;
870    unsigned int max_blockfile_size{MAX_BLOCKFILE_SIZE};
871    // Use smaller blockfiles in test-only -fastprune mode - but avoid
872    // the possibility of having a block not fit into the block file.
873    if (m_opts.fast_prune) {
874        max_blockfile_size = 0x10000; // 64kiB
875        if (nAddSize >= max_blockfile_size) {
876            // dynamically adjust the blockfile size to be larger than the added size
877            max_blockfile_size = nAddSize + 1;
878        }
879    }
880    assert(nAddSize < max_blockfile_size);
881
882    while (m_blockfile_info[nFile].nSize + nAddSize >= max_blockfile_size) {
883        // when the undo file is keeping up with the block file, we want to flush it explicitly
884        // when it is lagging behind (more blocks arrive than are being connected), we let the
885        // undo block write case handle it
886        finalize_undo = (static_cast<int>(m_blockfile_info[nFile].nHeightLast) ==
887                         Assert(m_blockfile_cursors[chain_type])->undo_height);
888
889        // Try the next unclaimed blockfile number
890        nFile = this->MaxBlockfileNum() + 1;
891        // Set to increment MaxBlockfileNum() for next iteration
892        m_blockfile_cursors[chain_type] = BlockfileCursor{nFile};
893
894        if (static_cast<int>(m_blockfile_info.size()) <= nFile) {
895            m_blockfile_info.resize(nFile + 1);
896        }
897    }
898    FlatFilePos pos;
899    pos.nFile = nFile;
900    pos.nPos = m_blockfile_info[nFile].nSize;
901
902    if (nFile != last_blockfile) {
903        LogDebug(BCLog::BLOCKSTORAGE, "Leaving block file %i: %s (onto %i) (height %i)\n",
904                 last_blockfile, m_blockfile_info[last_blockfile].ToString(), nFile, nHeight);
905
906        // Do not propagate the return code. The flush concerns a previous block
907        // and undo file that has already been written to. If a flush fails
908        // here, and we crash, there is no expected additional block data
909        // inconsistency arising from the flush failure here. However, the undo
910        // data may be inconsistent after a crash if the flush is called during
911        // a reindex. A flush error might also leave some of the data files
912        // untrimmed.
913        if (!FlushBlockFile(last_blockfile, /*fFinalize=*/true, finalize_undo)) {
914            LogWarning(
915                          "Failed to flush previous block file %05i (finalize=1, finalize_undo=%i) before opening new block file %05i\n",
916                          last_blockfile, finalize_undo, nFile);
917        }
918        // No undo data yet in the new file, so reset our undo-height tracking.
919        m_blockfile_cursors[chain_type] = BlockfileCursor{nFile};
920    }
921
922    m_blockfile_info[nFile].AddBlock(nHeight, nTime);
923    m_blockfile_info[nFile].nSize += nAddSize;
924
925    bool out_of_space;
926    size_t bytes_allocated = m_block_file_seq.Allocate(pos, nAddSize, out_of_space);
927    if (out_of_space) {
928        m_opts.notifications.fatalError(_("Disk space is too low!"));
929        return {};
930    }
931    if (bytes_allocated != 0 && IsPruneMode()) {
932        m_check_for_pruning = true;
933    }
934
935    m_dirty_fileinfo.insert(nFile);
936    return pos;
937}
938
939void BlockManager::UpdateBlockInfo(const CBlock& block, unsigned int nHeight, const FlatFilePos& pos)
940{
941    AssertLockHeld(::cs_main);
942    // Update the cursor so it points to the last file.
943    const BlockfileType chain_type{BlockfileTypeForHeight(nHeight)};
944    auto& cursor{m_blockfile_cursors[chain_type]};
945    if (!cursor || cursor->file_num < pos.nFile) {
946        m_blockfile_cursors[chain_type] = BlockfileCursor{pos.nFile};
947    }
948
949    // Update the file information with the current block.
950    const unsigned int added_size = ::GetSerializeSize(TX_WITH_WITNESS(block));
951    const int nFile = pos.nFile;
952    if (static_cast<int>(m_blockfile_info.size()) <= nFile) {
953        m_blockfile_info.resize(nFile + 1);
954    }
955    m_blockfile_info[nFile].AddBlock(nHeight, block.GetBlockTime());
956    m_blockfile_info[nFile].nSize = std::max(pos.nPos + added_size, m_blockfile_info[nFile].nSize);
957    m_dirty_fileinfo.insert(nFile);
958}
959
960bool BlockManager::FindUndoPos(BlockValidationState& state, int nFile, FlatFilePos& pos, unsigned int nAddSize)
961{
962    AssertLockHeld(::cs_main);
963    pos.nFile = nFile;
964
965    pos.nPos = m_blockfile_info[nFile].nUndoSize;
966    m_blockfile_info[nFile].nUndoSize += nAddSize;
967    m_dirty_fileinfo.insert(nFile);
968
969    bool out_of_space;
970    size_t bytes_allocated = m_undo_file_seq.Allocate(pos, nAddSize, out_of_space);
971    if (out_of_space) {
972        return FatalError(m_opts.notifications, state, _("Disk space is too low!"));
973    }
974    if (bytes_allocated != 0 && IsPruneMode()) {
975        m_check_for_pruning = true;
976    }
977
978    return true;
979}
980
981bool BlockManager::WriteBlockUndo(const CBlockUndo& blockundo, BlockValidationState& state, CBlockIndex& block)
982{
983    AssertLockHeld(::cs_main);
984    const BlockfileType type = BlockfileTypeForHeight(block.nHeight);
985    auto& cursor = *Assert(m_blockfile_cursors[type]);
986
987    // Write undo information to disk
988    if (block.GetUndoPos().IsNull()) {
989        FlatFilePos pos;
990        const auto blockundo_size{static_cast<uint32_t>(GetSerializeSize(blockundo))};
991        if (!FindUndoPos(state, block.nFile, pos, blockundo_size + UNDO_DATA_DISK_OVERHEAD)) {
992            LogError("FindUndoPos failed for %s while writing block undo", pos.ToString());
993            return false;
994        }
995
996        // Open history file to append
997        AutoFile file{OpenUndoFile(pos)};
998        if (file.IsNull()) {
999            LogError("OpenUndoFile failed for %s while writing block undo", pos.ToString());
1000            return FatalError(m_opts.notifications, state, _("Failed to write undo data."));