10 files changed, 62 insertions, 63 deletions

diff --git a/src/core/hle/kernel/k_code_memory.cpp b/src/core/hle/kernel/k_code_memory.cpp
index 0579b8b19..da57ceb21 100644
--- a/src/core/hle/kernel/k_code_memory.cpp
+++ b/src/core/hle/kernel/k_code_memory.cpp
@@ -7,7 +7,7 @@
 #include "core/hle/kernel/k_code_memory.h"
 #include "core/hle/kernel/k_light_lock.h"
 #include "core/hle/kernel/k_memory_block.h"
-#include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/slab_helpers.h"
diff --git a/src/core/hle/kernel/k_code_memory.h b/src/core/hle/kernel/k_code_memory.h
index 715c645bd..2410f74a3 100644
--- a/src/core/hle/kernel/k_code_memory.h
+++ b/src/core/hle/kernel/k_code_memory.h
@@ -7,7 +7,7 @@
 #include "core/device_memory.h"
 #include "core/hle/kernel/k_auto_object.h"
 #include "core/hle/kernel/k_light_lock.h"
-#include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/kernel/svc_types.h"
@@ -53,7 +53,7 @@ public:
     }
 
 private:
-    KPageLinkedList m_page_group{};
+    KPageGroup m_page_group{};
     KProcess* m_owner{};
     VAddr m_address{};
     KLightLock m_lock;
diff --git a/src/core/hle/kernel/k_memory_manager.cpp b/src/core/hle/kernel/k_memory_manager.cpp
index 0cdb4a050..5b0a9963a 100644
--- a/src/core/hle/kernel/k_memory_manager.cpp
+++ b/src/core/hle/kernel/k_memory_manager.cpp
@@ -11,7 +11,7 @@
 #include "core/device_memory.h"
 #include "core/hle/kernel/initial_process.h"
 #include "core/hle/kernel/k_memory_manager.h"
-#include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/svc_results.h"
 
@@ -208,7 +208,7 @@ PAddr KMemoryManager::AllocateAndOpenContinuous(size_t num_pages, size_t align_p
     return allocated_block;
 }
 
