Renamed files to match presentation

48 files changed, 653 insertions, 653 deletions

diff --git a/example/segelboot.cfg b/example/segelboot.cfg
index d30fc0d..640ebca 100644
--- a/example/segelboot.cfg
+++ b/example/segelboot.cfg
@@ -1,5 +1,8 @@
 TIMEOUT=10
 
+# Melvix
+PATH=hda0:/apps/kernel/exec
+
 # Multiboot 1
 PATH=hda0:/boot/mb1.elf
 
diff --git a/makefile b/makefile
index 6619bb8..47f8537 100644
--- a/makefile
+++ b/makefile
@@ -34,7 +34,7 @@ all: dir $(BLD)/boot.bin mb1 mb2
 dir:
 	@mkdir -p $(BLD)/entry/
 	@mkdir -p $(BLD)/loader/fs/
-	@mkdir -p $(BLD)/loader/impl/
+	@mkdir -p $(BLD)/loader/protocols/
 
 mb1:
 	@$(MAKE) --no-print-directory -C example/$@
diff --git a/run b/run
index ee456ae..129b1d9 100755
--- a/run
+++ b/run
@@ -98,6 +98,10 @@ build() {
     $SUDO mkdir -p mnt/boot/
     $SUDO cp example/segelboot.cfg mnt/boot/
     $SUDO cp build/examples/* mnt/boot/
+
+    $SUDO cp -r "$HOME"/code/melvix/disk/* mnt/ || true
+    $SUDO cp -r "$HOME"/code/melvix/build/apps/ mnt/apps/ || true
+
     $SUDO umount mnt/ || (sync && $SUDO umount mnt/)
     rm -rf mnt/
 
diff --git a/src/loader/a20.c b/src/loader/a20.c
index b59500a..ecb4594 100644
--- a/src/loader/a20.c
+++ b/src/loader/a20.c
@@ -4,8 +4,8 @@
 #include <a20.h>
 #include <cpu.h>
 #include <def.h>
-#include <pnc.h>
-#include <rem.h>
+#include <panic.h>
+#include <real.h>
 
 static u8 a20_check(void)
 {
@@ -26,9 +26,9 @@ void a20_enable(void)
 		return;
 
 	// BIOS method
-	struct rem_regs r = { 0 };
+	struct real_regs r = { 0 };
 	r.eax = 0x2401;
-	rem_int(0x15, &r, &r);
+	real_int(0x15, &r, &r);
 
 	if (a20_check())
 		return;
diff --git a/src/loader/acpi.c b/src/loader/acpi.c
index f7e958c..b010a6a 100644
--- a/src/loader/acpi.c
+++ b/src/loader/acpi.c
@@ -1,8 +1,8 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
 #include <acpi.h>
-#include <lib.h>
-#include <pnc.h>
+#include <library.h>
+#include <panic.h>
 
 /**
  * General SDP
diff --git a/src/loader/cfg.c b/src/loader/config.c
index bbe215a..2471d87 100644
--- a/src/loader/cfg.c
+++ b/src/loader/config.c
@@ -1,11 +1,11 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
-#include <cfg.h>
-#include <dev.h>
-#include <impl/all.h>
-#include <lib.h>
+#include <config.h>
+#include <device.h>
+#include <protocols/all.h>
+#include <library.h>
 #include <log.h>
-#include <pnc.h>
+#include <panic.h>
 
 // Keys
 #define TIMEOUT "TIMEOUT"
@@ -18,7 +18,7 @@ static struct cfg cfg = { 0 };
 static char file[1024] = { 0 };
 
 // Find config file
-static u8 cfg_find(struct dev *dev)
+static u8 config_find(struct dev *dev)
 {
 	if (!dev->p.disk.fs.read)
 		return 0; // No fs found or not readable - continue!
@@ -32,31 +32,31 @@ static u8 cfg_find(struct dev *dev)
 }
 
 // Checks if index is appropriate as some key/value need to be in entry
-static void cfg_in_entry(u8 index)
+static void config_in_entry(u8 index)
 {
 	if (index == 0xff)
 		panic("No entry name given\n");
 }
 
 // Add/overwrite value by key and entry index
-static void cfg_add(u8 index, enum cfg_key key, const char *value)
+static void config_add(u8 index, enum config_key key, const char *value)
 {
-	struct cfg_entry *entry = &cfg.entry[index];
+	struct config_entry *entry = &cfg.entry[index];
 	entry->exists = 1;
 
 	switch (key) {
-	case CFG_NAME:
-		cfg_in_entry(index);
+	case CONFIG_NAME:
+		config_in_entry(index);
 		strlcpy(entry->name, value, sizeof(entry->name));
 		break;
-	case CFG_TIMEOUT:
+	case CONFIG_TIMEOUT:
 		cfg.timeout = atoi(value);
 		break;
-	case CFG_PATH:
-		cfg_in_entry(index);
+	case CONFIG_PATH:
+		config_in_entry(index);
 		strlcpy(entry->full_path, value, sizeof(entry->full_path));
 		break;
-	case CFG_NONE:
+	case CONFIG_NONE:
 	default:
 		panic("Invalid config\n");
 	}
@@ -64,7 +64,7 @@ static void cfg_add(u8 index, enum cfg_key key, const char *value)
 
 // TODO: This code is kind of messy
 // Structure per line: KEY=VALUE
-static void cfg_parse(void)
+static void config_parse(void)
 {
 	// Entry index
 	u8 entry = 0xff;
@@ -74,7 +74,7 @@ static void cfg_parse(void)
 	u8 value_index = 0;
 
 	// States
-	enum cfg_key current = CFG_NONE; // Value key type
+	enum config_key current = CONFIG_NONE; // Value key type
 	u8 state = 0; // 0 is key, 1 is value, 2 is entry
 
 	const char *start = file; // Start is at the beginning of the key
@@ -96,14 +96,14 @@ static void cfg_parse(void)
 
 			// Timeout key
 			if (diff == sizeof(TIMEOUT) - 1 && memcmp(start, TIMEOUT, diff) == 0) {
-				current = CFG_TIMEOUT;
+				current = CONFIG_TIMEOUT;
 				state = 1;
 				continue;
 			}
 
 			// Path key
 			if (diff == sizeof(PATH) - 1 && memcmp(start, PATH, diff) == 0) {
-				current = CFG_PATH;
+				current = CONFIG_PATH;
 				state = 1;
 				continue;
 			}
@@ -112,7 +112,7 @@ static void cfg_parse(void)
 			assert(value_index + 1 < (u8)sizeof(value));
 			if (*p == '\n') { // Finished
 				value[value_index] = 0;
-				cfg_add(entry, current, value);
+				config_add(entry, current, value);
 				value_index = 0;
 				state = 0;
 				p--; // Repeat parse normally
@@ -125,7 +125,7 @@ static void cfg_parse(void)
 			if (*p == '\n') { // Finished
 				entry = entry == 0xff ? 0 : entry + 1;
 				value[value_index] = 0;
-				cfg_add(entry, CFG_NAME, value);
+				config_add(entry, CONFIG_NAME, value);
 				value_index = 0;
 				state = 0;
 				p--; // Repeat parse normally
@@ -138,7 +138,7 @@ static void cfg_parse(void)
 
 // Extract the disk from path by returning index of delimiter or 0xff
 // Example: disk:/boot/config.cfg returns 4 (:)
-static u8 cfg_path_disk(const char *path)
+static u8 config_path_disk(const char *path)
 {
 	for (const char *p = path; *p; p++)
 		if (*p == ':')
@@ -147,14 +147,14 @@ static u8 cfg_path_disk(const char *path)
 }
 
 // Find matching disk dev for every entry and verify path existence and readability
-static void cfg_verify(void)
+static void config_verify(void)
 {
 	for (u8 i = 0; i < COUNT(cfg.entry) && cfg.entry[i].exists; i++) {
-		struct cfg_entry *entry = &cfg.entry[i];
+		struct config_entry *entry = &cfg.entry[i];
 
-		u8 len = cfg_path_disk(entry->full_path);
-		struct dev *dev = dev_get_by_name(entry->full_path, len);
-		if (!dev || dev->type != DEV_DISK)
+		u8 len = config_path_disk(entry->full_path);
+		struct dev *dev = device_get_by_name(entry->full_path, len);
+		if (!dev || dev->type != DEVICE_DISK)
 			panic("Invalid device in config\n");
 		entry->dev = dev;
 
@@ -176,7 +176,7 @@ static void cfg_verify(void)
 }
 
 // Call cb for each entry config
-void cfg_foreach(u8 (*cb)(struct cfg_entry *))
+void config_foreach(u8 (*cb)(struct config_entry *))
 {
 	for (u8 i = 0; i < COUNT(cfg.entry) && cfg.entry[i].exists; i++) {
 		if (cb(&cfg.entry[i])) // 1 means break
@@ -185,7 +185,7 @@ void cfg_foreach(u8 (*cb)(struct cfg_entry *))
 }
 
 // Print all configs and entry values
-static void cfg_print(void)
+static void config_print(void)
 {
 	log("[CFG] Global: %d\n", cfg.timeout);
 
@@ -194,17 +194,17 @@ static void cfg_print(void)
 }
 
 // Execute entry implementation
-void cfg_exec(struct cfg_entry *entry)
+void config_exec(struct config_entry *entry)
 {
 	impl_exec(entry);
 }
 
-void cfg_read(void)
+void config_read(void)
 {
-	dev_foreach(DEV_DISK, &cfg_find);
+	device_foreach(DEVICE_DISK, &config_find);
 	if (!file[0])
 		panic("No config found\n");
-	cfg_parse();
-	cfg_verify();
-	cfg_print();
+	config_parse();
+	config_verify();
+	config_print();
 }
diff --git a/src/loader/dev.c b/src/loader/device.c
index 2a57b02..9c3e2ee 100644
--- a/src/loader/dev.c
+++ b/src/loader/device.c
@@ -1,32 +1,32 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 // Device manager
 
-#include <dev.h>
-#include <lib.h>
-#include <pnc.h>
+#include <device.h>
+#include <library.h>
+#include <panic.h>
 
 static struct dev devices[32] = { 0 };
 
-static const char *dev_resolve_type(enum dev_type type)
+static const char *device_resolve_type(enum device_type type)
 {
 	switch (type) {
-	case DEV_DISK:
+	case DEVICE_DISK:
 		return "Disk";
-	case DEV_FB:
+	case DEVICE_FB:
 		return "Framebuffer";
-	case DEV_NONE:
+	case DEVICE_NONE:
 	default:
 		return "Unknown";
 	}
 }
 
-struct dev *dev_get_by_id(u8 id)
+struct dev *device_get_by_id(u8 id)
 {
 	assert(id < COUNT(devices));
 	return &devices[id];
 }
 
-struct dev *dev_get_by_name(const char *name, u32 len)
+struct dev *device_get_by_name(const char *name, u32 len)
 {
 	if (!name || !name[0])
 		return NULL;
@@ -40,7 +40,7 @@ struct dev *dev_get_by_name(const char *name, u32 len)
 	return NULL;
 }
 
-void dev_foreach(enum dev_type type, u8 (*cb)(struct dev *))
+void device_foreach(enum device_type type, u8 (*cb)(struct dev *))
 {
 	for (u8 i = 0; i < COUNT(devices); i++) {
 		struct dev *dev = &devices[i];
@@ -50,7 +50,7 @@ void dev_foreach(enum dev_type type, u8 (*cb)(struct dev *))
 	}
 }
 
-u8 dev_register(enum dev_type type, char *name, u32 data,
+u8 device_register(enum device_type type, char *name, u32 data,
 		s32 (*read)(void *, u32, u32, struct dev *),
 		s32 (*write)(const void *, u32, u32, struct dev *))
 {
@@ -67,18 +67,18 @@ u8 dev_register(enum dev_type type, char *name, u32 data,
 	assert(strlen(name) < sizeof(dev->name));
 	memcpy(dev->name, name, sizeof(dev->name));
 
-	if (type == DEV_DISK)
-		dsk_detect(dev);
+	if (type == DEVICE_DISK)
+		disk_detect(dev);
 
 	return id;
 }
 
-void dev_print(void)
+void device_print(void)
 {
 	for (u8 i = 0; i < COUNT(devices); i++) {
 		struct dev *dev = &devices[i];
 		if (!dev->id)
 			continue;
-		log("[DEV] %d: %s device: %s\n", dev->id, dev_resolve_type(dev->type), dev->name);
+		log("[DEV] %d: %s device: %s\n", dev->id, device_resolve_type(dev->type), dev->name);
 	}
 }
diff --git a/src/loader/dsk.c b/src/loader/disk.c
index 5e8fc3d..42ec772 100644
--- a/src/loader/dsk.c
+++ b/src/loader/disk.c
@@ -1,14 +1,14 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
-#include <dsk.h>
+#include <disk.h>
 #include <fs/ext2.h>
 #include <log.h>
 #include <mbr.h>
-#include <pnc.h>
+#include <panic.h>
 
-void dsk_detect(struct dev *dev)
+void disk_detect(struct dev *dev)
 {
-	assert(dev->type == DEV_DISK);
+	assert(dev->type == DEVICE_DISK);
 
 	if (mbr_detect(dev))
 		return;
diff --git a/src/loader/elf.c b/src/loader/elf.c
index 3f5aea3..de596cf 100644
--- a/src/loader/elf.c
+++ b/src/loader/elf.c
@@ -1,11 +1,11 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
 #include <elf.h>
-#include <pnc.h>
+#include <panic.h>
 
 u32 elf_load(struct dev *dev, const char *path)
 {
-	assert(dev->type == DEV_DISK);
+	assert(dev->type == DEVICE_DISK);
 
 	struct elf_header header = { 0 };
 	s32 rd = dev->p.disk.fs.read(path, &header, 0, sizeof(header), dev);
diff --git a/src/loader/format.c b/src/loader/format.c
new file mode 100644
index 0000000..34327af
--- /dev/null
+++ b/src/loader/format.c
@@ -0,0 +1,60 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#include <library.h>
+#include <log.h>
+
+/**
+ * Formatting
+ */
+
+u32 vsnprintf(char *str, u32 size, const char *format, va_list ap)
+{
+	u32 length = 0;
+
+	int temp_int;
+	char temp_ch;
+	char *temp_str;
+
+	char buffer[64] = { 0 };
+
+	// TODO: Fix potential memory overflows because of str[length++]=xxx
+	char ch;
+	while ((ch = *format++)) {
+		if (ch == '%') {
+			switch (*format++) {
+			case '%':
+				str[length++] = '%';
+				break;
+			case 'c':
+				temp_ch = va_arg(ap, int);
+				str[length++] = temp_ch;
+				break;
+			case 's':
+				temp_str = va_arg(ap, char *);
+				length += strlcpy(&str[length], temp_str, size - length);
+				break;
+			case 'b':
+				temp_int = va_arg(ap, int);
+				itoa(temp_int, buffer, 2);
+				length += strlcpy(&str[length], buffer, size - length);
+				break;
+			case 'd':
+				temp_int = va_arg(ap, int);
+				itoa(temp_int, buffer, 10);
+				length += strlcpy(&str[length], buffer, size - length);
+				break;
+			case 'x':
+				temp_int = va_arg(ap, int);
+				itoa(temp_int, buffer, 16);
+				length += strlcpy(&str[length], buffer, size - length);
+				break;
+			default:
+				serial_print("Unknown printf format\n");
+			}
+		} else {
+			str[length++] = ch;
+		}
+	}
+
+	return length;
+}
diff --git a/src/loader/fs/ext2.c b/src/loader/fs/ext2.c
index 72fd3c0..3b2154b 100644
--- a/src/loader/fs/ext2.c
+++ b/src/loader/fs/ext2.c
@@ -1,9 +1,9 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
-#include <dev.h>
+#include <device.h>
 #include <fs/ext2.h>
-#include <lib.h>
-#include <pnc.h>
+#include <library.h>
+#include <panic.h>
 
 static void ext2_buffer_read(u32 block, void *buf, struct dev *dev)
 {
diff --git a/src/loader/gui.c b/src/loader/gui.c
index 6ae35e6..2932dcc 100644
--- a/src/loader/gui.c
+++ b/src/loader/gui.c
@@ -1,19 +1,19 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 // GUI - selection interface
 
-#include <cfg.h>
+#include <config.h>
 #include <cpu.h>
 #include <def.h>
 #include <gui.h>
-#include <int.h>
+#include <interrupt.h>
 #include <log.h>
-#include <pnc.h>
+#include <panic.h>
 
-struct {
-	struct cfg_entry *cfg;
+static struct {
+	struct config_entry *cfg;
 } gui_entries[16] = { 0 };
 
-static u8 gui_entry_add(struct cfg_entry *entry)
+static u8 gui_entry_add(struct config_entry *entry)
 {
 	static u8 index = 0;
 	assert(index + 1 < (u8)sizeof(gui_entries));
@@ -32,7 +32,7 @@ static u8 gui_entry_exists(u8 entry)
 static void gui_entry_select(u8 entry)
 {
 	if (gui_entry_exists(entry))
-		cfg_exec(gui_entries[entry].cfg);
+		config_exec(gui_entries[entry].cfg);
 	else
 		log("Invalid selection\n");
 }
@@ -71,8 +71,8 @@ void gui_draw(void)
 	vga_clear();
 	vga_log("SegelBoot by Marvin Borner\n\n");
 
-	cfg_foreach(&gui_entry_add);
+	config_foreach(&gui_entry_add);
 	gui_entries_draw();
 
-	int_event_handler_add(1, &gui_keyboard_handler);
+	interrupt_event_handler_add(1, &gui_keyboard_handler);
 }
diff --git a/src/loader/ide.c b/src/loader/ide.c
index c5461d0..7fb405a 100644
--- a/src/loader/ide.c
+++ b/src/loader/ide.c
@@ -2,13 +2,11 @@
 
 #include <cpu.h>
 #include <def.h>
-#include <dev.h>
+#include <device.h>
 #include <ide.h>
-#include <lib.h>
+#include <library.h>
 #include <log.h>
-#include <pnc.h>
-
-static u8 ide_buf[SECTOR_SIZE] = { 0 };
+#include <panic.h>
 
 static void ide_select_drive(u8 bus, u8 drive)
 {
@@ -27,6 +25,8 @@ static void ide_select_drive(u8 bus, u8 drive)
 
 static u8 ide_find(u8 bus, u8 drive)
 {
+	static u8 ide_buf[SECTOR_SIZE] = { 0 };
+
 	u16 io = bus == ATA_PRIMARY ? ATA_PRIMARY_IO : ATA_SECONDARY_IO;
 	ide_select_drive(bus, drive);
 
@@ -113,7 +113,7 @@ static void ata_probe(void)
 		name[2] = 'a' + i;
 
 		// Register without write support
-		dev_register(DEV_DISK, name, data, ata_read, NULL);
+		device_register(DEVICE_DISK, name, data, ata_read, NULL);
 	}
 }
 
diff --git a/src/loader/inc/cfg.h b/src/loader/inc/cfg.h
deleted file mode 100644
index cb91ab2..0000000
--- a/src/loader/inc/cfg.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// MIT License, Copyright (c) 2021 Marvin Borner
-
-#ifndef CFG_H
-#define CFG_H
-
-#include <def.h>
-#include <impl.h>
-
-extern u8 boot_disk;
-
-// Global config element index (can actually be anything but wth)
-#define CFG_GLOBAL 0
-
-enum cfg_key {
-	CFG_NONE,
-	CFG_NAME,
-	CFG_TIMEOUT,
-	CFG_PATH,
-};
-
-struct cfg_entry {
-	u8 exists : 1;
-	char name[64];
-	char full_path[64]; // With disk name
-	const char *path; // Without disk name
-	struct dev *dev;
-	struct impl impl;
-};
-
-struct cfg {
-	u32 timeout;
-	struct cfg_entry entry[16]; // Up to 16 different entries
-};
-
-void cfg_foreach(u8 (*cb)(struct cfg_entry *));
-void cfg_exec(struct cfg_entry *entry);
-void cfg_read(void);
-
-#endif
diff --git a/src/loader/inc/config.h b/src/loader/inc/config.h
new file mode 100644
index 0000000..4f2d7dc
--- /dev/null
+++ b/src/loader/inc/config.h
@@ -0,0 +1,39 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include <def.h>
+#include <protocol.h>
+
+extern u8 boot_disk;
+
+// Global config element index (can actually be anything but wth)
+#define CONFIG_GLOBAL 0
+
+enum config_key {
+	CONFIG_NONE,
+	CONFIG_NAME,
+	CONFIG_TIMEOUT,
+	CONFIG_PATH,
+};
+
+struct config_entry {
+	u8 exists : 1;
+	char name[64];
+	char full_path[64]; // With disk name
+	const char *path; // Without disk name
+	struct dev *dev;
+	struct impl impl;
+};
+
+struct cfg {
+	u32 timeout;
+	struct config_entry entry[16]; // Up to 16 different entries
+};
+
+void config_foreach(u8 (*cb)(struct config_entry *));
+void config_exec(struct config_entry *entry);
+void config_read(void);
+
+#endif
diff --git a/src/loader/inc/dev.h b/src/loader/inc/device.h
index cbefe99..5081cb7 100644
--- a/src/loader/inc/dev.h
+++ b/src/loader/inc/device.h
@@ -1,20 +1,20 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
-#ifndef DEV_H
-#define DEV_H
+#ifndef DEVICE_H
+#define DEVICE_H
 
 #include <def.h>
-#include <dsk.h>
+#include <disk.h>
 
-enum dev_type {
-	DEV_NONE,
-	DEV_DISK,
-	DEV_FB,
+enum device_type {
+	DEVICE_NONE,
+	DEVICE_DISK,
+	DEVICE_FB,
 };
 
 struct dev {
 	u8 id;
-	enum dev_type type;
+	enum device_type type;
 	char name[16];
 
 	s32 (*read)(void *, u32, u32, struct dev *);
@@ -30,12 +30,12 @@ struct dev {
 	u32 data; // Optional (device-specific) data/information
 };
 
-struct dev *dev_get_by_id(u8 id);
-struct dev *dev_get_by_name(const char *name, u32 len);
-void dev_foreach(enum dev_type type, u8 (*cb)(struct dev *)); // cb=1 => break
-u8 dev_register(enum dev_type type, char *name, u32 data,
+struct dev *device_get_by_id(u8 id);
+struct dev *device_get_by_name(const char *name, u32 len);
+void device_foreach(enum device_type type, u8 (*cb)(struct dev *)); // cb=1 => break
+u8 device_register(enum device_type type, char *name, u32 data,
 		s32 (*read)(void *, u32, u32, struct dev *),
 		s32 (*write)(const void *, u32, u32, struct dev *));
-void dev_print(void);
+void device_print(void);
 
 #endif
diff --git a/src/loader/inc/dsk.h b/src/loader/inc/disk.h
index 5b2dec9..e4fb285 100644
--- a/src/loader/inc/dsk.h
+++ b/src/loader/inc/disk.h
@@ -1,7 +1,7 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
-#ifndef DSK_H
-#define DSK_H
+#ifndef DISK_H
+#define DISK_H
 
 #include <def.h>
 
@@ -16,6 +16,6 @@ struct fs {
 	s32 (*read)(const char *, void *, u32, u32, struct dev *);
 };
 
-void dsk_detect(struct dev *dev);
+void disk_detect(struct dev *dev);
 
 #endif
diff --git a/src/loader/inc/elf.h b/src/loader/inc/elf.h
index 4b19f2f..9cf5c2b 100644
--- a/src/loader/inc/elf.h
+++ b/src/loader/inc/elf.h
@@ -5,7 +5,7 @@
 #define ELF_H
 
 #include <def.h>
-#include <dev.h>
+#include <device.h>
 
 #define ELF_MAG0 0x7F
 #define ELF_MAG1 'E'
diff --git a/src/loader/inc/fs/ext2.h b/src/loader/inc/fs/ext2.h
index 0c2052a..ce19ddb 100644
--- a/src/loader/inc/fs/ext2.h
+++ b/src/loader/inc/fs/ext2.h
@@ -4,7 +4,7 @@
 #define FS_EXT2_H
 
 #include <def.h>
-#include <dev.h>
+#include <device.h>
 
 #define EXT2_BOOT 0
 #define EXT2_SUPER 1
diff --git a/src/loader/inc/int.h b/src/loader/inc/interrupt.h
index ccd9ea8..4706dbe 100644
--- a/src/loader/inc/int.h
+++ b/src/loader/inc/interrupt.h
@@ -1,13 +1,13 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
-#ifndef INT_H
-#define INT_H
+#ifndef INTERRUPT_H
+#define INTERRUPT_H
 
 #include <def.h>
 
-#define INT_GATE 0x8e
-#define INT_TRAP 0xef
-#define INT_USER 0x60
+#define INTERRUPT_GATE 0x8e
+#define INTERRUPT_TRAP 0xef
+#define INTERRUPT_USER 0x60
 #define IDT_ENTRY(offset, selector, type)                                                          \
 	(struct idt_entry)                                                                         \
 	{                                                                                          \
@@ -15,17 +15,17 @@
 		.base_high = (u16)(((offset) >> 16) & 0xffff),                                     \
 	}
 
-struct int_frame {
+struct interrupt_frame {
 	u32 gs, fs, es, ds;
 	u32 edi, esi, ebp, esp, ebx, edx, ecx, eax;
-	u32 int_no, err_code;
+	u32 interrupt_no, err_code;
 	u32 eip, cs, eflags;
 } PACKED;
 
-struct int_frame_user {
+struct interrupt_frame_user {
 	u32 gs, fs, es, ds;
 	u32 edi, esi, ebp, esp, ebx, edx, ecx, eax;
-	u32 int_no, err_code;
+	u32 interrupt_no, err_code;
 	u32 eip, cs, eflags;
 	u32 useresp, ss;
 } PACKED;
@@ -44,6 +44,6 @@ struct idt_ptr {
 } PACKED;
 
 void idt_install(void);
-void int_event_handler_add(u32 int_no, void (*handler)(void));
+void interrupt_event_handler_add(u32 interrupt_no, void (*handler)(void));
 
 #endif
diff --git a/src/loader/inc/lib.h b/src/loader/inc/library.h
index 2f49007..2f49007 100644
--- a/src/loader/inc/lib.h
+++ b/src/loader/inc/library.h
diff --git a/src/loader/inc/log.h b/src/loader/inc/log.h
index cb1acd8..f6a28e1 100644
--- a/src/loader/inc/log.h
+++ b/src/loader/inc/log.h
@@ -5,13 +5,14 @@
 
 #include <def.h>
 
+u32 vsnprintf(char *str, u32 size, const char *format, va_list ap);
+
 void serial_install(void);
 void serial_print(const char *data);
+void log(const char *format, ...);
 
 void vga_put_at(char ch, u8 x, u8 y, u8 color);
 void vga_clear(void);
-
-void log(const char *format, ...);
 void vga_log(const char *format, ...);
 
 #endif
diff --git a/src/loader/inc/mbr.h b/src/loader/inc/mbr.h
index a9befe5..ec51944 100644
--- a/src/loader/inc/mbr.h
+++ b/src/loader/inc/mbr.h
@@ -4,7 +4,7 @@
 #define MBR_H
 
 #include <def.h>
-#include <dev.h>
+#include <device.h>
 
 struct mbr_entry {
 	u8 attributes;
diff --git a/src/loader/inc/mem.h b/src/loader/inc/mem.h
deleted file mode 100644
index 7153465..0000000
--- a/src/loader/inc/mem.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// MIT License, Copyright (c) 2021 Marvin Borner
-
-#ifndef MEM_H
-#define MEM_H
-
-#include <def.h>
-
-enum mem_entry_type {
-	MEM_NONE,
-	MEM_USABLE,
-	MEM_RESERVED,
-	MEM_RECLAIMABLE,
-	MEM_ACPI_NVS,
-	MEM_UNUSABLE,
-};
-
-// Generalised memory map entry struct
-struct mem_entry {
-	u32 base;
-	u32 length;
-	u32 type;
-};
-
-struct mem_map {
-	struct mem_entry *entry;
-	u32 count;
-};
-
-void mem_map(void);
-struct mem_map *mem_map_get(void);
-
-#endif
diff --git a/src/loader/inc/memory.h b/src/loader/inc/memory.h
new file mode 100644
index 0000000..1a74884
--- /dev/null
+++ b/src/loader/inc/memory.h
@@ -0,0 +1,32 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#ifndef MEMORY_H
+#define MEMORY_H
+
+#include <def.h>
+
+enum memory_entry_type {
+	MEMORY_NONE,
+	MEMORY_USABLE,
+	MEMORY_RESERVED,
+	MEMORY_RECLAIMABLE,
+	MEMORY_ACPI_NVS,
+	MEMORY_UNUSABLE,
+};
+
+// Generalised memory map entry struct
+struct memory_entry {
+	u32 base;
+	u32 length;
+	u32 type;
+};
+
+struct memory_map {
+	struct memory_entry *entry;
+	u32 count;
+};
+
+void memory_map(void);
+struct memory_map *memory_map_get(void);
+
+#endif
diff --git a/src/loader/inc/pnc.h b/src/loader/inc/panic.h
index 73819c9..73819c9 100644
--- a/src/loader/inc/pnc.h
+++ b/src/loader/inc/panic.h
diff --git a/src/loader/inc/pic.h b/src/loader/inc/pic.h
index c2a7d87..d662454 100644
--- a/src/loader/inc/pic.h
+++ b/src/loader/inc/pic.h
@@ -6,6 +6,6 @@
 #include <def.h>
 
 void pic_install(void);
-void pic_ack(u32 int_no);
+void pic_ack(u32 interrupt_no);
 
 #endif
diff --git a/src/loader/inc/impl.h b/src/loader/inc/protocol.h
index 58ae706..a667467 100644
--- a/src/loader/inc/impl.h
+++ b/src/loader/inc/protocol.h
@@ -3,7 +3,7 @@
 #ifndef IMPL_H
 #define IMPL_H
 
-#include <dev.h>
+#include <device.h>
 
 enum impl_type {
 	IMPL_NONE,
diff --git a/src/loader/inc/impl/all.h b/src/loader/inc/protocols/all.h
index 01565a6..9b6e750 100644
--- a/src/loader/inc/impl/all.h
+++ b/src/loader/inc/protocols/all.h
@@ -3,10 +3,10 @@
 #ifndef IMPL_ALL_H
 #define IMPL_ALL_H
 
-#include <cfg.h>
+#include <config.h>
 #include <def.h>
 
-u8 impl_detect(struct cfg_entry *cfg);
-void impl_exec(struct cfg_entry *cfg);
+u8 impl_detect(struct config_entry *cfg);
+void impl_exec(struct config_entry *cfg);
 
 #endif
diff --git a/src/loader/inc/impl/mb1.h b/src/loader/inc/protocols/mb1.h
index 5e68ece..2a85bc0 100644
--- a/src/loader/inc/impl/mb1.h
+++ b/src/loader/inc/protocols/mb1.h
@@ -3,9 +3,9 @@
 #ifndef IMPL_MB1_H
 #define IMPL_MB1_H
 
-#include <cfg.h>
+#include <config.h>
 #include <def.h>
-#include <dev.h>
+#include <device.h>
 
 #define MB1_MAGIC 0x1badb002 // Identifies kernel
 #define MB1_LOAD_MAGIC 0x2badb002 // Passed to kernel
@@ -16,7 +16,7 @@
 #define MB1_INFO_MODS 0x00000008
 #define MB1_INFO_AOUT_SYMS 0x00000010
 #define MB1_INFO_ELF_SHDR 0x00000020
-#define MB1_INFO_MEM_MAP 0x00000040
+#define MB1_INFO_MEMORY_MAP 0x00000040
 #define MB1_INFO_DRIVE_INFO 0x00000080
 #define MB1_INFO_CONFIG_TABLE 0x00000100
 #define MB1_INFO_BOOT_LOADER_NAME 0x00000200
@@ -53,8 +53,8 @@ struct mb1_elf_section_header_table {
 struct mb1_info {
 	u32 flags;
 
-	u32 mem_lower;
-	u32 mem_upper;
+	u32 memory_lower;
+	u32 memory_upper;
 
 	u32 boot_device;
 
@@ -128,7 +128,7 @@ struct mb1_mod_list {
 	u32 pad;
 };
 
-u8 mb1_detect(struct cfg_entry *cfg);
-void mb1_exec(struct cfg_entry *cfg);
+u8 mb1_detect(struct config_entry *cfg);
+void mb1_exec(struct config_entry *cfg);
 
 #endif
diff --git a/src/loader/inc/impl/mb2.h b/src/loader/inc/protocols/mb2.h
index 3f64dbd..b471b0f 100644
--- a/src/loader/inc/impl/mb2.h
+++ b/src/loader/inc/protocols/mb2.h
@@ -3,9 +3,9 @@
 #ifndef IMPL_MB2_H
 #define IMPL_MB2_H
 
-#include <cfg.h>
+#include <config.h>
 #include <def.h>
-#include <dev.h>
+#include <device.h>
 
 #define MB2_MAGIC 0xe85250d6 // Identifies kernel
 #define MB2_LOAD_MAGIC 0x36d76289 // Passed to kernel
@@ -55,7 +55,7 @@ enum mb2_tags {
 	MB2_TAG_ACPI_2 = 15,
 };
 
-u8 mb2_detect(struct cfg_entry *cfg);
-void mb2_exec(struct cfg_entry *cfg);
+u8 mb2_detect(struct config_entry *cfg);
+void mb2_exec(struct config_entry *cfg);
 
 #endif
diff --git a/src/loader/inc/rem.h b/src/loader/inc/real.h
index 61eb30a..a9d36dc 100644
--- a/src/loader/inc/rem.h
+++ b/src/loader/inc/real.h
@@ -1,15 +1,15 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 // Real mode emulation - Implementation by Napalm (see rem.asm)
 
-#ifndef REM_H
-#define REM_H
+#ifndef REAL_H
+#define REAL_H
 
 #include <def.h>
 
 #define EFLAGS_CF (1 << 0) // Carry flag
 #define EFLAGS_ZF (1 << 6) // Zero flag
 
-struct rem_regs {
+struct real_regs {
 	u16 gs;
 	u16 fs;
 	u16 es;
@@ -24,6 +24,6 @@ struct rem_regs {
 	u32 eax;
 } PACKED;
 
-void rem_int(u8 int_num, struct rem_regs *out_regs, struct rem_regs *in_regs);
+void real_int(u8 interrupt_num, struct real_regs *out_regs, struct real_regs *in_regs);
 
 #endif
diff --git a/src/loader/int.asm b/src/loader/int.asm
deleted file mode 100644
index 4805448..0000000
--- a/src/loader/int.asm
+++ /dev/null
@@ -1,149 +0,0 @@
-; MIT License, Copyright (c) 2021 Marvin Borner
-
-%macro INT_REGISTER 1
-dd int%1
-%endmacro
-
-%macro INT_ERR 1
-int%1:
-	push %1
-	jmp int_common
-%endmacro
-
-%macro INT_NOERR 1
-int%1:
-	push 0
-	push %1
-	jmp int_common
-%endmacro
-
-extern int_handler
-int_common:
-	cld
-
-	pushad
-	push ds
-	push es
-	push fs
-	push gs
-
-	mov ax, 0x20
-	mov ds, ax
-	mov es, ax
-	mov fs, ax
-	mov gs, ax
-
-	push esp
-	call int_handler
-	mov esp, eax
-
-	pop gs
-	pop fs
-	pop es
-	pop ds
-	popad
-
-	add esp, 8
-	iret
-
-INT_NOERR 0
-INT_NOERR 1
-INT_NOERR 2
-INT_NOERR 3
-INT_NOERR 4
-INT_NOERR 5
-INT_NOERR 6
-INT_NOERR 7
-INT_ERR   8
-INT_NOERR 9
-INT_ERR   10
-INT_ERR   11
-INT_ERR   12
-INT_ERR   13
-INT_ERR   14
-INT_NOERR 15
-INT_NOERR 16
-INT_ERR 17
-INT_NOERR 18
-INT_NOERR 19
-INT_NOERR 20
-INT_NOERR 21
-INT_NOERR 22
-INT_NOERR 23
-INT_NOERR 24
-INT_NOERR 25
-INT_NOERR 26
-INT_NOERR 27
-INT_NOERR 28
-INT_NOERR 29
-INT_ERR   30
-INT_NOERR 31
-
-INT_NOERR 32
-INT_NOERR 33
-INT_NOERR 34
-INT_NOERR 35
-INT_NOERR 36
-INT_NOERR 37
-INT_NOERR 38
-INT_NOERR 39
-INT_NOERR 40
-INT_NOERR 41
-INT_NOERR 42
-INT_NOERR 43
-INT_NOERR 44
-INT_NOERR 45
-INT_NOERR 46
-INT_NOERR 47
-
-global int_table
-int_table:
-	INT_REGISTER 0
-	INT_REGISTER 1
-	INT_REGISTER 2
-	INT_REGISTER 3
-	INT_REGISTER 4
-	INT_REGISTER 5
-	INT_REGISTER 6
-	INT_REGISTER 7
-	INT_REGISTER 8
-	INT_REGISTER 9
-	INT_REGISTER 10
-	INT_REGISTER 11
-	INT_REGISTER 12
-	INT_REGISTER 13
-	INT_REGISTER 14
-	INT_REGISTER 15
-	INT_REGISTER 16
-	INT_REGISTER 17
-	INT_REGISTER 18
-	INT_REGISTER 19
-	INT_REGISTER 20
-	INT_REGISTER 21
-	INT_REGISTER 22
-	INT_REGISTER 23
-	INT_REGISTER 24
-	INT_REGISTER 25
-	INT_REGISTER 26
-	INT_REGISTER 27
-	INT_REGISTER 28
-	INT_REGISTER 29
-	INT_REGISTER 30
-	INT_REGISTER 31
-
-	INT_REGISTER 32
-	INT_REGISTER 33
-	INT_REGISTER 34
-	INT_REGISTER 35
-	INT_REGISTER 36
-	INT_REGISTER 37
-	INT_REGISTER 38
-	INT_REGISTER 39
-	INT_REGISTER 40
-	INT_REGISTER 41
-	INT_REGISTER 42
-	INT_REGISTER 43
-	INT_REGISTER 44
-	INT_REGISTER 45
-	INT_REGISTER 46
-	INT_REGISTER 47
diff --git a/src/loader/interrupt.asm b/src/loader/interrupt.asm
new file mode 100644
index 0000000..7ac805b
--- /dev/null
+++ b/src/loader/interrupt.asm
@@ -0,0 +1,149 @@
+; MIT License, Copyright (c) 2021 Marvin Borner
+
+%macro INTERRUPT_REGISTER 1
+dd int%1
+%endmacro
+
+%macro INTERRUPT_ERR 1
+int%1:
+	push %1
+	jmp interrupt_common
+%endmacro
+
+%macro INTERRUPT_NOERR 1
+int%1:
+	push 0
+	push %1
+	jmp interrupt_common
+%endmacro
+
+extern interrupt_handler
+interrupt_common:
+	cld
+
+	pushad
+	push ds
+	push es
+	push fs
+	push gs
+
+	mov ax, 0x20
+	mov ds, ax
+	mov es, ax
+	mov fs, ax
+	mov gs, ax
+
+	push esp
+	call interrupt_handler
+	mov esp, eax
+
+	pop gs
+	pop fs
+	pop es
+	pop ds
+	popad
+
+	add esp, 8
+	iret
+
+INTERRUPT_NOERR 0
+INTERRUPT_NOERR 1
+INTERRUPT_NOERR 2
+INTERRUPT_NOERR 3
+INTERRUPT_NOERR 4
+INTERRUPT_NOERR 5
+INTERRUPT_NOERR 6
+INTERRUPT_NOERR 7
+INTERRUPT_ERR   8
+INTERRUPT_NOERR 9
+INTERRUPT_ERR   10
+INTERRUPT_ERR   11
+INTERRUPT_ERR   12
+INTERRUPT_ERR   13
+INTERRUPT_ERR   14
+INTERRUPT_NOERR 15
+INTERRUPT_NOERR 16
+INTERRUPT_ERR 17
+INTERRUPT_NOERR 18
+INTERRUPT_NOERR 19
+INTERRUPT_NOERR 20
+INTERRUPT_NOERR 21
+INTERRUPT_NOERR 22
+INTERRUPT_NOERR 23
+INTERRUPT_NOERR 24
+INTERRUPT_NOERR 25
+INTERRUPT_NOERR 26
+INTERRUPT_NOERR 27
+INTERRUPT_NOERR 28
+INTERRUPT_NOERR 29
+INTERRUPT_ERR   30
+INTERRUPT_NOERR 31
+
+INTERRUPT_NOERR 32
+INTERRUPT_NOERR 33
+INTERRUPT_NOERR 34
+INTERRUPT_NOERR 35
+INTERRUPT_NOERR 36
+INTERRUPT_NOERR 37
+INTERRUPT_NOERR 38
+INTERRUPT_NOERR 39
+INTERRUPT_NOERR 40
+INTERRUPT_NOERR 41
+INTERRUPT_NOERR 42
+INTERRUPT_NOERR 43
+INTERRUPT_NOERR 44
+INTERRUPT_NOERR 45
+INTERRUPT_NOERR 46
+INTERRUPT_NOERR 47
+
+global interrupt_table
+interrupt_table:
+	INTERRUPT_REGISTER 0
+	INTERRUPT_REGISTER 1
+	INTERRUPT_REGISTER 2
+	INTERRUPT_REGISTER 3
+	INTERRUPT_REGISTER 4
+	INTERRUPT_REGISTER 5
+	INTERRUPT_REGISTER 6
+	INTERRUPT_REGISTER 7
+	INTERRUPT_REGISTER 8
+	INTERRUPT_REGISTER 9
+	INTERRUPT_REGISTER 10
+	INTERRUPT_REGISTER 11
+	INTERRUPT_REGISTER 12
+	INTERRUPT_REGISTER 13
+	INTERRUPT_REGISTER 14
+	INTERRUPT_REGISTER 15
+	INTERRUPT_REGISTER 16
+	INTERRUPT_REGISTER 17
+	INTERRUPT_REGISTER 18
+	INTERRUPT_REGISTER 19
+	INTERRUPT_REGISTER 20
+	INTERRUPT_REGISTER 21
+	INTERRUPT_REGISTER 22
+	INTERRUPT_REGISTER 23
+	INTERRUPT_REGISTER 24
+	INTERRUPT_REGISTER 25
+	INTERRUPT_REGISTER 26
+	INTERRUPT_REGISTER 27
+	INTERRUPT_REGISTER 28
+	INTERRUPT_REGISTER 29
+	INTERRUPT_REGISTER 30
+	INTERRUPT_REGISTER 31
+
+	INTERRUPT_REGISTER 32
+	INTERRUPT_REGISTER 33
+	INTERRUPT_REGISTER 34
+	INTERRUPT_REGISTER 35
+	INTERRUPT_REGISTER 36
+	INTERRUPT_REGISTER 37
+	INTERRUPT_REGISTER 38
+	INTERRUPT_REGISTER 39
+	INTERRUPT_REGISTER 40
+	INTERRUPT_REGISTER 41
+	INTERRUPT_REGISTER 42
+	INTERRUPT_REGISTER 43
+	INTERRUPT_REGISTER 44
+	INTERRUPT_REGISTER 45
+	INTERRUPT_REGISTER 46
+	INTERRUPT_REGISTER 47
diff --git a/src/loader/int.c b/src/loader/interrupt.c
index d4e4841..e05b4e0 100644
--- a/src/loader/int.c
+++ b/src/loader/interrupt.c
@@ -1,28 +1,28 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
-#include <int.h>
+#include <interrupt.h>
 #include <log.h>
 #include <pic.h>
-#include <pnc.h>
+#include <panic.h>
 
 /**
  * IDT
  */
 
-extern u32 int_table[];
+extern u32 interrupt_table[];
 static struct idt_entry idt_entries[256] = { 0 };
 REAL static struct idt_ptr idt = { .size = sizeof(idt_entries) - 1, .base = idt_entries };
 
 void idt_install(void)
 {
 	for (u8 i = 0; i < 3; i++)
-		idt_entries[i] = IDT_ENTRY(int_table[i], 0x18, INT_GATE);
+		idt_entries[i] = IDT_ENTRY(interrupt_table[i], 0x18, INTERRUPT_GATE);
 
-	idt_entries[3] = IDT_ENTRY(int_table[3], 0x18, INT_TRAP);
-	idt_entries[4] = IDT_ENTRY(int_table[4], 0x18, INT_TRAP);
+	idt_entries[3] = IDT_ENTRY(interrupt_table[3], 0x18, INTERRUPT_TRAP);
+	idt_entries[4] = IDT_ENTRY(interrupt_table[4], 0x18, INTERRUPT_TRAP);
 
 	for (u8 i = 5; i < 48; i++)
-		idt_entries[i] = IDT_ENTRY(int_table[i], 0x18, INT_GATE);
+		idt_entries[i] = IDT_ENTRY(interrupt_table[i], 0x18, INTERRUPT_GATE);
 
 	// Load table
 	__asm__ volatile("lidt %0" : : "m"(idt) : "memory");
@@ -32,7 +32,7 @@ void idt_install(void)
  * Exception (trap) handling
  */
 
-const char *int_trap_names[32] = {
+static const char *interrupt_trap_names[32] = {
 	"Division By Zero",
 	"Debug",
 	"Non Maskable Interrupt",
@@ -70,7 +70,7 @@ const char *int_trap_names[32] = {
 	"Reserved",
 };
 
-static void int_trap_handler(struct int_frame *frame)
+static void interrupt_trap_handler(struct interrupt_frame *frame)
 {
 	static u8 faulting = 0;
 	faulting++;
@@ -82,7 +82,7 @@ static void int_trap_handler(struct int_frame *frame)
 			__asm__ volatile("cli\nhlt");
 	}
 
-	log("%s Exception (code %x) at 0x%x!\n", int_trap_names[frame->int_no], frame->err_code,
+	log("%s Exception (code %x) at 0x%x!\n", interrupt_trap_names[frame->interrupt_no], frame->err_code,
 	    frame->eip);
 
 	while (1)
@@ -93,19 +93,19 @@ static void int_trap_handler(struct int_frame *frame)
  * Event handling
  */
 
-static void (*int_event_handlers[16])(void) = { 0 };
+static void (*interrupt_event_handlers[16])(void) = { 0 };
 
-void int_event_handler_add(u32 int_no, void (*handler)(void))
+void interrupt_event_handler_add(u32 interrupt_no, void (*handler)(void))
 {
-	assert(int_no < COUNT(int_event_handlers));
-	int_event_handlers[int_no] = handler;
+	assert(interrupt_no < COUNT(interrupt_event_handlers));
+	interrupt_event_handlers[interrupt_no] = handler;
 }
 
-static u32 int_event_handler(struct int_frame *frame)
+static u32 interrupt_event_handler(struct interrupt_frame *frame)
 {
-	u32 int_no = frame->int_no - 32;
-	assert(int_no < COUNT(int_event_handlers));
-	void (*handler)(void) = int_event_handlers[int_no];
+	u32 interrupt_no = frame->interrupt_no - 32;
+	assert(interrupt_no < COUNT(interrupt_event_handlers));
+	void (*handler)(void) = interrupt_event_handlers[interrupt_no];
 	if (handler)
 		handler();
 
@@ -116,17 +116,17 @@ static u32 int_event_handler(struct int_frame *frame)
  * Universal handler
  */
 
-u32 int_handler(u32 esp);
-u32 int_handler(u32 esp)
+u32 interrupt_handler(u32 esp);
+u32 interrupt_handler(u32 esp)
 {
-	struct int_frame *frame = (struct int_frame *)esp;
-	if (frame->int_no < 32)
-		int_trap_handler(frame);
-	else if (frame->int_no < 48)
-		esp = int_event_handler(frame);
+	struct interrupt_frame *frame = (struct interrupt_frame *)esp;
+	if (frame->interrupt_no < 32)
+		interrupt_trap_handler(frame);
+	else if (frame->interrupt_no < 48)
+		esp = interrupt_event_handler(frame);
 	else
 		panic("Unknown interrupt\n");
 
-	pic_ack(frame->int_no);
+	pic_ack(frame->interrupt_no);
 	return esp;
 }
diff --git a/src/loader/jmp.asm b/src/loader/jumper.asm
index f591dda..f591dda 100644
--- a/src/loader/jmp.asm
+++ b/src/loader/jumper.asm
diff --git a/src/loader/lib.c b/src/loader/library.c
index a5a1aee..4317a8e 100644
--- a/src/loader/lib.c
+++ b/src/loader/library.c
@@ -1,6 +1,6 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
-#include <lib.h>
+#include <library.h>
 
 /**
  * Common string functions
diff --git a/src/loader/log.c b/src/loader/log.c
deleted file mode 100644
index 3a4167f..0000000
--- a/src/loader/log.c
+++ /dev/null
@@ -1,189 +0,0 @@
-// MIT License, Copyright (c) 2021 Marvin Borner
-
-#include <cpu.h>
-#include <lib.h>
-#include <log.h>
-#include <pnc.h>
-
-/**
- * Formatting
- */
-
-static u32 vsnprintf(char *str, u32 size, const char *format, va_list ap)
-{
-	u32 length = 0;
-
-	int temp_int;
-	char temp_ch;
-	char *temp_str;
-
-	char buffer[64] = { 0 };
-
-	// TODO: Fix potential memory overflows because of str[length++]=xxx
-	char ch;
-	while ((ch = *format++)) {
-		if (ch == '%') {
-			switch (*format++) {
-			case '%':
-				str[length++] = '%';
-				break;
-			case 'c':
-				temp_ch = va_arg(ap, int);
-				str[length++] = temp_ch;
-				break;
-			case 's':
-				temp_str = va_arg(ap, char *);
-				length += strlcpy(&str[length], temp_str, size - length);
-				break;
-			case 'b':
-				temp_int = va_arg(ap, int);
-				itoa(temp_int, buffer, 2);
-				length += strlcpy(&str[length], buffer, size - length);
-				break;
-			case 'd':
-				temp_int = va_arg(ap, int);
-				itoa(temp_int, buffer, 10);
-				length += strlcpy(&str[length], buffer, size - length);
-				break;
-			case 'x':
-				temp_int = va_arg(ap, int);
-				itoa(temp_int, buffer, 16);
-				length += strlcpy(&str[length], buffer, size - length);
-				break;
-			default:
-				serial_print("Unknown printf format\n");
-			}
-		} else {
-			str[length++] = ch;
-		}
-	}
-
-	return length;
-}
-
-/**
- * Serial
- */
-
-#define PORT 0x3f8
-
-void serial_install(void)
-{
-	outb(PORT + 1, 0x00);
-	outb(PORT + 3, 0x80);
-	outb(PORT + 0, 0x03);
-	outb(PORT + 1, 0x00);
-	outb(PORT + 3, 0x03);
-	outb(PORT + 2, 0xc7);
-
-	// Test serial chip
-	outb(PORT + 4, 0x1e); // Enable loopback
-	outb(PORT + 0, 0xae); // Write
-	assert(inb(PORT + 0) == 0xae); // Verify receive
-
-	// Activate
-	outb(PORT + 4, 0x0f);
-
-	log("[LOG] Initiated\n");
-}
-
-static int serial_empty(void)
-{
-	return inb(PORT + 5) & 0x20;
-}
-
-static void serial_put(char ch)
-{
-	while (serial_empty() == 0)
-		;
-	outb(PORT, (u8)ch);
-}
-
-void serial_print(const char *data)
-{
-	for (const char *p = data; *p; p++)
-		serial_put(*p);
-}
-
-/**
- * VGA
- */
-
-#define VGA_WIDTH 80
-#define VGA_HEIGHT 25
-#define VGA_ADDRESS 0xb8000
-
-void vga_clear(void)
-{
-	u16 *out = (u16 *)VGA_ADDRESS;
-	for (u16 i = 0; i < 80 * 25; i++)
-		out[i] = 0;
-}
-
-void vga_put_at(char ch, u8 x, u8 y, u8 color)
-{
-	u8 *out = (u8 *)(VGA_ADDRESS + 2 * (x + y * VGA_WIDTH));
-	*out++ = ch;
-	*out++ = color;
-}
-
-static void vga_put(char ch)
-{
-	static u8 x = 0;
-	static u8 y = 0;
-
-	if (ch == '\n') {
-		x = 0;
-		y++;
-		return;
-	} else if (x + 1 == VGA_WIDTH) {
-		x = 0;
-		y++;
-	} else if (y + 1 == VGA_HEIGHT) {
-		x = 0;
-		y = 0;
-		vga_clear();
-	}
-
-	u8 *out = (u8 *)(VGA_ADDRESS + 2 * (x + y * VGA_WIDTH));
-	*out++ = ch;
-	*out++ = 0x07;
-
-	x++;
-}
-
-static void vga_print(const char *data)
-{
-	for (const char *p = data; *p; p++)
-		vga_put(*p);
-}
-
-/**
- * Formatted print functions
- */
-
-// Serial
-void log(const char *format, ...)
-{
-	char buf[1024] = { 0 };
-
-	va_list ap;
-	va_start(ap, format);
-	vsnprintf(buf, sizeof(buf), format, ap);
-	va_end(ap);
-
-	serial_print(buf);
-}
-
-// VGA log
-void vga_log(const char *format, ...)
-{
-	char buf[1024] = { 0 };
-
-	va_list ap;
-	va_start(ap, format);
-	vsnprintf(buf, sizeof(buf), format, ap);
-	va_end(ap);
-
-	vga_print(buf);
-}
diff --git a/src/loader/main.c b/src/loader/main.c
index a16149e..1884b2f 100644
--- a/src/loader/main.c
+++ b/src/loader/main.c
@@ -2,14 +2,14 @@
 
 #include <a20.h>
 #include <acpi.h>
-#include <cfg.h>
+#include <config.h>
 #include <def.h>
-#include <dev.h>
+#include <device.h>
 #include <gui.h>
 #include <ide.h>
-#include <int.h>
+#include <interrupt.h>
 #include <log.h>
-#include <mem.h>
+#include <memory.h>
 #include <pci.h>
 #include <pic.h>
 
@@ -23,7 +23,7 @@ int start(u8 disk);
 int start(u8 disk)
 {
 	boot_disk = disk;
-	mem_map();
+	memory_map();
 	a20_enable();
 
 	vga_clear();
@@ -34,9 +34,9 @@ int start(u8 disk)
 
 	// acpi_probe(); // TODO: Fix slow ACPI probing
 	pci_probe();
-	dev_print();
+	device_print();
 
-	cfg_read();
+	config_read();
 	gui_draw();
 
 	// Sleep and wait for interrupts
diff --git a/src/loader/mbr.c b/src/loader/mbr.c
index df0c1db..f0f473a 100644
--- a/src/loader/mbr.c
+++ b/src/loader/mbr.c
@@ -1,17 +1,17 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
-#include <lib.h>
+#include <library.h>
 #include <log.h>
 #include <mbr.h>
-#include <pnc.h>
+#include <panic.h>
 
 static struct mbr_entry entries[16] = { 0 };
 
 static s32 mbr_read(void *buf, u32 lba, u32 sector_count, struct dev *part)
 {
-	u8 dev_id = (part->data & 0xff00) >> 8;
-	struct dev *dev = dev_get_by_id(dev_id);
-	assert(dev && dev->type == DEV_DISK && dev->read);
+	u8 device_id = (part->data & 0xff00) >> 8;
+	struct dev *dev = device_get_by_id(device_id);
+	assert(dev && dev->type == DEVICE_DISK && dev->read);
 
 	u8 mbr_id = part->data & 0xff;
 	assert(mbr_id < COUNT(entries));
@@ -30,7 +30,7 @@ static u8 mbr_add_entry(struct mbr_entry *entry)
 
 u8 mbr_detect(struct dev *dev)
 {
-	assert(dev->type == DEV_DISK);
+	assert(dev->type == DEVICE_DISK);
 
 	struct mbr mbr = { 0 };
 	dev->read(&mbr, 0, 1, dev); // Read first sector (MBR)
@@ -52,7 +52,7 @@ u8 mbr_detect(struct dev *dev)
 		// Saving space and everything
 		u16 data = mbr_add_entry(entry) | (dev->id << 8);
 
-		dev_register(DEV_DISK, name, data, mbr_read, NULL);
+		device_register(DEVICE_DISK, name, data, mbr_read, NULL);
 	}
 
 	return 1;
diff --git a/src/loader/mem.c b/src/loader/memory.c
index 698c85d..a38e48b 100644
--- a/src/loader/mem.c
+++ b/src/loader/memory.c
@@ -2,9 +2,9 @@
 // Memory map generator
 
 #include <log.h>
-#include <mem.h>
-#include <pnc.h>
-#include <rem.h>
+#include <memory.h>
+#include <panic.h>
+#include <real.h>
 
 /**
  * Memory map using e820 BIOS call
@@ -13,12 +13,12 @@
 #define E820_MAX_ENTRIES 256 // Spec
 
 enum e820_entry_type {
-	E820_MEM_NONE,
-	E820_MEM_USABLE,
-	E820_MEM_RESERVED,
-	E820_MEM_RECLAIMABLE,
-	E820_MEM_ACPI_NVS,
-	E820_MEM_UNUSABLE,
+	E820_MEMORY_NONE,
+	E820_MEMORY_USABLE,
+	E820_MEMORY_RESERVED,
+	E820_MEMORY_RECLAIMABLE,
+	E820_MEMORY_ACPI_NVS,
+	E820_MEMORY_UNUSABLE,
 };
 
 struct e820_entry {
@@ -33,9 +33,9 @@ struct e820_entry {
 u16 e820_count = 0;
 struct e820_entry e820_map[E820_MAX_ENTRIES] = { 0 };
 
-static u8 mem_e820(void)
+static u8 memory_e820(void)
 {
-	struct rem_regs r = { 0 };
+	struct real_regs r = { 0 };
 
 	for (u32 i = 0; i < E820_MAX_ENTRIES; i++) {
 		struct e820_entry entry = { 0 };
@@ -44,7 +44,7 @@ static u8 mem_e820(void)
 		r.ecx = 24;
 		r.edx = 0x534d4150;
 		r.edi = (u32)&entry;
-		rem_int(0x15, &r, &r);
+		real_int(0x15, &r, &r);
 
 		if (r.eflags & EFLAGS_CF) {
 			e820_count = i;
@@ -68,38 +68,38 @@ static u8 mem_e820(void)
 
 #define MAP_MAX_ENTRIES 256
 
-static struct mem_entry mem[MAP_MAX_ENTRIES] = { 0 };
-static struct mem_map map = { .entry = mem, .count = 0 };
+static struct memory_entry mem[MAP_MAX_ENTRIES] = { 0 };
+static struct memory_map map = { .entry = mem, .count = 0 };
 
-static void mem_map_e820(void)
+static void memory_map_e820(void)
 {
 	u32 i;
 	for (i = 0; i < COUNT(e820_map); i++) {
 		struct e820_entry *e820_entry = &e820_map[i];
-		struct mem_entry *map_entry = &mem[i];
+		struct memory_entry *map_entry = &mem[i];
 
 		map_entry->base = e820_entry->base_low;
 		map_entry->length = e820_entry->length_low;
 
 		// Set type accordingly
 		switch (e820_entry->type) {
-		case E820_MEM_NONE:
-			map_entry->type = MEM_USABLE;
+		case E820_MEMORY_NONE:
+			map_entry->type = MEMORY_USABLE;
 			continue;
-		case E820_MEM_USABLE:
-			map_entry->type = MEM_USABLE;
+		case E820_MEMORY_USABLE:
+			map_entry->type = MEMORY_USABLE;
 			break;
-		case E820_MEM_RESERVED:
-			map_entry->type = MEM_RESERVED;
+		case E820_MEMORY_RESERVED:
+			map_entry->type = MEMORY_RESERVED;
 			break;
-		case E820_MEM_RECLAIMABLE:
-			map_entry->type = MEM_RECLAIMABLE;
+		case E820_MEMORY_RECLAIMABLE:
+			map_entry->type = MEMORY_RECLAIMABLE;
 			break;
-		case E820_MEM_ACPI_NVS:
-			map_entry->type = MEM_ACPI_NVS;
+		case E820_MEMORY_ACPI_NVS:
+			map_entry->type = MEMORY_ACPI_NVS;
 			break;
-		case E820_MEM_UNUSABLE:
-			map_entry->type = MEM_UNUSABLE;
+		case E820_MEMORY_UNUSABLE:
+			map_entry->type = MEMORY_UNUSABLE;
 			break;
 		default:
 			panic("Unknown e820 type\n");
@@ -109,15 +109,15 @@ static void mem_map_e820(void)
 	map.count = i;
 }
 
-struct mem_map *mem_map_get(void)
+struct memory_map *memory_map_get(void)
 {
 	return &map;
 }
 
-void mem_map(void)
+void memory_map(void)
 {
-	if (mem_e820()) {
-		mem_map_e820();
+	if (memory_e820()) {
+		memory_map_e820();
 		return;
 	}
 
diff --git a/src/loader/pic.c b/src/loader/pic.c
index 18b248c..fa728b6 100644
--- a/src/loader/pic.c
+++ b/src/loader/pic.c
@@ -55,9 +55,9 @@ void pic_install(void)
 	pic_wait();
 }
 
-void pic_ack(u32 int_no)
+void pic_ack(u32 interrupt_no)
 {
-	if (int_no >= 40)
+	if (interrupt_no >= 40)
 		outb(PIC2, 0x20);
 
 	outb(PIC1, 0x20);
diff --git a/src/loader/impl/all.c b/src/loader/protocols/all.c
index 941986d..8ea16dd 100644
--- a/src/loader/impl/all.c
+++ b/src/loader/protocols/all.c
@@ -1,11 +1,11 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
-#include <impl/all.h>
-#include <impl/mb1.h>
-#include <impl/mb2.h>
-#include <pnc.h>
+#include <protocols/all.h>
+#include <protocols/mb1.h>
+#include <protocols/mb2.h>
+#include <panic.h>
 
-u8 impl_detect(struct cfg_entry *cfg)
+u8 impl_detect(struct config_entry *cfg)
 {
 	if (mb1_detect(cfg))
 		return 1;
@@ -16,9 +16,9 @@ u8 impl_detect(struct cfg_entry *cfg)
 	return 0;
 }
 
-void impl_exec(struct cfg_entry *cfg)
+void impl_exec(struct config_entry *cfg)
 {
-	assert(cfg->dev->type == DEV_DISK);
+	assert(cfg->dev->type == DEVICE_DISK);
 
 	switch (cfg->impl.type) {
 	case IMPL_MB1:
diff --git a/src/loader/impl/mb1.c b/src/loader/protocols/mb1.c
index c02aa50..cd57fad 100644
--- a/src/loader/impl/mb1.c
+++ b/src/loader/protocols/mb1.c
@@ -2,16 +2,16 @@
 // Everything according to spec
 
 #include <elf.h>
-#include <impl/mb1.h>
-#include <lib.h>
-#include <mem.h>
-#include <pnc.h>
+#include <library.h>
+#include <memory.h>
+#include <panic.h>
+#include <protocols/mb1.h>
 
 // The address where data gets stored
-#define MB1_LOAD_ADDRESS 0x10000
+#define MB1_LOAD_ADDRESS 0x20000
 
 #define MB1_FLAG_PAGE_ALIGN (1 << 0) // Align modules with page boundaries (4K)
-#define MB1_FLAG_MEMORY_INFO (1 << 1) // Load/store all mem_* fields and mmap_* structs
+#define MB1_FLAG_MEMORY_INFO (1 << 1) // Load/store all memory_* fields and mmap_* structs
 #define MB1_FLAG_VIDEO_MODE (1 << 2) // Load/store video mode table
 #define MB1_FLAG_MANUAL_ADDRESSES (1 << 16) // Use specified load addresses
 
@@ -36,7 +36,7 @@ static u32 mb1_checksum(struct mb1_entry *entry)
 	return -(entry->magic + entry->flags);
 }
 
-// Load data into memory and return address (not overlapping
+// Load data into memory and return address (not overlapping)
 static u32 mb1_store(void *data, u32 size)
 {
 	static u32 offset = 0;
@@ -47,17 +47,17 @@ static u32 mb1_store(void *data, u32 size)
 
 static void mb1_store_memory_info(struct mb1_info *info)
 {
-	// TODO: Store mem_lower and mem_upper
-	struct mem_map *mem_map = mem_map_get();
-	info->flags |= MB1_INFO_MEM_MAP;
-	info->mmap_length = mem_map->count * sizeof(struct mb1_mmap_entry);
+	// TODO: Store memory_lower and memory_upper
+	struct memory_map *memory_map = memory_map_get();
+	info->flags |= MB1_INFO_MEMORY_MAP;
+	info->mmap_length = memory_map->count * sizeof(struct mb1_mmap_entry);
 	info->mmap_addr = mb1_store(NULL, 0);
-	for (u32 i = 0; i < mem_map->count; i++) {
-		struct mb1_mmap_entry mmap_entry;
+	for (u32 i = 0; i < memory_map->count; i++) {
+		struct mb1_mmap_entry mmap_entry = { 0 };
 		mmap_entry.struct_size = sizeof(mmap_entry) - 4;
-		mmap_entry.addr_low = mem_map->entry[i].base;
-		mmap_entry.len_low = mem_map->entry[i].length;
-		mmap_entry.type = mem_map->entry[i].type;
+		mmap_entry.addr_low = memory_map->entry[i].base;
+		mmap_entry.len_low = memory_map->entry[i].length;
+		mmap_entry.type = memory_map->entry[i].type;
 		mb1_store(&mmap_entry, sizeof(mmap_entry));
 	}
 }
@@ -98,7 +98,7 @@ static void mb1_jump(u32 entry, u32 info)
 }
 
 // Detect and verify mb1
-u8 mb1_detect(struct cfg_entry *cfg)
+u8 mb1_detect(struct config_entry *cfg)
 {
 	u8 header[8192] = { 0 };
 
@@ -130,7 +130,7 @@ u8 mb1_detect(struct cfg_entry *cfg)
 }
 
 // Execute mb1 type kernel
-void mb1_exec(struct cfg_entry *cfg)
+void mb1_exec(struct config_entry *cfg)
 {
 	struct mb1_entry mb1_entry = { 0 };
 	s32 ret = cfg->dev->p.disk.fs.read(cfg->path, &mb1_entry, cfg->impl.offset,
diff --git a/src/loader/impl/mb2.c b/src/loader/protocols/mb2.c
index 09f69ea..8f0a660 100644
--- a/src/loader/impl/mb2.c
+++ b/src/loader/protocols/mb2.c
@@ -2,9 +2,9 @@
 // Everything according to spec
 
 #include <elf.h>
-#include <impl/mb2.h>
-#include <lib.h>
-#include <pnc.h>
+#include <protocols/mb2.h>
+#include <library.h>
+#include <panic.h>
 
 // The address where data gets stored
 #define MB2_LOAD_ADDRESS 0x10000
@@ -55,7 +55,7 @@ static void mb2_jump(u32 entry, u32 info)
 }
 
 // Detect and verify mb2
-u8 mb2_detect(struct cfg_entry *cfg)
+u8 mb2_detect(struct config_entry *cfg)
 {
 	u8 header[8192] = { 0 };
 
@@ -88,7 +88,7 @@ u8 mb2_detect(struct cfg_entry *cfg)
 }
 
 // Execute mb2 type kernel
-void mb2_exec(struct cfg_entry *cfg)
+void mb2_exec(struct config_entry *cfg)
 {
 	struct mb2_entry mb2_entry = { 0 };
 	s32 ret = cfg->dev->p.disk.fs.read(cfg->path, &mb2_entry, cfg->impl.offset,
diff --git a/src/loader/rem.asm b/src/loader/real.asm
index 7a33048..a7c6fc0 100644
--- a/src/loader/rem.asm
+++ b/src/loader/real.asm
@@ -3,11 +3,11 @@
 
 section .realmode
 
-global rem_int
-rem_int:
-	; Self-modifying code: int $int_no
+global real_int
+real_int:
+	; Self-modifying code: int $interrupt_no
 	mov al, byte [esp+4]
-	mov byte [.int_no], al
+	mov byte [.interrupt_no], al
 
 	; Save out_regs
 	mov eax, dword [esp+8]
@@ -24,7 +24,7 @@ rem_int:
 	sidt [.idt]
 
 	; Load BIOS IVT
-	lidt [.rem_idt]
+	lidt [.real_idt]
 
 	; Save non-scratch GPRs
 	push ebx
@@ -71,7 +71,7 @@ rem_int:
 
 	; Indirect interrupt call
 	db 0xcd
- .int_no:
+ .interrupt_no:
 	db 0
 
 	cli
@@ -134,6 +134,6 @@ align 16
 	dq 0
 .idt:
 	dq 0
-.rem_idt:
+.real_idt:
 	dw 0x3ff
 	dd 0
diff --git a/src/loader/serial.c b/src/loader/serial.c
new file mode 100644
index 0000000..20299c4
--- /dev/null
+++ b/src/loader/serial.c
@@ -0,0 +1,57 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#include <cpu.h>
+#include <log.h>
+#include <panic.h>
+
+#define PORT 0x3f8
+
+void serial_install(void)
+{
+	outb(PORT + 1, 0x00);
+	outb(PORT + 3, 0x80);
+	outb(PORT + 0, 0x03);
+	outb(PORT + 1, 0x00);
+	outb(PORT + 3, 0x03);
+	outb(PORT + 2, 0xc7);
+
+	// Test serial chip
+	outb(PORT + 4, 0x1e); // Enable loopback
+	outb(PORT + 0, 0xae); // Write
+	assert(inb(PORT + 0) == 0xae); // Verify receive
+
+	// Activate
+	outb(PORT + 4, 0x0f);
+
+	log("[LOG] Initiated\n");
+}
+
+static int serial_empty(void)
+{
+	return inb(PORT + 5) & 0x20;
+}
+
+static void serial_put(char ch)
+{
+	while (serial_empty() == 0)
+		;
+	outb(PORT, (u8)ch);
+}
+
+void serial_print(const char *data)
+{
+	for (const char *p = data; *p; p++)
+		serial_put(*p);
+}
+
+void log(const char *format, ...)
+{
+	char buf[1024] = { 0 };
+
+	va_list ap;
+	va_start(ap, format);
+	vsnprintf(buf, sizeof(buf), format, ap);
+	va_end(ap);
+
+	serial_print(buf);
+}
diff --git a/src/loader/vga.c b/src/loader/vga.c
new file mode 100644
index 0000000..6cc9bfa
--- /dev/null
+++ b/src/loader/vga.c
@@ -0,0 +1,64 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#include <log.h>
+
+#define VGA_WIDTH 80
+#define VGA_HEIGHT 25
+#define VGA_ADDRESS 0xb8000
+
+void vga_clear(void)
+{
+	u16 *out = (u16 *)VGA_ADDRESS;
+	for (u16 i = 0; i < 80 * 25; i++)
+		out[i] = 0;
+}
+
+void vga_put_at(char ch, u8 x, u8 y, u8 color)
+{
+	u8 *out = (u8 *)(VGA_ADDRESS + 2 * (x + y * VGA_WIDTH));
+	*out++ = ch;
+	*out++ = color;
+}
+
+static void vga_put(char ch)
+{
+	static u8 x = 0;
+	static u8 y = 0;
+
+	if (ch == '\n') {
+		x = 0;
+		y++;
+		return;
+	} else if (x + 1 == VGA_WIDTH) {
+		x = 0;
+		y++;
+	} else if (y + 1 == VGA_HEIGHT) {
+		x = 0;
+		y = 0;
+		vga_clear();
+	}
+
+	u8 *out = (u8 *)(VGA_ADDRESS + 2 * (x + y * VGA_WIDTH));
+	*out++ = ch;
+	*out++ = 0x07;
+
+	x++;
+}
+
+static void vga_print(const char *data)
+{
+	for (const char *p = data; *p; p++)
+		vga_put(*p);
+}
+
+void vga_log(const char *format, ...)
+{
+	char buf[1024] = { 0 };
+
+	va_list ap;
+	va_start(ap, format);
+	vsnprintf(buf, sizeof(buf), format, ap);
+	va_end(ap);
+
+	vga_print(buf);
+}