Index: uspace/app/klog/klog.c
===================================================================
--- uspace/app/klog/klog.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/app/klog/klog.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -74,5 +74,5 @@
 	}
 	
-	int res = ipc_share_in_start_1_0(PHONE_NS, (void *) klog,
+	int res = async_share_in_start_1_0(PHONE_NS, (void *) klog,
 	    klog_size, SERVICE_MEM_KLOG);
 	if (res != EOK) {
Index: uspace/lib/libblock/libblock.c
===================================================================
--- uspace/lib/libblock/libblock.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/lib/libblock/libblock.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -168,5 +168,5 @@
 	}
 
-	rc = ipc_share_out_start(dev_phone, comm_area,
+	rc = async_share_out_start(dev_phone, comm_area,
 	    AS_AREA_READ | AS_AREA_WRITE);
 	if (rc != EOK) {
Index: uspace/lib/libc/generic/async.c
===================================================================
--- uspace/lib/libc/generic/async.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/lib/libc/generic/async.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -1087,4 +1087,248 @@
 }
 
+/** Wrapper for making IPC_M_SHARE_IN calls using the async framework.
+ *
+ * @param phoneid	Phone that will be used to contact the receiving side.
+ * @param dst		Destination address space area base.
+ * @param size		Size of the destination address space area.
+ * @param arg		User defined argument.
+ * @param flags		Storage where the received flags will be stored. Can be
+ *			NULL.
+ *
+ * @return		Zero on success or a negative error code from errno.h.
+ */
+int async_share_in_start(int phoneid, void *dst, size_t size, ipcarg_t arg,
+    int *flags)
+{
+	int res;
+	sysarg_t tmp_flags;
+	res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
+	    (ipcarg_t) size, arg, NULL, &tmp_flags);
+	if (flags)
+		*flags = tmp_flags;
+	return res;
+}
+
+/** Wrapper for receiving the IPC_M_SHARE_IN calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to receive IPC_M_SHARE_IN calls
+ * so that the user doesn't have to remember the meaning of each IPC argument.
+ *
+ * So far, this wrapper is to be used from within a connection fibril.
+ *
+ * @param callid	Storage where the hash of the IPC_M_SHARE_IN call will
+ * 			be stored.
+ * @param size		Destination address space area size.	
+ *
+ * @return		Non-zero on success, zero on failure.
+ */
+int async_share_in_receive(ipc_callid_t *callid, size_t *size)
+{
+	ipc_call_t data;
+	
+	assert(callid);
+	assert(size);
+
+	*callid = async_get_call(&data);
+	if (IPC_GET_METHOD(data) != IPC_M_SHARE_IN)
+		return 0;
+	*size = (size_t) IPC_GET_ARG2(data);
+	return 1;
+}
+
+/** Wrapper for answering the IPC_M_SHARE_IN calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
+ * so that the user doesn't have to remember the meaning of each IPC argument.
+ *
+ * @param callid	Hash of the IPC_M_DATA_READ call to answer.
+ * @param src		Source address space base.
+ * @param flags		Flags to be used for sharing. Bits can be only cleared.
+ *
+ * @return		Zero on success or a value from @ref errno.h on failure.
+ */
+int async_share_in_finalize(ipc_callid_t callid, void *src, int flags)
+{
+	return ipc_share_in_finalize(callid, src, flags);
+}
+
+/** Wrapper for making IPC_M_SHARE_OUT calls using the async framework.
+ *
+ * @param phoneid	Phone that will be used to contact the receiving side.
+ * @param src		Source address space area base address.
+ * @param flags		Flags to be used for sharing. Bits can be only cleared.
+ *
+ * @return		Zero on success or a negative error code from errno.h.
+ */
+int async_share_out_start(int phoneid, void *src, int flags)
+{
+	return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
+	    (ipcarg_t) flags);
+}
+
+/** Wrapper for receiving the IPC_M_SHARE_OUT calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to receive IPC_M_SHARE_OUT calls
+ * so that the user doesn't have to remember the meaning of each IPC argument.
+ *
+ * So far, this wrapper is to be used from within a connection fibril.
+ *
+ * @param callid	Storage where the hash of the IPC_M_SHARE_OUT call will
+ * 			be stored.
+ * @param size		Storage where the source address space area size will be
+ *			stored.
+ * @param flags		Storage where the sharing flags will be stored.
+ *
+ * @return		Non-zero on success, zero on failure.
+ */
+int async_share_out_receive(ipc_callid_t *callid, size_t *size, int *flags)
+{
+	ipc_call_t data;
+	
+	assert(callid);
+	assert(size);
+	assert(flags);
+
+	*callid = async_get_call(&data);
+	if (IPC_GET_METHOD(data) != IPC_M_SHARE_OUT)
+		return 0;
+	*size = (size_t) IPC_GET_ARG2(data);
+	*flags = (int) IPC_GET_ARG3(data);
+	return 1;
+}
+
+/** Wrapper for answering the IPC_M_SHARE_OUT calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT calls
+ * so that the user doesn't have to remember the meaning of each IPC argument.
+ *
+ * @param callid	Hash of the IPC_M_DATA_WRITE call to answer.
+ * @param dst		Destination address space area base address.	
+ *
+ * @return		Zero on success or a value from @ref errno.h on failure.
+ */
+int async_share_out_finalize(ipc_callid_t callid, void *dst)
+{
+	return ipc_share_out_finalize(callid, dst);
+}
+
+
+/** Wrapper for making IPC_M_DATA_READ calls using the async framework.
+ *
+ * @param phoneid	Phone that will be used to contact the receiving side.
+ * @param dst		Address of the beginning of the destination buffer.
+ * @param size		Size of the destination buffer.
+ *
+ * @return		Zero on success or a negative error code from errno.h.
+ */
+int async_data_read_start(int phoneid, void *dst, size_t size)
+{
+	return async_req_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
+	    (ipcarg_t) size);
+}
+
+/** Wrapper for receiving the IPC_M_DATA_READ calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to receive IPC_M_DATA_READ calls
+ * so that the user doesn't have to remember the meaning of each IPC argument.
+ *
+ * So far, this wrapper is to be used from within a connection fibril.
+ *
+ * @param callid	Storage where the hash of the IPC_M_DATA_READ call will
+ * 			be stored.
+ * @param size		Storage where the maximum size will be stored. Can be
+ *			NULL.
+ *
+ * @return		Non-zero on success, zero on failure.
+ */
+int async_data_read_receive(ipc_callid_t *callid, size_t *size)
+{
+	ipc_call_t data;
+	
+	assert(callid);
+
+	*callid = async_get_call(&data);
+	if (IPC_GET_METHOD(data) != IPC_M_DATA_READ)
+		return 0;
+	if (size)
+		*size = (size_t) IPC_GET_ARG2(data);
+	return 1;
+}
+
+/** Wrapper for answering the IPC_M_DATA_READ calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ calls
+ * so that the user doesn't have to remember the meaning of each IPC argument.
+ *
+ * @param callid	Hash of the IPC_M_DATA_READ call to answer.
+ * @param src		Source address for the IPC_M_DATA_READ call.
+ * @param size		Size for the IPC_M_DATA_READ call. Can be smaller than
+ *			the maximum size announced by the sender.
+ *
+ * @return		Zero on success or a value from @ref errno.h on failure.
+ */
+int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
+{
+	return ipc_data_read_finalize(callid, src, size);
+}
+
+/** Wrapper for making IPC_M_DATA_WRITE calls using the async framework.
+ *
+ * @param phoneid	Phone that will be used to contact the receiving side.
+ * @param src		Address of the beginning of the source buffer.
+ * @param size		Size of the source buffer.
+ *
+ * @return		Zero on success or a negative error code from errno.h.
+ */
+int async_data_write_start(int phoneid, const void *src, size_t size)
+{
+	return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
+	    (ipcarg_t) size);
+}
+
+/** Wrapper for receiving the IPC_M_DATA_WRITE calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to receive IPC_M_DATA_WRITE calls
+ * so that the user doesn't have to remember the meaning of each IPC argument.
+ *
+ * So far, this wrapper is to be used from within a connection fibril.
+ *
+ * @param callid	Storage where the hash of the IPC_M_DATA_WRITE call will
+ * 			be stored.
+ * @param size		Storage where the suggested size will be stored. May be
+ *			NULL
+ *
+ * @return		Non-zero on success, zero on failure.
+ */
+int async_data_write_receive(ipc_callid_t *callid, size_t *size)
+{
+	ipc_call_t data;
+	
+	assert(callid);
+
+	*callid = async_get_call(&data);
+	if (IPC_GET_METHOD(data) != IPC_M_DATA_WRITE)
+		return 0;
+	if (size)
+		*size = (size_t) IPC_GET_ARG2(data);
+	return 1;
+}
+
+/** Wrapper for answering the IPC_M_DATA_WRITE calls using the async framework.
+ *
+ * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE calls
+ * so that the user doesn't have to remember the meaning of each IPC argument.
+ *
+ * @param callid	Hash of the IPC_M_DATA_WRITE call to answer.
+ * @param dst		Final destination address for the IPC_M_DATA_WRITE call.
+ * @param size		Final size for the IPC_M_DATA_WRITE call.
+ *
+ * @return		Zero on success or a value from @ref errno.h on failure.
+ */
+int async_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
+{
+	return ipc_data_write_finalize(callid, dst, size);
+}
+
 /** @}
  */
