MaxOS::memory::VirtualMemoryManager Class Reference

Manages the virtual memory of the system and provides functions to allocate and free memory in the virtual address space. More...

#include <virtual.h>

Public Member Functions
	VirtualMemoryManager ()
	Construct a new Virtual Memory Manager object and set up the initial page tables (kernel mapped into the hh)
	~VirtualMemoryManager ()
	Destroy the Virtual Memory Manager object and free all used pages.
void *	allocate (size_t size, size_t flags)
	Allocate a new chunk of virtual memory.
void *	allocate (uint64_t address, size_t size, size_t flags)
	Allocate a new chunk of virtual memory at a specific address (ie for mmap io devices)
void	free (void *address)
	Free a chunk of virtual memory.
void *	load_physical_into_address_space (uintptr_t physical_address, size_t size, size_t flags)
	Load physical memory into the VMM's address space.
void *	load_shared_memory (const string &name)
	Load shared memory into the VMM's address space.
void *	load_shared_memory (uintptr_t physical_address, size_t size)
	Load shared memory into the VMM's address space.
uint64_t *	pml4_root_address ()
	Get the virtual address of the PML4 root.
uint64_t *	pml4_root_address_physical ()
	Get the physical address of the PML4 root.
size_t	memory_used ()
	Returns the amount of memory used.

Detailed Description

Manages the virtual memory of the system and provides functions to allocate and free memory in the virtual address space.

Note

Have to use a linked list as vector class depends on dynamic memory allocation (which depends on this)

Definition at line 96 of file virtual.h.

Constructor & Destructor Documentation

VirtualMemoryManager()

VirtualMemoryManager::VirtualMemoryManager

(

)

Construct a new Virtual Memory Manager object and set up the initial page tables (kernel mapped into the hh)

Note

Should only be called once per memory manager (kernel and each process)

Definition at line 22 of file virtual.cpp.

                                           {
 
    // 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];
 
        }
        Logger::DEBUG() << "Mapped higher half of kernel\n";
 
 
    } 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);
    }
 
    // Allocate space for the vmm
    uint64_t vmm_space = PhysicalMemoryManager::align_to_page(HIGHER_HALF_DIRECT_MAP + PhysicalMemoryManager::s_current_manager->memory_size() + PAGE_SIZE);
    void* vmm_space_physical = PhysicalMemoryManager::s_current_manager->allocate_frame();
    PhysicalMemoryManager::s_current_manager->map(vmm_space_physical, (virtual_address_t*) vmm_space, PRESENT | WRITE, m_pml4_root_address);
    Logger::DEBUG() << "VMM space: physical - 0x" << (uint64_t) vmm_space_physical << ", virtual - 0x" << (uint64_t) vmm_space << "\n";
 
    // Make sure everything is mapped correctly
    if (!is_kernel)
        ASSERT(vmm_space_physical != PhysicalMemoryManager::s_current_manager->get_physical_address((virtual_address_t*) vmm_space, m_pml4_root_address), "Physical address does not match mapped address: 0x%x != 0x%x\n", vmm_space_physical,
               PhysicalMemoryManager::s_current_manager->get_physical_address((virtual_address_t*) vmm_space, m_pml4_root_address));
 
    // Set the first region
    m_first_region = (virtual_memory_region_t*) vmm_space;
    m_current_region = m_first_region;
    m_first_region->next = nullptr;
 
    // Calculate the next available address (kernel needs to reserve space for the higher half)
    m_next_available_address = is_kernel ? vmm_space + VMM_RESERVED : PAGE_SIZE;
    Logger::DEBUG() << "Next available address: 0x" << m_next_available_address << "\n";
 
}

References MaxOS::memory::PhysicalMemoryManager::align_to_page(), ASSERT, MaxOS::memory::PhysicalMemoryManager::clean_page_table(), MaxOS::Logger::DEBUG(), MaxOS::memory::HIGHER_HALF_DIRECT_MAP, MaxOS::memory::PAGE_SIZE, MaxOS::memory::PRESENT, MaxOS::memory::PhysicalMemoryManager::s_current_manager, MaxOS::memory::MemoryManager::s_kernel_memory_manager, MaxOS::memory::PhysicalMemoryManager::to_dm_region(), MaxOS::memory::PhysicalMemoryManager::to_lower_region(), and MaxOS::memory::WRITE.

~VirtualMemoryManager()

VirtualMemoryManager::~VirtualMemoryManager

(

)

Destroy the Virtual Memory Manager object and free all used pages.

Definition at line 81 of file virtual.cpp.

                                            {
 
    // 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;
 
            // 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);
                PhysicalMemoryManager::s_current_manager->free_frame(frame);
 
            }
        }
 
        region = region->next;
    }
}

References MaxOS::memory::PAGE_SIZE, MaxOS::memory::PhysicalMemoryManager::s_current_manager, and MaxOS::memory::PhysicalMemoryManager::size_to_frames().

Member Function Documentation

allocate() [1/2]

void * VirtualMemoryManager::allocate	(	size_t	size,
		size_t	flags
	)

Allocate a new chunk of virtual memory.

Parameters

size	The size of the memory to allocate
flags	The flags to set on the memory

Returns

The address of the allocated memory

Definition at line 119 of file virtual.cpp.

                                                              {
 
    return allocate(0, size, flags);
}

References allocate().

Referenced by allocate(), load_physical_into_address_space(), and MaxOS::memory::MemoryManager::MemoryManager().

allocate() [2/2]

void * VirtualMemoryManager::allocate	(	uint64_t	address,
		size_t	size,
		size_t	flags
	)

