MaxOS::memory::PhysicalMemoryManager Class Reference

Manages the physical memory of the system such as what pages are allocated/free and mapping of virtual to physical addresses. More...

#include <physical.h>

Public Member Functions
	PhysicalMemoryManager (system::Multiboot *multiboot)
	Constructs a PhysicalMemoryManager. Unmaps the lower kernel and sets up the bitmap for physical memory management. Reserves the kernel and the multiboot regions.
uint64_t	memory_size () const
	Gets total the memory size available for use (allocated or not)
uint64_t	memory_used () const
	Gets the memory currently used.
uint64_t *	pml4_root_address ()
	Gets the pml4 root address for the kernel.
void *	allocate_frame ()
	Allocates a physical page of memory, if the PMM is not initalise it will use the anon memory instead of the bitmap.
void	free_frame (void *address)
	Frees a frame in the bit map.
void *	allocate_area (uint64_t start_address, size_t size)
	Allocate an area of physical memory (ie reserve it)
void	free_area (uint64_t start_address, size_t size)
	Frees an area of physical memory.
virtual_address_t *	map (virtual_address_t *virtual_address, size_t flags)
	Allocates a physical address to a virtual address.
virtual_address_t *	map (physical_address_t *physical, virtual_address_t *virtual_address, size_t flags)
	Maps a physical address to a virtual address, using the kernel's pml4 table.
virtual_address_t *	map (physical_address_t *physical, virtual_address_t *virtual_address, size_t flags, uint64_t *pml4_root)
	Maps a physical address to a virtual address.
void	map_area (virtual_address_t *virtual_address_start, size_t length, size_t flags)
	Allocates a new area physical memory to a area virtual address.
void	map_area (physical_address_t *physical_address_start, virtual_address_t *virtual_address_start, size_t length, size_t flags)
	Maps an area of physical memory to a virtual address.
void	identity_map (physical_address_t *physical_address, size_t flags)
	Maps a physical address to its virtual address counter-part.
void	unmap (virtual_address_t *virtual_address)
	Unmaps a virtual address using the kernel's pml4 table.
void	unmap (virtual_address_t *virtual_address, uint64_t *pml4_root)
	Unmaps a virtual address.
void	unmap_area (virtual_address_t *virtual_address_start, size_t length)
	Unmaps an area of virtual memory.
void	reserve (uint64_t address)
	Reserves a physical address.
void	reserve (uint64_t address, size_t size, const char *="Unknown")
	Reserves an area of physical memory.
void	reserve_kernel_regions (system::Multiboot *multiboot)
	Reserves the kernel, multiboot modules, mmap regions and higher half mapping regions in the physical memory manager so that those pages arent overwritten later.
physical_address_t *	get_physical_address (virtual_address_t *virtual_address, uint64_t *pml4_root)
	Gets the physical address from a virtual address (if it exists)
bool	is_mapped (uintptr_t physical_address, uintptr_t virtual_address, uint64_t *pml4_root)
	Checks if a physical address is mapped to a virtual address.
void	change_page_flags (virtual_address_t *virtual_address, size_t flags, uint64_t *pml4_root)
	Changes the flags of a page.

Static Public Member Functions
static void	unmap_lower_kernel ()
	Unmaps the kernel physical memory from the lower half that was set up during the kernel boot.
static size_t	size_to_frames (size_t size)
	Converts a size to the number of frames.
static size_t	align_to_page (size_t size)
	Aligns a size to the page size. (Rounds up to the next multiple of PAGE_SIZE)
static size_t	align_direct_to_page (size_t size)
	Aligns a address to the page size.
static size_t	align_up_to_page (size_t size, size_t s_page_size)
	Aligns a size up to the page size, given a page size to a power of 2.
static bool	check_aligned (size_t size)
	Checks if an address is aligned.
static void	clean_page_table (uint64_t *table)
	Cleans a page table (fills it with 0 or null entries)
static void *	to_higher_region (uintptr_t physical_address)
	Converts a physical address to a higher region address if it is in the lower region using the higher half kernel offset.
static void *	to_lower_region (uintptr_t virtual_address)
	Converts a virtual address to a lower region address if it is in the higher region using the higher half kernel offset.
static void *	to_io_region (uintptr_t physical_address)
	Converts a physical address to an IO region address if it is in the lower region using the higher half memory offset.
static void *	to_dm_region (uintptr_t physical_address)
	Converts a physical address to a direct map region address if it is in the lower region using the higher half direct map offset.
static void *	from_dm_region (uintptr_t physical_address)
	Converts a direct map region address to a physical address if it is in the higher region using the higher half direct map offset.
static bool	in_higher_region (uintptr_t virtual_address)
	Checks if a virtual address is in the higher region.

Static Public Attributes
static PhysicalMemoryManager *	s_current_manager = nullptr
	The current physical memory manager in use.

Detailed Description

Manages the physical memory of the system such as what pages are allocated/free and mapping of virtual to physical addresses.

Todo:

Global paging so dont have map in every process

Definition at line 107 of file physical.h.

Constructor & Destructor Documentation

PhysicalMemoryManager()

PhysicalMemoryManager::PhysicalMemoryManager ( system::Multiboot *  multiboot )

