Index: uspace/app/tester/ipc/answer.c
===================================================================
--- uspace/app/tester/ipc/answer.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/app/tester/ipc/answer.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -47,5 +47,5 @@
 	}
 	if (!cnt)
-		return;
+		return NULL;
 	printf("Choose message:\n");
 	do {
@@ -70,5 +70,5 @@
 		errn = ENOENT;
 	printf("Answering %P\n", callids[i]);
-	ipc_answer_fast(callids[i], errn, 0, 0);
+	ipc_answer_0(callids[i], errn);
 	callids[i] = 0;
 	
Index: uspace/app/tester/ipc/register.c
===================================================================
--- uspace/app/tester/ipc/register.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/app/tester/ipc/register.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -30,4 +30,5 @@
 #include <unistd.h>
 #include <async.h>
+#include <errno.h>
 #include "../tester.h"
 
@@ -41,5 +42,5 @@
 
 	printf("Connected phone: %P, accepting\n", icall->in_phone_hash);
-	ipc_answer_fast(iid, 0, 0, 0);
+	ipc_answer_0(iid, EOK);
 	for (i = 0; i < 1024; i++)
 		if (!connections[i]) {
@@ -56,5 +57,6 @@
 			break;
 		default:
-			printf("Received message from %P: %X\n", phonehash,callid);
+			printf("Received message from %P: %X\n", phonehash,
+			    callid);
 			for (i = 0; i < 1024; i++)
 				if (!callids[i]) {
@@ -64,5 +66,5 @@
 			continue;
 		}
-		ipc_answer_fast(callid, retval, 0, 0);
+		ipc_answer_0(callid, retval);
 	}
 }
Index: uspace/app/tester/ipc/send_async.c
===================================================================
--- uspace/app/tester/ipc/send_async.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/app/tester/ipc/send_async.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -39,5 +39,4 @@
 {
 	int phoneid;
-	int res;
 	static int msgid = 1;
 	char c;
Index: uspace/lib/libc/generic/async.c
===================================================================
--- uspace/lib/libc/generic/async.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/lib/libc/generic/async.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -76,12 +76,12 @@
  * {
  * 	if (want_refuse) {
- * 		ipc_answer_fast(icallid, ELIMIT, 0, 0);
+ * 		ipc_answer_0(icallid, ELIMIT);
  * 		return;
  * 	}
- * 	ipc_answer_fast(icallid, EOK, 0, 0);
+ * 	ipc_answer_0(icallid, EOK);
  *
  * 	callid = async_get_call(&call);
  * 	handle_call(callid, call);
- * 	ipc_answer_fast(callid, 1, 2, 3);
+ * 	ipc_answer_2(callid, 1, 2, 3);
  *
  * 	callid = async_get_call(&call);
@@ -396,5 +396,5 @@
 static void default_client_connection(ipc_callid_t callid, ipc_call_t *call)
 {
-	ipc_answer_fast(callid, ENOENT, 0, 0);
+	ipc_answer_0(callid, ENOENT);
 }
 
@@ -441,9 +441,9 @@
 		if (msg->callid == FIBRIL_connection->close_callid)
 			close_answered = 1;
-		ipc_answer_fast(msg->callid, EHANGUP, 0, 0);
+		ipc_answer_0(msg->callid, EHANGUP);
 		free(msg);
 	}
 	if (FIBRIL_connection->close_callid)
-		ipc_answer_fast(FIBRIL_connection->close_callid, 0, 0, 0);
+		ipc_answer_0(FIBRIL_connection->close_callid, EOK);
 	
 	return 0;
@@ -476,5 +476,5 @@
 	if (!conn) {
 		if (callid)
-			ipc_answer_fast(callid, ENOMEM, 0, 0);
+			ipc_answer_0(callid, ENOMEM);
 		return NULL;
 	}
@@ -492,5 +492,5 @@
 		free(conn);
 		if (callid)
-			ipc_answer_fast(callid, ENOMEM, 0, 0);
+			ipc_answer_0(callid, ENOMEM);
 		return NULL;
 	}
@@ -537,5 +537,5 @@
 
 	/* Unknown call from unknown phone - hang it up */
-	ipc_answer_fast(callid, EHANGUP, 0, 0);
+	ipc_answer_0(callid, EHANGUP);
 }
 
Index: uspace/lib/libc/generic/ipc.c
===================================================================
--- uspace/lib/libc/generic/ipc.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/lib/libc/generic/ipc.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -376,6 +376,6 @@
 /** Answer a received call - fast version.
  *
- * The fast answer makes use of passing retval and first two arguments in
- * registers. If you need to return more, use the ipc_answer() instead.
+ * The fast answer makes use of passing retval and first four arguments in
+ * registers. If you need to return more, use the ipc_answer_slow() instead.
  *
  * @param callid	Hash of the call being answered.
@@ -383,24 +383,41 @@
  * @param arg1		First return argument.
  * @param arg2		Second return argument.
+ * @param arg3		Third return argument.
+ * @param arg4		Fourth return argument.
  *
  * @return		Zero on success or a value from @ref errno.h on failure.
  */
 ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
-    ipcarg_t arg2)
-{
-	return __SYSCALL4(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2);
-}
-
-/** Answer a received call - full version.
+    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4)
+{
+	return __SYSCALL6(SYS_IPC_ANSWER_FAST, callid, retval, arg1, arg2, arg3,
+	    arg4);
+}
+
+/** Answer a received call - slow full version.
  *
  * @param callid	Hash of the call being answered.
- * @param call 		Call structure with the answer.
- *			Must be already initialized by the responder.
+ * @param retval	Return value.
+ * @param arg1		First return argument.
+ * @param arg2		Second return argument.
+ * @param arg3		Third return argument.
+ * @param arg4		Fourth return argument.
+ * @param arg5		Fifth return argument.
  *
  * @return		Zero on success or a value from @ref errno.h on failure.
  */
-ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call)
-{
-	return __SYSCALL2(SYS_IPC_ANSWER, callid, (sysarg_t) call);
+ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval, ipcarg_t arg1,
+    ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5)
+{
+	ipc_call_t data;
+
+	IPC_SET_RETVAL(data, retval);
+	IPC_SET_ARG1(data, arg1);
+	IPC_SET_ARG2(data, arg2);
+	IPC_SET_ARG3(data, arg3);
+	IPC_SET_ARG4(data, arg4);
+	IPC_SET_ARG5(data, arg5);
+
+	return __SYSCALL2(SYS_IPC_ANSWER_SLOW, callid, (sysarg_t) &data);
 }
 
@@ -659,5 +676,4 @@
  * @param callid	Storage where the hash of the IPC_M_DATA_SEND call will
  * 			be stored.
- * @param call		Storage where the incoming call will be stored.
  * @param dst		Storage where the suggested destination address will
  *			be stored. May be NULL.
@@ -667,17 +683,17 @@
  * @return		Non-zero on success, zero on failure.
  */
