Squashed 'depend/bitcoin/' changes from 5991a69ee00..2dc27e2860b

2dc27e2860b kernel: Add pure kernel bitcoin-chainstate
338126c048f kernel: Add functions to get the block hash from a block
56345a77968 kernel: Add block index utility functions to C header
9530f65d19b kernel: Add function to read block undo data from disk to C header
f63860169fb kernel: Add functions to read block from disk to C header
f3aa1f9bf0c kernel: Add function for copying block data to C header
a70be77c908 kernel: Add functions for the block validation state to C header
e4e3dc585a3 kernel: Add validation interface to C header
d3c48b2bdc6 kernel: Add interrupt function to C header
7afbc516054 kernel: Add import blocks function to C header
bad89c8b30b kernel: Add chainstate load options for in-memory dbs in C header
1dcedf3da97 kernel: Add options for reindexing in C header
aeb68c7f022 kernel: Add block validation to C header
99136eb1656 kernel: Add chainstate loading when instantiating a ChainstateManager
0a2117ed501 kernel: Add chainstate manager option for setting worker threads
599dc235e98 kernel: Add chainstate manager object to C header
f280a5f3ab8 kernel: Add notifications context option to C header
6701d12b017 kernel: Add chain params context option to C header
f40f037a9cd kernel: Add kernel library context object
7a6c5c7abf2 kernel: Add logging to kernel library C header
REVERT: 5991a69ee00 kernel: Add pure kernel bitcoin-chainstate
REVERT: 05b7d136684 kernel: Add functions to get the block hash from a block
REVERT: f18c792d843 kernel: Add block index utility functions to C header
REVERT: 89f5bf04673 kernel: Add function to read block undo data from disk to C header
REVERT: b4f71fc64e7 kernel: Add functions to read block from disk to C header
REVERT: 41306f081ad kernel: Add function for copying  block data to C header
REVERT: 9385d9fc87e kernel: Add functions for the block validation state to C header
REVERT: 0bd9a710358 kernel: Add validation interface to C header
REVERT: 432710f3fc3 kernel: Add interrupt function to C header
REVERT: cb164ae1eb2 kernel: Add import blocks function to C header
REVERT: abd67fd93d0 kernel: Add chainstate load options for in-memory dbs in C header
REVERT: b98c2748e94 kernel: Add options for reindexing in C header
REVERT: 9d0efe1fc86 kernel: Add block validation to C header
REVERT: 87e364fc1ec kernel: Add chainstate loading when instantiating a ChainstateManager
REVERT: df1599b2d2a kernel: Add chainstate manager option for setting worker threads
REVERT: fb767002e97 kernel: Add chainstate manager object to C header
REVERT: 10b0fad2fd3 kernel: Add notifications context option to C header
REVERT: 39e7ad8d0dc kernel: Add chain params context option to C header
REVERT: 6285c353b89 kernel: Add kernel library context object
REVERT: 98d10160b6a kernel: Add logging to kernel library C header

git-subtree-dir: depend/bitcoin
git-subtree-split: 2dc27e2860b97c2bffa5f18706917b21858e5594

Author: stickies-v

depend/bitcoin/src/kernel/bitcoinkernel.cpp

@@ -214,9 +214,10 @@ class KernelValidationInterface final : public CValidationInterface
 };
 
 struct ContextOptions {
-    std::unique_ptr<const KernelNotifications> m_notifications;
-    std::unique_ptr<const CChainParams> m_chainparams;
-    std::unique_ptr<const KernelValidationInterface> m_validation_interface;
+    mutable Mutex m_mutex;
+    std::unique_ptr<const CChainParams> m_chainparams GUARDED_BY(m_mutex);
+    std::unique_ptr<const KernelNotifications> m_notifications GUARDED_BY(m_mutex);
+    std::unique_ptr<const KernelValidationInterface> m_validation_interface GUARDED_BY(m_mutex);
 };
 
 class Context
