early-access version 3408

README.md

@@ -1,7 +1,7 @@
 yuzu emulator early access
 =============
 
-This is the source code for early-access 3406.
+This is the source code for early-access 3408.
 
 ## Legal Notice
 

src/core/CMakeLists.txt

@@ -225,6 +225,8 @@ add_library(core STATIC
     hle/kernel/k_memory_manager.h
     hle/kernel/k_memory_region.h
     hle/kernel/k_memory_region_type.h
+    hle/kernel/k_object_name.cpp
+    hle/kernel/k_object_name.h
     hle/kernel/k_page_bitmap.h
     hle/kernel/k_page_buffer.cpp
     hle/kernel/k_page_buffer.h
@@ -291,8 +293,6 @@ add_library(core STATIC
     hle/kernel/physical_memory.h
     hle/kernel/process_capability.cpp
     hle/kernel/process_capability.h
-    hle/kernel/service_thread.cpp
-    hle/kernel/service_thread.h
     hle/kernel/slab_helpers.h
     hle/kernel/svc.cpp
     hle/kernel/svc.h
@@ -682,6 +682,10 @@ add_library(core STATIC
     hle/service/ptm/ts.h
     hle/service/kernel_helpers.cpp
     hle/service/kernel_helpers.h
+    hle/service/mutex.cpp
+    hle/service/mutex.h
+    hle/service/server_manager.cpp
+    hle/service/server_manager.h
     hle/service/service.cpp
     hle/service/service.h
     hle/service/set/set.cpp

src/core/core.cpp

@@ -380,9 +380,7 @@ struct System::Impl {
             gpu_core->NotifyShutdown();
         }
 
-        kernel.ShutdownCores();
-        cpu_manager.Shutdown();
-        debugger.reset();
+        kernel.SuspendApplication(true);
         if (services) {
             services->KillNVNFlinger();
         }
@@ -398,6 +396,9 @@ struct System::Impl {
         gpu_core.reset();
         host1x_core.reset();
         perf_stats.reset();
+        kernel.ShutdownCores();
+        cpu_manager.Shutdown();
+        debugger.reset();
         kernel.Shutdown();
         memory.Reset();
 
@@ -938,6 +939,10 @@ const Network::RoomNetwork& System::GetRoomNetwork() const {
     return impl->room_network;
 }
 
+void System::RunServer(std::unique_ptr<Service::ServerManager>&& server_manager) {
+    return impl->kernel.RunServer(std::move(server_manager));
+}
+
 void System::RegisterExecuteProgramCallback(ExecuteProgramCallback&& callback) {
     impl->execute_program_callback = std::move(callback);
 }

src/core/core.h

@@ -61,6 +61,8 @@ namespace Glue {
 class ARPManager;
 }
 
+class ServerManager;
+
 namespace SM {
 class ServiceManager;
 } // namespace SM
@@ -417,6 +419,9 @@ public:
     /// Tells if the system debugger is enabled.
     [[nodiscard]] bool DebuggerEnabled() const;
 
+    /// Runs a server instance until shutdown.
+    void RunServer(std::unique_ptr<Service::ServerManager>&& server_manager);
+
     /// Type used for the frontend to designate a callback for System to re-launch the application
     /// using a specified program index.
     using ExecuteProgramCallback = std::function<void(std::size_t)>;

src/core/debugger/debugger.cpp

@@ -16,6 +16,7 @@
 #include "core/debugger/debugger_interface.h"
 #include "core/debugger/gdbstub.h"
 #include "core/hle/kernel/global_scheduler_context.h"
+#include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_scheduler.h"
 
 template <typename Readable, typename Buffer, typename Callback>
@@ -284,12 +285,12 @@ private:
     void UpdateActiveThread() {
         const auto& threads{ThreadList()};
         if (std::find(threads.begin(), threads.end(), state->active_thread) == threads.end()) {
-            state->active_thread = threads[0];
+            state->active_thread = threads.front();
         }
     }
 
-    const std::vector<Kernel::KThread*>& ThreadList() {
-        return system.GlobalSchedulerContext().GetThreadList();
+    const std::list<Kernel::KThread*>& ThreadList() {
+        return system.ApplicationProcess()->GetThreadList();
     }
 
 private:

src/core/debugger/gdbstub.cpp

@@ -573,7 +573,7 @@ void GDBStub::HandleQuery(std::string_view command) {
         SendReply(PaginateBuffer(buffer, command.substr(21)));
     } else if (command.starts_with("fThreadInfo")) {
         // beginning of list
-        const auto& threads = system.GlobalSchedulerContext().GetThreadList();
+        const auto& threads = system.ApplicationProcess()->GetThreadList();
         std::vector<std::string> thread_ids;
         for (const auto& thread : threads) {
             thread_ids.push_back(fmt::format("{:x}", thread->GetThreadID()));
@@ -587,7 +587,7 @@ void GDBStub::HandleQuery(std::string_view command) {
         buffer += R"(<?xml version="1.0"?>)";
         buffer += "<threads>";
 
-        const auto& threads = system.GlobalSchedulerContext().GetThreadList();
+        const auto& threads = system.ApplicationProcess()->GetThreadList();
         for (const auto* thread : threads) {
             auto thread_name{GetThreadName(system, thread)};
             if (!thread_name) {
@@ -817,7 +817,7 @@ void GDBStub::HandleRcmd(const std::vector<u8>& command) {
 }
 
 Kernel::KThread* GDBStub::GetThreadByID(u64 thread_id) {
-    const auto& threads{system.GlobalSchedulerContext().GetThreadList()};
+    const auto& threads{system.ApplicationProcess()->GetThreadList()};
     for (auto* thread : threads) {
         if (thread->GetThreadID() == thread_id) {
             return thread;

src/core/hle/ipc_helpers.h

@@ -15,6 +15,7 @@
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_session.h"
 #include "core/hle/result.h"
+#include "core/hle/service/server_manager.h"
 
 namespace IPC {
 
@@ -145,7 +146,9 @@ public:
 
     template <class T>
     void PushIpcInterface(std::shared_ptr<T> iface) {
-        if (context->GetManager()->IsDomain()) {
+        auto manager{context->GetManager()};
+
+        if (manager->IsDomain()) {
             context->AddDomainObject(std::move(iface));
         } else {
             kernel.ApplicationProcess()->GetResourceLimit()->Reserve(
@@ -153,8 +156,11 @@ public:
 
             auto* session = Kernel::KSession::Create(kernel);
             session->Initialize(nullptr, iface->GetServiceName());
-            iface->RegisterSession(&session->GetServerSession(),
-                                   std::make_shared<Kernel::SessionRequestManager>(kernel));
+
+            auto next_manager = std::make_shared<Kernel::SessionRequestManager>(
+                kernel, manager->GetServerManager());
+            next_manager->SetSessionHandler(iface);
+            manager->GetServerManager().RegisterSession(&session->GetServerSession(), next_manager);
 
             context->AddMoveObject(&session->GetClientSession());
         }

src/core/hle/kernel/hle_ipc.cpp

@@ -21,36 +21,18 @@
 #include "core/hle/kernel/k_server_session.h"
 #include "core/hle/kernel/k_thread.h"
 #include "core/hle/kernel/kernel.h"
-#include "core/hle/kernel/service_thread.h"
 #include "core/memory.h"
 
 namespace Kernel {
 
-SessionRequestHandler::SessionRequestHandler(KernelCore& kernel_, const char* service_name_,
-                                             ServiceThreadType thread_type)
-    : kernel{kernel_}, service_thread{thread_type == ServiceThreadType::CreateNew
-                                          ? kernel.CreateServiceThread(service_name_)
-                                          : kernel.GetDefaultServiceThread()} {}
+SessionRequestHandler::SessionRequestHandler(KernelCore& kernel_, const char* service_name_)
+    : kernel{kernel_} {}
 
-SessionRequestHandler::~SessionRequestHandler() {
-    kernel.ReleaseServiceThread(service_thread);
-}
+SessionRequestHandler::~SessionRequestHandler() = default;
 
-void SessionRequestHandler::AcceptSession(KServerPort* server_port) {
-    auto* server_session = server_port->AcceptSession();
-    ASSERT(server_session != nullptr);
-
-    RegisterSession(server_session, std::make_shared<SessionRequestManager>(kernel));
-}
-
-void SessionRequestHandler::RegisterSession(KServerSession* server_session,
-                                            std::shared_ptr<SessionRequestManager> manager) {
-    manager->SetSessionHandler(shared_from_this());
-    service_thread.RegisterServerSession(server_session, manager);
-    server_session->Close();
-}
-
-SessionRequestManager::SessionRequestManager(KernelCore& kernel_) : kernel{kernel_} {}
+SessionRequestManager::SessionRequestManager(KernelCore& kernel_,
+                                             Service::ServerManager& server_manager_)
+    : kernel{kernel_}, server_manager{server_manager_} {}
 
 SessionRequestManager::~SessionRequestManager() = default;
 

src/core/hle/kernel/hle_ipc.h

@@ -31,12 +31,8 @@ class ResponseBuilder;
 
 namespace Service {
 class ServiceFrameworkBase;
-}
-
-enum class ServiceThreadType {
-    Default,
-    CreateNew,
-};
+class ServerManager;
+} // namespace Service
 
 namespace Kernel {
 
@@ -53,9 +49,6 @@ class KThread;
 class KReadableEvent;
 class KSession;
 class SessionRequestManager;
-class ServiceThread;
-
-enum class ThreadWakeupReason;
 
 /**
  * Interface implemented by HLE Session handlers.
@@ -64,8 +57,7 @@ enum class ThreadWakeupReason;
  */
 class SessionRequestHandler : public std::enable_shared_from_this<SessionRequestHandler> {
 public:
-    SessionRequestHandler(KernelCore& kernel_, const char* service_name_,
-                          ServiceThreadType thread_type);
+    SessionRequestHandler(KernelCore& kernel_, const char* service_name_);
     virtual ~SessionRequestHandler();
 
     /**
@@ -79,17 +71,8 @@ public:
     virtual Result HandleSyncRequest(Kernel::KServerSession& session,
                                      Kernel::HLERequestContext& context) = 0;
 
-    void AcceptSession(KServerPort* server_port);
-    void RegisterSession(KServerSession* server_session,
-                         std::shared_ptr<SessionRequestManager> manager);
-
-    ServiceThread& GetServiceThread() const {
-        return service_thread;
-    }
-
 protected:
     KernelCore& kernel;
-    ServiceThread& service_thread;
 };
 
 using SessionRequestHandlerWeakPtr = std::weak_ptr<SessionRequestHandler>;
@@ -102,7 +85,7 @@ using SessionRequestHandlerPtr = std::shared_ptr<SessionRequestHandler>;
  */
 class SessionRequestManager final {
 public:
-    explicit SessionRequestManager(KernelCore& kernel);
+    explicit SessionRequestManager(KernelCore& kernel, Service::ServerManager& server_manager);
     ~SessionRequestManager();
 
     bool IsDomain() const {
@@ -155,15 +138,15 @@ public:
         session_handler = std::move(handler);
     }
 
-    ServiceThread& GetServiceThread() const {
-        return session_handler->GetServiceThread();
-    }
-
     bool HasSessionRequestHandler(const HLERequestContext& context) const;
 
     Result HandleDomainSyncRequest(KServerSession* server_session, HLERequestContext& context);
     Result CompleteSyncRequest(KServerSession* server_session, HLERequestContext& context);
 
+    Service::ServerManager& GetServerManager() {
+        return server_manager;
+    }
+
 private:
     bool convert_to_domain{};
     bool is_domain{};
@@ -172,6 +155,7 @@ private:
 
 private:
     KernelCore& kernel;
+    Service::ServerManager& server_manager;
 };
 
 /**

src/core/hle/kernel/init/init_slab_setup.cpp

@@ -16,6 +16,7 @@
 #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_object_name.h"
 #include "core/hle/kernel/k_page_buffer.h"
 #include "core/hle/kernel/k_port.h"
 #include "core/hle/kernel/k_process.h"
@@ -49,6 +50,7 @@ namespace Kernel::Init {
     HANDLER(KThreadLocalPage,                                                                      \
             (SLAB_COUNT(KProcess) + (SLAB_COUNT(KProcess) + SLAB_COUNT(KThread)) / 8),             \
             ##__VA_ARGS__)                                                                         \
+    HANDLER(KObjectName, (SLAB_COUNT(KObjectName)), ##__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__)                                           \

src/core/hle/kernel/k_object_name.cpp

@@ -0,0 +1,102 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/hle/kernel/k_object_name.h"
+
+namespace Kernel {
+
+KObjectNameGlobalData::KObjectNameGlobalData(KernelCore& kernel) : m_object_list_lock{kernel} {}
+KObjectNameGlobalData::~KObjectNameGlobalData() = default;
+
+void KObjectName::Initialize(KAutoObject* obj, const char* name) {
+    // Set member variables.
+    m_object = obj;
+    std::strncpy(m_name.data(), name, sizeof(m_name) - 1);
+    m_name[sizeof(m_name) - 1] = '\x00';
+
+    // Open a reference to the object we hold.
+    m_object->Open();
+}
+
+bool KObjectName::MatchesName(const char* name) const {
+    return std::strncmp(m_name.data(), name, sizeof(m_name)) == 0;
+}
+
+Result KObjectName::NewFromName(KernelCore& kernel, KAutoObject* obj, const char* name) {
+    // Create a new object name.
+    KObjectName* new_name = KObjectName::Allocate(kernel);
+    R_UNLESS(new_name != nullptr, ResultOutOfResource);
+
+    // Initialize the new name.
+    new_name->Initialize(obj, name);
+
+    // Check if there's an existing name.
+    {
+        // Get the global data.
+        KObjectNameGlobalData& gd{kernel.ObjectNameGlobalData()};
+
+        // Ensure we have exclusive access to the global list.
+        KScopedLightLock lk{gd.GetObjectListLock()};
+
+        // If the object doesn't exist, put it into the list.
+        KScopedAutoObject existing_object = FindImpl(kernel, name);
+        if (existing_object.IsNull()) {
+            gd.GetObjectList().push_back(*new_name);
+            R_SUCCEED();
+        }
+    }
+
+    // The object already exists, which is an error condition. Perform cleanup.
+    obj->Close();
+    KObjectName::Free(kernel, new_name);
+    R_THROW(ResultInvalidState);
+}
+
+Result KObjectName::Delete(KernelCore& kernel, KAutoObject* obj, const char* compare_name) {
+    // Get the global data.
+    KObjectNameGlobalData& gd{kernel.ObjectNameGlobalData()};
+
+    // Ensure we have exclusive access to the global list.
+    KScopedLightLock lk{gd.GetObjectListLock()};
+
+    // Find a matching entry in the list, and delete it.
+    for (auto& name : gd.GetObjectList()) {
+        if (name.MatchesName(compare_name) && obj == name.GetObject()) {
+            // We found a match, clean up its resources.
+            obj->Close();
+            gd.GetObjectList().erase(gd.GetObjectList().iterator_to(name));
+            KObjectName::Free(kernel, std::addressof(name));
+            R_SUCCEED();
+        }
+    }
+
+    // We didn't find the object in the list.
+    R_THROW(ResultNotFound);
+}
+
+KScopedAutoObject<KAutoObject> KObjectName::Find(KernelCore& kernel, const char* name) {
+    // Get the global data.
+    KObjectNameGlobalData& gd{kernel.ObjectNameGlobalData()};
+
+    // Ensure we have exclusive access to the global list.
+    KScopedLightLock lk{gd.GetObjectListLock()};
+
+    return FindImpl(kernel, name);
+}
+
+KScopedAutoObject<KAutoObject> KObjectName::FindImpl(KernelCore& kernel, const char* compare_name) {
+    // Get the global data.
+    KObjectNameGlobalData& gd{kernel.ObjectNameGlobalData()};
+
+    // Try to find a matching object in the global list.
+    for (const auto& name : gd.GetObjectList()) {
+        if (name.MatchesName(compare_name)) {
+            return name.GetObject();
+        }
+    }
+
+    // There's no matching entry in the list.
+    return nullptr;
+}
+
+} // namespace Kernel

src/core/hle/kernel/k_object_name.h

@@ -0,0 +1,86 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <array>
+#include <memory>
+#include <boost/intrusive/list.hpp>
+
+#include "core/hle/kernel/k_light_lock.h"
+#include "core/hle/kernel/slab_helpers.h"
+#include "core/hle/kernel/svc_results.h"
+
+namespace Kernel {
+
+class KObjectNameGlobalData;
+
+class KObjectName : public KSlabAllocated<KObjectName>, public boost::intrusive::list_base_hook<> {
+public:
+    explicit KObjectName(KernelCore&) {}
+    virtual ~KObjectName() = default;
+
+    static constexpr size_t NameLengthMax = 12;
+    using List = boost::intrusive::list<KObjectName>;
+
+    static Result NewFromName(KernelCore& kernel, KAutoObject* obj, const char* name);
+    static Result Delete(KernelCore& kernel, KAutoObject* obj, const char* name);
+
+    static KScopedAutoObject<KAutoObject> Find(KernelCore& kernel, const char* name);
+
+    template <typename Derived>
+    static Result Delete(KernelCore& kernel, const char* name) {
+        // Find the object.
+        KScopedAutoObject obj = Find(kernel, name);
+        R_UNLESS(obj.IsNotNull(), ResultNotFound);
+
+        // Cast the object to the desired type.
+        Derived* derived = obj->DynamicCast<Derived*>();
+        R_UNLESS(derived != nullptr, ResultNotFound);
+
+        // Check that the object is closed.
+        R_UNLESS(derived->IsServerClosed(), ResultInvalidState);
+
+        return Delete(kernel, obj.GetPointerUnsafe(), name);
+    }
+
+    template <typename Derived>
+        requires(std::derived_from<Derived, KAutoObject>)
+    static KScopedAutoObject<Derived> Find(KernelCore& kernel, const char* name) {
+        return Find(kernel, name);
+    }
+
+private:
+    static KScopedAutoObject<KAutoObject> FindImpl(KernelCore& kernel, const char* name);
+
+    void Initialize(KAutoObject* obj, const char* name);
+
+    bool MatchesName(const char* name) const;
+    KAutoObject* GetObject() const {
+        return m_object;
+    }
+
+private:
+    std::array<char, NameLengthMax> m_name{};
+    KAutoObject* m_object{};
+};
+
+class KObjectNameGlobalData {
+public:
+    explicit KObjectNameGlobalData(KernelCore& kernel);
+    ~KObjectNameGlobalData();
+
+    KLightLock& GetObjectListLock() {
+        return m_object_list_lock;
+    }
+
+    KObjectName::List& GetObjectList() {
+        return m_object_list;
+    }
+
+private:
+    KLightLock m_object_list_lock;
+    KObjectName::List m_object_list;
+};
+
+} // namespace Kernel

src/core/hle/kernel/k_process.cpp

@@ -119,7 +119,6 @@ void KProcess::DecrementRunningThreadCount() {
 
     if (const auto prev = num_running_threads--; prev == 1) {
         // TODO(bunnei): Process termination to be implemented when multiprocess is supported.
-        UNIMPLEMENTED_MSG("KProcess termination is not implemennted!");
     }
 }
 
@@ -357,9 +356,6 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:
     system_resource_size = metadata.GetSystemResourceSize();
     image_size = code_size;
 
-    // We currently do not support process-specific system resource
-    UNIMPLEMENTED_IF(system_resource_size != 0);
-
     KScopedResourceReservation memory_reservation(
         resource_limit, LimitableResource::PhysicalMemoryMax, code_size + system_resource_size);
     if (!memory_reservation.Succeeded()) {

src/core/hle/kernel/k_thread.cpp

@@ -29,6 +29,7 @@
 #include "core/hle/kernel/k_thread_queue.h"
 #include "core/hle/kernel/k_worker_task_manager.h"
 #include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/svc.h"
 #include "core/hle/kernel/svc_results.h"
 #include "core/hle/kernel/svc_types.h"
 #include "core/hle/result.h"
@@ -298,6 +299,25 @@ Result KThread::InitializeUserThread(Core::System& system, KThread* thread, KThr
                               ThreadType::User, system.GetCpuManager().GetGuestThreadFunc()));
 }
 
+Result KThread::InitializeServiceThread(Core::System& system, KThread* thread,
+                                        std::function<void()>&& func, s32 prio, s32 virt_core,
+                                        KProcess* owner) {
+    system.Kernel().GlobalSchedulerContext().AddThread(thread);
+    std::function<void()> func2{[&system, func{std::move(func)}] {
+        // Similar to UserModeThreadStarter.
+        system.Kernel().CurrentScheduler()->OnThreadStart();
+
+        // Run the guest function.
+        func();
+
+        // Exit.
+        Svc::ExitThread(system);
+    }};
+
+    R_RETURN(InitializeThread(thread, {}, {}, {}, prio, virt_core, owner, ThreadType::HighPriority,
+                              std::move(func2)));
+}
+
 void KThread::PostDestroy(uintptr_t arg) {
     KProcess* owner = reinterpret_cast<KProcess*>(arg & ~1ULL);
     const bool resource_limit_release_hint = (arg & 1);

src/core/hle/kernel/k_thread.h

@@ -434,6 +434,10 @@ public:
                                                      VAddr user_stack_top, s32 prio, s32 virt_core,
                                                      KProcess* owner);
 
+    [[nodiscard]] static Result InitializeServiceThread(Core::System& system, KThread* thread,
+                                                        std::function<void()>&& thread_func,
+                                                        s32 prio, s32 virt_core, KProcess* owner);
+
 public:
     struct StackParameters {
         u8 svc_permission[0x10];

src/core/hle/kernel/kernel.cpp

@@ -29,18 +29,20 @@
 #include "core/hle/kernel/k_hardware_timer.h"
 #include "core/hle/kernel/k_memory_layout.h"
 #include "core/hle/kernel/k_memory_manager.h"
+#include "core/hle/kernel/k_object_name.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_scoped_resource_reservation.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"
 #include "core/hle/kernel/physical_core.h"
-#include "core/hle/kernel/service_thread.h"
 #include "core/hle/result.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/memory.h"
 
@@ -54,9 +56,7 @@ struct KernelCore::Impl {
     static constexpr size_t BlockInfoSlabHeapSize = 4000;
     static constexpr size_t ReservedDynamicPageCount = 64;
 
-    explicit Impl(Core::System& system_, KernelCore& kernel_)
-        : service_threads_manager{1, "ServiceThreadsManager"},
-          service_thread_barrier{2}, system{system_} {}
+    explicit Impl(Core::System& system_, KernelCore& kernel_) : system{system_} {}
 
     void SetMulticore(bool is_multi) {
         is_multicore = is_multi;
@@ -84,6 +84,7 @@ struct KernelCore::Impl {
         InitializeShutdownThreads();
         InitializePhysicalCores();
         InitializePreemption(kernel);
+        InitializeGlobalData(kernel);
 
         // Initialize the Dynamic Slab Heaps.
         {
@@ -96,8 +97,6 @@ struct KernelCore::Impl {
 
         InitializeHackSharedMemory();
         RegisterHostThread(nullptr);
-
-        default_service_thread = &CreateServiceThread(kernel, "DefaultServiceThread");
     }
 
     void InitializeCores() {
@@ -138,11 +137,6 @@ struct KernelCore::Impl {
 
         preemption_event = nullptr;
 
-        for (auto& iter : named_ports) {
-            iter.second->Close();
-        }
-        named_ports.clear();
-
         exclusive_monitor.reset();
 
         // Cleanup persistent kernel objects
@@ -194,6 +188,8 @@ struct KernelCore::Impl {
             }
         }
 
+        object_name_global_data.reset();
+
         // Ensure that the object list container is finalized and properly shutdown.
         global_object_list_container->Finalize();
         global_object_list_container.reset();
@@ -203,8 +199,9 @@ struct KernelCore::Impl {
     }
 
     void CloseServices() {
-        // Ensures all service threads gracefully shutdown.
-        ClearServiceThreads();
+        // Ensures all servers gracefully shutdown.
+        std::scoped_lock lk{server_lock};
+        server_managers.clear();
     }
 
     void InitializePhysicalCores() {
@@ -363,6 +360,10 @@ struct KernelCore::Impl {
         }
     }
 
+    void InitializeGlobalData(KernelCore& kernel) {
+        object_name_global_data = std::make_unique<KObjectNameGlobalData>(kernel);
+    }
+
     void MakeApplicationProcess(KProcess* process) {
         application_process = process;
     }
@@ -753,55 +754,6 @@ struct KernelCore::Impl {
                                       "HidBus:SharedMemory");
     }
 
-    KClientPort* CreateNamedServicePort(std::string name) {
-        auto search = service_interface_factory.find(name);
-        if (search == service_interface_factory.end()) {
-            UNIMPLEMENTED();
-            return {};
-        }
-
-        return &search->second(system.ServiceManager(), system);
-    }
-
-    void RegisterNamedServiceHandler(std::string name, KServerPort* server_port) {
-        auto search = service_interface_handlers.find(name);
-        if (search == service_interface_handlers.end()) {
-            return;
-        }
-
-        search->second(system.ServiceManager(), server_port);
-    }
-
-    Kernel::ServiceThread& CreateServiceThread(KernelCore& kernel, const std::string& name) {
-        auto* ptr = new ServiceThread(kernel, name);
-
-        service_threads_manager.QueueWork(
-            [this, ptr]() { service_threads.emplace(ptr, std::unique_ptr<ServiceThread>(ptr)); });
-
-        return *ptr;
-    }
-
-    void ReleaseServiceThread(Kernel::ServiceThread& service_thread) {
-        auto* ptr = &service_thread;
-
-        if (ptr == default_service_thread) {
-            // Nothing to do here, the service is using default_service_thread, which will be
-            // released on shutdown.
-            return;
-        }
-
-        service_threads_manager.QueueWork([this, ptr]() { service_threads.erase(ptr); });
-    }
-
-    void ClearServiceThreads() {
-        service_threads_manager.QueueWork([this] {
-            service_threads.clear();
-            default_service_thread = nullptr;
-            service_thread_barrier.Sync();
-        });
-        service_thread_barrier.Sync();
-    }
-
     std::mutex registered_objects_lock;
     std::mutex registered_in_use_objects_lock;
 
@@ -829,14 +781,14 @@ struct KernelCore::Impl {
 
     std::unique_ptr<KAutoObjectWithListContainer> global_object_list_container;
 
-    /// Map of named ports managed by the kernel, which can be retrieved using
-    /// the ConnectToPort SVC.
-    std::unordered_map<std::string, ServiceInterfaceFactory> service_interface_factory;
-    std::unordered_map<std::string, ServiceInterfaceHandlerFn> service_interface_handlers;
-    NamedPortTable named_ports;
+    std::unique_ptr<KObjectNameGlobalData> object_name_global_data;
+
     std::unordered_set<KAutoObject*> registered_objects;
     std::unordered_set<KAutoObject*> registered_in_use_objects;
 
+    std::mutex server_lock;
+    std::vector<std::unique_ptr<Service::ServerManager>> server_managers;
+
     std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor;
     std::array<std::unique_ptr<Kernel::PhysicalCore>, Core::Hardware::NUM_CPU_CORES> cores;
 
@@ -871,12 +823,6 @@ struct KernelCore::Impl {
     // Memory layout
     std::unique_ptr<KMemoryLayout> memory_layout;
 
-    // Threads used for services
-    std::unordered_map<ServiceThread*, std::unique_ptr<ServiceThread>> service_threads;
-    ServiceThread* default_service_thread{};
-    Common::ThreadWorker service_threads_manager;
-    Common::Barrier service_thread_barrier;
-
     std::array<KThread*, Core::Hardware::NUM_CPU_CORES> shutdown_threads{};
     std::array<std::unique_ptr<Kernel::KScheduler>, Core::Hardware::NUM_CPU_CORES> schedulers{};
 
@@ -1040,23 +986,6 @@ void KernelCore::PrepareReschedule(std::size_t id) {
     // TODO: Reimplement, this
 }
 
-void KernelCore::RegisterNamedService(std::string name, ServiceInterfaceFactory&& factory) {
-    impl->service_interface_factory.emplace(std::move(name), factory);
-}
-
-void KernelCore::RegisterInterfaceForNamedService(std::string name,
-                                                  ServiceInterfaceHandlerFn&& handler) {
-    impl->service_interface_handlers.emplace(std::move(name), handler);
-}
-
-KClientPort* KernelCore::CreateNamedServicePort(std::string name) {
-    return impl->CreateNamedServicePort(std::move(name));
-}
-
-void KernelCore::RegisterNamedServiceHandler(std::string name, KServerPort* server_port) {
-    impl->RegisterNamedServiceHandler(std::move(name), server_port);
-}
-
 void KernelCore::RegisterKernelObject(KAutoObject* object) {
     std::scoped_lock lk{impl->registered_objects_lock};
     impl->registered_objects.insert(object);
@@ -1077,8 +1006,19 @@ void KernelCore::UnregisterInUseObject(KAutoObject* object) {
     impl->registered_in_use_objects.erase(object);
 }
 
-bool KernelCore::IsValidNamedPort(NamedPortTable::const_iterator port) const {
-    return port != impl->named_ports.cend();
+void KernelCore::RunServer(std::unique_ptr<Service::ServerManager>&& server_manager) {
+    auto* manager = server_manager.get();
+
+    {
+        std::scoped_lock lk{impl->server_lock};
+        if (impl->is_shutting_down) {
+            return;
+        }
+
+        impl->server_managers.emplace_back(std::move(server_manager));
+    }
+
+    manager->LoopProcess();
 }
 
 u32 KernelCore::CreateNewObjectID() {
@@ -1117,6 +1057,87 @@ void KernelCore::RegisterHostThread(KThread* existing_thread) {
     }
 }
 
+static std::jthread RunHostThreadFunc(KernelCore& kernel, KProcess* process,
+                                      std::string&& thread_name, std::function<void()>&& func) {
+    // Reserve a new thread from the process resource limit.
+    KScopedResourceReservation thread_reservation(process, LimitableResource::ThreadCountMax);
+    ASSERT(thread_reservation.Succeeded());
+
+    // Initialize the thread.
+    KThread* thread = KThread::Create(kernel);
+    ASSERT(R_SUCCEEDED(KThread::InitializeDummyThread(thread, process)));
+
+    // Commit the thread reservation.
+    thread_reservation.Commit();
+
+    return std::jthread(
+        [&kernel, thread, thread_name{std::move(thread_name)}, func{std::move(func)}] {
+            // Set the thread name.
+            Common::SetCurrentThreadName(thread_name.c_str());
+
+            // Register the thread.
+            kernel.RegisterHostThread(thread);
+
+            // Run the callback.
+            func();
+
+            // Close the thread.
+            // This will free the process if it is the last reference.
+            thread->Close();
+        });
+}
+
+std::jthread KernelCore::RunOnHostCoreProcess(std::string&& process_name,
+                                              std::function<void()> func) {
+    // Make a new process.
+    KProcess* process = KProcess::Create(*this);
+    ASSERT(R_SUCCEEDED(KProcess::Initialize(process, System(), "", KProcess::ProcessType::Userland,
+                                            GetSystemResourceLimit())));
+
+    // Ensure that we don't hold onto any extra references.
+    SCOPE_EXIT({ process->Close(); });
+
+    // Run the host thread.
+    return RunHostThreadFunc(*this, process, std::move(process_name), std::move(func));
+}
+
+std::jthread KernelCore::RunOnHostCoreThread(std::string&& thread_name,
+                                             std::function<void()> func) {
+    // Get the current process.
+    KProcess* process = GetCurrentProcessPointer(*this);
+
+    // Run the host thread.
+    return RunHostThreadFunc(*this, process, std::move(thread_name), std::move(func));
+}
+
+void KernelCore::RunOnGuestCoreProcess(std::string&& process_name, std::function<void()> func) {
+    constexpr s32 ServiceThreadPriority = 16;
+    constexpr s32 ServiceThreadCore = 3;
+
+    // Make a new process.
+    KProcess* process = KProcess::Create(*this);
+    ASSERT(R_SUCCEEDED(KProcess::Initialize(process, System(), "", KProcess::ProcessType::Userland,
+                                            GetSystemResourceLimit())));
+
+    // Ensure that we don't hold onto any extra references.
+    SCOPE_EXIT({ process->Close(); });
+
+    // Reserve a new thread from the process resource limit.
+    KScopedResourceReservation thread_reservation(process, LimitableResource::ThreadCountMax);
+    ASSERT(thread_reservation.Succeeded());
+
+    // Initialize the thread.
+    KThread* thread = KThread::Create(*this);
+    ASSERT(R_SUCCEEDED(KThread::InitializeServiceThread(
+        System(), thread, std::move(func), ServiceThreadPriority, ServiceThreadCore, process)));
+
+    // Commit the thread reservation.
+    thread_reservation.Commit();
+
+    // Begin running the thread.
+    ASSERT(R_SUCCEEDED(thread->Run()));
+}
+
 u32 KernelCore::GetCurrentHostThreadID() const {
     return impl->GetCurrentHostThreadID();
 }
@@ -1129,6 +1150,10 @@ void KernelCore::SetCurrentEmuThread(KThread* thread) {
     impl->SetCurrentEmuThread(thread);
 }
 
+KObjectNameGlobalData& KernelCore::ObjectNameGlobalData() {
+    return *impl->object_name_global_data;
+}
+
 KMemoryManager& KernelCore::MemoryManager() {
     return *impl->memory_manager;
 }
@@ -1257,18 +1282,6 @@ void KernelCore::ExitSVCProfile() {
     MicroProfileLeave(MICROPROFILE_TOKEN(Kernel_SVC), impl->svc_ticks[CurrentPhysicalCoreIndex()]);
 }
 
-Kernel::ServiceThread& KernelCore::CreateServiceThread(const std::string& name) {
-    return impl->CreateServiceThread(*this, name);
-}
-
-Kernel::ServiceThread& KernelCore::GetDefaultServiceThread() const {
-    return *impl->default_service_thread;
-}
-
-void KernelCore::ReleaseServiceThread(Kernel::ServiceThread& service_thread) {
-    impl->ReleaseServiceThread(service_thread);
-}
-
 Init::KSlabResourceCounts& KernelCore::SlabResourceCounts() {
     return impl->slab_resource_counts;
 }

src/core/hle/kernel/kernel.h

@@ -9,6 +9,8 @@
 #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"
@@ -24,6 +26,10 @@ class CoreTiming;
 struct EventType;
 } // namespace Core::Timing
 
+namespace Service {
+class ServerManager;
+}
+
 namespace Service::SM {
 class ServiceManager;
 }
@@ -44,6 +50,8 @@ class KHardwareTimer;
 class KLinkedListNode;
 class KMemoryLayout;
 class KMemoryManager;
+class KObjectName;
+class KObjectNameGlobalData;
 class KPageBuffer;
 class KPageBufferSlabHeap;
 class KPort;
@@ -63,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;
@@ -78,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,
@@ -194,18 +188,6 @@ public:
 
     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);
-
     /// Registers all kernel objects with the global emulation state, this is purely for tracking
     /// leaks after emulation has been shutdown.
     void RegisterKernelObject(KAutoObject* object);
@@ -222,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;
@@ -240,6 +222,15 @@ 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();
 
@@ -305,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);
@@ -372,6 +336,8 @@ public:
             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, KObjectName>) {
+            return slab_heap_container->object_name;
         } else if constexpr (std::is_same_v<T, KSessionRequest>) {
             return slab_heap_container->session_request;
         } else if constexpr (std::is_same_v<T, KSecureSystemResource>) {
@@ -443,6 +409,7 @@ private:
         KSlabHeap<KDeviceAddressSpace> device_address_space;
         KSlabHeap<KPageBuffer> page_buffer;
         KSlabHeap<KThreadLocalPage> thread_local_page;
+        KSlabHeap<KObjectName> object_name;
         KSlabHeap<KSessionRequest> session_request;
         KSlabHeap<KSecureSystemResource> secure_system_resource;
         KSlabHeap<KEventInfo> event_info;

src/core/hle/kernel/svc/svc_info.cpp

@@ -126,6 +126,11 @@ Result GetInfo(Core::System& system, u64* result, InfoType info_id_type, Handle
             *result = process->GetTotalPhysicalMemoryUsedWithoutSystemResource();
             return ResultSuccess;
 
+        case InfoType::IsApplication:
+            LOG_WARNING(Kernel_SVC, "(STUBBED) Assuming process is application");
+            *result = true;
+            return ResultSuccess;
+
         case InfoType::FreeThreadCount:
             *result = process->GetFreeThreadCount();
             return ResultSuccess;

src/core/hle/kernel/svc/svc_port.cpp

@@ -5,62 +5,47 @@
 #include "core/core.h"
 #include "core/hle/kernel/k_client_port.h"
 #include "core/hle/kernel/k_client_session.h"
+#include "core/hle/kernel/k_object_name.h"
 #include "core/hle/kernel/k_port.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/svc.h"
 
 namespace Kernel::Svc {
 
-/// Connect to an OS service given the port name, returns the handle to the port to out
-Result ConnectToNamedPort(Core::System& system, Handle* out, VAddr port_name_address) {
-    auto& memory = system.Memory();
-    if (!memory.IsValidVirtualAddress(port_name_address)) {
-        LOG_ERROR(Kernel_SVC,
-                  "Port Name Address is not a valid virtual address, port_name_address=0x{:016X}",
-                  port_name_address);
-        return ResultNotFound;
-    }
+Result ConnectToNamedPort(Core::System& system, Handle* out, VAddr user_name) {
+    // Copy the provided name from user memory to kernel memory.
+    auto string_name = system.Memory().ReadCString(user_name, KObjectName::NameLengthMax);
 
-    static constexpr std::size_t PortNameMaxLength = 11;
-    // Read 1 char beyond the max allowed port name to detect names that are too long.
-    const std::string port_name = memory.ReadCString(port_name_address, PortNameMaxLength + 1);
-    if (port_name.size() > PortNameMaxLength) {
-        LOG_ERROR(Kernel_SVC, "Port name is too long, expected {} but got {}", PortNameMaxLength,
-                  port_name.size());
-        return ResultOutOfRange;
-    }
+    std::array<char, KObjectName::NameLengthMax> name{};
+    std::strncpy(name.data(), string_name.c_str(), KObjectName::NameLengthMax - 1);
 
-    LOG_TRACE(Kernel_SVC, "called port_name={}", port_name);
+    // Validate that the name is valid.
+    R_UNLESS(name[sizeof(name) - 1] == '\x00', ResultOutOfRange);
 
     // Get the current handle table.
-    auto& kernel = system.Kernel();
-    auto& handle_table = GetCurrentProcess(kernel).GetHandleTable();
+    auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
 
     // Find the client port.
-    auto port = kernel.CreateNamedServicePort(port_name);
-    if (!port) {
-        LOG_ERROR(Kernel_SVC, "tried to connect to unknown port: {}", port_name);
-        return ResultNotFound;
-    }
+    auto port = KObjectName::Find<KClientPort>(system.Kernel(), name.data());
+    R_UNLESS(port.IsNotNull(), ResultNotFound);
 
     // Reserve a handle for the port.
     // NOTE: Nintendo really does write directly to the output handle here.
     R_TRY(handle_table.Reserve(out));
-    auto handle_guard = SCOPE_GUARD({ handle_table.Unreserve(*out); });
+    ON_RESULT_FAILURE {
+        handle_table.Unreserve(*out);
+    };
 
     // Create a session.
-    KClientSession* session{};
+    KClientSession* session;
     R_TRY(port->CreateSession(std::addressof(session)));
 
-    kernel.RegisterNamedServiceHandler(port_name, &port->GetParent()->GetServerPort());
-
     // Register the session in the table, close the extra reference.
     handle_table.Register(*out, session);
     session->Close();
 
     // We succeeded.
-    handle_guard.Cancel();
-    return ResultSuccess;
+    R_SUCCEED();
 }
 
 Result CreatePort(Core::System& system, Handle* out_server, Handle* out_client,
@@ -74,10 +59,60 @@ Result ConnectToPort(Core::System& system, Handle* out_handle, Handle port) {
     R_THROW(ResultNotImplemented);
 }
 
-Result ManageNamedPort(Core::System& system, Handle* out_server_handle, uint64_t name,
+Result ManageNamedPort(Core::System& system, Handle* out_server_handle, uint64_t user_name,
                        int32_t max_sessions) {
-    UNIMPLEMENTED();
-    R_THROW(ResultNotImplemented);
+    // Copy the provided name from user memory to kernel memory.
+    auto string_name = system.Memory().ReadCString(user_name, KObjectName::NameLengthMax);
+
+    // Copy the provided name from user memory to kernel memory.
+    std::array<char, KObjectName::NameLengthMax> name{};
+    std::strncpy(name.data(), string_name.c_str(), KObjectName::NameLengthMax - 1);
+
+    // Validate that sessions and name are valid.
+    R_UNLESS(max_sessions >= 0, ResultOutOfRange);
+    R_UNLESS(name[sizeof(name) - 1] == '\x00', ResultOutOfRange);
+
+    if (max_sessions > 0) {
+        // Get the current handle table.
+        auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
+
+        // Create a new port.
+        KPort* port = KPort::Create(system.Kernel());
+        R_UNLESS(port != nullptr, ResultOutOfResource);
+
+        // Initialize the new port.
+        port->Initialize(max_sessions, false, "");
+
+        // Register the port.
+        KPort::Register(system.Kernel(), port);
+
+        // Ensure that our only reference to the port is in the handle table when we're done.
+        SCOPE_EXIT({
+            port->GetClientPort().Close();
+            port->GetServerPort().Close();
+        });
+
+        // Register the handle in the table.
+        R_TRY(handle_table.Add(out_server_handle, std::addressof(port->GetServerPort())));
+        ON_RESULT_FAILURE {
+            handle_table.Remove(*out_server_handle);
+        };
+
+        // Create a new object name.
+        R_TRY(KObjectName::NewFromName(system.Kernel(), std::addressof(port->GetClientPort()),
+                                       name.data()));
+    } else /* if (max_sessions == 0) */ {
+        // Ensure that this else case is correct.
+        ASSERT(max_sessions == 0);
+
+        // If we're closing, there's no server handle.
+        *out_server_handle = InvalidHandle;
+
+        // Delete the object.
+        R_TRY(KObjectName::Delete<KClientPort>(system.Kernel(), name.data()));
+    }
+
+    R_SUCCEED();
 }
 
 Result ConnectToNamedPort64(Core::System& system, Handle* out_handle, uint64_t name) {

src/core/hle/service/acc/acc.cpp

@@ -25,6 +25,7 @@
 #include "core/hle/service/acc/errors.h"
 #include "core/hle/service/acc/profile_manager.h"
 #include "core/hle/service/glue/glue_manager.h"
+#include "core/hle/service/server_manager.h"
 #include "core/loader/loader.h"
 
 namespace Service::Account {
@@ -942,18 +943,20 @@ Module::Interface::Interface(std::shared_ptr<Module> module_,
 
 Module::Interface::~Interface() = default;
 
-void InstallInterfaces(Core::System& system) {
+void LoopProcess(Core::System& system) {
     auto module = std::make_shared<Module>();
     auto profile_manager = std::make_shared<ProfileManager>();
+    auto server_manager = std::make_unique<ServerManager>(system);
 
-    std::make_shared<ACC_AA>(module, profile_manager, system)
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<ACC_SU>(module, profile_manager, system)
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<ACC_U0>(module, profile_manager, system)
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<ACC_U1>(module, profile_manager, system)
-        ->InstallAsService(system.ServiceManager());
+    server_manager->RegisterNamedService("acc:aa",
+                                         std::make_shared<ACC_AA>(module, profile_manager, system));
+    server_manager->RegisterNamedService("acc:su",
+                                         std::make_shared<ACC_SU>(module, profile_manager, system));
+    server_manager->RegisterNamedService("acc:u0",
+                                         std::make_shared<ACC_U0>(module, profile_manager, system));
+    server_manager->RegisterNamedService("acc:u1",
+                                         std::make_shared<ACC_U1>(module, profile_manager, system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::Account

src/core/hle/service/acc/acc.h

@@ -67,7 +67,6 @@ public:
     };
 };
 
-/// Registers all ACC services with the specified service manager.
-void InstallInterfaces(Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::Account

src/core/hle/service/am/am.cpp

@@ -32,6 +32,7 @@
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/nvflinger/nvflinger.h"
 #include "core/hle/service/pm/pm.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/hle/service/vi/vi.h"
 #include "core/memory.h"
@@ -1828,17 +1829,21 @@ void IApplicationFunctions::PrepareForJit(Kernel::HLERequestContext& ctx) {
     rb.Push(ResultSuccess);
 }
 
-void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger,
-                       Core::System& system) {
+void LoopProcess(NVFlinger::NVFlinger& nvflinger, Core::System& system) {
     auto message_queue = std::make_shared<AppletMessageQueue>(system);
     // Needed on game boot
     message_queue->PushMessage(AppletMessageQueue::AppletMessage::FocusStateChanged);
 
-    std::make_shared<AppletAE>(nvflinger, message_queue, system)->InstallAsService(service_manager);
-    std::make_shared<AppletOE>(nvflinger, message_queue, system)->InstallAsService(service_manager);
-    std::make_shared<IdleSys>(system)->InstallAsService(service_manager);
-    std::make_shared<OMM>(system)->InstallAsService(service_manager);
-    std::make_shared<SPSM>(system)->InstallAsService(service_manager);
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService(
+        "appletAE", std::make_shared<AppletAE>(nvflinger, message_queue, system));
+    server_manager->RegisterNamedService(
+        "appletOE", std::make_shared<AppletOE>(nvflinger, message_queue, system));
+    server_manager->RegisterNamedService("idle:sys", std::make_shared<IdleSys>(system));
+    server_manager->RegisterNamedService("omm", std::make_shared<OMM>(system));
+    server_manager->RegisterNamedService("spsm", std::make_shared<SPSM>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 IHomeMenuFunctions::IHomeMenuFunctions(Core::System& system_)

src/core/hle/service/am/am.h

@@ -396,8 +396,6 @@ public:
     ~IProcessWindingController() override;
 };
 
-/// Registers all AM services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger& nvflinger,
-                       Core::System& system);
+void LoopProcess(NVFlinger::NVFlinger& nvflinger, Core::System& system);
 
 } // namespace Service::AM

src/core/hle/service/aoc/aoc_u.cpp

@@ -17,6 +17,7 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/aoc/aoc_u.h"
+#include "core/hle/service/server_manager.h"
 #include "core/loader/loader.h"
 
 namespace Service::AOC {
@@ -311,8 +312,10 @@ void AOC_U::CreatePermanentEcPurchasedEventManager(Kernel::HLERequestContext& ct
     rb.PushIpcInterface<IPurchaseEventManager>(system);
 }
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<AOC_U>(system)->InstallAsService(service_manager);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+    server_manager->RegisterNamedService("aoc:u", std::make_shared<AOC_U>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::AOC

src/core/hle/service/aoc/aoc_u.h

@@ -40,7 +40,6 @@ private:
     Kernel::KEvent* aoc_change_event;
 };
 
-/// Registers all AOC services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::AOC

src/core/hle/service/apm/apm.cpp

@@ -4,20 +4,24 @@
 #include "core/core.h"
 #include "core/hle/service/apm/apm.h"
 #include "core/hle/service/apm/apm_interface.h"
+#include "core/hle/service/server_manager.h"
 
 namespace Service::APM {
 
 Module::Module() = default;
 Module::~Module() = default;
 
-void InstallInterfaces(Core::System& system) {
-    auto module_ = std::make_shared<Module>();
-    std::make_shared<APM>(system, module_, system.GetAPMController(), "apm")
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<APM>(system, module_, system.GetAPMController(), "apm:am")
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<APM_Sys>(system, system.GetAPMController())
-        ->InstallAsService(system.ServiceManager());
+void LoopProcess(Core::System& system) {
+    auto module = std::make_shared<Module>();
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService(
+        "apm", std::make_shared<APM>(system, module, system.GetAPMController(), "apm"));
+    server_manager->RegisterNamedService(
+        "apm:am", std::make_shared<APM>(system, module, system.GetAPMController(), "apm:am"));
+    server_manager->RegisterNamedService(
+        "apm:sys", std::make_shared<APM_Sys>(system, system.GetAPMController()));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::APM

src/core/hle/service/apm/apm.h

@@ -15,7 +15,6 @@ public:
     ~Module();
 };
 
-/// Registers all AM services with the specified service manager.
-void InstallInterfaces(Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::APM

src/core/hle/service/audio/audin_u.cpp

@@ -203,9 +203,8 @@ private:
 };
 
 AudInU::AudInU(Core::System& system_)
-    : ServiceFramework{system_, "audin:u", ServiceThreadType::CreateNew},
-      service_context{system_, "AudInU"}, impl{std::make_unique<AudioCore::AudioIn::Manager>(
-                                              system_)} {
+    : ServiceFramework{system_, "audin:u"}, service_context{system_, "AudInU"},
+      impl{std::make_unique<AudioCore::AudioIn::Manager>(system_)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &AudInU::ListAudioIns, "ListAudioIns"},

src/core/hle/service/audio/audio.cpp

@@ -1,6 +1,7 @@
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later
 
+#include "core/core.h"
 #include "core/hle/service/audio/audctl.h"
 #include "core/hle/service/audio/audin_u.h"
 #include "core/hle/service/audio/audio.h"
@@ -9,18 +10,22 @@
 #include "core/hle/service/audio/audrec_u.h"
 #include "core/hle/service/audio/audren_u.h"
 #include "core/hle/service/audio/hwopus.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 
 namespace Service::Audio {
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<AudCtl>(system)->InstallAsService(service_manager);
-    std::make_shared<AudOutU>(system)->InstallAsService(service_manager);
-    std::make_shared<AudInU>(system)->InstallAsService(service_manager);
-    std::make_shared<AudRecA>(system)->InstallAsService(service_manager);
-    std::make_shared<AudRecU>(system)->InstallAsService(service_manager);
-    std::make_shared<AudRenU>(system)->InstallAsService(service_manager);
-    std::make_shared<HwOpus>(system)->InstallAsService(service_manager);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("audctl", std::make_shared<AudCtl>(system));
+    server_manager->RegisterNamedService("audout:u", std::make_shared<AudOutU>(system));
+    server_manager->RegisterNamedService("audin:u", std::make_shared<AudInU>(system));
+    server_manager->RegisterNamedService("audrec:a", std::make_shared<AudRecA>(system));
+    server_manager->RegisterNamedService("audrec:u", std::make_shared<AudRecU>(system));
+    server_manager->RegisterNamedService("audren:u", std::make_shared<AudRenU>(system));
+    server_manager->RegisterNamedService("hwopus", std::make_shared<HwOpus>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::Audio

src/core/hle/service/audio/audio.h

@@ -13,7 +13,6 @@ class ServiceManager;
 
 namespace Service::Audio {
 
-/// Registers all Audio services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::Audio

src/core/hle/service/audio/audout_u.cpp

@@ -26,9 +26,8 @@ public:
     explicit IAudioOut(Core::System& system_, AudioCore::AudioOut::Manager& manager,
                        size_t session_id, const std::string& device_name,
                        const AudioOutParameter& in_params, u32 handle, u64 applet_resource_user_id)
-        : ServiceFramework{system_, "IAudioOut", ServiceThreadType::CreateNew},
-          service_context{system_, "IAudioOut"}, event{service_context.CreateEvent(
-                                                     "AudioOutEvent")},
+        : ServiceFramework{system_, "IAudioOut"}, service_context{system_, "IAudioOut"},
+          event{service_context.CreateEvent("AudioOutEvent")},
           impl{std::make_shared<AudioCore::AudioOut::Out>(system_, manager, event, session_id)} {
 
         // clang-format off
@@ -221,9 +220,8 @@ private:
 };
 
 AudOutU::AudOutU(Core::System& system_)
-    : ServiceFramework{system_, "audout:u", ServiceThreadType::CreateNew},
-      service_context{system_, "AudOutU"}, impl{std::make_unique<AudioCore::AudioOut::Manager>(
-                                               system_)} {
+    : ServiceFramework{system_, "audout:u"}, service_context{system_, "AudOutU"},
+      impl{std::make_unique<AudioCore::AudioOut::Manager>(system_)} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &AudOutU::ListAudioOuts, "ListAudioOuts"},

src/core/hle/service/audio/audren_u.cpp

@@ -35,10 +35,9 @@ public:
                             AudioCore::AudioRendererParameterInternal& params,
                             Kernel::KTransferMemory* transfer_memory, u64 transfer_memory_size,
                             u32 process_handle, u64 applet_resource_user_id, s32 session_id)
-        : ServiceFramework{system_, "IAudioRenderer", ServiceThreadType::CreateNew},
-          service_context{system_, "IAudioRenderer"}, rendered_event{service_context.CreateEvent(
-                                                          "IAudioRendererEvent")},
-          manager{manager_}, impl{std::make_unique<Renderer>(system_, manager, rendered_event)} {
+        : ServiceFramework{system_, "IAudioRenderer"}, service_context{system_, "IAudioRenderer"},
+          rendered_event{service_context.CreateEvent("IAudioRendererEvent")}, manager{manager_},
+          impl{std::make_unique<Renderer>(system_, manager, rendered_event)} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IAudioRenderer::GetSampleRate, "GetSampleRate"},
@@ -243,10 +242,8 @@ class IAudioDevice final : public ServiceFramework<IAudioDevice> {
 public:
     explicit IAudioDevice(Core::System& system_, u64 applet_resource_user_id, u32 revision,
                           u32 device_num)
-        : ServiceFramework{system_, "IAudioDevice", ServiceThreadType::CreateNew},
-          service_context{system_, "IAudioDevice"}, impl{std::make_unique<AudioDevice>(
-                                                        system_, applet_resource_user_id,
-                                                        revision)},
+        : ServiceFramework{system_, "IAudioDevice"}, service_context{system_, "IAudioDevice"},
+          impl{std::make_unique<AudioDevice>(system_, applet_resource_user_id, revision)},
           event{service_context.CreateEvent(fmt::format("IAudioDeviceEvent-{}", device_num))} {
         static const FunctionInfo functions[] = {
             {0, &IAudioDevice::ListAudioDeviceName, "ListAudioDeviceName"},
@@ -421,7 +418,7 @@ private:
 };
 
 AudRenU::AudRenU(Core::System& system_)
-    : ServiceFramework{system_, "audren:u", ServiceThreadType::CreateNew},
+    : ServiceFramework{system_, "audren:u"},
       service_context{system_, "audren:u"}, impl{std::make_unique<Manager>(system_)} {
     // clang-format off
     static const FunctionInfo functions[] = {

src/core/hle/service/bcat/bcat_module.cpp

@@ -15,6 +15,7 @@
 #include "core/hle/service/bcat/bcat.h"
 #include "core/hle/service/bcat/bcat_module.h"
 #include "core/hle/service/filesystem/filesystem.h"
+#include "core/hle/service/server_manager.h"
 
 namespace Service::BCAT {
 
@@ -585,16 +586,23 @@ Module::Interface::Interface(Core::System& system_, std::shared_ptr<Module> modu
 
 Module::Interface::~Interface() = default;
 
-void InstallInterfaces(Core::System& system) {
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
     auto module = std::make_shared<Module>();
-    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:a")
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:m")
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:u")
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:s")
-        ->InstallAsService(system.ServiceManager());
+
+    server_manager->RegisterNamedService(
+        "bcat:a",
+        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:a"));
+    server_manager->RegisterNamedService(
+        "bcat:m",
+        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:m"));
+    server_manager->RegisterNamedService(
+        "bcat:u",
+        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:u"));
+    server_manager->RegisterNamedService(
+        "bcat:s",
+        std::make_shared<BCAT>(system, module, system.GetFileSystemController(), "bcat:s"));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::BCAT

src/core/hle/service/bcat/bcat_module.h

@@ -39,8 +39,7 @@ public:
     };
 };
 
-/// Registers all BCAT services with the specified service manager.
-void InstallInterfaces(Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace BCAT
 

src/core/hle/service/bpc/bpc.cpp

@@ -4,8 +4,8 @@
 #include <memory>
 
 #include "core/hle/service/bpc/bpc.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 
 namespace Service::BPC {
 
@@ -54,9 +54,12 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<BPC>(system)->InstallAsService(sm);
-    std::make_shared<BPC_R>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("bpc", std::make_shared<BPC>(system));
+    server_manager->RegisterNamedService("bpc:r", std::make_shared<BPC_R>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::BPC

src/core/hle/service/bpc/bpc.h

@@ -13,6 +13,6 @@ class ServiceManager;
 
 namespace Service::BPC {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::BPC

src/core/hle/service/btdrv/btdrv.cpp

@@ -7,6 +7,7 @@
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/btdrv/btdrv.h"
 #include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 
@@ -196,9 +197,12 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<BtDrv>(system)->InstallAsService(sm);
-    std::make_shared<Bt>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("btdrv", std::make_shared<BtDrv>(system));
+    server_manager->RegisterNamedService("bt", std::make_shared<Bt>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::BtDrv

src/core/hle/service/btdrv/btdrv.h

@@ -13,7 +13,6 @@ class System;
 
 namespace Service::BtDrv {
 
-/// Registers all BtDrv services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::BtDrv

src/core/hle/service/btm/btm.cpp

@@ -9,6 +9,7 @@
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/btm/btm.h"
 #include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 
 namespace Service::BTM {
@@ -311,11 +312,14 @@ private:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<BTM>(system)->InstallAsService(sm);
-    std::make_shared<BTM_DBG>(system)->InstallAsService(sm);
-    std::make_shared<BTM_SYS>(system)->InstallAsService(sm);
-    std::make_shared<BTM_USR>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("btm", std::make_shared<BTM>(system));
+    server_manager->RegisterNamedService("btm:dbg", std::make_shared<BTM_DBG>(system));
+    server_manager->RegisterNamedService("btm:sys", std::make_shared<BTM_SYS>(system));
+    server_manager->RegisterNamedService("btm:u", std::make_shared<BTM_USR>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::BTM

src/core/hle/service/btm/btm.h

@@ -13,6 +13,6 @@ class System;
 
 namespace Service::BTM {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::BTM

src/core/hle/service/caps/caps.cpp

@@ -8,17 +8,21 @@
 #include "core/hle/service/caps/caps_ss.h"
 #include "core/hle/service/caps/caps_su.h"
 #include "core/hle/service/caps/caps_u.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 
 namespace Service::Capture {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<CAPS_A>(system)->InstallAsService(sm);
-    std::make_shared<CAPS_C>(system)->InstallAsService(sm);
-    std::make_shared<CAPS_U>(system)->InstallAsService(sm);
-    std::make_shared<CAPS_SC>(system)->InstallAsService(sm);
-    std::make_shared<CAPS_SS>(system)->InstallAsService(sm);
-    std::make_shared<CAPS_SU>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("caps:a", std::make_shared<CAPS_A>(system));
+    server_manager->RegisterNamedService("caps:c", std::make_shared<CAPS_C>(system));
+    server_manager->RegisterNamedService("caps:u", std::make_shared<CAPS_U>(system));
+    server_manager->RegisterNamedService("caps:sc", std::make_shared<CAPS_SC>(system));
+    server_manager->RegisterNamedService("caps:ss", std::make_shared<CAPS_SS>(system));
+    server_manager->RegisterNamedService("caps:su", std::make_shared<CAPS_SU>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::Capture

src/core/hle/service/caps/caps.h

@@ -90,7 +90,6 @@ struct ApplicationAlbumFileEntry {
 static_assert(sizeof(ApplicationAlbumFileEntry) == 0x30,
               "ApplicationAlbumFileEntry has incorrect size.");
 
-/// Registers all Capture services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::Capture

src/core/hle/service/erpt/erpt.cpp

@@ -4,6 +4,7 @@
 #include <memory>
 
 #include "core/hle/service/erpt/erpt.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 
@@ -52,9 +53,13 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<ErrorReportContext>(system)->InstallAsService(sm);
-    std::make_shared<ErrorReportSession>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("erpt:c", std::make_shared<ErrorReportContext>(system));
+    server_manager->RegisterNamedService("erpt:r", std::make_shared<ErrorReportSession>(system));
+
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::ERPT

src/core/hle/service/erpt/erpt.h

@@ -7,13 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::ERPT {
 
-/// Registers all ERPT services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::ERPT

src/core/hle/service/es/es.cpp

@@ -4,6 +4,7 @@
 #include "core/crypto/key_manager.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/es/es.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 
 namespace Service::ES {
@@ -307,8 +308,11 @@ private:
     Core::Crypto::KeyManager& keys = Core::Crypto::KeyManager::Instance();
 };
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<ETicket>(system)->InstallAsService(service_manager);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("es", std::make_shared<ETicket>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::ES

src/core/hle/service/es/es.h

@@ -7,13 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::ES {
 
-/// Registers all ES services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::ES

src/core/hle/service/eupld/eupld.cpp

@@ -4,8 +4,8 @@
 #include <memory>
 
 #include "core/hle/service/eupld/eupld.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 
 namespace Service::EUPLD {
 
@@ -44,9 +44,12 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<ErrorUploadContext>(system)->InstallAsService(sm);
-    std::make_shared<ErrorUploadRequest>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("eupld:c", std::make_shared<ErrorUploadContext>(system));
+    server_manager->RegisterNamedService("eupld:r", std::make_shared<ErrorUploadRequest>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::EUPLD

src/core/hle/service/eupld/eupld.h

@@ -7,13 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::EUPLD {
 
-/// Registers all EUPLD services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::EUPLD

src/core/hle/service/fatal/fatal.cpp

@@ -13,6 +13,7 @@
 #include "core/hle/service/fatal/fatal.h"
 #include "core/hle/service/fatal/fatal_p.h"
 #include "core/hle/service/fatal/fatal_u.h"
+#include "core/hle/service/server_manager.h"
 #include "core/reporter.h"
 
 namespace Service::Fatal {
@@ -163,10 +164,13 @@ void Module::Interface::ThrowFatalWithCpuContext(Kernel::HLERequestContext& ctx)
     rb.Push(ResultSuccess);
 }
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
     auto module = std::make_shared<Module>();
-    std::make_shared<Fatal_P>(module, system)->InstallAsService(service_manager);
-    std::make_shared<Fatal_U>(module, system)->InstallAsService(service_manager);
+
+    server_manager->RegisterNamedService("fatal:p", std::make_shared<Fatal_P>(module, system));
+    server_manager->RegisterNamedService("fatal:u", std::make_shared<Fatal_U>(module, system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::Fatal

src/core/hle/service/fatal/fatal.h

@@ -28,6 +28,6 @@ public:
     };
 };
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::Fatal

src/core/hle/service/fgm/fgm.cpp

@@ -5,6 +5,7 @@
 
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/fgm/fgm.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 
@@ -63,11 +64,14 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<FGM>(system, "fgm")->InstallAsService(sm);
-    std::make_shared<FGM>(system, "fgm:0")->InstallAsService(sm);
-    std::make_shared<FGM>(system, "fgm:9")->InstallAsService(sm);
-    std::make_shared<FGM_DBG>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("fgm", std::make_shared<FGM>(system, "fgm"));
+    server_manager->RegisterNamedService("fgm:0", std::make_shared<FGM>(system, "fgm:0"));
+    server_manager->RegisterNamedService("fgm:9", std::make_shared<FGM>(system, "fgm:9"));
+    server_manager->RegisterNamedService("fgm:dbg", std::make_shared<FGM_DBG>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::FGM

src/core/hle/service/fgm/fgm.h

@@ -7,12 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::FGM {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::FGM

src/core/hle/service/filesystem/filesystem.cpp

@@ -23,6 +23,7 @@
 #include "core/hle/service/filesystem/fsp_ldr.h"
 #include "core/hle/service/filesystem/fsp_pr.h"
 #include "core/hle/service/filesystem/fsp_srv.h"
+#include "core/hle/service/server_manager.h"
 #include "core/loader/loader.h"
 
 namespace Service::FileSystem {
@@ -796,10 +797,13 @@ void FileSystemController::CreateFactories(FileSys::VfsFilesystem& vfs, bool ove
     }
 }
 
-void InstallInterfaces(Core::System& system) {
-    std::make_shared<FSP_LDR>(system)->InstallAsService(system.ServiceManager());
-    std::make_shared<FSP_PR>(system)->InstallAsService(system.ServiceManager());
-    std::make_shared<FSP_SRV>(system)->InstallAsService(system.ServiceManager());
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("fsp-ldr", std::make_shared<FSP_LDR>(system));
+    server_manager->RegisterNamedService("fsp:pr", std::make_shared<FSP_PR>(system));
+    server_manager->RegisterNamedService("fsp-srv", std::make_shared<FSP_SRV>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::FileSystem

src/core/hle/service/filesystem/filesystem.h

@@ -139,7 +139,7 @@ private:
     Core::System& system;
 };
 
-void InstallInterfaces(Core::System& system);
+void LoopProcess(Core::System& system);
 
 // A class that wraps a VfsDirectory with methods that return ResultVal and Result instead of
 // pointers and booleans. This makes using a VfsDirectory with switch services much easier and

src/core/hle/service/filesystem/fsp_srv.cpp

@@ -57,8 +57,7 @@ enum class FileSystemType : u8 {
 class IStorage final : public ServiceFramework<IStorage> {
 public:
     explicit IStorage(Core::System& system_, FileSys::VirtualFile backend_)
-        : ServiceFramework{system_, "IStorage", ServiceThreadType::CreateNew},
-          backend(std::move(backend_)) {
+        : ServiceFramework{system_, "IStorage"}, backend(std::move(backend_)) {
         static const FunctionInfo functions[] = {
             {0, &IStorage::Read, "Read"},
             {1, nullptr, "Write"},
@@ -116,8 +115,7 @@ private:
 class IFile final : public ServiceFramework<IFile> {
 public:
     explicit IFile(Core::System& system_, FileSys::VirtualFile backend_)
-        : ServiceFramework{system_, "IFile", ServiceThreadType::CreateNew},
-          backend(std::move(backend_)) {
+        : ServiceFramework{system_, "IFile"}, backend(std::move(backend_)) {
         static const FunctionInfo functions[] = {
             {0, &IFile::Read, "Read"},
             {1, &IFile::Write, "Write"},
@@ -254,8 +252,7 @@ static void BuildEntryIndex(std::vector<FileSys::Entry>& entries, const std::vec
 class IDirectory final : public ServiceFramework<IDirectory> {
 public:
     explicit IDirectory(Core::System& system_, FileSys::VirtualDir backend_)
-        : ServiceFramework{system_, "IDirectory", ServiceThreadType::CreateNew},
-          backend(std::move(backend_)) {
+        : ServiceFramework{system_, "IDirectory"}, backend(std::move(backend_)) {
         static const FunctionInfo functions[] = {
             {0, &IDirectory::Read, "Read"},
             {1, &IDirectory::GetEntryCount, "GetEntryCount"},
@@ -311,8 +308,8 @@ private:
 class IFileSystem final : public ServiceFramework<IFileSystem> {
 public:
     explicit IFileSystem(Core::System& system_, FileSys::VirtualDir backend_, SizeGetter size_)
-        : ServiceFramework{system_, "IFileSystem", ServiceThreadType::CreateNew},
-          backend{std::move(backend_)}, size{std::move(size_)} {
+        : ServiceFramework{system_, "IFileSystem"}, backend{std::move(backend_)}, size{std::move(
+                                                                                      size_)} {
         static const FunctionInfo functions[] = {
             {0, &IFileSystem::CreateFile, "CreateFile"},
             {1, &IFileSystem::DeleteFile, "DeleteFile"},

src/core/hle/service/friend/friend.cpp

@@ -11,6 +11,7 @@
 #include "core/hle/service/friend/friend.h"
 #include "core/hle/service/friend/friend_interface.h"
 #include "core/hle/service/kernel_helpers.h"
+#include "core/hle/service/server_manager.h"
 
 namespace Service::Friend {
 
@@ -335,13 +336,22 @@ Module::Interface::Interface(std::shared_ptr<Module> module_, Core::System& syst
 
 Module::Interface::~Interface() = default;
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
     auto module = std::make_shared<Module>();
-    std::make_shared<Friend>(module, system, "friend:a")->InstallAsService(service_manager);
-    std::make_shared<Friend>(module, system, "friend:m")->InstallAsService(service_manager);
-    std::make_shared<Friend>(module, system, "friend:s")->InstallAsService(service_manager);
-    std::make_shared<Friend>(module, system, "friend:u")->InstallAsService(service_manager);
-    std::make_shared<Friend>(module, system, "friend:v")->InstallAsService(service_manager);
+
+    server_manager->RegisterNamedService("friend:a",
+                                         std::make_shared<Friend>(module, system, "friend:a"));
+    server_manager->RegisterNamedService("friend:m",
+                                         std::make_shared<Friend>(module, system, "friend:m"));
+    server_manager->RegisterNamedService("friend:s",
+                                         std::make_shared<Friend>(module, system, "friend:s"));
+    server_manager->RegisterNamedService("friend:u",
+                                         std::make_shared<Friend>(module, system, "friend:u"));
+    server_manager->RegisterNamedService("friend:v",
+                                         std::make_shared<Friend>(module, system, "friend:v"));
+
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::Friend

src/core/hle/service/friend/friend.h

@@ -27,7 +27,6 @@ public:
     };
 };
 
-/// Registers all Friend services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::Friend

src/core/hle/service/glue/glue.cpp

@@ -8,25 +8,30 @@
 #include "core/hle/service/glue/ectx.h"
 #include "core/hle/service/glue/glue.h"
 #include "core/hle/service/glue/notif.h"
+#include "core/hle/service/server_manager.h"
 
 namespace Service::Glue {
 
-void InstallInterfaces(Core::System& system) {
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
     // ARP
-    std::make_shared<ARP_R>(system, system.GetARPManager())
-        ->InstallAsService(system.ServiceManager());
-    std::make_shared<ARP_W>(system, system.GetARPManager())
-        ->InstallAsService(system.ServiceManager());
+    server_manager->RegisterNamedService("arp:r",
+                                         std::make_shared<ARP_R>(system, system.GetARPManager()));
+    server_manager->RegisterNamedService("arp:w",
+                                         std::make_shared<ARP_W>(system, system.GetARPManager()));
 
     // BackGround Task Controller
-    std::make_shared<BGTC_T>(system)->InstallAsService(system.ServiceManager());
-    std::make_shared<BGTC_SC>(system)->InstallAsService(system.ServiceManager());
+    server_manager->RegisterNamedService("bgtc:t", std::make_shared<BGTC_T>(system));
+    server_manager->RegisterNamedService("bgtc:sc", std::make_shared<BGTC_SC>(system));
 
     // Error Context
-    std::make_shared<ECTX_AW>(system)->InstallAsService(system.ServiceManager());
+    server_manager->RegisterNamedService("ectx:aw", std::make_shared<ECTX_AW>(system));
 
     // Notification Services for application
-    std::make_shared<NOTIF_A>(system)->InstallAsService(system.ServiceManager());
+    server_manager->RegisterNamedService("notif:a", std::make_shared<NOTIF_A>(system));
+
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::Glue

src/core/hle/service/glue/glue.h

@@ -9,7 +9,6 @@ class System;
 
 namespace Service::Glue {
 
-/// Registers all Glue services with the specified service manager.
-void InstallInterfaces(Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::Glue

src/core/hle/service/grc/grc.cpp

@@ -4,8 +4,8 @@
 #include <memory>
 
 #include "core/hle/service/grc/grc.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 
 namespace Service::GRC {
 
@@ -26,8 +26,11 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<GRC>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("grc:c", std::make_shared<GRC>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::GRC

src/core/hle/service/grc/grc.h

@@ -7,12 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::GRC {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::GRC

src/core/hle/service/hid/hid.cpp

@@ -18,6 +18,7 @@
 #include "core/hle/service/hid/hidbus.h"
 #include "core/hle/service/hid/irs.h"
 #include "core/hle/service/hid/xcd.h"
+#include "core/hle/service/server_manager.h"
 #include "core/memory.h"
 
 #include "core/hle/service/hid/controllers/console_sixaxis.h"
@@ -2734,16 +2735,20 @@ private:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<Hid>(system)->InstallAsService(service_manager);
-    std::make_shared<HidBus>(system)->InstallAsService(service_manager);
-    std::make_shared<HidDbg>(system)->InstallAsService(service_manager);
-    std::make_shared<HidSys>(system)->InstallAsService(service_manager);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
 
-    std::make_shared<Service::IRS::IRS>(system)->InstallAsService(service_manager);
-    std::make_shared<Service::IRS::IRS_SYS>(system)->InstallAsService(service_manager);
+    server_manager->RegisterNamedService("hid", std::make_shared<Hid>(system));
+    server_manager->RegisterNamedService("hidbus", std::make_shared<HidBus>(system));
+    server_manager->RegisterNamedService("hid:dbg", std::make_shared<HidDbg>(system));
+    server_manager->RegisterNamedService("hid:sys", std::make_shared<HidSys>(system));
 
-    std::make_shared<XCD_SYS>(system)->InstallAsService(service_manager);
+    server_manager->RegisterNamedService("irs", std::make_shared<Service::IRS::IRS>(system));
+    server_manager->RegisterNamedService("irs:sys",
+                                         std::make_shared<Service::IRS::IRS_SYS>(system));
+
+    server_manager->RegisterNamedService("xcd:sys", std::make_shared<XCD_SYS>(system));
+    system.RunServer(std::move(server_manager));
 }
 
 } // namespace Service::HID

src/core/hle/service/hid/hid.h

@@ -209,7 +209,6 @@ private:
     KernelHelpers::ServiceContext service_context;
 };
 
-/// Registers all HID services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::HID

src/core/hle/service/jit/jit.cpp

@@ -9,6 +9,7 @@
 #include "core/hle/result.h"
 #include "core/hle/service/jit/jit.h"
 #include "core/hle/service/jit/jit_context.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 #include "core/memory.h"
 
@@ -23,8 +24,8 @@ class IJitEnvironment final : public ServiceFramework<IJitEnvironment> {
 public:
     explicit IJitEnvironment(Core::System& system_, Kernel::KProcess& process_, CodeRange user_rx,
                              CodeRange user_ro)
-        : ServiceFramework{system_, "IJitEnvironment", ServiceThreadType::CreateNew},
-          process{&process_}, context{system_.Memory()} {
+        : ServiceFramework{system_, "IJitEnvironment"}, process{&process_}, context{
+                                                                                system_.Memory()} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &IJitEnvironment::GenerateCode, "GenerateCode"},
@@ -397,8 +398,11 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<JITU>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("jit:u", std::make_shared<JITU>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::JIT

src/core/hle/service/jit/jit.h

@@ -7,13 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::JIT {
 
-/// Registers all JIT services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::JIT

src/core/hle/service/kernel_helpers.cpp

@@ -15,17 +15,24 @@ namespace Service::KernelHelpers {
 
 ServiceContext::ServiceContext(Core::System& system_, std::string name_)
     : kernel(system_.Kernel()) {
+    if (process = Kernel::GetCurrentProcessPointer(kernel); process != nullptr) {
+        return;
+    }
+
     // Create the process.
     process = Kernel::KProcess::Create(kernel);
     ASSERT(Kernel::KProcess::Initialize(process, system_, std::move(name_),
                                         Kernel::KProcess::ProcessType::KernelInternal,
                                         kernel.GetSystemResourceLimit())
                .IsSuccess());
+    process_created = true;
 }
 
 ServiceContext::~ServiceContext() {
+    if (process_created) {
         process->Close();
         process = nullptr;
+    }
 }
 
 Kernel::KEvent* ServiceContext::CreateEvent(std::string&& name) {

src/core/hle/service/kernel_helpers.h

@@ -29,6 +29,7 @@ public:
 private:
     Kernel::KernelCore& kernel;
     Kernel::KProcess* process{};
+    bool process_created{false};
 };
 
 } // namespace Service::KernelHelpers

src/core/hle/service/lbl/lbl.cpp

@@ -7,6 +7,7 @@
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/lbl/lbl.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
 
@@ -319,8 +320,11 @@ private:
     bool auto_brightness = false; // TODO(ogniK): Move to system settings
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<LBL>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("lbl", std::make_shared<LBL>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::LBL

src/core/hle/service/lbl/lbl.h

@@ -7,12 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::LBL {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::LBL

src/core/hle/service/ldn/ldn.cpp

@@ -8,6 +8,7 @@
 #include "core/hle/service/ldn/ldn.h"
 #include "core/hle/service/ldn/ldn_results.h"
 #include "core/hle/service/ldn/ldn_types.h"
+#include "core/hle/service/server_manager.h"
 #include "core/internal_network/network.h"
 #include "core/internal_network/network_interface.h"
 #include "network/network.h"
@@ -106,7 +107,7 @@ class IUserLocalCommunicationService final
     : public ServiceFramework<IUserLocalCommunicationService> {
 public:
     explicit IUserLocalCommunicationService(Core::System& system_)
-        : ServiceFramework{system_, "IUserLocalCommunicationService", ServiceThreadType::CreateNew},
+        : ServiceFramework{system_, "IUserLocalCommunicationService"},
           service_context{system, "IUserLocalCommunicationService"},
           room_network{system_.GetRoomNetwork()}, lan_discovery{room_network} {
         // clang-format off
@@ -730,12 +731,15 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<LDNM>(system)->InstallAsService(sm);
-    std::make_shared<LDNS>(system)->InstallAsService(sm);
-    std::make_shared<LDNU>(system)->InstallAsService(sm);
-    std::make_shared<LP2PAPP>(system)->InstallAsService(sm);
-    std::make_shared<LP2PSYS>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("ldn:m", std::make_shared<LDNM>(system));
+    server_manager->RegisterNamedService("ldn:s", std::make_shared<LDNS>(system));
+    server_manager->RegisterNamedService("ldn:u", std::make_shared<LDNU>(system));
+    server_manager->RegisterNamedService("lp2p:app", std::make_shared<LP2PAPP>(system));
+    server_manager->RegisterNamedService("lp2p:sys", std::make_shared<LP2PSYS>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::LDN

src/core/hle/service/ldn/ldn.h

@@ -13,13 +13,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::LDN {
 
-/// Registers all LDN services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::LDN

src/core/hle/service/ldr/ldr.cpp

@@ -14,6 +14,7 @@
 #include "core/hle/kernel/svc_results.h"
 #include "core/hle/kernel/svc_types.h"
 #include "core/hle/service/ldr/ldr.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 #include "core/loader/nro.h"
 #include "core/memory.h"
@@ -159,8 +160,7 @@ public:
 
 class RelocatableObject final : public ServiceFramework<RelocatableObject> {
 public:
-    explicit RelocatableObject(Core::System& system_)
-        : ServiceFramework{system_, "ldr:ro", ServiceThreadType::CreateNew} {
+    explicit RelocatableObject(Core::System& system_) : ServiceFramework{system_, "ldr:ro"} {
         // clang-format off
         static const FunctionInfo functions[] = {
             {0, &RelocatableObject::LoadModule, "LoadModule"},
@@ -682,11 +682,15 @@ private:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<DebugMonitor>(system)->InstallAsService(sm);
-    std::make_shared<ProcessManager>(system)->InstallAsService(sm);
-    std::make_shared<Shell>(system)->InstallAsService(sm);
-    std::make_shared<RelocatableObject>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("ldr:dmnt", std::make_shared<DebugMonitor>(system));
+    server_manager->RegisterNamedService("ldr:pm", std::make_shared<ProcessManager>(system));
+    server_manager->RegisterNamedService("ldr:shel", std::make_shared<Shell>(system));
+    server_manager->RegisterNamedService("ldr:ro", std::make_shared<RelocatableObject>(system));
+
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::LDR

src/core/hle/service/ldr/ldr.h

@@ -7,13 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::LDR {
 
-/// Registers all LDR services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::LDR

src/core/hle/service/lm/lm.cpp

@@ -10,6 +10,7 @@
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/lm/lm.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 
 namespace Service::LM {
@@ -351,8 +352,11 @@ private:
     }
 };
 
-void InstallInterfaces(Core::System& system) {
-    std::make_shared<LM>(system)->InstallAsService(system.ServiceManager());
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("lm", std::make_shared<LM>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::LM

src/core/hle/service/lm/lm.h

@@ -9,7 +9,6 @@ class System;
 
 namespace Service::LM {
 
-/// Registers all LM services with the specified service manager.
-void InstallInterfaces(Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::LM

src/core/hle/service/mig/mig.cpp

@@ -4,8 +4,8 @@
 #include <memory>
 
 #include "core/hle/service/mig/mig.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 
 namespace Service::Migration {
 
@@ -32,8 +32,11 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<MIG_USR>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("mig:user", std::make_shared<MIG_USR>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::Migration

src/core/hle/service/mig/mig.h

@@ -7,12 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::Migration {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::Migration

src/core/hle/service/mii/mii.cpp

@@ -7,8 +7,8 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/mii/mii.h"
 #include "core/hle/service/mii/mii_manager.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 
 namespace Service::Mii {
 
@@ -310,11 +310,13 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<MiiDBModule>(system, "mii:e")->InstallAsService(sm);
-    std::make_shared<MiiDBModule>(system, "mii:u")->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
 
-    std::make_shared<MiiImg>(system)->InstallAsService(sm);
+    server_manager->RegisterNamedService("mii:e", std::make_shared<MiiDBModule>(system, "mii:e"));
+    server_manager->RegisterNamedService("mii:u", std::make_shared<MiiDBModule>(system, "mii:u"));
+    server_manager->RegisterNamedService("miiimg", std::make_shared<MiiImg>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::Mii

src/core/hle/service/mii/mii.h

@@ -7,12 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::Mii {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::Mii

src/core/hle/service/mm/mm_u.cpp

@@ -4,6 +4,7 @@
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/mm/mm_u.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/sm/sm.h"
 
 namespace Service::MM {
@@ -103,8 +104,11 @@ private:
     u32 id{1};
 };
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<MM_U>(system)->InstallAsService(service_manager);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("mm:u", std::make_shared<MM_U>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::MM

src/core/hle/service/mm/mm_u.h

@@ -7,13 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::MM {
 
-/// Registers all MM services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::MM

src/core/hle/service/mnpp/mnpp_app.cpp

@@ -4,7 +4,8 @@
 #include "common/logging/log.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/mnpp/mnpp_app.h"
-#include "core/hle/service/sm/sm.h"
+#include "core/hle/service/server_manager.h"
+#include "core/hle/service/service.h"
 
 namespace Service::MNPP {
 
@@ -37,8 +38,11 @@ private:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<MNPP_APP>(system)->InstallAsService(service_manager);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("mnpp:app", std::make_shared<MNPP_APP>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::MNPP

src/core/hle/service/mnpp/mnpp_app.h

@@ -7,13 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::MNPP {
 
-/// Registers all MNPP services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::MNPP

src/core/hle/service/mutex.cpp

@@ -0,0 +1,43 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "core/core.h"
+#include "core/hle/kernel/k_event.h"
+#include "core/hle/kernel/k_synchronization_object.h"
+#include "core/hle/service/mutex.h"
+
+namespace Service {
+
+Mutex::Mutex(Core::System& system) : m_system(system) {
+    m_event = Kernel::KEvent::Create(system.Kernel());
+    m_event->Initialize(nullptr);
+
+    ASSERT(R_SUCCEEDED(m_event->Signal()));
+}
+
+Mutex::~Mutex() {
+    m_event->GetReadableEvent().Close();
+    m_event->Close();
+}
+
+void Mutex::lock() {
+    // Infinitely retry until we successfully clear the event.
+    while (R_FAILED(m_event->GetReadableEvent().Reset())) {
+        s32 index;
+        Kernel::KSynchronizationObject* obj = &m_event->GetReadableEvent();
+
+        // The event was already cleared!
+        // Wait for it to become signaled again.
+        ASSERT(R_SUCCEEDED(
+            Kernel::KSynchronizationObject::Wait(m_system.Kernel(), &index, &obj, 1, -1)));
+    }
+
+    // We successfully cleared the event, and now have exclusive ownership.
+}
+
+void Mutex::unlock() {
+    // Unlock.
+    ASSERT(R_SUCCEEDED(m_event->Signal()));
+}
+
+} // namespace Service

src/core/hle/service/mutex.h

@@ -0,0 +1,31 @@
+// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include "common/common_types.h"
+
+namespace Core {
+class System;
+}
+
+namespace Kernel {
+class KEvent;
+}
+
+namespace Service {
+
+class Mutex {
+public:
+    explicit Mutex(Core::System& system);
+    ~Mutex();
+
+    void lock();
+    void unlock();
+
+private:
+    Core::System& m_system;
+    Kernel::KEvent* m_event{};
+};
+
+} // namespace Service

src/core/hle/service/ncm/ncm.cpp

@@ -6,8 +6,8 @@
 #include "core/file_sys/romfs_factory.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/ncm/ncm.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 
 namespace Service::NCM {
 
@@ -131,9 +131,12 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<LR>(system)->InstallAsService(sm);
-    std::make_shared<NCM>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("lr", std::make_shared<LR>(system));
+    server_manager->RegisterNamedService("ncm", std::make_shared<NCM>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::NCM

src/core/hle/service/ncm/ncm.h

@@ -7,12 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::NCM {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::NCM

src/core/hle/service/nfc/nfc.cpp

@@ -9,8 +9,8 @@
 #include "core/hle/service/nfc/mifare_user.h"
 #include "core/hle/service/nfc/nfc.h"
 #include "core/hle/service/nfc/nfc_user.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 
 namespace Service::NFC {
 
@@ -154,11 +154,14 @@ private:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<NFC_AM>(system)->InstallAsService(sm);
-    std::make_shared<NFC_MF_U>(system)->InstallAsService(sm);
-    std::make_shared<NFC_U>(system)->InstallAsService(sm);
-    std::make_shared<NFC_SYS>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("nfc:am", std::make_shared<NFC_AM>(system));
+    server_manager->RegisterNamedService("nfc:mf:u", std::make_shared<NFC_MF_U>(system));
+    server_manager->RegisterNamedService("nfc:user", std::make_shared<NFC_U>(system));
+    server_manager->RegisterNamedService("nfc:sys", std::make_shared<NFC_SYS>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::NFC

src/core/hle/service/nfc/nfc.h

@@ -7,12 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::NFC {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::NFC

src/core/hle/service/nfp/nfp.cpp

@@ -5,6 +5,7 @@
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/nfp/nfp.h"
 #include "core/hle/service/nfp/nfp_user.h"
+#include "core/hle/service/server_manager.h"
 
 namespace Service::NFP {
 
@@ -36,8 +37,11 @@ private:
     std::shared_ptr<IUser> user_interface;
 };
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<IUserManager>(system)->InstallAsService(service_manager);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("nfp:user", std::make_shared<IUserManager>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::NFP

src/core/hle/service/nfp/nfp.h

@@ -7,6 +7,6 @@
 
 namespace Service::NFP {
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::NFP

src/core/hle/service/ngct/ngct.cpp

@@ -5,6 +5,7 @@
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/service/ngct/ngct.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
 
 namespace Service::NGCT {
@@ -51,8 +52,11 @@ private:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<IService>(system)->InstallAsService(system.ServiceManager());
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("ngct:u", std::make_shared<IService>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::NGCT

src/core/hle/service/ngct/ngct.h

@@ -7,13 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::NGCT {
 
-/// Registers all NGCT services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::NGCT

src/core/hle/service/nifm/nifm.cpp

@@ -6,6 +6,7 @@
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/nifm/nifm.h"
+#include "core/hle/service/server_manager.h"
 
 namespace {
 
@@ -626,10 +627,16 @@ private:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
-    std::make_shared<NetworkInterface>("nifm:a", system)->InstallAsService(service_manager);
-    std::make_shared<NetworkInterface>("nifm:s", system)->InstallAsService(service_manager);
-    std::make_shared<NetworkInterface>("nifm:u", system)->InstallAsService(service_manager);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("nifm:a",
+                                         std::make_shared<NetworkInterface>("nifm:a", system));
+    server_manager->RegisterNamedService("nifm:s",
+                                         std::make_shared<NetworkInterface>("nifm:s", system));
+    server_manager->RegisterNamedService("nifm:u",
+                                         std::make_shared<NetworkInterface>("nifm:u", system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::NIFM

src/core/hle/service/nifm/nifm.h

@@ -12,14 +12,9 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::NIFM {
 
-/// Registers all NIFM services with the specified service manager.
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system);
+void LoopProcess(Core::System& system);
 
 class IGeneralService final : public ServiceFramework<IGeneralService> {
 public:

src/core/hle/service/nim/nim.cpp

@@ -8,8 +8,8 @@
 #include "core/hle/kernel/k_event.h"
 #include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/nim/nim.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 
 namespace Service::NIM {
 
@@ -418,11 +418,14 @@ private:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<NIM>(system)->InstallAsService(sm);
-    std::make_shared<NIM_ECA>(system)->InstallAsService(sm);
-    std::make_shared<NIM_SHP>(system)->InstallAsService(sm);
-    std::make_shared<NTC>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("nim", std::make_shared<NIM>(system));
+    server_manager->RegisterNamedService("nim:eca", std::make_shared<NIM_ECA>(system));
+    server_manager->RegisterNamedService("nim:shp", std::make_shared<NIM_SHP>(system));
+    server_manager->RegisterNamedService("ntc", std::make_shared<NTC>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::NIM

src/core/hle/service/nim/nim.h

@@ -7,12 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::NIM {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::NIM

src/core/hle/service/npns/npns.cpp

@@ -4,8 +4,8 @@
 #include <memory>
 
 #include "core/hle/service/npns/npns.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/service.h"
-#include "core/hle/service/sm/sm.h"
 
 namespace Service::NPNS {
 
@@ -94,9 +94,12 @@ public:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system) {
-    std::make_shared<NPNS_S>(system)->InstallAsService(sm);
-    std::make_shared<NPNS_U>(system)->InstallAsService(sm);
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->RegisterNamedService("npns:s", std::make_shared<NPNS_S>(system));
+    server_manager->RegisterNamedService("npns:u", std::make_shared<NPNS_U>(system));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::NPNS

src/core/hle/service/npns/npns.h

@@ -7,12 +7,8 @@ namespace Core {
 class System;
 }
 
-namespace Service::SM {
-class ServiceManager;
-}
-
 namespace Service::NPNS {
 
-void InstallInterfaces(SM::ServiceManager& sm, Core::System& system);
+void LoopProcess(Core::System& system);
 
 } // namespace Service::NPNS

src/core/hle/service/ns/ns.cpp

@@ -14,6 +14,7 @@
 #include "core/hle/service/ns/language.h"
 #include "core/hle/service/ns/ns.h"
 #include "core/hle/service/ns/pdm_qry.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/set/set.h"
 
 namespace Service::NS {
@@ -777,23 +778,26 @@ private:
     }
 };
 
-void InstallInterfaces(SM::ServiceManager& service_manager, Core::System& system) {
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
 
-    std::make_shared<NS>("ns:am2", system)->InstallAsService(service_manager);
-    std::make_shared<NS>("ns:ec", system)->InstallAsService(service_manager);
-    std::make_shared<NS>("ns:rid", system)->InstallAsService(service_manager);
-    std::make_shared<NS>("ns:rt", system)->InstallAsService(service_manager);
-    std::make_shared<NS>("ns:web", system)->InstallAsService(service_manager);
-    std::make_shared<NS>("ns:ro", system)->InstallAsService(service_manager);
+    server_manager->RegisterNamedService("ns:am2", std::make_shared<NS>("ns:am2", system));
+    server_manager->RegisterNamedService("ns:ec", std::make_shared<NS>("ns:ec", system));
+    server_manager->RegisterNamedService("ns:rid", std::make_shared<NS>("ns:rid", system));
+    server_manager->RegisterNamedService("ns:rt", std::make_shared<NS>("ns:rt", system));
+    server_manager->RegisterNamedService("ns:web", std::make_shared<NS>("ns:web", system));
+    server_manager->RegisterNamedService("ns:ro", std::make_shared<NS>("ns:ro", system));
 
-    std::make_shared<NS_DEV>(system)->InstallAsService(service_manager);
-    std::make_shared<NS_SU>(system)->InstallAsService(service_manager);
-    std::make_shared<NS_VM>(system)->InstallAsService(service_manager);
+    server_manager->RegisterNamedService("ns:dev", std::make_shared<NS_DEV>(system));
+    server_manager->RegisterNamedService("ns:su", std::make_shared<NS_SU>(system));
+    server_manager->RegisterNamedService("ns:vm", std::make_shared<NS_VM>(system));
+    server_manager->RegisterNamedService("pdm:qry", std::make_shared<PDM_QRY>(system));
 
-    std::make_shared<PDM_QRY>(system)->InstallAsService(service_manager);
-
-    std::make_shared<IPlatformServiceManager>(system, "pl:s")->InstallAsService(service_manager);
-    std::make_shared<IPlatformServiceManager>(system, "pl:u")->InstallAsService(service_manager);
+    server_manager->RegisterNamedService("pl:s",
+                                         std::make_shared<IPlatformServiceManager>(system, "pl:s"));
+    server_manager->RegisterNamedService("pl:u",
+                                         std::make_shared<IPlatformServiceManager>(system, "pl:u"));
+    ServerManager::RunServer(std::move(server_manager));
 }
 
 } // namespace Service::NS