From a8baee4dcde1e4ca2b97124f5591a0ae715aedf7 Mon Sep 17 00:00:00 2001 From: Andreas Kling Date: Wed, 16 Jan 2019 00:44:09 +0100 Subject: [PATCH] Tidy up memory map a bit and write out the general map in MemoryManager. There was a bug that given enough supervisor page allocation, we would eventually start dipping into the kmalloc range. --- Kernel/MemoryManager.cpp | 14 +++++++++----- Kernel/kmalloc.cpp | 16 ++++++++-------- 2 files changed, 17 insertions(+), 13 deletions(-) diff --git a/Kernel/MemoryManager.cpp b/Kernel/MemoryManager.cpp index b16cbc029a..9ff1525b21 100644 --- a/Kernel/MemoryManager.cpp +++ b/Kernel/MemoryManager.cpp @@ -69,20 +69,24 @@ void MemoryManager::initialize_paging() // The bottom 4 MB (except for the null page) are identity mapped & supervisor only. // Every process shares these mappings. create_identity_mapping(kernel_page_directory(), LinearAddress(PAGE_SIZE), (4 * MB) - PAGE_SIZE); - // Physical pages from this range are used for page tables. - for (size_t i = (1 * MB); i < (4 * MB); i += PAGE_SIZE) + + // Basic memory map: + // 0 -> 512 kB Kernel code. Root page directory & PDE 0. + // 1 MB -> 2 MB kmalloc_eternal() space. + // 2 MB -> 3 MB kmalloc() space. + // 3 MB -> 4 MB Supervisor physical pages (available for allocation!) + // 4 MB -> 32 MB Userspace physical pages (available for allocation!) + for (size_t i = (2 * MB); i < (4 * MB); i += PAGE_SIZE) m_free_supervisor_physical_pages.append(adopt(*new PhysicalPage(PhysicalAddress(i), true))); #ifdef MM_DEBUG dbgprintf("MM: 4MB-32MB available for allocation\n"); #endif - // The physical pages 4 MB through 8 MB are available for allocation. for (size_t i = (4 * MB); i < (32 * MB); i += PAGE_SIZE) m_free_physical_pages.append(adopt(*new PhysicalPage(PhysicalAddress(i), false))); m_quickmap_addr = LinearAddress(m_free_physical_pages.takeLast().leakRef()->paddr().get()); - kprintf("MM: Quickmap will use P%x\n", m_quickmap_addr.get()); - #ifdef MM_DEBUG + dbgprintf("MM: Quickmap will use P%x\n", m_quickmap_addr.get()); dbgprintf("MM: Installing page directory\n"); #endif asm volatile("movl %%eax, %%cr3"::"a"(kernel_page_directory().cr3())); diff --git a/Kernel/kmalloc.cpp b/Kernel/kmalloc.cpp index d297d28e2d..c22b7ca0ca 100644 --- a/Kernel/kmalloc.cpp +++ b/Kernel/kmalloc.cpp @@ -23,10 +23,10 @@ typedef struct #define CHUNK_SIZE 128 #define POOL_SIZE (1024 * 1024) -#define PAGE_ALIGNED_BASE_PHYSICAL 0x300000 -#define ETERNAL_BASE_PHYSICAL 0x200000 -#define BASE_PHYS 0x100000 +#define ETERNAL_BASE_PHYSICAL 0x100000 +#define ETERNAL_RANGE_SIZE 0x100000 +#define BASE_PHYSICAL 0x200000 #define RANGE_SIZE 0x100000 static byte alloc_map[POOL_SIZE / CHUNK_SIZE / 8]; @@ -42,20 +42,20 @@ bool is_kmalloc_address(void* ptr) { if (ptr >= (byte*)ETERNAL_BASE_PHYSICAL && ptr < s_next_eternal_ptr) return true; - return (dword)ptr >= BASE_PHYS && (dword)ptr <= (BASE_PHYS + POOL_SIZE); + return (dword)ptr >= BASE_PHYSICAL && (dword)ptr <= (BASE_PHYSICAL + POOL_SIZE); } void kmalloc_init() { - memset( &alloc_map, 0, sizeof(alloc_map) ); - memset( (void *)BASE_PHYS, 0, POOL_SIZE ); + memset(&alloc_map, 0, sizeof(alloc_map)); + memset((void *)BASE_PHYSICAL, 0, POOL_SIZE); kmalloc_sum_eternal = 0; sum_alloc = 0; sum_free = POOL_SIZE; s_next_eternal_ptr = (byte*)ETERNAL_BASE_PHYSICAL; - s_end_of_eternal_range = s_next_eternal_ptr + RANGE_SIZE; + s_end_of_eternal_range = s_next_eternal_ptr + ETERNAL_RANGE_SIZE; } void* kmalloc_eternal(size_t size) @@ -136,7 +136,7 @@ void* kmalloc_impl(dword size) if( chunks_here == chunks_needed ) { - auto* a = (allocation_t *)(BASE_PHYS + (first_chunk * CHUNK_SIZE)); + auto* a = (allocation_t *)(BASE_PHYSICAL + (first_chunk * CHUNK_SIZE)); byte *ptr = (byte *)a; ptr += sizeof(allocation_t); a->nchunk = chunks_needed;