kernel: convert KPort, KSession
This commit is contained in:
parent
d24ab14126
commit
097c25b164
|
@ -13,40 +13,40 @@ class KAffinityMask {
|
|||
public:
|
||||
constexpr KAffinityMask() = default;
|
||||
|
||||
[[nodiscard]] constexpr u64 GetAffinityMask() const {
|
||||
return this->mask;
|
||||
constexpr u64 GetAffinityMask() const {
|
||||
return m_mask;
|
||||
}
|
||||
|
||||
constexpr void SetAffinityMask(u64 new_mask) {
|
||||
ASSERT((new_mask & ~AllowedAffinityMask) == 0);
|
||||
this->mask = new_mask;
|
||||
m_mask = new_mask;
|
||||
}
|
||||
|
||||
[[nodiscard]] constexpr bool GetAffinity(s32 core) const {
|
||||
return (this->mask & GetCoreBit(core)) != 0;
|
||||
constexpr bool GetAffinity(s32 core) const {
|
||||
return (m_mask & GetCoreBit(core)) != 0;
|
||||
}
|
||||
|
||||
constexpr void SetAffinity(s32 core, bool set) {
|
||||
if (set) {
|
||||
this->mask |= GetCoreBit(core);
|
||||
m_mask |= GetCoreBit(core);
|
||||
} else {
|
||||
this->mask &= ~GetCoreBit(core);
|
||||
m_mask &= ~GetCoreBit(core);
|
||||
}
|
||||
}
|
||||
|
||||
constexpr void SetAll() {
|
||||
this->mask = AllowedAffinityMask;
|
||||
m_mask = AllowedAffinityMask;
|
||||
}
|
||||
|
||||
private:
|
||||
[[nodiscard]] static constexpr u64 GetCoreBit(s32 core) {
|
||||
static constexpr u64 GetCoreBit(s32 core) {
|
||||
ASSERT(0 <= core && core < static_cast<s32>(Core::Hardware::NUM_CPU_CORES));
|
||||
return (1ULL << core);
|
||||
}
|
||||
|
||||
static constexpr u64 AllowedAffinityMask = (1ULL << Core::Hardware::NUM_CPU_CORES) - 1;
|
||||
|
||||
u64 mask{};
|
||||
u64 m_mask{};
|
||||
};
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -164,17 +164,12 @@ public:
|
|||
}
|
||||
}
|
||||
|
||||
const std::string& GetName() const {
|
||||
return name;
|
||||
}
|
||||
|
||||
private:
|
||||
void RegisterWithKernel();
|
||||
void UnregisterWithKernel();
|
||||
|
||||
protected:
|
||||
KernelCore& kernel;
|
||||
std::string name;
|
||||
|
||||
private:
|
||||
std::atomic<u32> m_ref_count{};
|
||||
|
@ -208,10 +203,6 @@ public:
|
|||
return reinterpret_cast<u64>(this);
|
||||
}
|
||||
|
||||
virtual const std::string& GetName() const {
|
||||
return name;
|
||||
}
|
||||
|
||||
private:
|
||||
friend class KAutoObjectWithListContainer;
|
||||
};
|
||||
|
|
|
@ -11,7 +11,7 @@
|
|||
|
||||
namespace Kernel {
|
||||
|
||||
Result KCapabilities::InitializeForKIP(std::span<const u32> kern_caps, KPageTable* page_table) {
|
||||
Result KCapabilities::InitializeForKip(std::span<const u32> kern_caps, KPageTable* page_table) {
|
||||
// We're initializing an initial process.
|
||||
m_svc_access_flags.reset();
|
||||
m_irq_access_flags.reset();
|
||||
|
|
|
@ -22,7 +22,7 @@ class KCapabilities {
|
|||
public:
|
||||
constexpr explicit KCapabilities() = default;
|
||||
|
||||
Result InitializeForKIP(std::span<const u32> kern_caps, KPageTable* page_table);
|
||||
Result InitializeForKip(std::span<const u32> kern_caps, KPageTable* page_table);
|
||||
Result InitializeForUser(std::span<const u32> user_caps, KPageTable* page_table);
|
||||
|
||||
static Result CheckCapabilities(KernelCore& kernel, std::span<const u32> user_caps);
|
||||
|
|
|
@ -14,23 +14,18 @@ namespace Kernel {
|
|||
KClientPort::KClientPort(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}
|
||||
KClientPort::~KClientPort() = default;
|
||||
|
||||
void KClientPort::Initialize(KPort* parent_port_, s32 max_sessions_, std::string&& name_) {
|
||||
void KClientPort::Initialize(KPort* parent, s32 max_sessions) {
|
||||
// Set member variables.
|
||||
num_sessions = 0;
|
||||
peak_sessions = 0;
|
||||
parent = parent_port_;
|
||||
max_sessions = max_sessions_;
|
||||
name = std::move(name_);
|
||||
m_num_sessions = 0;
|
||||
m_peak_sessions = 0;
|
||||
m_parent = parent;
|
||||
m_max_sessions = max_sessions;
|
||||
}
|
||||
|
||||
void KClientPort::OnSessionFinalized() {
|
||||
KScopedSchedulerLock sl{kernel};
|
||||
|
||||
// This might happen if a session was improperly used with this port.
|
||||
ASSERT_MSG(num_sessions > 0, "num_sessions is invalid");
|
||||
|
||||
const auto prev = num_sessions--;
|
||||
if (prev == max_sessions) {
|
||||
if (const auto prev = m_num_sessions--; prev == m_max_sessions) {
|
||||
this->NotifyAvailable();
|
||||
}
|
||||
}
|
||||
|
@ -47,81 +42,81 @@ bool KClientPort::IsServerClosed() const {
|
|||
|
||||
void KClientPort::Destroy() {
|
||||
// Note with our parent that we're closed.
|
||||
parent->OnClientClosed();
|
||||
m_parent->OnClientClosed();
|
||||
|
||||
// Close our reference to our parent.
|
||||
parent->Close();
|
||||
m_parent->Close();
|
||||
}
|
||||
|
||||
bool KClientPort::IsSignaled() const {
|
||||
return num_sessions < max_sessions;
|
||||
return m_num_sessions.load() < m_max_sessions;
|
||||
}
|
||||
|
||||
Result KClientPort::CreateSession(KClientSession** out) {
|
||||
// Declare the session we're going to allocate.
|
||||
KSession* session{};
|
||||
|
||||
// Reserve a new session from the resource limit.
|
||||
//! FIXME: we are reserving this from the wrong resource limit!
|
||||
KScopedResourceReservation session_reservation(kernel.ApplicationProcess()->GetResourceLimit(),
|
||||
LimitableResource::SessionCountMax);
|
||||
R_UNLESS(session_reservation.Succeeded(), ResultLimitReached);
|
||||
|
||||
// Allocate a session normally.
|
||||
session = KSession::Create(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 = max_sessions;
|
||||
auto cur_sessions = num_sessions.load(std::memory_order_acquire);
|
||||
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 (!num_sessions.compare_exchange_weak(cur_sessions, new_sessions,
|
||||
std::memory_order_relaxed));
|
||||
} while (!m_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);
|
||||
auto peak = m_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));
|
||||
} while (!m_peak_sessions.compare_exchange_weak(peak, new_sessions,
|
||||
std::memory_order_relaxed));
|
||||
}
|
||||
}
|
||||
|
||||
// Create a new session.
|
||||
KSession* session = KSession::Create(kernel);
|
||||
if (session == nullptr) {
|
||||
// Decrement the session count.
|
||||
const auto prev = num_sessions--;
|
||||
if (prev == max_sessions) {
|
||||
this->NotifyAvailable();
|
||||
}
|
||||
|
||||
return ResultOutOfResource;
|
||||
}
|
||||
|
||||
// Initialize the session.
|
||||
session->Initialize(this, parent->GetName());
|
||||
session->Initialize(this, m_parent->GetName());
|
||||
|
||||
// Commit the session reservation.
|
||||
session_reservation.Commit();
|
||||
|
||||
// Register the session.
|
||||
KSession::Register(kernel, session);
|
||||
auto session_guard = SCOPE_GUARD({
|
||||
ON_RESULT_FAILURE {
|
||||
session->GetClientSession().Close();
|
||||
session->GetServerSession().Close();
|
||||
});
|
||||
};
|
||||
|
||||
// Enqueue the session with our parent.
|
||||
R_TRY(parent->EnqueueSession(std::addressof(session->GetServerSession())));
|
||||
R_TRY(m_parent->EnqueueSession(std::addressof(session->GetServerSession())));
|
||||
|
||||
// We succeeded, so set the output.
|
||||
session_guard.Cancel();
|
||||
*out = std::addressof(session->GetClientSession());
|
||||
return ResultSuccess;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -4,7 +4,6 @@
|
|||
#pragma once
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
|
||||
#include "common/common_types.h"
|
||||
#include "core/hle/kernel/k_synchronization_object.h"
|
||||
|
@ -20,28 +19,28 @@ class KClientPort final : public KSynchronizationObject {
|
|||
KERNEL_AUTOOBJECT_TRAITS(KClientPort, KSynchronizationObject);
|
||||
|
||||
public:
|
||||
explicit KClientPort(KernelCore& kernel_);
|
||||
explicit KClientPort(KernelCore& kernel);
|
||||
~KClientPort() override;
|
||||
|
||||
void Initialize(KPort* parent_, s32 max_sessions_, std::string&& name_);
|
||||
void Initialize(KPort* parent, s32 max_sessions);
|
||||
void OnSessionFinalized();
|
||||
void OnServerClosed();
|
||||
|
||||
const KPort* GetParent() const {
|
||||
return parent;
|
||||
return m_parent;
|
||||
}
|
||||
KPort* GetParent() {
|
||||
return parent;
|
||||
return m_parent;
|
||||
}
|
||||
|
||||
s32 GetNumSessions() const {
|
||||
return num_sessions;
|
||||
return m_num_sessions;
|
||||
}
|
||||
s32 GetPeakSessions() const {
|
||||
return peak_sessions;
|
||||
return m_peak_sessions;
|
||||
}
|
||||
s32 GetMaxSessions() const {
|
||||
return max_sessions;
|
||||
return m_max_sessions;
|
||||
}
|
||||
|
||||
bool IsLight() const;
|
||||
|
@ -54,10 +53,10 @@ public:
|
|||
Result CreateSession(KClientSession** out);
|
||||
|
||||
private:
|
||||
std::atomic<s32> num_sessions{};
|
||||
std::atomic<s32> peak_sessions{};
|
||||
s32 max_sessions{};
|
||||
KPort* parent{};
|
||||
std::atomic<s32> m_num_sessions{};
|
||||
std::atomic<s32> m_peak_sessions{};
|
||||
s32 m_max_sessions{};
|
||||
KPort* m_parent{};
|
||||
};
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -17,8 +17,8 @@ KClientSession::KClientSession(KernelCore& kernel_)
|
|||
KClientSession::~KClientSession() = default;
|
||||
|
||||
void KClientSession::Destroy() {
|
||||
parent->OnClientClosed();
|
||||
parent->Close();
|
||||
m_parent->OnClientClosed();
|
||||
m_parent->Close();
|
||||
}
|
||||
|
||||
void KClientSession::OnServerClosed() {}
|
||||
|
@ -33,7 +33,7 @@ Result KClientSession::SendSyncRequest() {
|
|||
request->Initialize(nullptr, GetCurrentThread(kernel).GetTLSAddress(), MessageBufferSize);
|
||||
|
||||
// Send the request.
|
||||
return parent->GetServerSession().OnRequest(request);
|
||||
R_RETURN(m_parent->GetServerSession().OnRequest(request));
|
||||
}
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -33,17 +33,16 @@ public:
|
|||
explicit KClientSession(KernelCore& kernel_);
|
||||
~KClientSession() override;
|
||||
|
||||
void Initialize(KSession* parent_session_, std::string&& name_) {
|
||||
void Initialize(KSession* parent) {
|
||||
// Set member variables.
|
||||
parent = parent_session_;
|
||||
name = std::move(name_);
|
||||
m_parent = parent;
|
||||
}
|
||||
|
||||
void Destroy() override;
|
||||
static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
|
||||
static void PostDestroy(uintptr_t arg) {}
|
||||
|
||||
KSession* GetParent() const {
|
||||
return parent;
|
||||
return m_parent;
|
||||
}
|
||||
|
||||
Result SendSyncRequest();
|
||||
|
@ -51,7 +50,7 @@ public:
|
|||
void OnServerClosed();
|
||||
|
||||
private:
|
||||
KSession* parent{};
|
||||
KSession* m_parent{};
|
||||
};
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -8,55 +8,54 @@
|
|||
namespace Kernel {
|
||||
|
||||
KPort::KPort(KernelCore& kernel_)
|
||||
: KAutoObjectWithSlabHeapAndContainer{kernel_}, server{kernel_}, client{kernel_} {}
|
||||
: KAutoObjectWithSlabHeapAndContainer{kernel_}, m_server{kernel_}, m_client{kernel_} {}
|
||||
|
||||
KPort::~KPort() = default;
|
||||
|
||||
void KPort::Initialize(s32 max_sessions_, bool is_light_, const std::string& name_) {
|
||||
void KPort::Initialize(s32 max_sessions, bool is_light, uintptr_t name) {
|
||||
// Open a new reference count to the initialized port.
|
||||
Open();
|
||||
this->Open();
|
||||
|
||||
// Create and initialize our server/client pair.
|
||||
KAutoObject::Create(std::addressof(server));
|
||||
KAutoObject::Create(std::addressof(client));
|
||||
server.Initialize(this, name_ + ":Server");
|
||||
client.Initialize(this, max_sessions_, name_ + ":Client");
|
||||
KAutoObject::Create(std::addressof(m_server));
|
||||
KAutoObject::Create(std::addressof(m_client));
|
||||
m_server.Initialize(this);
|
||||
m_client.Initialize(this, max_sessions);
|
||||
|
||||
// Set our member variables.
|
||||
is_light = is_light_;
|
||||
name = name_;
|
||||
state = State::Normal;
|
||||
m_is_light = is_light;
|
||||
m_name = name;
|
||||
m_state = State::Normal;
|
||||
}
|
||||
|
||||
void KPort::OnClientClosed() {
|
||||
KScopedSchedulerLock sl{kernel};
|
||||
|
||||
if (state == State::Normal) {
|
||||
state = State::ClientClosed;
|
||||
if (m_state == State::Normal) {
|
||||
m_state = State::ClientClosed;
|
||||
}
|
||||
}
|
||||
|
||||
void KPort::OnServerClosed() {
|
||||
KScopedSchedulerLock sl{kernel};
|
||||
|
||||
if (state == State::Normal) {
|
||||
state = State::ServerClosed;
|
||||
if (m_state == State::Normal) {
|
||||
m_state = State::ServerClosed;
|
||||
}
|
||||
}
|
||||
|
||||
bool KPort::IsServerClosed() const {
|
||||
KScopedSchedulerLock sl{kernel};
|
||||
return state == State::ServerClosed;
|
||||
return m_state == State::ServerClosed;
|
||||
}
|
||||
|
||||
Result KPort::EnqueueSession(KServerSession* session) {
|
||||
KScopedSchedulerLock sl{kernel};
|
||||
|
||||
R_UNLESS(state == State::Normal, ResultPortClosed);
|
||||
R_UNLESS(m_state == State::Normal, ResultPortClosed);
|
||||
|
||||
server.EnqueueSession(session);
|
||||
|
||||
return ResultSuccess;
|
||||
m_server.EnqueueSession(session);
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -22,14 +22,17 @@ public:
|
|||
explicit KPort(KernelCore& kernel_);
|
||||
~KPort() override;
|
||||
|
||||
static void PostDestroy([[maybe_unused]] uintptr_t arg) {}
|
||||
static void PostDestroy(uintptr_t arg) {}
|
||||
|
||||
void Initialize(s32 max_sessions_, bool is_light_, const std::string& name_);
|
||||
void Initialize(s32 max_sessions, bool is_light, uintptr_t name);
|
||||
void OnClientClosed();
|
||||
void OnServerClosed();
|
||||
|
||||
uintptr_t GetName() const {
|
||||
return m_name;
|
||||
}
|
||||
bool IsLight() const {
|
||||
return is_light;
|
||||
return m_is_light;
|
||||
}
|
||||
|
||||
bool IsServerClosed() const;
|
||||
|
@ -37,16 +40,16 @@ public:
|
|||
Result EnqueueSession(KServerSession* session);
|
||||
|
||||
KClientPort& GetClientPort() {
|
||||
return client;
|
||||
return m_client;
|
||||
}
|
||||
KServerPort& GetServerPort() {
|
||||
return server;
|
||||
return m_server;
|
||||
}
|
||||
const KClientPort& GetClientPort() const {
|
||||
return client;
|
||||
return m_client;
|
||||
}
|
||||
const KServerPort& GetServerPort() const {
|
||||
return server;
|
||||
return m_server;
|
||||
}
|
||||
|
||||
private:
|
||||
|
@ -57,10 +60,11 @@ private:
|
|||
ServerClosed = 3,
|
||||
};
|
||||
|
||||
KServerPort server;
|
||||
KClientPort client;
|
||||
State state{State::Invalid};
|
||||
bool is_light{};
|
||||
KServerPort m_server;
|
||||
KClientPort m_client;
|
||||
uintptr_t m_name;
|
||||
State m_state{State::Invalid};
|
||||
bool m_is_light{};
|
||||
};
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -395,6 +395,10 @@ public:
|
|||
return watchpoints;
|
||||
}
|
||||
|
||||
const std::string& GetName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
private:
|
||||
void PinThread(s32 core_id, KThread* thread) {
|
||||
ASSERT(0 <= core_id && core_id < static_cast<s32>(Core::Hardware::NUM_CPU_CORES));
|
||||
|
@ -499,6 +503,8 @@ private:
|
|||
|
||||
size_t memory_release_hint{};
|
||||
|
||||
std::string name{};
|
||||
|
||||
bool is_signaled{};
|
||||
bool is_suspended{};
|
||||
bool is_immortal{};
|
||||
|
|
|
@ -15,10 +15,9 @@ namespace Kernel {
|
|||
KServerPort::KServerPort(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}
|
||||
KServerPort::~KServerPort() = default;
|
||||
|
||||
void KServerPort::Initialize(KPort* parent_port_, std::string&& name_) {
|
||||
void KServerPort::Initialize(KPort* parent) {
|
||||
// Set member variables.
|
||||
parent = parent_port_;
|
||||
name = std::move(name_);
|
||||
m_parent = parent;
|
||||
}
|
||||
|
||||
bool KServerPort::IsLight() const {
|
||||
|
@ -37,9 +36,9 @@ void KServerPort::CleanupSessions() {
|
|||
KServerSession* session = nullptr;
|
||||
{
|
||||
KScopedSchedulerLock sl{kernel};
|
||||
if (!session_list.empty()) {
|
||||
session = std::addressof(session_list.front());
|
||||
session_list.pop_front();
|
||||
if (!m_session_list.empty()) {
|
||||
session = std::addressof(m_session_list.front());
|
||||
m_session_list.pop_front();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -54,13 +53,13 @@ void KServerPort::CleanupSessions() {
|
|||
|
||||
void KServerPort::Destroy() {
|
||||
// Note with our parent that we're closed.
|
||||
parent->OnServerClosed();
|
||||
m_parent->OnServerClosed();
|
||||
|
||||
// Perform necessary cleanup of our session lists.
|
||||
this->CleanupSessions();
|
||||
|
||||
// Close our reference to our parent.
|
||||
parent->Close();
|
||||
m_parent->Close();
|
||||
}
|
||||
|
||||
bool KServerPort::IsSignaled() const {
|
||||
|
@ -68,7 +67,7 @@ bool KServerPort::IsSignaled() const {
|
|||
UNIMPLEMENTED();
|
||||
return false;
|
||||
} else {
|
||||
return !session_list.empty();
|
||||
return !m_session_list.empty();
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -78,8 +77,8 @@ void KServerPort::EnqueueSession(KServerSession* session) {
|
|||
KScopedSchedulerLock sl{kernel};
|
||||
|
||||
// Add the session to our queue.
|
||||
session_list.push_back(*session);
|
||||
if (session_list.size() == 1) {
|
||||
m_session_list.push_back(*session);
|
||||
if (m_session_list.size() == 1) {
|
||||
this->NotifyAvailable();
|
||||
}
|
||||
}
|
||||
|
@ -90,12 +89,12 @@ KServerSession* KServerPort::AcceptSession() {
|
|||
KScopedSchedulerLock sl{kernel};
|
||||
|
||||
// Return the first session in the list.
|
||||
if (session_list.empty()) {
|
||||
if (m_session_list.empty()) {
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
KServerSession* session = std::addressof(session_list.front());
|
||||
session_list.pop_front();
|
||||
KServerSession* session = std::addressof(m_session_list.front());
|
||||
m_session_list.pop_front();
|
||||
return session;
|
||||
}
|
||||
|
||||
|
|
|
@ -25,14 +25,14 @@ public:
|
|||
explicit KServerPort(KernelCore& kernel_);
|
||||
~KServerPort() override;
|
||||
|
||||
void Initialize(KPort* parent_port_, std::string&& name_);
|
||||
void Initialize(KPort* parent);
|
||||
|
||||
void EnqueueSession(KServerSession* pending_session);
|
||||
void EnqueueSession(KServerSession* session);
|
||||
|
||||
KServerSession* AcceptSession();
|
||||
|
||||
const KPort* GetParent() const {
|
||||
return parent;
|
||||
return m_parent;
|
||||
}
|
||||
|
||||
bool IsLight() const;
|
||||
|
@ -46,8 +46,8 @@ private:
|
|||
|
||||
void CleanupSessions();
|
||||
|
||||
SessionList session_list;
|
||||
KPort* parent{};
|
||||
SessionList m_session_list{};
|
||||
KPort* m_parent{};
|
||||
};
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -33,18 +33,12 @@ KServerSession::KServerSession(KernelCore& kernel_)
|
|||
|
||||
KServerSession::~KServerSession() = default;
|
||||
|
||||
void KServerSession::Initialize(KSession* parent_session_, std::string&& name_) {
|
||||
// Set member variables.
|
||||
parent = parent_session_;
|
||||
name = std::move(name_);
|
||||
}
|
||||
|
||||
void KServerSession::Destroy() {
|
||||
parent->OnServerClosed();
|
||||
m_parent->OnServerClosed();
|
||||
|
||||
this->CleanupRequests();
|
||||
|
||||
parent->Close();
|
||||
m_parent->Close();
|
||||
}
|
||||
|
||||
void KServerSession::OnClientClosed() {
|
||||
|
@ -144,7 +138,7 @@ bool KServerSession::IsSignaled() const {
|
|||
ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(kernel));
|
||||
|
||||
// If the client is closed, we're always signaled.
|
||||
if (parent->IsClientClosed()) {
|
||||
if (m_parent->IsClientClosed()) {
|
||||
return true;
|
||||
}
|
||||
|
||||
|
@ -161,7 +155,7 @@ Result KServerSession::OnRequest(KSessionRequest* request) {
|
|||
KScopedSchedulerLock sl{kernel};
|
||||
|
||||
// Ensure that we can handle new requests.
|
||||
R_UNLESS(!parent->IsServerClosed(), ResultSessionClosed);
|
||||
R_UNLESS(!m_parent->IsServerClosed(), ResultSessionClosed);
|
||||
|
||||
// Check that we're not terminating.
|
||||
R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(), ResultTerminationRequested);
|
||||
|
@ -219,7 +213,7 @@ Result KServerSession::SendReply(bool is_hle) {
|
|||
KEvent* event = request->GetEvent();
|
||||
|
||||
// Check whether we're closed.
|
||||
const bool closed = (client_thread == nullptr || parent->IsClientClosed());
|
||||
const bool closed = (client_thread == nullptr || m_parent->IsClientClosed());
|
||||
|
||||
Result result = ResultSuccess;
|
||||
if (!closed) {
|
||||
|
@ -294,7 +288,7 @@ Result KServerSession::ReceiveRequest(std::shared_ptr<Service::HLERequestContext
|
|||
KScopedSchedulerLock sl{kernel};
|
||||
|
||||
// Ensure that we can service the request.
|
||||
R_UNLESS(!parent->IsClientClosed(), ResultSessionClosed);
|
||||
R_UNLESS(!m_parent->IsClientClosed(), ResultSessionClosed);
|
||||
|
||||
// Ensure we aren't already servicing a request.
|
||||
R_UNLESS(m_current_request == nullptr, ResultNotFound);
|
||||
|
|
|
@ -38,14 +38,12 @@ public:
|
|||
|
||||
void Destroy() override;
|
||||
|
||||
void Initialize(KSession* parent_session_, std::string&& name_);
|
||||
|
||||
KSession* GetParent() {
|
||||
return parent;
|
||||
void Initialize(KSession* p) {
|
||||
m_parent = p;
|
||||
}
|
||||
|
||||
const KSession* GetParent() const {
|
||||
return parent;
|
||||
return m_parent;
|
||||
}
|
||||
|
||||
bool IsSignaled() const override;
|
||||
|
@ -66,10 +64,10 @@ private:
|
|||
void CleanupRequests();
|
||||
|
||||
/// KSession that owns this KServerSession
|
||||
KSession* parent{};
|
||||
KSession* m_parent{};
|
||||
|
||||
/// List of threads which are pending a reply.
|
||||
boost::intrusive::list<KSessionRequest> m_request_list;
|
||||
boost::intrusive::list<KSessionRequest> m_request_list{};
|
||||
KSessionRequest* m_current_request{};
|
||||
|
||||
KLightLock m_lock;
|
||||
|
|
|
@ -10,68 +10,62 @@
|
|||
namespace Kernel {
|
||||
|
||||
KSession::KSession(KernelCore& kernel_)
|
||||
: KAutoObjectWithSlabHeapAndContainer{kernel_}, server{kernel_}, client{kernel_} {}
|
||||
: KAutoObjectWithSlabHeapAndContainer{kernel_}, m_server{kernel_}, m_client{kernel_} {}
|
||||
KSession::~KSession() = default;
|
||||
|
||||
void KSession::Initialize(KClientPort* port_, const std::string& name_) {
|
||||
void KSession::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.
|
||||
Open();
|
||||
this->Open();
|
||||
|
||||
// Create our sub sessions.
|
||||
KAutoObject::Create(std::addressof(server));
|
||||
KAutoObject::Create(std::addressof(client));
|
||||
KAutoObject::Create(std::addressof(m_server));
|
||||
KAutoObject::Create(std::addressof(m_client));
|
||||
|
||||
// Initialize our sub sessions.
|
||||
server.Initialize(this, name_ + ":Server");
|
||||
client.Initialize(this, name_ + ":Client");
|
||||
m_server.Initialize(this);
|
||||
m_client.Initialize(this);
|
||||
|
||||
// Set state and name.
|
||||
SetState(State::Normal);
|
||||
name = name_;
|
||||
this->SetState(State::Normal);
|
||||
m_name = name;
|
||||
|
||||
// Set our owner process.
|
||||
//! FIXME: this is the wrong process!
|
||||
process = kernel.ApplicationProcess();
|
||||
process->Open();
|
||||
m_process = kernel.ApplicationProcess();
|
||||
m_process->Open();
|
||||
|
||||
// Set our port.
|
||||
port = port_;
|
||||
if (port != nullptr) {
|
||||
port->Open();
|
||||
m_port = client_port;
|
||||
if (m_port != nullptr) {
|
||||
m_port->Open();
|
||||
}
|
||||
|
||||
// Mark initialized.
|
||||
initialized = true;
|
||||
m_initialized = true;
|
||||
}
|
||||
|
||||
void KSession::Finalize() {
|
||||
if (port == nullptr) {
|
||||
return;
|
||||
if (m_port != nullptr) {
|
||||
m_port->OnSessionFinalized();
|
||||
m_port->Close();
|
||||
}
|
||||
|
||||
port->OnSessionFinalized();
|
||||
port->Close();
|
||||
}
|
||||
|
||||
void KSession::OnServerClosed() {
|
||||
if (GetState() != State::Normal) {
|
||||
return;
|
||||
if (this->GetState() == State::Normal) {
|
||||
this->SetState(State::ServerClosed);
|
||||
m_client.OnServerClosed();
|
||||
}
|
||||
|
||||
SetState(State::ServerClosed);
|
||||
client.OnServerClosed();
|
||||
}
|
||||
|
||||
void KSession::OnClientClosed() {
|
||||
if (GetState() != State::Normal) {
|
||||
return;
|
||||
if (this->GetState() == State::Normal) {
|
||||
SetState(State::ClientClosed);
|
||||
m_server.OnClientClosed();
|
||||
}
|
||||
|
||||
SetState(State::ClientClosed);
|
||||
server.OnClientClosed();
|
||||
}
|
||||
|
||||
void KSession::PostDestroy(uintptr_t arg) {
|
||||
|
|
|
@ -21,16 +21,15 @@ public:
|
|||
explicit KSession(KernelCore& kernel_);
|
||||
~KSession() override;
|
||||
|
||||
void Initialize(KClientPort* port_, const std::string& name_);
|
||||
|
||||
void Initialize(KClientPort* port, uintptr_t name);
|
||||
void Finalize() override;
|
||||
|
||||
bool IsInitialized() const override {
|
||||
return initialized;
|
||||
return m_initialized;
|
||||
}
|
||||
|
||||
uintptr_t GetPostDestroyArgument() const override {
|
||||
return reinterpret_cast<uintptr_t>(process);
|
||||
return reinterpret_cast<uintptr_t>(m_process);
|
||||
}
|
||||
|
||||
static void PostDestroy(uintptr_t arg);
|
||||
|
@ -48,27 +47,23 @@ public:
|
|||
}
|
||||
|
||||
KClientSession& GetClientSession() {
|
||||
return client;
|
||||
return m_client;
|
||||
}
|
||||
|
||||
KServerSession& GetServerSession() {
|
||||
return server;
|
||||
return m_server;
|
||||
}
|
||||
|
||||
const KClientSession& GetClientSession() const {
|
||||
return client;
|
||||
return m_client;
|
||||
}
|
||||
|
||||
const KServerSession& GetServerSession() const {
|
||||
return server;
|
||||
return m_server;
|
||||
}
|
||||
|
||||
const KClientPort* GetParent() const {
|
||||
return port;
|
||||
}
|
||||
|
||||
KClientPort* GetParent() {
|
||||
return port;
|
||||
return m_port;
|
||||
}
|
||||
|
||||
private:
|
||||
|
@ -80,20 +75,20 @@ private:
|
|||
};
|
||||
|
||||
void SetState(State state) {
|
||||
atomic_state = static_cast<u8>(state);
|
||||
m_atomic_state = static_cast<u8>(state);
|
||||
}
|
||||
|
||||
State GetState() const {
|
||||
return static_cast<State>(atomic_state.load(std::memory_order_relaxed));
|
||||
return static_cast<State>(m_atomic_state.load());
|
||||
}
|
||||
|
||||
KServerSession server;
|
||||
KClientSession client;
|
||||
std::atomic<std::underlying_type_t<State>> atomic_state{
|
||||
static_cast<std::underlying_type_t<State>>(State::Invalid)};
|
||||
KClientPort* port{};
|
||||
KProcess* process{};
|
||||
bool initialized{};
|
||||
KServerSession m_server;
|
||||
KClientSession m_client;
|
||||
KClientPort* m_port{};
|
||||
uintptr_t m_name{};
|
||||
KProcess* m_process{};
|
||||
std::atomic<u8> m_atomic_state{static_cast<u8>(State::Invalid)};
|
||||
bool m_initialized{};
|
||||
};
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -17,15 +17,13 @@ KSharedMemory::~KSharedMemory() = default;
|
|||
|
||||
Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
|
||||
Svc::MemoryPermission owner_permission_,
|
||||
Svc::MemoryPermission user_permission_, std::size_t size_,
|
||||
std::string name_) {
|
||||
Svc::MemoryPermission user_permission_, std::size_t size_) {
|
||||
// Set members.
|
||||
owner_process = owner_process_;
|
||||
device_memory = &device_memory_;
|
||||
owner_permission = owner_permission_;
|
||||
user_permission = user_permission_;
|
||||
size = Common::AlignUp(size_, PageSize);
|
||||
name = std::move(name_);
|
||||
|
||||
const size_t num_pages = Common::DivideUp(size, PageSize);
|
||||
|
||||
|
@ -64,7 +62,7 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* o
|
|||
std::memset(device_memory_.GetPointer<void>(block.GetAddress()), 0, block.GetSize());
|
||||
}
|
||||
|
||||
return ResultSuccess;
|
||||
R_SUCCEED();
|
||||
}
|
||||
|
||||
void KSharedMemory::Finalize() {
|
||||
|
@ -94,15 +92,15 @@ Result KSharedMemory::Map(KProcess& target_process, VAddr address, std::size_t m
|
|||
R_UNLESS(map_perm == test_perm, ResultInvalidNewMemoryPermission);
|
||||
}
|
||||
|
||||
return target_process.PageTable().MapPageGroup(address, *page_group, KMemoryState::Shared,
|
||||
ConvertToKMemoryPermission(map_perm));
|
||||
R_RETURN(target_process.PageTable().MapPageGroup(address, *page_group, KMemoryState::Shared,
|
||||
ConvertToKMemoryPermission(map_perm)));
|
||||
}
|
||||
|
||||
Result KSharedMemory::Unmap(KProcess& target_process, VAddr address, std::size_t unmap_size) {
|
||||
// Validate the size.
|
||||
R_UNLESS(size == unmap_size, ResultInvalidSize);
|
||||
|
||||
return target_process.PageTable().UnmapPageGroup(address, *page_group, KMemoryState::Shared);
|
||||
R_RETURN(target_process.PageTable().UnmapPageGroup(address, *page_group, KMemoryState::Shared));
|
||||
}
|
||||
|
||||
} // namespace Kernel
|
||||
|
|
|
@ -28,7 +28,7 @@ public:
|
|||
|
||||
Result Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
|
||||
Svc::MemoryPermission owner_permission_,
|
||||
Svc::MemoryPermission user_permission_, std::size_t size_, std::string name_);
|
||||
Svc::MemoryPermission user_permission_, std::size_t size_);
|
||||
|
||||
/**
|
||||
* Maps a shared memory block to an address in the target process' address space
|
||||
|
|
|
@ -926,6 +926,7 @@ private:
|
|||
ThreadWaitReasonForDebugging wait_reason_for_debugging{};
|
||||
uintptr_t argument{};
|
||||
VAddr stack_top{};
|
||||
std::string name{};
|
||||
|
||||
public:
|
||||
using ConditionVariableThreadTreeType = ConditionVariableThreadTree;
|
||||
|
|
|
@ -742,16 +742,15 @@ struct KernelCore::Impl {
|
|||
hidbus_shared_mem = KSharedMemory::Create(system.Kernel());
|
||||
|
||||
hid_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
|
||||
Svc::MemoryPermission::Read, hid_size, "HID:SharedMemory");
|
||||
Svc::MemoryPermission::Read, hid_size);
|
||||
font_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
|
||||
Svc::MemoryPermission::Read, font_size, "Font:SharedMemory");
|
||||
Svc::MemoryPermission::Read, font_size);
|
||||
irs_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
|
||||
Svc::MemoryPermission::Read, irs_size, "IRS:SharedMemory");
|
||||
Svc::MemoryPermission::Read, irs_size);
|
||||
time_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
|
||||
Svc::MemoryPermission::Read, time_size, "Time:SharedMemory");
|
||||
Svc::MemoryPermission::Read, time_size);
|
||||
hidbus_shared_mem->Initialize(system.DeviceMemory(), nullptr, Svc::MemoryPermission::None,
|
||||
Svc::MemoryPermission::Read, hidbus_size,
|
||||
"HidBus:SharedMemory");
|
||||
Svc::MemoryPermission::Read, hidbus_size);
|
||||
}
|
||||
|
||||
std::mutex registered_objects_lock;
|
||||
|
|
|
@ -81,7 +81,7 @@ Result ManageNamedPort(Core::System& system, Handle* out_server_handle, uint64_t
|
|||
R_UNLESS(port != nullptr, ResultOutOfResource);
|
||||
|
||||
// Initialize the new port.
|
||||
port->Initialize(max_sessions, false, "");
|
||||
port->Initialize(max_sessions, false, 0);
|
||||
|
||||
// Register the port.
|
||||
KPort::Register(system.Kernel(), port);
|
||||
|
|
|
@ -12,7 +12,7 @@ namespace Kernel::Svc {
|
|||
namespace {
|
||||
|
||||
template <typename T>
|
||||
Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, u64 name) {
|
||||
Result CreateSession(Core::System& system, Handle* out_server, Handle* out_client, uint64_t name) {
|
||||
auto& process = GetCurrentProcess(system.Kernel());
|
||||
auto& handle_table = process.GetHandleTable();
|
||||
|
||||
|
@ -59,7 +59,7 @@ Result CreateSession(Core::System& system, Handle* out_server, Handle* out_clien
|
|||
R_UNLESS(session != nullptr, ResultOutOfResource);
|
||||
|
||||
// Initialize the session.
|
||||
session->Initialize(nullptr, fmt::format("{}", name));
|
||||
session->Initialize(nullptr, name);
|
||||
|
||||
// Commit the session reservation.
|
||||
session_reservation.Commit();
|
||||
|
|
|
@ -155,7 +155,7 @@ public:
|
|||
Kernel::LimitableResource::SessionCountMax, 1);
|
||||
|
||||
auto* session = Kernel::KSession::Create(kernel);
|
||||
session->Initialize(nullptr, iface->GetServiceName());
|
||||
session->Initialize(nullptr, 0);
|
||||
|
||||
auto next_manager = std::make_shared<Service::SessionRequestManager>(
|
||||
kernel, manager->GetServerManager());
|
||||
|
|
|
@ -124,7 +124,7 @@ Result ServerManager::ManageNamedPort(const std::string& service_name,
|
|||
|
||||
// Create a new port.
|
||||
auto* port = Kernel::KPort::Create(m_system.Kernel());
|
||||
port->Initialize(max_sessions, false, service_name);
|
||||
port->Initialize(max_sessions, false, 0);
|
||||
|
||||
// Register the port.
|
||||
Kernel::KPort::Register(m_system.Kernel(), port);
|
||||
|
|
|
@ -62,7 +62,7 @@ Result ServiceManager::RegisterService(std::string name, u32 max_sessions,
|
|||
}
|
||||
|
||||
auto* port = Kernel::KPort::Create(kernel);
|
||||
port->Initialize(ServerSessionCountMax, false, name);
|
||||
port->Initialize(ServerSessionCountMax, false, 0);
|
||||
|
||||
service_ports.emplace(name, port);
|
||||
registered_services.emplace(name, handler);
|
||||
|
@ -211,7 +211,7 @@ void SM::RegisterService(HLERequestContext& ctx) {
|
|||
}
|
||||
|
||||
auto* port = Kernel::KPort::Create(kernel);
|
||||
port->Initialize(ServerSessionCountMax, is_light, name);
|
||||
port->Initialize(ServerSessionCountMax, is_light, 0);
|
||||
SCOPE_EXIT({ port->GetClientPort().Close(); });
|
||||
|
||||
IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
|
||||
|
|
|
@ -44,7 +44,7 @@ void Controller::CloneCurrentObject(HLERequestContext& ctx) {
|
|||
ASSERT(session != nullptr);
|
||||
|
||||
// Initialize the session.
|
||||
session->Initialize(nullptr, "");
|
||||
session->Initialize(nullptr, 0);
|
||||
|
||||
// Commit the session reservation.
|
||||
session_reservation.Commit();
|
||||
|
|
|
@ -182,10 +182,9 @@ bool WaitTreeExpandableItem::IsExpandable() const {
|
|||
}
|
||||
|
||||
QString WaitTreeSynchronizationObject::GetText() const {
|
||||
return tr("[%1] %2 %3")
|
||||
return tr("[%1] %2")
|
||||
.arg(object.GetId())
|
||||
.arg(QString::fromStdString(object.GetTypeObj().GetName()),
|
||||
QString::fromStdString(object.GetName()));
|
||||
.arg(QString::fromStdString(object.GetTypeObj().GetName()));
|
||||
}
|
||||
|
||||
std::unique_ptr<WaitTreeSynchronizationObject> WaitTreeSynchronizationObject::make(
|
||||
|
|
Reference in New Issue