VERY experimental Nintendo Switch 2 emulator
C++
core: hle: kernel: Integrate system KSystemResource.
bunneie81fcf57953f
diff --git a/src/core/hle/kernel/init/init_slab_setup.cpp b/src/core/hle/kernel/init/init_slab_setup.cppindex 477e4e4075..aa2dddcc68 100644--- a/src/core/hle/kernel/init/init_slab_setup.cpp+++ b/src/core/hle/kernel/init/init_slab_setup.cpp@@ -10,7 +10,9 @@#include "core/hardware_properties.h"#include "core/hle/kernel/init/init_slab_setup.h"#include "core/hle/kernel/k_code_memory.h"+#include "core/hle/kernel/k_debug.h"#include "core/hle/kernel/k_event.h"+#include "core/hle/kernel/k_event_info.h"#include "core/hle/kernel/k_memory_layout.h"#include "core/hle/kernel/k_memory_manager.h"#include "core/hle/kernel/k_page_buffer.h"@@ -22,6 +24,7 @@#include "core/hle/kernel/k_shared_memory.h"#include "core/hle/kernel/k_shared_memory_info.h"#include "core/hle/kernel/k_system_control.h"+#include "core/hle/kernel/k_system_resource.h"#include "core/hle/kernel/k_thread.h"#include "core/hle/kernel/k_thread_local_page.h"#include "core/hle/kernel/k_transfer_memory.h"@@ -44,7 +47,10 @@ namespace Kernel::Init {HANDLER(KThreadLocalPage, \(SLAB_COUNT(KProcess) + (SLAB_COUNT(KProcess) + SLAB_COUNT(KThread)) / 8), \##__VA_ARGS__) \- HANDLER(KResourceLimit, (SLAB_COUNT(KResourceLimit)), ##__VA_ARGS__)+ HANDLER(KResourceLimit, (SLAB_COUNT(KResourceLimit)), ##__VA_ARGS__) \+ HANDLER(KEventInfo, (SLAB_COUNT(KThread) + SLAB_COUNT(KDebug)), ##__VA_ARGS__) \+ HANDLER(KDebug, (SLAB_COUNT(KDebug)), ##__VA_ARGS__) \+ HANDLER(KSecureSystemResource, (SLAB_COUNT(KProcess)), ##__VA_ARGS__)namespace {@@ -73,8 +79,20 @@ constexpr size_t SlabCountKResourceLimit = 5;constexpr size_t SlabCountKDebug = Core::Hardware::NUM_CPU_CORES;constexpr size_t SlabCountKIoPool = 1;constexpr size_t SlabCountKIoRegion = 6;+constexpr size_t SlabcountKSessionRequestMappings = 40;-constexpr size_t SlabCountExtraKThread = 160;+constexpr size_t SlabCountExtraKThread = (1024 + 256 + 256) - SlabCountKThread;++namespace test {++static_assert(KernelPageBufferHeapSize ==+ 2 * PageSize + (SlabCountKProcess + SlabCountKThread ++ (SlabCountKProcess + SlabCountKThread) / 8) *+ PageSize);+static_assert(KernelPageBufferAdditionalSize ==+ (SlabCountExtraKThread + (SlabCountExtraKThread / 8)) * PageSize);++} // namespace test/// Helper function to translate from the slab virtual address to the reserved location in physical/// memory.@@ -109,7 +127,7 @@ VAddr InitializeSlabHeap(Core::System& system, KMemoryLayout& memory_layout, VAd}size_t CalculateSlabHeapGapSize() {- constexpr size_t KernelSlabHeapGapSize = 2_MiB - 296_KiB;+ constexpr size_t KernelSlabHeapGapSize = 2_MiB - 320_KiB;static_assert(KernelSlabHeapGapSize <= KernelSlabHeapGapsSizeMax);return KernelSlabHeapGapSize;}@@ -134,6 +152,7 @@ KSlabResourceCounts KSlabResourceCounts::CreateDefault() {.num_KDebug = SlabCountKDebug,.num_KIoPool = SlabCountKIoPool,.num_KIoRegion = SlabCountKIoRegion,+ .num_KSessionRequestMappings = SlabcountKSessionRequestMappings,};}@@ -164,29 +183,6 @@ size_t CalculateTotalSlabHeapSize(const KernelCore& kernel) {return size;}-void InitializeKPageBufferSlabHeap(Core::System& system) {- auto& kernel = system.Kernel();-- const auto& counts = kernel.SlabResourceCounts();- const size_t num_pages =- counts.num_KProcess + counts.num_KThread + (counts.num_KProcess + counts.num_KThread) / 8;- const size_t slab_size = num_pages * PageSize;-- // Reserve memory from the system resource limit.- ASSERT(kernel.GetSystemResourceLimit()->Reserve(LimitableResource::PhysicalMemory, slab_size));-- // Allocate memory for the slab.- constexpr auto AllocateOption = KMemoryManager::EncodeOption(- KMemoryManager::Pool::System, KMemoryManager::Direction::FromFront);- const PAddr slab_address =- kernel.MemoryManager().AllocateAndOpenContinuous(num_pages, 1, AllocateOption);- ASSERT(slab_address != 0);-- // Initialize the slabheap.- KPageBuffer::InitializeSlabHeap(kernel, system.DeviceMemory().GetPointer<void>(slab_address),- slab_size);-}-void InitializeSlabHeaps(Core::System& system, KMemoryLayout& memory_layout) {auto& kernel = system.Kernel();@@ -258,3 +254,29 @@ void InitializeSlabHeaps(Core::System& system, KMemoryLayout& memory_layout) {}} // namespace Kernel::Init++namespace Kernel {++void KPageBufferSlabHeap::Initialize(Core::System& system) {+ auto& kernel = system.Kernel();+ const auto& counts = kernel.SlabResourceCounts();+ const size_t num_pages =+ counts.num_KProcess + counts.num_KThread + (counts.num_KProcess + counts.num_KThread) / 8;+ const size_t slab_size = num_pages * PageSize;++ // Reserve memory from the system resource limit.+ ASSERT(kernel.GetSystemResourceLimit()->Reserve(LimitableResource::PhysicalMemory, slab_size));++ // Allocate memory for the slab.+ constexpr auto AllocateOption = KMemoryManager::EncodeOption(+ KMemoryManager::Pool::System, KMemoryManager::Direction::FromFront);+ const PAddr slab_address =+ kernel.MemoryManager().AllocateAndOpenContinuous(num_pages, 1, AllocateOption);+ ASSERT(slab_address != 0);++ // Initialize the slabheap.+ KPageBuffer::InitializeSlabHeap(kernel, system.DeviceMemory().GetPointer<void>(slab_address),+ slab_size);+}++} // namespace Kerneldiff --git a/src/core/hle/kernel/init/init_slab_setup.h b/src/core/hle/kernel/init/init_slab_setup.hindex 13be63c87d..5e22821bcc 100644--- a/src/core/hle/kernel/init/init_slab_setup.h+++ b/src/core/hle/kernel/init/init_slab_setup.h@@ -33,11 +33,11 @@ struct KSlabResourceCounts {size_t num_KDebug;size_t num_KIoPool;size_t num_KIoRegion;+ size_t num_KSessionRequestMappings;};void InitializeSlabResourceCounts(KernelCore& kernel);size_t CalculateTotalSlabHeapSize(const KernelCore& kernel);-void InitializeKPageBufferSlabHeap(Core::System& system);void InitializeSlabHeaps(Core::System& system, KMemoryLayout& memory_layout);} // namespace Kernel::Initdiff --git a/src/core/hle/kernel/k_page_table.cpp b/src/core/hle/kernel/k_page_table.cppindex 307e491cb5..c513e790e6 100644--- a/src/core/hle/kernel/k_page_table.cpp+++ b/src/core/hle/kernel/k_page_table.cpp@@ -15,6 +15,7 @@#include "core/hle/kernel/k_resource_limit.h"#include "core/hle/kernel/k_scoped_resource_reservation.h"#include "core/hle/kernel/k_system_control.h"+#include "core/hle/kernel/k_system_resource.h"#include "core/hle/kernel/kernel.h"#include "core/hle/kernel/svc_results.h"#include "core/memory.h"@@ -49,9 +50,10 @@ KPageTable::KPageTable(Core::System& system_)KPageTable::~KPageTable() = default;Result KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr,- VAddr code_addr, size_t code_size,- KMemoryBlockSlabManager* mem_block_slab_manager,- KMemoryManager::Pool pool) {+ bool enable_das_merge, bool from_back,+ KMemoryManager::Pool pool, VAddr code_addr,+ size_t code_size, KSystemResource* system_resource,+ KResourceLimit* resource_limit) {const auto GetSpaceStart = [this](KAddressSpaceInfo::Type type) {return KAddressSpaceInfo::GetAddressSpaceStart(m_address_space_width, type);@@ -116,7 +118,9 @@ Result KPageTable::InitializeForProcess(FileSys::ProgramAddressSpaceType as_typem_address_space_start = start;m_address_space_end = end;m_is_kernel = false;- m_memory_block_slab_manager = mem_block_slab_manager;+ m_memory_block_slab_manager = system_resource->GetMemoryBlockSlabManagerPointer();+ m_block_info_manager = system_resource->GetBlockInfoManagerPointer();+ m_resource_limit = resource_limit;// Determine the region we can place our undetermineds inVAddr alloc_start{};diff --git a/src/core/hle/kernel/k_page_table.h b/src/core/hle/kernel/k_page_table.hindex c6aeacd96c..753e07c94b 100644--- a/src/core/hle/kernel/k_page_table.h+++ b/src/core/hle/kernel/k_page_table.h@@ -23,7 +23,10 @@ class System;namespace Kernel {+class KBlockInfoManager;class KMemoryBlockManager;+class KResourceLimit;+class KSystemResource;class KPageTable final {public:@@ -36,9 +39,9 @@ public:~KPageTable();Result InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr,- VAddr code_addr, size_t code_size,- KMemoryBlockSlabManager* mem_block_slab_manager,- KMemoryManager::Pool pool);+ bool enable_das_merge, bool from_back, KMemoryManager::Pool pool,+ VAddr code_addr, size_t code_size, KSystemResource* system_resource,+ KResourceLimit* resource_limit);void Finalize();@@ -74,9 +77,9 @@ public:KMemoryState state, KMemoryPermission perm,PAddr map_addr = 0);- Result LockForMapDeviceAddressSpace(VAddr address, size_t size, KMemoryPermission perm,- bool is_aligned);- Result LockForUnmapDeviceAddressSpace(VAddr address, size_t size);+ Result LockForMapDeviceAddressSpace(bool* out_is_io, VAddr address, size_t size,+ KMemoryPermission perm, bool is_aligned, bool check_heap);+ Result LockForUnmapDeviceAddressSpace(VAddr address, size_t size, bool check_heap);Result UnlockForDeviceAddressSpace(VAddr addr, size_t size);@@ -99,11 +102,13 @@ public:private:enum class OperationType : u32 {- Map,- MapGroup,- Unmap,- ChangePermissions,- ChangePermissionsAndRefresh,+ Map = 0,+ MapFirst = 1,+ MapGroup = 2,+ Unmap = 3,+ ChangePermissions = 4,+ ChangePermissionsAndRefresh = 5,+ Separate = 6,};static constexpr KMemoryAttribute DefaultMemoryIgnoreAttr =@@ -199,6 +204,10 @@ private:return *out != 0;}+ // HACK: These will be removed once we automatically manage page reference counts.+ void HACK_OpenPages(PAddr phys_addr, size_t num_pages);+ void HACK_ClosePages(VAddr virt_addr, size_t num_pages);+mutable KLightLock m_general_lock;mutable KLightLock m_map_physical_memory_lock;@@ -347,20 +356,27 @@ private:VAddr m_alias_code_region_start{};VAddr m_alias_code_region_end{};- size_t m_mapped_physical_memory_size{};size_t m_max_heap_size{};- size_t m_max_physical_memory_size{};+ size_t m_mapped_physical_memory_size{};+ size_t m_mapped_unsafe_physical_memory{};+ size_t m_mapped_insecure_memory{};+ size_t m_mapped_ipc_server_memory{};size_t m_address_space_width{};KMemoryBlockManager m_memory_block_manager;+ u32 m_allocate_option{};bool m_is_kernel{};bool m_enable_aslr{};bool m_enable_device_address_space_merge{};KMemoryBlockSlabManager* m_memory_block_slab_manager{};+ KBlockInfoManager* m_block_info_manager{};+ KResourceLimit* m_resource_limit{};u32 m_heap_fill_value{};+ u32 m_ipc_fill_value{};+ u32 m_stack_fill_value{};const KMemoryRegion* m_cached_physical_heap_region{};KMemoryManager::Pool m_memory_pool{KMemoryManager::Pool::Application};diff --git a/src/core/hle/kernel/k_process.cpp b/src/core/hle/kernel/k_process.cppindex 8c3495e5a5..4ddeea73b3 100644--- a/src/core/hle/kernel/k_process.cpp+++ b/src/core/hle/kernel/k_process.cpp@@ -358,8 +358,8 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:}// Initialize proces address spaceif (const Result result{page_table.InitializeForProcess(- metadata.GetAddressSpaceType(), false, 0x8000000, code_size,- &kernel.GetApplicationMemoryBlockManager(), KMemoryManager::Pool::Application)};+ metadata.GetAddressSpaceType(), false, false, false, KMemoryManager::Pool::Application,+ 0x8000000, code_size, &kernel.GetSystemSystemResource(), resource_limit)};result.IsError()) {R_RETURN(result);}diff --git a/src/core/hle/kernel/kernel.cpp b/src/core/hle/kernel/kernel.cppindex fc94cb22ce..eda4e9e1c4 100644--- a/src/core/hle/kernel/kernel.cpp+++ b/src/core/hle/kernel/kernel.cpp@@ -28,10 +28,12 @@#include "core/hle/kernel/k_handle_table.h"#include "core/hle/kernel/k_memory_layout.h"#include "core/hle/kernel/k_memory_manager.h"+#include "core/hle/kernel/k_page_buffer.h"#include "core/hle/kernel/k_process.h"#include "core/hle/kernel/k_resource_limit.h"#include "core/hle/kernel/k_scheduler.h"#include "core/hle/kernel/k_shared_memory.h"+#include "core/hle/kernel/k_system_resource.h"#include "core/hle/kernel/k_thread.h"#include "core/hle/kernel/k_worker_task_manager.h"#include "core/hle/kernel/kernel.h"@@ -47,6 +49,11 @@ MICROPROFILE_DEFINE(Kernel_SVC, "Kernel", "SVC", MP_RGB(70, 200, 70));namespace Kernel {struct KernelCore::Impl {+ static constexpr size_t ApplicationMemoryBlockSlabHeapSize = 20000;+ static constexpr size_t SystemMemoryBlockSlabHeapSize = 10000;+ static constexpr size_t BlockInfoSlabHeapSize = 4000;+ static constexpr size_t ReservedDynamicPageCount = 64;+explicit Impl(Core::System& system_, KernelCore& kernel_): time_manager{system_}, service_threads_manager{1, "ServiceThreadsManager"},service_thread_barrier{2}, system{system_} {}@@ -72,7 +79,6 @@ struct KernelCore::Impl {// Initialize kernel memory and resources.InitializeSystemResourceLimit(kernel, system.CoreTiming());InitializeMemoryLayout();- Init::InitializeKPageBufferSlabHeap(system);InitializeShutdownThreads();InitializePhysicalCores();InitializePreemption(kernel);@@ -82,7 +88,8 @@ struct KernelCore::Impl {const auto& pt_heap_region = memory_layout->GetPageTableHeapRegion();ASSERT(pt_heap_region.GetEndAddress() != 0);- InitializeResourceManagers(pt_heap_region.GetAddress(), pt_heap_region.GetSize());+ InitializeResourceManagers(kernel, pt_heap_region.GetAddress(),+ pt_heap_region.GetSize());}RegisterHostThread();@@ -263,16 +270,82 @@ struct KernelCore::Impl {system.CoreTiming().ScheduleLoopingEvent(time_interval, time_interval, preemption_event);}- void InitializeResourceManagers(VAddr address, size_t size) {- dynamic_page_manager = std::make_unique<KDynamicPageManager>();- memory_block_heap = std::make_unique<KMemoryBlockSlabHeap>();+ void InitializeResourceManagers(KernelCore& kernel, VAddr address, size_t size) {+ // Ensure that the buffer is suitable for our use.+ ASSERT(Common::IsAligned(address, PageSize));+ ASSERT(Common::IsAligned(size, PageSize));++ // Ensure that we have space for our reference counts.+ const size_t rc_size =+ Common::AlignUp(KPageTableSlabHeap::CalculateReferenceCountSize(size), PageSize);+ ASSERT(rc_size < size);+ size -= rc_size;++ // Initialize the resource managers' shared page manager.+ resource_manager_page_manager = std::make_unique<KDynamicPageManager>();+ 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);++ // 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>();++ // TODO(bunnei): Pass in address once we support kernel virtual memory allocations.+ page_table_heap->Initialize(+ resource_manager_page_manager.get(), 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>();-- dynamic_page_manager->Initialize(address, size);- static constexpr size_t ApplicationMemoryBlockSlabHeapSize = 20000;- memory_block_heap->Initialize(dynamic_page_manager.get(),- ApplicationMemoryBlockSlabHeapSize);- app_memory_block_manager->Initialize(nullptr, memory_block_heap.get());+ 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>();++ 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_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_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());++ // 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);++ // Set the managers for the system resources.+ app_system_resource->SetManagers(*app_memory_block_manager, *app_block_info_manager,+ *app_page_table_manager);+ sys_system_resource->SetManagers(*sys_memory_block_manager, *sys_block_info_manager,+ *sys_page_table_manager);}void InitializeShutdownThreads() {@@ -767,6 +840,8 @@ struct KernelCore::Impl {Init::KSlabResourceCounts slab_resource_counts{};KResourceLimit* system_resource_limit{};+ KPageBufferSlabHeap page_buffer_slab_heap;+std::shared_ptr<Core::Timing::EventType> preemption_event;// This is the kernel's handle table or supervisor handle table which@@ -792,10 +867,20 @@ struct KernelCore::Impl {// Kernel memory managementstd::unique_ptr<KMemoryManager> memory_manager;- // Dynamic slab managers- std::unique_ptr<KDynamicPageManager> dynamic_page_manager;- std::unique_ptr<KMemoryBlockSlabHeap> memory_block_heap;+ // 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;// Shared memory for servicesKernel::KSharedMemory* hid_shared_mem{};@@ -1073,12 +1158,12 @@ const KMemoryManager& KernelCore::MemoryManager() const {return *impl->memory_manager;}-KMemoryBlockSlabManager& KernelCore::GetApplicationMemoryBlockManager() {- return *impl->app_memory_block_manager;+KSystemResource& KernelCore::GetSystemSystemResource() {+ return *impl->sys_system_resource;}-const KMemoryBlockSlabManager& KernelCore::GetApplicationMemoryBlockManager() const {- return *impl->app_memory_block_manager;+const KSystemResource& KernelCore::GetSystemSystemResource() const {+ return *impl->sys_system_resource;}Kernel::KSharedMemory& KernelCore::GetHidSharedMem() {diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.hindex 266be2bc4f..2549503fcb 100644--- a/src/core/hle/kernel/kernel.h+++ b/src/core/hle/kernel/kernel.h@@ -34,13 +34,16 @@ class KClientPort;class GlobalSchedulerContext;class KAutoObjectWithListContainer;class KClientSession;+class KDebug;+class KDynamicPageManager;class KEvent;+class KEventInfo;class KHandleTable;class KLinkedListNode;-class KMemoryBlockSlabManager;class KMemoryLayout;class KMemoryManager;class KPageBuffer;+class KPageBufferSlabHeap;class KPort;class KProcess;class KResourceLimit;@@ -50,6 +53,7 @@ class KSession;class KSessionRequest;class KSharedMemory;class KSharedMemoryInfo;+class KSecureSystemResource;class KThread;class KThreadLocalPage;class KTransferMemory;@@ -243,11 +247,11 @@ public:/// Gets the virtual memory manager for the kernel.const KMemoryManager& MemoryManager() const;- /// Gets the application memory block manager for the kernel.- KMemoryBlockSlabManager& GetApplicationMemoryBlockManager();+ /// Gets the system resource manager.+ KSystemResource& GetSystemSystemResource();- /// Gets the application memory block manager for the kernel.- const KMemoryBlockSlabManager& GetApplicationMemoryBlockManager() const;+ /// Gets the system resource manager.+ const KSystemResource& GetSystemSystemResource() const;/// Gets the shared memory object for HID services.Kernel::KSharedMemory& GetHidSharedMem();@@ -363,6 +367,12 @@ public:return slab_heap_container->thread_local_page;} else if constexpr (std::is_same_v<T, KSessionRequest>) {return slab_heap_container->session_request;+ } else if constexpr (std::is_same_v<T, KSecureSystemResource>) {+ return slab_heap_container->secure_system_resource;+ } else if constexpr (std::is_same_v<T, KEventInfo>) {+ return slab_heap_container->event_info;+ } else if constexpr (std::is_same_v<T, KDebug>) {+ return slab_heap_container->debug;}}@@ -426,6 +436,9 @@ private:KSlabHeap<KPageBuffer> page_buffer;KSlabHeap<KThreadLocalPage> thread_local_page;KSlabHeap<KSessionRequest> session_request;+ KSlabHeap<KSecureSystemResource> secure_system_resource;+ KSlabHeap<KEventInfo> event_info;+ KSlabHeap<KDebug> debug;};std::unique_ptr<SlabHeapContainer> slab_heap_container;