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.

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.

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 108 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, MaxOS::common::Spinlock::unlock(), 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 767 of file physical.cpp.

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

References MaxOS::memory::PAGE_SIZE.

Referenced by reserve().

◆ align_to_page()

size_t PhysicalMemoryManager::align_to_page ( size_t size )

static

Aligns a size to the page size.

Parameters

size	The size to align

Returns: The aligned size

Definition at line 167 of file physical.cpp.

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

References MaxOS::memory::PAGE_SIZE.

Referenced by size_to_frames(), and MaxOS::memory::VirtualMemoryManager::VirtualMemoryManager().

◆ 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.

Parameters

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

Returns: The aligned size

Definition at line 179 of file physical.cpp.

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

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

◆ allocate_area()

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

Allocate an area of physical memory (ie reserve it)

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 275 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] == 0xFFFFFFFFFFFFFFF)
            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 ASSERT, MaxOS::common::Spinlock::lock(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::ROW_BITS, size_to_frames(), and MaxOS::common::Spinlock::unlock().

◆ 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 200 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] == 0xFFFFFFFFFFFFFFF)
            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();
 
            // Return the address
            uint64_t frame_address = (row * ROW_BITS) + column;
            return (void*) (frame_address * PAGE_SIZE);
        }
    }
 
    // Error frame not found
    ASSERT(false, "Frame not found\n");
    m_lock.unlock();
    return nullptr;
}

References multiboot_mmap_entry::addr, ASSERT, MaxOS::common::Spinlock::lock(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::ROW_BITS, and MaxOS::common::Spinlock::unlock().

Referenced by 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 847 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 190 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 639 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 344 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] &= ~(1 << ((frame_address + i) % ROW_BITS));
 
    m_lock.unlock();
}

References MaxOS::common::Spinlock::lock(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::ROW_BITS, size_to_frames(), and MaxOS::common::Spinlock::unlock().

◆ free_frame()

void PhysicalMemoryManager::free_frame ( void * address )

Frees a frame in the bit map.

Parameters

address The address to free

Definition at line 256 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] &= ~(1 << (frame_address % ROW_BITS));
 
    m_lock.unlock();
}

References MaxOS::common::Spinlock::lock(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::ROW_BITS, and MaxOS::common::Spinlock::unlock().

◆ 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 945 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

Definition at line 829 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 is_mapped().

◆ 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 582 of file physical.cpp.

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

References map().

◆ 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 961 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 870 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 496 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 511 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;
 
    // 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 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 538 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 identity_map(), MaxOS::hardwarecommunication::IOAPIC::IOAPIC(), 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 568 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 552 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().

◆ 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 746 of file physical.cpp.

                                                  {
 
    return m_memory_size;
}

◆ memory_used()

uint64_t PhysicalMemoryManager::memory_used ( ) const

Gets the memory currently used.

Returns: The memory size in bytes

Definition at line 756 of file physical.cpp.

                                                  {
 
    return m_used_frames * PAGE_SIZE;
}

References MaxOS::memory::PAGE_SIZE.

Referenced by PhysicalMemoryManager().

◆ 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 736 of file physical.cpp.

                                                   {
 
    return m_pml4_root_address;
}

◆ reserve() [1/2]

void PhysicalMemoryManager::reserve ( uint64_t address )

Reserves a physical address.

Parameters

address The address to reserve

Definition at line 777 of file physical.cpp.

                                                    {
 
    reserve(address, PAGE_SIZE);
}

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

Referenced by 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 789 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(), ASSERT, MaxOS::Logger::DEBUG(), MaxOS::common::Spinlock::lock(), MaxOS::memory::PAGE_SIZE, MaxOS::memory::ROW_BITS, and MaxOS::common::Spinlock::unlock().

◆ 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 96 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, 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, 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

Definition at line 156 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(), free_area(), MaxOS::memory::VirtualMemoryManager::load_physical_into_address_space(), map_area(), map_area(), unmap_area(), MaxOS::drivers::video::VideoElectronicsStandardsAssociation::VideoElectronicsStandardsAssociation(), 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 930 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 MaxOS::processes::GlobalScheduler::load_multiboot_elfs(), MaxOS::drivers::video::VideoElectronicsStandardsAssociation::VideoElectronicsStandardsAssociation(), 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 883 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 915 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 899 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 593 of file physical.cpp.

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

References unmap().

Referenced by 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 605 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 627 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 970 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 185 of file physical.h.

Referenced by MaxOS::memory::VirtualMemoryManager::allocate(), MaxOS::processes::SharedMemory::close(), MaxOS::system::CPU::init_cores(), MaxOS::hardwarecommunication::IOAPIC::IOAPIC(), MaxOS::memory::VirtualMemoryManager::load_physical_into_address_space(), MaxOS::hardwarecommunication::LocalAPIC::LocalAPIC(), PhysicalMemoryManager(), MaxOS::processes::SharedMemory::SharedMemory(), MaxOS::drivers::video::VideoElectronicsStandardsAssociation::VideoElectronicsStandardsAssociation(), 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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Detailed Description

Constructor & Destructor Documentation

◆ PhysicalMemoryManager()

Member Function Documentation

◆ align_direct_to_page()

◆ align_to_page()

◆ align_up_to_page()

◆ allocate_area()

◆ allocate_frame()

◆ change_page_flags()

◆ check_aligned()

◆ clean_page_table()

◆ free_area()

◆ free_frame()

◆ from_dm_region()

◆ get_physical_address()

◆ identity_map()

◆ in_higher_region()

◆ is_mapped()

◆ map() [1/3]

◆ map() [2/3]

◆ map() [3/3]

◆ map_area() [1/2]

◆ map_area() [2/2]

◆ memory_size()

◆ memory_used()

◆ pml4_root_address()

◆ reserve() [1/2]

◆ reserve() [2/2]

◆ reserve_kernel_regions()

◆ size_to_frames()

◆ to_dm_region()

◆ to_higher_region()

◆ to_io_region()

◆ to_lower_region()

◆ unmap() [1/2]

◆ unmap() [2/2]

◆ unmap_area()

◆ unmap_lower_kernel()

Member Data Documentation

◆ s_current_manager