Index: uspace/lib/libc/generic/devmap.c
===================================================================
--- uspace/lib/libc/generic/devmap.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/lib/libc/generic/devmap.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -105,5 +105,5 @@
 	aid_t req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
 	
-	ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
+	ipcarg_t retval = async_data_write_start(phone, name, str_size(name) + 1);
 	
 	if (retval != EOK) {
@@ -143,5 +143,5 @@
 	    &answer);
 	
-	ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
+	ipcarg_t retval = async_data_write_start(phone, name, str_size(name) + 1);
 	
 	if (retval != EOK) {
@@ -180,5 +180,5 @@
 	    &answer);
 	
-	ipcarg_t retval = ipc_data_write_start(phone, name, str_size(name) + 1);
+	ipcarg_t retval = async_data_write_start(phone, name, str_size(name) + 1);
 	
 	if (retval != EOK) {
@@ -271,5 +271,5 @@
 	aid_t req = async_send_0(phone, DEVMAP_DEVICE_GET_DEVICES, &answer);
 	
-	ipcarg_t retval = ipc_data_read_start(phone, data, count * sizeof(dev_desc_t));
+	ipcarg_t retval = async_data_read_start(phone, data, count * sizeof(dev_desc_t));
 	
 	if (retval != EOK) {
Index: uspace/lib/libc/generic/loader.c
===================================================================
--- uspace/lib/libc/generic/loader.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/lib/libc/generic/loader.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -90,5 +90,5 @@
 	ipc_call_t answer;
 	aid_t req = async_send_0(ldr->phone_id, LOADER_GET_TASKID, &answer);
-	int rc = ipc_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t));
+	int rc = async_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t));
 	if (rc != EOK) {
 		async_wait_for(req, NULL);
@@ -123,5 +123,5 @@
 	ipc_call_t answer;
 	aid_t req = async_send_0(ldr->phone_id, LOADER_SET_PATHNAME, &answer);
-	int rc = ipc_data_write_start(ldr->phone_id, (void *) pa, pa_len);
+	int rc = async_data_write_start(ldr->phone_id, (void *) pa, pa_len);
 	if (rc != EOK) {
 		async_wait_for(req, NULL);
@@ -178,5 +178,5 @@
 	ipc_call_t answer;
 	aid_t req = async_send_0(ldr->phone_id, LOADER_SET_ARGS, &answer);
-	ipcarg_t rc = ipc_data_write_start(ldr->phone_id, (void *) arg_buf, buffer_size);
+	ipcarg_t rc = async_data_write_start(ldr->phone_id, (void *) arg_buf, buffer_size);
 	if (rc != EOK) {
 		async_wait_for(req, NULL);
@@ -232,5 +232,5 @@
 	ipc_call_t answer;
 	aid_t req = async_send_0(ldr->phone_id, LOADER_SET_FILES, &answer);
-	ipcarg_t rc = ipc_data_write_start(ldr->phone_id, (void *) files_buf,
+	ipcarg_t rc = async_data_write_start(ldr->phone_id, (void *) files_buf,
 	    count * sizeof(fdi_node_t));
 	if (rc != EOK) {
Index: uspace/lib/libc/generic/vfs/vfs.c
===================================================================
--- uspace/lib/libc/generic/vfs/vfs.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/lib/libc/generic/vfs/vfs.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -140,5 +140,5 @@
 	
 	req = async_send_2(vfs_phone, VFS_IN_MOUNT, dev_handle, flags, NULL);
-	rc = ipc_data_write_start(vfs_phone, (void *) mpa, mpa_size);
+	rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
 	if (rc != EOK) {
 		async_wait_for(req, &rc_orig);
@@ -152,5 +152,5 @@
 	}
 	
-	rc = ipc_data_write_start(vfs_phone, (void *) opts, str_size(opts));
+	rc = async_data_write_start(vfs_phone, (void *) opts, str_size(opts));
 	if (rc != EOK) {
 		async_wait_for(req, &rc_orig);
@@ -164,5 +164,5 @@
 	}
 
-	rc = ipc_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
+	rc = async_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
 	if (rc != EOK) {
 		async_wait_for(req, &rc_orig);
@@ -213,5 +213,5 @@
 	
 	req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer);
-	rc = ipc_data_write_start(vfs_phone, pa, pa_size);
+	rc = async_data_write_start(vfs_phone, pa, pa_size);
 	if (rc != EOK) {
 		ipcarg_t rc_orig;
@@ -290,5 +290,5 @@
 	
 	req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
-	rc = ipc_data_read_start(vfs_phone, (void *)buf, nbyte);
+	rc = async_data_read_start(vfs_phone, (void *)buf, nbyte);
 	if (rc != EOK) {
 		ipcarg_t rc_orig;
@@ -322,5 +322,5 @@
 	
 	req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
-	rc = ipc_data_write_start(vfs_phone, (void *)buf, nbyte);
+	rc = async_data_write_start(vfs_phone, (void *)buf, nbyte);
 	if (rc != EOK) {
 		ipcarg_t rc_orig;
@@ -402,5 +402,5 @@
 	
 	req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL);
-	rc = ipc_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
+	rc = async_data_read_start(vfs_phone, (void *)stat, sizeof(struct stat));
 	if (rc != EOK) {
 		ipcarg_t rc_orig;
@@ -437,5 +437,5 @@
 	
 	req = async_send_0(vfs_phone, VFS_IN_STAT, NULL);
-	rc = ipc_data_write_start(vfs_phone, pa, pa_size);
+	rc = async_data_write_start(vfs_phone, pa, pa_size);
 	if (rc != EOK) {
 		async_wait_for(req, &rc_orig);
@@ -448,5 +448,5 @@
 			return (int) rc_orig;
 	}
-	rc = ipc_data_read_start(vfs_phone, stat, sizeof(struct stat));
+	rc = async_data_read_start(vfs_phone, stat, sizeof(struct stat));
 	if (rc != EOK) {
 		async_wait_for(req, &rc_orig);
@@ -514,5 +514,5 @@
 	
 	req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL);
-	rc = ipc_data_write_start(vfs_phone, pa, pa_size);
+	rc = async_data_write_start(vfs_phone, pa, pa_size);
 	if (rc != EOK) {
 		ipcarg_t rc_orig;
@@ -549,5 +549,5 @@
 	
 	req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL);
-	rc = ipc_data_write_start(vfs_phone, pa, pa_size);
+	rc = async_data_write_start(vfs_phone, pa, pa_size);
 	if (rc != EOK) {
 		ipcarg_t rc_orig;
@@ -602,5 +602,5 @@
 	
 	req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL);
-	rc = ipc_data_write_start(vfs_phone, olda, olda_size);
+	rc = async_data_write_start(vfs_phone, olda, olda_size);
 	if (rc != EOK) {
 		async_wait_for(req, &rc_orig);
@@ -614,5 +614,5 @@
 			return (int) rc_orig;
 	}
-	rc = ipc_data_write_start(vfs_phone, newa, newa_size);
+	rc = async_data_write_start(vfs_phone, newa, newa_size);
 	if (rc != EOK) {
 		async_wait_for(req, &rc_orig);
Index: uspace/lib/libc/include/async.h
===================================================================
--- uspace/lib/libc/include/async.h	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/lib/libc/include/async.h	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -259,4 +259,29 @@
 }
 
+/*
+ * User-friendly wrappers for async_share_in_start().
+ */
+#define async_share_in_start_0_0(phoneid, dst, size) \
+	async_share_in_start((phoneid), (dst), (size), 0, NULL)
+#define async_share_in_start_0_1(phoneid, dst, size, flags) \
+	async_share_in_start((phoneid), (dst), (size), 0, (flags))
+#define async_share_in_start_1_0(phoneid, dst, size, arg) \
+	async_share_in_start((phoneid), (dst), (size), (arg), NULL)
+#define async_share_in_start_1_1(phoneid, dst, size, arg, flags) \
+	async_share_in_start((phoneid), (dst), (size), (arg), (flags))
+
+extern int async_share_in_start(int, void *, size_t, ipcarg_t, int *);
+extern int async_share_in_receive(ipc_callid_t *, size_t *);
+extern int async_share_in_finalize(ipc_callid_t, void *, int );
+extern int async_share_out_start(int, void *, int);
+extern int async_share_out_receive(ipc_callid_t *, size_t *, int *);
+extern int async_share_out_finalize(ipc_callid_t, void *);
+extern int async_data_read_start(int, void *, size_t);
+extern int async_data_read_receive(ipc_callid_t *, size_t *);
+extern int async_data_read_finalize(ipc_callid_t, const void *, size_t);
+extern int async_data_write_start(int, const void *, size_t);
+extern int async_data_write_receive(ipc_callid_t *, size_t *);
+extern int async_data_write_finalize(ipc_callid_t, void *, size_t);
+
 #endif
 
Index: uspace/lib/libfs/libfs.c
===================================================================
--- uspace/lib/libfs/libfs.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/lib/libfs/libfs.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -91,5 +91,5 @@
 	 * Send our VFS info structure to VFS.
 	 */
-	int rc = ipc_data_write_start(vfs_phone, info, sizeof(*info)); 
+	int rc = async_data_write_start(vfs_phone, info, sizeof(*info)); 
 	if (rc != EOK) {
 		async_wait_for(req, NULL);
@@ -114,5 +114,5 @@
 	 * Request sharing the Path Lookup Buffer with VFS.
 	 */
-	rc = ipc_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);
+	rc = async_share_in_start_0_0(vfs_phone, reg->plb_ro, PLB_SIZE);
 	if (rc) {
 		async_wait_for(req, NULL);
@@ -169,5 +169,5 @@
 	ipc_answer_0(callid, EOK);	/* acknowledge the mountee_phone */
 	
-	res = ipc_data_write_receive(&callid, NULL);
+	res = async_data_write_receive(&callid, NULL);
 	if (!res) {
 		ipc_hangup(mountee_phone);
@@ -486,5 +486,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_read_receive(&callid, &size) ||
+	if (!async_data_read_receive(&callid, &size) ||
 	    size != sizeof(struct stat)) {
 		ipc_answer_0(callid, EINVAL);
@@ -503,5 +503,5 @@
 	stat.size = ops->size_get(fn);
 
-	ipc_data_read_finalize(callid, &stat, sizeof(struct stat));
+	async_data_read_finalize(callid, &stat, sizeof(struct stat));
 	ipc_answer_0(rid, EOK);
 }
Index: uspace/srv/bd/ata_bd/ata_bd.c
===================================================================
--- uspace/srv/bd/ata_bd/ata_bd.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/bd/ata_bd/ata_bd.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -252,5 +252,5 @@
 	ipc_answer_0(iid, EOK);
 
-	if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
+	if (!async_share_out_receive(&callid, &comm_size, &flags)) {
 		ipc_answer_0(callid, EHANGUP);
 		return;
@@ -263,5 +263,5 @@
 	}
 
-	(void) ipc_share_out_finalize(callid, fs_va);
+	(void) async_share_out_finalize(callid, fs_va);
 
 	while (1) {
Index: uspace/srv/bd/file_bd/file_bd.c
===================================================================
--- uspace/srv/bd/file_bd/file_bd.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/bd/file_bd/file_bd.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -130,5 +130,5 @@
 	ipc_answer_0(iid, EOK);
 
-	if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
+	if (!async_share_out_receive(&callid, &comm_size, &flags)) {
 		ipc_answer_0(callid, EHANGUP);
 		return;
@@ -141,5 +141,5 @@
 	}
 
-	(void) ipc_share_out_finalize(callid, fs_va);
+	(void) async_share_out_finalize(callid, fs_va);
 
 	while (1) {
Index: uspace/srv/bd/gxe_bd/gxe_bd.c
===================================================================
--- uspace/srv/bd/gxe_bd/gxe_bd.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/bd/gxe_bd/gxe_bd.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -185,5 +185,5 @@
 	ipc_answer_0(iid, EOK);
 
-	if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
+	if (!async_share_out_receive(&callid, &comm_size, &flags)) {
 		ipc_answer_0(callid, EHANGUP);
 		return;
@@ -201,5 +201,5 @@
 	}
 
-	(void) ipc_share_out_finalize(callid, fs_va);
+	(void) async_share_out_finalize(callid, fs_va);
 
 	while (1) {
Index: uspace/srv/bd/rd/rd.c
===================================================================
--- uspace/srv/bd/rd/rd.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/bd/rd/rd.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -102,8 +102,8 @@
 	 */
 	int flags;
-	if (ipc_share_out_receive(&callid, &comm_size, &flags)) {
+	if (async_share_out_receive(&callid, &comm_size, &flags)) {
 		fs_va = as_get_mappable_page(comm_size);
 		if (fs_va) {
-			(void) ipc_share_out_finalize(callid, fs_va);
+			(void) async_share_out_finalize(callid, fs_va);
 		} else {
 			ipc_answer_0(callid, EHANGUP);
Index: uspace/srv/console/console.c
===================================================================
--- uspace/srv/console/console.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/console/console.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -429,5 +429,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_write_receive(&callid, &size)) {
+	if (!async_data_write_receive(&callid, &size)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -442,5 +442,5 @@
 	}
 	
-	(void) ipc_data_write_finalize(callid, buf, size);
+	(void) async_data_write_finalize(callid, buf, size);
 	
 	async_serialize_start();
@@ -464,5 +464,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_read_receive(&callid, &size)) {
+	if (!async_data_read_receive(&callid, &size)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -489,5 +489,5 @@
 	
 	if (pos == size) {
-		(void) ipc_data_read_finalize(callid, buf, size);
+		(void) async_data_read_finalize(callid, buf, size);
 		ipc_answer_1(rid, EOK, size);
 		free(buf);
@@ -713,5 +713,5 @@
 	
 	if (interbuffer) {
-		if (ipc_share_out_start(fb_info.phone, interbuffer,
+		if (async_share_out_start(fb_info.phone, interbuffer,
 		    AS_AREA_READ) != EOK) {
 			as_area_destroy(interbuffer);
Index: uspace/srv/console/gcons.c
===================================================================
--- uspace/srv/console/gcons.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/console/gcons.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -339,5 +339,5 @@
 		goto exit;
 	
-	rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
+	rc = async_share_out_start(fbphone, shm, PROTO_READ);
 	if (rc)
 		goto drop;
@@ -409,5 +409,5 @@
 		goto exit;
 	
-	rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
+	rc = async_share_out_start(fbphone, shm, PROTO_READ);
 	if (rc)
 		goto drop;
Index: uspace/srv/devmap/devmap.c
===================================================================
--- uspace/srv/devmap/devmap.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/devmap/devmap.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -213,5 +213,5 @@
 	ipc_callid_t callid;
 	size_t name_size;
-	if (!ipc_data_write_receive(&callid, &name_size)) {
+	if (!async_data_write_receive(&callid, &name_size)) {
 		free(driver);
 		ipc_answer_0(callid, EREFUSED);
@@ -241,5 +241,5 @@
 	 * Send confirmation to sender and get data into buffer.
 	 */
-	if (ipc_data_write_finalize(callid, driver->name, name_size) != EOK) {
+	if (async_data_write_finalize(callid, driver->name, name_size) != EOK) {
 		free(driver->name);
 		free(driver);
@@ -358,5 +358,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_write_receive(&callid, &size)) {
+	if (!async_data_write_receive(&callid, &size)) {
 		free(device);
 		ipc_answer_0(iid, EREFUSED);
@@ -381,5 +381,5 @@
 	}
 	
-	ipc_data_write_finalize(callid, device->name, size);
+	async_data_write_finalize(callid, device->name, size);
 	device->name[size] = 0;
 	
@@ -466,5 +466,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_write_receive(&callid, &size)) {
+	if (!async_data_write_receive(&callid, &size)) {
 		ipc_answer_0(callid, EREFUSED);
 		ipc_answer_0(iid, EREFUSED);
@@ -491,5 +491,5 @@
 	 * Send confirmation to sender and get data into buffer.
 	 */
-	ipcarg_t retval = ipc_data_write_finalize(callid, name, size);
+	ipcarg_t retval = async_data_write_finalize(callid, name, size);
 	if (retval != EOK) {
 		ipc_answer_0(iid, EREFUSED);
@@ -553,5 +553,5 @@
 	 * size_t name_size = str_size(device->name);
 	 *
-	 * int rc = ipc_data_write_send(phone, device->name, name_size);
+	 * int rc = async_data_write_send(phone, device->name, name_size);
 	 * if (rc != EOK) {
 	 *     async_wait_for(req, NULL);
@@ -576,5 +576,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_read_receive(&callid, &size)) {
+	if (!async_data_read_receive(&callid, &size)) {
 		ipc_answer_0(callid, EREFUSED);
 		ipc_answer_0(iid, EREFUSED);
@@ -608,5 +608,5 @@
 	}
 	
-	ipcarg_t retval = ipc_data_read_finalize(callid, desc, pos * sizeof(dev_desc_t));
+	ipcarg_t retval = async_data_read_finalize(callid, desc, pos * sizeof(dev_desc_t));
 	if (retval != EOK) {
 		ipc_answer_0(iid, EREFUSED);
Index: uspace/srv/fs/devfs/devfs_ops.c
===================================================================
--- uspace/srv/fs/devfs/devfs_ops.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/fs/devfs/devfs_ops.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -108,5 +108,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_write_receive(&callid, &size)) {
+	if (!async_data_write_receive(&callid, &size)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -121,5 +121,5 @@
 	}
 	
-	ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
+	ipcarg_t retval = async_data_write_finalize(callid, opts, size);
 	if (retval != EOK) {
 		ipc_answer_0(rid, retval);
@@ -286,5 +286,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_read_receive(&callid, &size) ||
+	if (!async_data_read_receive(&callid, &size) ||
 	    size != sizeof(struct stat)) {
 		ipc_answer_0(callid, EINVAL);
@@ -315,5 +315,5 @@
 	}
 
-	ipc_data_read_finalize(callid, &stat, sizeof(struct stat));
+	async_data_read_finalize(callid, &stat, sizeof(struct stat));
 	ipc_answer_0(rid, EOK);
 }
@@ -340,5 +340,5 @@
 		
 		ipc_callid_t callid;
-		if (!ipc_data_read_receive(&callid, NULL)) {
+		if (!async_data_read_receive(&callid, NULL)) {
 			fibril_mutex_unlock(&devices_mutex);
 			ipc_answer_0(callid, EINVAL);
@@ -367,5 +367,5 @@
 		ipc_callid_t callid;
 		size_t size;
-		if (!ipc_data_read_receive(&callid, &size)) {
+		if (!async_data_read_receive(&callid, &size)) {
 			ipc_answer_0(callid, EINVAL);
 			ipc_answer_0(rid, EINVAL);
@@ -384,5 +384,5 @@
 		
 		if (pos < max) {
-			ipc_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
+			async_data_read_finalize(callid, desc[pos].name, str_size(desc[pos].name) + 1);
 		} else {
 			ipc_answer_0(callid, ENOENT);
@@ -418,5 +418,5 @@
 		
 		ipc_callid_t callid;
-		if (!ipc_data_write_receive(&callid, NULL)) {
+		if (!async_data_write_receive(&callid, NULL)) {
 			fibril_mutex_unlock(&devices_mutex);
 			ipc_answer_0(callid, EINVAL);
Index: uspace/srv/fs/fat/fat_ops.c
===================================================================
--- uspace/srv/fs/fat/fat_ops.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/fs/fat/fat_ops.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -897,5 +897,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_write_receive(&callid, &size)) {
+	if (!async_data_write_receive(&callid, &size)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -908,5 +908,5 @@
 		return;
 	}
-	ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
+	ipcarg_t retval = async_data_write_finalize(callid, opts, size);
 	if (retval != EOK) {
 		ipc_answer_0(rid, retval);
@@ -1047,5 +1047,5 @@
 	ipc_callid_t callid;
 	size_t len;
-	if (!ipc_data_read_receive(&callid, &len)) {
+	if (!async_data_read_receive(&callid, &len)) {
 		fat_node_put(fn);
 		ipc_answer_0(callid, EINVAL);
@@ -1066,5 +1066,5 @@
 			/* reading beyond the EOF */
 			bytes = 0;
-			(void) ipc_data_read_finalize(callid, NULL, 0);
+			(void) async_data_read_finalize(callid, NULL, 0);
 		} else {
 			bytes = min(len, bps - pos % bps);
@@ -1073,5 +1073,5 @@
 			    BLOCK_FLAGS_NONE);
 			assert(rc == EOK);
-			(void) ipc_data_read_finalize(callid, b->data + pos % bps,
+			(void) async_data_read_finalize(callid, b->data + pos % bps,
 			    bytes);
 			rc = block_put(b);
@@ -1131,5 +1131,5 @@
 		return;
 hit:
-		(void) ipc_data_read_finalize(callid, name, str_size(name) + 1);
+		(void) async_data_read_finalize(callid, name, str_size(name) + 1);
 		bytes = (pos - spos) + 1;
 	}
@@ -1169,5 +1169,5 @@
 	ipc_callid_t callid;
 	size_t len;
-	if (!ipc_data_write_receive(&callid, &len)) {
+	if (!async_data_write_receive(&callid, &len)) {
 		fat_node_put(fn);
 		ipc_answer_0(callid, EINVAL);
@@ -1204,5 +1204,5 @@
 		rc = fat_block_get(&b, bs, nodep, pos / bps, flags);
 		assert(rc == EOK);
-		(void) ipc_data_write_finalize(callid, b->data + pos % bps,
+		(void) async_data_write_finalize(callid, b->data + pos % bps,
 		    bytes);
 		b->dirty = true;		/* need to sync block */
@@ -1241,5 +1241,5 @@
 		    flags);
 		assert(rc == EOK);
-		(void) ipc_data_write_finalize(callid, b->data + pos % bps,
+		(void) async_data_write_finalize(callid, b->data + pos % bps,
 		    bytes);
 		b->dirty = true;		/* need to sync block */
Index: uspace/srv/fs/tmpfs/tmpfs_ops.c
===================================================================
--- uspace/srv/fs/tmpfs/tmpfs_ops.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/fs/tmpfs/tmpfs_ops.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -389,5 +389,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_write_receive(&callid, &size)) {
+	if (!async_data_write_receive(&callid, &size)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -400,5 +400,5 @@
 		return;
 	}
-	ipcarg_t retval = ipc_data_write_finalize(callid, opts, size);
+	ipcarg_t retval = async_data_write_finalize(callid, opts, size);
 	if (retval != EOK) {
 		ipc_answer_0(rid, retval);
@@ -467,5 +467,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_read_receive(&callid, &size)) {
+	if (!async_data_read_receive(&callid, &size)) {
 		ipc_answer_0(callid, EINVAL);	
 		ipc_answer_0(rid, EINVAL);
@@ -476,5 +476,5 @@
 	if (nodep->type == TMPFS_FILE) {
 		bytes = max(0, min(nodep->size - pos, size));
-		(void) ipc_data_read_finalize(callid, nodep->data + pos,
+		(void) async_data_read_finalize(callid, nodep->data + pos,
 		    bytes);
 	} else {
@@ -503,5 +503,5 @@
 		dentryp = list_get_instance(lnk, tmpfs_dentry_t, link);
 
-		(void) ipc_data_read_finalize(callid, dentryp->name,
+		(void) async_data_read_finalize(callid, dentryp->name,
 		    str_size(dentryp->name) + 1);
 		bytes = 1;
@@ -541,5 +541,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_write_receive(&callid, &size)) {
+	if (!async_data_write_receive(&callid, &size)) {
 		ipc_answer_0(callid, EINVAL);	
 		ipc_answer_0(rid, EINVAL);
@@ -552,5 +552,5 @@
 	if (pos + size <= nodep->size) {
 		/* The file size is not changing. */
-		(void) ipc_data_write_finalize(callid, nodep->data + pos, size);
+		(void) async_data_write_finalize(callid, nodep->data + pos, size);
 		ipc_answer_2(rid, EOK, size, nodep->size);
 		return;
@@ -574,5 +574,5 @@
 	nodep->size += delta;
 	nodep->data = newdata;
-	(void) ipc_data_write_finalize(callid, nodep->data + pos, size);
+	(void) async_data_write_finalize(callid, nodep->data + pos, size);
 	ipc_answer_2(rid, EOK, size, nodep->size);
 }
Index: uspace/srv/loader/main.c
===================================================================
--- uspace/srv/loader/main.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/loader/main.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -102,5 +102,5 @@
 	task_id = task_get_id();
 	
-	if (!ipc_data_read_receive(&callid, &len)) {
+	if (!async_data_read_receive(&callid, &len)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -111,5 +111,5 @@
 		len = sizeof(task_id);
 	
-	ipc_data_read_finalize(callid, &task_id, len);
+	async_data_read_finalize(callid, &task_id, len);
 	ipc_answer_0(rid, EOK);
 }
@@ -127,5 +127,5 @@
 	char *name_buf;
 	
-	if (!ipc_data_write_receive(&callid, &len)) {
+	if (!async_data_write_receive(&callid, &len)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -140,5 +140,5 @@
 	}
 	
-	ipc_data_write_finalize(callid, name_buf, len);
+	async_data_write_finalize(callid, name_buf, len);
 	ipc_answer_0(rid, EOK);
 	
@@ -164,5 +164,5 @@
 	int n;
 	
-	if (!ipc_data_write_receive(&callid, &buf_size)) {
+	if (!async_data_write_receive(&callid, &buf_size)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -187,5 +187,5 @@
 	}
 	
-	ipc_data_write_finalize(callid, arg_buf, buf_size);
+	async_data_write_finalize(callid, arg_buf, buf_size);
 	
 	arg_buf[buf_size] = '\0';
@@ -239,5 +239,5 @@
 	ipc_callid_t callid;
 	size_t buf_size;
-	if (!ipc_data_write_receive(&callid, &buf_size)) {
+	if (!async_data_write_receive(&callid, &buf_size)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -268,5 +268,5 @@
 	}
 	
-	ipc_data_write_finalize(callid, fil_buf, buf_size);
+	async_data_write_finalize(callid, fil_buf, buf_size);
 	
 	int count = buf_size / sizeof(fdi_node_t);
Index: uspace/srv/part/mbr_part/mbr_part.c
===================================================================
--- uspace/srv/part/mbr_part/mbr_part.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/part/mbr_part/mbr_part.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -419,5 +419,5 @@
 	ipc_answer_0(iid, EOK);
 
-	if (!ipc_share_out_receive(&callid, &comm_size, &flags)) {
+	if (!async_share_out_receive(&callid, &comm_size, &flags)) {
 		ipc_answer_0(callid, EHANGUP);
 		return;
@@ -430,5 +430,5 @@
 	}
 
-	(void) ipc_share_out_finalize(callid, fs_va);
+	(void) async_share_out_finalize(callid, fs_va);
 
 	while (1) {
Index: uspace/srv/vfs/vfs_ops.c
===================================================================
--- uspace/srv/vfs/vfs_ops.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/vfs/vfs_ops.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -125,5 +125,5 @@
 			    (ipcarg_t) dev_handle, &answer);
 			/* send the mount options */
-			rc = ipc_data_write_start(phone, (void *)opts,
+			rc = async_data_write_start(phone, (void *)opts,
 			    str_size(opts));
 			if (rc != EOK) {
@@ -207,5 +207,5 @@
 	
 	/* send the mount options */
-	rc = ipc_data_write_start(phone, (void *)opts, str_size(opts));
+	rc = async_data_write_start(phone, (void *)opts, str_size(opts));
 	if (rc != EOK) {
 		async_wait_for(msg, NULL);
@@ -268,5 +268,5 @@
 	ipc_callid_t callid;
 	size_t size;
-	if (!ipc_data_write_receive(&callid, &size)) {
+	if (!async_data_write_receive(&callid, &size)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -290,5 +290,5 @@
 	
 	/* Deliver the mount point. */
-	ipcarg_t retval = ipc_data_write_finalize(callid, mp, size);
+	ipcarg_t retval = async_data_write_finalize(callid, mp, size);
 	if (retval != EOK) {
 		ipc_answer_0(rid, retval);
@@ -299,5 +299,5 @@
 	
 	/* Now we expect to receive the mount options. */
-	if (!ipc_data_write_receive(&callid, &size)) {
+	if (!async_data_write_receive(&callid, &size)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -324,5 +324,5 @@
 
 	/* Deliver the mount options. */
-	retval = ipc_data_write_finalize(callid, opts, size);
+	retval = async_data_write_finalize(callid, opts, size);
 	if (retval != EOK) {
 		ipc_answer_0(rid, retval);
@@ -337,5 +337,5 @@
 	 * system.
 	 */
-	if (!ipc_data_write_receive(&callid, &size)) {
+	if (!async_data_write_receive(&callid, &size)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -370,5 +370,5 @@
 	
 	/* Deliver the file system name. */
-	retval = ipc_data_write_finalize(callid, fs_name, size);
+	retval = async_data_write_finalize(callid, fs_name, size);
 	if (retval != EOK) {
 		ipc_answer_0(rid, retval);
@@ -469,5 +469,5 @@
 	
 	ipc_callid_t callid;
-	if (!ipc_data_write_receive(&callid, &len)) {
+	if (!async_data_write_receive(&callid, &len)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -483,5 +483,5 @@
 	
 	int rc;
-	if ((rc = ipc_data_write_finalize(callid, path, len))) {
+	if ((rc = async_data_write_finalize(callid, path, len))) {
 		ipc_answer_0(rid, rc);
 		free(path);
@@ -747,7 +747,7 @@
 	int res;
 	if (read)
-		res = ipc_data_read_receive(&callid, NULL);
+		res = async_data_read_receive(&callid, NULL);
 	else 
-		res = ipc_data_write_receive(&callid, NULL);
+		res = async_data_write_receive(&callid, NULL);
 	if (!res) {
 		ipc_answer_0(callid, EINVAL);
@@ -943,5 +943,5 @@
 
 	ipc_callid_t callid;
-	if (!ipc_data_read_receive(&callid, NULL)) {
+	if (!async_data_read_receive(&callid, NULL)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -969,5 +969,5 @@
 	ipc_callid_t callid;
 
-	if (!ipc_data_write_receive(&callid, &len)) {
+	if (!async_data_write_receive(&callid, &len)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -981,5 +981,5 @@
 	}
 	int rc;
-	if ((rc = ipc_data_write_finalize(callid, path, len))) {
+	if ((rc = async_data_write_finalize(callid, path, len))) {
 		ipc_answer_0(rid, rc);
 		free(path);
@@ -988,5 +988,5 @@
 	path[len] = '\0';
 
-	if (!ipc_data_read_receive(&callid, NULL)) {
+	if (!async_data_read_receive(&callid, NULL)) {
 		free(path);
 		ipc_answer_0(callid, EINVAL);
@@ -1037,5 +1037,5 @@
 	ipc_callid_t callid;
 
-	if (!ipc_data_write_receive(&callid, &len)) {
+	if (!async_data_write_receive(&callid, &len)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -1049,5 +1049,5 @@
 	}
 	int rc;
-	if ((rc = ipc_data_write_finalize(callid, path, len))) {
+	if ((rc = async_data_write_finalize(callid, path, len))) {
 		ipc_answer_0(rid, rc);
 		free(path);
@@ -1074,5 +1074,5 @@
 	ipc_callid_t callid;
 
-	if (!ipc_data_write_receive(&callid, &len)) {
+	if (!async_data_write_receive(&callid, &len)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -1086,5 +1086,5 @@
 	}
 	int rc;
-	if ((rc = ipc_data_write_finalize(callid, path, len))) {
+	if ((rc = async_data_write_finalize(callid, path, len))) {
 		ipc_answer_0(rid, rc);
 		free(path);
@@ -1125,5 +1125,5 @@
 
 	/* Retrieve the old path. */
-	if (!ipc_data_write_receive(&callid, &olen)) {
+	if (!async_data_write_receive(&callid, &olen)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -1136,5 +1136,5 @@
 		return;
 	}
-	if ((rc = ipc_data_write_finalize(callid, old, olen))) {
+	if ((rc = async_data_write_finalize(callid, old, olen))) {
 		ipc_answer_0(rid, rc);
 		free(old);
@@ -1144,5 +1144,5 @@
 	
 	/* Retrieve the new path. */
-	if (!ipc_data_write_receive(&callid, &nlen)) {
+	if (!async_data_write_receive(&callid, &nlen)) {
 		ipc_answer_0(callid, EINVAL);
 		ipc_answer_0(rid, EINVAL);
@@ -1157,5 +1157,5 @@
 		return;
 	}
-	if ((rc = ipc_data_write_finalize(callid, new, nlen))) {
+	if ((rc = async_data_write_finalize(callid, new, nlen))) {
 		ipc_answer_0(rid, rc);
 		free(old);
Index: uspace/srv/vfs/vfs_register.c
===================================================================
--- uspace/srv/vfs/vfs_register.c	(revision bbb01b98a51d30dabc8f07bc5db6598151f1ad6b)
+++ uspace/srv/vfs/vfs_register.c	(revision 0da4e41be5a0b7a29e97e1f87816593416d3db04)
@@ -122,5 +122,5 @@
 	 * VFS info structure from the client FS.
 	 */
-	if (!ipc_data_write_receive(&callid, &size)) {
+	if (!async_data_write_receive(&callid, &size)) {
 		/*
 		 * The client doesn't obey the same protocol as we do.
@@ -163,5 +163,5 @@
 	fibril_mutex_initialize(&fs_info->phone_lock);
 		
-	rc = ipc_data_write_finalize(callid, &fs_info->vfs_info, size);
+	rc = async_data_write_finalize(callid, &fs_info->vfs_info, size);
 	if (rc != EOK) {
 		dprintf("Failed to deliver the VFS info into our AS, rc=%d.\n",
@@ -229,5 +229,5 @@
 	 */
 
-	if (!ipc_share_in_receive(&callid, &size)) {
+	if (!async_share_in_receive(&callid, &size)) {
 		dprintf("Unexpected call, method = %d\n", IPC_GET_METHOD(call));
 		list_remove(&fs_info->fs_link);
@@ -257,5 +257,5 @@
 	 * Commit to read-only sharing the PLB with the client.
 	 */
-	(void) ipc_share_in_finalize(callid, plb,
+	(void) async_share_in_finalize(callid, plb,
 	    AS_AREA_READ | AS_AREA_CACHEABLE);