kernel: Handle fatal errors through return values

contrib/devtools/bitcoin-tidy/CMakeLists.txt

@@ -25,7 +25,7 @@ find_program(CLANG_TIDY_EXE NAMES "clang-tidy-${LLVM_VERSION_MAJOR}" "clang-tidy
 message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 message(STATUS "Found clang-tidy: ${CLANG_TIDY_EXE}")
 
-add_library(bitcoin-tidy MODULE bitcoin-tidy.cpp logprintf.cpp)
+add_library(bitcoin-tidy MODULE bitcoin-tidy.cpp logprintf.cpp fatal_error.cpp)
 target_include_directories(bitcoin-tidy SYSTEM PRIVATE ${LLVM_INCLUDE_DIRS})
 
 # Disable RTTI and exceptions as necessary
@@ -58,8 +58,9 @@ else()
 endif()
 
 # Create a dummy library that runs clang-tidy tests as a side-effect of building
-add_library(bitcoin-tidy-tests OBJECT EXCLUDE_FROM_ALL example_logprintf.cpp)
+add_library(bitcoin-tidy-tests OBJECT EXCLUDE_FROM_ALL example_logprintf.cpp example_fatal_error.cpp)
 add_dependencies(bitcoin-tidy-tests bitcoin-tidy)
+target_include_directories(bitcoin-tidy-tests PRIVATE "${PROJECT_SOURCE_DIR}/../../../src")
 
 set_target_properties(bitcoin-tidy-tests PROPERTIES CXX_CLANG_TIDY "${CLANG_TIDY_COMMAND}")
 

contrib/devtools/bitcoin-tidy/bitcoin-tidy.cpp

@@ -2,6 +2,7 @@
 // Distributed under the MIT software license, see the accompanying
 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
 
+#include "fatal_error.h"
 #include "logprintf.h"
 
 #include <clang-tidy/ClangTidyModule.h>
@@ -13,6 +14,7 @@ class BitcoinModule final : public clang::tidy::ClangTidyModule
     void addCheckFactories(clang::tidy::ClangTidyCheckFactories& CheckFactories) override
     {
         CheckFactories.registerCheck<bitcoin::LogPrintfCheck>("bitcoin-unterminated-logprintf");
+        CheckFactories.registerCheck<bitcoin::FatalErrorCheck>("bitcoin-fatal-error");
     }
 };
 

contrib/devtools/bitcoin-tidy/example_fatal_error.cpp

