Hardened syscalls

13 files changed, 144 insertions, 110 deletions

diff --git a/kernel/drivers/fb.c b/kernel/drivers/fb.c
index 2db05f2..0a9494a 100644
--- a/kernel/drivers/fb.c
+++ b/kernel/drivers/fb.c
@@ -2,6 +2,7 @@
 
 #include <assert.h>
 #include <def.h>
+#include <errno.h>
 #include <fb.h>
 #include <fs.h>
 #include <ioctl.h>
@@ -23,7 +24,8 @@ struct vbe_basic {
 static u32 dev_id = 0;
 static struct vid_info *info = NULL;
 
-static s32 fb_ioctl(u32 request, void *arg1, void *arg2, void *arg3, struct device *dev)
+static u32 fb_owner = 0;
+static res fb_ioctl(u32 request, void *arg1, void *arg2, void *arg3, struct device *dev)
 {
 	UNUSED(arg2);
 	UNUSED(arg3);
@@ -32,17 +34,26 @@ static s32 fb_ioctl(u32 request, void *arg1, void *arg2, void *arg3, struct devi
 	switch (request) {
 	case IO_FB_GET: {
 		if (!info)
-			return -1;
+			return -ENOENT;
+
+		if (!arg1 || !memory_valid(arg1))
+			return -EFAULT;
+
+		if (fb_owner != 0 && proc_from_pid(fb_owner))
+			return -EBUSY;
+		else
+			fb_owner = proc_current()->pid;
+
 		memcpy(arg1, info->vbe, sizeof(struct vbe_basic));
 		fb_map_buffer(proc_current()->page_dir, info);
-		return 0;
+		return EOK;
 	}
 	default:
-		return -1;
+		return -EINVAL;
 	}
 }
 
-static s32 fb_ready(void)
+static res fb_ready(void)
 {
 	return 1;
 }
diff --git a/kernel/drivers/ide.c b/kernel/drivers/ide.c
index 2d02f94..7146eb2 100644
--- a/kernel/drivers/ide.c
+++ b/kernel/drivers/ide.c
@@ -106,7 +106,7 @@ static u8 ata_read_one(u8 *buf, u32 lba, struct device *dev)
 	return 1;
 }
 
-static s32 ata_read(void *buf, u32 lba, u32 sector_count, struct device *dev)
+static res ata_read(void *buf, u32 lba, u32 sector_count, struct device *dev)
 {
 	u8 *b = buf; // I love bytes, yk
 	for (u32 i = 0; i < sector_count; i++) {
diff --git a/kernel/drivers/keyboard.c b/kernel/drivers/keyboard.c
index 79cd579..b123bcc 100644
--- a/kernel/drivers/keyboard.c
+++ b/kernel/drivers/keyboard.c
@@ -61,7 +61,7 @@ static void keyboard_rate(void)
 	outb(0x60, 0x0); // Rate{00000} Delay{00} 0
 }*/
 
-static s32 keyboard_read(void *buf, u32 offset, u32 count, struct device *dev)
+static res keyboard_read(void *buf, u32 offset, u32 count, struct device *dev)
 {
 	UNUSED(dev);
 	if (stack_empty(queue))
@@ -73,7 +73,7 @@ static s32 keyboard_read(void *buf, u32 offset, u32 count, struct device *dev)
 	return MIN(count, sizeof(*e));
 }
 
-static s32 keyboard_ready(void)
+static res keyboard_ready(void)
 {
 	return !stack_empty(queue);
 }
diff --git a/kernel/drivers/mouse.c b/kernel/drivers/mouse.c
index 8545099..ad36cc4 100644
--- a/kernel/drivers/mouse.c
+++ b/kernel/drivers/mouse.c
@@ -84,12 +84,12 @@ static u8 mouse_serial_read(void)
 	return inb(0x60);
 }
 
-static s32 mouse_ready(void)
+static res mouse_ready(void)
 {
 	return !stack_empty(queue);
 }
 
-static s32 mouse_read(void *buf, u32 offset, u32 count, struct device *dev)
+static res mouse_read(void *buf, u32 offset, u32 count, struct device *dev)
 {
 	(void)dev;
 	if (stack_empty(queue))
diff --git a/kernel/features/fs.c b/kernel/features/fs.c
index 920add1..ce56b4c 100644
--- a/kernel/features/fs.c
+++ b/kernel/features/fs.c
@@ -106,7 +106,7 @@ static void vfs_list_mounts()
 	}
 }*/
 
