2019-11-25 15:28:48 -08:00
|
|
|
// Copyright 2019 yuzu emulator team
|
2016-06-14 16:03:30 -07:00
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#include <tuple>
|
2018-07-18 16:02:47 -07:00
|
|
|
#include <utility>
|
2016-06-14 16:03:30 -07:00
|
|
|
|
2018-07-31 05:06:09 -07:00
|
|
|
#include "common/assert.h"
|
2018-12-31 15:09:41 -08:00
|
|
|
#include "common/common_types.h"
|
2018-07-31 05:06:09 -07:00
|
|
|
#include "common/logging/log.h"
|
2018-03-13 14:49:59 -07:00
|
|
|
#include "core/core.h"
|
2019-11-25 15:28:48 -08:00
|
|
|
#include "core/core_timing.h"
|
2018-01-23 15:03:09 -08:00
|
|
|
#include "core/hle/ipc_helpers.h"
|
2017-06-04 21:52:19 -07:00
|
|
|
#include "core/hle/kernel/client_port.h"
|
2016-06-14 16:03:30 -07:00
|
|
|
#include "core/hle/kernel/client_session.h"
|
2017-12-28 21:36:22 -08:00
|
|
|
#include "core/hle/kernel/handle_table.h"
|
2017-06-04 21:52:19 -07:00
|
|
|
#include "core/hle/kernel/hle_ipc.h"
|
2018-08-31 09:21:34 -07:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2017-12-28 21:36:22 -08:00
|
|
|
#include "core/hle/kernel/process.h"
|
2020-05-08 15:53:13 -07:00
|
|
|
#include "core/hle/kernel/scheduler.h"
|
2016-06-14 16:03:30 -07:00
|
|
|
#include "core/hle/kernel/server_session.h"
|
2017-06-04 21:52:19 -07:00
|
|
|
#include "core/hle/kernel/session.h"
|
2016-06-14 16:03:30 -07:00
|
|
|
#include "core/hle/kernel/thread.h"
|
2019-11-26 12:19:15 -08:00
|
|
|
#include "core/memory.h"
|
2016-06-14 16:03:30 -07:00
|
|
|
|
|
|
|
namespace Kernel {
|
|
|
|
|
2020-02-11 06:46:25 -08:00
|
|
|
ServerSession::ServerSession(KernelCore& kernel) : SynchronizationObject{kernel} {}
|
2019-11-25 15:28:48 -08:00
|
|
|
ServerSession::~ServerSession() = default;
|
2016-06-14 16:03:30 -07:00
|
|
|
|
2019-11-24 17:15:51 -08:00
|
|
|
ResultVal<std::shared_ptr<ServerSession>> ServerSession::Create(KernelCore& kernel,
|
2019-11-25 15:28:48 -08:00
|
|
|
std::shared_ptr<Session> parent,
|
2019-11-24 17:15:51 -08:00
|
|
|
std::string name) {
|
2019-11-25 15:28:48 -08:00
|
|
|
std::shared_ptr<ServerSession> session{std::make_shared<ServerSession>(kernel)};
|
2016-06-14 16:03:30 -07:00
|
|
|
|
2020-07-27 16:00:41 -07:00
|
|
|
session->request_event =
|
|
|
|
Core::Timing::CreateEvent(name, [session](std::uintptr_t, std::chrono::nanoseconds) {
|
|
|
|
session->CompleteSyncRequest();
|
|
|
|
});
|
2019-11-25 15:28:48 -08:00
|
|
|
session->name = std::move(name);
|
|
|
|
session->parent = std::move(parent);
|
2016-06-14 16:03:30 -07:00
|
|
|
|
2019-11-25 15:28:48 -08:00
|
|
|
return MakeResult(std::move(session));
|
2016-06-14 16:03:30 -07:00
|
|
|
}
|
|
|
|
|
2019-04-01 15:19:42 -07:00
|
|
|
bool ServerSession::ShouldWait(const Thread* thread) const {
|
2019-11-25 15:28:48 -08:00
|
|
|
// Closed sessions should never wait, an error will be returned from svcReplyAndReceive.
|
|
|
|
if (!parent->Client()) {
|
|
|
|
return false;
|
2019-11-25 15:17:08 -08:00
|
|
|
}
|
|
|
|
|
2019-11-25 15:28:48 -08:00
|
|
|
// Wait if we have no pending requests, or if we're currently handling a request.
|
|
|
|
return pending_requesting_threads.empty() || currently_handling != nullptr;
|
2016-06-14 16:03:30 -07:00
|
|
|
}
|
|
|
|
|
2020-02-11 13:36:39 -08:00
|
|
|
bool ServerSession::IsSignaled() const {
|
|
|
|
// Closed sessions should never wait, an error will be returned from svcReplyAndReceive.
|
|
|
|
if (!parent->Client()) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Wait if we have no pending requests, or if we're currently handling a request.
|
2020-02-13 13:01:44 -08:00
|
|
|
return !pending_requesting_threads.empty() && currently_handling == nullptr;
|
2020-02-11 13:36:39 -08:00
|
|
|
}
|
|
|
|
|
2017-01-01 13:53:22 -08:00
|
|
|
void ServerSession::Acquire(Thread* thread) {
|
|
|
|
ASSERT_MSG(!ShouldWait(thread), "object unavailable!");
|
2017-06-20 15:33:28 -07:00
|
|
|
// 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();
|
2016-06-14 16:03:30 -07:00
|
|
|
}
|
|
|
|
|
2019-03-05 15:51:16 -08:00
|
|
|
void ServerSession::ClientDisconnected() {
|
|
|
|
// We keep a shared pointer to the hle handler to keep it alive throughout
|
|
|
|
// the call to ClientDisconnected, as ClientDisconnected invalidates the
|
|
|
|
// hle_handler member itself during the course of the function executing.
|
|
|
|
std::shared_ptr<SessionRequestHandler> handler = hle_handler;
|
|
|
|
if (handler) {
|
|
|
|
// Note that after this returns, this server session's hle_handler is
|
|
|
|
// invalidated (set to null).
|
2019-11-24 17:15:51 -08:00
|
|
|
handler->ClientDisconnected(SharedFrom(this));
|
2019-03-05 15:51:16 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Clean up the list of client threads with pending requests, they are unneeded now that the
|
|
|
|
// client endpoint is closed.
|
|
|
|
pending_requesting_threads.clear();
|
|
|
|
currently_handling = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void ServerSession::AppendDomainRequestHandler(std::shared_ptr<SessionRequestHandler> handler) {
|
|
|
|
domain_request_handlers.push_back(std::move(handler));
|
|
|
|
}
|
|
|
|
|
|
|
|
std::size_t ServerSession::NumDomainRequestHandlers() const {
|
|
|
|
return domain_request_handlers.size();
|
|
|
|
}
|
|
|
|
|
2018-02-18 10:22:19 -08:00
|
|
|
ResultCode ServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& context) {
|
2019-03-07 13:44:28 -08:00
|
|
|
if (!context.HasDomainMessageHeader()) {
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Set domain handlers in HLE context, used for domain objects (IPC interfaces) as inputs
|
|
|
|
context.SetDomainRequestHandlers(domain_request_handlers);
|
|
|
|
|
|
|
|
// If there is a DomainMessageHeader, then this is CommandType "Request"
|
|
|
|
const auto& domain_message_header = context.GetDomainMessageHeader();
|
|
|
|
const u32 object_id{domain_message_header.object_id};
|
|
|
|
switch (domain_message_header.command) {
|
|
|
|
case IPC::DomainMessageHeader::CommandType::SendMessage:
|
|
|
|
if (object_id > domain_request_handlers.size()) {
|
|
|
|
LOG_CRITICAL(IPC,
|
|
|
|
"object_id {} is too big! This probably means a recent service call "
|
|
|
|
"to {} needed to return a new interface!",
|
|
|
|
object_id, name);
|
|
|
|
UNREACHABLE();
|
|
|
|
return RESULT_SUCCESS; // Ignore error if asserts are off
|
2018-02-18 10:22:19 -08:00
|
|
|
}
|
2019-03-07 13:44:28 -08:00
|
|
|
return domain_request_handlers[object_id - 1]->HandleSyncRequest(context);
|
2018-02-18 10:22:19 -08:00
|
|
|
|
2019-03-07 13:44:28 -08:00
|
|
|
case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
|
|
|
|
LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x{:08X}", object_id);
|
|
|
|
|
|
|
|
domain_request_handlers[object_id - 1] = nullptr;
|
|
|
|
|
|
|
|
IPC::ResponseBuilder rb{context, 2};
|
|
|
|
rb.Push(RESULT_SUCCESS);
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
2018-02-18 10:22:19 -08:00
|
|
|
}
|
|
|
|
|
2019-03-07 13:44:28 -08:00
|
|
|
LOG_CRITICAL(IPC, "Unknown domain command={}",
|
|
|
|
static_cast<int>(domain_message_header.command.Value()));
|
|
|
|
ASSERT(false);
|
2018-02-18 10:22:19 -08:00
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2020-03-31 12:10:44 -07:00
|
|
|
ResultCode ServerSession::QueueSyncRequest(std::shared_ptr<Thread> thread,
|
|
|
|
Core::Memory::Memory& memory) {
|
2019-11-25 15:28:48 -08:00
|
|
|
u32* cmd_buf{reinterpret_cast<u32*>(memory.GetPointer(thread->GetTLSAddress()))};
|
2020-05-03 09:41:30 -07:00
|
|
|
auto context =
|
|
|
|
std::make_shared<HLERequestContext>(kernel, memory, SharedFrom(this), std::move(thread));
|
2019-11-25 15:28:48 -08:00
|
|
|
|
|
|
|
context->PopulateFromIncomingCommandBuffer(kernel.CurrentProcess()->GetHandleTable(), cmd_buf);
|
|
|
|
request_queue.Push(std::move(context));
|
|
|
|
|
|
|
|
return RESULT_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
ResultCode ServerSession::CompleteSyncRequest() {
|
|
|
|
ASSERT(!request_queue.Empty());
|
|
|
|
|
|
|
|
auto& context = *request_queue.Front();
|
2018-01-23 15:03:09 -08:00
|
|
|
|
2018-02-18 10:22:19 -08:00
|
|
|
ResultCode result = RESULT_SUCCESS;
|
|
|
|
// If the session has been converted to a domain, handle the domain request
|
2018-10-29 20:20:17 -07:00
|
|
|
if (IsDomain() && context.HasDomainMessageHeader()) {
|
2018-02-18 10:22:19 -08:00
|
|
|
result = HandleDomainSyncRequest(context);
|
2018-01-23 19:00:17 -08:00
|
|
|
// If there is no domain header, the regular session handler is used
|
2018-02-18 10:22:19 -08:00
|
|
|
} else if (hle_handler != nullptr) {
|
|
|
|
// If this ServerSession has an associated HLE handler, forward the request to it.
|
|
|
|
result = hle_handler->HandleSyncRequest(context);
|
2018-01-23 15:03:09 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (convert_to_domain) {
|
2018-08-15 03:50:22 -07:00
|
|
|
ASSERT_MSG(IsSession(), "ServerSession is already a domain instance.");
|
2018-01-23 19:00:17 -08:00
|
|
|
domain_request_handlers = {hle_handler};
|
2018-01-23 15:03:09 -08:00
|
|
|
convert_to_domain = false;
|
|
|
|
}
|
|
|
|
|
2019-11-25 15:28:48 -08:00
|
|
|
// Some service requests require the thread to block
|
2020-02-25 15:43:28 -08:00
|
|
|
{
|
|
|
|
SchedulerLock lock(kernel);
|
|
|
|
if (!context.IsThreadWaiting()) {
|
|
|
|
context.GetThread().ResumeFromWait();
|
|
|
|
context.GetThread().SetSynchronizationResults(nullptr, result);
|
|
|
|
}
|
2019-11-25 15:28:48 -08:00
|
|
|
}
|
2017-01-04 20:23:17 -08:00
|
|
|
|
2019-11-25 15:28:48 -08:00
|
|
|
request_queue.Pop();
|
2017-01-04 20:23:17 -08:00
|
|
|
|
2019-11-25 15:28:48 -08:00
|
|
|
return result;
|
|
|
|
}
|
2016-06-14 16:03:30 -07:00
|
|
|
|
2019-11-25 15:28:48 -08:00
|
|
|
ResultCode ServerSession::HandleSyncRequest(std::shared_ptr<Thread> thread,
|
2020-03-31 12:10:44 -07:00
|
|
|
Core::Memory::Memory& memory) {
|
2020-07-15 15:30:06 -07:00
|
|
|
const ResultCode result = QueueSyncRequest(std::move(thread), memory);
|
|
|
|
const auto delay = std::chrono::nanoseconds{kernel.IsMulticore() ? 0 : 20000};
|
2020-03-29 14:06:46 -07:00
|
|
|
Core::System::GetInstance().CoreTiming().ScheduleEvent(delay, request_event, {});
|
2020-02-25 15:43:28 -08:00
|
|
|
return result;
|
2016-06-14 16:03:30 -07:00
|
|
|
}
|
2019-11-25 15:28:48 -08:00
|
|
|
|
2017-06-20 15:33:28 -07:00
|
|
|
} // namespace Kernel
|