MaxOS::memory::MemoryManager Class Reference

Handles memory allocation and deallocation. More...

#include <memorymanagement.h>

Public Member Functions
	MemoryManager (VirtualMemoryManager *virtual_memory_manager=nullptr)
	Construct a new Memory Manager object. Will switch the pml4 to use the calling process's page tables.
	~MemoryManager ()
	Destroy the Memory Manager object, frees the VMM if not the kernel memory manager.
void *	handle_malloc (size_t size)
	Allocates a block of memory.
void	handle_free (void *pointer)
	Frees a block of memory.
VirtualMemoryManager *	vmm ()
size_t	memory_used ()
	Returns the amount of memory used.

Static Public Member Functions
static void *	malloc (size_t size)
	Allocates a block of memory in the current USERSPACE heap.
static void	free (void *pointer)
	Frees a block of memory using the current memory manager.
static void *	kmalloc (size_t size)
	Allocates a block of memory in the KERNEL space.
static void	kfree (void *pointer)
	Frees a block of memory using the kernel memory manager.
static size_t	align (size_t size)
	Aligns the size to the chunk alignment.
static void	switch_active_memory_manager (MemoryManager *manager)
	Switches the active memory manager.

Static Public Attributes
static MemoryManager *	s_current_memory_manager = nullptr
	The memory manager for the current process.
static MemoryManager *	s_kernel_memory_manager = nullptr
	The memory manager for any kernel processes and all kernel allocations.

Detailed Description

Handles memory allocation and deallocation.

Definition at line 40 of file memorymanagement.h.

Constructor & Destructor Documentation

MemoryManager()

MemoryManager::MemoryManager ( VirtualMemoryManager *  vmm = nullptr )

explicit

Construct a new Memory Manager object. Will switch the pml4 to use the calling process's page tables.

Parameters

vmm	The virtual memory manager to use, if nullptr a new one will be created

Definition at line 22 of file memorymanagement.cpp.

: m_virtual_memory_manager(vmm) {
 
    // Create the VMM if not provided
    if(m_virtual_memory_manager == nullptr)
        m_virtual_memory_manager = new VirtualMemoryManager();
 
    // Enable the memory manager
    switch_active_memory_manager(this);
 
    // Set up the first chunk of memory
    this->m_first_memory_chunk = (MemoryChunk*) m_virtual_memory_manager->allocate(PAGE_SIZE + sizeof(MemoryChunk), 0);
    m_first_memory_chunk->allocated = false;
    m_first_memory_chunk->prev = nullptr;
    m_first_memory_chunk->next = nullptr;
    m_first_memory_chunk->size = PAGE_SIZE - sizeof(MemoryChunk);
    m_last_memory_chunk = m_first_memory_chunk;
 
    // First memory manager is the kernel memory manager
    if(s_kernel_memory_manager == nullptr)
        s_kernel_memory_manager = this;
 
}

References MaxOS::memory::VirtualMemoryManager::allocate(), MaxOS::memory::MemoryChunk::allocated, MaxOS::memory::MemoryChunk::next, MaxOS::memory::PAGE_SIZE, MaxOS::memory::MemoryChunk::prev, s_kernel_memory_manager, MaxOS::memory::MemoryChunk::size, and switch_active_memory_manager().

~MemoryManager()

MemoryManager::~MemoryManager

(

)

Destroy the Memory Manager object, frees the VMM if not the kernel memory manager.

Definition at line 49 of file memorymanagement.cpp.

                              {
 
    // Free the VMM (if this is not the kernel memory manager)
    if(m_virtual_memory_manager != nullptr && s_current_memory_manager != s_kernel_memory_manager)
        delete m_virtual_memory_manager;
 
    // Remove the kernel reference to this
    if(s_kernel_memory_manager == this)
        s_kernel_memory_manager = nullptr;
 
    // Remove the active reference to this
    if(s_current_memory_manager == this)
        s_current_memory_manager = nullptr;
}

References s_current_memory_manager, and s_kernel_memory_manager.

Member Function Documentation

align()

size_t MemoryManager::align ( size_t  size )

static

Aligns the size to the chunk alignment.

Parameters

size	The size to align

Returns

The aligned size

Definition at line 288 of file memorymanagement.cpp.

                                       {
 
    return (size / CHUNK_ALIGNMENT + 1) * CHUNK_ALIGNMENT;
}

References MaxOS::memory::CHUNK_ALIGNMENT.

Referenced by handle_malloc().

free()

void MemoryManager::free ( void *  pointer )

static

Frees a block of memory using the current memory manager.

Parameters

pointer

The pointer to the block

Definition at line 158 of file memorymanagement.cpp.

                                      {
 
    // Make sure there is a memory manager
    if(s_current_memory_manager == nullptr)
        return;
 
    s_current_memory_manager->handle_free(pointer);
}

