From 009b15b3aa9858930f461d825f7dd030fc963801 Mon Sep 17 00:00:00 2001 From: Subv Date: Wed, 30 Nov 2016 22:50:13 -0500 Subject: A bit of a redesign. Sessions and Ports are now detached from each other. HLE services are handled by means of a SessionRequestHandler class, Interface now inherits from this class. The File and Directory classes are no longer kernel objects, but SessionRequestHandlers instead, bound to a ServerSession when requested. File::OpenLinkFile now creates a new session pair and binds the File instance to it. --- src/core/hle/service/service.h | 179 +++++++++++++++++++++++++++++++++++++++-- 1 file changed, 174 insertions(+), 5 deletions(-) (limited to 'src/core/hle/service/service.h') diff --git a/src/core/hle/service/service.h b/src/core/hle/service/service.h index e2d04450a..dd268f39c 100644 --- a/src/core/hle/service/service.h +++ b/src/core/hle/service/service.h @@ -10,8 +10,163 @@ #include #include "common/common_types.h" #include "core/hle/kernel/client_port.h" -#include "core/hle/kernel/server_session.h" +#include "core/hle/kernel/thread.h" #include "core/hle/result.h" +#include "core/memory.h" + +namespace Kernel { +class ServerSession; + +// TODO(Subv): Move these declarations out of here +static const int kCommandHeaderOffset = 0x80; ///< Offset into command buffer of header + +/** + * Returns a pointer to the command buffer in the current thread's TLS + * TODO(Subv): This is not entirely correct, the command buffer should be copied from + * the thread's TLS to an intermediate buffer in kernel memory, and then copied again to + * the service handler process' memory. + * @param offset Optional offset into command buffer + * @return Pointer to command buffer + */ +inline u32* GetCommandBuffer(const int offset = 0) { + return (u32*)Memory::GetPointer(GetCurrentThread()->GetTLSAddress() + kCommandHeaderOffset + + offset); +} +} + +// TODO(Subv): Move this namespace out of here +namespace IPC { + +enum DescriptorType : u32 { + // Buffer related desciptors types (mask : 0x0F) + StaticBuffer = 0x02, + PXIBuffer = 0x04, + MappedBuffer = 0x08, + // Handle related descriptors types (mask : 0x30, but need to check for buffer related + // descriptors first ) + CopyHandle = 0x00, + MoveHandle = 0x10, + CallingPid = 0x20, +}; + +/** +* @brief Creates a command header to be used for IPC +* @param command_id ID of the command to create a header for. +* @param normal_params Size of the normal parameters in words. Up to 63. +* @param translate_params_size Size of the translate parameters in words. Up to 63. +* @return The created IPC header. +* +* Normal parameters are sent directly to the process while the translate parameters might go +* through modifications and checks by the kernel. +* The translate parameters are described by headers generated with the IPC::*Desc functions. +* +* @note While #normal_params is equivalent to the number of normal parameters, +* #translate_params_size includes the size occupied by the translate parameters headers. +*/ +constexpr u32 MakeHeader(u16 command_id, unsigned int normal_params, + unsigned int translate_params_size) { + return (u32(command_id) << 16) | ((u32(normal_params) & 0x3F) << 6) | + (u32(translate_params_size) & 0x3F); +} + +union Header { + u32 raw; + BitField<0, 6, u32> translate_params_size; + BitField<6, 6, u32> normal_params; + BitField<16, 16, u32> command_id; +}; + +inline Header ParseHeader(u32 header) { + return{ header }; +} + +constexpr u32 MoveHandleDesc(u32 num_handles = 1) { + return MoveHandle | ((num_handles - 1) << 26); +} + +constexpr u32 CopyHandleDesc(u32 num_handles = 1) { + return CopyHandle | ((num_handles - 1) << 26); +} + +constexpr u32 CallingPidDesc() { + return CallingPid; +} + +constexpr bool isHandleDescriptor(u32 descriptor) { + return (descriptor & 0xF) == 0x0; +} + +constexpr u32 HandleNumberFromDesc(u32 handle_descriptor) { + return (handle_descriptor >> 26) + 1; +} + +constexpr u32 StaticBufferDesc(u32 size, u8 buffer_id) { + return StaticBuffer | (size << 14) | ((buffer_id & 0xF) << 10); +} + +union StaticBufferDescInfo { + u32 raw; + BitField<10, 4, u32> buffer_id; + BitField<14, 18, u32> size; +}; + +inline StaticBufferDescInfo ParseStaticBufferDesc(const u32 desc) { + return{ desc }; +} + +/** +* @brief Creates a header describing a buffer to be sent over PXI. +* @param size Size of the buffer. Max 0x00FFFFFF. +* @param buffer_id The Id of the buffer. Max 0xF. +* @param is_read_only true if the buffer is read-only. If false, the buffer is considered to have +* read-write access. +* @return The created PXI buffer header. +* +* The next value is a phys-address of a table located in the BASE memregion. +*/ +inline u32 PXIBufferDesc(u32 size, unsigned buffer_id, bool is_read_only) { + u32 type = PXIBuffer; + if (is_read_only) + type |= 0x2; + return type | (size << 8) | ((buffer_id & 0xF) << 4); +} + +enum MappedBufferPermissions { + R = 1, + W = 2, + RW = R | W, +}; + +constexpr u32 MappedBufferDesc(u32 size, MappedBufferPermissions perms) { + return MappedBuffer | (size << 4) | (u32(perms) << 1); +} + +union MappedBufferDescInfo { + u32 raw; + BitField<4, 28, u32> size; + BitField<1, 2, MappedBufferPermissions> perms; +}; + +inline MappedBufferDescInfo ParseMappedBufferDesc(const u32 desc) { + return{ desc }; +} + +inline DescriptorType GetDescriptorType(u32 descriptor) { + // Note: Those checks must be done in this order + if (isHandleDescriptor(descriptor)) + return (DescriptorType)(descriptor & 0x30); + + // handle the fact that the following descriptors can have rights + if (descriptor & MappedBuffer) + return MappedBuffer; + + if (descriptor & PXIBuffer) + return PXIBuffer; + + return StaticBuffer; +} + +} // namespace IPC //////////////////////////////////////////////////////////////////////////////////////////////////// // Namespace Service @@ -21,8 +176,22 @@ namespace Service { static const int kMaxPortSize = 8; ///< Maximum size of a port name (8 characters) static const u32 DefaultMaxSessions = 10; ///< Arbitrary default number of maximum connections to an HLE port +/// TODO(Subv): Write documentation for this class +class SessionRequestHandler { +public: + /** + * Dispatches and handles a sync request from the emulated application. + * @param server_session The ServerSession that was triggered for this sync request, + * it should be used to differentiate which client (As in ClientSession) we're answering to. + * TODO(Subv): Make a HandleSyncRequestParent function that is called from the outside and does { ReturnIfError(Translate()); HandleSyncRequest(); } + * The Translate() function would copy the command buffer from the ServerSession thread's TLS into a temporary buffer, and pass it to HandleSyncRequest. + * TODO(Subv): HandleSyncRequest's return type should be void. + */ + virtual ResultCode HandleSyncRequest(Kernel::SharedPtr server_session) = 0; +}; + /// Interface to a CTROS service -class Interface { +class Interface : public SessionRequestHandler { public: std::string GetName() const { return GetPortName(); @@ -56,7 +225,7 @@ public: return "[UNKNOWN SERVICE PORT]"; } - ResultCode HandleSyncRequest(Kernel::SharedPtr server_session); + ResultCode HandleSyncRequest(Kernel::SharedPtr server_session) override; protected: /** @@ -88,9 +257,9 @@ void Init(); void Shutdown(); /// Map of named ports managed by the kernel, which can be retrieved using the ConnectToPort SVC. -extern std::unordered_map> g_kernel_named_ports; +extern std::unordered_map, std::shared_ptr>> g_kernel_named_ports; /// Map of services registered with the "srv:" service, retrieved using GetServiceHandle. -extern std::unordered_map> g_srv_services; +extern std::unordered_map, std::shared_ptr>> g_srv_services; /// Adds a service to the services table void AddService(Interface* interface_); -- cgit v1.2.3