mika/Atmosphere-libs
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere-libs.git synced 2025-06-22 19:32:39 +02:00
Code Issues Packages Projects Releases Wiki Activity

svc: refactor/rename MemoryInfo fields

Browse Source
This commit is contained in:
Michael Scire 2021-10-05 15:16:54 -07:00
parent 782e449543
commit 390ce66da1
13 changed files with 98 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libmesosphere/include/mesosphere/kern_k_io_region.hpp
View File

@ -34,7 +34,7 @@ namespace ams::kern {
KPhysicalAddress m_physical_address; KPhysicalAddress m_physical_address;
size_t m_size; size_t m_size;
ams::svc::MemoryMapping m_mapping; ams::svc::MemoryMapping m_mapping;
ams::svc::MemoryPermission m_perm; ams::svc::MemoryPermission m_permission;
bool m_is_initialized; bool m_is_initialized;
bool m_is_mapped; bool m_is_mapped;
util::IntrusiveListNode m_process_list_node; util::IntrusiveListNode m_process_list_node;

68
libmesosphere/include/mesosphere/kern_k_memory_block.hpp
View File

@ -200,20 +200,20 @@ namespace ams::kern {
u16 m_ipc_lock_count; u16 m_ipc_lock_count;
u16 m_device_use_count; u16 m_device_use_count;
u16 m_ipc_disable_merge_count; u16 m_ipc_disable_merge_count;
KMemoryPermission m_perm; KMemoryPermission m_permission;
KMemoryAttribute m_attribute; KMemoryAttribute m_attribute;
KMemoryPermission m_original_perm; KMemoryPermission m_original_permission;
KMemoryBlockDisableMergeAttribute m_disable_merge_attribute; KMemoryBlockDisableMergeAttribute m_disable_merge_attribute;
constexpr ams::svc::MemoryInfo GetSvcMemoryInfo() const { constexpr ams::svc::MemoryInfo GetSvcMemoryInfo() const {
return { return {
.addr = m_address, .base_address = m_address,
.size = m_size, .size = m_size,
.state = static_cast<ams::svc::MemoryState>(m_state & KMemoryState_Mask), .state = static_cast<ams::svc::MemoryState>(m_state & KMemoryState_Mask),
.attr = static_cast<ams::svc::MemoryAttribute>(m_attribute & KMemoryAttribute_UserMask), .attribute = static_cast<ams::svc::MemoryAttribute>(m_attribute & KMemoryAttribute_UserMask),
.perm = static_cast<ams::svc::MemoryPermission>(m_perm & KMemoryPermission_UserMask), .permission = static_cast<ams::svc::MemoryPermission>(m_permission & KMemoryPermission_UserMask),
.ipc_refcount = m_ipc_lock_count, .ipc_count = m_ipc_lock_count,
.device_refcount = m_device_use_count, .device_count = m_device_use_count,
.padding = {}, .padding = {},
}; };
} }
@ -251,11 +251,11 @@ namespace ams::kern {
} }
constexpr KMemoryPermission GetPermission() const { constexpr KMemoryPermission GetPermission() const {
return m_perm; return m_permission;
} }
constexpr KMemoryPermission GetOriginalPermission() const { constexpr KMemoryPermission GetOriginalPermission() const {
return m_original_perm; return m_original_permission;
} }
constexpr KMemoryAttribute GetAttribute() const { constexpr KMemoryAttribute GetAttribute() const {
@ -277,8 +277,8 @@ namespace ams::kern {
u16 m_ipc_lock_count; u16 m_ipc_lock_count;
u16 m_device_use_count; u16 m_device_use_count;
u16 m_ipc_disable_merge_count; u16 m_ipc_disable_merge_count;
KMemoryPermission m_perm; KMemoryPermission m_permission;
KMemoryPermission m_original_perm; KMemoryPermission m_original_permission;
KMemoryAttribute m_attribute; KMemoryAttribute m_attribute;
KMemoryBlockDisableMergeAttribute m_disable_merge_attribute; KMemoryBlockDisableMergeAttribute m_disable_merge_attribute;
public: public:
@ -321,11 +321,11 @@ namespace ams::kern {
} }
constexpr KMemoryPermission GetPermission() const { constexpr KMemoryPermission GetPermission() const {
return m_perm; return m_permission;
} }
constexpr KMemoryPermission GetOriginalPermission() const { constexpr KMemoryPermission GetOriginalPermission() const {
return m_original_perm; return m_original_permission;
} }
constexpr KMemoryAttribute GetAttribute() const { constexpr KMemoryAttribute GetAttribute() const {
@ -342,21 +342,21 @@ namespace ams::kern {
.m_ipc_lock_count = m_ipc_lock_count, .m_ipc_lock_count = m_ipc_lock_count,
.m_device_use_count = m_device_use_count, .m_device_use_count = m_device_use_count,
.m_ipc_disable_merge_count = m_ipc_disable_merge_count, .m_ipc_disable_merge_count = m_ipc_disable_merge_count,
.m_perm = m_perm, .m_permission = m_permission,
.m_attribute = m_attribute, .m_attribute = m_attribute,
.m_original_perm = m_original_perm, .m_original_permission = m_original_permission,
.m_disable_merge_attribute = m_disable_merge_attribute, .m_disable_merge_attribute = m_disable_merge_attribute,
}; };
} }
public: public:
constexpr KMemoryBlock() 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) 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()
{ {
/* ... */ /* ... */
} }
@ -368,23 +368,23 @@ namespace ams::kern {
m_memory_state = ms; m_memory_state = ms;
m_ipc_lock_count = 0; m_ipc_lock_count = 0;
m_device_use_count = 0; m_device_use_count = 0;
m_perm = p; m_permission = p;
m_original_perm = KMemoryPermission_None; m_original_permission = KMemoryPermission_None;
m_attribute = attr; m_attribute = attr;
} }
constexpr bool HasProperties(KMemoryState s, KMemoryPermission p, KMemoryAttribute a) const { constexpr bool HasProperties(KMemoryState s, KMemoryPermission p, KMemoryAttribute a) const {
MESOSPHERE_ASSERT_THIS(); MESOSPHERE_ASSERT_THIS();
constexpr auto AttributeIgnoreMask = KMemoryAttribute_IpcLocked | KMemoryAttribute_DeviceShared; 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 { constexpr bool HasSameProperties(const KMemoryBlock &rhs) const {
MESOSPHERE_ASSERT_THIS(); MESOSPHERE_ASSERT_THIS();
return m_memory_state == rhs.m_memory_state && return m_memory_state == rhs.m_memory_state &&
m_perm == rhs.m_perm && m_permission == rhs.m_permission &&
m_original_perm == rhs.m_original_perm && m_original_permission == rhs.m_original_permission &&
m_attribute == rhs.m_attribute && m_attribute == rhs.m_attribute &&
m_ipc_lock_count == rhs.m_ipc_lock_count && m_ipc_lock_count == rhs.m_ipc_lock_count &&
m_device_use_count == rhs.m_device_use_count; m_device_use_count == rhs.m_device_use_count;
@ -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) { 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_THIS();
MESOSPHERE_ASSERT(m_original_perm == KMemoryPermission_None); MESOSPHERE_ASSERT(m_original_permission == KMemoryPermission_None);
MESOSPHERE_ASSERT((m_attribute & KMemoryAttribute_IpcLocked) == 0); MESOSPHERE_ASSERT((m_attribute & KMemoryAttribute_IpcLocked) == 0);
m_memory_state = s; m_memory_state = s;
m_perm = p; m_permission = p;
m_attribute = static_cast<KMemoryAttribute>(a | (m_attribute & (KMemoryAttribute_IpcLocked | KMemoryAttribute_DeviceShared))); m_attribute = static_cast<KMemoryAttribute>(a | (m_attribute & (KMemoryAttribute_IpcLocked | KMemoryAttribute_DeviceShared)));
if (set_disable_merge_attr && set_mask != 0) { if (set_disable_merge_attr && set_mask != 0) {
@ -440,8 +440,8 @@ namespace ams::kern {
block->m_memory_state = m_memory_state; block->m_memory_state = m_memory_state;
block->m_ipc_lock_count = m_ipc_lock_count; block->m_ipc_lock_count = m_ipc_lock_count;
block->m_device_use_count = m_device_use_count; block->m_device_use_count = m_device_use_count;
block->m_perm = m_perm; block->m_permission = m_permission;
block->m_original_perm = m_original_perm; block->m_original_permission = m_original_permission;
block->m_attribute = m_attribute; block->m_attribute = m_attribute;
block->m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(m_disable_merge_attribute & KMemoryBlockDisableMergeAttribute_AllLeft); block->m_disable_merge_attribute = static_cast<KMemoryBlockDisableMergeAttribute>(m_disable_merge_attribute & KMemoryBlockDisableMergeAttribute_AllLeft);
block->m_ipc_disable_merge_count = m_ipc_disable_merge_count; 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 this is our first lock, update our permissions. */
if (new_lock_count == 1) { if (new_lock_count == 1) {
MESOSPHERE_ASSERT(m_original_perm == KMemoryPermission_None); MESOSPHERE_ASSERT(m_original_permission == KMemoryPermission_None);
MESOSPHERE_ASSERT((m_perm | new_perm | KMemoryPermission_NotMapped) == (m_perm | KMemoryPermission_NotMapped)); MESOSPHERE_ASSERT((m_permission | new_perm | KMemoryPermission_NotMapped) == (m_permission | KMemoryPermission_NotMapped));
MESOSPHERE_ASSERT((m_perm & KMemoryPermission_UserExecute) != KMemoryPermission_UserExecute || (new_perm == KMemoryPermission_UserRead)); MESOSPHERE_ASSERT((m_permission & KMemoryPermission_UserExecute) != KMemoryPermission_UserExecute || (new_perm == KMemoryPermission_UserRead));
m_original_perm = m_perm; m_original_permission = m_permission;
m_perm = static_cast<KMemoryPermission>((new_perm & KMemoryPermission_IpcLockChangeMask) | (m_original_perm & ~KMemoryPermission_IpcLockChangeMask)); m_permission = static_cast<KMemoryPermission>((new_perm & KMemoryPermission_IpcLockChangeMask) | (m_original_permission & ~KMemoryPermission_IpcLockChangeMask));
} }
m_attribute = static_cast<KMemoryAttribute>(m_attribute | KMemoryAttribute_IpcLocked); m_attribute = static_cast<KMemoryAttribute>(m_attribute | KMemoryAttribute_IpcLocked);
@ -610,9 +610,9 @@ namespace ams::kern {
/* If this is our last unlock, update our permissions. */ /* If this is our last unlock, update our permissions. */
if (old_lock_count == 1) { if (old_lock_count == 1) {
MESOSPHERE_ASSERT(m_original_perm != KMemoryPermission_None); MESOSPHERE_ASSERT(m_original_permission != KMemoryPermission_None);
m_perm = m_original_perm; m_permission = m_original_permission;
m_original_perm = KMemoryPermission_None; m_original_permission = KMemoryPermission_None;
m_attribute = static_cast<KMemoryAttribute>(m_attribute & ~KMemoryAttribute_IpcLocked); m_attribute = static_cast<KMemoryAttribute>(m_attribute & ~KMemoryAttribute_IpcLocked);
} }

4
libmesosphere/source/kern_k_io_region.cpp
View File

@ -24,7 +24,7 @@ namespace ams::kern {
m_physical_address = phys_addr; m_physical_address = phys_addr;
m_size = size; m_size = size;
m_mapping = mapping; m_mapping = mapping;
m_perm = perm; m_permission = perm;
m_pool = pool; m_pool = pool;
m_is_mapped = false; m_is_mapped = false;
@ -52,7 +52,7 @@ namespace ams::kern {
MESOSPHERE_ASSERT_THIS(); MESOSPHERE_ASSERT_THIS();
/* Check that the desired perm is allowable. */ /* 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. */ /* Check that the size is correct. */
R_UNLESS(size == m_size, svc::ResultInvalidSize()); R_UNLESS(size == m_size, svc::ResultInvalidSize());

2
libmesosphere/source/kern_k_memory_block_manager.cpp
View File

@ -56,7 +56,7 @@ namespace ams::kern {
if (info.m_state == KMemoryState_Free) { if (info.m_state == KMemoryState_Free) {
return " "; return " ";
} else { } else {
switch (info.m_perm) { switch (info.m_permission) {
case KMemoryPermission_UserReadExecute: case KMemoryPermission_UserReadExecute:
return "r-x"; return "r-x";
case KMemoryPermission_UserRead: case KMemoryPermission_UserRead:

10
libmesosphere/source/kern_k_page_table_base.cpp
View File

@ -469,7 +469,7 @@ 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 { 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. */ /* Validate the states match expectation. */
R_UNLESS((info.m_state & state_mask) == state, svc::ResultInvalidCurrentMemory()); R_UNLESS((info.m_state & state_mask) == state, svc::ResultInvalidCurrentMemory());
R_UNLESS((info.m_perm & perm_mask) == perm, svc::ResultInvalidCurrentMemory()); R_UNLESS((info.m_permission & perm_mask) == perm, svc::ResultInvalidCurrentMemory());
R_UNLESS((info.m_attribute & attr_mask) == attr, svc::ResultInvalidCurrentMemory()); R_UNLESS((info.m_attribute & attr_mask) == attr, svc::ResultInvalidCurrentMemory());
return ResultSuccess(); return ResultSuccess();
@ -524,12 +524,12 @@ namespace ams::kern {
/* Validate all blocks in the range have correct state. */ /* Validate all blocks in the range have correct state. */
const KMemoryState first_state = info.m_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; const KMemoryAttribute first_attr = info.m_attribute;
while (true) { while (true) {
/* Validate the current block. */ /* Validate the current block. */
R_UNLESS(info.m_state == first_state, svc::ResultInvalidCurrentMemory()); 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()); R_UNLESS((info.m_attribute | ignore_attr) == (first_attr | ignore_attr), svc::ResultInvalidCurrentMemory());
/* Validate against the provided masks. */ /* Validate against the provided masks. */
@ -1720,9 +1720,9 @@ namespace ams::kern {
.m_ipc_lock_count = 0, .m_ipc_lock_count = 0,
.m_device_use_count = 0, .m_device_use_count = 0,
.m_ipc_disable_merge_count = 0, .m_ipc_disable_merge_count = 0,
.m_perm = KMemoryPermission_None, .m_permission = KMemoryPermission_None,
.m_attribute = KMemoryAttribute_None, .m_attribute = KMemoryAttribute_None,
.m_original_perm = KMemoryPermission_None, .m_original_permission = KMemoryPermission_None,
.m_disable_merge_attribute = KMemoryBlockDisableMergeAttribute_None, .m_disable_merge_attribute = KMemoryBlockDisableMergeAttribute_None,
}; };
out_page_info->flags = 0; out_page_info->flags = 0;

12
libmesosphere/source/svc/kern_svc_debug.cpp
View File

@ -242,16 +242,16 @@ namespace ams::kern::svc {
} else { } else {
/* Convert the info. */ /* Convert the info. */
T converted_info = {}; T converted_info = {};
static_assert(std::same_as<decltype(T{}.addr), decltype(ams::svc::MemoryInfo{}.addr)>); static_assert(std::same_as<decltype(T{}.base_address), decltype(ams::svc::MemoryInfo{}.base_address)>);
static_assert(std::same_as<decltype(T{}.size), decltype(ams::svc::MemoryInfo{}.size)>); static_assert(std::same_as<decltype(T{}.size), decltype(ams::svc::MemoryInfo{}.size)>);
converted_info.addr = info.addr; converted_info.base_address = info.base_address;
converted_info.size = info.size; converted_info.size = info.size;
converted_info.state = info.state; converted_info.state = info.state;
converted_info.attr = info.attr; converted_info.attribute = info.attribute;
converted_info.perm = info.perm; converted_info.permission = info.permission;
converted_info.ipc_refcount = info.ipc_refcount; converted_info.ipc_count = info.ipc_count;
converted_info.device_refcount = info.device_refcount; converted_info.device_count = info.device_count;
/* Copy it. */ /* Copy it. */
R_TRY(out_memory_info.CopyFrom(std::addressof(converted_info))); R_TRY(out_memory_info.CopyFrom(std::addressof(converted_info)));

12
libmesosphere/source/svc/kern_svc_query_memory.cpp
View File

@ -47,16 +47,16 @@ namespace ams::kern::svc {
} else { } else {
/* Convert the info. */ /* Convert the info. */
T converted_info = {}; T converted_info = {};
static_assert(std::same_as<decltype(T{}.addr), decltype(ams::svc::MemoryInfo{}.addr)>); static_assert(std::same_as<decltype(T{}.base_address), decltype(ams::svc::MemoryInfo{}.base_address)>);
static_assert(std::same_as<decltype(T{}.size), decltype(ams::svc::MemoryInfo{}.size)>); static_assert(std::same_as<decltype(T{}.size), decltype(ams::svc::MemoryInfo{}.size)>);
converted_info.addr = info.addr; converted_info.base_address = info.base_address;
converted_info.size = info.size; converted_info.size = info.size;
converted_info.state = info.state; converted_info.state = info.state;
converted_info.attr = info.attr; converted_info.attribute = info.attribute;
converted_info.perm = info.perm; converted_info.permission = info.permission;
converted_info.ipc_refcount = info.ipc_refcount; converted_info.ipc_count = info.ipc_count;
converted_info.device_refcount = info.device_refcount; converted_info.device_count = info.device_count;
/* Copy it. */ /* Copy it. */
R_TRY(out_memory_info.CopyFrom(std::addressof(converted_info))); R_TRY(out_memory_info.CopyFrom(std::addressof(converted_info)));

8
libstratosphere/source/ams/ams_environment.cpp
View File

@ -95,7 +95,7 @@ namespace ams {
svc::lp64::MemoryInfo mem_info; svc::lp64::MemoryInfo mem_info;
svc::PageInfo page_info; svc::PageInfo page_info;
if (R_SUCCEEDED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), GetPc()))) { 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 { } else {
ams_ctx.module_base = 0; ams_ctx.module_base = 0;
} }
@ -112,7 +112,7 @@ namespace ams {
StackFrame cur_frame; StackFrame cur_frame;
svc::lp64::MemoryInfo mem_info; svc::lp64::MemoryInfo mem_info;
svc::PageInfo page_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<void *>(cur_fp), sizeof(cur_frame)); std::memcpy(&cur_frame, reinterpret_cast<void *>(cur_fp), sizeof(cur_frame));
} else { } else {
break; break;
@ -131,8 +131,8 @@ namespace ams {
{ {
svc::lp64::MemoryInfo mem_info; svc::lp64::MemoryInfo mem_info;
svc::PageInfo page_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) { 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<size_t>(mem_info.addr + mem_info.size - ams_ctx.sp)); size_t copy_size = std::min(FatalErrorContext::MaxStackDumpSize, static_cast<size_t>(mem_info.base_address + mem_info.size - ams_ctx.sp));
ams_ctx.stack_dump_size = copy_size; ams_ctx.stack_dump_size = copy_size;
std::memcpy(ams_ctx.stack_dump, reinterpret_cast<void *>(ams_ctx.sp), copy_size); std::memcpy(ams_ctx.stack_dump, reinterpret_cast<void *>(ams_ctx.sp), copy_size);
} else { } else {

2
libstratosphere/source/diag/impl/diag_module_impl.os.horizon.cpp
View File

@ -44,7 +44,7 @@ namespace ams::diag::impl {
if (R_FAILED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), cur_address))) { if (R_FAILED(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), cur_address))) {
return 0; return 0;
} }
if (mem_info.perm != svc::MemoryPermission_ReadExecute) { if (mem_info.permission != svc::MemoryPermission_ReadExecute) {
break; break;
} }
cur_address += mem_info.size; cur_address += mem_info.size;

2
libstratosphere/source/os/impl/os_address_space_allocator_impl.os.horizon.hpp
View File

@ -32,7 +32,7 @@ namespace ams::os::impl {
R_ASSERT(result); R_ASSERT(result);
AMS_UNUSED(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;
} }
}; };

4
libstratosphere/source/os/impl/os_memory_permission_impl.os.horizon.cpp
View File

@ -27,9 +27,9 @@ namespace ams::os::impl {
svc::PageInfo page_info; svc::PageInfo page_info;
R_ABORT_UNLESS(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), cur_address)); 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)); R_ABORT_UNLESS(svc::SetMemoryPermission(cur_address, cur_size, perm));
} }

12
libstratosphere/source/ro/impl/ro_ro_exception_info.cpp
View File

@ -24,14 +24,14 @@ namespace ams::ro::impl {
svc::PageInfo page_info; svc::PageInfo page_info;
bool success = false; 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)); 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; break;
} }
*out = mem_info.addr; *out = mem_info.base_address;
success = true; success = true;
} }
@ -43,14 +43,14 @@ namespace ams::ro::impl {
svc::PageInfo page_info; svc::PageInfo page_info;
bool success = false; 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)); R_ABORT_UNLESS(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), cur));
if (mem_info.state != state) { if (mem_info.state != state) {
break; break;
} }
*out = mem_info.addr + mem_info.size - 1; *out = mem_info.base_address + mem_info.size - 1;
success = true; success = true;
} }
@ -64,7 +64,7 @@ namespace ams::ro::impl {
R_ABORT_UNLESS(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), pc)); R_ABORT_UNLESS(svc::QueryMemory(std::addressof(mem_info), std::addressof(page_info), pc));
/* Check memory info. */ /* Check memory info. */
if (mem_info.perm != svc::MemoryPermission_ReadExecute) { if (mem_info.permission != svc::MemoryPermission_ReadExecute) {
return false; return false;
} }

20
libvapours/include/vapours/svc/svc_types_base.hpp
View File

@ -21,13 +21,13 @@ namespace ams::svc {
namespace lp64 { namespace lp64 {
struct MemoryInfo { struct MemoryInfo {
u64 addr; u64 base_address;
u64 size; u64 size;
MemoryState state; MemoryState state;
MemoryAttribute attr; MemoryAttribute attribute;
MemoryPermission perm; MemoryPermission permission;
u32 ipc_refcount; u32 ipc_count;
u32 device_refcount; u32 device_count;
u32 padding; u32 padding;
}; };
@ -43,13 +43,13 @@ namespace ams::svc {
namespace ilp32 { namespace ilp32 {
struct MemoryInfo { struct MemoryInfo {
u64 addr; u64 base_address;
u64 size; u64 size;
MemoryState state; MemoryState state;
MemoryAttribute attr; MemoryAttribute attribute;
MemoryPermission perm; MemoryPermission permission;
u32 ipc_refcount; u32 ipc_count;
u32 device_refcount; u32 device_count;
u32 padding; u32 padding;
}; };