Added memory management using paging

This was quite a roller-coaster and most things are slower now, but it works and is way more secure. I still need to implement things like shared memory for the WM/GUI system but other than that everything is supported.

15 files changed, 635 insertions, 436 deletions

diff --git a/libc/Makefile b/libc/Makefile
index 9ac6c67..3bf4473 100644
--- a/libc/Makefile
+++ b/libc/Makefile
@@ -3,6 +3,7 @@
 # TODO: Remove serial and cpu from libc?
 COBJS = sanitize.o \
 	str.o \
+	alloc.o \
 	mem.o \
 	math.o \
 	conv.o \
diff --git a/libc/alloc.c b/libc/alloc.c
new file mode 100644
index 0000000..be986dc
--- /dev/null
+++ b/libc/alloc.c
@@ -0,0 +1,425 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+// Mostly by Durand Miller, released into public domain
+
+#include <assert.h>
+#include <cpu.h>
+#include <mem.h>
+
+#ifdef kernel
+
+#include <mm.h>
+
+static void *liballoc_alloc(u32 p)
+{
+	return memory_alloc(virtual_kernel_dir(), p, MEMORY_CLEAR);
+}
+
+static int liballoc_free(void *ptr, u32 p)
+{
+	memory_free(virtual_kernel_dir(), memory_range((u32)ptr, (u32)p));
+	return 0;
+}
+
+#else
+
+#include <sys.h>
+
+#define sys_alloc(size) (void *)sys1(SYS_ALLOC, size)
+#define sys_free(ptr, size) (u32) sys2(SYS_FREE, ptr, size)
+
+static void *liballoc_alloc(u32 p)
+{
+	return sys_alloc((u32)p);
+}
+
+static int liballoc_free(void *ptr, u32 p)
+{
+	sys_free((u32)ptr, (u32)p);
+	return 0;
+}
+
+#endif
+
+static int locked = 0;
+
+static int liballoc_lock(void)
+{
+	spinlock(&locked);
+	return 0;
+}
+
+static int liballoc_unlock(void)
+{
+	locked = 0;
+	return 0;
+}
+
+#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;
+};
+
+struct liballoc_minor {
+	struct liballoc_minor *prev;
+	struct liballoc_minor *next;
+	struct liballoc_major *block;
+	u32 magic;
+	u32 size;
+	u32 req_size;
+};
+
+#define MAJOR_SIZE (ALIGN_UP(sizeof(struct liballoc_major), 16))
+#define MINOR_SIZE (ALIGN_UP(sizeof(struct liballoc_minor), 16))
+
+static struct liballoc_major *l_mem_root = NULL;
+static struct liballoc_major *l_best_bet = NULL;
+
+static u32 l_page_size = 4096;
+static u32 l_page_count = 16;
+
+static struct liballoc_major *allocate_new_page(u32 size)
+{
+	u32 st = size + MAJOR_SIZE + MINOR_SIZE;
+
+	if ((st % l_page_size) == 0)
+		st = st / (l_page_size);
+	else
+		st = st / (l_page_size) + 1;
+
+	st = MAX(st, l_page_count);
+
+	struct liballoc_major *maj = (struct liballoc_major *)liballoc_alloc(st * l_page_size);
+
+	if (maj == NULL)
+		return NULL;
+
+	maj->prev = NULL;
+	maj->next = NULL;
+	maj->pages = st;
+	maj->size = st * l_page_size;
+	maj->usage = MAJOR_SIZE;
+	maj->first = NULL;
+
+	return maj;
+}
+
+static void *_malloc(u32 req_size)
+{
+	req_size = ALIGN_UP(req_size, 16);
+
+	u32 best_size = 0;
+	u32 size = req_size;
+
+	liballoc_lock();
+
+	if (size == 0) {
+		liballoc_unlock();
+		return malloc(1);
+	}
+
+	if (l_mem_root == NULL) {
+		l_mem_root = allocate_new_page(size);
+		if (l_mem_root == NULL) {
+			liballoc_unlock();
+			panic("Malloc failed!\n");
+		}
+	}
+
+	struct liballoc_major *maj = l_mem_root;
+	u8 started_bet = 0;
+
+	if (l_best_bet != NULL) {
+		best_size = l_best_bet->size - l_best_bet->usage;
+
+		if (best_size > (size + MINOR_SIZE)) {
+			maj = l_best_bet;
+			started_bet = 1;
+		}
+	}
+
+	while (maj != NULL) {
+		u32 diff = maj->size - maj->usage;
+		if (best_size < diff) {
+			l_best_bet = maj;
+			best_size = diff;
+		}
+
+#ifdef USE_CASE1
+		if (diff < (size + MINOR_SIZE)) {
+			if (maj->next != NULL) {
+				maj = maj->next;
+				continue;
+			}
+
+			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;
+			maj = maj->next;
+		}
+#endif
+
+#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
+
+#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;
+				}
+			}
+
+			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;
+				}
+			}
+
+			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();
+
+	panic("Malloc failed!\n");
+	return NULL;
+}
+
+static void _free(void *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();
+}
+
+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();
+		panic("Malloc failed!\n");
+		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"
+#define FUNC printf
+#else
+#define PREFIX "U"
+#define FUNC log
+#endif
+
+void *zalloc(u32 size)
+{
+	void *ret = malloc(size);
+	memset(ret, 0, size);
+	return ret;
+}
+
+void *realloc(void *ptr, u32 size)
+{
+	return _realloc(ptr, size);
+}
+
+void *malloc_debug(u32 size, const char *file, int line, const char *func, const char *inp)
+{
+	assert(size < (100 << 20)); // Don't brag with memory pls
+	void *ret = _malloc(size);
+
+	(void)file;
+	(void)line;
+	(void)func;
+	(void)inp;
+	/* FUNC(PREFIX "MALLOC\t%s:%d: %s: 0x%x %dB (%s)\n", file, line, func, ret, size, inp); */
+	return ret;
+}
+
+void free_debug(void *ptr, const char *file, int line, const char *func, const char *inp)
+{
+	if (ptr)
+		_free(ptr);
+
+	(void)file;
+	(void)line;
+	(void)func;
+	(void)inp;
+	/* FUNC(PREFIX "FREE\t%s:%d: %s: 0x%x (%s)\n", file, line, func, ptr, inp); */
+}
diff --git a/libc/cpu.c b/libc/cpu.c
index 08e742c..8ca4d27 100644
--- a/libc/cpu.c
+++ b/libc/cpu.c
@@ -70,34 +70,52 @@ void cpu_print(void)
 	printf("CPU vendor: %s\n", cpu_string(buf));
 }
 
