N-archive/citra
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Merge pull request #4014 from wwylele/old-service

Browse source 
service: remove deprecated service interface
This commit is contained in:
James Rowe 2018-07-30 11:31:54 -06:00 committed by GitHub
parent 9af731793a 323313b2e9
commit 05eb0ccb03
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
4 changed files with 0 additions and 151 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
src/core/hle/ipc.h
View file

@ -28,18 +28,6 @@ inline u32* GetCommandBuffer(const int offset = 0) {
offset);
}
/// Offset into static buffers, relative to command buffer header
static const int kStaticBuffersOffset = 0x100;
/**
* Returns a pointer to the static buffers area in the current thread's TLS
* TODO(Subv): cf. GetCommandBuffer
* @param offset Optional offset into static buffers area (in bytes)
* @return Pointer to static buffers area
*/
inline u32* GetStaticBuffers(const int offset = 0) {
return GetCommandBuffer(kStaticBuffersOffset + offset);
}
} // namespace Kernel
namespace IPC {

2
src/core/hle/service/frd/frd.h
View file

@ -10,8 +10,6 @@
namespace Service {
class Interface;
namespace FRD {
struct FriendKey {

54
src/core/hle/service/service.cpp
View file

@ -81,42 +81,6 @@ static std::string MakeFunctionString(const char* name, const char* port_name,
return function_string;
}
Interface::Interface(u32 max_sessions) : max_sessions(max_sessions) {}
Interface::~Interface() = default;
void Interface::HandleSyncRequest(SharedPtr<ServerSession> server_session) {
// TODO(Subv): Make use of the server_session in the HLE service handlers to distinguish which
// session triggered each command.
u32* cmd_buff = Kernel::GetCommandBuffer();
auto itr = m_functions.find(cmd_buff[0]);
if (itr == m_functions.end() || itr->second.func == nullptr) {
std::string function_name = (itr == m_functions.end())
? Common::StringFromFormat("0x%08X", cmd_buff[0])
: itr->second.name;
LOG_ERROR(Service, "unknown / unimplemented {}",
MakeFunctionString(function_name.c_str(), GetPortName().c_str(), cmd_buff));
// TODO(bunnei): Hack - ignore error
cmd_buff[1] = 0;
return;
}
LOG_TRACE(Service, "{}", MakeFunctionString(itr->second.name, GetPortName().c_str(), cmd_buff));
itr->second.func(this);
}
void Interface::Register(const FunctionInfo* functions, size_t n) {
m_functions.reserve(n);
for (size_t i = 0; i < n; ++i) {
// Usually this array is sorted by id already, so hint to instead at the end
m_functions.emplace_hint(m_functions.cend(), functions[i].id, functions[i]);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////////
ServiceFrameworkBase::ServiceFrameworkBase(const char* service_name, u32 max_sessions,
InvokerFn* handler_invoker)
: service_name(service_name), max_sessions(max_sessions), handler_invoker(handler_invoker) {}
@ -202,24 +166,6 @@ void AddNamedPort(std::string name, SharedPtr<ClientPort> port) {
g_kernel_named_ports.emplace(std::move(name), std::move(port));
}
static void AddNamedPort(Interface* interface_) {
SharedPtr<ServerPort> server_port;
SharedPtr<ClientPort> client_port;
std::tie(server_port, client_port) =
ServerPort::CreatePortPair(interface_->GetMaxSessions(), interface_->GetPortName());
server_port->SetHleHandler(std::shared_ptr<Interface>(interface_));
AddNamedPort(interface_->GetPortName(), std::move(client_port));
}
void AddService(Interface* interface_) {
auto server_port = Core::System::GetInstance()
.ServiceManager()
.RegisterService(interface_->GetPortName(), interface_->GetMaxSessions())
.Unwrap();
server_port->SetHleHandler(std::shared_ptr<Interface>(interface_));
}
/// Initialize ServiceManager
void Init(std::shared_ptr<SM::ServiceManager>& sm) {
SM::ServiceManager::InstallInterfaces(sm);

83
src/core/hle/service/service.h
View file

@ -32,87 +32,6 @@ static const int kMaxPortSize = 8; ///< Maximum size of a port name (8 character
/// Arbitrary default number of maximum connections to an HLE service.
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:
/**
* Creates an HLE interface with the specified max sessions.
* @param max_sessions Maximum number of sessions that can be
* connected to this service at the same time.
*/
Interface(u32 max_sessions = DefaultMaxSessions);
virtual ~Interface();
std::string GetName() const {
return GetPortName();
}
virtual void SetVersion(u32 raw_version) {
version.raw = raw_version;
}
/**
* Gets the maximum allowed number of sessions that can be connected to this service
* at the same time.
* @returns The maximum number of connections allowed.
*/
u32 GetMaxSessions() const {
return max_sessions;
}
typedef void (*Function)(Interface*);
struct FunctionInfo {
u32 id;
Function func;
const char* name;
};
/**
* Gets the string name used by CTROS for a service
* @return Port name of service
*/
virtual std::string GetPortName() const {
return "[UNKNOWN SERVICE PORT]";
}
protected:
void HandleSyncRequest(Kernel::SharedPtr<Kernel::ServerSession> server_session) override;
std::unique_ptr<SessionDataBase> MakeSessionData() const override {
return nullptr;
}
/**
* Registers the functions in the service
*/
template <size_t N>
inline void Register(const FunctionInfo (&functions)[N]) {
Register(functions, N);
}
void Register(const FunctionInfo* functions, size_t n);
union {
u32 raw;
BitField<0, 8, u32> major;
BitField<8, 8, u32> minor;
BitField<16, 8, u32> build;
BitField<24, 8, u32> revision;
} version = {};
private:
u32 max_sessions; ///< Maximum number of concurrent sessions that this service can handle.
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.
@ -272,7 +191,5 @@ extern std::unordered_map<std::string, Kernel::SharedPtr<Kernel::ClientPort>> g_
/// 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_);
} // namespace Service