Changeset f307f12 in mainline for uspace/lib/libc

Timestamp:

2009-10-11T16:26:01Z (16 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/lib/libc

Files:

• generic/async.c (modified) (16 diffs)
• generic/devmap.c (modified) (4 diffs)
• generic/fibril_sync.c (modified) (8 diffs)
• generic/ipc.c (modified) (5 diffs)
• generic/loader.c (modified) (4 diffs)
• generic/vfs/vfs.c (modified) (13 diffs)
• include/async.h (modified) (1 diff)
• include/async_priv.h (added)
• include/fibril_sync.h (modified) (2 diffs)
• include/ipc/ipc.h (modified) (1 diff)

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);