Allocate a new chunk of virtual memory at a specific address (ie for mmap io devices)

Parameters

address	The address to allocate at
size	The size of the memory to allocate
flags	The flags to set on the memory

Returns

The address of the allocated memory or nullptr if failed

Definition at line 133 of file virtual.cpp.

                                                                                {
 
    // Make sure allocating something
    if (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
    size = PhysicalMemoryManager::align_up_to_page(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(size) : nullptr;
    if (reusable_chunk != nullptr) {
 
        // If the chunk is not being reserved then the old memory needs to be unmapped
        if (flags & VirtualFlags::RESERVE) {
 
            // Unmap the memory
            size_t pages = PhysicalMemoryManager::size_to_frames(size);
            for (size_t i = 0; i < pages; i++) {
 
                // Get the frame
                physical_address_t* frame = PhysicalMemoryManager::s_current_manager->get_physical_address((virtual_address_t*) reusable_chunk->start_address + (i * PAGE_SIZE), m_pml4_root_address);
 
                // Free the frame
                PhysicalMemoryManager::s_current_manager->free_frame(frame);
 
            }
        }
 
        // Return the address
        return (void*) reusable_chunk->start_address;
    }
 
 
    // 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);
 
    // 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++;
 
    // 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(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;
}

References MaxOS::memory::PhysicalMemoryManager::align_up_to_page(), ASSERT, MaxOS::memory::PhysicalMemoryManager::check_aligned(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::PRESENT, MaxOS::memory::RESERVE, MaxOS::memory::PhysicalMemoryManager::s_current_manager, MaxOS::memory::PhysicalMemoryManager::size_to_frames(), and MaxOS::memory::WRITE.

free()

void VirtualMemoryManager::free

(

void *

address

)

Free a chunk of virtual memory.

Parameters

address

The address of the memory to free

Definition at line 253 of file virtual.cpp.

                                             {
 
    // 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;
 
    // If the chunk is shared, don't unmap it incase other processes are using it
    if (chunk->flags & VirtualFlags::SHARED) {
 
        // Find the resource
        for(const auto& resource : GlobalScheduler::current_process()->resource_manager.resources()){
 
            // Skip non-shared memory resources
            if(resource.second->type() != resource_type_t::SHARED_MEMORY)
                continue;
 
            // Skip shared memory that points elsewhere
            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);
        }
    }
 
    // Add the chunk to the free list
    add_free_chunk(chunk->start_address, chunk->size);
 
    // Clear the chunk
    chunk->size = 0;
    chunk->flags = 0;
    chunk->start_address = 0;
}

References MaxOS::processes::GlobalScheduler::current_process().

load_physical_into_address_space()

void * VirtualMemoryManager::load_physical_into_address_space	(	uintptr_t	physical_address,
		size_t	size,
		size_t	flags
	)

Load physical memory into the VMM's address space.

Parameters

physical_address	The physical address of the memory
size	The size of the memory
flags	The flags to set on the memory

Returns

The address of the memory in the VMM's address space

Definition at line 455 of file virtual.cpp.

                                                                                                                  {
 
    // 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;
}

References allocate(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::PRESENT, MaxOS::memory::RESERVE, MaxOS::memory::PhysicalMemoryManager::s_current_manager, MaxOS::memory::PhysicalMemoryManager::size_to_frames(), and MaxOS::memory::WRITE.

Referenced by load_shared_memory().

load_shared_memory() [1/2]

void * VirtualMemoryManager::load_shared_memory

(

const string &

name

)

Load shared memory into the VMM's address space.

Parameters

name	The name of the shared memory

Returns

The address of the shared memory in the VMM's address space

Definition at line 418 of file virtual.cpp.

                                                                 {
 
    // 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;
}

References MaxOS::processes::GlobalScheduler::current_process(), and load_shared_memory().

Referenced by load_shared_memory().

load_shared_memory() [2/2]

void * VirtualMemoryManager::load_shared_memory	(	uintptr_t	physical_address,
		size_t	size
	)

Load shared memory into the VMM's address space.

Parameters

physical_address	The physical address of the shared memory
size	The size of the shared memory

Returns

The address of the shared memory in the VMM's address space

Definition at line 437 of file virtual.cpp.

                                                                                      {
 
    // 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);
}

References load_physical_into_address_space(), and MaxOS::memory::SHARED.

memory_used()

size_t VirtualMemoryManager::memory_used

(

)

Returns the amount of memory used.

Returns

The amount of memory used

Definition at line 320 of file virtual.cpp.

                                         {
 
    // 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;
}

pml4_root_address()

uint64_t * VirtualMemoryManager::pml4_root_address

(

)

Get the virtual address of the PML4 root.

Returns

The virtual address or nullptr if not found

Definition at line 521 of file virtual.cpp.

                                                  {
 
    // Make sure the address is valid
    if (m_pml4_root_address == nullptr)
        return nullptr;
 
    // Return the address
    return m_pml4_root_address;
}

pml4_root_address_physical()

uint64_t * VirtualMemoryManager::pml4_root_address_physical

(

)

Get the physical address of the PML4 root.

Returns

The physical address of the PML4 root

Definition at line 407 of file virtual.cpp.

                                                           {
 
    return m_pml4_root_physical_address;
}

---

The documentation for this class was generated from the following files:

• /home/runner/work/MaxOS/MaxOS/kernel/include/memory/virtual.h
• /home/runner/work/MaxOS/MaxOS/kernel/src/memory/virtual.cpp