Squashed 'libbitcoinkernel-sys/bitcoin/' changes from edf99b88e644..20be96ee696b

20be96ee696b kernel: Fix bitcoin-chainstate for windows
db5bc2b0968d kernel: Add Purpose section to header documentation
e5ddd70c24da kernel: Allowing reducing exports
740f2ef7686e kernel: Add pure kernel bitcoin-chainstate
c89b59fc6867 Kernel: Add functions for working with outpoints
f82d691fba5c kernel: Add block hash type and block tree utility functions to C header
cd70f570ec6d kernel: Add function to read block undo data from disk to C header
301c10f598dc kernel: Add functions to read block from disk to C header
7092fee527a8 kernel: Add function for copying block data to C header
91a51d249f88 kernel: Add functions for the block validation state to C header
8cdd29f3c227 kernel: Add validation interface to C header
a4652f7897e2 kernel: Add interrupt function to C header
400048326795 kernel: Add import blocks function to C header
d775ba666707 kernel: Add chainstate load options for in-memory dbs in C header
d26192373b67 kernel: Add options for reindexing in C header
803e0de7aaa0 kernel: Add block validation to C header
781c7af4e2d0 kernel: Add chainstate loading when instantiating a ChainstateManager
f9bf4d9b3136 kernel: Add chainstate manager option for setting worker threads
3270c0615a7e kernel: Add chainstate manager object to C header
0ac5368b3df6 kernel: Add notifications context option to C header
b47496af140c kernel: Add chain params context option to C header
92f54852259d kernel: Add kernel library context object
3204110daee4 kernel: Add logging to kernel library C header
aba7824242d0 kernel: Introduce initial kernel C header API
REVERT: edf99b88e644 kernel: Fix bitcoin-chainstate for windows
REVERT: 8fbe027a8a66 kernel: Add Purpose section to header documentation
REVERT: 75f44d950566 kernel: Allowing reducing exports
REVERT: d3f5df4a38ce kernel: Add pure kernel bitcoin-chainstate
REVERT: e5009f3707ee Kernel: Add functions for working with outpoints
REVERT: c337b7e609d5 kernel: Add block hash type and block tree utility functions to C header
REVERT: 7d3f0ced45f0 kernel: Add function to read block undo data from disk to C header
REVERT: 83b7abc0537c kernel: Add functions to read block from disk to C header
REVERT: 4c765dddcbec kernel: Add function for copying block data to C header
REVERT: ae6570017493 kernel: Add functions for the block validation state to C header
REVERT: c2bb6b06af78 kernel: Add validation interface to C header
REVERT: 3efd276cedd9 kernel: Add interrupt function to C header
REVERT: f0ffab556086 kernel: Add import blocks function to C header
REVERT: bdcb7b8b05ab kernel: Add chainstate load options for in-memory dbs in C header
REVERT: 6dab7199fe78 kernel: Add options for reindexing in C header
REVERT: bee1c1d7363d kernel: Add block validation to C header
REVERT: 7e2b237e67d1 kernel: Add chainstate loading when instantiating a ChainstateManager
REVERT: e4f1e00203f2 kernel: Add chainstate manager option for setting worker threads
REVERT: a7a3138fa2b4 kernel: Add chainstate manager object to C header
REVERT: 564e0cf1bf84 kernel: Add notifications context option to C header
REVERT: 2ce38f954b86 kernel: Add chain params context option to C header
REVERT: 58eae5695813 kernel: Add kernel library context object
REVERT: c5f8bd0e0ea2 kernel: Add logging to kernel library C header
REVERT: bff9b7f388c7 kernel: Introduce initial kernel C header API

git-subtree-dir: libbitcoinkernel-sys/bitcoin
git-subtree-split: 20be96ee696ba8c3085da0877156e534a58c39bf

Author: alexanderwiederin

src/bitcoin-chainstate.cpp

@@ -176,7 +176,9 @@ int main(int argc, char* argv[])
         .always_print_category_levels = true,
     };
 
-    Logger logger{std::make_unique<KernelLog>(KernelLog{}), logging_options};
+    logging_set_options(logging_options);
+
+    Logger logger{std::make_unique<KernelLog>(KernelLog{})};
 
     ContextOptions options{};
     ChainParams params{ChainType::MAINNET};