-s32 vfs_mount(struct device *dev, const char *path)
+res vfs_mount(struct device *dev, const char *path)
 {
 	if (!path || !memory_valid(path))
 		return -EFAULT;
@@ -124,10 +124,10 @@ s32 vfs_mount(struct device *dev, const char *path)
 	m->dev = dev;
 	list_add(mount_points, m);
 
-	return 0;
+	return EOK;
 }
 
-s32 vfs_read(const char *path, void *buf, u32 offset, u32 count)
+res vfs_read(const char *path, void *buf, u32 offset, u32 count)
 {
 	/* printf("%s READ: %s\n", proc_current() ? proc_current()->name : "Unknown", path); */
 	if (!path || !memory_valid(path))
@@ -147,16 +147,16 @@ s32 vfs_read(const char *path, void *buf, u32 offset, u32 count)
 	if (len > 1)
 		path += len;
 
-	if (!m->dev->vfs->perm(path, VFS_READ, m->dev) && !proc_super())
+	if (m->dev->vfs->perm(path, VFS_READ, m->dev) != EOK && !proc_super())
 		return -EACCES;
 
 	if (!count)
-		return 0;
+		return EOK;
 
 	return m->dev->vfs->read(path, buf, offset, count, m->dev);
 }
 
-s32 vfs_write(const char *path, void *buf, u32 offset, u32 count)
+res vfs_write(const char *path, void *buf, u32 offset, u32 count)
 {
 	/* printf("%s WRITE: %s\n", proc_current() ? proc_current()->name : "Unknown", path); */
 	if (!path || !memory_valid(path))
@@ -176,16 +176,16 @@ s32 vfs_write(const char *path, void *buf, u32 offset, u32 count)
 	if (len > 1)
 		path += len;
 
-	if (!m->dev->vfs->perm(path, VFS_WRITE, m->dev) && !proc_super())
+	if (m->dev->vfs->perm(path, VFS_WRITE, m->dev) != EOK && !proc_super())
 		return -EACCES;
 
 	if (!count)
-		return 0;
+		return EOK;
 
 	return m->dev->vfs->write(path, buf, offset, count, m->dev);
 }
 
-s32 vfs_ioctl(const char *path, u32 request, void *arg1, void *arg2, void *arg3)
+res vfs_ioctl(const char *path, u32 request, void *arg1, void *arg2, void *arg3)
 {
 	if (!path || !memory_valid(path))
 		return -EFAULT;
@@ -201,13 +201,13 @@ s32 vfs_ioctl(const char *path, u32 request, void *arg1, void *arg2, void *arg3)
 	if (len > 1)
 		path += len;
 
-	if (!m->dev->vfs->perm(path, VFS_WRITE, m->dev) && !proc_super())
+	if (m->dev->vfs->perm(path, VFS_WRITE, m->dev) != EOK && !proc_super())
 		return -EACCES;
 
 	return m->dev->vfs->ioctl(path, request, arg1, arg2, arg3, m->dev);
 }
 
-s32 vfs_stat(const char *path, struct stat *buf)
+res vfs_stat(const char *path, struct stat *buf)
 {
 	if (!path || !memory_valid(path))
 		return -EFAULT;
@@ -226,13 +226,13 @@ s32 vfs_stat(const char *path, struct stat *buf)
 	if (len > 1)
 		path += len;
 
-	if (!m->dev->vfs->perm(path, VFS_READ, m->dev) && !proc_super())
+	if (m->dev->vfs->perm(path, VFS_READ, m->dev) != EOK && !proc_super())
 		return -EACCES;
 
 	return m->dev->vfs->stat(path, buf, m->dev);
 }
 
