diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 175276354..1e9f0248b 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -418,7 +418,6 @@ add_library(core STATIC loader/smdh.h memory.cpp memory.h - memory_setup.h mmio.h movie.cpp movie.h diff --git a/src/core/core.cpp b/src/core/core.cpp index c5c56d11a..95fa69f43 100644 --- a/src/core/core.cpp +++ b/src/core/core.cpp @@ -25,7 +25,6 @@ #include "core/hle/service/sm/sm.h" #include "core/hw/hw.h" #include "core/loader/loader.h" -#include "core/memory_setup.h" #include "core/movie.h" #ifdef ENABLE_SCRIPTING #include "core/rpc/rpc_server.h" diff --git a/src/core/hle/kernel/memory.cpp b/src/core/hle/kernel/memory.cpp index c2d4d3053..16d497b7a 100644 --- a/src/core/hle/kernel/memory.cpp +++ b/src/core/hle/kernel/memory.cpp @@ -19,7 +19,6 @@ #include "core/hle/kernel/vm_manager.h" #include "core/hle/result.h" #include "core/memory.h" -#include "core/memory_setup.h" //////////////////////////////////////////////////////////////////////////////////////////////////// diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp index a3b8b0d9c..136a705fa 100644 --- a/src/core/hle/kernel/process.cpp +++ b/src/core/hle/kernel/process.cpp @@ -402,7 +402,7 @@ ResultCode Process::Unmap(VAddr target, VAddr source, u32 size, VMAPermission pe } Kernel::Process::Process(KernelSystem& kernel) - : Object(kernel), handle_table(kernel), kernel(kernel) {} + : Object(kernel), handle_table(kernel), kernel(kernel), vm_manager(kernel.memory) {} Kernel::Process::~Process() {} SharedPtr KernelSystem::GetProcessById(u32 process_id) const { diff --git a/src/core/hle/kernel/vm_manager.cpp b/src/core/hle/kernel/vm_manager.cpp index bf6d36cd7..c7cc36a3c 100644 --- a/src/core/hle/kernel/vm_manager.cpp +++ b/src/core/hle/kernel/vm_manager.cpp @@ -8,7 +8,6 @@ #include "core/hle/kernel/errors.h" #include "core/hle/kernel/vm_manager.h" #include "core/memory.h" -#include "core/memory_setup.h" #include "core/mmio.h" namespace Kernel { @@ -37,7 +36,7 @@ bool VirtualMemoryArea::CanBeMergedWith(const VirtualMemoryArea& next) const { return true; } -VMManager::VMManager() { +VMManager::VMManager(Memory::MemorySystem& memory) : memory(memory) { Reset(); } @@ -351,13 +350,13 @@ VMManager::VMAIter VMManager::MergeAdjacent(VMAIter iter) { void VMManager::UpdatePageTableForVMA(const VirtualMemoryArea& vma) { switch (vma.type) { case VMAType::Free: - Memory::UnmapRegion(page_table, vma.base, vma.size); + memory.UnmapRegion(page_table, vma.base, vma.size); break; case VMAType::BackingMemory: - Memory::MapMemoryRegion(page_table, vma.base, vma.size, vma.backing_memory); + memory.MapMemoryRegion(page_table, vma.base, vma.size, vma.backing_memory); break; case VMAType::MMIO: - Memory::MapIoRegion(page_table, vma.base, vma.size, vma.mmio_handler); + memory.MapIoRegion(page_table, vma.base, vma.size, vma.mmio_handler); break; } } diff --git a/src/core/hle/kernel/vm_manager.h b/src/core/hle/kernel/vm_manager.h index db48d7aed..fbd9bf09b 100644 --- a/src/core/hle/kernel/vm_manager.h +++ b/src/core/hle/kernel/vm_manager.h @@ -113,7 +113,7 @@ public: std::map vma_map; using VMAHandle = decltype(vma_map)::const_iterator; - VMManager(); + explicit VMManager(Memory::MemorySystem& memory); ~VMManager(); /// Clears the address space map, re-initializing with a single free area. @@ -227,5 +227,7 @@ private: /// Updates the pages corresponding to this VMA so they match the VMA's attributes. void UpdatePageTableForVMA(const VirtualMemoryArea& vma); + + Memory::MemorySystem& memory; }; } // namespace Kernel diff --git a/src/core/memory.cpp b/src/core/memory.cpp index 08d403d99..75667ad2a 100644 --- a/src/core/memory.cpp +++ b/src/core/memory.cpp @@ -15,7 +15,6 @@ #include "core/hle/kernel/process.h" #include "core/hle/lock.h" #include "core/memory.h" -#include "core/memory_setup.h" #include "video_core/renderer_base.h" #include "video_core/video_core.h" @@ -87,7 +86,7 @@ PageTable* MemorySystem::GetCurrentPageTable() const { return impl->current_page_table; } -static void MapPages(PageTable& page_table, u32 base, u32 size, u8* memory, PageType type) { +void MemorySystem::MapPages(PageTable& page_table, u32 base, u32 size, u8* memory, PageType type) { LOG_DEBUG(HW_Memory, "Mapping {} onto {:08X}-{:08X}", (void*)memory, base * PAGE_SIZE, (base + size) * PAGE_SIZE); @@ -107,13 +106,14 @@ static void MapPages(PageTable& page_table, u32 base, u32 size, u8* memory, Page } } -void MapMemoryRegion(PageTable& page_table, VAddr base, u32 size, u8* target) { +void MemorySystem::MapMemoryRegion(PageTable& page_table, VAddr base, u32 size, u8* target) { ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: {:08X}", size); ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: {:08X}", base); MapPages(page_table, base / PAGE_SIZE, size / PAGE_SIZE, target, PageType::Memory); } -void MapIoRegion(PageTable& page_table, VAddr base, u32 size, MMIORegionPointer mmio_handler) { +void MemorySystem::MapIoRegion(PageTable& page_table, VAddr base, u32 size, + MMIORegionPointer mmio_handler) { ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: {:08X}", size); ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: {:08X}", base); MapPages(page_table, base / PAGE_SIZE, size / PAGE_SIZE, nullptr, PageType::Special); @@ -121,7 +121,7 @@ void MapIoRegion(PageTable& page_table, VAddr base, u32 size, MMIORegionPointer page_table.special_regions.emplace_back(SpecialRegion{base, size, mmio_handler}); } -void UnmapRegion(PageTable& page_table, VAddr base, u32 size) { +void MemorySystem::UnmapRegion(PageTable& page_table, VAddr base, u32 size) { ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: {:08X}", size); ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: {:08X}", base); MapPages(page_table, base / PAGE_SIZE, size / PAGE_SIZE, nullptr, PageType::Unmapped); diff --git a/src/core/memory.h b/src/core/memory.h index b6f0fb619..586652b1c 100644 --- a/src/core/memory.h +++ b/src/core/memory.h @@ -214,6 +214,27 @@ public: MemorySystem(); ~MemorySystem(); + /** + * Maps an allocated buffer onto a region of the emulated process address space. + * + * @param page_table The page table of the emulated process. + * @param base The address to start mapping at. Must be page-aligned. + * @param size The amount of bytes to map. Must be page-aligned. + * @param target Buffer with the memory backing the mapping. Must be of length at least `size`. + */ + void MapMemoryRegion(PageTable& page_table, VAddr base, u32 size, u8* target); + + /** + * Maps a region of the emulated process address space as a IO region. + * @param page_table The page table of the emulated process. + * @param base The address to start mapping at. Must be page-aligned. + * @param size The amount of bytes to map. Must be page-aligned. + * @param mmio_handler The handler that backs the mapping. + */ + void MapIoRegion(PageTable& page_table, VAddr base, u32 size, MMIORegionPointer mmio_handler); + + void UnmapRegion(PageTable& page_table, VAddr base, u32 size); + /// Currently active page table void SetCurrentPageTable(PageTable* page_table); PageTable* GetCurrentPageTable() const; @@ -275,6 +296,8 @@ private: */ u8* GetPointerForRasterizerCache(VAddr addr); + void MapPages(PageTable& page_table, u32 base, u32 size, u8* memory, PageType type); + class Impl; std::unique_ptr impl; diff --git a/src/core/memory_setup.h b/src/core/memory_setup.h deleted file mode 100644 index 92d2abfdb..000000000 --- a/src/core/memory_setup.h +++ /dev/null @@ -1,32 +0,0 @@ -// Copyright 2015 Citra Emulator Project -// Licensed under GPLv2 or any later version -// Refer to the license.txt file included. - -#pragma once - -#include "common/common_types.h" -#include "core/mmio.h" - -namespace Memory { - -/** - * Maps an allocated buffer onto a region of the emulated process address space. - * - * @param page_table The page table of the emulated process. - * @param base The address to start mapping at. Must be page-aligned. - * @param size The amount of bytes to map. Must be page-aligned. - * @param target Buffer with the memory backing the mapping. Must be of length at least `size`. - */ -void MapMemoryRegion(PageTable& page_table, VAddr base, u32 size, u8* target); - -/** - * Maps a region of the emulated process address space as a IO region. - * @param page_table The page table of the emulated process. - * @param base The address to start mapping at. Must be page-aligned. - * @param size The amount of bytes to map. Must be page-aligned. - * @param mmio_handler The handler that backs the mapping. - */ -void MapIoRegion(PageTable& page_table, VAddr base, u32 size, MMIORegionPointer mmio_handler); - -void UnmapRegion(PageTable& page_table, VAddr base, u32 size); -} // namespace Memory diff --git a/src/tests/core/arm/arm_test_common.cpp b/src/tests/core/arm/arm_test_common.cpp index c316f8f36..ff8f5406a 100644 --- a/src/tests/core/arm/arm_test_common.cpp +++ b/src/tests/core/arm/arm_test_common.cpp @@ -6,7 +6,6 @@ #include "core/core_timing.h" #include "core/hle/kernel/process.h" #include "core/memory.h" -#include "core/memory_setup.h" #include "tests/core/arm/arm_test_common.h" namespace ArmTests { @@ -31,15 +30,16 @@ TestEnvironment::TestEnvironment(bool mutable_memory_) page_table->pointers.fill(nullptr); page_table->attributes.fill(Memory::PageType::Unmapped); - Memory::MapIoRegion(*page_table, 0x00000000, 0x80000000, test_memory); - Memory::MapIoRegion(*page_table, 0x80000000, 0x80000000, test_memory); + memory.MapIoRegion(*page_table, 0x00000000, 0x80000000, test_memory); + memory.MapIoRegion(*page_table, 0x80000000, 0x80000000, test_memory); memory.SetCurrentPageTable(page_table); } TestEnvironment::~TestEnvironment() { - Memory::UnmapRegion(*page_table, 0x80000000, 0x80000000); - Memory::UnmapRegion(*page_table, 0x00000000, 0x80000000); + Memory::MemorySystem& memory = *Core::System::GetInstance().memory; + memory.UnmapRegion(*page_table, 0x80000000, 0x80000000); + memory.UnmapRegion(*page_table, 0x00000000, 0x80000000); } void TestEnvironment::SetMemory64(VAddr vaddr, u64 value) { diff --git a/src/tests/core/memory/vm_manager.cpp b/src/tests/core/memory/vm_manager.cpp index 775a254a7..bd510864a 100644 --- a/src/tests/core/memory/vm_manager.cpp +++ b/src/tests/core/memory/vm_manager.cpp @@ -11,9 +11,10 @@ TEST_CASE("Memory Basics", "[kernel][memory]") { auto block = std::make_shared>(Memory::PAGE_SIZE); + Memory::MemorySystem memory; SECTION("mapping memory") { // Because of the PageTable, Kernel::VMManager is too big to be created on the stack. - auto manager = std::make_unique(); + auto manager = std::make_unique(memory); auto result = manager->MapBackingMemory(Memory::HEAP_VADDR, block->data(), block->size(), Kernel::MemoryState::Private); REQUIRE(result.Code() == RESULT_SUCCESS); @@ -28,7 +29,7 @@ TEST_CASE("Memory Basics", "[kernel][memory]") { SECTION("unmapping memory") { // Because of the PageTable, Kernel::VMManager is too big to be created on the stack. - auto manager = std::make_unique(); + auto manager = std::make_unique(memory); auto result = manager->MapBackingMemory(Memory::HEAP_VADDR, block->data(), block->size(), Kernel::MemoryState::Private); REQUIRE(result.Code() == RESULT_SUCCESS); @@ -44,7 +45,7 @@ TEST_CASE("Memory Basics", "[kernel][memory]") { SECTION("changing memory permissions") { // Because of the PageTable, Kernel::VMManager is too big to be created on the stack. - auto manager = std::make_unique(); + auto manager = std::make_unique(memory); auto result = manager->MapBackingMemory(Memory::HEAP_VADDR, block->data(), block->size(), Kernel::MemoryState::Private); REQUIRE(result.Code() == RESULT_SUCCESS); @@ -63,7 +64,7 @@ TEST_CASE("Memory Basics", "[kernel][memory]") { SECTION("changing memory state") { // Because of the PageTable, Kernel::VMManager is too big to be created on the stack. - auto manager = std::make_unique(); + auto manager = std::make_unique(memory); auto result = manager->MapBackingMemory(Memory::HEAP_VADDR, block->data(), block->size(), Kernel::MemoryState::Private); REQUIRE(result.Code() == RESULT_SUCCESS);