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 ++
 1 file changed, 2 insertions(+)

(limited to 'apps/init.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]);
 
-- 
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 'apps/init.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 bbf700a0c6b2f8ca9a73c2a334973286d5b8afcc Mon Sep 17 00:00:00 2001
From: Marvin Borner
Date: Fri, 12 Mar 2021 19:11:26 +0100
Subject: Started basic ioctl fb interface

---
 apps/init.c               |  6 ++----
 kernel/Makefile           |  1 +
 kernel/drivers/fb.c       | 45 +++++++++++++++++++++++++++++++++++++++++++++
 kernel/features/fs.c      | 46 +++++++++++++++++++++++++++++++++++++++++-----
 kernel/features/proc.c    |  9 ---------
 kernel/features/syscall.c |  5 +++++
 kernel/inc/boot.h         |  1 -
 kernel/inc/fb.h           | 10 ++++++++++
 kernel/inc/fs.h           |  4 ++++
 kernel/main.c             |  8 ++------
 libc/inc/ioctl.h          | 11 +++++++++++
 libc/inc/sys.h            |  2 ++
 12 files changed, 123 insertions(+), 25 deletions(-)
 create mode 100644 kernel/drivers/fb.c
 create mode 100644 kernel/inc/fb.h
 create mode 100644 libc/inc/ioctl.h

(limited to 'apps/init.c')

diff --git a/apps/init.c b/apps/init.c
index 9e57078..6503022 100644
--- a/apps/init.c
+++ b/apps/init.c
@@ -8,13 +8,11 @@
 
 int main(int argc, char **argv)
 {
-	log("Loaded!\n");
+	log("%s loaded\n", argv[0]);
 	while (1) {
 	};
-	(void)argc;
-	log("%s loaded\n", argv[0]);
 
-	int wm = exec("/bin/wm", "wm", argv[1], NULL);
+	int wm = exec("/bin/wm", "wm", NULL);
 	int test = exec("/bin/window", "test", NULL);
 
 	return wm + test;
diff --git a/kernel/Makefile b/kernel/Makefile
index 2db201b..e9ade73 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -8,6 +8,7 @@ COBJS = main.o \
 	drivers/mouse.o \
 	drivers/pci.o \
 	drivers/ide.o \
+	drivers/fb.o \
 	drivers/timer.o \
 	drivers/rtl8139.o \
 	features/mm.o \
diff --git a/kernel/drivers/fb.c b/kernel/drivers/fb.c
new file mode 100644
index 0000000..a1a7729
--- /dev/null
+++ b/kernel/drivers/fb.c
@@ -0,0 +1,45 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#include <def.h>
+#include <fb.h>
+#include <fs.h>
+#include <ioctl.h>
+#include <mem.h>
+#include <str.h>
+#include <sys.h>
+
+static u32 dev_id = 0;
+static struct vid_info *info = NULL;
+
+static s32 fb_ioctl(u32 request, void *arg1, void *arg2, void *arg3, struct device *dev)
+{
+	UNUSED(arg2);
+	UNUSED(arg3);
+	UNUSED(dev);
+
+	switch (request) {
+	case IO_FB_GET:
+		memcpy(arg1, info->vbe, 256);
+		return 0;
+	default:
+		return -1;
+	}
+}
+
+static u8 fb_ready(void)
+{
+	return 1;
+}
+
+void fb_install(struct vid_info *boot)
+{
+	info = boot;
+
+	struct device *dev = zalloc(sizeof(*dev));
+	dev->name = strdup("fb");
+	dev->type = DEV_CHAR;
+	dev->ioctl = fb_ioctl;
+	dev->ready = fb_ready;
+	device_add(dev);
+	dev_id = dev->id;
+}
diff --git a/kernel/features/fs.c b/kernel/features/fs.c
index 687d7ad..4d19dde 100644
--- a/kernel/features/fs.c
+++ b/kernel/features/fs.c
@@ -131,7 +131,8 @@ s32 vfs_read(const char *path, void *buf, u32 offset, u32 count)
 		path++;
 
 	struct mount_info *m = vfs_find_mount_info(path);
-	assert(m && m->dev && m->dev->vfs && m->dev->vfs->read && m->dev->vfs->perm);
+	if (!(m && m->dev && m->dev->vfs && m->dev->vfs->read && m->dev->vfs->perm))
+		return -1;
 
 	u32 len = strlen(m->path);
 	if (len > 1)
@@ -156,7 +157,8 @@ s32 vfs_write(const char *path, void *buf, u32 offset, u32 count)
 		path++;
 
 	struct mount_info *m = vfs_find_mount_info(path);
-	assert(m && m->dev && m->dev->vfs && m->dev->vfs->write && m->dev->vfs->perm);
+	if (!(m && m->dev && m->dev->vfs && m->dev->vfs->write && m->dev->vfs->perm))
+		return -1;
 
 	u32 len = strlen(m->path);
 	if (len > 1)
@@ -168,6 +170,25 @@ s32 vfs_write(const char *path, void *buf, u32 offset, u32 count)
 	return m->dev->vfs->write(path, buf, offset, count, m->dev);
 }
 
+s32 vfs_ioctl(const char *path, u32 request, void *arg1, void *arg2, void *arg3)
+{
+	while (*path == ' ')
+		path++;
+
+	struct mount_info *m = vfs_find_mount_info(path);
+	if (!(m && m->dev && m->dev->vfs && m->dev->vfs->ioctl && m->dev->vfs->perm))
+		return -1;
+
+	u32 len = strlen(m->path);
+	if (len > 1)
+		path += len;
+
+	if (!m->dev->vfs->perm(path, VFS_WRITE, m->dev) && !proc_super())
+		return -1;
+
+	return m->dev->vfs->ioctl(path, request, arg1, arg2, arg3, m->dev);
+}
+
 s32 vfs_stat(const char *path, struct stat *buf)
 {
 	while (*path == ' ')
@@ -177,12 +198,16 @@ s32 vfs_stat(const char *path, struct stat *buf)
 		return -1;
 
 	struct mount_info *m = vfs_find_mount_info(path);
-	assert(m && m->dev && m->dev->vfs && m->dev->vfs->stat);
+	if (!(m && m->dev && m->dev->vfs && m->dev->vfs->stat && m->dev->vfs->perm))
+		return -1;
 
 	u32 len = strlen(m->path);
 	if (len > 1)
 		path += len;
 
+	if (!m->dev->vfs->perm(path, VFS_WRITE, m->dev) && !proc_super())
+		return -1;
+
 	return m->dev->vfs->stat(path, buf, m->dev);
 }
 
@@ -192,7 +217,8 @@ s32 vfs_wait(const char *path, u32 func_ptr)
 		path++;
 
 	struct mount_info *m = vfs_find_mount_info(path);
-	assert(m && m->dev && m->dev->vfs);
+	if (!(m && m->dev && m->dev->vfs))
+		return -1;
 
 	// Default wait
 	if (!m->dev->vfs->wait) {
@@ -280,10 +306,19 @@ static s32 devfs_read(const char *path, void *buf, u32 offset, u32 count, struct
 {
 	struct device *target = device_get_by_name(path + 1);
 	if (!target || !target->read)
-		return 0;
+		return -1;
 	return target->read(buf, offset, count, dev);
 }
 
+static s32 devfs_ioctl(const char *path, u32 request, void *arg1, void *arg2, void *arg3,
+		       struct device *dev)
+{
+	struct device *target = device_get_by_name(path + 1);
+	if (!target || !target->ioctl)
+		return -1;
+	return target->ioctl(request, arg1, arg2, arg3, dev);
+}
+
 static u8 devfs_perm(const char *path, enum vfs_perm perm, struct device *dev)
 {
 	(void)path;
@@ -309,6 +344,7 @@ void device_install(void)
 	struct vfs *vfs = zalloc(sizeof(*vfs));
 	vfs->type = VFS_DEVFS;
 	vfs->read = devfs_read;
+	vfs->ioctl = devfs_ioctl;
 	vfs->perm = devfs_perm;
 	vfs->ready = devfs_ready;
 	struct device *dev = zalloc(sizeof(*dev));
diff --git a/kernel/features/proc.c b/kernel/features/proc.c
index db2291c..38d88f8 100644
--- a/kernel/features/proc.c
+++ b/kernel/features/proc.c
@@ -479,15 +479,6 @@ void proc_init(void)
 	_eip = ((struct proc *)new->data)->regs.eip;
 	_esp = ((struct proc *)new->data)->regs.useresp;
 
-	/* u32 argc = 2; */
-	/* char **argv = malloc(sizeof(*argv) * (argc + 1)); */
-	/* argv[0] = strdup("init"); */
-	/* argv[1] = (char *)boot_passed->vbe; */
-	/* argv[2] = NULL; */
-
-	/* ((u32 *)_esp)[0] = argc; // First argument (argc) */
-	/* ((u32 *)_esp)[-1] = (u32)argv; // Second argument (argv) */
-
 	printf("Jumping to userspace!\n");
 	memory_switch_dir(((struct proc *)new->data)->page_dir);
 	proc_jump_userspace();
diff --git a/kernel/features/syscall.c b/kernel/features/syscall.c
index b3e69e0..bac1738 100644
--- a/kernel/features/syscall.c
+++ b/kernel/features/syscall.c
@@ -52,6 +52,11 @@ static void syscall_handler(struct regs *r)
 		r->eax = (u32)vfs_write((char *)r->ebx, (void *)r->ecx, r->edx, r->esi);
 		break;
 	}
+	case SYS_IOCTL: {
+		r->eax = (u32)vfs_ioctl((char *)r->ebx, r->ecx, (void *)r->edx, (void *)r->esi,
+					(void *)r->edi);
+		break;
+	}
 	case SYS_POLL: {
 		s32 ret = vfs_poll((const char **)r->ebx);
 		if (ret == PROC_MAX_WAIT_IDS + 1)
diff --git a/kernel/inc/boot.h b/kernel/inc/boot.h
index 052a56f..7f085cd 100644
--- a/kernel/inc/boot.h
+++ b/kernel/inc/boot.h
@@ -6,7 +6,6 @@
 
 #include <def.h>
 
-extern struct vid_info *boot_passed;
 struct vid_info {
 	u32 mode;
 	u32 *vbe;
diff --git a/kernel/inc/fb.h b/kernel/inc/fb.h
new file mode 100644
index 0000000..3e7b08f
--- /dev/null
+++ b/kernel/inc/fb.h
@@ -0,0 +1,10 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#ifndef FB
+#define FB
+
+#include <boot.h>
+
+void fb_install(struct vid_info *boot);
+
+#endif
diff --git a/kernel/inc/fs.h b/kernel/inc/fs.h
index 33b1afb..cd97b99 100644
--- a/kernel/inc/fs.h
+++ b/kernel/inc/fs.h
@@ -20,6 +20,7 @@ struct device {
 	void *data;
 	s32 (*read)(void *buf, u32 offset, u32 count, struct device *dev);
 	s32 (*write)(void *buf, u32 offset, u32 count, struct device *dev);
+	s32 (*ioctl)(u32 request, void *arg1, void *arg2, void *arg3, struct device *dev);
 	u8 (*ready)(void);
 };
 
@@ -40,6 +41,8 @@ struct vfs {
 	void *data;
 	s32 (*read)(const char *path, void *buf, u32 offset, u32 count, struct device *dev);
 	s32 (*write)(const char *path, void *buf, u32 offset, u32 count, struct device *dev);
+	s32 (*ioctl)(const char *path, u32 request, void *arg1, void *arg2, void *arg3,
+		     struct device *dev);
 	s32 (*stat)(const char *path, struct stat *buf, struct device *dev);
 	s32 (*wait)(const char *path, u32 func_ptr, struct device *dev);
 	u8 (*perm)(const char *path, enum vfs_perm perm, struct device *dev);
@@ -60,6 +63,7 @@ struct device *vfs_find_dev(const char *path);
 
 s32 vfs_read(const char *path, void *buf, u32 offset, u32 count);
 s32 vfs_write(const char *path, void *buf, u32 offset, u32 count);
+s32 vfs_ioctl(const char *path, u32 request, void *arg1, void *arg2, void *arg3);
 s32 vfs_stat(const char *path, struct stat *buf);
 s32 vfs_wait(const char *path, u32 func_ptr);
 s32 vfs_poll(const char **files);
diff --git a/kernel/main.c b/kernel/main.c
index 8247672..118fe11 100644
--- a/kernel/main.c
+++ b/kernel/main.c
@@ -2,6 +2,7 @@
 
 #include <boot.h>
 #include <cpu.h>
+#include <fb.h>
 #include <fs.h>
 #include <ide.h>
 #include <interrupts.h>
@@ -17,10 +18,6 @@
 #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
 void kernel_main(struct mem_info *mem_info, struct vid_info *vid_info)
 {
@@ -35,8 +32,6 @@ void kernel_main(struct mem_info *mem_info, struct vid_info *vid_info)
 
 	memory_install(mem_info);
 
-	boot_passed = vid_info;
-
 	cpu_enable_features();
 	cpu_print();
 	srand(rdseed());
@@ -50,6 +45,7 @@ void kernel_main(struct mem_info *mem_info, struct vid_info *vid_info)
 	timer_install();
 	keyboard_install();
 	mouse_install();
+	fb_install(vid_info);
 	/* net_install(); */
 
 	// Enable drivers
diff --git a/libc/inc/ioctl.h b/libc/inc/ioctl.h
new file mode 100644
index 0000000..c3eec56
--- /dev/null
+++ b/libc/inc/ioctl.h
@@ -0,0 +1,11 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#ifndef IOCTL
+#define IOCTL
+
+// FB interface
+#define IO_FB_GET 0
+
+int ioctl_is_awesome; // GCC is not
+
+#endif
diff --git a/libc/inc/sys.h b/libc/inc/sys.h
index 5858579..c20eabc 100644
--- a/libc/inc/sys.h
+++ b/libc/inc/sys.h
@@ -16,6 +16,7 @@ enum sys {
 	SYS_STAT, // Get file information
 	SYS_READ, // Read file
 	SYS_WRITE, // Write to file
+	SYS_IOCTL, // Interact with a file/device
 	SYS_POLL, // Wait for multiple files
 	SYS_EXEC, // Execute path
 	SYS_EXIT, // Exit current process // TODO: Free all memory of process
@@ -70,6 +71,7 @@ int sysv(enum sys num, ...);
 	(s32) sys4(SYS_READ, (int)(path), (int)(buf), (int)(offset), (int)(count))
 #define write(path, buf, offset, count)                                                            \
 	(s32) sys4(SYS_WRITE, (int)(path), (int)(buf), (int)(offset), (int)(count))
+#define ioctl(path, ...) (s32) sysv(SYS_IOCTL, (int)(path), ##__VA_ARGS__)
 #define stat(path, stat) (s32) sys2(SYS_STAT, (int)(path), (int)(stat))
 #define poll(files) (s32) sys1(SYS_POLL, (int)(files))
 #define exec(path, ...) (s32) sysv(SYS_EXEC, (int)(path), ##__VA_ARGS__)
-- 
cgit v1.2.3


From e8f17844d05fdc0e44d3793dc73996c7c09e44d6 Mon Sep 17 00:00:00 2001
From: Marvin Borner
Date: Fri, 12 Mar 2021 23:56:42 +0100
Subject: New memory allocation algorithms

---
 README.md                 |   4 +-
 apps/init.c               |   3 +-
 kernel/features/mm.c      |   6 -
 kernel/features/proc.c    |   1 +
 kernel/features/syscall.c |   8 +-
 libc/alloc.c              | 573 +++++++++++++++++++++++++---------------------
 libc/inc/mem.h            |   3 -
 libc/inc/sys.h            |   2 +-
 8 files changed, 327 insertions(+), 273 deletions(-)

(limited to 'apps/init.c')

diff --git a/README.md b/README.md
index 4a320c4..745555b 100644
--- a/README.md
+++ b/README.md
@@ -84,14 +84,14 @@ This project is somewhat of a coding playground for me. It doesn't have any usef
 
 Melvix is released under the MIT License and uses parts of the following 3rd party projects:
 
-Inspiration/usage:
+Inspiration/usage (documented in the respective files):
 
 -   [OSDev wiki](https://wiki.osdev.org) - Very helpful!
 -   [James Molloy's tutorials](http://jamesmolloy.co.uk/tutorial_html/)
 -   [virtix - tasking inspiration](https://github.com/16Bitt/virtix/) - [MIT License](https://github.com/16Bitt/virtix/blob/85a3c58f3d3b8932354e85a996a79c377139c201/LICENSE)
 -   [studix - FS inspiration](https://github.com/orodley/studix) - [MIT License](https://github.com/orodley/studix/blob/d1b1d006010120551df58ff3faaf97484dfa9806/LICENSE)
+-   [skiftOS - Memory management inspiration](https://github.com/skiftOS/skift) - [MIT License](https://github.com/skiftOS/skift/blob/ea0e1cf0d7b07302370fc1519be2e072a4cad70c/license.md)
 -   [ToAruOS - PCI and network driver inspiration](https://github.com/klange/toaruos) - [NCSA License](https://github.com/klange/toaruos/blob/351d5d38f22b570459931475d36468bf4e37f45a/LICENSE)
--   [SHMALL - Heap allocator inspiration](https://github.com/CCareaga/heap_allocator) - [MIT License](https://github.com/CCareaga/heap_allocator/blob/fc423c6113df598ac8d10bc1f2954d51248e6443/LICENSE)
 
 Resources:
 
diff --git a/apps/init.c b/apps/init.c
index 6503022..705f178 100644
--- a/apps/init.c
+++ b/apps/init.c
@@ -8,7 +8,8 @@
 
 int main(int argc, char **argv)
 {
-	log("%s loaded\n", argv[0]);
+	UNUSED(argc);
+	UNUSED(argv);
 	while (1) {
 	};
 
diff --git a/kernel/features/mm.c b/kernel/features/mm.c
index 5fe70fd..b5fd33c 100644
--- a/kernel/features/mm.c
+++ b/kernel/features/mm.c
@@ -448,8 +448,6 @@ static struct memory_range kernel_memory_range(void)
 
 void memory_install(struct mem_info *mem_info)
 {
-	heap_init(HEAP_START);
-
 	for (struct mmap_boot *p = mem_info->start; (u32)(p - mem_info->start) < mem_info->size;
 	     p++) {
 		if (p->hbase || !p->acpi || !p->type)
@@ -486,10 +484,6 @@ void memory_install(struct mem_info *mem_info)
 	memory_map_identity(&kernel_dir, memory_range_around(STACK_START - STACK_SIZE, STACK_SIZE),
 			    MEMORY_NONE);
 
-	// Map kernel heap
-	memory_map_identity(&kernel_dir, memory_range_around(HEAP_START, HEAP_INIT_SIZE),
-			    MEMORY_NONE);
-
 	// TODO: Triple fault prevention? Probably bootloader stuff or something
 	memory_map_identity(&kernel_dir, memory_range_around(0x7000, 0x1000), MEMORY_NONE);
 
diff --git a/kernel/features/proc.c b/kernel/features/proc.c
index e4b5105..e7ddf4b 100644
--- a/kernel/features/proc.c
+++ b/kernel/features/proc.c
@@ -487,6 +487,7 @@ void proc_init(void)
 	struct node *new = list_add(proc_list, proc_make(PROC_PRIV_ROOT));
 	bin_load("/bin/init", new->data);
 	current = new;
+	proc_stack_push(new->data, 0);
 
 	_eip = ((struct proc *)new->data)->regs.eip;
 	_esp = ((struct proc *)new->data)->regs.useresp;
diff --git a/kernel/features/syscall.c b/kernel/features/syscall.c
index bac1738..486da6c 100644
--- a/kernel/features/syscall.c
+++ b/kernel/features/syscall.c
@@ -5,6 +5,7 @@
 #include <interrupts.h>
 #include <load.h>
 #include <mem.h>
+#include <mm.h>
 #include <net.h>
 #include <print.h>
 #include <proc.h>
@@ -25,12 +26,13 @@ static void syscall_handler(struct regs *r)
 		loop();
 		break;
 	}
-	case SYS_MALLOC: {
-		r->eax = (u32)malloc(r->ebx);
+	case SYS_ALLOC: {
+		r->eax = (u32)memory_alloc(proc_current()->page_dir, r->ebx,
+					   MEMORY_CLEAR | MEMORY_USER);
 		break;
 	}
 	case SYS_FREE: {
-		free((void *)r->ebx);
+		memory_free(proc_current()->page_dir, memory_range(r->ebx, r->ecx));
 		break;
 	}
 	case SYS_STAT: {
diff --git a/libc/alloc.c b/libc/alloc.c
index f621c4e..083f2c0 100644
--- a/libc/alloc.c
+++ b/libc/alloc.c
@@ -1,297 +1,383 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
+// Mostly by Durand Miller, released into public domain
 
 #include <assert.h>
-#include <def.h>
+#include <cpu.h>
 #include <mem.h>
-#include <print.h>
-#include <sys.h>
-
-/**
- * Kernel heap allocator
- * Inspired by SHMALL (MIT License)
- * Copyright (c) 2017 Chris Careaga
- * Copyright (c) 2021 Marvin Borner
- */
 
 #ifdef kernel
 
-#define HEAP_MAGIC 0x424242
-#define HEAP_MIN_SIZE HEAP_INIT_SIZE
-#define MIN_ALLOC_SZ 4
-#define BIN_COUNT 9
-#define BIN_MAX_IDX (BIN_COUNT - 1)
-#define OVERHEAD (sizeof(struct h_footer) + sizeof(struct h_node))
-/* #define MIN_WILDERNESS 0x2000 */
-/* #define MAX_WILDERNESS 0x1000000 */
-
-struct h_node {
-	u32 magic;
-	u32 hole;
-	u32 size;
-	struct h_node *next;
-	struct h_node *prev;
-};
-
-struct h_footer {
-	struct h_node *header;
-};
+#include <mm.h>
 
-struct h_bin {
-	struct h_node *head;
-};
-
-struct heap {
-	u32 start;
-	u32 end;
-	struct h_bin bins[BIN_COUNT];
-};
-
-static void node_add(struct h_bin *bin, struct h_node *node)
+static void *liballoc_alloc(u32 p)
 {
-	node->magic = HEAP_MAGIC;
-	node->next = NULL;
-	node->prev = NULL;
-	if (!bin->head) {
-		bin->head = node;
-		return;
-	}
-	struct h_node *curr = bin->head;
-	struct h_node *prev = NULL;
-	while (curr && curr->size <= node->size) {
-		prev = curr;
-		curr = curr->next;
-	}
-	if (!curr) {
-		prev->next = node;
-		node->prev = prev;
-	} else if (prev) {
-		node->next = curr;
-		prev->next = node;
-		node->prev = prev;
-		curr->prev = node;
-	} else {
-		node->next = bin->head;
-		bin->head->prev = node;
-		bin->head = node;
-	}
+	return memory_alloc(virtual_kernel_dir(), p, MEMORY_CLEAR);
 }
 
-static void node_remove(struct h_bin *bin, struct h_node *node)
+static int liballoc_free(void *ptr, u32 p)
 {
-	if (!bin->head)
-		return;
-	if (bin->head == node) {
-		bin->head = bin->head->next;
-		return;
-	}
-
-	struct h_node *temp = bin->head->next;
-	while (temp) {
-		if (temp == node) {
-			if (!temp->next) {
-				temp->prev->next = NULL;
-			} else {
-				temp->prev->next = temp->next;
-				temp->next->prev = temp->prev;
-			}
-			return;
-		}
-		temp = temp->next;
-	}
+	memory_free(virtual_kernel_dir(), memory_range((u32)ptr, (u32)p));
+	return 0;
 }
 
-static struct h_node *node_best_fit(struct h_bin *bin, u32 size)
-{
-	if (!bin->head)
-		return NULL;
+#else
 
-	struct h_node *temp = bin->head;
-	while (temp) {
-		if (temp->size >= size)
-			return temp;
-		temp = temp->next;
-	}
-	return NULL;
-}
+#include <sys.h>
 
-/* static struct h_node *node_last(struct h_bin *bin) */
-/* { */
-/* 	struct h_node *temp = bin->head; */
-/* 	while (temp->next) */
-/* 		temp = temp->next; */
-/* 	return temp; */
-/* } */
+#define sys_alloc(size) (void *)sys1(SYS_ALLOC, size)
+#define sys_free(ptr, size) (u32) sys2(SYS_FREE, ptr, size)
 
-static struct h_footer *node_foot(struct h_node *node)
+static void *liballoc_alloc(u32 p)
 {
-	return (struct h_footer *)((char *)node + sizeof(*node) + node->size);
+	return sys_alloc((u32)p);
 }
 
-static void node_create_foot(struct h_node *head)
+static int liballoc_free(void *ptr, u32 p)
 {
-	struct h_footer *foot = node_foot(head);
-	foot->header = head;
+	sys_free((u32)ptr, (u32)p);
+	return 0;
 }
 
-static u32 bin_index(u32 sz)
+#endif
+
+static int locked = 0;
+
+static int liballoc_lock(void)
 {
-	u32 index = 0;
-	sz = sz < 4 ? 4 : sz;
-	while (sz >>= 1)
-		index++;
-	index -= 2;
-	if (index > BIN_MAX_IDX)
-		index = BIN_MAX_IDX;
-	return index;
+	spinlock(&locked);
+	return 0;
 }
 
-/* struct h_node *wilderness_get(struct heap *heap) */
-/* { */
-/* 	struct h_footer *wild_foot = (struct h_footer *)((char *)heap->end - sizeof(*wild_foot)); */
-/* 	return wild_foot->header; */
-/* } */
-
-/* static u32 expand(struct heap *heap, u32 sz) */
-/* { */
-/* 	(void)heap; */
-/* 	(void)sz; */
-/* 	return 0; */
-/* } */
-
-/* static u32 contract(struct heap *heap, u32 sz) */
-/* { */
-/* 	(void)heap; */
-/* 	(void)sz; */
-/* 	return 0; */
-/* } */
-
-static struct heap heap = { 0 };
-void heap_init(u32 start)
+static int liballoc_unlock(void)
 {
-	struct h_node *init_region = (struct h_node *)start;
-	init_region->hole = 1;
-	init_region->size = HEAP_INIT_SIZE - OVERHEAD;
-	node_create_foot(init_region);
-	node_add(&heap.bins[bin_index(init_region->size)], init_region);
-	heap.start = (u32)start;
-	heap.end = (u32)start + HEAP_INIT_SIZE;
+	locked = 0;
+	return 0;
 }
 
-#define ALIGN sizeof(long)
-static void *_malloc(u32 size)
-{
-	size = ((size + ALIGN - 1) / ALIGN) * ALIGN; // Alignment
-	u32 index = bin_index(size);
-	struct h_bin *temp = (struct h_bin *)&heap.bins[index];
-	struct h_node *found = node_best_fit(temp, size);
+#define ALIGNMENT 16
+#define ALIGN_UP(__addr, __align) (((__addr) + (__align)-1) & ~((__align)-1))
+#define ALIGN_DOWN(__addr, __align) ((__addr) & ~((__align)-1))
+
+#define USE_CASE1
+#define USE_CASE2
+#define USE_CASE3
+#define USE_CASE4
+#define USE_CASE5
+#define LIBALLOC_MAGIC 0x900df00d
+#define LIBALLOC_DEAD 0xbaadf00d
+
+struct liballoc_major {
+	struct liballoc_major *prev;
+	struct liballoc_major *next;
+	u32 pages;
+	u32 size;
+	u32 usage;
+	struct liballoc_minor *first;
+};
 
-	while (!found) {
-		assert(index + 1 < BIN_COUNT);
+struct liballoc_minor {
+	struct liballoc_minor *prev;
+	struct liballoc_minor *next;
+	struct liballoc_major *block;
+	u32 magic;
+	u32 size;
+	u32 req_size;
+};
 
-		temp = &heap.bins[++index];
-		found = node_best_fit(temp, size);
-	}
+#define MAJOR_SIZE (ALIGN_UP(sizeof(struct liballoc_major), 16))
+#define MINOR_SIZE (ALIGN_UP(sizeof(struct liballoc_minor), 16))
+#define MIN(__x, __y) ((__x) < (__y) ? (__x) : (__y))
+#define MAX(__x, __y) ((__x) > (__y) ? (__x) : (__y))
 
-	assert(found->magic == HEAP_MAGIC);
+static struct liballoc_major *l_mem_root = NULL;
+static struct liballoc_major *l_best_bet = NULL;
 
-	if ((found->size - size) > (OVERHEAD + MIN_ALLOC_SZ)) {
-		struct h_node *split = (struct h_node *)(((char *)found + OVERHEAD) + size);
-		split->magic = HEAP_MAGIC;
-		split->size = found->size - size - OVERHEAD;
-		split->hole = 1;
+static u32 l_page_size = 4096;
+static u32 l_page_count = 16;
 
-		node_create_foot(split);
+static struct liballoc_major *allocate_new_page(u32 size)
+{
+	u32 st = size + MAJOR_SIZE + MINOR_SIZE;
 
-		u32 new_idx = bin_index(split->size);
+	if ((st % l_page_size) == 0)
+		st = st / (l_page_size);
+	else
+		st = st / (l_page_size) + 1;
 
-		node_add(&heap.bins[new_idx], split);
+	st = MAX(st, l_page_count);
 
-		found->size = size;
-		node_create_foot(found);
-	}
+	struct liballoc_major *maj = (struct liballoc_major *)liballoc_alloc(st * l_page_size);
 
-	found->hole = 0;
-	node_remove(&heap.bins[index], found);
+	if (maj == NULL)
+		return NULL;
 
-	// TODO: Implement expand/contract
-	/* struct h_node *wild = wilderness_get(&heap); */
-	/* if (wild->size < MIN_WILDERNESS) { */
-	/* 	assert(expand(&heap, 0x1000)); */
-	/* } else if (wild->size > MAX_WILDERNESS) { */
-	/* 	assert(contract(&heap, 0x1000)); */
-	/* } */
+	maj->prev = NULL;
+	maj->next = NULL;
+	maj->pages = st;
+	maj->size = st * l_page_size;
+	maj->usage = MAJOR_SIZE;
+	maj->first = NULL;
 
-	found->prev = NULL;
-	found->next = NULL;
-	return &found->next;
+	return maj;
 }
 
-static void _free(void *p)
+static void *_malloc(u32 req_size)
 {
-	if (!p)
-		return;
+	req_size = ALIGN_UP(req_size, 16);
 
-	struct h_bin *list;
-	struct h_footer *new_foot, *old_foot;
+	u32 best_size = 0;
+	u32 size = req_size;
 
-	struct h_node *head = (struct h_node *)((char *)p - 12);
-	assert(head->magic == HEAP_MAGIC && head->hole == 0);
-	if (head == (struct h_node *)(u32 *)heap.start) {
-		head->hole = 1;
-		node_add(&heap.bins[bin_index(head->size)], head);
-		return;
+	liballoc_lock();
+
+	if (size == 0) {
+		liballoc_unlock();
+		return malloc(1);
 	}
 
-	struct h_node *next = (struct h_node *)((char *)node_foot(head) + sizeof(struct h_footer));
-	struct h_footer *f = (struct h_footer *)((char *)head - sizeof(struct h_footer));
-	struct h_node *prev = f->header;
+	if (l_mem_root == NULL) {
+		l_mem_root = allocate_new_page(size);
+		if (l_mem_root == NULL) {
+			liballoc_unlock();
+			return NULL;
+		}
+	}
 
-	if (prev->hole) {
-		list = &heap.bins[bin_index(prev->size)];
-		node_remove(list, prev);
+	struct liballoc_major *maj = l_mem_root;
+	u8 started_bet = 0;
 
-		prev->size += OVERHEAD + head->size;
-		new_foot = node_foot(head);
-		new_foot->header = prev;
+	if (l_best_bet != NULL) {
+		best_size = l_best_bet->size - l_best_bet->usage;
 
-		head = prev;
+		if (best_size > (size + MINOR_SIZE)) {
+			maj = l_best_bet;
+			started_bet = 1;
+		}
 	}
 
-	if (next->hole) {
-		list = &heap.bins[bin_index(next->size)];
-		node_remove(list, next);
+	while (maj != NULL) {
+		u32 diff = maj->size - maj->usage;
+		if (best_size < diff) {
+			l_best_bet = maj;
+			best_size = diff;
+		}
 
-		head->size += OVERHEAD + next->size;
+#ifdef USE_CASE1
+		if (diff < (size + MINOR_SIZE)) {
+			if (maj->next != NULL) {
+				maj = maj->next;
+				continue;
+			}
 
-		old_foot = node_foot(next);
-		old_foot->header = 0;
-		next->size = 0;
-		next->hole = 0;
+			if (started_bet == 1) {
+				maj = l_mem_root;
+				started_bet = 0;
+				continue;
+			}
 
-		new_foot = node_foot(head);
-		new_foot->header = head;
-	}
+			maj->next = allocate_new_page(size);
+			if (maj->next == NULL)
+				break;
+			maj->next->prev = maj;
+			maj = maj->next;
+		}
+#endif
 
-	head->hole = 1;
-	node_add(&heap.bins[bin_index(head->size)], head);
-}
+#ifdef USE_CASE2
+		if (maj->first == NULL) {
+			maj->first = (struct liballoc_minor *)((u32)maj + MAJOR_SIZE);
+
+			maj->first->magic = LIBALLOC_MAGIC;
+			maj->first->prev = NULL;
+			maj->first->next = NULL;
+			maj->first->block = maj;
+			maj->first->size = size;
+			maj->first->req_size = req_size;
+			maj->usage += size + MINOR_SIZE;
+			void *p = (void *)((u32)(maj->first) + MINOR_SIZE);
+			liballoc_unlock();
+			return p;
+		}
+#endif
+
+#ifdef USE_CASE3
+		diff = (u32)(maj->first);
+		diff -= (u32)maj;
+		diff -= MAJOR_SIZE;
+
+		if (diff >= (size + MINOR_SIZE)) {
+			maj->first->prev = (struct liballoc_minor *)((u32)maj + MAJOR_SIZE);
+			maj->first->prev->next = maj->first;
+			maj->first = maj->first->prev;
+			maj->first->magic = LIBALLOC_MAGIC;
+			maj->first->prev = NULL;
+			maj->first->block = maj;
+			maj->first->size = size;
+			maj->first->req_size = req_size;
+			maj->usage += size + MINOR_SIZE;
+			void *p = (void *)((u32)(maj->first) + MINOR_SIZE);
+			liballoc_unlock();
+			return p;
+		}
+#endif
 
-#elif defined(userspace)
+#ifdef USE_CASE4
+		struct liballoc_minor *min = maj->first;
+
+		while (min != NULL) {
+			if (min->next == NULL) {
+				diff = (u32)(maj) + maj->size;
+				diff -= (u32)min;
+				diff -= MINOR_SIZE;
+				diff -= min->size;
+				if (diff >= (size + MINOR_SIZE)) {
+					min->next =
+						(struct liballoc_minor *)((u32)min + MINOR_SIZE +
+									  min->size);
+					min->next->prev = min;
+					min = min->next;
+					min->next = NULL;
+					min->magic = LIBALLOC_MAGIC;
+					min->block = maj;
+					min->size = size;
+					min->req_size = req_size;
+					maj->usage += size + MINOR_SIZE;
+					void *p = (void *)((u32)min + MINOR_SIZE);
+					liballoc_unlock();
+					return p;
+				}
+			}
 
-#define kmalloc(n) (void *)sys1(SYS_MALLOC, n)
-#define kfree(ptr) (void)(sys1(SYS_FREE, (int)ptr))
+			if (min->next != NULL) {
+				diff = (u32)(min->next);
+				diff -= (u32)min;
+				diff -= MINOR_SIZE;
+				diff -= min->size;
+
+				if (diff >= (size + MINOR_SIZE)) {
+					struct liballoc_minor *new_min =
+						(struct liballoc_minor *)((u32)min + MINOR_SIZE +
+									  min->size);
+					new_min->magic = LIBALLOC_MAGIC;
+					new_min->next = min->next;
+					new_min->prev = min;
+					new_min->size = size;
+					new_min->req_size = req_size;
+					new_min->block = maj;
+					min->next->prev = new_min;
+					min->next = new_min;
+					maj->usage += size + MINOR_SIZE;
+					void *p = (void *)((u32)new_min + MINOR_SIZE);
+					liballoc_unlock();
+					return p;
+				}
+			}
 
-static void *_malloc(u32 size)
-{
-	return kmalloc(size);
+			min = min->next;
+		}
+#endif
+
+#ifdef USE_CASE5
+		if (maj->next == NULL) {
+			if (started_bet == 1) {
+				maj = l_mem_root;
+				started_bet = 0;
+				continue;
+			}
+			maj->next = allocate_new_page(size);
+			if (maj->next == NULL)
+				break;
+			maj->next->prev = maj;
+		}
+#endif
+		maj = maj->next;
+	}
+
+	liballoc_unlock();
+
+	return NULL;
 }
 
 static void _free(void *ptr)
 {
-	kfree(ptr);
+	if (ptr == NULL) {
+		return;
+	}
+
+	liballoc_lock();
+
+	struct liballoc_minor *min = (struct liballoc_minor *)((u32)ptr - MINOR_SIZE);
+
+	if (min->magic != LIBALLOC_MAGIC) {
+		liballoc_unlock();
+		return;
+	}
+
+	struct liballoc_major *maj = min->block;
+	maj->usage -= (min->size + MINOR_SIZE);
+	min->magic = LIBALLOC_DEAD;
+
+	if (min->next != NULL)
+		min->next->prev = min->prev;
+	if (min->prev != NULL)
+		min->prev->next = min->next;
+	if (min->prev == NULL)
+		maj->first = min->next;
+	if (maj->first == NULL) {
+		if (l_mem_root == maj)
+			l_mem_root = maj->next;
+		if (l_best_bet == maj)
+			l_best_bet = NULL;
+		if (maj->prev != NULL)
+			maj->prev->next = maj->next;
+		if (maj->next != NULL)
+			maj->next->prev = maj->prev;
+		liballoc_free(maj, maj->pages * l_page_size);
+	} else {
+		if (l_best_bet != NULL) {
+			int best_size = l_best_bet->size - l_best_bet->usage;
+			int maj_size = maj->size - maj->usage;
+			if (maj_size > best_size)
+				l_best_bet = maj;
+		}
+	}
+	liballoc_unlock();
 }
 
-#endif
+static void *_realloc(void *ptr, u32 size)
+{
+	size = ALIGN_UP(size, 16);
+
+	if (size == 0) {
+		free(ptr);
+		return NULL;
+	}
+
+	if (ptr == NULL)
+		return malloc(size);
+
+	liballoc_lock();
+	struct liballoc_minor *min = (struct liballoc_minor *)((u32)ptr - MINOR_SIZE);
+
+	if (min->magic != LIBALLOC_MAGIC) {
+		liballoc_unlock();
+		return NULL;
+	}
+
+	if (min->size >= size) {
+		min->req_size = size;
+		liballoc_unlock();
+		return ptr;
+	}
+
+	liballoc_unlock();
+
+	void *new_ptr = malloc(size);
+	memcpy(new_ptr, ptr, min->req_size);
+	free(ptr);
+
+	return new_ptr;
+}
 
 #ifdef kernel
 #define PREFIX "K"
@@ -303,42 +389,18 @@ 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;
 }
 
-// Naive realloc implementation - TODO!
 void *realloc(void *ptr, u32 size)
 {
-#ifdef userspace
-	panic("AAH!\n");
-#endif
-	if (!ptr)
-		return malloc(size);
-
-	FUNC("Realloc not implemented!\n");
-	return NULL;
-	/* // This could work; untested
-	struct h_node *node = (struct h_node *)((char *)ptr - 12);
-	u32 old_size = node->size;
-
-	void *new = malloc(size);
-	memcpy(new, ptr, old_size);
-
-	free(ptr);
-	return new;
-	*/
+	return _realloc(ptr, 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);
 
@@ -352,9 +414,6 @@ 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/mem.h b/libc/inc/mem.h
index e93f4d2..ec00628 100644
--- a/libc/inc/mem.h
+++ b/libc/inc/mem.h
@@ -15,9 +15,6 @@ void *zalloc(u32 size);
 #ifdef kernel
 #define STACK_START 0x00500000 // Defined it bootloader
 #define STACK_SIZE 0x1000 // idk
-#define HEAP_START 0x00f00000
-#define HEAP_INIT_SIZE 0x0f00000
-void heap_init(u32 start);
 #elif defined(userspace)
 #else
 #error "No lib target specified. Please use -Dkernel or -Duserspace"
diff --git a/libc/inc/sys.h b/libc/inc/sys.h
index c20eabc..c100e6a 100644
--- a/libc/inc/sys.h
+++ b/libc/inc/sys.h
@@ -11,7 +11,7 @@
 
 enum sys {
 	SYS_LOOP, // To infinity and beyond (debug)!
-	SYS_MALLOC, // Allocate memory
+	SYS_ALLOC, // Allocate memory
 	SYS_FREE, // Free memory
 	SYS_STAT, // Get file information
 	SYS_READ, // Read file
-- 
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 'apps/init.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


From 6dec7db5158447b66f31a3f786ce2916cab83cec Mon Sep 17 00:00:00 2001
From: Marvin Borner
Date: Sun, 14 Mar 2021 16:06:57 +0100
Subject: Maaany fixes :)

I don't have the motivation to write better commit messages...
---
 apps/init.c                 |  6 ++--
 apps/window.c               |  4 +++
 apps/wm.c                   | 71 ++++++++++++++++++++-------------------------
 kernel/drivers/interrupts.c |  4 +++
 kernel/drivers/keyboard.c   |  6 ++--
 kernel/drivers/mouse.c      |  6 ++--
 kernel/features/fs.c        |  4 +--
 kernel/features/mm.c        |  4 +--
 kernel/features/proc.c      | 20 ++++++++++---
 kernel/inc/mm.h             |  3 ++
 libc/alloc.c                |  2 --
 libc/inc/def.h              |  3 ++
 libc/inc/sys.h              |  4 ++-
 libgui/gfx.c                |  9 +++---
 libgui/gui.c                | 18 ++++++++----
 libgui/inc/gfx.h            |  7 ++---
 libgui/inc/gui.h            |  3 +-
 libgui/inc/msg.h            | 24 +++++++++++----
 libgui/msg.c                | 22 +++++++-------
 run                         |  9 +++++-
 20 files changed, 135 insertions(+), 94 deletions(-)

(limited to 'apps/init.c')

diff --git a/apps/init.c b/apps/init.c
index f854a81..c59e3bf 100644
--- a/apps/init.c
+++ b/apps/init.c
@@ -6,13 +6,15 @@
 #include <str.h>
 #include <sys.h>
 
+#include <cpu.h>
+
 int main(int argc, char **argv)
 {
 	UNUSED(argc);
 	UNUSED(argv);
 
 	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/window.c b/apps/window.c
index ac29ba1..90a414c 100644
--- a/apps/window.c
+++ b/apps/window.c
@@ -8,6 +8,9 @@ int main(void)
 {
 	struct gui_window win = { 0 };
 	assert(gui_new_window(&win) > 0);
+	while (1)
+		;
+#if 0
 	gfx_fill(win.ctx, COLOR_GREEN);
 	// Professional testing
 	for (int i = 0; i < 12; i++) {
@@ -16,5 +19,6 @@ int main(void)
 	}
 	assert(gui_redraw_window(win.id) > 0);
 	log("%d\n", win.ctx->size.x);
+#endif
 	return 0;
 }
diff --git a/apps/wm.c b/apps/wm.c
index 8eb6f70..ecc7cb2 100644
--- a/apps/wm.c
+++ b/apps/wm.c
@@ -8,6 +8,7 @@
 #include <ioctl.h>
 #include <keymap.h>
 #include <list.h>
+#include <msg.h>
 #include <random.h>
 #include <vesa.h>
 
@@ -308,46 +309,34 @@ static void handle_event_mouse(struct event_mouse *event)
 		window_redraw(cursor);
 }
 
-static void handle_message_new_window(struct message *msg)
+static void handle_message_new_window(struct message_new_window *msg)
 {
-	if (!msg->data) {
-		msg_send(msg->src, GUI_NEW_WINDOW | MSG_FAILURE, NULL);
-		return;
-	}
-	struct gui_window *buf = msg->data;
-	struct window *win = window_new((struct client){ .pid = msg->src }, "idk", vec2(500, 600),
-					vec2(600, 400), 0);
-	buf->id = win->id;
-	buf->ctx = &win->ctx;
-	buf->pos = &win->pos;
-	msg_send(msg->src, GUI_NEW_WINDOW | MSG_SUCCESS, NULL);
+	struct window *win = window_new((struct client){ .pid = msg->header.src }, "idk",
+					vec2(500, 600), vec2(600, 400), 0);
+	msg->ctx = win->ctx;
+	msg->id = win->id;
+	msg_send(msg->header.src, GUI_NEW_WINDOW | MSG_SUCCESS, msg, sizeof(*msg));
 	/* window_redraw(win); */
 }
 
-static void handle_message_redraw_window(struct message *msg)
+static void handle_message_redraw_window(struct message_redraw_window *msg)
 {
-	if (!msg->data) {
-		msg_send(msg->src, GUI_REDRAW_WINDOW | MSG_FAILURE, NULL);
-		return;
-	}
-	u32 id = *(u32 *)msg->data;
+	u32 id = msg->id;
 	struct window *win = window_find(id);
 	if (!win) {
-		msg_send(msg->src, GUI_REDRAW_WINDOW | MSG_FAILURE, NULL);
+		msg_send(msg->header.src, GUI_REDRAW_WINDOW | MSG_FAILURE, NULL,
+			 sizeof(msg->header));
 		return;
 	}
-	msg_send(msg->src, GUI_REDRAW_WINDOW | MSG_SUCCESS, NULL);
+	msg_send(msg->header.src, GUI_REDRAW_WINDOW | MSG_SUCCESS, NULL, sizeof(msg->header));
 	window_redraw(win);
 }
 
-static void handle_message(struct message *msg)
+static void handle_message(void *msg)
 {
-	if (msg->magic != MSG_MAGIC) {
-		log("Message magic doesn't match!\n");
-		return;
-	}
+	struct message_header *header = msg;
 
-	switch (msg->type) {
+	switch (header->type) {
 	case GUI_NEW_WINDOW:
 		handle_message_new_window(msg);
 		break;
@@ -355,8 +344,8 @@ static void handle_message(struct message *msg)
 		handle_message_redraw_window(msg);
 		break;
 	default:
-		log("Message type %d not implemented!\n", msg->type);
-		msg_send(msg->src, MSG_FAILURE, NULL);
+		log("Message type %d not implemented!\n", header->type);
+		msg_send(header->src, MSG_FAILURE, NULL, sizeof(*header));
 	}
 }
 
@@ -389,32 +378,34 @@ int main(int argc, char **argv)
 	gfx_load_wallpaper(&cursor->ctx, "/res/cursor.png");
 	window_redraw(wallpaper);
 
-	struct message msg = { 0 };
+	u8 msg[1024] = { 0 };
 	struct event_keyboard event_keyboard = { 0 };
 	struct event_mouse event_mouse = { 0 };
-	const char *listeners[] = { "/dev/kbd", "/dev/mouse", "/proc/self/msg" };
+	const char *listeners[] = { "/dev/kbd", "/dev/mouse", "/proc/self/msg", NULL };
 	while (1) {
 		int poll_ret = 0;
 		if ((poll_ret = poll(listeners)) >= 0) {
 			if (poll_ret == 0) {
 				if (read(listeners[poll_ret], &event_keyboard, 0,
-					 sizeof(event_keyboard)) > 0)
+					 sizeof(event_keyboard)) > 0) {
 					handle_event_keyboard(&event_keyboard);
-				continue;
+					continue;
+				}
 			} else if (poll_ret == 1) {
 				if (read(listeners[poll_ret], &event_mouse, 0,
-					 sizeof(event_mouse)) > 0)
+					 sizeof(event_mouse)) > 0) {
 					handle_event_mouse(&event_mouse);
-				continue;
+					continue;
+				}
 			} else if (poll_ret == 2) {
-				if (read(listeners[poll_ret], &msg, 0, sizeof(msg)) > 0)
-					handle_message(&msg);
-				continue;
+				if (msg_receive(msg, 1024) > 0) {
+					handle_message(msg);
+					continue;
+				}
 			}
-		} else {
-			err(1, "POLL ERROR!\n");
 		}
-	};
+		panic("Poll/read error!\n");
+	}
 
 	// TODO: Execute?
 	free(keymap);
diff --git a/kernel/drivers/interrupts.c b/kernel/drivers/interrupts.c
index fe2321a..2e1444f 100644
--- a/kernel/drivers/interrupts.c
+++ b/kernel/drivers/interrupts.c
@@ -5,6 +5,7 @@
 #include <def.h>
 #include <interrupts.h>
 #include <mem.h>
+#include <mm.h>
 #include <print.h>
 #include <proc.h>
 #include <serial.h>
@@ -236,6 +237,9 @@ static void isr_install(void)
 	// Set default routines
 	for (u32 i = 0; i < 256; i++)
 		isr_routines[i] = isr_panic;
+
+	// Set page fault handler
+	isr_install_handler(14, page_fault_handler);
 }
 
 /**
diff --git a/kernel/drivers/keyboard.c b/kernel/drivers/keyboard.c
index 3ae3c0e..dbee8e1 100644
--- a/kernel/drivers/keyboard.c
+++ b/kernel/drivers/keyboard.c
@@ -66,10 +66,10 @@ static s32 keyboard_read(void *buf, u32 offset, u32 count, struct device *dev)
 	if (stack_empty(queue))
 		return -1;
 
-	struct event *e = stack_pop(queue);
-	memcpy(buf, (u8 *)e + offset, count);
+	struct event_keyboard *e = stack_pop(queue);
+	memcpy(buf, (u8 *)e + offset, MIN(count, sizeof(*e)));
 	free(e);
-	return count;
+	return MIN(count, sizeof(*e));
 }
 
 static u8 keyboard_ready(void)
diff --git a/kernel/drivers/mouse.c b/kernel/drivers/mouse.c
index 40094d1..5c481da 100644
--- a/kernel/drivers/mouse.c
+++ b/kernel/drivers/mouse.c
@@ -94,10 +94,10 @@ static s32 mouse_read(void *buf, u32 offset, u32 count, struct device *dev)
 	if (stack_empty(queue))
 		return -1;
 
-	struct event *e = stack_pop(queue);
-	memcpy(buf, (u8 *)e + offset, count);
+	struct event_mouse *e = stack_pop(queue);
+	memcpy(buf, (u8 *)e + offset, MIN(count, sizeof(*e)));
 	free(e);
-	return count;
+	return MIN(count, sizeof(*e));
 }
 
 void mouse_install(void)
diff --git a/kernel/features/fs.c b/kernel/features/fs.c
index 20d00e5..c8ad317 100644
--- a/kernel/features/fs.c
+++ b/kernel/features/fs.c
@@ -122,7 +122,7 @@ s32 vfs_mount(struct device *dev, const char *path)
 
 s32 vfs_read(const char *path, void *buf, u32 offset, u32 count)
 {
-	/* printf("%s READ: %s\n", proc_current()->name, path); */
+	/* printf("%s READ: %s\n", proc_current() ? proc_current()->name : "Unknown", path); */
 	if (!count)
 		return 0;
 
@@ -148,7 +148,7 @@ s32 vfs_read(const char *path, void *buf, u32 offset, u32 count)
 
 s32 vfs_write(const char *path, void *buf, u32 offset, u32 count)
 {
-	/* printf("%s WRITE: %s\n", proc_current()->name, path); */
+	/* printf("%s WRITE: %s\n", proc_current() ? proc_current()->name : "Unknown", path); */
 	if (!count)
 		return 0;
 
diff --git a/kernel/features/mm.c b/kernel/features/mm.c
index bd32683..9eca438 100644
--- a/kernel/features/mm.c
+++ b/kernel/features/mm.c
@@ -32,7 +32,7 @@ static void paging_switch_dir(u32 dir)
 
 extern void paging_invalidate_tlb(void);
 
-static void page_fault(struct regs *r)
+void page_fault_handler(struct regs *r)
 {
 	// Check error code
 	const char *type = (r->err_code & 1) ? "present" : "non-present";
@@ -495,6 +495,4 @@ void memory_install(struct mem_info *mem_info, struct vid_info *vid_info)
 
 	memory_switch_dir(&kernel_dir);
 	paging_enable();
-
-	isr_install_handler(14, page_fault);
 }
diff --git a/kernel/features/proc.c b/kernel/features/proc.c
index 6bbe894..b93f7c8 100644
--- a/kernel/features/proc.c
+++ b/kernel/features/proc.c
@@ -305,6 +305,11 @@ static enum stream_defaults procfs_stream(const char *path)
 	}
 }
 
+struct procfs_message {
+	u8 *data;
+	u32 size;
+};
+
 static s32 procfs_write(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
 {
 	u32 pid = 0;
@@ -318,7 +323,10 @@ static s32 procfs_write(const char *path, void *buf, u32 offset, u32 count, stru
 		if (!memcmp(path, "msg", 4)) {
 			void *msg_data = malloc(count);
 			memcpy(msg_data, buf, count);
-			stack_push_bot(p->messages, msg_data); // TODO: Use offset
+			struct procfs_message *msg = malloc(sizeof(*msg));
+			msg->data = msg_data;
+			msg->size = count;
+			stack_push_bot(p->messages, msg); // TODO: Use offset
 			proc_enable_waiting(pid, PROC_WAIT_MSG);
 			return count;
 		} else if (!memcmp(path, "io/", 3)) {
@@ -371,12 +379,13 @@ static s32 procfs_read(const char *path, void *buf, u32 offset, u32 count, struc
 			if (stack_empty(p->messages)) {
 				return -1; // This shouldn't happen
 			} else {
-				u8 *msg = stack_pop(p->messages);
+				struct procfs_message *msg = stack_pop(p->messages);
 				if (!msg)
 					return -1;
-				memcpy(buf, msg + offset, count);
+				memcpy(buf, msg->data + offset, MIN(count, msg->size));
+				free(msg->data);
 				free(msg);
-				return count;
+				return MIN(count, msg->size);
 			}
 		} else if (!memcmp(path, "io/", 3)) {
 			path += 3;
@@ -500,7 +509,10 @@ void proc_init(void)
 
 	printf("Jumping to userspace!\n");
 	memory_switch_dir(((struct proc *)new->data)->page_dir);
+
+	// You're waiting for a train. A train that will take you far away...
 	proc_jump_userspace();
+
 	while (1) {
 	};
 }
diff --git a/kernel/inc/mm.h b/kernel/inc/mm.h
index 590875c..d3e37f6 100644
--- a/kernel/inc/mm.h
+++ b/kernel/inc/mm.h
@@ -5,6 +5,7 @@
 
 #include <boot.h>
 #include <def.h>
+#include <interrupts.h>
 
 struct memory_range {
 	u32 base;
@@ -102,4 +103,6 @@ void memory_backup_dir(struct page_dir **backup);
 
 void memory_install(struct mem_info *mem_info, struct vid_info *vid_info);
 
+void page_fault_handler(struct regs *r);
+
 #endif
diff --git a/libc/alloc.c b/libc/alloc.c
index 4ccf35f..be986dc 100644
--- a/libc/alloc.c
+++ b/libc/alloc.c
@@ -86,8 +86,6 @@ struct liballoc_minor {
 
 #define MAJOR_SIZE (ALIGN_UP(sizeof(struct liballoc_major), 16))
 #define MINOR_SIZE (ALIGN_UP(sizeof(struct liballoc_minor), 16))
-#define MIN(__x, __y) ((__x) < (__y) ? (__x) : (__y))
-#define MAX(__x, __y) ((__x) > (__y) ? (__x) : (__y))
 
 static struct liballoc_major *l_mem_root = NULL;
 static struct liballoc_major *l_best_bet = NULL;
diff --git a/libc/inc/def.h b/libc/inc/def.h
index db1c95e..c334fcb 100644
--- a/libc/inc/def.h
+++ b/libc/inc/def.h
@@ -25,6 +25,9 @@ typedef unsigned long long u64;
 
 #define UNUSED(a) ((void)(a))
 
+#define MIN(a, b) (((a) < (b)) ? (a) : (b))
+#define MAX(a, b) (((a) > (b)) ? (a) : (b))
+
 #define NORETURN __attribute__((noreturn))
 #define NO_SANITIZE __attribute__((no_sanitize("undefined")))
 #define PACKED __attribute__((packed))
diff --git a/libc/inc/sys.h b/libc/inc/sys.h
index 3125cb0..8add0de 100644
--- a/libc/inc/sys.h
+++ b/libc/inc/sys.h
@@ -93,7 +93,9 @@ int sysv(enum sys num, ...);
 
 static inline u32 getpid(void)
 {
-	u32 buf = 0;
+	static u32 buf = 0;
+	if (buf)
+		return buf;
 	read("/proc/self/pid", &buf, 0, sizeof(buf));
 	return buf;
 }
diff --git a/libgui/gfx.c b/libgui/gfx.c
index d9457c7..dad8b88 100644
--- a/libgui/gfx.c
+++ b/libgui/gfx.c
@@ -98,10 +98,11 @@ static void draw_rectangle(struct context *ctx, vec2 pos1, vec2 pos2, u32 c)
 
 struct context *gfx_new_ctx(struct context *ctx)
 {
-	struct message msg = { 0 };
-	assert(msg_send(pidof(WM_PATH), GFX_NEW_CONTEXT, ctx) > 0);
-	assert(msg_receive(&msg) > 0);
-	memcpy(ctx, msg.data, sizeof(*ctx));
+	/* struct message msg = { 0 }; */
+	assert(0);
+	/* assert(msg_send(pidof(WM_PATH), GFX_NEW_CONTEXT, ctx) > 0); */
+	/* assert(msg_receive(&msg) > 0); */
+	/* memcpy(ctx, msg.data, sizeof(*ctx)); */
 	return ctx;
 }
 
diff --git a/libgui/gui.c b/libgui/gui.c
index 2083f23..bc8adb1 100644
--- a/libgui/gui.c
+++ b/libgui/gui.c
@@ -2,24 +2,30 @@
 
 #include <def.h>
 #include <gui.h>
+#include <msg.h>
 #include <print.h>
 
 #define WM_PATH "/bin/wm"
 
 s32 gui_new_window(struct gui_window *win)
 {
-	struct message msg = { 0 };
-	if (msg_send(pidof(WM_PATH), GUI_NEW_WINDOW, win) > 0 && msg_receive(&msg) > 0 &&
-	    msg.type == (GUI_NEW_WINDOW | MSG_SUCCESS))
+	struct message_new_window msg = { 0 };
+	if (msg_send(pidof(WM_PATH), GUI_NEW_WINDOW, &msg, sizeof(msg)) > 0 &&
+	    msg_receive(&msg, sizeof(msg)) > 0 &&
+	    msg.header.type == (GUI_NEW_WINDOW | MSG_SUCCESS)) {
+		win->id = msg.id;
+		win->ctx = msg.ctx;
 		return win->id;
+	}
 	return -1;
 }
 
 s32 gui_redraw_window(u32 id)
 {
-	struct message msg = { 0 };
-	if (msg_send(pidof(WM_PATH), GUI_REDRAW_WINDOW, &id) > 0 && msg_receive(&msg) > 0 &&
-	    msg.type == (GUI_REDRAW_WINDOW | MSG_SUCCESS))
+	struct message_redraw_window msg = { .id = id };
+	if (msg_send(pidof(WM_PATH), GUI_REDRAW_WINDOW, &msg, sizeof(msg)) > 0 &&
+	    msg_receive(&msg, sizeof(msg)) > 0 &&
+	    msg.header.type == (GUI_REDRAW_WINDOW | MSG_SUCCESS))
 		return id;
 	return -1;
 }
diff --git a/libgui/inc/gfx.h b/libgui/inc/gfx.h
index 4a358ca..f3555a4 100644
--- a/libgui/inc/gfx.h
+++ b/libgui/inc/gfx.h
@@ -5,7 +5,6 @@
 #define GFX_H
 
 #include <def.h>
-#include <msg.h>
 #include <sys.h>
 #include <vec.h>
 #include <vesa.h>
@@ -82,8 +81,8 @@ int gfx_font_width(enum font_type);
  * Wrappers
  */
 
-#define gfx_redraw()                                                                               \
-	(msg_send(pidof(WM_PATH), GFX_REDRAW, NULL)) // TODO: Partial redraw (optimization)
-#define gfx_redraw_focused() (msg_send(pidof(WM_PATH), GFX_REDRAW_FOCUSED, NULL))
+/* #define gfx_redraw()                                                                               \ */
+/* 	(msg_send(pidof(WM_PATH), GFX_REDRAW, NULL)) // TODO: Partial redraw (optimization) */
+/* #define gfx_redraw_focused() (msg_send(pidof(WM_PATH), GFX_REDRAW_FOCUSED, NULL)) */
 
 #endif
diff --git a/libgui/inc/gui.h b/libgui/inc/gui.h
index 460bf88..d160333 100644
--- a/libgui/inc/gui.h
+++ b/libgui/inc/gui.h
@@ -8,8 +8,7 @@
 
 struct gui_window {
 	u32 id;
-	struct context *ctx;
-	vec2 *pos;
+	struct context ctx;
 };
 
 s32 gui_new_window(struct gui_window *win);
diff --git a/libgui/inc/msg.h b/libgui/inc/msg.h
index db00460..7cbfa2c 100644
--- a/libgui/inc/msg.h
+++ b/libgui/inc/msg.h
@@ -4,16 +4,28 @@
 #define MSG_H
 
 #include <def.h>
+#include <gfx.h>
 
 #define MSG_MAGIC 0x42042069
 #define MSG_SUCCESS (1 << 29)
 #define MSG_FAILURE (1 << 30)
 
-struct message {
+struct message_header {
 	u32 magic;
-	int src;
-	int type;
-	void *data;
+	u32 src;
+	u32 type;
+	u32 size;
+};
+
+struct message_new_window {
+	struct message_header header;
+	u32 id;
+	struct context ctx;
+};
+
+struct message_redraw_window {
+	struct message_header header;
+	u32 id;
 };
 
 enum message_type {
@@ -32,7 +44,7 @@ enum message_type {
 	GUI_MAX
 };
 
-int msg_send(u32 pid, enum message_type, void *data);
-int msg_receive(struct message *msg);
+int msg_send(u32 pid, enum message_type type, void *data, u32 size);
+int msg_receive(void *buf, u32 size);
 
 #endif
diff --git a/libgui/msg.c b/libgui/msg.c
index 8448e73..3f58267 100644
--- a/libgui/msg.c
+++ b/libgui/msg.c
@@ -5,23 +5,23 @@
 #include <print.h>
 #include <sys.h>
 
-int msg_send(u32 pid, enum message_type type, void *data)
+int msg_send(u32 pid, enum message_type type, void *data, u32 size)
 {
-	struct message msg = { 0 };
-	assert((signed)pid != -1);
+	assert((signed)pid != -1 && size >= sizeof(struct message_header));
 	char path[32] = { 0 };
 	sprintf(path, "/proc/%d/msg", pid);
-	msg.magic = MSG_MAGIC;
-	msg.src = getpid();
-	msg.type = type;
-	msg.data = data;
-	return write(path, &msg, 0, sizeof(msg));
+	struct message_header *header = data;
+	header->magic = MSG_MAGIC;
+	header->src = getpid();
+	header->type = type;
+	return write(path, data, 0, size);
 }
 
-int msg_receive(struct message *msg)
+int msg_receive(void *buf, u32 size)
 {
-	int ret = read("/proc/self/msg", msg, 0, sizeof(*msg));
-	if (msg->magic == MSG_MAGIC && ret == sizeof(*msg))
+	int ret = read("/proc/self/msg", buf, 0, size);
+	struct message_header *header = buf;
+	if (header->magic == MSG_MAGIC)
 		return ret;
 	else
 		return -1;
diff --git a/run b/run
index 1a8202a..cd03ba3 100755
--- a/run
+++ b/run
@@ -26,7 +26,7 @@ no_ask="${2}"
 # TODO: Support -enable-kvm: GPF?!
 qemu_with_flags() {
     network="rtl8139"
-    qemu-system-i386 -cpu max -no-reboot -vga std -rtc base=localtime -m 256M -netdev user,id=net0,hostfwd=tcp:127.0.0.1:8000-10.0.2.15:8000 -device $network,netdev=net0 -object filter-dump,id=dump,netdev=net0,file=dump.pcap "$@"
+    qemu-system-i386 -d guest_errors -cpu max -no-reboot -vga std -rtc base=localtime -m 256M -netdev user,id=net0,hostfwd=tcp:127.0.0.1:8000-10.0.2.15:8000 -device $network,netdev=net0 -object filter-dump,id=dump,netdev=net0,file=dump.pcap "$@"
 }
 
 make_cross() {
@@ -189,6 +189,10 @@ make_addr() {
     addr2line -e build/"$1".elf -f -p "$2"
 }
 
+make_cloc() {
+    cloc . --exclude-dir=build,iso,disk,res,cross
+}
+
 make_append_commands() {
     s=""
     while read -r data; do
@@ -239,6 +243,8 @@ elif [ "${mode}" = "disasm" ]; then
     make_disasm "$2" "$3"
 elif [ "${mode}" = "addr" ]; then
     make_addr "$2" "$3"
+elif [ "${mode}" = "cloc" ]; then
+    make_cloc
 elif [ "${mode}" = "sync" ]; then
     make_sync
 elif [ "${mode}" = "disk" ]; then
@@ -267,6 +273,7 @@ else
     printf "again\t\tOpens QEMU again using the previous build\n"
     printf "disasm\t\tDisassembles a given part of Melvix\n"
     printf "addr\t\tResolves an address to a line of code\n"
+    printf "cloc\t\tCount the total lines of code\n"
     printf "sync\t\tSyncs the 'tags' and 'compile_commands.json' file\n"
     printf "disk\t\tPrepares the userspace disk (e.g. fonts)\n"
     printf "*\t\tAnything else prints this help\n"
-- 
cgit v1.2.3