-s32 vfs_wait(const char *path, u32 func_ptr)
+res vfs_wait(const char *path, u32 func_ptr)
 {
 	if (!path || !func_ptr || !memory_valid(path))
 		return -EFAULT;
@@ -244,7 +244,7 @@ s32 vfs_wait(const char *path, u32 func_ptr)
 	// Default wait
 	if (!m->dev->vfs->wait) {
 		proc_wait_for(vfs_find_dev(path)->id, PROC_WAIT_DEV, func_ptr);
-		return 0;
+		return EOK;
 	}
 
 	u32 len = strlen(m->path);
@@ -254,13 +254,13 @@ s32 vfs_wait(const char *path, u32 func_ptr)
 	return m->dev->vfs->wait(path, func_ptr, m->dev);
 }
 
-s32 vfs_poll(const char **files)
+res vfs_poll(const char **files)
 {
 	if (!files || !memory_valid(files))
 		return -EFAULT;
 
 	for (const char **p = files; *p && memory_valid(*p) && **p; p++) {
-		s32 ready = vfs_ready(*p);
+		res ready = vfs_ready(*p);
 		if (ready == 1)
 			return p - files;
 		else if (ready < 0)
@@ -273,7 +273,7 @@ s32 vfs_poll(const char **files)
 	return PROC_MAX_WAIT_IDS + 1;
 }
 
-s32 vfs_ready(const char *path)
+res vfs_ready(const char *path)
 {
 	if (!path || !memory_valid(path))
 		return -EFAULT;
@@ -331,7 +331,7 @@ struct device *device_get_by_name(const char *name)
 	return NULL;
 }
 
-static s32 devfs_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev)
+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)
@@ -341,7 +341,7 @@ static s32 devfs_read(const char *path, void *buf, u32 offset, u32 count, struct
 	return target->read(buf, offset, count, dev);
 }
 
-static s32 devfs_ioctl(const char *path, u32 request, void *arg1, void *arg2, void *arg3,
+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);
@@ -352,15 +352,15 @@ static s32 devfs_ioctl(const char *path, u32 request, void *arg1, void *arg2, vo
 	return target->ioctl(request, arg1, arg2, arg3, dev);
 }
 
-static s32 devfs_perm(const char *path, enum vfs_perm perm, struct device *dev)
+static res devfs_perm(const char *path, enum vfs_perm perm, struct device *dev)
 {
 	UNUSED(path);
 	UNUSED(perm);
 	UNUSED(dev);
-	return 1;
+	return EOK;
 }
 
-static s32 devfs_ready(const char *path, struct device *dev)
+static res devfs_ready(const char *path, struct device *dev)
 {
 	UNUSED(dev);
 
@@ -477,13 +477,13 @@ static u32 read_indirect(u32 indirect, u32 block_num, struct device *dev)
 	return ind;
 }
 
-static s32 read_inode(struct ext2_inode *in, void *buf, u32 offset, u32 count, struct device *dev)
+static res read_inode(struct ext2_inode *in, void *buf, u32 offset, u32 count, struct device *dev)
 {
 	if (!in || !buf)
 		return -EINVAL;
 
 	if (in->size == 0)
-		return 0;
+		return EOK;
 
 	u32 num_blocks = in->blocks / (BLOCK_SIZE / SECTOR_SIZE) + 1;
 
@@ -619,7 +619,7 @@ static struct ext2_inode *find_inode_by_path(const char *path, struct ext2_inode
 	return get_inode(inode, in_buf, dev);
 }
 
-s32 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 device *dev)
 {
 	struct ext2_inode in = { 0 };
 	if (find_inode_by_path(path, &in, dev) == &in)
@@ -628,7 +628,7 @@ s32 ext2_read(const char *path, void *buf, u32 offset, u32 count, struct device
 		return -ENOENT;
 }
 
-s32 ext2_stat(const char *path, struct stat *buf, struct device *dev)
+res ext2_stat(const char *path, struct stat *buf, struct device *dev)
 {
 	struct ext2_inode in = { 0 };
 	if (find_inode_by_path(path, &in, dev) != &in)
@@ -640,10 +640,10 @@ s32 ext2_stat(const char *path, struct stat *buf, struct device *dev)
 	buf->dev_id = dev->id;
 	buf->size = in.size;
 
-	return 0;
+	return EOK;
 }
 
-s32 ext2_perm(const char *path, enum vfs_perm perm, struct device *dev)
+res ext2_perm(const char *path, enum vfs_perm perm, struct device *dev)
 {
 	struct ext2_inode in = { 0 };
 	if (find_inode_by_path(path, &in, dev) != &in)
@@ -651,17 +651,17 @@ s32 ext2_perm(const char *path, enum vfs_perm perm, struct device *dev)
 
 	switch (perm) {
 	case VFS_EXEC:
-		return (in.mode & EXT2_PERM_UEXEC) != 0;
+		return (in.mode & EXT2_PERM_UEXEC) != 0 ? EOK : -EACCES;
 	case VFS_WRITE:
-		return (in.mode & EXT2_PERM_UWRITE) != 0;
+		return (in.mode & EXT2_PERM_UWRITE) != 0 ? EOK : -EACCES;
 	case VFS_READ:
-		return (in.mode & EXT2_PERM_UREAD) != 0;
+		return (in.mode & EXT2_PERM_UREAD) != 0 ? EOK : -EACCES;
 	default:
-		return 0;
+		return -EINVAL;
 	}
 }
 
-s32 ext2_ready(const char *path, struct device *dev)
+res ext2_ready(const char *path, struct device *dev)
 {
 	UNUSED(path);
 	UNUSED(dev);
diff --git a/kernel/features/load.c b/kernel/features/load.c
index 1795efb..b8640c1 100644
--- a/kernel/features/load.c
+++ b/kernel/features/load.c
@@ -9,21 +9,21 @@
 
 #define PROC_STACK_SIZE 0x4000
 
-s32 elf_load(const char *path, struct proc *proc)
+res elf_load(const char *path, struct proc *proc)
 {
 	if (!path || !memory_valid(path) || !proc)
 		return -EFAULT;
 
 	struct stat s = { 0 };
 	memory_bypass_enable();
-	s32 stat = vfs_stat(path, &s);
+	res stat = vfs_stat(path, &s);
 	memory_bypass_disable();
 	if (stat != 0)
 		return stat;
 
 	struct elf_header header = { 0 };
 	memory_bypass_enable();
-	s32 read = vfs_read(path, &header, 0, sizeof(header));
+	res read = vfs_read(path, &header, 0, sizeof(header));
 	memory_bypass_disable();
 	if (read < 0)
 		return read;
diff --git a/kernel/features/mm.c b/kernel/features/mm.c
index a8e7e22..7e0d62a 100644
--- a/kernel/features/mm.c
+++ b/kernel/features/mm.c
@@ -4,6 +4,7 @@
 #include <assert.h>
 #include <cpu.h>
 #include <def.h>
+#include <errno.h>
 #include <fb.h>
 #include <mem.h>
 #include <mm.h>
@@ -383,8 +384,13 @@ struct shared_memory {
 	struct memory_range prange;
 };
 static struct shared_memory shmem[SHARED_MEMORY_MAX] = { 0 };
-u32 memory_shalloc(struct page_dir *dir, u32 size, u32 flags)
+res memory_shalloc(struct page_dir *dir, u32 size, u32 *id, u32 flags)
 {
+	if (!id || !memory_valid(id))
+		return -EFAULT;
+
+	*id = 0;
+
 	u32 slot = SHARED_MEMORY_MAX + 1;
 
 	for (u32 i = 0; i < SHARED_MEMORY_MAX; i++) {
@@ -395,20 +401,22 @@ u32 memory_shalloc(struct page_dir *dir, u32 size, u32 flags)
 	}
 
 	if (slot >= SHARED_MEMORY_MAX)
-		return 0;
+		return -ENOMEM;
 
 	void *addr = memory_alloc(dir, size, flags);
 	if (!addr)
-		return 0;
+		return -ENOMEM;
 
 	// TODO: Verify that shid isn't used already
 	// TODO: Check for colliding prange
-	u32 shid = rand() + 1;
+	u32 shid = rdseed() + 1;
 	shmem[slot].id = shid;
 	shmem[slot].used = 1;
 	shmem[slot].prange = memory_range(virtual_to_physical(dir, (u32)addr), size);
 
-	return shid;
+	*id = shid;
+
+	return EOK;
 }
 
 static struct shared_memory memory_shresolve_range(struct memory_range prange)
@@ -423,7 +431,7 @@ static struct shared_memory memory_shresolve_range(struct memory_range prange)
 			return shmem[i];
 	}
 
-	return (struct shared_memory){ 0, 0, 0, memory_range(0, 0) };
+	return (struct shared_memory){ 0 };
 }
 
 static struct shared_memory memory_shresolve_id(u32 shid)
@@ -436,19 +444,29 @@ static struct shared_memory memory_shresolve_id(u32 shid)
 			return shmem[i];
 	}
 
-	return shmem[0];
+	return (struct shared_memory){ 0 };
 }
 
-void *memory_shaccess(struct page_dir *dir, u32 shid)
+res memory_shaccess(struct page_dir *dir, u32 shid, u32 *addr, u32 *size)
 {
+	if (!addr || !memory_valid(addr) || !size || !memory_valid(size))
+		return -EFAULT;
+
+	*addr = 0;
+	*size = 0;
+
 	struct shared_memory sh = memory_shresolve_id(shid);
 	struct memory_range prange = sh.prange;
 	if (sh.used == 0 || prange.base == 0 || prange.size == 0)
-		return NULL;
+		return -ENOENT;
 
 	sh.refs++;
 
-	return (void *)virtual_alloc(dir, prange, MEMORY_CLEAR | MEMORY_USER).base;
+	struct memory_range shrange = virtual_alloc(dir, prange, MEMORY_CLEAR | MEMORY_USER);
+	*addr = shrange.base;
+	*size = shrange.size;
+
+	return EOK;
 }
 
 // TODO: Free by address instead of vrange (combine with shmem map?)
diff --git a/kernel/features/proc.c b/kernel/features/proc.c
index ff4638b..88c477f 100644
--- a/kernel/features/proc.c
+++ b/kernel/features/proc.c
@@ -125,15 +125,15 @@ void proc_clear_quantum(void)
 	quantum = 0;
 }
 