-int ipc_data_receive(ipc_callid_t *callid, ipc_call_t *call, void **dst,
-    size_t *size)
-{
+int ipc_data_receive(ipc_callid_t *callid, void **dst, size_t *size)
+{
+	ipc_call_t data;
+	
 	assert(callid);
-	assert(call);
-
-	*callid = async_get_call(call);
-	if (IPC_GET_METHOD(*call) != IPC_M_DATA_SEND)
+
+	*callid = async_get_call(&data);
+	if (IPC_GET_METHOD(data) != IPC_M_DATA_SEND)
 		return 0;
 	if (dst)
-		*dst = (void *) IPC_GET_ARG1(*call);
+		*dst = (void *) IPC_GET_ARG1(data);
 	if (size)
-		*size = (size_t) IPC_GET_ARG3(*call);
+		*size = (size_t) IPC_GET_ARG3(data);
 	return 1;
 }
@@ -689,5 +705,4 @@
  *
  * @param callid	Hash of the IPC_M_DATA_SEND call to answer.
- * @param call		Call structure with the request.
  * @param dst		Final destination address for the IPC_M_DATA_SEND call.
  * @param size		Final size for the IPC_M_DATA_SEND call.
@@ -695,11 +710,7 @@
  * @return		Zero on success or a value from @ref errno.h on failure.
  */
-ipcarg_t ipc_data_deliver(ipc_callid_t callid, ipc_call_t *call, void *dst,
-    size_t size)
-{
-	IPC_SET_RETVAL(*call, EOK);
-	IPC_SET_ARG1(*call, (ipcarg_t) dst);
-	IPC_SET_ARG3(*call, (ipcarg_t) size);
-	return ipc_answer(callid, call);
+ipcarg_t ipc_data_deliver(ipc_callid_t callid, void *dst, size_t size)
+{
+	return ipc_answer_3(callid, EOK, (ipcarg_t) dst, 0, (ipcarg_t) size);
 }
  
Index: uspace/lib/libc/include/ipc/ipc.h
===================================================================
--- uspace/lib/libc/include/ipc/ipc.h	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/lib/libc/include/ipc/ipc.h	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -191,11 +191,27 @@
 extern ipc_callid_t ipc_trywait_for_call(ipc_call_t *data);
 
-#define ipc_answer_fast_0(callid, retval) \
-    ipc_answer_fast((callid), (retval), 0, 0)
-#define ipc_answer_fast_1(callid, retval, arg1) \
-    ipc_answer_fast((callid), (retval), (arg1), 0)
+/*
+ * User-friendly wrappers for ipc_answer_fast() and ipc_answer_slow().
+ * They are in the form of ipc_answer_m(), where m is the number of return
+ * arguments. The macros decide between the fast and the slow version according
+ * to m.
+ */
+#define ipc_answer_0(callid, retval) \
+    ipc_answer_fast((callid), (retval), 0, 0, 0, 0)
+#define ipc_answer_1(callid, retval, arg1) \
+    ipc_answer_fast((callid), (retval), (arg1), 0, 0, 0)
+#define ipc_answer_2(callid, retval, arg1, arg2) \
+    ipc_answer_fast((callid), (retval), (arg1), (arg2), 0, 0)
+#define ipc_answer_3(callid, retval, arg1, arg2, arg3) \
+    ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), 0)
+#define ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4) \
+    ipc_answer_fast((callid), (retval), (arg1), (arg2), (arg3), (arg4))
+#define ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5) \
+    ipc_answer_slow((callid), (retval), (arg1), (arg2), (arg3), (arg4), (arg5))
+
 extern ipcarg_t ipc_answer_fast(ipc_callid_t callid, ipcarg_t retval,
-    ipcarg_t arg1, ipcarg_t arg2);
-extern ipcarg_t ipc_answer(ipc_callid_t callid, ipc_call_t *call);
+    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4);
+extern ipcarg_t ipc_answer_slow(ipc_callid_t callid, ipcarg_t retval,
+    ipcarg_t arg1, ipcarg_t arg2, ipcarg_t arg3, ipcarg_t arg4, ipcarg_t arg5);
 
 /*
@@ -245,8 +261,6 @@
     ipcarg_t arg1);
 extern int ipc_data_send(int phoneid, void *src, size_t size);
-extern int ipc_data_receive(ipc_callid_t *callid, ipc_call_t *call, void **dst,
-    size_t *size);
-extern ipcarg_t ipc_data_deliver(ipc_callid_t callid, ipc_call_t *call,
-    void *dst, size_t size);
+extern int ipc_data_receive(ipc_callid_t *callid, void **dst, size_t *size);
+extern ipcarg_t ipc_data_deliver(ipc_callid_t callid, void *dst, size_t size);
 
 #endif
Index: uspace/srv/console/console.c
===================================================================
--- uspace/srv/console/console.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/console/console.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -278,6 +278,5 @@
 		for (j = 0; j < conn->screenbuffer.size_y; j++) 
 			for (i = 0; i < conn->screenbuffer.size_x; i++) {
-				field = get_field_at(&conn->screenbuffer, i,
-				    j);
+				field = get_field_at(&conn->screenbuffer, i, j);
 				if (!style_same(*style, field->style))
 					set_style(&field->style);
@@ -350,6 +349,6 @@
 			if (conn->keyrequest_counter > 0) {		
 				conn->keyrequest_counter--;
-				ipc_answer_fast(fifo_pop(conn->keyrequests), 0,
-				    c, 0);
+				ipc_answer_1(fifo_pop(conn->keyrequests), EOK,
+				    c);
 				break;
 			}
@@ -362,5 +361,5 @@
 			retval = ENOENT;
 		}
-		ipc_answer_fast(callid, retval, 0, 0);
+		ipc_answer_0(callid, retval);
 	}
 }
@@ -376,5 +375,5 @@
 
 	if ((consnum = find_free_connection()) == -1) {
-		ipc_answer_fast(iid, ELIMIT, 0, 0);
+		ipc_answer_0(iid, ELIMIT);
 		return;
 	}
@@ -388,5 +387,5 @@
 	
 	/* Accept the connection */
-	ipc_answer_fast(iid, 0, 0, 0);
+	ipc_answer_0(iid, EOK);
 
 	while (1) {
@@ -404,6 +403,6 @@
 			while (conn->keyrequest_counter > 0) {		
 				conn->keyrequest_counter--;
-				ipc_answer_fast(fifo_pop(conn->keyrequests),
-				    ENOENT, 0, 0);
+				ipc_answer_0(fifo_pop(conn->keyrequests),
+				    ENOENT);
 				break;
 			}
@@ -465,5 +464,5 @@
 					 * requests => fail.
 					*/
-					ipc_answer_fast(callid, ELIMIT, 0, 0);
+					ipc_answer_0(callid, ELIMIT);
 				}
 				continue;
@@ -472,5 +471,5 @@
 			break;
 		}
-		ipc_answer_fast(callid, 0, arg1, arg2);
+		ipc_answer_2(callid, EOK, arg1, arg2);
 	}
 }
Index: uspace/srv/devmap/devmap.c
===================================================================
--- uspace/srv/devmap/devmap.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/devmap/devmap.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -114,5 +114,5 @@
 
 	if (item == &devices_list) {
-		printf("DevMap: no device named %s.\n", name);
+		printf("DEVMAP: no device named %s.\n", name);
 		return NULL;
 	}
@@ -190,5 +190,5 @@
 
 	if (IPC_GET_METHOD(icall) != DEVMAP_DRIVER_REGISTER) {
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	} 
@@ -196,5 +196,5 @@
 	if (NULL ==
 	    (driver = (devmap_driver_t *)malloc(sizeof(devmap_driver_t)))) {
-		ipc_answer_fast(iid, ENOMEM, 0, 0);
+		ipc_answer_0(iid, ENOMEM);
 		return;
 	}
@@ -203,9 +203,9 @@
 	 * Get driver name
 	 */
-	if (!ipc_data_receive(&callid, &call, NULL, &name_size)) {
-		printf("Unexpected request: %u.\n", IPC_GET_METHOD(call));
+	if (!ipc_data_receive(&callid, NULL, &name_size)) {
+		printf("Unexpected request.\n");
 		free(driver);
-		ipc_answer_fast(callid, EREFUSED, 0, 0);
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+		ipc_answer_0(callid, EREFUSED);
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	}
@@ -215,6 +215,6 @@
 		    DEVMAP_NAME_MAXLEN);
 		free(driver);
-		ipc_answer_fast(callid, EINVAL, 0, 0);
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	}
@@ -226,6 +226,6 @@
 		printf("Cannot allocate space for driver name.\n");
 		free(driver);
-		ipc_answer_fast(callid, ENOMEM, 0, 0);
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+		ipc_answer_0(callid, ENOMEM);
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	}	
@@ -234,9 +234,9 @@
 	 * Send confirmation to sender and get data into buffer.
 	 */
-	if (EOK != ipc_data_deliver(callid, &call, driver->name, name_size)) {
+	if (EOK != ipc_data_deliver(callid, driver->name, name_size)) {
 		printf("Cannot read driver name.\n");
 		free(driver->name);
 		free(driver);
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	}
@@ -251,5 +251,5 @@
 	/* 
 	 * Initialize list of asociated devices
-     */
+	 */
 	list_initialize(&(driver->devices));
 
@@ -260,11 +260,11 @@
 
 	if (IPC_M_CONNECT_TO_ME != IPC_GET_METHOD(call)) {
-		printf("DevMap: Unexpected method: %u.\n",
+		printf("DEVMAP: Unexpected method: %u.\n",
 		    IPC_GET_METHOD(call));
-		ipc_answer_fast(callid, ENOTSUP, 0, 0);
+		ipc_answer_0(callid, ENOTSUP);
 		
 		free(driver->name);
 		free(driver);
-		ipc_answer_fast(iid, ENOTSUP, 0, 0);
+		ipc_answer_0(iid, ENOTSUP);
 		return;
 	}
@@ -272,5 +272,5 @@
 	driver->phone = IPC_GET_ARG3(call);
 	
-	ipc_answer_fast(callid, EOK, 0, 0);
+	ipc_answer_0(callid, EOK);
 	
 	list_initialize(&(driver->drivers));
@@ -288,5 +288,5 @@
 	futex_up(&drivers_list_futex);	
 	
-	ipc_answer_fast(iid, EOK, 0, 0);
+	ipc_answer_0(iid, EOK);
 	printf("Driver registered.\n");
 
@@ -295,6 +295,6 @@
 }
 
-/** Unregister device driver, unregister all its devices and free driver structure.
- *
+/** Unregister device driver, unregister all its devices and free driver
+ * structure.
  */
 static int devmap_driver_unregister(devmap_driver_t *driver)
@@ -348,8 +348,7 @@
  */
 static void devmap_device_register(ipc_callid_t iid, ipc_call_t *icall,
-		devmap_driver_t *driver)
+    devmap_driver_t *driver)
 {
 	ipc_callid_t callid;
-	ipc_call_t call;
 	size_t size;
 	devmap_device_t *device;
@@ -357,5 +356,5 @@
 	if (NULL == driver) {
 		printf("Invalid driver registration.\n");
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	}
@@ -365,13 +364,13 @@
 	    (device = (devmap_device_t *)malloc(sizeof(devmap_device_t)))) {
 		printf("Cannot allocate new device.\n");
-		ipc_answer_fast(iid, ENOMEM, 0, 0);
+		ipc_answer_0(iid, ENOMEM);
 		return;
 	}
 	
 	/* Get device name */
