1 files changed, 42 insertions, 128 deletions

diff --git a/src/core/hle/kernel/kernel.h b/src/core/hle/kernel/kernel.h
index 8d22f8d2c..d5b08eeb5 100644
--- a/src/core/hle/kernel/kernel.h
+++ b/src/core/hle/kernel/kernel.h
@@ -9,9 +9,12 @@
 #include <string>
 #include <unordered_map>
 #include <vector>
+
+#include "common/polyfill_thread.h"
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/k_auto_object.h"
 #include "core/hle/kernel/k_slab_heap.h"
+#include "core/hle/kernel/k_typed_address.h"
 #include "core/hle/kernel/svc_common.h"
 
 namespace Core {
@@ -24,6 +27,10 @@ class CoreTiming;
 struct EventType;
 } // namespace Core::Timing
 
+namespace Service {
+class ServerManager;
+}
+
 namespace Service::SM {
 class ServiceManager;
 }
@@ -35,14 +42,16 @@ class GlobalSchedulerContext;
 class KAutoObjectWithListContainer;
 class KClientSession;
 class KDebug;
+class KDeviceAddressSpace;
 class KDynamicPageManager;
 class KEvent;
 class KEventInfo;
 class KHandleTable;
 class KHardwareTimer;
-class KLinkedListNode;
 class KMemoryLayout;
 class KMemoryManager;
+class KObjectName;
+class KObjectNameGlobalData;
 class KPageBuffer;
 class KPageBufferSlabHeap;
 class KPort;
@@ -62,13 +71,6 @@ class KTransferMemory;
 class KWorkerTaskManager;
 class KCodeMemory;
 class PhysicalCore;
