yuzu-emu
/
yuzu-android
Archived
1
0
Fork 0
Code

kernel: convert KPort, KSession

This commit is contained in:
Liam 2023-03-06 20:34:25 -05:00
parent d24ab14126
commit 097c25b164
28 changed files with 196 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/core/hle/kernel/k_affinity_mask.h
View File

@ -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

9
src/core/hle/kernel/k_auto_object.h
View File

@ -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;
};

2
src/core/hle/kernel/k_capabilities.cpp
View File

@ -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();

2
src/core/hle/kernel/k_capabilities.h
View File

@ -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);

73
src/core/hle/kernel/k_client_port.cpp
View File

@ -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

23
src/core/hle/kernel/k_client_port.h
View File

@ -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

6
src/core/hle/kernel/k_client_session.cpp
View File

@ -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

11
src/core/hle/kernel/k_client_session.h
View File

@ -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

37
src/core/hle/kernel/k_port.cpp
View File

@ -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

26
src/core/hle/kernel/k_port.h
View File

@ -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

6
src/core/hle/kernel/k_process.h
View File

@ -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{};

27
src/core/hle/kernel/k_server_port.cpp
View File

@ -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;
}

10
src/core/hle/kernel/k_server_port.h
View File

@ -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

18
src/core/hle/kernel/k_server_session.cpp
View File

@ -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);

12
src/core/hle/kernel/k_server_session.h
View File

@ -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;

54
src/core/hle/kernel/k_session.cpp
View File

@ -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) {

39
src/core/hle/kernel/k_session.h
View File

@ -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

12
src/core/hle/kernel/k_shared_memory.cpp
View File

@ -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

2
src/core/hle/kernel/k_shared_memory.h
View File

@ -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

1
src/core/hle/kernel/k_thread.h
View File

@ -926,6 +926,7 @@ private:
ThreadWaitReasonForDebugging wait_reason_for_debugging{};
uintptr_t argument{};
VAddr stack_top{};
std::string name{};
public:
using ConditionVariableThreadTreeType = ConditionVariableThreadTree;

11
src/core/hle/kernel/kernel.cpp
View File

@ -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;

2
src/core/hle/kernel/svc/svc_port.cpp
View File

@ -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);

4
src/core/hle/kernel/svc/svc_session.cpp
View File

@ -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();

2
src/core/hle/service/ipc_helpers.h
View File

@ -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());

2
src/core/hle/service/server_manager.cpp
View File

@ -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);

4
src/core/hle/service/sm/sm.cpp
View File

@ -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};

2
src/core/hle/service/sm/sm_controller.cpp
View File

@ -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();

5
src/yuzu/debugger/wait_tree.cpp
View File

@ -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(