VERY experimental Nintendo Switch 2 emulator
C++
kernel: remove kernel_
Liamcf0b407daa18
diff --git a/src/core/hle/kernel/k_auto_object.cpp b/src/core/hle/kernel/k_auto_object.cppindex 691af8ccb3..0ae42c95cb 100644--- a/src/core/hle/kernel/k_auto_object.cpp+++ b/src/core/hle/kernel/k_auto_object.cpp@@ -12,11 +12,11 @@ KAutoObject* KAutoObject::Create(KAutoObject* obj) {}void KAutoObject::RegisterWithKernel() {- kernel.RegisterKernelObject(this);+ m_kernel.RegisterKernelObject(this);}void KAutoObject::UnregisterWithKernel() {- kernel.UnregisterKernelObject(this);+ m_kernel.UnregisterKernelObject(this);}} // namespace Kerneldiff --git a/src/core/hle/kernel/k_auto_object.h b/src/core/hle/kernel/k_auto_object.hindex 2443ab2a55..edb9cf071b 100644--- a/src/core/hle/kernel/k_auto_object.h+++ b/src/core/hle/kernel/k_auto_object.h@@ -80,7 +80,7 @@ private:KERNEL_AUTOOBJECT_TRAITS_IMPL(KAutoObject, KAutoObject, const);public:- explicit KAutoObject(KernelCore& kernel_) : kernel(kernel_) {+ explicit KAutoObject(KernelCore& kernel) : m_kernel(kernel) {RegisterWithKernel();}virtual ~KAutoObject() = default;@@ -169,7 +169,7 @@ private:void UnregisterWithKernel();protected:- KernelCore& kernel;+ KernelCore& m_kernel;private:std::atomic<u32> m_ref_count{};@@ -179,7 +179,7 @@ class KAutoObjectWithListContainer;class KAutoObjectWithList : public KAutoObject, public boost::intrusive::set_base_hook<> {public:- explicit KAutoObjectWithList(KernelCore& kernel_) : KAutoObject(kernel_) {}+ explicit KAutoObjectWithList(KernelCore& kernel) : KAutoObject(kernel) {}static int Compare(const KAutoObjectWithList& lhs, const KAutoObjectWithList& rhs) {const u64 lid = lhs.GetId();diff --git a/src/core/hle/kernel/k_client_port.cpp b/src/core/hle/kernel/k_client_port.cppindex 7a3d650fdf..40e09e5325 100644--- a/src/core/hle/kernel/k_client_port.cpp+++ b/src/core/hle/kernel/k_client_port.cpp@@ -11,7 +11,7 @@namespace Kernel {-KClientPort::KClientPort(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}+KClientPort::KClientPort(KernelCore& kernel) : KSynchronizationObject{kernel} {}KClientPort::~KClientPort() = default;void KClientPort::Initialize(KPort* parent, s32 max_sessions) {@@ -23,7 +23,7 @@ void KClientPort::Initialize(KPort* parent, s32 max_sessions) {}void KClientPort::OnSessionFinalized() {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};if (const auto prev = m_num_sessions--; prev == m_max_sessions) {this->NotifyAvailable();@@ -58,12 +58,12 @@ Result KClientPort::CreateSession(KClientSession** out) {// 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);+ KScopedResourceReservation session_reservation(+ m_kernel.ApplicationProcess()->GetResourceLimit(), LimitableResource::SessionCountMax);R_UNLESS(session_reservation.Succeeded(), ResultLimitReached);// Allocate a session normally.- session = KSession::Create(kernel);+ session = KSession::Create(m_kernel);// Check that we successfully created a session.R_UNLESS(session != nullptr, ResultOutOfResource);@@ -105,7 +105,7 @@ Result KClientPort::CreateSession(KClientSession** out) {session_reservation.Commit();// Register the session.- KSession::Register(kernel, session);+ KSession::Register(m_kernel, session);ON_RESULT_FAILURE {session->GetClientSession().Close();session->GetServerSession().Close();diff --git a/src/core/hle/kernel/k_client_session.cpp b/src/core/hle/kernel/k_client_session.cppindex c9196d04b0..62a8fab454 100644--- a/src/core/hle/kernel/k_client_session.cpp+++ b/src/core/hle/kernel/k_client_session.cpp@@ -12,8 +12,7 @@ namespace Kernel {static constexpr u32 MessageBufferSize = 0x100;-KClientSession::KClientSession(KernelCore& kernel_)- : KAutoObjectWithSlabHeapAndContainer{kernel_} {}+KClientSession::KClientSession(KernelCore& kernel) : KAutoObjectWithSlabHeapAndContainer{kernel} {}KClientSession::~KClientSession() = default;void KClientSession::Destroy() {@@ -25,12 +24,12 @@ void KClientSession::OnServerClosed() {}Result KClientSession::SendSyncRequest() {// Create a session request.- KSessionRequest* request = KSessionRequest::Create(kernel);+ KSessionRequest* request = KSessionRequest::Create(m_kernel);R_UNLESS(request != nullptr, ResultOutOfResource);SCOPE_EXIT({ request->Close(); });// Initialize the request.- request->Initialize(nullptr, GetCurrentThread(kernel).GetTLSAddress(), MessageBufferSize);+ request->Initialize(nullptr, GetCurrentThread(m_kernel).GetTLSAddress(), MessageBufferSize);// Send the request.R_RETURN(m_parent->GetServerSession().OnRequest(request));diff --git a/src/core/hle/kernel/k_client_session.h b/src/core/hle/kernel/k_client_session.hindex ecde2549c8..9b62e55e45 100644--- a/src/core/hle/kernel/k_client_session.h+++ b/src/core/hle/kernel/k_client_session.h@@ -30,7 +30,7 @@ class KClientSession finalKERNEL_AUTOOBJECT_TRAITS(KClientSession, KAutoObject);public:- explicit KClientSession(KernelCore& kernel_);+ explicit KClientSession(KernelCore& kernel);~KClientSession() override;void Initialize(KSession* parent) {diff --git a/src/core/hle/kernel/k_code_memory.cpp b/src/core/hle/kernel/k_code_memory.cppindex 4167ade2b5..89df6b5d88 100644--- a/src/core/hle/kernel/k_code_memory.cpp+++ b/src/core/hle/kernel/k_code_memory.cpp@@ -16,18 +16,18 @@namespace Kernel {-KCodeMemory::KCodeMemory(KernelCore& kernel_)- : KAutoObjectWithSlabHeapAndContainer{kernel_}, m_lock(kernel_) {}+KCodeMemory::KCodeMemory(KernelCore& kernel)+ : KAutoObjectWithSlabHeapAndContainer{kernel}, m_lock(kernel) {}Result KCodeMemory::Initialize(Core::DeviceMemory& device_memory, VAddr addr, size_t size) {// Set members.- m_owner = GetCurrentProcessPointer(kernel);+ m_owner = GetCurrentProcessPointer(m_kernel);// Get the owner page table.auto& page_table = m_owner->PageTable();// Construct the page group.- m_page_group.emplace(kernel, page_table.GetBlockInfoManager());+ m_page_group.emplace(m_kernel, page_table.GetBlockInfoManager());// Lock the memory.R_TRY(page_table.LockForCodeMemory(std::addressof(*m_page_group), addr, size))@@ -74,7 +74,7 @@ Result KCodeMemory::Map(VAddr address, size_t size) {R_UNLESS(!m_is_mapped, ResultInvalidState);// Map the memory.- R_TRY(GetCurrentProcess(kernel).PageTable().MapPageGroup(+ R_TRY(GetCurrentProcess(m_kernel).PageTable().MapPageGroup(address, *m_page_group, KMemoryState::CodeOut, KMemoryPermission::UserReadWrite));// Mark ourselves as mapped.@@ -91,8 +91,8 @@ Result KCodeMemory::Unmap(VAddr address, size_t size) {KScopedLightLock lk(m_lock);// Unmap the memory.- R_TRY(GetCurrentProcess(kernel).PageTable().UnmapPageGroup(address, *m_page_group,- KMemoryState::CodeOut));+ R_TRY(GetCurrentProcess(m_kernel).PageTable().UnmapPageGroup(address, *m_page_group,+ KMemoryState::CodeOut));// Mark ourselves as unmapped.m_is_mapped = false;diff --git a/src/core/hle/kernel/k_code_memory.h b/src/core/hle/kernel/k_code_memory.hindex fa63c18df4..23cbb283b4 100644--- a/src/core/hle/kernel/k_code_memory.h+++ b/src/core/hle/kernel/k_code_memory.h@@ -29,7 +29,7 @@ class KCodeMemory finalKERNEL_AUTOOBJECT_TRAITS(KCodeMemory, KAutoObject);public:- explicit KCodeMemory(KernelCore& kernel_);+ explicit KCodeMemory(KernelCore& kernel);Result Initialize(Core::DeviceMemory& device_memory, VAddr address, size_t size);void Finalize() override;diff --git a/src/core/hle/kernel/k_condition_variable.cpp b/src/core/hle/kernel/k_condition_variable.cppindex 0dc01f6aae..067f26fba3 100644--- a/src/core/hle/kernel/k_condition_variable.cpp+++ b/src/core/hle/kernel/k_condition_variable.cpp@@ -57,8 +57,8 @@ bool UpdateLockAtomic(Core::System& system, u32* out, VAddr address, u32 if_zeroclass ThreadQueueImplForKConditionVariableWaitForAddress final : public KThreadQueue {public:- explicit ThreadQueueImplForKConditionVariableWaitForAddress(KernelCore& kernel_)- : KThreadQueue(kernel_) {}+ explicit ThreadQueueImplForKConditionVariableWaitForAddress(KernelCore& kernel)+ : KThreadQueue(kernel) {}void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) override {// Remove the thread as a waiter from its owner.@@ -75,8 +75,8 @@ private:public:explicit ThreadQueueImplForKConditionVariableWaitConditionVariable(- KernelCore& kernel_, KConditionVariable::ThreadTree* t)- : KThreadQueue(kernel_), m_tree(t) {}+ KernelCore& kernel, KConditionVariable::ThreadTree* t)+ : KThreadQueue(kernel), m_tree(t) {}void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) override {// Remove the thread as a waiter from its owner.diff --git a/src/core/hle/kernel/k_debug.h b/src/core/hle/kernel/k_debug.hindex 9ffcf27d14..2290e3bcab 100644--- a/src/core/hle/kernel/k_debug.h+++ b/src/core/hle/kernel/k_debug.h@@ -12,7 +12,7 @@ class KDebug final : public KAutoObjectWithSlabHeapAndContainer<KDebug, KAutoObjKERNEL_AUTOOBJECT_TRAITS(KDebug, KAutoObject);public:- explicit KDebug(KernelCore& kernel_) : KAutoObjectWithSlabHeapAndContainer{kernel_} {}+ explicit KDebug(KernelCore& kernel) : KAutoObjectWithSlabHeapAndContainer{kernel} {}static void PostDestroy(uintptr_t arg) {}};diff --git a/src/core/hle/kernel/k_device_address_space.cpp b/src/core/hle/kernel/k_device_address_space.cppindex 27659ea3b4..a2fc4fe1f1 100644--- a/src/core/hle/kernel/k_device_address_space.cpp+++ b/src/core/hle/kernel/k_device_address_space.cpp@@ -9,8 +9,8 @@namespace Kernel {-KDeviceAddressSpace::KDeviceAddressSpace(KernelCore& kernel_)- : KAutoObjectWithSlabHeapAndContainer(kernel_), m_lock(kernel_), m_is_initialized(false) {}+KDeviceAddressSpace::KDeviceAddressSpace(KernelCore& kernel)+ : KAutoObjectWithSlabHeapAndContainer(kernel), m_lock(kernel), m_is_initialized(false) {}KDeviceAddressSpace::~KDeviceAddressSpace() = default;void KDeviceAddressSpace::Initialize() {diff --git a/src/core/hle/kernel/k_event.cpp b/src/core/hle/kernel/k_event.cppindex d973853abf..d92b491f8b 100644--- a/src/core/hle/kernel/k_event.cpp+++ b/src/core/hle/kernel/k_event.cpp@@ -7,8 +7,8 @@namespace Kernel {-KEvent::KEvent(KernelCore& kernel_)- : KAutoObjectWithSlabHeapAndContainer{kernel_}, m_readable_event{kernel_} {}+KEvent::KEvent(KernelCore& kernel)+ : KAutoObjectWithSlabHeapAndContainer{kernel}, m_readable_event{kernel} {}KEvent::~KEvent() = default;@@ -36,7 +36,7 @@ void KEvent::Finalize() {}Result KEvent::Signal() {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};R_SUCCEED_IF(m_readable_event_destroyed);@@ -44,7 +44,7 @@ Result KEvent::Signal() {}Result KEvent::Clear() {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};R_SUCCEED_IF(m_readable_event_destroyed);diff --git a/src/core/hle/kernel/k_event.h b/src/core/hle/kernel/k_event.hindex 48ce7d9a06..f522b0a84c 100644--- a/src/core/hle/kernel/k_event.h+++ b/src/core/hle/kernel/k_event.h@@ -16,7 +16,7 @@ class KEvent final : public KAutoObjectWithSlabHeapAndContainer<KEvent, KAutoObjKERNEL_AUTOOBJECT_TRAITS(KEvent, KAutoObject);public:- explicit KEvent(KernelCore& kernel_);+ explicit KEvent(KernelCore& kernel);~KEvent() override;void Initialize(KProcess* owner);diff --git a/src/core/hle/kernel/k_port.cpp b/src/core/hle/kernel/k_port.cppindex f73bc34d47..1621ca1d38 100644--- a/src/core/hle/kernel/k_port.cpp+++ b/src/core/hle/kernel/k_port.cpp@@ -7,8 +7,8 @@namespace Kernel {-KPort::KPort(KernelCore& kernel_)- : KAutoObjectWithSlabHeapAndContainer{kernel_}, m_server{kernel_}, m_client{kernel_} {}+KPort::KPort(KernelCore& kernel)+ : KAutoObjectWithSlabHeapAndContainer{kernel}, m_server{kernel}, m_client{kernel} {}KPort::~KPort() = default;@@ -29,7 +29,7 @@ void KPort::Initialize(s32 max_sessions, bool is_light, uintptr_t name) {}void KPort::OnClientClosed() {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};if (m_state == State::Normal) {m_state = State::ClientClosed;@@ -37,7 +37,7 @@ void KPort::OnClientClosed() {}void KPort::OnServerClosed() {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};if (m_state == State::Normal) {m_state = State::ServerClosed;@@ -45,12 +45,12 @@ void KPort::OnServerClosed() {}bool KPort::IsServerClosed() const {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};return m_state == State::ServerClosed;}Result KPort::EnqueueSession(KServerSession* session) {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};R_UNLESS(m_state == State::Normal, ResultPortClosed);diff --git a/src/core/hle/kernel/k_port.h b/src/core/hle/kernel/k_port.hindex f2a08547c5..991be27ab9 100644--- a/src/core/hle/kernel/k_port.h+++ b/src/core/hle/kernel/k_port.h@@ -19,7 +19,7 @@ class KPort final : public KAutoObjectWithSlabHeapAndContainer<KPort, KAutoObjecKERNEL_AUTOOBJECT_TRAITS(KPort, KAutoObject);public:- explicit KPort(KernelCore& kernel_);+ explicit KPort(KernelCore& kernel);~KPort() override;static void PostDestroy(uintptr_t arg) {}diff --git a/src/core/hle/kernel/k_process.cpp b/src/core/hle/kernel/k_process.cppindex 74a04aa66d..4954a40db3 100644--- a/src/core/hle/kernel/k_process.cpp+++ b/src/core/hle/kernel/k_process.cpp@@ -126,7 +126,7 @@ u64 KProcess::GetTotalPhysicalMemoryAvailable() {const u64 capacity{resource_limit->GetFreeValue(LimitableResource::PhysicalMemoryMax) +page_table.GetNormalMemorySize() + GetSystemResourceSize() + image_size +main_thread_stack_size};- if (const auto pool_size = kernel.MemoryManager().GetSize(KMemoryManager::Pool::Application);+ if (const auto pool_size = m_kernel.MemoryManager().GetSize(KMemoryManager::Pool::Application);capacity != pool_size) {LOG_WARNING(Kernel, "capacity {} != application pool size {}", capacity, pool_size);}@@ -150,7 +150,7 @@ u64 KProcess::GetTotalPhysicalMemoryUsedWithoutSystemResource() {}bool KProcess::ReleaseUserException(KThread* thread) {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};if (exception_thread == thread) {exception_thread = nullptr;@@ -164,7 +164,7 @@ bool KProcess::ReleaseUserException(KThread* thread) {next->EndWait(ResultSuccess);}- KScheduler::SetSchedulerUpdateNeeded(kernel);+ KScheduler::SetSchedulerUpdateNeeded(m_kernel);return true;} else {@@ -173,11 +173,11 @@ bool KProcess::ReleaseUserException(KThread* thread) {}void KProcess::PinCurrentThread(s32 core_id) {- ASSERT(kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(m_kernel.GlobalSchedulerContext().IsLocked());// Get the current thread.KThread* cur_thread =- kernel.Scheduler(static_cast<std::size_t>(core_id)).GetSchedulerCurrentThread();+ m_kernel.Scheduler(static_cast<std::size_t>(core_id)).GetSchedulerCurrentThread();// If the thread isn't terminated, pin it.if (!cur_thread->IsTerminationRequested()) {@@ -186,27 +186,27 @@ void KProcess::PinCurrentThread(s32 core_id) {cur_thread->Pin(core_id);// An update is needed.- KScheduler::SetSchedulerUpdateNeeded(kernel);+ KScheduler::SetSchedulerUpdateNeeded(m_kernel);}}void KProcess::UnpinCurrentThread(s32 core_id) {- ASSERT(kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(m_kernel.GlobalSchedulerContext().IsLocked());// Get the current thread.KThread* cur_thread =- kernel.Scheduler(static_cast<std::size_t>(core_id)).GetSchedulerCurrentThread();+ m_kernel.Scheduler(static_cast<std::size_t>(core_id)).GetSchedulerCurrentThread();// Unpin it.cur_thread->Unpin();UnpinThread(core_id, cur_thread);// An update is needed.- KScheduler::SetSchedulerUpdateNeeded(kernel);+ KScheduler::SetSchedulerUpdateNeeded(m_kernel);}void KProcess::UnpinThread(KThread* thread) {- ASSERT(kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(m_kernel.GlobalSchedulerContext().IsLocked());// Get the thread's core id.const auto core_id = thread->GetActiveCore();@@ -216,7 +216,7 @@ void KProcess::UnpinThread(KThread* thread) {thread->Unpin();// An update is needed.- KScheduler::SetSchedulerUpdateNeeded(kernel);+ KScheduler::SetSchedulerUpdateNeeded(m_kernel);}Result KProcess::AddSharedMemory(KSharedMemory* shmem, [[maybe_unused]] VAddr address,@@ -234,7 +234,7 @@ Result KProcess::AddSharedMemory(KSharedMemory* shmem, [[maybe_unused]] VAddr ad}if (shemen_info == nullptr) {- shemen_info = KSharedMemoryInfo::Allocate(kernel);+ shemen_info = KSharedMemoryInfo::Allocate(m_kernel);R_UNLESS(shemen_info != nullptr, ResultOutOfMemory);shemen_info->Initialize(shmem);@@ -265,7 +265,7 @@ void KProcess::RemoveSharedMemory(KSharedMemory* shmem, [[maybe_unused]] VAddr aif (shemen_info->Close()) {shared_memory_list.erase(iter);- KSharedMemoryInfo::Free(kernel, shemen_info);+ KSharedMemoryInfo::Free(m_kernel, shemen_info);}// Close a reference to the shared memory.@@ -298,7 +298,7 @@ u64 KProcess::GetFreeThreadCount() const {Result KProcess::Reset() {// Lock the process and the scheduler.KScopedLightLock lk(state_lock);- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Validate that we're in a state that we can reset.R_UNLESS(state != State::Terminated, ResultInvalidState);@@ -313,7 +313,7 @@ Result KProcess::SetActivity(ProcessActivity activity) {// Lock ourselves and the scheduler.KScopedLightLock lk{state_lock};KScopedLightLock list_lk{list_lock};- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Validate our state.R_UNLESS(state != State::Terminating, ResultInvalidState);@@ -366,7 +366,7 @@ Result KProcess::LoadFromMetadata(const FileSys::ProgramMetadata& metadata, std:// Initialize process address spaceif (const Result result{page_table.InitializeForProcess(metadata.GetAddressSpaceType(), false, false, false, KMemoryManager::Pool::Application,- 0x8000000, code_size, &kernel.GetAppSystemResource(), resource_limit)};+ 0x8000000, code_size, &m_kernel.GetAppSystemResource(), resource_limit)};result.IsError()) {R_RETURN(result);}@@ -421,7 +421,7 @@ void KProcess::Run(s32 main_thread_priority, u64 stack_size) {ChangeState(State::Running);- SetupMainThread(kernel.System(), *this, main_thread_priority, main_thread_stack_top);+ SetupMainThread(m_kernel.System(), *this, main_thread_priority, main_thread_stack_top);}void KProcess::PrepareForTermination() {@@ -432,7 +432,7 @@ void KProcess::PrepareForTermination() {if (thread->GetOwnerProcess() != this)continue;- if (thread == GetCurrentThreadPointer(kernel))+ if (thread == GetCurrentThreadPointer(m_kernel))continue;// TODO(Subv): When are the other running/ready threads terminated?@@ -443,7 +443,7 @@ void KProcess::PrepareForTermination() {}};- stop_threads(kernel.System().GlobalSchedulerContext().GetThreadList());+ stop_threads(m_kernel.System().GlobalSchedulerContext().GetThreadList());this->DeleteThreadLocalRegion(plr_address);plr_address = 0;@@ -471,7 +471,7 @@ void KProcess::Finalize() {shmem->Close();it = shared_memory_list.erase(it);- KSharedMemoryInfo::Free(kernel, info);+ KSharedMemoryInfo::Free(m_kernel, info);}}@@ -494,7 +494,7 @@ Result KProcess::CreateThreadLocalRegion(VAddr* out) {// See if we can get a region from a partially used TLP.{- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};if (auto it = partially_used_tlp_tree.begin(); it != partially_used_tlp_tree.end()) {tlr = it->Reserve();@@ -512,12 +512,12 @@ Result KProcess::CreateThreadLocalRegion(VAddr* out) {}// Allocate a new page.- tlp = KThreadLocalPage::Allocate(kernel);+ tlp = KThreadLocalPage::Allocate(m_kernel);R_UNLESS(tlp != nullptr, ResultOutOfMemory);- auto tlp_guard = SCOPE_GUARD({ KThreadLocalPage::Free(kernel, tlp); });+ auto tlp_guard = SCOPE_GUARD({ KThreadLocalPage::Free(m_kernel, tlp); });// Initialize the new page.- R_TRY(tlp->Initialize(kernel, this));+ R_TRY(tlp->Initialize(m_kernel, this));// Reserve a TLR.tlr = tlp->Reserve();@@ -525,7 +525,7 @@ Result KProcess::CreateThreadLocalRegion(VAddr* out) {// Insert into our tree.{- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};if (tlp->IsAllUsed()) {fully_used_tlp_tree.insert(*tlp);} else {@@ -544,7 +544,7 @@ Result KProcess::DeleteThreadLocalRegion(VAddr addr) {// Release the region.{- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Try to find the page in the partially used list.auto it = partially_used_tlp_tree.find_key(Common::AlignDown(addr, PageSize));@@ -581,7 +581,7 @@ Result KProcess::DeleteThreadLocalRegion(VAddr addr) {if (page_to_free != nullptr) {page_to_free->Finalize();- KThreadLocalPage::Free(kernel, page_to_free);+ KThreadLocalPage::Free(m_kernel, page_to_free);}R_SUCCEED();@@ -639,8 +639,8 @@ void KProcess::LoadModule(CodeSet code_set, VAddr base_addr) {page_table.SetProcessMemoryPermission(segment.addr + base_addr, segment.size, permission);};- kernel.System().Memory().WriteBlock(*this, base_addr, code_set.memory.data(),- code_set.memory.size());+ m_kernel.System().Memory().WriteBlock(*this, base_addr, code_set.memory.data(),+ code_set.memory.size());ReprotectSegment(code_set.CodeSegment(), Svc::MemoryPermission::ReadExecute);ReprotectSegment(code_set.RODataSegment(), Svc::MemoryPermission::Read);@@ -648,14 +648,14 @@ void KProcess::LoadModule(CodeSet code_set, VAddr base_addr) {}bool KProcess::IsSignaled() const {- ASSERT(kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(m_kernel.GlobalSchedulerContext().IsLocked());return is_signaled;}-KProcess::KProcess(KernelCore& kernel_)- : KAutoObjectWithSlabHeapAndContainer{kernel_}, page_table{kernel_.System()},- handle_table{kernel_}, address_arbiter{kernel_.System()}, condition_var{kernel_.System()},- state_lock{kernel_}, list_lock{kernel_} {}+KProcess::KProcess(KernelCore& kernel)+ : KAutoObjectWithSlabHeapAndContainer{kernel}, page_table{m_kernel.System()},+ handle_table{m_kernel}, address_arbiter{m_kernel.System()}, condition_var{m_kernel.System()},+ state_lock{m_kernel}, list_lock{m_kernel} {}KProcess::~KProcess() = default;diff --git a/src/core/hle/kernel/k_process.h b/src/core/hle/kernel/k_process.hindex 8d65be17a7..a19d9b09d3 100644--- a/src/core/hle/kernel/k_process.h+++ b/src/core/hle/kernel/k_process.h@@ -68,7 +68,7 @@ class KProcess final : public KAutoObjectWithSlabHeapAndContainer<KProcess, KWorKERNEL_AUTOOBJECT_TRAITS(KProcess, KSynchronizationObject);public:- explicit KProcess(KernelCore& kernel_);+ explicit KProcess(KernelCore& kernel);~KProcess() override;enum class State {diff --git a/src/core/hle/kernel/k_readable_event.cpp b/src/core/hle/kernel/k_readable_event.cppindex eeac678e4a..c30662666b 100644--- a/src/core/hle/kernel/k_readable_event.cpp+++ b/src/core/hle/kernel/k_readable_event.cpp@@ -11,7 +11,7 @@namespace Kernel {-KReadableEvent::KReadableEvent(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}+KReadableEvent::KReadableEvent(KernelCore& kernel) : KSynchronizationObject{kernel} {}KReadableEvent::~KReadableEvent() = default;@@ -25,7 +25,7 @@ void KReadableEvent::Initialize(KEvent* parent) {}bool KReadableEvent::IsSignaled() const {- ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(kernel));+ ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));return m_is_signaled;}@@ -33,7 +33,7 @@ bool KReadableEvent::IsSignaled() const {void KReadableEvent::Destroy() {if (m_parent) {{- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};m_parent->OnReadableEventDestroyed();}m_parent->Close();@@ -41,7 +41,7 @@ void KReadableEvent::Destroy() {}Result KReadableEvent::Signal() {- KScopedSchedulerLock lk{kernel};+ KScopedSchedulerLock lk{m_kernel};if (!m_is_signaled) {m_is_signaled = true;@@ -58,7 +58,7 @@ Result KReadableEvent::Clear() {}Result KReadableEvent::Reset() {- KScopedSchedulerLock lk{kernel};+ KScopedSchedulerLock lk{m_kernel};R_UNLESS(m_is_signaled, ResultInvalidState);diff --git a/src/core/hle/kernel/k_readable_event.h b/src/core/hle/kernel/k_readable_event.hindex 743f96bf59..d2ec363233 100644--- a/src/core/hle/kernel/k_readable_event.h+++ b/src/core/hle/kernel/k_readable_event.h@@ -17,7 +17,7 @@ class KReadableEvent : public KSynchronizationObject {KERNEL_AUTOOBJECT_TRAITS(KReadableEvent, KSynchronizationObject);public:- explicit KReadableEvent(KernelCore& kernel_);+ explicit KReadableEvent(KernelCore& kernel);~KReadableEvent() override;void Initialize(KEvent* parent);diff --git a/src/core/hle/kernel/k_resource_limit.cpp b/src/core/hle/kernel/k_resource_limit.cppindex 2847da2919..e224e16227 100644--- a/src/core/hle/kernel/k_resource_limit.cpp+++ b/src/core/hle/kernel/k_resource_limit.cpp@@ -11,8 +11,8 @@namespace Kernel {constexpr s64 DefaultTimeout = 10000000000; // 10 seconds-KResourceLimit::KResourceLimit(KernelCore& kernel_)- : KAutoObjectWithSlabHeapAndContainer{kernel_}, lock{kernel_}, cond_var{kernel_} {}+KResourceLimit::KResourceLimit(KernelCore& kernel)+ : KAutoObjectWithSlabHeapAndContainer{kernel}, lock{kernel}, cond_var{kernel} {}KResourceLimit::~KResourceLimit() = default;void KResourceLimit::Initialize(const Core::Timing::CoreTiming* core_timing_) {diff --git a/src/core/hle/kernel/k_scheduler.cpp b/src/core/hle/kernel/k_scheduler.cppindex d6c214237e..b631ec4068 100644--- a/src/core/hle/kernel/k_scheduler.cpp+++ b/src/core/hle/kernel/k_scheduler.cpp@@ -27,7 +27,7 @@ static void IncrementScheduledCount(Kernel::KThread* thread) {}}-KScheduler::KScheduler(KernelCore& kernel_) : kernel{kernel_} {+KScheduler::KScheduler(KernelCore& kernel) : m_kernel{kernel} {m_switch_fiber = std::make_shared<Common::Fiber>([this] {while (true) {ScheduleImplFiber();@@ -47,7 +47,7 @@ void KScheduler::SetInterruptTaskRunnable() {void KScheduler::RequestScheduleOnInterrupt() {m_state.needs_scheduling = true;- if (CanSchedule(kernel)) {+ if (CanSchedule(m_kernel)) {ScheduleOnInterrupt();}}@@ -97,50 +97,50 @@ u64 KScheduler::UpdateHighestPriorityThreads(KernelCore& kernel) {}void KScheduler::Schedule() {- ASSERT(GetCurrentThread(kernel).GetDisableDispatchCount() == 1);- ASSERT(m_core_id == GetCurrentCoreId(kernel));+ ASSERT(GetCurrentThread(m_kernel).GetDisableDispatchCount() == 1);+ ASSERT(m_core_id == GetCurrentCoreId(m_kernel));ScheduleImpl();}void KScheduler::ScheduleOnInterrupt() {- GetCurrentThread(kernel).DisableDispatch();+ GetCurrentThread(m_kernel).DisableDispatch();Schedule();- GetCurrentThread(kernel).EnableDispatch();+ GetCurrentThread(m_kernel).EnableDispatch();}void KScheduler::PreemptSingleCore() {- GetCurrentThread(kernel).DisableDispatch();+ GetCurrentThread(m_kernel).DisableDispatch();- auto* thread = GetCurrentThreadPointer(kernel);- auto& previous_scheduler = kernel.Scheduler(thread->GetCurrentCore());+ auto* thread = GetCurrentThreadPointer(m_kernel);+ auto& previous_scheduler = m_kernel.Scheduler(thread->GetCurrentCore());previous_scheduler.Unload(thread);Common::Fiber::YieldTo(thread->GetHostContext(), *m_switch_fiber);- GetCurrentThread(kernel).EnableDispatch();+ GetCurrentThread(m_kernel).EnableDispatch();}void KScheduler::RescheduleCurrentCore() {- ASSERT(!kernel.IsPhantomModeForSingleCore());- ASSERT(GetCurrentThread(kernel).GetDisableDispatchCount() == 1);+ ASSERT(!m_kernel.IsPhantomModeForSingleCore());+ ASSERT(GetCurrentThread(m_kernel).GetDisableDispatchCount() == 1);- GetCurrentThread(kernel).EnableDispatch();+ GetCurrentThread(m_kernel).EnableDispatch();if (m_state.needs_scheduling.load()) {// Disable interrupts, and then check again if rescheduling is needed.// KScopedInterruptDisable intr_disable;- kernel.CurrentScheduler()->RescheduleCurrentCoreImpl();+ m_kernel.CurrentScheduler()->RescheduleCurrentCoreImpl();}}void KScheduler::RescheduleCurrentCoreImpl() {// Check that scheduling is needed.if (m_state.needs_scheduling.load()) [[likely]] {- GetCurrentThread(kernel).DisableDispatch();+ GetCurrentThread(m_kernel).DisableDispatch();Schedule();- GetCurrentThread(kernel).EnableDispatch();+ GetCurrentThread(m_kernel).EnableDispatch();}}@@ -153,14 +153,14 @@ void KScheduler::Initialize(KThread* main_thread, KThread* idle_thread, s32 core// Insert the main thread into the priority queue.// {- // KScopedSchedulerLock lk{kernel};- // GetPriorityQueue(kernel).PushBack(GetCurrentThreadPointer(kernel));- // SetSchedulerUpdateNeeded(kernel);+ // KScopedSchedulerLock lk{m_kernel};+ // GetPriorityQueue(m_kernel).PushBack(GetCurrentThreadPointer(m_kernel));+ // SetSchedulerUpdateNeeded(m_kernel);// }// Bind interrupt handler.// kernel.GetInterruptManager().BindHandler(- // GetSchedulerInterruptHandler(kernel), KInterruptName::Scheduler, m_core_id,+ // GetSchedulerInterruptHandler(m_kernel), KInterruptName::Scheduler, m_core_id,// KInterruptController::PriorityLevel::Scheduler, false, false);// Set the current thread.@@ -168,7 +168,7 @@ void KScheduler::Initialize(KThread* main_thread, KThread* idle_thread, s32 core}void KScheduler::Activate() {- ASSERT(GetCurrentThread(kernel).GetDisableDispatchCount() == 1);+ ASSERT(GetCurrentThread(m_kernel).GetDisableDispatchCount() == 1);// m_state.should_count_idle = KTargetSystem::IsDebugMode();m_is_active = true;@@ -176,7 +176,7 @@ void KScheduler::Activate() {}void KScheduler::OnThreadStart() {- GetCurrentThread(kernel).EnableDispatch();+ GetCurrentThread(m_kernel).EnableDispatch();}u64 KScheduler::UpdateHighestPriorityThread(KThread* highest_thread) {@@ -184,7 +184,7 @@ u64 KScheduler::UpdateHighestPriorityThread(KThread* highest_thread) {prev_highest_thread != highest_thread) [[likely]] {if (prev_highest_thread != nullptr) [[likely]] {IncrementScheduledCount(prev_highest_thread);- prev_highest_thread->SetLastScheduledTick(kernel.System().CoreTiming().GetCPUTicks());+ prev_highest_thread->SetLastScheduledTick(m_kernel.System().CoreTiming().GetCPUTicks());}if (m_state.should_count_idle) {if (highest_thread != nullptr) [[likely]] {@@ -328,8 +328,8 @@ u64 KScheduler::UpdateHighestPriorityThreadsImpl(KernelCore& kernel) {}void KScheduler::SwitchThread(KThread* next_thread) {- KProcess* const cur_process = GetCurrentProcessPointer(kernel);- KThread* const cur_thread = GetCurrentThreadPointer(kernel);+ KProcess* const cur_process = GetCurrentProcessPointer(m_kernel);+ KThread* const cur_thread = GetCurrentThreadPointer(m_kernel);// We never want to schedule a null thread, so use the idle thread if we don't have a next.if (next_thread == nullptr) {@@ -351,7 +351,7 @@ void KScheduler::SwitchThread(KThread* next_thread) {// Update the CPU time tracking variables.const s64 prev_tick = m_last_context_switch_time;- const s64 cur_tick = kernel.System().CoreTiming().GetCPUTicks();+ const s64 cur_tick = m_kernel.System().CoreTiming().GetCPUTicks();const s64 tick_diff = cur_tick - prev_tick;cur_thread->AddCpuTime(m_core_id, tick_diff);if (cur_process != nullptr) {@@ -375,7 +375,7 @@ void KScheduler::SwitchThread(KThread* next_thread) {// }// Set the new thread.- SetCurrentThread(kernel, next_thread);+ SetCurrentThread(m_kernel, next_thread);m_current_thread = next_thread;// Set the new Thread Local region.@@ -388,7 +388,7 @@ void KScheduler::ScheduleImpl() {std::atomic_thread_fence(std::memory_order_seq_cst);// Load the appropriate thread pointers for scheduling.- KThread* const cur_thread{GetCurrentThreadPointer(kernel)};+ KThread* const cur_thread{GetCurrentThreadPointer(m_kernel)};KThread* highest_priority_thread{m_state.highest_priority_thread};// Check whether there are runnable interrupt tasks.@@ -493,7 +493,7 @@ void KScheduler::ScheduleImplFiber() {}void KScheduler::Unload(KThread* thread) {- auto& cpu_core = kernel.System().ArmInterface(m_core_id);+ auto& cpu_core = m_kernel.System().ArmInterface(m_core_id);cpu_core.SaveContext(thread->GetContext32());cpu_core.SaveContext(thread->GetContext64());// Save the TPIDR_EL0 system register in case it was modified.@@ -508,7 +508,7 @@ void KScheduler::Unload(KThread* thread) {}void KScheduler::Reload(KThread* thread) {- auto& cpu_core = kernel.System().ArmInterface(m_core_id);+ auto& cpu_core = m_kernel.System().ArmInterface(m_core_id);cpu_core.LoadContext(thread->GetContext32());cpu_core.LoadContext(thread->GetContext64());cpu_core.SetTlsAddress(thread->GetTLSAddress());@@ -891,7 +891,7 @@ void KScheduler::YieldToAnyThread(KernelCore& kernel) {void KScheduler::RescheduleOtherCores(u64 cores_needing_scheduling) {if (const u64 core_mask = cores_needing_scheduling & ~(1ULL << m_core_id); core_mask != 0) {- RescheduleCores(kernel, core_mask);+ RescheduleCores(m_kernel, core_mask);}}diff --git a/src/core/hle/kernel/k_scheduler.h b/src/core/hle/kernel/k_scheduler.hindex 3f13b81931..d85a0c0408 100644--- a/src/core/hle/kernel/k_scheduler.h+++ b/src/core/hle/kernel/k_scheduler.h@@ -149,7 +149,7 @@ private:KInterruptTaskManager* interrupt_task_manager{nullptr};};- KernelCore& kernel;+ KernelCore& m_kernel;SchedulingState m_state;bool m_is_active{false};s32 m_core_id{0};diff --git a/src/core/hle/kernel/k_server_port.cpp b/src/core/hle/kernel/k_server_port.cppindex dc70ee8487..a29d34bc1f 100644--- a/src/core/hle/kernel/k_server_port.cpp+++ b/src/core/hle/kernel/k_server_port.cpp@@ -12,7 +12,7 @@namespace Kernel {-KServerPort::KServerPort(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}+KServerPort::KServerPort(KernelCore& kernel) : KSynchronizationObject{kernel} {}KServerPort::~KServerPort() = default;void KServerPort::Initialize(KPort* parent) {@@ -35,7 +35,7 @@ void KServerPort::CleanupSessions() {// Get the last session in the listKServerSession* session = nullptr;{- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};if (!m_session_list.empty()) {session = std::addressof(m_session_list.front());m_session_list.pop_front();@@ -74,7 +74,7 @@ bool KServerPort::IsSignaled() const {void KServerPort::EnqueueSession(KServerSession* session) {ASSERT(!this->IsLight());- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Add the session to our queue.m_session_list.push_back(*session);@@ -86,7 +86,7 @@ void KServerPort::EnqueueSession(KServerSession* session) {KServerSession* KServerPort::AcceptSession() {ASSERT(!this->IsLight());- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Return the first session in the list.if (m_session_list.empty()) {diff --git a/src/core/hle/kernel/k_server_port.h b/src/core/hle/kernel/k_server_port.hindex 9647671568..21c040e620 100644--- a/src/core/hle/kernel/k_server_port.h+++ b/src/core/hle/kernel/k_server_port.h@@ -22,7 +22,7 @@ class KServerPort final : public KSynchronizationObject {KERNEL_AUTOOBJECT_TRAITS(KServerPort, KSynchronizationObject);public:- explicit KServerPort(KernelCore& kernel_);+ explicit KServerPort(KernelCore& kernel);~KServerPort() override;void Initialize(KPort* parent);diff --git a/src/core/hle/kernel/k_server_session.cpp b/src/core/hle/kernel/k_server_session.cppindex c68ec09cee..e9b4ef5281 100644--- a/src/core/hle/kernel/k_server_session.cpp+++ b/src/core/hle/kernel/k_server_session.cpp@@ -28,8 +28,8 @@ namespace Kernel {using ThreadQueueImplForKServerSessionRequest = KThreadQueue;-KServerSession::KServerSession(KernelCore& kernel_)- : KSynchronizationObject{kernel_}, m_lock{kernel_} {}+KServerSession::KServerSession(KernelCore& kernel)+ : KSynchronizationObject{kernel}, m_lock{m_kernel} {}KServerSession::~KServerSession() = default;@@ -56,7 +56,7 @@ void KServerSession::OnClientClosed() {// Get the next request.{- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};if (m_current_request != nullptr && m_current_request != prev_request) {// Set the request, open a reference as we process it.@@ -135,7 +135,7 @@ void KServerSession::OnClientClosed() {}bool KServerSession::IsSignaled() const {- ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(kernel));+ ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));// If the client is closed, we're always signaled.if (m_parent->IsClientClosed()) {@@ -148,17 +148,17 @@ bool KServerSession::IsSignaled() const {Result KServerSession::OnRequest(KSessionRequest* request) {// Create the wait queue.- ThreadQueueImplForKServerSessionRequest wait_queue{kernel};+ ThreadQueueImplForKServerSessionRequest wait_queue{m_kernel};{// Lock the scheduler.- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Ensure that we can handle new requests.R_UNLESS(!m_parent->IsServerClosed(), ResultSessionClosed);// Check that we're not terminating.- R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(), ResultTerminationRequested);+ R_UNLESS(!GetCurrentThread(m_kernel).IsTerminationRequested(), ResultTerminationRequested);// Get whether we're empty.const bool was_empty = m_request_list.empty();@@ -176,11 +176,11 @@ Result KServerSession::OnRequest(KSessionRequest* request) {R_SUCCEED_IF(request->GetEvent() != nullptr);// This is a synchronous request, so we should wait for our request to complete.- GetCurrentThread(kernel).SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC);- GetCurrentThread(kernel).BeginWait(&wait_queue);+ GetCurrentThread(m_kernel).SetWaitReasonForDebugging(ThreadWaitReasonForDebugging::IPC);+ GetCurrentThread(m_kernel).BeginWait(&wait_queue);}- return GetCurrentThread(kernel).GetWaitResult();+ return GetCurrentThread(m_kernel).GetWaitResult();}Result KServerSession::SendReply(bool is_hle) {@@ -190,7 +190,7 @@ Result KServerSession::SendReply(bool is_hle) {// Get the request.KSessionRequest* request;{- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Get the current request.request = m_current_request;@@ -222,8 +222,8 @@ Result KServerSession::SendReply(bool is_hle) {// HLE servers write directly to a pointer to the thread command buffer. Therefore// the reply has already been written in this case.} else {- Core::Memory::Memory& memory{kernel.System().Memory()};- KThread* server_thread{GetCurrentThreadPointer(kernel)};+ Core::Memory::Memory& memory{m_kernel.System().Memory()};+ KThread* server_thread{GetCurrentThreadPointer(m_kernel)};UNIMPLEMENTED_IF(server_thread->GetOwnerProcess() != client_thread->GetOwnerProcess());auto* src_msg_buffer = memory.GetPointer(server_thread->GetTLSAddress());@@ -264,7 +264,7 @@ Result KServerSession::SendReply(bool is_hle) {event->Signal();} else {// End the client thread's wait.- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};if (!client_thread->IsTerminationRequested()) {client_thread->EndWait(client_result);@@ -285,7 +285,7 @@ Result KServerSession::ReceiveRequest(std::shared_ptr<Service::HLERequestContextKThread* client_thread;{- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Ensure that we can service the request.R_UNLESS(!m_parent->IsClientClosed(), ResultSessionClosed);@@ -319,18 +319,18 @@ Result KServerSession::ReceiveRequest(std::shared_ptr<Service::HLERequestContext// bool recv_list_broken = false;// Receive the message.- Core::Memory::Memory& memory{kernel.System().Memory()};+ Core::Memory::Memory& memory{m_kernel.System().Memory()};if (out_context != nullptr) {// HLE request.u32* cmd_buf{reinterpret_cast<u32*>(memory.GetPointer(client_message))};*out_context =- std::make_shared<Service::HLERequestContext>(kernel, memory, this, client_thread);+ std::make_shared<Service::HLERequestContext>(m_kernel, memory, this, client_thread);(*out_context)->SetSessionRequestManager(manager);(*out_context)->PopulateFromIncomingCommandBuffer(client_thread->GetOwnerProcess()->GetHandleTable(),cmd_buf);} else {- KThread* server_thread{GetCurrentThreadPointer(kernel)};+ KThread* server_thread{GetCurrentThreadPointer(m_kernel)};UNIMPLEMENTED_IF(server_thread->GetOwnerProcess() != client_thread->GetOwnerProcess());auto* src_msg_buffer = memory.GetPointer(client_message);@@ -350,7 +350,7 @@ void KServerSession::CleanupRequests() {// Get the next request.KSessionRequest* request = nullptr;{- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};if (m_current_request) {// Choose the current request if we have one.@@ -401,7 +401,7 @@ void KServerSession::CleanupRequests() {event->Signal();} else {// End the client thread's wait.- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};if (!client_thread->IsTerminationRequested()) {client_thread->EndWait(ResultSessionClosed);diff --git a/src/core/hle/kernel/k_server_session.h b/src/core/hle/kernel/k_server_session.hindex e340e4dd8a..5ee02f556b 100644--- a/src/core/hle/kernel/k_server_session.h+++ b/src/core/hle/kernel/k_server_session.h@@ -33,7 +33,7 @@ class KServerSession final : public KSynchronizationObject,friend class ServiceThread;public:- explicit KServerSession(KernelCore& kernel_);+ explicit KServerSession(KernelCore& kernel);~KServerSession() override;void Destroy() override;diff --git a/src/core/hle/kernel/k_session.cpp b/src/core/hle/kernel/k_session.cppindex 771ad68bff..44d7a8f028 100644--- a/src/core/hle/kernel/k_session.cpp+++ b/src/core/hle/kernel/k_session.cpp@@ -9,8 +9,8 @@namespace Kernel {-KSession::KSession(KernelCore& kernel_)- : KAutoObjectWithSlabHeapAndContainer{kernel_}, m_server{kernel_}, m_client{kernel_} {}+KSession::KSession(KernelCore& kernel)+ : KAutoObjectWithSlabHeapAndContainer{kernel}, m_server{kernel}, m_client{kernel} {}KSession::~KSession() = default;void KSession::Initialize(KClientPort* client_port, uintptr_t name) {@@ -34,7 +34,7 @@ void KSession::Initialize(KClientPort* client_port, uintptr_t name) {// Set our owner process.//! FIXME: this is the wrong process!- m_process = kernel.ApplicationProcess();+ m_process = m_kernel.ApplicationProcess();m_process->Open();// Set our port.diff --git a/src/core/hle/kernel/k_session.h b/src/core/hle/kernel/k_session.hindex ab553a04cd..f69bab0888 100644--- a/src/core/hle/kernel/k_session.h+++ b/src/core/hle/kernel/k_session.h@@ -18,7 +18,7 @@ class KSession final : public KAutoObjectWithSlabHeapAndContainer<KSession, KAutKERNEL_AUTOOBJECT_TRAITS(KSession, KAutoObject);public:- explicit KSession(KernelCore& kernel_);+ explicit KSession(KernelCore& kernel);~KSession() override;void Initialize(KClientPort* port, uintptr_t name);diff --git a/src/core/hle/kernel/k_session_request.h b/src/core/hle/kernel/k_session_request.hindex 5003e5c1d1..5685048ba2 100644--- a/src/core/hle/kernel/k_session_request.h+++ b/src/core/hle/kernel/k_session_request.h@@ -158,7 +158,7 @@ public:};public:- explicit KSessionRequest(KernelCore& kernel_) : KAutoObject(kernel_), m_mappings(kernel_) {}+ explicit KSessionRequest(KernelCore& kernel) : KAutoObject(kernel), m_mappings(kernel) {}static KSessionRequest* Create(KernelCore& kernel) {KSessionRequest* req = KSessionRequest::Allocate(kernel);@@ -170,13 +170,13 @@ public:void Destroy() override {this->Finalize();- KSessionRequest::Free(kernel, this);+ KSessionRequest::Free(m_kernel, this);}void Initialize(KEvent* event, uintptr_t address, size_t size) {m_mappings.Initialize();- m_thread = GetCurrentThreadPointer(kernel);+ m_thread = GetCurrentThreadPointer(m_kernel);m_event = event;m_address = address;m_size = size;diff --git a/src/core/hle/kernel/k_shared_memory.cpp b/src/core/hle/kernel/k_shared_memory.cppindex bf134f7c85..b7b3b612bb 100644--- a/src/core/hle/kernel/k_shared_memory.cpp+++ b/src/core/hle/kernel/k_shared_memory.cpp@@ -12,7 +12,7 @@namespace Kernel {-KSharedMemory::KSharedMemory(KernelCore& kernel_) : KAutoObjectWithSlabHeapAndContainer{kernel_} {}+KSharedMemory::KSharedMemory(KernelCore& kernel) : KAutoObjectWithSlabHeapAndContainer{kernel} {}KSharedMemory::~KSharedMemory() = default;Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory, KProcess* owner_process,@@ -28,7 +28,7 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory, KProcess* owconst size_t num_pages = Common::DivideUp(size, PageSize);// Get the resource limit.- KResourceLimit* reslimit = kernel.GetSystemResourceLimit();+ KResourceLimit* reslimit = m_kernel.GetSystemResourceLimit();// Reserve memory for ourselves.KScopedResourceReservation memory_reservation(reslimit, LimitableResource::PhysicalMemoryMax,@@ -40,11 +40,11 @@ Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory, KProcess* ow//! HACK: Open continuous mapping from sysmodule pool.auto option = KMemoryManager::EncodeOption(KMemoryManager::Pool::Secure,KMemoryManager::Direction::FromBack);- m_physical_address = kernel.MemoryManager().AllocateAndOpenContinuous(num_pages, 1, option);+ m_physical_address = m_kernel.MemoryManager().AllocateAndOpenContinuous(num_pages, 1, option);R_UNLESS(m_physical_address != 0, ResultOutOfMemory);//! Insert the result into our page group.- m_page_group.emplace(kernel, &kernel.GetSystemSystemResource().GetBlockInfoManager());+ m_page_group.emplace(m_kernel, &m_kernel.GetSystemSystemResource().GetBlockInfoManager());m_page_group->AddBlock(m_physical_address, num_pages);// Commit our reservation.diff --git a/src/core/hle/kernel/k_shared_memory.h b/src/core/hle/kernel/k_shared_memory.hindex 8c94ceb3ae..b4c4125bbf 100644--- a/src/core/hle/kernel/k_shared_memory.h+++ b/src/core/hle/kernel/k_shared_memory.h@@ -23,7 +23,7 @@ class KSharedMemory finalKERNEL_AUTOOBJECT_TRAITS(KSharedMemory, KAutoObject);public:- explicit KSharedMemory(KernelCore& kernel_);+ explicit KSharedMemory(KernelCore& kernel);~KSharedMemory() override;Result Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,diff --git a/src/core/hle/kernel/k_synchronization_object.cpp b/src/core/hle/kernel/k_synchronization_object.cppindex dd912a82d1..b7da3eee77 100644--- a/src/core/hle/kernel/k_synchronization_object.cpp+++ b/src/core/hle/kernel/k_synchronization_object.cpp@@ -17,9 +17,9 @@ namespace {class ThreadQueueImplForKSynchronizationObjectWait final : public KThreadQueueWithoutEndWait {public:- ThreadQueueImplForKSynchronizationObjectWait(KernelCore& kernel_, KSynchronizationObject** o,+ ThreadQueueImplForKSynchronizationObjectWait(KernelCore& kernel, KSynchronizationObject** o,KSynchronizationObject::ThreadListNode* n, s32 c)- : KThreadQueueWithoutEndWait(kernel_), m_objects(o), m_nodes(n), m_count(c) {}+ : KThreadQueueWithoutEndWait(kernel), m_objects(o), m_nodes(n), m_count(c) {}void NotifyAvailable(KThread* waiting_thread, KSynchronizationObject* signaled_object,Result wait_result) override {@@ -144,13 +144,12 @@ Result KSynchronizationObject::Wait(KernelCore& kernel, s32* out_index,R_RETURN(thread->GetWaitResult());}-KSynchronizationObject::KSynchronizationObject(KernelCore& kernel_)- : KAutoObjectWithList{kernel_} {}+KSynchronizationObject::KSynchronizationObject(KernelCore& kernel) : KAutoObjectWithList{kernel} {}KSynchronizationObject::~KSynchronizationObject() = default;void KSynchronizationObject::NotifyAvailable(Result result) {- KScopedSchedulerLock sl(kernel);+ KScopedSchedulerLock sl(m_kernel);// If we're not signaled, we've nothing to notify.if (!this->IsSignaled()) {@@ -168,7 +167,7 @@ std::vector<KThread*> KSynchronizationObject::GetWaitingThreadsForDebugging() co// If debugging, dump the list of waiters.{- KScopedSchedulerLock lock(kernel);+ KScopedSchedulerLock lock(m_kernel);for (auto* cur_node = m_thread_list_head; cur_node != nullptr; cur_node = cur_node->next) {threads.emplace_back(cur_node->thread);}diff --git a/src/core/hle/kernel/k_system_resource.h b/src/core/hle/kernel/k_system_resource.hindex aec058a95a..d36aaa9bd7 100644--- a/src/core/hle/kernel/k_system_resource.h+++ b/src/core/hle/kernel/k_system_resource.h@@ -21,7 +21,7 @@ class KSystemResource : public KAutoObject {KERNEL_AUTOOBJECT_TRAITS(KSystemResource, KAutoObject);public:- explicit KSystemResource(KernelCore& kernel_) : KAutoObject(kernel_) {}+ explicit KSystemResource(KernelCore& kernel) : KAutoObject(kernel) {}protected:void SetSecureResource() {@@ -87,8 +87,8 @@ private:class KSecureSystemResource final: public KAutoObjectWithSlabHeap<KSecureSystemResource, KSystemResource> {public:- explicit KSecureSystemResource(KernelCore& kernel_)- : KAutoObjectWithSlabHeap<KSecureSystemResource, KSystemResource>(kernel_) {+ explicit KSecureSystemResource(KernelCore& kernel)+ : KAutoObjectWithSlabHeap<KSecureSystemResource, KSystemResource>(kernel) {// Mark ourselves as being a secure resource.this->SetSecureResource();}diff --git a/src/core/hle/kernel/k_thread.cpp b/src/core/hle/kernel/k_thread.cppindex 26e3700e41..49a683e5ff 100644--- a/src/core/hle/kernel/k_thread.cpp+++ b/src/core/hle/kernel/k_thread.cpp@@ -77,14 +77,14 @@ struct ThreadLocalRegion {class ThreadQueueImplForKThreadSleep final : public KThreadQueueWithoutEndWait {public:- explicit ThreadQueueImplForKThreadSleep(KernelCore& kernel_)- : KThreadQueueWithoutEndWait(kernel_) {}+ explicit ThreadQueueImplForKThreadSleep(KernelCore& kernel)+ : KThreadQueueWithoutEndWait(kernel) {}};class ThreadQueueImplForKThreadSetProperty final : public KThreadQueue {public:- explicit ThreadQueueImplForKThreadSetProperty(KernelCore& kernel_, KThread::WaiterList* wl)- : KThreadQueue(kernel_), m_wait_list(wl) {}+ explicit ThreadQueueImplForKThreadSetProperty(KernelCore& kernel, KThread::WaiterList* wl)+ : KThreadQueue(kernel), m_wait_list(wl) {}void CancelWait(KThread* waiting_thread, Result wait_result, bool cancel_timer_task) override {// Remove the thread from the wait list.@@ -100,8 +100,8 @@ private:} // namespace-KThread::KThread(KernelCore& kernel_)- : KAutoObjectWithSlabHeapAndContainer{kernel_}, activity_pause_lock{kernel_} {}+KThread::KThread(KernelCore& kernel)+ : KAutoObjectWithSlabHeapAndContainer{kernel}, activity_pause_lock{kernel} {}KThread::~KThread() = default;Result KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_stack_top, s32 prio,@@ -236,7 +236,7 @@ Result KThread::Initialize(KThreadFunction func, uintptr_t arg, VAddr user_stackSetInExceptionHandler();// Set thread ID.- thread_id = kernel.CreateNewThreadID();+ thread_id = m_kernel.CreateNewThreadID();// We initialized!initialized = true;@@ -343,7 +343,7 @@ void KThread::Finalize() {// Release any waiters.{ASSERT(waiting_lock_info == nullptr);- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Check that we have no kernel waiters.ASSERT(num_kernel_waiters == 0);@@ -374,7 +374,7 @@ void KThread::Finalize() {it = held_lock_info_list.erase(it);// Free the lock info.- LockWithPriorityInheritanceInfo::Free(kernel, lock_info);+ LockWithPriorityInheritanceInfo::Free(m_kernel, lock_info);}}@@ -390,7 +390,7 @@ bool KThread::IsSignaled() const {}void KThread::OnTimer() {- ASSERT(kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(m_kernel.GlobalSchedulerContext().IsLocked());// If we're waiting, cancel the wait.if (GetState() == ThreadState::Waiting) {@@ -399,12 +399,12 @@ void KThread::OnTimer() {}void KThread::StartTermination() {- ASSERT(kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(m_kernel.GlobalSchedulerContext().IsLocked());// Release user exception and unpin, if relevant.if (parent != nullptr) {parent->ReleaseUserException(this);- if (parent->GetPinnedThread(GetCurrentCoreId(kernel)) == this) {+ if (parent->GetPinnedThread(GetCurrentCoreId(m_kernel)) == this) {parent->UnpinCurrentThread(core_id);}}@@ -422,7 +422,7 @@ void KThread::StartTermination() {KSynchronizationObject::NotifyAvailable();// Clear previous thread in KScheduler.- KScheduler::ClearPreviousThread(kernel, this);+ KScheduler::ClearPreviousThread(m_kernel, this);// Register terminated dpc flag.RegisterDpc(DpcFlag::Terminated);@@ -434,7 +434,7 @@ void KThread::FinishTermination() {for (std::size_t i = 0; i < static_cast<std::size_t>(Core::Hardware::NUM_CPU_CORES); ++i) {KThread* core_thread{};do {- core_thread = kernel.Scheduler(i).GetSchedulerCurrentThread();+ core_thread = m_kernel.Scheduler(i).GetSchedulerCurrentThread();} while (core_thread == this);}}@@ -449,7 +449,7 @@ void KThread::DoWorkerTaskImpl() {}void KThread::Pin(s32 current_core) {- ASSERT(kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(m_kernel.GlobalSchedulerContext().IsLocked());// Set ourselves as pinned.GetStackParameters().is_pinned = true;@@ -472,7 +472,7 @@ void KThread::Pin(s32 current_core) {if (active_core != current_core || physical_affinity_mask.GetAffinityMask() !=original_physical_affinity_mask.GetAffinityMask()) {- KScheduler::OnThreadAffinityMaskChanged(kernel, this, original_physical_affinity_mask,+ KScheduler::OnThreadAffinityMaskChanged(m_kernel, this, original_physical_affinity_mask,active_core);}}@@ -492,7 +492,7 @@ void KThread::Pin(s32 current_core) {}void KThread::Unpin() {- ASSERT(kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(m_kernel.GlobalSchedulerContext().IsLocked());// Set ourselves as unpinned.GetStackParameters().is_pinned = false;@@ -520,7 +520,7 @@ void KThread::Unpin() {std::countl_zero(physical_affinity_mask.GetAffinityMask())));}}- KScheduler::OnThreadAffinityMaskChanged(kernel, this, old_mask, active_core);+ KScheduler::OnThreadAffinityMaskChanged(m_kernel, this, old_mask, active_core);}}@@ -549,7 +549,7 @@ u16 KThread::GetUserDisableCount() const {return {};}- auto& memory = kernel.System().Memory();+ auto& memory = m_kernel.System().Memory();return memory.Read16(tls_address + offsetof(ThreadLocalRegion, disable_count));}@@ -559,7 +559,7 @@ void KThread::SetInterruptFlag() {return;}- auto& memory = kernel.System().Memory();+ auto& memory = m_kernel.System().Memory();memory.Write16(tls_address + offsetof(ThreadLocalRegion, interrupt_flag), 1);}@@ -569,12 +569,12 @@ void KThread::ClearInterruptFlag() {return;}- auto& memory = kernel.System().Memory();+ auto& memory = m_kernel.System().Memory();memory.Write16(tls_address + offsetof(ThreadLocalRegion, interrupt_flag), 0);}Result KThread::GetCoreMask(s32* out_ideal_core, u64* out_affinity_mask) {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Get the virtual mask.*out_ideal_core = virtual_ideal_core_id;@@ -584,7 +584,7 @@ Result KThread::GetCoreMask(s32* out_ideal_core, u64* out_affinity_mask) {}Result KThread::GetPhysicalCoreMask(s32* out_ideal_core, u64* out_affinity_mask) {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};ASSERT(num_core_migration_disables >= 0);// Select between core mask and original core mask.@@ -607,7 +607,7 @@ Result KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {// Set the core mask.u64 p_affinity_mask = 0;{- KScopedSchedulerLock sl(kernel);+ KScopedSchedulerLock sl(m_kernel);ASSERT(num_core_migration_disables >= 0);// If we're updating, set our ideal virtual core.@@ -653,7 +653,7 @@ Result KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {std::countl_zero(physical_affinity_mask.GetAffinityMask()));SetActiveCore(new_core);}- KScheduler::OnThreadAffinityMaskChanged(kernel, this, old_mask, active_core);+ KScheduler::OnThreadAffinityMaskChanged(m_kernel, this, old_mask, active_core);}} else {// Otherwise, we edit the original affinity for restoration later.@@ -663,12 +663,12 @@ Result KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {}// Update the pinned waiter list.- ThreadQueueImplForKThreadSetProperty wait_queue_(kernel, std::addressof(pinned_waiter_list));+ ThreadQueueImplForKThreadSetProperty wait_queue_(m_kernel, std::addressof(pinned_waiter_list));{bool retry_update{};do {// Lock the scheduler.- KScopedSchedulerLock sl(kernel);+ KScopedSchedulerLock sl(m_kernel);// Don't do any further management if our termination has been requested.R_SUCCEED_IF(IsTerminationRequested());@@ -681,7 +681,7 @@ Result KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {s32 thread_core;for (thread_core = 0; thread_core < static_cast<s32>(Core::Hardware::NUM_CPU_CORES);++thread_core) {- if (kernel.Scheduler(thread_core).GetSchedulerCurrentThread() == this) {+ if (m_kernel.Scheduler(thread_core).GetSchedulerCurrentThread() == this) {thread_is_current = true;break;}@@ -693,12 +693,12 @@ Result KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {// If the thread is pinned, we want to wait until it's not pinned.if (GetStackParameters().is_pinned) {// Verify that the current thread isn't terminating.- R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(),+ R_UNLESS(!GetCurrentThread(m_kernel).IsTerminationRequested(),ResultTerminationRequested);// Wait until the thread isn't pinned any more.- pinned_waiter_list.push_back(GetCurrentThread(kernel));- GetCurrentThread(kernel).BeginWait(std::addressof(wait_queue_));+ pinned_waiter_list.push_back(GetCurrentThread(m_kernel));+ GetCurrentThread(m_kernel).BeginWait(std::addressof(wait_queue_));} else {// If the thread isn't pinned, release the scheduler lock and retry until it's// not current.@@ -714,13 +714,13 @@ Result KThread::SetCoreMask(s32 core_id_, u64 v_affinity_mask) {void KThread::SetBasePriority(s32 value) {ASSERT(Svc::HighestThreadPriority <= value && value <= Svc::LowestThreadPriority);- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Change our base priority.base_priority = value;// Perform a priority restoration.- RestorePriority(kernel, this);+ RestorePriority(m_kernel, this);}KThread* KThread::GetLockOwner() const {@@ -729,7 +729,7 @@ KThread* KThread::GetLockOwner() const {void KThread::IncreaseBasePriority(s32 priority_) {ASSERT(Svc::HighestThreadPriority <= priority_ && priority_ <= Svc::LowestThreadPriority);- ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(kernel));+ ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));ASSERT(!this->GetStackParameters().is_pinned);// Set our base priority.@@ -737,12 +737,12 @@ void KThread::IncreaseBasePriority(s32 priority_) {base_priority = priority_;// Perform a priority restoration.- RestorePriority(kernel, this);+ RestorePriority(m_kernel, this);}}void KThread::RequestSuspend(SuspendType type) {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Note the request in our flags.suspend_request_flags |=@@ -753,7 +753,7 @@ void KThread::RequestSuspend(SuspendType type) {}void KThread::Resume(SuspendType type) {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Clear the request in our flags.suspend_request_flags &=@@ -764,7 +764,7 @@ void KThread::Resume(SuspendType type) {}void KThread::WaitCancel() {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Check if we're waiting and cancellable.if (this->GetState() == ThreadState::Waiting && cancellable) {@@ -777,7 +777,7 @@ void KThread::WaitCancel() {}void KThread::TrySuspend() {- ASSERT(kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(m_kernel.GlobalSchedulerContext().IsLocked());ASSERT(IsSuspendRequested());// Ensure that we have no waiters.@@ -791,7 +791,7 @@ void KThread::TrySuspend() {}void KThread::UpdateState() {- ASSERT(kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(m_kernel.GlobalSchedulerContext().IsLocked());// Set our suspend flags in state.const ThreadState old_state = thread_state.load(std::memory_order_relaxed);@@ -801,37 +801,37 @@ void KThread::UpdateState() {// Note the state change in scheduler.if (new_state != old_state) {- KScheduler::OnThreadStateChanged(kernel, this, old_state);+ KScheduler::OnThreadStateChanged(m_kernel, this, old_state);}}void KThread::Continue() {- ASSERT(kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(m_kernel.GlobalSchedulerContext().IsLocked());// Clear our suspend flags in state.const ThreadState old_state = thread_state.load(std::memory_order_relaxed);thread_state.store(old_state & ThreadState::Mask, std::memory_order_relaxed);// Note the state change in scheduler.- KScheduler::OnThreadStateChanged(kernel, this, old_state);+ KScheduler::OnThreadStateChanged(m_kernel, this, old_state);}void KThread::CloneFpuStatus() {// We shouldn't reach here when starting kernel threads.ASSERT(this->GetOwnerProcess() != nullptr);- ASSERT(this->GetOwnerProcess() == GetCurrentProcessPointer(kernel));+ ASSERT(this->GetOwnerProcess() == GetCurrentProcessPointer(m_kernel));if (this->GetOwnerProcess()->Is64BitProcess()) {// Clone FPSR and FPCR.ThreadContext64 cur_ctx{};- kernel.System().CurrentArmInterface().SaveContext(cur_ctx);+ m_kernel.System().CurrentArmInterface().SaveContext(cur_ctx);this->GetContext64().fpcr = cur_ctx.fpcr;this->GetContext64().fpsr = cur_ctx.fpsr;} else {// Clone FPSCR.ThreadContext32 cur_ctx{};- kernel.System().CurrentArmInterface().SaveContext(cur_ctx);+ m_kernel.System().CurrentArmInterface().SaveContext(cur_ctx);this->GetContext32().fpscr = cur_ctx.fpscr;}@@ -844,7 +844,7 @@ Result KThread::SetActivity(Svc::ThreadActivity activity) {// Set the activity.{// Lock the scheduler.- KScopedSchedulerLock sl(kernel);+ KScopedSchedulerLock sl(m_kernel);// Verify our state.const auto cur_state = this->GetState();@@ -871,13 +871,13 @@ Result KThread::SetActivity(Svc::ThreadActivity activity) {// If the thread is now paused, update the pinned waiter list.if (activity == Svc::ThreadActivity::Paused) {- ThreadQueueImplForKThreadSetProperty wait_queue_(kernel,+ ThreadQueueImplForKThreadSetProperty wait_queue_(m_kernel,std::addressof(pinned_waiter_list));bool thread_is_current;do {// Lock the scheduler.- KScopedSchedulerLock sl(kernel);+ KScopedSchedulerLock sl(m_kernel);// Don't do any further management if our termination has been requested.R_SUCCEED_IF(this->IsTerminationRequested());@@ -888,17 +888,17 @@ Result KThread::SetActivity(Svc::ThreadActivity activity) {// Check whether the thread is pinned.if (this->GetStackParameters().is_pinned) {// Verify that the current thread isn't terminating.- R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(),+ R_UNLESS(!GetCurrentThread(m_kernel).IsTerminationRequested(),ResultTerminationRequested);// Wait until the thread isn't pinned any more.- pinned_waiter_list.push_back(GetCurrentThread(kernel));- GetCurrentThread(kernel).BeginWait(std::addressof(wait_queue_));+ pinned_waiter_list.push_back(GetCurrentThread(m_kernel));+ GetCurrentThread(m_kernel).BeginWait(std::addressof(wait_queue_));} else {// Check if the thread is currently running.// If it is, we'll need to retry.for (auto i = 0; i < static_cast<s32>(Core::Hardware::NUM_CPU_CORES); ++i) {- if (kernel.Scheduler(i).GetSchedulerCurrentThread() == this) {+ if (m_kernel.Scheduler(i).GetSchedulerCurrentThread() == this) {thread_is_current = true;break;}@@ -917,7 +917,7 @@ Result KThread::GetThreadContext3(std::vector<u8>& out) {// Get the context.{// Lock the scheduler.- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Verify that we're suspended.R_UNLESS(IsSuspendRequested(SuspendType::Thread), ResultInvalidState);@@ -946,7 +946,7 @@ Result KThread::GetThreadContext3(std::vector<u8>& out) {}void KThread::AddHeldLock(LockWithPriorityInheritanceInfo* lock_info) {- ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(kernel));+ ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));// Set ourselves as the lock's owner.lock_info->SetOwner(this);@@ -957,7 +957,7 @@ void KThread::AddHeldLock(LockWithPriorityInheritanceInfo* lock_info) {KThread::LockWithPriorityInheritanceInfo* KThread::FindHeldLock(VAddr address_key_,bool is_kernel_address_key_) {- ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(kernel));+ ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));// Try to find an existing held lock.for (auto& held_lock : held_lock_info_list) {@@ -971,7 +971,7 @@ KThread::LockWithPriorityInheritanceInfo* KThread::FindHeldLock(VAddr address_ke}void KThread::AddWaiterImpl(KThread* thread) {- ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(kernel));+ ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));ASSERT(thread->GetConditionVariableTree() == nullptr);// Get the thread's address key.@@ -981,7 +981,7 @@ void KThread::AddWaiterImpl(KThread* thread) {// Keep track of how many kernel waiters we have.if (is_kernel_address_key_) {ASSERT((num_kernel_waiters++) >= 0);- KScheduler::SetSchedulerUpdateNeeded(kernel);+ KScheduler::SetSchedulerUpdateNeeded(m_kernel);}// Get the relevant lock info.@@ -989,7 +989,7 @@ void KThread::AddWaiterImpl(KThread* thread) {if (lock_info == nullptr) {// Create a new lock for the address key.lock_info =- LockWithPriorityInheritanceInfo::Create(kernel, address_key_, is_kernel_address_key_);+ LockWithPriorityInheritanceInfo::Create(m_kernel, address_key_, is_kernel_address_key_);// Add the new lock to our list.this->AddHeldLock(lock_info);@@ -1000,12 +1000,12 @@ void KThread::AddWaiterImpl(KThread* thread) {}void KThread::RemoveWaiterImpl(KThread* thread) {- ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(kernel));+ ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));// Keep track of how many kernel waiters we have.if (thread->GetIsKernelAddressKey()) {ASSERT((num_kernel_waiters--) > 0);- KScheduler::SetSchedulerUpdateNeeded(kernel);+ KScheduler::SetSchedulerUpdateNeeded(m_kernel);}// Get the info for the lock the thread is waiting on.@@ -1015,7 +1015,7 @@ void KThread::RemoveWaiterImpl(KThread* thread) {// Remove the waiter.if (lock_info->RemoveWaiter(thread)) {held_lock_info_list.erase(held_lock_info_list.iterator_to(*lock_info));- LockWithPriorityInheritanceInfo::Free(kernel, lock_info);+ LockWithPriorityInheritanceInfo::Free(m_kernel, lock_info);}}@@ -1076,7 +1076,7 @@ void KThread::AddWaiter(KThread* thread) {// If the thread has a higher priority than us, we should inherit.if (thread->GetPriority() < this->GetPriority()) {- RestorePriority(kernel, this);+ RestorePriority(m_kernel, this);}}@@ -1087,12 +1087,12 @@ void KThread::RemoveWaiter(KThread* thread) {// lower priority.if (this->GetPriority() == thread->GetPriority() &&this->GetPriority() < this->GetBasePriority()) {- RestorePriority(kernel, this);+ RestorePriority(m_kernel, this);}}KThread* KThread::RemoveWaiterByKey(bool* out_has_waiters, VAddr key, bool is_kernel_address_key_) {- ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(kernel));+ ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));// Get the relevant lock info.auto* lock_info = this->FindHeldLock(key, is_kernel_address_key_);@@ -1108,7 +1108,7 @@ KThread* KThread::RemoveWaiterByKey(bool* out_has_waiters, VAddr key, bool is_keif (lock_info->GetIsKernelAddressKey()) {num_kernel_waiters -= lock_info->GetWaiterCount();ASSERT(num_kernel_waiters >= 0);- KScheduler::SetSchedulerUpdateNeeded(kernel);+ KScheduler::SetSchedulerUpdateNeeded(m_kernel);}ASSERT(lock_info->GetWaiterCount() > 0);@@ -1120,7 +1120,7 @@ KThread* KThread::RemoveWaiterByKey(bool* out_has_waiters, VAddr key, bool is_ke*out_has_waiters = false;// Free the lock info, since it has no waiters.- LockWithPriorityInheritanceInfo::Free(kernel, lock_info);+ LockWithPriorityInheritanceInfo::Free(m_kernel, lock_info);} else {// There are additional waiters on the lock.*out_has_waiters = true;@@ -1142,7 +1142,7 @@ KThread* KThread::RemoveWaiterByKey(bool* out_has_waiters, VAddr key, bool is_ke// to lower priority.if (this->GetPriority() == next_lock_owner->GetPriority() &&this->GetPriority() < this->GetBasePriority()) {- RestorePriority(kernel, this);+ RestorePriority(m_kernel, this);// NOTE: No need to restore priority on the next lock owner, because it was already the// highest priority waiter on the lock.}@@ -1153,18 +1153,18 @@ KThread* KThread::RemoveWaiterByKey(bool* out_has_waiters, VAddr key, bool is_keResult KThread::Run() {while (true) {- KScopedSchedulerLock lk{kernel};+ KScopedSchedulerLock lk{m_kernel};// If either this thread or the current thread are requesting termination, note it.R_UNLESS(!IsTerminationRequested(), ResultTerminationRequested);- R_UNLESS(!GetCurrentThread(kernel).IsTerminationRequested(), ResultTerminationRequested);+ R_UNLESS(!GetCurrentThread(m_kernel).IsTerminationRequested(), ResultTerminationRequested);// Ensure our thread state is correct.R_UNLESS(GetState() == ThreadState::Initialized, ResultInvalidState);// If the current thread has been asked to suspend, suspend it and retry.- if (GetCurrentThread(kernel).IsSuspended()) {- GetCurrentThread(kernel).UpdateState();+ if (GetCurrentThread(m_kernel).IsSuspended()) {+ GetCurrentThread(m_kernel).UpdateState();continue;}@@ -1184,7 +1184,7 @@ Result KThread::Run() {}void KThread::Exit() {- ASSERT(this == GetCurrentThreadPointer(kernel));+ ASSERT(this == GetCurrentThreadPointer(m_kernel));// Release the thread resource hint, running thread count from parent.if (parent != nullptr) {@@ -1195,7 +1195,7 @@ void KThread::Exit() {// Perform termination.{- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Disallow all suspension.suspend_allowed_flags = 0;@@ -1208,21 +1208,21 @@ void KThread::Exit() {StartTermination();// Register the thread as a work task.- KWorkerTaskManager::AddTask(kernel, KWorkerTaskManager::WorkerType::Exit, this);+ KWorkerTaskManager::AddTask(m_kernel, KWorkerTaskManager::WorkerType::Exit, this);}UNREACHABLE_MSG("KThread::Exit() would return");}Result KThread::Terminate() {- ASSERT(this != GetCurrentThreadPointer(kernel));+ ASSERT(this != GetCurrentThreadPointer(m_kernel));// Request the thread terminate if it hasn't already.if (const auto new_state = this->RequestTerminate(); new_state != ThreadState::Terminated) {// If the thread isn't terminated, wait for it to terminate.s32 index;KSynchronizationObject* objects[] = {this};- R_TRY(KSynchronizationObject::Wait(kernel, std::addressof(index), objects, 1,+ R_TRY(KSynchronizationObject::Wait(m_kernel, std::addressof(index), objects, 1,Svc::WaitInfinite));}@@ -1230,9 +1230,9 @@ Result KThread::Terminate() {}ThreadState KThread::RequestTerminate() {- ASSERT(this != GetCurrentThreadPointer(kernel));+ ASSERT(this != GetCurrentThreadPointer(m_kernel));- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Determine if this is the first termination request.const bool first_request = [&]() -> bool {@@ -1268,10 +1268,10 @@ ThreadState KThread::RequestTerminate() {// If the thread is runnable, send a termination interrupt to other cores.if (this->GetState() == ThreadState::Runnable) {- if (const u64 core_mask =- physical_affinity_mask.GetAffinityMask() & ~(1ULL << GetCurrentCoreId(kernel));+ if (const u64 core_mask = physical_affinity_mask.GetAffinityMask() &+ ~(1ULL << GetCurrentCoreId(m_kernel));core_mask != 0) {- Kernel::KInterruptManager::SendInterProcessorInterrupt(kernel, core_mask);+ Kernel::KInterruptManager::SendInterProcessorInterrupt(m_kernel, core_mask);}}@@ -1285,15 +1285,15 @@ ThreadState KThread::RequestTerminate() {}Result KThread::Sleep(s64 timeout) {- ASSERT(!kernel.GlobalSchedulerContext().IsLocked());- ASSERT(this == GetCurrentThreadPointer(kernel));+ ASSERT(!m_kernel.GlobalSchedulerContext().IsLocked());+ ASSERT(this == GetCurrentThreadPointer(m_kernel));ASSERT(timeout > 0);- ThreadQueueImplForKThreadSleep wait_queue_(kernel);+ ThreadQueueImplForKThreadSleep wait_queue_(m_kernel);KHardwareTimer* timer{};{// Setup the scheduling lock and sleep.- KScopedSchedulerLockAndSleep slp(kernel, std::addressof(timer), this, timeout);+ KScopedSchedulerLockAndSleep slp(m_kernel, std::addressof(timer), this, timeout);// Check if the thread should terminate.if (this->IsTerminationRequested()) {@@ -1311,7 +1311,7 @@ Result KThread::Sleep(s64 timeout) {}void KThread::RequestDummyThreadWait() {- ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(kernel));+ ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));ASSERT(this->IsDummyThread());// We will block when the scheduler lock is released.@@ -1319,7 +1319,7 @@ void KThread::RequestDummyThreadWait() {}void KThread::DummyThreadBeginWait() {- if (!this->IsDummyThread() || kernel.IsPhantomModeForSingleCore()) {+ if (!this->IsDummyThread() || m_kernel.IsPhantomModeForSingleCore()) {// Occurs in single core mode.return;}@@ -1329,7 +1329,7 @@ void KThread::DummyThreadBeginWait() {}void KThread::DummyThreadEndWait() {- ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(kernel));+ ASSERT(KScheduler::IsSchedulerLockedByCurrentThread(m_kernel));ASSERT(this->IsDummyThread());// Wake up the waiting thread.@@ -1347,7 +1347,7 @@ void KThread::BeginWait(KThreadQueue* queue) {void KThread::NotifyAvailable(KSynchronizationObject* signaled_object, Result wait_result_) {// Lock the scheduler.- KScopedSchedulerLock sl(kernel);+ KScopedSchedulerLock sl(m_kernel);// If we're waiting, notify our queue that we're available.if (GetState() == ThreadState::Waiting) {@@ -1357,7 +1357,7 @@ void KThread::NotifyAvailable(KSynchronizationObject* signaled_object, Result wavoid KThread::EndWait(Result wait_result_) {// Lock the scheduler.- KScopedSchedulerLock sl(kernel);+ KScopedSchedulerLock sl(m_kernel);// If we're waiting, notify our queue that we're available.if (GetState() == ThreadState::Waiting) {@@ -1373,7 +1373,7 @@ void KThread::EndWait(Result wait_result_) {void KThread::CancelWait(Result wait_result_, bool cancel_timer_task) {// Lock the scheduler.- KScopedSchedulerLock sl(kernel);+ KScopedSchedulerLock sl(m_kernel);// If we're waiting, notify our queue that we're available.if (GetState() == ThreadState::Waiting) {@@ -1382,7 +1382,7 @@ void KThread::CancelWait(Result wait_result_, bool cancel_timer_task) {}void KThread::SetState(ThreadState state) {- KScopedSchedulerLock sl{kernel};+ KScopedSchedulerLock sl{m_kernel};// Clear debugging stateSetMutexWaitAddressForDebugging({});@@ -1393,7 +1393,7 @@ void KThread::SetState(ThreadState state) {static_cast<ThreadState>((old_state & ~ThreadState::Mask) | (state & ThreadState::Mask)),std::memory_order_relaxed);if (thread_state.load(std::memory_order_relaxed) != old_state) {- KScheduler::OnThreadStateChanged(kernel, this, old_state);+ KScheduler::OnThreadStateChanged(m_kernel, this, old_state);}}@@ -1427,20 +1427,20 @@ s32 GetCurrentCoreId(KernelCore& kernel) {KScopedDisableDispatch::~KScopedDisableDispatch() {// If we are shutting down the kernel, none of this is relevant anymore.- if (kernel.IsShuttingDown()) {+ if (m_kernel.IsShuttingDown()) {return;}- if (GetCurrentThread(kernel).GetDisableDispatchCount() <= 1) {- auto* scheduler = kernel.CurrentScheduler();+ if (GetCurrentThread(m_kernel).GetDisableDispatchCount() <= 1) {+ auto* scheduler = m_kernel.CurrentScheduler();- if (scheduler && !kernel.IsPhantomModeForSingleCore()) {+ if (scheduler && !m_kernel.IsPhantomModeForSingleCore()) {scheduler->RescheduleCurrentCore();} else {- KScheduler::RescheduleCurrentHLEThread(kernel);+ KScheduler::RescheduleCurrentHLEThread(m_kernel);}} else {- GetCurrentThread(kernel).EnableDispatch();+ GetCurrentThread(m_kernel).EnableDispatch();}}diff --git a/src/core/hle/kernel/k_thread.h b/src/core/hle/kernel/k_thread.hindex f4cb861a9c..e541ea0794 100644--- a/src/core/hle/kernel/k_thread.h+++ b/src/core/hle/kernel/k_thread.h@@ -128,7 +128,7 @@ public:static constexpr s32 IdleThreadPriority = Svc::LowestThreadPriority + 1;static constexpr s32 DummyThreadPriority = Svc::LowestThreadPriority + 2;- explicit KThread(KernelCore& kernel_);+ explicit KThread(KernelCore& kernel);~KThread() override;public:@@ -494,12 +494,12 @@ public:}void DisableDispatch() {- ASSERT(GetCurrentThread(kernel).GetDisableDispatchCount() >= 0);+ ASSERT(GetCurrentThread(m_kernel).GetDisableDispatchCount() >= 0);this->GetStackParameters().disable_count++;}void EnableDispatch() {- ASSERT(GetCurrentThread(kernel).GetDisableDispatchCount() > 0);+ ASSERT(GetCurrentThread(m_kernel).GetDisableDispatchCount() > 0);this->GetStackParameters().disable_count--;}@@ -970,9 +970,9 @@ public:class KScopedDisableDispatch {public:- [[nodiscard]] explicit KScopedDisableDispatch(KernelCore& kernel_) : kernel{kernel_} {+ [[nodiscard]] explicit KScopedDisableDispatch(KernelCore& kernel) : m_kernel{kernel} {// If we are shutting down the kernel, none of this is relevant anymore.- if (kernel.IsShuttingDown()) {+ if (m_kernel.IsShuttingDown()) {return;}GetCurrentThread(kernel).DisableDispatch();@@ -981,7 +981,7 @@ public:~KScopedDisableDispatch();private:- KernelCore& kernel;+ KernelCore& m_kernel;};inline void KTimerTask::OnTimer() {diff --git a/src/core/hle/kernel/k_thread_queue.h b/src/core/hle/kernel/k_thread_queue.hindex 8ec2f900bf..117af0919a 100644--- a/src/core/hle/kernel/k_thread_queue.h+++ b/src/core/hle/kernel/k_thread_queue.h@@ -31,7 +31,7 @@ private:class KThreadQueueWithoutEndWait : public KThreadQueue {public:- explicit KThreadQueueWithoutEndWait(KernelCore& kernel_) : KThreadQueue(kernel_) {}+ explicit KThreadQueueWithoutEndWait(KernelCore& kernel) : KThreadQueue(kernel) {}void EndWait(KThread* waiting_thread, Result wait_result) override final;};diff --git a/src/core/hle/kernel/k_transfer_memory.cpp b/src/core/hle/kernel/k_transfer_memory.cppindex c25cc2e39d..ceec364afc 100644--- a/src/core/hle/kernel/k_transfer_memory.cpp+++ b/src/core/hle/kernel/k_transfer_memory.cpp@@ -8,23 +8,23 @@namespace Kernel {-KTransferMemory::KTransferMemory(KernelCore& kernel_)- : KAutoObjectWithSlabHeapAndContainer{kernel_} {}+KTransferMemory::KTransferMemory(KernelCore& kernel)+ : KAutoObjectWithSlabHeapAndContainer{kernel} {}KTransferMemory::~KTransferMemory() = default;-Result KTransferMemory::Initialize(VAddr address_, std::size_t size_,- Svc::MemoryPermission owner_perm_) {+Result KTransferMemory::Initialize(VAddr address, std::size_t size,+ Svc::MemoryPermission owner_perm) {// Set members.- m_owner = GetCurrentProcessPointer(kernel);+ m_owner = GetCurrentProcessPointer(m_kernel);// TODO(bunnei): Lock for transfer memory// Set remaining tracking members.m_owner->Open();- m_owner_perm = owner_perm_;- m_address = address_;- m_size = size_;+ m_owner_perm = owner_perm;+ m_address = address;+ m_size = size;m_is_initialized = true;R_SUCCEED();diff --git a/src/core/hle/kernel/k_transfer_memory.h b/src/core/hle/kernel/k_transfer_memory.hindex 9a37bd903f..3d4d795a58 100644--- a/src/core/hle/kernel/k_transfer_memory.h+++ b/src/core/hle/kernel/k_transfer_memory.h@@ -23,10 +23,10 @@ class KTransferMemory finalKERNEL_AUTOOBJECT_TRAITS(KTransferMemory, KAutoObject);public:- explicit KTransferMemory(KernelCore& kernel_);+ explicit KTransferMemory(KernelCore& kernel);~KTransferMemory() override;- Result Initialize(VAddr address_, std::size_t size_, Svc::MemoryPermission owner_perm_);+ Result Initialize(VAddr address, std::size_t size, Svc::MemoryPermission owner_perm);void Finalize() override;diff --git a/src/core/hle/kernel/k_worker_task.h b/src/core/hle/kernel/k_worker_task.hindex ef591d8319..9a230c03c4 100644--- a/src/core/hle/kernel/k_worker_task.h+++ b/src/core/hle/kernel/k_worker_task.h@@ -9,7 +9,7 @@ namespace Kernel {class KWorkerTask : public KSynchronizationObject {public:- explicit KWorkerTask(KernelCore& kernel_);+ explicit KWorkerTask(KernelCore& kernel);void DoWorkerTask();};diff --git a/src/core/hle/kernel/k_worker_task_manager.cpp b/src/core/hle/kernel/k_worker_task_manager.cppindex 04042bf8f6..8ead395911 100644--- a/src/core/hle/kernel/k_worker_task_manager.cpp+++ b/src/core/hle/kernel/k_worker_task_manager.cpp@@ -10,7 +10,7 @@namespace Kernel {-KWorkerTask::KWorkerTask(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}+KWorkerTask::KWorkerTask(KernelCore& kernel) : KSynchronizationObject{kernel} {}void KWorkerTask::DoWorkerTask() {if (auto* const thread = this->DynamicCast<KThread*>(); thread != nullptr) {diff --git a/src/core/hle/kernel/k_worker_task_manager.h b/src/core/hle/kernel/k_worker_task_manager.hindex f6618883ee..8745a4ce22 100644--- a/src/core/hle/kernel/k_worker_task_manager.h+++ b/src/core/hle/kernel/k_worker_task_manager.h@@ -20,7 +20,7 @@ public:KWorkerTaskManager();- static void AddTask(KernelCore& kernel_, WorkerType type, KWorkerTask* task);+ static void AddTask(KernelCore& kernel, WorkerType type, KWorkerTask* task);private:void AddTask(KernelCore& kernel, KWorkerTask* task);diff --git a/src/core/hle/kernel/slab_helpers.h b/src/core/hle/kernel/slab_helpers.hindex b9f5066dea..d1bbc76709 100644--- a/src/core/hle/kernel/slab_helpers.h+++ b/src/core/hle/kernel/slab_helpers.h@@ -66,7 +66,7 @@ private:}public:- explicit KAutoObjectWithSlabHeap(KernelCore& kernel_) : Base(kernel_), kernel(kernel_) {}+ explicit KAutoObjectWithSlabHeap(KernelCore& kernel) : Base(kernel) {}virtual ~KAutoObjectWithSlabHeap() = default;virtual void Destroy() override {@@ -76,7 +76,7 @@ public:arg = this->GetPostDestroyArgument();this->Finalize();}- Free(kernel, static_cast<Derived*>(this));+ Free(Base::m_kernel, static_cast<Derived*>(this));if (is_initialized) {Derived::PostDestroy(arg);}@@ -90,7 +90,7 @@ public:}size_t GetSlabIndex() const {- return SlabHeap<Derived>(kernel).GetObjectIndex(static_cast<const Derived*>(this));+ return SlabHeap<Derived>(Base::m_kernel).GetObjectIndex(static_cast<const Derived*>(this));}public:@@ -125,9 +125,6 @@ public:static size_t GetNumRemaining(KernelCore& kernel) {return kernel.SlabHeap<Derived>().GetNumRemaining();}--protected:- KernelCore& kernel;};template <typename Derived, typename Base>@@ -144,18 +141,18 @@ private:}public:- KAutoObjectWithSlabHeapAndContainer(KernelCore& kernel_) : Base(kernel_) {}+ KAutoObjectWithSlabHeapAndContainer(KernelCore& kernel) : Base(kernel) {}virtual ~KAutoObjectWithSlabHeapAndContainer() {}virtual void Destroy() override {const bool is_initialized = this->IsInitialized();uintptr_t arg = 0;if (is_initialized) {- Base::kernel.ObjectListContainer().Unregister(this);+ Base::m_kernel.ObjectListContainer().Unregister(this);arg = this->GetPostDestroyArgument();this->Finalize();}- Free(Base::kernel, static_cast<Derived*>(this));+ Free(Base::m_kernel, static_cast<Derived*>(this));if (is_initialized) {Derived::PostDestroy(arg);}@@ -169,7 +166,7 @@ public:}size_t GetSlabIndex() const {- return SlabHeap<Derived>(Base::kernel).GetObjectIndex(static_cast<const Derived*>(this));+ return SlabHeap<Derived>(Base::m_kernel).GetObjectIndex(static_cast<const Derived*>(this));}public: