2020-04-08 23:28:42 +02:00
|
|
|
// Copyright 2020 yuzu Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <memory>
|
|
|
|
#include <mutex>
|
|
|
|
|
|
|
|
#include "common/common_types.h"
|
|
|
|
#include "common/page_table.h"
|
|
|
|
#include "core/file_sys/program_metadata.h"
|
2021-02-13 02:02:51 +01:00
|
|
|
#include "core/hle/kernel/k_memory_block.h"
|
2021-02-13 02:38:40 +01:00
|
|
|
#include "core/hle/kernel/k_memory_manager.h"
|
2020-05-03 19:41:15 +02:00
|
|
|
#include "core/hle/result.h"
|
2020-04-08 23:28:42 +02:00
|
|
|
|
|
|
|
namespace Core {
|
|
|
|
class System;
|
|
|
|
}
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
namespace Kernel {
|
2020-04-08 23:28:42 +02:00
|
|
|
|
2021-02-13 02:58:31 +01:00
|
|
|
class KMemoryBlockManager;
|
2020-04-08 23:28:42 +02:00
|
|
|
|
2021-02-13 02:58:31 +01:00
|
|
|
class KPageTable final : NonCopyable {
|
2020-04-08 23:28:42 +02:00
|
|
|
public:
|
2021-02-13 02:58:31 +01:00
|
|
|
explicit KPageTable(Core::System& system);
|
2020-04-08 23:28:42 +02:00
|
|
|
|
|
|
|
ResultCode InitializeForProcess(FileSys::ProgramAddressSpaceType as_type, bool enable_aslr,
|
|
|
|
VAddr code_addr, std::size_t code_size,
|
2021-02-13 02:38:40 +01:00
|
|
|
KMemoryManager::Pool pool);
|
2021-02-13 02:02:51 +01:00
|
|
|
ResultCode MapProcessCode(VAddr addr, std::size_t pages_count, KMemoryState state,
|
|
|
|
KMemoryPermission perm);
|
2020-04-08 23:28:42 +02:00
|
|
|
ResultCode MapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
|
|
|
|
ResultCode UnmapProcessCodeMemory(VAddr dst_addr, VAddr src_addr, std::size_t size);
|
|
|
|
ResultCode MapPhysicalMemory(VAddr addr, std::size_t size);
|
|
|
|
ResultCode UnmapPhysicalMemory(VAddr addr, std::size_t size);
|
|
|
|
ResultCode UnmapMemory(VAddr addr, std::size_t size);
|
|
|
|
ResultCode Map(VAddr dst_addr, VAddr src_addr, std::size_t size);
|
|
|
|
ResultCode Unmap(VAddr dst_addr, VAddr src_addr, std::size_t size);
|
2021-02-13 02:26:01 +01:00
|
|
|
ResultCode MapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state,
|
2021-02-13 02:02:51 +01:00
|
|
|
KMemoryPermission perm);
|
2021-04-30 23:53:22 +02:00
|
|
|
ResultCode UnmapPages(VAddr addr, KPageLinkedList& page_linked_list, KMemoryState state);
|
2021-02-13 02:02:51 +01:00
|
|
|
ResultCode SetCodeMemoryPermission(VAddr addr, std::size_t size, KMemoryPermission perm);
|
|
|
|
KMemoryInfo QueryInfo(VAddr addr);
|
|
|
|
ResultCode ReserveTransferMemory(VAddr addr, std::size_t size, KMemoryPermission perm);
|
2020-04-08 23:28:42 +02:00
|
|
|
ResultCode ResetTransferMemory(VAddr addr, std::size_t size);
|
2021-02-13 02:02:51 +01:00
|
|
|
ResultCode SetMemoryAttribute(VAddr addr, std::size_t size, KMemoryAttribute mask,
|
|
|
|
KMemoryAttribute value);
|
2020-04-08 23:28:42 +02:00
|
|
|
ResultCode SetHeapCapacity(std::size_t new_heap_capacity);
|
|
|
|
ResultVal<VAddr> SetHeapSize(std::size_t size);
|
|
|
|
ResultVal<VAddr> AllocateAndMapMemory(std::size_t needed_num_pages, std::size_t align,
|
|
|
|
bool is_map_only, VAddr region_start,
|
2021-02-13 02:02:51 +01:00
|
|
|
std::size_t region_num_pages, KMemoryState state,
|
|
|
|
KMemoryPermission perm, PAddr map_addr = 0);
|
2020-04-23 17:37:12 +02:00
|
|
|
ResultCode LockForDeviceAddressSpace(VAddr addr, std::size_t size);
|
|
|
|
ResultCode UnlockForDeviceAddressSpace(VAddr addr, std::size_t size);
|
2020-04-08 23:28:42 +02:00
|
|
|
|
|
|
|
Common::PageTable& PageTableImpl() {
|
|
|
|
return page_table_impl;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Common::PageTable& PageTableImpl() const {
|
|
|
|
return page_table_impl;
|
|
|
|
}
|
|
|
|
|
2021-05-05 07:14:06 +02:00
|
|
|
bool CanContain(VAddr addr, std::size_t size, KMemoryState state) const;
|
2021-04-30 23:53:22 +02:00
|
|
|
|
2020-04-08 23:28:42 +02:00
|
|
|
private:
|
|
|
|
enum class OperationType : u32 {
|
|
|
|
Map,
|
|
|
|
MapGroup,
|
|
|
|
Unmap,
|
|
|
|
ChangePermissions,
|
|
|
|
ChangePermissionsAndRefresh,
|
|
|
|
};
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
static constexpr KMemoryAttribute DefaultMemoryIgnoreAttr = KMemoryAttribute::DontCareMask |
|
|
|
|
KMemoryAttribute::IpcLocked |
|
|
|
|
KMemoryAttribute::DeviceShared;
|
2020-04-08 23:28:42 +02:00
|
|
|
|
|
|
|
ResultCode InitializeMemoryLayout(VAddr start, VAddr end);
|
2021-02-13 02:26:01 +01:00
|
|
|
ResultCode MapPages(VAddr addr, const KPageLinkedList& page_linked_list,
|
|
|
|
KMemoryPermission perm);
|
2021-04-30 23:53:22 +02:00
|
|
|
ResultCode UnmapPages(VAddr addr, const KPageLinkedList& page_linked_list);
|
2021-02-13 02:26:01 +01:00
|
|
|
void MapPhysicalMemory(KPageLinkedList& page_linked_list, VAddr start, VAddr end);
|
2020-04-08 23:28:42 +02:00
|
|
|
bool IsRegionMapped(VAddr address, u64 size);
|
|
|
|
bool IsRegionContiguous(VAddr addr, u64 size) const;
|
2021-02-13 02:26:01 +01:00
|
|
|
void AddRegionToPages(VAddr start, std::size_t num_pages, KPageLinkedList& page_linked_list);
|
2021-02-13 02:02:51 +01:00
|
|
|
KMemoryInfo QueryInfoImpl(VAddr addr);
|
2020-04-08 23:28:42 +02:00
|
|
|
VAddr AllocateVirtualMemory(VAddr start, std::size_t region_num_pages, u64 needed_num_pages,
|
|
|
|
std::size_t align);
|
2021-02-13 02:26:01 +01:00
|
|
|
ResultCode Operate(VAddr addr, std::size_t num_pages, const KPageLinkedList& page_group,
|
2020-04-08 23:28:42 +02:00
|
|
|
OperationType operation);
|
2021-02-13 02:02:51 +01:00
|
|
|
ResultCode Operate(VAddr addr, std::size_t num_pages, KMemoryPermission perm,
|
2020-04-08 23:28:42 +02:00
|
|
|
OperationType operation, PAddr map_addr = 0);
|
2021-02-13 02:02:51 +01:00
|
|
|
constexpr VAddr GetRegionAddress(KMemoryState state) const;
|
|
|
|
constexpr std::size_t GetRegionSize(KMemoryState state) const;
|
|
|
|
|
|
|
|
constexpr ResultCode CheckMemoryState(const KMemoryInfo& info, KMemoryState state_mask,
|
|
|
|
KMemoryState state, KMemoryPermission perm_mask,
|
|
|
|
KMemoryPermission perm, KMemoryAttribute attr_mask,
|
|
|
|
KMemoryAttribute attr) const;
|
|
|
|
ResultCode CheckMemoryState(KMemoryState* out_state, KMemoryPermission* out_perm,
|
|
|
|
KMemoryAttribute* out_attr, VAddr addr, std::size_t size,
|
|
|
|
KMemoryState state_mask, KMemoryState state,
|
|
|
|
KMemoryPermission perm_mask, KMemoryPermission perm,
|
|
|
|
KMemoryAttribute attr_mask, KMemoryAttribute attr,
|
|
|
|
KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr);
|
|
|
|
ResultCode CheckMemoryState(VAddr addr, std::size_t size, KMemoryState state_mask,
|
|
|
|
KMemoryState state, KMemoryPermission perm_mask,
|
|
|
|
KMemoryPermission perm, KMemoryAttribute attr_mask,
|
|
|
|
KMemoryAttribute attr,
|
|
|
|
KMemoryAttribute ignore_attr = DefaultMemoryIgnoreAttr) {
|
2020-04-08 23:28:42 +02:00
|
|
|
return CheckMemoryState(nullptr, nullptr, nullptr, addr, size, state_mask, state, perm_mask,
|
|
|
|
perm, attr_mask, attr, ignore_attr);
|
|
|
|
}
|
|
|
|
|
|
|
|
std::recursive_mutex page_table_lock;
|
2021-02-13 02:02:51 +01:00
|
|
|
std::unique_ptr<KMemoryBlockManager> block_manager;
|
2020-04-08 23:28:42 +02:00
|
|
|
|
|
|
|
public:
|
|
|
|
constexpr VAddr GetAddressSpaceStart() const {
|
|
|
|
return address_space_start;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetAddressSpaceEnd() const {
|
|
|
|
return address_space_end;
|
|
|
|
}
|
|
|
|
constexpr std::size_t GetAddressSpaceSize() const {
|
|
|
|
return address_space_end - address_space_start;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetHeapRegionStart() const {
|
|
|
|
return heap_region_start;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetHeapRegionEnd() const {
|
|
|
|
return heap_region_end;
|
|
|
|
}
|
|
|
|
constexpr std::size_t GetHeapRegionSize() const {
|
|
|
|
return heap_region_end - heap_region_start;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetAliasRegionStart() const {
|
|
|
|
return alias_region_start;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetAliasRegionEnd() const {
|
|
|
|
return alias_region_end;
|
|
|
|
}
|
|
|
|
constexpr std::size_t GetAliasRegionSize() const {
|
|
|
|
return alias_region_end - alias_region_start;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetStackRegionStart() const {
|
|
|
|
return stack_region_start;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetStackRegionEnd() const {
|
|
|
|
return stack_region_end;
|
|
|
|
}
|
|
|
|
constexpr std::size_t GetStackRegionSize() const {
|
|
|
|
return stack_region_end - stack_region_start;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetKernelMapRegionStart() const {
|
|
|
|
return kernel_map_region_start;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetKernelMapRegionEnd() const {
|
|
|
|
return kernel_map_region_end;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetCodeRegionStart() const {
|
|
|
|
return code_region_start;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetCodeRegionEnd() const {
|
|
|
|
return code_region_end;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetAliasCodeRegionStart() const {
|
|
|
|
return alias_code_region_start;
|
|
|
|
}
|
|
|
|
constexpr VAddr GetAliasCodeRegionSize() const {
|
|
|
|
return alias_code_region_end - alias_code_region_start;
|
|
|
|
}
|
|
|
|
constexpr std::size_t GetAddressSpaceWidth() const {
|
|
|
|
return address_space_width;
|
|
|
|
}
|
|
|
|
constexpr std::size_t GetHeapSize() {
|
|
|
|
return current_heap_addr - heap_region_start;
|
|
|
|
}
|
|
|
|
constexpr std::size_t GetTotalHeapSize() {
|
|
|
|
return GetHeapSize() + physical_memory_usage;
|
|
|
|
}
|
|
|
|
constexpr bool IsInsideAddressSpace(VAddr address, std::size_t size) const {
|
|
|
|
return address_space_start <= address && address + size - 1 <= address_space_end - 1;
|
|
|
|
}
|
|
|
|
constexpr bool IsOutsideAliasRegion(VAddr address, std::size_t size) const {
|
|
|
|
return alias_region_start > address || address + size - 1 > alias_region_end - 1;
|
|
|
|
}
|
|
|
|
constexpr bool IsOutsideStackRegion(VAddr address, std::size_t size) const {
|
|
|
|
return stack_region_start > address || address + size - 1 > stack_region_end - 1;
|
|
|
|
}
|
|
|
|
constexpr bool IsInvalidRegion(VAddr address, std::size_t size) const {
|
|
|
|
return address + size - 1 > GetAliasCodeRegionStart() + GetAliasCodeRegionSize() - 1;
|
|
|
|
}
|
|
|
|
constexpr bool IsInsideHeapRegion(VAddr address, std::size_t size) const {
|
|
|
|
return address + size > heap_region_start && heap_region_end > address;
|
|
|
|
}
|
|
|
|
constexpr bool IsInsideAliasRegion(VAddr address, std::size_t size) const {
|
|
|
|
return address + size > alias_region_start && alias_region_end > address;
|
|
|
|
}
|
|
|
|
constexpr bool IsOutsideASLRRegion(VAddr address, std::size_t size) const {
|
|
|
|
if (IsInvalidRegion(address, size)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (IsInsideHeapRegion(address, size)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
if (IsInsideAliasRegion(address, size)) {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
constexpr bool IsInsideASLRRegion(VAddr address, std::size_t size) const {
|
|
|
|
return !IsOutsideASLRRegion(address, size);
|
|
|
|
}
|
2020-04-09 05:37:24 +02:00
|
|
|
constexpr PAddr GetPhysicalAddr(VAddr addr) {
|
2021-02-13 02:02:51 +01:00
|
|
|
return page_table_impl.backing_addr[addr >> PageBits] + addr;
|
2020-04-09 05:37:24 +02:00
|
|
|
}
|
2020-04-08 23:28:42 +02:00
|
|
|
constexpr bool Contains(VAddr addr) const {
|
|
|
|
return address_space_start <= addr && addr <= address_space_end - 1;
|
|
|
|
}
|
|
|
|
constexpr bool Contains(VAddr addr, std::size_t size) const {
|
|
|
|
return address_space_start <= addr && addr < addr + size &&
|
|
|
|
addr + size - 1 <= address_space_end - 1;
|
|
|
|
}
|
2021-04-17 09:52:53 +02:00
|
|
|
|
|
|
|
private:
|
2020-04-08 23:28:42 +02:00
|
|
|
constexpr bool IsKernel() const {
|
|
|
|
return is_kernel;
|
|
|
|
}
|
|
|
|
constexpr bool IsAslrEnabled() const {
|
|
|
|
return is_aslr_enabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
constexpr std::size_t GetNumGuardPages() const {
|
|
|
|
return IsKernel() ? 1 : 4;
|
|
|
|
}
|
|
|
|
|
|
|
|
constexpr bool ContainsPages(VAddr addr, std::size_t num_pages) const {
|
|
|
|
return (address_space_start <= addr) &&
|
|
|
|
(num_pages <= (address_space_end - address_space_start) / PageSize) &&
|
|
|
|
(addr + num_pages * PageSize - 1 <= address_space_end - 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
VAddr address_space_start{};
|
|
|
|
VAddr address_space_end{};
|
|
|
|
VAddr heap_region_start{};
|
|
|
|
VAddr heap_region_end{};
|
|
|
|
VAddr current_heap_end{};
|
|
|
|
VAddr alias_region_start{};
|
|
|
|
VAddr alias_region_end{};
|
|
|
|
VAddr stack_region_start{};
|
|
|
|
VAddr stack_region_end{};
|
|
|
|
VAddr kernel_map_region_start{};
|
|
|
|
VAddr kernel_map_region_end{};
|
|
|
|
VAddr code_region_start{};
|
|
|
|
VAddr code_region_end{};
|
|
|
|
VAddr alias_code_region_start{};
|
|
|
|
VAddr alias_code_region_end{};
|
|
|
|
VAddr current_heap_addr{};
|
|
|
|
|
|
|
|
std::size_t heap_capacity{};
|
|
|
|
std::size_t physical_memory_usage{};
|
|
|
|
std::size_t max_heap_size{};
|
|
|
|
std::size_t max_physical_memory_size{};
|
|
|
|
std::size_t address_space_width{};
|
|
|
|
|
|
|
|
bool is_kernel{};
|
|
|
|
bool is_aslr_enabled{};
|
|
|
|
|
2021-02-13 02:38:40 +01:00
|
|
|
KMemoryManager::Pool memory_pool{KMemoryManager::Pool::Application};
|
2020-04-08 23:28:42 +02:00
|
|
|
|
|
|
|
Common::PageTable page_table_impl;
|
|
|
|
|
|
|
|
Core::System& system;
|
|
|
|
};
|
|
|
|
|
2021-02-13 02:58:31 +01:00
|
|
|
} // namespace Kernel
|