@@ -0,0 +1,237 @@
+// Copyright (c) 2024-present Bitcoin Developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include "util/result.h"
+
+#include <functional>
+#include <string>
+#include <thread>
+
+// Test for bitcoin-fatal-error
+
+using util::Result;
+
+enum class FatalError
+{
+    Fatal
+};
+
+enum class ChainstateLoadError
+{
+    Error
+};
+
+Result<void, FatalError> void_fatal_func()
+{
+    return {};
+}
+
+Result<bool, FatalError> bool_fatal_func()
+{
+    return true;
+}
+
+Result<int, FatalError> int_fatal_func()
+{
+    return 1;
+}
+
+class Test {
+public:
+    Result<void, FatalError> fatal_func() {
+        return void_fatal_func();
+    }
+};
+
+template<typename T>
+void CheckFatalBad(Result<T, FatalError> fatal, int i, int j) {
+    return;
+}
+
+template<typename T>
+void CheckFatal(Result<T, FatalError> fatal, int i, int j) {
+    return;
+}
+
+void TraceThread(std::string name, std::function<void()> thread_func) {
+    thread_func();
+}
+
+Result<void, FatalError> good_fatal_func_1()
+{
+    auto lambda_1 = ([&]() {
+        return void_fatal_func();
+    });
+
+    auto lambda_2 = ([&]() {
+        Result<void, FatalError> result{};
+        result.Set(void_fatal_func());
+    });
+
+    auto lambda_3 = ([&]() {
+        Result<void, FatalError> result{};
+        result.MoveMessages(void_fatal_func());
+    });
+
+    auto lambda_4 = ([&]() {
+        Result<void, FatalError> result{};
+        auto res{void_fatal_func()};
+        result.MoveMessages(res);
+    });
+    return {};
+}
+
+Result<void, FatalError> good_fatal_func_2()
+{
+    Result<void, FatalError> result{};
+    auto res{void_fatal_func()};
+    result.MoveMessages(res);
+    return result;
+}
+
+Result<void, FatalError> good_fatal_func_3()
+{
+    auto res{void_fatal_func()};
+    return res;
+}
+
+Result<void, FatalError> good_fatal_func_4()
+{
+    Result<void, FatalError> result{};
+    result.Set(void_fatal_func());
+    result.MoveMessages(void_fatal_func());
+    if (result)
+    {
+        return void_fatal_func();
+    }
+    return result;
+}
+
+Result<void, FatalError> good_fatal_func_5()
+{
+    Result<void, FatalError> result{};
+    if (auto res{void_fatal_func()}; !res)
+    {
+        result.MoveMessages(res);
+        return result;
+    }
+    return {};
+}
+
+Result<int, FatalError> good_fatal_func_6()
+{
+    Test testy{};
+    auto res{testy.fatal_func()};
+    Result<void, FatalError> result{};
+    result.MoveMessages(res);
+    return 0;
+}
+
+Result<int, FatalError> good_fatal_func_7()
+{
+    Result<int, FatalError> result{1};
+    result.Set([&]()
+    {
+        return int_fatal_func();
+    }());
+    return int_fatal_func();
+}
+
+Result<void, FatalError> good_fatal_func_8()
+{
+    Result<void, FatalError> result{};
+    result.Set(void_fatal_func());
+    auto res{void_fatal_func()};
+    if (!res) {
+        result.Set(std::move(res));
+    } else {
+        result.MoveMessages(res);
+    }
+    return result;
+}
+
+void good_fatal_func_9()
+{
+    CheckFatal(bool_fatal_func(), 0, 0);
+}
+
+void good_fatal_func_10()
+{
+    [&]()
+    {
+        CheckFatal(void_fatal_func(), 0, 0);
+    }();
+}
+
+int good_fatal_func_11()
+{
+    int i = 0;
+    if (1) {
+        i += 1;
+    }
+    auto handle = std::thread(&TraceThread, "", [] {
+        CheckFatal(void_fatal_func(), 0, 0);
+    });
+    return i;
+}
+
+Result<int, ChainstateLoadError> good_fatal_func_12()
+{
+    bool_fatal_func();
+    return {0};
+}
+
+void bad_fatal_func_1()
+{
+    void_fatal_func();
+    auto testy{void_fatal_func()};
+}
+
+void bad_fatal_func_2()
+{
+    Test testy{};
+    testy.fatal_func();
+}
+
+void bad_fatal_func_3()
+{
+    [&]()
+    {
+        void_fatal_func();
+    }();
+}
+
+void bad_fatal_func_4()
+{
+    CheckFatalBad(void_fatal_func(), 0, 0);
+}
+
+void bad_fatal_func_5()
+{
+    CheckFatal(void_fatal_func(), 0, 0);
+    void_fatal_func();
+}
+
+void bad_fatal_func_6()
+{
+    int zero{0};
+    void_fatal_func();
+    CheckFatal(void_fatal_func(), 0, 0);
+}
+
+Result<int, FatalError> bad_fatal_func_7()
+{
+    [&]()
+    {
+        return void_fatal_func();
+    }();
+    return {0};
+}
+
+Result<int, FatalError> bad_fatal_func_8()
+{
+    auto res{void_fatal_func()};
+    if (!res) return {util::Error{}, util::MoveMessages(res), res.GetFailure()};
+    return 0;
+}