Changeset f307f12 in mainline

Timestamp:

2009-10-11T16:26:01Z (15 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

c088fd4

Parents:

c123609 (diff), ba8f8cb (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge experimental support for timeoutable fibril condition variables.
The merge includes a fix for an IPC/async framework problem caused by the fact
that timeoutable entities in the async framework (and also fibril
synchronization code) often call gettimeofday() when async_futex is held, and
the fact that gettimeofday() had a dependency on async framework.

Location:

uspace

Files:

• app/klog/klog.c (modified) (1 diff)
• lib/libblock/libblock.c (modified) (1 diff)
• lib/libc/generic/async.c (modified) (16 diffs)
• lib/libc/generic/devmap.c (modified) (4 diffs)
• lib/libc/generic/fibril_sync.c (modified) (8 diffs)
• lib/libc/generic/ipc.c (modified) (5 diffs)
• lib/libc/generic/loader.c (modified) (4 diffs)
• lib/libc/generic/vfs/vfs.c (modified) (13 diffs)
• lib/libc/include/async.h (modified) (1 diff)
• lib/libc/include/async_priv.h (added)
• lib/libc/include/fibril_sync.h (modified) (2 diffs)
• lib/libc/include/ipc/ipc.h (modified) (1 diff)
• lib/libfs/libfs.c (modified) (5 diffs)
• srv/bd/ata_bd/ata_bd.c (modified) (2 diffs)
• srv/bd/file_bd/file_bd.c (modified) (2 diffs)
• srv/bd/gxe_bd/gxe_bd.c (modified) (2 diffs)
• srv/bd/rd/rd.c (modified) (1 diff)
• srv/console/console.c (modified) (5 diffs)
• srv/console/gcons.c (modified) (2 diffs)
• srv/devmap/devmap.c (modified) (9 diffs)
• srv/fs/devfs/devfs_ops.c (modified) (8 diffs)
• srv/fs/fat/fat_ops.c (modified) (9 diffs)
• srv/fs/tmpfs/tmpfs_ops.c (modified) (8 diffs)
• srv/loader/main.c (modified) (8 diffs)
• srv/part/mbr_part/mbr_part.c (modified) (2 diffs)
• srv/vfs/vfs_ops.c (modified) (23 diffs)
• srv/vfs/vfs_register.c (modified) (4 diffs)

uspace/app/klog/klog.c

@@ -74 +74 @@
         }
         
-        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) {

uspace/lib/libblock/libblock.c

@@ -168 +168 @@
         }
 
