kernel: convert KPort, KSession

src/core/hle/kernel/k_affinity_mask.h

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

src/core/hle/kernel/k_auto_object.h

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

src/core/hle/kernel/k_capabilities.cpp

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

src/core/hle/kernel/k_capabilities.h

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

src/core/hle/kernel/k_client_port.cpp

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

src/core/hle/kernel/k_client_port.h

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

src/core/hle/kernel/k_client_session.cpp

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

src/core/hle/kernel/k_client_session.h

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

src/core/hle/kernel/k_port.cpp

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

src/core/hle/kernel/k_port.h

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

src/core/hle/kernel/k_process.h

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

src/core/hle/kernel/k_server_port.cpp

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

src/core/hle/kernel/k_server_port.h

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

src/core/hle/kernel/k_server_session.cpp

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

src/core/hle/kernel/k_server_session.h

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

src/core/hle/kernel/k_session.cpp

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

src/core/hle/kernel/k_session.h

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

src/core/hle/kernel/k_shared_memory.cpp

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

src/core/hle/kernel/k_shared_memory.h

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

src/core/hle/kernel/k_thread.h

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

src/core/hle/kernel/kernel.cpp

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

src/core/hle/kernel/svc/svc_port.cpp

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

src/core/hle/kernel/svc/svc_session.cpp

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

src/core/hle/service/ipc_helpers.h

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

src/core/hle/service/server_manager.cpp

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

src/core/hle/service/sm/sm.cpp

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

src/core/hle/service/sm/sm_controller.cpp

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

src/yuzu/debugger/wait_tree.cpp

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