From 016307ae656afc85ab59a5c2598205ef81f99231 Mon Sep 17 00:00:00 2001 From: Subv Date: Wed, 14 Dec 2016 12:33:49 -0500 Subject: Fixed the codestyle to match our clang-format rules. --- src/core/hle/kernel/client_port.cpp | 6 ++++-- src/core/hle/kernel/client_port.h | 5 +++-- src/core/hle/kernel/client_session.cpp | 9 ++++++--- src/core/hle/kernel/client_session.h | 11 ++++++----- src/core/hle/kernel/server_port.cpp | 3 ++- src/core/hle/kernel/server_session.cpp | 25 +++++++++++++++---------- src/core/hle/kernel/server_session.h | 25 +++++++++++++++---------- 7 files changed, 51 insertions(+), 33 deletions(-) (limited to 'src/core/hle/kernel') diff --git a/src/core/hle/kernel/client_port.cpp b/src/core/hle/kernel/client_port.cpp index bd8ef055d..22645f4ec 100644 --- a/src/core/hle/kernel/client_port.cpp +++ b/src/core/hle/kernel/client_port.cpp @@ -19,7 +19,8 @@ ResultVal> ClientPort::Connect() { // AcceptSession before returning from this call. if (active_sessions >= max_sessions) { - // TODO(Subv): Return an error code in this situation after session disconnection is implemented. + // TODO(Subv): Return an error code in this situation after session disconnection is + // implemented. /*return ResultCode(ErrorDescription::MaxConnectionsReached, ErrorModule::OS, ErrorSummary::WouldBlock, ErrorLevel::Temporary);*/ @@ -27,7 +28,8 @@ ResultVal> ClientPort::Connect() { active_sessions++; // Create a new session pair, let the created sessions inherit the parent port's HLE handler. - auto sessions = ServerSession::CreateSessionPair(server_port->GetName(), server_port->hle_handler); + auto sessions = + ServerSession::CreateSessionPair(server_port->GetName(), server_port->hle_handler); auto client_session = std::get>(sessions); auto server_session = std::get>(sessions); diff --git a/src/core/hle/kernel/client_port.h b/src/core/hle/kernel/client_port.h index 0039cf028..511490c7c 100644 --- a/src/core/hle/kernel/client_port.h +++ b/src/core/hle/kernel/client_port.h @@ -29,8 +29,9 @@ public: } /** - * Creates a new Session pair, adds the created ServerSession to the associated ServerPort's list of pending sessions, - * and signals the ServerPort, causing any threads waiting on it to awake. + * Creates a new Session pair, adds the created ServerSession to the associated ServerPort's + * list of pending sessions, and signals the ServerPort, causing any threads + * waiting on it to awake. * @returns ClientSession The client endpoint of the created Session pair, or error code. */ ResultVal> Connect(); diff --git a/src/core/hle/kernel/client_session.cpp b/src/core/hle/kernel/client_session.cpp index 17302baca..0331386ec 100644 --- a/src/core/hle/kernel/client_session.cpp +++ b/src/core/hle/kernel/client_session.cpp @@ -11,16 +11,19 @@ namespace Kernel { ClientSession::ClientSession() = default; ClientSession::~ClientSession() { - // This destructor will be called automatically when the last ClientSession handle is closed by the emulated application. + // This destructor will be called automatically when the last ClientSession handle is closed by + // the emulated application. if (server_session->hle_handler) server_session->hle_handler->ClientDisconnected(server_session); // TODO(Subv): If the session is still open, set the connection status to 2 (Closed by client), - // wake up all the ServerSession's waiting threads and set the WaitSynchronization result to 0xC920181A. + // wake up all the ServerSession's waiting threads and set the WaitSynchronization result to + // 0xC920181A. } -ResultVal> ClientSession::Create(ServerSession* server_session, std::string name) { +ResultVal> ClientSession::Create(ServerSession* server_session, + std::string name) { SharedPtr client_session(new ClientSession); client_session->name = std::move(name); diff --git a/src/core/hle/kernel/client_session.h b/src/core/hle/kernel/client_session.h index fedbd0625..ed468dec6 100644 --- a/src/core/hle/kernel/client_session.h +++ b/src/core/hle/kernel/client_session.h @@ -4,8 +4,8 @@ #pragma once -#include #include +#include #include "common/common_types.h" @@ -44,9 +44,9 @@ public: */ ResultCode SendSyncRequest(); - std::string name; ///< Name of client port (optional) - ServerSession* server_session; ///< The server session associated with this client session. - SessionStatus session_status; ///< The session's current status. + std::string name; ///< Name of client port (optional) + ServerSession* server_session; ///< The server session associated with this client session. + SessionStatus session_status; ///< The session's current status. private: ClientSession(); @@ -58,7 +58,8 @@ private: * @param name Optional name of client session * @return The created client session */ - static ResultVal> Create(ServerSession* server_session, std::string name = "Unknown"); + static ResultVal> Create(ServerSession* server_session, + std::string name = "Unknown"); }; } // namespace diff --git a/src/core/hle/kernel/server_port.cpp b/src/core/hle/kernel/server_port.cpp index f7699f023..6c19aa7c0 100644 --- a/src/core/hle/kernel/server_port.cpp +++ b/src/core/hle/kernel/server_port.cpp @@ -24,7 +24,8 @@ void ServerPort::Acquire() { } std::tuple, SharedPtr> ServerPort::CreatePortPair( - u32 max_sessions, std::string name, std::shared_ptr hle_handler) { + u32 max_sessions, std::string name, + std::shared_ptr hle_handler) { SharedPtr server_port(new ServerPort); SharedPtr client_port(new ClientPort); diff --git a/src/core/hle/kernel/server_session.cpp b/src/core/hle/kernel/server_session.cpp index 1e54c3a2e..146458c1c 100644 --- a/src/core/hle/kernel/server_session.cpp +++ b/src/core/hle/kernel/server_session.cpp @@ -12,12 +12,14 @@ namespace Kernel { ServerSession::ServerSession() = default; ServerSession::~ServerSession() { - // This destructor will be called automatically when the last ServerSession handle is closed by the emulated application. + // This destructor will be called automatically when the last ServerSession handle is closed by + // the emulated application. // TODO(Subv): Reduce the ClientPort's connection count, // if the session is still open, set the connection status to 3 (Closed by server), } -ResultVal> ServerSession::Create(std::string name, std::shared_ptr hle_handler) { +ResultVal> ServerSession::Create( + std::string name, std::shared_ptr hle_handler) { SharedPtr server_session(new ServerSession); server_session->name = std::move(name); @@ -38,7 +40,8 @@ void ServerSession::Acquire() { ResultCode ServerSession::HandleSyncRequest() { // The ServerSession received a sync request, this means that there's new data available - // from its ClientSession, so wake up any threads that may be waiting on a svcReplyAndReceive or similar. + // from its ClientSession, so wake up any threads that may be waiting on a svcReplyAndReceive or + // similar. // If this ServerSession has an associated HLE handler, forward the request to it. if (hle_handler != nullptr) { @@ -50,17 +53,20 @@ ResultCode ServerSession::HandleSyncRequest() { // TODO(Subv): Translate the response command buffer. } - // If this ServerSession does not have an HLE implementation, just wake up the threads waiting on it. + // If this ServerSession does not have an HLE implementation, just wake up the threads waiting + // on it. signaled = true; WakeupAllWaitingThreads(); return RESULT_SUCCESS; } -ServerSession::SessionPair ServerSession::CreateSessionPair(const std::string& name, - std::shared_ptr hle_handler) { - auto server_session = ServerSession::Create(name + "_Server", std::move(hle_handler)).MoveFrom(); - // We keep a non-owning pointer to the ServerSession in the ClientSession because we don't want to prevent the - // ServerSession's destructor from being called when the emulated application closes the last ServerSession handle. +ServerSession::SessionPair ServerSession::CreateSessionPair( + const std::string& name, std::shared_ptr hle_handler) { + auto server_session = + ServerSession::Create(name + "_Server", std::move(hle_handler)).MoveFrom(); + // We keep a non-owning pointer to the ServerSession in the ClientSession because we don't want + // to prevent the ServerSession's destructor from being called when the emulated + // application closes the last ServerSession handle. auto client_session = ClientSession::Create(server_session.get(), name + "_Client").MoveFrom(); return std::make_tuple(std::move(server_session), std::move(client_session)); @@ -70,5 +76,4 @@ ResultCode TranslateHLERequest(ServerSession* server_session) { // TODO(Subv): Implement this function once multiple concurrent processes are supported. return RESULT_SUCCESS; } - } diff --git a/src/core/hle/kernel/server_session.h b/src/core/hle/kernel/server_session.h index 7abc09011..458284a5d 100644 --- a/src/core/hle/kernel/server_session.h +++ b/src/core/hle/kernel/server_session.h @@ -24,10 +24,10 @@ class ClientSession; * * To make a service call, the client must write the command header and parameters to the buffer * located at offset 0x80 of the TLS (Thread-Local Storage) area, then execute a SendSyncRequest - * SVC call with its ClientSession handle. The kernel will read the command header, using it to marshall - * the parameters to the process at the server endpoint of the session. After the server replies to - * the request, the response is marshalled back to the caller's TLS buffer and control is - * transferred back to it. + * SVC call with its ClientSession handle. The kernel will read the command header, using it to + * marshall the parameters to the process at the server endpoint of the session. + * After the server replies to the request, the response is marshalled back to the caller's + * TLS buffer and control is transferred back to it. */ class ServerSession final : public WaitObject { public: @@ -47,7 +47,9 @@ public: * @param name Optional name of the ports * @return The created session tuple */ - static SessionPair CreateSessionPair(const std::string& name = "Unknown", std::shared_ptr hle_handler = nullptr); + static SessionPair CreateSessionPair( + const std::string& name = "Unknown", + std::shared_ptr hle_handler = nullptr); /** * Handle a sync request from the emulated application. @@ -61,7 +63,8 @@ public: std::string name; ///< The name of this session (optional) bool signaled; ///< Whether there's new data available to this ServerSession - std::shared_ptr hle_handler; ///< This session's HLE request handler (optional) + std::shared_ptr + hle_handler; ///< This session's HLE request handler (optional) private: ServerSession(); @@ -74,16 +77,18 @@ private: * @param hle_handler Optional HLE handler for this server session. * @return The created server session */ - static ResultVal> Create(std::string name = "Unknown", std::shared_ptr hle_handler = nullptr); + static ResultVal> Create( + std::string name = "Unknown", + std::shared_ptr hle_handler = nullptr); }; /** * Performs command buffer translation for an HLE IPC request. * The command buffer from the ServerSession thread's TLS is copied into a * buffer and all descriptors in the buffer are processed. - * TODO(Subv): Implement this function, currently we do not support multiple processes running at once, - * but once that is implemented we'll need to properly translate all descriptors in the command buffer. + * TODO(Subv): Implement this function, currently we do not support multiple processes running at + * once, but once that is implemented we'll need to properly translate all descriptors + * in the command buffer. */ ResultCode TranslateHLERequest(ServerSession* server_session); - } -- cgit v1.2.3