void pmm_init(struct multiboot_info* mb_info)
{
struct multiboot_mmap* mmap = mb_info->mbs_mmap_addr;
struct multiboot_mmap* mmap_end = (void*)
((uintptr_t) mb_info->mbs_mmap_addr + mb_info->mbs_mmap_length);
/* at begin all is reserved */
memset(bitmap, 0, sizeof(bitmap));
/*
* the BIOS-memory-map deklares free memory
*/
while (mmap < mmap_end)
{
if (mmap->type == 1)
{
/* it's free, so set the bit */
uintptr_t addr = mmap->base;
uintptr_t end_addr = addr + mmap->length;
while (addr < end_addr)
{
pmm_free((void*) addr);
addr += 0x1000;
}
}
mmap++;
}
/* IMPORTANT: mark kernel space as alloc'd */
uintptr_t addr = (uintptr_t) &kernel_start;
while (addr < (uintptr_t) &kernel_end)
{
pmm_mark_used((void*) addr);
addr += 0x1000;
}
/*
* lets mark the multiboot struct and the module list too.
* Let's say both stay under 4k TODO make real solutiion
*/
struct multiboot_module* modules = mb_info->mbs_mods_addr;
pmm_mark_used(mb_info);
pmm_mark_used(modules);
/* naturally the modules themself are used too */
int i;
for (i = 0; i < mb_info->mbs_mods_count; i++)
{
addr = modules[i].mod_start;
while (addr < modules[i].mod_end)
{
pmm_mark_used((void*) addr);
addr += 0x1000;
}
}
}
void init_pmm(struct info_multiboot* mb_info)
{
struct mmap_multiboot* memory_map = mb_info->mbs_mmap_addr;
struct mmap_multiboot* memory_map_end = (void*) ((uint32_t) mb_info->mbs_mmap_addr + mb_info->mbs_mmap_length);
while(memory_map < memory_map_end)
{
if(memory_map->type == 1)
{
uint32_t address = memory_map->base;
uint32_t end_address = address + memory_map->length;
while(address < end_address)
{
pmm_free((void*) address);
address += 0x1000;
}
}
memory_map++;
}
uint32_t address = (uint32_t) &kernel_start;
while(address < (uint32_t) &kernel_end)
{
pmm_mark_used((void*) address);
address += 0x1000;
}
}
void pmminit(struct multiboot_info *mb_info)
{
DG("PMM: Init...");
pc("[00.000027] +kernel_start = %d", &kernel_start);
uint16_t addr = (uint16_t) &kernel_start;
pc("[00.000029] +for addr < kernel_end do useMark");
while (addr < (uint16_t) &kernel_end) {
pmm_mark_used((void*) addr);
addr += 0x1000;
}
struct multiboot_mmap* mmap = mb_info->mb_mmap_addr;
struct multiboot_mmap* mmap_end = (void*) ((uint16_t) mb_info->mb_mmap_addr + mb_info->mb_mmap_length);
struct multiboot_module *mod = mb_info->mb_mods_addr;
pc("[00.000039] +useMark multibootModule");
pmm_mark_used(mod);
int i;
void *Maddr;
for (i = 0; i < mb_info->mb_mods_count; i++) {
Maddr = mod[i].start;
while (Maddr < mod[i].end) {
pmm_mark_used((void*) Maddr);
Maddr += 0x1000;
}
}
while (mmap < mmap_end) {
// Der Speicherbereich ist frei, entsprechend markieren
uint16_t addr = mmap->base;
uint16_t end_addr = addr + mmap->length;
if (mmap->type == 1) {
// Der Speicherbereich ist frei, entsprechend markieren
addr = mmap->base;
end_addr = addr + mmap->length;
while (addr < end_addr) {
free((void*) addr);
addr += 0x1000;
}
}
mmap++;
}
dbg(true);
}
void* pmm_malloc( size_t size )
{
size_t page_count = size / PAGE_SIZE;
if((size % PAGE_SIZE) != 0)
page_count++;
void * pages = pmm_prepare_alloc(page_count);
if (pages == (void*) -1) panic(PF);
pmm_mark_used(pages);
return pages;
}
void init_pmm(void* mbd){
multiboot_info_t* mb_info = (multiboot_info_t*)mbd;
multiboot_mmap_entry_t* mmap = (multiboot_mmap_entry_t*)mb_info->mmap_addr;
multiboot_mmap_entry_t* mmap_end = (void*) ((unsigned int*) mb_info->mmap_addr + mb_info->mmap_length);
/* Per Default ist erst einmal alles reserviert */
memset(bitmap, 0, sizeof(bitmap));
/*
* Nur, was die BIOS-Memory-Map als frei bezeichnet, wird wieder als frei
* markiert
*/
while (mmap < mmap_end) {
if (mmap->type == 1) {
/* Der Speicherbereich ist frei, entsprechend markieren */
unsigned int addr = mmap->addr;
unsigned int end_addr = (unsigned char*)addr + mmap->len;
while (addr < end_addr) {
pmm_free((void*) addr);
addr += 0x1000;
}
}
mmap++;
}
extern const void kernel_start;
extern const void kernel_end;
unsigned int addr = (unsigned int) &kernel_start;
while (addr < (unsigned int*) &kernel_end) {
pmm_mark_used((void*) addr);
addr += 0x1000;
}
addr = (unsigned int)0x00;
unsigned int addr_end = (unsigned int)0x800000;
while (addr < addr_end) {
pmm_mark_used((void*) addr);
addr += 0x1000;
}
}
void pmm_init(struct multiboot_info * mb_info)
{
struct multiboot_mmap* mmap = (void *)((uintptr_t)(mb_info->mbs_mmap_addr));
struct multiboot_mmap* mmap_end = (void*)
((uintptr_t) (mb_info->mbs_mmap_addr + mb_info->mbs_mmap_length));
uintptr_t end_addr;
uint_t * pmm_stack_ptr_init=pmm_stack_ptr;
int i;
kprintf("[PMM] I: pmm_init ... ");
/* by default everything is free */
memset(&physbitmap, 0xffffffff, sizeof(physbitmap));
/*
* Here we look in the memory map for free space
*/
uintptr_t addr = (uintptr_t) &kernel_start;
while (addr <= (uintptr_t) &kernel_end)
{
//kprintf("x%x",addr/PAGE_SIZE);
pmm_mark_used(addr/PAGE_SIZE);
addr += 0x1000;
}
/*
* the multiboot structures and the mb_info shouldn't be overwritten either. their maximum allowed size is one Page
*/
//struct multiboot_module* modules = (void *)((uintptr_t)(mb_info->mbs_mods_addr) & 0xffffffff);
pmm_mark_used((uintptr_t)(mb_info)/PAGE_SIZE);
pmm_mark_used((uintptr_t)(modules_glob)/PAGE_SIZE);
/* Und die Multibootmodule selber sind auch belegt */
for (i = 0; i < mb_info->mbs_mods_count; i++)
{
addr = modules_glob[i].mod_start;
while (addr < modules_glob[i].mod_end)
{
pmm_mark_used(addr/PAGE_SIZE);
addr += PAGE_SIZE;
}
}
memset(0x00000000,0x00000000,PAGE_SIZE);
pmm_mark_used( DIV_PAGE_SIZE(TMP_PAGEBUF) );//0x1000 is reserved,because that's,where we tmp map our pagetables to
pmm_mark_used( DIV_PAGE_SIZE(TRAMPOLINE) );// Trampoline space
for (i = bsp_stack/0x1000; i<(bsp_stack+EASYMAPTBL_SIZ+STDRD_STACKSIZ+PMM_STACK_SIZ+ALIGNED_BASE(mod_size))/PAGE_SIZE+PAGING_HIER_SIZE+2; i++)
pmm_mark_used(i); // That's our Stack which is still the MB Loader
kprintf("now i is 0x%x", i);
kprintf("mod_size is 0x%x",ALIGNED_BASE(mod_size));
for(i=0;i<0x100;i++)
pmm_mark_used(i);
addr=0;
while (mmap < mmap_end)
{
if (mmap->type == 1)
{
addr = ALIGNED_BASE(mmap->base);
end_addr = addr +( mmap->length & 0xfffff000);
while(addr<end_addr)
{
*pmm_stack_ptr_init=addr;
pmm_stack_ptr_init++;
addr+=0x1000;
}
}
mmap++;
}
kprintf("SUCCESS\n");
}
