From acc4b7ccc133b64312e7ab1da3225b7945b1e13d Mon Sep 17 00:00:00 2001
From: Marvin Borner
Date: Tue, 2 Mar 2021 19:04:53 +0100
Subject: very good this is

---
 kernel/features/load.c | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

(limited to 'kernel/features/load.c')

diff --git a/kernel/features/load.c b/kernel/features/load.c
index 8a4aae3..610abf8 100644
--- a/kernel/features/load.c
+++ b/kernel/features/load.c
@@ -3,14 +3,19 @@
 #include <fs.h>
 #include <load.h>
 #include <mem.h>
+#include <mm.h>
 #include <str.h>
 
+#define PROC_STACK_SIZE 0x4000
+
 void proc_load(struct proc *proc, void *data)
 {
-	u32 stack = (u32)malloc(0x2000) + 0x1000;
+	u32 stack;
+	memory_alloc(proc->page_dir, PROC_STACK_SIZE, MEMORY_CLEAR, &stack);
+	u32 ptr = stack + PROC_STACK_SIZE - 1;
 
-	proc->regs.ebp = (u32)stack;
-	proc->regs.useresp = (u32)stack;
+	proc->regs.ebp = (u32)ptr;
+	proc->regs.useresp = (u32)ptr;
 	proc->regs.eip = (u32)data;
 	proc->entry = (u32)data;
 }
@@ -19,12 +24,13 @@ int bin_load(const char *path, struct proc *proc)
 {
 	struct stat s = { 0 };
 	vfs_stat(path, &s);
-	char *data = malloc(s.size);
-	if (!vfs_read(path, data, 0, s.size))
+	u32 data;
+	memory_alloc(proc->page_dir, PAGE_ALIGN_UP(s.size), MEMORY_CLEAR, &data);
+	if (!vfs_read(path, (void *)data, 0, s.size))
 		return 1;
 
 	strcpy(proc->name, path);
-	proc_load(proc, data);
+	proc_load(proc, (void *)data);
 
 	return 0;
 }
-- 
cgit v1.2.3


From d47e627d0006e038dcd1c34b9015c3370f7b4b0c Mon Sep 17 00:00:00 2001
From: Marvin Borner
Date: Tue, 2 Mar 2021 23:34:39 +0100
Subject: Getting closer!

---
 kernel/drivers/interrupts.c | 38 +++++++++++++++++++++-----------------
 kernel/features/load.c      | 13 ++++++-------
 kernel/features/mm.c        | 32 +++++++++++++++++++++++++++++++-
 kernel/features/proc.c      | 11 +++++------
 kernel/inc/interrupts.h     |  1 +
 kernel/inc/load.h           |  2 +-
 kernel/main.c               |  5 +++++
 7 files changed, 70 insertions(+), 32 deletions(-)

(limited to 'kernel/features/load.c')

diff --git a/kernel/drivers/interrupts.c b/kernel/drivers/interrupts.c
index fa455d7..55926b7 100644
--- a/kernel/drivers/interrupts.c
+++ b/kernel/drivers/interrupts.c
@@ -169,26 +169,30 @@ void isr_uninstall_handler(int isr)
 	isr_routines[isr] = 0;
 }
 
-void isr_handler(struct regs *r);
-void isr_handler(struct regs *r)
+void isr_panic(struct regs *r)
 {
-	if (r->int_no <= 32) {
-		struct proc *proc = proc_current();
-		printf("%s Exception at 0x%x, exiting!\n", isr_exceptions[r->int_no], r->eip);
-		if (proc) {
-			printf("\t-> Exception occurred in %s at addr 0x%x\n", proc->name,
-			       r->eip - proc->entry);
-			proc_exit(proc, 1);
-		} else {
-			__asm__ volatile("cli\nhlt");
-		}
-		proc_yield(r);
+	struct proc *proc = proc_current();
+	printf("%s Exception (%x) at 0x%x, exiting!\n", isr_exceptions[r->int_no], r->err_code,
+	       r->eip);
+	if (proc) {
+		printf("\t-> Exception occurred in %s at addr 0x%x\n", proc->name,
+		       r->eip - proc->entry);
+		proc_exit(proc, 1);
 	} else {
-		// Execute fault handler if exists
-		void (*handler)(struct regs * r) = isr_routines[r->int_no];
-		if (handler)
-			handler(r);
+		__asm__ volatile("cli\nhlt");
 	}
+	proc_yield(r);
+}
+
+void isr_handler(struct regs *r);
+void isr_handler(struct regs *r)
+{
+	// Execute fault handler if exists
+	void (*handler)(struct regs * r) = isr_routines[r->int_no];
+	if (handler)
+		handler(r);
+	else
+		isr_panic(r);
 }
 
 static void isr_install(void)
diff --git a/kernel/features/load.c b/kernel/features/load.c
index 610abf8..4b3f8ea 100644
--- a/kernel/features/load.c
+++ b/kernel/features/load.c
@@ -8,16 +8,15 @@
 
 #define PROC_STACK_SIZE 0x4000
 
-void proc_load(struct proc *proc, void *data)
+void proc_load(struct proc *proc, u32 entry)
 {
 	u32 stack;
 	memory_alloc(proc->page_dir, PROC_STACK_SIZE, MEMORY_CLEAR, &stack);
-	u32 ptr = stack + PROC_STACK_SIZE - 1;
 
-	proc->regs.ebp = (u32)ptr;
-	proc->regs.useresp = (u32)ptr;
-	proc->regs.eip = (u32)data;
-	proc->entry = (u32)data;
+	proc->regs.ebp = stack;
+	proc->regs.useresp = stack;
+	proc->regs.eip = entry;
+	proc->entry = entry;
 }
 
 int bin_load(const char *path, struct proc *proc)
@@ -30,7 +29,7 @@ int bin_load(const char *path, struct proc *proc)
 		return 1;
 
 	strcpy(proc->name, path);
-	proc_load(proc, (void *)data);
+	proc_load(proc, data);
 
 	return 0;
 }
diff --git a/kernel/features/mm.c b/kernel/features/mm.c
index ccc2727..ad70685 100644
--- a/kernel/features/mm.c
+++ b/kernel/features/mm.c
@@ -25,6 +25,7 @@ void paging_enable(void)
 
 void paging_switch_dir(u32 dir)
 {
+	assert(dir);
 	cr3_set(dir);
 }
 
@@ -418,7 +419,7 @@ void memory_initialize(struct mem_info *mem_info)
 	memory_map_identity(&kernel_dir, memory_range_around_address(HEAP_START, HEAP_INIT_SIZE),
 			    MEMORY_NONE);
 
-	// TODO: Map something, idk? Triple fault prevention?
+	// TODO: Triple fault prevention? Probably bootloader stuff or something
 	memory_map_identity(&kernel_dir, memory_range_around_address(0x7000, 0x1000), MEMORY_NONE);
 
 	// Unmap NULL byte/page
@@ -429,8 +430,37 @@ void memory_initialize(struct mem_info *mem_info)
 	paging_enable();
 }
 
+static void page_fault(struct regs *r)
+{
+	// Check error code
+	const char *type = (r->err_code & 4) ? "present" : "non-present";
+	const char *operation = (r->err_code & 2) ? "write" : "read";
+	const char *super = (r->err_code & 1) ? "User" : "Super";
+
+	// Check cr2 address
+	u32 vaddr;
+	__asm__ volatile("movl %%cr2, %%eax" : "=a"(vaddr));
+	struct proc *proc = proc_current();
+	struct page_dir *dir = NULL;
+	if (proc && proc->page_dir) {
+		dir = proc->page_dir;
+		printf("Stack is at %x, entry at %x\n", virtual_to_physical(dir, proc->regs.ebp),
+		       virtual_to_physical(dir, proc->entry));
+	} else {
+		dir = &kernel_dir;
+	}
+	u32 paddr = virtual_to_physical(dir, vaddr);
+
+	// Print!
+	printf("%s process tried to %s a %s page at [vaddr=%x; paddr=%x]\n", super, operation, type,
+	       vaddr, paddr);
+
+	isr_panic(r);
+}
+
 void paging_install(struct mem_info *mem_info)
 {
 	memory_initialize(mem_info);
 	heap_init(HEAP_START);
+	isr_install_handler(14, page_fault);
 }
