summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/core/core.cpp6
-rw-r--r--src/core/hle/kernel/process.cpp2
-rw-r--r--src/core/hle/kernel/thread.cpp17
-rw-r--r--src/core/hle/kernel/thread.h15
-rw-r--r--src/core/hle/svc.cpp5
-rw-r--r--src/core/loader/3dsx.cpp15
-rw-r--r--src/core/loader/3dsx.h2
-rw-r--r--src/core/loader/elf.cpp15
-rw-r--r--src/core/loader/elf.h2
-rw-r--r--src/core/loader/loader.h13
-rw-r--r--src/core/loader/ncch.cpp19
-rw-r--r--src/core/loader/ncch.h5
-rw-r--r--src/core/memory.cpp25
-rw-r--r--src/core/memory.h7
-rw-r--r--src/tests/CMakeLists.txt1
-rw-r--r--src/tests/core/arm/arm_test_common.cpp22
-rw-r--r--src/tests/core/memory/memory.cpp56
17 files changed, 157 insertions, 70 deletions
diff --git a/src/core/core.cpp b/src/core/core.cpp
index 59b8768e7..0c7a72987 100644
--- a/src/core/core.cpp
+++ b/src/core/core.cpp
@@ -13,6 +13,7 @@
#include "core/core_timing.h"
#include "core/gdbstub/gdbstub.h"
#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/process.h"
#include "core/hle/kernel/thread.h"
#include "core/hle/service/service.h"
#include "core/hw/hw.h"
@@ -100,7 +101,7 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
return init_result;
}
- const Loader::ResultStatus load_result{app_loader->Load()};
+ const Loader::ResultStatus load_result{app_loader->Load(Kernel::g_current_process)};
if (Loader::ResultStatus::Success != load_result) {
LOG_CRITICAL(Core, "Failed to load ROM (Error %i)!", load_result);
System::Shutdown();
@@ -114,6 +115,7 @@ System::ResultStatus System::Load(EmuWindow* emu_window, const std::string& file
return ResultStatus::ErrorLoader;
}
}
+ Memory::SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
status = ResultStatus::Success;
return status;
}
@@ -196,4 +198,4 @@ void System::Shutdown() {
LOG_DEBUG(Core, "Shutdown OK");
}
-} // namespace
+} // namespace Core
diff --git a/src/core/hle/kernel/process.cpp b/src/core/hle/kernel/process.cpp
index 522ad2333..cf3163e0f 100644
--- a/src/core/hle/kernel/process.cpp
+++ b/src/core/hle/kernel/process.cpp
@@ -147,7 +147,7 @@ void Process::Run(s32 main_thread_priority, u32 stack_size) {
}
vm_manager.LogLayout(Log::Level::Debug);
- Kernel::SetupMainThread(codeset->entrypoint, main_thread_priority);
+ Kernel::SetupMainThread(codeset->entrypoint, main_thread_priority, this);
}
VAddr Process::GetLinearHeapAreaAddress() const {
diff --git a/src/core/hle/kernel/thread.cpp b/src/core/hle/kernel/thread.cpp
index 61378211f..1033f8552 100644
--- a/src/core/hle/kernel/thread.cpp
+++ b/src/core/hle/kernel/thread.cpp
@@ -361,7 +361,8 @@ static void ResetThreadContext(ARM_Interface::ThreadContext& context, u32 stack_
}
ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point, u32 priority,
- u32 arg, s32 processor_id, VAddr stack_top) {
+ u32 arg, s32 processor_id, VAddr stack_top,
+ SharedPtr<Process> owner_process) {
// Check if priority is in ranged. Lowest priority -> highest priority id.
if (priority > THREADPRIO_LOWEST) {
LOG_ERROR(Kernel_SVC, "Invalid thread priority: %d", priority);
@@ -375,7 +376,7 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
// TODO(yuriks): Other checks, returning 0xD9001BEA
- if (!Memory::IsValidVirtualAddress(entry_point)) {
+ if (!Memory::IsValidVirtualAddress(*owner_process, entry_point)) {
LOG_ERROR(Kernel_SVC, "(name=%s): invalid entry %08x", name.c_str(), entry_point);
// TODO: Verify error
return ResultCode(ErrorDescription::InvalidAddress, ErrorModule::Kernel,
@@ -399,10 +400,10 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
thread->wait_address = 0;
thread->name = std::move(name);
thread->callback_handle = wakeup_callback_handle_table.Create(thread).Unwrap();
- thread->owner_process = g_current_process;
+ thread->owner_process = owner_process;
// Find the next available TLS index, and mark it as used
- auto& tls_slots = Kernel::g_current_process->tls_slots;
+ auto& tls_slots = owner_process->tls_slots;
bool needs_allocation = true;
u32 available_page; // Which allocated page has free space
u32 available_slot; // Which slot within the page is free
@@ -426,13 +427,13 @@ ResultVal<SharedPtr<Thread>> Thread::Create(std::string name, VAddr entry_point,
// Allocate some memory from the end of the linear heap for this region.
linheap_memory->insert(linheap_memory->end(), Memory::PAGE_SIZE, 0);
memory_region->used += Memory::PAGE_SIZE;
- Kernel::g_current_process->linear_heap_used += Memory::PAGE_SIZE;
+ owner_process->linear_heap_used += Memory::PAGE_SIZE;
tls_slots.emplace_back(0); // The page is completely available at the start
available_page = tls_slots.size() - 1;
available_slot = 0; // Use the first slot in the new page
- auto& vm_manager = Kernel::g_current_process->vm_manager;
+ auto& vm_manager = owner_process->vm_manager;
vm_manager.RefreshMemoryBlockMappings(linheap_memory.get());
// Map the page to the current process' address space.
@@ -486,10 +487,10 @@ void Thread::BoostPriority(s32 priority) {
current_priority = priority;
}
-SharedPtr<Thread> SetupMainThread(u32 entry_point, s32 priority) {
+SharedPtr<Thread> SetupMainThread(u32 entry_point, s32 priority, SharedPtr<Process> owner_process) {
// Initialize new "main" thread
auto thread_res = Thread::Create("main", entry_point, priority, 0, THREADPROCESSORID_0,
- Memory::HEAP_VADDR_END);
+ Memory::HEAP_VADDR_END, owner_process);
SharedPtr<Thread> thread = std::move(thread_res).Unwrap();
diff --git a/src/core/hle/kernel/thread.h b/src/core/hle/kernel/thread.h
index 6a3566f15..ddc0d15c5 100644
--- a/src/core/hle/kernel/thread.h
+++ b/src/core/hle/kernel/thread.h
@@ -56,10 +56,12 @@ public:
* @param arg User data to pass to the thread
* @param processor_id The ID(s) of the processors on which the thread is desired to be run
* @param stack_top The address of the thread's stack top
+ * @param owner_process The parent process for the thread
* @return A shared pointer to the newly created thread
*/
static ResultVal<SharedPtr<Thread>> Create(std::string name, VAddr entry_point, u32 priority,
- u32 arg, s32 processor_id, VAddr stack_top);
+ u32 arg, s32 processor_id, VAddr stack_top,
+ SharedPtr<Process> owner_process);
std::string GetName() const override {
return name;
@@ -116,9 +118,9 @@ public:
void ResumeFromWait();
/**
- * Schedules an event to wake up the specified thread after the specified delay
- * @param nanoseconds The time this thread will be allowed to sleep for
- */
+ * Schedules an event to wake up the specified thread after the specified delay
+ * @param nanoseconds The time this thread will be allowed to sleep for
+ */
void WakeAfterDelay(s64 nanoseconds);
/**
@@ -214,9 +216,10 @@ private:
* Sets up the primary application thread
* @param entry_point The address at which the thread should start execution
* @param priority The priority to give the main thread
+ * @param owner_process The parent process for the main thread
* @return A shared pointer to the main thread
*/
-SharedPtr<Thread> SetupMainThread(u32 entry_point, s32 priority);
+SharedPtr<Thread> SetupMainThread(u32 entry_point, s32 priority, SharedPtr<Process> owner_process);
/**
* Returns whether there are any threads that are ready to run.
@@ -276,4 +279,4 @@ void ThreadingShutdown();
*/
const std::vector<SharedPtr<Thread>>& GetThreadList();
-} // namespace
+} // namespace Kernel
diff --git a/src/core/hle/svc.cpp b/src/core/hle/svc.cpp
index dfc36748c..05c6897bf 100644
--- a/src/core/hle/svc.cpp
+++ b/src/core/hle/svc.cpp
@@ -656,8 +656,9 @@ static ResultCode CreateThread(Kernel::Handle* out_handle, u32 priority, u32 ent
"Newly created thread must run in the SysCore (Core1), unimplemented.");
}
- CASCADE_RESULT(SharedPtr<Thread> thread, Kernel::Thread::Create(name, entry_point, priority,
- arg, processor_id, stack_top));
+ CASCADE_RESULT(SharedPtr<Thread> thread,
+ Kernel::Thread::Create(name, entry_point, priority, arg, processor_id, stack_top,
+ Kernel::g_current_process));
thread->context.fpscr =
FPSCR_DEFAULT_NAN | FPSCR_FLUSH_TO_ZERO | FPSCR_ROUND_TOZERO; // 0x03C00000
diff --git a/src/core/loader/3dsx.cpp b/src/core/loader/3dsx.cpp
index 5ad5c5287..918038f1e 100644
--- a/src/core/loader/3dsx.cpp
+++ b/src/core/loader/3dsx.cpp
@@ -91,8 +91,8 @@ static u32 TranslateAddr(u32 addr, const THREEloadinfo* loadinfo, u32* offsets)
return loadinfo->seg_addrs[2] + addr - offsets[1];
}
-using Kernel::SharedPtr;
using Kernel::CodeSet;
+using Kernel::SharedPtr;
static THREEDSX_Error Load3DSXFile(FileUtil::IOFile& file, u32 base_addr,
SharedPtr<CodeSet>* out_codeset) {
@@ -255,7 +255,7 @@ FileType AppLoader_THREEDSX::IdentifyType(FileUtil::IOFile& file) {
return FileType::Error;
}
-ResultStatus AppLoader_THREEDSX::Load() {
+ResultStatus AppLoader_THREEDSX::Load(Kernel::SharedPtr<Kernel::Process>& process) {
if (is_loaded)
return ResultStatus::ErrorAlreadyLoaded;
@@ -267,16 +267,15 @@ ResultStatus AppLoader_THREEDSX::Load() {
return ResultStatus::Error;
codeset->name = filename;
- Kernel::g_current_process = Kernel::Process::Create(std::move(codeset));
- Kernel::g_current_process->svc_access_mask.set();
- Kernel::g_current_process->address_mappings = default_address_mappings;
- Memory::SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
+ process = Kernel::Process::Create(std::move(codeset));
+ process->svc_access_mask.set();
+ process->address_mappings = default_address_mappings;
// Attach the default resource limit (APPLICATION) to the process
- Kernel::g_current_process->resource_limit =
+ process->resource_limit =
Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
- Kernel::g_current_process->Run(48, Kernel::DEFAULT_STACK_SIZE);
+ process->Run(48, Kernel::DEFAULT_STACK_SIZE);
Service::FS::RegisterSelfNCCH(*this);
diff --git a/src/core/loader/3dsx.h b/src/core/loader/3dsx.h
index 3f376778a..1e59bbb9d 100644
--- a/src/core/loader/3dsx.h
+++ b/src/core/loader/3dsx.h
@@ -31,7 +31,7 @@ public:
return IdentifyType(file);
}
- ResultStatus Load() override;
+ ResultStatus Load(Kernel::SharedPtr<Kernel::Process>& process) override;
ResultStatus ReadIcon(std::vector<u8>& buffer) override;
diff --git a/src/core/loader/elf.cpp b/src/core/loader/elf.cpp
index 2de1f4e81..e36e42120 100644
--- a/src/core/loader/elf.cpp
+++ b/src/core/loader/elf.cpp
@@ -13,8 +13,8 @@
#include "core/loader/elf.h"
#include "core/memory.h"
-using Kernel::SharedPtr;
using Kernel::CodeSet;
+using Kernel::SharedPtr;
////////////////////////////////////////////////////////////////////////////////////////////////////
// ELF Header Constants
@@ -375,7 +375,7 @@ FileType AppLoader_ELF::IdentifyType(FileUtil::IOFile& file) {
return FileType::Error;
}
-ResultStatus AppLoader_ELF::Load() {
+ResultStatus AppLoader_ELF::Load(Kernel::SharedPtr<Kernel::Process>& process) {
if (is_loaded)
return ResultStatus::ErrorAlreadyLoaded;
@@ -394,16 +394,15 @@ ResultStatus AppLoader_ELF::Load() {
SharedPtr<CodeSet> codeset = elf_reader.LoadInto(Memory::PROCESS_IMAGE_VADDR);
codeset->name = filename;
- Kernel::g_current_process = Kernel::Process::Create(std::move(codeset));
- Kernel::g_current_process->svc_access_mask.set();
- Kernel::g_current_process->address_mappings = default_address_mappings;
- Memory::SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
+ process = Kernel::Process::Create(std::move(codeset));
+ process->svc_access_mask.set();
+ process->address_mappings = default_address_mappings;
// Attach the default resource limit (APPLICATION) to the process
- Kernel::g_current_process->resource_limit =
+ process->resource_limit =
Kernel::ResourceLimit::GetForCategory(Kernel::ResourceLimitCategory::APPLICATION);
- Kernel::g_current_process->Run(48, Kernel::DEFAULT_STACK_SIZE);
+ process->Run(48, Kernel::DEFAULT_STACK_SIZE);
is_loaded = true;
return ResultStatus::Success;
diff --git a/src/core/loader/elf.h b/src/core/loader/elf.h
index 862aa90d8..113da5917 100644
--- a/src/core/loader/elf.h
+++ b/src/core/loader/elf.h
@@ -30,7 +30,7 @@ public:
return IdentifyType(file);
}
- ResultStatus Load() override;
+ ResultStatus Load(Kernel::SharedPtr<Kernel::Process>& process) override;
private:
std::string filename;
diff --git a/src/core/loader/loader.h b/src/core/loader/loader.h
index 3160fd2fd..82b2be6a3 100644
--- a/src/core/loader/loader.h
+++ b/src/core/loader/loader.h
@@ -13,10 +13,12 @@
#include <boost/optional.hpp>
#include "common/common_types.h"
#include "common/file_util.h"
+#include "core/hle/kernel/kernel.h"
namespace Kernel {
struct AddressMapping;
-}
+class Process;
+} // namespace Kernel
////////////////////////////////////////////////////////////////////////////////////////////////////
// Loader namespace
@@ -92,10 +94,11 @@ public:
virtual FileType GetFileType() = 0;
/**
- * Load the application
- * @return ResultStatus result of function
+ * Load the application and return the created Process instance
+ * @param process The newly created process.
+ * @return The status result of the operation.
*/
- virtual ResultStatus Load() = 0;
+ virtual ResultStatus Load(Kernel::SharedPtr<Kernel::Process>& process) = 0;
/**
* Loads the system mode that this application needs.
@@ -206,4 +209,4 @@ extern const std::initializer_list<Kernel::AddressMapping> default_address_mappi
*/
std::unique_ptr<AppLoader> GetLoader(const std::string& filename);
-} // namespace
+} // namespace Loader
diff --git a/src/core/loader/ncch.cpp b/src/core/loader/ncch.cpp
index 5107135f9..66bc5823d 100644
--- a/src/core/loader/ncch.cpp
+++ b/src/core/loader/ncch.cpp
@@ -67,9 +67,9 @@ std::pair<boost::optional<u32>, ResultStatus> AppLoader_NCCH::LoadKernelSystemMo
ResultStatus::Success);
}
-ResultStatus AppLoader_NCCH::LoadExec() {
- using Kernel::SharedPtr;
+ResultStatus AppLoader_NCCH::LoadExec(Kernel::SharedPtr<Kernel::Process>& process) {
using Kernel::CodeSet;
+ using Kernel::SharedPtr;
if (!is_loaded)
return ResultStatus::ErrorNotLoaded;
@@ -107,16 +107,15 @@ ResultStatus AppLoader_NCCH::LoadExec() {
codeset->entrypoint = codeset->code.addr;
codeset->memory = std::make_shared<std::vector<u8>>(std::move(code));
- Kernel::g_current_process = Kernel::Process::Create(std::move(codeset));
- Memory::SetCurrentPageTable(&Kernel::g_current_process->vm_manager.page_table);
+ process = Kernel::Process::Create(std::move(codeset));
// Attach a resource limit to the process based on the resource limit category
- Kernel::g_current_process->resource_limit =
+ process->resource_limit =
Kernel::ResourceLimit::GetForCategory(static_cast<Kernel::ResourceLimitCategory>(
overlay_ncch->exheader_header.arm11_system_local_caps.resource_limit_category));
// Set the default CPU core for this process
- Kernel::g_current_process->ideal_processor =
+ process->ideal_processor =
overlay_ncch->exheader_header.arm11_system_local_caps.ideal_processor;
// Copy data while converting endianness
@@ -124,11 +123,11 @@ ResultStatus AppLoader_NCCH::LoadExec() {
kernel_caps;
std::copy_n(overlay_ncch->exheader_header.arm11_kernel_caps.descriptors, kernel_caps.size(),
begin(kernel_caps));
- Kernel::g_current_process->ParseKernelCaps(kernel_caps.data(), kernel_caps.size());
+ process->ParseKernelCaps(kernel_caps.data(), kernel_caps.size());
s32 priority = overlay_ncch->exheader_header.arm11_system_local_caps.priority;
u32 stack_size = overlay_ncch->exheader_header.codeset_info.stack_size;
- Kernel::g_current_process->Run(priority, stack_size);
+ process->Run(priority, stack_size);
return ResultStatus::Success;
}
return ResultStatus::Error;
@@ -151,7 +150,7 @@ void AppLoader_NCCH::ParseRegionLockoutInfo() {
}
}
-ResultStatus AppLoader_NCCH::Load() {
+ResultStatus AppLoader_NCCH::Load(Kernel::SharedPtr<Kernel::Process>& process) {
u64_le ncch_program_id;
if (is_loaded)
@@ -183,7 +182,7 @@ ResultStatus AppLoader_NCCH::Load() {
is_loaded = true; // Set state to loaded
- result = LoadExec(); // Load the executable into memory for booting
+ result = LoadExec(process); // Load the executable into memory for booting
if (ResultStatus::Success != result)
return result;
diff --git a/src/core/loader/ncch.h b/src/core/loader/ncch.h
index 9b56465cb..09230ae33 100644
--- a/src/core/loader/ncch.h
+++ b/src/core/loader/ncch.h
@@ -33,7 +33,7 @@ public:
return IdentifyType(file);
}
- ResultStatus Load() override;
+ ResultStatus Load(Kernel::SharedPtr<Kernel::Process>& process) override;
/**
* Loads the Exheader and returns the system mode for this application.
@@ -62,9 +62,10 @@ public:
private:
/**
* Loads .code section into memory for booting
+ * @param process The newly created process
* @return ResultStatus result of function
*/
- ResultStatus LoadExec();
+ ResultStatus LoadExec(Kernel::SharedPtr<Kernel::Process>& process);
/// Reads the region lockout info in the SMDH and send it to CFG service
void ParseRegionLockoutInfo();
diff --git a/src/core/memory.cpp b/src/core/memory.cpp
index 9b394f84b..5ea0694a9 100644
--- a/src/core/memory.cpp
+++ b/src/core/memory.cpp
@@ -110,8 +110,8 @@ static u8* GetPointerFromVMA(VAddr vaddr) {
/**
* This function should only be called for virtual addreses with attribute `PageType::Special`.
*/
-static MMIORegionPointer GetMMIOHandler(VAddr vaddr) {
- for (const auto& region : current_page_table->special_regions) {
+static MMIORegionPointer GetMMIOHandler(const PageTable& page_table, VAddr vaddr) {
+ for (const auto& region : page_table.special_regions) {
if (vaddr >= region.base && vaddr < (region.base + region.size)) {
return region.handler;
}
@@ -120,6 +120,11 @@ static MMIORegionPointer GetMMIOHandler(VAddr vaddr) {
return nullptr; // Should never happen
}
+static MMIORegionPointer GetMMIOHandler(VAddr vaddr) {
+ const PageTable& page_table = Kernel::g_current_process->vm_manager.page_table;
+ return GetMMIOHandler(page_table, vaddr);
+}
+
template <typename T>
T ReadMMIO(MMIORegionPointer mmio_handler, VAddr addr);
@@ -204,18 +209,20 @@ void Write(const VAddr vaddr, const T data) {
}
}
-bool IsValidVirtualAddress(const VAddr vaddr) {
- const u8* page_pointer = current_page_table->pointers[vaddr >> PAGE_BITS];
+bool IsValidVirtualAddress(const Kernel::Process& process, const VAddr vaddr) {
+ auto& page_table = process.vm_manager.page_table;
+
+ const u8* page_pointer = page_table.pointers[vaddr >> PAGE_BITS];
if (page_pointer)
return true;
- if (current_page_table->attributes[vaddr >> PAGE_BITS] == PageType::RasterizerCachedMemory)
+ if (page_table.attributes[vaddr >> PAGE_BITS] == PageType::RasterizerCachedMemory)
return true;
- if (current_page_table->attributes[vaddr >> PAGE_BITS] != PageType::Special)
+ if (page_table.attributes[vaddr >> PAGE_BITS] != PageType::Special)
return false;
- MMIORegionPointer mmio_region = GetMMIOHandler(vaddr);
+ MMIORegionPointer mmio_region = GetMMIOHandler(page_table, vaddr);
if (mmio_region) {
return mmio_region->IsValidAddress(vaddr);
}
@@ -223,6 +230,10 @@ bool IsValidVirtualAddress(const VAddr vaddr) {
return false;
}
+bool IsValidVirtualAddress(const VAddr vaddr) {
+ return IsValidVirtualAddress(*Kernel::g_current_process, vaddr);
+}
+
bool IsValidPhysicalAddress(const PAddr paddr) {
return GetPhysicalPointer(paddr) != nullptr;
}
diff --git a/src/core/memory.h b/src/core/memory.h
index 1865bfea0..347c08c78 100644
--- a/src/core/memory.h
+++ b/src/core/memory.h
@@ -12,6 +12,10 @@
#include "common/common_types.h"
#include "core/mmio.h"
+namespace Kernel {
+class Process;
+}
+
namespace Memory {
/**
@@ -185,7 +189,10 @@ enum : VAddr {
void SetCurrentPageTable(PageTable* page_table);
PageTable* GetCurrentPageTable();
+/// Determines if the given VAddr is valid for the specified process.
+bool IsValidVirtualAddress(const Kernel::Process& process, const VAddr vaddr);
bool IsValidVirtualAddress(const VAddr addr);
+
bool IsValidPhysicalAddress(const PAddr addr);
u8 Read8(VAddr addr);
diff --git a/src/tests/CMakeLists.txt b/src/tests/CMakeLists.txt
index 5e9c4c2bf..1aac0daa2 100644
--- a/src/tests/CMakeLists.txt
+++ b/src/tests/CMakeLists.txt
@@ -4,6 +4,7 @@ set(SRCS
core/arm/dyncom/arm_dyncom_vfp_tests.cpp
core/file_sys/path_parser.cpp
core/hle/kernel/hle_ipc.cpp
+ core/memory/memory.cpp
glad.cpp
tests.cpp
)
diff --git a/src/tests/core/arm/arm_test_common.cpp b/src/tests/core/arm/arm_test_common.cpp
index cfe0d503a..484713a92 100644
--- a/src/tests/core/arm/arm_test_common.cpp
+++ b/src/tests/core/arm/arm_test_common.cpp
@@ -3,30 +3,34 @@
// Refer to the license.txt file included.
#include "core/core.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 {
-static Memory::PageTable page_table;
+static Memory::PageTable* page_table = nullptr;
TestEnvironment::TestEnvironment(bool mutable_memory_)
: mutable_memory(mutable_memory_), test_memory(std::make_shared<TestMemory>(this)) {
- page_table.pointers.fill(nullptr);
- page_table.attributes.fill(Memory::PageType::Unmapped);
- page_table.cached_res_count.fill(0);
+ Kernel::g_current_process = Kernel::Process::Create(Kernel::CodeSet::Create("", 0));
+ page_table = &Kernel::g_current_process->vm_manager.page_table;
- Memory::MapIoRegion(page_table, 0x00000000, 0x80000000, test_memory);
- Memory::MapIoRegion(page_table, 0x80000000, 0x80000000, test_memory);
+ page_table->pointers.fill(nullptr);
+ page_table->attributes.fill(Memory::PageType::Unmapped);
+ page_table->cached_res_count.fill(0);
- Memory::SetCurrentPageTable(&page_table);
+ 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::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/memory.cpp b/src/tests/core/memory/memory.cpp
new file mode 100644
index 000000000..a01b896f7
--- /dev/null
+++ b/src/tests/core/memory/memory.cpp
@@ -0,0 +1,56 @@
+// Copyright 2017 Citra Emulator Project
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <catch.hpp>
+#include "core/hle/kernel/memory.h"
+#include "core/hle/kernel/process.h"
+#include "core/memory.h"
+
+TEST_CASE("Memory::IsValidVirtualAddress", "[core][memory]") {
+ SECTION("these regions should not be mapped on an empty process") {
+ auto process = Kernel::Process::Create(Kernel::CodeSet::Create("", 0));
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::PROCESS_IMAGE_VADDR) == false);
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::HEAP_VADDR) == false);
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::LINEAR_HEAP_VADDR) == false);
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::VRAM_VADDR) == false);
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::CONFIG_MEMORY_VADDR) == false);
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::SHARED_PAGE_VADDR) == false);
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::TLS_AREA_VADDR) == false);
+ }
+
+ SECTION("CONFIG_MEMORY_VADDR and SHARED_PAGE_VADDR should be valid after mapping them") {
+ auto process = Kernel::Process::Create(Kernel::CodeSet::Create("", 0));
+ Kernel::MapSharedPages(process->vm_manager);
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::CONFIG_MEMORY_VADDR) == true);
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::SHARED_PAGE_VADDR) == true);
+ }
+
+ SECTION("special regions should be valid after mapping them") {
+ auto process = Kernel::Process::Create(Kernel::CodeSet::Create("", 0));
+ SECTION("VRAM") {
+ Kernel::HandleSpecialMapping(process->vm_manager,
+ {Memory::VRAM_VADDR, Memory::VRAM_SIZE, false, false});
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::VRAM_VADDR) == true);
+ }
+
+ SECTION("IO (Not yet implemented)") {
+ Kernel::HandleSpecialMapping(
+ process->vm_manager, {Memory::IO_AREA_VADDR, Memory::IO_AREA_SIZE, false, false});
+ CHECK_FALSE(Memory::IsValidVirtualAddress(*process, Memory::IO_AREA_VADDR) == true);
+ }
+
+ SECTION("DSP") {
+ Kernel::HandleSpecialMapping(
+ process->vm_manager, {Memory::DSP_RAM_VADDR, Memory::DSP_RAM_SIZE, false, false});
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::DSP_RAM_VADDR) == true);
+ }
+ }
+
+ SECTION("Unmapping a VAddr should make it invalid") {
+ auto process = Kernel::Process::Create(Kernel::CodeSet::Create("", 0));
+ Kernel::MapSharedPages(process->vm_manager);
+ process->vm_manager.UnmapRange(Memory::CONFIG_MEMORY_VADDR, Memory::CONFIG_MEMORY_SIZE);
+ CHECK(Memory::IsValidVirtualAddress(*process, Memory::CONFIG_MEMORY_VADDR) == false);
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-11-04 10:52:27 +0000