2021-04-24 02:00:15 +02:00
|
|
|
// Copyright 2021 Citra Emulator Project
|
2016-05-22 18:22:49 +02:00
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2021-04-24 02:00:15 +02:00
|
|
|
#include "common/scope_exit.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 02:00:15 +02:00
|
|
|
#include "core/hle/kernel/k_port.h"
|
|
|
|
#include "core/hle/kernel/k_scheduler.h"
|
|
|
|
#include "core/hle/kernel/k_scoped_resource_reservation.h"
|
2021-04-14 02:48:37 +02:00
|
|
|
#include "core/hle/kernel/k_session.h"
|
2021-02-13 00:43:01 +01:00
|
|
|
#include "core/hle/kernel/svc_results.h"
|
2016-05-22 18:22:49 +02:00
|
|
|
|
|
|
|
namespace Kernel {
|
|
|
|
|
2021-05-08 18:11:36 +02:00
|
|
|
KClientPort::KClientPort(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}
|
2021-04-22 06:43:25 +02:00
|
|
|
KClientPort::~KClientPort() = default;
|
2016-05-22 18:22:49 +02:00
|
|
|
|
2021-06-07 00:39:11 +02:00
|
|
|
void KClientPort::Initialize(KPort* parent_port_, s32 max_sessions_, std::string&& name_) {
|
2021-04-24 02:00:15 +02:00
|
|
|
// Set member variables.
|
|
|
|
num_sessions = 0;
|
|
|
|
peak_sessions = 0;
|
2021-06-07 00:39:11 +02:00
|
|
|
parent = parent_port_;
|
2021-04-22 06:43:25 +02:00
|
|
|
max_sessions = max_sessions_;
|
|
|
|
name = std::move(name_);
|
|
|
|
}
|
|
|
|
|
2021-04-24 02:00:15 +02:00
|
|
|
void KClientPort::OnSessionFinalized() {
|
|
|
|
KScopedSchedulerLock sl{kernel};
|
2018-10-06 09:47:33 +02:00
|
|
|
|
2021-04-24 02:00:15 +02:00
|
|
|
const auto prev = num_sessions--;
|
|
|
|
if (prev == max_sessions) {
|
|
|
|
this->NotifyAvailable();
|
2016-12-05 19:59:57 +01:00
|
|
|
}
|
2021-04-24 02:00:15 +02:00
|
|
|
}
|
2016-12-05 19:59:57 +01:00
|
|
|
|
2021-04-24 02:00:15 +02:00
|
|
|
void KClientPort::OnServerClosed() {}
|
2016-12-05 17:02:08 +01:00
|
|
|
|
2021-04-24 02:00:15 +02:00
|
|
|
bool KClientPort::IsLight() const {
|
|
|
|
return this->GetParent()->IsLight();
|
|
|
|
}
|
2016-12-05 17:02:08 +01:00
|
|
|
|
2021-04-24 02:00:15 +02:00
|
|
|
bool KClientPort::IsServerClosed() const {
|
|
|
|
return this->GetParent()->IsServerClosed();
|
2016-06-15 01:03:30 +02:00
|
|
|
}
|
|
|
|
|
2021-04-24 02:00:15 +02:00
|
|
|
void KClientPort::Destroy() {
|
|
|
|
// Note with our parent that we're closed.
|
|
|
|
parent->OnClientClosed();
|
2018-08-07 04:09:31 +02:00
|
|
|
|
2021-04-24 02:00:15 +02:00
|
|
|
// Close our reference to our parent.
|
|
|
|
parent->Close();
|
2021-04-22 06:43:25 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool KClientPort::IsSignaled() const {
|
|
|
|
return num_sessions < max_sessions;
|
2018-08-07 04:09:31 +02:00
|
|
|
}
|
|
|
|
|
2021-06-05 04:26:48 +02:00
|
|
|
ResultCode KClientPort::CreateSession(KClientSession** out,
|
|
|
|
std::shared_ptr<SessionRequestManager> session_manager) {
|
2021-04-24 02:00:15 +02:00
|
|
|
// Reserve a new session from the resource limit.
|
2021-05-16 07:34:55 +02:00
|
|
|
KScopedResourceReservation session_reservation(kernel.CurrentProcess()->GetResourceLimit(),
|
|
|
|
LimitableResource::Sessions);
|
|
|
|
R_UNLESS(session_reservation.Succeeded(), ResultLimitReached);
|
2021-04-24 02:00:15 +02:00
|
|
|
|
|
|
|
// Update the session counts.
|
|
|
|
{
|
|
|
|
// Atomically increment the number of sessions.
|
2021-06-10 07:29:18 +02:00
|
|
|
s32 new_sessions{};
|
2021-04-24 02:00:15 +02:00
|
|
|
{
|
|
|
|
const auto max = max_sessions;
|
|
|
|
auto cur_sessions = num_sessions.load(std::memory_order_acquire);
|
|
|
|
do {
|
|
|
|
R_UNLESS(cur_sessions < max, ResultOutOfSessions);
|
|
|
|
new_sessions = cur_sessions + 1;
|
|
|
|
} while (!num_sessions.compare_exchange_weak(cur_sessions, new_sessions,
|
|
|
|
std::memory_order_relaxed));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Atomically update the peak session tracking.
|
|
|
|
{
|
|
|
|
auto peak = peak_sessions.load(std::memory_order_acquire);
|
|
|
|
do {
|
|
|
|
if (peak >= new_sessions) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} while (!peak_sessions.compare_exchange_weak(peak, new_sessions,
|
|
|
|
std::memory_order_relaxed));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a new session.
|
|
|
|
KSession* session = KSession::Create(kernel);
|
|
|
|
if (session == nullptr) {
|
2021-05-11 00:41:46 +02:00
|
|
|
// Decrement the session count.
|
2021-04-24 02:00:15 +02:00
|
|
|
const auto prev = num_sessions--;
|
|
|
|
if (prev == max_sessions) {
|
|
|
|
this->NotifyAvailable();
|
|
|
|
}
|
|
|
|
|
|
|
|
return ResultOutOfResource;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Initialize the session.
|
2021-06-05 04:26:48 +02:00
|
|
|
session->Initialize(this, parent->GetName(), session_manager);
|
2021-04-24 02:00:15 +02:00
|
|
|
|
|
|
|
// Commit the session reservation.
|
2021-05-16 07:34:55 +02:00
|
|
|
session_reservation.Commit();
|
2021-04-24 02:00:15 +02:00
|
|
|
|
|
|
|
// Register the session.
|
|
|
|
KSession::Register(kernel, session);
|
|
|
|
auto session_guard = SCOPE_GUARD({
|
|
|
|
session->GetClientSession().Close();
|
|
|
|
session->GetServerSession().Close();
|
|
|
|
});
|
|
|
|
|
|
|
|
// Enqueue the session with our parent.
|
|
|
|
R_TRY(parent->EnqueueSession(std::addressof(session->GetServerSession())));
|
|
|
|
|
|
|
|
// We succeeded, so set the output.
|
|
|
|
session_guard.Cancel();
|
|
|
|
*out = std::addressof(session->GetClientSession());
|
2021-05-21 07:05:04 +02:00
|
|
|
return ResultSuccess;
|
2021-04-24 02:00:15 +02:00
|
|
|
}
|
|
|
|
|
2018-01-20 08:48:02 +01:00
|
|
|
} // namespace Kernel
|