eden-emu
/
eden
mirror of https://git.eden-emu.dev/eden-emu/eden.git
1
0
Fork 0
Code Releases Wiki Activity
Browse Source

physmem: add helpers, cleanup logic.

nce_cpp
Michael Scire 7 years ago
parent
1a0bbd14e7
commit
4ce2cda054
2 changed files with 170 additions and 171 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 307
      src/core/hle/kernel/vm_manager.cpp
  2. 16
      src/core/hle/kernel/vm_manager.h

307
src/core/hle/kernel/vm_manager.cpp
View File

@ -310,43 +310,23 @@ ResultVal<VAddr> VMManager::SetHeapSize(u64 size) {
}
ResultCode VMManager::MapPhysicalMemory(VAddr target, u64 size) {
const auto last_addr = target + size - 1;
const auto end_addr = target + size;
const auto last_addr = end_addr - 1;
VAddr cur_addr = target;
std::size_t mapped_size = 0;
ResultCode result = RESULT_SUCCESS;
// Check whether we've already mapped the desired memory.
{
auto vma = FindVMA(target);
ASSERT_MSG(vma != vma_map.end(), "MapPhysicalMemory vma != end");
while (true) {
const auto vma_start = vma->second.base;
const auto vma_size = vma->second.size;
const auto state = vma->second.state;
// Handle last block.
if (last_addr <= (vma_start + vma_size - 1)) {
if (state != MemoryState::Unmapped) {
mapped_size += last_addr - cur_addr + 1;
}
break;
}
if (state != MemoryState::Unmapped) {
mapped_size += vma_start + vma_size - cur_addr;
}
cur_addr = vma_start + vma_size;
vma++;
ASSERT_MSG(vma != vma_map.end(), "MapPhysicalMemory vma != end");
// Check how much memory we've already mapped.
const auto mapped_size_result = SizeOfAllocatedVMAsInRange(target, size);
if (mapped_size_result.Failed()) {
return mapped_size_result.Code();
}
// If we already have the desired amount mapped, we're done.
// If we've already mapped the desired amount, return early.
const std::size_t mapped_size = *mapped_size_result;
if (mapped_size == size) {
return RESULT_SUCCESS;
}
}
// Check that we can map the memory we want.
const auto res_limit = system.CurrentProcess()->GetResourceLimit();
@ -360,97 +340,54 @@ ResultCode VMManager::MapPhysicalMemory(VAddr target, u64 size) {
std::vector<std::pair<u64, u64>> mapped_regions;
// Iterate, trying to map memory.
// Map initially with VMAPermission::None.
{
cur_addr = target;
auto vma = FindVMA(target);
ASSERT_MSG(vma != vma_map.end(), "MapPhysicalMemory vma != end");
auto iter = FindVMA(target);
ASSERT_MSG(iter != vma_map.end(), "MapPhysicalMemory iter != end");
while (true) {
const auto vma_start = vma->second.base;
const auto vma_size = vma->second.size;
const auto state = vma->second.state;
// Handle last block.
if (last_addr <= (vma_start + vma_size - 1)) {
if (state == MemoryState::Unmapped) {
const auto map_res = MapMemoryBlock(
cur_addr, std::make_shared<std::vector<u8>>(last_addr - cur_addr + 1, 0), 0,
last_addr - cur_addr + 1, MemoryState::Heap, VMAPermission::None);
const auto& vma = iter->second;
const auto vma_start = vma.base;
const auto vma_end = vma_start + vma.size;
const auto vma_last = vma_end - 1;
// Map the memory block
const auto map_size = std::min(end_addr - cur_addr, vma_end - cur_addr);
if (vma.state == MemoryState::Unmapped) {
const auto map_res =
MapMemoryBlock(cur_addr, std::make_shared<std::vector<u8>>(map_size, 0), 0,
map_size, MemoryState::Heap, VMAPermission::ReadWrite);
result = map_res.Code();
if (result.IsSuccess()) {
mapped_regions.push_back(
std::make_pair(cur_addr, last_addr - cur_addr + 1));
}
}
if (result.IsError()) {
break;
}
if (state == MemoryState::Unmapped) {
const auto map_res = MapMemoryBlock(
cur_addr, std::make_shared<std::vector<u8>>(vma_start + vma_size - cur_addr, 0),
0, vma_start + vma_size - cur_addr, MemoryState::Heap, VMAPermission::None);
result = map_res.Code();
if (result.IsSuccess()) {
mapped_regions.push_back(
std::make_pair(cur_addr, vma_start + vma_size - cur_addr));
} else {
break;
mapped_regions.emplace_back(cur_addr, map_size);
}
// Break once we hit the end of the range.
if (last_addr <= vma_last) {
break;
}
cur_addr = vma_start + vma_size;
vma = FindVMA(cur_addr);
ASSERT_MSG(vma != vma_map.end(), "MapPhysicalMemory vma != end");
// Advance to the next block.
cur_addr = vma_end;
iter = FindVMA(cur_addr);
ASSERT_MSG(iter != vma_map.end(), "MapPhysicalMemory iter != end");
}
}
// If we failed, unmap memory.
if (result.IsError()) {
for (const auto& it : mapped_regions) {
const auto unmap_res = UnmapRange(it.first, it.second);
ASSERT_MSG(unmap_res.IsSuccess(), "MapPhysicalMemory un-map on error");
for (const auto [unmap_address, unmap_size] : mapped_regions) {
ASSERT_MSG(UnmapRange(unmap_address, unmap_size).IsSuccess(),
"MapPhysicalMemory un-map on error");
}
return result;
}
// We didn't fail, so reprotect all the memory to ReadWrite.
{
cur_addr = target;
auto vma = FindVMA(target);
ASSERT_MSG(vma != vma_map.end(), "MapPhysicalMemory vma != end");
while (true) {
const auto vma_start = vma->second.base;
const auto vma_size = vma->second.size;
const auto state = vma->second.state;
const auto perm = vma->second.permissions;
// Handle last block.
if (last_addr <= (vma_start + vma_size - 1)) {
if (state == MemoryState::Heap && perm == VMAPermission::None) {
ASSERT_MSG(
ReprotectRange(cur_addr, last_addr - cur_addr + 1, VMAPermission::ReadWrite)
.IsSuccess(),
"MapPhysicalMemory reprotect");
}
break;
}
if (state == MemoryState::Heap && perm == VMAPermission::None) {
ASSERT_MSG(ReprotectRange(cur_addr, vma_start + vma_size - cur_addr,
VMAPermission::ReadWrite)
.IsSuccess(),
"MapPhysicalMemory reprotect");
}
cur_addr = vma_start + vma_size;
vma = FindVMA(cur_addr);
ASSERT_MSG(vma != vma_map.end(), "MapPhysicalMemory vma != end");
}
}
// Update amount of mapped physical memory.
physical_memory_mapped += size - mapped_size;
@ -458,50 +395,23 @@ ResultCode VMManager::MapPhysicalMemory(VAddr target, u64 size) {
}
ResultCode VMManager::UnmapPhysicalMemory(VAddr target, u64 size) {
auto last_addr = target + size - 1;
const auto end_addr = target + size;
const auto last_addr = end_addr - 1;
VAddr cur_addr = target;
std::size_t mapped_size = 0;
ResultCode result = RESULT_SUCCESS;
// Check how much of the memory is currently mapped.
{
auto vma = FindVMA(target);
ASSERT_MSG(vma != vma_map.end(), "UnmapPhysicalMemory vma != end");
while (true) {
const auto vma_start = vma->second.base;
const auto vma_size = vma->second.size;
const auto state = vma->second.state;
const auto attr = vma->second.attribute;
// Memory within region must be free or mapped heap.
if (!((state == MemoryState::Heap && attr == MemoryAttribute::None) ||
(state == MemoryState::Unmapped))) {
return ERR_INVALID_ADDRESS_STATE;
}
// If this is the last block and it's mapped, update mapped size.
if (last_addr <= (vma_start + vma_size - 1)) {
if (state == MemoryState::Heap) {
mapped_size += last_addr - cur_addr + 1;
}
break;
// Check how much memory is currently mapped.
const auto mapped_size_result = SizeOfUnmappablePhysicalMemoryInRange(target, size);
if (mapped_size_result.Failed()) {
return mapped_size_result.Code();
}
if (state == MemoryState::Heap) {
mapped_size += vma_start + vma_size - cur_addr;
}
cur_addr = vma_start + vma_size;
vma++;
ASSERT_MSG(vma != vma_map.end(), "UnmapPhysicalMemory vma != end");
}
// If memory is already unmapped, we're done.
// If we've already unmapped all the memory, return early.
const std::size_t mapped_size = *mapped_size_result;
if (mapped_size == 0) {
return RESULT_SUCCESS;
}
}
// Keep track of the memory regions we unmap.
std::vector<std::pair<u64, u64>> unmapped_regions;
@ -510,50 +420,45 @@ ResultCode VMManager::UnmapPhysicalMemory(VAddr target, u64 size) {
{
cur_addr = target;
auto vma = FindVMA(target);
ASSERT_MSG(vma != vma_map.end(), "UnmapPhysicalMemory vma != end");
auto iter = FindVMA(target);
ASSERT_MSG(iter != vma_map.end(), "UnmapPhysicalMemory iter != end");
while (true) {
const auto vma_start = vma->second.base;
const auto vma_size = vma->second.size;
const auto state = vma->second.state;
const auto perm = vma->second.permissions;
// Handle last block.
if (last_addr <= (vma_start + vma_size - 1)) {
if (state == MemoryState::Heap) {
result = UnmapRange(cur_addr, last_addr - cur_addr + 1);
if (result.IsSuccess()) {
unmapped_regions.push_back(
std::make_pair(cur_addr, last_addr - cur_addr + 1));
}
}
const auto& vma = iter->second;
const auto vma_start = vma.base;
const auto vma_end = vma_start + vma.size;
const auto vma_last = vma_end - 1;
// Unmap the memory block
const auto unmap_size = std::min(end_addr - cur_addr, vma_end - cur_addr);
if (vma.state == MemoryState::Heap) {
result = UnmapRange(cur_addr, unmap_size);
if (result.IsError()) {
break;
}
if (state == MemoryState::Heap) {
result = UnmapRange(cur_addr, vma_start + vma_size - cur_addr);
if (result.IsSuccess()) {
unmapped_regions.push_back(
std::make_pair(cur_addr, vma_start + vma_size - cur_addr));
} else {
break;
unmapped_regions.emplace_back(cur_addr, unmap_size);
}
// Break once we hit the end of the range.
if (last_addr <= vma_last) {
break;
}
cur_addr = vma_start + vma_size;
vma = FindVMA(cur_addr);
ASSERT_MSG(vma != vma_map.end(), "UnmapPhysicalMemory vma != end");
// Advance to the next block.
cur_addr = vma_end;
iter = FindVMA(cur_addr);
ASSERT_MSG(iter != vma_map.end(), "UnmapPhysicalMemory iter != end");
}
}
// If we failed, re-map regions.
// TODO: Preserve memory contents?
if (result.IsError()) {
for (const auto& it : unmapped_regions) {
for (const auto [map_address, map_size] : unmapped_regions) {
const auto remap_res =
MapMemoryBlock(it.first, std::make_shared<std::vector<u8>>(it.second, 0), 0,
it.second, MemoryState::Heap, VMAPermission::None);
MapMemoryBlock(map_address, std::make_shared<std::vector<u8>>(map_size, 0), 0,
map_size, MemoryState::Heap, VMAPermission::None);
ASSERT_MSG(remap_res.Succeeded(), "UnmapPhysicalMemory re-map on error");
}
}
@ -1085,6 +990,84 @@ VMManager::CheckResults VMManager::CheckRangeState(VAddr address, u64 size, Memo
std::make_tuple(initial_state, initial_permissions, initial_attributes & ~ignore_mask));
}
ResultVal<std::size_t> VMManager::SizeOfAllocatedVMAsInRange(VAddr address,
std::size_t size) const {
const VAddr end_addr = address + size;
const VAddr last_addr = end_addr - 1;
std::size_t mapped_size = 0;
VAddr cur_addr = address;
auto iter = FindVMA(cur_addr);
ASSERT_MSG(iter != vma_map.end(), "SizeOfAllocatedVMAsInRange iter != end");
while (true) {
const auto& vma = iter->second;
const VAddr vma_start = vma.base;
const VAddr vma_end = vma_start + vma.size;
const VAddr vma_last = vma_end - 1;
// Add size if relevant.
if (vma.state != MemoryState::Unmapped) {
mapped_size += std::min(end_addr - cur_addr, vma_end - cur_addr);
}
// Break once we hit the end of the range.
if (last_addr <= vma_last) {
break;
}
// Advance to the next block.
cur_addr = vma_end;
iter = std::next(iter);
ASSERT_MSG(iter != vma_map.end(), "SizeOfAllocatedVMAsInRange iter != end");
}
return MakeResult(mapped_size);
}
ResultVal<std::size_t> VMManager::SizeOfUnmappablePhysicalMemoryInRange(VAddr address,
std::size_t size) const {
const VAddr end_addr = address + size;
const VAddr last_addr = end_addr - 1;
std::size_t mapped_size = 0;
VAddr cur_addr = address;
auto iter = FindVMA(cur_addr);
ASSERT_MSG(iter != vma_map.end(), "SizeOfUnmappablePhysicalMemoryInRange iter != end");
while (true) {
const auto& vma = iter->second;
const auto vma_start = vma.base;
const auto vma_end = vma_start + vma.size;
const auto vma_last = vma_end - 1;
const auto state = vma.state;
const auto attr = vma.attribute;
// Memory within region must be free or mapped heap.
if (!((state == MemoryState::Heap && attr == MemoryAttribute::None) ||
(state == MemoryState::Unmapped))) {
return ERR_INVALID_ADDRESS_STATE;
}
// Add size if relevant.
if (state != MemoryState::Unmapped) {
mapped_size += std::min(end_addr - cur_addr, vma_end - cur_addr);
}
// Break once we hit the end of the range.
if (last_addr <= vma_last) {
break;
}
// Advance to the next block.
cur_addr = vma_end;
iter = std::next(iter);
ASSERT_MSG(iter != vma_map.end(), "SizeOfUnmappablePhysicalMemoryInRange iter != end");
}
return MakeResult(mapped_size);
}
u64 VMManager::GetTotalPhysicalMemoryAvailable() const {
LOG_WARNING(Kernel, "(STUBBED) called");
return 0xF8000000;

16
src/core/hle/kernel/vm_manager.h
View File

@ -303,6 +303,15 @@ struct VirtualMemoryArea {
PAddr paddr = 0;
Common::MemoryHookPointer mmio_handler = nullptr;
/// If the address lies within this VMA, returns the size left before the
/// end of this VMA. If the given address doesn't lie within the VMA, then
/// an empty optional value is returned.
///
/// For example, given a VMA 100 bytes long. If '10' was given as the
/// start address, then this would return 90.
///
std::optional<u64> SizeRemainingFromAddress(VAddr address) const;
/// Tests if this area can be merged to the right with `next`.
bool CanBeMergedWith(const VirtualMemoryArea& next) const;
};
@ -735,6 +744,13 @@ private:
MemoryAttribute attribute_mask, MemoryAttribute attribute,
MemoryAttribute ignore_mask) const;
/// Gets the amount of memory currently mapped (state != Unmapped) in a range.
ResultVal<std::size_t> SizeOfAllocatedVMAsInRange(VAddr address, std::size_t size) const;
/// Gets the amount of memory unmappable by UnmapPhysicalMemory in a range.
ResultVal<std::size_t> SizeOfUnmappablePhysicalMemoryInRange(VAddr address,
std::size_t size) const;
/**
* A map covering the entirety of the managed address space, keyed by the `base` field of each
* VMA. It must always be modified by splitting or merging VMAs, so that the invariant

Write Preview
Loading…
Cancel
Save