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"); }