kern: SvcChangeKernelTraceState

2020-07-31 17:01:01 -07:00
parent 89f1c0ce33
commit f9d68db3f6
10 changed files with 279 additions and 45 deletions
--- a/libraries/libmesosphere/source/kern_k_trace.cpp
+++ b/libraries/libmesosphere/source/kern_k_trace.cpp
@@ -0,0 +1,104 @@
+/*
+ * 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 <mesosphere.hpp>
+
+namespace ams::kern {
+
+    /* Static initializations. */
+    constinit bool KTrace::s_is_active = false;
+
+    namespace {
+
+        constinit KSpinLock g_ktrace_lock;
+        constinit KVirtualAddress g_ktrace_buffer_address = Null<KVirtualAddress>;
+        constinit size_t g_ktrace_buffer_size = 0;
+
+        struct KTraceHeader {
+            u32 magic;
+            u32 offset;
+            u32 index;
+            u32 count;
+
+            static constexpr u32 Magic = util::FourCC<'K','T','R','0'>::Code;
+        };
+        static_assert(util::is_pod<KTraceHeader>::value);
+
+        struct KTraceRecord {
+            u8 core_id;
+            u8 type;
+            u16 process_id;
+            u32 thread_id;
+            u64 tick;
+            u64 data[6];
+        };
+        static_assert(util::is_pod<KTraceRecord>::value);
+        static_assert(sizeof(KTraceRecord) == 0x40);
+
+    }
+
+    void KTrace::Initialize(KVirtualAddress address, size_t size) {
+        /* Only perform tracing when on development hardware. */
+        if (KTargetSystem::IsDebugMode()) {
+            const size_t offset = util::AlignUp(sizeof(KTraceHeader), sizeof(KTraceRecord));
+            if (offset < size) {
+                /* Clear the trace buffer. */
+                std::memset(GetVoidPointer(address), 0, size);
+
+                /* Initialize the KTrace header. */
+                KTraceHeader *header = GetPointer<KTraceHeader>(address);
+                header->magic  = KTraceHeader::Magic;
+                header->offset = offset;
+                header->index  = 0;
+                header->count  = (size - offset) / sizeof(KTraceRecord);
+
+                /* Set the global data. */
+                g_ktrace_buffer_address = address;
+                g_ktrace_buffer_size    = size;
+            }
+        }
+    }
+
+    void KTrace::Start() {
+        if (g_ktrace_buffer_address != Null<KVirtualAddress>) {
+            /* Get exclusive access to the trace buffer. */
+            KScopedInterruptDisable di;
+            KScopedSpinLock lk(g_ktrace_lock);
+
+            /* Reset the header. */
+            KTraceHeader *header = GetPointer<KTraceHeader>(g_ktrace_buffer_address);
+            header->index = 0;
+
+            /* Reset the records. */
+            KTraceRecord *records = GetPointer<KTraceRecord>(g_ktrace_buffer_address + header->offset);
+            std::memset(records, 0, sizeof(*records) * header->count);
+
+            /* Note that we're active. */
+            s_is_active = true;
+        }
+    }
+
+    void KTrace::Stop() {
+        if (g_ktrace_buffer_address != Null<KVirtualAddress>) {
+            /* Get exclusive access to the trace buffer. */
+            KScopedInterruptDisable di;
+            KScopedSpinLock lk(g_ktrace_lock);
+
+            /* Note that we're paused. */
+            s_is_active = false;
+        }
+    }
+
+}