-        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) {

uspace/lib/libc/generic/async.c

@@ -83 +83 @@
  *
  *     callid = async_get_call(&call);
- *     handle_call(callid, call);
+ *     somehow_handle_the_call(callid, call);
  *     ipc_answer_2(callid, 1, 2, 3);
  *
@@ -94 +94 @@
 #include <futex.h>
 #include <async.h>
+#include <async_priv.h>
 #include <fibril.h>
 #include <stdio.h>
@@ -110 +111 @@
 atomic_t threads_in_ipc_wait = { 0 };
 
-/** Structures of this type represent a waiting fibril. */
-typedef struct {
-        /** Expiration time. */
-        struct timeval expires;
-        
-        /** If true, this struct is in the timeout list. */
-        bool inlist;
-        
-        /** Timeout list link. */
-        link_t link;
-        
-        /** Identification of and link to the waiting fibril. */
-        fid_t fid;
-        
-        /** If true, this fibril is currently active. */
-        bool active;
-        
-        /** If true, we have timed out. */
-        bool timedout;
-} awaiter_t;
-
 typedef struct {
         awaiter_t wdata;
@@ -253 +233 @@
  *
  */
-static void insert_timeout(awaiter_t *wd)
-{
-        wd->timedout = false;
-        wd->inlist = true;
+void async_insert_timeout(awaiter_t *wd)
+{
+        wd->to_event.occurred = false;
+        wd->to_event.inlist = true;
         
         link_t *tmp = timeout_list.next;
         while (tmp != &timeout_list) {
-                awaiter_t *cur = list_get_instance(tmp, awaiter_t, link);
-                
-                if (tv_gteq(&cur->expires, &wd->expires))
+                awaiter_t *cur;
+                
+                cur = list_get_instance(tmp, awaiter_t, to_event.link);
+                if (tv_gteq(&cur->to_event.expires, &wd->to_event.expires))
                         break;
-                
                 tmp = tmp->next;
         }
         
-        list_append(&wd->link, tmp);
+        list_append(&wd->to_event.link, tmp);
 }
 
@@ -315 +295 @@
                 
                 /* If in timeout list, remove it */
-                if (conn->wdata.inlist) {
-                        conn->wdata.inlist = false;
-                        list_remove(&conn->wdata.link);
+                if (conn->wdata.to_event.inlist) {
+                        conn->wdata.to_event.inlist = false;
+                        list_remove(&conn->wdata.to_event.link);
                 }
                 
@@ -405 +385 @@
         
         if (usecs) {
-                gettimeofday(&conn->wdata.expires, NULL);
-                tv_add(&conn->wdata.expires, usecs);
+                gettimeofday(&conn->wdata.to_event.expires, NULL);
+                tv_add(&conn->wdata.to_event.expires, usecs);
         } else
-                conn->wdata.inlist = false;
+                conn->wdata.to_event.inlist = false;
         
         /* If nothing in queue, wait until something arrives */
         while (list_empty(&conn->msg_queue)) {
                 if (usecs)
-                        insert_timeout(&conn->wdata);
+                        async_insert_timeout(&conn->wdata);
                 
                 conn->wdata.active = false;
@@ -430 +410 @@
                  */
                 futex_down(&async_futex);
-                if ((usecs) && (conn->wdata.timedout)
+                if ((usecs) && (conn->wdata.to_event.occurred)
                     && (list_empty(&conn->msg_queue))) {
                         /* If we timed out -> exit */
@@ -625 +605 @@
         link_t *cur = timeout_list.next;
         while (cur != &timeout_list) {
-                awaiter_t *waiter = list_get_instance(cur, awaiter_t, link);
-                
-                if (tv_gt(&waiter->expires, &tv))
+                awaiter_t *waiter;
+                
+                waiter = list_get_instance(cur, awaiter_t, to_event.link);
+                if (tv_gt(&waiter->to_event.expires, &tv))
                         break;
-                
+
                 cur = cur->next;
-                
-                list_remove(&waiter->link);
-                waiter->inlist = false;
-                waiter->timedout = true;
+
+                list_remove(&waiter->to_event.link);
+                waiter->to_event.inlist = false;
+                waiter->to_event.occurred = true;
                 
                 /*
@@ -671 +652 @@
                 if (!list_empty(&timeout_list)) {
                         awaiter_t *waiter = list_get_instance(timeout_list.next,
-                            awaiter_t, link);
+                            awaiter_t, to_event.link);
                         
                         struct timeval tv;
                         gettimeofday(&tv, NULL);
                         
-                        if (tv_gteq(&tv, &waiter->expires)) {
+                        if (tv_gteq(&tv, &waiter->to_event.expires)) {
                                 futex_up(&async_futex);
                                 handle_expired_timeouts();
                                 continue;
                         } else
-                                timeout = tv_sub(&waiter->expires, &tv);
+                                timeout = tv_sub(&waiter->to_event.expires,
+                                    &tv);
                 } else
                         timeout = SYNCH_NO_TIMEOUT;
@@ -782 +764 @@
         
         /* Remove message from timeout list */
-        if (msg->wdata.inlist)
-                list_remove(&msg->wdata.link);
+        if (msg->wdata.to_event.inlist)
+                list_remove(&msg->wdata.to_event.link);
         
         msg->done = true;
@@ -822 +804 @@
         msg->dataptr = dataptr;
         
-        msg->wdata.inlist = false;
+        msg->wdata.to_event.inlist = false;
         /* We may sleep in the next method, but it will use its own mechanism */
         msg->wdata.active = true;
@@ -862 +844 @@
         msg->dataptr = dataptr;
         
-        msg->wdata.inlist = false;
+        msg->wdata.to_event.inlist = false;
         /* We may sleep in next method, but it will use its own mechanism */
         msg->wdata.active = true;
@@ -891 +873 @@
         msg->wdata.fid = fibril_get_id();
         msg->wdata.active = false;
-        msg->wdata.inlist = false;
+        msg->wdata.to_event.inlist = false;
         
         /* Leave the async_futex locked when entering this function */
@@ -929 +911 @@
         }
         
-        gettimeofday(&msg->wdata.expires, NULL);
-        tv_add(&msg->wdata.expires, timeout);
+        gettimeofday(&msg->wdata.to_event.expires, NULL);
+        tv_add(&msg->wdata.to_event.expires, timeout);
         
         msg->wdata.fid = fibril_get_id();
         msg->wdata.active = false;
-        insert_timeout(&msg->wdata);
+        async_insert_timeout(&msg->wdata);
         
         /* Leave the async_futex locked when entering this function */
@@ -970 +952 @@
         msg->wdata.active = false;
         
-        gettimeofday(&msg->wdata.expires, NULL);
-        tv_add(&msg->wdata.expires, timeout);
+        gettimeofday(&msg->wdata.to_event.expires, NULL);
+        tv_add(&msg->wdata.to_event.expires, timeout);
         
         futex_down(&async_futex);
         
-        insert_timeout(&msg->wdata);
+        async_insert_timeout(&msg->wdata);
         
         /* Leave the async_futex locked when entering this function */
@@ -1105 +1087 @@
 }
 
+/** 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);
+}
+
 /** @}
  */

uspace/lib/libc/generic/devmap.c

@@ -105 +105 @@
         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 +143 @@
             &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 +180 @@
             &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 +271 @@
         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) {

uspace/lib/libc/generic/fibril_sync.c

@@ -36 +36 @@
 #include <fibril.h>
 #include <async.h>
+#include <async_priv.h>
 #include <adt/list.h>
 #include <futex.h>
+#include <sys/time.h>
+#include <errno.h>
 #include <assert.h>
 
@@ -63 +66 @@
         futex_down(&async_futex);
         if (fm->counter-- <= 0) {
-                fibril_t *f = (fibril_t *) fibril_get_id();
-                list_append(&f->link, &fm->waiters);
+                awaiter_t wdata;
+
+                wdata.fid = fibril_get_id();
+                wdata.active = false;
+                wdata.wu_event.inlist = true;
+                link_initialize(&wdata.wu_event.link);
+                list_append(&wdata.wu_event.link, &fm->waiters);
                 fibril_switch(FIBRIL_TO_MANAGER);
         } else {
@@ -90 +98 @@
         if (fm->counter++ < 0) {
                 link_t *tmp;
-                fibril_t *f;
+                awaiter_t *wdp;
         
                 assert(!list_empty(&fm->waiters));
                 tmp = fm->waiters.next;
-                f = list_get_instance(tmp, fibril_t, link);
-                list_remove(&f->link);
-                fibril_add_ready((fid_t) f);
+                wdp = list_get_instance(tmp, awaiter_t, wu_event.link);
+                wdp->active = true;
+                wdp->wu_event.inlist = false;
+                list_remove(&wdp->wu_event.link);
+                fibril_add_ready(wdp->fid);
                 optimize_execution_power();
         }
@@ -120 +130 @@
         if (frw->writers) {
                 fibril_t *f = (fibril_t *) fibril_get_id();
+                awaiter_t wdata;
+
+                wdata.fid = (fid_t) f;
+                wdata.active = false;
+                wdata.wu_event.inlist = true;
+                link_initialize(&wdata.wu_event.link);
                 f->flags &= ~FIBRIL_WRITER;
-                list_append(&f->link, &frw->waiters);
+                list_append(&wdata.wu_event.link, &frw->waiters);
                 fibril_switch(FIBRIL_TO_MANAGER);
         } else {
@@ -134 +150 @@
         if (frw->writers || frw->readers) {
                 fibril_t *f = (fibril_t *) fibril_get_id();
+                awaiter_t wdata;
+
+                wdata.fid = (fid_t) f;
+                wdata.active = false;
+                wdata.wu_event.inlist = true;
+                link_initialize(&wdata.wu_event.link);
                 f->flags |= FIBRIL_WRITER;
-                list_append(&f->link, &frw->waiters);
+                list_append(&wdata.wu_event.link, &frw->waiters);
                 fibril_switch(FIBRIL_TO_MANAGER);
         } else {
@@ -158 +180 @@
         while (!list_empty(&frw->waiters)) {
                 link_t *tmp = frw->waiters.next;
-                fibril_t *f = list_get_instance(tmp, fibril_t, link);
+                awaiter_t *wdp;
+                fibril_t *f;
+                
+                wdp = list_get_instance(tmp, awaiter_t, wu_event.link);
+                f = (fibril_t *) wdp->fid;
                 
                 if (f->flags & FIBRIL_WRITER) {
                         if (frw->readers)
                                 break;
-                        list_remove(&f->link);
-                        fibril_add_ready((fid_t) f);
+                        wdp->active = true;
+                        wdp->wu_event.inlist = false;
+                        list_remove(&wdp->wu_event.link);
+                        fibril_add_ready(wdp->fid);
                         frw->writers++;
                         optimize_execution_power();
                         break;
                 } else {
-                        list_remove(&f->link);
-                        fibril_add_ready((fid_t) f);
+                        wdp->active = true;
+                        wdp->wu_event.inlist = false;
+                        list_remove(&wdp->wu_event.link);
+                        fibril_add_ready(wdp->fid);
                         frw->readers++;
                         optimize_execution_power();
@@ -194 +224 @@
 }
 
-void fibril_condvar_wait(fibril_condvar_t *fcv, fibril_mutex_t *fm)
-{
-        fibril_t *f = (fibril_t *) fibril_get_id();
-
-        futex_down(&async_futex);
-        list_append(&f->link, &fcv->waiters);
+int
+fibril_condvar_wait_timeout(fibril_condvar_t *fcv, fibril_mutex_t *fm,
+    suseconds_t timeout)
+{
+        awaiter_t wdata;
+
+        if (timeout < 0)
+                return ETIMEOUT;
+
+        wdata.fid = fibril_get_id();
+        wdata.active = false;
+        
+        wdata.to_event.inlist = timeout > 0;
+        wdata.to_event.occurred = false;
+        link_initialize(&wdata.to_event.link);
+
+        wdata.wu_event.inlist = true;
+        link_initialize(&wdata.wu_event.link);
+
+        futex_down(&async_futex);
+        if (timeout) {
+                gettimeofday(&wdata.to_event.expires, NULL);
+                tv_add(&wdata.to_event.expires, timeout);
+                async_insert_timeout(&wdata);
+        }
+        list_append(&wdata.wu_event.link, &fcv->waiters);
         _fibril_mutex_unlock_unsafe(fm);
         fibril_switch(FIBRIL_TO_MANAGER);
         fibril_mutex_lock(fm);
+
+        /* async_futex not held after fibril_switch() */
+        futex_down(&async_futex);
+        if (wdata.to_event.inlist)
+                list_remove(&wdata.to_event.link);
+        if (wdata.wu_event.inlist)
+                list_remove(&wdata.wu_event.link);
+        futex_up(&async_futex);
+        
+        return wdata.to_event.occurred ? ETIMEOUT : EOK;
+}
+
+void fibril_condvar_wait(fibril_condvar_t *fcv, fibril_mutex_t *fm)
+{
+        int rc;
+
+        rc = fibril_condvar_wait_timeout(fcv, fm, 0);
+        assert(rc == EOK);
 }
 
@@ -208 +276 @@
 {
         link_t *tmp;
-        fibril_t *f;
+        awaiter_t *wdp;
 
         futex_down(&async_futex);
         while (!list_empty(&fcv->waiters)) {
                 tmp = fcv->waiters.next;
-                f = list_get_instance(tmp, fibril_t, link);
-                list_remove(&f->link);
-                fibril_add_ready((fid_t) f);
-                optimize_execution_power();
-                if (once)
-                        break;
+                wdp = list_get_instance(tmp, awaiter_t, wu_event.link);
+                list_remove(&wdp->wu_event.link);
+                wdp->wu_event.inlist = false;
+                if (!wdp->active) {
+                        wdp->active = true;
+                        fibril_add_ready(wdp->fid);
+                        optimize_execution_power();
+                        if (once)
+                                break;
+                }
         }
         futex_up(&async_futex);

uspace/lib/libc/generic/ipc.c

@@ -730 +730 @@
         int res;
         sysarg_t tmp_flags;
-        res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
+        res = ipc_call_sync_3_2(phoneid, IPC_M_SHARE_IN, (ipcarg_t) dst,
             (ipcarg_t) size, arg, NULL, &tmp_flags);
         if (flags)
@@ -737 +737 @@
 }
 
-/** Wrapper for receiving the IPC_M_SHARE_IN calls.
- *
- * 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 ipc_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.
  *
@@ -790 +763 @@
 int ipc_share_out_start(int phoneid, void *src, int flags)
 {
-        return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
+        return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (ipcarg_t) src, 0,
             (ipcarg_t) flags);
-}
-
-/** Wrapper for receiving the IPC_M_SHARE_OUT calls.
- *
- * 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 ipc_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;
 }
 
@@ -851 +793 @@
 int ipc_data_read_start(int phoneid, void *dst, size_t size)
 {
-        return async_req_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
+        return ipc_call_sync_2_0(phoneid, IPC_M_DATA_READ, (ipcarg_t) dst,
             (ipcarg_t) size);
-}
-
-/** Wrapper for receiving the IPC_M_DATA_READ calls.
- *
- * 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 ipc_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;
 }
 
@@ -910 +824 @@
 int ipc_data_write_start(int phoneid, const void *src, size_t size)
 {
-        return async_req_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
+        return ipc_call_sync_2_0(phoneid, IPC_M_DATA_WRITE, (ipcarg_t) src,
             (ipcarg_t) size);
-}
-
-/** Wrapper for receiving the IPC_M_DATA_WRITE calls.
- *
- * 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 ipc_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;
 }
 

uspace/lib/libc/generic/loader.c

@@ -90 +90 @@
         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 +123 @@
         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 +178 @@
         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 +232 @@
         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) {

uspace/lib/libc/generic/vfs/vfs.c

@@ -140 +140 @@
         
         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 +152 @@
         }
         
-        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 +164 @@
         }
 
-        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 +213 @@
         
         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 +290 @@
         
         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 +322 @@
         
         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 +402 @@
         
         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 +437 @@
         
         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 +448 @@
                         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 +514 @@
         
         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 +549 @@
         
         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 +602 @@
         
         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 +614 @@
                         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);

uspace/lib/libc/include/async.h

@@ -259 +259 @@
 }
 
+/*
+ * 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
 

uspace/lib/libc/include/fibril_sync.h

@@ -40 +40 @@
 #include <adt/list.h>
 #include <libarch/tls.h>
+#include <sys/time.h>
 
 typedef struct {
@@ -95 +96 @@
 
 extern void fibril_condvar_initialize(fibril_condvar_t *);
+extern int fibril_condvar_wait_timeout(fibril_condvar_t *, fibril_mutex_t *,
+    suseconds_t);
 extern void fibril_condvar_wait(fibril_condvar_t *, fibril_mutex_t *);
 extern void fibril_condvar_signal(fibril_condvar_t *);

uspace/lib/libc/include/ipc/ipc.h

@@ -283 +283 @@
 
 extern int ipc_share_in_start(int, void *, size_t, ipcarg_t, int *);
-extern int ipc_share_in_receive(ipc_callid_t *, size_t *);
 extern int ipc_share_in_finalize(ipc_callid_t, void *, int );
 extern int ipc_share_out_start(int, void *, int);
-extern int ipc_share_out_receive(ipc_callid_t *, size_t *, int *);
 extern int ipc_share_out_finalize(ipc_callid_t, void *);
 extern int ipc_data_read_start(int, void *, size_t);
-extern int ipc_data_read_receive(ipc_callid_t *, size_t *);
 extern int ipc_data_read_finalize(ipc_callid_t, const void *, size_t);
 extern int ipc_data_write_start(int, const void *, size_t);
-extern int ipc_data_write_receive(ipc_callid_t *, size_t *);
 extern int ipc_data_write_finalize(ipc_callid_t, void *, size_t);
 

uspace/lib/libfs/libfs.c

@@ -91 +91 @@
          * 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 +114 @@
          * 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 +169 @@
         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 +486 @@
         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 +503 @@
         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);
 }

uspace/srv/bd/ata_bd/ata_bd.c

@@ -252 +252 @@
         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 +263 @@
         }
 
-        (void) ipc_share_out_finalize(callid, fs_va);
+        (void) async_share_out_finalize(callid, fs_va);
 
         while (1) {

uspace/srv/bd/file_bd/file_bd.c

@@ -130 +130 @@
         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 +141 @@
         }
 
-        (void) ipc_share_out_finalize(callid, fs_va);
+        (void) async_share_out_finalize(callid, fs_va);
 
         while (1) {

uspace/srv/bd/gxe_bd/gxe_bd.c

@@ -185 +185 @@
         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 +201 @@
         }
 
-        (void) ipc_share_out_finalize(callid, fs_va);
+        (void) async_share_out_finalize(callid, fs_va);
 
         while (1) {

uspace/srv/bd/rd/rd.c

@@ -102 +102 @@
          */
         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);

uspace/srv/console/console.c

@@ -429 +429 @@
         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 +442 @@
         }
         
-        (void) ipc_data_write_finalize(callid, buf, size);
+        (void) async_data_write_finalize(callid, buf, size);
         
         async_serialize_start();
@@ -464 +464 @@
         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 +489 @@
         
         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 +713 @@
         
         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);

uspace/srv/console/gcons.c

@@ -339 +339 @@
                 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 +409 @@
                 goto exit;
         
-        rc = ipc_share_out_start(fbphone, shm, PROTO_READ);
+        rc = async_share_out_start(fbphone, shm, PROTO_READ);
         if (rc)
                 goto drop;

uspace/srv/devmap/devmap.c

@@ -213 +213 @@
         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 +241 @@
          * 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 +358 @@
         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 +381 @@
         }
         
-        ipc_data_write_finalize(callid, device->name, size);
+        async_data_write_finalize(callid, device->name, size);
         device->name[size] = 0;
         
@@ -466 +466 @@
         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 +491 @@
          * 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 +553 @@
          * 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 +576 @@
         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 +608 @@
         }
         
-        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);

uspace/srv/fs/devfs/devfs_ops.c

@@ -108 +108 @@
         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 +121 @@
         }
         
-        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 +286 @@
         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 +315 @@
         }
 
-        ipc_data_read_finalize(callid, &stat, sizeof(struct stat));
+        async_data_read_finalize(callid, &stat, sizeof(struct stat));
         ipc_answer_0(rid, EOK);
 }
@@ -340 +340 @@
                 
                 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 +367 @@
                 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 +384 @@
                 
                 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 +418 @@
                 
                 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);

uspace/srv/fs/fat/fat_ops.c

@@ -897 +897 @@
         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 +908 @@
                 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 +1047 @@
         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 +1066 @@
                         /* 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 +1073 @@
                             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 +1131 @@
                 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 +1169 @@
         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 +1204 @@
                 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 +1241 @@
                     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 */

uspace/srv/fs/tmpfs/tmpfs_ops.c

@@ -389 +389 @@
         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 +400 @@
                 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 +467 @@
         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 +476 @@
         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 +503 @@
                 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 +541 @@
         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 +552 @@
         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 +574 @@
         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);
 }

