Luna/kernel/src/memory/MemoryManager.cpp

#include "memory/MemoryManager.h"
#include "Log.h"
#include "arch/CPU.h"
#include "arch/MMU.h"
#include "boot/bootboot.h"
#include <luna/Alignment.h>
#include <luna/Bitmap.h>
#include <luna/String.h>
#include <luna/SystemError.h>
#include <luna/Types.h>
#include <luna/Units.h>

extern BOOTBOOT bootboot;

extern u8 start_of_kernel_rodata[1];
extern u8 end_of_kernel_rodata[1];
extern u8 start_of_kernel_data[1];
extern u8 end_of_kernel_data[1];

static u64 free_mem = 0;
static u64 used_mem = 0;
static u64 reserved_mem = 0;

static u64 start_index = 0;

static Bitmap g_frame_bitmap;

#define CHECK_PAGE_ALIGNED(address) check(is_aligned(address, ARCH_PAGE_SIZE))

static usize get_physical_address_space_size()
{
    MMapEnt* ptr = &bootboot.mmap;
    u64 biggest_ptr = 0;
    u64 biggest_ptr_size = 0;
    u64 mmap_entries = (bootboot.size - 128) / 16;
    for (u64 i = 0; i < mmap_entries; i++)
    {
        if (MMapEnt_Ptr(ptr) > biggest_ptr)
        {
            biggest_ptr = MMapEnt_Ptr(ptr);
            biggest_ptr_size = MMapEnt_Size(ptr);
        }

        ptr++;
    }

    return biggest_ptr + biggest_ptr_size; // This would be the address at the end of the last entry, thus the whole
                                           // address space that was passed to us.
}

namespace MemoryManager
{
    Result<void> protect_kernel_sections()
    {
        const u64 rodata_size = (u64)(end_of_kernel_rodata - start_of_kernel_rodata);
        const u64 rodata_pages = get_blocks_from_size(rodata_size, ARCH_PAGE_SIZE);
        TRY(remap((u64)start_of_kernel_rodata, rodata_pages, MMU::NoExecute));

        const u64 data_size = (u64)(end_of_kernel_data - start_of_kernel_data);
        const u64 data_pages = get_blocks_from_size(data_size, ARCH_PAGE_SIZE);
        TRY(remap((u64)start_of_kernel_data, data_pages, MMU::NoExecute | MMU::ReadWrite));

        return {};
    }

    void init_physical_frame_allocator()
    {
        u64 total_mem = 0;

        void* biggest_usable_memory_block = nullptr;
        u64 biggest_usable_memory_block_size = 0;

        // walk the memory map
        MMapEnt* ptr = &bootboot.mmap;
        u64 mmap_entries = (bootboot.size - 128) / 16;
        for (u64 i = 0; i < mmap_entries; i++)
        {
            u64 size = MMapEnt_Size(ptr);
            total_mem += size;
            if (!MMapEnt_IsFree(ptr))
            {
                ptr++;
                continue;
            }
            if (size > biggest_usable_memory_block_size)
            {
                biggest_usable_memory_block = (void*)MMapEnt_Ptr(ptr);
                biggest_usable_memory_block_size = MMapEnt_Size(ptr);
            }
            ptr++;
        }

        // The entire physical address space. May contain inexistent memory holes, thus differs from total_mem which
        // only counts existent memory. Our bitmap needs to have space for all of the physical address space, since
        // usable addresses will be scattered across it.
        usize physical_address_space_size = get_physical_address_space_size();

        char* frame_bitmap_addr = (char*)biggest_usable_memory_block;
        usize frame_bitmap_size = physical_address_space_size / ARCH_PAGE_SIZE / 8 + 1;

        // This should never happen, unless memory is very fragmented. Usually there is always a very big block of
        // usable memory and then some tiny blocks around it.
        if (frame_bitmap_size >= biggest_usable_memory_block_size) [[unlikely]]
        {
            kerrorln("ERROR: No single memory block is enough to hold the frame bitmap");
            CPU::efficient_halt();
        }

        g_frame_bitmap.initialize(frame_bitmap_addr, frame_bitmap_size);

        g_frame_bitmap.clear(true); // Set all pages to used/reserved by default, then clear out the free ones

        ptr = &bootboot.mmap;
        for (u64 i = 0; i < mmap_entries; i++)
        {
            u64 index = MMapEnt_Ptr(ptr) / ARCH_PAGE_SIZE;
            u64 pages = MMapEnt_Size(ptr) / ARCH_PAGE_SIZE;
            if (!MMapEnt_IsFree(ptr)) { reserved_mem += MMapEnt_Size(ptr); }
            else
            {
                free_mem += MMapEnt_Size(ptr);
                g_frame_bitmap.clear_region(index, pages, false);
            }
            ptr++;
        }

        lock_frames((u64)frame_bitmap_addr, frame_bitmap_size / ARCH_PAGE_SIZE + 1);
    }

