LogManager: implement system module, client api, logging api (#1617)

Some notes: * Unless `atmosphere!enable_log_manager` is true, Nintendo's log manager will be used instead. * This prevents paying memory costs for LM when not enabling logging. * To facilitate this, Atmosphere's log manager has a different program id from Nintendo's. * `atmosphere!enable_htc` implies `atmosphere!enable_log_manager`. * LogManager logs to tma, and the SD card (if `lm!enable_sd_card_logging` is true, which it is by default). * Binary logs are saved to `lm!sd_card_log_output_directory`, which is `atmosphere/binlogs` by default.
2025-05-16 16:14:25 -04:00 · 2021-09-11 19:32:14 -07:00 · 2021-09-11 19:32:14 -07:00 · e9849c74cf
commit e9849c74cf
parent a1fb8a91c8
94 changed files with 5595 additions and 45 deletions
--- a/libraries/libstratosphere/source/lm/srv/lm_flush_thread.cpp
+++ b/libraries/libstratosphere/source/lm/srv/lm_flush_thread.cpp
@ -0,0 +1,179 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#include <stratosphere.hpp>
+#include "lm_log_server_proxy.hpp"
+#include "lm_sd_card_logger.hpp"
+#include "lm_log_buffer.hpp"
+#include "lm_event_log_transmitter.hpp"
+
+namespace ams::lm::srv {
+
+    bool IsSleeping();
+
+    namespace {
+
+        alignas(os::ThreadStackAlignment) u8 g_flush_thread_stack[8_KB];
+
+        constinit u8 g_fs_heap[32_KB];
+        constinit lmem::HeapHandle g_fs_heap_handle;
+
+        constinit os::ThreadType g_flush_thread;
+
+        os::Event g_stop_event(os::EventClearMode_ManualClear);
+        os::Event g_sd_logging_event(os::EventClearMode_ManualClear);
+        os::Event g_host_connection_event(os::EventClearMode_ManualClear);
+
+        constinit std::unique_ptr<fs::IEventNotifier> g_sd_card_detection_event_notifier;
+        os::SystemEvent g_sd_card_detection_event;
+
+        void *AllocateForFs(size_t size) {
+            return lmem::AllocateFromExpHeap(g_fs_heap_handle, size);
+        }
+
+        void DeallocateForFs(void *ptr, size_t size) {
+            return lmem::FreeToExpHeap(g_fs_heap_handle, ptr);
+        }
+
+        void HostConnectionObserver(bool is_connected) {
+            /* Update the host connection event. */
+            if (is_connected) {
+                g_host_connection_event.Signal();
+            } else {
+                g_host_connection_event.Clear();
+
+                /* Potentially cancel the log buffer push. */
+                if (!g_sd_logging_event.TryWait()) {
+                    LogBuffer::GetDefaultInstance().CancelPush();
+                }
+            }
+        }
+
+        void SdLoggingObserver(bool is_available) {
+            /* Update the SD card logging event. */
+            if (is_available) {
+                g_sd_logging_event.Signal();
+            } else {
+                g_sd_logging_event.Clear();
+
+                /* Potentially cancel the log buffer push. */
+                if (!g_host_connection_event.TryWait()) {
+                    LogBuffer::GetDefaultInstance().CancelPush();
+                }
+            }
+        }
+
+        bool WaitForFlush() {
+            while (true) {
+                /* Wait for something to be signaled. */
+                os::WaitAny(g_stop_event.GetBase(), g_host_connection_event.GetBase(), g_sd_logging_event.GetBase(), g_sd_card_detection_event.GetBase());
+
+                /* If we're stopping, no flush. */
+                if (g_stop_event.TryWait()) {
+                    return false;
+                }
+
+                /* If host is connected/we're logging to sd, flush. */
+                if (g_host_connection_event.TryWait() || g_sd_logging_event.TryWait()) {
+                    return true;
+                }
+
+                /* If the sd card is newly inserted, flush. */
+                if (g_sd_card_detection_event.TryWait()) {
+                    g_sd_card_detection_event.Clear();
+
+                    if (fs::IsSdCardInserted()) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        void FlushThreadFunction(void *) {
+            /* Disable abort. */
+            fs::SetEnabledAutoAbort(false);
+
+            /* Create fs heap. */
+            g_fs_heap_handle = lmem::CreateExpHeap(g_fs_heap, sizeof(g_fs_heap), lmem::CreateOption_None);
+            AMS_ABORT_UNLESS(g_fs_heap_handle != nullptr);
+
+            /* Set fs allocation functions. */
+            fs::SetAllocator(AllocateForFs, DeallocateForFs);
+
+            /* Create SD card detection event notifier. */
+            R_ABORT_UNLESS(fs::OpenSdCardDetectionEventNotifier(std::addressof(g_sd_card_detection_event_notifier)));
+            R_ABORT_UNLESS(g_sd_card_detection_event_notifier->BindEvent(g_sd_card_detection_event.GetBase(), os::EventClearMode_ManualClear));
+
+            /* Set connection observers. */
+            SdCardLogger::GetInstance().SetLoggingObserver(SdLoggingObserver);
+            LogServerProxy::GetInstance().SetConnectionObserver(HostConnectionObserver);
+
+            /* Do flush loop. */
+            do {
+                if (LogBuffer::GetDefaultInstance().Flush()) {
+                    EventLogTransmitter::GetDefaultInstance().PushLogPacketDropCountIfExists();
+                }
+            } while (WaitForFlush());
+
+            /* Clear connection observer. */
+            LogServerProxy::GetInstance().SetConnectionObserver(nullptr);
+
+            /* Finalize the SD card logger. */
+            SdCardLogger::GetInstance().Finalize();
+            SdCardLogger::GetInstance().SetLoggingObserver(nullptr);
+
+            /* Destroy the fs heap. */
+            lmem::DestroyExpHeap(g_fs_heap_handle);
+        }
+
+    }
+
+    bool IsFlushAvailable() {
+        /* If we're sleeping, we can't flush. */
+        if (IsSleeping()) {
+            return false;
+        }
+
+        /* Try to wait for an event. */
+        if (os::TryWaitAny(g_stop_event.GetBase(), g_host_connection_event.GetBase(), g_sd_logging_event.GetBase()) < 0) {
+            return false;
+        }
+
+        /* Return whether we're not stopping. */
+        return !os::TryWaitEvent(g_stop_event.GetBase());
+    }
+
+    void InitializeFlushThread() {
+        /* Create the flush thread. */
+        R_ABORT_UNLESS(os::CreateThread(std::addressof(g_flush_thread), FlushThreadFunction, nullptr, g_flush_thread_stack, sizeof(g_flush_thread_stack), AMS_GET_SYSTEM_THREAD_PRIORITY(lm, Flush)));
+        os::SetThreadNamePointer(std::addressof(g_flush_thread), AMS_GET_SYSTEM_THREAD_NAME(lm, Flush));
+
+        /* Clear the stop event. */
+        g_stop_event.Clear();
+
+        /* Start the flush thread. */
+        os::StartThread(std::addressof(g_flush_thread));
+    }
+
+    void FinalizeFlushThread() {
+        /* Signal the flush thread to stop. */
+        g_stop_event.Signal();
+
+        /* Wait for the flush thread to stop. */
+        os::WaitThread(std::addressof(g_flush_thread));
+        os::DestroyThread(std::addressof(g_flush_thread));
+    }
+
+}