uspace/srv/loader/main.c

@@ -102 +102 @@
         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 +111 @@
                 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 +127 @@
         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 +140 @@
         }
         
-        ipc_data_write_finalize(callid, name_buf, len);
+        async_data_write_finalize(callid, name_buf, len);
         ipc_answer_0(rid, EOK);
         
@@ -164 +164 @@
         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 +187 @@
         }
         
-        ipc_data_write_finalize(callid, arg_buf, buf_size);
+        async_data_write_finalize(callid, arg_buf, buf_size);
         
         arg_buf[buf_size] = '\0';
@@ -239 +239 @@
         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 +268 @@
         }
         
-        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);

uspace/srv/part/mbr_part/mbr_part.c

@@ -419 +419 @@
         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 +430 @@
         }
 
-        (void) ipc_share_out_finalize(callid, fs_va);
+        (void) async_share_out_finalize(callid, fs_va);
 
         while (1) {

uspace/srv/vfs/vfs_ops.c

@@ -125 +125 @@
                             (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 +207 @@
         
         /* 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 +268 @@
         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 +290 @@
         
         /* 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 +299 @@
         
         /* 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 +324 @@
 
         /* 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 +337 @@
          * 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 +370 @@
         
         /* 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 +469 @@
         
         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 +483 @@
         
         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 +747 @@
         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 +943 @@
 
         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 +969 @@
         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 +981 @@
         }
         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 +988 @@
         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 +1037 @@
         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 +1049 @@
         }
         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 +1074 @@
         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 +1086 @@
         }
         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 +1125 @@
 
         /* 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 +1136 @@
                 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 +1144 @@
         
         /* 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 +1157 @@
                 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);

uspace/srv/vfs/vfs_register.c

@@ -122 +122 @@
          * 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 +163 @@
         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 +229 @@
          */
 
-        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 +257 @@
          * 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);