validationinterface.cpp

Go to the documentation of this file.

// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2016 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
#include <validationinterface.h>
 
#include <chain.h>
#include <consensus/validation.h>
#include <kernel/chain.h>
#include <logging.h>
#include <primitives/block.h>
#include <primitives/transaction.h>
#include <util/check.h>
#include <util/task_runner.h>
 
#include <future>
#include <tuple>
#include <unordered_map>
#include <utility>
 
std::string RemovalReasonToString(const MemPoolRemovalReason &r) noexcept;
 
class ValidationSignalsImpl {
private:
    Mutex m_mutex;
    struct ListEntry {
        std::shared_ptr<CValidationInterface> callbacks;
        int count = 1;
    };
    std::list<ListEntry> m_list GUARDED_BY(m_mutex);
    std::unordered_map<CValidationInterface *, std::list<ListEntry>::iterator>
        m_map GUARDED_BY(m_mutex);
 
public:
    std::unique_ptr<util::TaskRunnerInterface> m_task_runner;
 
    explicit ValidationSignalsImpl(
        std::unique_ptr<util::TaskRunnerInterface> task_runner)
        : m_task_runner{std::move(Assert(task_runner))} {}
 
    void Register(std::shared_ptr<CValidationInterface> callbacks)
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
        LOCK(m_mutex);
        auto inserted = m_map.emplace(callbacks.get(), m_list.end());
        if (inserted.second) {
            inserted.first->second = m_list.emplace(m_list.end());
        }
        inserted.first->second->callbacks = std::move(callbacks);
    }
 
    void Unregister(CValidationInterface *callbacks)
        EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
        LOCK(m_mutex);
        auto it = m_map.find(callbacks);
        if (it != m_map.end()) {
            if (!--it->second->count) {
                m_list.erase(it->second);
            }
            m_map.erase(it);
        }
    }
 
    void Clear() EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
        LOCK(m_mutex);
        for (const auto &entry : m_map) {
            if (!--entry.second->count) {
                m_list.erase(entry.second);
            }
        }
        m_map.clear();
    }
 
    template <typename F>
    void Iterate(F &&f) EXCLUSIVE_LOCKS_REQUIRED(!m_mutex) {
        WAIT_LOCK(m_mutex, lock);
        for (auto it = m_list.begin(); it != m_list.end();) {
            ++it->count;
            {
                REVERSE_LOCK(lock);
                f(*it->callbacks);
            }
            it = --it->count ? std::next(it) : m_list.erase(it);
        }
    }
};
 
ValidationSignals::ValidationSignals(
    std::unique_ptr<util::TaskRunnerInterface> task_runner)
    : m_internals{
          std::make_unique<ValidationSignalsImpl>(std::move(task_runner))} {}
 
ValidationSignals::~ValidationSignals() {}
 
void ValidationSignals::FlushBackgroundCallbacks() {
    m_internals->m_task_runner->flush();
}
 
size_t ValidationSignals::CallbacksPending() {
    return m_internals->m_task_runner->size();
}
 
void ValidationSignals::RegisterSharedValidationInterface(
    std::shared_ptr<CValidationInterface> callbacks) {
    // Each connection captures the shared_ptr to ensure that each callback is
    // executed before the subscriber is destroyed. For more details see #18338.
    m_internals->Register(std::move(callbacks));
}
 
void ValidationSignals::RegisterValidationInterface(
    CValidationInterface *callbacks) {
    // Create a shared_ptr with a no-op deleter - CValidationInterface lifecycle
    // is managed by the caller.
    RegisterSharedValidationInterface(
        {callbacks, [](CValidationInterface *) {}});
}
 
void ValidationSignals::UnregisterSharedValidationInterface(
    std::shared_ptr<CValidationInterface> callbacks) {
    UnregisterValidationInterface(callbacks.get());
}
 
void ValidationSignals::UnregisterValidationInterface(
    CValidationInterface *callbacks) {
    m_internals->Unregister(callbacks);
}
 
void ValidationSignals::UnregisterAllValidationInterfaces() {
    m_internals->Clear();
}
 
void ValidationSignals::CallFunctionInValidationInterfaceQueue(
    std::function<void()> func) {
    m_internals->m_task_runner->insert(std::move(func));
}
 
void ValidationSignals::SyncWithValidationInterfaceQueue() {
    AssertLockNotHeld(cs_main);
    // Block until the validation queue drains
    std::promise<void> promise;
    CallFunctionInValidationInterfaceQueue([&promise] { promise.set_value(); });
    promise.get_future().wait();
}
 
// Use a macro instead of a function for conditional logging to prevent
// evaluating arguments when logging is not enabled.
//
// NOTE: The lambda captures all local variables by value.
#define ENQUEUE_AND_LOG_EVENT(event, fmt, name, ...)                           \
    do {                                                                       \
        auto local_name = (name);                                              \
        LOG_EVENT("Enqueuing " fmt, local_name, __VA_ARGS__);                  \
        m_internals->m_task_runner->insert([=] {                               \
            LOG_EVENT(fmt, local_name, __VA_ARGS__);                           \
            event();                                                           \
        });                                                                    \
    } while (0)
 
#define LOG_EVENT(fmt, ...) LogPrint(BCLog::VALIDATION, fmt "\n", __VA_ARGS__)
 
