add entire atmosphere source code and also add ram timing fixes

Source/Atmosphere/libraries/libmesosphere/source/kern_k_trace.cpp

@@ -0,0 +1,150 @@
+/*
+ * Copyright (c) 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;
+        constinit u64 g_type_filter = 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);
+
+        ALWAYS_INLINE bool IsTypeFiltered(u8 type) {
+            return (g_type_filter & (UINT64_C(1) << (type & (BITSIZEOF(u64) - 1)))) != 0;
+        }
+
+    }
+
+    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;
+
+                /* Set the filters to defaults. */
+                g_type_filter = ~(UINT64_C(0));
+            }
+        }
+    }
+
+    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;
+        }
+    }
+
+    void KTrace::PushRecord(u8 type, u64 param0, u64 param1, u64 param2, u64 param3, u64 param4, u64 param5) {
+        /* Get exclusive access to the trace buffer. */
+        KScopedInterruptDisable di;
+        KScopedSpinLock lk(g_ktrace_lock);
+
+        /* Check whether we should push the record to the trace buffer. */
+        if (s_is_active && IsTypeFiltered(type)) {
+            /* Get the current thread and process. */
+            KThread &cur_thread   = GetCurrentThread();
+            KProcess *cur_process = GetCurrentProcessPointer();
+
+            /* Get the current record index from the header. */
+            KTraceHeader *header = GetPointer<KTraceHeader>(g_ktrace_buffer_address);
+            u32 index = header->index;
+
+            /* Get the current record. */
+            KTraceRecord *record = GetPointer<KTraceRecord>(g_ktrace_buffer_address + header->offset + index * sizeof(KTraceRecord));
+
+            /* Set the record's data. */
+            *record = {
+                .core_id    = static_cast<u8>(GetCurrentCoreId()),
+                .type       = type,
+                .process_id = static_cast<u16>(cur_process != nullptr ? cur_process->GetId() : ~0),
+                .thread_id  = static_cast<u32>(cur_thread.GetId()),
+                .tick       = static_cast<u64>(KHardwareTimer::GetTick()),
+                .data       = { param0, param1, param2, param3, param4, param5 },
+            };
+
+            /* Advance the current index. */
+            if ((++index) >= header->count) {
+                index = 0;
+            }
+
+            /* Set the next index. */
+            header->index = index;
+        }
+    }
+
+}