mirrors/Atmosphere
1
0
Fork 0
mirror of https://github.com/Atmosphere-NX/Atmosphere.git synced 2025-05-13 14:44:23 -04:00
Code Issues Projects Releases Packages Wiki Activity

kern: change terminology metadata -> management

Browse source
This commit is contained in:
Michael Scire 2020-08-25 16:12:14 -07:00 • committed by SciresM
parent 546e2de300
commit ce95af89ef
7 changed files with 133 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

48
libraries/libmesosphere/source/kern_k_memory_manager.cpp
View file

@ -31,10 +31,10 @@ namespace ams::kern {
}
void KMemoryManager::Initialize(KVirtualAddress metadata_region, size_t metadata_region_size) {
/* Clear the metadata region to zero. */
const KVirtualAddress metadata_region_end = metadata_region + metadata_region_size;
std::memset(GetVoidPointer(metadata_region), 0, metadata_region_size);
void KMemoryManager::Initialize(KVirtualAddress management_region, size_t management_region_size) {
/* Clear the management region to zero. */
const KVirtualAddress management_region_end = management_region + management_region_size;
std::memset(GetVoidPointer(management_region), 0, management_region_size);
/* Traverse the virtual memory layout tree, initializing each manager as appropriate. */
while (true) {
@ -72,9 +72,9 @@ namespace ams::kern {
Impl *manager = std::addressof(this->managers[this->num_managers++]);
MESOSPHERE_ABORT_UNLESS(this->num_managers <= util::size(this->managers));
const size_t cur_size = manager->Initialize(region, pool, metadata_region, metadata_region_end);
metadata_region += cur_size;
MESOSPHERE_ABORT_UNLESS(metadata_region <= metadata_region_end);
const size_t cur_size = manager->Initialize(region, pool, management_region, management_region_end);
management_region += cur_size;
MESOSPHERE_ABORT_UNLESS(management_region <= management_region_end);
/* Insert the manager into the pool list. */
if (this->pool_managers_tail[pool] == nullptr) {
@ -313,25 +313,25 @@ namespace ams::kern {
return ResultSuccess();
}
size_t KMemoryManager::Impl::Initialize(const KMemoryRegion *region, Pool p, KVirtualAddress metadata, KVirtualAddress metadata_end) {
/* Calculate metadata sizes. */
size_t KMemoryManager::Impl::Initialize(const KMemoryRegion *region, Pool p, KVirtualAddress management, KVirtualAddress management_end) {
/* Calculate management sizes. */
const size_t ref_count_size = (region->GetSize() / PageSize) * sizeof(u16);
const size_t optimize_map_size = CalculateOptimizedProcessOverheadSize(region->GetSize());
const size_t manager_size = util::AlignUp(optimize_map_size + ref_count_size, PageSize);
const size_t page_heap_size = KPageHeap::CalculateMetadataOverheadSize(region->GetSize());
const size_t total_metadata_size = manager_size + page_heap_size;
MESOSPHERE_ABORT_UNLESS(manager_size <= total_metadata_size);
MESOSPHERE_ABORT_UNLESS(metadata + total_metadata_size <= metadata_end);
MESOSPHERE_ABORT_UNLESS(util::IsAligned(total_metadata_size, PageSize));
const size_t page_heap_size = KPageHeap::CalculateManagementOverheadSize(region->GetSize());
const size_t total_management_size = manager_size + page_heap_size;
MESOSPHERE_ABORT_UNLESS(manager_size <= total_management_size);
MESOSPHERE_ABORT_UNLESS(management + total_management_size <= management_end);
MESOSPHERE_ABORT_UNLESS(util::IsAligned(total_management_size, PageSize));
/* Setup region. */
this->pool = p;
this->metadata_region = metadata;
this->page_reference_counts = GetPointer<RefCount>(metadata + optimize_map_size);
MESOSPHERE_ABORT_UNLESS(util::IsAligned(GetInteger(this->metadata_region), PageSize));
this->management_region = management;
this->page_reference_counts = GetPointer<RefCount>(management + optimize_map_size);
MESOSPHERE_ABORT_UNLESS(util::IsAligned(GetInteger(this->management_region), PageSize));
/* Initialize the manager's KPageHeap. */
this->heap.Initialize(region->GetAddress(), region->GetSize(), metadata + manager_size, page_heap_size);
this->heap.Initialize(region->GetAddress(), region->GetSize(), management + manager_size, page_heap_size);
/* Free the memory to the heap. */
this->heap.Free(region->GetAddress(), region->GetSize() / PageSize);
@ -339,7 +339,7 @@ namespace ams::kern {
/* Update the heap's used size. */
this->heap.UpdateUsedSize();
return total_metadata_size;
return total_management_size;
}
void KMemoryManager::Impl::TrackUnoptimizedAllocation(KVirtualAddress block, size_t num_pages) {
@ -348,7 +348,7 @@ namespace ams::kern {
const size_t last = offset + num_pages - 1;
/* Track. */
u64 *optimize_map = GetPointer<u64>(this->metadata_region);
u64 *optimize_map = GetPointer<u64>(this->management_region);
while (offset <= last) {
/* Mark the page as not being optimized-allocated. */
optimize_map[offset / BITSIZEOF(u64)] &= ~(u64(1) << (offset % BITSIZEOF(u64)));
@ -363,7 +363,7 @@ namespace ams::kern {
const size_t last = offset + num_pages - 1;
/* Track. */
u64 *optimize_map = GetPointer<u64>(this->metadata_region);
u64 *optimize_map = GetPointer<u64>(this->management_region);
while (offset <= last) {
/* Mark the page as being optimized-allocated. */
optimize_map[offset / BITSIZEOF(u64)] |= (u64(1) << (offset % BITSIZEOF(u64)));
@ -381,7 +381,7 @@ namespace ams::kern {
const size_t last = offset + num_pages - 1;
/* Process. */
u64 *optimize_map = GetPointer<u64>(this->metadata_region);
u64 *optimize_map = GetPointer<u64>(this->management_region);
while (offset <= last) {
/* Check if the page has been optimized-allocated before. */
if ((optimize_map[offset / BITSIZEOF(u64)] & (u64(1) << (offset % BITSIZEOF(u64)))) == 0) {
@ -399,11 +399,11 @@ namespace ams::kern {
return any_new;
}
size_t KMemoryManager::Impl::CalculateMetadataOverheadSize(size_t region_size) {
size_t KMemoryManager::Impl::CalculateManagementOverheadSize(size_t region_size) {
const size_t ref_count_size = (region_size / PageSize) * sizeof(u16);
const size_t optimize_map_size = (util::AlignUp((region_size / PageSize), BITSIZEOF(u64)) / BITSIZEOF(u64)) * sizeof(u64);
const size_t manager_meta_size = util::AlignUp(optimize_map_size + ref_count_size, PageSize);
const size_t page_heap_size = KPageHeap::CalculateMetadataOverheadSize(region_size);
const size_t page_heap_size = KPageHeap::CalculateManagementOverheadSize(region_size);
return manager_meta_size + page_heap_size;
}