Renamed device prefix from 'io_' to 'dev_'

23 files changed, 208 insertions, 209 deletions

diff --git a/apps/wm/main.c b/apps/wm/main.c
index 771bd44..3f01922 100644
--- a/apps/wm/main.c
+++ b/apps/wm/main.c
@@ -429,11 +429,12 @@ static void window_ping_check(void)
 	}
 }
 
+// TODO: Run ping in parallel thread/process
 static void window_ping_all(void)
 {
 	static struct timer last = { 0 };
 	struct timer timer;
-	io_read(IO_TIMER, &timer, 0, sizeof(timer));
+	dev_read(DEV_TIMER, &timer, 0, sizeof(timer));
 	if (timer.time - last.time > PING_INTERVAL) {
 		window_ping_check();
 
@@ -726,7 +727,7 @@ int main(int argc, char **argv)
 
 	atexit(handle_exit);
 
-	assert(io_control(IO_FRAMEBUFFER, IOCTL_FB_GET, &screen, sizeof(screen)) == EOK);
+	assert(dev_control(DEV_FRAMEBUFFER, DEVCTL_FB_GET, &screen, sizeof(screen)) == EOK);
 	log("WM loaded: %dx%d\n", screen.width, screen.height);
 	wm_client = (struct client){ .conn = 0 };
 	bypp = (screen.bpp >> 3);
@@ -750,26 +751,27 @@ int main(int argc, char **argv)
 	gfx_load_wallpaper(&cursor->ctx, "/res/cursor.png");
 	window_redraw(wallpaper);
 
-	assert(io_control(IO_BUS, IOCTL_BUS_REGISTER, "wm") == EOK);
+	assert(dev_control(DEV_BUS, DEVCTL_BUS_REGISTER, "wm") == EOK);
 
-	assert(exec("view", NULL) == EOK);
+	assert(exec("test", NULL) == EOK);
+	assert(exec("test", NULL) == EOK);
 
 	u8 msg[1024] = { 0 };
 	struct event_keyboard event_keyboard = { 0 };
 	struct event_mouse event_mouse = { 0 };
-	enum io_type listeners[] = { IO_KEYBOARD, IO_MOUSE, IO_BUS, 0 };
+	enum dev_type listeners[] = { DEV_KEYBOARD, DEV_MOUSE, DEV_BUS, 0 };
 
 	while (1) {
 		res poll_ret = 0;
-		if ((poll_ret = io_poll(listeners)) >= 0) {
-			if (poll_ret == IO_KEYBOARD) {
-				if (io_read(IO_KEYBOARD, &event_keyboard, 0,
-					    sizeof(event_keyboard)) > 0)
+		if ((poll_ret = dev_poll(listeners)) >= 0) {
+			if (poll_ret == DEV_KEYBOARD) {
+				if (dev_read(DEV_KEYBOARD, &event_keyboard, 0,
+					     sizeof(event_keyboard)) > 0)
 					handle_event_keyboard(&event_keyboard);
-			} else if (poll_ret == IO_MOUSE) {
-				if (io_read(IO_MOUSE, &event_mouse, 0, sizeof(event_mouse)) > 0)
+			} else if (poll_ret == DEV_MOUSE) {
+				if (dev_read(DEV_MOUSE, &event_mouse, 0, sizeof(event_mouse)) > 0)
 					handle_event_mouse(&event_mouse);
-			} else if (poll_ret == IO_BUS) {
+			} else if (poll_ret == DEV_BUS) {
 				if (msg_receive(msg, sizeof(msg)) > 0)
 					handle_message(msg);
 			}
diff --git a/kernel/Makefile b/kernel/Makefile
index 7107e14..9fed3f1 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -22,7 +22,7 @@ COBJS = entry_asm.o \
 	drivers/ps2/keyboard.o \
 	features/mm.o \
 	features/fs.o \
-	features/io.o \
+	features/dev.o \
 	features/bus.o \
 	features/fb.o \
 	features/logger.o \
diff --git a/kernel/drivers/bga.c b/kernel/drivers/bga.c
index 2f3b1fa..cc93b75 100644
--- a/kernel/drivers/bga.c
+++ b/kernel/drivers/bga.c
@@ -2,11 +2,11 @@
 
 #include <assert.h>
 #include <def.h>
+#include <dev.h>
 #include <drivers/bga.h>
 #include <drivers/cpu.h>
 #include <drivers/pci.h>
 #include <fb.h>
-#include <io.h>
 #include <mem.h>
 #include <mm.h>
 
@@ -75,7 +75,7 @@ static res bga_control(u32 request, void *arg1, void *arg2, void *arg3)
 	UNUSED(arg3);
 
 	switch (request) {
-	case IOCTL_FB_GET: {
+	case DEVCTL_FB_GET: {
 		if (!generic.fb)
 			return -ENOENT;
 
@@ -121,7 +121,7 @@ CLEAR void bga_install(void)
 {
 	bga_enable(1920, 1200, 32);
 
-	struct io_dev *dev = zalloc(sizeof(*dev));
+	struct dev_dev *dev = zalloc(sizeof(*dev));
 	dev->control = bga_control;
-	io_add(IO_FRAMEBUFFER, dev);
+	dev_add(DEV_FRAMEBUFFER, dev);
 }
diff --git a/kernel/drivers/ps2/keyboard.c b/kernel/drivers/ps2/keyboard.c
index 3516a7e..b16f4b2 100644
--- a/kernel/drivers/ps2/keyboard.c
+++ b/kernel/drivers/ps2/keyboard.c
@@ -1,11 +1,11 @@
 // MIT License, Copyright (c) 2020 Marvin Borner
 
 #include <def.h>
+#include <dev.h>
 #include <drivers/cpu.h>
 #include <drivers/int.h>
 #include <drivers/ps2.h>
 #include <errno.h>
-#include <io.h>
 #include <mem.h>
 #include <print.h>
 #include <proc.h>
@@ -43,7 +43,7 @@ static void keyboard_handler(void)
 	state = 0;
 	merged = 0;
 
-	io_unblock(IO_KEYBOARD);
+	dev_unblock(DEV_KEYBOARD);
 }
 
 static res keyboard_read(void *buf, u32 offset, u32 count)
@@ -75,8 +75,8 @@ CLEAR void ps2_keyboard_install(u8 device)
 	int_event_handler_add(1, keyboard_handler);
 
 	queue = stack_new();
-	struct io_dev *dev = zalloc(sizeof(*dev));
+	struct dev_dev *dev = zalloc(sizeof(*dev));
 	dev->read = keyboard_read;
 	dev->ready = keyboard_ready;
-	io_add(IO_KEYBOARD, dev);
+	dev_add(DEV_KEYBOARD, dev);
 }
diff --git a/kernel/drivers/ps2/mouse.c b/kernel/drivers/ps2/mouse.c
index ab20c90..086f522 100644
--- a/kernel/drivers/ps2/mouse.c
+++ b/kernel/drivers/ps2/mouse.c
@@ -1,11 +1,11 @@
 // MIT License, Copyright (c) 2020 Marvin Borner
 
 #include <assert.h>
+#include <dev.h>
 #include <drivers/cpu.h>
 #include <drivers/int.h>
 #include <drivers/ps2.h>
 #include <errno.h>
-#include <io.h>
 #include <mem.h>
 #include <print.h>
 #include <proc.h>
@@ -33,7 +33,7 @@ static void mouse_finish(void)
 	event->but.middle = (mouse_byte[0] >> 2) & 1;
 	stack_push_bot(queue, event);
 	mouse_cycle = 0;
-	io_unblock(IO_MOUSE);
+	dev_unblock(DEV_MOUSE);
 }
 
 static void mouse_handler(void)
@@ -141,8 +141,8 @@ CLEAR void ps2_mouse_install(u8 device)
 	int_event_handler_add(12, mouse_handler);
 
 	queue = stack_new();
-	struct io_dev *dev = zalloc(sizeof(*dev));
+	struct dev_dev *dev = zalloc(sizeof(*dev));
 	dev->read = mouse_read;
 	dev->ready = mouse_ready;
-	io_add(IO_MOUSE, dev);
+	dev_add(DEV_MOUSE, dev);
 }
diff --git a/kernel/drivers/timer.c b/kernel/drivers/timer.c
index 44d66f3..977647c 100644
--- a/kernel/drivers/timer.c
+++ b/kernel/drivers/timer.c
@@ -1,11 +1,11 @@
 // MIT License, Copyright (c) 2020 Marvin Borner
 
 #include <def.h>
+#include <dev.h>
 #include <drivers/cpu.h>
 #include <drivers/int.h>
 #include <drivers/rtc.h>
 #include <drivers/timer.h>
-#include <io.h>
 #include <mem.h>
 #include <proc.h>
 
@@ -70,7 +70,7 @@ CLEAR void timer_install(void)
 	timer_phase(1000);
 	int_event_handler_add(0, timer_handler);
 
-	struct io_dev *dev = zalloc(sizeof(*dev));
+	struct dev_dev *dev = zalloc(sizeof(*dev));
 	dev->read = timer_read;
-	io_add(IO_TIMER, dev);
+	dev_add(DEV_TIMER, dev);
 }
diff --git a/kernel/drivers/vbe.c b/kernel/drivers/vbe.c
index fd91062..2ba9fb1 100644
--- a/kernel/drivers/vbe.c
+++ b/kernel/drivers/vbe.c
@@ -2,11 +2,11 @@
 
 #include <assert.h>
 #include <def.h>
+#include <dev.h>
 #include <drivers/cpu.h>
 #include <drivers/vbe.h>
 #include <errno.h>
 #include <fb.h>
-#include <io.h>
 #include <mem.h>
 #include <mm.h>
 #include <multiboot.h>
@@ -31,7 +31,7 @@ static res vbe_control(u32 request, void *arg1, void *arg2, void *arg3)
 	UNUSED(arg3);
 
 	switch (request) {
-	case IOCTL_FB_GET: {
+	case DEVCTL_FB_GET: {
 		if (!generic.fb)
 			return -ENOENT;
 
@@ -67,7 +67,7 @@ CLEAR void vbe_install(u32 data)
 	generic.fb = vbe->fb;
 	fb_protect(&generic);
 
-	struct io_dev *dev = zalloc(sizeof(*dev));
+	struct dev_dev *dev = zalloc(sizeof(*dev));
 	dev->control = vbe_control;
-	io_add(IO_FRAMEBUFFER, dev);
+	dev_add(DEV_FRAMEBUFFER, dev);
 }
diff --git a/kernel/drivers/vmware.c b/kernel/drivers/vmware.c
index 24f56a0..b2069b6 100644
--- a/kernel/drivers/vmware.c
+++ b/kernel/drivers/vmware.c
@@ -2,10 +2,10 @@
 // VMWare extensions/backdoors for better VM integration
 
 #include <def.h>
+#include <dev.h>
 #include <drivers/int.h>
 #include <drivers/ps2.h>
 #include <drivers/vmware.h>
-#include <io.h>
 #include <mem.h>
 #include <print.h>
 #include <stack.h>
@@ -125,7 +125,7 @@ static void vmware_mouse_handler(void)
 	event->but.right = (buttons & VMMOUSE_RIGHT_CLICK) != 0;
 	event->but.middle = (buttons & VMMOUSE_MIDDLE_CLICK) != 0;
 	stack_push_bot(queue, event);
-	io_unblock(IO_MOUSE);
+	dev_unblock(DEV_MOUSE);
 }
 
 static res vmware_mouse_ready(void)
@@ -152,8 +152,8 @@ CLEAR void vmware_mouse_install(u8 device)
 	int_event_handler_add(12, vmware_mouse_handler);
 
 	queue = stack_new();
-	struct io_dev *dev = zalloc(sizeof(*dev));
+	struct dev_dev *dev = zalloc(sizeof(*dev));
 	dev->read = vmware_mouse_read;
 	dev->ready = vmware_mouse_ready;
-	io_add(IO_MOUSE, dev);
+	dev_add(DEV_MOUSE, dev);
 }
diff --git a/kernel/features/bus.c b/kernel/features/bus.c
index 3757a3a..ad7352f 100644
--- a/kernel/features/bus.c
+++ b/kernel/features/bus.c
@@ -4,9 +4,9 @@
 #include <bus.h>
 #include <crypto.h>
 #include <def.h>
+#include <dev.h>
 #include <drivers/cpu.h>
 #include <errno.h>
-#include <io.h>
 #include <list.h>
 #include <mem.h>
 #include <mm.h>
@@ -36,8 +36,8 @@ struct bus {
 	u32 hash;
 };
 
-PROTECTED struct list *bus_list = NULL;
-PROTECTED struct list *bus_conns = NULL;
+PROTECTED static struct list *bus_list = NULL;
+PROTECTED static struct list *bus_conns = NULL;
 static u32 conn_cnt = 1; // 0 is reserved
 
 static struct bus *bus_find_bus(u32 hash)
@@ -104,7 +104,10 @@ static res bus_register(const char *name)
 
 	u32 hash = crc32_user(0, name, len);
 	if (bus_find_bus(hash))
-		return -EBUSY;
+		return -EINVAL;
+
+	if (bus_find_owner(proc_current()->pid))
+		return -EEXIST;
 
 	struct bus *bus = zalloc(sizeof(*bus));
 	strlcpy_user(bus->name, name, sizeof(bus->name));
@@ -182,10 +185,10 @@ static res bus_send(u32 conn, const void *buf, u32 count)
 
 	if (bus->pid == proc_current()->pid) {
 		stack_push_bot(bus_conn->out, msg);
-		io_unblock_pid(bus_conn->pid);
+		dev_unblock_pid(bus_conn->pid);
 	} else {
 		stack_push_bot(bus_conn->in, msg);
-		io_unblock_pid(bus->pid);
+		dev_unblock_pid(bus->pid);
 	}
 
 	return count;
@@ -229,8 +232,6 @@ static res bus_receive(void *buf, u32 offset, u32 count)
 	if (!bus_owner && !bus_conn)
 		return -ENOENT;
 
-	// TODO: Better round-robin
-
 	if (bus_owner) {
 		struct node *iterator = bus_conns->head;
 		while (iterator) {
@@ -257,13 +258,13 @@ static res bus_control(u32 request, void *arg1, void *arg2, void *arg3)
 	UNUSED(arg3);
 
 	switch (request) {
-	case IOCTL_BUS_CONNECT_BUS: {
+	case DEVCTL_BUS_CONNECT_BUS: {
 		return bus_connect_bus(arg1, arg2);
 	}
-	case IOCTL_BUS_CONNECT_CONN: {
+	case DEVCTL_BUS_CONNECT_CONN: {
 		return bus_connect_conn((u32)arg1);
 	}
-	case IOCTL_BUS_REGISTER: {
+	case DEVCTL_BUS_REGISTER: {
 		return bus_register(arg1);
 	}
 	default: {
@@ -307,8 +308,6 @@ static res bus_ready(void)
 	if (!bus_owner && !bus_conn)
 		return -ENOENT;
 
-	// TODO: Better round-robin
-
 	if (bus_owner) {
 		struct node *iterator = bus_conns->head;
 		while (iterator) {
@@ -331,10 +330,10 @@ CLEAR void bus_install(void)
 	bus_list = list_new();
 	bus_conns = list_new();
 
-	struct io_dev *dev = zalloc(sizeof(*dev));
+	struct dev_dev *dev = zalloc(sizeof(*dev));
 	dev->control = bus_control;
 	dev->read = bus_read;
 	dev->ready = bus_ready;
 	dev->write = bus_write;
-	io_add(IO_BUS, dev);
+	dev_add(DEV_BUS, dev);
 }
diff --git a/kernel/features/io.c b/kernel/features/dev.c
index 8126ccf..ecc3f0c 100644
--- a/kernel/features/io.c
+++ b/kernel/features/dev.c
@@ -3,6 +3,7 @@
 #include <assert.h>
 #include <bus.h>
 #include <def.h>
+#include <dev.h>
 #include <drivers/bga.h>
 #include <drivers/cpu.h>
 #include <drivers/int.h>
@@ -11,7 +12,6 @@
 #include <drivers/vbe.h>
 #include <drivers/vmware.h>
 #include <fb.h>
-#include <io.h>
 #include <list.h>
 #include <logger.h>
 #include <mem.h>
@@ -22,39 +22,39 @@
 #include <str.h>
 #include <syscall.h>
 
-struct io_listener {
+struct dev_listener {
 	u32 group;
 	struct proc *proc;
 };
 
-PROTECTED static struct io_dev *io_mappings[IO_MAX] = { 0 };
-PROTECTED static struct list *io_listeners[IO_MAX] = { 0 };
+PROTECTED static struct dev_dev *dev_mappings[DEV_MAX] = { 0 };
+PROTECTED static struct list *dev_listeners[DEV_MAX] = { 0 };
 
 static u32 group_id = 0;
 
-static u8 io_type_valid(enum io_type io)
+static u8 dev_type_valid(enum dev_type type)
 {
-	return io > IO_MIN && io < IO_MAX;
+	return type > DEV_MIN && type < DEV_MAX;
 }
 
-static struct io_dev *io_get(enum io_type io)
+static struct dev_dev *dev_get(enum dev_type type)
 {
-	if (!io_type_valid(io))
+	if (!dev_type_valid(type))
 		return NULL;
 
-	return io_mappings[io];
+	return dev_mappings[type];
 }
 
 // TODO: Efficiency
-static void io_remove_group(u32 group)
+static void dev_remove_group(u32 group)
 {
-	for (u32 io = IO_MIN; io < IO_MAX; io++) {
-		struct node *iterator = io_listeners[io]->head;
+	for (u32 dev = DEV_MIN; dev < DEV_MAX; dev++) {
+		struct node *iterator = dev_listeners[dev]->head;
 		while (iterator) {
-			struct io_listener *listener = iterator->data;
+			struct dev_listener *listener = iterator->data;
 			struct node *next = iterator->next;
 			if (listener->group == group)
-				list_remove(io_listeners[io], iterator);
+				list_remove(dev_listeners[dev], iterator);
 			iterator = next;
 		}
 	}
@@ -63,13 +63,13 @@ static void io_remove_group(u32 group)
 		group_id--;
 }
 
-CLEAR void io_add(enum io_type io, struct io_dev *dev)
+CLEAR void dev_add(enum dev_type type, struct dev_dev *dev)
 {
-	assert(io_type_valid(io) && !io_mappings[io]);
-	io_mappings[io] = dev;
+	assert(dev_type_valid(type) && !dev_mappings[type]);
+	dev_mappings[type] = dev;
 }
 
-res io_poll(u32 *devs)
+res dev_poll(u32 *devs)
 {
 	if (!memory_readable(devs))
 		return -EFAULT;
@@ -78,67 +78,67 @@ res io_poll(u32 *devs)
 
 	for (u32 *p = devs; p && memory_readable(p); p++) {
 		stac();
-		enum io_type io = *p;
+		enum dev_type type = *p;
 		clac();
 
-		if (!io)
+		if (!type)
 			break;
 
-		struct io_dev *dev = io_get(io);
+		struct dev_dev *dev = dev_get(type);
 		if (!dev || !dev->read) {
-			io_remove_group(group);
+			dev_remove_group(group);
 			return -ENOENT;
 		}
 
 		if (dev->ready) {
 			res ready = dev->ready();
 			if (ready == EOK) {
-				io_remove_group(group);
-				return io;
+				dev_remove_group(group);
+				return type;
 			} else if (ready != -EAGAIN) {
 				return ready;
 			}
 		}
 
-		struct io_listener *listener = zalloc(sizeof(*listener));
+		struct dev_listener *listener = zalloc(sizeof(*listener));
 		listener->group = group;
 		listener->proc = proc_current();
-		list_add(io_listeners[io], listener);
+		list_add(dev_listeners[type], listener);
 	}
 
 	proc_state(proc_current(), PROC_BLOCKED);
 	proc_yield();
-	return io_poll(devs);
+	return dev_poll(devs);
 }
 
-res io_control(enum io_type io, u32 request, void *arg1, void *arg2, void *arg3)
+res dev_control(enum dev_type type, u32 request, void *arg1, void *arg2, void *arg3)
 {
-	struct io_dev *dev;
-	if (!(dev = io_get(io)) || !dev->control)
+	struct dev_dev *dev;
+	if (!(dev = dev_get(type)) || !dev->control)
 		return -ENOENT;
 
 	return dev->control(request, arg1, arg2, arg3);
 }
 
-res io_write(enum io_type io, const void *buf, u32 offset, u32 count)
+res dev_write(enum dev_type type, const void *buf, u32 offset, u32 count)
 {
 	if (!memory_readable_range(memory_range(buf, count)))
 		return -EFAULT;
 
-	struct io_dev *dev;
-	if (!(dev = io_get(io)) || !dev->write)
+	struct dev_dev *dev;
+	if (!(dev = dev_get(type)) || !dev->write)
 		return -ENOENT;
 
 	return dev->write(buf, offset, count);
 }
 
-res io_read(enum io_type io, void *buf, u32 offset, u32 count)
+res dev_read(enum dev_type type, void *buf, u32 offset, u32 count)
 {
 	if (!memory_writable_range(memory_range(buf, count)))
 		return -EFAULT;
 
-	struct io_dev *dev;
-	if (!(dev = io_get(io)) || !dev->read)
+	struct dev_dev *dev;
+	if (!(dev = dev_get(type)) || !dev->read)
 		return -ENOENT;
 
 	if (dev->ready && dev->ready() != EOK)
@@ -147,10 +147,10 @@ res io_read(enum io_type io, void *buf, u32 offset, u32 count)
 	return dev->read(buf, offset, count);
 }
 
-res io_ready(enum io_type io)
+res dev_ready(enum dev_type type)
 {
-	struct io_dev *dev;
-	if (!(dev = io_get(io)))
+	struct dev_dev *dev;
+	if (!(dev = dev_get(type)))
 		return -ENOENT;
 
 	if (dev->ready && dev->ready() != EOK)
@@ -159,27 +159,27 @@ res io_ready(enum io_type io)
 	return EOK;
 }
 
-void io_block(enum io_type io, struct proc *proc)
+void dev_block(enum dev_type type, struct proc *proc)
 {
-	assert(io_type_valid(io));
-	struct io_listener *listener = zalloc(sizeof(*listener));
+	assert(dev_type_valid(type));
+	struct dev_listener *listener = zalloc(sizeof(*listener));
 	listener->group = group_id++;
 	listener->proc = proc;
-	list_add(io_listeners[io], listener);
+	list_add(dev_listeners[type], listener);
 	proc_state(proc_current(), PROC_BLOCKED);
 	proc_yield();
 }
 
-void io_unblock(enum io_type io)
+void dev_unblock(enum dev_type type)
 {
-	assert(io_type_valid(io));
-	struct node *iterator = io_listeners[io]->head;
+	assert(dev_type_valid(type));
+	struct node *iterator = dev_listeners[type]->head;
 	while (iterator) {
-		struct io_listener *listener = iterator->data;
+		struct dev_listener *listener = iterator->data;
 		struct proc *proc = listener->proc;
 		proc_state(proc, PROC_RUNNING);
 		struct node *next = iterator->next;
-		io_remove_group(listener->group);
+		dev_remove_group(listener->group);
 		free(listener);
 		iterator = next;
 	}
@@ -188,17 +188,17 @@ void io_unblock(enum io_type io)
 		proc_yield();
 }
 
-void io_unblock_pid(u32 pid)
+void dev_unblock_pid(u32 pid)
 {
-	for (u32 io = IO_MIN; io < IO_MAX; io++) {
-		struct node *iterator = io_listeners[io]->head;
+	for (u32 type = DEV_MIN; type < DEV_MAX; type++) {
+		struct node *iterator = dev_listeners[type]->head;
 		while (iterator) {
-			struct io_listener *listener = iterator->data;
+			struct dev_listener *listener = iterator->data;
 			struct proc *proc = listener->proc;
 			proc_state(proc, PROC_RUNNING);
 			struct node *next = iterator->next;
 			if (proc->pid == pid) {
-				list_remove(io_listeners[io], iterator);
+				list_remove(dev_listeners[type], iterator);
 				free(listener);
 			}
 			iterator = next;
@@ -209,10 +209,10 @@ void io_unblock_pid(u32 pid)
 		proc_yield();
 }
 
-CLEAR void io_install(void)
+CLEAR void dev_install(void)
 {
-	for (u32 i = 0; i < IO_MAX; i++)
-		io_listeners[i] = list_new();
+	for (u32 i = 0; i < DEV_MAX; i++)
+		dev_listeners[i] = list_new();
 
 	/**
 	 * Keyboard & mouse detection
diff --git a/kernel/features/logger.c b/kernel/features/logger.c
index fd5d730..4385408 100644
--- a/kernel/features/logger.c
+++ b/kernel/features/logger.c
@@ -1,10 +1,10 @@
 // MIT License, Copyright (c) 2021 Marvin Borner
 
 #include <def.h>
+#include <dev.h>
 #include <drivers/cpu.h>
 #include <drivers/serial.h>
 #include <errno.h>
-#include <io.h>
 #include <logger.h>
 #include <mem.h>
 #include <print.h>
@@ -36,7 +36,7 @@ static res logger_write(const void *buf, u32 offset, u32 count)
 
 void logger_install(void)
 {
-	struct io_dev *dev = zalloc(sizeof(*dev));
+	struct dev_dev *dev = zalloc(sizeof(*dev));
 	dev->write = logger_write;
-	io_add(IO_LOGGER, dev);
+	dev_add(DEV_LOGGER, dev);
 }
diff --git a/kernel/features/syscall.c b/kernel/features/syscall.c
index 6e43caa..997fa96 100644
--- a/kernel/features/syscall.c
+++ b/kernel/features/syscall.c
@@ -1,11 +1,11 @@
 // MIT License, Copyright (c) 2020 Marvin Borner
 
+#include <dev.h>
 #include <drivers/cpu.h>
 #include <drivers/int.h>
 #include <drivers/timer.h>
 #include <errno.h>
 #include <fs.h>
-#include <io.h>
 #include <load.h>
 #include <mem.h>
 #include <mm.h>
@@ -57,29 +57,29 @@ static u32 syscall_handler(u32 esp)
 		break;
 	}
 
-	// I/O operations
-	case SYS_IOPOLL: {
-		frame->eax = io_poll((void *)frame->ebx);
+	// Device operations
+	case SYS_DEV_POLL: {
+		frame->eax = dev_poll((void *)frame->ebx);
 		break;
 	}
-	case SYS_IOREAD: {
-		res ready = io_ready(frame->ebx);
+	case SYS_DEV_READ: {
+		res ready = dev_ready(frame->ebx);
 		if (ready == -EAGAIN) {
-			io_block(frame->ebx, proc_current());
+			dev_block(frame->ebx, proc_current());
 		} else if (ready != EOK) {
 			frame->eax = ready;
 			break;
 		}
-		frame->eax = io_read(frame->ebx, (void *)frame->ecx, frame->edx, frame->esi);
+		frame->eax = dev_read(frame->ebx, (void *)frame->ecx, frame->edx, frame->esi);
 		break;
 	}
-	case SYS_IOWRITE: {
-		frame->eax = io_write(frame->ebx, (void *)frame->ecx, frame->edx, frame->esi);
+	case SYS_DEV_WRITE: {
+		frame->eax = dev_write(frame->ebx, (void *)frame->ecx, frame->edx, frame->esi);
 		break;
 	}
-	case SYS_IOCONTROL: {
-		frame->eax = io_control(frame->ebx, frame->ecx, (void *)frame->edx,
-					(void *)frame->esi, (void *)frame->edi);
+	case SYS_DEV_CONTROL: {
+		frame->eax = dev_control(frame->ebx, frame->ecx, (void *)frame->edx,
+					 (void *)frame->esi, (void *)frame->edi);
 		break;
 	}
 
diff --git a/kernel/inc/dev.h b/kernel/inc/dev.h
new file mode 100644
index 0000000..fc5e424
--- /dev/null
+++ b/kernel/inc/dev.h
@@ -0,0 +1,32 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#ifndef dev_H
+#define dev_H
+
+#include <def.h>
+#include <drivers/int.h>
+#include <proc.h>
+#include <sys.h>
+
+struct dev_dev {
+	res (*read)(void *buf, u32 offset, u32 count) NONNULL;
+	res (*write)(const void *buf, u32 offset, u32 count) NONNULL;
+	res (*control)(u32 request, void *arg1, void *arg2, void *arg3);
+	res (*ready)(void);
+};
+
+void dev_install(void);
+void dev_add(enum dev_type type, struct dev_dev *dev) NONNULL;
+
+// No NONNULL on syscalls
+res dev_control(enum dev_type type, u32 request, void *arg1, void *arg2, void *arg3);
+res dev_write(enum dev_type type, const void *buf, u32 offset, u32 count);
+res dev_read(enum dev_type type, void *buf, u32 offset, u32 count);
+res dev_poll(u32 *devs);
+res dev_ready(enum dev_type type);
+
+void dev_block(enum dev_type type, struct proc *proc) NONNULL;
+void dev_unblock(enum dev_type type);
+void dev_unblock_pid(u32 pid);
+
+#endif
diff --git a/kernel/inc/fs.h b/kernel/inc/fs.h
index 1ea4b21..42cf21a 100644
--- a/kernel/inc/fs.h
+++ b/kernel/inc/fs.h
@@ -11,12 +11,12 @@
  * Device
  */
 
-enum dev_type { DEV_BLOCK, DEV_CHAR };
+enum vfs_dev_type { DEV_BLOCK, DEV_CHAR };
 
 struct vfs_dev {
 	u32 id;
 	char name[8];
-	enum dev_type type;
+	enum vfs_dev_type type;
 	struct vfs *vfs;
 	void *data;
 	res (*read)(void *buf, u32 offset, u32 count, struct vfs_dev *dev) NONNULL;
diff --git a/kernel/inc/io.h b/kernel/inc/io.h
deleted file mode 100644
index c20a6f7..0000000
--- a/kernel/inc/io.h
+++ /dev/null
@@ -1,32 +0,0 @@
-// MIT License, Copyright (c) 2021 Marvin Borner
-
-#ifndef IO_H
-#define IO_H
-
-#include <def.h>
-#include <drivers/int.h>
-#include <proc.h>
-#include <sys.h>
-
-struct io_dev {
-	res (*read)(void *buf, u32 offset, u32 count) NONNULL;
-	res (*write)(const void *buf, u32 offset, u32 count) NONNULL;
-	res (*control)(u32 request, void *arg1, void *arg2, void *arg3);
-	res (*ready)(void);
-};
-
-void io_install(void);
-void io_add(enum io_type io, struct io_dev *dev) NONNULL;
-
-// No NONNULL on syscalls
-res io_control(enum io_type io, u32 request, void *arg1, void *arg2, void *arg3);
-res io_write(enum io_type io, const void *buf, u32 offset, u32 count);
-res io_read(enum io_type io, void *buf, u32 offset, u32 count);
-res io_poll(u32 *devs);
-res io_ready(enum io_type io);
-
-void io_block(enum io_type io, struct proc *proc) NONNULL;
-void io_unblock(enum io_type io);
-void io_unblock_pid(u32 pid);
-
-#endif
diff --git a/kernel/main.c b/kernel/main.c
index d6e7727..e7daf16 100644
--- a/kernel/main.c
+++ b/kernel/main.c
@@ -1,5 +1,6 @@
 // MIT License, Copyright (c) 2020 Marvin Borner
 
+#include <dev.h>
 #include <drivers/cpu.h>
 #include <drivers/gdt.h>
 #include <drivers/ide.h>
@@ -9,7 +10,6 @@
 #include <drivers/rtc.h>
 #include <drivers/serial.h>
 #include <fs.h>
-#include <io.h>
 #include <load.h>
 #include <mem.h>
 #include <mm.h>
@@ -42,7 +42,7 @@ int kernel_main(u32 magic, u32 addr, u32 esp)
 	pci_install();
 	pic_install();
 	idt_install();
-	io_install();
+	dev_install();
 
 	syscall_init();
 	proc_init();
diff --git a/libs/libc/crt/crt0.c b/libs/libc/crt/crt0.c
index 9e41ae2..409ec19 100644
--- a/libs/libc/crt/crt0.c
+++ b/libs/libc/crt/crt0.c
@@ -16,7 +16,7 @@ int _start(int argc, char **argv);
 int _start(int argc, char **argv)
 {
 	struct timer timer = { 0 };
-	assert(io_read(IO_TIMER, &timer, 0, sizeof(timer)) == sizeof(timer));
+	assert(dev_read(DEV_TIMER, &timer, 0, sizeof(timer)) == sizeof(timer));
 	srand(timer.rtc + timer.time);
 	__stack_chk_guard = rand();
 
diff --git a/libs/libc/inc/print.h b/libs/libc/inc/print.h
index 6997796..af06318 100644
--- a/libs/libc/inc/print.h
+++ b/libs/libc/inc/print.h
@@ -16,9 +16,9 @@ NORETURN void panic(const char *format, ...) NONNULL;
 #ifdef USER
 #include <sys.h>
 int vfprintf(const char *path, const char *format, va_list ap) NONNULL;
-int viprintf(enum io_type io, const char *format, va_list ap) NONNULL;
+int vdprintf(enum dev_type io, const char *format, va_list ap) NONNULL;
 int fprintf(const char *path, const char *format, ...) NONNULL;
-int iprintf(enum io_type io, const char *format, ...) NONNULL;
+int dprintf(enum dev_type io, const char *format, ...) NONNULL;
 int log(const char *format, ...) NONNULL;
 NORETURN void err(int code, const char *format, ...) NONNULL;
 #else
diff --git a/libs/libc/inc/sys.h b/libs/libc/inc/sys.h
index 14d9698..5b2130c 100644
--- a/libs/libc/inc/sys.h
+++ b/libs/libc/inc/sys.h
@@ -24,33 +24,33 @@ enum sys {
 	SYS_WRITE, // Write to file
 	SYS_STAT, // Get file information
 	SYS_EXEC, // Execute path
-	SYS_IOPOLL, // Block proc until I/O device is ready
-	SYS_IOREAD, // Read data from I/O device (blocking)
-	SYS_IOWRITE, // Write data to I/O device
-	SYS_IOCONTROL, // Interact with an I/O device
+	SYS_DEV_POLL, // Block proc until device is ready
+	SYS_DEV_READ, // Read data from device (blocking)
+	SYS_DEV_WRITE, // Write data to device
+	SYS_DEV_CONTROL, // Interact with an I/O device
 	SYS_EXIT, // Exit current process
 	SYS_BOOT, // Boot functions (e.g. reboot/shutdown)
 	SYS_YIELD, // Switch to next process
 	SYS_MAX,
 };
 
-enum io_type {
-	IO_MIN,
-	IO_LOGGER,
-	IO_FRAMEBUFFER,
-	IO_NETWORK,
-	IO_KEYBOARD,
-	IO_MOUSE,
-	IO_TIMER,
-	IO_BUS,
-	IO_MAX,
+enum dev_type {
+	DEV_MIN,
+	DEV_LOGGER,
+	DEV_FRAMEBUFFER,
+	DEV_NETWORK,
+	DEV_KEYBOARD,
+	DEV_MOUSE,
+	DEV_TIMER,
+	DEV_BUS,
+	DEV_MAX,
 };
 
-// I/O control declarations
-#define IOCTL_FB_GET 0
-#define IOCTL_BUS_CONNECT_BUS 0
-#define IOCTL_BUS_CONNECT_CONN 1
-#define IOCTL_BUS_REGISTER 2
+// Device control declarations
+#define DEVCTL_FB_GET 0
+#define DEVCTL_BUS_CONNECT_BUS 0
+#define DEVCTL_BUS_CONNECT_CONN 1
+#define DEVCTL_BUS_REGISTER 2
 
 struct fb_generic {
 	u16 bpp;
@@ -112,10 +112,10 @@ res write(const char *path, const void *buf, u32 offset, u32 count) NONNULL;
 res stat(const char *path, struct stat *buf) NONNULL;
 res exec(const char *path, ...) ATTR((nonnull(1))) SENTINEL;
 
-res io_poll(enum io_type *devs) NONNULL;
-res io_read(enum io_type io, void *buf, u32 offset, u32 count) NONNULL;
-res io_write(enum io_type io, const void *buf, u32 offset, u32 count) NONNULL;
-res io_control(enum io_type io, ...);
+res dev_poll(enum dev_type *devs) NONNULL;
+res dev_read(enum dev_type dev, void *buf, u32 offset, u32 count) NONNULL;
+res dev_write(enum dev_type dev, const void *buf, u32 offset, u32 count) NONNULL;
+res dev_control(enum dev_type dev, ...);
 
 res yield(void);
 res boot(u32 cmd);
diff --git a/libs/libc/print.c b/libs/libc/print.c
index 091df82..00b47c3 100644
--- a/libs/libc/print.c
+++ b/libs/libc/print.c
@@ -84,7 +84,7 @@ int snprintf(char *str, u32 size, const char *format, ...)
 
 int vprintf(const char *format, va_list ap)
 {
-	return viprintf(IO_LOGGER, format, ap);
+	return vdprintf(DEV_LOGGER, format, ap);
 }
 
 int vfprintf(const char *path, const char *format, va_list ap)
@@ -94,11 +94,11 @@ int vfprintf(const char *path, const char *format, va_list ap)
 	return write(path, buf, 0, len);
 }
 
-int viprintf(enum io_type io, const char *format, va_list ap)
+int vdprintf(enum dev_type io, const char *format, va_list ap)
 {
 	char buf[1024] = { 0 };
 	int len = vsnprintf(buf, sizeof(buf), format, ap);
-	return io_write(io, buf, 0, len);
+	return dev_write(io, buf, 0, len);
 }
 
 int fprintf(const char *path, const char *format, ...)
@@ -111,11 +111,11 @@ int fprintf(const char *path, const char *format, ...)
 	return len;
 }
 
-int iprintf(enum io_type io, const char *format, ...)
+int dprintf(enum dev_type io, const char *format, ...)
 {
 	va_list ap;
 	va_start(ap, format);
-	int len = viprintf(io, format, ap);
+	int len = vdprintf(io, format, ap);
 	va_end(ap);
 
 	return len;
@@ -135,7 +135,7 @@ int log(const char *format, ...)
 {
 	va_list ap;
 	va_start(ap, format);
-	int len = viprintf(IO_LOGGER, format, ap);
+	int len = vdprintf(DEV_LOGGER, format, ap);
 	va_end(ap);
 
 	return len;
@@ -143,18 +143,19 @@ int log(const char *format, ...)
 
 NORETURN void err(int code, const char *format, ...)
 {
+	log("Exiting process with code %d\n", code);
 	if (errno != EOK)
 		log("ERRNO: %d (%s)\n", errno, strerror(errno));
 	va_list ap;
 	va_start(ap, format);
-	viprintf(IO_LOGGER, format, ap);
+	vdprintf(DEV_LOGGER, format, ap);
 	va_end(ap);
 	exit(code);
 }
 
 int print(const char *str)
 {
-	return io_write(IO_LOGGER, str, 0, strlen(str));
+	return dev_write(DEV_LOGGER, str, 0, strlen(str));
 }
 
 #else
diff --git a/libs/libc/sys.c b/libs/libc/sys.c
index 8d0a9b8..b00bd32 100644
--- a/libs/libc/sys.c
+++ b/libs/libc/sys.c
@@ -128,22 +128,22 @@ res exec(const char *path, ...)
 	return sys5(SYS_EXEC, (int)path, args[0], args[1], args[2], args[3]);
 }
 
-res io_poll(enum io_type *devs)
+res dev_poll(enum dev_type *devs)
 {
-	return sys1(SYS_IOPOLL, (int)devs);
+	return sys1(SYS_DEV_POLL, (int)devs);
 }
 
-res io_read(enum io_type io, void *buf, u32 offset, u32 count)
+res dev_read(enum dev_type io, void *buf, u32 offset, u32 count)
 {
-	return sys4(SYS_IOREAD, (int)io, (int)buf, (int)offset, (int)count);
+	return sys4(SYS_DEV_READ, (int)io, (int)buf, (int)offset, (int)count);
 }
 
-res io_write(enum io_type io, const void *buf, u32 offset, u32 count)
+res dev_write(enum dev_type io, const void *buf, u32 offset, u32 count)
 {
-	return sys4(SYS_IOWRITE, (int)io, (int)buf, (int)offset, (int)count);
+	return sys4(SYS_DEV_WRITE, (int)io, (int)buf, (int)offset, (int)count);
 }
 
-res io_control(enum io_type io, ...)
+res dev_control(enum dev_type io, ...)
 {
 	va_list ap;
 	int args[4] = { 0 };
@@ -153,7 +153,7 @@ res io_control(enum io_type io, ...)
 		args[i] = va_arg(ap, int);
 	va_end(ap);
 
-	return sys5(SYS_IOCONTROL, (int)io, args[0], args[1], args[2], args[3]);
+	return sys5(SYS_DEV_CONTROL, (int)io, args[0], args[1], args[2], args[3]);
 }
 
 res yield(void)
diff --git a/libs/libgui/gfx.c b/libs/libgui/gfx.c
index bae98a0..f16b8dd 100644
--- a/libs/libgui/gfx.c
+++ b/libs/libgui/gfx.c
@@ -242,14 +242,11 @@ void gfx_draw_image_filter(struct gfx_context *ctx, vec2 pos, vec2 size, enum gf
 	// Scaling clones!
 	bmp = gfx_scale(bmp, size);
 
-	assert(bmp->size.x + pos.x <= ctx->size.x);
-	assert(bmp->size.y + pos.y <= ctx->size.y);
-
 	u8 bypp = bmp->bpp >> 3;
 	u8 *srcfb = bmp->fb;
 	u8 *destfb = &ctx->fb[pos.x * bypp + pos.y * ctx->pitch];
 	for (u32 cy = 0; cy < bmp->size.y && cy + pos.y < ctx->size.y; cy++) {
-		int diff = 0;
+		u32 diff = 0;
 		for (u32 cx = 0; cx < bmp->size.x && cx + pos.x < ctx->size.x; cx++) {
 			if (srcfb[bypp - 1]) {
 				if (filter == GFX_FILTER_NONE) {
diff --git a/libs/libgui/msg.c b/libs/libgui/msg.c
index eda4c34..a8da87c 100644
--- a/libs/libgui/msg.c
+++ b/libs/libgui/msg.c
@@ -10,14 +10,14 @@
 
 res msg_connect_bus(const char *bus, u32 *conn)
 {
-	res ret = io_control(IO_BUS, IOCTL_BUS_CONNECT_BUS, bus, conn);
+	res ret = dev_control(DEV_BUS, DEVCTL_BUS_CONNECT_BUS, bus, conn);
 	/* assert(ret == EOK && *conn); */
 	return ret;
 }
 
 res msg_connect_conn(u32 conn)
 {
-	res ret = io_control(IO_BUS, IOCTL_BUS_CONNECT_CONN, conn);
+	res ret = dev_control(DEV_BUS, DEVCTL_BUS_CONNECT_CONN, conn);
 	/* assert(ret == EOK); */
 	return ret;
 }
@@ -28,14 +28,14 @@ res msg_send(enum message_type type, void *data, u32 size)
 	struct message_header *header = data;
 	header->magic = MSG_MAGIC;
 	header->type = type;
-	res ret = io_write(IO_BUS, (u8 *)data + sizeof(struct bus_header), 0, size);
+	res ret = dev_write(DEV_BUS, (u8 *)data + sizeof(struct bus_header), 0, size);
 	/* assert(ret >= EOK); */
 	return ret;
 }
 
 res msg_receive(void *buf, u32 size)
 {
-	res ret = io_read(IO_BUS, buf, 0, size);
+	res ret = dev_read(DEV_BUS, buf, 0, size);
 	struct message_header *header = buf;
 	if (header->magic == MSG_MAGIC)
 		return ret;