2019-11-26 00:28:48 +01:00
|
|
|
// Copyright 2019 yuzu emulator team
|
2016-06-15 01:03:30 +02:00
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#include <tuple>
|
2018-07-19 01:02:47 +02:00
|
|
|
#include <utility>
|
2016-06-15 01:03:30 +02:00
|
|
|
|
2018-07-31 14:06:09 +02:00
|
|
|
#include "common/assert.h"
|
2019-01-01 00:09:41 +01:00
|
|
|
#include "common/common_types.h"
|
2018-07-31 14:06:09 +02:00
|
|
|
#include "common/logging/log.h"
|
2019-11-26 00:28:48 +01:00
|
|
|
#include "core/core_timing.h"
|
2018-01-24 00:03:09 +01:00
|
|
|
#include "core/hle/ipc_helpers.h"
|
2017-06-05 06:52:19 +02:00
|
|
|
#include "core/hle/kernel/hle_ipc.h"
|
2021-04-22 06:43:25 +02:00
|
|
|
#include "core/hle/kernel/k_client_port.h"
|
2021-04-24 11:40:31 +02:00
|
|
|
#include "core/hle/kernel/k_handle_table.h"
|
2021-04-24 07:04:28 +02:00
|
|
|
#include "core/hle/kernel/k_process.h"
|
2020-12-03 03:08:35 +01:00
|
|
|
#include "core/hle/kernel/k_scheduler.h"
|
2021-06-05 04:26:48 +02:00
|
|
|
#include "core/hle/kernel/k_server_port.h"
|
2021-04-14 02:48:37 +02:00
|
|
|
#include "core/hle/kernel/k_server_session.h"
|
|
|
|
#include "core/hle/kernel/k_session.h"
|
2020-12-31 08:01:08 +01:00
|
|
|
#include "core/hle/kernel/k_thread.h"
|
2018-08-31 18:21:34 +02:00
|
|
|
#include "core/hle/kernel/kernel.h"
|
2021-11-04 02:31:09 +01:00
|
|
|
#include "core/hle/kernel/service_thread.h"
|
2019-11-26 21:19:15 +01:00
|
|
|
#include "core/memory.h"
|
2016-06-15 01:03:30 +02:00
|
|
|
|
|
|
|
namespace Kernel {
|
|
|
|
|
2021-06-05 04:26:48 +02:00
|
|
|
KServerSession::KServerSession(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}
|
2020-12-15 09:41:48 +01:00
|
|
|
|
2021-07-03 00:19:04 +02:00
|
|
|
KServerSession::~KServerSession() {
|
|
|
|
// Ensure that the global list tracking server sessions does not hold on to a reference.
|
|
|
|
kernel.UnregisterServerSession(this);
|
|
|
|
}
|
2016-06-15 01:03:30 +02:00
|
|
|
|
2021-06-07 00:39:11 +02:00
|
|
|
void KServerSession::Initialize(KSession* parent_session_, std::string&& name_,
|
2021-06-05 04:26:48 +02:00
|
|
|
std::shared_ptr<SessionRequestManager> manager_) {
|
2021-04-14 02:48:37 +02:00
|
|
|
// Set member variables.
|
2021-06-07 00:39:11 +02:00
|
|
|
parent = parent_session_;
|
2021-04-14 02:48:37 +02:00
|
|
|
name = std::move(name_);
|
2021-06-05 04:26:48 +02:00
|
|
|
|
|
|
|
if (manager_) {
|
|
|
|
manager = manager_;
|
|
|
|
} else {
|
|
|
|
manager = std::make_shared<SessionRequestManager>(kernel);
|
|
|
|
}
|
2016-06-15 01:03:30 +02:00
|
|
|
}
|
|
|
|
|
2021-04-14 02:48:37 +02:00
|
|
|
void KServerSession::Destroy() {
|
|
|
|
parent->OnServerClosed();
|
|
|
|
|
|
|
|
parent->Close();
|
2022-03-11 09:13:21 +01:00
|
|
|
|
|
|
|
// Release host emulation members.
|
|
|
|
manager.reset();
|
2020-02-11 22:36:39 +01:00
|
|
|
}
|
|
|
|
|
2021-04-14 02:48:37 +02:00
|
|
|
void KServerSession::OnClientClosed() {
|
2021-05-16 08:49:03 +02:00
|
|
|
if (manager->HasSessionHandler()) {
|
|
|
|
manager->SessionHandler().ClientDisconnected(this);
|
2021-04-14 02:48:37 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool KServerSession::IsSignaled() const {
|
|
|
|
ASSERT(kernel.GlobalSchedulerContext().IsLocked());
|
|
|
|
|
|
|
|
// If the client is closed, we're always signaled.
|
|
|
|
if (parent->IsClientClosed()) {
|
|
|
|
return true;
|
2019-03-06 00:51:16 +01:00
|
|
|
}
|
2021-04-14 02:48:37 +02:00
|
|
|
|
|
|
|
// Otherwise, we're signaled if we have a request and aren't handling one.
|
|
|
|
return false;
|
2019-03-06 00:51:16 +01:00
|
|
|
}
|
|
|
|
|
2021-05-16 08:49:03 +02:00
|
|
|
void KServerSession::AppendDomainHandler(SessionRequestHandlerPtr handler) {
|
|
|
|
manager->AppendDomainHandler(std::move(handler));
|
2019-03-06 00:51:16 +01:00
|
|
|
}
|
|
|
|
|
2021-04-14 02:48:37 +02:00
|
|
|
std::size_t KServerSession::NumDomainRequestHandlers() const {
|
2021-05-16 08:49:03 +02:00
|
|
|
return manager->DomainHandlerCount();
|
2019-03-06 00:51:16 +01:00
|
|
|
}
|
|
|
|
|
2021-04-14 02:48:37 +02:00
|
|
|
ResultCode KServerSession::HandleDomainSyncRequest(Kernel::HLERequestContext& context) {
|
2019-03-07 22:44:28 +01:00
|
|
|
if (!context.HasDomainMessageHeader()) {
|
2021-05-21 07:05:04 +02:00
|
|
|
return ResultSuccess;
|
2019-03-07 22:44:28 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
// Set domain handlers in HLE context, used for domain objects (IPC interfaces) as inputs
|
2021-05-16 08:49:03 +02:00
|
|
|
context.SetSessionRequestManager(manager);
|
2019-03-07 22:44:28 +01:00
|
|
|
|
|
|
|
// 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:
|
2021-05-16 08:49:03 +02:00
|
|
|
if (object_id > manager->DomainHandlerCount()) {
|
2019-03-07 22:44:28 +01:00
|
|
|
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();
|
2021-05-21 07:05:04 +02:00
|
|
|
return ResultSuccess; // Ignore error if asserts are off
|
2018-02-18 19:22:19 +01:00
|
|
|
}
|
2022-03-11 08:45:54 +01:00
|
|
|
if (auto strong_ptr = manager->DomainHandler(object_id - 1).lock()) {
|
|
|
|
return strong_ptr->HandleSyncRequest(*this, context);
|
|
|
|
} else {
|
|
|
|
UNREACHABLE();
|
|
|
|
return ResultSuccess;
|
|
|
|
}
|
2018-02-18 19:22:19 +01:00
|
|
|
|
2019-03-07 22:44:28 +01:00
|
|
|
case IPC::DomainMessageHeader::CommandType::CloseVirtualHandle: {
|
|
|
|
LOG_DEBUG(IPC, "CloseVirtualHandle, object_id=0x{:08X}", object_id);
|
|
|
|
|
2021-05-16 08:49:03 +02:00
|
|
|
manager->CloseDomainHandler(object_id - 1);
|
2019-03-07 22:44:28 +01:00
|
|
|
|
|
|
|
IPC::ResponseBuilder rb{context, 2};
|
2021-05-21 07:05:04 +02:00
|
|
|
rb.Push(ResultSuccess);
|
|
|
|
return ResultSuccess;
|
2019-03-07 22:44:28 +01:00
|
|
|
}
|
2018-02-18 19:22:19 +01:00
|
|
|
}
|
|
|
|
|
2020-12-08 04:00:34 +01:00
|
|
|
LOG_CRITICAL(IPC, "Unknown domain command={}", domain_message_header.command.Value());
|
2019-03-07 22:44:28 +01:00
|
|
|
ASSERT(false);
|
2021-05-21 07:05:04 +02:00
|
|
|
return ResultSuccess;
|
2018-02-18 19:22:19 +01:00
|
|
|
}
|
|
|
|
|
2021-04-14 02:48:37 +02:00
|
|
|
ResultCode KServerSession::QueueSyncRequest(KThread* thread, Core::Memory::Memory& memory) {
|
2019-11-26 00:28:48 +01:00
|
|
|
u32* cmd_buf{reinterpret_cast<u32*>(memory.GetPointer(thread->GetTLSAddress()))};
|
2021-04-14 02:48:37 +02:00
|
|
|
auto context = std::make_shared<HLERequestContext>(kernel, memory, this, thread);
|
2019-11-26 00:28:48 +01:00
|
|
|
|
|
|
|
context->PopulateFromIncomingCommandBuffer(kernel.CurrentProcess()->GetHandleTable(), cmd_buf);
|
2020-12-15 09:41:48 +01:00
|
|
|
|
2021-06-08 06:55:37 +02:00
|
|
|
// Ensure we have a session request handler
|
|
|
|
if (manager->HasSessionRequestHandler(*context)) {
|
|
|
|
if (auto strong_ptr = manager->GetServiceThread().lock()) {
|
|
|
|
strong_ptr->QueueSyncRequest(*parent, std::move(context));
|
|
|
|
} else {
|
|
|
|
ASSERT_MSG(false, "strong_ptr is nullptr!");
|
|
|
|
}
|
2021-06-07 02:03:36 +02:00
|
|
|
} else {
|
2021-06-08 06:55:37 +02:00
|
|
|
ASSERT_MSG(false, "handler is invalid!");
|
2020-12-15 09:41:48 +01:00
|
|
|
}
|
2019-11-26 00:28:48 +01:00
|
|
|
|
2021-05-21 07:05:04 +02:00
|
|
|
return ResultSuccess;
|
2019-11-26 00:28:48 +01:00
|
|
|
}
|
|
|
|
|
2021-04-14 02:48:37 +02:00
|
|
|
ResultCode KServerSession::CompleteSyncRequest(HLERequestContext& context) {
|
2021-05-21 07:05:04 +02:00
|
|
|
ResultCode result = ResultSuccess;
|
2021-06-08 22:39:20 +02:00
|
|
|
|
2018-02-18 19:22:19 +01:00
|
|
|
// If the session has been converted to a domain, handle the domain request
|
2021-06-08 22:39:20 +02:00
|
|
|
if (manager->HasSessionRequestHandler(context)) {
|
|
|
|
if (IsDomain() && context.HasDomainMessageHeader()) {
|
|
|
|
result = HandleDomainSyncRequest(context);
|
|
|
|
// If there is no domain header, the regular session handler is used
|
|
|
|
} else if (manager->HasSessionHandler()) {
|
|
|
|
// If this ServerSession has an associated HLE handler, forward the request to it.
|
|
|
|
result = manager->SessionHandler().HandleSyncRequest(*this, context);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
ASSERT_MSG(false, "Session handler is invalid, stubbing response!");
|
|
|
|
IPC::ResponseBuilder rb(context, 2);
|
|
|
|
rb.Push(ResultSuccess);
|
2018-01-24 00:03:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (convert_to_domain) {
|
2021-05-16 08:49:03 +02:00
|
|
|
ASSERT_MSG(!IsDomain(), "ServerSession is already a domain instance.");
|
|
|
|
manager->ConvertToDomain();
|
2018-01-24 00:03:09 +01:00
|
|
|
convert_to_domain = false;
|
|
|
|
}
|
|
|
|
|
2022-01-18 01:51:18 +01:00
|
|
|
// The calling thread is waiting for this request to complete, so wake it up.
|
|
|
|
context.GetThread().EndWait(result);
|
2017-01-05 05:23:17 +01:00
|
|
|
|
2019-11-26 00:28:48 +01:00
|
|
|
return result;
|
|
|
|
}
|
2016-06-15 01:03:30 +02:00
|
|
|
|
2021-04-14 02:48:37 +02:00
|
|
|
ResultCode KServerSession::HandleSyncRequest(KThread* thread, Core::Memory::Memory& memory,
|
|
|
|
Core::Timing::CoreTiming& core_timing) {
|
2021-04-03 03:02:10 +02:00
|
|
|
return QueueSyncRequest(thread, memory);
|
2016-06-15 01:03:30 +02:00
|
|
|
}
|
2019-11-26 00:28:48 +01:00
|
|
|
|
2017-06-21 00:33:28 +02:00
|
|
|
} // namespace Kernel
|