@@ -239,22 +240,23 @@ class Context
           m_interrupt{std::make_unique<util::SignalInterrupt>()},
           m_signals{std::make_unique<ValidationSignals>(std::make_unique<ImmediateTaskRunner>())}
     {
-        if (options && options->m_notifications) {
-            m_notifications = std::make_unique<KernelNotifications>(*options->m_notifications);
-        } else {
+        if (!options) {
             m_notifications = std::make_unique<KernelNotifications>(kernel_NotificationInterfaceCallbacks{
                 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr});
-        }
-
-        if (options && options->m_chainparams) {
-            m_chainparams = std::make_unique<const CChainParams>(*options->m_chainparams);
-        } else {
             m_chainparams = CChainParams::Main();
-        }
+        } else {
+            LOCK(options->m_mutex);
+            if (options->m_chainparams) {
+                m_chainparams = std::make_unique<const CChainParams>(*options->m_chainparams);
+            }
+            if (options->m_notifications) {
+                m_notifications = std::make_unique<KernelNotifications>(*options->m_notifications);
+            }
+            if (options->m_validation_interface) {
+                m_validation_interface = std::make_unique<KernelValidationInterface>(*options->m_validation_interface);
+                m_signals->RegisterValidationInterface(m_validation_interface.get());
+            }
 
-        if (options && options->m_validation_interface) {
-            m_validation_interface = std::make_unique<KernelValidationInterface>(*options->m_validation_interface);
-            m_signals->RegisterValidationInterface(m_validation_interface.get());
         }
 
         if (!kernel::SanityChecks(*m_context)) {
@@ -270,9 +272,10 @@ class Context
 
 //! Helper struct to wrap the ChainstateManager-related Options
 struct ChainstateManagerOptions {
-    ChainstateManager::Options m_chainman_options;
-    node::BlockManager::Options m_blockman_options;
-    node::ChainstateLoadOptions m_chainstate_load_options;
+    mutable Mutex m_mutex;
+    ChainstateManager::Options m_chainman_options GUARDED_BY(m_mutex);
+    node::BlockManager::Options m_blockman_options GUARDED_BY(m_mutex);
+    node::ChainstateLoadOptions m_chainstate_load_options GUARDED_BY(m_mutex);
 
     ChainstateManagerOptions(const Context* context, const fs::path& data_dir, const fs::path& blocks_dir)
         : m_chainman_options{ChainstateManager::Options{
@@ -309,6 +312,7 @@ const CTxOut* cast_transaction_output(const kernel_TransactionOutput* transactio
 {
     assert(transaction_output);
     return reinterpret_cast<const CTxOut*>(transaction_output);
+
 }
 
 const ContextOptions* cast_const_context_options(const kernel_ContextOptions* options)
@@ -638,19 +642,22 @@ void kernel_context_options_set_chainparams(kernel_ContextOptions* options_, con
     auto options{cast_context_options(options_)};
     auto chain_params{cast_const_chain_params(chain_parameters)};
     // Copy the chainparams, so the caller can free it again
+    LOCK(options->m_mutex);
     options->m_chainparams = std::make_unique<const CChainParams>(*chain_params);
 }
 
 void kernel_context_options_set_notifications(kernel_ContextOptions* options_, kernel_NotificationInterfaceCallbacks notifications)
 {
     auto options{cast_context_options(options_)};
     // Copy the notifications, so the caller can free it again
+    LOCK(options->m_mutex);
     options->m_notifications = std::make_unique<const KernelNotifications>(notifications);
 }
 
 void kernel_context_options_set_validation_interface(kernel_ContextOptions* options_, kernel_ValidationInterfaceCallbacks vi_cbs)
 {
     auto options{cast_context_options(options_)};
+    LOCK(options->m_mutex);
     options->m_validation_interface = std::make_unique<KernelValidationInterface>(KernelValidationInterface(vi_cbs));
 }
 
@@ -739,6 +746,7 @@ kernel_ChainstateManagerOptions* kernel_chainstate_manager_options_create(const
 void kernel_chainstate_manager_options_set_worker_threads_num(kernel_ChainstateManagerOptions* opts_, int worker_threads)
 {
     auto opts{cast_chainstate_manager_options(opts_)};
+    LOCK(opts->m_mutex);
     opts->m_chainman_options.worker_threads_num = worker_threads;
 }
 
@@ -755,26 +763,29 @@ bool kernel_chainstate_manager_options_set_wipe_dbs(kernel_ChainstateManagerOpti
         LogError("Wiping the block tree db without also wiping the chainstate db is currently unsupported.");
         return false;
     }
-    auto chainman_opts{cast_chainstate_manager_options(chainman_opts_)};
-    chainman_opts->m_blockman_options.block_tree_db_params.wipe_data = wipe_block_tree_db;
-    chainman_opts->m_chainstate_load_options.wipe_chainstate_db = wipe_chainstate_db;
+    auto opts{cast_chainstate_manager_options(chainman_opts_)};
+    LOCK(opts->m_mutex);
+    opts->m_blockman_options.block_tree_db_params.wipe_data = wipe_block_tree_db;
+    opts->m_chainstate_load_options.wipe_chainstate_db = wipe_chainstate_db;
     return true;
 }
 
 void kernel_chainstate_manager_options_set_block_tree_db_in_memory(
     kernel_ChainstateManagerOptions* chainstate_load_opts_,
     bool block_tree_db_in_memory)
 {
-    auto chainman_opts{cast_chainstate_manager_options(chainstate_load_opts_)};
-    chainman_opts->m_blockman_options.block_tree_db_params.memory_only = block_tree_db_in_memory;
+    auto opts{cast_chainstate_manager_options(chainstate_load_opts_)};
+    LOCK(opts->m_mutex);
+    opts->m_blockman_options.block_tree_db_params.memory_only = block_tree_db_in_memory;
 }
 
 void kernel_chainstate_manager_options_set_chainstate_db_in_memory(
     kernel_ChainstateManagerOptions* chainstate_load_opts_,
     bool chainstate_db_in_memory)
 {
-    auto chainman_opts{cast_chainstate_manager_options(chainstate_load_opts_)};
-    chainman_opts->m_chainstate_load_options.coins_db_in_memory = chainstate_db_in_memory;
+    auto opts{cast_chainstate_manager_options(chainstate_load_opts_)};
+    LOCK(opts->m_mutex);
+    opts->m_chainstate_load_options.coins_db_in_memory = chainstate_db_in_memory;
 }
 
 kernel_ChainstateManager* kernel_chainstate_manager_create(
@@ -787,14 +798,15 @@ kernel_ChainstateManager* kernel_chainstate_manager_create(
     ChainstateManager* chainman;
 
     try {
+        LOCK(chainman_opts->m_mutex);
         chainman = new ChainstateManager{*context->m_interrupt, chainman_opts->m_chainman_options, chainman_opts->m_blockman_options};
     } catch (const std::exception& e) {
         LogError("Failed to create chainstate manager: %s", e.what());
         return nullptr;
     }
 
     try {
-        const auto& chainstate_load_opts{chainman_opts->m_chainstate_load_options};
+        const auto chainstate_load_opts{WITH_LOCK(chainman_opts->m_mutex, return chainman_opts->m_chainstate_load_options)};
 
         kernel::CacheSizes cache_sizes{DEFAULT_KERNEL_CACHE};
         auto [status, chainstate_err]{node::LoadChainstate(*chainman, cache_sizes, chainstate_load_opts)};

depend/bitcoin/src/kernel/bitcoinkernel.h

@@ -122,7 +122,9 @@ typedef struct kernel_TransactionOutput kernel_TransactionOutput;
  *
  * Messages that were logged before a connection is created are buffered in a
  * 1MB buffer. Logging can alternatively be permanently disabled by calling
- * kernel_disable_logging().
+ * kernel_disable_logging(). Functions changing the logging settings are global
+ * (and not thread safe) and change the settings for all existing
+ * kernel_LoggingConnection instances.
  */
 typedef struct kernel_LoggingConnection kernel_LoggingConnection;
 
@@ -557,15 +559,19 @@ BITCOINKERNEL_API bool BITCOINKERNEL_WARN_UNUSED_RESULT kernel_verify_script(
 /**
  * @brief This disables the global internal logger. No log messages will be
  * buffered internally anymore once this is called and the buffer is cleared.
- * This function should only be called once. Log messages will be buffered until
- * this function is called, or a logging connection is created.
+ * This function should only be called once and is not thread or re-entry safe.
+ * Log messages will be buffered until this function is called, or a logging
+ * connection is created.
  */
 BITCOINKERNEL_API void kernel_disable_logging();
 
 /**
- * @brief Set the log level of the global internal logger. This does not enable
- * the selected categories. Use `kernel_enable_log_category` to start logging
- * from a specific, or all categories.
+ * @brief Set the log level of the global internal logger. This does not
+ * enable the selected categories. Use `kernel_enable_log_category` to start
+ * logging from a specific, or all categories. This function is not thread
+ * safe. Mutiple calls from different threads are allowed but must be
+ * synchronized. This changes a global setting and will override settings for
+ * all existing `kernelLoggingConnection instances.
  *
  * @param[in] category If kernel_LOG_ALL is chosen, all messages at the specified level
  *                     will be logged. Otherwise only messages from the specified category
@@ -575,14 +581,20 @@ BITCOINKERNEL_API void kernel_disable_logging();
 BITCOINKERNEL_API void kernel_add_log_level_category(const kernel_LogCategory category, kernel_LogLevel level);
 
 /**
- * @brief Enable a specific log category for the global internal logger.
+ * @brief Enable a specific log category for the global internal logger. This
+ * function is not thread safe. Mutiple calls from different threads are
+ * allowed but must be synchronized. This changes a global setting and will
+ * override settings for all existing `kernelLoggingConnection instances.
  *
  * @param[in] category If kernel_LOG_ALL is chosen, all categories will be enabled.
  */
 BITCOINKERNEL_API void kernel_enable_log_category(const kernel_LogCategory category);
 
 /**
- * Disable a specific log category for the global internal logger.
+ * @brief Disable a specific log category for the global internal logger. This
+ * function is not thread safe. Mutiple calls from different threads are
+ * allowed but must be synchronized. This changes a global setting and will
+ * override settings for all existing `kernelLoggingConnection instances.
  *
  * @param[in] category If kernel_LOG_ALL is chosen, all categories will be disabled.
  */