core: hle: kernel: k_page_table: Impl. LockForUn/MapDeviceAddressSpace, cleanup.

src/core/hle/kernel/k_page_table.h

@@ -36,60 +36,66 @@ public:
     ~KPageTable();
 
     Result InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr,
-                                VAddr code_addr, std::size_t code_size,
+                                VAddr code_addr, size_t code_size,
                                 KMemoryBlockSlabManager* mem_block_slab_manager,
                                 KMemoryManager::Pool pool);
 
     void Finalize();
 
-    Result MapProcessCode(VAddr addr, std::size_t pages_count, KMemoryState state,
+    Result MapProcessCode(VAddr addr, size_t pages_count, KMemoryState state,
                           KMemoryPermission perm);
-    Result MapCodeMemory(VAddr dst_address, VAddr src_address, std::size_t size);
+    Result MapCodeMemory(VAddr dst_address, VAddr src_address, size_t size);
-    Result UnmapCodeMemory(VAddr dst_address, VAddr src_address, std::size_t size,
+    Result UnmapCodeMemory(VAddr dst_address, VAddr src_address, size_t size,
                            ICacheInvalidationStrategy icache_invalidation_strategy);
-    Result UnmapProcessMemory(VAddr dst_addr, std::size_t size, KPageTable& src_page_table,
+    Result UnmapProcessMemory(VAddr dst_addr, size_t size, KPageTable& src_page_table,
                               VAddr src_addr);
-    Result MapPhysicalMemory(VAddr addr, std::size_t size);
+    Result MapPhysicalMemory(VAddr addr, size_t size);
-    Result UnmapPhysicalMemory(VAddr addr, std::size_t size);
+    Result UnmapPhysicalMemory(VAddr addr, size_t size);
-    Result MapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
+    Result MapMemory(VAddr dst_addr, VAddr src_addr, size_t size);
-    Result UnmapMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
+    Result UnmapMemory(VAddr dst_addr, VAddr src_addr, size_t size);
     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,
+    Result MapPages(VAddr* out_addr, size_t num_pages, size_t alignment, PAddr phys_addr,
                     KMemoryState state, KMemoryPermission perm) {
         return this->MapPages(out_addr, num_pages, alignment, phys_addr, true,
                               this->GetRegionAddress(state), this->GetRegionSize(state) / PageSize,
                               state, perm);
     }
     Result UnmapPages(VAddr addr, KPageGroup& page_linked_list, KMemoryState state);
-    Result UnmapPages(VAddr address, std::size_t num_pages, KMemoryState state);
+    Result UnmapPages(VAddr address, size_t num_pages, KMemoryState state);
-    Result SetProcessMemoryPermission(VAddr addr, std::size_t size, Svc::MemoryPermission svc_perm);
+    Result SetProcessMemoryPermission(VAddr addr, size_t size, Svc::MemoryPermission svc_perm);
     KMemoryInfo QueryInfo(VAddr addr);
-    Result SetMemoryPermission(VAddr addr, std::size_t size, Svc::MemoryPermission perm);
+    Result SetMemoryPermission(VAddr addr, size_t size, Svc::MemoryPermission perm);
-    Result SetMemoryAttribute(VAddr addr, std::size_t size, u32 mask, u32 attr);
+    Result SetMemoryAttribute(VAddr addr, size_t size, u32 mask, u32 attr);
-    Result SetMaxHeapSize(std::size_t size);
+    Result SetMaxHeapSize(size_t size);
-    Result SetHeapSize(VAddr* out, std::size_t size);
+    Result SetHeapSize(VAddr* out, size_t size);
-    ResultVal<VAddr> AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align,
+    ResultVal<VAddr> AllocateAndMapMemory(size_t needed_num_pages, size_t align, bool is_map_only,
-                                          bool is_map_only, VAddr region_start,
+                                          VAddr region_start, size_t region_num_pages,
-                                          std::size_t region_num_pages, KMemoryState state,
+                                          KMemoryState state, KMemoryPermission perm,
-                                          KMemoryPermission perm, PAddr map_addr = 0);
+                                          PAddr map_addr = 0);
-    Result UnlockForDeviceAddressSpace(VAddr addr, std::size_t size);
+
-    Result LockForCodeMemory(KPageGroup* out, VAddr addr, std::size_t size);
+    Result LockForMapDeviceAddressSpace(VAddr address, size_t size, KMemoryPermission perm,
-    Result UnlockForCodeMemory(VAddr addr, std::size_t size, const KPageGroup& pg);
+                                        bool is_aligned);
+    Result LockForUnmapDeviceAddressSpace(VAddr address, size_t size);
+
+    Result UnlockForDeviceAddressSpace(VAddr addr, size_t size);
+
+    Result LockForCodeMemory(KPageGroup* out, VAddr addr, size_t size);
+    Result UnlockForCodeMemory(VAddr addr, 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);
 
     Common::PageTable& PageTableImpl() {
-        return page_table_impl;
+        return m_page_table_impl;
     }
 
     const Common::PageTable& PageTableImpl() const {
-        return page_table_impl;
+        return m_page_table_impl;
     }
 
-    bool CanContain(VAddr addr, std::size_t size, KMemoryState state) const;
+    bool CanContain(VAddr addr, size_t size, KMemoryState state) const;
 
 private:
     enum class OperationType : u32 {
@@ -104,30 +110,30 @@ private:
         KMemoryAttribute::IpcLocked | KMemoryAttribute::DeviceShared;
 
     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,
+    Result MapPages(VAddr* out_addr, size_t num_pages, size_t alignment, PAddr phys_addr,
-                    bool is_pa_valid, VAddr region_start, std::size_t region_num_pages,
+                    bool is_pa_valid, VAddr region_start, size_t region_num_pages,
                     KMemoryState state, KMemoryPermission perm);
     Result UnmapPages(VAddr addr, const KPageGroup& page_linked_list);
     bool IsRegionContiguous(VAddr addr, u64 size) const;
-    void AddRegionToPages(VAddr start, std::size_t num_pages, KPageGroup& page_linked_list);
+    void AddRegionToPages(VAddr start, 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,
+    VAddr AllocateVirtualMemory(VAddr start, size_t region_num_pages, u64 needed_num_pages,
-                                std::size_t align);
+                                size_t align);
-    Result Operate(VAddr addr, std::size_t num_pages, const KPageGroup& page_group,
+    Result Operate(VAddr addr, size_t num_pages, const KPageGroup& page_group,
                    OperationType operation);
-    Result Operate(VAddr addr, std::size_t num_pages, KMemoryPermission perm,
+    Result Operate(VAddr addr, size_t num_pages, KMemoryPermission perm, OperationType operation,
-                   OperationType operation, PAddr map_addr = 0);
+                   PAddr map_addr = 0);
     VAddr GetRegionAddress(KMemoryState state) const;
-    std::size_t GetRegionSize(KMemoryState state) const;
+    size_t GetRegionSize(KMemoryState state) const;
 
-    VAddr FindFreeArea(VAddr region_start, std::size_t region_num_pages, std::size_t num_pages,
+    VAddr FindFreeArea(VAddr region_start, size_t region_num_pages, size_t num_pages,
-                       std::size_t alignment, std::size_t offset, std::size_t guard_pages);
+                       size_t alignment, size_t offset, size_t guard_pages);
 
-    Result CheckMemoryStateContiguous(std::size_t* out_blocks_needed, VAddr addr, std::size_t size,
+    Result CheckMemoryStateContiguous(size_t* out_blocks_needed, VAddr addr, size_t size,
                                       KMemoryState state_mask, KMemoryState state,
                                       KMemoryPermission perm_mask, KMemoryPermission perm,
                                       KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
-    Result CheckMemoryStateContiguous(VAddr addr, std::size_t size, KMemoryState state_mask,
+    Result CheckMemoryStateContiguous(VAddr addr, size_t size, KMemoryState state_mask,
                                       KMemoryState state, KMemoryPermission perm_mask,
                                       KMemoryPermission perm, KMemoryAttribute attr_mask,
                                       KMemoryAttribute attr) const {
@@ -139,12 +145,12 @@ private:
                             KMemoryPermission perm_mask, KMemoryPermission perm,
                             KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
     Result CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
-                            KMemoryAttribute* out_attr, std::size_t* out_blocks_needed, VAddr addr,
+                            KMemoryAttribute* out_attr, size_t* out_blocks_needed, VAddr addr,
-                            std::size_t size, KMemoryState state_mask, KMemoryState state,
+                            size_t size, KMemoryState state_mask, KMemoryState state,
                             KMemoryPermission perm_mask, KMemoryPermission perm,
                             KMemoryAttribute attr_mask, KMemoryAttribute attr,
                             KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const;
-    Result CheckMemoryState(std::size_t* out_blocks_needed, VAddr addr, std::size_t size,
+    Result CheckMemoryState(size_t* out_blocks_needed, VAddr addr, size_t size,
                             KMemoryState state_mask, KMemoryState state,
                             KMemoryPermission perm_mask, KMemoryPermission perm,
                             KMemoryAttribute attr_mask, KMemoryAttribute attr,
@@ -152,8 +158,8 @@ private:
         return CheckMemoryState(nullptr, nullptr, nullptr, out_blocks_needed, addr, size,
                                 state_mask, state, perm_mask, perm, attr_mask, attr, ignore_attr);
     }
-    Result CheckMemoryState(VAddr addr, std::size_t size, KMemoryState state_mask,
+    Result CheckMemoryState(VAddr addr, size_t size, KMemoryState state_mask, KMemoryState state,
-                            KMemoryState state, KMemoryPermission perm_mask, KMemoryPermission perm,
+                            KMemoryPermission perm_mask, KMemoryPermission perm,
                             KMemoryAttribute attr_mask, KMemoryAttribute attr,
                             KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
         return this->CheckMemoryState(nullptr, addr, size, state_mask, state, perm_mask, perm,
@@ -175,13 +181,13 @@ private:
     bool IsValidPageGroup(const KPageGroup& pg, VAddr addr, size_t num_pages);
 
     bool IsLockedByCurrentThread() const {
-        return general_lock.IsLockedByCurrentThread();
+        return m_general_lock.IsLockedByCurrentThread();
     }
 
     bool IsHeapPhysicalAddress(const KMemoryLayout& layout, PAddr phys_addr) {
         ASSERT(this->IsLockedByCurrentThread());
 
-        return layout.IsHeapPhysicalAddress(cached_physical_heap_region, phys_addr);
+        return layout.IsHeapPhysicalAddress(m_cached_physical_heap_region, phys_addr);
     }
 
     bool GetPhysicalAddressLocked(PAddr* out, VAddr virt_addr) const {
@@ -192,93 +198,93 @@ private:
         return *out != 0;
     }
 
-    mutable KLightLock general_lock;
+    mutable KLightLock m_general_lock;
-    mutable KLightLock map_physical_memory_lock;
+    mutable KLightLock m_map_physical_memory_lock;
 
 public:
     constexpr VAddr GetAddressSpaceStart() const {
-        return address_space_start;
+        return m_address_space_start;
     }
     constexpr VAddr GetAddressSpaceEnd() const {
-        return address_space_end;
+        return m_address_space_end;
     }
-    constexpr std::size_t GetAddressSpaceSize() const {
+    constexpr size_t GetAddressSpaceSize() const {
-        return address_space_end - address_space_start;
+        return m_address_space_end - m_address_space_start;
     }
     constexpr VAddr GetHeapRegionStart() const {
-        return heap_region_start;
+        return m_heap_region_start;
     }
     constexpr VAddr GetHeapRegionEnd() const {
-        return heap_region_end;
+        return m_heap_region_end;
     }
-    constexpr std::size_t GetHeapRegionSize() const {
+    constexpr size_t GetHeapRegionSize() const {
-        return heap_region_end - heap_region_start;
+        return m_heap_region_end - m_heap_region_start;
     }
     constexpr VAddr GetAliasRegionStart() const {
-        return alias_region_start;
+        return m_alias_region_start;
     }
     constexpr VAddr GetAliasRegionEnd() const {
-        return alias_region_end;
+        return m_alias_region_end;
     }
-    constexpr std::size_t GetAliasRegionSize() const {
+    constexpr size_t GetAliasRegionSize() const {
-        return alias_region_end - alias_region_start;
+        return m_alias_region_end - m_alias_region_start;
     }
     constexpr VAddr GetStackRegionStart() const {
-        return stack_region_start;
+        return m_stack_region_start;
     }
     constexpr VAddr GetStackRegionEnd() const {
-        return stack_region_end;
+        return m_stack_region_end;
     }
-    constexpr std::size_t GetStackRegionSize() const {
+    constexpr size_t GetStackRegionSize() const {
-        return stack_region_end - stack_region_start;
+        return m_stack_region_end - m_stack_region_start;
     }
     constexpr VAddr GetKernelMapRegionStart() const {
-        return kernel_map_region_start;
+        return m_kernel_map_region_start;
     }
     constexpr VAddr GetKernelMapRegionEnd() const {
-        return kernel_map_region_end;
+        return m_kernel_map_region_end;
     }
     constexpr VAddr GetCodeRegionStart() const {
-        return code_region_start;
+        return m_code_region_start;
     }
     constexpr VAddr GetCodeRegionEnd() const {
-        return code_region_end;
+        return m_code_region_end;
     }
     constexpr VAddr GetAliasCodeRegionStart() const {
-        return alias_code_region_start;
+        return m_alias_code_region_start;
     }
     constexpr VAddr GetAliasCodeRegionSize() const {
-        return alias_code_region_end - alias_code_region_start;
+        return m_alias_code_region_end - m_alias_code_region_start;
     }
-    std::size_t GetNormalMemorySize() {
+    size_t GetNormalMemorySize() {
-        KScopedLightLock lk(general_lock);
+        KScopedLightLock lk(m_general_lock);
-        return GetHeapSize() + mapped_physical_memory_size;
+        return GetHeapSize() + m_mapped_physical_memory_size;
     }
-    constexpr std::size_t GetAddressSpaceWidth() const {
+    constexpr size_t GetAddressSpaceWidth() const {
-        return address_space_width;
+        return m_address_space_width;
     }
-    constexpr std::size_t GetHeapSize() const {
+    constexpr size_t GetHeapSize() const {
-        return current_heap_end - heap_region_start;
+        return m_current_heap_end - m_heap_region_start;
     }
-    constexpr bool IsInsideAddressSpace(VAddr address, std::size_t size) const {
+    constexpr bool IsInsideAddressSpace(VAddr address, size_t size) const {
-        return address_space_start <= address && address + size - 1 <= address_space_end - 1;
+        return m_address_space_start <= address && address + size - 1 <= m_address_space_end - 1;
     }
-    constexpr bool IsOutsideAliasRegion(VAddr address, std::size_t size) const {
+    constexpr bool IsOutsideAliasRegion(VAddr address, size_t size) const {
-        return alias_region_start > address || address + size - 1 > alias_region_end - 1;
+        return m_alias_region_start > address || address + size - 1 > m_alias_region_end - 1;
     }
-    constexpr bool IsOutsideStackRegion(VAddr address, std::size_t size) const {
+    constexpr bool IsOutsideStackRegion(VAddr address, size_t size) const {
-        return stack_region_start > address || address + size - 1 > stack_region_end - 1;
+        return m_stack_region_start > address || address + size - 1 > m_stack_region_end - 1;
     }
-    constexpr bool IsInvalidRegion(VAddr address, std::size_t size) const {
+    constexpr bool IsInvalidRegion(VAddr address, size_t size) const {
         return address + size - 1 > GetAliasCodeRegionStart() + GetAliasCodeRegionSize() - 1;
     }
-    constexpr bool IsInsideHeapRegion(VAddr address, std::size_t size) const {
+    constexpr bool IsInsideHeapRegion(VAddr address, size_t size) const {
-        return address + size > heap_region_start && heap_region_end > address;
+        return address + size > m_heap_region_start && m_heap_region_end > address;
     }
-    constexpr bool IsInsideAliasRegion(VAddr address, std::size_t size) const {
+    constexpr bool IsInsideAliasRegion(VAddr address, size_t size) const {
-        return address + size > alias_region_start && alias_region_end > address;
+        return address + size > m_alias_region_start && m_alias_region_end > address;
     }
-    constexpr bool IsOutsideASLRRegion(VAddr address, std::size_t size) const {
+    constexpr bool IsOutsideASLRRegion(VAddr address, size_t size) const {
         if (IsInvalidRegion(address, size)) {
             return true;
         }
@@ -290,77 +296,78 @@ public:
         }
         return {};
     }
-    constexpr bool IsInsideASLRRegion(VAddr address, std::size_t size) const {
+    constexpr bool IsInsideASLRRegion(VAddr address, size_t size) const {
         return !IsOutsideASLRRegion(address, size);
     }
-    constexpr std::size_t GetNumGuardPages() const {
+    constexpr size_t GetNumGuardPages() const {
         return IsKernel() ? 1 : 4;
     }
     PAddr GetPhysicalAddr(VAddr addr) const {
-        const auto backing_addr = page_table_impl.backing_addr[addr >> PageBits];
+        const auto backing_addr = m_page_table_impl.backing_addr[addr >> PageBits];
         ASSERT(backing_addr);
         return backing_addr + addr;
     }
     constexpr bool Contains(VAddr addr) const {
-        return address_space_start <= addr && addr <= address_space_end - 1;
+        return m_address_space_start <= addr && addr <= m_address_space_end - 1;
     }
-    constexpr bool Contains(VAddr addr, std::size_t size) const {
+    constexpr bool Contains(VAddr addr, size_t size) const {
-        return address_space_start <= addr && addr < addr + size &&
+        return m_address_space_start <= addr && addr < addr + size &&
-               addr + size - 1 <= address_space_end - 1;
+               addr + size - 1 <= m_address_space_end - 1;
     }
 
 private:
     constexpr bool IsKernel() const {
-        return is_kernel;
+        return m_is_kernel;
     }
     constexpr bool IsAslrEnabled() const {
-        return is_aslr_enabled;
+        return m_enable_aslr;
     }
 
-    constexpr bool ContainsPages(VAddr addr, std::size_t num_pages) const {
+    constexpr bool ContainsPages(VAddr addr, size_t num_pages) const {
-        return (address_space_start <= addr) &&
+        return (m_address_space_start <= addr) &&
-               (num_pages <= (address_space_end - address_space_start) / PageSize) &&
+               (num_pages <= (m_address_space_end - m_address_space_start) / PageSize) &&
-               (addr + num_pages * PageSize - 1 <= address_space_end - 1);
+               (addr + num_pages * PageSize - 1 <= m_address_space_end - 1);
     }
 
 private:
-    VAddr address_space_start{};
+    VAddr m_address_space_start{};
-    VAddr address_space_end{};
+    VAddr m_address_space_end{};
-    VAddr heap_region_start{};
+    VAddr m_heap_region_start{};
-    VAddr heap_region_end{};
+    VAddr m_heap_region_end{};
-    VAddr current_heap_end{};
+    VAddr m_current_heap_end{};
-    VAddr alias_region_start{};
+    VAddr m_alias_region_start{};
-    VAddr alias_region_end{};
+    VAddr m_alias_region_end{};
-    VAddr stack_region_start{};
+    VAddr m_stack_region_start{};
-    VAddr stack_region_end{};
+    VAddr m_stack_region_end{};
-    VAddr kernel_map_region_start{};
+    VAddr m_kernel_map_region_start{};
-    VAddr kernel_map_region_end{};
+    VAddr m_kernel_map_region_end{};
-    VAddr code_region_start{};
+    VAddr m_code_region_start{};
-    VAddr code_region_end{};
+    VAddr m_code_region_end{};
-    VAddr alias_code_region_start{};
+    VAddr m_alias_code_region_start{};
-    VAddr alias_code_region_end{};
+    VAddr m_alias_code_region_end{};
 
-    std::size_t mapped_physical_memory_size{};
+    size_t m_mapped_physical_memory_size{};
-    std::size_t max_heap_size{};
+    size_t m_max_heap_size{};
-    std::size_t max_physical_memory_size{};
+    size_t m_max_physical_memory_size{};
-    std::size_t address_space_width{};
+    size_t m_address_space_width{};
 
-    KMemoryBlockManager memory_block_manager;
+    KMemoryBlockManager m_memory_block_manager;
 
-    bool is_kernel{};
+    bool m_is_kernel{};
-    bool is_aslr_enabled{};
+    bool m_enable_aslr{};
+    bool m_enable_device_address_space_merge{};
 
-    KMemoryBlockSlabManager* memory_block_slab_manager{};
+    KMemoryBlockSlabManager* m_memory_block_slab_manager{};
 
-    u32 heap_fill_value{};
+    u32 m_heap_fill_value{};
-    const KMemoryRegion* cached_physical_heap_region{};
+    const KMemoryRegion* m_cached_physical_heap_region{};
 
-    KMemoryManager::Pool memory_pool{KMemoryManager::Pool::Application};
+    KMemoryManager::Pool m_memory_pool{KMemoryManager::Pool::Application};
-    KMemoryManager::Direction allocation_option{KMemoryManager::Direction::FromFront};
+    KMemoryManager::Direction m_allocation_option{KMemoryManager::Direction::FromFront};
 
-    Common::PageTable page_table_impl;
+    Common::PageTable m_page_table_impl;
 
-    Core::System& system;
+    Core::System& m_system;
 };
 
 } // namespace Kernel

src/core/hle/service/nvdrv/devices/nvmap.cpp

@@ -128,7 +128,8 @@ NvResult nvmap::IocAlloc(const std::vector<u8>& input, std::vector<u8>& output)
     }
     ASSERT(system.CurrentProcess()
                ->PageTable()
-               .LockForDeviceAddressSpace(handle_description->address, handle_description->size)
+               .LockForMapDeviceAddressSpace(handle_description->address, handle_description->size,
+                                             Kernel::KMemoryPermission::None, true)
                .IsSuccess());
     std::memcpy(output.data(), &params, sizeof(params));
     return result;