From 8feeb81af27ea8fed6888e26c1024be3b3231d48 Mon Sep 17 00:00:00 2001 From: Subv Date: Tue, 20 Jun 2017 17:33:28 -0500 Subject: Kernel/ServerSession: Keep track of which threads have issued sync requests. --- src/core/hle/kernel/client_session.cpp | 2 +- src/core/hle/kernel/server_session.cpp | 22 ++++++++++++++++------ src/core/hle/kernel/server_session.h | 14 ++++++++++++-- 3 files changed, 29 insertions(+), 9 deletions(-) (limited to 'src/core/hle/kernel') diff --git a/src/core/hle/kernel/client_session.cpp b/src/core/hle/kernel/client_session.cpp index fef97af1f..78a64d105 100644 --- a/src/core/hle/kernel/client_session.cpp +++ b/src/core/hle/kernel/client_session.cpp @@ -39,7 +39,7 @@ ResultCode ClientSession::SendSyncRequest() { return ERR_SESSION_CLOSED_BY_REMOTE; // Signal the server session that new data is available - return server->HandleSyncRequest(); + return server->HandleSyncRequest(GetCurrentThread()); } } // namespace diff --git a/src/core/hle/kernel/server_session.cpp b/src/core/hle/kernel/server_session.cpp index 2dc709bc9..970eac5fe 100644 --- a/src/core/hle/kernel/server_session.cpp +++ b/src/core/hle/kernel/server_session.cpp @@ -32,22 +32,29 @@ ResultVal> ServerSession::Create(std::string name) { SharedPtr server_session(new ServerSession); server_session->name = std::move(name); - server_session->signaled = false; server_session->parent = nullptr; return MakeResult(std::move(server_session)); } bool ServerSession::ShouldWait(Thread* thread) const { - return !signaled; + // Closed sessions should never wait, an error will be returned from svcReplyAndReceive. + if (parent->client == nullptr) + return false; + // Wait if we have no pending requests, or if we're currently handling a request. + return pending_requesting_threads.empty() || currently_handling != nullptr; } void ServerSession::Acquire(Thread* thread) { ASSERT_MSG(!ShouldWait(thread), "object unavailable!"); - signaled = false; + // We are now handling a request, pop it from the stack. + // TODO(Subv): What happens if the client endpoint is closed before any requests are made? + ASSERT(!pending_requesting_threads.empty()); + currently_handling = pending_requesting_threads.back(); + pending_requesting_threads.pop_back(); } -ResultCode ServerSession::HandleSyncRequest() { +ResultCode ServerSession::HandleSyncRequest(SharedPtr thread) { // 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. @@ -60,11 +67,14 @@ ResultCode ServerSession::HandleSyncRequest() { return result; hle_handler->HandleSyncRequest(SharedPtr(this)); // TODO(Subv): Translate the response command buffer. + } else { + // Add the thread to the list of threads that have issued a sync request with this + // server. + pending_requesting_threads.push_back(std::move(thread)); } // If this ServerSession does not have an HLE implementation, just wake up the threads waiting // on it. - signaled = true; WakeupAllWaitingThreads(); return RESULT_SUCCESS; } @@ -90,4 +100,4 @@ ResultCode TranslateHLERequest(ServerSession* server_session) { // TODO(Subv): Implement this function once multiple concurrent processes are supported. return RESULT_SUCCESS; } -} +} // namespace Kernel diff --git a/src/core/hle/kernel/server_session.h b/src/core/hle/kernel/server_session.h index 5365605da..f4360ddf3 100644 --- a/src/core/hle/kernel/server_session.h +++ b/src/core/hle/kernel/server_session.h @@ -67,20 +67,30 @@ public: /** * Handle a sync request from the emulated application. + * @param thread Thread that initiated the request. * @returns ResultCode from the operation. */ - ResultCode HandleSyncRequest(); + ResultCode HandleSyncRequest(SharedPtr thread); bool ShouldWait(Thread* thread) const override; void Acquire(Thread* thread) override; std::string name; ///< The name of this session (optional) - bool signaled; ///< Whether there's new data available to this ServerSession std::shared_ptr parent; ///< The parent session, which links to the client endpoint. std::shared_ptr hle_handler; ///< This session's HLE request handler (optional) + /// List of threads that are pending a response after a sync request. This list is processed in + /// a LIFO manner, thus, the last request will be dispatched first. + /// TODO(Subv): Verify if this is indeed processed in LIFO using a hardware test. + std::vector> pending_requesting_threads; + + /// Thread whose request is currently being handled. A request is considered "handled" when a + /// response is sent via svcReplyAndReceive. + /// TODO(Subv): Find a better name for this. + SharedPtr currently_handling; + private: ServerSession(); ~ServerSession() override; -- cgit v1.2.3 From c3c9175a1c14cd82ea9ee9147281802f5b94013e Mon Sep 17 00:00:00 2001 From: Subv Date: Sun, 25 Jun 2017 20:14:04 -0500 Subject: Kernel/Sessions: Clean up the list of pending request threads of a session when the client endpoint is closed. --- src/core/hle/kernel/client_session.cpp | 5 +++++ 1 file changed, 5 insertions(+) (limited to 'src/core/hle/kernel') diff --git a/src/core/hle/kernel/client_session.cpp b/src/core/hle/kernel/client_session.cpp index 78a64d105..e9cf05747 100644 --- a/src/core/hle/kernel/client_session.cpp +++ b/src/core/hle/kernel/client_session.cpp @@ -27,6 +27,11 @@ ClientSession::~ClientSession() { // TODO(Subv): Force a wake up of all the ServerSession's waiting threads and set // their WaitSynchronization result to 0xC920181A. + + // Clean up the list of client threads with pending requests, they are unneeded now that the + // client endpoint is closed. + server->pending_requesting_threads.clear(); + server->currently_handling = nullptr; } parent->client = nullptr; -- cgit v1.2.3 From b53fa9514fd8d6aa9a93629ab5512da7706c536d Mon Sep 17 00:00:00 2001 From: Subv Date: Thu, 29 Jun 2017 12:30:34 -0500 Subject: Kernel/SVC: Pass the current thread as a parameter to ClientSession::SendSyncRequest. --- src/core/hle/kernel/client_session.cpp | 5 +++-- src/core/hle/kernel/client_session.h | 4 +++- 2 files changed, 6 insertions(+), 3 deletions(-) (limited to 'src/core/hle/kernel') diff --git a/src/core/hle/kernel/client_session.cpp b/src/core/hle/kernel/client_session.cpp index e9cf05747..646a5cc64 100644 --- a/src/core/hle/kernel/client_session.cpp +++ b/src/core/hle/kernel/client_session.cpp @@ -9,6 +9,7 @@ #include "core/hle/kernel/hle_ipc.h" #include "core/hle/kernel/server_session.h" #include "core/hle/kernel/session.h" +#include "core/hle/kernel/thread.h" namespace Kernel { @@ -37,14 +38,14 @@ ClientSession::~ClientSession() { parent->client = nullptr; } -ResultCode ClientSession::SendSyncRequest() { +ResultCode ClientSession::SendSyncRequest(SharedPtr thread) { // Keep ServerSession alive until we're done working with it. SharedPtr server = parent->server; if (server == nullptr) return ERR_SESSION_CLOSED_BY_REMOTE; // Signal the server session that new data is available - return server->HandleSyncRequest(GetCurrentThread()); + return server->HandleSyncRequest(std::move(thread)); } } // namespace diff --git a/src/core/hle/kernel/client_session.h b/src/core/hle/kernel/client_session.h index 2de379c09..daf521529 100644 --- a/src/core/hle/kernel/client_session.h +++ b/src/core/hle/kernel/client_session.h @@ -14,6 +14,7 @@ namespace Kernel { class ServerSession; class Session; +class Thread; class ClientSession final : public Object { public: @@ -34,9 +35,10 @@ public: /** * Sends an SyncRequest from the current emulated thread. + * @param thread Thread that initiated the request. * @return ResultCode of the operation. */ - ResultCode SendSyncRequest(); + ResultCode SendSyncRequest(SharedPtr thread); std::string name; ///< Name of client port (optional) -- cgit v1.2.3