References s_current_memory_manager.

Referenced by MaxOS::system::SyscallManager::syscall_free_memory().

handle_free()

void MemoryManager::handle_free

(

void *

pointer

)

Frees a block of memory.

Parameters

pointer

A pointer to the block

Definition at line 186 of file memorymanagement.cpp.

                                             {
 
    // Cant free unallocated memory
    if(pointer == nullptr)
        return;
 
    // Check bounds
    if((uint64_t) pointer < (uint64_t) m_first_memory_chunk || (uint64_t) pointer > (uint64_t) m_last_memory_chunk)
        return;
 
    // Get the chunk information from the pointer
    auto* chunk = (MemoryChunk*) ((size_t) pointer - sizeof(MemoryChunk));
    chunk->allocated = false;
 
    // If there is a free chunk before this chunk then merge them
    if(chunk->prev != nullptr && !chunk->prev->allocated) {
 
        // Grow the chunk behind this one so that it now contains the freed one
        chunk->prev->size += chunk->size + sizeof(MemoryChunk);
        chunk->prev->next = chunk->next;
 
        // The chunk in front of the freed one now needs to point to the merged chunk
        if(chunk->next != nullptr)
            chunk->next->prev = chunk->prev;
 
        // Freed chunk doesn't exist anymore so now working with the merged chunk
        chunk = chunk->prev;
 
    }
 
    // If there is a free chunk after this chunk then merge them
    if(chunk->next != nullptr && !chunk->next->allocated) {
 
        // Grow this chunk so that it now contains the free chunk in front of the old (now freed) one
        chunk->size += chunk->next->size + sizeof(MemoryChunk);
 
        // Now that this chunk contains the next one, it has to point to the one in front of what has just been merged
        // and that has to point to this
        chunk->next = chunk->next->next;
        if(chunk->next != nullptr)
            chunk->next->prev = chunk;
 
    }
}

handle_malloc()

void * MemoryManager::handle_malloc

(

size_t

size

)

Allocates a block of memory.

Parameters

size	The size of the block to allocate

Returns

A pointer to the block, or nullptr if no block is available

Definition at line 100 of file memorymanagement.cpp.

                                              {
 
    MemoryChunk* result = nullptr;
 
    // Nothing to allocate
    if(size == 0)
        return nullptr;
 
    // Add room to store the chunk information
    size = align(size + sizeof(MemoryChunk));
 
    // Find the next free chunk that is big enough
    for(MemoryChunk* chunk = m_first_memory_chunk; chunk != nullptr && result == nullptr; chunk = chunk->next) {
        if(chunk->size > size && !chunk->allocated)
            result = chunk;
    }
 
    // If there is no free chunk then make more room
    if(result == nullptr)
        result = expand_heap(size);
 
    // If there is not left over space to store extra chunks there is no need to split the chunk
    if(result->size < size + sizeof(MemoryChunk) + 1) {
        result->allocated = true;
        void* p = (void*) (((size_t) result) + sizeof(MemoryChunk));
        return p;
    }
 
    // Split the chunk into: what was requested + free overflow space for future allocates
    //  - This prevents waste in the event that a big free chunk was found but the requested size would only use a portion of that
    auto* extra = (MemoryChunk*) ((size_t) result + sizeof(MemoryChunk) + size);
    extra->allocated = false;
    extra->size = result->size - size - sizeof(MemoryChunk);
    extra->prev = result;
 
    // Add to the linked list
    extra->next = result->next;
    if(extra->next != nullptr)
        extra->next->prev = extra;
 
    // Requested chunk is now allocated exactly to the size requested and points to the free (split) block of memory that
    // it did not use
    result->size = size;
    result->allocated = true;
    result->next = extra;
 
    // Update the last memory chunk if necessary
    if(result == m_last_memory_chunk)
        m_last_memory_chunk = extra;
 
    return (void*) (((size_t) result) + sizeof(MemoryChunk));
}

References align().

kfree()

void MemoryManager::kfree ( void *  pointer )

static

Frees a block of memory using the kernel memory manager.

Parameters

pointer

The pointer to the block

Definition at line 172 of file memorymanagement.cpp.

                                       {
 
    // Make sure there is a kernel memory manager
    if(s_kernel_memory_manager == nullptr)
        return;
 
    s_kernel_memory_manager->handle_free(pointer);
}

References s_kernel_memory_manager.

