Index: kernel/generic/src/cap/cap.c
===================================================================
--- kernel/generic/src/cap/cap.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/cap/cap.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -124,5 +124,5 @@
  * @param task  Task for which to allocate the info structure.
  */
-int caps_task_alloc(task_t *task)
+errno_t caps_task_alloc(task_t *task)
 {
 	task->cap_info = (cap_info_t *) malloc(sizeof(cap_info_t),
@@ -261,5 +261,5 @@
  * @return An error code in case of error.
  */
-int cap_alloc(task_t *task, cap_handle_t *handle)
+errno_t cap_alloc(task_t *task, cap_handle_t *handle)
 {
 	cap_t *cap = NULL;
Index: kernel/generic/src/console/cmd.c
===================================================================
--- kernel/generic/src/console/cmd.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/console/cmd.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -972,5 +972,5 @@
 	sysarg_t (*fnc)(void);
 	fncptr_t fptr;
-	int rc;
+	errno_t rc;
 
 	symbol = (char *) argv->buffer;
@@ -1033,5 +1033,5 @@
 	sysarg_t arg1 = argv[1].intval;
 	fncptr_t fptr;
-	int rc;
+	errno_t rc;
 
 	symbol = (char *) argv->buffer;
@@ -1070,5 +1070,5 @@
 	sysarg_t arg2 = argv[2].intval;
 	fncptr_t fptr;
-	int rc;
+	errno_t rc;
 
 	symbol = (char *) argv->buffer;
@@ -1107,5 +1107,5 @@
 	sysarg_t arg3 = argv[3].intval;
 	fncptr_t fptr;
-	int rc;
+	errno_t rc;
 	
 	symbol = (char *) argv->buffer;
@@ -1182,5 +1182,5 @@
 	uint32_t arg1 = argv[1].intval;
 	bool pointer = false;
-	int rc;
+	errno_t rc;
 	
 	if (((char *) argv->buffer)[0] == '*') {
Index: kernel/generic/src/console/console.c
===================================================================
--- kernel/generic/src/console/console.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/console/console.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -391,8 +391,8 @@
  *
  */
-sysarg_t sys_kio(int cmd, const void *buf, size_t size)
+sys_errno_t sys_kio(int cmd, const void *buf, size_t size)
 {
 	char *data;
-	int rc;
+	errno_t rc;
 
 	switch (cmd) {
@@ -408,15 +408,15 @@
 
 	if (size > PAGE_SIZE)
-		return (sysarg_t) ELIMIT;
+		return (sys_errno_t) ELIMIT;
 	
 	if (size > 0) {
 		data = (char *) malloc(size + 1, 0);
 		if (!data)
-			return (sysarg_t) ENOMEM;
+			return (sys_errno_t) ENOMEM;
 		
 		rc = copy_from_uspace(data, buf, size);
 		if (rc) {
 			free(data);
-			return (sysarg_t) rc;
+			return (sys_errno_t) rc;
 		}
 		data[size] = 0;
Index: kernel/generic/src/console/kconsole.c
===================================================================
--- kernel/generic/src/console/kconsole.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/console/kconsole.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -563,17 +563,17 @@
 		
 		uintptr_t symaddr;
-		int rc = symtab_addr_lookup(symname, &symaddr);
-		switch (rc) {
-		case ENOENT:
+		errno_t rc = symtab_addr_lookup(symname, &symaddr);
+		switch ((case_errno_t) rc) {
+		case (case_errno_t) ENOENT:
 			printf("Symbol %s not found.\n", symname);
 			return false;
-		case EOVERFLOW:
+		case (case_errno_t) EOVERFLOW:
 			printf("Duplicate symbol %s.\n", symname);
 			symtab_print_search(symname);
 			return false;
-		case ENOTSUP:
+		case (case_errno_t) ENOTSUP:
 			printf("No symbol information available.\n");
 			return false;
-		case EOK:
+		case (case_errno_t) EOK:
 			if (isaddr)
 				*result = (sysarg_t) symaddr;
@@ -591,15 +591,15 @@
 		uint64_t value;
 		char *end;
-		int rc = str_uint64_t(text, &end, 0, false, &value);
+		errno_t rc = str_uint64_t(text, &end, 0, false, &value);
 		if (end != text + len)
 			rc = EINVAL;
-		switch (rc) {
-		case EINVAL:
+		switch ((case_errno_t) rc) {
+		case (case_errno_t) EINVAL:
 			printf("Invalid number '%s'.\n", text);
 			return false;
-		case EOVERFLOW:
+		case (case_errno_t) EOVERFLOW:
 			printf("Integer overflow in '%s'.\n", text);
 			return false;
-		case EOK:
+		case (case_errno_t) EOK:
 			*result = (sysarg_t) value;
 			if (isptr)
Index: kernel/generic/src/ddi/ddi.c
===================================================================
--- kernel/generic/src/ddi/ddi.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ddi/ddi.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -104,5 +104,5 @@
  *
  */
-NO_TRACE static int physmem_map(uintptr_t phys, size_t pages,
+NO_TRACE static errno_t physmem_map(uintptr_t phys, size_t pages,
     unsigned int flags, uintptr_t *virt, uintptr_t bound)
 {
@@ -210,5 +210,5 @@
 }
 
-NO_TRACE static int physmem_unmap(uintptr_t virt)
+NO_TRACE static errno_t physmem_unmap(uintptr_t virt)
 {
 	assert(TASK);
@@ -228,9 +228,9 @@
  *
  */
-sysarg_t sys_physmem_map(uintptr_t phys, size_t pages, unsigned int flags,
+sys_errno_t sys_physmem_map(uintptr_t phys, size_t pages, unsigned int flags,
     void *virt_ptr, uintptr_t bound)
 {
 	uintptr_t virt;
-	int rc = copy_from_uspace(&virt, virt_ptr, sizeof(virt));
+	errno_t rc = copy_from_uspace(&virt, virt_ptr, sizeof(virt));
 	if (rc != EOK)
 		return rc;
@@ -250,5 +250,5 @@
 }
 
-sysarg_t sys_physmem_unmap(uintptr_t virt)
+sys_errno_t sys_physmem_unmap(uintptr_t virt)
 {
 	return physmem_unmap(virt);
@@ -265,5 +265,5 @@
  *
  */
-NO_TRACE static int iospace_enable(task_id_t id, uintptr_t ioaddr, size_t size)
+NO_TRACE static errno_t iospace_enable(task_id_t id, uintptr_t ioaddr, size_t size)
 {
 	/*
@@ -290,5 +290,5 @@
 	/* Lock the task and release the lock protecting tasks_btree. */
 	irq_spinlock_exchange(&tasks_lock, &task->lock);
-	int rc = ddi_iospace_enable_arch(task, ioaddr, size);
+	errno_t rc = ddi_iospace_enable_arch(task, ioaddr, size);
 	irq_spinlock_unlock(&task->lock, true);
 
@@ -306,5 +306,5 @@
  *
  */
-NO_TRACE static int iospace_disable(task_id_t id, uintptr_t ioaddr, size_t size)
+NO_TRACE static errno_t iospace_disable(task_id_t id, uintptr_t ioaddr, size_t size)
 {
 	/*
@@ -331,5 +331,5 @@
 	/* Lock the task and release the lock protecting tasks_btree. */
 	irq_spinlock_exchange(&tasks_lock, &task->lock);
-	int rc = ddi_iospace_disable_arch(task, ioaddr, size);
+	errno_t rc = ddi_iospace_disable_arch(task, ioaddr, size);
 	irq_spinlock_unlock(&task->lock, true);
 	
@@ -344,27 +344,27 @@
  *
  */
-sysarg_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
+sys_errno_t sys_iospace_enable(ddi_ioarg_t *uspace_io_arg)
 {
 	ddi_ioarg_t arg;
-	int rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
+	errno_t rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
 	if (rc != 0)
-		return (sysarg_t) rc;
-	
-	return (sysarg_t) iospace_enable((task_id_t) arg.task_id,
+		return (sys_errno_t) rc;
+	
+	return (sys_errno_t) iospace_enable((task_id_t) arg.task_id,
 	    (uintptr_t) arg.ioaddr, (size_t) arg.size);
 }
 
-sysarg_t sys_iospace_disable(ddi_ioarg_t *uspace_io_arg)
+sys_errno_t sys_iospace_disable(ddi_ioarg_t *uspace_io_arg)
 {
 	ddi_ioarg_t arg;
-	int rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
+	errno_t rc = copy_from_uspace(&arg, uspace_io_arg, sizeof(ddi_ioarg_t));
 	if (rc != 0)
-		return (sysarg_t) rc;
-
-	return (sysarg_t) iospace_disable((task_id_t) arg.task_id,
+		return (sys_errno_t) rc;
+
+	return (sys_errno_t) iospace_disable((task_id_t) arg.task_id,
 	    (uintptr_t) arg.ioaddr, (size_t) arg.size);
 }
 
-NO_TRACE static int dmamem_map(uintptr_t virt, size_t size, unsigned int map_flags,
+NO_TRACE static errno_t dmamem_map(uintptr_t virt, size_t size, unsigned int map_flags,
     unsigned int flags, uintptr_t *phys)
 {
@@ -375,5 +375,5 @@
 }
 
-NO_TRACE static int dmamem_map_anonymous(size_t size, uintptr_t constraint,
+NO_TRACE static errno_t dmamem_map_anonymous(size_t size, uintptr_t constraint,
     unsigned int map_flags, unsigned int flags, uintptr_t *phys,
     uintptr_t *virt, uintptr_t bound)
@@ -403,5 +403,5 @@
 }
 
-NO_TRACE static int dmamem_unmap(uintptr_t virt, size_t size)
+NO_TRACE static errno_t dmamem_unmap(uintptr_t virt, size_t size)
 {
 	// TODO: implement unlocking & unmap
@@ -409,10 +409,10 @@
 }
 
-NO_TRACE static int dmamem_unmap_anonymous(uintptr_t virt)
+NO_TRACE static errno_t dmamem_unmap_anonymous(uintptr_t virt)
 {
 	return as_area_destroy(TASK->as, virt);
 }
 
-sysarg_t sys_dmamem_map(size_t size, unsigned int map_flags, unsigned int flags,
+sys_errno_t sys_dmamem_map(size_t size, unsigned int map_flags, unsigned int flags,
     void *phys_ptr, void *virt_ptr, uintptr_t bound)
 {
@@ -423,5 +423,5 @@
 		
 		uintptr_t phys;
-		int rc = dmamem_map((uintptr_t) virt_ptr, size, map_flags,
+		errno_t rc = dmamem_map((uintptr_t) virt_ptr, size, map_flags,
 		    flags, &phys);
 		
@@ -440,5 +440,5 @@
 		
 		uintptr_t constraint;
-		int rc = copy_from_uspace(&constraint, phys_ptr,
+		errno_t rc = copy_from_uspace(&constraint, phys_ptr,
 		    sizeof(constraint));
 		if (rc != EOK)
@@ -472,5 +472,5 @@
 }
 
-sysarg_t sys_dmamem_unmap(uintptr_t virt, size_t size, unsigned int flags)
+sys_errno_t sys_dmamem_unmap(uintptr_t virt, size_t size, unsigned int flags)
 {
 	if ((flags & DMAMEM_FLAGS_ANONYMOUS) == 0)
Index: kernel/generic/src/debug/symtab.c
===================================================================
--- kernel/generic/src/debug/symtab.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/debug/symtab.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -54,5 +54,5 @@
  *
  */
-int symtab_name_lookup(uintptr_t addr, const char **name, uintptr_t *offset)
+errno_t symtab_name_lookup(uintptr_t addr, const char **name, uintptr_t *offset)
 {
 #ifdef CONFIG_SYMTAB
@@ -96,10 +96,10 @@
 {
 	const char *name;
-	int rc = symtab_name_lookup(addr, &name, NULL);
-	
-	switch (rc) {
-	case EOK:
+	errno_t rc = symtab_name_lookup(addr, &name, NULL);
+	
+	switch ((case_errno_t) rc) {
+	case (case_errno_t) EOK:
 		return name;
-	case ENOENT:
+	case (case_errno_t) ENOENT:
 		return "unknown";
 	default:
@@ -156,5 +156,5 @@
  *
  */
-int symtab_addr_lookup(const char *name, uintptr_t *addr)
+errno_t symtab_addr_lookup(const char *name, uintptr_t *addr)
 {
 #ifdef CONFIG_SYMTAB
Index: kernel/generic/src/ipc/event.c
===================================================================
--- kernel/generic/src/ipc/event.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/event.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -138,8 +138,8 @@
 }
 
-static int event_enqueue(event_t *event, bool mask, sysarg_t a1, sysarg_t a2,
+static errno_t event_enqueue(event_t *event, bool mask, sysarg_t a1, sysarg_t a2,
     sysarg_t a3, sysarg_t a4, sysarg_t a5)
 {
-	int res;
+	errno_t res;
 
 	spinlock_lock(&event->lock);
@@ -206,5 +206,5 @@
  *
  */
-int event_notify(event_type_t evno, bool mask, sysarg_t a1, sysarg_t a2,
+errno_t event_notify(event_type_t evno, bool mask, sysarg_t a1, sysarg_t a2,
     sysarg_t a3, sysarg_t a4, sysarg_t a5)
 {
@@ -234,5 +234,5 @@
  *
  */
-int event_task_notify(task_t *task, event_task_type_t evno, bool mask,
+errno_t event_task_notify(task_t *task, event_task_type_t evno, bool mask,
     sysarg_t a1, sysarg_t a2, sysarg_t a3, sysarg_t a4, sysarg_t a5)
 {
@@ -255,8 +255,8 @@
  *
  */
-static int event_subscribe(event_t *event, sysarg_t imethod,
+static errno_t event_subscribe(event_t *event, sysarg_t imethod,
     answerbox_t *answerbox)
 {
-	int res;
+	errno_t res;
 	
 	spinlock_lock(&event->lock);
@@ -286,7 +286,7 @@
  *
  */
-static int event_unsubscribe(event_t *event, answerbox_t *answerbox)
-{
-	int res;
+static errno_t event_unsubscribe(event_t *event, answerbox_t *answerbox)
+{
+	errno_t res;
 	
 	spinlock_lock(&event->lock);
@@ -338,10 +338,10 @@
  *
  */
-sysarg_t sys_ipc_event_subscribe(sysarg_t evno, sysarg_t imethod)
+sys_errno_t sys_ipc_event_subscribe(sysarg_t evno, sysarg_t imethod)
 {
 	if (evno >= EVENT_TASK_END)
 		return ELIMIT;
 	
-	return (sysarg_t) event_subscribe(evno2event(evno, TASK),
+	return (sys_errno_t) event_subscribe(evno2event(evno, TASK),
 	    (sysarg_t) imethod, &TASK->answerbox);
 }
@@ -357,10 +357,10 @@
  *
  */
-sysarg_t sys_ipc_event_unsubscribe(sysarg_t evno)
+sys_errno_t sys_ipc_event_unsubscribe(sysarg_t evno)
 {
 	if (evno >= EVENT_TASK_END)
 		return ELIMIT;
 	
-	return (sysarg_t) event_unsubscribe(evno2event(evno, TASK),
+	return (sys_errno_t) event_unsubscribe(evno2event(evno, TASK),
 	    &TASK->answerbox);
 }
@@ -379,5 +379,5 @@
  *
  */
-sysarg_t sys_ipc_event_unmask(sysarg_t evno)
+sys_errno_t sys_ipc_event_unmask(sysarg_t evno)
 {
 	if (evno >= EVENT_TASK_END)
Index: kernel/generic/src/ipc/ipc.c
===================================================================
--- kernel/generic/src/ipc/ipc.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/ipc.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -208,5 +208,5 @@
  *
  */
-int ipc_call_sync(phone_t *phone, call_t *request)
+errno_t ipc_call_sync(phone_t *phone, call_t *request)
 {
 	answerbox_t *mybox = slab_alloc(answerbox_cache, 0);
@@ -216,5 +216,5 @@
 	request->callerbox = mybox;
 	
-	int rc = ipc_call(phone, request);
+	errno_t rc = ipc_call(phone, request);
 	if (rc != EOK) {
 		slab_free(answerbox_cache, mybox);
@@ -371,5 +371,5 @@
  *
  */
-void ipc_backsend_err(phone_t *phone, call_t *call, int err)
+void ipc_backsend_err(phone_t *phone, call_t *call, errno_t err)
 {
 	_ipc_call_actions_internal(phone, call, false);
@@ -415,5 +415,5 @@
  *
  */
-int ipc_call(phone_t *phone, call_t *call)
+errno_t ipc_call(phone_t *phone, call_t *call)
 {
 	mutex_lock(&phone->lock);
@@ -448,5 +448,5 @@
  *
  */
-int ipc_phone_hangup(phone_t *phone)
+errno_t ipc_phone_hangup(phone_t *phone)
 {
 	mutex_lock(&phone->lock);
@@ -495,5 +495,5 @@
  *
  */
-int ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox,
+errno_t ipc_forward(call_t *call, phone_t *newphone, answerbox_t *oldbox,
     unsigned int mode)
 {
@@ -535,5 +535,5 @@
 	uint64_t answer_cnt = 0;
 	uint64_t call_cnt = 0;
-	int rc;
+	errno_t rc;
 	
 restart:
Index: kernel/generic/src/ipc/ipcrsc.c
===================================================================
--- kernel/generic/src/ipc/ipcrsc.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/ipcrsc.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -170,8 +170,8 @@
  * @return  An error code if a new capability cannot be allocated.
  */
-int phone_alloc(task_t *task, cap_handle_t *out_handle)
+errno_t phone_alloc(task_t *task, cap_handle_t *out_handle)
 {
 	cap_handle_t handle;
-	int rc = cap_alloc(task, &handle);
+	errno_t rc = cap_alloc(task, &handle);
 	if (rc == EOK) {
 		phone_t *phone = slab_alloc(phone_cache, FRAME_ATOMIC);
Index: kernel/generic/src/ipc/irq.c
===================================================================
--- kernel/generic/src/ipc/irq.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/irq.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -78,5 +78,5 @@
 }
 
-static int ranges_map_and_apply(irq_pio_range_t *ranges, size_t rangecount,
+static errno_t ranges_map_and_apply(irq_pio_range_t *ranges, size_t rangecount,
     irq_cmd_t *cmds, size_t cmdcount)
 {
@@ -164,5 +164,5 @@
  *
  */
-static int code_check(irq_cmd_t *cmds, size_t cmdcount)
+static errno_t code_check(irq_cmd_t *cmds, size_t cmdcount)
 {
 	for (size_t i = 0; i < cmdcount; i++) {
@@ -226,5 +226,5 @@
 	
 	irq_code_t *code = malloc(sizeof(*code), 0);
-	int rc = copy_from_uspace(code, ucode, sizeof(*code));
+	errno_t rc = copy_from_uspace(code, ucode, sizeof(*code));
 	if (rc != EOK)
 		goto error;
@@ -313,5 +313,5 @@
  *
  */
-int ipc_irq_subscribe(answerbox_t *box, inr_t inr, sysarg_t imethod,
+errno_t ipc_irq_subscribe(answerbox_t *box, inr_t inr, sysarg_t imethod,
     irq_code_t *ucode, cap_handle_t *uspace_handle)
 {
@@ -331,5 +331,5 @@
 	 */
 	cap_handle_t handle;
-	int rc = cap_alloc(TASK, &handle);
+	errno_t rc = cap_alloc(TASK, &handle);
 	if (rc != EOK)
 		return rc;
@@ -390,5 +390,5 @@
  *
  */
-int ipc_irq_unsubscribe(answerbox_t *box, int handle)
+errno_t ipc_irq_unsubscribe(answerbox_t *box, int handle)
 {
 	kobject_t *kobj = cap_unpublish(TASK, handle, KOBJECT_TYPE_IRQ);
Index: kernel/generic/src/ipc/kbox.c
===================================================================
--- kernel/generic/src/ipc/kbox.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/kbox.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -210,5 +210,5 @@
  *
  */
-int ipc_connect_kbox(task_id_t taskid, cap_handle_t *out_phone)
+errno_t ipc_connect_kbox(task_id_t taskid, cap_handle_t *out_phone)
 {
 	irq_spinlock_lock(&tasks_lock, true);
@@ -253,5 +253,5 @@
 	/* Allocate a new phone. */
 	cap_handle_t phone_handle;
-	int rc = phone_alloc(TASK, &phone_handle);
+	errno_t rc = phone_alloc(TASK, &phone_handle);
 	if (rc != EOK) {
 		mutex_unlock(&task->kb.cleanup_lock);
Index: kernel/generic/src/ipc/ops/conctmeto.c
===================================================================
--- kernel/generic/src/ipc/ops/conctmeto.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/ops/conctmeto.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -40,8 +40,8 @@
 #include <arch.h>
 
-static int request_preprocess(call_t *call, phone_t *phone)
+static errno_t request_preprocess(call_t *call, phone_t *phone)
 {
 	cap_handle_t phone_handle;
-	int rc = phone_alloc(TASK, &phone_handle);
+	errno_t rc = phone_alloc(TASK, &phone_handle);
 
 	/* Remember the phone capability or that an error occured. */
@@ -61,5 +61,5 @@
 }
 
-static int request_forget(call_t *call)
+static errno_t request_forget(call_t *call)
 {
 	cap_handle_t phone_handle = (cap_handle_t) call->priv;
@@ -77,5 +77,5 @@
 }
 
-static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
+static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
 	/* Hand over reference from ARG5 to phone */
@@ -93,5 +93,5 @@
 }
 
-static int answer_process(call_t *answer)
+static errno_t answer_process(call_t *answer)
 {
 	cap_handle_t phone_handle = (cap_handle_t) answer->priv;
Index: kernel/generic/src/ipc/ops/concttome.c
===================================================================
--- kernel/generic/src/ipc/ops/concttome.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/ops/concttome.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -43,10 +43,10 @@
 {
 	cap_handle_t phone_handle;
-	int rc = phone_alloc(TASK, &phone_handle);
+	errno_t rc = phone_alloc(TASK, &phone_handle);
 	IPC_SET_ARG5(call->data, (rc == EOK) ? phone_handle : -1);
 	return 0;
 }
 
-static int answer_cleanup(call_t *answer, ipc_data_t *olddata)
+static errno_t answer_cleanup(call_t *answer, ipc_data_t *olddata)
 {
 	cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
@@ -58,5 +58,5 @@
 }
 
-static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
+static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
 	cap_handle_t phone_handle = (cap_handle_t) IPC_GET_ARG5(*olddata);
Index: kernel/generic/src/ipc/ops/dataread.c
===================================================================
--- kernel/generic/src/ipc/ops/dataread.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/ops/dataread.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -41,5 +41,5 @@
 #include <config.h>
 
-static int request_preprocess(call_t *call, phone_t *phone)
+static errno_t request_preprocess(call_t *call, phone_t *phone)
 {
 	size_t size = IPC_GET_ARG2(call->data);
@@ -57,5 +57,5 @@
 }
 
-static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
+static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
 	assert(!answer->buffer);
@@ -76,5 +76,5 @@
 				
 			answer->buffer = malloc(size, 0);
-			int rc = copy_from_uspace(answer->buffer,
+			errno_t rc = copy_from_uspace(answer->buffer,
 			    (void *) src, size);
 			if (rc) {
@@ -95,10 +95,10 @@
 }
 
-static int answer_process(call_t *answer)
+static errno_t answer_process(call_t *answer)
 {
 	if (answer->buffer) {
 		uintptr_t dst = IPC_GET_ARG1(answer->data);
 		size_t size = IPC_GET_ARG2(answer->data);
-		int rc;
+		errno_t rc;
 
 		rc = copy_to_uspace((void *) dst, answer->buffer, size);
Index: kernel/generic/src/ipc/ops/datawrite.c
===================================================================
--- kernel/generic/src/ipc/ops/datawrite.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/ops/datawrite.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -41,5 +41,5 @@
 #include <config.h>
 
-static int request_preprocess(call_t *call, phone_t *phone)
+static errno_t request_preprocess(call_t *call, phone_t *phone)
 {
 	uintptr_t src = IPC_GET_ARG1(call->data);
@@ -57,5 +57,5 @@
 
 	call->buffer = (uint8_t *) malloc(size, 0);
-	int rc = copy_from_uspace(call->buffer, (void *) src, size);
+	errno_t rc = copy_from_uspace(call->buffer, (void *) src, size);
 	if (rc != 0) {
 		/*
@@ -69,5 +69,5 @@
 }
 
-static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
+static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
 	assert(answer->buffer);
@@ -80,5 +80,5 @@
 			
 		if (size <= max_size) {
-			int rc = copy_to_uspace((void *) dst,
+			errno_t rc = copy_to_uspace((void *) dst,
 			    answer->buffer, size);
 			if (rc)
Index: kernel/generic/src/ipc/ops/debug.c
===================================================================
--- kernel/generic/src/ipc/ops/debug.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/ops/debug.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -44,10 +44,10 @@
 }
 
-static int answer_process(call_t *answer)
+static errno_t answer_process(call_t *answer)
 {
 	if (answer->buffer) {
 		uintptr_t dst = IPC_GET_ARG1(answer->data);
 		size_t size = IPC_GET_ARG2(answer->data);
-		int rc;
+		errno_t rc;
 
 		rc = copy_to_uspace((void *) dst, answer->buffer, size);
Index: kernel/generic/src/ipc/ops/pagein.c
===================================================================
--- kernel/generic/src/ipc/ops/pagein.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/ops/pagein.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -44,5 +44,5 @@
 #include <arch.h>
 
-static int pagein_request_preprocess(call_t *call, phone_t *phone)
+static errno_t pagein_request_preprocess(call_t *call, phone_t *phone)
 {
 	/*
@@ -58,5 +58,5 @@
 }
 
-static int pagein_answer_preprocess(call_t *answer, ipc_data_t *olddata)
+static errno_t pagein_answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
 	/*
Index: kernel/generic/src/ipc/ops/sharein.c
===================================================================
--- kernel/generic/src/ipc/ops/sharein.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/ops/sharein.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -41,5 +41,5 @@
 #include <arch.h>
 
-static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
+static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
 	if (!IPC_GET_RETVAL(answer->data)) {
@@ -49,5 +49,5 @@
 			
 		uintptr_t dst_base = (uintptr_t) -1;
-		int rc = as_area_share(AS, IPC_GET_ARG1(answer->data),
+		errno_t rc = as_area_share(AS, IPC_GET_ARG1(answer->data),
 		    IPC_GET_ARG1(*olddata), as, IPC_GET_ARG2(answer->data),
 		    &dst_base, IPC_GET_ARG3(answer->data));
Index: kernel/generic/src/ipc/ops/shareout.c
===================================================================
--- kernel/generic/src/ipc/ops/shareout.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/ops/shareout.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -42,5 +42,5 @@
 #include <arch.h>
 
-static int request_preprocess(call_t *call, phone_t *phone)
+static errno_t request_preprocess(call_t *call, phone_t *phone)
 {
 	size_t size = as_area_get_size(IPC_GET_ARG1(call->data));
@@ -53,7 +53,7 @@
 }
 
-static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
+static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
-	int rc = EOK;
+	errno_t rc = EOK;
 
 	if (!IPC_GET_RETVAL(answer->data)) {
Index: kernel/generic/src/ipc/ops/stchngath.c
===================================================================
--- kernel/generic/src/ipc/ops/stchngath.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/ops/stchngath.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -41,5 +41,5 @@
 #include <macros.h>
 
-static int request_preprocess(call_t *call, phone_t *phone)
+static errno_t request_preprocess(call_t *call, phone_t *phone)
 {
 	task_t *other_task_s;
@@ -68,7 +68,7 @@
 }
 
-static int answer_preprocess(call_t *answer, ipc_data_t *olddata)
+static errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
 {
-	int rc = EOK;
+	errno_t rc = EOK;
 
 	if (!IPC_GET_RETVAL(answer->data)) {
Index: kernel/generic/src/ipc/sysipc.c
===================================================================
--- kernel/generic/src/ipc/sysipc.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/sysipc.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -158,7 +158,7 @@
  *
  */
-int answer_preprocess(call_t *answer, ipc_data_t *olddata)
-{
-	int rc = EOK;
+errno_t answer_preprocess(call_t *answer, ipc_data_t *olddata)
+{
+	errno_t rc = EOK;
 
 	spinlock_lock(&answer->forget_lock);
@@ -194,5 +194,5 @@
 	spinlock_unlock(&answer->forget_lock);
 
-	if ((int) IPC_GET_RETVAL(answer->data) == EHANGUP) {
+	if ((errno_t) IPC_GET_RETVAL(answer->data) == EHANGUP) {
 		phone_t *phone = answer->caller_phone;
 		mutex_lock(&phone->lock);
@@ -222,5 +222,5 @@
  *
  */
-static int request_preprocess(call_t *call, phone_t *phone)
+static errno_t request_preprocess(call_t *call, phone_t *phone)
 {
 	call->request_method = IPC_GET_IMETHOD(call->data);
@@ -239,5 +239,5 @@
 static void process_answer(call_t *call)
 {
-	if (((int) IPC_GET_RETVAL(call->data) == EHANGUP) &&
+	if (((errno_t) IPC_GET_RETVAL(call->data) == EHANGUP) &&
 	    (call->flags & IPC_CALL_FORWARDED))
 		IPC_SET_RETVAL(call->data, EFORWARD);
@@ -271,5 +271,5 @@
  *
  */
-int ipc_req_internal(cap_handle_t handle, ipc_data_t *data, sysarg_t priv)
+errno_t ipc_req_internal(cap_handle_t handle, ipc_data_t *data, sysarg_t priv)
 {
 	kobject_t *kobj = kobject_get(TASK, handle, KOBJECT_TYPE_PHONE);
@@ -281,5 +281,5 @@
 	memcpy(call->data.args, data->args, sizeof(data->args));
 	
-	int rc = request_preprocess(call, kobj->phone);
+	errno_t rc = request_preprocess(call, kobj->phone);
 	if (!rc) {
 #ifdef CONFIG_UDEBUG
@@ -362,5 +362,5 @@
  *
  */
-sysarg_t sys_ipc_call_async_fast(sysarg_t handle, sysarg_t imethod,
+sys_errno_t sys_ipc_call_async_fast(sysarg_t handle, sysarg_t imethod,
     sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t label)
 {
@@ -389,5 +389,5 @@
 	call->data.label = label;
 	
-	int res = request_preprocess(call, kobj->phone);
+	errno_t res = request_preprocess(call, kobj->phone);
 	
 	if (!res)
@@ -409,5 +409,5 @@
  *
  */
-sysarg_t sys_ipc_call_async_slow(sysarg_t handle, ipc_data_t *data,
+sys_errno_t sys_ipc_call_async_slow(sysarg_t handle, ipc_data_t *data,
     sysarg_t label)
 {
@@ -422,10 +422,10 @@
 
 	call_t *call = ipc_call_alloc(0);
-	int rc = copy_from_uspace(&call->data.args, &data->args,
+	errno_t rc = copy_from_uspace(&call->data.args, &data->args,
 	    sizeof(call->data.args));
 	if (rc != 0) {
 		kobject_put(call->kobject);
 		kobject_put(kobj);
-		return (sysarg_t) rc;
+		return (sys_errno_t) rc;
 	}
 
@@ -433,5 +433,5 @@
 	call->data.label = label;
 	
-	int res = request_preprocess(call, kobj->phone);
+	errno_t res = request_preprocess(call, kobj->phone);
 	
 	if (!res)
@@ -466,5 +466,5 @@
  *
  */
-static sysarg_t sys_ipc_forward_common(sysarg_t chandle, sysarg_t phandle,
+static sys_errno_t sys_ipc_forward_common(sysarg_t chandle, sysarg_t phandle,
     sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
     sysarg_t arg4, sysarg_t arg5, unsigned int mode, bool slow)
@@ -482,5 +482,5 @@
 	
 	bool after_forward = false;
-	int rc;
+	errno_t rc;
 
 	kobject_t *pkobj = kobject_get(TASK, phandle, KOBJECT_TYPE_PHONE);
@@ -577,5 +577,5 @@
  *
  */
-sysarg_t sys_ipc_forward_fast(sysarg_t chandle, sysarg_t phandle,
+sys_errno_t sys_ipc_forward_fast(sysarg_t chandle, sysarg_t phandle,
     sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
 {
@@ -601,12 +601,12 @@
  *
  */
-sysarg_t sys_ipc_forward_slow(sysarg_t chandle, sysarg_t phandle,
+sys_errno_t sys_ipc_forward_slow(sysarg_t chandle, sysarg_t phandle,
     ipc_data_t *data, unsigned int mode)
 {
 	ipc_data_t newdata;
-	int rc = copy_from_uspace(&newdata.args, &data->args,
+	errno_t rc = copy_from_uspace(&newdata.args, &data->args,
 	    sizeof(newdata.args));
 	if (rc != 0)
-		return (sysarg_t) rc;
+		return (sys_errno_t) rc;
 	
 	return sys_ipc_forward_common(chandle, phandle,
@@ -631,5 +631,5 @@
  *
  */
-sysarg_t sys_ipc_answer_fast(sysarg_t chandle, sysarg_t retval, sysarg_t arg1,
+sys_errno_t sys_ipc_answer_fast(sysarg_t chandle, sysarg_t retval, sysarg_t arg1,
     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
 {
@@ -660,5 +660,5 @@
 	 */
 	IPC_SET_ARG5(call->data, 0);
-	int rc = answer_preprocess(call, saved ? &saved_data : NULL);
+	errno_t rc = answer_preprocess(call, saved ? &saved_data : NULL);
 	
 	ipc_answer(&TASK->answerbox, call);
@@ -678,5 +678,5 @@
  *
  */
-sysarg_t sys_ipc_answer_slow(sysarg_t chandle, ipc_data_t *data)
+sys_errno_t sys_ipc_answer_slow(sysarg_t chandle, ipc_data_t *data)
 {
 	kobject_t *kobj = cap_unpublish(TASK, chandle, KOBJECT_TYPE_CALL);
@@ -695,5 +695,5 @@
 		saved = false;
 	
-	int rc = copy_from_uspace(&call->data.args, &data->args, 
+	errno_t rc = copy_from_uspace(&call->data.args, &data->args, 
 	    sizeof(call->data.args));
 	if (rc != 0) {
@@ -722,5 +722,5 @@
  *
  */
-sysarg_t sys_ipc_hangup(sysarg_t handle)
+sys_errno_t sys_ipc_hangup(sysarg_t handle)
 {
 	kobject_t *kobj = kobject_get(TASK, handle, KOBJECT_TYPE_PHONE);
@@ -728,5 +728,5 @@
 		return ENOENT;
 	
-	int rc = ipc_phone_hangup(kobj->phone);
+	errno_t rc = ipc_phone_hangup(kobj->phone);
 	kobject_put(kobj);
 	return rc;
@@ -742,5 +742,5 @@
  * @return An error code on error.
  */
-sysarg_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
+sys_errno_t sys_ipc_wait_for_call(ipc_data_t *calldata, uint32_t usec,
     unsigned int flags)
 {
@@ -800,5 +800,5 @@
 	
 	cap_handle_t handle;
-	int rc = cap_alloc(TASK, &handle);
+	errno_t rc = cap_alloc(TASK, &handle);
 	if (rc != EOK) {
 		goto error;
@@ -848,5 +848,5 @@
  *
  */
-sysarg_t sys_ipc_poke(void)
+sys_errno_t sys_ipc_poke(void)
 {
 	waitq_unsleep(&TASK->answerbox.wq);
@@ -866,5 +866,5 @@
  *
  */
-sysarg_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod, irq_code_t *ucode,
+sys_errno_t sys_ipc_irq_subscribe(inr_t inr, sysarg_t imethod, irq_code_t *ucode,
 	cap_handle_t *uspace_handle)
 {
@@ -883,5 +883,5 @@
  *
  */
-sysarg_t sys_ipc_irq_unsubscribe(sysarg_t cap)
+sys_errno_t sys_ipc_irq_unsubscribe(sysarg_t cap)
 {
 	if (!(perm_get(TASK) & PERM_IRQ_REG))
@@ -898,5 +898,5 @@
  *
  */
-sysarg_t sys_ipc_connect_kbox(task_id_t *uspace_taskid, cap_handle_t *uspace_phone)
+sys_errno_t sys_ipc_connect_kbox(task_id_t *uspace_taskid, cap_handle_t *uspace_phone)
 {
 #ifdef CONFIG_UDEBUG
@@ -904,5 +904,5 @@
 	cap_handle_t phone;
 	
-	int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(task_id_t));
+	errno_t rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(task_id_t));
 	if (rc == EOK) {
 		rc = ipc_connect_kbox((task_id_t) taskid, &phone);
@@ -917,7 +917,7 @@
 	}
 	
-	return (sysarg_t) rc;
+	return (sys_errno_t) rc;
 #else
-	return (sysarg_t) ENOTSUP;
+	return (sys_errno_t) ENOTSUP;
 #endif
 }
Index: kernel/generic/src/ipc/sysipc_ops.c
===================================================================
--- kernel/generic/src/ipc/sysipc_ops.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/sysipc_ops.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -69,10 +69,10 @@
 };
 
-int null_request_preprocess(call_t *call, phone_t *phone)
+errno_t null_request_preprocess(call_t *call, phone_t *phone)
 {
 	return EOK;
 }
 
-int null_request_forget(call_t *call)
+errno_t null_request_forget(call_t *call)
 {
 	return EOK;
@@ -84,15 +84,15 @@
 }
 
-int null_answer_cleanup(call_t *call, ipc_data_t *data)
+errno_t null_answer_cleanup(call_t *call, ipc_data_t *data)
 {
 	return EOK;
 }
 
-int null_answer_preprocess(call_t *call, ipc_data_t *data)
+errno_t null_answer_preprocess(call_t *call, ipc_data_t *data)
 {
 	return EOK;
 }
 
-int null_answer_process(call_t *call)
+errno_t null_answer_process(call_t *call)
 {
 	return EOK;
Index: kernel/generic/src/lib/str.c
===================================================================
--- kernel/generic/src/lib/str.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/lib/str.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -217,5 +217,5 @@
  *         code was invalid.
  */
-int chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
+errno_t chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
 {
 	if (*offset >= size)
@@ -794,5 +794,5 @@
  *
  */
-static int str_uint(const char *nptr, char **endptr, unsigned int base,
+static errno_t str_uint(const char *nptr, char **endptr, unsigned int base,
     bool *neg, uint64_t *result)
 {
@@ -915,5 +915,5 @@
  *
  */
-int str_uint64_t(const char *nptr, char **endptr, unsigned int base,
+errno_t str_uint64_t(const char *nptr, char **endptr, unsigned int base,
     bool strict, uint64_t *result)
 {
@@ -922,5 +922,5 @@
 	bool neg;
 	char *lendptr;
-	int ret = str_uint(nptr, &lendptr, base, &neg, result);
+	errno_t ret = str_uint(nptr, &lendptr, base, &neg, result);
 	
 	if (endptr != NULL)
Index: kernel/generic/src/lib/str_error.c
===================================================================
--- kernel/generic/src/lib/str_error.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/lib/str_error.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -40,5 +40,5 @@
 #define __errno_entry(name, num, desc) name,
 
-static const int err_num[] = {
+static const errno_t err_num[] = {
 #include <abi/errno.in>
 };
Index: kernel/generic/src/log/log.c
===================================================================
--- kernel/generic/src/log/log.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/log/log.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -221,5 +221,5 @@
 		
 		size_t buffer_offset = 0;
-		int rc = chr_encode(wstr[chars], buffer, &buffer_offset, 16);
+		errno_t rc = chr_encode(wstr[chars], buffer, &buffer_offset, 16);
 		if (rc != EOK) {
 			return EOF;
@@ -293,12 +293,12 @@
  *
  */
-sysarg_t sys_klog(sysarg_t operation, void *buf, size_t size,
+sys_errno_t sys_klog(sysarg_t operation, void *buf, size_t size,
     sysarg_t level, size_t *uspace_nread)
 {
 	char *data;
-	int rc;
+	errno_t rc;
 	
 	if (size > PAGE_SIZE)
-		return (sysarg_t) ELIMIT;
+		return (sys_errno_t) ELIMIT;
 	
 	switch (operation) {
@@ -306,10 +306,10 @@
 			data = (char *) malloc(size + 1, 0);
 			if (!data)
-				return (sysarg_t) ENOMEM;
+				return (sys_errno_t) ENOMEM;
 			
 			rc = copy_from_uspace(data, buf, size);
 			if (rc) {
 				free(data);
-				return (sysarg_t) rc;
+				return (sys_errno_t) rc;
 			}
 			data[size] = 0;
@@ -325,5 +325,5 @@
 			data = (char *) malloc(size, 0);
 			if (!data)
-				return (sysarg_t) ENOMEM;
+				return (sys_errno_t) ENOMEM;
 			
 			size_t entry_len = 0;
@@ -366,5 +366,5 @@
 			if (rc != EOK) {
 				free(data);
-				return (sysarg_t) rc;
+				return (sys_errno_t) rc;
 			}
 			
@@ -374,10 +374,10 @@
 			
 			if (rc != EOK)
-				return (sysarg_t) rc;
+				return (sys_errno_t) rc;
 			
 			return copy_to_uspace(uspace_nread, &copied, sizeof(copied));
 			return EOK;
 		default:
-			return (sysarg_t) ENOTSUP;
+			return (sys_errno_t) ENOTSUP;
 	}
 }
Index: kernel/generic/src/main/kinit.c
===================================================================
--- kernel/generic/src/main/kinit.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/main/kinit.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -253,5 +253,5 @@
 		assert(page);
 		
-		int rc = program_create_from_image((void *) page, namebuf,
+		errno_t rc = program_create_from_image((void *) page, namebuf,
 		    &programs[i]);
 		
Index: kernel/generic/src/mm/as.c
===================================================================
--- kernel/generic/src/mm/as.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/mm/as.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -111,5 +111,5 @@
 as_t *AS_KERNEL = NULL;
 
-NO_TRACE static int as_constructor(void *obj, unsigned int flags)
+NO_TRACE static errno_t as_constructor(void *obj, unsigned int flags)
 {
 	as_t *as = (as_t *) obj;
@@ -760,5 +760,5 @@
  *
  */
-int as_area_resize(as_t *as, uintptr_t address, size_t size, unsigned int flags)
+errno_t as_area_resize(as_t *as, uintptr_t address, size_t size, unsigned int flags)
 {
 	if (!IS_ALIGNED(address, PAGE_SIZE))
@@ -969,5 +969,5 @@
  *
  */
-int as_area_destroy(as_t *as, uintptr_t address)
+errno_t as_area_destroy(as_t *as, uintptr_t address)
 {
 	mutex_lock(&as->lock);
@@ -1085,5 +1085,5 @@
  *
  */
-int as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
+errno_t as_area_share(as_t *src_as, uintptr_t src_base, size_t acc_size,
     as_t *dst_as, unsigned int dst_flags_mask, uintptr_t *dst_base,
     uintptr_t bound)
@@ -1248,5 +1248,5 @@
  *
  */
-int as_area_change_flags(as_t *as, unsigned int flags, uintptr_t address)
+errno_t as_area_change_flags(as_t *as, unsigned int flags, uintptr_t address)
 {
 	/* Flags for the new memory mapping */
@@ -2208,17 +2208,17 @@
 }
 
-sysarg_t sys_as_area_resize(uintptr_t address, size_t size, unsigned int flags)
-{
-	return (sysarg_t) as_area_resize(AS, address, size, 0);
-}
-
-sysarg_t sys_as_area_change_flags(uintptr_t address, unsigned int flags)
-{
-	return (sysarg_t) as_area_change_flags(AS, flags, address);
-}
-
-sysarg_t sys_as_area_destroy(uintptr_t address)
-{
-	return (sysarg_t) as_area_destroy(AS, address);
+sys_errno_t sys_as_area_resize(uintptr_t address, size_t size, unsigned int flags)
+{
+	return (sys_errno_t) as_area_resize(AS, address, size, 0);
+}
+
+sys_errno_t sys_as_area_change_flags(uintptr_t address, unsigned int flags)
+{
+	return (sys_errno_t) as_area_change_flags(AS, flags, address);
+}
+
+sys_errno_t sys_as_area_destroy(uintptr_t address)
+{
+	return (sys_errno_t) as_area_destroy(AS, address);
 }
 
Index: kernel/generic/src/mm/backend_user.c
===================================================================
--- kernel/generic/src/mm/backend_user.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/mm/backend_user.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -126,5 +126,5 @@
 	IPC_SET_ARG5(data, pager_info->id3);
 
-	int rc = ipc_req_internal(pager_info->pager, &data, (sysarg_t) true);
+	errno_t rc = ipc_req_internal(pager_info->pager, &data, (sysarg_t) true);
 
 	if (rc != EOK) {
Index: kernel/generic/src/mm/page.c
===================================================================
--- kernel/generic/src/mm/page.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/mm/page.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -190,5 +190,5 @@
 }
 
-int page_find_mapping(uintptr_t virt, uintptr_t *phys)
+errno_t page_find_mapping(uintptr_t virt, uintptr_t *phys)
 {
 	page_table_lock(AS, true);
@@ -215,13 +215,13 @@
  *
  */
-sysarg_t sys_page_find_mapping(uintptr_t virt, uintptr_t *phys_ptr)
+sys_errno_t sys_page_find_mapping(uintptr_t virt, uintptr_t *phys_ptr)
 {
 	uintptr_t phys;
-	int rc = page_find_mapping(virt, &phys);
+	errno_t rc = page_find_mapping(virt, &phys);
 	if (rc != EOK)
 		return rc;
 	
 	rc = copy_to_uspace(phys_ptr, &phys, sizeof(phys));
-	return (sysarg_t) rc;
+	return (sys_errno_t) rc;
 }
 
Index: kernel/generic/src/mm/slab.c
===================================================================
--- kernel/generic/src/mm/slab.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/mm/slab.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -608,5 +608,5 @@
  */
 NO_TRACE static void _slab_cache_create(slab_cache_t *cache, const char *name,
-    size_t size, size_t align, int (*constructor)(void *obj,
+    size_t size, size_t align, errno_t (*constructor)(void *obj,
     unsigned int kmflag), size_t (*destructor)(void *obj), unsigned int flags)
 {
@@ -662,5 +662,5 @@
  */
 slab_cache_t *slab_cache_create(const char *name, size_t size, size_t align,
-    int (*constructor)(void *obj, unsigned int kmflag),
+    errno_t (*constructor)(void *obj, unsigned int kmflag),
     size_t (*destructor)(void *obj), unsigned int flags)
 {
Index: kernel/generic/src/proc/program.c
===================================================================
--- kernel/generic/src/proc/program.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/proc/program.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -69,5 +69,5 @@
  *
  */
-int program_create(as_t *as, uintptr_t entry_addr, char *name, program_t *prg)
+errno_t program_create(as_t *as, uintptr_t entry_addr, char *name, program_t *prg)
 {
 	prg->loader_status = EE_OK;
@@ -137,5 +137,5 @@
  *
  */
-int program_create_from_image(void *image_addr, char *name, program_t *prg)
+errno_t program_create_from_image(void *image_addr, char *name, program_t *prg)
 {
 	as_t *as = as_create(0);
@@ -174,5 +174,5 @@
  *
  */
-int program_create_loader(program_t *prg, char *name)
+errno_t program_create_loader(program_t *prg, char *name)
 {
 	as_t *as = as_create(0);
@@ -225,5 +225,5 @@
  *
  */
-sysarg_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
+sys_errno_t sys_program_spawn_loader(char *uspace_name, size_t name_len)
 {
 	/* Cap length of name and copy it from userspace. */
@@ -232,7 +232,7 @@
 	
 	char namebuf[TASK_NAME_BUFLEN];
-	int rc = copy_from_uspace(namebuf, uspace_name, name_len);
+	errno_t rc = copy_from_uspace(namebuf, uspace_name, name_len);
 	if (rc != 0)
-		return (sysarg_t) rc;
+		return (sys_errno_t) rc;
 	
 	namebuf[name_len] = 0;
Index: kernel/generic/src/proc/task.c
===================================================================
--- kernel/generic/src/proc/task.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/proc/task.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -83,5 +83,5 @@
 /* Forward declarations. */
 static void task_kill_internal(task_t *);
-static int tsk_constructor(void *, unsigned int);
+static errno_t tsk_constructor(void *, unsigned int);
 static size_t tsk_destructor(void *obj);
 
@@ -158,9 +158,9 @@
 }
 
-int tsk_constructor(void *obj, unsigned int kmflags)
+errno_t tsk_constructor(void *obj, unsigned int kmflags)
 {
 	task_t *task = (task_t *) obj;
 
-	int rc = caps_task_alloc(task);
+	errno_t rc = caps_task_alloc(task);
 	if (rc != EOK)
 		return rc;
@@ -246,5 +246,5 @@
 	    (container_check(ipc_phone_0->task->container, task->container))) {
 		cap_handle_t phone_handle;
-		int rc = phone_alloc(task, &phone_handle);
+		errno_t rc = phone_alloc(task, &phone_handle);
 		if (rc != EOK) {
 			task->as = NULL;
@@ -345,5 +345,5 @@
  *
  */
-sysarg_t sys_task_get_id(sysarg64_t *uspace_taskid)
+sys_errno_t sys_task_get_id(sysarg64_t *uspace_taskid)
 {
 	/*
@@ -351,5 +351,5 @@
 	 * the lifespan of the task.
 	 */
-	return (sysarg_t) copy_to_uspace(uspace_taskid, &TASK->taskid,
+	return (sys_errno_t) copy_to_uspace(uspace_taskid, &TASK->taskid,
 	    sizeof(TASK->taskid));
 }
@@ -385,5 +385,5 @@
  *
  */
-sysarg_t sys_task_set_name(const char *uspace_name, size_t name_len)
+sys_errno_t sys_task_set_name(const char *uspace_name, size_t name_len)
 {
 	char namebuf[TASK_NAME_BUFLEN];
@@ -393,7 +393,7 @@
 		name_len = TASK_NAME_BUFLEN - 1;
 	
-	int rc = copy_from_uspace(namebuf, uspace_name, name_len);
+	errno_t rc = copy_from_uspace(namebuf, uspace_name, name_len);
 	if (rc != 0)
-		return (sysarg_t) rc;
+		return (sys_errno_t) rc;
 	
 	namebuf[name_len] = '\0';
@@ -426,12 +426,12 @@
  *
  */
-sysarg_t sys_task_kill(task_id_t *uspace_taskid)
+sys_errno_t sys_task_kill(task_id_t *uspace_taskid)
 {
 	task_id_t taskid;
-	int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(taskid));
+	errno_t rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(taskid));
 	if (rc != 0)
-		return (sysarg_t) rc;
-	
-	return (sysarg_t) task_kill(taskid);
+		return (sys_errno_t) rc;
+	
+	return (sys_errno_t) task_kill(taskid);
 }
 
@@ -539,5 +539,5 @@
  *
  */
-int task_kill(task_id_t id)
+errno_t task_kill(task_id_t id)
 {
 	if (id == 1)
@@ -596,5 +596,5 @@
  *
  */
-sysarg_t sys_task_exit(sysarg_t notify)
+sys_errno_t sys_task_exit(sysarg_t notify)
 {
 	task_kill_self(notify);
Index: kernel/generic/src/proc/thread.c
===================================================================
--- kernel/generic/src/proc/thread.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/proc/thread.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -153,5 +153,5 @@
  *
  */
-static int thr_constructor(void *obj, unsigned int kmflags)
+static errno_t thr_constructor(void *obj, unsigned int kmflags)
 {
 	thread_t *thread = (thread_t *) obj;
@@ -639,5 +639,5 @@
  *
  */
-int thread_join_timeout(thread_t *thread, uint32_t usec, unsigned int flags)
+errno_t thread_join_timeout(thread_t *thread, uint32_t usec, unsigned int flags)
 {
 	if (thread == THREAD)
@@ -930,5 +930,5 @@
  *
  */
-sysarg_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
+sys_errno_t sys_thread_create(uspace_arg_t *uspace_uarg, char *uspace_name,
     size_t name_len, thread_id_t *uspace_thread_id)
 {
@@ -937,7 +937,7 @@
 	
 	char namebuf[THREAD_NAME_BUFLEN];
-	int rc = copy_from_uspace(namebuf, uspace_name, name_len);
+	errno_t rc = copy_from_uspace(namebuf, uspace_name, name_len);
 	if (rc != 0)
-		return (sysarg_t) rc;
+		return (sys_errno_t) rc;
 	
 	namebuf[name_len] = 0;
@@ -953,5 +953,5 @@
 	if (rc != 0) {
 		free(kernel_uarg);
-		return (sysarg_t) rc;
+		return (sys_errno_t) rc;
 	}
 	
@@ -977,5 +977,5 @@
 				free(kernel_uarg);
 				
-				return (sysarg_t) rc;
+				return (sys_errno_t) rc;
 			 }
 		}
@@ -999,5 +999,5 @@
 		free(kernel_uarg);
 	
-	return (sysarg_t) ENOMEM;
+	return (sys_errno_t) ENOMEM;
 }
 
@@ -1005,5 +1005,5 @@
  *
  */
-sysarg_t sys_thread_exit(int uspace_status)
+sys_errno_t sys_thread_exit(int uspace_status)
 {
 	thread_exit();
@@ -1018,5 +1018,5 @@
  *
  */
-sysarg_t sys_thread_get_id(thread_id_t *uspace_thread_id)
+sys_errno_t sys_thread_get_id(thread_id_t *uspace_thread_id)
 {
 	/*
@@ -1025,10 +1025,10 @@
 	 *
 	 */
-	return (sysarg_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
+	return (sys_errno_t) copy_to_uspace(uspace_thread_id, &THREAD->tid,
 	    sizeof(THREAD->tid));
 }
 
 /** Syscall wrapper for sleeping. */
-sysarg_t sys_thread_usleep(uint32_t usec)
+sys_errno_t sys_thread_usleep(uint32_t usec)
 {
 	thread_usleep(usec);
@@ -1036,5 +1036,5 @@
 }
 
-sysarg_t sys_thread_udelay(uint32_t usec)
+sys_errno_t sys_thread_udelay(uint32_t usec)
 {
 	delay(usec);
Index: kernel/generic/src/security/perm.c
===================================================================
--- kernel/generic/src/security/perm.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/security/perm.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -84,5 +84,5 @@
  *
  */
-static int perm_grant(task_id_t taskid, perm_t perms)
+static errno_t perm_grant(task_id_t taskid, perm_t perms)
 {
 	if (!(perm_get(TASK) & PERM_PERM))
@@ -116,5 +116,5 @@
  *
  */
-static int perm_revoke(task_id_t taskid, perm_t perms)
+static errno_t perm_revoke(task_id_t taskid, perm_t perms)
 {
 	irq_spinlock_lock(&tasks_lock, true);
@@ -158,10 +158,10 @@
  *
  */
-sysarg_t sys_perm_grant(sysarg64_t *uspace_taskid, perm_t perms)
+sys_errno_t sys_perm_grant(sysarg64_t *uspace_taskid, perm_t perms)
 {
 	sysarg64_t taskid;
-	int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
+	errno_t rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
 	if (rc != 0)
-		return (sysarg_t) rc;
+		return (sys_errno_t) rc;
 	
 	return perm_grant((task_id_t) taskid, perms);
@@ -179,10 +179,10 @@
  *
  */
-sysarg_t sys_perm_revoke(sysarg64_t *uspace_taskid, perm_t perms)
+sys_errno_t sys_perm_revoke(sysarg64_t *uspace_taskid, perm_t perms)
 {
 	sysarg64_t taskid;
-	int rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
+	errno_t rc = copy_from_uspace(&taskid, uspace_taskid, sizeof(sysarg64_t));
 	if (rc != 0)
-		return (sysarg_t) rc;
+		return (sys_errno_t) rc;
 	
 	return perm_revoke((task_id_t) taskid, perms);
@@ -203,5 +203,5 @@
  *
  */
-sysarg_t sys_perm_grant(sysarg_t taskid, perm_t perms)
+sys_errno_t sys_perm_grant(sysarg_t taskid, perm_t perms)
 {
 	return perm_grant((task_id_t) taskid, perms);
@@ -219,5 +219,5 @@
  *
  */
-sysarg_t sys_perm_revoke(sysarg_t taskid, perm_t perms)
+sys_errno_t sys_perm_revoke(sysarg_t taskid, perm_t perms)
 {
 	return perm_revoke((task_id_t) taskid, perms);
Index: kernel/generic/src/synch/condvar.c
===================================================================
--- kernel/generic/src/synch/condvar.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/synch/condvar.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -85,7 +85,7 @@
  * @return		See comment for waitq_sleep_timeout().
  */
-int _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec, int flags)
+errno_t _condvar_wait_timeout(condvar_t *cv, mutex_t *mtx, uint32_t usec, int flags)
 {
-	int rc;
+	errno_t rc;
 	ipl_t ipl;
 	bool blocked;
@@ -124,8 +124,8 @@
  * @return See comment for waitq_sleep_timeout().
  */
-int _condvar_wait_timeout_spinlock_impl(condvar_t *cv, spinlock_t *lock, 
+errno_t _condvar_wait_timeout_spinlock_impl(condvar_t *cv, spinlock_t *lock, 
 	uint32_t usec, int flags)
 {
-	int rc;
+	errno_t rc;
 	ipl_t ipl;
 	bool blocked;
@@ -161,8 +161,8 @@
  * @return See comment for waitq_sleep_timeout().
  */
-int _condvar_wait_timeout_irq_spinlock(condvar_t *cv, irq_spinlock_t *irq_lock, 
+errno_t _condvar_wait_timeout_irq_spinlock(condvar_t *cv, irq_spinlock_t *irq_lock, 
 	uint32_t usec, int flags)
 {
-	int rc;
+	errno_t rc;
 	/* Save spinlock's state so we can restore it correctly later on. */
 	ipl_t ipl = irq_lock->ipl;
Index: kernel/generic/src/synch/futex.c
===================================================================
--- kernel/generic/src/synch/futex.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/synch/futex.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -398,10 +398,10 @@
  *                      waitq_sleep_timeout().
  */
-sysarg_t sys_futex_sleep(uintptr_t uaddr)
+sys_errno_t sys_futex_sleep(uintptr_t uaddr)
 {
 	futex_t *futex = get_futex(uaddr);
 	
 	if (!futex) 
-		return (sysarg_t) ENOENT;
+		return (sys_errno_t) ENOENT;
 
 #ifdef CONFIG_UDEBUG
@@ -409,5 +409,5 @@
 #endif
 
-	int rc = waitq_sleep_timeout(
+	errno_t rc = waitq_sleep_timeout(
 	    &futex->wq, 0, SYNCH_FLAGS_INTERRUPTIBLE, NULL);
 
@@ -416,5 +416,5 @@
 #endif
 
-	return (sysarg_t) rc;
+	return (sys_errno_t) rc;
 }
 
@@ -425,5 +425,5 @@
  * @return		ENOENT if there is no physical mapping for uaddr.
  */
-sysarg_t sys_futex_wakeup(uintptr_t uaddr)
+sys_errno_t sys_futex_wakeup(uintptr_t uaddr)
 {
 	futex_t *futex = get_futex(uaddr);
@@ -433,5 +433,5 @@
 		return EOK;
 	} else {
-		return (sysarg_t) ENOENT;
+		return (sys_errno_t) ENOENT;
 	}
 }
Index: kernel/generic/src/synch/mutex.c
===================================================================
--- kernel/generic/src/synch/mutex.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/synch/mutex.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -85,7 +85,7 @@
  *
  */
-int _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, unsigned int flags)
+errno_t _mutex_lock_timeout(mutex_t *mtx, uint32_t usec, unsigned int flags)
 {
-	int rc;
+	errno_t rc;
 
 	if (mtx->type == MUTEX_PASSIVE && THREAD) {
Index: kernel/generic/src/synch/rcu.c
===================================================================
--- kernel/generic/src/synch/rcu.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/synch/rcu.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -957,5 +957,5 @@
 			
 			/* Wait for the GP to complete. */
-			int ret = _condvar_wait_timeout_spinlock(&rcu.gp_ended, &rcu.gp_lock, 
+			errno_t ret = _condvar_wait_timeout_spinlock(&rcu.gp_ended, &rcu.gp_lock, 
 				SYNCH_NO_TIMEOUT, SYNCH_FLAGS_INTERRUPTIBLE);
 			
@@ -1013,5 +1013,5 @@
 		spinlock_lock(&rcu.gp_lock);
 
-		int ret = 0;
+		errno_t ret = 0;
 		ret = _condvar_wait_timeout_spinlock(&rcu.expedite_now, &rcu.gp_lock,
 			DETECT_SLEEP_MS * 1000, SYNCH_FLAGS_INTERRUPTIBLE);
Index: kernel/generic/src/synch/semaphore.c
===================================================================
--- kernel/generic/src/synch/semaphore.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/synch/semaphore.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -71,5 +71,5 @@
  *
  */
-int _semaphore_down_timeout(semaphore_t *sem, uint32_t usec, unsigned int flags)
+errno_t _semaphore_down_timeout(semaphore_t *sem, uint32_t usec, unsigned int flags)
 {
 	return waitq_sleep_timeout(&sem->wq, usec, flags, NULL);
Index: kernel/generic/src/synch/smc.c
===================================================================
--- kernel/generic/src/synch/smc.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/synch/smc.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -43,5 +43,5 @@
 #include <mm/as.h>
 
-sysarg_t sys_smc_coherence(uintptr_t va, size_t size)
+sys_errno_t sys_smc_coherence(uintptr_t va, size_t size)
 {
 	if (overlaps(va, size, (uintptr_t) NULL, PAGE_SIZE))
Index: kernel/generic/src/synch/smp_memory_barrier.c
===================================================================
--- kernel/generic/src/synch/smp_memory_barrier.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/synch/smp_memory_barrier.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -51,5 +51,5 @@
  * @return Irrelevant.
  */
-sysarg_t sys_smp_memory_barrier(void)
+sys_errno_t sys_smp_memory_barrier(void)
 {
 	for (unsigned int cpu_id = 0; cpu_id < config.cpu_active; ++cpu_id) {
Index: kernel/generic/src/synch/waitq.c
===================================================================
--- kernel/generic/src/synch/waitq.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/synch/waitq.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -268,5 +268,5 @@
  *
  */
-int waitq_sleep_timeout(waitq_t *wq, uint32_t usec, unsigned int flags, bool *blocked)
+errno_t waitq_sleep_timeout(waitq_t *wq, uint32_t usec, unsigned int flags, bool *blocked)
 {
 	assert((!PREEMPTION_DISABLED) || (PARAM_NON_BLOCKING(flags, usec)));
@@ -274,5 +274,5 @@
 	ipl_t ipl = waitq_sleep_prepare(wq);
 	bool nblocked;
-	int rc = waitq_sleep_timeout_unsafe(wq, usec, flags, &nblocked);
+	errno_t rc = waitq_sleep_timeout_unsafe(wq, usec, flags, &nblocked);
 	waitq_sleep_finish(wq, nblocked, ipl);
 
@@ -373,5 +373,5 @@
  *
  */
-int waitq_sleep_timeout_unsafe(waitq_t *wq, uint32_t usec, unsigned int flags, bool *blocked)
+errno_t waitq_sleep_timeout_unsafe(waitq_t *wq, uint32_t usec, unsigned int flags, bool *blocked)
 {
 	*blocked = false;
Index: kernel/generic/src/synch/workqueue.c
===================================================================
--- kernel/generic/src/synch/workqueue.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/synch/workqueue.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -895,5 +895,5 @@
 	
 	while (list_empty(&info->work_queues) && !stop) {
-		int ret = _condvar_wait_timeout_irq_spinlock(&info->req_cv, 
+		errno_t ret = _condvar_wait_timeout_irq_spinlock(&info->req_cv, 
 			&info->lock, SYNCH_NO_TIMEOUT, SYNCH_FLAGS_INTERRUPTIBLE);
 		
Index: kernel/generic/src/syscall/copy.c
===================================================================
--- kernel/generic/src/syscall/copy.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/syscall/copy.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -59,8 +59,8 @@
  * @return EOK on success or an error code from @ref errno.h.
  */
-int copy_from_uspace(void *dst, const void *uspace_src, size_t size)
+errno_t copy_from_uspace(void *dst, const void *uspace_src, size_t size)
 {
 	ipl_t ipl;
-	int rc;
+	errno_t rc;
 	
 	assert(THREAD);
@@ -110,8 +110,8 @@
  * @return 0 on success or an error code from @ref errno.h.
  */
-int copy_to_uspace(void *uspace_dst, const void *src, size_t size)
+errno_t copy_to_uspace(void *uspace_dst, const void *src, size_t size)
 {
 	ipl_t ipl;
-	int rc;
+	errno_t rc;
 	
 	assert(THREAD);
Index: kernel/generic/src/sysinfo/sysinfo.c
===================================================================
--- kernel/generic/src/sysinfo/sysinfo.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/sysinfo/sysinfo.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -61,5 +61,5 @@
  *
  */
-NO_TRACE static int sysinfo_item_constructor(void *obj, unsigned int kmflag)
+NO_TRACE static errno_t sysinfo_item_constructor(void *obj, unsigned int kmflag)
 {
 	sysinfo_item_t *item = (sysinfo_item_t *) obj;
@@ -790,8 +790,8 @@
  *
  */
-sysarg_t sys_sysinfo_get_keys_size(void *path_ptr, size_t path_size,
+sys_errno_t sys_sysinfo_get_keys_size(void *path_ptr, size_t path_size,
     void *size_ptr)
 {
-	int rc;
+	errno_t rc;
 	
 	/*
@@ -811,5 +811,5 @@
 		rc = EINVAL;
 	
-	return (sysarg_t) rc;
+	return (sys_errno_t) rc;
 }
 
@@ -838,8 +838,8 @@
  *
  */
-sysarg_t sys_sysinfo_get_keys(void *path_ptr, size_t path_size,
+sys_errno_t sys_sysinfo_get_keys(void *path_ptr, size_t path_size,
     void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
 {
-	int rc;
+	errno_t rc;
 	
 	/* Get the keys */
@@ -858,5 +858,5 @@
 		rc = EINVAL;
 	
-	return (sysarg_t) rc;
+	return (sys_errno_t) rc;
 }
 
@@ -909,8 +909,8 @@
  *
  */
-sysarg_t sys_sysinfo_get_value(void *path_ptr, size_t path_size,
+sys_errno_t sys_sysinfo_get_value(void *path_ptr, size_t path_size,
     void *value_ptr)
 {
-	int rc;
+	errno_t rc;
 	
 	/*
@@ -928,5 +928,5 @@
 		rc = EINVAL;
 	
-	return (sysarg_t) rc;
+	return (sys_errno_t) rc;
 }
 
@@ -945,8 +945,8 @@
  *
  */
-sysarg_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size,
+sys_errno_t sys_sysinfo_get_data_size(void *path_ptr, size_t path_size,
     void *size_ptr)
 {
-	int rc;
+	errno_t rc;
 	
 	/*
@@ -965,5 +965,5 @@
 		rc = EINVAL;
 	
-	return (sysarg_t) rc;
+	return (sys_errno_t) rc;
 }
 
@@ -995,8 +995,8 @@
  *
  */
-sysarg_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
+sys_errno_t sys_sysinfo_get_data(void *path_ptr, size_t path_size,
     void *buffer_ptr, size_t buffer_size, size_t *size_ptr)
 {
-	int rc;
+	errno_t rc;
 	
 	/* Get the item */
@@ -1018,5 +1018,5 @@
 		free(ret.data.data);
 	
-	return (sysarg_t) rc;
+	return (sys_errno_t) rc;
 }
 
Index: kernel/generic/src/udebug/udebug.c
===================================================================
--- kernel/generic/src/udebug/udebug.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/udebug/udebug.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -397,5 +397,5 @@
  *
  */
-int udebug_task_cleanup(struct task *task)
+errno_t udebug_task_cleanup(struct task *task)
 {
 	assert(mutex_locked(&task->udebug.lock));
Index: kernel/generic/src/udebug/udebug_ipc.c
===================================================================
--- kernel/generic/src/udebug/udebug_ipc.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/udebug/udebug_ipc.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -51,5 +51,5 @@
 #include <udebug/udebug_ipc.h>
 
-int udebug_request_preprocess(call_t *call, phone_t *phone)
+errno_t udebug_request_preprocess(call_t *call, phone_t *phone)
 {
 	switch (IPC_GET_ARG1(call->data)) {
@@ -71,5 +71,5 @@
 static void udebug_receive_begin(call_t *call)
 {
-	int rc;
+	errno_t rc;
 	bool active;
 
@@ -98,5 +98,5 @@
 static void udebug_receive_end(call_t *call)
 {
-	int rc;
+	errno_t rc;
 
 	rc = udebug_end();
@@ -113,5 +113,5 @@
 static void udebug_receive_set_evmask(call_t *call)
 {
-	int rc;
+	errno_t rc;
 	udebug_evmask_t mask;
 
@@ -132,5 +132,5 @@
 {
 	thread_t *t;
-	int rc;
+	errno_t rc;
 
 	t = (thread_t *)IPC_GET_ARG2(call->data);
@@ -152,5 +152,5 @@
 {
 	thread_t *t;
-	int rc;
+	errno_t rc;
 
 	t = (thread_t *)IPC_GET_ARG2(call->data);
@@ -172,5 +172,5 @@
 	void *buffer;
 	size_t copied, needed;
-	int rc;
+	errno_t rc;
 
 	uspace_addr = IPC_GET_ARG2(call->data);	/* Destination address */
@@ -307,5 +307,5 @@
 	thread_t *t;
 	sysarg_t uspace_addr;
-	int rc;
+	errno_t rc;
 	void *buffer;
 
@@ -346,5 +346,5 @@
 	sysarg_t to_copy;
 	void *buffer = NULL;
-	int rc;
+	errno_t rc;
 
 	t = (thread_t *) IPC_GET_ARG2(call->data);
@@ -390,5 +390,5 @@
 	unsigned size;
 	void *buffer = NULL;
-	int rc;
+	errno_t rc;
 
 	uspace_dst = IPC_GET_ARG2(call->data);
Index: kernel/generic/src/udebug/udebug_ops.c
===================================================================
--- kernel/generic/src/udebug/udebug_ops.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/udebug/udebug_ops.c	(revision e211ea04fccf33d4cb2092f630a29e893e096a02)
@@ -79,5 +79,5 @@
  *
  */
-static int _thread_op_begin(thread_t *thread, bool being_go)
+static errno_t _thread_op_begin(thread_t *thread, bool being_go)
 {
 	mutex_lock(&TASK->udebug.lock);
@@ -174,5 +174,5 @@
  *         debugging session.
  */
-int udebug_begin(call_t *call, bool *active)
+errno_t udebug_begin(call_t *call, bool *active)
 {
 	LOG("Debugging task %" PRIu64, TASK->taskid);
@@ -219,10 +219,10 @@
  *
  */
-int udebug_end(void)
+errno_t udebug_end(void)
 {
 	LOG("Task %" PRIu64, TASK->taskid);
 	
 	mutex_lock(&TASK->udebug.lock);
-	int rc = udebug_task_cleanup(TASK);
+	errno_t rc = udebug_task_cleanup(TASK);
 	mutex_unlock(&TASK->udebug.lock);
 	
@@ -239,5 +239,5 @@
  *
  */
-int udebug_set_evmask(udebug_evmask_t mask)
+errno_t udebug_set_evmask(udebug_evmask_t mask)
 {
 	LOG("mask = 0x%x", mask);
@@ -266,8 +266,8 @@
  *
  */
-int udebug_go(thread_t *thread, call_t *call)
+errno_t udebug_go(thread_t *thread, call_t *call)
 {
 	/* On success, this will lock thread->udebug.lock. */
-	int rc = _thread_op_begin(thread, false);
+	errno_t rc = _thread_op_begin(thread, false);
 	if (rc != EOK)
 		return rc;
@@ -297,5 +297,5 @@
  *
  */
-int udebug_stop(thread_t *thread, call_t *call)
+errno_t udebug_stop(thread_t *thread, call_t *call)
 {
 	LOG("udebug_stop()");
@@ -306,5 +306,5 @@
 	 *
 	 */
-	int rc = _thread_op_begin(thread, true);
+	errno_t rc = _thread_op_begin(thread, true);
 	if (rc != EOK)
 		return rc;
@@ -364,5 +364,5 @@
  *
  */
-int udebug_thread_read(void **buffer, size_t buf_size, size_t *stored,
+errno_t udebug_thread_read(void **buffer, size_t buf_size, size_t *stored,
     size_t *needed)
 {
@@ -428,5 +428,5 @@
  *
  */
-int udebug_name_read(char **data, size_t *data_size)
+errno_t udebug_name_read(char **data, size_t *data_size)
 {
 	size_t name_size = str_size(TASK->name) + 1;
@@ -457,8 +457,8 @@
  *
  */
-int udebug_args_read(thread_t *thread, void **buffer)
+errno_t udebug_args_read(thread_t *thread, void **buffer)
 {
 	/* On success, this will lock t->udebug.lock. */
-	int rc = _thread_op_begin(thread, false);
+	errno_t rc = _thread_op_begin(thread, false);
 	if (rc != EOK)
 		return rc;
@@ -500,8 +500,8 @@
  *
  */
-int udebug_regs_read(thread_t *thread, void **buffer)
+errno_t udebug_regs_read(thread_t *thread, void **buffer)
 {
 	/* On success, this will lock t->udebug.lock */
-	int rc = _thread_op_begin(thread, false);
+	errno_t rc = _thread_op_begin(thread, false);
 	if (rc != EOK)
 		return rc;
@@ -536,5 +536,5 @@
  *
  */
-int udebug_mem_read(sysarg_t uspace_addr, size_t n, void **buffer)
+errno_t udebug_mem_read(sysarg_t uspace_addr, size_t n, void **buffer)
 {
 	/* Verify task state */
@@ -553,5 +553,5 @@
 	 *
 	 */
-	int rc = copy_from_uspace(data_buffer, (void *) uspace_addr, n);
+	errno_t rc = copy_from_uspace(data_buffer, (void *) uspace_addr, n);
 	mutex_unlock(&TASK->udebug.lock);