-static u32 cr0_get(void)
+u32 cr0_get(void)
 {
 	u32 cr0;
 	__asm__ volatile("movl %%cr0, %%eax" : "=a"(cr0));
 	return cr0;
 }
 
-static void cr0_set(u32 cr0)
+void cr0_set(u32 cr0)
 {
 	__asm__ volatile("movl %%eax, %%cr0" ::"a"(cr0));
 }
 
-static u32 cr4_get(void)
+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));
+}
+
+u32 cr4_get(void)
 {
 	u32 cr4;
 	__asm__ volatile("movl %%cr4, %%eax" : "=a"(cr4));
 	return cr4;
 }
 
-static void cr4_set(u32 cr4)
+void cr4_set(u32 cr4)
 {
 	__asm__ volatile("movl %%eax, %%cr4" ::"a"(cr4));
 }
 
-static u32 cpu_features = 0;
-static u8 cpu_has_feature(u32 feature)
+static u32 cpu_cfeatures = 0;
+u8 cpu_has_cfeature(enum cpuid_features feature)
+{
+	return (cpu_cfeatures & feature) != 0;
+}
+
+static u32 cpu_dfeatures = 0;
+u8 cpu_has_dfeature(enum cpuid_features feature)
 {
-	return (cpu_features & feature) != 0;
+	return (cpu_dfeatures & feature) != 0;
 }
 
 static void fpu_handler(struct regs *r)
