diff --git a/libmesosphere/include/mesosphere/kern_k_io_region.hpp b/libmesosphere/include/mesosphere/kern_k_io_region.hpp index 58cad7f4..4d9d7b2b 100644 --- a/libmesosphere/include/mesosphere/kern_k_io_region.hpp +++ b/libmesosphere/include/mesosphere/kern_k_io_region.hpp @@ -34,7 +34,7 @@ namespace ams::kern { KPhysicalAddress m_physical_address; size_t m_size; ams::svc::MemoryMapping m_mapping; - ams::svc::MemoryPermission m_perm; + ams::svc::MemoryPermission m_permission; bool m_is_initialized; bool m_is_mapped; util::IntrusiveListNode m_process_list_node; diff --git a/libmesosphere/include/mesosphere/kern_k_memory_block.hpp b/libmesosphere/include/mesosphere/kern_k_memory_block.hpp index 55761632..9700a80f 100644 --- a/libmesosphere/include/mesosphere/kern_k_memory_block.hpp +++ b/libmesosphere/include/mesosphere/kern_k_memory_block.hpp @@ -200,21 +200,21 @@ namespace ams::kern { u16 m_ipc_lock_count; u16 m_device_use_count; u16 m_ipc_disable_merge_count; - KMemoryPermission m_perm; + KMemoryPermission m_permission; KMemoryAttribute m_attribute; - KMemoryPermission m_original_perm; + KMemoryPermission m_original_permission; KMemoryBlockDisableMergeAttribute m_disable_merge_attribute; constexpr ams::svc::MemoryInfo GetSvcMemoryInfo() const { return { - .addr = m_address, - .size = m_size, - .state = static_cast(m_state & KMemoryState_Mask), - .attr = static_cast(m_attribute & KMemoryAttribute_UserMask), - .perm = static_cast(m_perm & KMemoryPermission_UserMask), - .ipc_refcount = m_ipc_lock_count, - .device_refcount = m_device_use_count, - .padding = {}, + .base_address = m_address, + .size = m_size, + .state = static_cast(m_state & KMemoryState_Mask), + .attribute = static_cast(m_attribute & KMemoryAttribute_UserMask), + .permission = static_cast(m_permission & KMemoryPermission_UserMask), + .ipc_count = m_ipc_lock_count, + .device_count = m_device_use_count, + .padding = {}, }; } @@ -251,11 +251,11 @@ namespace ams::kern { } constexpr KMemoryPermission GetPermission() const { - return m_perm; + return m_permission; } constexpr KMemoryPermission GetOriginalPermission() const { - return m_original_perm; + return m_original_permission; } constexpr KMemoryAttribute GetAttribute() const { @@ -277,8 +277,8 @@ namespace ams::kern { u16 m_ipc_lock_count; u16 m_device_use_count; u16 m_ipc_disable_merge_count; - KMemoryPermission m_perm; - KMemoryPermission m_original_perm; + KMemoryPermission m_permission; + KMemoryPermission m_original_permission; KMemoryAttribute m_attribute; KMemoryBlockDisableMergeAttribute m_disable_merge_attribute; public: @@ -321,11 +321,11 @@ namespace ams::kern { } constexpr KMemoryPermission GetPermission() const { - return m_perm; + return m_permission; } constexpr KMemoryPermission GetOriginalPermission() const { - return m_original_perm; + return m_original_permission; } constexpr KMemoryAttribute GetAttribute() const { @@ -342,52 +342,52 @@ namespace ams::kern { .m_ipc_lock_count = m_ipc_lock_count, .m_device_use_count = m_device_use_count, .m_ipc_disable_merge_count = m_ipc_disable_merge_count, - .m_perm = m_perm, + .m_permission = m_permission, .m_attribute = m_attribute, - .m_original_perm = m_original_perm, + .m_original_permission = m_original_permission, .m_disable_merge_attribute = m_disable_merge_attribute, }; } public: constexpr KMemoryBlock() - : m_device_disable_merge_left_count(), m_device_disable_merge_right_count(), m_address(), m_num_pages(), m_memory_state(KMemoryState_None), m_ipc_lock_count(), m_device_use_count(), m_ipc_disable_merge_count(), m_perm(), m_original_perm(), m_attribute(), m_disable_merge_attribute() + : m_device_disable_merge_left_count(), m_device_disable_merge_right_count(), m_address(), m_num_pages(), m_memory_state(KMemoryState_None), m_ipc_lock_count(), m_device_use_count(), m_ipc_disable_merge_count(), m_permission(), m_original_permission(), m_attribute(), m_disable_merge_attribute() { /* ... */ } constexpr KMemoryBlock(KProcessAddress addr, size_t np, KMemoryState ms, KMemoryPermission p, KMemoryAttribute attr) - : m_device_disable_merge_left_count(), m_device_disable_merge_right_count(), m_address(addr), m_num_pages(np), m_memory_state(ms), m_ipc_lock_count(0), m_device_use_count(0), m_ipc_disable_merge_count(), m_perm(p), m_original_perm(KMemoryPermission_None), m_attribute(attr), m_disable_merge_attribute() + : m_device_disable_merge_left_count(), m_device_disable_merge_right_count(), m_address(addr), m_num_pages(np), m_memory_state(ms), m_ipc_lock_count(0), m_device_use_count(0), m_ipc_disable_merge_count(), m_permission(p), m_original_permission(KMemoryPermission_None), m_attribute(attr), m_disable_merge_attribute() { /* ... */ } constexpr void Initialize(KProcessAddress addr, size_t np, KMemoryState ms, KMemoryPermission p, KMemoryAttribute attr) { MESOSPHERE_ASSERT_THIS(); - m_address = addr; - m_num_pages = np; - m_memory_state = ms; - m_ipc_lock_count = 0; - m_device_use_count = 0; - m_perm = p; - m_original_perm = KMemoryPermission_None; - m_attribute = attr; + m_address = addr; + m_num_pages = np; + m_memory_state = ms; + m_ipc_lock_count = 0; + m_device_use_count = 0; + m_permission = p; + m_original_permission = KMemoryPermission_None; + m_attribute = attr; } constexpr bool HasProperties(KMemoryState s, KMemoryPermission p, KMemoryAttribute a) const { MESOSPHERE_ASSERT_THIS(); constexpr auto AttributeIgnoreMask = KMemoryAttribute_IpcLocked | KMemoryAttribute_DeviceShared; - return m_memory_state == s && m_perm == p && (m_attribute | AttributeIgnoreMask) == (a | AttributeIgnoreMask); + return m_memory_state == s && m_permission == p && (m_attribute | AttributeIgnoreMask) == (a | AttributeIgnoreMask); } constexpr bool HasSameProperties(const KMemoryBlock &rhs) const { MESOSPHERE_ASSERT_THIS(); - return m_memory_state == rhs.m_memory_state && - m_perm == rhs.m_perm && - m_original_perm == rhs.m_original_perm && - m_attribute == rhs.m_attribute && - m_ipc_lock_count == rhs.m_ipc_lock_count && - m_device_use_count == rhs.m_device_use_count; + return m_memory_state == rhs.m_memory_state && + m_permission == rhs.m_permission && + m_original_permission == rhs.m_original_permission && + m_attribute == rhs.m_attribute && + m_ipc_lock_count == rhs.m_ipc_lock_count && + m_device_use_count == rhs.m_device_use_count; } constexpr bool CanMergeWith(const KMemoryBlock &rhs) const { @@ -414,11 +414,11 @@ namespace ams::kern { constexpr void Update(KMemoryState s, KMemoryPermission p, KMemoryAttribute a, bool set_disable_merge_attr, u8 set_mask, u8 clear_mask) { MESOSPHERE_ASSERT_THIS(); - MESOSPHERE_ASSERT(m_original_perm == KMemoryPermission_None); + MESOSPHERE_ASSERT(m_original_permission == KMemoryPermission_None); MESOSPHERE_ASSERT((m_attribute & KMemoryAttribute_IpcLocked) == 0); m_memory_state = s; - m_perm = p; + m_permission = p; m_attribute = static_cast(a | (m_attribute & (KMemoryAttribute_IpcLocked | KMemoryAttribute_DeviceShared))); if (set_disable_merge_attr && set_mask != 0) { @@ -440,8 +440,8 @@ namespace ams::kern { block->m_memory_state = m_memory_state; block->m_ipc_lock_count = m_ipc_lock_count; block->m_device_use_count = m_device_use_count; - block->m_perm = m_perm; - block->m_original_perm = m_original_perm; + block->m_permission = m_permission; + block->m_original_permission = m_original_permission; block->m_attribute = m_attribute; block->m_disable_merge_attribute = static_cast(m_disable_merge_attribute & KMemoryBlockDisableMergeAttribute_AllLeft); block->m_ipc_disable_merge_count = m_ipc_disable_merge_count; @@ -581,11 +581,11 @@ namespace ams::kern { /* If this is our first lock, update our permissions. */ if (new_lock_count == 1) { - MESOSPHERE_ASSERT(m_original_perm == KMemoryPermission_None); - MESOSPHERE_ASSERT((m_perm | new_perm | KMemoryPermission_NotMapped) == (m_perm | KMemoryPermission_NotMapped)); - MESOSPHERE_ASSERT((m_perm & KMemoryPermission_UserExecute) != KMemoryPermission_UserExecute || (new_perm == KMemoryPermission_UserRead)); - m_original_perm = m_perm; - m_perm = static_cast((new_perm & KMemoryPermission_IpcLockChangeMask) | (m_original_perm & ~KMemoryPermission_IpcLockChangeMask)); + MESOSPHERE_ASSERT(m_original_permission == KMemoryPermission_None); + MESOSPHERE_ASSERT((m_permission | new_perm | KMemoryPermission_NotMapped) == (m_permission | KMemoryPermission_NotMapped)); + MESOSPHERE_ASSERT((m_permission & KMemoryPermission_UserExecute) != KMemoryPermission_UserExecute || (new_perm == KMemoryPermission_UserRead)); + m_original_permission = m_permission; + m_permission = static_cast((new_perm & KMemoryPermission_IpcLockChangeMask) | (m_original_permission & ~KMemoryPermission_IpcLockChangeMask)); } m_attribute = static_cast(m_attribute | KMemoryAttribute_IpcLocked); @@ -610,9 +610,9 @@ namespace ams::kern { /* If this is our last unlock, update our permissions. */ if (old_lock_count == 1) { - MESOSPHERE_ASSERT(m_original_perm != KMemoryPermission_None); - m_perm = m_original_perm; - m_original_perm = KMemoryPermission_None; + MESOSPHERE_ASSERT(m_original_permission != KMemoryPermission_None); + m_permission = m_original_permission; + m_original_permission = KMemoryPermission_None; m_attribute = static_cast(m_attribute & ~KMemoryAttribute_IpcLocked); } diff --git a/libmesosphere/source/kern_k_io_region.cpp b/libmesosphere/source/kern_k_io_region.cpp index e243b849..25cf7e20 100644 --- a/libmesosphere/source/kern_k_io_region.cpp +++ b/libmesosphere/source/kern_k_io_region.cpp @@ -24,7 +24,7 @@ namespace ams::kern { m_physical_address = phys_addr; m_size = size; m_mapping = mapping; - m_perm = perm; + m_permission = perm; m_pool = pool; m_is_mapped = false; @@ -52,7 +52,7 @@ namespace ams::kern { MESOSPHERE_ASSERT_THIS(); /* Check that the desired perm is allowable. */ - R_UNLESS((m_perm | map_perm) == m_perm, svc::ResultInvalidNewMemoryPermission()); + R_UNLESS((m_permission | map_perm) == m_permission, svc::ResultInvalidNewMemoryPermission()); /* Check that the size is correct. */ R_UNLESS(size == m_size, svc::ResultInvalidSize()); diff --git a/libmesosphere/source/kern_k_memory_block_manager.cpp b/libmesosphere/source/kern_k_memory_block_manager.cpp index 6fa43c8a..c10643c1 100644 --- a/libmesosphere/source/kern_k_memory_block_manager.cpp +++ b/libmesosphere/source/kern_k_memory_block_manager.cpp @@ -56,7 +56,7 @@ namespace ams::kern { if (info.m_state == KMemoryState_Free) { return " "; } else { - switch (info.m_perm) { + switch (info.m_permission) { case KMemoryPermission_UserReadExecute: return "r-x"; case KMemoryPermission_UserRead: diff --git a/libmesosphere/source/kern_k_page_table_base.cpp b/libmesosphere/source/kern_k_page_table_base.cpp index 61491f49..5afc9ac8 100644 --- a/libmesosphere/source/kern_k_page_table_base.cpp +++ b/libmesosphere/source/kern_k_page_table_base.cpp @@ -468,9 +468,9 @@ namespace ams::kern { Result KPageTableBase::CheckMemoryState(const KMemoryInfo &info, u32 state_mask, u32 state, u32 perm_mask, u32 perm, u32 attr_mask, u32 attr) const { /* Validate the states match expectation. */ - R_UNLESS((info.m_state & state_mask) == state, svc::ResultInvalidCurrentMemory()); - R_UNLESS((info.m_perm & perm_mask) == perm, svc::ResultInvalidCurrentMemory()); - R_UNLESS((info.m_attribute & attr_mask) == attr, svc::ResultInvalidCurrentMemory()); + R_UNLESS((info.m_state & state_mask) == state, svc::ResultInvalidCurrentMemory()); + R_UNLESS((info.m_permission & perm_mask) == perm, svc::ResultInvalidCurrentMemory()); + R_UNLESS((info.m_attribute & attr_mask) == attr, svc::ResultInvalidCurrentMemory()); return ResultSuccess(); } @@ -524,12 +524,12 @@ namespace ams::kern { /* Validate all blocks in the range have correct state. */ const KMemoryState first_state = info.m_state; - const KMemoryPermission first_perm = info.m_perm; + const KMemoryPermission first_perm = info.m_permission; const KMemoryAttribute first_attr = info.m_attribute; while (true) { /* Validate the current block. */ R_UNLESS(info.m_state == first_state, svc::ResultInvalidCurrentMemory()); - R_UNLESS(info.m_perm == first_perm, svc::ResultInvalidCurrentMemory()); + R_UNLESS(info.m_permission == first_perm, svc::ResultInvalidCurrentMemory()); R_UNLESS((info.m_attribute | ignore_attr) == (first_attr | ignore_attr), svc::ResultInvalidCurrentMemory()); /* Validate against the provided masks. */ @@ -1720,9 +1720,9 @@ namespace ams::kern { .m_ipc_lock_count = 0, .m_device_use_count = 0, .m_ipc_disable_merge_count = 0, - .m_perm = KMemoryPermission_None, + .m_permission = KMemoryPermission_None, .m_attribute = KMemoryAttribute_None, - .m_original_perm = KMemoryPermission_None, + .m_original_permission = KMemoryPermission_None, .m_disable_merge_attribute = KMemoryBlockDisableMergeAttribute_None, }; out_page_info->flags = 0; diff --git a/libmesosphere/source/svc/kern_svc_debug.cpp b/libmesosphere/source/svc/kern_svc_debug.cpp index 5b1b8f9b..eb4c0484 100644 --- a/libmesosphere/source/svc/kern_svc_debug.cpp +++ b/libmesosphere/source/svc/kern_svc_debug.cpp @@ -242,16 +242,16 @@ namespace ams::kern::svc { } else { /* Convert the info. */ T converted_info = {}; - static_assert(std::same_as); + static_assert(std::same_as); static_assert(std::same_as); - converted_info.addr = info.addr; - converted_info.size = info.size; - converted_info.state = info.state; - converted_info.attr = info.attr; - converted_info.perm = info.perm; - converted_info.ipc_refcount = info.ipc_refcount; - converted_info.device_refcount = info.device_refcount; + converted_info.base_address = info.base_address; + converted_info.size = info.size; + converted_info.state = info.state; + converted_info.attribute = info.attribute; + converted_info.permission = info.permission; + converted_info.ipc_count = info.ipc_count; + converted_info.device_count = info.device_count; /* Copy it. */ R_TRY(out_memory_info.CopyFrom(std::addressof(converted_info))); diff --git a/libmesosphere/source/svc/kern_svc_query_memory.cpp b/libmesosphere/source/svc/kern_svc_query_memory.cpp index 40e6d334..8fbe9869 100644 --- a/libmesosphere/source/svc/kern_svc_query_memory.cpp +++ b/libmesosphere/source/svc/kern_svc_query_memory.cpp @@ -47,16 +47,16 @@ namespace ams::kern::svc { } else { /* Convert the info. */ T converted_info = {}; - static_assert(std::same_as); + static_assert(std::same_as); static_assert(std::same_as); - converted_info.addr = info.addr; - converted_info.size = info.size; - converted_info.state = info.state; - converted_info.attr = info.attr; - converted_info.perm = info.perm; - converted_info.ipc_refcount = info.ipc_refcount; - converted_info.device_refcount = info.device_refcount; + converted_info.base_address = info.base_address; + converted_info.size = info.size; + converted_info.state = info.state; + converted_info.attribute = info.attribute; + converted_info.permission = info.permission; + converted_info.ipc_count = info.ipc_count; + converted_info.device_count = info.device_count; /* Copy it. */ R_TRY(out_memory_info.CopyFrom(std::addressof(converted_info))); diff --git a/libstratosphere/source/ams/ams_environment.cpp b/libstratosphere/source/ams/ams_environment.cpp index d63aaf0f..7cbb5be8 100644 --- a/libstratosphere/source/ams/ams_environment.cpp +++ b/libstratosphere/source/ams/ams_environment.cpp @@ -95,7 +95,7 @@ namespace ams { svc::lp64::MemoryInfo mem_info; svc::PageInfo page_info; if (R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), GetPc()))) { - ams_ctx.module_base = mem_info.addr; + ams_ctx.module_base = mem_info.base_address; } else { ams_ctx.module_base = 0; } @@ -112,7 +112,7 @@ namespace ams { StackFrame cur_frame; svc::lp64::MemoryInfo mem_info; svc::PageInfo page_info; - if (R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), cur_fp)) && (mem_info.perm & svc::MemoryPermission_Read) == svc::MemoryPermission_Read) { + if (R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), cur_fp)) && (mem_info.permission & svc::MemoryPermission_Read) == svc::MemoryPermission_Read) { std::memcpy(&cur_frame, reinterpret_cast(cur_fp), sizeof(cur_frame)); } else { break; @@ -131,8 +131,8 @@ namespace ams { { svc::lp64::MemoryInfo mem_info; svc::PageInfo page_info; - if (R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), ams_ctx.sp)) && (mem_info.perm & svc::MemoryPermission_Read) == svc::MemoryPermission_Read) { - size_t copy_size = std::min(FatalErrorContext::MaxStackDumpSize, static_cast(mem_info.addr + mem_info.size - ams_ctx.sp)); + if (R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), ams_ctx.sp)) && (mem_info.permission & svc::MemoryPermission_Read) == svc::MemoryPermission_Read) { + size_t copy_size = std::min(FatalErrorContext::MaxStackDumpSize, static_cast(mem_info.base_address + mem_info.size - ams_ctx.sp)); ams_ctx.stack_dump_size = copy_size; std::memcpy(ams_ctx.stack_dump, reinterpret_cast(ams_ctx.sp), copy_size); } else { diff --git a/libstratosphere/source/diag/impl/diag_module_impl.os.horizon.cpp b/libstratosphere/source/diag/impl/diag_module_impl.os.horizon.cpp index 8f1d79c0..0aebd2b4 100644 --- a/libstratosphere/source/diag/impl/diag_module_impl.os.horizon.cpp +++ b/libstratosphere/source/diag/impl/diag_module_impl.os.horizon.cpp @@ -44,7 +44,7 @@ namespace ams::diag::impl { if (R_FAILED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), cur_address))) { return 0; } - if (mem_info.perm != svc::MemoryPermission_ReadExecute) { + if (mem_info.permission != svc::MemoryPermission_ReadExecute) { break; } cur_address += mem_info.size; diff --git a/libstratosphere/source/os/impl/os_address_space_allocator_impl.os.horizon.hpp b/libstratosphere/source/os/impl/os_address_space_allocator_impl.os.horizon.hpp index 055e823d..9ba15af4 100644 --- a/libstratosphere/source/os/impl/os_address_space_allocator_impl.os.horizon.hpp +++ b/libstratosphere/source/os/impl/os_address_space_allocator_impl.os.horizon.hpp @@ -32,7 +32,7 @@ namespace ams::os::impl { R_ASSERT(result); AMS_UNUSED(result); - return memory_info.state == svc::MemoryState_Free && address + size <= memory_info.addr + memory_info.size; + return memory_info.state == svc::MemoryState_Free && address + size <= memory_info.base_address + memory_info.size; } }; diff --git a/libstratosphere/source/os/impl/os_memory_permission_impl.os.horizon.cpp b/libstratosphere/source/os/impl/os_memory_permission_impl.os.horizon.cpp index b2af6d24..bd258b8d 100644 --- a/libstratosphere/source/os/impl/os_memory_permission_impl.os.horizon.cpp +++ b/libstratosphere/source/os/impl/os_memory_permission_impl.os.horizon.cpp @@ -27,9 +27,9 @@ namespace ams::os::impl { svc::PageInfo page_info; R_ABORT_UNLESS(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), cur_address)); - size_t cur_size = std::min(mem_info.addr + mem_info.size - cur_address, remaining_size); + size_t cur_size = std::min(mem_info.base_address + mem_info.size - cur_address, remaining_size); - if (mem_info.perm != perm) { + if (mem_info.permission != perm) { R_ABORT_UNLESS(svc::SetMemoryPermission(cur_address, cur_size, perm)); } diff --git a/libstratosphere/source/ro/impl/ro_ro_exception_info.cpp b/libstratosphere/source/ro/impl/ro_ro_exception_info.cpp index bf70d87c..03956139 100644 --- a/libstratosphere/source/ro/impl/ro_ro_exception_info.cpp +++ b/libstratosphere/source/ro/impl/ro_ro_exception_info.cpp @@ -24,14 +24,14 @@ namespace ams::ro::impl { svc::PageInfo page_info; bool success = false; - for (uintptr_t cur = target; cur <= target; cur = mem_info.addr - 1) { + for (uintptr_t cur = target; cur <= target; cur = mem_info.base_address - 1) { R_ABORT_UNLESS(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), cur)); - if (mem_info.state != state || mem_info.perm != svc::MemoryPermission_ReadExecute) { + if (mem_info.state != state || mem_info.permission != svc::MemoryPermission_ReadExecute) { break; } - *out = mem_info.addr; + *out = mem_info.base_address; success = true; } @@ -43,14 +43,14 @@ namespace ams::ro::impl { svc::PageInfo page_info; bool success = false; - for (uintptr_t cur = target; cur >= target; cur = mem_info.addr + mem_info.size) { + for (uintptr_t cur = target; cur >= target; cur = mem_info.base_address + mem_info.size) { R_ABORT_UNLESS(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), cur)); if (mem_info.state != state) { break; } - *out = mem_info.addr + mem_info.size - 1; + *out = mem_info.base_address + mem_info.size - 1; success = true; } @@ -64,7 +64,7 @@ namespace ams::ro::impl { R_ABORT_UNLESS(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), pc)); /* Check memory info. */ - if (mem_info.perm != svc::MemoryPermission_ReadExecute) { + if (mem_info.permission != svc::MemoryPermission_ReadExecute) { return false; } diff --git a/libvapours/include/vapours/svc/svc_types_base.hpp b/libvapours/include/vapours/svc/svc_types_base.hpp index e0a22ab2..0fee6810 100644 --- a/libvapours/include/vapours/svc/svc_types_base.hpp +++ b/libvapours/include/vapours/svc/svc_types_base.hpp @@ -21,13 +21,13 @@ namespace ams::svc { namespace lp64 { struct MemoryInfo { - u64 addr; + u64 base_address; u64 size; MemoryState state; - MemoryAttribute attr; - MemoryPermission perm; - u32 ipc_refcount; - u32 device_refcount; + MemoryAttribute attribute; + MemoryPermission permission; + u32 ipc_count; + u32 device_count; u32 padding; }; @@ -43,13 +43,13 @@ namespace ams::svc { namespace ilp32 { struct MemoryInfo { - u64 addr; + u64 base_address; u64 size; MemoryState state; - MemoryAttribute attr; - MemoryPermission perm; - u32 ipc_refcount; - u32 device_refcount; + MemoryAttribute attribute; + MemoryPermission permission; + u32 ipc_count; + u32 device_count; u32 padding; };