-class ServiceThread;
-class Synchronization;
-
-using ServiceInterfaceFactory =
-    std::function<KClientPort&(Service::SM::ServiceManager&, Core::System&)>;
-
-using ServiceInterfaceHandlerFn = std::function<void(Service::SM::ServiceManager&, KServerPort*)>;
 
 namespace Init {
 struct KSlabResourceCounts;
@@ -77,15 +79,8 @@ struct KSlabResourceCounts;
 template <typename T>
 class KSlabHeap;
 
-using EmuThreadHandle = uintptr_t;
-constexpr EmuThreadHandle EmuThreadHandleInvalid{};
-constexpr EmuThreadHandle EmuThreadHandleReserved{1ULL << 63};
-
 /// Represents a single instance of the kernel.
 class KernelCore {
-private:
-    using NamedPortTable = std::unordered_map<std::string, KClientPort*>;
-
 public:
     /// Constructs an instance of the kernel using the given System
     /// instance as a context for any necessary system-related state,
@@ -130,17 +125,17 @@ public:
     /// Adds the given shared pointer to an internal list of active processes.
     void AppendNewProcess(KProcess* process);
 
-    /// Makes the given process the new current process.
-    void MakeCurrentProcess(KProcess* process);
+    /// Makes the given process the new application process.
+    void MakeApplicationProcess(KProcess* process);
 
-    /// Retrieves a pointer to the current process.
-    KProcess* CurrentProcess();
+    /// Retrieves a pointer to the application process.
+    KProcess* ApplicationProcess();
 
-    /// Retrieves a const pointer to the current process.
-    const KProcess* CurrentProcess() const;
+    /// Retrieves a const pointer to the application process.
+    const KProcess* ApplicationProcess() const;
 
-    /// Closes the current process.
-    void CloseCurrentProcess();
+    /// Closes the application process.
+    void CloseApplicationProcess();
 
     /// Retrieves the list of processes.
     const std::vector<KProcess*>& GetProcessList() const;
@@ -191,19 +186,7 @@ public:
 
     void InvalidateAllInstructionCaches();
 
-    void InvalidateCpuInstructionCacheRange(VAddr addr, std::size_t size);
-
-    /// 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);
-
-    /// Accepts a session on a port created by CreateNamedServicePort.
-    void RegisterNamedServiceHandler(std::string name, KServerPort* server_port);
+    void InvalidateCpuInstructionCacheRange(KProcessAddress addr, std::size_t size);
 
     /// Registers all kernel objects with the global emulation state, this is purely for tracking
     /// leaks after emulation has been shutdown.
@@ -221,8 +204,8 @@ public:
     /// destroyed during the current emulation session.
     void UnregisterInUseObject(KAutoObject* object);
 
-    /// Determines whether or not the given port is a valid named port.
-    bool IsValidNamedPort(NamedPortTable::const_iterator port) const;
+    // Runs the given server manager until shutdown.
+    void RunServer(std::unique_ptr<Service::ServerManager>&& server_manager);
 
     /// Gets the current host_thread/guest_thread pointer.
     KThread* GetCurrentEmuThread() const;
@@ -239,12 +222,27 @@ public:
     /// Register the current thread as a non CPU core thread.
     void RegisterHostThread(KThread* existing_thread = nullptr);
 
+    void RunOnGuestCoreProcess(std::string&& process_name, std::function<void()> func);
+
+    std::jthread RunOnHostCoreProcess(std::string&& process_name, std::function<void()> func);
+
+    std::jthread RunOnHostCoreThread(std::string&& thread_name, std::function<void()> func);
+
+    /// Gets global data for KObjectName.
+    KObjectNameGlobalData& ObjectNameGlobalData();
+
     /// Gets the virtual memory manager for the kernel.
     KMemoryManager& MemoryManager();
 
     /// Gets the virtual memory manager for the kernel.
     const KMemoryManager& MemoryManager() const;
 
+    /// Gets the application resource manager.
+    KSystemResource& GetAppSystemResource();
+
+    /// Gets the application resource manager.
+    const KSystemResource& GetAppSystemResource() const;
+
     /// Gets the system resource manager.
     KSystemResource& GetSystemSystemResource();
 
@@ -281,11 +279,11 @@ public:
     /// Gets the shared memory object for HIDBus services.
     const Kernel::KSharedMemory& GetHidBusSharedMem() const;
 
-    /// Suspend/unsuspend all processes.
-    void Suspend(bool suspend);
+    /// Suspend/unsuspend application process.
+    void SuspendApplication(bool suspend);
 
-    /// Exceptional exit all processes.
-    void ExceptionalExit();
+    /// Exceptional exit application process.
+    void ExceptionalExitApplication();
 
     /// Notify emulated CPU cores to shut down.
     void ShutdownCores();
@@ -298,33 +296,6 @@ public:
 
     void ExitSVCProfile();
 
-    /**
-     * Creates a host thread to execute HLE service requests, which are used to execute service
-     * routines asynchronously. While these are allocated per ServerSession, these need to be owned
-     * and managed outside of ServerSession to avoid a circular dependency. In general, most
-     * services can just use the default service thread, and not need their own host service thread.
-     * See GetDefaultServiceThread.
-     * @param name String name for the ServerSession creating this thread, used for debug
-     * purposes.
-     * @returns A reference to the newly created service thread.
-     */
-    Kernel::ServiceThread& CreateServiceThread(const std::string& name);
-
-    /**
-     * Gets the default host service thread, which executes HLE service requests. Unless service
-     * requests need to block on the host, the default service thread should be used in favor of
-     * creating a new service thread.
-     * @returns A reference to the default service thread.
-     */
-    Kernel::ServiceThread& GetDefaultServiceThread() const;
-
-    /**
-     * Releases a HLE service thread, instructing KernelCore to free it. This should be called when
-     * the ServerSession associated with the thread is destroyed.
-     * @param service_thread Service thread to release.
-     */
-    void ReleaseServiceThread(Kernel::ServiceThread& service_thread);
-
     /// Workaround for single-core mode when preempting threads while idle.
     bool IsPhantomModeForSingleCore() const;
     void SetIsPhantomModeForSingleCore(bool value);
@@ -334,45 +305,7 @@ public:
 
     /// Gets the slab heap for the specified kernel object type.
     template <typename T>
-    KSlabHeap<T>& SlabHeap() {
-        if constexpr (std::is_same_v<T, KClientSession>) {
-            return slab_heap_container->client_session;
-        } else if constexpr (std::is_same_v<T, KEvent>) {
-            return slab_heap_container->event;
-        } else if constexpr (std::is_same_v<T, KLinkedListNode>) {
-            return slab_heap_container->linked_list_node;
-        } else if constexpr (std::is_same_v<T, KPort>) {
-            return slab_heap_container->port;
-        } else if constexpr (std::is_same_v<T, KProcess>) {
-            return slab_heap_container->process;
-        } else if constexpr (std::is_same_v<T, KResourceLimit>) {
-            return slab_heap_container->resource_limit;
-        } else if constexpr (std::is_same_v<T, KSession>) {
-            return slab_heap_container->session;
-        } else if constexpr (std::is_same_v<T, KSharedMemory>) {
-            return slab_heap_container->shared_memory;
-        } else if constexpr (std::is_same_v<T, KSharedMemoryInfo>) {
-            return slab_heap_container->shared_memory_info;
-        } else if constexpr (std::is_same_v<T, KThread>) {
-            return slab_heap_container->thread;
-        } else if constexpr (std::is_same_v<T, KTransferMemory>) {
-            return slab_heap_container->transfer_memory;
-        } else if constexpr (std::is_same_v<T, KCodeMemory>) {
-            return slab_heap_container->code_memory;
-        } else if constexpr (std::is_same_v<T, KPageBuffer>) {
-            return slab_heap_container->page_buffer;
-        } else if constexpr (std::is_same_v<T, KThreadLocalPage>) {
-            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;
-        }
-    }
+    KSlabHeap<T>& SlabHeap();
 
     /// Gets the current slab resource counts.
     Init::KSlabResourceCounts& SlabResourceCounts();
@@ -418,26 +351,7 @@ private:
 
 private:
     /// Helper to encapsulate all slab heaps in a single heap allocated container
-    struct SlabHeapContainer {
-        KSlabHeap<KClientSession> client_session;
-        KSlabHeap<KEvent> event;
-        KSlabHeap<KLinkedListNode> linked_list_node;
-        KSlabHeap<KPort> port;
-        KSlabHeap<KProcess> process;
-        KSlabHeap<KResourceLimit> resource_limit;
-        KSlabHeap<KSession> session;
-        KSlabHeap<KSharedMemory> shared_memory;
-        KSlabHeap<KSharedMemoryInfo> shared_memory_info;
-        KSlabHeap<KThread> thread;
-        KSlabHeap<KTransferMemory> transfer_memory;
-        KSlabHeap<KCodeMemory> code_memory;
-        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;
-    };
+    struct SlabHeapContainer;
 
     std::unique_ptr<SlabHeapContainer> slab_heap_container;
 };