virtual.cpp

Go to the documentation of this file.

 
#include <memory/virtual.h>
#include <common/logger.h>
#include <processes/scheduler.h>
 
using namespace MaxOS::memory;
using namespace MaxOS::common;
using namespace MaxOS::processes;
using namespace MaxOS::processes::resources;
 
VirtualMemoryManager::VirtualMemoryManager() {
 
    // Set the kernel flag
    bool is_kernel = MemoryManager::s_kernel_memory_manager == nullptr;
    if (!is_kernel) {
 
        // Get a new pml4 table
        m_pml4_root_physical_address = (uint64_t*)PhysicalMemoryManager::s_current_manager->allocate_frame();
        m_pml4_root_address = (uint64_t*)PhysicalMemoryManager::to_dm_region((uint64_t)m_pml4_root_physical_address);
 
        // Clear the table
        PhysicalMemoryManager::clean_page_table(m_pml4_root_address);
 
        // Map the higher half of the kernel (p4 256 - 511)
        for (size_t i = 256; i < 512; i++) {
 
            // Recursive Map the pml4 table (so that we can access the new pml4 table later on)
            if (i == 510) {
                m_pml4_root_address[i] = (uint64_t)m_pml4_root_physical_address | PRESENT | WRITE;
                continue;
            }
 
            // Set the new pml4 table to the old (kernel) pml4 table
            m_pml4_root_address[i] = PhysicalMemoryManager::s_current_manager->pml4_root_address()[i];
 
        }
 
        // Load the userspace pml4
        asm volatile("mov %0, %%cr3"::"r"((uint64_t)m_pml4_root_physical_address) : "memory");
 
    } else {
        m_pml4_root_address = PhysicalMemoryManager::s_current_manager->pml4_root_address();
        m_pml4_root_physical_address = (uint64_t*)PhysicalMemoryManager::to_lower_region((uint64_t)m_pml4_root_address);
    }
 
    // Set up the first region
    new_region();
    m_first_region = m_current_region;
 
    // Calculate the next available address (kernel needs to reserve space for the higher half)
    m_next_available_address = is_kernel ? HIGHER_HALF_DIRECT_MAP + PhysicalMemoryManager::s_current_manager->memory_size() + VMM_RESERVED : PAGE_SIZE;
}
 
VirtualMemoryManager::~VirtualMemoryManager() {
 
    // Free all the frames used by the VMM
    virtual_memory_region_t* region = m_first_region;
 
    // Loop through the regions
    while (region != nullptr) {
 
        // Loop through the chunks
        for (size_t i = 0; i < CHUNKS_PER_PAGE; i++) {
 
            // Have reached the end?
            if (i == m_current_chunk && region == m_current_region)
                break;
 
            // Cant free shared frames that may be in use by another VMM
            if (region->chunks[i].flags & SHARED)
                continue;
 
            // Free each page in the chunk
            size_t pages = PhysicalMemoryManager::size_to_frames(region->chunks[i].size);
            for (size_t j = 0; j < pages; j++) {
 
                // Convert the virtual address to a physical address and free it
                physical_address_t* frame = PhysicalMemoryManager::s_current_manager->get_physical_address((virtual_address_t*)(region->chunks[i].start_address + j * PAGE_SIZE), m_pml4_root_address);
                if (frame != nullptr)
                    PhysicalMemoryManager::s_current_manager->free_frame(frame);
 
            }
        }
 
        region = region->next;
    }
}
 
void* VirtualMemoryManager::allocate(size_t requested_size, size_t flags) {
 
    size_t actual_size;
    return allocate(0, requested_size, actual_size, flags);
}
 