    void init()
    {
        init_physical_frame_allocator();
        MMU::setup_initial_page_directory();
    }

    void lock_frame(u64 frame)
    {
        const u64 index = ((u64)frame) / ARCH_PAGE_SIZE;
        if (g_frame_bitmap.get(index)) return;
        g_frame_bitmap.set(index, true);
        used_mem += ARCH_PAGE_SIZE;
        free_mem -= ARCH_PAGE_SIZE;
    }

    void lock_frames(u64 frames, u64 count)
    {
        for (u64 index = 0; index < count; index++) { lock_frame(frames + (index * ARCH_PAGE_SIZE)); }
    }

    Result<u64> alloc_frame()
    {
        for (u64 index = start_index; index < g_frame_bitmap.size(); index++)
        {
            if (g_frame_bitmap.get(index)) continue;
            g_frame_bitmap.set(index, true);
            start_index = index + 1;
            free_mem -= ARCH_PAGE_SIZE;
            used_mem += ARCH_PAGE_SIZE;
            return index * ARCH_PAGE_SIZE;
        }

        return err(ENOMEM);
    }

    Result<void> free_frame(u64 frame)
    {
        const u64 index = frame / ARCH_PAGE_SIZE;
        if (index > g_frame_bitmap.size()) return err(EFAULT);
        if (!g_frame_bitmap.get(index)) return err(EFAULT);
        g_frame_bitmap.set(index, false);
        used_mem -= ARCH_PAGE_SIZE;
        free_mem += ARCH_PAGE_SIZE;
        if (start_index > index) start_index = index;
        return {};
    }

    Result<void> remap(u64 address, usize count, int flags)
    {
        CHECK_PAGE_ALIGNED(address);

        while (count--)
        {
            TRY(MMU::remap(address, flags));
            address += ARCH_PAGE_SIZE;
        }

        return {};
    }

    Result<void> map_frames_at(u64 virt, u64 phys, usize count, int flags)
    {
        CHECK_PAGE_ALIGNED(virt);
        CHECK_PAGE_ALIGNED(phys);

        while (count--)
        {
            TRY(MMU::map(virt, phys, flags));
            virt += ARCH_PAGE_SIZE;
            phys += ARCH_PAGE_SIZE;
        }

        return {};
    }

    Result<u64> alloc_at(u64 virt, usize count, int flags)
    {
        CHECK_PAGE_ALIGNED(virt);

        u64 start = virt;

        while (count--)
        {
            u64 frame = TRY(alloc_frame());
            TRY(MMU::map(virt, frame, flags));
            virt += ARCH_PAGE_SIZE;
        }

        return start;
    }

    Result<void> unmap_owned(u64 virt, usize count)
    {
        CHECK_PAGE_ALIGNED(virt);

        while (count--)
        {
            u64 frame = TRY(MMU::unmap(virt));
            TRY(free_frame(frame));
            virt += ARCH_PAGE_SIZE;
        }

        return {};
    }

    Result<void> unmap_weak(u64 virt, usize count)
    {
        CHECK_PAGE_ALIGNED(virt);

        while (count--)
        {
            TRY(MMU::unmap(virt));
            virt += ARCH_PAGE_SIZE;
        }

        return {};
    }

    Result<void> remap_unaligned(u64 address, usize count, int flags)
    {
        if (!is_aligned(address, ARCH_PAGE_SIZE)) count++;
        address = align_down(address, ARCH_PAGE_SIZE);

        while (count--)
        {
            TRY(MMU::remap(address, flags));
            address += ARCH_PAGE_SIZE;
        }

        return {};
    }

    bool validate_readable_page(u64 address)
    {
        auto rc = MMU::get_flags(address);
        if (rc.has_error()) return false;
        return true;
    }

    bool validate_writable_page(u64 address)
    {
        auto rc = MMU::get_flags(address);
        if (rc.has_error()) return false;
        if (rc.release_value() & MMU::ReadWrite) return true;
        return false;
    }

    u64 free()
    {
        return free_mem;
    }

    u64 used()
    {
        return used_mem;
    }

    u64 reserved()
    {
        return reserved_mem;
    }

    u64 total()
    {
        return free_mem + used_mem + reserved_mem;
    }
}