explicit

Constructs a PhysicalMemoryManager. Unmaps the lower kernel and sets up the bitmap for physical memory management. Reserves the kernel and the multiboot regions.

Parameters

multiboot

The multiboot information structure to use for memory information such as the memory map.

Definition at line 31 of file physical.cpp.

: m_kernel_end((uint64_t) &_kernel_physical_end),
m_multiboot(multiboot),
m_pml4_root_address((uint64_t*) p4_table),
m_pml4_root((pte_t*) p4_table) {
 
    Logger::INFO() << "Setting up Physical Memory Manager\n";
    Logger::DEBUG() << "Kernel Memory: kernel_end = 0x" << (uint64_t) &_kernel_end << ", kernel_size = 0x"
                    << (uint64_t) &_kernel_size << ", kernel_physical_end = 0x" << (uint64_t) &_kernel_physical_end
                    << "\n";
    m_kernel_start_page = align_up_to_page((size_t) &_kernel_physical_end + PAGE_SIZE, PAGE_SIZE);
 
    // Set up the current manager
    unmap_lower_kernel();
    m_lock.unlock();
    s_current_manager = this;
    m_nx_allowed = CPU::check_nx();
 
    // Find a region of memory available to be used
    m_mmap_tag = m_multiboot->mmap();
    for(multiboot_mmap_entry* entry = m_mmap_tag->entries; (multiboot_uint8_t*) entry < (multiboot_uint8_t*) m_mmap_tag + m_mmap_tag->size; entry = (multiboot_mmap_entry*) ( (unsigned long) entry + m_mmap_tag->entry_size)) {
 
        // Skip if the region is not free or there is not enough space
        if(entry->type != MULTIBOOT_MEMORY_AVAILABLE)
            continue;
 
        // Store the entry. (note: don't break here as it is desired to find the last usable entry as that is normally biggest)
        m_mmap = entry;
    }
 
    // Store the information about the bitmap
    m_memory_size = (m_mmap->addr + m_mmap->len);
    m_bitmap_size = m_memory_size / PAGE_SIZE + 1;
    m_total_entries = m_bitmap_size / ROW_BITS + 1;
    Logger::DEBUG() << "Memory Info: size = " << (int) (m_memory_size / 1024 / 1024) << "mb, bitmap size = 0x" << (uint64_t) m_bitmap_size << ", total entries = " << (int) m_total_entries << ", page size = 0x"<< (uint64_t) PAGE_SIZE << "\n";
 
    // Map the physical memory into the virtual memory
    Logger::DEBUG() << "Mapping from 0x0 to 0x" << (uint64_t) (m_mmap->addr + m_mmap->len) << " to higher half direct map at offset 0x" << HIGHER_HALF_DIRECT_MAP << "\n";
    for(uint64_t physical_address = 0; physical_address < (m_mmap->addr + m_mmap->len); physical_address += PAGE_SIZE)
        map((physical_address_t*) physical_address, (virtual_address_t*) (HIGHER_HALF_DIRECT_MAP + physical_address),PRESENT | WRITE);
 
    // Kernel Setup
    initialise_bit_map();
    reserve_kernel_regions(multiboot);
 
    // Initialisation Done
    m_initialised = true;
    Logger::DEBUG() << "Memory used at start: " << (int) (memory_used() / 1024 / 1024) << "mb \n";
}

