1 files changed, 26 insertions, 12 deletions

diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index 266be2bc4..caca60586 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -34,22 +34,27 @@ 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;
 class KScheduler;
+class KServerPort;
 class KServerSession;
 class KSession;
 class KSessionRequest;
 class KSharedMemory;
 class KSharedMemoryInfo;
+class KSecureSystemResource;
 class KThread;
 class KThreadLocalPage;
 class KTransferMemory;
@@ -63,6 +68,8 @@ class TimeManager;
 using ServiceInterfaceFactory =
     std::function<KClientPort&(Service::SM::ServiceManager&, Core::System&)>;
 
+using ServiceInterfaceHandlerFn = std::function<void(Service::SM::ServiceManager&, KServerPort*)>;
+
 namespace Init {
 struct KSlabResourceCounts;
 }
@@ -192,16 +199,14 @@ public:
     /// Registers a named HLE service, passing a factory used to open a port to that service.
     void RegisterNamedService(std::string name, ServiceInterfaceFactory&& factory);
 
+    /// Registers a setup function for the named HLE service.
+    void RegisterInterfaceForNamedService(std::string name, ServiceInterfaceHandlerFn&& handler);
+
     /// Opens a port to a service previously registered with RegisterNamedService.
     KClientPort* CreateNamedServicePort(std::string name);
 
-    /// Registers a server session or port with the gobal emulation state, to be freed on shutdown.
-    /// This is necessary because we do not emulate processes for HLE sessions and ports.
-    void RegisterServerObject(KAutoObject* server_object);
-
-    /// Unregisters a server session or port previously registered with RegisterServerSession when
-    /// it was destroyed during the current emulation session.
-    void UnregisterServerObject(KAutoObject* server_object);
+    /// Accepts a session on a port created by CreateNamedServicePort.
+    void RegisterNamedServiceHandler(std::string name, KServerPort* server_port);
 
     /// Registers all kernel objects with the global emulation state, this is purely for tracking
     /// leaks after emulation has been shutdown.
@@ -243,11 +248,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 +368,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 +437,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;