void ValidationSignals::UpdatedBlockTip(const CBlockIndex *pindexNew,
                                        const CBlockIndex *pindexFork,
                                        bool fInitialDownload) {
    // Dependencies exist that require UpdatedBlockTip events to be delivered in
    // the order in which the chain actually updates. One way to ensure this is
    // for the caller to invoke this signal in the same critical section where
    // the chain is updated
 
    auto event = [pindexNew, pindexFork, fInitialDownload, this] {
        m_internals->Iterate([&](CValidationInterface &callbacks) {
            callbacks.UpdatedBlockTip(pindexNew, pindexFork, fInitialDownload);
        });
    };
    ENQUEUE_AND_LOG_EVENT(
        event, "%s: new block hash=%s fork block hash=%s (in IBD=%s)", __func__,
        pindexNew->GetBlockHash().ToString(),
        pindexFork ? pindexFork->GetBlockHash().ToString() : "null",
        fInitialDownload);
}
 
void ValidationSignals::TransactionAddedToMempool(
    const CTransactionRef &tx,
    std::shared_ptr<const std::vector<Coin>> spent_coins,
    uint64_t mempool_sequence) {
    auto event = [tx, spent_coins, mempool_sequence, this] {
        m_internals->Iterate([&](CValidationInterface &callbacks) {
            callbacks.TransactionAddedToMempool(tx, spent_coins,
                                                mempool_sequence);
        });
    };
    ENQUEUE_AND_LOG_EVENT(event, "%s: txid=%s", __func__,
                          tx->GetHash().ToString());
}
 
void ValidationSignals::TransactionRemovedFromMempool(
    const CTransactionRef &tx, MemPoolRemovalReason reason,
    uint64_t mempool_sequence) {
    auto event = [tx, reason, mempool_sequence, this] {
        m_internals->Iterate([&](CValidationInterface &callbacks) {
            callbacks.TransactionRemovedFromMempool(tx, reason,
                                                    mempool_sequence);
        });
    };
    ENQUEUE_AND_LOG_EVENT(event, "%s: txid=%s reason=%s", __func__,
                          tx->GetHash().ToString(),
                          RemovalReasonToString(reason));
}
 
void ValidationSignals::BlockConnected(
    ChainstateRole role, const std::shared_ptr<const CBlock> &pblock,
    const CBlockIndex *pindex) {
    auto event = [role, pblock, pindex, this] {
        m_internals->Iterate([&](CValidationInterface &callbacks) {
            callbacks.BlockConnected(role, pblock, pindex);
        });
    };
    ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s block height=%d", __func__,
                          pblock->GetHash().ToString(), pindex->nHeight);
}
 
void ValidationSignals::BlockDisconnected(
    const std::shared_ptr<const CBlock> &pblock, const CBlockIndex *pindex) {
    auto event = [pblock, pindex, this] {
        m_internals->Iterate([&](CValidationInterface &callbacks) {
            callbacks.BlockDisconnected(pblock, pindex);
        });
    };
    ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s", __func__,
                          pblock->GetHash().ToString());
}
 
void ValidationSignals::ChainStateFlushed(ChainstateRole role,
                                          const CBlockLocator &locator) {
    auto event = [role, locator, this] {
        m_internals->Iterate([&](CValidationInterface &callbacks) {
            callbacks.ChainStateFlushed(role, locator);
        });
    };
    ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s", __func__,
                          locator.IsNull() ? "null"
                                           : locator.vHave.front().ToString());
}
 
void ValidationSignals::BlockChecked(const CBlock &block,
                                     const BlockValidationState &state) {
    LOG_EVENT("%s: block hash=%s state=%s", __func__,
              block.GetHash().ToString(), state.ToString());
    m_internals->Iterate([&](CValidationInterface &callbacks) {
        callbacks.BlockChecked(block, state);
    });
}
 
void ValidationSignals::NewPoWValidBlock(
    const CBlockIndex *pindex, const std::shared_ptr<const CBlock> &block) {
    LOG_EVENT("%s: block hash=%s", __func__, block->GetHash().ToString());
    m_internals->Iterate([&](CValidationInterface &callbacks) {
        callbacks.NewPoWValidBlock(pindex, block);
    });
}
 
void ValidationSignals::BlockFinalized(const CBlockIndex *pindex) {
    auto event = [pindex, this] {
        m_internals->Iterate([&](CValidationInterface &callbacks) {
            callbacks.BlockFinalized(pindex);
        });
    };
    ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s", __func__,
                          pindex ? pindex->GetBlockHash().ToString() : "null");
}
 
void ValidationSignals::BlockInvalidated(
    const CBlockIndex *pindex, const std::shared_ptr<const CBlock> &block) {
    auto event = [pindex, block, this] {
        m_internals->Iterate([&](CValidationInterface &callbacks) {
            callbacks.BlockInvalidated(pindex, block);
        });
    };
    ENQUEUE_AND_LOG_EVENT(event, "%s: block hash=%s", __func__,
                          block ? block->GetHash().ToString() : "null");
}
 
void ValidationSignals::TransactionFinalized(const CTransactionRef &tx) {
    auto event = [tx, this] {
        m_internals->Iterate([&](CValidationInterface &callbacks) {
            callbacks.TransactionFinalized(tx);
        });
    };
    ENQUEUE_AND_LOG_EVENT(event, "%s: txid=%s", __func__,
                          tx->GetId().ToString());
}
 
void ValidationSignals::TransactionInvalidated(
    const CTransactionRef &tx,
    std::shared_ptr<const std::vector<Coin>> spent_coins) {
    auto event = [tx, spent_coins, this] {
        m_internals->Iterate([&](CValidationInterface &callbacks) {
            callbacks.TransactionInvalidated(tx, spent_coins);
        });
    };
    ENQUEUE_AND_LOG_EVENT(event, "%s: txid=%s", __func__,
                          tx->GetId().ToString());
}