service: refactor server architecture

Converts services to have their own processes

src/core/hle/service/sm/sm.cpp

@@ -12,6 +12,7 @@
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_server_port.h"
 #include "core/hle/result.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/sm/sm.h"
 #include "core/hle/service/sm/sm_controller.h"
 
@@ -22,7 +23,9 @@ constexpr Result ERR_ALREADY_REGISTERED(ErrorModule::SM, 4);
 constexpr Result ERR_INVALID_NAME(ErrorModule::SM, 6);
 constexpr Result ERR_SERVICE_NOT_REGISTERED(ErrorModule::SM, 7);
 
-ServiceManager::ServiceManager(Kernel::KernelCore& kernel_) : kernel{kernel_} {}
+ServiceManager::ServiceManager(Kernel::KernelCore& kernel_) : kernel{kernel_} {
+    controller_interface = std::make_unique<Controller>(kernel.System());
+}
 
 ServiceManager::~ServiceManager() {
     for (auto& [name, port] : service_ports) {
@@ -43,21 +46,12 @@ static Result ValidateServiceName(const std::string& name) {
     return ResultSuccess;
 }
 
-Kernel::KClientPort& ServiceManager::InterfaceFactory(ServiceManager& self, Core::System& system) {
-    self.sm_interface = std::make_shared<SM>(self, system);
-    self.controller_interface = std::make_unique<Controller>(system);
-    return self.sm_interface->CreatePort();
-}
-
-void ServiceManager::SessionHandler(ServiceManager& self, Kernel::KServerPort* server_port) {
-    self.sm_interface->AcceptSession(server_port);
-}
-
 Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
                                        Kernel::SessionRequestHandlerPtr handler) {
 
     CASCADE_CODE(ValidateServiceName(name));
 
+    std::scoped_lock lk{lock};
     if (registered_services.find(name) != registered_services.end()) {
         LOG_ERROR(Service_SM, "Service is already registered! service={}", name);
         return ERR_ALREADY_REGISTERED;
@@ -75,6 +69,7 @@ Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
 Result ServiceManager::UnregisterService(const std::string& name) {
     CASCADE_CODE(ValidateServiceName(name));
 
+    std::scoped_lock lk{lock};
     const auto iter = registered_services.find(name);
     if (iter == registered_services.end()) {
         LOG_ERROR(Service_SM, "Server is not registered! service={}", name);
@@ -89,6 +84,8 @@ Result ServiceManager::UnregisterService(const std::string& name) {
 
 ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name) {
     CASCADE_CODE(ValidateServiceName(name));
+
+    std::scoped_lock lk{lock};
     auto it = service_ports.find(name);
     if (it == service_ports.end()) {
         LOG_ERROR(Service_SM, "Server is not registered! service={}", name);
@@ -154,8 +151,7 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(Kernel::HLERequestContext&
 
     // Find the named port.
     auto port_result = service_manager.GetServicePort(name);
-    auto service = service_manager.GetService<Kernel::SessionRequestHandler>(name);
-    if (port_result.Failed() || !service) {
+    if (port_result.Failed()) {
         LOG_ERROR(Service_SM, "called service={} -> error 0x{:08X}", name, port_result.Code().raw);
         return port_result.Code();
     }
@@ -167,7 +163,6 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(Kernel::HLERequestContext&
         LOG_ERROR(Service_SM, "called service={} -> error 0x{:08X}", name, result.raw);
         return result;
     }
-    service->AcceptSession(&port->GetServerPort());
 
     LOG_DEBUG(Service_SM, "called service={} -> session={}", name, session->GetId());
 
@@ -212,7 +207,7 @@ void SM::UnregisterService(Kernel::HLERequestContext& ctx) {
 }
 
 SM::SM(ServiceManager& service_manager_, Core::System& system_)
-    : ServiceFramework{system_, "sm:", ServiceThreadType::Default, 4},
+    : ServiceFramework{system_, "sm:", 4},
       service_manager{service_manager_}, kernel{system_.Kernel()} {
     RegisterHandlers({
         {0, &SM::Initialize, "Initialize"},
@@ -232,4 +227,11 @@ SM::SM(ServiceManager& service_manager_, Core::System& system_)
 
 SM::~SM() = default;
 
+void LoopProcess(Core::System& system) {
+    auto server_manager = std::make_unique<ServerManager>(system);
+
+    server_manager->ManageNamedPort("sm:", std::make_shared<SM>(system.ServiceManager(), system));
+    ServerManager::RunServer(std::move(server_manager));
+}
+
 } // namespace Service::SM

src/core/hle/service/sm/sm.h

@@ -4,6 +4,7 @@
 #pragma once
 
 #include <memory>
+#include <mutex>
 #include <string>
 #include <unordered_map>
 
@@ -50,9 +51,6 @@ private:
 
 class ServiceManager {
 public:
-    static Kernel::KClientPort& InterfaceFactory(ServiceManager& self, Core::System& system);
-    static void SessionHandler(ServiceManager& self, Kernel::KServerPort* server_port);
-
     explicit ServiceManager(Kernel::KernelCore& kernel_);
     ~ServiceManager();
 
@@ -78,6 +76,7 @@ private:
     std::unique_ptr<Controller> controller_interface;
 
     /// Map of registered services, retrieved using GetServicePort.
+    std::mutex lock;
     std::unordered_map<std::string, Kernel::SessionRequestHandlerPtr> registered_services;
     std::unordered_map<std::string, Kernel::KPort*> service_ports;
 
@@ -85,4 +84,7 @@ private:
     Kernel::KernelCore& kernel;
 };
 
+/// Runs SM services.
+void LoopProcess(Core::System& system);
+
 } // namespace Service::SM

src/core/hle/service/sm/sm_controller.cpp

@@ -10,6 +10,7 @@
 #include "core/hle/kernel/k_scoped_resource_reservation.h"
 #include "core/hle/kernel/k_server_session.h"
 #include "core/hle/kernel/k_session.h"
+#include "core/hle/service/server_manager.h"
 #include "core/hle/service/sm/sm_controller.h"
 
 namespace Service::SM {
@@ -48,9 +49,9 @@ void Controller::CloneCurrentObject(Kernel::HLERequestContext& ctx) {
     // Commit the session reservation.
     session_reservation.Commit();
 
-    // Register with manager.
-    session_manager->SessionHandler().RegisterSession(&session->GetServerSession(),
-                                                      session_manager);
+    // Register with server manager.
+    session_manager->GetServerManager().RegisterSession(&session->GetServerSession(),
+                                                        session_manager);
 
     // We succeeded.
     IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};