From 84c497292a27d75b83305d053e734ab5659ffe41 Mon Sep 17 00:00:00 2001
From: Yuri Kunde Schlesner <yuriks@yuriks.net>
Date: Tue, 6 Jun 2017 21:20:52 -0700
Subject: [PATCH] Service: Add new ServiceFramework framework for writing HLE
services
The old "Interface" class had a few problems such as using free
functions (Which didn't allow you to write the service handler as if it
were a regular class.) which weren't very extensible. (Only received one
parameter with a pointer to the Interface object.)
The new ServiceFramework aims to solve these problems by working with
member functions and passing a generic context struct as parameter. This
struct can be extended in the future without having to update all
existing service implementations.
---
src/core/CMakeLists.txt | 2 +-
src/core/hle/kernel/hle_ipc.cpp | 2 +
src/core/hle/kernel/hle_ipc.h | 36 +++++++-
src/core/hle/service/service.cpp | 83 ++++++++++++++++-
src/core/hle/service/service.h | 150 +++++++++++++++++++++++++++++++
5 files changed, 269 insertions(+), 4 deletions(-)
diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt
index 6e602b0c52..b16a899902 100644
--- a/src/core/CMakeLists.txt
+++ b/src/core/CMakeLists.txt
@@ -385,4 +385,4 @@ set(HEADERS
create_directory_groups(${SRCS} ${HEADERS})
add_library(core STATIC ${SRCS} ${HEADERS})
target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE cryptopp dynarmic)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE cryptopp dynarmic fmt)
diff --git a/src/core/hle/kernel/hle_ipc.cpp b/src/core/hle/kernel/hle_ipc.cpp
index 0922b3f47f..a60b8ef002 100644
--- a/src/core/hle/kernel/hle_ipc.cpp
+++ b/src/core/hle/kernel/hle_ipc.cpp
@@ -21,4 +21,6 @@ void SessionRequestHandler::ClientDisconnected(SharedPtr<ServerSession> server_s
boost::range::remove_erase(connected_sessions, server_session);
}
+HLERequestContext::~HLERequestContext() = default;
+
} // namespace Kernel
diff --git a/src/core/hle/kernel/hle_ipc.h b/src/core/hle/kernel/hle_ipc.h
index 5de9d59d3c..c30184eab9 100644
--- a/src/core/hle/kernel/hle_ipc.h
+++ b/src/core/hle/kernel/hle_ipc.h
@@ -7,10 +7,13 @@
#include <memory>
#include <vector>
#include "core/hle/kernel/kernel.h"
+#include "core/hle/kernel/server_session.h"
-namespace Kernel {
+namespace Service {
+class ServiceFrameworkBase;
+}
-class ServerSession;
+namespace Kernel {
/**
* Interface implemented by HLE Session handlers.
@@ -52,4 +55,33 @@ protected:
std::vector<SharedPtr<ServerSession>> connected_sessions;
};
+/**
+ * Class containing information about an in-flight IPC request being handled by an HLE service
+ * implementation. Services should avoid using old global APIs (e.g. Kernel::GetCommandBuffer()) and
+ * when possible use the APIs in this class to service the request.
+ */
+class HLERequestContext {
+public:
+ ~HLERequestContext();
+
+ /// Returns a pointer to the IPC command buffer for this request.
+ u32* CommandBuffer() const {
+ return cmd_buf;
+ }
+
+ /**
+ * Returns the session through which this request was made. This can be used as a map key to
+ * access per-client data on services.
+ */
+ SharedPtr<ServerSession> Session() const {
+ return session;
+ }
+
+private:
+ friend class Service::ServiceFrameworkBase;
+
+ u32* cmd_buf = nullptr;
+ SharedPtr<ServerSession> session;
+};
+
} // namespace Kernel
diff --git a/src/core/hle/service/service.cpp b/src/core/hle/service/service.cpp
index 0d443aa447..10f2b3ee3f 100644
--- a/src/core/hle/service/service.cpp
+++ b/src/core/hle/service/service.cpp
@@ -2,6 +2,7 @@
// Licensed under GPLv2 or any later version
// Refer to the license.txt file included.
+#include <fmt/format.h>
#include "common/logging/log.h"
#include "common/string_util.h"
#include "core/hle/kernel/client_port.h"
@@ -45,6 +46,11 @@
#include "core/hle/service/ssl_c.h"
#include "core/hle/service/y2r_u.h"
+using Kernel::ClientPort;
+using Kernel::ServerPort;
+using Kernel::ServerSession;
+using Kernel::SharedPtr;
+
namespace Service {
std::unordered_map<std::string, Kernel::SharedPtr<Kernel::ClientPort>> g_kernel_named_ports;
@@ -102,9 +108,84 @@ void Interface::Register(const FunctionInfo* functions, size_t n) {
}
}
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ServiceFrameworkBase::ServiceFrameworkBase(const char* service_name, u32 max_sessions,
+ InvokerFn* handler_invoker)
+ : service_name(service_name), max_sessions(max_sessions), handler_invoker(handler_invoker) {}
+
+ServiceFrameworkBase::~ServiceFrameworkBase() = default;
+
+void ServiceFrameworkBase::InstallAsService(SM::ServiceManager& service_manager) {
+ ASSERT(port == nullptr);
+ port = service_manager.RegisterService(service_name, max_sessions).Unwrap();
+ port->SetHleHandler(shared_from_this());
+}
+
+void ServiceFrameworkBase::InstallAsNamedPort() {
+ ASSERT(port == nullptr);
+ SharedPtr<ServerPort> server_port;
+ SharedPtr<ClientPort> client_port;
+ std::tie(server_port, client_port) = ServerPort::CreatePortPair(max_sessions, service_name);
+ server_port->SetHleHandler(shared_from_this());
+ AddNamedPort(service_name, std::move(client_port));
+}
+
+void ServiceFrameworkBase::RegisterHandlersBase(const FunctionInfoBase* functions, size_t n) {
+ handlers.reserve(handlers.size() + n);
+ for (size_t i = 0; i < n; ++i) {
+ // Usually this array is sorted by id already, so hint to insert at the end
+ handlers.emplace_hint(handlers.cend(), functions[i].expected_header, functions[i]);
+ }
+}
+
+void ServiceFrameworkBase::ReportUnimplementedFunction(u32* cmd_buf, const FunctionInfoBase* info) {
+ IPC::Header header{cmd_buf[0]};
+ int num_params = header.normal_params_size + header.translate_params_size;
+ std::string function_name = info == nullptr ? fmt::format("{:#08x}", cmd_buf[0]) : info->name;
+
+ fmt::MemoryWriter w;
+ w.write("function '{}': port='{}' cmd_buf={{[0]={:#x}", function_name, service_name,
+ cmd_buf[0]);
+ for (int i = 1; i <= num_params; ++i) {
+ w.write(", [{}]={:#x}", i, cmd_buf[i]);
+ }
+ w << '}';
+
+ LOG_ERROR(Service, "unknown / unimplemented %s", w.c_str());
+ // TODO(bunnei): Hack - ignore error
+ cmd_buf[1] = 0;
+}
+
+void ServiceFrameworkBase::HandleSyncRequest(SharedPtr<ServerSession> server_session) {
+ u32* cmd_buf = Kernel::GetCommandBuffer();
+
+ // TODO(yuriks): The kernel should be the one handling this as part of translation after
+ // everything else is migrated
+ Kernel::HLERequestContext context;
+ context.cmd_buf = cmd_buf;
+ context.session = std::move(server_session);
+
+ u32 header_code = cmd_buf[0];
+ auto itr = handlers.find(header_code);
+ const FunctionInfoBase* info = itr == handlers.end() ? nullptr : &itr->second;
+ if (info == nullptr || info->handler_callback == nullptr) {
+ return ReportUnimplementedFunction(cmd_buf, info);
+ }
+
+ LOG_TRACE(Service, "%s",
+ MakeFunctionString(info->name, GetServiceName().c_str(), cmd_buf).c_str());
+ handler_invoker(this, info->handler_callback, context);
+}
+
////////////////////////////////////////////////////////////////////////////////////////////////////
// Module interface
+// TODO(yuriks): Move to kernel
+void AddNamedPort(std::string name, SharedPtr<ClientPort> port) {
+ g_kernel_named_ports.emplace(std::move(name), std::move(port));
+}
+
static void AddNamedPort(Interface* interface_) {
Kernel::SharedPtr<Kernel::ServerPort> server_port;
Kernel::SharedPtr<Kernel::ClientPort> client_port;
@@ -112,7 +193,7 @@ static void AddNamedPort(Interface* interface_) {
Kernel::ServerPort::CreatePortPair(interface_->GetMaxSessions(), interface_->GetPortName());
server_port->SetHleHandler(std::shared_ptr<Interface>(interface_));
- g_kernel_named_ports.emplace(interface_->GetPortName(), std::move(client_port));
+ AddNamedPort(interface_->GetPortName(), std::move(client_port));
}
void AddService(Interface* interface_) {
diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h
index 8933d57ccf..281ff99bb2 100644
--- a/src/core/hle/service/service.h
+++ b/src/core/hle/service/service.h
@@ -18,11 +18,16 @@
namespace Kernel {
class ClientPort;
+class ServerPort;
class ServerSession;
}
namespace Service {
+namespace SM {
+class ServiceManager;
+}
+
static const int kMaxPortSize = 8; ///< Maximum size of a port name (8 characters)
/// Arbitrary default number of maximum connections to an HLE service.
static const u32 DefaultMaxSessions = 10;
@@ -30,6 +35,9 @@ static const u32 DefaultMaxSessions = 10;
/**
* Framework for implementing HLE service handlers which dispatch incoming SyncRequests based on a
* table mapping header ids to handler functions.
+ *
+ * @deprecated Use ServiceFramework for new services instead. It allows services to be stateful and
+ * is more extensible going forward.
*/
class Interface : public Kernel::SessionRequestHandler {
public:
@@ -101,6 +109,146 @@ private:
boost::container::flat_map<u32, FunctionInfo> m_functions;
};
+/**
+ * This is an non-templated base of ServiceFramework to reduce code bloat and compilation times, it
+ * is not meant to be used directly.
+ *
+ * @see ServiceFramework
+ */
+class ServiceFrameworkBase : public Kernel::SessionRequestHandler {
+public:
+ /// Returns the string identifier used to connect to the service.
+ std::string GetServiceName() const {
+ return service_name;
+ }
+
+ /**
+ * Returns the maximum number of sessions that can be connected to this service at the same
+ * time.
+ */
+ u32 GetMaxSessions() const {
+ return max_sessions;
+ }
+
+ /// Creates a port pair and registers this service with the given ServiceManager.
+ void InstallAsService(SM::ServiceManager& service_manager);
+ /// Creates a port pair and registers it on the kernel's global port registry.
+ void InstallAsNamedPort();
+
+ void HandleSyncRequest(Kernel::SharedPtr<Kernel::ServerSession> server_session) override;
+
+protected:
+ /// Member-function pointer type of SyncRequest handlers.
+ template <typename Self>
+ using HandlerFnP = void (Self::*)(Kernel::HLERequestContext&);
+
+private:
+ template <typename T>
+ friend class ServiceFramework;
+
+ struct FunctionInfoBase {
+ u32 expected_header;
+ HandlerFnP<ServiceFrameworkBase> handler_callback;
+ const char* name;
+ };
+
+ using InvokerFn = void(ServiceFrameworkBase* object, HandlerFnP<ServiceFrameworkBase> member,
+ Kernel::HLERequestContext& ctx);
+
+ ServiceFrameworkBase(const char* service_name, u32 max_sessions, InvokerFn* handler_invoker);
+ ~ServiceFrameworkBase();
+
+ void RegisterHandlersBase(const FunctionInfoBase* functions, size_t n);
+ void ReportUnimplementedFunction(u32* cmd_buf, const FunctionInfoBase* info);
+
+ /// Identifier string used to connect to the service.
+ std::string service_name;
+ /// Maximum number of concurrent sessions that this service can handle.
+ u32 max_sessions;
+
+ /**
+ * Port where incoming connections will be received. Only created when InstallAsService() or
+ * InstallAsNamedPort() are called.
+ */
+ Kernel::SharedPtr<Kernel::ServerPort> port;
+
+ /// Function used to safely up-cast pointers to the derived class before invoking a handler.
+ InvokerFn* handler_invoker;
+ boost::container::flat_map<u32, FunctionInfoBase> handlers;
+};
+
+/**
+ * Framework for implementing HLE services. Dispatches on the header id of incoming SyncRequests
+ * based on a table mapping header ids to handler functions. Service implementations should inherit
+ * from ServiceFramework using the CRTP (`class Foo : public ServiceFramework<Foo> { ... };`) and
+ * populate it with handlers by calling #RegisterHandlers.
+ *
+ * In order to avoid duplicating code in the binary and exposing too many implementation details in
+ * the header, this class is split into a non-templated base (ServiceFrameworkBase) and a template
+ * deriving from it (ServiceFramework). The functions in this class will mostly only erase the type
+ * of the passed in function pointers and then delegate the actual work to the implementation in the
+ * base class.
+ */
+template <typename Self>
+class ServiceFramework : public ServiceFrameworkBase {
+protected:
+ /// Contains information about a request type which is handled by the service.
+ struct FunctionInfo : FunctionInfoBase {
+ // TODO(yuriks): This function could be constexpr, but clang is the only compiler that
+ // doesn't emit an ICE or a wrong diagnostic because of the static_cast.
+
+ /**
+ * Constructs a FunctionInfo for a function.
+ *
+ * @param expected_header request header in the command buffer which will trigger dispatch
+ * to this handler
+ * @param handler_callback member function in this service which will be called to handle
+ * the request
+ * @param name human-friendly name for the request. Used mostly for logging purposes.
+ */
+ FunctionInfo(u32 expected_header, HandlerFnP<Self> handler_callback, const char* name)
+ : FunctionInfoBase{
+ expected_header,
+ // Type-erase member function pointer by casting it down to the base class.
+ static_cast<HandlerFnP<ServiceFrameworkBase>>(handler_callback), name} {}
+ };
+
+ /**
+ * Initializes the handler with no functions installed.
+ * @param max_sessions Maximum number of sessions that can be
+ * connected to this service at the same time.
+ */
+ ServiceFramework(const char* service_name, u32 max_sessions = DefaultMaxSessions)
+ : ServiceFrameworkBase(service_name, max_sessions, Invoker) {}
+
+ /// Registers handlers in the service.
+ template <size_t N>
+ void RegisterHandlers(const FunctionInfo (&functions)[N]) {
+ RegisterHandlers(functions, N);
+ }
+
+ /**
+ * Registers handlers in the service. Usually prefer using the other RegisterHandlers
+ * overload in order to avoid needing to specify the array size.
+ */
+ void RegisterHandlers(const FunctionInfo* functions, size_t n) {
+ RegisterHandlersBase(functions, n);
+ }
+
+private:
+ /**
+ * This function is used to allow invocation of pointers to handlers stored in the base class
+ * without needing to expose the type of this derived class. Pointers-to-member may require a
+ * fixup when being up or downcast, and thus code that does that needs to know the concrete type
+ * of the derived class in order to invoke one of it's functions through a pointer.
+ */
+ static void Invoker(ServiceFrameworkBase* object, HandlerFnP<ServiceFrameworkBase> member,
+ Kernel::HLERequestContext& ctx) {
+ // Cast back up to our original types and call the member function
+ (static_cast<Self*>(object)->*static_cast<HandlerFnP<Self>>(member))(ctx);
+ }
+};
+
/// Initialize ServiceManager
void Init();
@@ -110,6 +258,8 @@ void Shutdown();
/// Map of named ports managed by the kernel, which can be retrieved using the ConnectToPort SVC.
extern std::unordered_map<std::string, Kernel::SharedPtr<Kernel::ClientPort>> g_kernel_named_ports;
+/// Adds a port to the named port table
+void AddNamedPort(std::string name, Kernel::SharedPtr<Kernel::ClientPort> port);
/// Adds a service to the services table
void AddService(Interface* interface_);
--
GitLab