@@ -116,8 +134,9 @@ void cpu_enable_features(void)
 {
 	u32 a, b, c, d;
 	cpuid(CPUID_FEATURES, &a, &b, &c, &d);
-	cpu_features = d;
-	if (cpu_has_feature(CPUID_FEAT_EDX_SSE)) {
+	cpu_cfeatures = c;
+	cpu_dfeatures = d;
+	if (cpu_has_dfeature(CPUID_FEAT_EDX_SSE)) {
 		cr0_set(cr0_get() & ~(1 << 2));
 		cr0_set(cr0_get() | (1 << 1));
 		cr4_set(cr4_get() | (3 << 9));
@@ -125,7 +144,7 @@ void cpu_enable_features(void)
 		panic("No SSE support!\n");
 	}
 
-	if (cpu_has_feature(CPUID_FEAT_EDX_FPU)) {
+	if (cpu_has_dfeature(CPUID_FEAT_EDX_FPU)) {
 		__asm__ volatile("fninit");
 		__asm__ volatile("fxsave %0" : "=m"(fpu_state));
 		irq_install_handler(7, fpu_handler);
diff --git a/libc/crt/crt0.asm b/libc/crt/crt0.asm
index a0621ff..0f8024d 100644
--- a/libc/crt/crt0.asm
+++ b/libc/crt/crt0.asm
@@ -10,6 +10,6 @@ _start:
 	call main
 
 	push eax
-	push 8
+	push 9
 	call sys1
 	jmp $
diff --git a/libc/inc/cpu.h b/libc/inc/cpu.h
index fa82fbe..d709d86 100644
--- a/libc/inc/cpu.h
+++ b/libc/inc/cpu.h
@@ -27,6 +27,13 @@ void cpu_print(void);
 void cpu_enable_features(void);
 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);
+
 void cli(void);
 void sti(void);
 void hlt(void);
@@ -35,63 +42,69 @@ void loop(void);
 
 enum cpuid_requests { CPUID_VENDOR_STRING, CPUID_FEATURES, CPUID_TLB, CPUID_SERIAL };
 enum cpuid_features {
-	CPUID_FEAT_ECX_SSE3 = 1 << 0,
-	CPUID_FEAT_ECX_PCLMUL = 1 << 1,
-	CPUID_FEAT_ECX_DTES64 = 1 << 2,
-	CPUID_FEAT_ECX_MONITOR = 1 << 3,
-	CPUID_FEAT_ECX_DS_CPL = 1 << 4,
-	CPUID_FEAT_ECX_VMX = 1 << 5,
-	CPUID_FEAT_ECX_SMX = 1 << 6,
-	CPUID_FEAT_ECX_EST = 1 << 7,
-	CPUID_FEAT_ECX_TM2 = 1 << 8,
-	CPUID_FEAT_ECX_SSSE3 = 1 << 9,
-	CPUID_FEAT_ECX_CID = 1 << 10,
-	CPUID_FEAT_ECX_FMA = 1 << 12,
-	CPUID_FEAT_ECX_CX16 = 1 << 13,
-	CPUID_FEAT_ECX_ETPRD = 1 << 14,
-	CPUID_FEAT_ECX_PDCM = 1 << 15,
-	CPUID_FEAT_ECX_PCIDE = 1 << 17,
-	CPUID_FEAT_ECX_DCA = 1 << 18,
-	CPUID_FEAT_ECX_SSE4_1 = 1 << 19,
-	CPUID_FEAT_ECX_SSE4_2 = 1 << 20,
-	CPUID_FEAT_ECX_x2APIC = 1 << 21,
-	CPUID_FEAT_ECX_MOVBE = 1 << 22,
-	CPUID_FEAT_ECX_POPCNT = 1 << 23,
-	CPUID_FEAT_ECX_AES = 1 << 25,
-	CPUID_FEAT_ECX_XSAVE = 1 << 26,
-	CPUID_FEAT_ECX_OSXSAVE = 1 << 27,
-	CPUID_FEAT_ECX_AVX = 1 << 28,
+	CPUID_FEAT_ECX_SSE3 = 1u << 0,
+	CPUID_FEAT_ECX_PCLMUL = 1u << 1,
+	CPUID_FEAT_ECX_DTES64 = 1u << 2,
+	CPUID_FEAT_ECX_MONITOR = 1u << 3,
+	CPUID_FEAT_ECX_DS_CPL = 1u << 4,
+	CPUID_FEAT_ECX_VMX = 1u << 5,
+	CPUID_FEAT_ECX_SMX = 1u << 6,
+	CPUID_FEAT_ECX_EST = 1u << 7,
+	CPUID_FEAT_ECX_TM2 = 1u << 8,
+	CPUID_FEAT_ECX_SSSE3 = 1u << 9,
+	CPUID_FEAT_ECX_CID = 1u << 10,
+	CPUID_FEAT_ECX_FMA = 1u << 12,
+	CPUID_FEAT_ECX_CX16 = 1u << 13,
+	CPUID_FEAT_ECX_ETPRD = 1u << 14,
+	CPUID_FEAT_ECX_PDCM = 1u << 15,
+	CPUID_FEAT_ECX_PCIDE = 1u << 17,
+	CPUID_FEAT_ECX_DCA = 1u << 18,
+	CPUID_FEAT_ECX_SSE4_1 = 1u << 19,
+	CPUID_FEAT_ECX_SSE4_2 = 1u << 20,
+	CPUID_FEAT_ECX_x2APIC = 1u << 21,
+	CPUID_FEAT_ECX_MOVBE = 1u << 22,
+	CPUID_FEAT_ECX_POPCNT = 1u << 23,
+	CPUID_FEAT_ECX_AES = 1u << 25,
+	CPUID_FEAT_ECX_XSAVE = 1u << 26,
+	CPUID_FEAT_ECX_OSXSAVE = 1u << 27,
+	CPUID_FEAT_ECX_AVX = 1u << 28,
+	CPUID_FEAT_ECX_F16C = 1u << 29,
+	CPUID_FEAT_ECX_RDRND = 1u << 30,
 
-	CPUID_FEAT_EDX_FPU = 1 << 0,
-	CPUID_FEAT_EDX_VME = 1 << 1,
-	CPUID_FEAT_EDX_DE = 1 << 2,
-	CPUID_FEAT_EDX_PSE = 1 << 3,
-	CPUID_FEAT_EDX_TSC = 1 << 4,
-	CPUID_FEAT_EDX_MSR = 1 << 5,
-	CPUID_FEAT_EDX_PAE = 1 << 6,
-	CPUID_FEAT_EDX_MCE = 1 << 7,
-	CPUID_FEAT_EDX_CX8 = 1 << 8,
-	CPUID_FEAT_EDX_APIC = 1 << 9,
-	CPUID_FEAT_EDX_SEP = 1 << 11,
-	CPUID_FEAT_EDX_MTRR = 1 << 12,
-	CPUID_FEAT_EDX_PGE = 1 << 13,
-	CPUID_FEAT_EDX_MCA = 1 << 14,
-	CPUID_FEAT_EDX_CMOV = 1 << 15,
-	CPUID_FEAT_EDX_PAT = 1 << 16,
-	CPUID_FEAT_EDX_PSE36 = 1 << 17,
-	CPUID_FEAT_EDX_PSN = 1 << 18,
-	CPUID_FEAT_EDX_CLF = 1 << 19,
-	CPUID_FEAT_EDX_DTES = 1 << 21,
-	CPUID_FEAT_EDX_ACPI = 1 << 22,
-	CPUID_FEAT_EDX_MMX = 1 << 23,
-	CPUID_FEAT_EDX_FXSR = 1 << 24,
-	CPUID_FEAT_EDX_SSE = 1 << 25,
-	CPUID_FEAT_EDX_SSE2 = 1 << 26,
-	CPUID_FEAT_EDX_SS = 1 << 27,
-	CPUID_FEAT_EDX_HTT = 1 << 28,
-	CPUID_FEAT_EDX_TM1 = 1 << 29,
-	CPUID_FEAT_EDX_IA64 = 1 << 30,
+	CPUID_FEAT_EDX_FPU = 1u << 0,
+	CPUID_FEAT_EDX_VME = 1u << 1,
+	CPUID_FEAT_EDX_DE = 1u << 2,
+	CPUID_FEAT_EDX_PSE = 1u << 3,
+	CPUID_FEAT_EDX_TSC = 1u << 4,
+	CPUID_FEAT_EDX_MSR = 1u << 5,
+	CPUID_FEAT_EDX_PAE = 1u << 6,
+	CPUID_FEAT_EDX_MCE = 1u << 7,
+	CPUID_FEAT_EDX_CX8 = 1u << 8,
+	CPUID_FEAT_EDX_APIC = 1u << 9,
+	CPUID_FEAT_EDX_SEP = 1u << 11,
+	CPUID_FEAT_EDX_MTRR = 1u << 12,
+	CPUID_FEAT_EDX_PGE = 1u << 13,
+	CPUID_FEAT_EDX_MCA = 1u << 14,
+	CPUID_FEAT_EDX_CMOV = 1u << 15,
+	CPUID_FEAT_EDX_PAT = 1u << 16,
+	CPUID_FEAT_EDX_PSE36 = 1u << 17,
+	CPUID_FEAT_EDX_PSN = 1u << 18,
+	CPUID_FEAT_EDX_CLF = 1u << 19,
+	CPUID_FEAT_EDX_DTES = 1u << 21,
+	CPUID_FEAT_EDX_ACPI = 1u << 22,
+	CPUID_FEAT_EDX_MMX = 1u << 23,
+	CPUID_FEAT_EDX_FXSR = 1u << 24,
+	CPUID_FEAT_EDX_SSE = 1u << 25,
+	CPUID_FEAT_EDX_SSE2 = 1u << 26,
+	CPUID_FEAT_EDX_SS = 1u << 27,
+	CPUID_FEAT_EDX_HTT = 1u << 28,
+	CPUID_FEAT_EDX_TM1 = 1u << 29,
+	CPUID_FEAT_EDX_IA64 = 1u << 30,
 };
+
+u8 cpu_has_cfeature(enum cpuid_features feature);
+u8 cpu_has_dfeature(enum cpuid_features feature);
+
 #endif
 
 #endif
diff --git a/libc/inc/def.h b/libc/inc/def.h
index c8b9dbf..c334fcb 100644
--- a/libc/inc/def.h
+++ b/libc/inc/def.h
@@ -25,7 +25,13 @@ 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))
+#define ALIGNED(align) __attribute__((aligned(align)))
 
 #define EOF (-1)
 #define NULL ((void *)0)
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/mem.h b/libc/inc/mem.h
index 6c37844..ec00628 100644
--- a/libc/inc/mem.h
+++ b/libc/inc/mem.h
@@ -13,7 +13,8 @@ void *realloc(void *ptr, u32 size);
 void *zalloc(u32 size);
 
 #ifdef kernel
-void heap_init(u32 start);
+#define STACK_START 0x00500000 // Defined it bootloader
+#define STACK_SIZE 0x1000 // idk
 #elif defined(userspace)
 #else
 #error "No lib target specified. Please use -Dkernel or -Duserspace"
diff --git a/libc/inc/print.h b/libc/inc/print.h
index 90a715c..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);
@@ -20,6 +21,7 @@ int err(int code, const char *format, ...);
 #else
 #include <proc.h>
 int print_app(enum stream_defaults id, const char *proc_name, const char *str);
