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 (size_t requested_size, size_t &actual_size, size_t flags)
	Allocate a new chunk of virtual memory.
void *	allocate (uint64_t address, size_t requested_size, size_t &actual_size, size_t flags)
	Allocate a new chunk of virtual memory at a specific address (ie for mmap io devices)
void	free (void *address, bool reusable_pages=true)
	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_range_from_process (VirtualMemoryManager *other_vmm, const void *start_address, size_t size)
	Loads the pages from a virtual memory region in another vmm into this one.
void	unload_range_from_process (const void *start_address, size_t size)
	Unload a shared range of pages from this vmm.
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 104 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 25 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];
 
        }
 
        // 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;
}

References MaxOS::memory::PhysicalMemoryManager::clean_page_table(), MaxOS::memory::HIGHER_HALF_DIRECT_MAP, MaxOS::memory::PhysicalMemoryManager::memory_size(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::PhysicalMemoryManager::pml4_root_address(), 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(), MaxOS::memory::VMM_RESERVED, and MaxOS::memory::WRITE.

~VirtualMemoryManager()

VirtualMemoryManager::~VirtualMemoryManager

(

)

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

Definition at line 71 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;
 
            // 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;
    }
}

References MaxOS::memory::CHUNKS_PER_PAGE, MaxOS::memory::PhysicalMemoryManager::free_frame(), MaxOS::memory::PhysicalMemoryManager::get_physical_address(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::PhysicalMemoryManager::s_current_manager, MaxOS::memory::SHARED, and MaxOS::memory::PhysicalMemoryManager::size_to_frames().

Member Function Documentation

allocate() [1/3]

void * VirtualMemoryManager::allocate	(	size_t	requested_size,
		size_t &	actual_size,
		size_t	flags
	)

Allocate a new chunk of virtual memory.

Parameters

requested_size	The size of the memory to allocate
actual_size	The size of the memory allocated (>= requested size)
flags	The flags to set on the memory

Returns

The address of the allocated memory

Definition at line 127 of file virtual.cpp.

                                                                                             {
 
    return allocate(0, requested_size, actual_size, flags);
}

References allocate().

Referenced by allocate().

allocate() [2/3]

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

Allocate a new chunk of virtual memory.

Parameters

requested_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 113 of file virtual.cpp.

                                                                        {
 
    size_t actual_size;
    return allocate(0, requested_size, actual_size, flags);
}

References allocate().

Referenced by allocate(), MaxOS::memory::BumpMemoryManager::BumpMemoryManager(), load_physical_into_address_space(), load_range_from_process(), and MaxOS::processes::GlobalScheduler::prepare_initrd().

allocate() [3/3]

void * VirtualMemoryManager::allocate	(	uint64_t	address,
		size_t	requested_size,
		size_t &	actual_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
requested_size	The size of the memory to allocate
actual_size	The size of the memory allocated (>= requested size)
flags	The flags to set on the memory

Returns

The address of the allocated memory or nullptr if failed

Definition at line 142 of file virtual.cpp.

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

References MaxOS::memory::PhysicalMemoryManager::align_up_to_page(), MaxOS::memory::PhysicalMemoryManager::allocate_frame(), MaxOS::memory::PhysicalMemoryManager::check_aligned(), MaxOS::memory::CHUNKS_PER_PAGE, MaxOS::memory::VirtualMemoryChunk::flags, MaxOS::memory::PhysicalMemoryManager::free_frame(), MaxOS::memory::PhysicalMemoryManager::get_physical_address(), MaxOS::memory::PhysicalMemoryManager::map(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::PRESENT, MaxOS::memory::RESERVE, MaxOS::memory::PhysicalMemoryManager::s_current_manager, MaxOS::memory::VirtualMemoryChunk::size, MaxOS::memory::PhysicalMemoryManager::size_to_frames(), MaxOS::memory::VirtualMemoryChunk::start_address, MaxOS::memory::FreeChunk::start_address, MaxOS::memory::PhysicalMemoryManager::unmap(), and MaxOS::memory::WRITE.

free()

void VirtualMemoryManager::free	(	void *	address,
		bool	reusable_pages = true
	)

Free a chunk of virtual memory.

Parameters

address	The address of the memory to free
reusable_pages	Can these pages be reused (chunk will be added to free list)

Definition at line 282 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;
 
    // 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;
}

References MaxOS::memory::CHUNKS_PER_PAGE, MaxOS::processes::resources::ResourceManager::close_resource(), MaxOS::processes::GlobalScheduler::current_process(), MaxOS::memory::VirtualMemoryChunk::flags, MaxOS::memory::RESERVE, MaxOS::processes::Process::resource_manager, MaxOS::processes::resources::ResourceManager::resources(), MaxOS::memory::SHARED, MaxOS::memory::VirtualMemoryChunk::size, and MaxOS::memory::VirtualMemoryChunk::start_address.

Referenced by unload_range_from_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 524 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_range_from_process()

void * VirtualMemoryManager::load_range_from_process	(	VirtualMemoryManager *	other_vmm,
		const void *	start_address,
		size_t	size
	)

Loads the pages from a virtual memory region in another vmm into this one.

Parameters

other_vmm	The vmm that contains the region
start_address	The starting virtual address of the region
size	The length in bytes of the region

Returns

The virtual address for the region in this vmm

Warning

Re security see todo: https://discord.com/channels/578193015433330698/884443149919993856/1471057118407950436

Todo:

maybe move from void* to uint8* ??

take flags for mapping (ro)

Definition at line 552 of file virtual.cpp.

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

References MaxOS::memory::PhysicalMemoryManager::align_direct_to_page(), MaxOS::memory::PhysicalMemoryManager::align_up_to_page(), allocate(), MaxOS::memory::PhysicalMemoryManager::get_physical_address(), MaxOS::memory::PhysicalMemoryManager::map(), MaxOS::memory::PAGE_SIZE, pml4_root_address(), MaxOS::memory::PRESENT, MaxOS::memory::RESERVE, MaxOS::memory::PhysicalMemoryManager::s_current_manager, and MaxOS::memory::WRITE.

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 487 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(), MaxOS::processes::resources::ResourceManager::get_resource(), load_shared_memory(), and MaxOS::processes::Process::resource_manager.

Referenced by MaxOS::processes::resources::BridgeHandler::BridgeHandler(), load_shared_memory(), and MaxOS::processes::SharedMemory::open().

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 506 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 348 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;
}

References MaxOS::memory::CHUNKS_PER_PAGE.

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 691 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;
}

Referenced by load_range_from_process().

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 476 of file virtual.cpp.

                                                           {
 
    return m_pml4_root_physical_address;
}

Referenced by MaxOS::memory::BumpMemoryManager::switch_active_memory_manager().

unload_range_from_process()

void VirtualMemoryManager::unload_range_from_process	(	const void *	start_address,
		size_t	size
	)

Unload a shared range of pages from this vmm.

Parameters

start_address	The start of the range
size	The length of the range in bytes

Definition at line 602 of file virtual.cpp.

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

References MaxOS::memory::PhysicalMemoryManager::align_direct_to_page(), MaxOS::memory::PhysicalMemoryManager::align_up_to_page(), free(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::PhysicalMemoryManager::s_current_manager, MaxOS::memory::PhysicalMemoryManager::size_to_frames(), and MaxOS::memory::PhysicalMemoryManager::unmap().

Referenced by MaxOS::processes::resources::BridgeHandler::send_to_bridge().

---

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