early-access version 3764

src/core/hle/kernel/k_server_session.cpp

@@ -20,12 +20,132 @@
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/message_buffer.h"
 #include "core/hle/service/hle_ipc.h"
 #include "core/hle/service/ipc_helpers.h"
 #include "core/memory.h"
 
 namespace Kernel {
 
+namespace {
+
+template <bool MoveHandleAllowed>
+Result ProcessMessageSpecialData(KProcess& dst_process, KProcess& src_process, KThread& src_thread,
+                                 MessageBuffer& dst_msg, const MessageBuffer& src_msg,
+                                 MessageBuffer::SpecialHeader& src_special_header) {
+    // Copy the special header to the destination.
+    s32 offset = dst_msg.Set(src_special_header);
+
+    // Copy the process ID.
+    if (src_special_header.GetHasProcessId()) {
+        offset = dst_msg.SetProcessId(offset, src_process.GetProcessId());
+    }
+
+    // Prepare to process handles.
+    auto& dst_handle_table = dst_process.GetHandleTable();
+    auto& src_handle_table = src_process.GetHandleTable();
+    Result result = ResultSuccess;
+
+    // Process copy handles.
+    for (auto i = 0; i < src_special_header.GetCopyHandleCount(); ++i) {
+        // Get the handles.
+        const Handle src_handle = src_msg.GetHandle(offset);
+        Handle dst_handle = Svc::InvalidHandle;
+
+        // If we're in a success state, try to move the handle to the new table.
+        if (R_SUCCEEDED(result) && src_handle != Svc::InvalidHandle) {
+            KScopedAutoObject obj =
+                src_handle_table.GetObjectForIpc(src_handle, std::addressof(src_thread));
+            if (obj.IsNotNull()) {
+                Result add_result =
+                    dst_handle_table.Add(std::addressof(dst_handle), obj.GetPointerUnsafe());
+                if (R_FAILED(add_result)) {
+                    result = add_result;
+                    dst_handle = Svc::InvalidHandle;
+                }
+            } else {
+                result = ResultInvalidHandle;
+            }
+        }
+
+        // Set the handle.
+        offset = dst_msg.SetHandle(offset, dst_handle);
+    }
+
+    // Process move handles.
+    if constexpr (MoveHandleAllowed) {
+        for (auto i = 0; i < src_special_header.GetMoveHandleCount(); ++i) {
+            // Get the handles.
+            const Handle src_handle = src_msg.GetHandle(offset);
+            Handle dst_handle = Svc::InvalidHandle;
+
+            // Whether or not we've succeeded, we need to remove the handles from the source table.
+            if (src_handle != Svc::InvalidHandle) {
+                if (R_SUCCEEDED(result)) {
+                    KScopedAutoObject obj =
+                        src_handle_table.GetObjectForIpcWithoutPseudoHandle(src_handle);
+                    if (obj.IsNotNull()) {
+                        Result add_result = dst_handle_table.Add(std::addressof(dst_handle),
+                                                                 obj.GetPointerUnsafe());
+
+                        src_handle_table.Remove(src_handle);
+
+                        if (R_FAILED(add_result)) {
+                            result = add_result;
+                            dst_handle = Svc::InvalidHandle;
+                        }
+                    } else {
+                        result = ResultInvalidHandle;
+                    }
+                } else {
+                    src_handle_table.Remove(src_handle);
+                }
+            }
+
+            // Set the handle.
+            offset = dst_msg.SetHandle(offset, dst_handle);
+        }
+    }
+
+    R_RETURN(result);
+}
+
+void CleanupSpecialData(KProcess& dst_process, u32* dst_msg_ptr, size_t dst_buffer_size) {
+    // Parse the message.
+    const MessageBuffer dst_msg(dst_msg_ptr, dst_buffer_size);
+    const MessageBuffer::MessageHeader dst_header(dst_msg);
+    const MessageBuffer::SpecialHeader dst_special_header(dst_msg, dst_header);
+
+    // Check that the size is big enough.
+    if (MessageBuffer::GetMessageBufferSize(dst_header, dst_special_header) > dst_buffer_size) {
+        return;
+    }
+
+    // Set the special header.
+    int offset = dst_msg.Set(dst_special_header);
+
+    // Clear the process id, if needed.
+    if (dst_special_header.GetHasProcessId()) {
+        offset = dst_msg.SetProcessId(offset, 0);
+    }
+
+    // Clear handles, as relevant.
+    auto& dst_handle_table = dst_process.GetHandleTable();
+    for (auto i = 0;
+         i < (dst_special_header.GetCopyHandleCount() + dst_special_header.GetMoveHandleCount());
+         ++i) {
+        const Handle handle = dst_msg.GetHandle(offset);
+
+        if (handle != Svc::InvalidHandle) {
+            dst_handle_table.Remove(handle);
+        }
+
+        offset = dst_msg.SetHandle(offset, Svc::InvalidHandle);
+    }
+}
+
+} // namespace
+
 using ThreadQueueImplForKServerSessionRequest = KThreadQueue;
 
 KServerSession::KServerSession(KernelCore& kernel)
@@ -223,12 +343,27 @@ Result KServerSession::SendReply(bool is_hle) {
             // the reply has already been written in this case.
         } else {
             Core::Memory::Memory& memory{client_thread->GetOwnerProcess()->GetMemory()};
-            KThread* server_thread{GetCurrentThreadPointer(m_kernel)};
+            KThread* server_thread = GetCurrentThreadPointer(m_kernel);
+            KProcess& src_process = *client_thread->GetOwnerProcess();
+            KProcess& dst_process = *server_thread->GetOwnerProcess();
             UNIMPLEMENTED_IF(server_thread->GetOwnerProcess() != client_thread->GetOwnerProcess());
 
-            auto* src_msg_buffer = memory.GetPointer(server_thread->GetTlsAddress());
-            auto* dst_msg_buffer = memory.GetPointer(client_message);
+            auto* src_msg_buffer = memory.GetPointer<u32>(server_thread->GetTlsAddress());
+            auto* dst_msg_buffer = memory.GetPointer<u32>(client_message);
             std::memcpy(dst_msg_buffer, src_msg_buffer, client_buffer_size);
+
+            // Translate special header ad-hoc.
+            MessageBuffer src_msg(src_msg_buffer, client_buffer_size);
+            MessageBuffer::MessageHeader src_header(src_msg);
+            MessageBuffer::SpecialHeader src_special_header(src_msg, src_header);
+            if (src_header.GetHasSpecialHeader()) {
+                MessageBuffer dst_msg(dst_msg_buffer, client_buffer_size);
+                result = ProcessMessageSpecialData<true>(dst_process, src_process, *server_thread,
+                                                         dst_msg, src_msg, src_special_header);
+                if (R_FAILED(result)) {
+                    CleanupSpecialData(dst_process, dst_msg_buffer, client_buffer_size);
+                }
+            }
         }
     } else {
         result = ResultSessionClosed;
@@ -330,12 +465,28 @@ Result KServerSession::ReceiveRequest(std::shared_ptr<Service::HLERequestContext
             ->PopulateFromIncomingCommandBuffer(client_thread->GetOwnerProcess()->GetHandleTable(),
                                                 cmd_buf);
     } else {
-        KThread* server_thread{GetCurrentThreadPointer(m_kernel)};
-        UNIMPLEMENTED_IF(server_thread->GetOwnerProcess() != client_thread->GetOwnerProcess());
+        KThread* server_thread = GetCurrentThreadPointer(m_kernel);
+        KProcess& src_process = *client_thread->GetOwnerProcess();
+        KProcess& dst_process = *server_thread->GetOwnerProcess();
+        UNIMPLEMENTED_IF(client_thread->GetOwnerProcess() != server_thread->GetOwnerProcess());
 
-        auto* src_msg_buffer = memory.GetPointer(client_message);
-        auto* dst_msg_buffer = memory.GetPointer(server_thread->GetTlsAddress());
+        auto* src_msg_buffer = memory.GetPointer<u32>(client_message);
+        auto* dst_msg_buffer = memory.GetPointer<u32>(server_thread->GetTlsAddress());
         std::memcpy(dst_msg_buffer, src_msg_buffer, client_buffer_size);
+
+        // Translate special header ad-hoc.
+        // TODO: fix this mess
+        MessageBuffer src_msg(src_msg_buffer, client_buffer_size);
+        MessageBuffer::MessageHeader src_header(src_msg);
+        MessageBuffer::SpecialHeader src_special_header(src_msg, src_header);
+        if (src_header.GetHasSpecialHeader()) {
+            MessageBuffer dst_msg(dst_msg_buffer, client_buffer_size);
+            Result res = ProcessMessageSpecialData<false>(dst_process, src_process, *client_thread,
+                                                          dst_msg, src_msg, src_special_header);
+            if (R_FAILED(res)) {
+                CleanupSpecialData(dst_process, dst_msg_buffer, client_buffer_size);
+            }
+        }
     }
 
     // We succeeded.

src/core/hle/kernel/k_thread.cpp

@@ -302,12 +302,12 @@ Result KThread::InitializeServiceThread(Core::System& system, KThread* thread,
                                         std::function<void()>&& func, s32 prio, s32 virt_core,
                                         KProcess* owner) {
     system.Kernel().GlobalSchedulerContext().AddThread(thread);
-    std::function<void()> func2{[&system, func{std::move(func)}] {
+    std::function<void()> func2{[&system, func_{std::move(func)}] {
         // Similar to UserModeThreadStarter.
         system.Kernel().CurrentScheduler()->OnThreadStart();
 
         // Run the guest function.
-        func();
+        func_();
 
         // Exit.
         Svc::ExitThread(system);

src/core/hle/kernel/kernel.cpp

@@ -1089,15 +1089,15 @@ static std::jthread RunHostThreadFunc(KernelCore& kernel, KProcess* process,
     KThread::Register(kernel, thread);
 
     return std::jthread(
-        [&kernel, thread, thread_name{std::move(thread_name)}, func{std::move(func)}] {
+        [&kernel, thread, thread_name_{std::move(thread_name)}, func_{std::move(func)}] {
             // Set the thread name.
-            Common::SetCurrentThreadName(thread_name.c_str());
+            Common::SetCurrentThreadName(thread_name_.c_str());
 
             // Set the thread as current.
             kernel.RegisterHostThread(thread);
 
             // Run the callback.
-            func();
+            func_();
 
             // Close the thread.
             // This will free the process if it is the last reference.

src/core/hle/kernel/message_buffer.h

@@ -0,0 +1,612 @@
+// SPDX-FileCopyrightText: 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/alignment.h"
+#include "common/bit_field.h"
+#include "core/hle/kernel/k_thread.h"
+
+namespace Kernel {
+
+constexpr inline size_t MessageBufferSize = 0x100;
+
+class MessageBuffer {
+public:
+    class MessageHeader {
+    private:
+        static constexpr inline u64 NullTag = 0;
+
+    public:
+        enum class ReceiveListCountType : u32 {
+            None = 0,
+            ToMessageBuffer = 1,
+            ToSingleBuffer = 2,
+
+            CountOffset = 2,
+            CountMax = 13,
+        };
+
+    private:
+        union {
+            std::array<u32, 2> raw;
+
+            struct {
+                // Define fields for the first header word.
+                union {
+                    BitField<0, 16, u16> tag;
+                    BitField<16, 4, u32> pointer_count;
+                    BitField<20, 4, u32> send_count;
+                    BitField<24, 4, u32> receive_count;
+                    BitField<28, 4, u32> exchange_count;
+                };
+
+                // Define fields for the second header word.
+                union {
+                    BitField<0, 10, u32> raw_count;
+                    BitField<10, 4, ReceiveListCountType> receive_list_count;
+                    BitField<14, 6, u32> reserved0;
+                    BitField<20, 11, u32> receive_list_offset;
+                    BitField<31, 1, u32> has_special_header;
+                };
+            };
+        } m_header;
+
+    public:
+        constexpr MessageHeader() : m_header{} {}
+
+        constexpr MessageHeader(u16 tag, bool special, s32 ptr, s32 send, s32 recv, s32 exch,
+                                s32 raw, ReceiveListCountType recv_list)
+            : m_header{} {
+            m_header.raw[0] = 0;
+            m_header.raw[1] = 0;
+
+            m_header.tag.Assign(tag);
+            m_header.pointer_count.Assign(ptr);
+            m_header.send_count.Assign(send);
+            m_header.receive_count.Assign(recv);
+            m_header.exchange_count.Assign(exch);
+
+            m_header.raw_count.Assign(raw);
+            m_header.receive_list_count.Assign(recv_list);
+            m_header.has_special_header.Assign(special);
+        }
+
+        explicit MessageHeader(const MessageBuffer& buf) : m_header{} {
+            buf.Get(0, m_header.raw.data(), 2);
+        }
+
+        explicit MessageHeader(const u32* msg) : m_header{{msg[0], msg[1]}} {}
+
+        constexpr u16 GetTag() const {
+            return m_header.tag;
+        }
+
+        constexpr s32 GetPointerCount() const {
+            return m_header.pointer_count;
+        }
+
+        constexpr s32 GetSendCount() const {
+            return m_header.send_count;
+        }
+
+        constexpr s32 GetReceiveCount() const {
+            return m_header.receive_count;
+        }
+
+        constexpr s32 GetExchangeCount() const {
+            return m_header.exchange_count;
+        }
+
+        constexpr s32 GetMapAliasCount() const {
+            return this->GetSendCount() + this->GetReceiveCount() + this->GetExchangeCount();
+        }
+
+        constexpr s32 GetRawCount() const {
+            return m_header.raw_count;
+        }
+
+        constexpr ReceiveListCountType GetReceiveListCount() const {
+            return m_header.receive_list_count;
+        }
+
+        constexpr s32 GetReceiveListOffset() const {
+            return m_header.receive_list_offset;
+        }
+
+        constexpr bool GetHasSpecialHeader() const {
+            return m_header.has_special_header.Value() != 0;
+        }
+
+        constexpr void SetReceiveListCount(ReceiveListCountType recv_list) {
+            m_header.receive_list_count.Assign(recv_list);
+        }
+
+        constexpr const u32* GetData() const {
+            return m_header.raw.data();
+        }
+
+        static constexpr size_t GetDataSize() {
+            return sizeof(m_header);
+        }
+    };
+
+    class SpecialHeader {
+    private:
+        union {
+            std::array<u32, 1> raw;
+
+            // Define fields for the header word.
+            BitField<0, 1, u32> has_process_id;
+            BitField<1, 4, u32> copy_handle_count;
+            BitField<5, 4, u32> move_handle_count;
+        } m_header;
+        bool m_has_header;
+
+    public:
+        constexpr explicit SpecialHeader(bool pid, s32 copy, s32 move)
+            : m_header{}, m_has_header(true) {
+            m_header.has_process_id.Assign(pid);
+            m_header.copy_handle_count.Assign(copy);
+            m_header.move_handle_count.Assign(move);
+        }
+
+        constexpr explicit SpecialHeader(bool pid, s32 copy, s32 move, bool _has_header)
+            : m_header{}, m_has_header(_has_header) {
+            m_header.has_process_id.Assign(pid);
+            m_header.copy_handle_count.Assign(copy);
+            m_header.move_handle_count.Assign(move);
+        }
+
+        explicit SpecialHeader(const MessageBuffer& buf, const MessageHeader& hdr)
+            : m_header{}, m_has_header(hdr.GetHasSpecialHeader()) {
+            if (m_has_header) {
+                buf.Get(static_cast<s32>(MessageHeader::GetDataSize() / sizeof(u32)),
+                        m_header.raw.data(), sizeof(m_header) / sizeof(u32));
+            }
+        }
+
+        constexpr bool GetHasProcessId() const {
+            return m_header.has_process_id.Value() != 0;
+        }
+
+        constexpr s32 GetCopyHandleCount() const {
+            return m_header.copy_handle_count;
+        }
+
+        constexpr s32 GetMoveHandleCount() const {
+            return m_header.move_handle_count;
+        }
+
+        constexpr const u32* GetHeader() const {
+            return m_header.raw.data();
+        }
+
+        constexpr size_t GetHeaderSize() const {
+            if (m_has_header) {
+                return sizeof(m_header);
+            } else {
+                return 0;
+            }
+        }
+
+        constexpr size_t GetDataSize() const {
+            if (m_has_header) {
+                return (this->GetHasProcessId() ? sizeof(u64) : 0) +
+                       (this->GetCopyHandleCount() * sizeof(Handle)) +
+                       (this->GetMoveHandleCount() * sizeof(Handle));
+            } else {
+                return 0;
+            }
+        }
+    };
+
+    class MapAliasDescriptor {
+    public:
+        enum class Attribute : u32 {
+            Ipc = 0,
+            NonSecureIpc = 1,
+            NonDeviceIpc = 3,
+        };
+
+    private:
+        static constexpr u32 SizeLowCount = 32;
+        static constexpr u32 SizeHighCount = 4;
+        static constexpr u32 AddressLowCount = 32;
+        static constexpr u32 AddressMidCount = 4;
+
+        constexpr u32 GetAddressMid(u64 address) {
+            return static_cast<u32>(address >> AddressLowCount) & ((1U << AddressMidCount) - 1);
+        }
+
+        constexpr u32 GetAddressHigh(u64 address) {
+            return static_cast<u32>(address >> (AddressLowCount + AddressMidCount));
+        }
+
+    private:
+        union {
+            std::array<u32, 3> raw;
+
+            struct {
+                // Define fields for the first two words.
+                u32 size_low;
+                u32 address_low;
+
+                // Define fields for the packed descriptor word.
+                union {
+                    BitField<0, 2, Attribute> attributes;
+                    BitField<2, 3, u32> address_high;
+                    BitField<5, 19, u32> reserved;
+                    BitField<24, 4, u32> size_high;
+                    BitField<28, 4, u32> address_mid;
+                };
+            };
+        } m_data;
+
+    public:
+        constexpr MapAliasDescriptor() : m_data{} {}
+
+        MapAliasDescriptor(const void* buffer, size_t _size, Attribute attr = Attribute::Ipc)
+            : m_data{} {
+            const u64 address = reinterpret_cast<u64>(buffer);
+            const u64 size = static_cast<u64>(_size);
+            m_data.size_low = static_cast<u32>(size);
+            m_data.address_low = static_cast<u32>(address);
+            m_data.attributes.Assign(attr);
+            m_data.address_mid.Assign(GetAddressMid(address));
+            m_data.size_high.Assign(static_cast<u32>(size >> SizeLowCount));
+            m_data.address_high.Assign(GetAddressHigh(address));
+        }
+
+        MapAliasDescriptor(const MessageBuffer& buf, s32 index) : m_data{} {
+            buf.Get(index, m_data.raw.data(), 3);
+        }
+
+        constexpr uintptr_t GetAddress() const {
+            return (static_cast<u64>((m_data.address_high << AddressMidCount) | m_data.address_mid)
+                    << AddressLowCount) |
+                   m_data.address_low;
+        }
+
+        constexpr uintptr_t GetSize() const {
+            return (static_cast<u64>(m_data.size_high) << SizeLowCount) | m_data.size_low;
+        }
+
+        constexpr Attribute GetAttribute() const {
+            return m_data.attributes;
+        }
+
+        constexpr const u32* GetData() const {
+            return m_data.raw.data();
+        }
+
+        static constexpr size_t GetDataSize() {
+            return sizeof(m_data);
+        }
+    };
+
+    class PointerDescriptor {
+    private:
+        static constexpr u32 AddressLowCount = 32;
+        static constexpr u32 AddressMidCount = 4;
+
+        constexpr u32 GetAddressMid(u64 address) {
+            return static_cast<u32>(address >> AddressLowCount) & ((1u << AddressMidCount) - 1);
+        }
+
+        constexpr u32 GetAddressHigh(u64 address) {
+            return static_cast<u32>(address >> (AddressLowCount + AddressMidCount));
+        }
+
+    private:
+        union {
+            std::array<u32, 2> raw;
+
+            struct {
+                // Define fields for the packed descriptor word.
+                union {
+                    BitField<0, 4, u32> index;
+                    BitField<4, 2, u32> reserved0;
+                    BitField<6, 3, u32> address_high;
+                    BitField<9, 3, u32> reserved1;
+                    BitField<12, 4, u32> address_mid;
+                    BitField<16, 16, u32> size;
+                };
+
+                // Define fields for the second word.
+                u32 address_low;
+            };
+        } m_data;
+
+    public:
+        constexpr PointerDescriptor() : m_data{} {}
+
+        PointerDescriptor(const void* buffer, size_t size, s32 index) : m_data{} {
+            const u64 address = reinterpret_cast<u64>(buffer);
+
+            m_data.index.Assign(index);
+            m_data.address_high.Assign(GetAddressHigh(address));
+            m_data.address_mid.Assign(GetAddressMid(address));
+            m_data.size.Assign(static_cast<u32>(size));
+
+            m_data.address_low = static_cast<u32>(address);
+        }
+
+        PointerDescriptor(const MessageBuffer& buf, s32 index) : m_data{} {
+            buf.Get(index, m_data.raw.data(), 2);
+        }
+
+        constexpr s32 GetIndex() const {
+            return m_data.index;
+        }
+
+        constexpr uintptr_t GetAddress() const {
+            return (static_cast<u64>((m_data.address_high << AddressMidCount) | m_data.address_mid)
+                    << AddressLowCount) |
+                   m_data.address_low;
+        }
+
+        constexpr size_t GetSize() const {
+            return m_data.size;
+        }
+
+        constexpr const u32* GetData() const {
+            return m_data.raw.data();
+        }
+
+        static constexpr size_t GetDataSize() {
+            return sizeof(m_data);
+        }
+    };
+
+    class ReceiveListEntry {
+    private:
+        static constexpr u32 AddressLowCount = 32;
+
+        constexpr u32 GetAddressHigh(u64 address) {
+            return static_cast<u32>(address >> (AddressLowCount));
+        }
+
+    private:
+        union {
+            std::array<u32, 2> raw;
+
+            struct {
+                // Define fields for the first word.
+                u32 address_low;
+
+                // Define fields for the packed descriptor word.
+                union {
+                    BitField<0, 7, u32> address_high;
+                    BitField<7, 9, u32> reserved;
+                    BitField<16, 16, u32> size;
+                };
+            };
+        } m_data;
+
+    public:
+        constexpr ReceiveListEntry() : m_data{} {}
+
+        ReceiveListEntry(const void* buffer, size_t size) : m_data{} {
+            const u64 address = reinterpret_cast<u64>(buffer);
+
+            m_data.address_low = static_cast<u32>(address);
+
+            m_data.address_high.Assign(GetAddressHigh(address));
+            m_data.size.Assign(static_cast<u32>(size));
+        }
+
+        ReceiveListEntry(u32 a, u32 b) : m_data{{a, b}} {}
+
+        constexpr uintptr_t GetAddress() const {
+            return (static_cast<u64>(m_data.address_high) << AddressLowCount) | m_data.address_low;
+        }
+
+        constexpr size_t GetSize() const {
+            return m_data.size;
+        }
+
+        constexpr const u32* GetData() const {
+            return m_data.raw.data();
+        }
+
+        static constexpr size_t GetDataSize() {
+            return sizeof(m_data);
+        }
+    };
+
+private:
+    u32* m_buffer;
+    size_t m_size;
+
+public:
+    constexpr MessageBuffer(u32* b, size_t sz) : m_buffer(b), m_size(sz) {}
+    constexpr explicit MessageBuffer(u32* b) : m_buffer(b), m_size(MessageBufferSize) {}
+
+    constexpr void* GetBufferForDebug() const {
+        return m_buffer;
+    }
+
+    constexpr size_t GetBufferSize() const {
+        return m_size;
+    }
+
+    void Get(s32 index, u32* dst, size_t count) const {
+        // Ensure that this doesn't get re-ordered.
+        std::atomic_thread_fence(std::memory_order_seq_cst);
+
+        // Get the words.
+        static_assert(sizeof(*dst) == sizeof(*m_buffer));
+
+        memcpy(dst, m_buffer + index, count * sizeof(*dst));
+    }
+
+    s32 Set(s32 index, u32* src, size_t count) const {
+        // Ensure that this doesn't get re-ordered.
+        std::atomic_thread_fence(std::memory_order_seq_cst);
+
+        // Set the words.
+        memcpy(m_buffer + index, src, count * sizeof(*src));
+
+        // Ensure that this doesn't get re-ordered.
+        std::atomic_thread_fence(std::memory_order_seq_cst);
+
+        return static_cast<s32>(index + count);
+    }
+
+    template <typename T>
+    const T& GetRaw(s32 index) const {
+        return *reinterpret_cast<const T*>(m_buffer + index);
+    }
+
+    template <typename T>
+    s32 SetRaw(s32 index, const T& val) const {
+        *reinterpret_cast<const T*>(m_buffer + index) = val;
+        return index + (Common::AlignUp(sizeof(val), sizeof(*m_buffer)) / sizeof(*m_buffer));
+    }
+
+    void GetRawArray(s32 index, void* dst, size_t len) const {
+        memcpy(dst, m_buffer + index, len);
+    }
+
+    void SetRawArray(s32 index, const void* src, size_t len) const {
+        memcpy(m_buffer + index, src, len);
+    }
+
+    void SetNull() const {
+        this->Set(MessageHeader());
+    }
+
+    s32 Set(const MessageHeader& hdr) const {
+        memcpy(m_buffer, hdr.GetData(), hdr.GetDataSize());
+        return static_cast<s32>(hdr.GetDataSize() / sizeof(*m_buffer));
+    }
+
+    s32 Set(const SpecialHeader& spc) const {
+        const s32 index = static_cast<s32>(MessageHeader::GetDataSize() / sizeof(*m_buffer));
+        memcpy(m_buffer + index, spc.GetHeader(), spc.GetHeaderSize());
+        return static_cast<s32>(index + (spc.GetHeaderSize() / sizeof(*m_buffer)));
+    }
+
+    s32 SetHandle(s32 index, const Handle& hnd) const {
+        memcpy(m_buffer + index, std::addressof(hnd), sizeof(hnd));
+        return static_cast<s32>(index + (sizeof(hnd) / sizeof(*m_buffer)));
+    }
+
+    s32 SetProcessId(s32 index, const u64 pid) const {
+        memcpy(m_buffer + index, std::addressof(pid), sizeof(pid));
+        return static_cast<s32>(index + (sizeof(pid) / sizeof(*m_buffer)));
+    }
+
+    s32 Set(s32 index, const MapAliasDescriptor& desc) const {
+        memcpy(m_buffer + index, desc.GetData(), desc.GetDataSize());
+        return static_cast<s32>(index + (desc.GetDataSize() / sizeof(*m_buffer)));
+    }
+
+    s32 Set(s32 index, const PointerDescriptor& desc) const {
+        memcpy(m_buffer + index, desc.GetData(), desc.GetDataSize());
+        return static_cast<s32>(index + (desc.GetDataSize() / sizeof(*m_buffer)));
+    }
+
+    s32 Set(s32 index, const ReceiveListEntry& desc) const {
+        memcpy(m_buffer + index, desc.GetData(), desc.GetDataSize());
+        return static_cast<s32>(index + (desc.GetDataSize() / sizeof(*m_buffer)));
+    }
+
+    s32 Set(s32 index, const u32 val) const {
+        memcpy(m_buffer + index, std::addressof(val), sizeof(val));
+        return static_cast<s32>(index + (sizeof(val) / sizeof(*m_buffer)));
+    }
+
+    Result GetAsyncResult() const {
+        MessageHeader hdr(m_buffer);
+        MessageHeader null{};
+        if (memcmp(hdr.GetData(), null.GetData(), MessageHeader::GetDataSize()) != 0) [[unlikely]] {
+            R_SUCCEED();
+        }
+        return Result(m_buffer[MessageHeader::GetDataSize() / sizeof(*m_buffer)]);
+    }
+
+    void SetAsyncResult(Result res) const {
+        const s32 index = this->Set(MessageHeader());
+        const auto value = res.raw;
+        memcpy(m_buffer + index, std::addressof(value), sizeof(value));
+    }
+
+    u32 Get32(s32 index) const {
+        return m_buffer[index];
+    }
+
+    u64 Get64(s32 index) const {
+        u64 value;
+        memcpy(std::addressof(value), m_buffer + index, sizeof(value));
+        return value;
+    }
+
+    u64 GetProcessId(s32 index) const {
+        return this->Get64(index);
+    }
+
+    Handle GetHandle(s32 index) const {
+        static_assert(sizeof(Handle) == sizeof(*m_buffer));
+        return Handle(m_buffer[index]);
+    }
+
+    static constexpr s32 GetSpecialDataIndex(const MessageHeader& hdr, const SpecialHeader& spc) {
+        return static_cast<s32>((MessageHeader::GetDataSize() / sizeof(u32)) +
+                                (spc.GetHeaderSize() / sizeof(u32)));
+    }
+
+    static constexpr s32 GetPointerDescriptorIndex(const MessageHeader& hdr,
+                                                   const SpecialHeader& spc) {
+        return static_cast<s32>(GetSpecialDataIndex(hdr, spc) + (spc.GetDataSize() / sizeof(u32)));
+    }
+
+    static constexpr s32 GetMapAliasDescriptorIndex(const MessageHeader& hdr,
+                                                    const SpecialHeader& spc) {
+        return GetPointerDescriptorIndex(hdr, spc) +
+               static_cast<s32>(hdr.GetPointerCount() * PointerDescriptor::GetDataSize() /
+                                sizeof(u32));
+    }
+
+    static constexpr s32 GetRawDataIndex(const MessageHeader& hdr, const SpecialHeader& spc) {
+        return GetMapAliasDescriptorIndex(hdr, spc) +
+               static_cast<s32>(hdr.GetMapAliasCount() * MapAliasDescriptor::GetDataSize() /
+                                sizeof(u32));
+    }
+
+    static constexpr s32 GetReceiveListIndex(const MessageHeader& hdr, const SpecialHeader& spc) {
+        if (const s32 recv_list_index = hdr.GetReceiveListOffset()) {
+            return recv_list_index;
+        } else {
+            return GetRawDataIndex(hdr, spc) + hdr.GetRawCount();
+        }
+    }
+
+    static constexpr size_t GetMessageBufferSize(const MessageHeader& hdr,
+                                                 const SpecialHeader& spc) {
+        // Get the size of the plain message.
+        size_t msg_size = GetReceiveListIndex(hdr, spc) * sizeof(u32);
+
+        // Add the size of the receive list.
+        const auto count = hdr.GetReceiveListCount();
+        switch (count) {
+        case MessageHeader::ReceiveListCountType::None:
+            break;
+        case MessageHeader::ReceiveListCountType::ToMessageBuffer:
+            break;
+        case MessageHeader::ReceiveListCountType::ToSingleBuffer:
+            msg_size += ReceiveListEntry::GetDataSize();
+            break;
+        default:
+            msg_size += (static_cast<s32>(count) -
+                         static_cast<s32>(MessageHeader::ReceiveListCountType::CountOffset)) *
+                        ReceiveListEntry::GetDataSize();
+            break;
+        }
+
+        return msg_size;
+    }
+};
+
+} // namespace Kernel

src/core/hle/service/am/am.cpp

@@ -506,8 +506,8 @@ void ISelfController::SetHandlesRequestToDisplay(HLERequestContext& ctx) {
 void ISelfController::SetIdleTimeDetectionExtension(HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     idle_time_detection_extension = rp.Pop<u32>();
-    LOG_WARNING(Service_AM, "(STUBBED) called idle_time_detection_extension={}",
-                idle_time_detection_extension);
+    LOG_DEBUG(Service_AM, "(STUBBED) called idle_time_detection_extension={}",
+              idle_time_detection_extension);
 
     IPC::ResponseBuilder rb{ctx, 2};
     rb.Push(ResultSuccess);

src/core/hle/service/nifm/nifm.cpp

@@ -7,6 +7,7 @@
 #include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/nifm/nifm.h"
 #include "core/hle/service/server_manager.h"
+#include "network/network.h"
 
 namespace {
 

src/core/hle/service/nifm/nifm.h

@@ -4,14 +4,15 @@
 #pragma once
 
 #include "core/hle/service/service.h"
-#include "network/network.h"
-#include "network/room.h"
-#include "network/room_member.h"
 
 namespace Core {
 class System;
 }
 
+namespace Network {
+class RoomNetwork;
+}
+
 namespace Service::NIFM {
 
 void LoopProcess(Core::System& system);

src/core/hle/service/ssl/ssl_backend.h

@@ -3,15 +3,15 @@
 
 #pragma once
 
-#include "core/hle/result.h"
-
-#include "common/common_types.h"
-
 #include <memory>
 #include <span>
 #include <string>
 #include <vector>
 
+#include "common/common_types.h"
+
+#include "core/hle/result.h"
+
 namespace Network {
 class SocketBase;
 }

src/core/hle/service/ssl/ssl_backend_none.cpp

@@ -1,10 +1,10 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "core/hle/service/ssl/ssl_backend.h"
-
 #include "common/logging/log.h"
 
+#include "core/hle/service/ssl/ssl_backend.h"
+
 namespace Service::SSL {
 
 ResultVal<std::unique_ptr<SSLConnectionBackend>> CreateSSLConnectionBackend() {

src/core/hle/service/ssl/ssl_backend_openssl.cpp

@@ -1,14 +1,6 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "core/hle/service/ssl/ssl_backend.h"
-#include "core/internal_network/network.h"
-#include "core/internal_network/sockets.h"
-
-#include "common/fs/file.h"
-#include "common/hex_util.h"
-#include "common/string_util.h"
-
 #include <mutex>
 
 #include <openssl/bio.h>
@@ -16,6 +8,14 @@
 #include <openssl/ssl.h>
 #include <openssl/x509.h>
 
+#include "common/fs/file.h"
+#include "common/hex_util.h"
+#include "common/string_util.h"
+
+#include "core/hle/service/ssl/ssl_backend.h"
+#include "core/internal_network/network.h"
+#include "core/internal_network/sockets.h"
+
 using namespace Common::FS;
 
 namespace Service::SSL {

src/core/hle/service/ssl/ssl_backend_schannel.cpp

@@ -1,16 +1,16 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "core/hle/service/ssl/ssl_backend.h"
-#include "core/internal_network/network.h"
-#include "core/internal_network/sockets.h"
+#include <mutex>
 
 #include "common/error.h"
 #include "common/fs/file.h"
 #include "common/hex_util.h"
 #include "common/string_util.h"
 
-#include <mutex>
+#include "core/hle/service/ssl/ssl_backend.h"
+#include "core/internal_network/network.h"
+#include "core/internal_network/sockets.h"
 
 namespace {
 
@@ -20,6 +20,7 @@ namespace {
 #define SECURITY_WIN32
 #include <schnlsp.h>
 #include <security.h>
+#include <wincrypt.h>
 
 std::once_flag one_time_init_flag;
 bool one_time_init_success = false;

src/core/hle/service/ssl/ssl_backend_securetransport.cpp

@@ -1,18 +1,21 @@
 // SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
-#include "core/hle/service/ssl/ssl_backend.h"
-#include "core/internal_network/network.h"
-#include "core/internal_network/sockets.h"
-
 #include <mutex>
 
-#include <Security/SecureTransport.h>
-
 // SecureTransport has been deprecated in its entirety in favor of
 // Network.framework, but that does not allow layering TLS on top of an
 // arbitrary socket.
+#if defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#include <Security/SecureTransport.h>
+#pragma GCC diagnostic pop
+#endif
+
+#include "core/hle/service/ssl/ssl_backend.h"
+#include "core/internal_network/network.h"
+#include "core/internal_network/sockets.h"
 
 namespace {