Finally finished implementation of memory management and adequate tests.

The heap is actually causing a page fault when I use too much RAM, but
I'm not sure if it is because I reach the end of the space available
faster than anticipated or what. Regardless, it is in a very
satisfactory state.

Author: Louis Jenkins

README.md

@@ -12,13 +12,14 @@ The below depicts an early "schedule" or rather a path I will be taking in terms
 - [x] Interrupts (IRQ + ISR)
 - [x] VGA Display Driver
 - [x] Keyboard Driver
-- [ ] Memory Management (Physical + Virtual)
-- [ ] Interactive Shell
+- [x] Memory Management (Physical + Virtual)
+- [x] Higher Half Kernel
 - [ ] File System
+- [ ] Process Creation and Managements
 - [ ] Multitasking and Scheduling
 - [ ] Networking
-- [ ] Process Creation and Managements
 - [ ] ELF Binary Support
+- [ ] Interactive Shell
 - [ ] Graphical User Interfaces
 
 #Progress Update & Changelog
@@ -47,4 +48,11 @@ a significant amount of work and should be pushed to master.
 
 Lastly, I also added a nice logger macro, `KLOG`, and panic macro, `KPANIC`.
 
-![Screenshot](/ram_and_kbd.PNG)
+![Screenshot](/ram_and_kbd.PNG)
+
+
+## Version .002
+
+It is FINALLY here! I have implemented not only memory management (paging and a heap allocator), but even converted to a higher-half kernel approach, which was also easier, surprisingly, than a normal identity-mapped system. I've also fixed up the tests and their output format to better portray the significance of the initialization of the kernel thus far. I am very satisfied with what I have done, but unfortunately, I have to attend to another project for the time being.
+
+![Screenshot](/all_tests_and_heap.PNG)

all_tests_and_heap.PNG

@@ -4,6 +4,10 @@
 #include <stdio.h>
 #include <stdbool.h>
 
+#define MAX(x, y) ((x) > (y) ? (x) : (y))
+
+#define MIN(x, y) ((x) > (y) ? (y) : (x))
+
 #define HALT \
 do { \
 	asm volatile ("cli"); \

src/kernel/.sym

@@ -63,13 +63,12 @@ struct multiboot_mmap {
 
 static bool multiboot_RAM(struct multiboot_info *mbinfo, uint32_t *start, uint32_t *end) {
 	bool found = false;
-	printf("Flags: %d\n", mbinfo->flags);
 	// Check if there is a memory mapping available
 	if (mbinfo->flags & (1 << 6)) {
-		KLOG("MMAP Entries: %d", mbinfo->mmap_length / 24);
+		// KLOG("MMAP Entries: %d", mbinfo->mmap_length / 24);
 		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);
+			// 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) {
 				*start = mmap->start_low;

src/kernel/debug_kernel.sh

@@ -1,6 +1,7 @@
 #include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
+#include <string.h>
 #include <stdio.h>
 
 #define __IS_MOLTAROS 1
@@ -13,62 +14,123 @@
 #include <include/drivers/rtc.h>
 #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;
 uint32_t PHYSICAL_MEMORY_START;
 
 size_t ticks_x, ticks_y, time_x, time_y;
+static bool timer_done = false;
 
 void kernel_init(struct multiboot_info *info) {
 	vga_init();
+	KLOG("Virtual Memory (Paging) Initialized...");
+	KLOG("Video Graphics Array (VGA) Initialized...");
 	gdt_init();
+	KLOG("Global Descriptor Table (GDT) Initialized...");
 	idt_init();
+	KLOG("Interrupt Descriptor Table (IDT) Initialized...");
 	timer_init();
-	bool retval = multiboot_RAM(info, &PHYSICAL_MEMORY_START, &PHYSICAL_MEMORY_END);
-	KLOG("RAM Stats: Available: %d, Start: %d, End: %d", retval, PHYSICAL_MEMORY_START, PHYSICAL_MEMORY_END);
-	// page_init();
-	// KFRAME;
+	KLOG("System Timer (PIT) Initialized...");
+	if (!multiboot_RAM(info, &PHYSICAL_MEMORY_START, &PHYSICAL_MEMORY_END)) {
+		KPANIC("Failed to detect physical memory (RAM)!!!");
+	}
+	KLOG("Detected => RAM {Start: %d, End: %d, Total: %d}", PHYSICAL_MEMORY_START, PHYSICAL_MEMORY_END, PHYSICAL_MEMORY_END - PHYSICAL_MEMORY_START);
+	mem_init();
+	KLOG("Memory Heap and Allocators (kmalloc & kfree) Initialized...");
 }
 
-static void kernel_tick(struct registers *UNUSED(regs)) {
-	static uint32_t ticks = 0;
-
-	vga_set_x(ticks_x);
-	vga_set_y(ticks_y);
-	printf("%d", ++ticks);
+// Memory test that purposefully performs allocation-heavy allocations to test the state of the heap and virtual memory
+// implementation. It works by filling up half of the amount of RAM with a deterministic sequence (for debugging) of
+// values. On each iteration, we resize by allocating and copying into a new container. 
+static void memtest() {
+	uint32_t total_memory = PHYSICAL_MEMORY_END - PHYSICAL_MEMORY_START;
+	uint32_t total_alloc = 0;
+	uint32_t alloc_size = 1;
+	uint32_t **allocated_data = NULL;
+	uint32_t num_alloc = 1;
+
+	printf("Allocated: ");
+	uint32_t x = vga_get_x();
+	uint32_t y = vga_get_y();
+	printf("%d/%d", total_alloc, total_memory / 4);
+
+	// TODO: Stops working at 1/2 RAM used.
+	while (total_alloc < (total_memory / 4)) {
+		// Allocate new storage
+		uint32_t **new_data = kmalloc(sizeof(void *) * num_alloc);
+		memcpy(new_data, allocated_data, sizeof(void *) * (num_alloc - 1));
+		kfree(allocated_data);
+		allocated_data = new_data;
+
+		allocated_data[num_alloc - 1] = kmalloc(alloc_size);
+		*allocated_data[num_alloc - 1] = alloc_size;
+		total_alloc += alloc_size;
+		alloc_size = MIN(2 * 1024 * 1024, alloc_size * 2);
+		num_alloc++;
+
+		vga_set_x(x);
+		vga_set_y(y);
+		printf("%d/%d", total_alloc, total_memory / 4);
+	}
 
-	if(ticks % 1000 == 0) {
-		vga_set_x(time_x);
-		vga_set_y(time_y);
-		rtc_print();
-		vga_putc(' ');
+	alloc_size = 1;
+	num_alloc = 0;
+
+	printf("\nTesting and Deallocating: ");
+	x = vga_get_x();
+	y = vga_get_y();
+	printf("%d/%d", total_alloc, total_memory / 4);
+
+	while (total_alloc) {
+		uint32_t *val = allocated_data[num_alloc];
+		if (*val != alloc_size) {
+			KPANIC("Bad Value for Index: %d, Expected: %d, Received: %d, Address: %x", num_alloc, alloc_size, *val, val);
+		}
+
+		total_alloc -= alloc_size;
+		num_alloc++;
+		alloc_size = MIN(2 * 1024 * 1024, alloc_size * 2);
+		kfree(val);
+		vga_set_x(x);
+		vga_set_y(y);
+		printf("%d/%d", total_alloc, total_memory / 4);
 	}
 
-	if (ticks > 0 && ticks % 10000 == 0) {
-		int i = *(int *) 5000000;
-		i++;
+	printf("\n");
+}
+
+static void kernel_tick(struct registers *UNUSED(regs)) {
+	static uint32_t ticks = 0;
+
+	if (ticks == 10000) {
+		timer_done = true;		
+	} else {
+		vga_set_x(ticks_x);
+		vga_set_y(ticks_y);
+		printf("%d", ++ticks);
 	}
 }
 
-static void kernel_clock_test() {
-	printf("Operating System: MoltarOS\nKernel: Moltar\nVersion: 0.001a\nTime: ");
+static void timer_test() {
 	time_x = vga_get_x();
 	time_y = vga_get_y();
-	rtc_print();
 
-	printf("\nTesting Clock at 1KHz...\nTicks: 0");
+	printf("Ticks: 0");
 	ticks_x = vga_get_x() - 1;
 	ticks_y = vga_get_y();
 
 	timer_set_handler(1000, kernel_tick);
 
 	asm volatile ("sti");
-
-	while(true)
+	while(!timer_done)
 		asm volatile ("hlt");
+
+	// init currently only sets a default callback, so this is adequate
+	timer_init();
+
+	printf("\n");
 }
 
 static void kernel_keyboard_test() {
@@ -85,13 +147,38 @@ void kernel_main(void) {
 	// 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);
+	printf("Memory Test (%d Bytes): ", (PHYSICAL_MEMORY_END - PHYSICAL_MEMORY_START) / 4);
+	uint32_t x = vga_get_x();
+	uint32_t y = vga_get_y();
+	printf("START\n");
+	memtest();
+	uint32_t tmpx = vga_get_x();
+	uint32_t tmpy = vga_get_y();
+	vga_set_x(x);
+	vga_set_y(y);
+	KLOG("SUCCESS!");
+	vga_set_x(tmpx);
+	vga_set_y(tmpy);
+
+	printf("SysTimer Test (1KHz): ");
+	x = vga_get_x();
+	y = vga_get_y();
+	printf("START\n");
+	timer_test();
+	tmpx = vga_get_x();
+	tmpy = vga_get_y();
+	vga_set_x(x);
+	vga_set_y(y);
+	KLOG("SUCCESS!");
+	vga_set_x(tmpx);
+	vga_set_y(tmpy);
+
+	KLOG("Tests Complete!");
+	keyboard_init();
+	KLOG("Keyboard Initialized... Press any Button...");
+
+	// Loop infinitely
+	while (true) {
+		asm volatile ("hlt");
+	}
 }

src/kernel/include/helpers.h

@@ -13,9 +13,6 @@ 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) {
@@ -31,9 +28,15 @@ void *kmalloc(size_t sz) {
 		data = memheap_alloc(&kheap, sz);
 	}
 
+	if (!data) {
+		KPANIC("Heap Allocation Failed!");
+	}
+
 	return data;
 }
 
 void kfree(void *ptr) {
-	memheap_free(&kheap, ptr);
+	if (ptr) {
+		memheap_free(&kheap, ptr);
+	}
 }