Index: kernel/generic/src/ipc/event.c
===================================================================
--- kernel/generic/src/ipc/event.c	(revision cde999aca79219e8751af76502001a86d411d176)
+++ kernel/generic/src/ipc/event.c	(revision b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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 b7fd2a02e4161f4edd38548e7f8456b8021549be)
@@ -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;
