sneedmca/suyu
1
0
Fork 0
mirror of https://git.suyu.dev/suyu/suyu synced 2024-11-01 21:07:52 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

core: hle: Address various feedback & code cleanup.

Browse source 
- Should be no functional changes.
This commit is contained in:
bunnei 2020-04-17 00:59:08 -04:00
parent 92caa003a8
commit 8bbe74a8dc
11 changed files with 153 additions and 251 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/core/device_memory.h
View file

@ -13,13 +13,15 @@ namespace Core {
class System; class System;
namespace DramMemoryMap { namespace DramMemoryMap {
constexpr u64 Base = 0x80000000ULL; enum : u64 {
constexpr u64 Size = 0x100000000ULL; Base = 0x80000000ULL,
constexpr u64 End = Base + Size; Size = 0x100000000ULL,
constexpr u64 KernelReserveBase = Base + 0x60000; End = Base + Size,
constexpr u64 SlabHeapBase = KernelReserveBase + 0x85000; KernelReserveBase = Base + 0x60000,
constexpr u64 SlapHeapSize = 0xa21000; SlabHeapBase = KernelReserveBase + 0x85000,
constexpr u64 SlabHeapEnd = SlabHeapBase + SlapHeapSize; SlapHeapSize = 0xa21000,
SlabHeapEnd = SlabHeapBase + SlapHeapSize,
};
}; // namespace DramMemoryMap }; // namespace DramMemoryMap
class DeviceMemory : NonCopyable { class DeviceMemory : NonCopyable {

22
src/core/hle/kernel/memory/address_space_info.cpp
View file

@ -14,16 +14,18 @@ namespace Kernel::Memory {
namespace { namespace {
constexpr std::size_t Size_1_MB{0x100000}; enum : u64 {
constexpr std::size_t Size_2_MB{2 * Size_1_MB}; Size_1_MB = 0x100000,
constexpr std::size_t Size_128_MB{128 * Size_1_MB}; Size_2_MB = 2 * Size_1_MB,
constexpr std::size_t Size_1_GB{0x40000000}; Size_128_MB = 128 * Size_1_MB,
constexpr std::size_t Size_2_GB{2 * Size_1_GB}; Size_1_GB = 0x40000000,
constexpr std::size_t Size_4_GB{4 * Size_1_GB}; Size_2_GB = 2 * Size_1_GB,
constexpr std::size_t Size_6_GB{6 * Size_1_GB}; Size_4_GB = 4 * Size_1_GB,
constexpr std::size_t Size_64_GB{64 * Size_1_GB}; Size_6_GB = 6 * Size_1_GB,
constexpr std::size_t Size_512_GB{512 * Size_1_GB}; Size_64_GB = 64 * Size_1_GB,
constexpr u64 Invalid{std::numeric_limits<u64>::max()}; Size_512_GB = 512 * Size_1_GB,
Invalid = std::numeric_limits<u64>::max(),
};
// clang-format off // clang-format off
constexpr std::array<AddressSpaceInfo, 13> AddressSpaceInfos{{ constexpr std::array<AddressSpaceInfo, 13> AddressSpaceInfos{{

6
src/core/hle/kernel/memory/memory_block_manager.cpp
View file

@ -15,7 +15,7 @@ MemoryBlockManager::MemoryBlockManager(VAddr start_addr, VAddr end_addr)
} }
MemoryBlockManager::iterator MemoryBlockManager::FindIterator(VAddr addr) { MemoryBlockManager::iterator MemoryBlockManager::FindIterator(VAddr addr) {
iterator node{memory_block_tree.begin()}; auto node{memory_block_tree.begin()};
while (node != end()) { while (node != end()) {
const VAddr end_addr{node->GetNumPages() * PageSize + node->GetAddress()}; const VAddr end_addr{node->GetNumPages() * PageSize + node->GetAddress()};
if (node->GetAddress() <= addr && end_addr - 1 >= addr) { if (node->GetAddress() <= addr && end_addr - 1 >= addr) {
@ -35,8 +35,8 @@ VAddr MemoryBlockManager::FindFreeArea(VAddr region_start, std::size_t region_nu
const VAddr region_end{region_start + region_num_pages * PageSize}; const VAddr region_end{region_start + region_num_pages * PageSize};
const VAddr region_last{region_end - 1}; const VAddr region_last{region_end - 1};
for (const_iterator it{FindIterator(region_start)}; it != memory_block_tree.cend(); it++) { for (auto it{FindIterator(region_start)}; it != memory_block_tree.cend(); it++) {
const MemoryInfo info{it->GetMemoryInfo()}; const auto info{it->GetMemoryInfo()};
if (region_last < info.GetAddress()) { if (region_last < info.GetAddress()) {
break; break;
} }

29
src/core/hle/kernel/memory/memory_manager.cpp
View file

@ -15,15 +15,14 @@
namespace Kernel::Memory { namespace Kernel::Memory {
std::size_t MemoryManager::Impl::Initialize(Pool new_pool, u64 start_address, u64 end_address) { std::size_t MemoryManager::Impl::Initialize(Pool new_pool, u64 start_address, u64 end_address) {
const std::size_t size{end_address - start_address}; const auto size{end_address - start_address};
// Calculate metadata sizes // Calculate metadata sizes
const std::size_t ref_count_size{(size / PageSize) * sizeof(u16)}; const auto ref_count_size{(size / PageSize) * sizeof(u16)};
const std::size_t optimize_map_size{(Common::AlignUp((size / PageSize), 64) / 64) * const auto optimize_map_size{(Common::AlignUp((size / PageSize), 64) / 64) * sizeof(u64)};
sizeof(u64)}; const auto manager_size{Common::AlignUp(optimize_map_size + ref_count_size, PageSize)};
const std::size_t manager_size{Common::AlignUp(optimize_map_size + ref_count_size, PageSize)}; const auto page_heap_size{PageHeap::CalculateMetadataOverheadSize(size)};
const std::size_t page_heap_size{PageHeap::CalculateMetadataOverheadSize(size)}; const auto total_metadata_size{manager_size + page_heap_size};
const std::size_t total_metadata_size{manager_size + page_heap_size};
ASSERT(manager_size <= total_metadata_size); ASSERT(manager_size <= total_metadata_size);
ASSERT(Common::IsAligned(total_metadata_size, PageSize)); ASSERT(Common::IsAligned(total_metadata_size, PageSize));
@ -55,7 +54,7 @@ VAddr MemoryManager::AllocateContinuous(std::size_t num_pages, std::size_t align
} }
// Lock the pool that we're allocating from // Lock the pool that we're allocating from
const std::size_t pool_index{static_cast<std::size_t>(pool)}; const auto pool_index{static_cast<std::size_t>(pool)};
std::lock_guard lock{pool_locks[pool_index]}; std::lock_guard lock{pool_locks[pool_index]};
// Choose a heap based on our page size request // Choose a heap based on our page size request
@ -72,7 +71,7 @@ VAddr MemoryManager::AllocateContinuous(std::size_t num_pages, std::size_t align
} }
// If we allocated more than we need, free some // If we allocated more than we need, free some
const std::size_t allocated_pages{PageHeap::GetBlockNumPages(heap_index)}; const auto allocated_pages{PageHeap::GetBlockNumPages(heap_index)};
if (allocated_pages > num_pages) { if (allocated_pages > num_pages) {
chosen_manager.Free(allocated_block + num_pages * PageSize, allocated_pages - num_pages); chosen_manager.Free(allocated_block + num_pages * PageSize, allocated_pages - num_pages);
} }
@ -90,7 +89,7 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
} }
// Lock the pool that we're allocating from // Lock the pool that we're allocating from
const std::size_t pool_index{static_cast<std::size_t>(pool)}; const auto pool_index{static_cast<std::size_t>(pool)};
std::lock_guard lock{pool_locks[pool_index]}; std::lock_guard lock{pool_locks[pool_index]};
// Choose a heap based on our page size request // Choose a heap based on our page size request
@ -105,7 +104,7 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
// Ensure that we don't leave anything un-freed // Ensure that we don't leave anything un-freed
auto group_guard = detail::ScopeExit([&] { auto group_guard = detail::ScopeExit([&] {
for (const auto& it : page_list.Nodes()) { for (const auto& it : page_list.Nodes()) {
const std::size_t num_pages{std::min( const auto num_pages{std::min(
it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)}; it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
chosen_manager.Free(it.GetAddress(), num_pages); chosen_manager.Free(it.GetAddress(), num_pages);
} }
@ -113,12 +112,12 @@ ResultCode MemoryManager::Allocate(PageLinkedList& page_list, std::size_t num_pa
// Keep allocating until we've allocated all our pages // Keep allocating until we've allocated all our pages
for (s32 index{heap_index}; index >= 0 && num_pages > 0; index--) { for (s32 index{heap_index}; index >= 0 && num_pages > 0; index--) {
const std::size_t pages_per_alloc{PageHeap::GetBlockNumPages(index)}; const auto pages_per_alloc{PageHeap::GetBlockNumPages(index)};
while (num_pages >= pages_per_alloc) { while (num_pages >= pages_per_alloc) {
// Allocate a block // Allocate a block
VAddr allocated_block{chosen_manager.AllocateBlock(index)}; VAddr allocated_block{chosen_manager.AllocateBlock(index)};
if (allocated_block == 0) { if (!allocated_block) {
break; break;
} }
@ -158,7 +157,7 @@ ResultCode MemoryManager::Free(PageLinkedList& page_list, std::size_t num_pages,
} }
// Lock the pool that we're freeing from // Lock the pool that we're freeing from
const std::size_t pool_index{static_cast<std::size_t>(pool)}; const auto pool_index{static_cast<std::size_t>(pool)};
std::lock_guard lock{pool_locks[pool_index]}; std::lock_guard lock{pool_locks[pool_index]};
// TODO (bunnei): Support multiple managers // TODO (bunnei): Support multiple managers
@ -166,7 +165,7 @@ ResultCode MemoryManager::Free(PageLinkedList& page_list, std::size_t num_pages,
// Free all of the pages // Free all of the pages
for (const auto& it : page_list.Nodes()) { for (const auto& it : page_list.Nodes()) {
const std::size_t num_pages{std::min( const auto num_pages{std::min(
it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)}; it.GetNumPages(), (chosen_manager.GetEndAddress() - it.GetAddress()) / PageSize)};
chosen_manager.Free(it.GetAddress(), num_pages); chosen_manager.Free(it.GetAddress(), num_pages);
} }

48
src/core/hle/kernel/memory/page_heap.h
View file

@ -22,9 +22,10 @@ namespace Kernel::Memory {
class PageHeap final : NonCopyable { class PageHeap final : NonCopyable {
public: public:
static constexpr s32 GetAlignedBlockIndex(std::size_t num_pages, std::size_t align_pages) { static constexpr s32 GetAlignedBlockIndex(std::size_t num_pages, std::size_t align_pages) {
const std::size_t target_pages{std::max(num_pages, align_pages)}; const auto target_pages{std::max(num_pages, align_pages)};
for (std::size_t i = 0; i < NumMemoryBlockPageShifts; i++) { for (std::size_t i = 0; i < NumMemoryBlockPageShifts; i++) {
if (target_pages <= (std::size_t(1) << MemoryBlockPageShifts[i]) / PageSize) { if (target_pages <=
(static_cast<std::size_t>(1) << MemoryBlockPageShifts[i]) / PageSize) {
return static_cast<s32>(i); return static_cast<s32>(i);
} }
} }
@ -33,7 +34,7 @@ public:
static constexpr s32 GetBlockIndex(std::size_t num_pages) { static constexpr s32 GetBlockIndex(std::size_t num_pages) {
for (s32 i{static_cast<s32>(NumMemoryBlockPageShifts) - 1}; i >= 0; i--) { for (s32 i{static_cast<s32>(NumMemoryBlockPageShifts) - 1}; i >= 0; i--) {
if (num_pages >= (std::size_t(1) << MemoryBlockPageShifts[i]) / PageSize) { if (num_pages >= (static_cast<std::size_t>(1) << MemoryBlockPageShifts[i]) / PageSize) {
return i; return i;
} }
} }
@ -41,7 +42,7 @@ public:
} }
static constexpr std::size_t GetBlockSize(std::size_t index) { static constexpr std::size_t GetBlockSize(std::size_t index) {
return std::size_t(1) << MemoryBlockPageShifts[index]; return static_cast<std::size_t>(1) << MemoryBlockPageShifts[index];
} }
static constexpr std::size_t GetBlockNumPages(std::size_t index) { static constexpr std::size_t GetBlockNumPages(std::size_t index) {
@ -51,7 +52,8 @@ public:
private: private:
static constexpr std::size_t NumMemoryBlockPageShifts{7}; static constexpr std::size_t NumMemoryBlockPageShifts{7};
static constexpr std::array<std::size_t, NumMemoryBlockPageShifts> MemoryBlockPageShifts{ static constexpr std::array<std::size_t, NumMemoryBlockPageShifts> MemoryBlockPageShifts{
0xC, 0x10, 0x15, 0x16, 0x19, 0x1D, 0x1E}; 0xC, 0x10, 0x15, 0x16, 0x19, 0x1D, 0x1E,
};
class Block final : NonCopyable { class Block final : NonCopyable {
private: private:
@ -122,13 +124,13 @@ private:
constexpr bool ClearRange(std::size_t offset, std::size_t count) { constexpr bool ClearRange(std::size_t offset, std::size_t count) {
const s32 depth{GetHighestDepthIndex()}; const s32 depth{GetHighestDepthIndex()};
const std::size_t bit_ind{offset / 64}; const auto bit_ind{offset / 64};
u64* bits{bit_storages[depth]}; u64* bits{bit_storages[depth]};
if (count < 64) { if (count < 64) {
const std::size_t shift{offset % 64}; const auto shift{offset % 64};
ASSERT(shift + count <= 64); ASSERT(shift + count <= 64);
// Check that all the bits are set // Check that all the bits are set
const u64 mask{((u64(1) << count) - 1) << shift}; const u64 mask{((1ULL << count) - 1) << shift};
u64 v{bits[bit_ind]}; u64 v{bits[bit_ind]};
if ((v & mask) != mask) { if ((v & mask) != mask) {
return false; return false;
@ -171,9 +173,9 @@ private:
private: private:
constexpr void SetBit(s32 depth, std::size_t offset) { constexpr void SetBit(s32 depth, std::size_t offset) {
while (depth >= 0) { while (depth >= 0) {
const std::size_t ind{offset / 64}; const auto ind{offset / 64};
const std::size_t which{offset % 64}; const auto which{offset % 64};
const u64 mask{u64(1) << which}; const u64 mask{1ULL << which};
u64* bit{std::addressof(bit_storages[depth][ind])}; u64* bit{std::addressof(bit_storages[depth][ind])};
const u64 v{*bit}; const u64 v{*bit};
@ -189,9 +191,9 @@ private:
constexpr void ClearBit(s32 depth, std::size_t offset) { constexpr void ClearBit(s32 depth, std::size_t offset) {
while (depth >= 0) { while (depth >= 0) {
const std::size_t ind{offset / 64}; const auto ind{offset / 64};
const std::size_t which{offset % 64}; const auto which{offset % 64};
const u64 mask{u64(1) << which}; const u64 mask{1ULL << which};
u64* bit{std::addressof(bit_storages[depth][ind])}; u64* bit{std::addressof(bit_storages[depth][ind])};
u64 v{*bit}; u64 v{*bit};
@ -246,7 +248,7 @@ private:
return next_block_shift; return next_block_shift;
} }
constexpr std::size_t GetSize() const { constexpr std::size_t GetSize() const {
return std::size_t(1) << GetShift(); return static_cast<std::size_t>(1) << GetShift();
} }
constexpr std::size_t GetNumPages() const { constexpr std::size_t GetNumPages() const {
return GetSize() / PageSize; return GetSize() / PageSize;
@ -266,13 +268,13 @@ private:
// Align up the address // Align up the address
VAddr end{addr + size}; VAddr end{addr + size};
const std::size_t align{(next_block_shift != 0) ? (u64(1) << next_block_shift) const auto align{(next_block_shift != 0) ? (1ULL << next_block_shift)
: (u64(1) << block_shift)}; : (1ULL << block_shift)};
addr = Common::AlignDown((addr), align); addr = Common::AlignDown((addr), align);
end = Common::AlignUp((end), align); end = Common::AlignUp((end), align);
heap_address = addr; heap_address = addr;
end_offset = (end - addr) / (u64(1) << block_shift); end_offset = (end - addr) / (1ULL << block_shift);
return bitmap.Initialize(bit_storage, end_offset); return bitmap.Initialize(bit_storage, end_offset);
} }
@ -283,7 +285,7 @@ private:
// If we have a next shift, try to clear the blocks below and return the address // If we have a next shift, try to clear the blocks below and return the address
if (GetNextShift()) { if (GetNextShift()) {
const std::size_t diff{u64(1) << (GetNextShift() - GetShift())}; const auto diff{1ULL << (GetNextShift() - GetShift())};
offset = Common::AlignDown(offset, diff); offset = Common::AlignDown(offset, diff);
if (bitmap.ClearRange(offset, diff)) { if (bitmap.ClearRange(offset, diff)) {
return heap_address + (offset << GetShift()); return heap_address + (offset << GetShift());
@ -300,7 +302,7 @@ private:
if (soffset < 0) { if (soffset < 0) {
return 0; return 0;
} }
const std::size_t offset{static_cast<std::size_t>(soffset)}; const auto offset{static_cast<std::size_t>(soffset)};
// Update our tracking and return it // Update our tracking and return it
bitmap.ClearBit(offset); bitmap.ClearBit(offset);
@ -311,9 +313,9 @@ private:
static constexpr std::size_t CalculateMetadataOverheadSize(std::size_t region_size, static constexpr std::size_t CalculateMetadataOverheadSize(std::size_t region_size,
std::size_t cur_block_shift, std::size_t cur_block_shift,
std::size_t next_block_shift) { std::size_t next_block_shift) {
const std::size_t cur_block_size{(u64(1) << cur_block_shift)}; const auto cur_block_size{(1ULL << cur_block_shift)};
const std::size_t next_block_size{(u64(1) << next_block_shift)}; const auto next_block_size{(1ULL << next_block_shift)};
const std::size_t align{(next_block_shift != 0) ? next_block_size : cur_block_size}; const auto align{(next_block_shift != 0) ? next_block_size : cur_block_size};
return Bitmap::CalculateMetadataOverheadSize( return Bitmap::CalculateMetadataOverheadSize(
(align * 2 + Common::AlignUp(region_size, align)) / cur_block_size); (align * 2 + Common::AlignUp(region_size, align)) / cur_block_size);
} }

236
src/core/hle/kernel/memory/page_table.cpp
View file

@ -64,10 +64,10 @@ ResultCode PageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_t
bool enable_aslr, VAddr code_addr, std::size_t code_size, bool enable_aslr, VAddr code_addr, std::size_t code_size,
Memory::MemoryManager::Pool pool) { Memory::MemoryManager::Pool pool) {
const auto GetSpaceStart = [&](AddressSpaceInfo::Type type) { const auto GetSpaceStart = [this](AddressSpaceInfo::Type type) {
return AddressSpaceInfo::GetAddressSpaceStart(address_space_width, type); return AddressSpaceInfo::GetAddressSpaceStart(address_space_width, type);
}; };
const auto GetSpaceSize = [&](AddressSpaceInfo::Type type) { const auto GetSpaceSize = [this](AddressSpaceInfo::Type type) {
return AddressSpaceInfo::GetAddressSpaceSize(address_space_width, type); return AddressSpaceInfo::GetAddressSpaceSize(address_space_width, type);
}; };
@ -286,17 +286,9 @@ ResultCode PageTable::MapProcessCode(VAddr addr, std::size_t num_pages, MemorySt
} }
PageLinkedList page_linked_list; PageLinkedList page_linked_list;
if (const ResultCode result{ CASCADE_CODE(
system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool)}; system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool));
result.IsError()) { CASCADE_CODE(Operate(addr, num_pages, page_linked_list, OperationType::MapGroup));
return result;
}
if (const ResultCode result{
Operate(addr, num_pages, page_linked_list, OperationType::MapGroup)};
result.IsError()) {
return result;
}
block_manager->Update(addr, num_pages, state, perm); block_manager->Update(addr, num_pages, state, perm);
@ -310,13 +302,10 @@ ResultCode PageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::
MemoryState state{}; MemoryState state{};
MemoryPermission perm{}; MemoryPermission perm{};
if (const ResultCode result{CheckMemoryState( CASCADE_CODE(CheckMemoryState(&state, &perm, nullptr, src_addr, size, MemoryState::All,
&state, &perm, nullptr, src_addr, size, MemoryState::All, MemoryState::Normal, MemoryState::Normal, MemoryPermission::Mask,
MemoryPermission::Mask, MemoryPermission::ReadAndWrite, MemoryAttribute::Mask, MemoryPermission::ReadAndWrite, MemoryAttribute::Mask,
MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)}; MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
result.IsError()) {
return result;
}
if (IsRegionMapped(dst_addr, size)) { if (IsRegionMapped(dst_addr, size)) {
return ERR_INVALID_ADDRESS_STATE; return ERR_INVALID_ADDRESS_STATE;
@ -329,16 +318,9 @@ ResultCode PageTable::MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::
auto block_guard = detail::ScopeExit( auto block_guard = detail::ScopeExit(
[&] { Operate(src_addr, num_pages, perm, OperationType::ChangePermissions); }); [&] { Operate(src_addr, num_pages, perm, OperationType::ChangePermissions); });
if (const ResultCode result{Operate(src_addr, num_pages, MemoryPermission::None, CASCADE_CODE(
OperationType::ChangePermissions)}; Operate(src_addr, num_pages, MemoryPermission::None, OperationType::ChangePermissions));
result.IsError()) { CASCADE_CODE(MapPages(dst_addr, page_linked_list, MemoryPermission::None));
return result;
}
if (const ResultCode result{MapPages(dst_addr, page_linked_list, MemoryPermission::None)};
result.IsError()) {
return result;
}
block_guard.Cancel(); block_guard.Cancel();
} }
@ -359,35 +341,20 @@ ResultCode PageTable::UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std
const std::size_t num_pages{size / PageSize}; const std::size_t num_pages{size / PageSize};
if (const ResultCode result{CheckMemoryState( CASCADE_CODE(CheckMemoryState(nullptr, nullptr, nullptr, src_addr, size, MemoryState::All,
nullptr, nullptr, nullptr, src_addr, size, MemoryState::All, MemoryState::Normal, MemoryState::Normal, MemoryPermission::None,
MemoryPermission::None, MemoryPermission::None, MemoryAttribute::Mask, MemoryPermission::None, MemoryAttribute::Mask,
MemoryAttribute::Locked, MemoryAttribute::IpcAndDeviceMapped)}; MemoryAttribute::Locked, MemoryAttribute::IpcAndDeviceMapped));
result.IsError()) {
return result;
}
MemoryState state{}; MemoryState state{};
if (const ResultCode result{CheckMemoryState( CASCADE_CODE(CheckMemoryState(
&state, nullptr, nullptr, dst_addr, PageSize, MemoryState::FlagCanCodeAlias, &state, nullptr, nullptr, dst_addr, PageSize, MemoryState::FlagCanCodeAlias,
MemoryState::FlagCanCodeAlias, MemoryPermission::None, MemoryPermission::None, MemoryState::FlagCanCodeAlias, MemoryPermission::None, MemoryPermission::None,
MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)}; MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
result.IsError()) { CASCADE_CODE(CheckMemoryState(dst_addr, size, MemoryState::All, state, MemoryPermission::None,
return result; MemoryPermission::None, MemoryAttribute::Mask,
} MemoryAttribute::None));
CASCADE_CODE(Operate(dst_addr, num_pages, MemoryPermission::None, OperationType::Unmap));
if (const ResultCode result{CheckMemoryState(dst_addr, size, MemoryState::All, state,
MemoryPermission::None, MemoryPermission::None,
MemoryAttribute::Mask, MemoryAttribute::None)};
result.IsError()) {
return result;
}
if (const ResultCode result{
Operate(dst_addr, num_pages, MemoryPermission::None, OperationType::Unmap)};
result.IsError()) {
return result;
}
block_manager->Update(dst_addr, num_pages, MemoryState::Free); block_manager->Update(dst_addr, num_pages, MemoryState::Free);
block_manager->Update(src_addr, num_pages, MemoryState::Normal, MemoryPermission::ReadAndWrite); block_manager->Update(src_addr, num_pages, MemoryState::Normal, MemoryPermission::ReadAndWrite);
@ -459,11 +426,8 @@ ResultCode PageTable::MapPhysicalMemory(VAddr addr, std::size_t size) {
process->GetResourceLimit()->Release(ResourceType::PhysicalMemory, remaining_size); process->GetResourceLimit()->Release(ResourceType::PhysicalMemory, remaining_size);
}); });
if (const ResultCode result{system.Kernel().MemoryManager().Allocate( CASCADE_CODE(system.Kernel().MemoryManager().Allocate(page_linked_list, remaining_pages,
page_linked_list, remaining_pages, memory_pool)}; memory_pool));
result.IsError()) {
return result;
}
block_guard.Cancel(); block_guard.Cancel();
} }
@ -508,9 +472,7 @@ ResultCode PageTable::UnmapPhysicalMemory(VAddr addr, std::size_t size) {
return RESULT_SUCCESS; return RESULT_SUCCESS;
} }
if (const ResultCode result{UnmapMemory(addr, size)}; result.IsError()) { CASCADE_CODE(UnmapMemory(addr, size));
return result;
}
auto process{system.Kernel().CurrentProcess()}; auto process{system.Kernel().CurrentProcess()};
process->GetResourceLimit()->Release(ResourceType::PhysicalMemory, mapped_size); process->GetResourceLimit()->Release(ResourceType::PhysicalMemory, mapped_size);
@ -559,13 +521,10 @@ ResultCode PageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
std::lock_guard lock{page_table_lock}; std::lock_guard lock{page_table_lock};
MemoryState src_state{}; MemoryState src_state{};
if (const ResultCode result{CheckMemoryState( CASCADE_CODE(CheckMemoryState(
&src_state, nullptr, nullptr, src_addr, size, MemoryState::FlagCanAlias, &src_state, nullptr, nullptr, src_addr, size, MemoryState::FlagCanAlias,
MemoryState::FlagCanAlias, MemoryPermission::Mask, MemoryPermission::ReadAndWrite, MemoryState::FlagCanAlias, MemoryPermission::Mask, MemoryPermission::ReadAndWrite,
MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)}; MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
result.IsError()) {
return result;
}
if (IsRegionMapped(dst_addr, size)) { if (IsRegionMapped(dst_addr, size)) {
return ERR_INVALID_ADDRESS_STATE; return ERR_INVALID_ADDRESS_STATE;
@ -582,17 +541,9 @@ ResultCode PageTable::Map(VAddr dst_addr, VAddr src_addr, std::size_t size) {
OperationType::ChangePermissions); OperationType::ChangePermissions);
}); });
if (const ResultCode result{Operate(src_addr, num_pages, MemoryPermission::None, CASCADE_CODE(
OperationType::ChangePermissions)}; Operate(src_addr, num_pages, MemoryPermission::None, OperationType::ChangePermissions));
result.IsError()) { CASCADE_CODE(MapPages(dst_addr, page_linked_list, MemoryPermission::ReadAndWrite));
return result;
}
if (const ResultCode result{
MapPages(dst_addr, page_linked_list, MemoryPermission::ReadAndWrite)};
result.IsError()) {
return result;
}
block_guard.Cancel(); block_guard.Cancel();
} }
@ -608,22 +559,16 @@ ResultCode PageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
std::lock_guard lock{page_table_lock}; std::lock_guard lock{page_table_lock};
MemoryState src_state{}; MemoryState src_state{};
if (const ResultCode result{CheckMemoryState( CASCADE_CODE(CheckMemoryState(
&src_state, nullptr, nullptr, src_addr, size, MemoryState::FlagCanAlias, &src_state, nullptr, nullptr, src_addr, size, MemoryState::FlagCanAlias,
MemoryState::FlagCanAlias, MemoryPermission::Mask, MemoryPermission::None, MemoryState::FlagCanAlias, MemoryPermission::Mask, MemoryPermission::None,
MemoryAttribute::Mask, MemoryAttribute::Locked, MemoryAttribute::IpcAndDeviceMapped)}; MemoryAttribute::Mask, MemoryAttribute::Locked, MemoryAttribute::IpcAndDeviceMapped));
result.IsError()) {
return result;
}
MemoryPermission dst_perm{}; MemoryPermission dst_perm{};
if (const ResultCode result{CheckMemoryState( CASCADE_CODE(CheckMemoryState(nullptr, &dst_perm, nullptr, dst_addr, size, MemoryState::All,
nullptr, &dst_perm, nullptr, dst_addr, size, MemoryState::All, MemoryState::Stack, MemoryState::Stack, MemoryPermission::None,
MemoryPermission::None, MemoryPermission::None, MemoryAttribute::Mask, MemoryPermission::None, MemoryAttribute::Mask,
MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)}; MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
result.IsError()) {
return result;
}
PageLinkedList src_pages; PageLinkedList src_pages;
PageLinkedList dst_pages; PageLinkedList dst_pages;
@ -639,17 +584,9 @@ ResultCode PageTable::Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size) {
{ {
auto block_guard = detail::ScopeExit([&] { MapPages(dst_addr, dst_pages, dst_perm); }); auto block_guard = detail::ScopeExit([&] { MapPages(dst_addr, dst_pages, dst_perm); });
if (const ResultCode result{ CASCADE_CODE(Operate(dst_addr, num_pages, MemoryPermission::None, OperationType::Unmap));
Operate(dst_addr, num_pages, MemoryPermission::None, OperationType::Unmap)}; CASCADE_CODE(Operate(src_addr, num_pages, MemoryPermission::ReadAndWrite,
result.IsError()) { OperationType::ChangePermissions));
return result;
}
if (const ResultCode result{Operate(src_addr, num_pages, MemoryPermission::ReadAndWrite,
OperationType::ChangePermissions)};
result.IsError()) {
return result;
}
block_guard.Cancel(); block_guard.Cancel();
} }
@ -665,7 +602,7 @@ ResultCode PageTable::MapPages(VAddr addr, const PageLinkedList& page_linked_lis
VAddr cur_addr{addr}; VAddr cur_addr{addr};
for (const auto& node : page_linked_list.Nodes()) { for (const auto& node : page_linked_list.Nodes()) {
if (const ResultCode result{ if (const auto result{
Operate(cur_addr, node.GetNumPages(), perm, OperationType::Map, node.GetAddress())}; Operate(cur_addr, node.GetNumPages(), perm, OperationType::Map, node.GetAddress())};
result.IsError()) { result.IsError()) {
const MemoryInfo info{block_manager->FindBlock(cur_addr).GetMemoryInfo()}; const MemoryInfo info{block_manager->FindBlock(cur_addr).GetMemoryInfo()};
@ -698,9 +635,7 @@ ResultCode PageTable::MapPages(VAddr addr, PageLinkedList& page_linked_list, Mem
return ERR_INVALID_ADDRESS_STATE; return ERR_INVALID_ADDRESS_STATE;
} }
if (const ResultCode result{MapPages(addr, page_linked_list, perm)}; result.IsError()) { CASCADE_CODE(MapPages(addr, page_linked_list, perm));
return result;
}
block_manager->Update(addr, num_pages, state, perm); block_manager->Update(addr, num_pages, state, perm);
@ -714,13 +649,10 @@ ResultCode PageTable::SetCodeMemoryPermission(VAddr addr, std::size_t size, Memo
MemoryState prev_state{}; MemoryState prev_state{};
MemoryPermission prev_perm{}; MemoryPermission prev_perm{};
if (const ResultCode result{CheckMemoryState( CASCADE_CODE(CheckMemoryState(
&prev_state, &prev_perm, nullptr, addr, size, MemoryState::FlagCode, &prev_state, &prev_perm, nullptr, addr, size, MemoryState::FlagCode, MemoryState::FlagCode,
MemoryState::FlagCode, MemoryPermission::None, MemoryPermission::None, MemoryPermission::None, MemoryPermission::None, MemoryAttribute::Mask,
MemoryAttribute::Mask, MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)}; MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped));
result.IsError()) {
return result;
}
MemoryState state{prev_state}; MemoryState state{prev_state};
@ -745,9 +677,7 @@ ResultCode PageTable::SetCodeMemoryPermission(VAddr addr, std::size_t size, Memo
? OperationType::ChangePermissionsAndRefresh ? OperationType::ChangePermissionsAndRefresh
: OperationType::ChangePermissions}; : OperationType::ChangePermissions};
if (const ResultCode result{Operate(addr, num_pages, perm, operation)}; result.IsError()) { CASCADE_CODE(Operate(addr, num_pages, perm, operation));
return result;
}
block_manager->Update(addr, num_pages, state, perm); block_manager->Update(addr, num_pages, state, perm);
@ -775,15 +705,12 @@ ResultCode PageTable::ReserveTransferMemory(VAddr addr, std::size_t size, Memory
MemoryState state{}; MemoryState state{};
MemoryAttribute attribute{}; MemoryAttribute attribute{};
if (const ResultCode result{CheckMemoryState( CASCADE_CODE(CheckMemoryState(&state, nullptr, &attribute, addr, size,
&state, nullptr, &attribute, addr, size,
MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted, MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted, MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
MemoryPermission::Mask, MemoryPermission::ReadAndWrite, MemoryAttribute::Mask, MemoryPermission::Mask, MemoryPermission::ReadAndWrite,
MemoryAttribute::None, MemoryAttribute::IpcAndDeviceMapped)}; MemoryAttribute::Mask, MemoryAttribute::None,
result.IsError()) { MemoryAttribute::IpcAndDeviceMapped));
return result;
}
block_manager->Update(addr, size / PageSize, state, perm, attribute | MemoryAttribute::Locked); block_manager->Update(addr, size / PageSize, state, perm, attribute | MemoryAttribute::Locked);
@ -795,15 +722,12 @@ ResultCode PageTable::ResetTransferMemory(VAddr addr, std::size_t size) {
MemoryState state{}; MemoryState state{};
if (const ResultCode result{ CASCADE_CODE(CheckMemoryState(&state, nullptr, nullptr, addr, size,
CheckMemoryState(&state, nullptr, nullptr, addr, size,
MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted, MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted, MemoryState::FlagCanTransfer | MemoryState::FlagReferenceCounted,
MemoryPermission::None, MemoryPermission::None, MemoryAttribute::Mask, MemoryPermission::None, MemoryPermission::None,
MemoryAttribute::Locked, MemoryAttribute::IpcAndDeviceMapped)}; MemoryAttribute::Mask, MemoryAttribute::Locked,
result.IsError()) { MemoryAttribute::IpcAndDeviceMapped));
return result;
}
block_manager->Update(addr, size / PageSize, state, MemoryPermission::ReadAndWrite); block_manager->Update(addr, size / PageSize, state, MemoryPermission::ReadAndWrite);
@ -818,14 +742,11 @@ ResultCode PageTable::SetMemoryAttribute(VAddr addr, std::size_t size, MemoryAtt
MemoryPermission perm{}; MemoryPermission perm{};
MemoryAttribute attribute{}; MemoryAttribute attribute{};
if (const ResultCode result{CheckMemoryState( CASCADE_CODE(CheckMemoryState(&state, &perm, &attribute, addr, size,
&state, &perm, &attribute, addr, size, MemoryState::FlagCanChangeAttribute, MemoryState::FlagCanChangeAttribute,
MemoryState::FlagCanChangeAttribute, MemoryPermission::None, MemoryPermission::None, MemoryState::FlagCanChangeAttribute, MemoryPermission::None,
MemoryAttribute::LockedAndIpcLocked, MemoryAttribute::None, MemoryPermission::None, MemoryAttribute::LockedAndIpcLocked,
MemoryAttribute::DeviceSharedAndUncached)}; MemoryAttribute::None, MemoryAttribute::DeviceSharedAndUncached));
result.IsError()) {
return result;
}
attribute = attribute & ~mask; attribute = attribute & ~mask;
attribute = attribute | (mask & value); attribute = attribute | (mask & value);
@ -866,21 +787,15 @@ ResultVal<VAddr> PageTable::SetHeapSize(std::size_t size) {
PageLinkedList page_linked_list; PageLinkedList page_linked_list;
const std::size_t num_pages{delta / PageSize}; const std::size_t num_pages{delta / PageSize};
if (const ResultCode result{ CASCADE_CODE(
system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool)}; system.Kernel().MemoryManager().Allocate(page_linked_list, num_pages, memory_pool));
result.IsError()) {
return result;
}
if (IsRegionMapped(current_heap_addr, delta)) { if (IsRegionMapped(current_heap_addr, delta)) {
return ERR_INVALID_ADDRESS_STATE; return ERR_INVALID_ADDRESS_STATE;
} }
if (const ResultCode result{ CASCADE_CODE(
Operate(current_heap_addr, num_pages, page_linked_list, OperationType::MapGroup)}; Operate(current_heap_addr, num_pages, page_linked_list, OperationType::MapGroup));
result.IsError()) {
return result;
}
block_manager->Update(current_heap_addr, num_pages, MemoryState::Normal, block_manager->Update(current_heap_addr, num_pages, MemoryState::Normal,
MemoryPermission::ReadAndWrite); MemoryPermission::ReadAndWrite);
@ -912,23 +827,12 @@ ResultVal<VAddr> PageTable::AllocateAndMapMemory(std::size_t needed_num_pages, s
} }
if (is_map_only) { if (is_map_only) {
if (const ResultCode result{ CASCADE_CODE(Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr));
Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr)};
result.IsError()) {
return result;
}
} else { } else {
PageLinkedList page_group; PageLinkedList page_group;
if (const ResultCode result{system.Kernel().MemoryManager().Allocate( CASCADE_CODE(
page_group, needed_num_pages, memory_pool)}; system.Kernel().MemoryManager().Allocate(page_group, needed_num_pages, memory_pool));
result.IsError()) { CASCADE_CODE(Operate(addr, needed_num_pages, page_group, OperationType::MapGroup));
return result;
}
if (const ResultCode result{
Operate(addr, needed_num_pages, page_group, OperationType::MapGroup)};
result.IsError()) {
return result;
}
} }
block_manager->Update(addr, needed_num_pages, state, perm); block_manager->Update(addr, needed_num_pages, state, perm);
@ -1196,11 +1100,7 @@ ResultCode PageTable::CheckMemoryState(MemoryState* out_state, MemoryPermission*
} }
// Validate against the provided masks // Validate against the provided masks
if (const ResultCode result{ CASCADE_CODE(CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr));
CheckMemoryState(info, state_mask, state, perm_mask, perm, attr_mask, attr)};
result.IsError()) {
return result;
}
// Break once we're done // Break once we're done
if (last_addr <= info.GetLastAddress()) { if (last_addr <= info.GetLastAddress()) {

6
src/core/hle/kernel/memory/system_control.cpp
View file

@ -11,9 +11,9 @@
namespace Kernel::Memory::SystemControl { namespace Kernel::Memory::SystemControl {
u64 GenerateRandomU64ForInit() { u64 GenerateRandomU64ForInit() {
std::random_device device; static std::random_device device;
std::mt19937 gen(device()); static std::mt19937 gen(device());
std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max()); static std::uniform_int_distribution<u64> distribution(1, std::numeric_limits<u64>::max());
return distribution(gen); return distribution(gen);
} }

4
src/core/hle/kernel/shared_memory.cpp
View file

@ -40,14 +40,14 @@ ResultCode SharedMemory::Map(Process& target_process, VAddr address, std::size_t
const u64 page_count{(size + Memory::PageSize - 1) / Memory::PageSize}; const u64 page_count{(size + Memory::PageSize - 1) / Memory::PageSize};
if (page_list.GetNumPages() != page_count) { if (page_list.GetNumPages() != page_count) {
UNIMPLEMENTED(); UNIMPLEMENTED_MSG("Page count does not match");
} }
Memory::MemoryPermission expected = Memory::MemoryPermission expected =
&target_process == owner_process ? owner_permission : user_permission; &target_process == owner_process ? owner_permission : user_permission;
if (permission != expected) { if (permission != expected) {
UNIMPLEMENTED(); UNIMPLEMENTED_MSG("Permission does not match");
} }
return target_process.PageTable().MapPages(address, page_list, Memory::MemoryState::Shared, return target_process.PageTable().MapPages(address, page_list, Memory::MemoryState::Shared,

2
src/core/hle/kernel/shared_memory.h
View file

@ -28,7 +28,7 @@ public:
KernelCore& kernel, Core::DeviceMemory& device_memory, Process* owner_process, KernelCore& kernel, Core::DeviceMemory& device_memory, Process* owner_process,
Memory::PageLinkedList&& page_list, Memory::MemoryPermission owner_permission, Memory::PageLinkedList&& page_list, Memory::MemoryPermission owner_permission,
Memory::MemoryPermission user_permission, PAddr physical_address, std::size_t size, Memory::MemoryPermission user_permission, PAddr physical_address, std::size_t size,
std::string name = "Unknown"); std::string name);
std::string GetTypeName() const override { std::string GetTypeName() const override {
return "SharedMemory"; return "SharedMemory";

2
src/core/hle/kernel/svc.cpp
View file

@ -1196,7 +1196,7 @@ static ResultCode QueryProcessMemory(Core::System& system, VAddr memory_info_add
} }
auto& memory{system.Memory()}; auto& memory{system.Memory()};
const Svc::MemoryInfo memory_info{process->PageTable().QueryInfo(address).GetSvcMemoryInfo()}; const auto memory_info{process->PageTable().QueryInfo(address).GetSvcMemoryInfo()};
memory.Write64(memory_info_address + 0x00, memory_info.addr); memory.Write64(memory_info_address + 0x00, memory_info.addr);
memory.Write64(memory_info_address + 0x08, memory_info.size); memory.Write64(memory_info_address + 0x08, memory_info.size);

13
src/core/hle/service/ldr/ldr.cpp
View file

@ -298,9 +298,7 @@ public:
continue; continue;
} }
if (result.IsError()) { CASCADE_CODE(result);
return result;
}
if (ValidateRegionForMap(page_table, addr, size)) { if (ValidateRegionForMap(page_table, addr, size)) {
return MakeResult<VAddr>(addr); return MakeResult<VAddr>(addr);
@ -470,16 +468,15 @@ public:
} }
// Map memory for the NRO // Map memory for the NRO
const ResultVal<VAddr> map_result{MapNro(system.CurrentProcess(), nro_address, nro_size, const auto map_result{MapNro(system.CurrentProcess(), nro_address, nro_size, bss_address,
bss_address, bss_size, nro_size + bss_size)}; bss_size, nro_size + bss_size)};
if (map_result.Failed()) { if (map_result.Failed()) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(map_result.Code()); rb.Push(map_result.Code());
} }
// Load the NRO into the mapped memory // Load the NRO into the mapped memory
if (const ResultCode result{ if (const auto result{LoadNro(system.CurrentProcess(), header, nro_address, *map_result)};
LoadNro(system.CurrentProcess(), header, nro_address, *map_result)};
result.IsError()) { result.IsError()) {
IPC::ResponseBuilder rb{ctx, 2}; IPC::ResponseBuilder rb{ctx, 2};
rb.Push(map_result.Code()); rb.Push(map_result.Code());
@ -551,7 +548,7 @@ public:
return; return;
} }
const ResultCode result{UnmapNro(iter->second)}; const auto result{UnmapNro(iter->second)};
system.InvalidateCpuInstructionCaches(); system.InvalidateCpuInstructionCaches();