VERY experimental Nintendo Switch 2 emulator
C++
core: hle: kernel: Add KSystemResource.
bunnei57796fc36e1b
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txtindex f0d5b08877..f6e082c36b 100644--- a/src/core/CMakeLists.txt+++ b/src/core/CMakeLists.txt@@ -258,6 +258,8 @@ add_library(core STATIChle/kernel/k_synchronization_object.cpphle/kernel/k_synchronization_object.hhle/kernel/k_system_control.h+ hle/kernel/k_system_resource.cpp+ hle/kernel/k_system_resource.hhle/kernel/k_thread.cpphle/kernel/k_thread.hhle/kernel/k_thread_local_page.cppdiff --git a/src/core/hle/kernel/k_class_token.cpp b/src/core/hle/kernel/k_class_token.cppindex 10265c23ce..6eb44d6a62 100644--- a/src/core/hle/kernel/k_class_token.cpp+++ b/src/core/hle/kernel/k_class_token.cpp@@ -16,6 +16,7 @@#include "core/hle/kernel/k_session.h"#include "core/hle/kernel/k_shared_memory.h"#include "core/hle/kernel/k_synchronization_object.h"+#include "core/hle/kernel/k_system_resource.h"#include "core/hle/kernel/k_thread.h"#include "core/hle/kernel/k_transfer_memory.h"@@ -119,4 +120,6 @@ static_assert(std::is_final_v<KTransferMemory> && std::is_base_of_v<KAutoObject,// static_assert(std::is_final_v<KCodeMemory> &&// std::is_base_of_v<KAutoObject, KCodeMemory>);+static_assert(std::is_base_of<KAutoObject, KSystemResource>::value);+} // namespace Kerneldiff --git a/src/core/hle/kernel/k_class_token.h b/src/core/hle/kernel/k_class_token.hindex ab20e00ff8..e75b1c035c 100644--- a/src/core/hle/kernel/k_class_token.h+++ b/src/core/hle/kernel/k_class_token.h@@ -10,6 +10,8 @@ namespace Kernel {class KAutoObject;+class KSystemResource;+class KClassTokenGenerator {public:using TokenBaseType = u16;@@ -58,7 +60,7 @@ private:if constexpr (std::is_same<T, KAutoObject>::value) {static_assert(T::ObjectType == ObjectType::KAutoObject);return 0;- } else if constexpr (!std::is_final<T>::value) {+ } else if constexpr (!std::is_final<T>::value && !std::same_as<T, KSystemResource>) {static_assert(ObjectType::BaseClassesStart <= T::ObjectType &&T::ObjectType < ObjectType::BaseClassesEnd);constexpr auto ClassIndex = static_cast<TokenBaseType>(T::ObjectType) -@@ -108,6 +110,8 @@ public:KSessionRequest,KCodeMemory,+ KSystemResource,+// NOTE: True order for these has not been determined yet.KAlpha,KBeta,diff --git a/src/core/hle/kernel/k_system_resource.cpp b/src/core/hle/kernel/k_system_resource.cppnew file mode 100644index 0000000000..4cc377a6c5--- /dev/null+++ b/src/core/hle/kernel/k_system_resource.cpp@@ -0,0 +1,26 @@+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project+// SPDX-License-Identifier: GPL-2.0-or-later++#include "core/hle/kernel/k_system_resource.h"++namespace Kernel {++Result KSecureSystemResource::Initialize([[maybe_unused]] size_t size,+ [[maybe_unused]] KResourceLimit* resource_limit,+ [[maybe_unused]] KMemoryManager::Pool pool) {+ // Unimplemented+ UNREACHABLE();+}++void KSecureSystemResource::Finalize() {+ // Unimplemented+ UNREACHABLE();+}++size_t KSecureSystemResource::CalculateRequiredSecureMemorySize(+ [[maybe_unused]] size_t size, [[maybe_unused]] KMemoryManager::Pool pool) {+ // Unimplemented+ UNREACHABLE();+}++} // namespace Kerneldiff --git a/src/core/hle/kernel/k_system_resource.h b/src/core/hle/kernel/k_system_resource.hnew file mode 100644index 0000000000..9a991f7259--- /dev/null+++ b/src/core/hle/kernel/k_system_resource.h@@ -0,0 +1,137 @@+// SPDX-FileCopyrightText: Copyright 2022 yuzu Emulator Project+// SPDX-License-Identifier: GPL-2.0-or-later++#pragma once++#include "common/assert.h"+#include "common/common_types.h"+#include "core/hle/kernel/k_auto_object.h"+#include "core/hle/kernel/k_dynamic_resource_manager.h"+#include "core/hle/kernel/k_memory_manager.h"+#include "core/hle/kernel/k_page_table_manager.h"+#include "core/hle/kernel/k_resource_limit.h"+#include "core/hle/kernel/slab_helpers.h"++namespace Kernel {++// NOTE: Nintendo's implementation does not have the "is_secure_resource" field, and instead uses+// virtual IsSecureResource().++class KSystemResource : public KAutoObject {+ KERNEL_AUTOOBJECT_TRAITS(KSystemResource, KAutoObject);++public:+ explicit KSystemResource(KernelCore& kernel_) : KAutoObject(kernel_) {}++protected:+ void SetSecureResource() {+ m_is_secure_resource = true;+ }++public:+ virtual void Destroy() override {+ UNREACHABLE_MSG("KSystemResource::Destroy() was called");+ }++ bool IsSecureResource() const {+ return m_is_secure_resource;+ }++ void SetManagers(KMemoryBlockSlabManager& mb, KBlockInfoManager& bi, KPageTableManager& pt) {+ ASSERT(m_p_memory_block_slab_manager == nullptr);+ ASSERT(m_p_block_info_manager == nullptr);+ ASSERT(m_p_page_table_manager == nullptr);++ m_p_memory_block_slab_manager = std::addressof(mb);+ m_p_block_info_manager = std::addressof(bi);+ m_p_page_table_manager = std::addressof(pt);+ }++ const KMemoryBlockSlabManager& GetMemoryBlockSlabManager() const {+ return *m_p_memory_block_slab_manager;+ }+ const KBlockInfoManager& GetBlockInfoManager() const {+ return *m_p_block_info_manager;+ }+ const KPageTableManager& GetPageTableManager() const {+ return *m_p_page_table_manager;+ }++ KMemoryBlockSlabManager& GetMemoryBlockSlabManager() {+ return *m_p_memory_block_slab_manager;+ }+ KBlockInfoManager& GetBlockInfoManager() {+ return *m_p_block_info_manager;+ }+ KPageTableManager& GetPageTableManager() {+ return *m_p_page_table_manager;+ }++ KMemoryBlockSlabManager* GetMemoryBlockSlabManagerPointer() {+ return m_p_memory_block_slab_manager;+ }+ KBlockInfoManager* GetBlockInfoManagerPointer() {+ return m_p_block_info_manager;+ }+ KPageTableManager* GetPageTableManagerPointer() {+ return m_p_page_table_manager;+ }++private:+ KMemoryBlockSlabManager* m_p_memory_block_slab_manager{};+ KBlockInfoManager* m_p_block_info_manager{};+ KPageTableManager* m_p_page_table_manager{};+ bool m_is_secure_resource{false};+};++class KSecureSystemResource final+ : public KAutoObjectWithSlabHeap<KSecureSystemResource, KSystemResource> {+public:+ explicit KSecureSystemResource(KernelCore& kernel_)+ : KAutoObjectWithSlabHeap<KSecureSystemResource, KSystemResource>(kernel_) {+ // Mark ourselves as being a secure resource.+ this->SetSecureResource();+ }++ Result Initialize(size_t size, KResourceLimit* resource_limit, KMemoryManager::Pool pool);+ void Finalize();++ bool IsInitialized() const {+ return m_is_initialized;+ }+ static void PostDestroy([[maybe_unused]] uintptr_t arg) {}++ size_t CalculateRequiredSecureMemorySize() const {+ return CalculateRequiredSecureMemorySize(m_resource_size, m_resource_pool);+ }++ size_t GetSize() const {+ return m_resource_size;+ }+ size_t GetUsedSize() const {+ return m_dynamic_page_manager.GetUsed() * PageSize;+ }++ const KDynamicPageManager& GetDynamicPageManager() const {+ return m_dynamic_page_manager;+ }++public:+ static size_t CalculateRequiredSecureMemorySize(size_t size, KMemoryManager::Pool pool);++private:+ bool m_is_initialized{};+ KMemoryManager::Pool m_resource_pool{};+ KDynamicPageManager m_dynamic_page_manager;+ KMemoryBlockSlabManager m_memory_block_slab_manager;+ KBlockInfoManager m_block_info_manager;+ KPageTableManager m_page_table_manager;+ KMemoryBlockSlabHeap m_memory_block_heap;+ KBlockInfoSlabHeap m_block_info_heap;+ KPageTableSlabHeap m_page_table_heap;+ KResourceLimit* m_resource_limit{};+ VAddr m_resource_address{};+ size_t m_resource_size{};+};++} // namespace Kernel