diff --git a/kernel/features/proc.c b/kernel/features/proc.c
index bbe675e..43cedb6 100644
--- a/kernel/features/proc.c
+++ b/kernel/features/proc.c
@@ -20,7 +20,7 @@ struct list *proc_list = NULL;
 struct node *idle_proc = NULL;
 struct node *current = NULL;
 
-// TODO: Use less memcpy and only copy relevant registers
+// TODO: Use less memcpy and only copy relevant registers (rewrite for efficiency argh)
 // TODO: 20 priority queues (https://www.kernel.org/doc/html/latest/scheduler/sched-nice-design.html)
 void scheduler(struct regs *regs)
 {
@@ -57,8 +57,8 @@ void scheduler(struct regs *regs)
 		}
 	}
 
-	memcpy(regs, &((struct proc *)current->data)->regs, sizeof(struct regs));
 	memory_dir_switch(((struct proc *)current->data)->page_dir);
+	memcpy(regs, &((struct proc *)current->data)->regs, sizeof(struct regs));
 
 	if (regs->cs != GDT_USER_CODE_OFFSET) {
 		regs->gs = GDT_USER_DATA_OFFSET;
@@ -473,8 +473,7 @@ void proc_init(void)
 
 	// Idle proc
 	struct proc *kernel_proc = proc_make(PROC_PRIV_NONE);
-	void (*func)(void) = kernel_idle;
-	proc_load(kernel_proc, *(void **)&func);
+	proc_load(kernel_proc, (u32)kernel_idle);
 	strcpy(kernel_proc->name, "idle");
 	kernel_proc->state = PROC_SLEEPING;
 	idle_proc = list_add(proc_list, kernel_proc);
@@ -494,11 +493,11 @@ void proc_init(void)
 	argv[2] = NULL;
 
 	((u32 *)_esp)[0] = argc; // First argument (argc)
-	((u32 *)_esp)[1] = (u32)argv; // Second argument (argv)
+	((u32 *)_esp)[-1] = (u32)argv; // Second argument (argv)
 
 	printf("Jumping to userspace!\n");
-	proc_jump_userspace();
 	memory_dir_switch(((struct proc *)new->data)->page_dir);
+	proc_jump_userspace();
 	while (1) {
 	};
 }
diff --git a/kernel/inc/interrupts.h b/kernel/inc/interrupts.h
index 30c91c3..fc00402 100644
--- a/kernel/inc/interrupts.h
+++ b/kernel/inc/interrupts.h
@@ -32,6 +32,7 @@ void irq_uninstall_handler(int irq);
 
 void isr_install_handler(int isr, void (*handler)(struct regs *r));
 void isr_uninstall_handler(int isr);
+void isr_panic(struct regs *r);
 
 void interrupts_install(void);
 
diff --git a/kernel/inc/load.h b/kernel/inc/load.h
index 407fbeb..330caca 100644
--- a/kernel/inc/load.h
+++ b/kernel/inc/load.h
@@ -5,7 +5,7 @@
 
 #include <proc.h>
 
-void proc_load(struct proc *proc, void *data);
+void proc_load(struct proc *proc, u32 entry);
 int bin_load(const char *path, struct proc *proc);
 
 #endif
diff --git a/kernel/main.c b/kernel/main.c
index b46db0d..2e2e030 100644
--- a/kernel/main.c
+++ b/kernel/main.c
@@ -7,6 +7,7 @@
 #include <interrupts.h>
 #include <keyboard.h>
 #include <load.h>
+#include <mem.h>
 #include <mm.h>
 #include <mouse.h>
 #include <net.h>
@@ -21,6 +22,10 @@ struct vid_info *boot_passed;
 void kernel_main(struct mem_info *mem_info, struct vid_info *vid_info); // Decl
 void kernel_main(struct mem_info *mem_info, struct vid_info *vid_info)
 {
+	// Clear stack
+	for (u32 i = 0; i < STACK_SIZE; i++)
+		((u8 *)STACK_START)[-i] = 0;
+
 	// Serial connection
 	serial_install();
 	serial_print("\nKernel was compiled at " __TIME__ " on " __DATE__ "\n");
-- 
cgit v1.2.3


From 03e53516ac31639a47584bd7be655cd2f6f44eb9 Mon Sep 17 00:00:00 2001
From: Marvin Borner
Date: Fri, 5 Mar 2021 18:21:57 +0100
Subject: Oh man... Idfk anymore

---
 kernel/features/load.c | 31 +++++++++++++++++++++++--------
 kernel/features/mm.c   |  5 +++++
 kernel/inc/mm.h        | 13 ++++++++++++-
 3 files changed, 40 insertions(+), 9 deletions(-)

(limited to 'kernel/features/load.c')

diff --git a/kernel/features/load.c b/kernel/features/load.c
index 4b3f8ea..31e22dc 100644
--- a/kernel/features/load.c
+++ b/kernel/features/load.c
@@ -6,15 +6,21 @@
 #include <mm.h>
 #include <str.h>
 
+// TODO: Fix pdi < 256!
+#define PROC_DATA_ADDR 0xc000000
+
 #define PROC_STACK_SIZE 0x4000
+#define PROC_STACK_ADDR (PROC_DATA_ADDR - 256)
 
 void proc_load(struct proc *proc, u32 entry)
 {
-	u32 stack;
-	memory_alloc(proc->page_dir, PROC_STACK_SIZE, MEMORY_CLEAR, &stack);
+	/* memory_dir_switch(proc->page_dir); */
+	u32 paddr = physical_alloc(PROC_STACK_SIZE);
+	virtual_map(proc->page_dir, PROC_STACK_ADDR, paddr, PROC_STACK_SIZE,
+		    MEMORY_USER | MEMORY_CLEAR);
 
-	proc->regs.ebp = stack;
-	proc->regs.useresp = stack;
+	proc->regs.ebp = PROC_STACK_ADDR;
+	proc->regs.useresp = PROC_STACK_ADDR;
 	proc->regs.eip = entry;
 	proc->entry = entry;
 }
@@ -23,13 +29,22 @@ int bin_load(const char *path, struct proc *proc)
 {
 	struct stat s = { 0 };
 	vfs_stat(path, &s);
-	u32 data;
-	memory_alloc(proc->page_dir, PAGE_ALIGN_UP(s.size), MEMORY_CLEAR, &data);
-	if (!vfs_read(path, (void *)data, 0, s.size))
+	struct proc *current = proc_current();
+	struct page_dir *prev = current ? current->page_dir : memory_kernel_dir();
+
+	u32 size = PAGE_ALIGN_UP(s.size);
+	memory_dir_switch(proc->page_dir);
+	u32 paddr = physical_alloc(size);
+	virtual_map(proc->page_dir, PROC_DATA_ADDR, paddr, size, MEMORY_USER | MEMORY_CLEAR);
+
+	if (!vfs_read(path, (void *)PROC_DATA_ADDR, 0, s.size)) {
+		memory_dir_switch(prev);
 		return 1;
+	}
 
 	strcpy(proc->name, path);
-	proc_load(proc, data);
+	proc_load(proc, PROC_DATA_ADDR);
 
+	memory_dir_switch(prev);
 	return 0;
 }
diff --git a/kernel/features/mm.c b/kernel/features/mm.c
index ad70685..b17d9fc 100644
--- a/kernel/features/mm.c
+++ b/kernel/features/mm.c
@@ -128,8 +128,13 @@ u32 virtual_to_physical(struct page_dir *dir, u32 vaddr)
 	u32 pti = PTI(vaddr);
 
 	union page_dir_entry *dir_entry = &dir->entries[pdi];
+	if (!dir_entry->bits.present)
+		return 0;
+
 	struct page_table *table = (struct page_table *)(dir_entry->bits.address * PAGE_SIZE);
 	union page_table_entry *table_entry = &table->entries[pti];
+	if (!table_entry->bits.present)
+		return 0;
 
 	return (table_entry->bits.address * PAGE_SIZE) + (vaddr & (PAGE_SIZE - 1));
 }