+void print_trace(u32 count);
 #endif
 
 #endif
diff --git a/libc/inc/random.h b/libc/inc/random.h
index 59add9b..a82524c 100644
--- a/libc/inc/random.h
+++ b/libc/inc/random.h
@@ -6,6 +6,8 @@
 #include <def.h>
 
 void srand(u32 seed);
+u32 rdrand(void);
+u32 rdseed(void);
 u32 rand(void);
 char *randstr(u32 size);
 
diff --git a/libc/inc/sys.h b/libc/inc/sys.h
index 5858579..8add0de 100644
--- a/libc/inc/sys.h
+++ b/libc/inc/sys.h
@@ -9,16 +9,22 @@
 #define KEYBOARD_MAGIC 0x555555
 #define MOUSE_MAGIC 0xaaaaaa
 
+#define SYS_BOOT_MAGIC 0x18122002
+#define SYS_BOOT_REBOOT 0xeeb007
+#define SYS_BOOT_SHUTDOWN 0xdead
+
 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
 	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
+	SYS_EXIT, // Exit current process
+	SYS_BOOT, // Boot functions (e.g. reboot/shutdown)
 	SYS_YIELD, // Switch to next process
 	SYS_TIME, // Get kernel time
 	SYS_NET_OPEN, // Open network socket
