Merge branch 'develop' into feat/53_general_updates

Author: ab9rf

docs/changelog.txt

@@ -59,6 +59,7 @@ Template for new versions:
 ## New Features
 
 ## Fixes
+- `buildingplan`: Bolt throwers will no longer be constructed using populated bins.
 - `suspendmanager`: treat reinforced walls as a blocking construction and buildable platform
 
 ## Misc Improvements

library/CMakeLists.txt

@@ -136,6 +136,7 @@ endif()
 
 set(MAIN_SOURCES_LINUX
     ${CONSOLE_SOURCES}
+    Crashlog.cpp
 )
 
 set(MAIN_SOURCES_DARWIN

library/Core.cpp

@@ -1540,6 +1540,11 @@ bool Core::InitMainThread() {
 
     Filesystem::init();
 
+    #ifdef LINUX_BUILD
+        extern void dfhack_crashlog_init();
+        dfhack_crashlog_init();
+    #endif
+
     // Re-route stdout and stderr again - DF seems to set up stdout and
     // stderr.txt on Windows as of 0.43.05. Also, log before switching files to
     // make it obvious what's going on if someone checks the *.txt files.
@@ -2375,6 +2380,11 @@ void Core::onStateChange(color_ostream &out, state_change_event event)
 
 int Core::Shutdown ( void )
 {
+    #ifdef LINUX_BUILD
+        extern void dfhack_crashlog_shutdown();
+        dfhack_crashlog_shutdown();
+    #endif
+
     if(errorstate)
         return true;
     errorstate = 1;

library/Crashlog.cpp

@@ -0,0 +1,182 @@
+#include "DFHackVersion.h"
+#include <csignal>
+#include <iomanip>
+#include <filesystem>
+#include <fstream>
+#include <thread>
+
+#include <sys/eventfd.h>
+#include <execinfo.h>
+#include <unistd.h>
+
+const int BT_ENTRY_MAX = 25;
+struct CrashInfo {
+    int backtrace_entries = 0;
+    void* backtrace[BT_ENTRY_MAX];
+    int signal = 0;
+};
+
+CrashInfo crash_info;
+
+std::atomic<bool> crashed = false;
+std::atomic<bool> crashlog_ready = false;
+std::atomic<bool> shutdown = false;
+
+// Use eventfd for async-signal safe waiting
+int crashlog_complete = -1;
+
+void flag_set(std::atomic_bool &atom) {
+    atom.store(true);
+    atom.notify_all();
+}
+void flag_wait(std::atomic_bool &atom) {
+    atom.wait(false);
+}
+
+void signal_crashlog_complete() {
+    if (crashlog_complete == -1)
+        return;
+    uint64_t v = 1;
+    [[maybe_unused]] auto _ = write(crashlog_complete, &v, sizeof(v));
+}
+
+std::thread crashlog_thread;
+
+extern "C" void dfhack_crashlog_handle_signal(int sig) {
+    if (shutdown.load() || crashed.exchange(true) || crashlog_ready.load()) {
+        // Ensure the signal handler doesn't try to write a crashlog
+        // whilst the crashlog thread is unavailable.
+        std::quick_exit(1);
+    }
+    crash_info.signal = sig;
+    crash_info.backtrace_entries = backtrace(crash_info.backtrace, BT_ENTRY_MAX);
+
+    // Signal saving of crashlog
+    flag_set(crashlog_ready);
+    // Wait for completion via eventfd read, if fd isn't valid, bail
+    if (crashlog_complete != -1) {
+        [[maybe_unused]] uint64_t v;
+        [[maybe_unused]] auto _ = read(crashlog_complete, &v, sizeof(v));
+    }
+    std::quick_exit(1);
+}
+
+void dfhack_crashlog_handle_terminate() {
+    dfhack_crashlog_handle_signal(0);
+}
+
+std::string signal_name(int sig) {
+    switch (sig) {
+        case SIGINT:
+            return "SIGINT";
+        case SIGILL:
+            return "SIGILL";
+        case SIGABRT:
+            return "SIGABRT";
+        case SIGFPE:
+            return "SIGFPE";
+        case SIGSEGV:
+            return "SIGSEGV";
+        case SIGTERM:
+            return "SIGTERM";
+    }
+    return "";
+}
+
+std::filesystem::path get_crashlog_path() {
+    std::time_t time = std::time(nullptr);
+    std::tm* tm = std::localtime(&time);
+
+    std::string timestamp = "unknown";
+    if (tm) {
+        char stamp[64];
+        std::size_t out = strftime(&stamp[0], 63, "%Y-%m-%d-%H-%M-%S", tm);
+        if (out != 0)
+            timestamp = stamp;
+    }
+
+    std::filesystem::path dir = "crashlog";
+    std::error_code err;
+    std::filesystem::create_directories(dir, err);
+
+    std::filesystem::path log_path = dir / ("crash_" + timestamp + ".txt");
+    return log_path;
+}
+
+void dfhack_save_crashlog() {
+    char** backtrace_strings = backtrace_symbols(crash_info.backtrace, crash_info.backtrace_entries);
+    if (!backtrace_strings) {
+        // Allocation failed, give up
+        return;
+    }
+    try {
+        std::filesystem::path crashlog_path = get_crashlog_path();
+        std::ofstream crashlog(crashlog_path);
+
+        crashlog << "Dwarf Fortress Linux has crashed!" << "\n";
+        crashlog << "Dwarf Fortress Version " << DFHack::Version::df_version() << "\n";
+        crashlog << "DFHack Version " << DFHack::Version::dfhack_version() << "\n\n";
+
+        std::string signal = signal_name(crash_info.signal);
+        if (!signal.empty()) {
+            crashlog << "Signal " << signal << "\n";
+        }
+
+        for (int i = 0; i < crash_info.backtrace_entries; i++) {
+            crashlog << i << "> " << backtrace_strings[i] << "\n";
+        }
+    } catch (...) {}
+
+    free(backtrace_strings);
+}
+
+void dfhack_crashlog_thread() {
+    // Wait for activation signal
+    flag_wait(crashlog_ready);
+    if (shutdown.load()) // Shutting down gracefully, end thread.
+        return;
+
+    dfhack_save_crashlog();
+    signal_crashlog_complete();
+    std::quick_exit(1);
+}
+
+std::terminate_handler term_handler = nullptr;
+
+const int desired_signals[3] = {SIGSEGV,SIGILL,SIGABRT};
+namespace DFHack {
+    void dfhack_crashlog_init() {
+        // Initialize eventfd flag
+        crashlog_complete = eventfd(0, EFD_CLOEXEC);
+
+        crashlog_thread = std::thread(dfhack_crashlog_thread);
+
+        for (int signal : desired_signals) {
+            std::signal(signal, dfhack_crashlog_handle_signal);
+        }
+        term_handler = std::set_terminate(dfhack_crashlog_handle_terminate);
+
+        // https://sourceware.org/glibc/manual/latest/html_mono/libc.html#index-backtrace-1
+        // backtrace is AsyncSignal-Unsafe due to dynamic loading of libgcc_s
+        // Using it here ensures it is loaded before use in the signal handler.
+        [[maybe_unused]] int _ = backtrace(crash_info.backtrace, 1);
+    }
+
+    void dfhack_crashlog_shutdown() {
+        shutdown.exchange(true);
+        for (int signal : desired_signals) {
+            std::signal(signal, SIG_DFL);
+        }
+        std::set_terminate(term_handler);
+
+        // Shutdown the crashlog thread.
+        flag_set(crashlog_ready);
+        crashlog_thread.join();
+
+        // If the signal handler is somehow running whilst here, let it terminate
+        signal_crashlog_complete();
+        if (crashlog_complete != -1)
+            close(crashlog_complete); // Close fd
+        return;
+    }
+}

library/include/df/custom/.gitignore

@@ -0,0 +1 @@
+!*.h

library/include/df/custom/hash/labor_kitchen_interface_food_key.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <functional>
+#include <bit>
+#include "df/labor_kitchen_interface_food_key.h"
+
+namespace std
+{
+    template<>
+    struct hash<df::labor_kitchen_interface_food_key>
+    {
+        auto operator()(const df::labor_kitchen_interface_food_key& a) const -> size_t
+        {
+            struct thing
+            {
+                int16_t t;
+                int16_t st;
+                int32_t x;
+            } thing{
+                .t = a.type,
+                .st = a.subtype,
+                .x = static_cast<int32_t>(a.mat) ^ (static_cast<int32_t>(a.matg))
+            };
+
+            return hash<int64_t>()(std::bit_cast<int64_t>(thing));
+        }
+    };
+}

library/include/df/custom/labor_kitchen_interface_food_key.methods.inc

@@ -0,0 +1,11 @@
+    bool operator<(const df::labor_kitchen_interface_food_key &b) const {
+        if (type<b.type) return true;
+        if (subtype<b.subtype) return true;
+        if (mat<b.mat) return true;
+        if (matg<b.matg) return true;
+        return false;
+        }
+
+    bool operator==(const df::labor_kitchen_interface_food_key &b) const {
+        return type==b.type&&subtype==b.subtype&&mat==b.mat&&matg==b.matg;
+        }

library/lua/dfhack/buildings.lua

@@ -358,6 +358,7 @@ local siegeengine_input = {
             vector_id=df.job_item_vector_id.BOLT_THROWER_PARTS,
         },
         {
+            flags1={ empty=true },
             item_type=df.item_type.BIN,
             vector_id=df.job_item_vector_id.BIN,
         },