diff --git a/kernel/inc/mm.h b/kernel/inc/mm.h
index 00d9e4b..e680ab7 100644
--- a/kernel/inc/mm.h
+++ b/kernel/inc/mm.h
@@ -10,6 +10,8 @@
  * Physical
  */
 
+u32 physical_alloc(u32 n);
+
 /**
  * Virtual
  */
@@ -63,6 +65,10 @@ struct page_dir {
 	union page_dir_entry entries[PAGE_COUNT];
 } PACKED;
 
+u32 virtual_to_physical(struct page_dir *dir, u32 vaddr);
+void virtual_map(struct page_dir *dir, u32 vaddr, u32 paddr, u32 n, u8 user);
+struct memory_range virtual_alloc(struct page_dir *dir, struct memory_range physical_range,
+				  u32 flags);
 void paging_install(struct mem_info *mem_info);
 
 /**
@@ -79,9 +85,14 @@ struct memory_range {
 	u32 size;
 };
 
+struct memory_range memory_range_from_address(u32 base, u32 size);
+struct memory_range memory_range_around_address(u32 base, u32 size);
+
 struct page_dir *memory_dir_create(void);
 void memory_dir_switch(struct page_dir *dir);
-void memory_alloc(struct page_dir *dir, u32 size, u32 flags, u32 *out);
+// TODO: Remove these wrappers completely?
+/* void memory_alloc(struct page_dir *dir, u32 size, u32 flags, u32 *out); */
+/* void memory_map(struct page_dir *dir, struct memory_range range, u32 flags); */
 struct page_dir *memory_kernel_dir(void);
 
 #endif
-- 
cgit v1.2.3


From f1751c121d48f2d8936c72bdc347777d1e7402d9 Mon Sep 17 00:00:00 2001
From: Marvin Borner
Date: Fri, 12 Mar 2021 16:07:45 +0100
Subject: Let's gooo!

---
 apps/init.c                 |  2 ++
 kernel/drivers/interrupts.c |  4 ++--
 kernel/features/load.c      | 37 +++++++++++++++++--------------------
 kernel/features/mm.c        | 39 ++++++++++++++++++++++-----------------
 kernel/features/proc.c      | 20 +++++++++++---------
 kernel/inc/mm.h             |  2 ++
 kernel/main.c               |  4 +++-
 libc/alloc.c                | 12 ++++++++++++
 libc/inc/def.h              |  1 +
 libc/inc/print.h            |  3 ++-
 libc/print.c                |  2 +-
 libc/sanitize.c             |  4 ++--
 12 files changed, 77 insertions(+), 53 deletions(-)

(limited to 'kernel/features/load.c')