@@ -70,6 +76,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__)
@@ -80,12 +87,15 @@ int sysv(enum sys num, ...);
 			yield();                                                                   \
 		}                                                                                  \
 	}
-#define yield(void) (int)sys0(SYS_YIELD)
+#define boot(cmd) (s32) sys2(SYS_BOOT, SYS_BOOT_MAGIC, cmd)
+#define yield(void) (s32) sys0(SYS_YIELD)
 #define time(void) (u32) sys0(SYS_TIME)
 
 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/libc/mem.c b/libc/mem.c
index 971315a..95242e4 100644
--- a/libc/mem.c
+++ b/libc/mem.c
@@ -66,12 +66,13 @@ void *memcpy(void *dest, const void *src, u32 n)
 
 void *memset(void *dest, int val, u32 n)
 {
+	u32 uval = val;
 	u32 num_dwords = n / 4;
 	u32 num_bytes = n % 4;
 	u32 *dest32 = (u32 *)dest;
 	u8 *dest8 = ((u8 *)dest) + num_dwords * 4;
 	u8 val8 = (u8)val;
-	u32 val32 = val | (val << 8) | (val << 16) | (val << 24);
+	u32 val32 = uval | (uval << 8) | (uval << 16) | (uval << 24);
 
 	// TODO: What's faster?
 	__asm__ volatile("rep stosl\n"
@@ -118,351 +119,3 @@ int mememp(const u8 *buf, u32 n)
 {
 	return buf[0] == 0 && !memcmp(buf, buf + 1, n - 1);
 }
-
-/**
- * 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_INIT_SIZE 0xf000000
-#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;
-};
-
-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)
-{
-	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;
-	}
-}
-
-static void node_remove(struct h_bin *bin, struct h_node *node)
-{
-	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;
-	}
-}
-
-static struct h_node *node_best_fit(struct h_bin *bin, u32 size)
-{
-	if (!bin->head)
-		return NULL;
-
-	struct h_node *temp = bin->head;
-	while (temp) {
-		if (temp->size >= size)
-			return temp;
-		temp = temp->next;
-	}
-	return NULL;
-}
-
-/* static struct h_node *node_last(struct h_bin *bin) */
-/* { */
-/* 	struct h_node *temp = bin->head; */
-/* 	while (temp->next) */
-/* 		temp = temp->next; */
-/* 	return temp; */
-/* } */
-
-static struct h_footer *node_foot(struct h_node *node)
-{
-	return (struct h_footer *)((char *)node + sizeof(*node) + node->size);
-}
-
-static void node_create_foot(struct h_node *head)
-{
-	struct h_footer *foot = node_foot(head);
-	foot->header = head;
-}
-
-static u32 bin_index(u32 sz)
-{
-	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;
-}
-
-/* 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)
-{
-	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;
-}
-
-#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);
-
-	while (!found) {
-		assert(index + 1 < BIN_COUNT);
-
-		temp = &heap.bins[++index];
-		found = node_best_fit(temp, size);
-	}
-
-	assert(found->magic == HEAP_MAGIC);
-
-	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;
-
-		node_create_foot(split);
-
-		u32 new_idx = bin_index(split->size);
-
-		node_add(&heap.bins[new_idx], split);
-
-		found->size = size;
-		node_create_foot(found);
-	}
-
-	found->hole = 0;
-	node_remove(&heap.bins[index], found);
-
-	// 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)); */
-	/* } */
-
-	found->prev = NULL;
-	found->next = NULL;
-	return &found->next;
-}
-
-static void _free(void *p)
-{
-	if (!p)
-		return;
-
-	struct h_bin *list;
-	struct h_footer *new_foot, *old_foot;
-
-	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;
-	}
-
-	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 (prev->hole) {
-		list = &heap.bins[bin_index(prev->size)];
-		node_remove(list, prev);
-
-		prev->size += OVERHEAD + head->size;
-		new_foot = node_foot(head);
-		new_foot->header = prev;
-
-		head = prev;
-	}
-
-	if (next->hole) {
-		list = &heap.bins[bin_index(next->size)];
-		node_remove(list, next);
-
-		head->size += OVERHEAD + next->size;
-
-		old_foot = node_foot(next);
-		old_foot->header = 0;
-		next->size = 0;
-		next->hole = 0;
-
-		new_foot = node_foot(head);
-		new_foot->header = head;
-	}
-
-	head->hole = 1;
-	node_add(&heap.bins[bin_index(head->size)], head);
-}
-
-#elif defined(userspace)
-
-#define kmalloc(n) (void *)sys1(SYS_MALLOC, n)
-#define kfree(ptr) (void)(sys1(SYS_FREE, (int)ptr))
-
-static void *_malloc(u32 size)
-{
-	return kmalloc(size);
-}
-
-static void _free(void *ptr)
-{
-	kfree(ptr);
-}
-
-#endif
-
-#ifdef kernel
-#define PREFIX "K"
-#define FUNC printf
-#else
-#define PREFIX "U"
-#define FUNC log
-#endif
-
-void *zalloc(u32 size)
-{
-	void *ret = malloc(size);
-	memset(ret, 0, size);
-	return ret;
-}
-
-// Naive realloc implementation - TODO!
-void *realloc(void *ptr, u32 size)
-{
-	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;
-	*/
-}
-
-void *malloc_debug(u32 size, const char *file, int line, const char *func, const char *inp)
-{
-	assert(size < (100 << 20)); // Don't brag with memory pls
-	void *ret = _malloc(size);
-
-	(void)file;
-	(void)line;
-	(void)func;
-	(void)inp;
-	/* FUNC(PREFIX "MALLOC\t%s:%d: %s: 0x%x %dB (%s)\n", file, line, func, ret, size, inp); */
-	return ret;
-}
-
-void free_debug(void *ptr, const char *file, int line, const char *func, const char *inp)
-{
-	if (ptr)
-		_free(ptr);
-
-	(void)file;
-	(void)line;
-	(void)func;
-	(void)inp;
-	/* FUNC(PREFIX "FREE\t%s:%d: %s: 0x%x (%s)\n", file, line, func, ptr, inp); */
-}
diff --git a/libc/print.c b/libc/print.c
index 91ecf8f..1c577e5 100644
--- a/libc/print.c
+++ b/libc/print.c
@@ -214,9 +214,23 @@ int print(const char *str)
 	return strlen(str);
 }
 
