kern: implement more of KMemoryManager through KPageBuffer slab init

libraries/libmesosphere/source/kern_k_page_heap.cpp

@@ -41,6 +41,87 @@ namespace ams::kern {
         MESOSPHERE_ABORT_UNLESS(KVirtualAddress(cur_bitmap_storage) <= metadata_end);
     }
 
+    size_t KPageHeap::GetNumFreePages() const {
+        size_t num_free = 0;
+
+        for (size_t i = 0; i < this->num_blocks; i++) {
+            num_free += this->blocks[i].GetNumFreePages();
+        }
+
+        return num_free;
+    }
+
+    KVirtualAddress KPageHeap::AllocateBlock(s32 index) {
+        const size_t needed_size = this->blocks[index].GetSize();
+
+        for (s32 i = index; i < static_cast<s32>(this->num_blocks); i++) {
+            if (const KVirtualAddress addr = this->blocks[index].PopBlock(); addr != Null<KVirtualAddress>) {
+                if (const size_t allocated_size = this->blocks[index].GetSize(); allocated_size > needed_size) {
+                    this->Free(addr + needed_size, (allocated_size - needed_size) / PageSize);
+                }
+                return addr;
+            }
+        }
+
+        return Null<KVirtualAddress>;
+    }
+
+    void KPageHeap::FreeBlock(KVirtualAddress block, s32 index) {
+        do {
+            block = this->blocks[index++].PushBlock(block);
+        } while (block != Null<KVirtualAddress>);
+    }
+
+    void KPageHeap::Free(KVirtualAddress addr, size_t num_pages) {
+        /* Freeing no pages is a no-op. */
+        if (num_pages == 0) {
+            return;
+        }
+
+        /* Find the largest block size that we can free, and free as many as possible. */
+        s32 big_index = static_cast<s32>(this->num_blocks) - 1;
+        const KVirtualAddress start  = addr;
+        const KVirtualAddress end    = addr + num_pages * PageSize;
+        KVirtualAddress before_start = start;
+        KVirtualAddress before_end   = start;
+        KVirtualAddress after_start  = end;
+        KVirtualAddress after_end    = end;
+        while (big_index >= 0) {
+            const size_t block_size = this->blocks[big_index].GetSize();
+            const KVirtualAddress big_start = util::AlignUp(GetInteger(start), block_size);
+            const KVirtualAddress big_end   = util::AlignDown(GetInteger(end), block_size);
+            if (big_start < big_end) {
+                /* Free as many big blocks as we can. */
+                for (auto block = big_start; block < big_end; block += block_size) {
+                    this->FreeBlock(block, big_index);
+                }
+                before_end  = big_start;
+                after_start = big_end;
+                break;
+            }
+            big_index--;
+        }
+        MESOSPHERE_ASSERT(big_index >= 0);
+
+        /* Free space before the big blocks. */
+        for (s32 i = big_index; i >= 0; i--) {
+            const size_t block_size = this->blocks[i].GetSize();
+            while (before_start + block_size <= before_end) {
+                before_end -= block_size;
+                this->FreeBlock(before_end, i);
+            }
+        }
+
+        /* Free space after the big blocks. */
+        for (s32 i = big_index; i >= 0; i--) {
+            const size_t block_size = this->blocks[i].GetSize();
+            while (after_start + block_size <= after_end) {
+                after_start += block_size;
+                this->FreeBlock(after_start, i);
+            }
+        }
+    }
+
     size_t KPageHeap::CalculateMetadataOverheadSize(size_t region_size, const size_t *block_shifts, size_t num_block_shifts) {
         size_t overhead_size = 0;
         for (size_t i = 0; i < num_block_shifts; i++) {