diff --git a/apps/init.c b/apps/init.c
index 87f0d82..7044365 100644
--- a/apps/init.c
+++ b/apps/init.c
@@ -8,6 +8,8 @@
 
 int main(int argc, char **argv)
 {
+	while (1) {
+	};
 	(void)argc;
 	log("%s loaded\n", argv[0]);
 
diff --git a/kernel/drivers/interrupts.c b/kernel/drivers/interrupts.c
index 55926b7..a0cd106 100644
--- a/kernel/drivers/interrupts.c
+++ b/kernel/drivers/interrupts.c
@@ -171,9 +171,9 @@ void isr_uninstall_handler(int isr)
 
 void isr_panic(struct regs *r)
 {
+	printf("%s Exception (%x) at 0x%x (ring %d), exiting!\n", isr_exceptions[r->int_no],
+	       r->err_code, r->eip, r->cs & 3);
 	struct proc *proc = proc_current();
-	printf("%s Exception (%x) at 0x%x, exiting!\n", isr_exceptions[r->int_no], r->err_code,
-	       r->eip);
 	if (proc) {
 		printf("\t-> Exception occurred in %s at addr 0x%x\n", proc->name,
 		       r->eip - proc->entry);
diff --git a/kernel/features/load.c b/kernel/features/load.c
index 31e22dc..ec9a387 100644
--- a/kernel/features/load.c
+++ b/kernel/features/load.c
@@ -6,45 +6,42 @@
 #include <mm.h>
 #include <str.h>
 
-// TODO: Fix pdi < 256!
-#define PROC_DATA_ADDR 0xc000000
-
 #define PROC_STACK_SIZE 0x4000
-#define PROC_STACK_ADDR (PROC_DATA_ADDR - 256)
 
-void proc_load(struct proc *proc, u32 entry)
+/*void proc_load(struct proc *proc, u32 entry)
 {
-	/* memory_dir_switch(proc->page_dir); */
-	u32 paddr = physical_alloc(PROC_STACK_SIZE);
-	virtual_map(proc->page_dir, PROC_STACK_ADDR, paddr, PROC_STACK_SIZE,
-		    MEMORY_USER | MEMORY_CLEAR);
+	u32 stack = (u32)memory_alloc(proc->page_dir, PROC_STACK_SIZE, MEMORY_USER | MEMORY_CLEAR);
 
-	proc->regs.ebp = PROC_STACK_ADDR;
-	proc->regs.useresp = PROC_STACK_ADDR;
+	proc->regs.ebp = stack;
+	proc->regs.useresp = stack;
 	proc->regs.eip = entry;
 	proc->entry = entry;
-}
+}*/
 
 int bin_load(const char *path, struct proc *proc)
 {
 	struct stat s = { 0 };
 	vfs_stat(path, &s);
 	struct proc *current = proc_current();
-	struct page_dir *prev = current ? current->page_dir : memory_kernel_dir();
+	struct page_dir *prev = current ? current->page_dir : virtual_kernel_dir();
 
 	u32 size = PAGE_ALIGN_UP(s.size);
-	memory_dir_switch(proc->page_dir);
-	u32 paddr = physical_alloc(size);
-	virtual_map(proc->page_dir, PROC_DATA_ADDR, paddr, size, MEMORY_USER | MEMORY_CLEAR);
+	memory_switch_dir(proc->page_dir);
+	u32 data = (u32)memory_alloc(proc->page_dir, size, MEMORY_USER | MEMORY_CLEAR);
 
-	if (!vfs_read(path, (void *)PROC_DATA_ADDR, 0, s.size)) {
-		memory_dir_switch(prev);
+	if (!vfs_read(path, (void *)data, 0, s.size)) {
+		memory_switch_dir(prev);
 		return 1;
 	}
 
 	strcpy(proc->name, path);
-	proc_load(proc, PROC_DATA_ADDR);
 
-	memory_dir_switch(prev);
+	u32 stack = (u32)memory_alloc(proc->page_dir, PROC_STACK_SIZE, MEMORY_USER | MEMORY_CLEAR);
+	proc->regs.ebp = stack;
+	proc->regs.useresp = stack;
+	proc->regs.eip = data;
+	proc->entry = data;
+
+	memory_switch_dir(prev);
 	return 0;
 }
diff --git a/kernel/features/mm.c b/kernel/features/mm.c
index cde9a94..c39b8b7 100644
--- a/kernel/features/mm.c
+++ b/kernel/features/mm.c
@@ -6,7 +6,6 @@
 #include <def.h>
 #include <mem.h>
 #include <mm.h>
-
 #include <print.h>
 
 static struct page_dir kernel_dir ALIGNED(PAGE_SIZE) = { 0 };
@@ -138,7 +137,7 @@ static u8 physical_is_used(struct memory_range range)
 	return 0;
 }
 
-static struct memory_range physical_alloc(u32 size)
+struct memory_range physical_alloc(u32 size)
 {
 	assert(PAGE_ALIGNED(size));
 
@@ -165,34 +164,34 @@ static void physical_free(struct memory_range range)
  * Virtual
  */
 
-#define PDI(vaddr) ((vaddr) >> 22)
+#define PDI(vaddr) (((vaddr) >> 22) & 0x03ff)
 #define PTI(vaddr) (((vaddr) >> 12) & 0x03ff)
 
 u8 virtual_present(struct page_dir *dir, u32 vaddr)
 {
 	u32 pdi = PDI(vaddr);
-	u32 pti = PTI(vaddr);
-
 	union page_dir_entry *dir_entry = &dir->entries[pdi];
 	if (!dir_entry->bits.present)
 		return 0;
 
 	struct page_table *table = (struct page_table *)(dir_entry->bits.address * PAGE_SIZE);
+
+	u32 pti = PTI(vaddr);
 	union page_table_entry *table_entry = &table->entries[pti];
 
-	return !table_entry->bits.present;
+	return table_entry->bits.present;
 }
 
 u32 virtual_to_physical(struct page_dir *dir, u32 vaddr)
 {
 	u32 pdi = PDI(vaddr);
-	u32 pti = PTI(vaddr);
-
 	union page_dir_entry *dir_entry = &dir->entries[pdi];
 	if (!dir_entry->bits.present)
 		return 0;
 
 	struct page_table *table = (struct page_table *)(dir_entry->bits.address * PAGE_SIZE);
+
+	u32 pti = PTI(vaddr);
 	union page_table_entry *table_entry = &table->entries[pti];
 	if (!table_entry->bits.present)
 		return 0;
@@ -204,9 +203,8 @@ void virtual_map(struct page_dir *dir, struct memory_range prange, u32 vaddr, u3
 {
 	for (u32 i = 0; i < prange.size / PAGE_SIZE; i++) {
 		u32 offset = i * PAGE_SIZE;
-		u32 pdi = PDI(vaddr + offset);
-		u32 pti = PTI(vaddr + offset);
 
+		u32 pdi = PDI(vaddr + offset);
 		union page_dir_entry *dir_entry = &dir->entries[pdi];
 		struct page_table *table =
 			(struct page_table *)(dir_entry->bits.address * PAGE_SIZE);
@@ -219,6 +217,7 @@ void virtual_map(struct page_dir *dir, struct memory_range prange, u32 vaddr, u3
 			dir_entry->bits.address = (u32)(table) >> 12;
 		}
 
+		u32 pti = PTI(vaddr + offset);
 		union page_table_entry *table_entry = &table->entries[pti];
 		table_entry->bits.present = 1;
 		table_entry->bits.writable = 1;
@@ -263,14 +262,14 @@ void virtual_free(struct page_dir *dir, struct memory_range vrange)
 		u32 offset = i * PAGE_SIZE;
 
 		u32 pdi = PDI(vrange.base + offset);
-		u32 pti = PTI(vrange.base + offset);
-
 		union page_dir_entry *dir_entry = &dir->entries[pdi];
 		if (!dir_entry->bits.present)
 			continue;
 
 		struct page_table *table =
 			(struct page_table *)(dir_entry->bits.address * PAGE_SIZE);
+
+		u32 pti = PTI(vrange.base + offset);
 		union page_table_entry *table_entry = &table->entries[pti];
 
 		if (table_entry->bits.present)
@@ -284,12 +283,14 @@ struct page_dir *virtual_create_dir(void)
 {
 	struct page_dir *dir = memory_alloc(&kernel_dir, sizeof(*dir), MEMORY_CLEAR);
 
+	memset(dir, 0, sizeof(*dir));
+
 	for (u32 i = 0; i < 256; i++) {
 		union page_dir_entry *dir_entry = &dir->entries[i];
 
-		dir_entry->bits.user = 0;
-		dir_entry->bits.writable = 1;
 		dir_entry->bits.present = 1;
+		dir_entry->bits.writable = 1;
+		dir_entry->bits.user = 0;
 		dir_entry->bits.address = (u32)&kernel_tables[i] / PAGE_SIZE;
 	}
 
@@ -334,22 +335,26 @@ void *memory_alloc(struct page_dir *dir, u32 size, u32 flags)
 	assert(PAGE_ALIGNED(size));
 
 	if (!size)
-		return 0;
+		goto err;
 
 	struct memory_range prange = physical_alloc(size);
 	if (prange.size == 0)
-		return 0;
+		goto err;
 
 	u32 vaddr = virtual_alloc(dir, prange, flags).base;
 	if (!vaddr) {
 		physical_free(prange);
-		return 0;
+		goto err;
 	}
 
 	if (flags & MEMORY_CLEAR)
 		memset((void *)vaddr, 0, size);
 
 	return (void *)vaddr;
+
+err:
+	print("Memory allocation error!\n");
+	return 0;
 }
 
 void *memory_alloc_identity(struct page_dir *dir, u32 flags)
diff --git a/kernel/features/proc.c b/kernel/features/proc.c
index 19a92d3..4d1311e 100644
--- a/kernel/features/proc.c
+++ b/kernel/features/proc.c
@@ -57,7 +57,7 @@ void scheduler(struct regs *regs)
 		}
 	}
 
-	memory_dir_switch(((struct proc *)current->data)->page_dir);
+	memory_switch_dir(((struct proc *)current->data)->page_dir);
 	memcpy(regs, &((struct proc *)current->data)->regs, sizeof(struct regs));
 
 	if (regs->cs != GDT_USER_CODE_OFFSET) {
@@ -248,9 +248,9 @@ struct proc *proc_make(enum proc_priv priv)
 	proc->state = PROC_RUNNING;
 
 	if (priv == PROC_PRIV_KERNEL)
-		proc->page_dir = memory_kernel_dir();
+		proc->page_dir = virtual_kernel_dir();
 	else
-		proc->page_dir = memory_dir_create();
+		proc->page_dir = virtual_create_dir();
 
 	if (current)
 		list_add(proc_list, proc);
@@ -472,11 +472,11 @@ void proc_init(void)
 	vfs_mount(dev, "/proc/");
 
 	// Idle proc
-	struct proc *kernel_proc = proc_make(PROC_PRIV_NONE);
-	proc_load(kernel_proc, (u32)kernel_idle);
-	strcpy(kernel_proc->name, "idle");
-	kernel_proc->state = PROC_SLEEPING;
-	idle_proc = list_add(proc_list, kernel_proc);
+	/* struct proc *kernel_proc = proc_make(PROC_PRIV_NONE); */
+	/* proc_load(kernel_proc, (u32)kernel_idle); */
+	/* strcpy(kernel_proc->name, "idle"); */
+	/* kernel_proc->state = PROC_SLEEPING; */
+	/* idle_proc = list_add(proc_list, kernel_proc); */
 
 	// Init proc (root)
 	struct node *new = list_add(proc_list, proc_make(PROC_PRIV_ROOT));
@@ -496,7 +496,9 @@ void proc_init(void)
 	/* ((u32 *)_esp)[-1] = (u32)argv; // Second argument (argv) */
 
 	printf("Jumping to userspace!\n");
-	memory_dir_switch(((struct proc *)new->data)->page_dir);
+	/* printf("%x\n", ((u32 *)((struct proc *)new->data)->entry)[5]); */
+	memory_switch_dir(((struct proc *)new->data)->page_dir);
+	/* printf("%x\n", ((u32 *)((struct proc *)new->data)->entry)[5]); */
 	proc_jump_userspace();
 	while (1) {
 	};
diff --git a/kernel/inc/mm.h b/kernel/inc/mm.h
index 6d3714d..aad4ffd 100644
--- a/kernel/inc/mm.h
+++ b/kernel/inc/mm.h
@@ -15,6 +15,8 @@ struct memory_range {
  * Physical
  */
 
+struct memory_range physical_alloc(u32 size);
+
 /**
  * Virtual
  */
diff --git a/kernel/main.c b/kernel/main.c
index f0bfc3c..8247672 100644
--- a/kernel/main.c
+++ b/kernel/main.c
@@ -17,6 +17,8 @@
 #include <syscall.h>
 #include <timer.h>
 
+#include <print.h>
+
 struct vid_info *boot_passed;
 
 void kernel_main(struct mem_info *mem_info, struct vid_info *vid_info); // Decl
@@ -31,7 +33,7 @@ void kernel_main(struct mem_info *mem_info, struct vid_info *vid_info)
 	serial_print("\nKernel was compiled at " __TIME__ " on " __DATE__ "\n");
 	serial_print("Serial connected.\n");
 
-	paging_install(mem_info);
+	memory_install(mem_info);
 
 	boot_passed = vid_info;
 
diff --git a/libc/alloc.c b/libc/alloc.c
index 11639a6..f621c4e 100644
--- a/libc/alloc.c
+++ b/libc/alloc.c
@@ -303,6 +303,9 @@ static void _free(void *ptr)
 
 void *zalloc(u32 size)
 {
+#ifdef userspace
+	panic("AAH!\n");
+#endif
 	void *ret = malloc(size);
 	memset(ret, 0, size);
 	return ret;
@@ -311,6 +314,9 @@ void *zalloc(u32 size)
 // Naive realloc implementation - TODO!
 void *realloc(void *ptr, u32 size)
 {
+#ifdef userspace
+	panic("AAH!\n");
+#endif
 	if (!ptr)
 		return malloc(size);
 
@@ -330,6 +336,9 @@ void *realloc(void *ptr, u32 size)
 
 void *malloc_debug(u32 size, const char *file, int line, const char *func, const char *inp)
 {
+#ifdef userspace
+	panic("AAH!\n");
+#endif
 	assert(size < (100 << 20)); // Don't brag with memory pls
 	void *ret = _malloc(size);
 
@@ -343,6 +352,9 @@ void *malloc_debug(u32 size, const char *file, int line, const char *func, const
 
 void free_debug(void *ptr, const char *file, int line, const char *func, const char *inp)
 {
+#ifdef userspace
+	panic("AAH!\n");
+#endif
 	if (ptr)
 		_free(ptr);
 
diff --git a/libc/inc/def.h b/libc/inc/def.h
index 945ccb0..db1c95e 100644
--- a/libc/inc/def.h
+++ b/libc/inc/def.h
@@ -25,6 +25,7 @@ typedef unsigned long long u64;
 
 #define UNUSED(a) ((void)(a))
 
+#define NORETURN __attribute__((noreturn))
 #define NO_SANITIZE __attribute__((no_sanitize("undefined")))
 #define PACKED __attribute__((packed))
 #define ALIGNED(align) __attribute__((aligned(align)))
diff --git a/libc/inc/print.h b/libc/inc/print.h
index 110ba4c..58b5dc6 100644
--- a/libc/inc/print.h
+++ b/libc/inc/print.h
@@ -4,13 +4,14 @@
 #define PRINT_H
 
 #include "arg.h"
+#include <def.h>
 
 int printf(const char *format, ...);
 int vprintf(const char *format, va_list ap);
 int sprintf(char *str, const char *format, ...);
 int vsprintf(char *str, const char *format, va_list ap);
 int print(const char *str);
-void panic(const char *format, ...);
+NORETURN void panic(const char *format, ...);
 
 #ifdef userspace
 int vfprintf(const char *path, const char *format, va_list ap);
diff --git a/libc/print.c b/libc/print.c
index ca2ab98..173e117 100644
--- a/libc/print.c
+++ b/libc/print.c
@@ -230,7 +230,7 @@ void print_trace(u32 count)
 
 #endif
 
-void panic(const char *format, ...)
+NORETURN void panic(const char *format, ...)
 {
 	char buf[1024] = { 0 };
 	va_list ap;
diff --git a/libc/sanitize.c b/libc/sanitize.c
index 8cfec49..8514e49 100644
--- a/libc/sanitize.c
+++ b/libc/sanitize.c
@@ -13,13 +13,13 @@
 u32 __stack_chk_guard = STACK_CHK_GUARD;
 
 void __stack_chk_fail(void);
-void __stack_chk_fail(void)
+NORETURN void __stack_chk_fail(void)
 {
 	panic("FATAL: Stack smashing detected\n");
 }
 
 void __stack_chk_fail_local(void);
-void __stack_chk_fail_local(void)
+NORETURN void __stack_chk_fail_local(void)
 {
 	panic("FATAL: Local stack smashing detected\n");
 }
-- 
cgit v1.2.3


From 0aef683b9d1e08555791426ba12223ed78051353 Mon Sep 17 00:00:00 2001
From: Marvin Borner
Date: Fri, 12 Mar 2021 17:27:01 +0100
Subject: Boots successfully...

---
 Makefile               |  2 +-
 apps/Makefile          |  2 +-
 apps/idle.c            |  7 +++++++
 apps/init.c            |  1 +
 kernel/features/load.c | 17 ++++-------------
 kernel/features/mm.c   | 24 +++++++++++++++---------
 kernel/features/proc.c | 19 +++++--------------
 kernel/inc/load.h      |  1 -
 kernel/inc/mm.h        |  9 ++++++++-
 libc/cpu.c             |  7 +++++++
 libc/inc/cpu.h         |  1 +
 libc/print.c           |  1 +
 12 files changed, 51 insertions(+), 40 deletions(-)
 create mode 100644 apps/idle.c

(limited to 'kernel/features/load.c')

diff --git a/Makefile b/Makefile
index a9817cd..1e20a7a 100644
--- a/Makefile
+++ b/Makefile
@@ -6,7 +6,7 @@ CFLAGS_DEFAULT = $(CFLAGS_WARNINGS) $(CFLAGS_OPTIMIZATION) -std=c99 -m32 -nostdl
 
 all: compile
 
-debug: CFLAGS_DEFAULT += -Wno-error -ggdb3 -s -fstack-protector-all -fsanitize=undefined
+debug: CFLAGS_DEFAULT += -Wno-error -ggdb3 -s -fsanitize=undefined # -fstack-protector-all # TODO: Fix stack protector in userspace
 debug: compile
 
 export
diff --git a/apps/Makefile b/apps/Makefile
index 8426b9c..2c6c643 100644
--- a/apps/Makefile
+++ b/apps/Makefile
@@ -1,6 +1,6 @@
 # MIT License, Copyright (c) 2020 Marvin Borner
 
-COBJS = init.o wm.o test.o window.o #mandelbrot.o window.o exec.o files.o test.o cc.o browser.o server.o
+COBJS = init.o idle.o wm.o test.o window.o #mandelbrot.o window.o exec.o files.o test.o cc.o browser.o server.o
 CC = ccache ../cross/opt/bin/i686-elf-gcc
 LD = ccache ../cross/opt/bin/i686-elf-ld
 OC = ccache ../cross/opt/bin/i686-elf-objcopy
diff --git a/apps/idle.c b/apps/idle.c
new file mode 100644
index 0000000..3f10c3e
--- /dev/null
+++ b/apps/idle.c
@@ -0,0 +1,7 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+int main(void)
+{
+	while (1)
+		;
+}
diff --git a/apps/init.c b/apps/init.c
index 7044365..9e57078 100644
--- a/apps/init.c
+++ b/apps/init.c
@@ -8,6 +8,7 @@
 
 int main(int argc, char **argv)
 {
+	log("Loaded!\n");
 	while (1) {
 	};
 	(void)argc;
diff --git a/kernel/features/load.c b/kernel/features/load.c
index ec9a387..4ad2cbf 100644
--- a/kernel/features/load.c
+++ b/kernel/features/load.c
@@ -8,25 +8,16 @@
 
 #define PROC_STACK_SIZE 0x4000
 
-/*void proc_load(struct proc *proc, u32 entry)
-{
-	u32 stack = (u32)memory_alloc(proc->page_dir, PROC_STACK_SIZE, MEMORY_USER | MEMORY_CLEAR);
-
-	proc->regs.ebp = stack;
-	proc->regs.useresp = stack;
-	proc->regs.eip = entry;
-	proc->entry = entry;
-}*/
-
 int bin_load(const char *path, struct proc *proc)
 {
 	struct stat s = { 0 };
 	vfs_stat(path, &s);
-	struct proc *current = proc_current();
-	struct page_dir *prev = current ? current->page_dir : virtual_kernel_dir();
 
-	u32 size = PAGE_ALIGN_UP(s.size);
+	struct page_dir *prev;
+	memory_backup_dir(&prev);
 	memory_switch_dir(proc->page_dir);
+
+	u32 size = PAGE_ALIGN_UP(s.size);
 	u32 data = (u32)memory_alloc(proc->page_dir, size, MEMORY_USER | MEMORY_CLEAR);
 
 	if (!vfs_read(path, (void *)data, 0, s.size)) {
diff --git a/kernel/features/mm.c b/kernel/features/mm.c
index c39b8b7..5fe70fd 100644
--- a/kernel/features/mm.c
+++ b/kernel/features/mm.c
@@ -15,10 +15,10 @@ static struct page_table kernel_tables[256] ALIGNED(PAGE_SIZE) = { 0 };
  * Lowlevel paging
  */
 
-static void paging_disable(void)
+/*static void paging_disable(void)
 {
 	cr0_set(cr0_get() | 0x7fffffff);
-}
+}*/
 
 static void paging_enable(void)
 {
@@ -27,7 +27,6 @@ static void paging_enable(void)
 
 static void paging_switch_dir(u32 dir)
 {
-	assert(dir);
 	cr3_set(dir);
 }
 
@@ -154,7 +153,7 @@ struct memory_range physical_alloc(u32 size)
 	return memory_range(0, 0);
 }
 
-static void physical_free(struct memory_range range)
+void physical_free(struct memory_range range)
 {
 	assert(PAGE_ALIGNED(range.base) && PAGE_ALIGNED(range.size));
 	physical_set_free(range);
@@ -297,11 +296,6 @@ struct page_dir *virtual_create_dir(void)
 	return dir;
 }
 
-struct page_dir *virtual_kernel_dir(void)
-{
-	return &kernel_dir;
-}
-
 void virtual_destroy_dir(struct page_dir *dir)
 {
 	assert(dir != &kernel_dir);
@@ -326,6 +320,11 @@ void virtual_destroy_dir(struct page_dir *dir)
 	memory_free(&kernel_dir, memory_range((u32)dir, sizeof(*dir)));
 }
 
+struct page_dir *virtual_kernel_dir(void)
+{
+	return &kernel_dir;
+}
+
 /**
  * Memory wrappers
  */
@@ -405,6 +404,13 @@ void memory_switch_dir(struct page_dir *dir)
 	paging_switch_dir(virtual_to_physical(&kernel_dir, (u32)dir));
 }
 
+void memory_backup_dir(struct page_dir **backup)
+{
+	struct proc *proc = proc_current();
+	struct page_dir *dir = proc ? proc->page_dir : virtual_kernel_dir();
+	*backup = dir;
+}
+
 struct memory_range memory_range_from(u32 base, u32 size)
 {
 	u32 align = PAGE_SIZE - base % PAGE_SIZE;
diff --git a/kernel/features/proc.c b/kernel/features/proc.c
index 4d1311e..db2291c 100644
--- a/kernel/features/proc.c
+++ b/kernel/features/proc.c
@@ -76,12 +76,6 @@ void scheduler(struct regs *regs)
 	/* printf("{%d}", ((struct proc *)current->data)->pid); */
 }
 
-static void kernel_idle(void)
-{
-	while (1)
-		;
-}
-
 void proc_print(void)
 {
 	struct node *node = proc_list->head;
@@ -328,7 +322,7 @@ static s32 procfs_write(const char *path, void *buf, u32 offset, u32 count, stru
 		}
 	}
 
-	printf("%s - off: %d, cnt: %d, buf: %x, dev %x\n", path, offset, count, buf, dev);
+	printf("ERR: %s - off: %d, cnt: %d, buf: %x, dev %x\n", path, offset, count, buf, dev);
 	return -1;
 }
 
@@ -472,11 +466,10 @@ void proc_init(void)
 	vfs_mount(dev, "/proc/");
 
 	// Idle proc
-	/* struct proc *kernel_proc = proc_make(PROC_PRIV_NONE); */
-	/* proc_load(kernel_proc, (u32)kernel_idle); */
-	/* strcpy(kernel_proc->name, "idle"); */
-	/* kernel_proc->state = PROC_SLEEPING; */
-	/* idle_proc = list_add(proc_list, kernel_proc); */
+	struct proc *kernel_proc = proc_make(PROC_PRIV_NONE);
+	bin_load("/bin/idle", kernel_proc);
+	kernel_proc->state = PROC_SLEEPING;
+	idle_proc = list_add(proc_list, kernel_proc);
 
 	// Init proc (root)
 	struct node *new = list_add(proc_list, proc_make(PROC_PRIV_ROOT));
@@ -496,9 +489,7 @@ void proc_init(void)
 	/* ((u32 *)_esp)[-1] = (u32)argv; // Second argument (argv) */
 
 	printf("Jumping to userspace!\n");
-	/* printf("%x\n", ((u32 *)((struct proc *)new->data)->entry)[5]); */
 	memory_switch_dir(((struct proc *)new->data)->page_dir);
-	/* printf("%x\n", ((u32 *)((struct proc *)new->data)->entry)[5]); */
 	proc_jump_userspace();
 	while (1) {
 	};
diff --git a/kernel/inc/load.h b/kernel/inc/load.h
index 330caca..f493e84 100644
--- a/kernel/inc/load.h
+++ b/kernel/inc/load.h
@@ -5,7 +5,6 @@
 
 #include <proc.h>
 
-void proc_load(struct proc *proc, u32 entry);
 int bin_load(const char *path, struct proc *proc);
 
 #endif
diff --git a/kernel/inc/mm.h b/kernel/inc/mm.h
index aad4ffd..6a1c063 100644
--- a/kernel/inc/mm.h
+++ b/kernel/inc/mm.h
@@ -16,6 +16,7 @@ struct memory_range {
  */
 
 struct memory_range physical_alloc(u32 size);
+void physical_free(struct memory_range range);
 
 /**
  * Virtual
@@ -70,11 +71,14 @@ struct page_dir {
 	union page_dir_entry entries[PAGE_COUNT];
 } PACKED;
 
+u8 virtual_present(struct page_dir *dir, u32 vaddr);
 u32 virtual_to_physical(struct page_dir *dir, u32 vaddr);
 void virtual_map(struct page_dir *dir, struct memory_range prange, u32 vaddr, u32 flags);
 struct memory_range virtual_alloc(struct page_dir *dir, struct memory_range physical_range,
 				  u32 flags);
+void virtual_free(struct page_dir *dir, struct memory_range vrange);
 struct page_dir *virtual_create_dir(void);
+void virtual_destroy_dir(struct page_dir *dir);
 struct page_dir *virtual_kernel_dir(void);
 
 /**
@@ -89,10 +93,13 @@ struct page_dir *virtual_kernel_dir(void);
 struct memory_range memory_range_from(u32 base, u32 size);
 struct memory_range memory_range_around(u32 base, u32 size);
 
-void memory_install(struct mem_info *mem_info);
 void *memory_alloc(struct page_dir *dir, u32 size, u32 flags);
 void *memory_alloc_identity(struct page_dir *dir, u32 flags);
+void memory_map_identity(struct page_dir *dir, struct memory_range prange, u32 flags);
 void memory_free(struct page_dir *dir, struct memory_range vrange);
 void memory_switch_dir(struct page_dir *dir);
+void memory_backup_dir(struct page_dir **backup);
+
+void memory_install(struct mem_info *mem_info);
 
 #endif
diff --git a/libc/cpu.c b/libc/cpu.c
index cb9aa49..8ca4d27 100644
--- a/libc/cpu.c
+++ b/libc/cpu.c
@@ -82,6 +82,13 @@ void cr0_set(u32 cr0)
 	__asm__ volatile("movl %%eax, %%cr0" ::"a"(cr0));
 }
 
+u32 cr3_get(void)
+{
+	u32 cr3;
+	__asm__ volatile("movl %%cr0, %%eax" : "=a"(cr3));
+	return cr3;
+}
+
 void cr3_set(u32 cr3)
 {
 	__asm__ volatile("movl %%eax, %%cr3" ::"a"(cr3));
diff --git a/libc/inc/cpu.h b/libc/inc/cpu.h
index 161b7a4..d709d86 100644
--- a/libc/inc/cpu.h
+++ b/libc/inc/cpu.h
@@ -29,6 +29,7 @@ void fpu_restore(void);
 
 u32 cr0_get(void);
 void cr0_set(u32 cr0);
+u32 cr3_get(void);
 void cr3_set(u32 cr3);
 u32 cr4_get(void);
 void cr4_set(u32 cr4);
diff --git a/libc/print.c b/libc/print.c
index 173e117..1c577e5 100644
--- a/libc/print.c
+++ b/libc/print.c
@@ -238,6 +238,7 @@ NORETURN void panic(const char *format, ...)
 	vsprintf(buf, format, ap);
 	va_end(ap);
 #ifdef kernel
+	print("--- DON'T PANIC! ---\n");
 	print(buf);
 	loop();
 #else
-- 
cgit v1.2.3


From 8176351e1a3d1598bedbc007897d530475942275 Mon Sep 17 00:00:00 2001
From: Marvin Borner
Date: Sat, 13 Mar 2021 13:33:26 +0100
Subject: Nicü

---
 Makefile                  |  4 +++-
 apps/init.c               |  6 ++----
 apps/wm.c                 |  8 +++++---
 kernel/drivers/fb.c       | 23 +++++++++++++++++++++--
 kernel/features/fs.c      |  6 ++++--
 kernel/features/load.c    |  6 +++---
 kernel/features/mm.c      | 11 ++++++-----
 kernel/features/proc.c    | 32 +++++++++++++++++++-------------
 kernel/features/syscall.c | 12 ++----------
 kernel/inc/mm.h           |  2 +-
 kernel/inc/proc.h         |  1 +
 kernel/main.c             |  2 +-
 libc/alloc.c              |  4 +++-
 13 files changed, 71 insertions(+), 46 deletions(-)

(limited to 'kernel/features/load.c')

diff --git a/Makefile b/Makefile
index 1e20a7a..fa1954c 100644
--- a/Makefile
+++ b/Makefile
@@ -6,7 +6,9 @@ CFLAGS_DEFAULT = $(CFLAGS_WARNINGS) $(CFLAGS_OPTIMIZATION) -std=c99 -m32 -nostdl
 
 all: compile
 
-debug: CFLAGS_DEFAULT += -Wno-error -ggdb3 -s -fsanitize=undefined # -fstack-protector-all # TODO: Fix stack protector in userspace
+# TODO: Fix stack protector in userspace
+# TODO: Fix ubsan in userspace (probably due to kernel size)
+debug: CFLAGS_DEFAULT += -Wno-error -ggdb3 -s #-fsanitize=undefined # -fstack-protector-all
 debug: compile
 
 export
diff --git a/apps/init.c b/apps/init.c
index 705f178..f854a81 100644
--- a/apps/init.c
+++ b/apps/init.c
@@ -10,11 +10,9 @@ int main(int argc, char **argv)
 {
 	UNUSED(argc);
 	UNUSED(argv);
-	while (1) {
-	};
 
 	int wm = exec("/bin/wm", "wm", NULL);
-	int test = exec("/bin/window", "test", NULL);
+	/* int test = exec("/bin/window", "test", NULL); */
 
-	return wm + test;
+	return wm; //+ test;
 }
diff --git a/apps/wm.c b/apps/wm.c
index becbf0a..8eb6f70 100644
--- a/apps/wm.c
+++ b/apps/wm.c
@@ -5,6 +5,7 @@
 #include <gfx.h>
 #include <gui.h>
 #include <input.h>
+#include <ioctl.h>
 #include <keymap.h>
 #include <list.h>
 #include <random.h>
@@ -361,11 +362,12 @@ static void handle_message(struct message *msg)
 
 int main(int argc, char **argv)
 {
-	(void)argc;
-	screen = *(struct vbe *)argv[1];
+	UNUSED(argc);
+	UNUSED(argv);
+	assert(ioctl("/dev/fb", IO_FB_GET, &screen) == 0);
+	log("WM loaded: %dx%d\n", screen.width, screen.height);
 	wm_client = (struct client){ .pid = getpid() };
 	bypp = (screen.bpp >> 3);
-	log("WM loaded: %dx%d\n", screen.width, screen.height);
 
 	windows = list_new();
 	keymap = keymap_parse("/res/keymaps/en.keymap");
diff --git a/kernel/drivers/fb.c b/kernel/drivers/fb.c
index a1a7729..8e73f5b 100644
--- a/kernel/drivers/fb.c
+++ b/kernel/drivers/fb.c
@@ -1,13 +1,25 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
+#include <assert.h>
 #include <def.h>
 #include <fb.h>
 #include <fs.h>
 #include <ioctl.h>
 #include <mem.h>
+#include <mm.h>
 #include <str.h>
 #include <sys.h>
 
+struct vbe_basic {
+	u8 stuff1[16];
+	u16 pitch;
+	u16 width;
+	u16 height;
+	u8 stuff2[18];
+	u8 *fb;
+	u8 stuff3[212];
+};
+
 static u32 dev_id = 0;
 static struct vid_info *info = NULL;
 
@@ -18,9 +30,16 @@ static s32 fb_ioctl(u32 request, void *arg1, void *arg2, void *arg3, struct devi
 	UNUSED(dev);
 
 	switch (request) {
-	case IO_FB_GET:
-		memcpy(arg1, info->vbe, 256);
+	case IO_FB_GET: {
+		if (!info)
+			return -1;
+		struct vbe_basic *vbe = (struct vbe_basic *)info->vbe;
+		memcpy(arg1, info->vbe, sizeof(struct vbe_basic));
+		u32 size = vbe->height * vbe->pitch;
+		memory_map_identity(proc_current()->page_dir,
+				    memory_range_around((u32)vbe->fb, size), MEMORY_USER);
 		return 0;
+	}
 	default:
 		return -1;
 	}
diff --git a/kernel/features/fs.c b/kernel/features/fs.c
index 4d19dde..20d00e5 100644
--- a/kernel/features/fs.c
+++ b/kernel/features/fs.c
@@ -62,13 +62,15 @@ static struct mount_info *vfs_recursive_find(char *path)
 
 static struct mount_info *vfs_find_mount_info(const char *path)
 {
-	assert(path[0] == '/');
+	if (path[0] != '/')
+		return NULL;
 	return vfs_recursive_find(strdup(path));
 }
 
 struct device *vfs_find_dev(const char *path)
 {
-	assert(path[0] == '/');
+	if (path[0] != '/')
+		return NULL;
 	struct mount_info *m = vfs_find_mount_info(path);
 	if (m->dev->vfs->type == VFS_DEVFS) // TODO: ?
 		return device_get_by_name(path + strlen(m->path) + 1);
diff --git a/kernel/features/load.c b/kernel/features/load.c
index 4ad2cbf..9e6db79 100644
--- a/kernel/features/load.c
+++ b/kernel/features/load.c
@@ -13,6 +13,8 @@ int bin_load(const char *path, struct proc *proc)
 	struct stat s = { 0 };
 	vfs_stat(path, &s);
 
+	strcpy(proc->name, path);
+
 	struct page_dir *prev;
 	memory_backup_dir(&prev);
 	memory_switch_dir(proc->page_dir);
@@ -20,13 +22,11 @@ int bin_load(const char *path, struct proc *proc)
 	u32 size = PAGE_ALIGN_UP(s.size);
 	u32 data = (u32)memory_alloc(proc->page_dir, size, MEMORY_USER | MEMORY_CLEAR);
 
-	if (!vfs_read(path, (void *)data, 0, s.size)) {
+	if (!vfs_read(proc->name, (void *)data, 0, s.size)) {
 		memory_switch_dir(prev);
 		return 1;
 	}
 
-	strcpy(proc->name, path);
-
 	u32 stack = (u32)memory_alloc(proc->page_dir, PROC_STACK_SIZE, MEMORY_USER | MEMORY_CLEAR);
 	proc->regs.ebp = stack;
 	proc->regs.useresp = stack;
diff --git a/kernel/features/mm.c b/kernel/features/mm.c
index b5fd33c..bd32683 100644
--- a/kernel/features/mm.c
+++ b/kernel/features/mm.c
@@ -35,9 +35,9 @@ extern void paging_invalidate_tlb(void);
 static void page_fault(struct regs *r)
 {
 	// Check error code
-	const char *type = (r->err_code & 4) ? "present" : "non-present";
+	const char *type = (r->err_code & 1) ? "present" : "non-present";
 	const char *operation = (r->err_code & 2) ? "write" : "read";
-	const char *super = (r->err_code & 1) ? "User" : "Super";
+	const char *super = (r->err_code & 4) ? "User" : "Super";
 
 	// Check cr2 address
 	u32 vaddr;
@@ -446,7 +446,7 @@ static struct memory_range kernel_memory_range(void)
 	return memory_range_around((u32)&kernel_start, (u32)&kernel_end - (u32)&kernel_start);
 }
 
-void memory_install(struct mem_info *mem_info)
+void memory_install(struct mem_info *mem_info, struct vid_info *vid_info)
 {
 	for (struct mmap_boot *p = mem_info->start; (u32)(p - mem_info->start) < mem_info->size;
 	     p++) {
@@ -484,8 +484,9 @@ void memory_install(struct mem_info *mem_info)
 	memory_map_identity(&kernel_dir, memory_range_around(STACK_START - STACK_SIZE, STACK_SIZE),
 			    MEMORY_NONE);
 
-	// TODO: Triple fault prevention? Probably bootloader stuff or something
-	memory_map_identity(&kernel_dir, memory_range_around(0x7000, 0x1000), MEMORY_NONE);
+	// Map VBE data
+	memory_map_identity(&kernel_dir, memory_range_around((u32)vid_info->vbe, 0x1000),
+			    MEMORY_NONE);
 
 	// Unmap NULL byte/page
 	struct memory_range zero = memory_range(0, PAGE_SIZE);
diff --git a/kernel/features/proc.c b/kernel/features/proc.c
index e7ddf4b..6bbe894 100644
--- a/kernel/features/proc.c
+++ b/kernel/features/proc.c
@@ -157,6 +157,9 @@ void proc_yield(struct regs *r)
 
 void proc_enable_waiting(u32 id, enum proc_wait_type type)
 {
+	struct page_dir *dir_bak;
+	memory_backup_dir(&dir_bak);
+
 	struct proc *proc_bak = proc_current();
 	if (!proc_bak)
 		return;
@@ -179,8 +182,11 @@ void proc_enable_waiting(u32 id, enum proc_wait_type type)
 				struct regs *r = &p->regs;
 				u32 (*func)(u32, u32, u32, u32) =
 					(u32(*)(u32, u32, u32, u32))w->ids[i].func_ptr;
-				if (w->ids[i].func_ptr)
+				if (w->ids[i].func_ptr) {
+					memory_switch_dir(p->page_dir);
 					r->eax = func(r->ebx, r->ecx, r->edx, r->esi);
+					memory_switch_dir(dir_bak);
+				}
 				memset(&w->ids[i], 0, sizeof(w->ids[i]));
 				p->wait.id_cnt--;
 				p->state = PROC_RUNNING;
@@ -252,6 +258,18 @@ struct proc *proc_make(enum proc_priv priv)
 	return proc;
 }
 
+void proc_stack_push(struct proc *proc, u32 data)
+{
+	struct page_dir *prev;
+	memory_backup_dir(&prev);
+	memory_switch_dir(proc->page_dir);
+
+	proc->regs.useresp -= sizeof(data);
+	*(u32 *)proc->regs.useresp = data;
+
+	memory_switch_dir(prev);
+}
+
 // TODO: Procfs needs a simpler interface structure (memcmp and everything sucks)
 
 static const char *procfs_parse_path(const char **path, u32 *pid)
@@ -437,18 +455,6 @@ static u8 procfs_ready(const char *path, struct device *dev)
 	return 1;
 }
 
-static void proc_stack_push(struct proc *proc, u32 data)
-{
-	struct page_dir *prev;
-	memory_backup_dir(&prev);
-	memory_switch_dir(proc->page_dir);
-
-	proc->regs.useresp -= sizeof(data);
-	*(u32 *)proc->regs.useresp = data;
-
-	memory_switch_dir(prev);
-}
-
 extern void proc_jump_userspace(void);
 
 u32 _esp, _eip;
diff --git a/kernel/features/syscall.c b/kernel/features/syscall.c
index 31cdf5f..dc49d67 100644
--- a/kernel/features/syscall.c
+++ b/kernel/features/syscall.c
@@ -71,22 +71,14 @@ static void syscall_handler(struct regs *r)
 		char *path = (char *)r->ebx;
 		struct proc *proc = proc_make(PROC_PRIV_NONE);
 		r->eax = (u32)bin_load(path, proc);
-		u32 argc = 3; // TODO: Add argc evaluator
-		char **argv = malloc(sizeof(*argv) * (argc + 1));
-		argv[0] = (char *)r->ecx;
-		argv[1] = (char *)r->edx;
-		argv[2] = (char *)r->esi;
-		argv[3] = (char *)r->edi;
-		argv[4] = NULL;
-		((u32 *)proc->regs.useresp)[0] = argc;
-		((u32 *)proc->regs.useresp)[1] = (u32)argv;
+		// TODO: Reimplement argc,argv
+		proc_stack_push(proc, 0);
 		if (r->eax)
 			proc_exit(proc, (int)r->eax);
 		proc_yield(r);
 		break;
 	}
 	case SYS_EXIT: {
-		print("EXIT!\n");
 		proc_exit(proc_current(), (int)r->ebx);
 		break;
 	}
diff --git a/kernel/inc/mm.h b/kernel/inc/mm.h
index 6a1c063..590875c 100644
--- a/kernel/inc/mm.h
+++ b/kernel/inc/mm.h
@@ -100,6 +100,6 @@ void memory_free(struct page_dir *dir, struct memory_range vrange);
 void memory_switch_dir(struct page_dir *dir);
 void memory_backup_dir(struct page_dir **backup);
 
-void memory_install(struct mem_info *mem_info);
+void memory_install(struct mem_info *mem_info, struct vid_info *vid_info);
 
 #endif
diff --git a/kernel/inc/proc.h b/kernel/inc/proc.h
index de4eb84..a44fd68 100644
--- a/kernel/inc/proc.h
+++ b/kernel/inc/proc.h
@@ -70,5 +70,6 @@ void proc_clear_quantum(void);
 void proc_enable_waiting(u32 id, enum proc_wait_type type);
 void proc_wait_for(u32 id, enum proc_wait_type type, u32 func_ptr);
 struct proc *proc_make(enum proc_priv priv);
+void proc_stack_push(struct proc *proc, u32 data);
 
 #endif
diff --git a/kernel/main.c b/kernel/main.c
index 118fe11..3b75c7d 100644
--- a/kernel/main.c
+++ b/kernel/main.c
@@ -30,7 +30,7 @@ void kernel_main(struct mem_info *mem_info, struct vid_info *vid_info)
 	serial_print("\nKernel was compiled at " __TIME__ " on " __DATE__ "\n");
 	serial_print("Serial connected.\n");
 
-	memory_install(mem_info);
+	memory_install(mem_info, vid_info);
 
 	cpu_enable_features();
 	cpu_print();
diff --git a/libc/alloc.c b/libc/alloc.c
index 083f2c0..4ccf35f 100644
--- a/libc/alloc.c
+++ b/libc/alloc.c
@@ -139,7 +139,7 @@ static void *_malloc(u32 req_size)
 		l_mem_root = allocate_new_page(size);
 		if (l_mem_root == NULL) {
 			liballoc_unlock();
-			return NULL;
+			panic("Malloc failed!\n");
 		}
 	}
 
@@ -295,6 +295,7 @@ static void *_malloc(u32 req_size)
 
 	liballoc_unlock();
 
+	panic("Malloc failed!\n");
 	return NULL;
 }
 
@@ -361,6 +362,7 @@ static void *_realloc(void *ptr, u32 size)
 
 	if (min->magic != LIBALLOC_MAGIC) {
 		liballoc_unlock();
+		panic("Malloc failed!\n");
 		return NULL;
 	}
 
-- 
cgit v1.2.3