Memory Namespace Reference

Namespaces
	Physical

Data Structures
class	MemoryMap
class	Section

Enumerations
enum	Type {   Available, Reserved, ACPI, NVS,   Bad, Bootloader, Kernel, Unknown }

Functions
	KERNEL_PARAM (enableMappingLogs, MAPPING_OUTPUT_FLAG, argumentsCallback)
void	init (MemoryMap *map)
void	mapKernelPage (Arch::Memory::Address vaddr, Arch::Memory::Address paddr)
void	mapKernelRangeVirtual (Section sect)
void	mapKernelRangePhysical (Section sect)
void *	newPage (size_t size)
void	freePage (void *page, size_t size)
bool	isPresent (uintptr_t addr)
uintptr_t	getPageDirPhysAddr ()

Enumeration Type Documentation

Type

enum Memory::Type

Enumerator
Available
Reserved
ACPI
NVS
Bad
Bootloader
Kernel
Unknown

Definition at line 18 of file MemorySection.hpp.

          {
    Available,
    Reserved,
    ACPI,
    NVS,
    Bad,
    Bootloader,
    Kernel,
    Unknown
};

Function Documentation

freePage()

void Memory::freePage	(	void *	page,
		size_t	size
	)

Frees pages starting at a given page address.

Parameters

page	Starting location of page(s) to be freed
size	Number of bytes to be freed

Definition at line 246 of file paging.cpp.

{
    RAIIMutex lock(pagingLock);
    size_t page_count = PAGE_COUNT(size);
    Arch::Memory::Address addr((uintptr_t)page);
    for (size_t i = addr.page().tableIndex; i < addr.page().tableIndex + page_count; i++) {
        mappedPages.Reset(i);
        // this is the same as the line above
        struct Arch::Memory::TableEntry* pte = &(pageTables[i / ARCH_PAGE_TABLE_ENTRIES].pages[i % ARCH_PAGE_TABLE_ENTRIES]);
        // the frame field is actually the page frame's index basically it's frame 0, 1...(2^21-1)
        physical.setFree(pte->frame);
        // zero it out to unmap it
        memset(pte, 0, sizeof(struct Arch::Memory::TableEntry));
        // clear that tlb
        Arch::Memory::pageInvalidate(page);
    }
}

Here is the caller graph for this function:

getPageDirPhysAddr()

uintptr_t Memory::getPageDirPhysAddr

(

)

Gets the physical address of the current page directory.

Returns

the physical address of the current page directory.

Definition at line 272 of file paging.cpp.

{
    return pageDirectoryAddress;
}

init()

void Memory::init

(

MemoryMap *

map

)

Sets up the environment, page directories etc and enables paging.

Definition at line 57 of file paging.cpp.

{
    // we can set breakpoints or make a futile attempt to recover.
    Interrupts::registerHandler(Interrupts::EXCEPTION_PAGE_FAULT, pageFaultCallback);
    // populate the physical memory map based on bootloader information
    initPhysical(map);
    // init our structures
    initDirectory();
    // identity map the first 1 MiB of RAM
    mapEarlyMem();
    // map in our higher-half kernel
    mapKernel();
    // use our new set of page tables
    Arch::Memory::setPageDirectory(Arch::Memory::pageAlign(pageDirectoryAddress));
    // flush the tlb and we're off to the races!
    Arch::Memory::pagingEnable();
}

isPresent()

bool Memory::isPresent

(

uintptr_t

addr

)

Checks whether an address is mapped into memory.

Parameters

addr	Address to be checked.

Returns

true The address is mapped in and valid.

false The address is not mapped into memory.

Definition at line 264 of file paging.cpp.

{
    // Convert the address into an index and check whether the page is in the bitmap
    // TODO: Fix this function. It's inaccurate and can result in triple faults.
    return mappedPages[addr >> ARCH_PAGE_TABLE_ENTRY_SHIFT];
}

KERNEL_PARAM()

Memory::KERNEL_PARAM	(	enableMappingLogs	,
		MAPPING_OUTPUT_FLAG	,
		argumentsCallback
	)