-Result KMemoryManager::AllocatePageGroupImpl(KPageLinkedList* out, size_t num_pages, Pool pool,
+Result KMemoryManager::AllocatePageGroupImpl(KPageGroup* out, size_t num_pages, Pool pool,
                                              Direction dir, bool random) {
     // Choose a heap based on our page size request.
     const s32 heap_index = KPageHeap::GetBlockIndex(num_pages);
@@ -257,7 +257,7 @@ Result KMemoryManager::AllocatePageGroupImpl(KPageLinkedList* out, size_t num_pa
     return ResultSuccess;
 }
 
-Result KMemoryManager::AllocateAndOpen(KPageLinkedList* out, size_t num_pages, u32 option) {
+Result KMemoryManager::AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 option) {
     ASSERT(out != nullptr);
     ASSERT(out->GetNumPages() == 0);
 
@@ -293,7 +293,7 @@ Result KMemoryManager::AllocateAndOpen(KPageLinkedList* out, size_t num_pages, u
     return ResultSuccess;
 }
 
-Result KMemoryManager::AllocateAndOpenForProcess(KPageLinkedList* out, size_t num_pages, u32 option,
+Result KMemoryManager::AllocateAndOpenForProcess(KPageGroup* out, size_t num_pages, u32 option,
                                                  u64 process_id, u8 fill_pattern) {
     ASSERT(out != nullptr);
     ASSERT(out->GetNumPages() == 0);
@@ -370,12 +370,12 @@ void KMemoryManager::Close(PAddr address, size_t num_pages) {
     }
 }
 
-void KMemoryManager::Close(const KPageLinkedList& pg) {
+void KMemoryManager::Close(const KPageGroup& pg) {
     for (const auto& node : pg.Nodes()) {
         Close(node.GetAddress(), node.GetNumPages());
     }
 }
-void KMemoryManager::Open(const KPageLinkedList& pg) {
+void KMemoryManager::Open(const KPageGroup& pg) {
     for (const auto& node : pg.Nodes()) {
         Open(node.GetAddress(), node.GetNumPages());
     }
diff --git a/src/core/hle/kernel/k_memory_manager.h b/src/core/hle/kernel/k_memory_manager.h
index 1ebda7a4b..dcb9b6348 100644
--- a/src/core/hle/kernel/k_memory_manager.h
+++ b/src/core/hle/kernel/k_memory_manager.h
@@ -19,7 +19,7 @@ class System;
 
 namespace Kernel {
 
-class KPageLinkedList;
+class KPageGroup;
 
 class KMemoryManager final {
 public:
@@ -65,17 +65,17 @@ public:
     }
 
     PAddr AllocateAndOpenContinuous(size_t num_pages, size_t align_pages, u32 option);
-    Result AllocateAndOpen(KPageLinkedList* out, size_t num_pages, u32 option);
-    Result AllocateAndOpenForProcess(KPageLinkedList* out, size_t num_pages, u32 option,
-                                     u64 process_id, u8 fill_pattern);
+    Result AllocateAndOpen(KPageGroup* out, size_t num_pages, u32 option);
+    Result AllocateAndOpenForProcess(KPageGroup* out, size_t num_pages, u32 option, u64 process_id,
+                                     u8 fill_pattern);
 
     static constexpr size_t MaxManagerCount = 10;
 
     void Close(PAddr address, size_t num_pages);
-    void Close(const KPageLinkedList& pg);
+    void Close(const KPageGroup& pg);
 
     void Open(PAddr address, size_t num_pages);
-    void Open(const KPageLinkedList& pg);
+    void Open(const KPageGroup& pg);
 
 public:
     static size_t CalculateManagementOverheadSize(size_t region_size) {
@@ -262,7 +262,7 @@ private:
         }
     }
 
-    Result AllocatePageGroupImpl(KPageLinkedList* out, size_t num_pages, Pool pool, Direction dir,
+    Result AllocatePageGroupImpl(KPageGroup* out, size_t num_pages, Pool pool, Direction dir,
                                  bool random);
 
 private:
diff --git a/src/core/hle/kernel/k_page_linked_list.h b/src/core/hle/kernel/k_page_group.h
index fc2ef9698..968753992 100644
--- a/src/core/hle/kernel/k_page_linked_list.h
+++ b/src/core/hle/kernel/k_page_group.h
@@ -12,7 +12,7 @@
 
 namespace Kernel {
 
-class KPageLinkedList final {
+class KPageGroup final {
 public:
     class Node final {
     public:
@@ -36,8 +36,8 @@ public:
     };
 
 public:
-    KPageLinkedList() = default;
-    KPageLinkedList(u64 address, u64 num_pages) {
+    KPageGroup() = default;
+    KPageGroup(u64 address, u64 num_pages) {
         ASSERT(AddBlock(address, num_pages).IsSuccess());
     }
 
@@ -57,7 +57,7 @@ public:
         return num_pages;
     }
 
-    bool IsEqual(KPageLinkedList& other) const {
+    bool IsEqual(KPageGroup& other) const {
         auto this_node = nodes.begin();
         auto other_node = other.nodes.begin();
         while (this_node != nodes.end() && other_node != other.nodes.end()) {
diff --git a/src/core/hle/kernel/k_page_table.cpp b/src/core/hle/kernel/k_page_table.cpp
index 909162716..d975de844 100644
--- a/src/core/hle/kernel/k_page_table.cpp
+++ b/src/core/hle/kernel/k_page_table.cpp
@@ -9,7 +9,7 @@
 #include "core/hle/kernel/k_address_space_info.h"
 #include "core/hle/kernel/k_memory_block.h"
 #include "core/hle/kernel/k_memory_block_manager.h"
-#include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_resource_limit.h"
@@ -271,7 +271,7 @@ Result KPageTable::MapProcessCode(VAddr addr, std::size_t num_pages, KMemoryStat
     R_TRY(this->CheckMemoryState(addr, size, KMemoryState::All, KMemoryState::Free,
                                  KMemoryPermission::None, KMemoryPermission::None,
                                  KMemoryAttribute::None, KMemoryAttribute::None));
-    KPageLinkedList pg;
+    KPageGroup pg;
     R_TRY(system.Kernel().MemoryManager().AllocateAndOpen(
         &pg, num_pages,
         KMemoryManager::EncodeOption(KMemoryManager::Pool::Application, allocation_option)));
@@ -313,7 +313,7 @@ Result KPageTable::MapCodeMemory(VAddr dst_address, VAddr src_address, std::size
         const std::size_t num_pages = size / PageSize;
 
         // Create page groups for the memory being mapped.
-        KPageLinkedList pg;
+        KPageGroup pg;
         AddRegionToPages(src_address, num_pages, pg);
 
         // Reprotect the source as kernel-read/not mapped.
@@ -489,7 +489,7 @@ VAddr KPageTable::FindFreeArea(VAddr region_start, std::size_t region_num_pages,
     return address;
 }
 
-Result KPageTable::MakePageGroup(KPageLinkedList& pg, VAddr addr, size_t num_pages) {
+Result KPageTable::MakePageGroup(KPageGroup& pg, VAddr addr, size_t num_pages) {
     ASSERT(this->IsLockedByCurrentThread());
 
     const size_t size = num_pages * PageSize;
@@ -541,7 +541,7 @@ Result KPageTable::MakePageGroup(KPageLinkedList& pg, VAddr addr, size_t num_pag
     return ResultSuccess;
 }
 
-bool KPageTable::IsValidPageGroup(const KPageLinkedList& pg_ll, VAddr addr, size_t num_pages) {
+bool KPageTable::IsValidPageGroup(const KPageGroup& pg_ll, VAddr addr, size_t num_pages) {
     ASSERT(this->IsLockedByCurrentThread());
 
     const size_t size = num_pages * PageSize;
@@ -721,7 +721,7 @@ Result KPageTable::MapPhysicalMemory(VAddr address, std::size_t size) {
             R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);
 
             // Allocate pages for the new memory.
-            KPageLinkedList pg;
+            KPageGroup pg;
             R_TRY(system.Kernel().MemoryManager().AllocateAndOpenForProcess(
                 &pg, (size - mapped_size) / PageSize,
                 KMemoryManager::EncodeOption(memory_pool, allocation_option), 0, 0));
@@ -972,7 +972,7 @@ Result KPageTable::UnmapPhysicalMemory(VAddr address, std::size_t size) {
     }
 
     // Make a page group for the unmap region.
-    KPageLinkedList pg;
+    KPageGroup pg;
     {
         auto& impl = this->PageTableImpl();
 
@@ -1147,7 +1147,7 @@ Result KPageTable::MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size) {
         return ResultInvalidCurrentMemory;
     }
 
-    KPageLinkedList page_linked_list;
+    KPageGroup page_linked_list;
     const std::size_t num_pages{size / PageSize};
 
     AddRegionToPages(src_addr, num_pages, page_linked_list);
@@ -1188,8 +1188,8 @@ Result KPageTable::UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size)
                                   KMemoryPermission::None, KMemoryAttribute::Mask,
                                   KMemoryAttribute::None, KMemoryAttribute::IpcAndDeviceMapped));
 
-    KPageLinkedList src_pages;
-    KPageLinkedList dst_pages;
+    KPageGroup src_pages;
+    KPageGroup dst_pages;
     const std::size_t num_pages{size / PageSize};
 
     AddRegionToPages(src_addr, num_pages, src_pages);
@@ -1215,7 +1215,7 @@ Result KPageTable::UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size)
     return ResultSuccess;
 }
 
-Result KPageTable::MapPages(VAddr addr, const KPageLinkedList& page_linked_list,
+Result KPageTable::MapPages(VAddr addr, const KPageGroup& page_linked_list,
                             KMemoryPermission perm) {
     ASSERT(this->IsLockedByCurrentThread());
 
@@ -1239,7 +1239,7 @@ Result KPageTable::MapPages(VAddr addr, const KPageLinkedList& page_linked_list,
     return ResultSuccess;
 }
 
-Result KPageTable::MapPages(VAddr address, KPageLinkedList& page_linked_list, KMemoryState state,
+Result KPageTable::MapPages(VAddr address, KPageGroup& page_linked_list, KMemoryState state,
                             KMemoryPermission perm) {
     // Check that the map is in range.
     const std::size_t num_pages{page_linked_list.GetNumPages()};
@@ -1303,7 +1303,7 @@ Result KPageTable::MapPages(VAddr* out_addr, std::size_t num_pages, std::size_t
     return ResultSuccess;
 }
 
-Result KPageTable::UnmapPages(VAddr addr, const KPageLinkedList& page_linked_list) {
+Result KPageTable::UnmapPages(VAddr addr, const KPageGroup& page_linked_list) {
     ASSERT(this->IsLockedByCurrentThread());
 
     VAddr cur_addr{addr};
@@ -1321,7 +1321,7 @@ Result KPageTable::UnmapPages(VAddr addr, const KPageLinkedList& page_linked_lis
     return ResultSuccess;
 }
 
-Result KPageTable::UnmapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state) {
+Result KPageTable::UnmapPages(VAddr addr, KPageGroup& page_linked_list, KMemoryState state) {
     // Check that the unmap is in range.
     const std::size_t num_pages{page_linked_list.GetNumPages()};
     const std::size_t size{num_pages * PageSize};
@@ -1368,7 +1368,7 @@ Result KPageTable::UnmapPages(VAddr address, std::size_t num_pages, KMemoryState
     return ResultSuccess;
 }
 
-Result KPageTable::MakeAndOpenPageGroup(KPageLinkedList* out, VAddr address, size_t num_pages,
+Result KPageTable::MakeAndOpenPageGroup(KPageGroup* out, VAddr address, size_t num_pages,
                                         KMemoryState state_mask, KMemoryState state,
                                         KMemoryPermission perm_mask, KMemoryPermission perm,
                                         KMemoryAttribute attr_mask, KMemoryAttribute attr) {
@@ -1641,7 +1641,7 @@ Result KPageTable::SetHeapSize(VAddr* out, std::size_t size) {
     R_UNLESS(memory_reservation.Succeeded(), ResultLimitReached);
 
     // Allocate pages for the heap extension.
-    KPageLinkedList pg;
+    KPageGroup pg;
     R_TRY(system.Kernel().MemoryManager().AllocateAndOpen(
         &pg, allocation_size / PageSize,
         KMemoryManager::EncodeOption(memory_pool, allocation_option)));
@@ -1716,7 +1716,7 @@ ResultVal<VAddr> KPageTable::AllocateAndMapMemory(std::size_t needed_num_pages,
     if (is_map_only) {
         R_TRY(Operate(addr, needed_num_pages, perm, OperationType::Map, map_addr));
     } else {
-        KPageLinkedList page_group;
+        KPageGroup page_group;
         R_TRY(system.Kernel().MemoryManager().AllocateAndOpenForProcess(
             &page_group, needed_num_pages,
             KMemoryManager::EncodeOption(memory_pool, allocation_option), 0, 0));
@@ -1774,7 +1774,7 @@ Result KPageTable::UnlockForDeviceAddressSpace(VAddr addr, std::size_t size) {
     return ResultSuccess;
 }
 
-Result KPageTable::LockForCodeMemory(KPageLinkedList* out, VAddr addr, std::size_t size) {
+Result KPageTable::LockForCodeMemory(KPageGroup* out, VAddr addr, std::size_t size) {
     return this->LockMemoryAndOpen(
         out, nullptr, addr, size, KMemoryState::FlagCanCodeMemory, KMemoryState::FlagCanCodeMemory,
         KMemoryPermission::All, KMemoryPermission::UserReadWrite, KMemoryAttribute::All,
@@ -1784,7 +1784,7 @@ Result KPageTable::LockForCodeMemory(KPageLinkedList* out, VAddr addr, std::size
         KMemoryAttribute::Locked);
 }
 
-Result KPageTable::UnlockForCodeMemory(VAddr addr, std::size_t size, const KPageLinkedList& pg) {
+Result KPageTable::UnlockForCodeMemory(VAddr addr, std::size_t size, const KPageGroup& pg) {
     return this->UnlockMemory(
         addr, size, KMemoryState::FlagCanCodeMemory, KMemoryState::FlagCanCodeMemory,
         KMemoryPermission::None, KMemoryPermission::None, KMemoryAttribute::All,
@@ -1816,7 +1816,7 @@ bool KPageTable::IsRegionContiguous(VAddr addr, u64 size) const {
 }
 
 void KPageTable::AddRegionToPages(VAddr start, std::size_t num_pages,
-                                  KPageLinkedList& page_linked_list) {
+                                  KPageGroup& page_linked_list) {
     VAddr addr{start};
     while (addr < start + (num_pages * PageSize)) {
         const PAddr paddr{GetPhysicalAddr(addr)};
@@ -1835,7 +1835,7 @@ VAddr KPageTable::AllocateVirtualMemory(VAddr start, std::size_t region_num_page
                                        IsKernel() ? 1 : 4);
 }
 
-Result KPageTable::Operate(VAddr addr, std::size_t num_pages, const KPageLinkedList& page_group,
+Result KPageTable::Operate(VAddr addr, std::size_t num_pages, const KPageGroup& page_group,
                            OperationType operation) {
     ASSERT(this->IsLockedByCurrentThread());
 
@@ -2119,8 +2119,8 @@ Result KPageTable::CheckMemoryState(KMemoryState* out_state, KMemoryPermission*
     return ResultSuccess;
 }
 
-Result KPageTable::LockMemoryAndOpen(KPageLinkedList* out_pg, PAddr* out_paddr, VAddr addr,
-                                     size_t size, KMemoryState state_mask, KMemoryState state,
+Result KPageTable::LockMemoryAndOpen(KPageGroup* out_pg, PAddr* out_paddr, VAddr addr, size_t size,
+                                     KMemoryState state_mask, KMemoryState state,
                                      KMemoryPermission perm_mask, KMemoryPermission perm,
                                      KMemoryAttribute attr_mask, KMemoryAttribute attr,
                                      KMemoryPermission new_perm, KMemoryAttribute lock_attr) {
@@ -2181,7 +2181,7 @@ Result KPageTable::UnlockMemory(VAddr addr, size_t size, KMemoryState state_mask
                                 KMemoryState state, KMemoryPermission perm_mask,
                                 KMemoryPermission perm, KMemoryAttribute attr_mask,
                                 KMemoryAttribute attr, KMemoryPermission new_perm,
-                                KMemoryAttribute lock_attr, const KPageLinkedList* pg) {
+                                KMemoryAttribute lock_attr, const KPageGroup* pg) {
     // Validate basic preconditions.
     ASSERT((attr_mask & lock_attr) == lock_attr);
     ASSERT((attr & lock_attr) == lock_attr);
diff --git a/src/core/hle/kernel/k_page_table.h b/src/core/hle/kernel/k_page_table.h
index 64e770f8f..25774f232 100644
--- a/src/core/hle/kernel/k_page_table.h
+++ b/src/core/hle/kernel/k_page_table.h
@@ -46,7 +46,7 @@ public:
     Result UnmapPhysicalMemory(VAddr addr, std::size_t size);
     Result MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
     Result UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
-    Result MapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state,
+    Result MapPages(VAddr addr, KPageGroup& page_linked_list, KMemoryState state,
                     KMemoryPermission perm);
     Result MapPages(VAddr* out_addr, std::size_t num_pages, std::size_t alignment, PAddr phys_addr,
                     KMemoryState state, KMemoryPermission perm) {
@@ -54,7 +54,7 @@ public:
                               this->GetRegionAddress(state), this->GetRegionSize(state) / PageSize,
                               state, perm);
     }
-    Result UnmapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state);
+    Result UnmapPages(VAddr addr, KPageGroup& page_linked_list, KMemoryState state);
     Result UnmapPages(VAddr address, std::size_t num_pages, KMemoryState state);
     Result SetProcessMemoryPermission(VAddr addr, std::size_t size, Svc::MemoryPermission svc_perm);
     KMemoryInfo QueryInfo(VAddr addr);
@@ -70,9 +70,9 @@ public:
                                           KMemoryPermission perm, PAddr map_addr = 0);
     Result LockForDeviceAddressSpace(VAddr addr, std::size_t size);
     Result UnlockForDeviceAddressSpace(VAddr addr, std::size_t size);
-    Result LockForCodeMemory(KPageLinkedList* out, VAddr addr, std::size_t size);
-    Result UnlockForCodeMemory(VAddr addr, std::size_t size, const KPageLinkedList& pg);
-    Result MakeAndOpenPageGroup(KPageLinkedList* out, VAddr address, size_t num_pages,
+    Result LockForCodeMemory(KPageGroup* out, VAddr addr, std::size_t size);
+    Result UnlockForCodeMemory(VAddr addr, std::size_t size, const KPageGroup& pg);
+    Result MakeAndOpenPageGroup(KPageGroup* out, VAddr address, size_t num_pages,
                                 KMemoryState state_mask, KMemoryState state,
                                 KMemoryPermission perm_mask, KMemoryPermission perm,
                                 KMemoryAttribute attr_mask, KMemoryAttribute attr);
@@ -101,18 +101,18 @@ private:
                                                                 KMemoryAttribute::DeviceShared;
 
     Result InitializeMemoryLayout(VAddr start, VAddr end);
-    Result MapPages(VAddr addr, const KPageLinkedList& page_linked_list, KMemoryPermission perm);
+    Result MapPages(VAddr addr, const KPageGroup& page_linked_list, KMemoryPermission perm);
     Result MapPages(VAddr* out_addr, std::size_t num_pages, std::size_t alignment, PAddr phys_addr,
                     bool is_pa_valid, VAddr region_start, std::size_t region_num_pages,
                     KMemoryState state, KMemoryPermission perm);
-    Result UnmapPages(VAddr addr, const KPageLinkedList& page_linked_list);
+    Result UnmapPages(VAddr addr, const KPageGroup& page_linked_list);
     bool IsRegionMapped(VAddr address, u64 size);
     bool IsRegionContiguous(VAddr addr, u64 size) const;
-    void AddRegionToPages(VAddr start, std::size_t num_pages, KPageLinkedList& page_linked_list);
+    void AddRegionToPages(VAddr start, std::size_t num_pages, KPageGroup& page_linked_list);
     KMemoryInfo QueryInfoImpl(VAddr addr);
     VAddr AllocateVirtualMemory(VAddr start, std::size_t region_num_pages, u64 needed_num_pages,
                                 std::size_t align);
-    Result Operate(VAddr addr, std::size_t num_pages, const KPageLinkedList& page_group,
+    Result Operate(VAddr addr, std::size_t num_pages, const KPageGroup& page_group,
                    OperationType operation);
     Result Operate(VAddr addr, std::size_t num_pages, KMemoryPermission perm,
                    OperationType operation, PAddr map_addr = 0);
@@ -159,7 +159,7 @@ private:
                                       attr_mask, attr, ignore_attr);
     }
 
-    Result LockMemoryAndOpen(KPageLinkedList* out_pg, PAddr* out_paddr, VAddr addr, size_t size,
+    Result LockMemoryAndOpen(KPageGroup* out_pg, PAddr* out_paddr, VAddr addr, size_t size,
                              KMemoryState state_mask, KMemoryState state,
                              KMemoryPermission perm_mask, KMemoryPermission perm,
                              KMemoryAttribute attr_mask, KMemoryAttribute attr,
@@ -168,10 +168,10 @@ private:
                         KMemoryPermission perm_mask, KMemoryPermission perm,
                         KMemoryAttribute attr_mask, KMemoryAttribute attr,
                         KMemoryPermission new_perm, KMemoryAttribute lock_attr,
-                        const KPageLinkedList* pg);
+                        const KPageGroup* pg);
 
-    Result MakePageGroup(KPageLinkedList& pg, VAddr addr, size_t num_pages);
-    bool IsValidPageGroup(const KPageLinkedList& pg, VAddr addr, size_t num_pages);
+    Result MakePageGroup(KPageGroup& pg, VAddr addr, size_t num_pages);
+    bool IsValidPageGroup(const KPageGroup& pg, VAddr addr, size_t num_pages);
 
     bool IsLockedByCurrentThread() const {
         return general_lock.IsLockedByCurrentThread();
diff --git a/src/core/hle/kernel/k_shared_memory.cpp b/src/core/hle/kernel/k_shared_memory.cpp
index a1cd83873..b77735736 100644
--- a/src/core/hle/kernel/k_shared_memory.cpp
+++ b/src/core/hle/kernel/k_shared_memory.cpp
@@ -19,8 +19,7 @@ KSharedMemory::~KSharedMemory() {
 }
 
 Result KSharedMemory::Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
-                                 KPageLinkedList&& page_list_,
-                                 Svc::MemoryPermission owner_permission_,
+                                 KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,
                                  Svc::MemoryPermission user_permission_, PAddr physical_address_,
                                  std::size_t size_, std::string name_) {
     // Set members.
diff --git a/src/core/hle/kernel/k_shared_memory.h b/src/core/hle/kernel/k_shared_memory.h
index f84efa236..2c1db0e70 100644
--- a/src/core/hle/kernel/k_shared_memory.h
+++ b/src/core/hle/kernel/k_shared_memory.h
@@ -9,7 +9,7 @@
 #include "common/common_types.h"
 #include "core/device_memory.h"
 #include "core/hle/kernel/k_memory_block.h"
-#include "core/hle/kernel/k_page_linked_list.h"
+#include "core/hle/kernel/k_page_group.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/slab_helpers.h"
 #include "core/hle/result.h"
@@ -27,7 +27,7 @@ public:
     ~KSharedMemory() override;
 
     Result Initialize(Core::DeviceMemory& device_memory_, KProcess* owner_process_,
-                      KPageLinkedList&& page_list_, Svc::MemoryPermission owner_permission_,
+                      KPageGroup&& page_list_, Svc::MemoryPermission owner_permission_,
                       Svc::MemoryPermission user_permission_, PAddr physical_address_,
                       std::size_t size_, std::string name_);
 
@@ -77,7 +77,7 @@ public:
 private:
     Core::DeviceMemory* device_memory;
     KProcess* owner_process{};
-    KPageLinkedList page_list;
+    KPageGroup page_list;
     Svc::MemoryPermission owner_permission{};
     Svc::MemoryPermission user_permission{};
     PAddr physical_address{};
diff --git a/src/core/hle/kernel/svc.cpp b/src/core/hle/kernel/svc.cpp
index de8a0864c..e809c820f 100644
--- a/src/core/hle/kernel/svc.cpp
+++ b/src/core/hle/kernel/svc.cpp
@@ -1365,7 +1365,7 @@ static Result MapProcessMemory(Core::System& system, VAddr dst_address, Handle p
              ResultInvalidMemoryRegion);
 
     // Create a new page group.
-    KPageLinkedList pg;
+    KPageGroup pg;
     R_TRY(src_pt.MakeAndOpenPageGroup(
         std::addressof(pg), src_address, size / PageSize, KMemoryState::FlagCanMapProcess,
         KMemoryState::FlagCanMapProcess, KMemoryPermission::None, KMemoryPermission::None,