References _kernel_end, _kernel_physical_end, _kernel_size, multiboot_mmap_entry::addr, align_up_to_page(), MaxOS::system::CPU::check_nx(), MaxOS::Logger::DEBUG(), multiboot_tag_mmap::entries, multiboot_tag_mmap::entry_size, MaxOS::memory::HIGHER_HALF_DIRECT_MAP, MaxOS::Logger::INFO(), multiboot_mmap_entry::len, map(), memory_used(), MaxOS::system::Multiboot::mmap(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::PRESENT, reserve_kernel_regions(), MaxOS::memory::ROW_BITS, s_current_manager, multiboot_tag_mmap::size, unmap_lower_kernel(), and MaxOS::memory::WRITE.

Member Function Documentation

align_direct_to_page()

size_t PhysicalMemoryManager::align_direct_to_page ( size_t  size )

static

Aligns a address to the page size.

Parameters

size	The address to align

Returns

The aligned address

Definition at line 764 of file physical.cpp.

                                                              {
 
    return (size & (~(PAGE_SIZE - 1)));
}

References MaxOS::memory::PAGE_SIZE.

Referenced by MaxOS::memory::VirtualMemoryManager::load_range_from_process(), reserve(), and MaxOS::memory::VirtualMemoryManager::unload_range_from_process().

align_to_page()

size_t PhysicalMemoryManager::align_to_page ( size_t  size )

static

Aligns a size to the page size. (Rounds up to the next multiple of PAGE_SIZE)

Parameters

size	The size to align

Returns

The aligned size

Definition at line 155 of file physical.cpp.

                                                       {
 
    return ((size + PAGE_SIZE - 1) / PAGE_SIZE) * PAGE_SIZE;
}

References MaxOS::memory::PAGE_SIZE.

Referenced by size_to_frames().

align_up_to_page()

size_t PhysicalMemoryManager::align_up_to_page ( size_t  size, size_t  page_size  )

static

Aligns a size up to the page size, given a page size to a power of 2.

Parameters

size	The size to align
page_size	The page size to align to

Returns

The aligned size

Definition at line 167 of file physical.cpp.

                                                                            {
 
    return (size + page_size - 1) & ~(page_size - 1);
}

Referenced by MaxOS::memory::VirtualMemoryManager::allocate(), MaxOS::memory::VirtualMemoryManager::load_range_from_process(), PhysicalMemoryManager(), reserve(), and MaxOS::memory::VirtualMemoryManager::unload_range_from_process().

allocate_area()

void * PhysicalMemoryManager::allocate_area	(	uint64_t	start_address,
		size_t	size
	)

Allocate an area of physical memory (ie reserve it)

Todo:

freeing

Parameters

start_address	The start of the block
size	The size to allocate

Returns

A pointer to the start of the block (physical address)

Definition at line 270 of file physical.cpp.

                                                                              {
 
    m_lock.lock();
 
    // Store the information about the frames needed to be allocated for this size
    size_t frame_count = size_to_frames(size);
    uint32_t start_row = 0;
    uint32_t start_column = 0;
    size_t adjacent_frames = 0;
 
    for(uint32_t row = 0; row < m_total_entries; ++row) {
 
        // Skip full rows
        if(m_bit_map[row] == 0xFFFFFFFFFFFFFFFF) {
            adjacent_frames = 0;
            continue;
        }
 
        for(uint32_t column = 0; column < ROW_BITS; ++column) {
 
            // Not enough adjacent frames
            if(m_bit_map[row] & (1ULL << column)) {
                adjacent_frames = 0;
                continue;
            }
 
            // Store the address of the first frame in set of adjacent ones
            if(adjacent_frames == 0) {
                start_row = row;
                start_column = column;
            }
 
            // Make sure there are enough frames in a row found
            adjacent_frames++;
            if(adjacent_frames != frame_count)
                continue;
 
            // Mark the frames as used
            m_used_frames += frame_count;
            for(uint32_t i = 0; i < frame_count; ++i) {
 
                // Get the location of the bit
                uint32_t index = start_row + (start_column + i) / ROW_BITS;
                uint32_t bit = (start_column + i) % ROW_BITS;
 
                // Check bounds
                ASSERT(index < m_total_entries && bit < ROW_BITS, "Index out of bounds\n");
 
                // Mark the bit as used
                m_bit_map[index] |= (1ULL << bit);
            }
 
            // Return start of the block of adjacent frames
            m_lock.unlock();
            return (void*) (start_address + (start_row * ROW_BITS + start_column) * PAGE_SIZE);
 
        }
    }
 
    // Not enough free frames adjacent to each other
    m_lock.unlock();
    ASSERT(false, "Cannot allocate that much memory\n");
    return nullptr;
}

References MaxOS::memory::PAGE_SIZE, MaxOS::memory::ROW_BITS, and size_to_frames().

allocate_frame()

void * PhysicalMemoryManager::allocate_frame

(

)

Allocates a physical page of memory, if the PMM is not initalise it will use the anon memory instead of the bitmap.

Returns

The physical address of the page

Definition at line 188 of file physical.cpp.

                                            {
 
    // Wait for the lock
    m_lock.lock();
 
    // If not initialised, cant use the bitmap or higher half mapped physical memory so use leftover kernel memory already
    // mapped in loader.s
    if(!m_initialised) {
 
        // Use frames at the start of the mmap free
        void* address = (void*) ((uintptr_t) m_mmap->addr + (m_setup_frames * PAGE_SIZE));
        m_setup_frames++;
 
        m_lock.unlock();
        return address;
    }
 
    // Check if there are enough frames
    ASSERT(m_used_frames < m_bitmap_size, "No more frames available\n");
 
    for(uint32_t row = 0; row < m_total_entries; ++row) {
 
        // If the row is full continue
        if(m_bit_map[row] == 0xFFFFFFFFFFFFFFFF)
            continue;
 
        for(uint32_t column = 0; column < ROW_BITS; ++column) {
 
            // Entry isn't free
            if(m_bit_map[row] & (1ULL << column))
                continue;
 
            // Mark the frame as used
            m_bit_map[row] |= (1ULL << column);
            m_used_frames++;
 
            // Thread safe
            m_lock.unlock();
 
            // Calculate the address
            uint64_t frame_address = (row * ROW_BITS) + column;
            frame_address *= PAGE_SIZE;
 
            // Zero the page
            void* virt = to_dm_region(frame_address);
            memset(virt, 0, PAGE_SIZE);
 
            return (void*)frame_address;
        }
    }
 
    // Error frame not found
    ASSERT(false, "Frame not found\n");
    m_lock.unlock();
    return nullptr;
}

References multiboot_mmap_entry::addr, MaxOS::memory::PAGE_SIZE, MaxOS::memory::ROW_BITS, and to_dm_region().

Referenced by MaxOS::memory::VirtualMemoryManager::allocate(), and map().

change_page_flags()

void PhysicalMemoryManager::change_page_flags	(	virtual_address_t *	virtual_address,
		size_t	flags,
		uint64_t *	pml4_root
	)

Changes the flags of a page.

Parameters

virtual_address	The virtual address of the page
flags	The flags to set the page to
pml4_root	The address of the root pml to use

Definition at line 846 of file physical.cpp.

                                                                                                                   {
 
    pte_t* entry = get_entry(virtual_address, (pml_t*) pml4_root);
 
    // Cant edit a non-present entry (will page fault)
    if(!entry->present)
        return;
 
    *entry = create_page_table_entry(physical_address_of_entry(entry), flags);
 
    // Flush the TLB (cache)
    asm volatile("invlpg (%0)"::"r" (virtual_address) : "memory");
 
}

check_aligned()

bool PhysicalMemoryManager::check_aligned ( size_t  size )

static

Checks if an address is aligned.

Parameters

size	The address to check

Returns

True if the address is aligned

Definition at line 178 of file physical.cpp.

                                                     {
 
    return (size % PAGE_SIZE) == 0;
}

References MaxOS::memory::PAGE_SIZE.

Referenced by MaxOS::memory::VirtualMemoryManager::allocate().

clean_page_table()

void PhysicalMemoryManager::clean_page_table ( uint64_t *  table )

static

Cleans a page table (fills it with 0 or null entries)

Parameters

table

The table to clean

Definition at line 636 of file physical.cpp.

                                                            {
 
    // Null the table (prevents false mappings when re-using frames)
    for(int i = 0; i < 512; i++)
        table[i] = 0x00l;
}

Referenced by MaxOS::memory::VirtualMemoryManager::VirtualMemoryManager().

free_area()

void PhysicalMemoryManager::free_area	(	uint64_t	start_address,
		size_t	size
	)

Frees an area of physical memory.

Parameters

start_address	The start of the block
size	The size to free

Definition at line 341 of file physical.cpp.

                                                                         {
 
    // Convert address into frames
    size_t frame_count = size_to_frames(size);
    uint64_t frame_address = start_address / PAGE_SIZE;
 
    // Check bounds
    if(frame_address >= m_bitmap_size)
        return;
 
    // Wait until other threads have finished other memory operations
    m_lock.lock();
 
    // Mark the frames as not used
    m_used_frames -= frame_count;
    for(uint32_t i = 0; i < frame_count; ++i)
        m_bit_map[(frame_address + i) / ROW_BITS] &= ~(1ULL << ((frame_address + i) % ROW_BITS));
 
    m_lock.unlock();
}

References MaxOS::memory::PAGE_SIZE, MaxOS::memory::ROW_BITS, and size_to_frames().

Referenced by MaxOS::processes::SharedMemory::close().

free_frame()

void PhysicalMemoryManager::free_frame

(

void *

address

)

Frees a frame in the bit map.

Parameters

address

The address to free

Definition at line 250 of file physical.cpp.

                                                    {
 
    m_lock.lock();
 
    // Mark the frame as not used
    m_used_frames--;
    uint64_t frame_address = (uint64_t) address / PAGE_SIZE;
    m_bit_map[frame_address / ROW_BITS] &= ~(1ULL << (frame_address % ROW_BITS));
 
    m_lock.unlock();
}

References MaxOS::memory::PAGE_SIZE, and MaxOS::memory::ROW_BITS.

Referenced by MaxOS::memory::VirtualMemoryManager::allocate(), and MaxOS::memory::VirtualMemoryManager::~VirtualMemoryManager().

from_dm_region()

void * PhysicalMemoryManager::from_dm_region ( uintptr_t  virtual_address )

static

Converts a direct map region address to a physical address if it is in the higher region using the higher half direct map offset.

Parameters

virtual_address

The physical address in the direct map region

Returns

The physical address

Definition at line 944 of file physical.cpp.

                                                                     {
 
    if(virtual_address > HIGHER_HALF_DIRECT_MAP)
        return (void*) (virtual_address - HIGHER_HALF_DIRECT_MAP);
 
    // Must be in the lower half
    return (void*) virtual_address;
}

References MaxOS::memory::HIGHER_HALF_DIRECT_MAP.

Referenced by reserve_kernel_regions().

get_physical_address()

physical_address_t * PhysicalMemoryManager::get_physical_address	(	virtual_address_t *	virtual_address,
		uint64_t *	pml4_root
	)

Gets the physical address from a virtual address (if it exists)

Parameters

virtual_address	The virtual address to get the physical address from
pml4_root	The address of the root pml to use

Returns

The physical address or nullptr if it does not exist

Todo:

make static version

Definition at line 828 of file physical.cpp.

                                                                                                                       {
 
    pte_t* entry = get_entry(virtual_address, (pml_t*) pml4_root);
 
    // Cant get a physical address if its inst free
    if(!entry->present)
        return nullptr;
 
    return (physical_address_t*) physical_address_of_entry(entry);
}

Referenced by MaxOS::memory::VirtualMemoryManager::allocate(), is_mapped(), MaxOS::memory::VirtualMemoryManager::load_range_from_process(), and MaxOS::memory::VirtualMemoryManager::~VirtualMemoryManager().

identity_map()

void PhysicalMemoryManager::identity_map	(	physical_address_t *	physical_address,
		size_t	flags
	)

Maps a physical address to its virtual address counter-part.

Parameters

physical_address	The physical address to map
flags	The flags to set the mapping to

Definition at line 579 of file physical.cpp.

                                                                                           {
 
    // Map the physical address to its virtual address counter-part
    map(physical_address, physical_address, flags);
}

References map().

Referenced by MaxOS::system::CPU::init_cores().

in_higher_region()

bool PhysicalMemoryManager::in_higher_region ( uintptr_t  virtual_address )

static

Checks if a virtual address is in the higher region.

Parameters

virtual_address

The virtual address

Returns

True if the address is in the higher region, false otherwise

Definition at line 960 of file physical.cpp.

                                                                      {
 
    return virtual_address & (1l << 62);
}

Referenced by map(), and MaxOS::system::CPU::prepare_for_panic().

is_mapped()

bool PhysicalMemoryManager::is_mapped	(	uintptr_t	physical_address,
		uintptr_t	virtual_address,
		uint64_t *	pml4_root
	)

Checks if a physical address is mapped to a virtual address.

Parameters

physical_address	The physical address to check
virtual_address	The virtual address to check
pml4_root	The pml4 table to use

Returns

True if the physical address is mapped to the virtual address

Definition at line 869 of file physical.cpp.

                                                                                                                {
 
    return get_physical_address((virtual_address_t*) virtual_address, pml4_root) ==
           (physical_address_t*) physical_address;
 
}

References get_physical_address().

map() [1/3]

virtual_address_t * PhysicalMemoryManager::map	(	physical_address_t *	physical_address,
		virtual_address_t *	virtual_address,
		size_t	flags
	)

Maps a physical address to a virtual address, using the kernel's pml4 table.

Parameters

physical_address	The physical address to map
virtual_address	The virtual address to map to
flags	The flags to set the mapping to

Returns

The virtual address

Definition at line 493 of file physical.cpp.

                                                                                                                                    {
 
    // Map using the kernel's pml4 table
    return map(physical_address, virtual_address, flags, m_pml4_root_address);
}

References map().

map() [2/3]

virtual_address_t * PhysicalMemoryManager::map	(	physical_address_t *	physical_address,
		virtual_address_t *	virtual_address,
		size_t	flags,
		uint64_t *	pml4_table
	)

Maps a physical address to a virtual address.

Parameters

physical_address	The physical address
virtual_address	The virtual address
flags	The flags to set the mapping to
pml4_table	The pml4 table to use

Returns

The virtual address

Definition at line 508 of file physical.cpp.

                                                                                                                                                          {
 
    // If it is in a lower region then assume it is the user space
    if(!in_higher_region((uint64_t) virtual_address))
        flags |= (USER | GLOBAL);
 
    // If the entry already exists then the mapping is already done
    pte_t* pte = get_entry(virtual_address, (pml_t*) pml4_table);
    if(pte->present)
        return virtual_address;
 
    // Map the physical address to the virtual address
    *pte = create_page_table_entry((uint64_t) physical_address, flags);
 
    // Flush the TLB (cache)
    asm volatile("invlpg (%0)"::"r" (virtual_address) : "memory");
 
    return virtual_address;
}

References MaxOS::memory::GLOBAL, in_higher_region(), and MaxOS::memory::USER.

map() [3/3]

virtual_address_t * PhysicalMemoryManager::map	(	virtual_address_t *	virtual_address,
		size_t	flags
	)

Allocates a physical address to a virtual address.

Parameters

virtual_address	The virtual address
flags	The flags to set the mapping to

Returns

The virtual address

Definition at line 535 of file physical.cpp.

                                                                                              {
 
    // Map a new physical address to the requested virtual address
    return map(allocate_frame(), virtual_address, flags);
 
}

References allocate_frame(), and map().

Referenced by MaxOS::memory::VirtualMemoryManager::allocate(), identity_map(), MaxOS::hardwarecommunication::IOAPIC::IOAPIC(), MaxOS::memory::VirtualMemoryManager::load_range_from_process(), MaxOS::hardwarecommunication::LocalAPIC::LocalAPIC(), map(), map(), map_area(), map_area(), and PhysicalMemoryManager().

map_area() [1/2]

void PhysicalMemoryManager::map_area	(	physical_address_t *	physical_address_start,
		virtual_address_t *	virtual_address_start,
		size_t	length,
		size_t	flags
	)

Maps an area of physical memory to a virtual address.

Parameters

physical_address_start	The start of the physical address
virtual_address_start	The start of the virtual address
length	The length of the area
flags	The flags to set the mapping to

Definition at line 565 of file physical.cpp.

                                                                                                                                                      {
 
    // Map the required frames
    for(size_t i = 0; i < size_to_frames(length); ++i)
        map((virtual_address_t*) ((uintptr_t) physical_address_start + (i * PAGE_SIZE)),
            (virtual_address_t*) ((uintptr_t) virtual_address_start + (i * PAGE_SIZE)), flags);
}

References map(), MaxOS::memory::PAGE_SIZE, and size_to_frames().

map_area() [2/2]

void PhysicalMemoryManager::map_area	(	virtual_address_t *	virtual_address_start,
		size_t	length,
		size_t	flags
	)

Allocates a new area physical memory to a area virtual address.

Parameters

virtual_address_start	The start of the virtual address
length	The length of the area
flags	The flags to set the mapping to

Definition at line 549 of file physical.cpp.

                                                                                                          {
 
    // Map the required frames
    for(size_t i = 0; i < size_to_frames(length); ++i)
        map((virtual_address_t*) ((uintptr_t) virtual_address_start + (i * PAGE_SIZE)), flags);
 
}

References map(), MaxOS::memory::PAGE_SIZE, and size_to_frames().

Referenced by MaxOS::console::FramebufferConsole::FramebufferConsole().

memory_size()

uint64_t PhysicalMemoryManager::memory_size

(

)

const

Gets total the memory size available for use (allocated or not)

Returns

The memory size in bytes

Definition at line 743 of file physical.cpp.

                                                  {
 
    return m_memory_size;
}

Referenced by MaxOS::memory::VirtualMemoryManager::VirtualMemoryManager().

memory_used()

uint64_t PhysicalMemoryManager::memory_used

(

)

const

Gets the memory currently used.

Returns

The memory size in bytes

Definition at line 753 of file physical.cpp.

                                                  {
 
    return m_used_frames * PAGE_SIZE;
}

References MaxOS::memory::PAGE_SIZE.

Referenced by PhysicalMemoryManager(), and MaxOS::processes::Process::~Process().

pml4_root_address()

uint64_t * PhysicalMemoryManager::pml4_root_address

(

)

Gets the pml4 root address for the kernel.

Returns

The pml4 root address

Definition at line 733 of file physical.cpp.

                                                   {
 
    return m_pml4_root_address;
}

Referenced by MaxOS::memory::VirtualMemoryManager::VirtualMemoryManager().

reserve() [1/2]

void PhysicalMemoryManager::reserve

(

uint64_t

address

)

Reserves a physical address.

Parameters

address

The address to reserve

Definition at line 774 of file physical.cpp.

                                                    {
 
    reserve(address, PAGE_SIZE);
}

References MaxOS::memory::PAGE_SIZE, and reserve().

Referenced by MaxOS::console::FramebufferConsole::FramebufferConsole(), MaxOS::hardwarecommunication::LocalAPIC::LocalAPIC(), reserve(), and reserve_kernel_regions().

reserve() [2/2]

void PhysicalMemoryManager::reserve	(	uint64_t	address,
		size_t	size,
		const char *	type = "Unknown"
	)

Reserves an area of physical memory.

Parameters

address	The start of the area
size	The size of the area
type	The name for the region being reserved (not required, logging purposes only, defaults to unkown)

Definition at line 786 of file physical.cpp.

                                                                                   {
 
    // Cant reserve virtual addresses (ensure the address is physical)
    ASSERT(address < m_memory_size, "Attempt to reserve address bigger then the memory can contain: 0x%x\n", address);
    ASSERT(address + size < m_memory_size, "Attempt to reserve region bigger then the memory can contain: 0x%x-0x%x\n",
           address, address + size);
 
    // Wait to be able to reserve
    m_lock.lock();
 
    // Align to a page, if rounding down need to correct the range
    size_t aligned_address = align_direct_to_page(address);
    if(aligned_address < address)
        size += address - aligned_address;
 
    // Convert in to amount of pages
    size = align_up_to_page(size, PAGE_SIZE);
    size_t page_count = size / PAGE_SIZE;
    uint64_t frame_index = aligned_address / PAGE_SIZE;
 
    // Mark all as used
    for(size_t i = 0; i < page_count; ++i)
        m_bit_map[(frame_index + i) / ROW_BITS] |= (1ULL << ((frame_index + i) % ROW_BITS));
 
    // Update the used frames
    m_used_frames += page_count;
 
    // Clear the lock
    m_lock.unlock();
    Logger::DEBUG() << "Reserved Address for " << type << ": 0x" << aligned_address << " - 0x" << aligned_address + size
                    << " (length of 0x" << size << ")\n";
}

References align_direct_to_page(), align_up_to_page(), MaxOS::Logger::DEBUG(), MaxOS::memory::PAGE_SIZE, and MaxOS::memory::ROW_BITS.

reserve_kernel_regions()

void PhysicalMemoryManager::reserve_kernel_regions

(

system::Multiboot *

multiboot

)

Reserves the kernel, multiboot modules, mmap regions and higher half mapping regions in the physical memory manager so that those pages arent overwritten later.

Parameters

multiboot

The multiboot information structure to use for memory information such as the memory map.

Definition at line 89 of file physical.cpp.

                                                                       {
 
    // Reserve the pages used by the higher half mapping
    reserve((uint64_t) m_mmap->addr, m_setup_frames * PAGE_SIZE, "HHDM");
 
    // Reserve the area for the bitmap
    reserve((uint64_t) from_dm_region((uint64_t) m_bit_map), m_bitmap_size / 8, "Bitmap");
 
    // Calculate how much space the kernel takes up
    uint32_t kernel_entries = (m_kernel_start_page / PAGE_SIZE) + 1;
    if((((uint32_t) (m_kernel_start_page)) % PAGE_SIZE) != 0)
        kernel_entries += 1;
 
    // Reserve the kernel entries
    reserve(0, kernel_entries * PAGE_SIZE, "Kernel");
 
    // Reserve the area for the mmap
    uint64_t mem_end = m_mmap->addr + m_mmap->len;
    for(multiboot_mmap_entry* entry = m_mmap_tag->entries; (multiboot_uint8_t*) entry < (multiboot_uint8_t*) m_mmap_tag + m_mmap_tag->size; entry = (multiboot_mmap_entry*) ( (unsigned long) entry + m_mmap_tag->entry_size)) {
 
        // Dont reserve free regions
        if(entry->type <= MULTIBOOT_MEMORY_AVAILABLE)
            continue;
 
        // Don't reserve the memory being managed by pmm
        if(entry->addr >= mem_end)
            continue;
 
        reserve(entry->addr, entry->len, "MMap");
    }
 
    // Reserve the area for each multiboot module
    for(multiboot_tag* tag = multiboot->start_tag(); tag->type != MULTIBOOT_TAG_TYPE_END; tag = (struct multiboot_tag*) ((multiboot_uint8_t*) tag + ((tag->size + 7) & ~7))) {
 
        if(tag->type != MULTIBOOT_TAG_TYPE_MODULE)
            continue;
 
        // Reserve the module's address
        auto* module = (struct multiboot_tag_module*) tag;
        reserve(module->mod_start, module->mod_end - module->mod_start, "Module");
    }
 
    // Reserve all the tags
    auto end_tag = (multiboot_tag*) to_higher_region(multiboot->end_address);
    auto start_tag = (uint64_t) to_lower_region((uintptr_t) multiboot->start_tag());
    size_t tags_size = multiboot->end_address - start_tag + ((end_tag->size + 7) & ~7);
    reserve(start_tag, tags_size, "Tags");
}

References multiboot_mmap_entry::addr, MaxOS::system::Multiboot::end_address, multiboot_tag_mmap::entries, multiboot_tag_mmap::entry_size, from_dm_region(), multiboot_mmap_entry::len, MaxOS::memory::PAGE_SIZE, reserve(), multiboot_tag_mmap::size, MaxOS::system::Multiboot::start_tag(), to_higher_region(), and to_lower_region().

Referenced by PhysicalMemoryManager().

size_to_frames()

size_t PhysicalMemoryManager::size_to_frames ( size_t  size )

static

Converts a size to the number of frames.

Parameters

size	The size to convert

Returns

The number of frames to fully cover the region (min 1 if size > 0)

Definition at line 144 of file physical.cpp.

                                                        {
 
    return align_to_page(size) / PAGE_SIZE;
}

References align_to_page(), and MaxOS::memory::PAGE_SIZE.

Referenced by MaxOS::memory::VirtualMemoryManager::allocate(), allocate_area(), MaxOS::console::FramebufferConsole::FramebufferConsole(), free_area(), MaxOS::memory::VirtualMemoryManager::load_physical_into_address_space(), map_area(), map_area(), MaxOS::memory::VirtualMemoryManager::unload_range_from_process(), unmap_area(), and MaxOS::memory::VirtualMemoryManager::~VirtualMemoryManager().

to_dm_region()

void * PhysicalMemoryManager::to_dm_region ( uintptr_t  physical_address )

static

Converts a physical address to a direct map region address if it is in the lower region using the higher half direct map offset.

Parameters

physical_address

The physical address

Returns

The direct map region address

Definition at line 929 of file physical.cpp.

                                                                    {
 
    if(physical_address < HIGHER_HALF_OFFSET)
        return (void*) (physical_address + HIGHER_HALF_DIRECT_MAP);
 
    // Must be in the higher half
    return (void*) physical_address;
}

References MaxOS::memory::HIGHER_HALF_DIRECT_MAP, and MaxOS::memory::HIGHER_HALF_OFFSET.

Referenced by allocate_frame(), MaxOS::console::FramebufferConsole::FramebufferConsole(), MaxOS::processes::GlobalScheduler::load_multiboot_elfs(), MaxOS::processes::GlobalScheduler::prepare_initrd(), MaxOS::console::FramebufferConsole::print_logo(), and MaxOS::memory::VirtualMemoryManager::VirtualMemoryManager().

to_higher_region()

void * PhysicalMemoryManager::to_higher_region ( uintptr_t  physical_address )

static

Converts a physical address to a higher region address if it is in the lower region using the higher half kernel offset.

Parameters

physical_address

The physical address

Returns

The higher region address

Definition at line 882 of file physical.cpp.

                                                                        {
 
    // If it's in the lower half then add the offset
    if(physical_address < HIGHER_HALF_KERNEL_OFFSET)
        return (void*) (physical_address + HIGHER_HALF_KERNEL_OFFSET);
 
    // Must be in the higher half
    return (void*) physical_address;
}

References MaxOS::memory::HIGHER_HALF_KERNEL_OFFSET.

Referenced by reserve_kernel_regions().

to_io_region()

void * PhysicalMemoryManager::to_io_region ( uintptr_t  physical_address )

static

Converts a physical address to an IO region address if it is in the lower region using the higher half memory offset.

Parameters

physical_address

The physical address

Returns

The IO region address

Definition at line 914 of file physical.cpp.

                                                                    {
 
    if(physical_address < HIGHER_HALF_MEM_OFFSET)
        return (void*) (physical_address + HIGHER_HALF_MEM_OFFSET);
 
    // Must be in the higher half
    return (void*) physical_address;
}

References MaxOS::memory::HIGHER_HALF_MEM_OFFSET.

Referenced by MaxOS::hardwarecommunication::AdvancedConfigurationAndPowerInterface::find(), MaxOS::hardwarecommunication::IOAPIC::IOAPIC(), and MaxOS::hardwarecommunication::LocalAPIC::LocalAPIC().

to_lower_region()

void * PhysicalMemoryManager::to_lower_region ( uintptr_t  virtual_address )

static

Converts a virtual address to a lower region address if it is in the higher region using the higher half kernel offset.

Parameters

virtual_address

The virtual address

Returns

The lower region address

Definition at line 898 of file physical.cpp.

                                                                      {
 
    // If it's in the lower half then add the offset
    if(virtual_address > HIGHER_HALF_KERNEL_OFFSET)
        return (void*) (virtual_address - HIGHER_HALF_KERNEL_OFFSET);
 
    // Must be in the lower half
    return (void*) virtual_address;
}

References MaxOS::memory::HIGHER_HALF_KERNEL_OFFSET.

Referenced by MaxOS::system::CPU::init_cores(), MaxOS::system::Multiboot::Multiboot(), reserve_kernel_regions(), and MaxOS::memory::VirtualMemoryManager::VirtualMemoryManager().

unmap() [1/2]

void PhysicalMemoryManager::unmap

(

virtual_address_t *

virtual_address

)

Unmaps a virtual address using the kernel's pml4 table.

Parameters

virtual_address

The virtual address to unmap

Definition at line 590 of file physical.cpp.

                                                                    {
 
    // Pass the kernel's pml4 table
    unmap(virtual_address, m_pml4_root_address);
}

References unmap().

Referenced by MaxOS::memory::VirtualMemoryManager::allocate(), MaxOS::memory::VirtualMemoryManager::unload_range_from_process(), unmap(), and unmap_area().

unmap() [2/2]

void PhysicalMemoryManager::unmap	(	virtual_address_t *	virtual_address,
		uint64_t *	pml4_root
	)

Unmaps a virtual address.

Parameters

virtual_address	The virtual address to unmap
pml4_root	The pml4 table to use

Definition at line 602 of file physical.cpp.

                                                                                         {
 
    // Get the entry
    pte_t* pte = get_entry(virtual_address, (pml_t*) pml4_root);
 
    // Make sure the address is actually mapped
    if(!pte->present)
        return;
 
    // Unmap the entry
    pte->present = false;
 
    // Flush the TLB (cache)
    asm volatile("invlpg (%0)"::"r" (virtual_address) : "memory");
}

unmap_area()

void PhysicalMemoryManager::unmap_area	(	virtual_address_t *	virtual_address_start,
		size_t	length
	)

Unmaps an area of virtual memory.

Parameters

virtual_address_start	The start of the area
length	The length of the area

Definition at line 624 of file physical.cpp.

                                                                                              {
 
    // Unmap the required frames
    for(size_t i = 0; i < size_to_frames(length); ++i)
        unmap((virtual_address_t*) ((uintptr_t) virtual_address_start + (i * PAGE_SIZE)));
}

References MaxOS::memory::PAGE_SIZE, size_to_frames(), and unmap().

unmap_lower_kernel()

void PhysicalMemoryManager::unmap_lower_kernel ( )

static

Unmaps the kernel physical memory from the lower half that was set up during the kernel boot.

Definition at line 969 of file physical.cpp.

                                               {
 
    p4_table[0] = 0;
}

References p4_table.

Referenced by PhysicalMemoryManager().

Member Data Documentation

s_current_manager

PhysicalMemoryManager* MaxOS::memory::PhysicalMemoryManager::s_current_manager = nullptr

inlinestatic

The current physical memory manager in use.

Todo:

Make private with getter, maybe make mapping static?

Definition at line 183 of file physical.h.

Referenced by MaxOS::memory::VirtualMemoryManager::allocate(), MaxOS::processes::SharedMemory::close(), MaxOS::console::FramebufferConsole::FramebufferConsole(), MaxOS::system::CPU::init_cores(), MaxOS::hardwarecommunication::IOAPIC::IOAPIC(), MaxOS::memory::VirtualMemoryManager::load_physical_into_address_space(), MaxOS::memory::VirtualMemoryManager::load_range_from_process(), MaxOS::hardwarecommunication::LocalAPIC::LocalAPIC(), PhysicalMemoryManager(), MaxOS::processes::SharedMemory::SharedMemory(), MaxOS::memory::VirtualMemoryManager::unload_range_from_process(), MaxOS::memory::VirtualMemoryManager::VirtualMemoryManager(), MaxOS::processes::Process::~Process(), and MaxOS::memory::VirtualMemoryManager::~VirtualMemoryManager().

---

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

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