+void print_trace(u32 count)
+{
+	struct frame {
+		struct frame *ebp;
+		u32 eip;
+	} * stk;
+	__asm__ volatile("movl %%ebp, %0;" : "=r"(stk));
+	print("EBP\tEIP\n");
+	for (u32 i = 0; stk && i < count; i++) {
+		printf("0x%x\t0x%x\n", stk->ebp, stk->eip);
+		stk = stk->ebp;
+	}
+}
+
 #endif
 
-void panic(const char *format, ...)
+NORETURN void panic(const char *format, ...)
 {
 	char buf[1024] = { 0 };
 	va_list ap;
@@ -224,6 +238,7 @@ void panic(const char *format, ...)
 	vsprintf(buf, format, ap);
 	va_end(ap);
 #ifdef kernel
+	print("--- DON'T PANIC! ---\n");
 	print(buf);
 	loop();
 #else
diff --git a/libc/random.c b/libc/random.c
index 8c8076f..cfd082d 100644
--- a/libc/random.c
+++ b/libc/random.c
@@ -1,5 +1,6 @@
 // MIT License, Copyright (c) 2020 Marvin Borner
 
+#include <cpu.h>
 #include <def.h>
 #include <mem.h>
 #include <random.h>
@@ -11,6 +12,34 @@ void srand(u32 seed)
 	g_seed = seed;
 }
 
