I managed to implement a very basic and minimal heap that can allocate

virtual memory, although I'm more than a bit skeptical on whether it
works as it should or not. I'll experiment with it... for now, I know
that memory allocated is available now, as it does not page fault when I
do so.

Author: Louis Jenkins

MoltarOS.sublime-workspace

@@ -22,7 +22,7 @@ static struct {
     // Note: All the above is packed into 1 byte. :)
 
     // Bit array of currently pressed keys
-    uint8_t pressed[BIT_ARRAY_SZ(256)];
+    uint8_t pressed[BITMAP_SIZE(256)];
 } KBD_STATE;
 
 #endif /* endif MOLTAROS_KBD_HAL_H */

src/kernel/include/drivers/kbd_hal.h

@@ -0,0 +1,15 @@
+#ifndef MOLTAROS_MEM_H
+#define MOLTAROS_MEM_H
+
+#include <stddef.h>
+#include <stdint.h>
+
+extern uint32_t PAGE_SIZE;
+
+void mem_init();
+
+void *kmalloc(size_t sz);
+
+void kfree(void *ptr);
+
+#endif /* endif MOLTAROS_MEM_H */

src/kernel/include/kernel/mem.h

@@ -67,8 +67,8 @@ static bool multiboot_RAM(struct multiboot_info *mbinfo, uint32_t *start, uint32
 	// Check if there is a memory mapping available
 	if (mbinfo->flags & (1 << 6)) {
 		KLOG("MMAP Entries: %d", mbinfo->mmap_length / 24);
-		struct multiboot_mmap *mmap = (struct multiboot_mmap *) mbinfo->mmap_addr;
-		while((uint32_t) mmap < mbinfo->mmap_addr + mbinfo->mmap_length) {
+		struct multiboot_mmap *mmap = (struct multiboot_mmap *) (0xC0000000 + mbinfo->mmap_addr);
+		while((uint32_t) mmap - 0xC0000000 < (mbinfo->mmap_addr + mbinfo->mmap_length)) {
 			KLOG("MMAP Entry: {Type: %s, Start: %x, Length: %x}", mmap->type == MULTIBOOT_MMAP_RAM ? "RAM" : "RESERVED", mmap->start_low, mmap->length_low);
 			// Jackpot... (The OS is 32-bit, so there is no upper currently.)
 			if (mmap->type == MULTIBOOT_MMAP_RAM) {

src/kernel/include/kernel/multiboot.h

@@ -10,6 +10,6 @@ typedef uint32_t vaddr_t;
 
 void alloc_init();
 
-paddr_t alloc(size_t size, uint32_t *phys_addr, bool aligned);
+vaddr_t alloc_block();
 
 #endif

src/kernel/include/mm/alloc.h

@@ -32,8 +32,12 @@ struct memheap {
 	memblock_t *head;
 };
 
-void *kmalloc(size_t size);
+void memheap_init(memheap_t *heap);
 
-void kfree(void *ptr);
+void memheap_add_block(memheap_t *heap, uintptr_t addr, uint32_t size, uint32_t block_size);
+
+void *memheap_alloc(memheap_t *heap, uint32_t size);
+
+void memheap_free(memheap_t *heap, void *ptr);
 
 #endif /* endif MOLTAROS_MEMORY_MANAGEMENT_H */

src/kernel/include/mm/heap.h

@@ -14,6 +14,7 @@
 #include <include/kernel/multiboot.h>
 #include <include/kernel/logger.h>
 #include <include/mm/page.h>
+#include <include/kernel/mem.h>
 #include <include/helpers.h>
 
 uint32_t PHYSICAL_MEMORY_END;
@@ -81,8 +82,16 @@ static void kernel_keyboard_test() {
 void kernel_main(void) {
 	// KLOG("Initializing Keyboard...");
 	// keyboard_init();
-	kernel_clock_test();
+	// kernel_clock_test();
 	// KLOG("Initiating Keyboard Test...");
 	// kernel_keyboard_test();
-
+	KLOG("Initializing Heap...");
+	mem_init();
+	KLOG("Allocating memory...");
+	char *str = kmalloc(3);
+	KLOG("Writing to memory...");
+	str[0] = 'H';
+	str[1] = 'i';
+	str[2] = '\0';
+	KLOG("String: %s", str);
 }

src/kernel/kernel/kernel.c

@@ -0,0 +1,39 @@
+#include <include/kernel/mem.h>
+#include <include/kernel/logger.h>
+#include <include/mm/heap.h>
+#include <include/mm/alloc.h>
+
+static memheap_t kheap = {0};
+
+static void more_memory() {
+	memheap_add_block(&kheap, alloc_block(), PAGE_SIZE, 16);
+}
+
+void mem_init() {
+	// Initialize modules we depend on
+	memheap_init(&kheap);
+	alloc_init();
+
+	// Allocate the first chunk of memory for the kernel heap
+	more_memory();
+}
+
+void *kmalloc(size_t sz) {
+	// Validate request
+	if (sz > PAGE_SIZE) {
+		KPANIC("Bad Allocation Size... Max: %x, Attempt: %x", PAGE_SIZE, sz);
+	}
+
+	// Check allocation of heap and add more if need be
+	void *data = memheap_alloc(&kheap, sz);
+	if (!data) {
+		more_memory();
+		data = memheap_alloc(&kheap, sz);
+	}
+
+	return data;
+}
+
+void kfree(void *ptr) {
+	memheap_free(&kheap, ptr);
+}

src/kernel/kernel/mem.c

@@ -1,37 +1,120 @@
 #include <include/mm/alloc.h>
+#include <include/kernel/logger.h>
+#include <include/helpers.h>
 #include <string.h>
 #include <stdint.h>
 
+const uint32_t PAGE_SIZE = 4 * 1024 * 1024;
+const uint32_t NUM_FRAMES = 1024;
+static const uint32_t PRESENT = 0x1;
+static const uint32_t READ_WRITE = 0x2;
+static const uint32_t PAGE_MB = 1 << 7;
+
+// Maximum number of frames is 1024 / 32 = 32, so -1 is a valid error number.
+static const uint32_t PAGE_ERR = (uint32_t) -1;
+
 // The current physical memory offset we are allocating in memory. This is a very simple allocator
 // and as such only allocates memory, and never frees it, and so this only ever increases.
-uint32_t ALLOC_PHYSICAL_ADDRESS_OFFSET;
-
-static const uint32_t PAGE_ALIGNED = 0xFFFFF000;
-static const uint32_t STACK_SIZE = 16 * 1024 * 1024;
+static uint32_t physical_address_offset;
+static uint32_t *page_directory;
+static uint32_t alloc_bitmap[NUM_FRAMES / 32];
 
 extern uint32_t PHYSICAL_MEMORY_START;
 extern uint32_t PHYSICAL_MEMORY_END;
 
+static uint32_t index_of(uint32_t frame) {
+	return frame / 32;
+}
+
+static uint32_t first_free_frame() {
+	// For each bitmapped frame entry
+	for(uint32_t i = 0; i < index_of(NUM_FRAMES); i++) {
+		// If all bits are set, then there is nothing here for us
+		if (alloc_bitmap[i] != 0xFFFFFFFF) {
+			// We know that at least one bit is free, find it
+			for (uint32_t j = 0; j < 32; j++) {
+				uint32_t bit = 0x1 << j;
+				// If the bit to test for is unset, we found our entry
+				if (!(alloc_bitmap[i] & bit)) {
+					return i * 32 + j;
+				}
+			}
+		}
+	}
+
+	return PAGE_ERR;
+}
+
+static void debug_pd(uint32_t idx) {
+	uint32_t cr3;
+	asm volatile ("mov %%cr3, %0" : "=r" (cr3));
+	uint32_t *pd = (uint32_t *) (cr3 + 0xC0000000);
+	uint32_t pde = pd[idx];
+
+	uint32_t frame_addr = (pde & 0xFFFFF000);
+	bool present = pde & PRESENT;
+	bool rw = pde & READ_WRITE;
+	bool sz = pde & PAGE_MB;
+
+	KLOG("PDE #%d: addr:%x,present:%d,rw:%d,sz:%d", idx, frame_addr, present, rw, sz);
+}
+
 void alloc_init() {
-		ALLOC_PHYSICAL_ADDRESS_OFFSET = PHYSICAL_MEMORY_START + STACK_SIZE;
+		// Zero necessary fields
+		physical_address_offset = 0;
+		memset(alloc_bitmap, 0, index_of(NUM_FRAMES) * sizeof(uint32_t));
+
+		// The kernel directory set in page directory neds to get set
+		BITMAP_SET(alloc_bitmap, 0);
+
+		
+		// Obtain the bootstrap page directory stored in CR3 register.
+		uint32_t cr3;
+		asm volatile ("mov %%cr3, %0" : "=r" (cr3));
+		page_directory = (uint32_t *) (cr3 + 0xC0000000);
+		KLOG("Address of Page Directory: %x", cr3);
 }
 
-paddr_t alloc(size_t size, uint32_t *phys_addr, bool aligned) {
-	// If we need to align it, we need to ensure the pointer is on a 4KB boundary
-	if (aligned && (ALLOC_PHYSICAL_ADDRESS_OFFSET & ~PAGE_ALIGNED)) {
-		ALLOC_PHYSICAL_ADDRESS_OFFSET &= PAGE_ALIGNED;
-		ALLOC_PHYSICAL_ADDRESS_OFFSET += 0x1000;
+vaddr_t alloc_block() {
+	// Obtain the first free frame by cycling through all possible frames for one without it's PRESENT bit set.
+	bool found = false;
+	for (int i = 0; i < 1024; i++) {
+		uint32_t idx = (physical_address_offset / PAGE_SIZE) % NUM_FRAMES;
+		if (!(page_directory[idx] & PRESENT)) {
+			uint32_t frame_idx = first_free_frame();
+			KLOG("Allocation: PDE #%d, Index: %d, Physical Address: %x, Virtual Address: %x", idx, frame_idx, frame_idx * PAGE_SIZE, physical_address_offset);
+			
+			// Out of Memory
+			if (frame_idx == PAGE_ERR) {
+				KPANIC("Could not find a free physical address!");
+			}
+
+			// Claim the frame
+			BITMAP_SET(alloc_bitmap, frame_idx);
+
+			// Mark frame as present and invalidate for TLB
+			page_directory[idx] = (frame_idx * PAGE_SIZE) | PAGE_MB | PRESENT | READ_WRITE;
+			asm volatile ("invlpg (%0)" :: "b" (physical_address_offset) : "memory");
+
+
+			debug_pd(idx);
+			// Exit early
+			found = true;
+			break;
+		}
+
+		physical_address_offset += PAGE_SIZE;
 	}
 
-	// If the user wants the actual physical address...
-	if (phys_addr) {
-		*phys_addr = ALLOC_PHYSICAL_ADDRESS_OFFSET;
+	// Out of Memory
+	if (!found) {
+		KPANIC("Could not find a free virtual address!");
 	}
 
-	uint32_t retval = ALLOC_PHYSICAL_ADDRESS_OFFSET;
-	ALLOC_PHYSICAL_ADDRESS_OFFSET += size;
+	uint32_t retval = physical_address_offset;
+	physical_address_offset += PAGE_SIZE;
 
-	// Clear the memory allocated for the user
-	memset((void *) retval, 0, size);
+	// Clear the memory allocated frame for the user
+	memset((void *) retval, 0, PAGE_SIZE);
 	return retval;
 }

src/kernel/mm/alloc.c

@@ -5,7 +5,7 @@
 // Idenitifies that the bitmap's entry is free to use
 static const uint8_t FREE = 0;
 
-static void memheap_init(memheap_t *heap) {
+void memheap_init(memheap_t *heap) {
 	heap->head = NULL;
 }
 
@@ -27,7 +27,7 @@ static uint8_t generate_identifier(uint8_t x, uint8_t y) {
 	return z;
 }
 
-static void memheap_add_block(memheap_t *heap, uintptr_t addr, uint32_t size, uint32_t block_size) {
+void memheap_add_block(memheap_t *heap, uintptr_t addr, uint32_t size, uint32_t block_size) {
 	// We reserve the first bytes of memory (pointed to by 'addr') for the superblock itself. Since the superblock
 	// takes up space, we must make the appropriate corrections to the size.
 	memblock_t *sblock = (memblock_t *) addr;
@@ -52,7 +52,7 @@ static void memheap_add_block(memheap_t *heap, uintptr_t addr, uint32_t size, ui
 	sblock->used = block_count;
 }
 
-static void *memheap_alloc(memheap_t *heap, uint32_t size) {
+void *memheap_alloc(memheap_t *heap, uint32_t size) {
 	// For each superblock...
 	for (memblock_t *sblock = heap->head; sblock; sblock = sblock->next) {
 		// If this superblock is large enough
@@ -101,7 +101,7 @@ static void *memheap_alloc(memheap_t *heap, uint32_t size) {
 	return NULL;
 }
 
-static void memheap_free(memheap_t *heap, void *ptr) {
+void memheap_free(memheap_t *heap, void *ptr) {
 	// For each superblock...
 	for (memblock_t *sblock = heap->head; sblock; sblock = sblock->next) {
 		// If the pointer is within the superblock