VERY experimental Nintendo Switch 2 emulator
C++
core: hle: kernel: k_process: Improve management of page table & cleanup.
bunnei55ed04af3498
diff --git a/src/core/hle/kernel/k_page_table.cpp b/src/core/hle/kernel/k_page_table.cppindex fcffc0b88d..22098c056e 100644--- a/src/core/hle/kernel/k_page_table.cpp+++ b/src/core/hle/kernel/k_page_table.cpp@@ -256,16 +256,21 @@ Result KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_typem_mapped_physical_memory_size = 0;m_memory_pool = pool;- m_page_table_impl.Resize(m_address_space_width, PageBits);+ m_page_table_impl = std::make_unique<Common::PageTable>();+ m_page_table_impl->Resize(m_address_space_width, PageBits);return m_memory_block_manager.Initialize(m_address_space_start, m_address_space_end,m_memory_block_slab_manager);}void KPageTable::Finalize() {+ // Finalize memory blocks.m_memory_block_manager.Finalize(m_memory_block_slab_manager, [&](VAddr addr, u64 size) {- m_system.Memory().UnmapRegion(m_page_table_impl, addr, size);+ m_system.Memory().UnmapRegion(*m_page_table_impl, addr, size);});++ // Close the backing page table, as the destructor is not called for guest objects.+ m_page_table_impl.reset();}Result KPageTable::MapProcessCode(VAddr addr, size_t num_pages, KMemoryState state,@@ -514,7 +519,7 @@ Result KPageTable::MakePageGroup(KPageGroup& pg, VAddr addr, size_t num_pages) {// Begin traversal.Common::PageTable::TraversalContext context;Common::PageTable::TraversalEntry next_entry;- R_UNLESS(m_page_table_impl.BeginTraversal(next_entry, context, addr),+ R_UNLESS(m_page_table_impl->BeginTraversal(next_entry, context, addr),ResultInvalidCurrentMemory);// Prepare tracking variables.@@ -525,7 +530,7 @@ Result KPageTable::MakePageGroup(KPageGroup& pg, VAddr addr, size_t num_pages) {// Iterate, adding to group as we go.const auto& memory_layout = m_system.Kernel().MemoryLayout();while (tot_size < size) {- R_UNLESS(m_page_table_impl.ContinueTraversal(next_entry, context),+ R_UNLESS(m_page_table_impl->ContinueTraversal(next_entry, context),ResultInvalidCurrentMemory);if (next_entry.phys_addr != (cur_addr + cur_size)) {@@ -588,7 +593,7 @@ bool KPageTable::IsValidPageGroup(const KPageGroup& pg_ll, VAddr addr, size_t nu// Begin traversal.Common::PageTable::TraversalContext context;Common::PageTable::TraversalEntry next_entry;- if (!m_page_table_impl.BeginTraversal(next_entry, context, addr)) {+ if (!m_page_table_impl->BeginTraversal(next_entry, context, addr)) {return false;}@@ -599,7 +604,7 @@ bool KPageTable::IsValidPageGroup(const KPageGroup& pg_ll, VAddr addr, size_t nu// Iterate, comparing expected to actual.while (tot_size < size) {- if (!m_page_table_impl.ContinueTraversal(next_entry, context)) {+ if (!m_page_table_impl->ContinueTraversal(next_entry, context)) {return false;}@@ -2042,7 +2047,7 @@ Result KPageTable::Operate(VAddr addr, size_t num_pages, const KPageGroup& page_switch (operation) {case OperationType::MapGroup:- m_system.Memory().MapMemoryRegion(m_page_table_impl, addr, size, node.GetAddress());+ m_system.Memory().MapMemoryRegion(*m_page_table_impl, addr, size, node.GetAddress());break;default:ASSERT(false);@@ -2064,12 +2069,12 @@ Result KPageTable::Operate(VAddr addr, size_t num_pages, KMemoryPermission perm,switch (operation) {case OperationType::Unmap:- m_system.Memory().UnmapRegion(m_page_table_impl, addr, num_pages * PageSize);+ m_system.Memory().UnmapRegion(*m_page_table_impl, addr, num_pages * PageSize);break;case OperationType::Map: {ASSERT(map_addr);ASSERT(Common::IsAligned(map_addr, PageSize));- m_system.Memory().MapMemoryRegion(m_page_table_impl, addr, num_pages * PageSize, map_addr);+ m_system.Memory().MapMemoryRegion(*m_page_table_impl, addr, num_pages * PageSize, map_addr);break;}case OperationType::ChangePermissions:diff --git a/src/core/hle/kernel/k_page_table.h b/src/core/hle/kernel/k_page_table.hindex 2258543197..1811d3e2d2 100644--- a/src/core/hle/kernel/k_page_table.h+++ b/src/core/hle/kernel/k_page_table.h@@ -88,11 +88,11 @@ public:KMemoryAttribute attr_mask, KMemoryAttribute attr);Common::PageTable& PageTableImpl() {- return m_page_table_impl;+ return *m_page_table_impl;}const Common::PageTable& PageTableImpl() const {- return m_page_table_impl;+ return *m_page_table_impl;}bool CanContain(VAddr addr, size_t size, KMemoryState state) const;@@ -303,7 +303,7 @@ public:return IsKernel() ? 1 : 4;}PAddr GetPhysicalAddr(VAddr addr) const {- const auto backing_addr = m_page_table_impl.backing_addr[addr >> PageBits];+ const auto backing_addr = m_page_table_impl->backing_addr[addr >> PageBits];ASSERT(backing_addr);return backing_addr + addr;}@@ -365,7 +365,7 @@ private:KMemoryManager::Pool m_memory_pool{KMemoryManager::Pool::Application};KMemoryManager::Direction m_allocation_option{KMemoryManager::Direction::FromFront};- Common::PageTable m_page_table_impl;+ std::unique_ptr<Common::PageTable> m_page_table_impl;Core::System& m_system;};diff --git a/src/core/hle/kernel/k_process.cpp b/src/core/hle/kernel/k_process.cppindex abc2115bd9..1a0aec56a7 100644--- a/src/core/hle/kernel/k_process.cpp+++ b/src/core/hle/kernel/k_process.cpp@@ -72,6 +72,7 @@ Result KProcess::Initialize(KProcess* process, Core::System& system, std::stringprocess->name = std::move(process_name);process->resource_limit = res_limit;+ process->system_resource_address = 0;process->state = State::Created;process->program_id = 0;process->process_id = type == ProcessType::KernelInternal ? kernel.CreateNewKernelProcessID()@@ -92,6 +93,7 @@ Result KProcess::Initialize(KProcess* process, Core::System& system, std::stringprocess->exception_thread = nullptr;process->is_suspended = false;process->schedule_count = 0;+ process->is_handle_table_initialized = false;// Open a reference to the resource limit.process->resource_limit->Open();@@ -121,9 +123,9 @@ void KProcess::DecrementRunningThreadCount() {}}-u64 KProcess::GetTotalPhysicalMemoryAvailable() const {+u64 KProcess::GetTotalPhysicalMemoryAvailable() {const u64 capacity{resource_limit->GetFreeValue(LimitableResource::PhysicalMemory) +- page_table->GetNormalMemorySize() + GetSystemResourceSize() + image_size ++ page_table.GetNormalMemorySize() + GetSystemResourceSize() + image_size +main_thread_stack_size};if (const auto pool_size = kernel.MemoryManager().GetSize(KMemoryManager::Pool::Application);capacity != pool_size) {@@ -135,16 +137,16 @@ u64 KProcess::GetTotalPhysicalMemoryAvailable() const {return memory_usage_capacity;}-u64 KProcess::GetTotalPhysicalMemoryAvailableWithoutSystemResource() const {+u64 KProcess::GetTotalPhysicalMemoryAvailableWithoutSystemResource() {return GetTotalPhysicalMemoryAvailable() - GetSystemResourceSize();}-u64 KProcess::GetTotalPhysicalMemoryUsed() const {- return image_size + main_thread_stack_size + page_table->GetNormalMemorySize() ++u64 KProcess::GetTotalPhysicalMemoryUsed() {+ return image_size + main_thread_stack_size + page_table.GetNormalMemorySize() +GetSystemResourceSize();}-u64 KProcess::GetTotalPhysicalMemoryUsedWithoutSystemResource() const {+u64 KProcess::GetTotalPhysicalMemoryUsedWithoutSystemResource() {return GetTotalPhysicalMemoryUsed() - GetSystemResourceUsage();}@@ -348,6 +350,9 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:system_resource_size = metadata.GetSystemResourceSize();image_size = code_size;+ // We currently do not support process-specific system resource+ UNIMPLEMENTED_IF(system_resource_size != 0);+KScopedResourceReservation memory_reservation(resource_limit, LimitableResource::PhysicalMemory,code_size + system_resource_size);if (!memory_reservation.Succeeded()) {@@ -356,7 +361,7 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:return ResultLimitReached;}// Initialize proces address space- if (const Result result{page_table->InitializeForProcess(+ if (const Result result{page_table.InitializeForProcess(metadata.GetAddressSpaceType(), false, 0x8000000, code_size,&kernel.GetApplicationMemoryBlockManager(), KMemoryManager::Pool::Application)};result.IsError()) {@@ -364,9 +369,9 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:}// Map process code region- if (const Result result{page_table->MapProcessCode(page_table->GetCodeRegionStart(),- code_size / PageSize, KMemoryState::Code,- KMemoryPermission::None)};+ if (const Result result{page_table.MapProcessCode(page_table.GetCodeRegionStart(),+ code_size / PageSize, KMemoryState::Code,+ KMemoryPermission::None)};result.IsError()) {return result;}@@ -374,7 +379,7 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:// Initialize process capabilitiesconst auto& caps{metadata.GetKernelCapabilities()};if (const Result result{- capabilities.InitializeForUserProcess(caps.data(), caps.size(), *page_table)};+ capabilities.InitializeForUserProcess(caps.data(), caps.size(), page_table)};result.IsError()) {return result;}@@ -384,12 +389,12 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:case FileSys::ProgramAddressSpaceType::Is32Bit:case FileSys::ProgramAddressSpaceType::Is36Bit:case FileSys::ProgramAddressSpaceType::Is39Bit:- memory_usage_capacity = page_table->GetHeapRegionEnd() - page_table->GetHeapRegionStart();+ memory_usage_capacity = page_table.GetHeapRegionEnd() - page_table.GetHeapRegionStart();break;case FileSys::ProgramAddressSpaceType::Is32BitNoMap:- memory_usage_capacity = page_table->GetHeapRegionEnd() - page_table->GetHeapRegionStart() +- page_table->GetAliasRegionEnd() - page_table->GetAliasRegionStart();+ memory_usage_capacity = page_table.GetHeapRegionEnd() - page_table.GetHeapRegionStart() ++ page_table.GetAliasRegionEnd() - page_table.GetAliasRegionStart();break;default:@@ -397,7 +402,7 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:}// Create TLS region- R_TRY(this->CreateThreadLocalRegion(std::addressof(tls_region_address)));+ R_TRY(this->CreateThreadLocalRegion(std::addressof(plr_address)));memory_reservation.Commit();return handle_table.Initialize(capabilities.GetHandleTableSize());@@ -409,7 +414,7 @@ void KProcess::Run(s32 main_thread_priority, u64 stack_size) {resource_limit->Reserve(LimitableResource::PhysicalMemory, main_thread_stack_size);const std::size_t heap_capacity{memory_usage_capacity - (main_thread_stack_size + image_size)};- ASSERT(!page_table->SetMaxHeapSize(heap_capacity).IsError());+ ASSERT(!page_table.SetMaxHeapSize(heap_capacity).IsError());ChangeState(State::Running);@@ -437,8 +442,8 @@ void KProcess::PrepareForTermination() {stop_threads(kernel.System().GlobalSchedulerContext().GetThreadList());- this->DeleteThreadLocalRegion(tls_region_address);- tls_region_address = 0;+ this->DeleteThreadLocalRegion(plr_address);+ plr_address = 0;if (resource_limit) {resource_limit->Release(LimitableResource::PhysicalMemory,@@ -474,7 +479,7 @@ void KProcess::Finalize() {}// Finalize the page table.- page_table.reset();+ page_table.Finalize();// Perform inherited finalization.KAutoObjectWithSlabHeapAndContainer<KProcess, KWorkerTask>::Finalize();@@ -628,7 +633,7 @@ bool KProcess::RemoveWatchpoint(Core::System& system, VAddr addr, u64 size,void KProcess::LoadModule(CodeSet code_set, VAddr base_addr) {const auto ReprotectSegment = [&](const CodeSet::Segment& segment,Svc::MemoryPermission permission) {- page_table->SetProcessMemoryPermission(segment.addr + base_addr, segment.size, permission);+ page_table.SetProcessMemoryPermission(segment.addr + base_addr, segment.size, permission);};kernel.System().Memory().WriteBlock(*this, base_addr, code_set.memory.data(),@@ -645,8 +650,7 @@ bool KProcess::IsSignaled() const {}KProcess::KProcess(KernelCore& kernel_)- : KAutoObjectWithSlabHeapAndContainer{kernel_}, page_table{std::make_unique<KPageTable>(- kernel_.System())},+ : KAutoObjectWithSlabHeapAndContainer{kernel_}, page_table{kernel_.System()},handle_table{kernel_}, address_arbiter{kernel_.System()}, condition_var{kernel_.System()},state_lock{kernel_}, list_lock{kernel_} {}@@ -668,11 +672,11 @@ Result KProcess::AllocateMainThreadStack(std::size_t stack_size) {// The kernel always ensures that the given stack size is page aligned.main_thread_stack_size = Common::AlignUp(stack_size, PageSize);- const VAddr start{page_table->GetStackRegionStart()};- const std::size_t size{page_table->GetStackRegionEnd() - start};+ const VAddr start{page_table.GetStackRegionStart()};+ const std::size_t size{page_table.GetStackRegionEnd() - start};CASCADE_RESULT(main_thread_stack_top,- page_table->AllocateAndMapMemory(+ page_table.AllocateAndMapMemory(main_thread_stack_size / PageSize, PageSize, false, start, size / PageSize,KMemoryState::Stack, KMemoryPermission::UserReadWrite));@@ -681,4 +685,12 @@ Result KProcess::AllocateMainThreadStack(std::size_t stack_size) {return ResultSuccess;}+void KProcess::FinalizeHandleTable() {+ // Finalize the table.+ handle_table.Finalize();++ // Note that the table is finalized.+ is_handle_table_initialized = false;+}+} // namespace Kerneldiff --git a/src/core/hle/kernel/k_process.h b/src/core/hle/kernel/k_process.hindex b1c7da4543..fcc2897f99 100644--- a/src/core/hle/kernel/k_process.h+++ b/src/core/hle/kernel/k_process.h@@ -13,6 +13,7 @@#include "core/hle/kernel/k_auto_object.h"#include "core/hle/kernel/k_condition_variable.h"#include "core/hle/kernel/k_handle_table.h"+#include "core/hle/kernel/k_page_table.h"#include "core/hle/kernel/k_synchronization_object.h"#include "core/hle/kernel/k_thread_local_page.h"#include "core/hle/kernel/k_worker_task.h"@@ -31,7 +32,6 @@ class ProgramMetadata;namespace Kernel {class KernelCore;-class KPageTable;class KResourceLimit;class KThread;class KSharedMemoryInfo;@@ -107,12 +107,12 @@ public:/// Gets a reference to the process' page table.KPageTable& PageTable() {- return *page_table;+ return page_table;}/// Gets const a reference to the process' page table.const KPageTable& PageTable() const {- return *page_table;+ return page_table;}/// Gets a reference to the process' handle table.@@ -150,9 +150,8 @@ public:return address_arbiter.WaitForAddress(address, arb_type, value, timeout);}- /// Gets the address to the process' dedicated TLS region.- VAddr GetTLSRegionAddress() const {- return tls_region_address;+ VAddr GetProcessLocalRegionAddress() const {+ return plr_address;}/// Gets the current status of the process@@ -279,18 +278,18 @@ public:}/// Retrieves the total physical memory available to this process in bytes.- u64 GetTotalPhysicalMemoryAvailable() const;+ u64 GetTotalPhysicalMemoryAvailable();/// Retrieves the total physical memory available to this process in bytes,/// without the size of the personal system resource heap added to it.- u64 GetTotalPhysicalMemoryAvailableWithoutSystemResource() const;+ u64 GetTotalPhysicalMemoryAvailableWithoutSystemResource();/// Retrieves the total physical memory used by this process in bytes.- u64 GetTotalPhysicalMemoryUsed() const;+ u64 GetTotalPhysicalMemoryUsed();/// Retrieves the total physical memory used by this process in bytes,/// without the size of the personal system resource heap added to it.- u64 GetTotalPhysicalMemoryUsedWithoutSystemResource() const;+ u64 GetTotalPhysicalMemoryUsedWithoutSystemResource();/// Gets the list of all threads created with this process as their owner.std::list<KThread*>& GetThreadList() {@@ -413,8 +412,10 @@ private:/// Allocates the main thread stack for the process, given the stack size in bytes.Result AllocateMainThreadStack(std::size_t stack_size);+ void FinalizeHandleTable();+/// Memory manager for this process- std::unique_ptr<KPageTable> page_table;+ KPageTable page_table;/// Current status of the processState state{};@@ -433,6 +434,8 @@ private:/// Resource limit descriptor for this processKResourceLimit* resource_limit{};+ VAddr system_resource_address{};+/// The ideal CPU core for this process, threads are scheduled on this core by default.u8 ideal_core = 0;@@ -459,7 +462,7 @@ private:KConditionVariable condition_var;/// Address indicating the location of the process' dedicated TLS region.- VAddr tls_region_address = 0;+ VAddr plr_address = 0;/// Random values for svcGetInfo RandomEntropystd::array<u64, RANDOM_ENTROPY_SIZE> random_entropy{};@@ -485,8 +488,12 @@ private:/// Schedule count of this processs64 schedule_count{};+ size_t memory_release_hint{};+bool is_signaled{};bool is_suspended{};+ bool is_immortal{};+ bool is_handle_table_initialized{};bool is_initialized{};std::atomic<u16> num_running_threads{};diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cppindex b6bbd4984b..6879de9ef3 100644--- a/src/core/hle/kernel/kernel.cpp+++ b/src/core/hle/kernel/kernel.cpp@@ -95,6 +95,15 @@ struct KernelCore::Impl {}}+ void CloseCurrentProcess() {+ (*current_process).Finalize();+ // current_process->Close();+ // TODO: The current process should be destroyed based on accurate ref counting after+ // calling Close(). Adding a manual Destroy() call instead to avoid a memory leak.+ (*current_process).Destroy();+ current_process = nullptr;+ }+void Shutdown() {is_shutting_down.store(true, std::memory_order_relaxed);SCOPE_EXIT({ is_shutting_down.store(false, std::memory_order_relaxed); });@@ -157,15 +166,7 @@ struct KernelCore::Impl {}}- // Shutdown all processes.- if (current_process) {- (*current_process).Finalize();- // current_process->Close();- // TODO: The current process should be destroyed based on accurate ref counting after- // calling Close(). Adding a manual Destroy() call instead to avoid a memory leak.- (*current_process).Destroy();- current_process = nullptr;- }+ CloseCurrentProcess();// Track kernel objects that were not freed on shutdown{@@ -870,6 +871,10 @@ const KProcess* KernelCore::CurrentProcess() const {return impl->current_process;}+void KernelCore::CloseCurrentProcess() {+ impl->CloseCurrentProcess();+}+const std::vector<KProcess*>& KernelCore::GetProcessList() const {return impl->process_list;}diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.hindex 79e66483ee..6eded95393 100644--- a/src/core/hle/kernel/kernel.h+++ b/src/core/hle/kernel/kernel.h@@ -131,6 +131,9 @@ public:/// Retrieves a const pointer to the current process.const KProcess* CurrentProcess() const;+ /// Closes the current process.+ void CloseCurrentProcess();+/// Retrieves the list of processes.const std::vector<KProcess*>& GetProcessList() const;diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cppindex bac61fd096..b07ae3f027 100644--- a/src/core/hle/kernel/svc.cpp+++ b/src/core/hle/kernel/svc.cpp@@ -933,7 +933,7 @@ static Result GetInfo(Core::System& system, u64* result, u64 info_id, Handle hanreturn ResultSuccess;case GetInfoType::UserExceptionContextAddr:- *result = process->GetTLSRegionAddress();+ *result = process->GetProcessLocalRegionAddress();return ResultSuccess;case GetInfoType::TotalPhysicalMemoryAvailableWithoutSystemResource: