Trying to track an annoying bug.

4 files changed, 75 insertions, 32 deletions

diff --git a/kernel/l0/idt.c b/kernel/l0/idt.c
index 3bfcfc5..2d7b3bc 100644
--- a/kernel/l0/idt.c
+++ b/kernel/l0/idt.c
@@ -66,12 +66,6 @@ static isr_handler_t ex_handlers[32] = {0};
 
 /*	Called in interrupt.s when an exception fires (interrupt 0 to 31) */
 void idt_exHandler(registers_t *regs) {
-	/*dbg_printf("/ Exception %i\n", regs->int_no);*/
-	/*dbg_printf("| EAX: 0x%p   EBX: 0x%p   ECX: 0x%p   EDX: 0x%p\n", regs->eax, regs->ebx, regs->ecx, regs->edx);*/
-	/*dbg_printf("| EDI: 0x%p   ESI: 0x%p   ESP: 0x%p   EBP: 0x%p\n", regs->edi, regs->esi, regs->esp, regs->ebp);*/
-	/*dbg_printf("| EIP: 0x%p   CS : 0x%p   DS : 0x%p   SS : 0x%p\n", regs->eip, regs->cs, regs->ds, regs->ss);*/
-	/*dbg_printf("\\ EFl: 0x%p   I# : 0x%p   Err: 0x%p\n", regs->eflags, regs->int_no, regs->err_code);*/
-
 	if (ex_handlers[regs->int_no] != 0) {
 		ex_handlers[regs->int_no](regs);
 	}
@@ -194,4 +188,13 @@ void idt_set_ex_handler(int number, isr_handler_t func) {
 	}
 }
 
+void dbg_dump_registers(registers_t *regs) {
+	dbg_printf("/ Exception %i\n", regs->int_no);
+	dbg_printf("| EAX: 0x%p   EBX: 0x%p   ECX: 0x%p   EDX: 0x%p\n", regs->eax, regs->ebx, regs->ecx, regs->edx);
+	dbg_printf("| EDI: 0x%p   ESI: 0x%p   ESP: 0x%p   EBP: 0x%p\n", regs->edi, regs->esi, regs->esp, regs->ebp);
+	dbg_printf("| EIP: 0x%p   CS : 0x%p   DS : 0x%p   SS : 0x%p\n", regs->eip, regs->cs, regs->ds, regs->ss);
+	dbg_printf("\\ EFl: 0x%p   I# : 0x%p   Err: 0x%p\n", regs->eflags, regs->int_no, regs->err_code);
+}
+
 /* vim: set ts=4 sw=4 tw=0 noet :*/
+
diff --git a/kernel/l0/kmain.c b/kernel/l0/kmain.c
index a935c9c..8cb370a 100644
--- a/kernel/l0/kmain.c
+++ b/kernel/l0/kmain.c
@@ -11,26 +11,37 @@
 
 #include <slab_alloc.h>
 
+extern char k_end_addr;	// defined in linker script : 0xC0000000 plus kernel stuff
+
 void breakpoint_handler(registers_t *regs) {
 	dbg_printf("Breakpoint! (int3)\n");
 	BOCHS_BREAKPOINT;
 }
 
 void test_pf_handler(pagedir_t *pd, region_info_t *i, void* addr) {
-	dbg_printf("0x%p", addr);
+	dbg_printf(" {0x%p", addr);
 
 	uint32_t f = frame_alloc(1);
 	if (f == 0) PANIC("Out Of Memory");
-	dbg_printf(" -> %i", f);
+	dbg_printf(" -> %i} ", f);
 
 	int error = pd_map_page(addr, f, 1);
 	if (error) PANIC("Could not map frame (OOM)");
 }
 
 void* page_alloc_fun_for_kmalloc(size_t bytes) {
-	return region_alloc(bytes, REGION_T_CORE_HEAP, test_pf_handler);
+	void* addr = region_alloc(bytes, REGION_T_CORE_HEAP, test_pf_handler);
+	return addr;
 }
 void page_free_fun_for_kmalloc(void* ptr) {
+	region_info_t *i = find_region(ptr);
+	for (void* x = i->addr; x < i->addr + i->size; x += PAGE_SIZE) {
+		uint32_t f = pd_get_frame(x);
+		if (f != 0) {
+			pd_unmap_page(x);
+			frame_free(f, 1);
+		}
+	}
 	region_free(ptr);
 }
 slab_type_t slab_sizes[] = {
@@ -47,8 +58,6 @@ slab_type_t slab_sizes[] = {
 	{ 0, 0, 0 }
 };
 
-
-extern char k_end_addr;	// defined in linker script : 0xC0000000 plus kernel stuff
  
 void kmain(struct multiboot_info_t *mbd, int32_t mb_magic) {
 	dbglog_setup();
@@ -66,7 +75,6 @@ void kmain(struct multiboot_info_t *mbd, int32_t mb_magic) {
 
 	size_t total_ram = ((mbd->mem_upper + mbd->mem_lower) * 1024);
 	dbg_printf("Total ram: %d Kb\n", total_ram / 1024);
-	// paging_init(totalRam);
 
 	// used for allocation of data structures before malloc is set up
 	// a pointer to this pointer is passed to the functions that might have
@@ -80,6 +88,8 @@ void kmain(struct multiboot_info_t *mbd, int32_t mb_magic) {
 	paging_setup(kernel_data_end);
 	dbg_printf("Paging seems to be working!\n");
 
+	BOCHS_BREAKPOINT;
+
 	region_allocator_init(kernel_data_end);
 	dbg_print_region_stats();
 
@@ -107,9 +117,10 @@ void kmain(struct multiboot_info_t *mbd, int32_t mb_magic) {
 	region_free(s);
 	dbg_printf("Freed region 0x%p\n", s);
 	dbg_print_region_stats();
+	BOCHS_BREAKPOINT;
 
 	// allocate a big region and try to write into it
-	const size_t n = 1000;
+	const size_t n = 200;
 	void* p0 = region_alloc(n * PAGE_SIZE, REGION_T_HW, test_pf_handler);
 	for (size_t i = 0; i < n; i++) {
 		uint32_t *x = (uint32_t*)(p0 + i * PAGE_SIZE);
@@ -119,43 +130,44 @@ void kmain(struct multiboot_info_t *mbd, int32_t mb_magic) {
 		x[1] = (i * 20422) % 122;
 		dbg_printf("]\n", i);
 	}
+	BOCHS_BREAKPOINT;
 	// unmap memory
 	for (size_t i = 0; i < n; i++) {
-		uint32_t *x = (uint32_t*)(p0 + i * PAGE_SIZE);
+		void* p = p0 + i * PAGE_SIZE;
+		uint32_t *x = (uint32_t*)p;
 		ASSERT(x[1] == (i * 20422) % 122);
 
-		uint32_t f = pd_get_frame(x);
+		uint32_t f = pd_get_frame(p);
 		ASSERT(f != 0);
-		pd_unmap_page(x);
+		pd_unmap_page(p);
+		ASSERT(pd_get_frame(p) == 0);
 
 		frame_free(f, 1);
 	}
 	region_free(s);
+	BOCHS_BREAKPOINT;
 
 	// TEST SLAB ALLOCATOR!!!
 	mem_allocator_t *a =
 		create_slab_allocator(slab_sizes, page_alloc_fun_for_kmalloc,
 										  page_free_fun_for_kmalloc);
 	dbg_printf("Created slab allocator at 0x%p\n", a);
-	const int m = 100;
-	void* ptr[m];
-	for (int i = 0; i < m; i++) {
-		size_t s = 1 << ((i * 7) % 12 + 1);
-		ptr[i] = slab_alloc(a, s);
-		dbg_printf("Alloc %i : 0x%p\n", s, ptr[i]);
-		dbg_print_region_stats();
-	}
-	for (int i = 0; i < m; i++) {
-		slab_free(a, ptr[m - i - 1]);
-	}
 	dbg_print_region_stats();
+	const int m = 10000;
+	uint16_t* ptr[m];
 	for (int i = 0; i < m; i++) {
-		size_t s = 1 << ((i * 7) % 12 + 1);
-		ASSERT(slab_alloc(a, s) == ptr[i]);
+		size_t s = 1 << ((i * 7) % 12 + 2);
+		ptr[i] = (uint16_t*)slab_alloc(a, s);
+		ASSERT((void*)ptr[i] >= kernel_data_end && (size_t)ptr[i] < 0xFFC00000);
+		*ptr[i] = ((i * 211) % 1024);
+		dbg_printf("Alloc %i : 0x%p\n", s, ptr[i]);
 	}
 	dbg_print_region_stats();
 	for (int i = 0; i < m; i++) {
-		slab_free(a, ptr[m - i - 1]);
+		for (int j = i; j < m; j++) {
+			ASSERT(*ptr[j] == (j * 211) % 1024);
+		}
+		slab_free(a, ptr[i]);
 	}
 	dbg_print_region_stats();
 	dbg_printf("Destroying slab allocator.\n");
diff --git a/kernel/l0/paging.c b/kernel/l0/paging.c
index ca217c6..adb076c 100644
--- a/kernel/l0/paging.c
+++ b/kernel/l0/paging.c
@@ -58,13 +58,32 @@ void page_fault_handler(registers_t *regs) {
 			return;
 		}
 
+		if ((size_t)vaddr >= PD_MIRROR_ADDR) {
+			dbg_printf("Fault on access to mirrorred PD at 0x%p\n", vaddr);
+
+			uint32_t x = (size_t)vaddr - PD_MIRROR_ADDR;
+			uint32_t page = (x % PAGE_SIZE) / 4;
+			uint32_t pt = x / PAGE_SIZE;
+			dbg_printf("For pt 0x%p, page 0x%p -> addr 0x%p\n", pt, page, ((pt * 1024) + page) * PAGE_SIZE);
+
+			for (int i = 0; i < N_PAGES_IN_PT; i++) {
+				dbg_printf("%i. 0x%p\n", i, kernel_pd.page[i]);
+			}
+
+			dbg_dump_registers(regs);
+			dbg_print_region_stats();
+			PANIC("Unhandled kernel space page fault");
+		}
+
 		region_info_t *i = find_region(vaddr);
 		if (i == 0) {
 			dbg_printf("Kernel pagefault in non-existing region at 0x%p\n", vaddr);
+			dbg_dump_registers(regs);
 			PANIC("Unhandled kernel space page fault");
 		}
 		if (i->pf == 0) {
 			dbg_printf("Kernel pagefault in region with no handler at 0x%p\n", vaddr);
+			dbg_dump_registers(regs);
 			PANIC("Unhandled kernel space page fault");
 		}
 		i->pf(current_pd_d, i, vaddr);
@@ -149,6 +168,8 @@ int pd_map_page(void* vaddr, uint32_t frame_id, bool rw) {
 	uint32_t pt = PT_OF_ADDR(vaddr);
 	uint32_t page = PAGE_OF_ADDR(vaddr);
 
+	ASSERT((size_t)vaddr < PD_MIRROR_ADDR);
+	
 	pagetable_t *pd = ((size_t)vaddr >= K_HIGHHALF_ADDR ? &kernel_pd : current_pd);
 
 	if (!pd->page[pt] & PTE_PRESENT) {
@@ -159,12 +180,16 @@ int pd_map_page(void* vaddr, uint32_t frame_id, bool rw) {
 			(new_pt_frame << PTE_FRAME_SHIFT) | PTE_PRESENT | PTE_RW;
 		invlpg(&current_pt[pt]);
 	}
+	dbg_printf("[%p,%i,%i,", vaddr, pt, page);
 
 	current_pt[pt].page[page] =
-		frame_id << PTE_FRAME_SHIFT
+		(frame_id << PTE_FRAME_SHIFT)
 			| PTE_PRESENT
 			| ((size_t)vaddr < K_HIGHHALF_ADDR ? PTE_USER : PTE_GLOBAL)
 			| (rw ? PTE_RW : 0);
+	invlpg(vaddr);
+
+	dbg_printf("]");
 
 	return 0;
 } 
@@ -177,7 +202,9 @@ void pd_unmap_page(void* vaddr) {
 
 	if (!pd->page[pt] & PTE_PRESENT) return;
 	if (!current_pt[pt].page[page] & PTE_PRESENT) return;
-	current_pt[pt].page[page] &= ~PTE_PRESENT;
+
+	current_pt[pt].page[page] = 0;
+	invlpg(vaddr);
 
 	// TODO (?) : if pagetable is completely empty, free it
 }
diff --git a/kernel/l0/sys.c b/kernel/l0/sys.c
index b388eba..2b77463 100644
--- a/kernel/l0/sys.c
+++ b/kernel/l0/sys.c
@@ -10,6 +10,7 @@ static void panic_do(const char* type, const char *msg, const char* file, int li
 	dbg_printf("| File: \t%s:%i\n", file, line);
 	dbg_printf("| System halted -_-'\n");
 	dbg_printf("\\---------------------------------------------------------/");
+	BOCHS_BREAKPOINT;
 	asm volatile("hlt");
 }