mapKernelPage()

void Memory::mapKernelPage	(	Arch::Memory::Address	vaddr,
		Arch::Memory::Address	paddr
	)

Map a page into the kernel address space.

Parameters

vaddr	Virtual address (in kernel space)
paddr	Physical address

Definition at line 147 of file paging.cpp.

{
    // Set the page directory entry (pde) and page table entry (pte)
    size_t pde = vaddr.page().dirIndex;
    size_t pte = vaddr.page().tableIndex;
 
    // Print a debug message to serial
    if (is_mapping_output_enabled) {
        Logger::Debug(__func__, "map 0x%08lx to 0x%08lx, pde = 0x%08lx, pte = 0x%08lx", paddr.val(), vaddr.val(), pde, pte);
    }
 
    // If the page's virtual address is not aligned
    if (vaddr.page().offset) {
        panicf("Attempted to map a non-page-aligned virtual address.\n(Address: 0x%08lX)\n", vaddr.val());
    }
 
    // If the page is already mapped into memory
    Arch::Memory::TableEntry* entry = &(pageTables[pde].pages[pte]);
    if (entry->present) {
        if (entry->frame == paddr.frame().index) {
            // this page was already mapped the same way
            return;
        }
 
        panic("Attempted to map already mapped page.\n");
    }
    // Set the page information
    pageTables[pde].pages[pte] = {
        .present = 1,                   // The page is present
        .readWrite = 1,                 // The page has r/w permissions
        .usermode = 0,                  // These are kernel pages
        .writeThrough = 0,              // Disable write through
        .cacheDisable = 0,              // The page is cached
        .accessed = 0,                  // The page is unaccessed
        .dirty = 0,                     // The page is clean
        .pageAttrTable = 0,             // The page has no attribute table
        .global = 0,                    // The page is local
        .unused = 0,                    // Ignored
        .frame = paddr.frame().index,   // The last 20 bits are the frame
    };
    // Set the associated bit in the bitmaps
    physical.setUsed(paddr);
    mappedPages.Set(vaddr.frame().index);
}

Here is the caller graph for this function:

mapKernelRangePhysical()

void Memory::mapKernelRangePhysical

(

Section

sect

)

Map a kernel address range into physical memory.

Parameters

sect	Memory section

Definition at line 199 of file paging.cpp.

{
    for (Arch::Memory::Address a(sect.base()); a < sect.end(); a += ARCH_PAGE_SIZE) {
        Arch::Memory::Address phys(KADDR_TO_PHYS(a));
        mapKernelPage(a, phys);
    }
}

Here is the call graph for this function:

mapKernelRangeVirtual()

void Memory::mapKernelRangeVirtual

(

Section

sect

)

Map an address range into the kernel virtual address space.

Parameters

sect	Memory section

Definition at line 192 of file paging.cpp.

{
    for (Arch::Memory::Address a(sect.base()); a < sect.end(); a += ARCH_PAGE_SIZE) {
        mapKernelPage(a, a);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

newPage()

void * Memory::newPage

(

size_t

size

)

Returns a new page in memory for use. If less than one page is requested, exactly one page will be allocated and returned.

Parameters

size	Page size in bytes

Returns

void* Page memory address

Definition at line 228 of file paging.cpp.

{
    RAIIMutex lock(pagingLock);
    size_t page_count = PAGE_COUNT(size);
    size_t free_idx = findNextFreeVirtualAddress(page_count);
    if (free_idx == SIZE_MAX)
        return NULL;
    for (size_t i = free_idx; i < free_idx + page_count; i++) {
        size_t phys_page_idx = physical.findNextFreePhysicalAddress();
        if (phys_page_idx == SIZE_MAX)
            return NULL;
        Arch::Memory::Address phys(phys_page_idx * ARCH_PAGE_SIZE);
        Arch::Memory::Address vaddr(i * ARCH_PAGE_SIZE);
        mapKernelPage(vaddr, phys);
    }
    return (void*)(free_idx * ARCH_PAGE_SIZE);
}

Here is the caller graph for this function: