Started IO dev manager

6 files changed, 121 insertions, 361 deletions

diff --git a/kernel/features/fs.c b/kernel/features/fs.c
index 82d00b6..c3d5402 100644
--- a/kernel/features/fs.c
+++ b/kernel/features/fs.c
@@ -10,7 +10,7 @@
 #include <mem.h>
 #include <mm.h>
 #include <print.h>
-#include <random.h>
+#include <rand.h>
 #include <str.h>
 
 /**
@@ -28,7 +28,7 @@ static char *vfs_normalize_path(const char *path)
 	return fixed;
 }
 
-u8 vfs_mounted(struct device *dev, const char *path)
+u8 vfs_mounted(struct vfs_dev *dev, const char *path)
 {
 	struct node *iterator = mount_points->head;
 	while (iterator) {
@@ -77,7 +77,12 @@ static struct mount_info *vfs_find_mount_info(const char *path)
 	return ret;
 }
 
-struct device *vfs_find_dev(const char *path)
+CLEAR void vfs_add_dev(struct vfs_dev *dev)
+{
+	dev->id = rand() + 1;
+}
+
+struct vfs_dev *vfs_find_dev(const char *path)
 {
 	stac();
 	if (path[0] != '/') {
@@ -86,8 +91,6 @@ struct device *vfs_find_dev(const char *path)
 	}
 	clac();
 	struct mount_info *m = vfs_find_mount_info(path);
-	if (m->dev->vfs->type == VFS_DEVFS) // TODO: ?
-		return device_get_by_name(path + strlen(m->path) + 1);
 	return m && m->dev ? m->dev : NULL;
 }
 
@@ -118,7 +121,7 @@ static void vfs_list_mounts()
 	}
 }*/
 
-res vfs_mount(struct device *dev, const char *path)
+res vfs_mount(struct vfs_dev *dev, const char *path)
 {
 	if (!memory_readable(path))
 		return -EFAULT;
@@ -242,187 +245,24 @@ res vfs_stat(const char *path, struct stat *buf)
 	return m->dev->vfs->stat(path, buf, m->dev);
 }
 
