diff options
Diffstat (limited to 'src/core/hle/kernel')
| -rw-r--r-- | src/core/hle/kernel/k_process.cpp | 14 | ||||
| -rw-r--r-- | src/core/hle/kernel/k_process.h | 82 | ||||
| -rw-r--r-- | src/core/hle/kernel/kernel.cpp | 119 |
3 files changed, 111 insertions, 104 deletions
diff --git a/src/core/hle/kernel/k_process.cpp b/src/core/hle/kernel/k_process.cpp index 322f971ba3..082049f957 100644 --- a/src/core/hle/kernel/k_process.cpp +++ b/src/core/hle/kernel/k_process.cpp @@ -1148,9 +1148,17 @@ Result KProcess::GetThreadList(s32* out_num_threads, KProcessAddress out_thread_ void KProcess::Switch(KProcess* cur_process, KProcess* next_process) {} KProcess::KProcess(KernelCore& kernel) - : KAutoObjectWithSlabHeapAndContainer(kernel), m_page_table{kernel}, m_state_lock{kernel}, - m_list_lock{kernel}, m_cond_var{kernel.System()}, m_address_arbiter{kernel.System()}, - m_handle_table{kernel}, m_exclusive_monitor{}, m_memory{kernel.System()} {} + : KAutoObjectWithSlabHeapAndContainer(kernel) + , m_exclusive_monitor{} + , m_memory{kernel.System()} + , m_handle_table{kernel} + , m_page_table{kernel} + , m_state_lock{kernel} + , m_list_lock{kernel} + , m_cond_var{kernel.System()} + , m_address_arbiter{kernel.System()} +{} + KProcess::~KProcess() = default; Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std::size_t code_size, diff --git a/src/core/hle/kernel/k_process.h b/src/core/hle/kernel/k_process.h index 92ddb1aca4..13717cc090 100644 --- a/src/core/hle/kernel/k_process.h +++ b/src/core/hle/kernel/k_process.h @@ -66,60 +66,55 @@ public: private: using SharedMemoryInfoList = Common::IntrusiveListBaseTraits<KSharedMemoryInfo>::ListType; - using TLPTree = - Common::IntrusiveRedBlackTreeBaseTraits<KThreadLocalPage>::TreeType<KThreadLocalPage>; + using TLPTree = Common::IntrusiveRedBlackTreeBaseTraits<KThreadLocalPage>::TreeType<KThreadLocalPage>; using TLPIterator = TLPTree::iterator; private: + std::array<std::unique_ptr<Core::ArmInterface>, Core::Hardware::NUM_CPU_CORES> m_arm_interfaces{}; + std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_running_threads{}; + std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_idle_counts{}; + std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_switch_counts{}; + std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_pinned_threads{}; + std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS> m_watchpoints{}; + std::map<KProcessAddress, u64> m_debug_page_refcounts{}; +#ifdef HAS_NCE + std::unordered_map<u64, u64> m_post_handlers{}; +#endif + std::unique_ptr<Core::ExclusiveMonitor> m_exclusive_monitor; + Core::Memory::Memory m_memory; + KCapabilities m_capabilities{}; + KProcessAddress m_code_address{}; + KHandleTable m_handle_table; + KProcessAddress m_plr_address{}; + ThreadList m_thread_list{}; + SharedMemoryInfoList m_shared_memory_list{}; KProcessPageTable m_page_table; std::atomic<size_t> m_used_kernel_memory_size{}; TLPTree m_fully_used_tlp_tree{}; TLPTree m_partially_used_tlp_tree{}; - s32 m_ideal_core_id{}; - KResourceLimit* m_resource_limit{}; - KSystemResource* m_system_resource{}; - size_t m_memory_release_hint{}; State m_state{}; KLightLock m_state_lock; KLightLock m_list_lock; KConditionVariable m_cond_var; KAddressArbiter m_address_arbiter; std::array<u64, 4> m_entropy{}; - bool m_is_signaled{}; - bool m_is_initialized{}; u32 m_pointer_buffer_size = 0x8000; // Default pointer buffer size (can be game-specific later) - bool m_is_application{}; - bool m_is_default_application_system_resource{}; - bool m_is_hbl{}; std::array<char, 13> m_name{}; - std::atomic<u16> m_num_running_threads{}; Svc::CreateProcessFlag m_flags{}; KMemoryManager::Pool m_memory_pool{}; - s64 m_schedule_count{}; - KCapabilities m_capabilities{}; - u64 m_program_id{}; - u64 m_process_id{}; - KProcessAddress m_code_address{}; + + KResourceLimit* m_resource_limit{}; + KSystemResource* m_system_resource{}; + KThread* m_exception_thread{}; + size_t m_code_size{}; size_t m_main_thread_stack_size{}; size_t m_max_process_memory{}; - u32 m_version{}; - KHandleTable m_handle_table; - KProcessAddress m_plr_address{}; - KThread* m_exception_thread{}; - ThreadList m_thread_list{}; - SharedMemoryInfoList m_shared_memory_list{}; - bool m_is_suspended{}; - bool m_is_immortal{}; - bool m_is_handle_table_initialized{}; - std::array<std::unique_ptr<Core::ArmInterface>, Core::Hardware::NUM_CPU_CORES> - m_arm_interfaces{}; - std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_running_threads{}; - std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_idle_counts{}; - std::array<u64, Core::Hardware::NUM_CPU_CORES> m_running_thread_switch_counts{}; - std::array<KThread*, Core::Hardware::NUM_CPU_CORES> m_pinned_threads{}; - std::array<DebugWatchpoint, Core::Hardware::NUM_WATCHPOINTS> m_watchpoints{}; - std::map<KProcessAddress, u64> m_debug_page_refcounts{}; + size_t m_memory_release_hint{}; + s64 m_schedule_count{}; + u64 m_program_id{}; + u64 m_process_id{}; + std::atomic<s64> m_cpu_time{}; std::atomic<s64> m_num_process_switches{}; std::atomic<s64> m_num_thread_switches{}; @@ -128,11 +123,20 @@ private: std::atomic<s64> m_num_ipc_messages{}; std::atomic<s64> m_num_ipc_replies{}; std::atomic<s64> m_num_ipc_receives{}; -#ifdef HAS_NCE - std::unordered_map<u64, u64> m_post_handlers{}; -#endif - std::unique_ptr<Core::ExclusiveMonitor> m_exclusive_monitor; - Core::Memory::Memory m_memory; + + s32 m_ideal_core_id{}; + u32 m_version{}; + + std::atomic<u16> m_num_running_threads{}; + + bool m_is_signaled : 1 = false; + bool m_is_initialized : 1 = false; + bool m_is_application : 1 = false; + bool m_is_default_application_system_resource : 1 = false; + bool m_is_hbl : 1 = false; + bool m_is_suspended : 1 = false; + bool m_is_immortal : 1 = false; + bool m_is_handle_table_initialized : 1 = false; private: Result StartTermination(); diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cpp index 062387a29b..6986a98e35 100644 --- a/src/core/hle/kernel/kernel.cpp +++ b/src/core/hle/kernel/kernel.cpp @@ -88,11 +88,11 @@ struct KernelCore::Impl { } void Initialize(KernelCore& kernel) { - hardware_timer = std::make_unique<Kernel::KHardwareTimer>(kernel); + hardware_timer.emplace(kernel); hardware_timer->Initialize(); - global_object_list_container = std::make_unique<KAutoObjectWithListContainer>(kernel); - global_scheduler_context = std::make_unique<Kernel::GlobalSchedulerContext>(kernel); + global_object_list_container.emplace(kernel); + global_scheduler_context.emplace(kernel); // Derive the initial memory layout from the emulated board Init::InitializeSlabResourceCounts(kernel); @@ -212,10 +212,9 @@ struct KernelCore::Impl { void InitializePhysicalCores() { for (u32 i = 0; i < Core::Hardware::NUM_CPU_CORES; i++) { - const s32 core{static_cast<s32>(i)}; - - schedulers[i] = std::make_unique<Kernel::KScheduler>(system.Kernel()); - cores[i] = std::make_unique<Kernel::PhysicalCore>(system.Kernel(), i); + auto const core = s32(i); + schedulers[i].emplace(system.Kernel()); + cores[i].emplace(system.Kernel(), i); auto* main_thread{Kernel::KThread::Create(system.Kernel())}; main_thread->SetCurrentCore(core); @@ -280,57 +279,56 @@ struct KernelCore::Impl { size -= rc_size; // Initialize the resource managers' shared page manager. - resource_manager_page_manager = std::make_unique<KDynamicPageManager>(); + resource_manager_page_manager.emplace(); resource_manager_page_manager->Initialize(address, size, std::max<size_t>(PageSize, KPageBufferSlabHeap::BufferSize)); // Initialize the KPageBuffer slab heap. page_buffer_slab_heap.Initialize(system); // Initialize the fixed-size slabheaps. - app_memory_block_heap = std::make_unique<KMemoryBlockSlabHeap>(); - sys_memory_block_heap = std::make_unique<KMemoryBlockSlabHeap>(); - block_info_heap = std::make_unique<KBlockInfoSlabHeap>(); - app_memory_block_heap->Initialize(resource_manager_page_manager.get(), ApplicationMemoryBlockSlabHeapSize); - sys_memory_block_heap->Initialize(resource_manager_page_manager.get(), SystemMemoryBlockSlabHeapSize); - block_info_heap->Initialize(resource_manager_page_manager.get(), BlockInfoSlabHeapSize); + app_memory_block_heap.emplace(); + sys_memory_block_heap.emplace(); + block_info_heap.emplace(); + app_memory_block_heap->Initialize(std::addressof(*resource_manager_page_manager), ApplicationMemoryBlockSlabHeapSize); + sys_memory_block_heap->Initialize(std::addressof(*resource_manager_page_manager), SystemMemoryBlockSlabHeapSize); + block_info_heap->Initialize(std::addressof(*resource_manager_page_manager), BlockInfoSlabHeapSize); // Reserve all but a fixed number of remaining pages for the page table heap. const size_t num_pt_pages = resource_manager_page_manager->GetCount() - resource_manager_page_manager->GetUsed() - ReservedDynamicPageCount; - page_table_heap = std::make_unique<KPageTableSlabHeap>(); + page_table_heap.emplace(); // TODO(bunnei): Pass in address once we support kernel virtual memory allocations. page_table_heap->Initialize( - resource_manager_page_manager.get(), num_pt_pages, + std::addressof(*resource_manager_page_manager), num_pt_pages, /*GetPointer<KPageTableManager::RefCount>(address + size)*/ nullptr); // Setup the slab managers. KDynamicPageManager* const app_dynamic_page_manager = nullptr; KDynamicPageManager* const sys_dynamic_page_manager = /*KTargetSystem::IsDynamicResourceLimitsEnabled()*/ true - ? resource_manager_page_manager.get() - : nullptr; - app_memory_block_manager = std::make_unique<KMemoryBlockSlabManager>(); - sys_memory_block_manager = std::make_unique<KMemoryBlockSlabManager>(); - app_block_info_manager = std::make_unique<KBlockInfoManager>(); - sys_block_info_manager = std::make_unique<KBlockInfoManager>(); - app_page_table_manager = std::make_unique<KPageTableManager>(); - sys_page_table_manager = std::make_unique<KPageTableManager>(); + ? std::addressof(*resource_manager_page_manager) : nullptr; + app_memory_block_manager.emplace(); + sys_memory_block_manager.emplace(); + app_block_info_manager.emplace(); + sys_block_info_manager.emplace(); + app_page_table_manager.emplace(); + sys_page_table_manager.emplace(); - app_memory_block_manager->Initialize(app_dynamic_page_manager, app_memory_block_heap.get()); - sys_memory_block_manager->Initialize(sys_dynamic_page_manager, sys_memory_block_heap.get()); + app_memory_block_manager->Initialize(app_dynamic_page_manager, std::addressof(*app_memory_block_heap)); + sys_memory_block_manager->Initialize(sys_dynamic_page_manager, std::addressof(*sys_memory_block_heap)); - app_block_info_manager->Initialize(app_dynamic_page_manager, block_info_heap.get()); - sys_block_info_manager->Initialize(sys_dynamic_page_manager, block_info_heap.get()); + app_block_info_manager->Initialize(app_dynamic_page_manager, std::addressof(*block_info_heap)); + sys_block_info_manager->Initialize(sys_dynamic_page_manager, std::addressof(*block_info_heap)); - app_page_table_manager->Initialize(app_dynamic_page_manager, page_table_heap.get()); - sys_page_table_manager->Initialize(sys_dynamic_page_manager, page_table_heap.get()); + app_page_table_manager->Initialize(app_dynamic_page_manager, std::addressof(*page_table_heap)); + sys_page_table_manager->Initialize(sys_dynamic_page_manager, std::addressof(*page_table_heap)); // Check that we have the correct number of dynamic pages available. ASSERT(resource_manager_page_manager->GetCount() - resource_manager_page_manager->GetUsed() == ReservedDynamicPageCount); // Create the system page table managers. - app_system_resource = std::make_unique<KSystemResource>(kernel); - sys_system_resource = std::make_unique<KSystemResource>(kernel); + app_system_resource.emplace(kernel); + sys_system_resource.emplace(kernel); KAutoObject::Create(std::addressof(*app_system_resource)); KAutoObject::Create(std::addressof(*sys_system_resource)); @@ -349,7 +347,7 @@ struct KernelCore::Impl { } void InitializeGlobalData(KernelCore& kernel) { - object_name_global_data = std::make_unique<KObjectNameGlobalData>(kernel); + object_name_global_data.emplace(kernel); } void MakeApplicationProcess(KProcess* process) { @@ -431,7 +429,7 @@ struct KernelCore::Impl { } void DeriveInitialMemoryLayout() { - memory_layout = std::make_unique<KMemoryLayout>(); + memory_layout.emplace(); // Insert the root region for the virtual memory tree, from which all other regions will // derive. @@ -726,7 +724,7 @@ struct KernelCore::Impl { void InitializeMemoryLayout() { // Initialize the memory manager. - memory_manager = std::make_unique<KMemoryManager>(system); + memory_manager.emplace(system); const auto& management_region = memory_layout->GetPoolManagementRegion(); ASSERT(management_region.GetEndAddress() != 0); memory_manager->Initialize(management_region.GetAddress(), management_region.GetSize()); @@ -774,8 +772,8 @@ struct KernelCore::Impl { std::mutex process_list_lock; std::vector<KProcess*> process_list; KProcess* application_process{}; - std::unique_ptr<Kernel::GlobalSchedulerContext> global_scheduler_context; - std::unique_ptr<Kernel::KHardwareTimer> hardware_timer; + std::optional<Kernel::GlobalSchedulerContext> global_scheduler_context; + std::optional<Kernel::KHardwareTimer> hardware_timer; Init::KSlabResourceCounts slab_resource_counts{}; KResourceLimit* system_resource_limit{}; @@ -784,9 +782,9 @@ struct KernelCore::Impl { std::shared_ptr<Core::Timing::EventType> preemption_event; - std::unique_ptr<KAutoObjectWithListContainer> global_object_list_container; + std::optional<KAutoObjectWithListContainer> global_object_list_container; - std::unique_ptr<KObjectNameGlobalData> object_name_global_data; + std::optional<KObjectNameGlobalData> object_name_global_data; std::unordered_set<KAutoObject*> registered_objects; std::unordered_set<KAutoObject*> registered_in_use_objects; @@ -794,28 +792,28 @@ struct KernelCore::Impl { std::mutex server_lock; std::vector<std::unique_ptr<Service::ServerManager>> server_managers; - std::array<std::unique_ptr<Kernel::PhysicalCore>, Core::Hardware::NUM_CPU_CORES> cores; + std::array<std::optional<Kernel::PhysicalCore>, Core::Hardware::NUM_CPU_CORES> cores; // Next host thead ID to use, 0-3 IDs represent core threads, >3 represent others std::atomic<u32> next_host_thread_id{Core::Hardware::NUM_CPU_CORES}; // Kernel memory management - std::unique_ptr<KMemoryManager> memory_manager; + std::optional<KMemoryManager> memory_manager; // Resource managers - std::unique_ptr<KDynamicPageManager> resource_manager_page_manager; - std::unique_ptr<KPageTableSlabHeap> page_table_heap; - std::unique_ptr<KMemoryBlockSlabHeap> app_memory_block_heap; - std::unique_ptr<KMemoryBlockSlabHeap> sys_memory_block_heap; - std::unique_ptr<KBlockInfoSlabHeap> block_info_heap; - std::unique_ptr<KPageTableManager> app_page_table_manager; - std::unique_ptr<KPageTableManager> sys_page_table_manager; - std::unique_ptr<KMemoryBlockSlabManager> app_memory_block_manager; - std::unique_ptr<KMemoryBlockSlabManager> sys_memory_block_manager; - std::unique_ptr<KBlockInfoManager> app_block_info_manager; - std::unique_ptr<KBlockInfoManager> sys_block_info_manager; - std::unique_ptr<KSystemResource> app_system_resource; - std::unique_ptr<KSystemResource> sys_system_resource; + std::optional<KDynamicPageManager> resource_manager_page_manager; + std::optional<KPageTableSlabHeap> page_table_heap; + std::optional<KMemoryBlockSlabHeap> app_memory_block_heap; + std::optional<KMemoryBlockSlabHeap> sys_memory_block_heap; + std::optional<KBlockInfoSlabHeap> block_info_heap; + std::optional<KPageTableManager> app_page_table_manager; + std::optional<KPageTableManager> sys_page_table_manager; + std::optional<KMemoryBlockSlabManager> app_memory_block_manager; + std::optional<KMemoryBlockSlabManager> sys_memory_block_manager; + std::optional<KBlockInfoManager> app_block_info_manager; + std::optional<KBlockInfoManager> sys_block_info_manager; + std::optional<KSystemResource> app_system_resource; + std::optional<KSystemResource> sys_system_resource; // Shared memory for services Kernel::KSharedMemory* hid_shared_mem{}; @@ -825,10 +823,10 @@ struct KernelCore::Impl { Kernel::KSharedMemory* hidbus_shared_mem{}; // Memory layout - std::unique_ptr<KMemoryLayout> memory_layout; + std::optional<KMemoryLayout> memory_layout; std::array<KThread*, Core::Hardware::NUM_CPU_CORES> shutdown_threads{}; - std::array<std::unique_ptr<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{}; + std::array<std::optional<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{}; bool is_multicore{}; std::atomic_bool is_shutting_down{}; @@ -948,12 +946,9 @@ const Kernel::PhysicalCore& KernelCore::CurrentPhysicalCore() const { } Kernel::KScheduler* KernelCore::CurrentScheduler() { - const u32 core_id = impl->GetCurrentHostThreadID(); - if (core_id >= Core::Hardware::NUM_CPU_CORES) { - // This is expected when called from not a guest thread - return {}; - } - return impl->schedulers[core_id].get(); + if (auto const core_id = impl->GetCurrentHostThreadID(); core_id < Core::Hardware::NUM_CPU_CORES) + return std::addressof(*impl->schedulers[core_id]); + return {}; // This is expected when called from not a guest thread } Kernel::KHardwareTimer& KernelCore::HardwareTimer() { |