VERY experimental Nintendo Switch 2 emulator
C++
k_server_session: translate special header for non-HLE requests
Liamac90cfb9276d
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txtindex 3655b84788..28cb6f86fd 100644--- a/src/core/CMakeLists.txt+++ b/src/core/CMakeLists.txt@@ -285,6 +285,7 @@ add_library(core STATIChle/kernel/kernel.cpphle/kernel/kernel.hhle/kernel/memory_types.h+ hle/kernel/message_buffer.hhle/kernel/physical_core.cpphle/kernel/physical_core.hhle/kernel/physical_memory.hdiff --git a/src/core/hle/kernel/k_server_session.cpp b/src/core/hle/kernel/k_server_session.cppindex c66aff5013..c64ceb5302 100644--- a/src/core/hle/kernel/k_server_session.cpp+++ b/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.diff --git a/src/core/hle/kernel/message_buffer.h b/src/core/hle/kernel/message_buffer.hnew file mode 100644index 0000000000..75b275310e--- /dev/null+++ b/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