void* VirtualMemoryManager::allocate(size_t requested_size, size_t& actual_size, size_t flags) {
 
    return allocate(0, requested_size, actual_size, flags);
}
 
 
void* VirtualMemoryManager::allocate(uint64_t address, size_t requested_size, size_t& actual_size, size_t flags) {
 
    // Make sure allocating something
    if (requested_size == 0)
        return nullptr;
 
    // If specific address is given
    if (address != 0) {
 
        // Make sure isn't already allocated
        if (address < m_next_available_address)
            return nullptr;
 
        // Make sure its aligned
        if (!PhysicalMemoryManager::check_aligned(address))
            return nullptr;
 
    }
 
    // Make sure the size is aligned
    actual_size = PhysicalMemoryManager::align_up_to_page(requested_size, PAGE_SIZE);
 
    // Check the free list for a chunk (if not asking for a specific address)
    free_chunk_t* reusable_chunk = address == 0 ? find_and_remove_free_chunk(actual_size) : nullptr;
    if (reusable_chunk != nullptr) {
 
        // If the chunk is being reserved then the old memory needs to be unmapped (as the owner of this reserved region will perform the mapping as required)
        uintptr_t chunk_start = reusable_chunk->start_address;
        if (flags & RESERVE) {
 
            // Unmap the memory
            size_t pages = PhysicalMemoryManager::size_to_frames(actual_size);
            for (size_t i = 0; i < pages; i++) {
 
                // Free the frame
                physical_address_t* frame = PhysicalMemoryManager::s_current_manager->get_physical_address((virtual_address_t*)(chunk_start + i * PAGE_SIZE), m_pml4_root_address);
                if (frame != nullptr)
                    PhysicalMemoryManager::s_current_manager->free_frame(frame);
 
                // Unmap the page
                auto page = (virtual_address_t*)(chunk_start + (i * PAGE_SIZE));
                if (page != nullptr)
                    PhysicalMemoryManager::s_current_manager->unmap(page, m_pml4_root_address);
 
            }
        }
 
        // Ensure there is enough space if no reusable chunk is found
        if (m_current_chunk >= CHUNKS_PER_PAGE)
            new_region();
 
        // Allocate the memory
        virtual_memory_chunk_t* chunk = &m_current_region->chunks[m_current_chunk++];
        chunk->size = actual_size;
        chunk->flags = flags;
        chunk->start_address = chunk_start;
 
        // Return the address
        return (void*)chunk_start;
    }
 
    // Is there space in the current region
    if (m_current_chunk >= CHUNKS_PER_PAGE)
        new_region();
 
    // If needed to allocate at a specific address, fill with free memory up to that address to prevent fragmentation
    if (address != 0)
        fill_up_to_address(address, flags, false);
 
    // fill_up_to_address() may have filled the last slot.
    if (m_current_chunk >= CHUNKS_PER_PAGE)
        new_region();
 
    // Allocate the memory
    virtual_memory_chunk_t* chunk = &m_current_region->chunks[m_current_chunk];
    chunk->size = actual_size;
    chunk->flags = flags;
    chunk->start_address = m_next_available_address;
 
    // Update the next available address
    m_next_available_address += actual_size;
    m_current_chunk++;
 
    // If just reserving the space don't map it
    if (flags & RESERVE)
        return (void*)chunk->start_address;
 
    // Map the memory
    size_t pages = PhysicalMemoryManager::size_to_frames(actual_size);
    for (size_t i = 0; i < pages; i++) {
 
        // Allocate a new frame
        physical_address_t* frame = PhysicalMemoryManager::s_current_manager->allocate_frame();
        ASSERT(frame != nullptr, "Failed to allocate frame (from current region)\n");
 
        // Map the frame
        PhysicalMemoryManager::s_current_manager->map(frame, (virtual_address_t*)(chunk->start_address + i * PAGE_SIZE), PRESENT | WRITE, m_pml4_root_address);
 
    }
 
    // Return the address
    return (void*)chunk->start_address;
}
 
void VirtualMemoryManager::new_region() {
 
    // Space for the new region
    physical_address_t* new_region_physical = PhysicalMemoryManager::s_current_manager->allocate_frame();
    ASSERT(new_region_physical != nullptr, "Failed to allocate new VMM region\n");
 
    // Align the new region
    auto* new_region = (virtual_memory_region_t*)PhysicalMemoryManager::align_to_page((uint64_t)m_current_region + PAGE_SIZE);
 
    // Map the new region
    PhysicalMemoryManager::s_current_manager->map(new_region_physical, (virtual_address_t*)new_region, PRESENT | WRITE, m_pml4_root_address);
    new_region->next = nullptr;
 
    // Clear the new region
    for (size_t i = 0; i < CHUNKS_PER_PAGE; i++) {
        new_region->chunks[i].size = 0;
        new_region->chunks[i].flags = 0;
        new_region->chunks[i].start_address = 0;
    }
 
    // Set the current region
    if (m_current_region)
        m_current_region->next = new_region;
    m_current_chunk = 0;
    m_current_region = new_region;
}
 
void VirtualMemoryManager::free(void* address, bool reusable_pages) {
 
    // Make sure freeing something
    if (address == nullptr)
        return;
 
    // Find the chunk
    virtual_memory_region_t* region = m_first_region;
    virtual_memory_chunk_t* chunk = nullptr;
    while (region != nullptr) {
 
        // Loop through the chunks
        for (size_t i = 0; i < CHUNKS_PER_PAGE; i++) {
 
            // Check if the address is in the chunk
            if (region->chunks[i].start_address == (uintptr_t)address) {
                chunk = &region->chunks[i];
                break;
            }
        }
 
        // If the chunk was found
        if (chunk != nullptr)
            break;
 
        // Move to the next region
        region = region->next;
    }
 
    // Make sure the chunk was found
    if (chunk == nullptr)
        return;
 
    // No longer using a shared memory chunk
    if (chunk->flags & VirtualFlags::SHARED) {
 
        // Find the resource
        for (const auto& resource : GlobalScheduler::current_process()->resource_manager.resources()) {
            if (resource.second->type() != resource_type_t::SHARED_MEMORY)
                continue;
 
            // Skip shared memory that points elsewhere TODO: this is vaddr so get paddr and comapre?
            auto shared = (SharedMemory*)resource.second;
            if ((void*)shared->physical_address() != address)
                continue;
 
            // Close the resource
            GlobalScheduler::current_process()->resource_manager.close_resource(resource.first, 0);
        }
    }
 
    // Can only re use pages we own
    if (reusable_pages && !(chunk->flags & (SHARED | RESERVE)))
        add_free_chunk(chunk->start_address, chunk->size);
 
    // Clear the chunk
    chunk->size = 0;
    chunk->flags = 0;
    chunk->start_address = 0;
}
 