-	if (!ipc_data_receive(&callid, &call, NULL, &size)) {
+	if (!ipc_data_receive(&callid, NULL, &size)) {
 		free(device);
 		printf("Cannot read device name.\n");
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	}
@@ -380,6 +379,6 @@
 		printf("Too long device name: %u.\n", size);
 		free(device);
-		ipc_answer_fast(callid, EINVAL, 0, 0);
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	}
@@ -391,10 +390,10 @@
 		printf("Cannot read device name.\n");
 		free(device);
-		ipc_answer_fast(callid, ENOMEM, 0, 0);
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
-		return;
-	}
-	
-	ipc_data_deliver(callid, &call, device->name, size);
+		ipc_answer_0(callid, ENOMEM);
+		ipc_answer_0(iid, EREFUSED);
+		return;
+	}
+	
+	ipc_data_deliver(callid, device->name, size);
 	device->name[size] = 0;
 
@@ -410,5 +409,5 @@
 		free(device->name);
 		free(device);
-		ipc_answer_fast(iid, EEXISTS, 0, 0);
+		ipc_answer_0(iid, EEXISTS);
 		return;
 	}
@@ -420,16 +419,16 @@
 	
 	/* Insert device into list of all devices  */
-	list_append(&(device->devices), &devices_list);
+	list_append(&device->devices, &devices_list);
 
 	/* Insert device into list of devices that belog to one driver */
-	futex_down(&(device->driver->devices_futex));	
-	
-	list_append(&(device->driver_devices), &(device->driver->devices));
-	
-	futex_up(&(device->driver->devices_futex));	
+	futex_down(&device->driver->devices_futex);	
+	
+	list_append(&device->driver_devices, &device->driver->devices);
+	
+	futex_up(&device->driver->devices_futex);	
 	futex_up(&devices_list_futex);	
 
 	printf("Device '%s' registered.\n", device->name);	
-	ipc_answer_fast(iid, EOK, device->handle, 0);
+	ipc_answer_1(iid, EOK, device->handle);
 
 	return;
@@ -440,5 +439,5 @@
  */
 static int devmap_device_unregister(ipc_callid_t iid, ipc_call_t *icall, 
-	devmap_driver_t *driver)
+    devmap_driver_t *driver)
 {
 	/* TODO */
@@ -465,7 +464,7 @@
 
 	if (NULL == dev) {
-		printf("DevMap: No registered device with handle %d.\n",
+		printf("DEVMAP: No registered device with handle %d.\n",
 		    handle);
-		ipc_answer_fast(callid, ENOENT, 0, 0);
+		ipc_answer_0(callid, ENOENT);
 		return;
 	} 
@@ -487,5 +486,4 @@
 	const devmap_device_t *dev;
 	ipc_callid_t callid;
-	ipc_call_t call;
 	ipcarg_t retval;
 	
@@ -495,13 +493,13 @@
 	 * read the name itself until the buffer is allocated).
 	 */
-	if (!ipc_data_receive(&callid, &call, NULL, &name_size)) {
-		ipc_answer_fast(callid, EREFUSED, 0, 0);
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+	if (!ipc_data_receive(&callid, NULL, &name_size)) {
+		ipc_answer_0(callid, EREFUSED);
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	}
 
 	if (name_size > DEVMAP_NAME_MAXLEN) {
-		ipc_answer_fast(callid, EINVAL, 0, 0);
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	}
@@ -511,6 +509,6 @@
 	 */
 	if (NULL == (name = (char *)malloc(name_size))) {
-		ipc_answer_fast(callid, ENOMEM, 0, 0);
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+		ipc_answer_0(callid, ENOMEM);
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	}	
@@ -519,7 +517,6 @@
 	 * Send confirmation to sender and get data into buffer.
 	 */
-	if (EOK != (retval = ipc_data_deliver(callid, &call, name,
-	    name_size))) {
-		ipc_answer_fast(iid, EREFUSED, 0, 0);
+	if (EOK != (retval = ipc_data_deliver(callid, name, name_size))) {
+		ipc_answer_0(iid, EREFUSED);
 		return;
 	}
@@ -534,12 +531,12 @@
 	 */
 	if (NULL == dev) {
-		printf("DevMap: device %s has not been registered.\n", name);
-		ipc_answer_fast(iid, ENOENT, 0, 0);
-		return;
-	}
-
-	printf("DevMap: device %s has handler %d.\n", name, dev->handle);
+		printf("DEVMAP: device %s has not been registered.\n", name);
+		ipc_answer_0(iid, ENOENT);
+		return;
+	}
+
+	printf("DEVMAP: device %s has handler %d.\n", name, dev->handle);
 		
-	ipc_answer_fast(iid, EOK, dev->handle, 0);
+	ipc_answer_1(iid, EOK, dev->handle);
 
 	return;
@@ -560,9 +557,9 @@
 	 */
 	if (NULL == device) {
-		ipc_answer_fast(iid, ENOENT, 0, 0);
+		ipc_answer_0(iid, ENOENT);
 		return;
 	}	
 
-	ipc_answer_fast(iid, EOK, 0, 0);
+	ipc_answer_0(iid, EOK);
 
 	name_size = strlen(device->name);
@@ -570,5 +567,5 @@
 
 /*	FIXME:
-	we have no channel from DevMap to client -> 
+	we have no channel from DEVMAP to client -> 
 	sending must be initiated by client
 
@@ -595,10 +592,10 @@
 	devmap_driver_t *driver = NULL; 
 
-	ipc_answer_fast(iid, EOK, 0, 0); 
+	ipc_answer_0(iid, EOK); 
 
 	devmap_driver_register(&driver);
 
 	if (NULL == driver) {
-		printf("DevMap: driver registration failed.\n");
+		printf("DEVMAP: driver registration failed.\n");
 		return;
 	}
@@ -609,14 +606,14 @@
  		switch (IPC_GET_METHOD(call)) {
 		case IPC_M_PHONE_HUNGUP:
-			printf("DevMap: connection hung up.\n");
+			printf("DEVMAP: connection hung up.\n");
 			cont = false;
 			continue; /* Exit thread */
 		case DEVMAP_DRIVER_UNREGISTER:
-			printf("DevMap: unregister driver.\n");
+			printf("DEVMAP: unregister driver.\n");
 			if (NULL == driver) {
-				printf("DevMap: driver was not registered!\n");
-				ipc_answer_fast(callid, ENOENT, 0, 0);
+				printf("DEVMAP: driver was not registered!\n");
+				ipc_answer_0(callid, ENOENT);
 			} else {
-				ipc_answer_fast(callid, EOK, 0, 0);
+				ipc_answer_0(callid, EOK);
 			}
 			break;
@@ -637,5 +634,5 @@
 		default:
 			if (!(callid & IPC_CALLID_NOTIFICATION)) {
-				ipc_answer_fast(callid, ENOENT, 0, 0);
+				ipc_answer_0(callid, ENOENT);
 			}
 		}
@@ -643,7 +640,7 @@
 	
 	if (NULL != driver) {
-			/* 
-			 * Unregister the device driver and all its devices.
-			 */
+		/* 
+		 * Unregister the device driver and all its devices.
+		 */
 		devmap_driver_unregister(driver);
 		driver = NULL;
@@ -662,5 +659,5 @@
 	bool cont = true;
 
-	ipc_answer_fast(iid, EOK, 0, 0); /* Accept connection */
+	ipc_answer_0(iid, EOK); /* Accept connection */
 
 	while (cont) {
@@ -669,5 +666,5 @@
  		switch (IPC_GET_METHOD(call)) {
 		case IPC_M_PHONE_HUNGUP:
-			printf("DevMap: connection hung up.\n");
+			printf("DEVMAP: connection hung up.\n");
 			cont = false;
 			continue; /* Exit thread */
@@ -675,5 +672,5 @@
 		case DEVMAP_DEVICE_CONNECT_ME_TO:
 			/* Connect client to selected device */
-			printf("DevMap: connect to device %d.\n",
+			printf("DEVMAP: connect to device %d.\n",
 			    IPC_GET_ARG1(call));
 			devmap_forward(callid, &call);
@@ -690,5 +687,5 @@
 		default:
 			if (!(callid & IPC_CALLID_NOTIFICATION)) {
-				ipc_answer_fast(callid, ENOENT, 0, 0);
+				ipc_answer_0(callid, ENOENT);
 			}
 		}
@@ -703,5 +700,5 @@
 {
 
-	printf("DevMap: new connection.\n");
+	printf("DEVMAP: new connection.\n");
 
 		/* Select interface */
@@ -714,6 +711,6 @@
 		break;
 	default:
-		ipc_answer_fast(iid, ENOENT, 0, 0); /* No such interface */
-		printf("DevMap: Unknown interface %u.\n",
+		ipc_answer_0(iid, ENOENT); /* No such interface */
+		printf("DEVMAP: Unknown interface %u.\n",
 		    (ipcarg_t)(IPC_GET_ARG1(*icall)));
 	}
@@ -721,5 +718,5 @@
 	/* Cleanup */
 	
-	printf("DevMap: connection closed.\n");
+	printf("DEVMAP: connection closed.\n");
 	return;
 }
@@ -732,8 +729,8 @@
 	ipcarg_t phonead;
 
-	printf("DevMap: HelenOS device mapper.\n");
+	printf("DEVMAP: HelenOS device mapper.\n");
 
 	if (devmap_init() != 0) {
-		printf("Error while initializing DevMap service.\n");
+		printf("Error while initializing DEVMAP service.\n");
 		return -1;
 	}
Index: uspace/srv/fb/ega.c
===================================================================
--- uspace/srv/fb/ega.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/fb/ega.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -83,5 +83,5 @@
 	int i;
 	
-	for (i = 0; i < scr_width*scr_height; i++) {
+	for (i = 0; i < scr_width * scr_height; i++) {
 		scr_addr[i * 2] = ' ';
 		scr_addr[i * 2 + 1] = style;
@@ -126,11 +126,11 @@
 	if (rows > 0) {
 		memcpy(scr_addr, ((char *) scr_addr) + rows * scr_width * 2,
-			scr_width * scr_height * 2 - rows * scr_width * 2);
+		    scr_width * scr_height * 2 - rows * scr_width * 2);
 		for (i = 0; i < rows * scr_width; i++)
 			(((short *) scr_addr) + scr_width * scr_height - rows *
-				scr_width)[i] = ((style << 8) + ' ');
+			    scr_width)[i] = ((style << 8) + ' ');
 	} else if (rows < 0) {
 		memcpy(((char *)scr_addr) - rows * scr_width * 2, scr_addr,
-			scr_width * scr_height * 2 + rows * scr_width * 2);
+		    scr_width * scr_height * 2 + rows * scr_width * 2);
 		for (i = 0; i < -rows * scr_width; i++)
 			((short *)scr_addr)[i] = ((style << 8 ) + ' ');
@@ -153,5 +153,5 @@
 		scr_addr[i * 2] = data[i].character;
 		scr_addr[i * 2 + 1] = EGA_STYLE(data[i].style.fg_color,
-			data[i].style.bg_color);
+		    data[i].style.bg_color);
 	}
 }
@@ -161,5 +161,5 @@
 	int i;
 
-	for (i=0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++)
+	for (i = 0; (i < MAX_SAVED_SCREENS) && (saved_screens[i].data); i++)
 		;
 	if (i == MAX_SAVED_SCREENS) 
@@ -176,5 +176,5 @@
 	if (saved_screens[i].data)
 		memcpy(scr_addr, saved_screens[i].data, 2 * scr_width *
-			scr_height);
+		    scr_height);
 	else
 		return EINVAL;
@@ -196,9 +196,9 @@
 
 	if (client_connected) {
-		ipc_answer_fast(iid, ELIMIT, 0,0);
+		ipc_answer_0(iid, ELIMIT);
 		return;
 	}
 	client_connected = 1;
-	ipc_answer_fast(iid, 0, 0, 0); /* Accept connection */
+	ipc_answer_0(iid, EOK); /* Accept connection */
 
 	while (1) {
@@ -207,5 +207,5 @@
 		case IPC_M_PHONE_HUNGUP:
 			client_connected = 0;
-			ipc_answer_fast(callid, 0, 0, 0);
+			ipc_answer_0(callid, EOK);
 			return; /* Exit thread */
 		case IPC_M_AS_AREA_SEND:
@@ -213,7 +213,7 @@
 			intersize = IPC_GET_ARG2(call);
 			if (intersize >= scr_width * scr_height *
-				sizeof(*interbuf)) {
-				receive_comm_area(callid, &call, (void *)
-					&interbuf);
+			    sizeof(*interbuf)) {
+				receive_comm_area(callid, &call,
+				    (void *) &interbuf);
 				continue;
 			}
@@ -229,5 +229,5 @@
 			break;
 		case FB_GET_CSIZE:
-			ipc_answer_fast(callid, 0, scr_height, scr_width);
+			ipc_answer_2(callid, EOK, scr_height, scr_width);
 			continue;
 		case FB_CLEAR:
@@ -301,5 +301,5 @@
 			retval = ENOENT;
 		}
-		ipc_answer_fast(callid, retval, 0, 0);
+		ipc_answer_0(callid, retval);
 	}
 }
@@ -319,5 +319,5 @@
 
 	physmem_map(ega_ph_addr, scr_addr, ALIGN_UP(sz, PAGE_SIZE) >>
-		PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
+	    PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
 
 	async_set_client_connection(ega_client_connection);
Index: uspace/srv/fb/fb.c
===================================================================
--- uspace/srv/fb/fb.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/fb/fb.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -166,5 +166,5 @@
 {
 	*((uint32_t *) dst) = BLUE(rgb, 8) << 16 | GREEN(rgb, 8) << 8 |
-		RED(rgb, 8);
+	    RED(rgb, 8);
 }
 
@@ -174,5 +174,5 @@
 	int color = *(uint32_t *)(src);
 	return ((color & 0xff) << 16) | (((color >> 8) & 0xff) << 8) |
-		((color >> 16) & 0xff);
+	    ((color >> 16) & 0xff);
 }
 
@@ -209,5 +209,5 @@
 	/* 5-bit, 5-bits, 5-bits */ 
 	*((uint16_t *)(dst)) = RED(rgb, 5) << 10 | GREEN(rgb, 5) << 5 |
-		BLUE(rgb, 5);
+	    BLUE(rgb, 5);
 }
 
@@ -218,5 +218,5 @@
 	int color = *(uint16_t *)(src);
 	return (((color >> 10) & 0x1f) << (16 + 3)) |
-		(((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
+	    (((color >> 5) & 0x1f) << (8 + 3)) | ((color & 0x1f) << 3);
 }
 
@@ -227,5 +227,5 @@
 	/* 5-bit, 6-bits, 5-bits */ 
 	*((uint16_t *)(dst)) = RED(rgb, 5) << 11 | GREEN(rgb, 6) << 5 |
-		BLUE(rgb, 5);
+	    BLUE(rgb, 5);
 }
 
@@ -236,5 +236,5 @@
 	int color = *(uint16_t *)(src);
 	return (((color >> 11) & 0x1f) << (16 + 3)) |
-		(((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
+	    (((color >> 5) & 0x3f) << (8 + 2)) | ((color & 0x1f) << 3);
 }
 
@@ -252,5 +252,5 @@
 	int color = *(uint8_t *)src;
 	return (((color >> 5) & 0x7) << (16 + 5)) |
-		(((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
+	    (((color >> 3) & 0x3) << (8 + 6)) | ((color & 0x7) << 5);
 }
 
@@ -270,5 +270,5 @@
 	if (! (vport->paused && vport->dbdata))
 		(*screen.rgb2scr)(&screen.fbaddress[POINTPOS(dx,dy)],
-			COLOR(color));
+		    COLOR(color));
 
 	if (vport->dbdata) {
@@ -292,5 +292,5 @@
 putpixel_mem(char *mem, unsigned int x, unsigned int y, int color)
 {
-	(*screen.rgb2scr)(&mem[POINTPOS(x,y)], COLOR(color));
+	(*screen.rgb2scr)(&mem[POINTPOS(x, y)], COLOR(color));
 }
 
@@ -303,5 +303,5 @@
 
 	if (!tmpline)
-		tmpline = malloc(screen.scanline*screen.pixelbytes);
+		tmpline = malloc(screen.scanline * screen.pixelbytes);
 
 	/* Clear first line */
@@ -316,5 +316,5 @@
 		for (y = sy;y < sy+height; y++)
 			memcpy(&screen.fbaddress[POINTPOS(sx,y)], tmpline, 
-			       screen.pixelbytes * width);
+			    screen.pixelbytes * width);
 	}
 	if (vport->dbdata) {
@@ -322,7 +322,7 @@
 			int rline = (y + vport->dboffset) % vport->height;
 			int rpos = (rline * vport->width + sx) *
-				screen.pixelbytes;
+			    screen.pixelbytes;
 			memcpy(&vport->dbdata[rpos], tmpline,
-				screen.pixelbytes * width);
+			    screen.pixelbytes * width);
 		}
 	}
@@ -335,5 +335,5 @@
 {
 	draw_rectangle(vport, 0, 0, vport->width, vport->height,
-		vport->style.bg_color);
+	    vport->style.bg_color);
 }
 
