122 lines
3.6 KiB
D
122 lines
3.6 KiB
D
/**
|
|
* HIPPO, the HOS In-place Physical Page Organizer.
|
|
*/
|
|
module hulk.hippo;
|
|
|
|
import hulk.header;
|
|
import hulk.bootinfo;
|
|
import hulk.klog;
|
|
import hulk.linker_addresses;
|
|
|
|
struct hippo
|
|
{
|
|
/**
|
|
* Linked list node entry for a physical page.
|
|
*/
|
|
private struct PhysicalPage
|
|
{
|
|
PhysicalPage * next;
|
|
}
|
|
|
|
/**
|
|
* Linked list of free physical pages.
|
|
*/
|
|
private static __gshared PhysicalPage * free_pages;
|
|
|
|
/**
|
|
* Number of free physical pages.
|
|
*/
|
|
private static __gshared size_t n_free_pages;
|
|
|
|
/**
|
|
* Initialize HIPPO.
|
|
*
|
|
* Ok, what we do here is iterate through all of the memory map regions in
|
|
* the bootinfo memory_map array, and create a linked list of all free
|
|
* physical pages that are available. Within the available memory regions,
|
|
* we have to watch out for the following items:
|
|
* 1) HULK binary (text + data)
|
|
* - This includes the HULK header and bootinfo structures
|
|
* 2) HULK bss
|
|
* 3) HULK stack
|
|
* 4) Framebuffer
|
|
* 5) Page tables
|
|
*
|
|
* @param bootinfo HULK boot information structure.
|
|
*/
|
|
public static void initialize(HulkHeader * header)
|
|
{
|
|
size_t usable_memory;
|
|
ulong[2][5] reserved = [
|
|
[header.bootinfo.hulk_phys, cast(ulong)header.total_size],
|
|
[header.bootinfo.bss_phys, LinkerAddresses.hulk_bss_size],
|
|
[header.bootinfo.stack_phys, header.stack_size],
|
|
[cast(ulong)header.bootinfo.fb.buffer, header.bootinfo.fb.height * header.bootinfo.fb.stride],
|
|
[header.bootinfo.pt_phys, header.bootinfo.pt_size],
|
|
];
|
|
for (size_t ri = 0u; ri < reserved.length; ri++)
|
|
{
|
|
reserved[ri][1] += reserved[ri][0];
|
|
}
|
|
for (size_t bii = 0u; bii < header.bootinfo.memory_map_count; bii++)
|
|
{
|
|
if (header.bootinfo.memory_map[bii].type == BootInfo.MemoryRegion.Type.Conventional)
|
|
{
|
|
ulong phys = header.bootinfo.memory_map[bii].base;
|
|
ulong phys_end = phys + header.bootinfo.memory_map[bii].size;
|
|
usable_memory += header.bootinfo.memory_map[bii].size;
|
|
while (phys < phys_end)
|
|
{
|
|
bool is_reserved = false;
|
|
for (size_t ri = 0u; ri < reserved.length; ri++)
|
|
{
|
|
if ((reserved[ri][0] <= phys) && (phys < reserved[ri][1]))
|
|
{
|
|
is_reserved = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!is_reserved)
|
|
{
|
|
free_page(phys);
|
|
}
|
|
phys += 4096u;
|
|
}
|
|
}
|
|
}
|
|
size_t usable_kb = usable_memory >> 10u;
|
|
size_t usable_mb = usable_kb >> 10u;
|
|
size_t frac_mb = ((1000u * (usable_kb & 0x3FFu)) + 512u) >> 10u;
|
|
klog.writefln("Found %u.%03uMB of usable RAM", usable_mb, frac_mb);
|
|
}
|
|
|
|
/**
|
|
* Free a physical page.
|
|
*
|
|
* @param phys Physical page address.
|
|
*/
|
|
private static void free_page(ulong phys)
|
|
{
|
|
PhysicalPage * pp = cast(PhysicalPage *)phys;
|
|
pp.next = free_pages;
|
|
free_pages = pp;
|
|
n_free_pages++;
|
|
}
|
|
|
|
/**
|
|
* Allocate a physical page.
|
|
*
|
|
* @return Page address, or null if none available.
|
|
*/
|
|
public static void * allocate_page()
|
|
{
|
|
PhysicalPage * pp;
|
|
if (free_pages != null)
|
|
{
|
|
pp = free_pages;
|
|
free_pages = free_pages.next;
|
|
}
|
|
return cast(void *)pp;
|
|
}
|
|
}
|