size_t VirtualMemoryManager::memory_used() {
 
    // Loop through all the regions and add up the size of the allocated chunks
    size_t result = 0;
 
    // Iterate through the regions
    virtual_memory_region_t* region = m_first_region;
    while (region != nullptr) {
 
        // Loop through the chunks
        for (size_t i = 0; i < CHUNKS_PER_PAGE; i++) {
 
            // Check if the address is in the chunk
            if (region->chunks[i].size != 0)
                result += region->chunks[i].size;
        }
 
        // Move to the next region
        region = region->next;
    }
 
    return result;
}
 
void VirtualMemoryManager::add_free_chunk(uintptr_t start_address, size_t size) {
 
    // Create the new chunk
    auto* new_chunk = (free_chunk_t*)start_address;
    new_chunk->start_address = start_address;
    new_chunk->size = size;
    new_chunk->next = m_free_chunks;
 
    // Set the new chunk
    m_free_chunks = new_chunk;
}
 
free_chunk_t* VirtualMemoryManager::find_and_remove_free_chunk(size_t size) {
 
    // Find the chunk
    free_chunk_t* current = m_free_chunks;
    free_chunk_t* previous = nullptr;
    while (current != nullptr) {
 
        // Check if the chunk is big enough
        if (current->size >= size) {
 
            // Remove the chunk
            if (previous != nullptr) {
                previous->next = current->next;
            } else {
                m_free_chunks = current->next;
            }
 
            // Return the chunk
            return current;
 
        }
 
        // Move to the next chunk
        previous = current;
        current = current->next;
    }
 
    // No chunk found
    return nullptr;
 
}
 
virtual_memory_chunk_t* VirtualMemoryManager::find_containing_chunk(const void* start_address, size_t size) {
 
    // Search all the regions for the virtual chunk containing the range
    virtual_memory_region_t* region = m_first_region;
    while (region != nullptr) {
        for (size_t i = 0; i < CHUNKS_PER_PAGE; i++) {
 
            // Get the chunk info
            auto chunk = region->chunks[i];
            auto chunk_start = (void*)chunk.start_address;
            auto chunk_end = (void*)(chunk.start_address + chunk.size);
 
            // Does the region start in this chunk?
            if (!(start_address >= chunk_start && start_address <= chunk_end))
                continue;
 
            // Can this chunk contain the whole region?
            if (!(start_address + size <= chunk_end))
                continue;
 
            return &region->chunks[i];
 
        }
        region = region->next;
    }
 
    // Not found
    return nullptr;
}
 
uint64_t* VirtualMemoryManager::pml4_root_address_physical() {
 
    return m_pml4_root_physical_address;
}
 
void* VirtualMemoryManager::load_shared_memory(const string& name) {
 
    // Get the shared memory block
    auto block = (SharedMemory*)GlobalScheduler::current_process()->resource_manager.get_resource(name);
 
    // Load the shared memory
    if (block != nullptr)
        return load_shared_memory(block->physical_address(), block->size());
 
    return nullptr;
}
 
void* VirtualMemoryManager::load_shared_memory(uintptr_t physical_address, size_t size) {
 
    // Make sure there is somthing to map
    if (size == 0 || physical_address == 0)
        return nullptr;
 
    // Load it into physical memory
    return load_physical_into_address_space(physical_address, size, SHARED);
}
 
void* VirtualMemoryManager::load_physical_into_address_space(uintptr_t physical_address, size_t size, size_t flags) {
 
    // Reserve some space
    void* address = allocate(size, flags | RESERVE);
 
    // Map the shared memory
    size_t pages = PhysicalMemoryManager::size_to_frames(size);
    for (size_t i = 0; i < pages; i++)
        PhysicalMemoryManager::s_current_manager->map((physical_address_t*)(physical_address + (i * PAGE_SIZE)), (virtual_address_t*)((uintptr_t)address + (i * PAGE_SIZE)), PRESENT | WRITE, m_pml4_root_address);
 
 
    // All done
    return address;
}
 
void* VirtualMemoryManager::load_range_from_process(VirtualMemoryManager* other_vmm, const void* start_address, size_t size) {
 
    // Check bounds
    if (!other_vmm || !start_address || size == 0)
        return nullptr;
 
    // Convert given region to be page orientated
    size_t aligned_start = PhysicalMemoryManager::align_direct_to_page((size_t)start_address);
    size_t offset = (size_t)start_address - aligned_start;
    size_t total_size = offset + size;
    size_t paged_size = PhysicalMemoryManager::align_up_to_page(total_size, PAGE_SIZE);
 
    // Reserve space to receive the copy
    auto dest = allocate(paged_size, RESERVE);
    if (!dest)
        return nullptr;
 
    // Find the pages that contains the chunk
    size_t range_pages = paged_size / PAGE_SIZE;
 
    // Map each page in the range
    for (size_t i = 0; i < range_pages; i++) {
        uintptr_t virtual_page = aligned_start + i * PAGE_SIZE;
 
        // Haven't reached the start of the region
        if (virtual_page + PAGE_SIZE <= aligned_start)
            continue;
 
        // Dont copy pages past the region
        if (virtual_page >= aligned_start + paged_size)
            break;
 
        // Map the page into this vmm
        physical_address_t* frame = PhysicalMemoryManager::s_current_manager->get_physical_address((virtual_address_t*)virtual_page, other_vmm->pml4_root_address());
        if (frame == nullptr)
            continue;
 
        PhysicalMemoryManager::s_current_manager->map(frame, (virtual_address_t*)(dest + virtual_page - aligned_start), PRESENT | WRITE, m_pml4_root_address);
    }
 
    // Return where the region actually starts, not the chunk
    return dest + offset;
}
 
void VirtualMemoryManager::unload_range_from_process(const void* start_address, size_t size) {
 
    // Check bounds
    if (!start_address || size == 0)
        return;
 
    // Convert given region to be page orientated
    size_t aligned_start = PhysicalMemoryManager::align_direct_to_page((size_t)start_address);
    size_t offset = (size_t)start_address - aligned_start;
    size_t total_size = offset + size;
    size_t paged_size = PhysicalMemoryManager::align_up_to_page(total_size, PAGE_SIZE);
 
    // Find the chunk that contains the region
    auto containing_chunk = find_containing_chunk(start_address, size);
    size_t chunk_pages = PhysicalMemoryManager::size_to_frames(containing_chunk->size);
 
    // Unmap each page in the range
    for (size_t i = 0; i < chunk_pages; i++) {
        uintptr_t virtual_page = containing_chunk->start_address + i * PAGE_SIZE;
 
        // Haven't reached the start of the region
        if (virtual_page + PAGE_SIZE <= aligned_start)
            continue;
 
        // Dont unmap pages past the region
        if (virtual_page >= aligned_start + paged_size)
            break;
 
        // Free the page
        PhysicalMemoryManager::s_current_manager->unmap((virtual_address_t*)virtual_page, m_pml4_root_address);
    }
 
    // Free the whole region
    free((void*)aligned_start, false);
}
 
void VirtualMemoryManager::fill_up_to_address(uintptr_t address, size_t flags, bool mark_used) {
 
    // Make sure the address is aligned
    address = PhysicalMemoryManager::align_to_page(address);
 
    // Make sure the address is not before the next available address
    ASSERT(address >= m_next_available_address, "FAILED TO FILL: Address is before the next available address - 0x%x < 0x%x\n", address, m_next_available_address);
 
    // Calculate the size
    size_t size = address - m_next_available_address;
 
    // Allocate the memory
    virtual_memory_chunk_t* chunk = &m_current_region->chunks[m_current_chunk];
    chunk->size = size;
    chunk->flags = flags;
    chunk->start_address = m_next_available_address;
 
    // Update the next available address
    m_next_available_address += size;
    m_current_chunk++;
 
    // Map the memory
    size_t pages = PhysicalMemoryManager::size_to_frames(size);
    for (size_t i = 0; i < pages; i++) {
 
        // Allocate a new frame
        physical_address_t* frame = PhysicalMemoryManager::s_current_manager->allocate_frame();
        ASSERT(frame != nullptr, "Failed to allocate frame (from fill up)\n");
 
        // Map the frame
        PhysicalMemoryManager::s_current_manager->map(frame, (virtual_address_t*)(chunk->start_address + i * PAGE_SIZE), PRESENT | WRITE, m_pml4_root_address);
 
    }
 
    // Mark as free if needed
    if (!mark_used)
        free((void*)chunk->start_address);
}
 
uint64_t* VirtualMemoryManager::pml4_root_address() {
 
    // Make sure the address is valid
    if (m_pml4_root_address == nullptr)
        return nullptr;
 
    // Return the address
    return m_pml4_root_address;
}