-void proc_exit(struct proc *proc, int status)
+void proc_exit(struct proc *proc, s32 status)
 {
 	assert(proc);
 
-	int res = 0;
+	u8 found = 0;
 	struct node *iterator = proc_list->head;
 	while (iterator) {
 		if (iterator->data == proc) {
-			res = 1;
+			found = 1;
 			list_remove(proc_list, iterator);
 			break;
 		}
@@ -143,7 +143,7 @@ void proc_exit(struct proc *proc, int status)
 	if (memcmp(proc, current->data, sizeof(*proc)) == 0)
 		current = NULL;
 
-	if (res)
+	if (found)
 		printf("Process %s (%d) exited with status %d (%s)\n",
 		       proc->name[0] ? proc->name : "UNKNOWN", proc->pid, status,
 		       status == 0 ? "success" : "error");
@@ -317,14 +317,14 @@ struct procfs_message {
 	u32 size;
 };
 
-static s32 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 device *dev)
 {
 	u32 pid = 0;
 	procfs_parse_path(&path, &pid);
 	if (pid) {
 		struct proc *p = proc_from_pid(pid);
 		if (!p || path[0] != '/')
-			return -1;
+			return -ENOENT;
 
 		path++;
 		if (!memcmp(path, "msg", 4)) {
@@ -340,7 +340,7 @@ static s32 procfs_write(const char *path, void *buf, u32 offset, u32 count, stru
 			path += 3;
 			enum stream_defaults id = procfs_stream(path);
 			if (id == STREAM_UNKNOWN)
-				return -1;
+				return -ENOENT;
 
 			// Put proc log/err messages to serial console for debugging
 			if (id == STREAM_LOG || id == STREAM_ERR)
@@ -356,10 +356,10 @@ static s32 procfs_write(const char *path, void *buf, u32 offset, u32 count, stru
 	}
 
 	printf("ERR: %s - off: %d, cnt: %d, buf: %x, dev %x\n", path, offset, count, buf, dev);
-	return -1;
+	return -ENOENT;
 }
 
-static s32 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 device *dev)
 {
 	(void)dev;
 	u32 pid = 0;
@@ -409,7 +409,7 @@ static s32 procfs_read(const char *path, void *buf, u32 offset, u32 count, struc
 	return -ENOENT;
 }
 
-static s32 procfs_wait(const char *path, u32 func_ptr, struct device *dev)
+static res procfs_wait(const char *path, u32 func_ptr, struct device *dev)
 {
 	u32 pid = 0;
 	procfs_parse_path(&path, &pid);
@@ -422,28 +422,28 @@ static s32 procfs_wait(const char *path, u32 func_ptr, struct device *dev)
 		path++;
 		if (!memcmp(path, "msg", 4)) {
 			proc_wait_for(pid, PROC_WAIT_MSG, func_ptr);
-			return 0;
+			return EOK;
 		} else {
 			proc_wait_for(dev->id, PROC_WAIT_DEV, func_ptr);
-			return 0;
+			return EOK;
 		}
 	}
 
 	return -ENOENT;
 }
 
-static s32 procfs_perm(const char *path, enum vfs_perm perm, struct device *dev)
+static res procfs_perm(const char *path, enum vfs_perm perm, struct device *dev)
 {
 	(void)path;
 	(void)dev;
 
 	if (perm == VFS_EXEC)
-		return 0;
+		return -EACCES;
 	else
-		return 1;
+		return EOK;
 }
 
-static s32 procfs_ready(const char *path, struct device *dev)
+static res procfs_ready(const char *path, struct device *dev)
 {
 	(void)dev;
 
diff --git a/kernel/features/syscall.c b/kernel/features/syscall.c
index c59c423..48a5850 100644
--- a/kernel/features/syscall.c
+++ b/kernel/features/syscall.c
@@ -18,7 +18,7 @@
 static void syscall_handler(struct regs *r)
 {
 	enum sys num = r->eax;
-	r->eax = 0;
+	r->eax = EOK;
 
 	/* printf("[SYSCALL] %d from %s\n", num, proc_current()->name); */
 
@@ -34,12 +34,13 @@ static void syscall_handler(struct regs *r)
 		break;
 	}
 	case SYS_SHALLOC: {
-		r->eax = (u32)memory_shalloc(proc_current()->page_dir, PAGE_ALIGN_UP(r->ebx),
-					     MEMORY_CLEAR | MEMORY_USER);
+		r->eax = memory_shalloc(proc_current()->page_dir, PAGE_ALIGN_UP(r->ebx),
+					(u32 *)r->ecx, MEMORY_CLEAR | MEMORY_USER);
 		break;
 	}
 	case SYS_SHACCESS: {
-		r->eax = (u32)memory_shaccess(proc_current()->page_dir, r->ebx);
+		r->eax = memory_shaccess(proc_current()->page_dir, r->ebx, (u32 *)r->ecx,
+					 (u32 *)r->edx);
 		break;
 	}
 	case SYS_FREE: {
@@ -47,14 +48,14 @@ static void syscall_handler(struct regs *r)
 		break;
 	}
 	case SYS_STAT: {
-		r->eax = (u32)vfs_stat((char *)r->ebx, (struct stat *)r->ecx);
+		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 {
-			s32 wait = vfs_wait((char *)r->ebx, (u32)vfs_read);
+			res wait = vfs_wait((char *)r->ebx, (u32)vfs_read);
 			if (wait != 0)
 				r->eax = wait;
 			else
@@ -63,16 +64,16 @@ static void syscall_handler(struct regs *r)
 		break;
 	}
 	case SYS_WRITE: {
-		r->eax = (u32)vfs_write((char *)r->ebx, (void *)r->ecx, r->edx, r->esi);
+		r->eax = vfs_write((char *)r->ebx, (void *)r->ecx, r->edx, r->esi);
 		break;
 	}
 	case SYS_IOCTL: {
-		r->eax = (u32)vfs_ioctl((char *)r->ebx, r->ecx, (void *)r->edx, (void *)r->esi,
-					(void *)r->edi);
+		r->eax = vfs_ioctl((char *)r->ebx, r->ecx, (void *)r->edx, (void *)r->esi,
+				   (void *)r->edi);
 		break;
 	}
 	case SYS_POLL: {
-		s32 ret = vfs_poll((const char **)r->ebx);
+		res ret = vfs_poll((const char **)r->ebx);
 		r->eax = ret;
 		if (ret == PROC_MAX_WAIT_IDS + 1)
 			proc_yield(r);
@@ -92,7 +93,7 @@ static void syscall_handler(struct regs *r)
 		break;
 	}
 	case SYS_EXIT: {
-		proc_exit(proc_current(), (int)r->ebx);
+		proc_exit(proc_current(), (s32)r->ebx);
 		proc_yield(r);
 		break;
 	}
diff --git a/kernel/inc/fs.h b/kernel/inc/fs.h
index fd5c470..4b333ac 100644
--- a/kernel/inc/fs.h
+++ b/kernel/inc/fs.h
@@ -4,6 +4,7 @@
 #define FS_H
 
 #include <def.h>
+#include <errno.h>
 #include <sys.h>
 
 /**
@@ -18,10 +19,10 @@ struct device {
 	enum dev_type type;
 	struct vfs *vfs;
 	void *data;
-	s32 (*read)(void *buf, u32 offset, u32 count, struct device *dev);
-	s32 (*write)(void *buf, u32 offset, u32 count, struct device *dev);
-	s32 (*ioctl)(u32 request, void *arg1, void *arg2, void *arg3, struct device *dev);
-	s32 (*ready)(void);
+	res (*read)(void *buf, u32 offset, u32 count, struct device *dev);
+	res (*write)(void *buf, u32 offset, u32 count, struct device *dev);
+	res (*ioctl)(u32 request, void *arg1, void *arg2, void *arg3, struct device *dev);
+	res (*ready)(void);
 };
 
 void device_install(void);
@@ -39,14 +40,14 @@ struct vfs {
 	enum vfs_type type;
 	int flags;
 	void *data;
-	s32 (*read)(const char *path, void *buf, u32 offset, u32 count, struct device *dev);
-	s32 (*write)(const char *path, void *buf, u32 offset, u32 count, struct device *dev);
-	s32 (*ioctl)(const char *path, u32 request, void *arg1, void *arg2, void *arg3,
+	res (*read)(const char *path, void *buf, u32 offset, u32 count, struct device *dev);
+	res (*write)(const char *path, void *buf, u32 offset, u32 count, struct device *dev);
+	res (*ioctl)(const char *path, u32 request, void *arg1, void *arg2, void *arg3,
 		     struct device *dev);
-	s32 (*stat)(const char *path, struct stat *buf, struct device *dev);
-	s32 (*wait)(const char *path, u32 func_ptr, struct device *dev);
-	s32 (*ready)(const char *path, struct device *dev);
-	s32 (*perm)(const char *path, enum vfs_perm perm, struct device *dev);
+	res (*stat)(const char *path, struct stat *buf, struct device *dev);
+	res (*wait)(const char *path, u32 func_ptr, struct device *dev);
+	res (*ready)(const char *path, struct device *dev);
+	res (*perm)(const char *path, enum vfs_perm perm, struct device *dev);
 };
 
 struct mount_info {
@@ -57,17 +58,17 @@ struct mount_info {
 void vfs_install(void);
 
 u8 vfs_mounted(struct device *dev, const char *path);
-s32 vfs_mount(struct device *dev, const char *path);
+res vfs_mount(struct device *dev, const char *path);
 
 struct device *vfs_find_dev(const char *path);
 
-s32 vfs_read(const char *path, void *buf, u32 offset, u32 count);
-s32 vfs_write(const char *path, void *buf, u32 offset, u32 count);
-s32 vfs_ioctl(const char *path, u32 request, void *arg1, void *arg2, void *arg3);
-s32 vfs_stat(const char *path, struct stat *buf);
-s32 vfs_wait(const char *path, u32 func_ptr);
-s32 vfs_poll(const char **files);
-s32 vfs_ready(const char *path);
+res vfs_read(const char *path, void *buf, u32 offset, u32 count);
+res vfs_write(const char *path, void *buf, u32 offset, u32 count);
+res vfs_ioctl(const char *path, u32 request, void *arg1, void *arg2, void *arg3);
+res vfs_stat(const char *path, struct stat *buf);
+res vfs_wait(const char *path, u32 func_ptr);
+res vfs_poll(const char **files);
+res vfs_ready(const char *path);
 
 struct device *device_get_by_name(const char *name);
 struct device *device_get_by_id(u32 id);
@@ -174,9 +175,9 @@ struct ext2_file {
 	u32 curr_block_pos;
 };
 
-s32 ext2_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev);
-s32 ext2_stat(const char *path, struct stat *buf, struct device *dev);
-s32 ext2_perm(const char *path, enum vfs_perm perm, struct device *dev);
-s32 ext2_ready(const char *path, struct device *dev);
+res ext2_read(const char *path, void *buf, u32 offset, u32 count, struct device *dev);
+res ext2_stat(const char *path, struct stat *buf, struct device *dev);
+res ext2_perm(const char *path, enum vfs_perm perm, struct device *dev);
+res ext2_ready(const char *path, struct device *dev);
 
 #endif
diff --git a/kernel/inc/load.h b/kernel/inc/load.h
index 54ace4e..363a70f 100644
--- a/kernel/inc/load.h
+++ b/kernel/inc/load.h
@@ -105,6 +105,6 @@ struct elf_program {
 	u32 align;
 };
 
-s32 elf_load(const char *path, struct proc *proc);
+res elf_load(const char *path, struct proc *proc);
 
 #endif
diff --git a/kernel/inc/mm.h b/kernel/inc/mm.h
index 5e30be6..5e49aa7 100644
--- a/kernel/inc/mm.h
+++ b/kernel/inc/mm.h
@@ -5,6 +5,7 @@
 
 #include <boot.h>
 #include <def.h>
+#include <errno.h>
 #include <interrupts.h>
 
 struct memory_range {
@@ -104,8 +105,6 @@ struct memory_range memory_range_around(u32 base, u32 size);
 
 void *memory_alloc(struct page_dir *dir, u32 size, u32 flags);
 void *memory_alloc_identity(struct page_dir *dir, u32 flags);
-u32 memory_shalloc(struct page_dir *dir, u32 size, u32 flags);
-void *memory_shaccess(struct page_dir *dir, u32 shid);
 void memory_free(struct page_dir *dir, struct memory_range vrange);
 void memory_map_identity(struct page_dir *dir, struct memory_range prange, u32 flags);
 void memory_switch_dir(struct page_dir *dir);
@@ -117,6 +116,10 @@ void memory_bypass_disable(void);
 u8 memory_is_user(u32 addr);
 u8 memory_valid(const void *addr);
 
+// User interface
+res memory_shalloc(struct page_dir *dir, u32 size, u32 *id, u32 flags);
+res memory_shaccess(struct page_dir *dir, u32 shid, u32 *addr, u32 *size);
+
 void memory_install(struct mem_info *mem_info, struct vid_info *vid_info);
 
 #endif
diff --git a/kernel/inc/proc.h b/kernel/inc/proc.h
index a44fd68..c946116 100644
--- a/kernel/inc/proc.h
+++ b/kernel/inc/proc.h
@@ -64,7 +64,7 @@ void proc_print(void);
 struct proc *proc_current(void);
 u8 proc_super(void);
 struct proc *proc_from_pid(u32 pid);
-void proc_exit(struct proc *proc, int status);
+void proc_exit(struct proc *proc, s32 status);
 void proc_yield(struct regs *r);
 void proc_clear_quantum(void);
 void proc_enable_waiting(u32 id, enum proc_wait_type type);