-res vfs_block(const char *path, u32 func_ptr)
-{
-	if (!func_ptr || !memory_readable(path))
-		return -EFAULT;
-
-	struct mount_info *m = vfs_find_mount_info(path);
-	if (!m || !m->dev || !m->dev->vfs)
-		return -ENOENT;
-
-	// Default block
-	if (!m->dev->vfs->block) {
-		proc_block(vfs_find_dev(path)->id, PROC_BLOCK_DEV, func_ptr);
-		return EOK;
-	}
-
-	u32 len = strlen(m->path);
-	if (len > 1)
-		path += len;
-
-	return m->dev->vfs->block(path, func_ptr, m->dev);
-}
-
-// TODO: Reduce stac clac?
-// TODO: Fix page fault when called too often/fast
-res vfs_poll(const char **files)
-{
-	if (!memory_readable(files))
-		return -EFAULT;
-
-	stac();
-	for (const char **p = files; *p && memory_readable(*p) && **p; p++) {
-		res ready = vfs_ready(*p);
-		clac();
-		if (ready == 1)
-			return p - files;
-		else if (ready < 0)
-			return ready;
-		stac();
-	}
-
-	for (const char **p = files; *p && memory_readable(*p) && **p; p++) {
-		vfs_block(*p, (u32)vfs_poll);
-		stac();
-	}
-	clac();
-
-	return PROC_MAX_BLOCK_IDS + 1;
-}
-
-res vfs_ready(const char *path)
-{
-	if (!memory_readable(path))
-		return -EFAULT;
-
-	struct mount_info *m = vfs_find_mount_info(path);
-	if (!m || !m->dev || !m->dev->vfs)
-		return -ENOENT;
-
-	if (!m->dev->vfs->ready)
-		return -EINVAL;
-
-	u32 len = strlen(m->path);
-	if (len > 1)
-		path += len;
-
-	return m->dev->vfs->ready(path, m->dev);
-}
-
 CLEAR void vfs_install(void)
 {
 	mount_points = list_new();
 }
 
 /**
- * Device
- */
-
-PROTECTED static struct list *devices = NULL;
-
-CLEAR void device_add(struct device *dev)
-{
-	dev->id = rand() + 1;
-	list_add(devices, dev);
-}
-
-struct device *device_get_by_id(u32 id)
-{
-	struct node *iterator = devices->head;
-	while (iterator) {
-		if (((struct device *)iterator->data)->id == id)
-			return iterator->data;
-		iterator = iterator->next;
-	}
-	return NULL;
-}
-
-struct device *device_get_by_name(const char *name)
-{
-	struct node *iterator = devices->head;
-	while (iterator) {
-		if (!strcmp_user(((struct device *)iterator->data)->name, name))
-			return iterator->data;
-		iterator = iterator->next;
-	}
-	return NULL;
-}
-
-static res devfs_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
-{
-	struct device *target = device_get_by_name(path + 1);
-	if (!target)
-		return -ENOENT;
-	if (!target->read)
-		return -EINVAL;
-	return target->read(buf, offset, count, dev);
-}
-
-static res devfs_ioctl(const char *path, u32 request, void *arg1, void *arg2, void *arg3,
-		       struct device *dev)
-{
-	struct device *target = device_get_by_name(path + 1);
-	if (!target)
-		return -ENOENT;
-	if (!target->ioctl)
-		return -EINVAL;
-	return target->ioctl(request, arg1, arg2, arg3, dev);
-}
-
-static res devfs_perm(const char *path, enum vfs_perm perm, struct device *dev)
-{
-	UNUSED(path);
-	UNUSED(perm);
-	UNUSED(dev);
-	return EOK;
-}
-
-static res devfs_ready(const char *path, struct device *dev)
-{
-	UNUSED(dev);
-
-	struct device *target = device_get_by_name(path + 1);
-	if (!target)
-		return -ENOENT;
-	if (!target->ready)
-		return -EINVAL;
-	return target->ready();
-}
-
-CLEAR void device_install(void)
-{
-	devices = list_new();
-
-	struct vfs *vfs = zalloc(sizeof(*vfs));
-	vfs->type = VFS_DEVFS;
-	vfs->read = devfs_read;
-	vfs->ioctl = devfs_ioctl;
-	vfs->perm = devfs_perm;
-	vfs->ready = devfs_ready;
-	struct device *dev = zalloc(sizeof(*dev));
-	dev->name = "dev";
-	dev->type = DEV_CHAR;
-	dev->vfs = vfs;
-	device_add(dev);
-	vfs_mount(dev, "/dev/");
-
-	/* vfs_list_mounts(); */
-}
-
-/**
  * EXT2
  */
 
 // TODO: Remove malloc from ext2_buffer_read (attempt in #56cd63f199)
-static void *ext2_buffer_read(u32 block, struct device *dev)
+static void *ext2_buffer_read(u32 block, struct vfs_dev *dev)
 {
 	void *buf = zalloc(BLOCK_SIZE);
 	dev->read(buf, block * SECTOR_COUNT, SECTOR_COUNT, dev);
 	return buf;
 }
 
-static struct ext2_superblock *ext2_get_superblock(struct device *dev)
+static struct ext2_superblock *ext2_get_superblock(struct vfs_dev *dev)
 {
 	struct ext2_superblock *sb = ext2_buffer_read(EXT2_SUPER, dev);
 
@@ -430,12 +270,12 @@ static struct ext2_superblock *ext2_get_superblock(struct device *dev)
 	return sb;
 }
 
-static struct ext2_bgd *ext2_get_bgd(struct device *dev)
+static struct ext2_bgd *ext2_get_bgd(struct vfs_dev *dev)
 {
 	return ext2_buffer_read(EXT2_SUPER + 1, dev);
 }
 
