early-access version 4012
This commit is contained in:
parent
0ed30f380a
commit
ec2356b0cc
25 changed files with 1066 additions and 134 deletions
|
@ -1,7 +1,7 @@
|
||||||
yuzu emulator early access
|
yuzu emulator early access
|
||||||
=============
|
=============
|
||||||
|
|
||||||
This is the source code for early-access 4011.
|
This is the source code for early-access 4012.
|
||||||
|
|
||||||
## Legal Notice
|
## Legal Notice
|
||||||
|
|
||||||
|
|
|
@ -251,10 +251,16 @@ add_library(core STATIC
|
||||||
hle/kernel/k_hardware_timer.h
|
hle/kernel/k_hardware_timer.h
|
||||||
hle/kernel/k_interrupt_manager.cpp
|
hle/kernel/k_interrupt_manager.cpp
|
||||||
hle/kernel/k_interrupt_manager.h
|
hle/kernel/k_interrupt_manager.h
|
||||||
|
hle/kernel/k_light_client_session.cpp
|
||||||
|
hle/kernel/k_light_client_session.h
|
||||||
hle/kernel/k_light_condition_variable.cpp
|
hle/kernel/k_light_condition_variable.cpp
|
||||||
hle/kernel/k_light_condition_variable.h
|
hle/kernel/k_light_condition_variable.h
|
||||||
hle/kernel/k_light_lock.cpp
|
hle/kernel/k_light_lock.cpp
|
||||||
hle/kernel/k_light_lock.h
|
hle/kernel/k_light_lock.h
|
||||||
|
hle/kernel/k_light_server_session.cpp
|
||||||
|
hle/kernel/k_light_server_session.h
|
||||||
|
hle/kernel/k_light_session.cpp
|
||||||
|
hle/kernel/k_light_session.h
|
||||||
hle/kernel/k_memory_block.h
|
hle/kernel/k_memory_block.h
|
||||||
hle/kernel/k_memory_block_manager.cpp
|
hle/kernel/k_memory_block_manager.cpp
|
||||||
hle/kernel/k_memory_block_manager.h
|
hle/kernel/k_memory_block_manager.h
|
||||||
|
|
|
@ -3,6 +3,7 @@
|
||||||
|
|
||||||
#include "common/scope_exit.h"
|
#include "common/scope_exit.h"
|
||||||
#include "core/hle/kernel/k_client_port.h"
|
#include "core/hle/kernel/k_client_port.h"
|
||||||
|
#include "core/hle/kernel/k_light_session.h"
|
||||||
#include "core/hle/kernel/k_port.h"
|
#include "core/hle/kernel/k_port.h"
|
||||||
#include "core/hle/kernel/k_scheduler.h"
|
#include "core/hle/kernel/k_scheduler.h"
|
||||||
#include "core/hle/kernel/k_scoped_resource_reservation.h"
|
#include "core/hle/kernel/k_scoped_resource_reservation.h"
|
||||||
|
@ -63,6 +64,7 @@ Result KClientPort::CreateSession(KClientSession** out) {
|
||||||
R_UNLESS(session_reservation.Succeeded(), ResultLimitReached);
|
R_UNLESS(session_reservation.Succeeded(), ResultLimitReached);
|
||||||
|
|
||||||
// Allocate a session normally.
|
// Allocate a session normally.
|
||||||
|
// TODO: Dynamic resource limits
|
||||||
session = KSession::Create(m_kernel);
|
session = KSession::Create(m_kernel);
|
||||||
|
|
||||||
// Check that we successfully created a session.
|
// Check that we successfully created a session.
|
||||||
|
@ -119,4 +121,71 @@ Result KClientPort::CreateSession(KClientSession** out) {
|
||||||
R_SUCCEED();
|
R_SUCCEED();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Result KClientPort::CreateLightSession(KLightClientSession** out) {
|
||||||
|
// Declare the session we're going to allocate.
|
||||||
|
KLightSession* session{};
|
||||||
|
|
||||||
|
// Reserve a new session from the resource limit.
|
||||||
|
KScopedResourceReservation session_reservation(GetCurrentProcessPointer(m_kernel),
|
||||||
|
Svc::LimitableResource::SessionCountMax);
|
||||||
|
R_UNLESS(session_reservation.Succeeded(), ResultLimitReached);
|
||||||
|
|
||||||
|
// Allocate a session normally.
|
||||||
|
// TODO: Dynamic resource limits
|
||||||
|
session = KLightSession::Create(m_kernel);
|
||||||
|
|
||||||
|
// Check that we successfully created a session.
|
||||||
|
R_UNLESS(session != nullptr, ResultOutOfResource);
|
||||||
|
|
||||||
|
// Update the session counts.
|
||||||
|
{
|
||||||
|
ON_RESULT_FAILURE {
|
||||||
|
session->Close();
|
||||||
|
};
|
||||||
|
|
||||||
|
// Atomically increment the number of sessions.
|
||||||
|
s32 new_sessions;
|
||||||
|
{
|
||||||
|
const auto max = m_max_sessions;
|
||||||
|
auto cur_sessions = m_num_sessions.load(std::memory_order_acquire);
|
||||||
|
do {
|
||||||
|
R_UNLESS(cur_sessions < max, ResultOutOfSessions);
|
||||||
|
new_sessions = cur_sessions + 1;
|
||||||
|
} while (!m_num_sessions.compare_exchange_weak(cur_sessions, new_sessions,
|
||||||
|
std::memory_order_relaxed));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Atomically update the peak session tracking.
|
||||||
|
{
|
||||||
|
auto peak = m_peak_sessions.load(std::memory_order_acquire);
|
||||||
|
do {
|
||||||
|
if (peak >= new_sessions) {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
} while (!m_peak_sessions.compare_exchange_weak(peak, new_sessions,
|
||||||
|
std::memory_order_relaxed));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Initialize the session.
|
||||||
|
session->Initialize(this, m_parent->GetName());
|
||||||
|
|
||||||
|
// Commit the session reservation.
|
||||||
|
session_reservation.Commit();
|
||||||
|
|
||||||
|
// Register the session.
|
||||||
|
KLightSession::Register(m_kernel, session);
|
||||||
|
ON_RESULT_FAILURE {
|
||||||
|
session->GetClientSession().Close();
|
||||||
|
session->GetServerSession().Close();
|
||||||
|
};
|
||||||
|
|
||||||
|
// Enqueue the session with our parent.
|
||||||
|
R_TRY(m_parent->EnqueueSession(std::addressof(session->GetServerSession())));
|
||||||
|
|
||||||
|
// We succeeded, so set the output.
|
||||||
|
*out = std::addressof(session->GetClientSession());
|
||||||
|
R_SUCCEED();
|
||||||
|
}
|
||||||
|
|
||||||
} // namespace Kernel
|
} // namespace Kernel
|
||||||
|
|
|
@ -11,6 +11,7 @@
|
||||||
|
|
||||||
namespace Kernel {
|
namespace Kernel {
|
||||||
|
|
||||||
|
class KLightClientSession;
|
||||||
class KClientSession;
|
class KClientSession;
|
||||||
class KernelCore;
|
class KernelCore;
|
||||||
class KPort;
|
class KPort;
|
||||||
|
@ -51,6 +52,7 @@ public:
|
||||||
bool IsSignaled() const override;
|
bool IsSignaled() const override;
|
||||||
|
|
||||||
Result CreateSession(KClientSession** out);
|
Result CreateSession(KClientSession** out);
|
||||||
|
Result CreateLightSession(KLightClientSession** out);
|
||||||
|
|
||||||
private:
|
private:
|
||||||
std::atomic<s32> m_num_sessions{};
|
std::atomic<s32> m_num_sessions{};
|
||||||
|
|
|
@ -10,9 +10,7 @@
|
||||||
|
|
||||||
namespace Kernel {
|
namespace Kernel {
|
||||||
|
|
||||||
static constexpr u32 MessageBufferSize = 0x100;
|
KClientSession::KClientSession(KernelCore& kernel) : KAutoObject{kernel} {}
|
||||||
|
|
||||||
KClientSession::KClientSession(KernelCore& kernel) : KAutoObjectWithSlabHeapAndContainer{kernel} {}
|
|
||||||
KClientSession::~KClientSession() = default;
|
KClientSession::~KClientSession() = default;
|
||||||
|
|
||||||
void KClientSession::Destroy() {
|
void KClientSession::Destroy() {
|
||||||
|
@ -22,18 +20,30 @@ void KClientSession::Destroy() {
|
||||||
|
|
||||||
void KClientSession::OnServerClosed() {}
|
void KClientSession::OnServerClosed() {}
|
||||||
|
|
||||||
Result KClientSession::SendSyncRequest() {
|
Result KClientSession::SendSyncRequest(uintptr_t address, size_t size) {
|
||||||
// Create a session request.
|
// Create a session request.
|
||||||
KSessionRequest* request = KSessionRequest::Create(m_kernel);
|
KSessionRequest* request = KSessionRequest::Create(m_kernel);
|
||||||
R_UNLESS(request != nullptr, ResultOutOfResource);
|
R_UNLESS(request != nullptr, ResultOutOfResource);
|
||||||
SCOPE_EXIT({ request->Close(); });
|
SCOPE_EXIT({ request->Close(); });
|
||||||
|
|
||||||
// Initialize the request.
|
// Initialize the request.
|
||||||
request->Initialize(nullptr, GetInteger(GetCurrentThread(m_kernel).GetTlsAddress()),
|
request->Initialize(nullptr, address, size);
|
||||||
MessageBufferSize);
|
|
||||||
|
|
||||||
// Send the request.
|
// Send the request.
|
||||||
R_RETURN(m_parent->GetServerSession().OnRequest(request));
|
R_RETURN(m_parent->OnRequest(request));
|
||||||
|
}
|
||||||
|
|
||||||
|
Result KClientSession::SendAsyncRequest(KEvent* event, uintptr_t address, size_t size) {
|
||||||
|
// Create a session request.
|
||||||
|
KSessionRequest* request = KSessionRequest::Create(m_kernel);
|
||||||
|
R_UNLESS(request != nullptr, ResultOutOfResource);
|
||||||
|
SCOPE_EXIT({ request->Close(); });
|
||||||
|
|
||||||
|
// Initialize the request.
|
||||||
|
request->Initialize(event, address, size);
|
||||||
|
|
||||||
|
// Send the request.
|
||||||
|
R_RETURN(m_parent->OnRequest(request));
|
||||||
}
|
}
|
||||||
|
|
||||||
} // namespace Kernel
|
} // namespace Kernel
|
||||||
|
|
|
@ -9,24 +9,12 @@
|
||||||
#include "core/hle/kernel/slab_helpers.h"
|
#include "core/hle/kernel/slab_helpers.h"
|
||||||
#include "core/hle/result.h"
|
#include "core/hle/result.h"
|
||||||
|
|
||||||
union Result;
|
|
||||||
|
|
||||||
namespace Core::Memory {
|
|
||||||
class Memory;
|
|
||||||
}
|
|
||||||
|
|
||||||
namespace Core::Timing {
|
|
||||||
class CoreTiming;
|
|
||||||
}
|
|
||||||
|
|
||||||
namespace Kernel {
|
namespace Kernel {
|
||||||
|
|
||||||
class KernelCore;
|
class KernelCore;
|
||||||
class KSession;
|
class KSession;
|
||||||
class KThread;
|
|
||||||
|
|
||||||
class KClientSession final
|
class KClientSession final : public KAutoObject {
|
||||||
: public KAutoObjectWithSlabHeapAndContainer<KClientSession, KAutoObjectWithList> {
|
|
||||||
KERNEL_AUTOOBJECT_TRAITS(KClientSession, KAutoObject);
|
KERNEL_AUTOOBJECT_TRAITS(KClientSession, KAutoObject);
|
||||||
|
|
||||||
public:
|
public:
|
||||||
|
@ -39,13 +27,13 @@ public:
|
||||||
}
|
}
|
||||||
|
|
||||||
void Destroy() override;
|
void Destroy() override;
|
||||||
static void PostDestroy(uintptr_t arg) {}
|
|
||||||
|
|
||||||
KSession* GetParent() const {
|
KSession* GetParent() const {
|
||||||
return m_parent;
|
return m_parent;
|
||||||
}
|
}
|
||||||
|
|
||||||
Result SendSyncRequest();
|
Result SendSyncRequest(uintptr_t address, size_t size);
|
||||||
|
Result SendAsyncRequest(KEvent* event, uintptr_t address, size_t size);
|
||||||
|
|
||||||
void OnServerClosed();
|
void OnServerClosed();
|
||||||
|
|
||||||
|
|
31
src/core/hle/kernel/k_light_client_session.cpp
Executable file
31
src/core/hle/kernel/k_light_client_session.cpp
Executable file
|
@ -0,0 +1,31 @@
|
||||||
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#include "core/hle/kernel/k_light_client_session.h"
|
||||||
|
#include "core/hle/kernel/k_light_session.h"
|
||||||
|
#include "core/hle/kernel/k_thread.h"
|
||||||
|
|
||||||
|
namespace Kernel {
|
||||||
|
|
||||||
|
KLightClientSession::KLightClientSession(KernelCore& kernel) : KAutoObject(kernel) {}
|
||||||
|
|
||||||
|
KLightClientSession::~KLightClientSession() = default;
|
||||||
|
|
||||||
|
void KLightClientSession::Destroy() {
|
||||||
|
m_parent->OnClientClosed();
|
||||||
|
}
|
||||||
|
|
||||||
|
void KLightClientSession::OnServerClosed() {}
|
||||||
|
|
||||||
|
Result KLightClientSession::SendSyncRequest(u32* data) {
|
||||||
|
// Get the request thread.
|
||||||
|
KThread* cur_thread = GetCurrentThreadPointer(m_kernel);
|
||||||
|
|
||||||
|
// Set the light data.
|
||||||
|
cur_thread->SetLightSessionData(data);
|
||||||
|
|
||||||
|
// Send the request.
|
||||||
|
R_RETURN(m_parent->OnRequest(cur_thread));
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace Kernel
|
39
src/core/hle/kernel/k_light_client_session.h
Executable file
39
src/core/hle/kernel/k_light_client_session.h
Executable file
|
@ -0,0 +1,39 @@
|
||||||
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "core/hle/kernel/k_auto_object.h"
|
||||||
|
#include "core/hle/result.h"
|
||||||
|
|
||||||
|
namespace Kernel {
|
||||||
|
|
||||||
|
class KLightSession;
|
||||||
|
|
||||||
|
class KLightClientSession final : public KAutoObject {
|
||||||
|
KERNEL_AUTOOBJECT_TRAITS(KLightClientSession, KAutoObject);
|
||||||
|
|
||||||
|
public:
|
||||||
|
explicit KLightClientSession(KernelCore& kernel);
|
||||||
|
~KLightClientSession();
|
||||||
|
|
||||||
|
void Initialize(KLightSession* parent) {
|
||||||
|
// Set member variables.
|
||||||
|
m_parent = parent;
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void Destroy() override;
|
||||||
|
|
||||||
|
const KLightSession* GetParent() const {
|
||||||
|
return m_parent;
|
||||||
|
}
|
||||||
|
|
||||||
|
Result SendSyncRequest(u32* data);
|
||||||
|
|
||||||
|
void OnServerClosed();
|
||||||
|
|
||||||
|
private:
|
||||||
|
KLightSession* m_parent;
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace Kernel
|
247
src/core/hle/kernel/k_light_server_session.cpp
Executable file
247
src/core/hle/kernel/k_light_server_session.cpp
Executable file
|
@ -0,0 +1,247 @@
|
||||||
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#include "core/hle/kernel/k_light_server_session.h"
|
||||||
|
#include "core/hle/kernel/k_light_session.h"
|
||||||
|
#include "core/hle/kernel/k_thread.h"
|
||||||
|
#include "core/hle/kernel/k_thread_queue.h"
|
||||||
|
#include "core/hle/kernel/svc_results.h"
|
||||||
|
|
||||||
|
namespace Kernel {
|
||||||
|
|
||||||
|
namespace {
|
||||||
|
|
||||||
|
constexpr u64 InvalidThreadId = std::numeric_limits<u64>::max();
|
||||||
|
|
||||||
|
class ThreadQueueImplForKLightServerSessionRequest final : public KThreadQueue {
|
||||||
|
private:
|
||||||
|
KThread::WaiterList* m_wait_list;
|
||||||
|
|
||||||
|
public:
|
||||||
|
ThreadQueueImplForKLightServerSessionRequest(KernelCore& kernel, KThread::WaiterList* wl)
|
||||||
|
: KThreadQueue(kernel), m_wait_list(wl) {}
|
||||||
|
|
||||||
|
virtual void EndWait(KThread* waiting_thread, Result wait_result) override {
|
||||||
|
// Remove the thread from our wait list.
|
||||||
|
m_wait_list->erase(m_wait_list->iterator_to(*waiting_thread));
|
||||||
|
|
||||||
|
// Invoke the base end wait handler.
|
||||||
|
KThreadQueue::EndWait(waiting_thread, wait_result);
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void CancelWait(KThread* waiting_thread, Result wait_result,
|
||||||
|
bool cancel_timer_task) override {
|
||||||
|
// Remove the thread from our wait list.
|
||||||
|
m_wait_list->erase(m_wait_list->iterator_to(*waiting_thread));
|
||||||
|
|
||||||
|
// Invoke the base cancel wait handler.
|
||||||
|
KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
class ThreadQueueImplForKLightServerSessionReceive final : public KThreadQueue {
|
||||||
|
private:
|
||||||
|
KThread** m_server_thread;
|
||||||
|
|
||||||
|
public:
|
||||||
|
ThreadQueueImplForKLightServerSessionReceive(KernelCore& kernel, KThread** st)
|
||||||
|
: KThreadQueue(kernel), m_server_thread(st) {}
|
||||||
|
|
||||||
|
virtual void EndWait(KThread* waiting_thread, Result wait_result) override {
|
||||||
|
// Clear the server thread.
|
||||||
|
*m_server_thread = nullptr;
|
||||||
|
|
||||||
|
// Set the waiting thread as not cancelable.
|
||||||
|
waiting_thread->ClearCancellable();
|
||||||
|
|
||||||
|
// Invoke the base end wait handler.
|
||||||
|
KThreadQueue::EndWait(waiting_thread, wait_result);
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void CancelWait(KThread* waiting_thread, Result wait_result,
|
||||||
|
bool cancel_timer_task) override {
|
||||||
|
// Clear the server thread.
|
||||||
|
*m_server_thread = nullptr;
|
||||||
|
|
||||||
|
// Set the waiting thread as not cancelable.
|
||||||
|
waiting_thread->ClearCancellable();
|
||||||
|
|
||||||
|
// Invoke the base cancel wait handler.
|
||||||
|
KThreadQueue::CancelWait(waiting_thread, wait_result, cancel_timer_task);
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
KLightServerSession::KLightServerSession(KernelCore& kernel) : KAutoObject(kernel) {}
|
||||||
|
KLightServerSession::~KLightServerSession() = default;
|
||||||
|
|
||||||
|
void KLightServerSession::Destroy() {
|
||||||
|
this->CleanupRequests();
|
||||||
|
|
||||||
|
m_parent->OnServerClosed();
|
||||||
|
}
|
||||||
|
|
||||||
|
void KLightServerSession::OnClientClosed() {
|
||||||
|
this->CleanupRequests();
|
||||||
|
}
|
||||||
|
|
||||||
|
Result KLightServerSession::OnRequest(KThread* request_thread) {
|
||||||
|
ThreadQueueImplForKLightServerSessionRequest wait_queue(m_kernel,
|
||||||
|
std::addressof(m_request_list));
|
||||||
|
|
||||||
|
// Send the request.
|
||||||
|
{
|
||||||
|
// Lock the scheduler.
|
||||||
|
KScopedSchedulerLock sl(m_kernel);
|
||||||
|
|
||||||
|
// Check that the server isn't closed.
|
||||||
|
R_UNLESS(!m_parent->IsServerClosed(), ResultSessionClosed);
|
||||||
|
|
||||||
|
// Check that the request thread isn't terminating.
|
||||||
|
R_UNLESS(!request_thread->IsTerminationRequested(), ResultTerminationRequested);
|
||||||
|
|
||||||
|
// Add the request thread to our list.
|
||||||
|
m_request_list.push_back(*request_thread);
|
||||||
|
|
||||||
|
// Begin waiting on the request.
|
||||||
|
request_thread->SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC);
|
||||||
|
request_thread->BeginWait(std::addressof(wait_queue));
|
||||||
|
|
||||||
|
// If we have a server thread, end its wait.
|
||||||
|
if (m_server_thread != nullptr) {
|
||||||
|
m_server_thread->EndWait(ResultSuccess);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// NOTE: Nintendo returns GetCurrentThread().GetWaitResult() here.
|
||||||
|
// This is technically incorrect, although it doesn't cause problems in practice
|
||||||
|
// because this is only ever called with request_thread = GetCurrentThreadPointer().
|
||||||
|
R_RETURN(request_thread->GetWaitResult());
|
||||||
|
}
|
||||||
|
|
||||||
|
Result KLightServerSession::ReplyAndReceive(u32* data) {
|
||||||
|
// Set the server context.
|
||||||
|
GetCurrentThread(m_kernel).SetLightSessionData(data);
|
||||||
|
|
||||||
|
// Reply, if we need to.
|
||||||
|
if (data[0] & KLightSession::ReplyFlag) {
|
||||||
|
KScopedSchedulerLock sl(m_kernel);
|
||||||
|
|
||||||
|
// Check that we're open.
|
||||||
|
R_UNLESS(!m_parent->IsClientClosed(), ResultSessionClosed);
|
||||||
|
R_UNLESS(!m_parent->IsServerClosed(), ResultSessionClosed);
|
||||||
|
|
||||||
|
// Check that we have a request to reply to.
|
||||||
|
R_UNLESS(m_current_request != nullptr, ResultInvalidState);
|
||||||
|
|
||||||
|
// Check that the server thread id is correct.
|
||||||
|
R_UNLESS(m_server_thread_id == GetCurrentThread(m_kernel).GetId(), ResultInvalidState);
|
||||||
|
|
||||||
|
// If we can reply, do so.
|
||||||
|
if (!m_current_request->IsTerminationRequested()) {
|
||||||
|
std::memcpy(m_current_request->GetLightSessionData(),
|
||||||
|
GetCurrentThread(m_kernel).GetLightSessionData(), KLightSession::DataSize);
|
||||||
|
m_current_request->EndWait(ResultSuccess);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Close our current request.
|
||||||
|
m_current_request->Close();
|
||||||
|
|
||||||
|
// Clear our current request.
|
||||||
|
m_current_request = nullptr;
|
||||||
|
m_server_thread_id = InvalidThreadId;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Create the wait queue for our receive.
|
||||||
|
ThreadQueueImplForKLightServerSessionReceive wait_queue(m_kernel,
|
||||||
|
std::addressof(m_server_thread));
|
||||||
|
|
||||||
|
// Receive.
|
||||||
|
while (true) {
|
||||||
|
// Try to receive a request.
|
||||||
|
{
|
||||||
|
KScopedSchedulerLock sl(m_kernel);
|
||||||
|
|
||||||
|
// Check that we aren't already receiving.
|
||||||
|
R_UNLESS(m_server_thread == nullptr, ResultInvalidState);
|
||||||
|
R_UNLESS(m_server_thread_id == InvalidThreadId, ResultInvalidState);
|
||||||
|
|
||||||
|
// Check that we're open.
|
||||||
|
R_UNLESS(!m_parent->IsClientClosed(), ResultSessionClosed);
|
||||||
|
R_UNLESS(!m_parent->IsServerClosed(), ResultSessionClosed);
|
||||||
|
|
||||||
|
// Check that we're not terminating.
|
||||||
|
R_UNLESS(!GetCurrentThread(m_kernel).IsTerminationRequested(),
|
||||||
|
ResultTerminationRequested);
|
||||||
|
|
||||||
|
// If we have a request available, use it.
|
||||||
|
if (auto head = m_request_list.begin(); head != m_request_list.end()) {
|
||||||
|
// Set our current request.
|
||||||
|
m_current_request = std::addressof(*head);
|
||||||
|
m_current_request->Open();
|
||||||
|
|
||||||
|
// Set our server thread id.
|
||||||
|
m_server_thread_id = GetCurrentThread(m_kernel).GetId();
|
||||||
|
|
||||||
|
// Copy the client request data.
|
||||||
|
std::memcpy(GetCurrentThread(m_kernel).GetLightSessionData(),
|
||||||
|
m_current_request->GetLightSessionData(), KLightSession::DataSize);
|
||||||
|
|
||||||
|
// We successfully received.
|
||||||
|
R_SUCCEED();
|
||||||
|
}
|
||||||
|
|
||||||
|
// We need to wait for a request to come in.
|
||||||
|
|
||||||
|
// Check if we were cancelled.
|
||||||
|
if (GetCurrentThread(m_kernel).IsWaitCancelled()) {
|
||||||
|
GetCurrentThread(m_kernel).ClearWaitCancelled();
|
||||||
|
R_THROW(ResultCancelled);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Mark ourselves as cancellable.
|
||||||
|
GetCurrentThread(m_kernel).SetCancellable();
|
||||||
|
|
||||||
|
// Wait for a request to come in.
|
||||||
|
m_server_thread = GetCurrentThreadPointer(m_kernel);
|
||||||
|
GetCurrentThread(m_kernel).SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC);
|
||||||
|
GetCurrentThread(m_kernel).BeginWait(std::addressof(wait_queue));
|
||||||
|
}
|
||||||
|
|
||||||
|
// We waited to receive a request; if our wait failed, return the failing result.
|
||||||
|
R_TRY(GetCurrentThread(m_kernel).GetWaitResult());
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void KLightServerSession::CleanupRequests() {
|
||||||
|
// Cleanup all pending requests.
|
||||||
|
{
|
||||||
|
KScopedSchedulerLock sl(m_kernel);
|
||||||
|
|
||||||
|
// Handle the current request.
|
||||||
|
if (m_current_request != nullptr) {
|
||||||
|
// Reply to the current request.
|
||||||
|
if (!m_current_request->IsTerminationRequested()) {
|
||||||
|
m_current_request->EndWait(ResultSessionClosed);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Clear our current request.
|
||||||
|
m_current_request->Close();
|
||||||
|
m_current_request = nullptr;
|
||||||
|
m_server_thread_id = InvalidThreadId;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Reply to all other requests.
|
||||||
|
for (auto& thread : m_request_list) {
|
||||||
|
thread.EndWait(ResultSessionClosed);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Wait up our server thread, if we have one.
|
||||||
|
if (m_server_thread != nullptr) {
|
||||||
|
m_server_thread->EndWait(ResultSessionClosed);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace Kernel
|
49
src/core/hle/kernel/k_light_server_session.h
Executable file
49
src/core/hle/kernel/k_light_server_session.h
Executable file
|
@ -0,0 +1,49 @@
|
||||||
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "core/hle/kernel/k_auto_object.h"
|
||||||
|
#include "core/hle/kernel/k_thread.h"
|
||||||
|
#include "core/hle/result.h"
|
||||||
|
|
||||||
|
namespace Kernel {
|
||||||
|
|
||||||
|
class KLightSession;
|
||||||
|
|
||||||
|
class KLightServerSession final : public KAutoObject,
|
||||||
|
public Common::IntrusiveListBaseNode<KLightServerSession> {
|
||||||
|
KERNEL_AUTOOBJECT_TRAITS(KLightServerSession, KAutoObject);
|
||||||
|
|
||||||
|
private:
|
||||||
|
KLightSession* m_parent{};
|
||||||
|
KThread::WaiterList m_request_list{};
|
||||||
|
KThread* m_current_request{};
|
||||||
|
u64 m_server_thread_id{std::numeric_limits<u64>::max()};
|
||||||
|
KThread* m_server_thread{};
|
||||||
|
|
||||||
|
public:
|
||||||
|
explicit KLightServerSession(KernelCore& kernel);
|
||||||
|
~KLightServerSession();
|
||||||
|
|
||||||
|
void Initialize(KLightSession* parent) {
|
||||||
|
// Set member variables. */
|
||||||
|
m_parent = parent;
|
||||||
|
}
|
||||||
|
|
||||||
|
virtual void Destroy() override;
|
||||||
|
|
||||||
|
constexpr const KLightSession* GetParent() const {
|
||||||
|
return m_parent;
|
||||||
|
}
|
||||||
|
|
||||||
|
Result OnRequest(KThread* request_thread);
|
||||||
|
Result ReplyAndReceive(u32* data);
|
||||||
|
|
||||||
|
void OnClientClosed();
|
||||||
|
|
||||||
|
private:
|
||||||
|
void CleanupRequests();
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace Kernel
|
81
src/core/hle/kernel/k_light_session.cpp
Executable file
81
src/core/hle/kernel/k_light_session.cpp
Executable file
|
@ -0,0 +1,81 @@
|
||||||
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#include "core/hle/kernel/k_client_port.h"
|
||||||
|
#include "core/hle/kernel/k_light_client_session.h"
|
||||||
|
#include "core/hle/kernel/k_light_server_session.h"
|
||||||
|
#include "core/hle/kernel/k_light_session.h"
|
||||||
|
#include "core/hle/kernel/k_process.h"
|
||||||
|
|
||||||
|
namespace Kernel {
|
||||||
|
|
||||||
|
KLightSession::KLightSession(KernelCore& kernel)
|
||||||
|
: KAutoObjectWithSlabHeapAndContainer(kernel), m_server(kernel), m_client(kernel) {}
|
||||||
|
KLightSession::~KLightSession() = default;
|
||||||
|
|
||||||
|
void KLightSession::Initialize(KClientPort* client_port, uintptr_t name) {
|
||||||
|
// Increment reference count.
|
||||||
|
// Because reference count is one on creation, this will result
|
||||||
|
// in a reference count of two. Thus, when both server and client are closed
|
||||||
|
// this object will be destroyed.
|
||||||
|
this->Open();
|
||||||
|
|
||||||
|
// Create our sub sessions.
|
||||||
|
KAutoObject::Create(std::addressof(m_server));
|
||||||
|
KAutoObject::Create(std::addressof(m_client));
|
||||||
|
|
||||||
|
// Initialize our sub sessions.
|
||||||
|
m_server.Initialize(this);
|
||||||
|
m_client.Initialize(this);
|
||||||
|
|
||||||
|
// Set state and name.
|
||||||
|
m_state = State::Normal;
|
||||||
|
m_name = name;
|
||||||
|
|
||||||
|
// Set our owner process.
|
||||||
|
m_process = GetCurrentProcessPointer(m_kernel);
|
||||||
|
m_process->Open();
|
||||||
|
|
||||||
|
// Set our port.
|
||||||
|
m_port = client_port;
|
||||||
|
if (m_port != nullptr) {
|
||||||
|
m_port->Open();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Mark initialized.
|
||||||
|
m_initialized = true;
|
||||||
|
}
|
||||||
|
|
||||||
|
void KLightSession::Finalize() {
|
||||||
|
if (m_port != nullptr) {
|
||||||
|
m_port->OnSessionFinalized();
|
||||||
|
m_port->Close();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
void KLightSession::OnServerClosed() {
|
||||||
|
if (m_state == State::Normal) {
|
||||||
|
m_state = State::ServerClosed;
|
||||||
|
m_client.OnServerClosed();
|
||||||
|
}
|
||||||
|
|
||||||
|
this->Close();
|
||||||
|
}
|
||||||
|
|
||||||
|
void KLightSession::OnClientClosed() {
|
||||||
|
if (m_state == State::Normal) {
|
||||||
|
m_state = State::ClientClosed;
|
||||||
|
m_server.OnClientClosed();
|
||||||
|
}
|
||||||
|
|
||||||
|
this->Close();
|
||||||
|
}
|
||||||
|
|
||||||
|
void KLightSession::PostDestroy(uintptr_t arg) {
|
||||||
|
// Release the session count resource the owner process holds.
|
||||||
|
KProcess* owner = reinterpret_cast<KProcess*>(arg);
|
||||||
|
owner->ReleaseResource(Svc::LimitableResource::SessionCountMax, 1);
|
||||||
|
owner->Close();
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace Kernel
|
86
src/core/hle/kernel/k_light_session.h
Executable file
86
src/core/hle/kernel/k_light_session.h
Executable file
|
@ -0,0 +1,86 @@
|
||||||
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||||
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
|
#pragma once
|
||||||
|
|
||||||
|
#include "core/hle/kernel/k_light_client_session.h"
|
||||||
|
#include "core/hle/kernel/k_light_server_session.h"
|
||||||
|
#include "core/hle/kernel/slab_helpers.h"
|
||||||
|
#include "core/hle/result.h"
|
||||||
|
|
||||||
|
namespace Kernel {
|
||||||
|
|
||||||
|
class KClientPort;
|
||||||
|
class KProcess;
|
||||||
|
|
||||||
|
// TODO: SupportDynamicExpansion for SlabHeap
|
||||||
|
class KLightSession final
|
||||||
|
: public KAutoObjectWithSlabHeapAndContainer<KLightSession, KAutoObjectWithList> {
|
||||||
|
KERNEL_AUTOOBJECT_TRAITS(KLightSession, KAutoObject);
|
||||||
|
|
||||||
|
private:
|
||||||
|
enum class State : u8 {
|
||||||
|
Invalid = 0,
|
||||||
|
Normal = 1,
|
||||||
|
ClientClosed = 2,
|
||||||
|
ServerClosed = 3,
|
||||||
|
};
|
||||||
|
|
||||||
|
public:
|
||||||
|
static constexpr size_t DataSize = sizeof(u32) * 7;
|
||||||
|
static constexpr u32 ReplyFlag = (1U << 31);
|
||||||
|
|
||||||
|
private:
|
||||||
|
KLightServerSession m_server;
|
||||||
|
KLightClientSession m_client;
|
||||||
|
State m_state{State::Invalid};
|
||||||
|
KClientPort* m_port{};
|
||||||
|
uintptr_t m_name{};
|
||||||
|
KProcess* m_process{};
|
||||||
|
bool m_initialized{};
|
||||||
|
|
||||||
|
public:
|
||||||
|
explicit KLightSession(KernelCore& kernel);
|
||||||
|
~KLightSession();
|
||||||
|
|
||||||
|
void Initialize(KClientPort* client_port, uintptr_t name);
|
||||||
|
void Finalize() override;
|
||||||
|
|
||||||
|
bool IsInitialized() const override {
|
||||||
|
return m_initialized;
|
||||||
|
}
|
||||||
|
uintptr_t GetPostDestroyArgument() const override {
|
||||||
|
return reinterpret_cast<uintptr_t>(m_process);
|
||||||
|
}
|
||||||
|
|
||||||
|
static void PostDestroy(uintptr_t arg);
|
||||||
|
|
||||||
|
void OnServerClosed();
|
||||||
|
void OnClientClosed();
|
||||||
|
|
||||||
|
bool IsServerClosed() const {
|
||||||
|
return m_state != State::Normal;
|
||||||
|
}
|
||||||
|
bool IsClientClosed() const {
|
||||||
|
return m_state != State::Normal;
|
||||||
|
}
|
||||||
|
|
||||||
|
Result OnRequest(KThread* request_thread) {
|
||||||
|
R_RETURN(m_server.OnRequest(request_thread));
|
||||||
|
}
|
||||||
|
|
||||||
|
KLightClientSession& GetClientSession() {
|
||||||
|
return m_client;
|
||||||
|
}
|
||||||
|
KLightServerSession& GetServerSession() {
|
||||||
|
return m_server;
|
||||||
|
}
|
||||||
|
const KLightClientSession& GetClientSession() const {
|
||||||
|
return m_client;
|
||||||
|
}
|
||||||
|
const KLightServerSession& GetServerSession() const {
|
||||||
|
return m_server;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
} // namespace Kernel
|
|
@ -58,4 +58,13 @@ Result KPort::EnqueueSession(KServerSession* session) {
|
||||||
R_SUCCEED();
|
R_SUCCEED();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Result KPort::EnqueueSession(KLightServerSession* session) {
|
||||||
|
KScopedSchedulerLock sl{m_kernel};
|
||||||
|
|
||||||
|
R_UNLESS(m_state == State::Normal, ResultPortClosed);
|
||||||
|
|
||||||
|
m_server.EnqueueSession(session);
|
||||||
|
R_SUCCEED();
|
||||||
|
}
|
||||||
|
|
||||||
} // namespace Kernel
|
} // namespace Kernel
|
||||||
|
|
|
@ -13,6 +13,7 @@
|
||||||
|
|
||||||
namespace Kernel {
|
namespace Kernel {
|
||||||
|
|
||||||
|
class KLightServerSession;
|
||||||
class KServerSession;
|
class KServerSession;
|
||||||
|
|
||||||
class KPort final : public KAutoObjectWithSlabHeapAndContainer<KPort, KAutoObjectWithList> {
|
class KPort final : public KAutoObjectWithSlabHeapAndContainer<KPort, KAutoObjectWithList> {
|
||||||
|
@ -38,6 +39,7 @@ public:
|
||||||
bool IsServerClosed() const;
|
bool IsServerClosed() const;
|
||||||
|
|
||||||
Result EnqueueSession(KServerSession* session);
|
Result EnqueueSession(KServerSession* session);
|
||||||
|
Result EnqueueSession(KLightServerSession* session);
|
||||||
|
|
||||||
KClientPort& GetClientPort() {
|
KClientPort& GetClientPort() {
|
||||||
return m_client;
|
return m_client;
|
||||||
|
|
|
@ -27,12 +27,14 @@ bool KServerPort::IsLight() const {
|
||||||
void KServerPort::CleanupSessions() {
|
void KServerPort::CleanupSessions() {
|
||||||
// Ensure our preconditions are met.
|
// Ensure our preconditions are met.
|
||||||
if (this->IsLight()) {
|
if (this->IsLight()) {
|
||||||
UNIMPLEMENTED();
|
ASSERT(m_session_list.empty());
|
||||||
|
} else {
|
||||||
|
ASSERT(m_light_session_list.empty());
|
||||||
}
|
}
|
||||||
|
|
||||||
// Cleanup the session list.
|
// Cleanup the session list.
|
||||||
while (true) {
|
while (true) {
|
||||||
// Get the last session in the list
|
// Get the last session in the list.
|
||||||
KServerSession* session = nullptr;
|
KServerSession* session = nullptr;
|
||||||
{
|
{
|
||||||
KScopedSchedulerLock sl{m_kernel};
|
KScopedSchedulerLock sl{m_kernel};
|
||||||
|
@ -49,6 +51,26 @@ void KServerPort::CleanupSessions() {
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// Cleanup the light session list.
|
||||||
|
while (true) {
|
||||||
|
// Get the last session in the list.
|
||||||
|
KLightServerSession* session = nullptr;
|
||||||
|
{
|
||||||
|
KScopedSchedulerLock sl{m_kernel};
|
||||||
|
if (!m_light_session_list.empty()) {
|
||||||
|
session = std::addressof(m_light_session_list.front());
|
||||||
|
m_light_session_list.pop_front();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Close the session.
|
||||||
|
if (session != nullptr) {
|
||||||
|
session->Close();
|
||||||
|
} else {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
void KServerPort::Destroy() {
|
void KServerPort::Destroy() {
|
||||||
|
@ -64,8 +86,7 @@ void KServerPort::Destroy() {
|
||||||
|
|
||||||
bool KServerPort::IsSignaled() const {
|
bool KServerPort::IsSignaled() const {
|
||||||
if (this->IsLight()) {
|
if (this->IsLight()) {
|
||||||
UNIMPLEMENTED();
|
return !m_light_session_list.empty();
|
||||||
return false;
|
|
||||||
} else {
|
} else {
|
||||||
return !m_session_list.empty();
|
return !m_session_list.empty();
|
||||||
}
|
}
|
||||||
|
@ -83,6 +104,18 @@ void KServerPort::EnqueueSession(KServerSession* session) {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
void KServerPort::EnqueueSession(KLightServerSession* session) {
|
||||||
|
ASSERT(this->IsLight());
|
||||||
|
|
||||||
|
KScopedSchedulerLock sl{m_kernel};
|
||||||
|
|
||||||
|
// Add the session to our queue.
|
||||||
|
m_light_session_list.push_back(*session);
|
||||||
|
if (m_light_session_list.size() == 1) {
|
||||||
|
this->NotifyAvailable();
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
KServerSession* KServerPort::AcceptSession() {
|
KServerSession* KServerPort::AcceptSession() {
|
||||||
ASSERT(!this->IsLight());
|
ASSERT(!this->IsLight());
|
||||||
|
|
||||||
|
@ -98,4 +131,19 @@ KServerSession* KServerPort::AcceptSession() {
|
||||||
return session;
|
return session;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
KLightServerSession* KServerPort::AcceptLightSession() {
|
||||||
|
ASSERT(this->IsLight());
|
||||||
|
|
||||||
|
KScopedSchedulerLock sl{m_kernel};
|
||||||
|
|
||||||
|
// Return the first session in the list.
|
||||||
|
if (m_light_session_list.empty()) {
|
||||||
|
return nullptr;
|
||||||
|
}
|
||||||
|
|
||||||
|
KLightServerSession* session = std::addressof(m_light_session_list.front());
|
||||||
|
m_light_session_list.pop_front();
|
||||||
|
return session;
|
||||||
|
}
|
||||||
|
|
||||||
} // namespace Kernel
|
} // namespace Kernel
|
||||||
|
|
|
@ -9,6 +9,7 @@
|
||||||
|
|
||||||
#include "common/intrusive_list.h"
|
#include "common/intrusive_list.h"
|
||||||
|
|
||||||
|
#include "core/hle/kernel/k_light_server_session.h"
|
||||||
#include "core/hle/kernel/k_server_session.h"
|
#include "core/hle/kernel/k_server_session.h"
|
||||||
#include "core/hle/kernel/k_synchronization_object.h"
|
#include "core/hle/kernel/k_synchronization_object.h"
|
||||||
|
|
||||||
|
@ -28,8 +29,10 @@ public:
|
||||||
void Initialize(KPort* parent);
|
void Initialize(KPort* parent);
|
||||||
|
|
||||||
void EnqueueSession(KServerSession* session);
|
void EnqueueSession(KServerSession* session);
|
||||||
|
void EnqueueSession(KLightServerSession* session);
|
||||||
|
|
||||||
KServerSession* AcceptSession();
|
KServerSession* AcceptSession();
|
||||||
|
KLightServerSession* AcceptLightSession();
|
||||||
|
|
||||||
const KPort* GetParent() const {
|
const KPort* GetParent() const {
|
||||||
return m_parent;
|
return m_parent;
|
||||||
|
@ -43,10 +46,12 @@ public:
|
||||||
|
|
||||||
private:
|
private:
|
||||||
using SessionList = Common::IntrusiveListBaseTraits<KServerSession>::ListType;
|
using SessionList = Common::IntrusiveListBaseTraits<KServerSession>::ListType;
|
||||||
|
using LightSessionList = Common::IntrusiveListBaseTraits<KLightServerSession>::ListType;
|
||||||
|
|
||||||
void CleanupSessions();
|
void CleanupSessions();
|
||||||
|
|
||||||
SessionList m_session_list{};
|
SessionList m_session_list{};
|
||||||
|
LightSessionList m_light_session_list{};
|
||||||
KPort* m_parent{};
|
KPort* m_parent{};
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
|
@ -453,6 +453,11 @@ Result KServerSession::ReceiveRequest(std::shared_ptr<Service::HLERequestContext
|
||||||
size_t client_buffer_size = request->GetSize();
|
size_t client_buffer_size = request->GetSize();
|
||||||
// bool recv_list_broken = false;
|
// bool recv_list_broken = false;
|
||||||
|
|
||||||
|
if (!client_message) {
|
||||||
|
client_message = GetInteger(client_thread->GetTlsAddress());
|
||||||
|
client_buffer_size = MessageBufferSize;
|
||||||
|
}
|
||||||
|
|
||||||
// Receive the message.
|
// Receive the message.
|
||||||
Core::Memory::Memory& memory{client_thread->GetOwnerProcess()->GetMemory()};
|
Core::Memory::Memory& memory{client_thread->GetOwnerProcess()->GetMemory()};
|
||||||
if (out_context != nullptr) {
|
if (out_context != nullptr) {
|
||||||
|
|
|
@ -46,6 +46,10 @@ public:
|
||||||
return this->GetState() != State::Normal;
|
return this->GetState() != State::Normal;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
Result OnRequest(KSessionRequest* request) {
|
||||||
|
R_RETURN(m_server.OnRequest(request));
|
||||||
|
}
|
||||||
|
|
||||||
KClientSession& GetClientSession() {
|
KClientSession& GetClientSession() {
|
||||||
return m_client;
|
return m_client;
|
||||||
}
|
}
|
||||||
|
|
|
@ -385,6 +385,13 @@ public:
|
||||||
m_cancellable = false;
|
m_cancellable = false;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
u32* GetLightSessionData() const {
|
||||||
|
return m_light_ipc_data;
|
||||||
|
}
|
||||||
|
void SetLightSessionData(u32* data) {
|
||||||
|
m_light_ipc_data = data;
|
||||||
|
}
|
||||||
|
|
||||||
bool IsTerminationRequested() const {
|
bool IsTerminationRequested() const {
|
||||||
return m_termination_requested || GetRawState() == ThreadState::Terminated;
|
return m_termination_requested || GetRawState() == ThreadState::Terminated;
|
||||||
}
|
}
|
||||||
|
|
|
@ -1340,6 +1340,7 @@ struct KernelCore::SlabHeapContainer {
|
||||||
KSlabHeap<KProcess> process;
|
KSlabHeap<KProcess> process;
|
||||||
KSlabHeap<KResourceLimit> resource_limit;
|
KSlabHeap<KResourceLimit> resource_limit;
|
||||||
KSlabHeap<KSession> session;
|
KSlabHeap<KSession> session;
|
||||||
|
KSlabHeap<KLightSession> light_session;
|
||||||
KSlabHeap<KSharedMemory> shared_memory;
|
KSlabHeap<KSharedMemory> shared_memory;
|
||||||
KSlabHeap<KSharedMemoryInfo> shared_memory_info;
|
KSlabHeap<KSharedMemoryInfo> shared_memory_info;
|
||||||
KSlabHeap<KThread> thread;
|
KSlabHeap<KThread> thread;
|
||||||
|
@ -1370,6 +1371,8 @@ KSlabHeap<T>& KernelCore::SlabHeap() {
|
||||||
return slab_heap_container->resource_limit;
|
return slab_heap_container->resource_limit;
|
||||||
} else if constexpr (std::is_same_v<T, KSession>) {
|
} else if constexpr (std::is_same_v<T, KSession>) {
|
||||||
return slab_heap_container->session;
|
return slab_heap_container->session;
|
||||||
|
} else if constexpr (std::is_same_v<T, KLightSession>) {
|
||||||
|
return slab_heap_container->light_session;
|
||||||
} else if constexpr (std::is_same_v<T, KSharedMemory>) {
|
} else if constexpr (std::is_same_v<T, KSharedMemory>) {
|
||||||
return slab_heap_container->shared_memory;
|
return slab_heap_container->shared_memory;
|
||||||
} else if constexpr (std::is_same_v<T, KSharedMemoryInfo>) {
|
} else if constexpr (std::is_same_v<T, KSharedMemoryInfo>) {
|
||||||
|
@ -1407,6 +1410,7 @@ template KSlabHeap<KPort>& KernelCore::SlabHeap();
|
||||||
template KSlabHeap<KProcess>& KernelCore::SlabHeap();
|
template KSlabHeap<KProcess>& KernelCore::SlabHeap();
|
||||||
template KSlabHeap<KResourceLimit>& KernelCore::SlabHeap();
|
template KSlabHeap<KResourceLimit>& KernelCore::SlabHeap();
|
||||||
template KSlabHeap<KSession>& KernelCore::SlabHeap();
|
template KSlabHeap<KSession>& KernelCore::SlabHeap();
|
||||||
|
template KSlabHeap<KLightSession>& KernelCore::SlabHeap();
|
||||||
template KSlabHeap<KSharedMemory>& KernelCore::SlabHeap();
|
template KSlabHeap<KSharedMemory>& KernelCore::SlabHeap();
|
||||||
template KSlabHeap<KSharedMemoryInfo>& KernelCore::SlabHeap();
|
template KSlabHeap<KSharedMemoryInfo>& KernelCore::SlabHeap();
|
||||||
template KSlabHeap<KThread>& KernelCore::SlabHeap();
|
template KSlabHeap<KThread>& KernelCore::SlabHeap();
|
||||||
|
|
|
@ -7,71 +7,39 @@
|
||||||
#include "core/hle/kernel/k_client_session.h"
|
#include "core/hle/kernel/k_client_session.h"
|
||||||
#include "core/hle/kernel/k_hardware_timer.h"
|
#include "core/hle/kernel/k_hardware_timer.h"
|
||||||
#include "core/hle/kernel/k_process.h"
|
#include "core/hle/kernel/k_process.h"
|
||||||
|
#include "core/hle/kernel/k_scoped_resource_reservation.h"
|
||||||
#include "core/hle/kernel/k_server_session.h"
|
#include "core/hle/kernel/k_server_session.h"
|
||||||
|
#include "core/hle/kernel/k_session.h"
|
||||||
#include "core/hle/kernel/svc.h"
|
#include "core/hle/kernel/svc.h"
|
||||||
#include "core/hle/kernel/svc_results.h"
|
#include "core/hle/kernel/svc_results.h"
|
||||||
|
|
||||||
namespace Kernel::Svc {
|
namespace Kernel::Svc {
|
||||||
|
|
||||||
/// Makes a blocking IPC call to a service.
|
namespace {
|
||||||
Result SendSyncRequest(Core::System& system, Handle handle) {
|
|
||||||
// Get the client session from its handle.
|
Result SendSyncRequestImpl(KernelCore& kernel, uintptr_t message, size_t buffer_size,
|
||||||
|
Handle session_handle) {
|
||||||
|
// Get the client session.
|
||||||
KScopedAutoObject session =
|
KScopedAutoObject session =
|
||||||
GetCurrentProcess(system.Kernel()).GetHandleTable().GetObject<KClientSession>(handle);
|
GetCurrentProcess(kernel).GetHandleTable().GetObject<KClientSession>(session_handle);
|
||||||
R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
|
R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
|
||||||
|
|
||||||
LOG_TRACE(Kernel_SVC, "called handle=0x{:08X}", handle);
|
// Get the parent, and persist a reference to it until we're done.
|
||||||
|
KScopedAutoObject parent = session->GetParent();
|
||||||
|
ASSERT(parent.IsNotNull());
|
||||||
|
|
||||||
R_RETURN(session->SendSyncRequest());
|
// Send the request.
|
||||||
|
R_RETURN(session->SendSyncRequest(message, buffer_size));
|
||||||
}
|
}
|
||||||
|
|
||||||
Result SendSyncRequestWithUserBuffer(Core::System& system, uint64_t message_buffer,
|
Result ReplyAndReceiveImpl(KernelCore& kernel, int32_t* out_index, uintptr_t message,
|
||||||
uint64_t message_buffer_size, Handle session_handle) {
|
size_t buffer_size, KPhysicalAddress message_paddr,
|
||||||
UNIMPLEMENTED();
|
KSynchronizationObject** objs, int32_t num_objects, Handle reply_target,
|
||||||
R_THROW(ResultNotImplemented);
|
int64_t timeout_ns) {
|
||||||
}
|
|
||||||
|
|
||||||
Result SendAsyncRequestWithUserBuffer(Core::System& system, Handle* out_event_handle,
|
|
||||||
uint64_t message_buffer, uint64_t message_buffer_size,
|
|
||||||
Handle session_handle) {
|
|
||||||
UNIMPLEMENTED();
|
|
||||||
R_THROW(ResultNotImplemented);
|
|
||||||
}
|
|
||||||
|
|
||||||
Result ReplyAndReceive(Core::System& system, s32* out_index, uint64_t handles_addr, s32 num_handles,
|
|
||||||
Handle reply_target, s64 timeout_ns) {
|
|
||||||
// Ensure number of handles is valid.
|
|
||||||
R_UNLESS(0 <= num_handles && num_handles <= ArgumentHandleCountMax, ResultOutOfRange);
|
|
||||||
|
|
||||||
// Get the synchronization context.
|
|
||||||
auto& kernel = system.Kernel();
|
|
||||||
auto& handle_table = GetCurrentProcess(kernel).GetHandleTable();
|
|
||||||
auto objs = GetCurrentThread(kernel).GetSynchronizationObjectBuffer();
|
|
||||||
auto handles = GetCurrentThread(kernel).GetHandleBuffer();
|
|
||||||
|
|
||||||
// Copy user handles.
|
|
||||||
if (num_handles > 0) {
|
|
||||||
// Get the handles.
|
|
||||||
R_UNLESS(GetCurrentMemory(kernel).ReadBlock(handles_addr, handles.data(),
|
|
||||||
sizeof(Handle) * num_handles),
|
|
||||||
ResultInvalidPointer);
|
|
||||||
|
|
||||||
// Convert the handles to objects.
|
|
||||||
R_UNLESS(handle_table.GetMultipleObjects<KSynchronizationObject>(
|
|
||||||
objs.data(), handles.data(), num_handles),
|
|
||||||
ResultInvalidHandle);
|
|
||||||
}
|
|
||||||
|
|
||||||
// Ensure handles are closed when we're done.
|
|
||||||
SCOPE_EXIT({
|
|
||||||
for (auto i = 0; i < num_handles; ++i) {
|
|
||||||
objs[i]->Close();
|
|
||||||
}
|
|
||||||
});
|
|
||||||
|
|
||||||
// Reply to the target, if one is specified.
|
// Reply to the target, if one is specified.
|
||||||
if (reply_target != InvalidHandle) {
|
if (reply_target != InvalidHandle) {
|
||||||
KScopedAutoObject session = handle_table.GetObject<KServerSession>(reply_target);
|
KScopedAutoObject session =
|
||||||
|
GetCurrentProcess(kernel).GetHandleTable().GetObject<KServerSession>(reply_target);
|
||||||
R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
|
R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
|
||||||
|
|
||||||
// If we fail to reply, we want to set the output index to -1.
|
// If we fail to reply, we want to set the output index to -1.
|
||||||
|
@ -81,57 +49,223 @@ Result ReplyAndReceive(Core::System& system, s32* out_index, uint64_t handles_ad
|
||||||
|
|
||||||
// Send the reply.
|
// Send the reply.
|
||||||
R_TRY(session->SendReply());
|
R_TRY(session->SendReply());
|
||||||
|
// R_TRY(session->SendReply(message, buffer_size, message_paddr));
|
||||||
}
|
}
|
||||||
|
|
||||||
// Convert the timeout from nanoseconds to ticks.
|
// Receive a message.
|
||||||
// NOTE: Nintendo does not use this conversion logic in WaitSynchronization...
|
{
|
||||||
s64 timeout;
|
// Convert the timeout from nanoseconds to ticks.
|
||||||
if (timeout_ns > 0) {
|
// NOTE: Nintendo does not use this conversion logic in WaitSynchronization...
|
||||||
const s64 offset_tick(timeout_ns);
|
s64 timeout;
|
||||||
if (offset_tick > 0) {
|
if (timeout_ns > 0) {
|
||||||
timeout = kernel.HardwareTimer().GetTick() + offset_tick + 2;
|
const s64 offset_tick(timeout_ns);
|
||||||
if (timeout <= 0) {
|
if (offset_tick > 0) {
|
||||||
|
timeout = kernel.HardwareTimer().GetTick() + offset_tick + 2;
|
||||||
|
if (timeout <= 0) {
|
||||||
|
timeout = std::numeric_limits<s64>::max();
|
||||||
|
}
|
||||||
|
} else {
|
||||||
timeout = std::numeric_limits<s64>::max();
|
timeout = std::numeric_limits<s64>::max();
|
||||||
}
|
}
|
||||||
} else {
|
} else {
|
||||||
timeout = std::numeric_limits<s64>::max();
|
timeout = timeout_ns;
|
||||||
}
|
|
||||||
} else {
|
|
||||||
timeout = timeout_ns;
|
|
||||||
}
|
|
||||||
|
|
||||||
// Wait for a message.
|
|
||||||
while (true) {
|
|
||||||
// Wait for an object.
|
|
||||||
s32 index;
|
|
||||||
Result result = KSynchronizationObject::Wait(kernel, std::addressof(index), objs.data(),
|
|
||||||
num_handles, timeout);
|
|
||||||
if (result == ResultTimedOut) {
|
|
||||||
R_RETURN(result);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Receive the request.
|
// Wait for a message.
|
||||||
if (R_SUCCEEDED(result)) {
|
while (true) {
|
||||||
KServerSession* session = objs[index]->DynamicCast<KServerSession*>();
|
// Wait for an object.
|
||||||
if (session != nullptr) {
|
s32 index;
|
||||||
result = session->ReceiveRequest();
|
Result result = KSynchronizationObject::Wait(kernel, std::addressof(index), objs,
|
||||||
if (result == ResultNotFound) {
|
num_objects, timeout);
|
||||||
continue;
|
if (ResultTimedOut == result) {
|
||||||
|
R_THROW(result);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Receive the request.
|
||||||
|
if (R_SUCCEEDED(result)) {
|
||||||
|
KServerSession* session = objs[index]->DynamicCast<KServerSession*>();
|
||||||
|
if (session != nullptr) {
|
||||||
|
// result = session->ReceiveRequest(message, buffer_size, message_paddr);
|
||||||
|
result = session->ReceiveRequest();
|
||||||
|
if (ResultNotFound == result) {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
|
||||||
|
|
||||||
*out_index = index;
|
*out_index = index;
|
||||||
R_RETURN(result);
|
R_RETURN(result);
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
Result ReplyAndReceiveWithUserBuffer(Core::System& system, int32_t* out_index,
|
Result ReplyAndReceiveImpl(KernelCore& kernel, int32_t* out_index, uintptr_t message,
|
||||||
uint64_t message_buffer, uint64_t message_buffer_size,
|
size_t buffer_size, KPhysicalAddress message_paddr,
|
||||||
uint64_t handles, int32_t num_handles, Handle reply_target,
|
KProcessAddress user_handles, int32_t num_handles, Handle reply_target,
|
||||||
int64_t timeout_ns) {
|
int64_t timeout_ns) {
|
||||||
UNIMPLEMENTED();
|
// Ensure number of handles is valid.
|
||||||
R_THROW(ResultNotImplemented);
|
R_UNLESS(0 <= num_handles && num_handles <= Svc::ArgumentHandleCountMax, ResultOutOfRange);
|
||||||
|
|
||||||
|
// Get the synchronization context.
|
||||||
|
auto& process = GetCurrentProcess(kernel);
|
||||||
|
auto& thread = GetCurrentThread(kernel);
|
||||||
|
auto& handle_table = process.GetHandleTable();
|
||||||
|
KSynchronizationObject** objs = thread.GetSynchronizationObjectBuffer().data();
|
||||||
|
Handle* handles = thread.GetHandleBuffer().data();
|
||||||
|
|
||||||
|
// Copy user handles.
|
||||||
|
if (num_handles > 0) {
|
||||||
|
// Ensure that we can try to get the handles.
|
||||||
|
R_UNLESS(process.GetPageTable().Contains(user_handles, num_handles * sizeof(Handle)),
|
||||||
|
ResultInvalidPointer);
|
||||||
|
|
||||||
|
// Get the handles
|
||||||
|
R_UNLESS(
|
||||||
|
GetCurrentMemory(kernel).ReadBlock(user_handles, handles, sizeof(Handle) * num_handles),
|
||||||
|
ResultInvalidPointer);
|
||||||
|
|
||||||
|
// Convert the handles to objects.
|
||||||
|
R_UNLESS(
|
||||||
|
handle_table.GetMultipleObjects<KSynchronizationObject>(objs, handles, num_handles),
|
||||||
|
ResultInvalidHandle);
|
||||||
|
}
|
||||||
|
|
||||||
|
// Ensure handles are closed when we're done.
|
||||||
|
SCOPE_EXIT({
|
||||||
|
for (auto i = 0; i < num_handles; ++i) {
|
||||||
|
objs[i]->Close();
|
||||||
|
}
|
||||||
|
});
|
||||||
|
|
||||||
|
R_RETURN(ReplyAndReceiveImpl(kernel, out_index, message, buffer_size, message_paddr, objs,
|
||||||
|
num_handles, reply_target, timeout_ns));
|
||||||
|
}
|
||||||
|
|
||||||
|
} // namespace
|
||||||
|
|
||||||
|
/// Makes a blocking IPC call to a service.
|
||||||
|
Result SendSyncRequest(Core::System& system, Handle session_handle) {
|
||||||
|
R_RETURN(SendSyncRequestImpl(system.Kernel(), 0, 0, session_handle));
|
||||||
|
}
|
||||||
|
|
||||||
|
Result SendSyncRequestWithUserBuffer(Core::System& system, uint64_t message, uint64_t buffer_size,
|
||||||
|
Handle session_handle) {
|
||||||
|
auto& kernel = system.Kernel();
|
||||||
|
|
||||||
|
// Validate that the message buffer is page aligned and does not overflow.
|
||||||
|
R_UNLESS(Common::IsAligned(message, PageSize), ResultInvalidAddress);
|
||||||
|
R_UNLESS(buffer_size > 0, ResultInvalidSize);
|
||||||
|
R_UNLESS(Common::IsAligned(buffer_size, PageSize), ResultInvalidSize);
|
||||||
|
R_UNLESS(message < message + buffer_size, ResultInvalidCurrentMemory);
|
||||||
|
|
||||||
|
// Get the process page table.
|
||||||
|
auto& page_table = GetCurrentProcess(kernel).GetPageTable();
|
||||||
|
|
||||||
|
// Lock the message buffer.
|
||||||
|
R_TRY(page_table.LockForIpcUserBuffer(nullptr, message, buffer_size));
|
||||||
|
|
||||||
|
{
|
||||||
|
// If we fail to send the message, unlock the message buffer.
|
||||||
|
ON_RESULT_FAILURE {
|
||||||
|
page_table.UnlockForIpcUserBuffer(message, buffer_size);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Send the request.
|
||||||
|
ASSERT(message != 0);
|
||||||
|
R_TRY(SendSyncRequestImpl(kernel, message, buffer_size, session_handle));
|
||||||
|
}
|
||||||
|
|
||||||
|
// We successfully processed, so try to unlock the message buffer.
|
||||||
|
R_RETURN(page_table.UnlockForIpcUserBuffer(message, buffer_size));
|
||||||
|
}
|
||||||
|
|
||||||
|
Result SendAsyncRequestWithUserBuffer(Core::System& system, Handle* out_event_handle,
|
||||||
|
uint64_t message, uint64_t buffer_size,
|
||||||
|
Handle session_handle) {
|
||||||
|
// Get the process and handle table.
|
||||||
|
auto& process = GetCurrentProcess(system.Kernel());
|
||||||
|
auto& handle_table = process.GetHandleTable();
|
||||||
|
|
||||||
|
// Reserve a new event from the process resource limit.
|
||||||
|
KScopedResourceReservation event_reservation(std::addressof(process),
|
||||||
|
Svc::LimitableResource::EventCountMax);
|
||||||
|
R_UNLESS(event_reservation.Succeeded(), ResultLimitReached);
|
||||||
|
|
||||||
|
// Get the client session.
|
||||||
|
KScopedAutoObject session = process.GetHandleTable().GetObject<KClientSession>(session_handle);
|
||||||
|
R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
|
||||||
|
|
||||||
|
// Get the parent, and persist a reference to it until we're done.
|
||||||
|
KScopedAutoObject parent = session->GetParent();
|
||||||
|
ASSERT(parent.IsNotNull());
|
||||||
|
|
||||||
|
// Create a new event.
|
||||||
|
KEvent* event = KEvent::Create(system.Kernel());
|
||||||
|
R_UNLESS(event != nullptr, ResultOutOfResource);
|
||||||
|
|
||||||
|
// Initialize the event.
|
||||||
|
event->Initialize(std::addressof(process));
|
||||||
|
|
||||||
|
// Commit our reservation.
|
||||||
|
event_reservation.Commit();
|
||||||
|
|
||||||
|
// At end of scope, kill the standing references to the sub events.
|
||||||
|
SCOPE_EXIT({
|
||||||
|
event->GetReadableEvent().Close();
|
||||||
|
event->Close();
|
||||||
|
});
|
||||||
|
|
||||||
|
// Register the event.
|
||||||
|
KEvent::Register(system.Kernel(), event);
|
||||||
|
|
||||||
|
// Add the readable event to the handle table.
|
||||||
|
R_TRY(handle_table.Add(out_event_handle, std::addressof(event->GetReadableEvent())));
|
||||||
|
|
||||||
|
// Ensure that if we fail to send the request, we close the readable handle.
|
||||||
|
ON_RESULT_FAILURE {
|
||||||
|
handle_table.Remove(*out_event_handle);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Send the async request.
|
||||||
|
R_RETURN(session->SendAsyncRequest(event, message, buffer_size));
|
||||||
|
}
|
||||||
|
|
||||||
|
Result ReplyAndReceive(Core::System& system, s32* out_index, uint64_t handles, s32 num_handles,
|
||||||
|
Handle reply_target, s64 timeout_ns) {
|
||||||
|
R_RETURN(ReplyAndReceiveImpl(system.Kernel(), out_index, 0, 0, 0, handles, num_handles,
|
||||||
|
reply_target, timeout_ns));
|
||||||
|
}
|
||||||
|
|
||||||
|
Result ReplyAndReceiveWithUserBuffer(Core::System& system, int32_t* out_index, uint64_t message,
|
||||||
|
uint64_t buffer_size, uint64_t handles, int32_t num_handles,
|
||||||
|
Handle reply_target, int64_t timeout_ns) {
|
||||||
|
// Validate that the message buffer is page aligned and does not overflow.
|
||||||
|
R_UNLESS(Common::IsAligned(message, PageSize), ResultInvalidAddress);
|
||||||
|
R_UNLESS(buffer_size > 0, ResultInvalidSize);
|
||||||
|
R_UNLESS(Common::IsAligned(buffer_size, PageSize), ResultInvalidSize);
|
||||||
|
R_UNLESS(message < message + buffer_size, ResultInvalidCurrentMemory);
|
||||||
|
|
||||||
|
// Get the process page table.
|
||||||
|
auto& page_table = GetCurrentProcess(system.Kernel()).GetPageTable();
|
||||||
|
|
||||||
|
// Lock the message buffer, getting its physical address.
|
||||||
|
KPhysicalAddress message_paddr;
|
||||||
|
R_TRY(page_table.LockForIpcUserBuffer(std::addressof(message_paddr), message, buffer_size));
|
||||||
|
|
||||||
|
{
|
||||||
|
// If we fail to send the message, unlock the message buffer.
|
||||||
|
ON_RESULT_FAILURE {
|
||||||
|
page_table.UnlockForIpcUserBuffer(message, buffer_size);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Reply/Receive the request.
|
||||||
|
ASSERT(message != 0);
|
||||||
|
R_TRY(ReplyAndReceiveImpl(system.Kernel(), out_index, message, buffer_size, message_paddr,
|
||||||
|
handles, num_handles, reply_target, timeout_ns));
|
||||||
|
}
|
||||||
|
|
||||||
|
// We successfully processed, so try to unlock the message buffer.
|
||||||
|
R_RETURN(page_table.UnlockForIpcUserBuffer(message, buffer_size));
|
||||||
}
|
}
|
||||||
|
|
||||||
Result SendSyncRequest64(Core::System& system, Handle session_handle) {
|
Result SendSyncRequest64(Core::System& system, Handle session_handle) {
|
||||||
|
|
|
@ -1,21 +1,40 @@
|
||||||
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
// SPDX-FileCopyrightText: Copyright 2023 yuzu Emulator Project
|
||||||
// SPDX-License-Identifier: GPL-2.0-or-later
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
||||||
|
|
||||||
#include "core/arm/arm_interface.h"
|
|
||||||
#include "core/core.h"
|
#include "core/core.h"
|
||||||
|
#include "core/hle/kernel/k_light_client_session.h"
|
||||||
|
#include "core/hle/kernel/k_light_server_session.h"
|
||||||
|
#include "core/hle/kernel/k_process.h"
|
||||||
|
#include "core/hle/kernel/k_thread.h"
|
||||||
#include "core/hle/kernel/svc.h"
|
#include "core/hle/kernel/svc.h"
|
||||||
#include "core/hle/kernel/svc_results.h"
|
#include "core/hle/kernel/svc_results.h"
|
||||||
|
|
||||||
namespace Kernel::Svc {
|
namespace Kernel::Svc {
|
||||||
|
|
||||||
Result SendSyncRequestLight(Core::System& system, Handle session_handle, u32* args) {
|
Result SendSyncRequestLight(Core::System& system, Handle session_handle, u32* args) {
|
||||||
UNIMPLEMENTED();
|
// Get the light client session from its handle.
|
||||||
R_THROW(ResultNotImplemented);
|
KScopedAutoObject session = GetCurrentProcess(system.Kernel())
|
||||||
|
.GetHandleTable()
|
||||||
|
.GetObject<KLightClientSession>(session_handle);
|
||||||
|
R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
|
||||||
|
|
||||||
|
// Send the request.
|
||||||
|
R_TRY(session->SendSyncRequest(args));
|
||||||
|
|
||||||
|
R_SUCCEED();
|
||||||
}
|
}
|
||||||
|
|
||||||
Result ReplyAndReceiveLight(Core::System& system, Handle session_handle, u32* args) {
|
Result ReplyAndReceiveLight(Core::System& system, Handle session_handle, u32* args) {
|
||||||
UNIMPLEMENTED();
|
// Get the light server session from its handle.
|
||||||
R_THROW(ResultNotImplemented);
|
KScopedAutoObject session = GetCurrentProcess(system.Kernel())
|
||||||
|
.GetHandleTable()
|
||||||
|
.GetObject<KLightServerSession>(session_handle);
|
||||||
|
R_UNLESS(session.IsNotNull(), ResultInvalidHandle);
|
||||||
|
|
||||||
|
// Handle the request.
|
||||||
|
R_TRY(session->ReplyAndReceive(args));
|
||||||
|
|
||||||
|
R_SUCCEED();
|
||||||
}
|
}
|
||||||
|
|
||||||
Result SendSyncRequestLight64(Core::System& system, Handle session_handle, u32* args) {
|
Result SendSyncRequestLight64(Core::System& system, Handle session_handle, u32* args) {
|
||||||
|
|
|
@ -5,6 +5,7 @@
|
||||||
#include "core/core.h"
|
#include "core/core.h"
|
||||||
#include "core/hle/kernel/k_client_port.h"
|
#include "core/hle/kernel/k_client_port.h"
|
||||||
#include "core/hle/kernel/k_client_session.h"
|
#include "core/hle/kernel/k_client_session.h"
|
||||||
|
#include "core/hle/kernel/k_light_client_session.h"
|
||||||
#include "core/hle/kernel/k_object_name.h"
|
#include "core/hle/kernel/k_object_name.h"
|
||||||
#include "core/hle/kernel/k_port.h"
|
#include "core/hle/kernel/k_port.h"
|
||||||
#include "core/hle/kernel/k_process.h"
|
#include "core/hle/kernel/k_process.h"
|
||||||
|
@ -51,13 +52,73 @@ Result ConnectToNamedPort(Core::System& system, Handle* out, u64 user_name) {
|
||||||
|
|
||||||
Result CreatePort(Core::System& system, Handle* out_server, Handle* out_client,
|
Result CreatePort(Core::System& system, Handle* out_server, Handle* out_client,
|
||||||
int32_t max_sessions, bool is_light, uint64_t name) {
|
int32_t max_sessions, bool is_light, uint64_t name) {
|
||||||
UNIMPLEMENTED();
|
auto& kernel = system.Kernel();
|
||||||
R_THROW(ResultNotImplemented);
|
|
||||||
|
// Ensure max sessions is valid.
|
||||||
|
R_UNLESS(max_sessions > 0, ResultOutOfRange);
|
||||||
|
|
||||||
|
// Get the current handle table.
|
||||||
|
auto& handle_table = GetCurrentProcess(kernel).GetHandleTable();
|
||||||
|
|
||||||
|
// Create a new port.
|
||||||
|
KPort* port = KPort::Create(kernel);
|
||||||
|
R_UNLESS(port != nullptr, ResultOutOfResource);
|
||||||
|
|
||||||
|
// Initialize the port.
|
||||||
|
port->Initialize(max_sessions, is_light, name);
|
||||||
|
|
||||||
|
// Ensure that we clean up the port (and its only references are handle table) on function end.
|
||||||
|
SCOPE_EXIT({
|
||||||
|
port->GetServerPort().Close();
|
||||||
|
port->GetClientPort().Close();
|
||||||
|
});
|
||||||
|
|
||||||
|
// Register the port.
|
||||||
|
KPort::Register(kernel, port);
|
||||||
|
|
||||||
|
// Add the client to the handle table.
|
||||||
|
R_TRY(handle_table.Add(out_client, std::addressof(port->GetClientPort())));
|
||||||
|
|
||||||
|
// Ensure that we maintain a clean handle state on exit.
|
||||||
|
ON_RESULT_FAILURE {
|
||||||
|
handle_table.Remove(*out_client);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Add the server to the handle table.
|
||||||
|
R_RETURN(handle_table.Add(out_server, std::addressof(port->GetServerPort())));
|
||||||
}
|
}
|
||||||
|
|
||||||
Result ConnectToPort(Core::System& system, Handle* out_handle, Handle port) {
|
Result ConnectToPort(Core::System& system, Handle* out, Handle port) {
|
||||||
UNIMPLEMENTED();
|
// Get the current handle table.
|
||||||
R_THROW(ResultNotImplemented);
|
auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
|
||||||
|
|
||||||
|
// Get the client port.
|
||||||
|
KScopedAutoObject client_port = handle_table.GetObject<KClientPort>(port);
|
||||||
|
R_UNLESS(client_port.IsNotNull(), ResultInvalidHandle);
|
||||||
|
|
||||||
|
// Reserve a handle for the port.
|
||||||
|
// NOTE: Nintendo really does write directly to the output handle here.
|
||||||
|
R_TRY(handle_table.Reserve(out));
|
||||||
|
ON_RESULT_FAILURE {
|
||||||
|
handle_table.Unreserve(*out);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Create the session.
|
||||||
|
KAutoObject* session;
|
||||||
|
if (client_port->IsLight()) {
|
||||||
|
R_TRY(client_port->CreateLightSession(
|
||||||
|
reinterpret_cast<KLightClientSession**>(std::addressof(session))));
|
||||||
|
} else {
|
||||||
|
R_TRY(client_port->CreateSession(
|
||||||
|
reinterpret_cast<KClientSession**>(std::addressof(session))));
|
||||||
|
}
|
||||||
|
|
||||||
|
// Register the session.
|
||||||
|
handle_table.Register(*out, session);
|
||||||
|
session->Close();
|
||||||
|
|
||||||
|
// We succeeded.
|
||||||
|
R_SUCCEED();
|
||||||
}
|
}
|
||||||
|
|
||||||
Result ManageNamedPort(Core::System& system, Handle* out_server_handle, uint64_t user_name,
|
Result ManageNamedPort(Core::System& system, Handle* out_server_handle, uint64_t user_name,
|
||||||
|
|
|
@ -3,8 +3,10 @@
|
||||||
|
|
||||||
#include "common/scope_exit.h"
|
#include "common/scope_exit.h"
|
||||||
#include "core/core.h"
|
#include "core/core.h"
|
||||||
|
#include "core/hle/kernel/k_light_session.h"
|
||||||
#include "core/hle/kernel/k_process.h"
|
#include "core/hle/kernel/k_process.h"
|
||||||
#include "core/hle/kernel/k_scoped_resource_reservation.h"
|
#include "core/hle/kernel/k_scoped_resource_reservation.h"
|
||||||
|
#include "core/hle/kernel/k_server_port.h"
|
||||||
#include "core/hle/kernel/k_session.h"
|
#include "core/hle/kernel/k_session.h"
|
||||||
#include "core/hle/kernel/svc.h"
|
#include "core/hle/kernel/svc.h"
|
||||||
|
|
||||||
|
@ -20,7 +22,7 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien
|
||||||
T* session;
|
T* session;
|
||||||
|
|
||||||
// Reserve a new session from the process resource limit.
|
// Reserve a new session from the process resource limit.
|
||||||
// FIXME: LimitableResource_SessionCountMax
|
// TODO: Dynamic resource limits
|
||||||
KScopedResourceReservation session_reservation(std::addressof(process),
|
KScopedResourceReservation session_reservation(std::addressof(process),
|
||||||
LimitableResource::SessionCountMax);
|
LimitableResource::SessionCountMax);
|
||||||
if (session_reservation.Succeeded()) {
|
if (session_reservation.Succeeded()) {
|
||||||
|
@ -92,16 +94,42 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien
|
||||||
Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, bool is_light,
|
Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, bool is_light,
|
||||||
u64 name) {
|
u64 name) {
|
||||||
if (is_light) {
|
if (is_light) {
|
||||||
// return CreateSession<KLightSession>(system, out_server, out_client, name);
|
R_RETURN(CreateSession<KLightSession>(system, out_server, out_client, name));
|
||||||
R_THROW(ResultNotImplemented);
|
|
||||||
} else {
|
} else {
|
||||||
R_RETURN(CreateSession<KSession>(system, out_server, out_client, name));
|
R_RETURN(CreateSession<KSession>(system, out_server, out_client, name));
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
Result AcceptSession(Core::System& system, Handle* out_handle, Handle port_handle) {
|
Result AcceptSession(Core::System& system, Handle* out, Handle port_handle) {
|
||||||
UNIMPLEMENTED();
|
// Get the current handle table.
|
||||||
R_THROW(ResultNotImplemented);
|
auto& handle_table = GetCurrentProcess(system.Kernel()).GetHandleTable();
|
||||||
|
|
||||||
|
// Get the server port.
|
||||||
|
KScopedAutoObject port = handle_table.GetObject<KServerPort>(port_handle);
|
||||||
|
R_UNLESS(port.IsNotNull(), ResultInvalidHandle);
|
||||||
|
|
||||||
|
// Reserve an entry for the new session.
|
||||||
|
R_TRY(handle_table.Reserve(out));
|
||||||
|
ON_RESULT_FAILURE {
|
||||||
|
handle_table.Unreserve(*out);
|
||||||
|
};
|
||||||
|
|
||||||
|
// Accept the session.
|
||||||
|
KAutoObject* session;
|
||||||
|
if (port->IsLight()) {
|
||||||
|
session = port->AcceptLightSession();
|
||||||
|
} else {
|
||||||
|
session = port->AcceptSession();
|
||||||
|
}
|
||||||
|
|
||||||
|
// Ensure we accepted successfully.
|
||||||
|
R_UNLESS(session != nullptr, ResultNotFound);
|
||||||
|
|
||||||
|
// Register the session.
|
||||||
|
handle_table.Register(*out, session);
|
||||||
|
session->Close();
|
||||||
|
|
||||||
|
R_SUCCEED();
|
||||||
}
|
}
|
||||||
|
|
||||||
Result CreateSession64(Core::System& system, Handle* out_server_session_handle,
|
Result CreateSession64(Core::System& system, Handle* out_server_session_handle,
|
||||||
|
|
|
@ -192,8 +192,6 @@ Result SM::GetServiceImpl(Kernel::KClientSession** out_client_session, HLEReques
|
||||||
return result;
|
return result;
|
||||||
}
|
}
|
||||||
|
|
||||||
LOG_DEBUG(Service_SM, "called service={} -> session={}", name, session->GetId());
|
|
||||||
|
|
||||||
*out_client_session = session;
|
*out_client_session = session;
|
||||||
return ResultSuccess;
|
return ResultSuccess;
|
||||||
}
|
}
|
||||||
|
|
Loading…
Reference in a new issue