@@ -351,17 +351,16 @@
 		for (y = vport->y; y < vport->y+vport->height - lines; y++)
 			memcpy(&screen.fbaddress[POINTPOS(vport->x,y)],
-			       &screen.fbaddress[POINTPOS(vport->x,y + lines)],
-			       screen.pixelbytes * vport->width);
+			    &screen.fbaddress[POINTPOS(vport->x,y + lines)],
+			    screen.pixelbytes * vport->width);
 		draw_rectangle(vport, 0, vport->height - lines, vport->width,
-			lines, vport->style.bg_color);
+		    lines, vport->style.bg_color);
 	} else if (lines < 0) {
 		lines = -lines;
-		for (y = vport->y + vport->height-1; y >= vport->y + lines;
-			 y--)
+		for (y = vport->y + vport->height-1; y >= vport->y + lines; y--)
 			memcpy(&screen.fbaddress[POINTPOS(vport->x,y)],
-			       &screen.fbaddress[POINTPOS(vport->x,y - lines)],
-			       screen.pixelbytes * vport->width);
+			    &screen.fbaddress[POINTPOS(vport->x,y - lines)],
+			    screen.pixelbytes * vport->width);
 		draw_rectangle(vport, 0, 0, vport->width, lines,
-			vport->style.bg_color);
+		    vport->style.bg_color);
 	}
 }
@@ -381,6 +380,5 @@
 
 		memcpy(&screen.fbaddress[POINTPOS(dstx,dsty)],
-		       &vport->dbdata[srcoff], 
-		       vport->width*screen.pixelbytes);
+		    &vport->dbdata[srcoff], vport->width * screen.pixelbytes);
 	}
 }
@@ -393,12 +391,11 @@
 	if (lines > 0) {
 		draw_rectangle(vport, 0, 0, vport->width, lines,
-			       vport->style.bg_color);
+		    vport->style.bg_color);
 		vport->dboffset += lines;
 		vport->dboffset %= vport->height;
 	} else if (lines < 0) {
 		lines = -lines;
-		draw_rectangle(vport, 0, vport->height-lines, 
-			       vport->width, lines,
-			       vport->style.bg_color);
+		draw_rectangle(vport, 0, vport->height-lines, vport->width,
+		    lines, vport->style.bg_color);
 
 		if (vport->dboffset < lines)
@@ -442,6 +439,6 @@
  */
 static void
-draw_glyph(viewport_t *vport,uint8_t glyph, unsigned int sx,
-	 unsigned int sy, style_t style, int transparent)
+draw_glyph(viewport_t *vport,uint8_t glyph, unsigned int sx, unsigned int sy,
+    style_t style, int transparent)
 {
 	int i;
@@ -453,9 +450,7 @@
 		for (i = 0; i < 8; i++) {
 			if (glline & (1 << (7 - i)))
-				putpixel(vport, sx + i, sy + y,
-					style.fg_color);
+				putpixel(vport, sx + i, sy + y, style.fg_color);
 			else if (!transparent)
-				putpixel(vport, sx + i, sy + y,
-					style.bg_color);
+				putpixel(vport, sx + i, sy + y, style.bg_color);
 		}
 	}
@@ -472,5 +467,5 @@
 		for (y = 0; y < FONT_SCANLINES; y++)
 			invert_pixel(vport, col * COL_WIDTH + x, row *
-				FONT_SCANLINES + y);
+			    FONT_SCANLINES + y);
 }
 
@@ -631,5 +626,5 @@
 	
 	draw_glyph(vport, c, col * COL_WIDTH, row * FONT_SCANLINES, style,
-		transparent);
+	    transparent);
 
 	vport->cur_col = col;
@@ -660,11 +655,11 @@
 	for (i = 0; i < vport->cols * vport->rows; i++) {
 		if (data[i].character == ' ' && style_same(data[i].style,
-			vport->style))
+		    vport->style))
 			continue;
 		col = i % vport->cols;
 		row = i / vport->cols;
 		draw_glyph(vport, data[i].character, col * COL_WIDTH, row *
-			FONT_SCANLINES, data[i].style,
-			style_same(data[i].style,vport->style));
+		    FONT_SCANLINES, data[i].style, style_same(data[i].style,
+		    vport->style));
 	}
 	cursor_print(vport);
@@ -712,5 +707,5 @@
 
 	ppm_draw(shm, size, 0, 0, pmap->width, pmap->height, 
-		 (putpixel_cb_t)putpixel_pixmap, (void *)pm);
+	    (putpixel_cb_t)putpixel_pixmap, (void *)pm);
 
 	return pm;
@@ -758,5 +753,5 @@
 			void *dest = as_get_mappable_page(IPC_GET_ARG2(*call));
 			shm_size = IPC_GET_ARG2(*call);
-			if (!ipc_answer_fast(callid, 0, (sysarg_t) dest, 0)) 
+			if (!ipc_answer_1(callid, EOK, (sysarg_t) dest)) 
 				shm = dest;
 			else
@@ -806,6 +801,6 @@
 		
 		ppm_draw(shm, shm_size, IPC_GET_ARG1(*call),
-			IPC_GET_ARG2(*call), vport->width - x,
-			vport->height - y, (putpixel_cb_t)putpixel, vport);
+		    IPC_GET_ARG2(*call), vport->width - x, vport->height - y,
+		    (putpixel_cb_t)putpixel, vport);
 		break;
 	case FB_DRAW_TEXT_DATA:
@@ -815,5 +810,5 @@
 		}
 		if (intersize < vport->cols * vport->rows *
-			sizeof(*interbuffer)) {
+		    sizeof(*interbuffer)) {
 			retval = EINVAL;
 			break;
@@ -826,5 +821,5 @@
 	
 	if (handled)
-		ipc_answer_fast(callid, retval, 0, 0);
+		ipc_answer_0(callid, retval);
 	return handled;
 }
@@ -852,7 +847,7 @@
 	for (y = 0; y < realheight; y++) {
 		tmp = (vport->y + y) * screen.scanline +
-			vport->x * screen.pixelbytes;
+		    vport->x * screen.pixelbytes;
 		memcpy(pmap->data + srcrowsize * y, screen.fbaddress + tmp,
-			realrowsize); 
+		    realrowsize); 
 	}
 }
@@ -913,7 +908,7 @@
 	for (y = 0; y < realheight; y++) {
 		tmp = (vport->y + y) * screen.scanline + 
-			vport->x * screen.pixelbytes;
+		    vport->x * screen.pixelbytes;
 		memcpy(screen.fbaddress + tmp, pmap->data + y * srcrowsize,
-			realrowsize);
+		    realrowsize);
 	}
 	return 0;
@@ -934,10 +929,10 @@
 	for (i = 0; i < MAX_ANIMATIONS; i++) {
 		if (!animations[i].animlen || !animations[i].initialized ||
-			!animations[i].enabled)
+		    !animations[i].enabled)
 			continue;
 		draw_pixmap(animations[i].vp,
-			animations[i].pixmaps[animations[i].pos]);
+		    animations[i].pixmaps[animations[i].pos]);
 		animations[i].pos = (animations[i].pos + 1) %
-			animations[i].animlen;
+		    animations[i].animlen;
 	}
 }
@@ -963,5 +958,5 @@
 	if (pointer_vport == -1) {
 		pointer_vport = viewport_create(pointer_x, pointer_y,
-			pointer_width, pointer_height);
+		    pointer_width, pointer_height);
 		if (pointer_vport < 0)
 			return;
@@ -975,5 +970,5 @@
 	else
 		copy_vp_to_pixmap(&viewports[pointer_vport],
-			&pixmaps[pointer_pixmap]);
+		    &pixmaps[pointer_pixmap]);
 
 	/* Draw cursor */
@@ -982,12 +977,12 @@
 			bytepos = i * ((pointer_width - 1) / 8 + 1) + j / 8;
 			visibility = pointer_mask_bits[bytepos] &