-static struct ext2_inode *ext2_get_inode(u32 i, struct ext2_inode *in_buf, struct device *dev)
+static struct ext2_inode *ext2_get_inode(u32 i, struct ext2_inode *in_buf, struct vfs_dev *dev)
 {
 	struct ext2_superblock *s = ext2_get_superblock(dev);
 	assert(s);
@@ -465,7 +305,7 @@ struct indirect_cache {
 	u8 data[BLOCK_SIZE];
 };
 static struct list *indirect_cache = NULL;
-static u32 ext2_read_indirect(u32 indirect, u32 block_num, struct device *dev)
+static u32 ext2_read_indirect(u32 indirect, u32 block_num, struct vfs_dev *dev)
 {
 	void *data = NULL;
 	if (indirect_cache) {
@@ -496,7 +336,7 @@ static u32 ext2_read_indirect(u32 indirect, u32 block_num, struct device *dev)
 }
 
 static res ext2_read_inode(struct ext2_inode *in, void *buf, u32 offset, u32 count,
-			   struct device *dev)
+			   struct vfs_dev *dev)
 {
 	if (!in || !buf)
 		return -EINVAL;
@@ -563,7 +403,7 @@ static res ext2_read_inode(struct ext2_inode *in, void *buf, u32 offset, u32 cou
 	return copied;
 }
 
-static u32 ext2_find_inode(const char *name, u32 dir_inode, struct device *dev)
+static u32 ext2_find_inode(const char *name, u32 dir_inode, struct vfs_dev *dev)
 {
 	if ((signed)dir_inode <= 0)
 		return (unsigned)-1;
@@ -599,7 +439,7 @@ static u32 ext2_find_inode(const char *name, u32 dir_inode, struct device *dev)
 }
 
 static struct ext2_inode *ext2_find_inode_by_path(const char *path, struct ext2_inode *in_buf,
-						  struct device *dev)
+						  struct vfs_dev *dev)
 {
 	char *path_cp = strdup_user(path);
 	char *init = path_cp; // For freeing
@@ -640,7 +480,7 @@ static struct ext2_inode *ext2_find_inode_by_path(const char *path, struct ext2_
 	return ext2_get_inode(inode, in_buf, dev);
 }
 
-res ext2_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
+res ext2_read(const char *path, void *buf, u32 offset, u32 count, struct vfs_dev *dev)
 {
 	struct ext2_inode in = { 0 };
 	if (ext2_find_inode_by_path(path, &in, dev) == &in) {
@@ -649,7 +489,7 @@ res ext2_read(const char *path, void *buf, u32 offset, u32 count, struct device
 		return -ENOENT;
 }
 
-res ext2_stat(const char *path, struct stat *buf, struct device *dev)
+res ext2_stat(const char *path, struct stat *buf, struct vfs_dev *dev)
 {
 	struct ext2_inode in = { 0 };
 	if (ext2_find_inode_by_path(path, &in, dev) != &in)
@@ -666,7 +506,7 @@ res ext2_stat(const char *path, struct stat *buf, struct device *dev)
 	return EOK;
 }
 
-res ext2_perm(const char *path, enum vfs_perm perm, struct device *dev)
+res ext2_perm(const char *path, enum vfs_perm perm, struct vfs_dev *dev)
 {
 	struct ext2_inode in = { 0 };
 	if (ext2_find_inode_by_path(path, &in, dev) != &in)
@@ -683,10 +523,3 @@ res ext2_perm(const char *path, enum vfs_perm perm, struct device *dev)
 		return -EINVAL;
 	}
 }
-
-res ext2_ready(const char *path, struct device *dev)
-{
-	UNUSED(path);
-	UNUSED(dev);
-	return 1;
-}
diff --git a/kernel/features/io.c b/kernel/features/io.c
new file mode 100644
index 0000000..2bd925b
--- /dev/null
+++ b/kernel/features/io.c
@@ -0,0 +1,67 @@
+// MIT License, Copyright (c) 2021 Marvin Borner
+
+#include <assert.h>
+#include <def.h>
+#include <io.h>
+#include <list.h>
+#include <mm.h>
+#include <rand.h>
+#include <str.h>
+
+PROTECTED static struct io_dev *io_mappings[IO_MAX] = { 0 };
+
+static u8 io_type_valid(enum io_type io)
+{
+	return io > IO_MIN && io < IO_MAX;
+}
+
+static struct io_dev *io_get(enum io_type io)
+{
+	if (!io_type_valid(io))
+		return NULL;
+
+	return io_mappings[io];
+}
+
+CLEAR void io_add(enum io_type io, struct io_dev *dev)
+{
+	assert(io_type_valid(io) && !io_mappings[io]);
+	io_mappings[io] = dev;
+}
+
+res io_control(enum io_type io)
+{
+	if (!io_get(io))
+		return -ENOENT;
+
+	return -ENOENT;
+}
+
+res io_write(enum io_type io, void *buf, u32 offset, u32 count)
+{
+	if (!memory_readable(buf))
+		return -EFAULT;
+
+	if (!io_get(io))
+		return -ENOENT;
+}
+
+res io_read(enum io_type io, void *buf, u32 offset, u32 count)
+{
+	if (!memory_readable(buf))
+		return -EFAULT;
+
+	if (!io_get(io))
+		return -ENOENT;
+}
+
+res io_poll(enum io_type io)
+{
+	if (!io_get(io))
+		return -ENOENT;
+}
+
+CLEAR void io_install(void)
+{
+	// TODO: Install I/O devices by selecting best working driver
+}
diff --git a/kernel/features/load.c b/kernel/features/load.c
index 77bb680..cbe32ed 100644
--- a/kernel/features/load.c
+++ b/kernel/features/load.c
@@ -6,7 +6,7 @@
 #include <load.h>
 #include <mem.h>
 #include <mm.h>
-#include <random.h>
+#include <rand.h>
 #include <str.h>
 
 res elf_load(const char *name, struct proc *proc)
diff --git a/kernel/features/mm.c b/kernel/features/mm.c
index 9a7a64e..d9e4577 100644
--- a/kernel/features/mm.c
+++ b/kernel/features/mm.c
@@ -9,7 +9,7 @@
 #include <mem.h>
 #include <mm.h>
 #include <print.h>
-#include <random.h>
+#include <rand.h>
 
 PROTECTED static struct page_dir kernel_dir ALIGNED(PAGE_SIZE) = { 0 };
 static struct page_table kernel_tables[PAGE_KERNEL_COUNT] ALIGNED(PAGE_SIZE) = { 0 };
diff --git a/kernel/features/proc.c b/kernel/features/proc.c
index 3a6b429..a71919e 100644
--- a/kernel/features/proc.c
+++ b/kernel/features/proc.c
@@ -184,92 +184,6 @@ void proc_yield(struct regs *r)
 	scheduler(r);
 }
 
-// TODO: Rewrite block/unblock mechanisms
-void proc_block(u32 id, enum proc_block_type type, u32 func_ptr)
-{
-	u8 already_exists = 0;
-	struct proc *p = proc_current();
-
-	// Check if already exists
-	for (u32 i = 0; i < p->block.id_cnt; i++) {
-		if (p->block.ids[i].id == id && p->block.ids[i].type == type) {
-			assert(p->block.ids[i].func_ptr == func_ptr);
-			already_exists = 1;
-		}
-	}
-
-	if (already_exists)
-		goto end;
-
-	assert(p->block.id_cnt + 1 < PROC_MAX_BLOCK_IDS);
-
-	// Find slot
-	struct proc_block_identifier *slot = NULL;
-	for (u32 i = 0; i < PROC_MAX_BLOCK_IDS; i++) {
-		if (p->block.ids[i].magic != PROC_BLOCK_MAGIC) {
-			slot = &p->block.ids[i];
-			break;
-		}
-	}
-	assert(slot);
-
-	slot->magic = PROC_BLOCK_MAGIC;
-	slot->id = id;
-	slot->type = type;
-	slot->func_ptr = func_ptr;
-	p->block.id_cnt++;
-
-end:
-	proc_state(p, PROC_BLOCKED);
-}
-
-// TODO: Rewrite block/unblock mechanisms
-void proc_unblock(u32 id, enum proc_block_type type)
-{
-	struct page_dir *dir_bak;
-	memory_backup_dir(&dir_bak);
-
-	struct node *proc_bak = current;
-	if (!proc_bak)
-		return;
-
-	struct node *iterator = proc_list_blocked->head;
-	while (iterator) {
-		struct proc *p = iterator->data;
-		struct proc_block *w = &p->block;
-
-		if (!p || !w || w->id_cnt == 0) {
-			iterator = iterator->next;
-			continue;
-		}
-
-		current = list_first_data(proc_list_blocked, p);
-		assert(w->id_cnt < PROC_MAX_BLOCK_IDS);
-		for (u32 i = 0; i < w->id_cnt; i++) {
-			if (w->ids[i].magic == PROC_BLOCK_MAGIC && w->ids[i].id == id &&
-			    w->ids[i].type == type) {
-				struct regs *r = &p->regs;
-				u32 (*func)(u32, u32, u32, u32) =
-					(u32(*)(u32, u32, u32, u32))w->ids[i].func_ptr;
-				if (w->ids[i].func_ptr) {
-					memory_switch_dir(p->page_dir);
-					r->eax = func(r->ebx, r->ecx, r->edx, r->esi);
-					memory_switch_dir(dir_bak);
-				}
-				memset(&w->ids[i], 0, sizeof(w->ids[i]));
-				p->block.id_cnt--;
-				proc_state(p, PROC_RUNNING);
-				break;
-			}
-		}
-
-		iterator = iterator->next;
-	}
-
-	if (current != proc_bak)
-		current = proc_bak;
-}
-
 struct proc *proc_make(enum proc_priv priv)
 {
 	struct proc *proc = zalloc(sizeof(*proc));
@@ -355,9 +269,10 @@ struct procfs_message {
 	u32 size;
 };
 
-static res procfs_write(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
+static res procfs_write(const char *path, void *buf, u32 offset, u32 count, struct vfs_dev *dev)
 {
 	UNUSED(offset);
+	UNUSED(dev);
 
 	u32 pid = 0;
 	procfs_parse_path(&path, &pid);
@@ -378,7 +293,6 @@ static res procfs_write(const char *path, void *buf, u32 offset, u32 count, stru
 			msg->data = msg_data;
 			msg->size = count;
 			stack_push_bot(p->messages, msg); // TODO: Use offset
-			proc_unblock(pid, PROC_BLOCK_MSG);
 			return count;
 		} else if (!memcmp_user(path, "io/", 3)) {
 			path += 3;
@@ -394,7 +308,6 @@ static res procfs_write(const char *path, void *buf, u32 offset, u32 count, stru
 			assert(stream->offset_write + count < STREAM_MAX_SIZE); // TODO: Resize
 			memcpy_user((char *)(stream->data + stream->offset_write), buf, count);
 			stream->offset_write += count;
-			proc_unblock(dev->id, PROC_BLOCK_DEV);
 			return count;
 		}
 	}
@@ -402,7 +315,7 @@ static res procfs_write(const char *path, void *buf, u32 offset, u32 count, stru
 	return -ENOENT;
 }
 
-static res procfs_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
+static res procfs_read(const char *path, void *buf, u32 offset, u32 count, struct vfs_dev *dev)
 {
 	(void)dev;
 	u32 pid = 0;
@@ -458,34 +371,7 @@ static res procfs_read(const char *path, void *buf, u32 offset, u32 count, struc
 	return -ENOENT;
 }
 
-static res procfs_block(const char *path, u32 func_ptr, struct device *dev)
-{
-	u32 pid = 0;
-	procfs_parse_path(&path, &pid);
-
-	if (pid) {
-		struct proc *p = proc_from_pid(pid);
-		stac();
-		if (!p || path[0] != '/') {
-			clac();
-			return -ENOENT;
-		}
-		clac();
-
-		path++;
-		if (!memcmp_user(path, "msg", 4)) {
-			proc_block(pid, PROC_BLOCK_MSG, func_ptr);
-			return EOK;
-		} else {
-			proc_block(dev->id, PROC_BLOCK_DEV, func_ptr);
-			return EOK;
-		}
-	}
-
-	return -ENOENT;
-}
-
-static res procfs_perm(const char *path, enum vfs_perm perm, struct device *dev)
+static res procfs_perm(const char *path, enum vfs_perm perm, struct vfs_dev *dev)
 {
 	(void)path;
 	(void)dev;
@@ -496,38 +382,6 @@ static res procfs_perm(const char *path, enum vfs_perm perm, struct device *dev)
 		return EOK;
 }
 
-static res procfs_ready(const char *path, struct device *dev)
-{
-	(void)dev;
-
-	u32 pid = 0;
-	procfs_parse_path(&path, &pid);
-
-	if (pid) {
-		struct proc *p = proc_from_pid(pid);
-		stac();
-		if (!p || path[0] != '/') {
-			clac();
-			return -ENOENT;
-		}
-		clac();
-
-		path++;
-		if (!memcmp_user(path, "msg", 4)) {
-			return stack_empty(p->messages) == 0;
-		} else if (!memcmp_user(path, "io/", 3)) {
-			path += 3;
-			enum stream_defaults id = procfs_stream(path);
-			if (id == STREAM_UNKNOWN)
-				return -ENOENT;
-			struct stream *stream = &p->streams[id];
-			return stream->data[stream->offset_read] != 0;
-		}
-	}
-
-	return 1;
-}
-
 extern void proc_jump_userspace(void);
 
 u32 _esp, _eip;
@@ -547,15 +401,13 @@ NORETURN void proc_init(void)
 	vfs->type = VFS_PROCFS;
 	vfs->read = procfs_read;
 	vfs->write = procfs_write;
-	vfs->block = procfs_block;
 	vfs->perm = procfs_perm;
-	vfs->ready = procfs_ready;
 	vfs->data = NULL;
-	struct device *dev = zalloc(sizeof(*dev));
+	struct vfs_dev *dev = zalloc(sizeof(*dev));
 	dev->name = "proc";
 	dev->type = DEV_CHAR;
 	dev->vfs = vfs;
-	device_add(dev);
+	vfs_add_dev(dev);
 	assert(vfs_mount(dev, "/proc/") == EOK);
 
 	// Idle proc
diff --git a/kernel/features/syscall.c b/kernel/features/syscall.c
index 65777d8..1e21edd 100644
--- a/kernel/features/syscall.c
+++ b/kernel/features/syscall.c
@@ -4,6 +4,7 @@
 #include <errno.h>
 #include <fs.h>
 #include <interrupts.h>
+#include <io.h>
 #include <load.h>
 #include <mem.h>
 #include <mm.h>
@@ -23,6 +24,7 @@ static void syscall_handler(struct regs *r)
 	/* printf("[SYSCALL] %d from %s\n", num, proc_current()->name); */
 
 	switch (num) {
+	// Memory operations
 	case SYS_ALLOC: {
 		r->eax = memory_sys_alloc(proc_current()->page_dir, r->ebx, (u32 *)r->ecx,
 					  (u32 *)r->edx, (u8)r->esi);
@@ -37,20 +39,14 @@ static void syscall_handler(struct regs *r)
 					     (u32 *)r->edx);
 		break;
 	}
+
+	// File operations
 	case SYS_STAT: {
 		r->eax = vfs_stat((char *)r->ebx, (struct stat *)r->ecx);
 		break;
 	}
 	case SYS_READ: {
-		if (vfs_ready((char *)r->ebx)) {
-			r->eax = (u32)vfs_read((char *)r->ebx, (void *)r->ecx, r->edx, r->esi);
-		} else {
-			res wait = vfs_block((char *)r->ebx, (u32)vfs_read);
-			if (wait != 0)
-				r->eax = wait;
-			else
-				proc_yield(r);
-		}
+		r->eax = vfs_read((char *)r->ebx, (void *)r->ecx, r->edx, r->esi);
 		break;
 	}
 	case SYS_WRITE: {
@@ -62,13 +58,22 @@ static void syscall_handler(struct regs *r)
 				   (void *)r->edi);
 		break;
 	}
-	case SYS_POLL: {
-		res ret = vfs_poll((const char **)r->ebx);
-		r->eax = ret;
-		if (ret == PROC_MAX_BLOCK_IDS + 1)
-			proc_yield(r);
+
+	// I/O operations
+	case SYS_IOPOLL: {
+		r->eax = io_poll((void *)r->ebx);
 		break;
 	}
+	case SYS_IOREAD: {
+		r->eax = io_read(r->ebx, (void *)r->ecx, r->edx, r->esi);
+		break;
+	}
+	case SYS_IOWRITE: {
+		r->eax = io_write(r->ebx, (void *)r->ecx, r->edx, r->esi);
+		break;
+	}
+
+	// Process operations
 	case SYS_EXEC: {
 		char *path = (char *)r->ebx;
 		struct proc *proc = proc_make(PROC_PRIV_NONE);
@@ -86,6 +91,12 @@ static void syscall_handler(struct regs *r)
 		proc_exit(proc_current(), r, (s32)r->ebx);
 		break;
 	}
+	case SYS_YIELD: {
+		proc_yield(r);
+		break;
+	}
+
+	// System operations
 	case SYS_BOOT: { // TODO: Move
 		if (r->ebx != SYS_BOOT_MAGIC) {
 			r->eax = -EINVAL;
@@ -113,10 +124,7 @@ static void syscall_handler(struct regs *r)
 		}
 		break;
 	}
-	case SYS_YIELD: {
-		proc_yield(r);
-		break;
-	}
+
 	// TODO: Reimplement network functions using VFS
 	default: {
 		printf("Unknown syscall %d!\n", num);