+u32 rdrand(void)
+{
+#ifdef kernel
+	if (!cpu_has_cfeature(CPUID_FEAT_ECX_RDRND))
+		return rand();
+
+	u32 rd;
+	__asm__ volatile("rdrand %%eax" : "=a"(rd));
+	return rd;
+#else
+	return rand();
+#endif
+}
+
+u32 rdseed(void)
+{
+#ifdef kernel
+	if (!cpu_has_cfeature(CPUID_FEAT_ECX_RDRND))
+		return rand();
+
+	u32 rd;
+	__asm__ volatile("rdseed %%eax" : "=a"(rd));
+	return rd;
+#else
+	return rand();
+#endif
+}
+
 u32 rand(void)
 {
 	g_seed = g_seed * 1103515245 + 12345;
diff --git a/libc/sanitize.c b/libc/sanitize.c
index 983b10f..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");
 }
@@ -97,28 +97,40 @@ void __ubsan_handle_vla_bound_not_positive(void)
 	panic("UBSAN: vla-bound-not-positive\n");
 }
 
-void __ubsan_handle_add_overflow(void);
-void __ubsan_handle_add_overflow(void)
+void __ubsan_handle_add_overflow(struct overflow *data, void *left, void *right);
+void __ubsan_handle_add_overflow(struct overflow *data, void *left, void *right)
 {
-	panic("UBSAN: add-overflow\n");
+	UNUSED(left);
+	UNUSED(right);
+	struct source_location *loc = &data->location;
+	panic("%s:%d: UBSAN: add-overflow [type: %s]\n", loc->file, loc->line, data->type->name);
 }
 