-				(1 << (j % 8));
+			    (1 << (j % 8));
 			if (visibility) {
-				color = pointer_bits[bytepos] & (1 << (j % 8))
-					? 0 : 0xffffff;
+				color = pointer_bits[bytepos] &
+				    (1 << (j % 8)) ? 0 : 0xffffff;
 				if (pointer_x + j < screen.xres && pointer_y +
-					i < screen.yres)
+				    i < screen.yres)
 					putpixel(&viewports[0], pointer_x + j,
-						pointer_y + i, color);
+					    pointer_y + i, color);
 			}
 		}
@@ -1107,5 +1102,5 @@
 	}
 	if (handled)
-		ipc_answer_fast(callid, retval, 0, 0);
+		ipc_answer_0(callid, retval);
 	return handled;
 }
@@ -1158,5 +1153,5 @@
 
 	if (handled)
-		ipc_answer_fast(callid, retval, 0, 0);
+		ipc_answer_0(callid, retval);
 	return handled;
 	
@@ -1180,9 +1175,9 @@
 
 	if (client_connected) {
-		ipc_answer_fast(iid, ELIMIT, 0,0);
+		ipc_answer_0(iid, ELIMIT);
 		return;
 	}
 	client_connected = 1;
-	ipc_answer_fast(iid, 0, 0, 0); /* Accept connection */
+	ipc_answer_0(iid, EOK); /* Accept connection */
 
 	while (1) {
@@ -1223,8 +1218,8 @@
 				break;
 			}
-			ipc_answer_fast(callid, 0, 0, 0);
+			ipc_answer_0(callid, EOK);
 
 			draw_char(vport, c, row, col, vport->style,
-				IPC_GET_METHOD(call) == FB_TRANS_PUTCHAR);
+			    IPC_GET_METHOD(call) == FB_TRANS_PUTCHAR);
 			continue; /* msg already answered */
 		case FB_CLEAR:
@@ -1253,5 +1248,5 @@
 			break;
 		case FB_GET_CSIZE:
-			ipc_answer_fast(callid, 0, vport->rows, vport->cols);
+			ipc_answer_2(callid, EOK, vport->rows, vport->cols);
 			continue;
 		case FB_SCROLL:
@@ -1275,5 +1270,5 @@
 				break;
 			}
-			if (! viewports[i].initialized ) {
+			if (!viewports[i].initialized ) {
 				retval = EADDRNOTAVAIL;
 				break;
@@ -1281,9 +1276,9 @@
 			viewports[i].dboffset = 0;
 			if (IPC_GET_ARG2(call) == 1 && !viewports[i].dbdata)
-				viewports[i].dbdata = malloc(screen.pixelbytes
-					* viewports[i].width *
-					viewports[i].height);
+				viewports[i].dbdata =
+				    malloc(screen.pixelbytes *
+				    viewports[i].width * viewports[i].height);
 			else if (IPC_GET_ARG2(call) == 0 &&
-				viewports[i].dbdata) {
+			    viewports[i].dbdata) {
 				free(viewports[i].dbdata);
 				viewports[i].dbdata = NULL;
@@ -1309,7 +1304,7 @@
 		case FB_VIEWPORT_CREATE:
 			retval = viewport_create(IPC_GET_ARG1(call) >> 16,
-				IPC_GET_ARG1(call) & 0xffff,
-				IPC_GET_ARG2(call) >> 16,
-				IPC_GET_ARG2(call) & 0xffff);
+			    IPC_GET_ARG1(call) & 0xffff,
+			    IPC_GET_ARG2(call) >> 16,
+			    IPC_GET_ARG2(call) & 0xffff);
 			break;
 		case FB_VIEWPORT_DELETE:
@@ -1336,5 +1331,5 @@
 			break;
 		case FB_GET_RESOLUTION:
-			ipc_answer_fast(callid, 0, screen.xres,screen.yres);
+			ipc_answer_2(callid, EOK, screen.xres, screen.yres);
 			continue;
 		case FB_POINTER_MOVE:
@@ -1346,5 +1341,5 @@
 			retval = ENOENT;
 		}
-		ipc_answer_fast(callid,retval, 0, 0);
+		ipc_answer_0(callid, retval);
 	}
 }
@@ -1376,8 +1371,8 @@
 	
 	physmem_map(fb_ph_addr, fb_addr, ALIGN_UP(asz, PAGE_SIZE) >>
-		PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
+	    PAGE_WIDTH, AS_AREA_READ | AS_AREA_WRITE);
 
 	if (screen_init(fb_addr, fb_width, fb_height, fb_scanline, fb_visual,
-		fb_invert_colors))
+	    fb_invert_colors))
 		return 0;
 	
Index: uspace/srv/fb/main.c
===================================================================
--- uspace/srv/fb/main.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/fb/main.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -45,5 +45,5 @@
 
 	dest = as_get_mappable_page(IPC_GET_ARG2(*call));
-	if (ipc_answer_fast(callid, 0, (sysarg_t) dest, 0) == 0) {
+	if (ipc_answer_1(callid, EOK, (sysarg_t) dest) == 0) {
 		if (*area)
 			as_area_destroy(*area);
Index: uspace/srv/fb/sysio.c
===================================================================
--- uspace/srv/fb/sysio.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/fb/sysio.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -118,67 +118,67 @@
 
 	if (client_connected) {
-		ipc_answer_fast(iid, ELIMIT, 0,0);
+		ipc_answer_0(iid, ELIMIT);
 		return;
 	}
 	
 	client_connected = 1;
-	ipc_answer_fast(iid, 0, 0, 0); /* Accept connection */
+	ipc_answer_0(iid, EOK); /* Accept connection */
 	while (1) {
 		callid = async_get_call(&call);
 		switch (IPC_GET_METHOD(call)) {
-			case IPC_M_PHONE_HUNGUP:
-				client_connected = 0;
-				ipc_answer_fast(callid, 0, 0, 0);
-				return; /* Exit thread */
-			case FB_PUTCHAR:
-				c = IPC_GET_ARG1(call);
-				newrow = IPC_GET_ARG2(call);
-				newcol = IPC_GET_ARG3(call);
-				if ((lastcol != newcol) || (lastrow != newrow))
-					curs_goto(newrow, newcol);
-				lastcol = newcol + 1;
-				lastrow = newrow;
-				sysput(c);
-				retval = 0;
+		case IPC_M_PHONE_HUNGUP:
+			client_connected = 0;
+			ipc_answer_0(callid, EOK);
+			return; /* Exit thread */
+		case FB_PUTCHAR:
+			c = IPC_GET_ARG1(call);
+			newrow = IPC_GET_ARG2(call);
+			newcol = IPC_GET_ARG3(call);
+			if ((lastcol != newcol) || (lastrow != newrow))
+				curs_goto(newrow, newcol);
+			lastcol = newcol + 1;
+			lastrow = newrow;
+			sysput(c);
+			retval = 0;
+			break;
+		case FB_CURSOR_GOTO:
+			newrow = IPC_GET_ARG1(call);
+			newcol = IPC_GET_ARG2(call);
+			curs_goto(newrow, newcol);
+			lastrow = newrow;
+			lastcol = newcol;
+			retval = 0;
+			break;
+		case FB_GET_CSIZE:
+			ipc_answer_2(callid, EOK, HEIGHT, WIDTH);
+			continue;
+		case FB_CLEAR:
+			clrscr();
+			retval = 0;
+			break;
+		case FB_SET_STYLE:
+			fgcolor = IPC_GET_ARG1(call);
+			bgcolor = IPC_GET_ARG2(call);
+			if (fgcolor < bgcolor)
+				set_style(0);
+			else
+				set_style(7);
+			retval = 0;
+			break;
+		case FB_SCROLL:
+			i = IPC_GET_ARG1(call);
+			if ((i > HEIGHT) || (i < -HEIGHT)) {
+				retval = EINVAL;
 				break;
-			case FB_CURSOR_GOTO:
-				newrow = IPC_GET_ARG1(call);
-				newcol = IPC_GET_ARG2(call);
-				curs_goto(newrow, newcol);
-				lastrow = newrow;
-				lastcol = newcol;
-				retval = 0;
-				break;
-			case FB_GET_CSIZE:
-				ipc_answer_fast(callid, 0, HEIGHT, WIDTH);
-				continue;
-			case FB_CLEAR:
-				clrscr();
-				retval = 0;
-				break;
-			case FB_SET_STYLE:
-				fgcolor = IPC_GET_ARG1(call);
-				bgcolor = IPC_GET_ARG2(call);
-				if (fgcolor < bgcolor)
-					set_style(0);
-				else
-					set_style(7);
-				retval = 0;
-				break;
-			case FB_SCROLL:
-				i = IPC_GET_ARG1(call);
-				if ((i > HEIGHT) || (i < -HEIGHT)) {
-					retval = EINVAL;
-					break;
-				}
-				scroll(i);
-				curs_goto(lastrow, lastcol);
-				retval = 0;
-				break;
-			default:
-				retval = ENOENT;
+			}
+			scroll(i);
+			curs_goto(lastrow, lastcol);
+			retval = 0;
+			break;
+		default:
+			retval = ENOENT;
 		}
 		
-		ipc_answer_fast(callid, retval, 0, 0);
+		ipc_answer_0(callid, retval);
 	}
 }
Index: uspace/srv/fs/fat/fat.c
===================================================================
--- uspace/srv/fs/fat/fat.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/fs/fat/fat.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -94,5 +94,5 @@
 		 * created by IPC_M_CONNECT_TO_ME.
 		 */
-		ipc_answer_fast_0(iid, EOK);
+		ipc_answer_0(iid, EOK);
 	}
 	
