2020-04-05 21:26:25 +02:00
|
|
|
// Copyright 2020 yuzu Emulator Project
|
|
|
|
// Licensed under GPLv2 or any later version
|
|
|
|
// Refer to the license.txt file included.
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
#include "core/hle/kernel/k_memory_block_manager.h"
|
|
|
|
#include "core/hle/kernel/memory_types.h"
|
2020-04-05 21:26:25 +02:00
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
namespace Kernel {
|
2020-04-05 21:26:25 +02:00
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
KMemoryBlockManager::KMemoryBlockManager(VAddr start_addr, VAddr end_addr)
|
2020-04-05 21:26:25 +02:00
|
|
|
: start_addr{start_addr}, end_addr{end_addr} {
|
|
|
|
const u64 num_pages{(end_addr - start_addr) / PageSize};
|
2021-02-13 02:02:51 +01:00
|
|
|
memory_block_tree.emplace_back(start_addr, num_pages, KMemoryState::Free,
|
|
|
|
KMemoryPermission::None, KMemoryAttribute::None);
|
2020-04-05 21:26:25 +02:00
|
|
|
}
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
KMemoryBlockManager::iterator KMemoryBlockManager::FindIterator(VAddr addr) {
|
2020-04-17 06:59:08 +02:00
|
|
|
auto node{memory_block_tree.begin()};
|
2020-04-05 21:26:25 +02:00
|
|
|
while (node != end()) {
|
|
|
|
const VAddr end_addr{node->GetNumPages() * PageSize + node->GetAddress()};
|
|
|
|
if (node->GetAddress() <= addr && end_addr - 1 >= addr) {
|
|
|
|
return node;
|
|
|
|
}
|
|
|
|
node = std::next(node);
|
|
|
|
}
|
|
|
|
return end();
|
|
|
|
}
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
VAddr KMemoryBlockManager::FindFreeArea(VAddr region_start, std::size_t region_num_pages,
|
|
|
|
std::size_t num_pages, std::size_t align,
|
|
|
|
std::size_t offset, std::size_t guard_pages) {
|
2020-04-05 21:26:25 +02:00
|
|
|
if (num_pages == 0) {
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
|
|
|
const VAddr region_end{region_start + region_num_pages * PageSize};
|
|
|
|
const VAddr region_last{region_end - 1};
|
2020-04-17 06:59:08 +02:00
|
|
|
for (auto it{FindIterator(region_start)}; it != memory_block_tree.cend(); it++) {
|
|
|
|
const auto info{it->GetMemoryInfo()};
|
2020-04-05 21:26:25 +02:00
|
|
|
if (region_last < info.GetAddress()) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
if (info.state != KMemoryState::Free) {
|
2020-04-05 21:26:25 +02:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
VAddr area{(info.GetAddress() <= region_start) ? region_start : info.GetAddress()};
|
|
|
|
area += guard_pages * PageSize;
|
|
|
|
|
|
|
|
const VAddr offset_area{Common::AlignDown(area, align) + offset};
|
|
|
|
area = (area <= offset_area) ? offset_area : offset_area + align;
|
|
|
|
|
|
|
|
const VAddr area_end{area + num_pages * PageSize + guard_pages * PageSize};
|
|
|
|
const VAddr area_last{area_end - 1};
|
|
|
|
|
|
|
|
if (info.GetAddress() <= area && area < area_last && area_last <= region_last &&
|
|
|
|
area_last <= info.GetLastAddress()) {
|
|
|
|
return area;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return {};
|
|
|
|
}
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
void KMemoryBlockManager::Update(VAddr addr, std::size_t num_pages, KMemoryState prev_state,
|
|
|
|
KMemoryPermission prev_perm, KMemoryAttribute prev_attribute,
|
|
|
|
KMemoryState state, KMemoryPermission perm,
|
|
|
|
KMemoryAttribute attribute) {
|
2020-04-05 21:26:25 +02:00
|
|
|
const VAddr end_addr{addr + num_pages * PageSize};
|
|
|
|
iterator node{memory_block_tree.begin()};
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
prev_attribute |= KMemoryAttribute::IpcAndDeviceMapped;
|
2020-04-05 21:26:25 +02:00
|
|
|
|
|
|
|
while (node != memory_block_tree.end()) {
|
2021-02-13 02:02:51 +01:00
|
|
|
KMemoryBlock* block{&(*node)};
|
2020-04-05 21:26:25 +02:00
|
|
|
iterator next_node{std::next(node)};
|
|
|
|
const VAddr cur_addr{block->GetAddress()};
|
|
|
|
const VAddr cur_end_addr{block->GetNumPages() * PageSize + cur_addr};
|
|
|
|
|
|
|
|
if (addr < cur_end_addr && cur_addr < end_addr) {
|
|
|
|
if (!block->HasProperties(prev_state, prev_perm, prev_attribute)) {
|
|
|
|
node = next_node;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
iterator new_node{node};
|
|
|
|
if (addr > cur_addr) {
|
|
|
|
memory_block_tree.insert(node, block->Split(addr));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (end_addr < cur_end_addr) {
|
|
|
|
new_node = memory_block_tree.insert(node, block->Split(end_addr));
|
|
|
|
}
|
|
|
|
|
|
|
|
new_node->Update(state, perm, attribute);
|
|
|
|
|
|
|
|
MergeAdjacent(new_node, next_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cur_end_addr - 1 >= end_addr - 1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
node = next_node;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
void KMemoryBlockManager::Update(VAddr addr, std::size_t num_pages, KMemoryState state,
|
|
|
|
KMemoryPermission perm, KMemoryAttribute attribute) {
|
2020-04-05 21:26:25 +02:00
|
|
|
const VAddr end_addr{addr + num_pages * PageSize};
|
|
|
|
iterator node{memory_block_tree.begin()};
|
|
|
|
|
|
|
|
while (node != memory_block_tree.end()) {
|
2021-02-13 02:02:51 +01:00
|
|
|
KMemoryBlock* block{&(*node)};
|
2020-04-05 21:26:25 +02:00
|
|
|
iterator next_node{std::next(node)};
|
|
|
|
const VAddr cur_addr{block->GetAddress()};
|
|
|
|
const VAddr cur_end_addr{block->GetNumPages() * PageSize + cur_addr};
|
|
|
|
|
|
|
|
if (addr < cur_end_addr && cur_addr < end_addr) {
|
|
|
|
iterator new_node{node};
|
|
|
|
|
|
|
|
if (addr > cur_addr) {
|
|
|
|
memory_block_tree.insert(node, block->Split(addr));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (end_addr < cur_end_addr) {
|
|
|
|
new_node = memory_block_tree.insert(node, block->Split(end_addr));
|
|
|
|
}
|
|
|
|
|
|
|
|
new_node->Update(state, perm, attribute);
|
|
|
|
|
|
|
|
MergeAdjacent(new_node, next_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cur_end_addr - 1 >= end_addr - 1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
node = next_node;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
void KMemoryBlockManager::UpdateLock(VAddr addr, std::size_t num_pages, LockFunc&& lock_func,
|
|
|
|
KMemoryPermission perm) {
|
2020-04-23 17:37:12 +02:00
|
|
|
const VAddr end_addr{addr + num_pages * PageSize};
|
|
|
|
iterator node{memory_block_tree.begin()};
|
|
|
|
|
|
|
|
while (node != memory_block_tree.end()) {
|
2021-02-13 02:02:51 +01:00
|
|
|
KMemoryBlock* block{&(*node)};
|
2020-04-23 17:37:12 +02:00
|
|
|
iterator next_node{std::next(node)};
|
|
|
|
const VAddr cur_addr{block->GetAddress()};
|
|
|
|
const VAddr cur_end_addr{block->GetNumPages() * PageSize + cur_addr};
|
|
|
|
|
|
|
|
if (addr < cur_end_addr && cur_addr < end_addr) {
|
|
|
|
iterator new_node{node};
|
|
|
|
|
|
|
|
if (addr > cur_addr) {
|
|
|
|
memory_block_tree.insert(node, block->Split(addr));
|
|
|
|
}
|
|
|
|
|
|
|
|
if (end_addr < cur_end_addr) {
|
|
|
|
new_node = memory_block_tree.insert(node, block->Split(end_addr));
|
|
|
|
}
|
|
|
|
|
|
|
|
lock_func(new_node, perm);
|
|
|
|
|
|
|
|
MergeAdjacent(new_node, next_node);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cur_end_addr - 1 >= end_addr - 1) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
node = next_node;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
void KMemoryBlockManager::IterateForRange(VAddr start, VAddr end, IterateFunc&& func) {
|
2020-04-05 21:26:25 +02:00
|
|
|
const_iterator it{FindIterator(start)};
|
2021-02-13 02:02:51 +01:00
|
|
|
KMemoryInfo info{};
|
2020-04-05 21:26:25 +02:00
|
|
|
do {
|
|
|
|
info = it->GetMemoryInfo();
|
|
|
|
func(info);
|
|
|
|
it = std::next(it);
|
|
|
|
} while (info.addr + info.size - 1 < end - 1 && it != cend());
|
|
|
|
}
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
void KMemoryBlockManager::MergeAdjacent(iterator it, iterator& next_it) {
|
|
|
|
KMemoryBlock* block{&(*it)};
|
2020-04-05 21:26:25 +02:00
|
|
|
|
|
|
|
auto EraseIt = [&](const iterator it_to_erase) {
|
|
|
|
if (next_it == it_to_erase) {
|
|
|
|
next_it = std::next(next_it);
|
|
|
|
}
|
|
|
|
memory_block_tree.erase(it_to_erase);
|
|
|
|
};
|
|
|
|
|
|
|
|
if (it != memory_block_tree.begin()) {
|
2021-02-13 02:02:51 +01:00
|
|
|
KMemoryBlock* prev{&(*std::prev(it))};
|
2020-04-05 21:26:25 +02:00
|
|
|
|
|
|
|
if (block->HasSameProperties(*prev)) {
|
|
|
|
const iterator prev_it{std::prev(it)};
|
|
|
|
|
|
|
|
prev->Add(block->GetNumPages());
|
|
|
|
EraseIt(it);
|
|
|
|
|
|
|
|
it = prev_it;
|
|
|
|
block = prev;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (it != cend()) {
|
2021-02-13 02:02:51 +01:00
|
|
|
const KMemoryBlock* const next{&(*std::next(it))};
|
2020-04-05 21:26:25 +02:00
|
|
|
|
|
|
|
if (block->HasSameProperties(*next)) {
|
|
|
|
block->Add(next->GetNumPages());
|
|
|
|
EraseIt(std::next(it));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-02-13 02:02:51 +01:00
|
|
|
} // namespace Kernel
|