Referenced by MaxOS::net::TCPSocket::connected(), MaxOS::net::UserDatagramProtocolHandler::disconnect(), MaxOS::net::TCPSocket::disconnected(), MaxOS::net::TCPSocket::handle_transmission_control_protocol_payload(), MaxOS::net::UDPSocket::handle_user_datagram_protocol_payload(), operator delete(), operator delete(), operator delete[](), operator delete[](), MaxOS::net::UserDatagramProtocolHandler::send(), MaxOS::net::EthernetFrameHandler::send_ethernet_frame(), MaxOS::net::InternetProtocolHandler::send_internet_protocol_packet(), and MaxOS::net::TransmissionControlProtocolHandler::send_transmission_control_protocol_packet().

kmalloc()

void * MemoryManager::kmalloc ( size_t  size )

static

Allocates a block of memory in the KERNEL space.

Parameters

size	The size of the block

Returns

The pointer to the block, or nullptr if no block is available

Definition at line 85 of file memorymanagement.cpp.

                                        {
 
    // Make sure there is a kernel memory manager
    if(s_kernel_memory_manager == nullptr)
        return nullptr;
 
    return s_kernel_memory_manager->handle_malloc(size);
}

References s_kernel_memory_manager.

Referenced by MaxOS::drivers::ethernet::AMD_AM79C973::AMD_AM79C973(), MaxOS::net::TransmissionControlProtocolHandler::connect(), MaxOS::net::UserDatagramProtocolHandler::connect(), MaxOS::net::TransmissionControlProtocolHandler::listen(), MaxOS::net::UserDatagramProtocolHandler::listen(), operator new(), operator new[](), MaxOS::net::UserDatagramProtocolHandler::send(), MaxOS::net::EthernetFrameHandler::send_ethernet_frame(), MaxOS::net::InternetProtocolHandler::send_internet_protocol_packet(), MaxOS::net::TransmissionControlProtocolHandler::send_transmission_control_protocol_packet(), MaxOS::processes::Thread::Thread(), MaxOS::drivers::console::VESABootConsole::VESABootConsole(), and MaxOS::system::Core::wake_up().

malloc()

void * MemoryManager::malloc ( size_t  size )

static

Allocates a block of memory in the current USERSPACE heap.

Parameters

size	size of the block

Returns

a pointer to the block, 0 if no block is available or no memory manager is set

Definition at line 70 of file memorymanagement.cpp.

                                       {
 
    // Make sure there is somthing to do the allocation
    if(s_current_memory_manager == nullptr)
        return nullptr;
 
    return s_current_memory_manager->handle_malloc(size);
}

References s_current_memory_manager.

Referenced by MaxOS::system::SyscallManager::syscall_allocate_memory(), and MaxOS::processes::Thread::Thread().

memory_used()

size_t MemoryManager::memory_used

(

)

Returns the amount of memory used.

Returns

The amount of memory used

Definition at line 270 of file memorymanagement.cpp.

                                  {
 
    size_t result = 0;
 
    // Loop through all the chunks and add up the size of the allocated chunks
    for(MemoryChunk* chunk = m_first_memory_chunk; chunk != nullptr; chunk = chunk->next)
        if(chunk->allocated)
            result += chunk->size;
 
    return result;
}

switch_active_memory_manager()

void MemoryManager::switch_active_memory_manager ( MemoryManager *  manager )

static

Switches the active memory manager.

Parameters

manager

The new memory manager

Definition at line 299 of file memorymanagement.cpp.

                                                                       {
 
    // Make sure there is a manager
    if(manager == nullptr)
        return;
 
    // Switch the address space
    asm volatile("mov %0, %%cr3"::"r"((uint64_t) manager->m_virtual_memory_manager->pml4_root_address_physical()) : "memory");
 
    // Set the active memory manager
    s_current_memory_manager = manager;
}

References s_current_memory_manager.

Referenced by MemoryManager().

vmm()

VirtualMemoryManager * MemoryManager::vmm

(

)

Gets the active virtual memory manager

Returns

The active virtual memory manager

Definition at line 317 of file memorymanagement.cpp.

                                         {
 
    return m_virtual_memory_manager;
}

Member Data Documentation

s_current_memory_manager

MemoryManager* MaxOS::memory::MemoryManager::s_current_memory_manager = nullptr

inlinestatic

The memory manager for the current process.

Definition at line 51 of file memorymanagement.h.

Referenced by free(), malloc(), switch_active_memory_manager(), and ~MemoryManager().

s_kernel_memory_manager

MemoryManager* MaxOS::memory::MemoryManager::s_kernel_memory_manager = nullptr

inlinestatic

The memory manager for any kernel processes and all kernel allocations.

Definition at line 52 of file memorymanagement.h.

Referenced by kfree(), kmalloc(), MemoryManager(), MaxOS::processes::Process::Process(), MaxOS::processes::Scheduler::Scheduler(), MaxOS::memory::VirtualMemoryManager::VirtualMemoryManager(), and ~MemoryManager().

---

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

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