@@ -105,5 +105,5 @@
 		switch  (IPC_GET_METHOD(call)) {
 		default:
-			ipc_answer_fast_0(callid, ENOTSUP);
+			ipc_answer_0(callid, ENOTSUP);
 			break;
 		}
Index: uspace/srv/kbd/generic/kbd.c
===================================================================
--- uspace/srv/kbd/generic/kbd.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/kbd/generic/kbd.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -69,5 +69,8 @@
 
 	if (cons_connected && phone2cons != -1) {
-		/* recode to ASCII - one interrupt can produce more than one code so result is stored in fifo */
+		/*
+		 * recode to ASCII - one interrupt can produce more than one
+		 * code so result is stored in fifo
+		 */
 		while (!keybuffer_empty(&keybuffer)) {
 			if (!keybuffer_pop(&keybuffer, (int *)&chr))
@@ -86,9 +89,9 @@
 
 	if (cons_connected) {
-		ipc_answer_fast(iid, ELIMIT, 0, 0);
+		ipc_answer_0(iid, ELIMIT);
 		return;
 	}
 	cons_connected = 1;
-	ipc_answer_fast(iid, 0, 0, 0);
+	ipc_answer_0(iid, EOK);
 
 	while (1) {
@@ -99,5 +102,5 @@
 			ipc_hangup(phone2cons);
 			phone2cons = -1;
-			ipc_answer_fast(callid, 0,0,0);
+			ipc_answer_0(callid, EOK);
 			return;
 		case IPC_M_CONNECT_TO_ME:
@@ -112,5 +115,5 @@
 			retval = EINVAL;
 		}
-		ipc_answer_fast(callid, retval, 0, 0);
+		ipc_answer_0(callid, retval);
 	}	
 }
Index: uspace/srv/ns/ns.c
===================================================================
--- uspace/srv/ns/ns.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/ns/ns.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -93,5 +93,5 @@
 		ph_addr = (void *) sysinfo_value(name);
 		if (!ph_addr) {
-			ipc_answer_fast_0(callid, ENOENT);
+			ipc_answer_0(callid, ENOENT);
 			return;
 		}
@@ -100,5 +100,5 @@
 		    AS_AREA_READ | AS_AREA_CACHEABLE);
 	}
-	ipc_answer_fast(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ);
+	ipc_answer_2(callid, EOK, (ipcarg_t) *addr, AS_AREA_READ);
 }
 
@@ -129,5 +129,5 @@
 				break;
 			default:
-				ipc_answer_fast_0(callid, ENOENT);
+				ipc_answer_0(callid, ENOENT);
 			}
 			continue;
@@ -154,5 +154,5 @@
 		}
 		if (!(callid & IPC_CALLID_NOTIFICATION)) {
-			ipc_answer_fast_0(callid, retval);
+			ipc_answer_0(callid, retval);
 		}
 	}
Index: uspace/srv/pci/pci.c
===================================================================
--- uspace/srv/pci/pci.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/pci/pci.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -67,15 +67,15 @@
 		ipc_call_t call;
 		ipc_callid_t callid;
+		ipcarg_t retval = ENOTSUP;
 
 		callid = ipc_wait_for_call(&call);
 		switch(IPC_GET_METHOD(call)) {
 		case IPC_M_CONNECT_ME_TO:
-			IPC_SET_RETVAL(call, 0);
+			retval = EOK;
 			break;
 		}
-		if (! (callid & IPC_CALLID_NOTIFICATION)) {
-			ipc_answer(callid, &call);
-		}
-		printf("%s: received call from %lX\n", NAME, call.in_phone_hash);
+		ipc_answer_0(callid, retval);
+		printf("%s: received call from %lX\n", NAME,
+		    call.in_phone_hash);
 	}
 
Index: uspace/srv/rd/rd.c
===================================================================
--- uspace/srv/rd/rd.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/rd/rd.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -91,5 +91,5 @@
 		 * This is the answer to the call that opened the connection.
 		 */
-		ipc_answer_fast(iid, EHANGUP, 0, 0);
+		ipc_answer_0(iid, EHANGUP);
 		return;
 	} else {
@@ -98,5 +98,5 @@
 		 * Return supported block size as ARG1.
 		 */
-		ipc_answer_fast(iid, EOK, BLOCK_SIZE, 0);
+		ipc_answer_1(iid, EOK, BLOCK_SIZE);
 	}
 
@@ -111,5 +111,5 @@
 			 * block.
 			 */
-			ipc_answer_fast(callid, EOK, (uintptr_t) fs_va, 0);
+			ipc_answer_1(callid, EOK, (uintptr_t) fs_va);
 		} else {
 			/*
@@ -117,5 +117,5 @@
 			 * Close the connection.
 			 */
-			ipc_answer_fast(callid, EHANGUP, 0, 0);
+			ipc_answer_0(callid, EHANGUP);
 			return;		
 		}
@@ -126,5 +126,5 @@
 		 * Close the connection.
 		 */
-		ipc_answer_fast(callid, EHANGUP, 0, 0);
+		ipc_answer_0(callid, EHANGUP);
 		return;
 	}
@@ -138,5 +138,5 @@
 			 * Answer the message and exit the fibril.
 			 */
-			ipc_answer_fast(callid, EOK, 0, 0);
+			ipc_answer_0(callid, EOK);
 			return;
 		case RD_READ_BLOCK:
@@ -178,5 +178,5 @@
 			break;
 		}
-		ipc_answer_fast(callid, retval, 0, 0);
+		ipc_answer_0(callid, retval);
 	}
 }
Index: uspace/srv/vfs/vfs.c
===================================================================
--- uspace/srv/vfs/vfs.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/vfs/vfs.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -60,5 +60,5 @@
 	 * This call needs to be answered.
 	 */
-	ipc_answer_fast_0(iid, EOK);
+	ipc_answer_0(iid, EOK);
 
 	/*
@@ -104,5 +104,5 @@
 		case VFS_RENAME:
 		default:
-			ipc_answer_fast_0(callid, ENOTSUP);
+			ipc_answer_0(callid, ENOTSUP);
 			break;
 		}
Index: uspace/srv/vfs/vfs_mount.c
===================================================================
--- uspace/srv/vfs/vfs_mount.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/vfs/vfs_mount.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -85,9 +85,8 @@
 	 */
 	ipc_callid_t callid;
-	ipc_call_t call;
 	size_t size;
-	if (!ipc_data_receive(&callid, &call, NULL, &size)) {
-		ipc_answer_fast_0(callid, EINVAL);
-		ipc_answer_fast_0(rid, EINVAL);
+	if (!ipc_data_receive(&callid, NULL, &size)) {
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(rid, EINVAL);
 		return;
 	}
@@ -100,6 +99,6 @@
 	if ((size < FS_NAME_MAXLEN + 1) ||
 	    (size > FS_NAME_MAXLEN + MAX_PATH_LEN)) {
-		ipc_answer_fast_0(callid, EINVAL);
-		ipc_answer_fast_0(rid, EINVAL);
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(rid, EINVAL);
 		return;
 	}
@@ -111,6 +110,6 @@
 	buf = malloc(size);
 	if (!buf) {
-		ipc_answer_fast_0(callid, ENOMEM);
-		ipc_answer_fast_0(rid, ENOMEM);
+		ipc_answer_0(callid, ENOMEM);
+		ipc_answer_0(rid, ENOMEM);
 		return;
 	}
@@ -119,5 +118,5 @@
 	 * Deliver the data.
 	 */
-	(void) ipc_data_deliver(callid, &call, buf, size);
+	(void) ipc_data_deliver(callid, buf, size);
 
 	char fs_name[FS_NAME_MAXLEN + 1];
@@ -132,5 +131,5 @@
 	if (!fs_handle) {
 		free(buf);
-		ipc_answer_fast_0(rid, ENOENT);
+		ipc_answer_0(rid, ENOENT);
 		return;
 	}
@@ -147,5 +146,5 @@
 	if (rc != EOK) {
 		free(buf);
-		ipc_answer_fast_0(rid, rc);
+		ipc_answer_0(rid, rc);
 		return;
 	}
@@ -153,5 +152,5 @@
 	if (!mr_node) {
 		free(buf);
-		ipc_answer_fast_0(rid, ENOMEM);
+		ipc_answer_0(rid, ENOMEM);
 		return;
 	}
@@ -177,5 +176,5 @@
 			vfs_node_put(mr_node);	/* failed -> drop reference */
 			free(buf);
-			ipc_answer_fast_0(rid, rc);
+			ipc_answer_0(rid, rc);
 			return;
 		}