-void __ubsan_handle_sub_overflow(void);
-void __ubsan_handle_sub_overflow(void)
+void __ubsan_handle_sub_overflow(struct overflow *data, void *left, void *right);
+void __ubsan_handle_sub_overflow(struct overflow *data, void *left, void *right)
 {
-	panic("UBSAN: sub-overflow\n");
+	UNUSED(left);
+	UNUSED(right);
+	struct source_location *loc = &data->location;
+	panic("%s:%d: UBSAN: sub-overflow [type: %s]\n", loc->file, loc->line, data->type->name);
 }
 
-void __ubsan_handle_negate_overflow(void);
-void __ubsan_handle_negate_overflow(void)
+void __ubsan_handle_negate_overflow(struct overflow *data, void *left, void *right);
+void __ubsan_handle_negate_overflow(struct overflow *data, void *left, void *right)
 {
-	panic("UBSAN: negate-overflow\n");
+	UNUSED(left);
+	UNUSED(right);
+	struct source_location *loc = &data->location;
+	panic("%s:%d: UBSAN: negate-overflow [type: %s]\n", loc->file, loc->line, data->type->name);
 }
 
-void __ubsan_handle_mul_overflow(void);
-void __ubsan_handle_mul_overflow(void)
+void __ubsan_handle_mul_overflow(struct overflow *data, void *left, void *right);
+void __ubsan_handle_mul_overflow(struct overflow *data, void *left, void *right)
 {
-	panic("UBSAN: mul-overflow\n");
+	UNUSED(left);
+	UNUSED(right);
+	struct source_location *loc = &data->location;
+	panic("%s:%d: UBSAN: mul-overflow [type: %s]\n", loc->file, loc->line, data->type->name);
 }
 
 void __ubsan_handle_shift_out_of_bounds(void);