src/kernel/bitcoinkernel.cpp

@@ -230,30 +230,20 @@ struct LoggingConnection {
     void* m_user_data;
     std::function<void(void* user_data)> m_deleter;
 
-    LoggingConnection(btck_LogCallback callback, void* user_data, btck_DestroyCallback user_data_destroy_callback, const btck_LoggingOptions options)
+    LoggingConnection(btck_LogCallback callback, void* user_data, btck_DestroyCallback user_data_destroy_callback)
     {
         LOCK(cs_main);
 
-        LogInstance().m_log_timestamps = options.log_timestamps;
-        LogInstance().m_log_time_micros = options.log_time_micros;
-        LogInstance().m_log_threadnames = options.log_threadnames;
-        LogInstance().m_log_sourcelocations = options.log_sourcelocations;
-        LogInstance().m_always_print_category_level = options.always_print_category_levels;
-
         auto connection{LogInstance().PushBackCallback([callback, user_data](const std::string& str) { callback(user_data, str.c_str(), str.length()); })};
 
-        try {
-            // Only start logging if we just added the connection.
-            if (LogInstance().NumConnections() == 1 && !LogInstance().StartLogging()) {
-                LogError("Logger start failed.");
-                LogInstance().DeleteCallback(connection);
+        // Only start logging if we just added the connection.
+        if (LogInstance().NumConnections() == 1 && !LogInstance().StartLogging()) {
+            LogError("Logger start failed.");
+            LogInstance().DeleteCallback(connection);
+            if (user_data && user_data_destroy_callback) {
                 user_data_destroy_callback(user_data);
             }
-        } catch (std::exception& e) {
-            LogError("Logger start failed: %s", e.what());
-            LogInstance().DeleteCallback(connection);
-            user_data_destroy_callback(user_data);
-            throw;
+            throw std::runtime_error("Failed to start logging");
         }
 
         m_connection = std::make_unique<std::list<std::function<void(const std::string&)>>::iterator>(connection);
@@ -266,19 +256,20 @@ struct LoggingConnection {
     ~LoggingConnection()
     {
         LOCK(cs_main);
+        LogDebug(BCLog::KERNEL, "Logger disconnecting.");
+
+        // Switch back to buffering by calling DisconnectTestLogger if the
+        // connection that we are about to remove is the last one.
+        if (LogInstance().NumConnections() == 1) {
+            LogInstance().DisconnectTestLogger();
+        } else {
+            LogInstance().DeleteCallback(*m_connection);
+        }
 
-        LogDebug(BCLog::KERNEL, "Logger disconnected.");
-        LogInstance().DeleteCallback(*m_connection);
         m_connection.reset();
         if (m_user_data && m_deleter) {
             m_deleter(m_user_data);
         }
-
-        // Switch back to buffering by calling DisconnectTestLogger if the
-        // connection that was just removed was the last one.
-        if (!LogInstance().Enabled()) {
-            LogInstance().DisconnectTestLogger();
-        }
     }
 };
 
@@ -713,6 +704,16 @@ void btck_txid_destroy(btck_Txid* txid)
     delete txid;
 }
 
+void btck_logging_set_options(const btck_LoggingOptions options)
+{
+    LOCK(cs_main);
+    LogInstance().m_log_timestamps = options.log_timestamps;
+    LogInstance().m_log_time_micros = options.log_time_micros;
+    LogInstance().m_log_threadnames = options.log_threadnames;
+    LogInstance().m_log_sourcelocations = options.log_sourcelocations;
+    LogInstance().m_always_print_category_level = options.always_print_category_levels;
+}
+
 void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level)
 {
     LOCK(cs_main);
@@ -738,12 +739,13 @@ void btck_logging_disable()
     LogInstance().DisableLogging();
 }
 
-btck_LoggingConnection* btck_logging_connection_create(btck_LogCallback callback,
-                                                       void* user_data,
-                                                       btck_DestroyCallback user_data_destroy_callback,
-                                                       const btck_LoggingOptions options)
+btck_LoggingConnection* btck_logging_connection_create(btck_LogCallback callback, void* user_data, btck_DestroyCallback user_data_destroy_callback)
 {
-    return btck_LoggingConnection::create(callback, user_data, user_data_destroy_callback, options);
+    try {
+        return btck_LoggingConnection::create(callback, user_data, user_data_destroy_callback);
+    } catch (const std::exception&) {
+        return nullptr;
+    }
 }
 
 void btck_logging_connection_destroy(btck_LoggingConnection* connection)

src/kernel/bitcoinkernel.h

@@ -483,7 +483,7 @@ BITCOINKERNEL_API btck_Transaction* BITCOINKERNEL_WARN_UNUSED_RESULT btck_transa
 
 /*
  * @brief Serializes the transaction through the passed in callback to bytes.
- * This is consensus serialization that is also used for the p2p network.
+ * This is consensus serialization that is also used for the P2P network.
  *
  * @param[in] transaction Non-null.
  * @param[in] writer      Non-null, callback to a write bytes function.
@@ -689,20 +689,33 @@ BITCOINKERNEL_API void btck_transaction_output_destroy(btck_TransactionOutput* t
  * buffered internally anymore once this is called and the buffer is cleared.
  * 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.
+ * connection is created. This must not be called while a logging connection
+ * already exists.
  */
 BITCOINKERNEL_API void btck_logging_disable();
 
+/**
+ * @brief Set some options for the global internal logger. This changes global
+ * settings and will override settings for all existing @ref
+ * btck_LoggingConnection instances.
+ *
+ * @param[in] options Sets formatting options of the log messages.
+ */
+BITCOINKERNEL_API void btck_logging_set_options(const btck_LoggingOptions options);
+
 /**
  * @brief Set the log level of the global internal logger. This does not
  * enable the selected categories. Use @ref btck_logging_enable_category to
  * start logging from a specific, or all categories. This changes a global
  * setting and will override settings for all existing
  * @ref btck_LoggingConnection instances.
  *
- * @param[in] category If btck_LOG_ALL is chosen, all messages at the specified level
- *                     will be logged. Otherwise only messages from the specified category
- *                     will be logged at the specified level and above.
+ * @param[in] category If btck_LogCategory_ALL is chosen, sets both the global fallback log level
+ *                     used by all categories that don't have a specific level set, and also
+ *                     sets the log level for messages logged with the btck_LogCategory_ALL category itself.
+ *                     For any other category, sets a category-specific log level that overrides
+ *                     the global fallback for that category only.
+
  * @param[in] level    Log level at which the log category is set.
  */
 BITCOINKERNEL_API void btck_logging_set_level_category(btck_LogCategory category, btck_LogLevel level);
@@ -736,14 +749,12 @@ BITCOINKERNEL_API void btck_logging_disable_category(btck_LogCategory category);
  *                                       is also defined it is assumed that ownership of the user_data is passed
  *                                       to the created logging connection.
  * @param[in] user_data_destroy_callback Nullable, function for freeing the user data.
- * @param[in] options                    Sets formatting options of the log messages.
- * @return                               A new kernel logging connection, or null on error.
+ * @return                               A new kernel logging connection.
  */
 BITCOINKERNEL_API btck_LoggingConnection* BITCOINKERNEL_WARN_UNUSED_RESULT btck_logging_connection_create(
     btck_LogCallback log_callback,
     void* user_data,
-    btck_DestroyCallback user_data_destroy_callback,
-    const btck_LoggingOptions options) BITCOINKERNEL_ARG_NONNULL(1);
+    btck_DestroyCallback user_data_destroy_callback) BITCOINKERNEL_ARG_NONNULL(1);
 
 /**
  * Stop logging and destroy the logging connection.
@@ -1141,7 +1152,7 @@ BITCOINKERNEL_API btck_BlockHash* BITCOINKERNEL_WARN_UNUSED_RESULT btck_block_ge
 
 /*
  * @brief Serializes the block through the passed in callback to bytes.
- * This is consensus serialization that is also used for the p2p network.
+ * This is consensus serialization that is also used for the P2P network.
  *
  * @param[in] block     Non-null.
  * @param[in] writer    Non-null, callback to a write bytes function.

src/kernel/bitcoinkernel_wrapper.h

@@ -741,6 +741,11 @@ inline void logging_disable()
     btck_logging_disable();
 }
 
+inline void logging_set_options(const btck_LoggingOptions& logging_options)
+{
+    btck_logging_set_options(logging_options);
+}
+
 inline void logging_set_level_category(LogCategory category, LogLevel level)
 {
     btck_logging_set_level_category(static_cast<btck_LogCategory>(category), static_cast<btck_LogLevel>(level));
@@ -765,12 +770,11 @@ template <Log T>
 class Logger : UniqueHandle<btck_LoggingConnection, btck_logging_connection_destroy>
 {
 public:
-    Logger(std::unique_ptr<T> log, const btck_LoggingOptions& logging_options)
+    Logger(std::unique_ptr<T> log)
         : UniqueHandle{btck_logging_connection_create(
               +[](void* user_data, const char* message, size_t message_len) { static_cast<T*>(user_data)->LogMessage({message, message_len}); },
               log.release(),
-              +[](void* user_data) { delete static_cast<T*>(user_data); },
-              logging_options)}
+              +[](void* user_data) { delete static_cast<T*>(user_data); })}
     {
     }
 };

src/test/kernel/test_kernel.cpp

@@ -537,6 +537,7 @@ BOOST_AUTO_TEST_CASE(logging_tests)
         .always_print_category_levels = true,
     };
 
+    logging_set_options(logging_options);
     logging_set_level_category(LogCategory::BENCH, LogLevel::TRACE_LEVEL);
     logging_disable_category(LogCategory::BENCH);
     logging_enable_category(LogCategory::VALIDATION);
@@ -546,10 +547,10 @@ BOOST_AUTO_TEST_CASE(logging_tests)
     {
         logging_set_level_category(LogCategory::KERNEL, LogLevel::TRACE_LEVEL);
         logging_enable_category(LogCategory::KERNEL);
-        Logger logger{std::make_unique<TestLog>(TestLog{}), logging_options};
-        Logger logger_2{std::make_unique<TestLog>(TestLog{}), logging_options};
+        Logger logger{std::make_unique<TestLog>()};
+        Logger logger_2{std::make_unique<TestLog>()};
     }
-    Logger logger{std::make_unique<TestLog>(TestLog{}), logging_options};
+    Logger logger{std::make_unique<TestLog>()};
 }
 
 BOOST_AUTO_TEST_CASE(btck_context_tests)
@@ -600,14 +601,7 @@ Context create_context(std::shared_ptr<TestKernelNotifications> notifications, C
 
 BOOST_AUTO_TEST_CASE(btck_chainman_tests)
 {
-    btck_LoggingOptions logging_options = {
-        .log_timestamps = true,
-        .log_time_micros = true,
-        .log_threadnames = false,
-        .log_sourcelocations = false,
-        .always_print_category_levels = true,
-    };
-    Logger logger{std::make_unique<TestLog>(TestLog{}), logging_options};
+    Logger logger{std::make_unique<TestLog>(TestLog{})};
     auto test_directory{TestDirectory{"chainman_test_bitcoin_kernel"}};
 
     { // test with default context
@@ -665,15 +659,6 @@ std::unique_ptr<ChainMan> create_chainman(TestDirectory& test_directory,
 
 void chainman_reindex_test(TestDirectory& test_directory)
 {
-    btck_LoggingOptions logging_options = {
-        .log_timestamps = true,
-        .log_time_micros = true,
-        .log_threadnames = false,
-        .log_sourcelocations = false,
-        .always_print_category_levels = true,
-    };
-    Logger logger{std::make_unique<TestLog>(TestLog{}), logging_options};
-
     auto mainnet_test_directory{TestDirectory{"mainnet_test_bitcoin_kernel"}};
 
     auto notifications{std::make_shared<TestKernelNotifications>()};
@@ -797,15 +782,6 @@ void chainman_mainnet_validation_test(TestDirectory& test_directory)
 
 BOOST_AUTO_TEST_CASE(btck_chainman_mainnet_tests)
 {
-    btck_LoggingOptions logging_options = {
-        .log_timestamps = true,
-        .log_time_micros = true,
-        .log_threadnames = false,
-        .log_sourcelocations = false,
-        .always_print_category_levels = true,
-    };
-    Logger logger{std::make_unique<TestLog>(TestLog{}), logging_options};
-
     auto test_directory{TestDirectory{"mainnet_test_bitcoin_kernel"}};
     chainman_mainnet_validation_test(test_directory);
     chainman_reindex_test(test_directory);