@@ -186,5 +185,5 @@
 			vfs_node_put(mr_node);	/* failed -> drop reference */
 			free(buf);
-			ipc_answer_fast_0(rid, ENOMEM);
+			ipc_answer_0(rid, ENOMEM);
 			return;
 		}
@@ -207,5 +206,5 @@
 			futex_up(&rootfs_futex);
 			free(buf);
-			ipc_answer_fast_0(rid, EOK);
+			ipc_answer_0(rid, EOK);
 			return;
 		} else {
@@ -217,5 +216,5 @@
 			free(buf);
 			vfs_node_put(mr_node);	/* failed -> drop reference */
-			ipc_answer_fast_0(rid, ENOENT);
+			ipc_answer_0(rid, ENOENT);
 			return;
 		}
@@ -255,9 +254,9 @@
 	
 	if (rc2 == EOK)
-		ipc_answer_fast_0(rid, rc1);
+		ipc_answer_0(rid, rc1);
 	else if (rc1 == EOK)
-		ipc_answer_fast_0(rid, rc2);
+		ipc_answer_0(rid, rc2);
 	else
-		ipc_answer_fast_0(rid, rc1);
+		ipc_answer_0(rid, rc1);
 }
 
Index: uspace/srv/vfs/vfs_open.c
===================================================================
--- uspace/srv/vfs/vfs_open.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/vfs/vfs_open.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -47,5 +47,5 @@
 {
 	if (!vfs_files_init()) {
-		ipc_answer_fast_0(rid, ENOMEM);
+		ipc_answer_0(rid, ENOMEM);
 		return;
 	}
@@ -61,9 +61,8 @@
 
 	ipc_callid_t callid;
-	ipc_call_t call;
 
-	if (!ipc_data_receive(&callid, &call, NULL, &size)) {
-		ipc_answer_fast_0(callid, EINVAL);
-		ipc_answer_fast_0(rid, EINVAL);
+	if (!ipc_data_receive(&callid, NULL, &size)) {
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(rid, EINVAL);
 		return;
 	}
@@ -78,12 +77,12 @@
 	
 	if (!path) {
-		ipc_answer_fast_0(callid, ENOMEM);
-		ipc_answer_fast_0(rid, ENOMEM);
+		ipc_answer_0(callid, ENOMEM);
+		ipc_answer_0(rid, ENOMEM);
 		return;
 	}
 
 	int rc;
-	if ((rc = ipc_data_deliver(callid, &call, path, size))) {
-		ipc_answer_fast_0(rid, rc);
+	if ((rc = ipc_data_deliver(callid, path, size))) {
+		ipc_answer_0(rid, rc);
 		free(path);
 		return;
@@ -104,5 +103,5 @@
 	if (rc) {
 		futex_up(&unlink_futex);
-		ipc_answer_fast_0(rid, rc);
+		ipc_answer_0(rid, rc);
 		free(path);
 		return;
@@ -124,5 +123,5 @@
 	if (fd < 0) {
 		vfs_node_put(node);
-		ipc_answer_fast_0(rid, fd);
+		ipc_answer_0(rid, fd);
 		return;
 	}
@@ -143,5 +142,5 @@
 	 * Success! Return the new file descriptor to the client.
 	 */
-	ipc_answer_fast_1(rid, EOK, fd);
+	ipc_answer_1(rid, EOK, fd);
 }
 
Index: uspace/srv/vfs/vfs_register.c
===================================================================
--- uspace/srv/vfs/vfs_register.c	(revision 32099239a6124d59220f89570e99659141d22ed7)
+++ uspace/srv/vfs/vfs_register.c	(revision b74959bd4f5b3c25215165e16f18a594cc56d741)
@@ -156,11 +156,11 @@
 	 * VFS info structure from the client FS.
 	 */
-	if (!ipc_data_receive(&callid, &call, NULL, &size)) {
+	if (!ipc_data_receive(&callid, NULL, &size)) {
 		/*
 		 * The client doesn't obey the same protocol as we do.
 		 */
 		dprintf("Receiving of VFS info failed.\n");
-		ipc_answer_fast_0(callid, EINVAL);
-		ipc_answer_fast_0(rid, EINVAL);
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(rid, EINVAL);
 		return;
 	}
@@ -178,6 +178,6 @@
 		 */
 		dprintf("Received VFS info has bad size.\n");
-		ipc_answer_fast_0(callid, EINVAL);
-		ipc_answer_fast_0(rid, EINVAL);
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(rid, EINVAL);
 		return;
 	}
@@ -190,17 +190,17 @@
 	if (!fs_info) {
 		dprintf("Could not allocate memory for FS info.\n");
-		ipc_answer_fast_0(callid, ENOMEM);
-		ipc_answer_fast_0(rid, ENOMEM);
+		ipc_answer_0(callid, ENOMEM);
+		ipc_answer_0(rid, ENOMEM);
 		return;
 	}
 	link_initialize(&fs_info->fs_link);
 		
-	rc = ipc_data_deliver(callid, &call, &fs_info->vfs_info, size);
+	rc = ipc_data_deliver(callid, &fs_info->vfs_info, size);
 	if (rc != EOK) {
 		dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
 		    rc);
 		free(fs_info);
-		ipc_answer_fast_0(callid, rc);
-		ipc_answer_fast_0(rid, rc);
+		ipc_answer_0(callid, rc);
+		ipc_answer_0(rid, rc);
 		return;
 	}
@@ -210,6 +210,6 @@
 	if (!vfs_info_sane(&fs_info->vfs_info)) {
 		free(fs_info);
-		ipc_answer_fast_0(callid, EINVAL);
-		ipc_answer_fast_0(rid, EINVAL);
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(rid, EINVAL);
 		return;
 	}
@@ -227,6 +227,6 @@
 		futex_up(&fs_head_futex);
 		free(fs_info);
-		ipc_answer_fast_0(callid, EEXISTS);
-		ipc_answer_fast_0(rid, EEXISTS);
+		ipc_answer_0(callid, EEXISTS);
+		ipc_answer_0(rid, EEXISTS);
 		return;
 	}
@@ -249,10 +249,10 @@
 		futex_up(&fs_head_futex);
 		free(fs_info);
-		ipc_answer_fast_0(callid, EINVAL);
-		ipc_answer_fast_0(rid, EINVAL);
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(rid, EINVAL);
 		return;
 	}
 	fs_info->phone = IPC_GET_ARG3(call);
-	ipc_answer_fast_0(callid, EOK);
+	ipc_answer_0(callid, EOK);
 
 	dprintf("Callback connection to FS created.\n");
@@ -268,6 +268,6 @@
 		ipc_hangup(fs_info->phone);
 		free(fs_info);
-		ipc_answer_fast_0(callid, EINVAL);
-		ipc_answer_fast_0(rid, EINVAL);
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(rid, EINVAL);
 		return;
 	}
@@ -283,6 +283,6 @@
 		ipc_hangup(fs_info->phone);
 		free(fs_info);
-		ipc_answer_fast_0(callid, EINVAL);
-		ipc_answer_fast_0(rid, EINVAL);
+		ipc_answer_0(callid, EINVAL);
+		ipc_answer_0(rid, EINVAL);
 		return;
 	}
@@ -291,5 +291,5 @@
 	 * Commit to read-only sharing the PLB with the client.
 	 */
-	ipc_answer_fast(callid, EOK, (ipcarg_t) plb,
+	ipc_answer_2(callid, EOK, (ipcarg_t) plb,
 	    (ipcarg_t) (AS_AREA_READ | AS_AREA_CACHEABLE));	
 
@@ -302,5 +302,5 @@
 	 */
 	fs_info->fs_handle = (int) atomic_postinc(&fs_handle_next);
-	ipc_answer_fast_1(rid, EOK, (ipcarg_t) fs_info->fs_handle);
+	ipc_answer_1(rid, EOK, (ipcarg_t) fs_info->fs_handle);
 	
 	futex_up(&fs_head_futex);