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

master
bunnei 2022-10-01 14:08:47 +07:00
parent d00245d444
commit ff26190d42
3 changed files with 616 additions and 537 deletions

File diff suppressed because it is too large Load Diff

@ -36,60 +36,66 @@ public:
~KPageTable(); ~KPageTable();
Result InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr, 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, KMemoryBlockSlabManager* mem_block_slab_manager,
KMemoryManager::Pool pool); KMemoryManager::Pool pool);
void Finalize(); 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); 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); 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); 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, Result MapPages(VAddr addr, KPageGroup& page_linked_list, KMemoryState state,
KMemoryPermission perm); 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) { KMemoryState state, KMemoryPermission perm) {
return this->MapPages(out_addr, num_pages, alignment, phys_addr, true, return this->MapPages(out_addr, num_pages, alignment, phys_addr, true,
this->GetRegionAddress(state), this->GetRegionSize(state) / PageSize, this->GetRegionAddress(state), this->GetRegionSize(state) / PageSize,
state, perm); state, perm);
} }
Result UnmapPages(VAddr addr, KPageGroup& 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 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); 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, Result MakeAndOpenPageGroup(KPageGroup* out, VAddr address, size_t num_pages,
KMemoryState state_mask, KMemoryState state, KMemoryState state_mask, KMemoryState state,
KMemoryPermission perm_mask, KMemoryPermission perm, KMemoryPermission perm_mask, KMemoryPermission perm,
KMemoryAttribute attr_mask, KMemoryAttribute attr); KMemoryAttribute attr_mask, KMemoryAttribute attr);
Common::PageTable& PageTableImpl() { Common::PageTable& PageTableImpl() {
return page_table_impl; return m_page_table_impl;
} }
const Common::PageTable& PageTableImpl() const { 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: private:
enum class OperationType : u32 { enum class OperationType : u32 {
@ -104,30 +110,30 @@ private:
KMemoryAttribute::IpcLocked | KMemoryAttribute::DeviceShared; KMemoryAttribute::IpcLocked | KMemoryAttribute::DeviceShared;
Result MapPages(VAddr addr, const KPageGroup& 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, 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); KMemoryState state, KMemoryPermission perm);
Result UnmapPages(VAddr addr, const KPageGroup& page_linked_list); Result UnmapPages(VAddr addr, const KPageGroup& page_linked_list);
bool IsRegionContiguous(VAddr addr, u64 size) const; 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); 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); 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; 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, KMemoryState state_mask, KMemoryState state,
KMemoryPermission perm_mask, KMemoryPermission perm, KMemoryPermission perm_mask, KMemoryPermission perm,
KMemoryAttribute attr_mask, KMemoryAttribute attr) const; 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, KMemoryState state, KMemoryPermission perm_mask,
KMemoryPermission perm, KMemoryAttribute attr_mask, KMemoryPermission perm, KMemoryAttribute attr_mask,
KMemoryAttribute attr) const { KMemoryAttribute attr) const {
@ -139,12 +145,12 @@ private:
KMemoryPermission perm_mask, KMemoryPermission perm, KMemoryPermission perm_mask, KMemoryPermission perm,
KMemoryAttribute attr_mask, KMemoryAttribute attr) const; KMemoryAttribute attr_mask, KMemoryAttribute attr) const;
Result CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm, 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, KMemoryPermission perm_mask, KMemoryPermission perm,
KMemoryAttribute attr_mask, KMemoryAttribute attr, KMemoryAttribute attr_mask, KMemoryAttribute attr,
KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const; 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, KMemoryState state_mask, KMemoryState state,
KMemoryPermission perm_mask, KMemoryPermission perm, KMemoryPermission perm_mask, KMemoryPermission perm,
KMemoryAttribute attr_mask, KMemoryAttribute attr, KMemoryAttribute attr_mask, KMemoryAttribute attr,
@ -152,8 +158,8 @@ private:
return CheckMemoryState(nullptr, nullptr, nullptr, out_blocks_needed, addr, size, return CheckMemoryState(nullptr, nullptr, nullptr, out_blocks_needed, addr, size,
state_mask, state, perm_mask, perm, attr_mask, attr, ignore_attr); 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 attr_mask, KMemoryAttribute attr,
KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const { KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) const {
return this->CheckMemoryState(nullptr, addr, size, state_mask, state, perm_mask, perm, 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 IsValidPageGroup(const KPageGroup& pg, VAddr addr, size_t num_pages);
bool IsLockedByCurrentThread() const { bool IsLockedByCurrentThread() const {
return general_lock.IsLockedByCurrentThread(); return m_general_lock.IsLockedByCurrentThread();
} }
bool IsHeapPhysicalAddress(const KMemoryLayout& layout, PAddr phys_addr) { bool IsHeapPhysicalAddress(const KMemoryLayout& layout, PAddr phys_addr) {
ASSERT(this->IsLockedByCurrentThread()); 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 { bool GetPhysicalAddressLocked(PAddr* out, VAddr virt_addr) const {
@ -192,93 +198,93 @@ private:
return *out != 0; 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: public:
constexpr VAddr GetAddressSpaceStart() const { constexpr VAddr GetAddressSpaceStart() const {
return address_space_start; return m_address_space_start;
} }
constexpr VAddr GetAddressSpaceEnd() const { 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 { constexpr VAddr GetHeapRegionStart() const {
return heap_region_start; return m_heap_region_start;
} }
constexpr VAddr GetHeapRegionEnd() const { 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 { constexpr VAddr GetAliasRegionStart() const {
return alias_region_start; return m_alias_region_start;
} }
constexpr VAddr GetAliasRegionEnd() const { 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 { constexpr VAddr GetStackRegionStart() const {
return stack_region_start; return m_stack_region_start;
} }
constexpr VAddr GetStackRegionEnd() const { 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 { constexpr VAddr GetKernelMapRegionStart() const {
return kernel_map_region_start; return m_kernel_map_region_start;
} }
constexpr VAddr GetKernelMapRegionEnd() const { constexpr VAddr GetKernelMapRegionEnd() const {
return kernel_map_region_end; return m_kernel_map_region_end;
} }
constexpr VAddr GetCodeRegionStart() const { constexpr VAddr GetCodeRegionStart() const {
return code_region_start; return m_code_region_start;
} }
constexpr VAddr GetCodeRegionEnd() const { constexpr VAddr GetCodeRegionEnd() const {
return code_region_end; return m_code_region_end;
} }
constexpr VAddr GetAliasCodeRegionStart() const { constexpr VAddr GetAliasCodeRegionStart() const {
return alias_code_region_start; return m_alias_code_region_start;
} }
constexpr VAddr GetAliasCodeRegionSize() const { 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; 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)) { if (IsInvalidRegion(address, size)) {
return true; return true;
} }
@ -290,77 +296,78 @@ public:
} }
return {}; return {};
} }
constexpr bool IsInsideASLRRegion(VAddr address, std::size_t size) const { constexpr bool IsInsideASLRRegion(VAddr address, size_t size) const {
return !IsOutsideASLRRegion(address, size); return !IsOutsideASLRRegion(address, size);
} }
constexpr std::size_t GetNumGuardPages() const { constexpr size_t GetNumGuardPages() const {
return IsKernel() ? 1 : 4; return IsKernel() ? 1 : 4;
} }
PAddr GetPhysicalAddr(VAddr addr) const { 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); ASSERT(backing_addr);
return backing_addr + addr; return backing_addr + addr;
} }
constexpr bool Contains(VAddr addr) const { 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: private:
constexpr bool IsKernel() const { constexpr bool IsKernel() const {
return is_kernel; return m_is_kernel;
} }
constexpr bool IsAslrEnabled() const { 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: 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 } // namespace Kernel

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