Changeset ad7a6c9 in mainline for uspace/lib/c/generic/async.c

Timestamp:

2011-03-30T13:10:24Z (14 years ago)

Author:

Vojtech Horky <vojtechhorky@…>

Branches:

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

Children:

4ae90f9

Parents:

6e50466 (diff), d6b81941 (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 mainline changes

File:

• uspace/lib/c/generic/async.c (modified) (49 diffs)

uspace/lib/c/generic/async.c

@@ -43 +43 @@
  * framework will automatically take care of most synchronization problems.
  *
- * Default semantics:
- * - async_send_*(): Send asynchronously. If the kernel refuses to send
- *                   more messages, [ try to get responses from kernel, if
- *                   nothing found, might try synchronous ]
- *
  * Example of use (pseudo C):
  *
@@ -58 +53 @@
  *   int fibril1(void *arg)
  *   {
- *     conn = ipc_connect_me_to();
+ *     conn = async_connect_me_to();
  *     c1 = async_send(conn);
  *     c2 = async_send(conn);
@@ -77 +72 @@
  *   {
  *     if (want_refuse) {
- *       ipc_answer_0(icallid, ELIMIT);
+ *       async_answer_0(icallid, ELIMIT);
  *       return;
  *     }
- *     ipc_answer_0(icallid, EOK);
+ *     async_answer_0(icallid, EOK);
  *
  *     callid = async_get_call(&call);
  *     somehow_handle_the_call(callid, call);
- *     ipc_answer_2(callid, 1, 2, 3);
+ *     async_answer_2(callid, 1, 2, 3);
  *
  *     callid = async_get_call(&call);
@@ -92 +87 @@
  */
 
+#define LIBC_ASYNC_C_
+#include <ipc/ipc.h>
+#include <async.h>
+#undef LIBC_ASYNC_C_
+
 #include <futex.h>
-#include <async.h>
-#include <async_priv.h>
 #include <fibril.h>
 #include <stdio.h>
 #include <adt/hash_table.h>
 #include <adt/list.h>
-#include <ipc/ipc.h>
 #include <assert.h>
 #include <errno.h>
@@ -105 +102 @@
 #include <arch/barrier.h>
 #include <bool.h>
+#include "private/async.h"
 
 atomic_t async_futex = FUTEX_INITIALIZER;
@@ -124 +122 @@
 
 /**
- * Structures of this type are used to group information about a call and a
- * message queue link.
+ * Structures of this type are used to group information about
+ * a call and about a message queue link.
  */
 typedef struct {
@@ -134 +132 @@
 
 typedef struct {
+        sysarg_t in_task_hash;
+        link_t link;
+        int refcnt;
+        void *data;
+} client_t;
+
+typedef struct {
         awaiter_t wdata;
         
@@ -139 +144 @@
         link_t link;
         
+        /** Incoming client task hash. */
+        sysarg_t in_task_hash;
         /** Incoming phone hash. */
         sysarg_t in_phone_hash;
+        
+        /** Link to the client tracking structure. */
+        client_t *client;
         
         /** Messages that should be delivered to this fibril. */
@@ -158 +168 @@
 
 /** Identifier of the incoming connection handled by the current fibril. */
-fibril_local connection_t *FIBRIL_connection;
-
-static void default_client_connection(ipc_callid_t callid, ipc_call_t *call);
-static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call);
+static fibril_local connection_t *FIBRIL_connection;
+
+static void *default_client_data_constructor(void)
+{
+        return NULL;
+}
+
+static void default_client_data_destructor(void *data)
+{
+}
+
+static async_client_data_ctor_t async_client_data_create =
+    default_client_data_constructor;
+static async_client_data_dtor_t async_client_data_destroy =
+    default_client_data_destructor;
+
+void async_set_client_data_constructor(async_client_data_ctor_t ctor)
+{
+        async_client_data_create = ctor;
+}
+
+void async_set_client_data_destructor(async_client_data_dtor_t dtor)
+{
+        async_client_data_destroy = dtor;
+}
+
+void *async_client_data_get(void)
+{
+        assert(FIBRIL_connection);
+        return FIBRIL_connection->client->data;
+}
+
+/** Default fibril function that gets called to handle new connection.
+ *
+ * This function is defined as a weak symbol - to be redefined in user code.
+ *
+ * @param callid Hash of the incoming call.
+ * @param call   Data of the incoming call.
+ *
+ */
+static void default_client_connection(ipc_callid_t callid, ipc_call_t *call)
+{
+        ipc_answer_0(callid, ENOENT);
+}
 
 /**
@@ -167 +217 @@
  */
 static async_client_conn_t client_connection = default_client_connection;
+
+/** Default fibril function that gets called to handle interrupt notifications.
+ *
+ * This function is defined as a weak symbol - to be redefined in user code.
+ *
+ * @param callid Hash of the incoming call.
+ * @param call   Data of the incoming call.
+ *
+ */
+static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call)
+{
+}
 
 /**
@@ -174 +236 @@
 static async_client_conn_t interrupt_received = default_interrupt_received;
 
+static hash_table_t client_hash_table;
 static hash_table_t conn_hash_table;
 static LIST_INITIALIZE(timeout_list);
 
-#define CONN_HASH_TABLE_CHAINS  32
+#define CLIENT_HASH_TABLE_BUCKETS  32
+#define CONN_HASH_TABLE_BUCKETS    32
+
+static hash_index_t client_hash(unsigned long key[])
+{
+        assert(key);
+        return (((key[0]) >> 4) % CLIENT_HASH_TABLE_BUCKETS);
+}
+
+static int client_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
+        client_t *client = hash_table_get_instance(item, client_t, link);
+        return (key[0] == client->in_task_hash);
+}
+
+static void client_remove(link_t *item)
+{
+}
+
+/** Operations for the client hash table. */
+static hash_table_operations_t client_hash_table_ops = {
+        .hash = client_hash,
+        .compare = client_compare,
+        .remove_callback = client_remove
+};
 
 /** Compute hash into the connection hash table based on the source phone hash.
@@ -186 +273 @@
  *
  */
-static hash_index_t conn_hash(unsigned long *key)
+static hash_index_t conn_hash(unsigned long key[])
 {
         assert(key);
-        return (((*key) >> 4) % CONN_HASH_TABLE_CHAINS);
+        return (((key[0]) >> 4) % CONN_HASH_TABLE_BUCKETS);
 }
 
@@ -203 +290 @@
 static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item)
 {
-        connection_t *hs = hash_table_get_instance(item, connection_t, link);
-        return (key[0] == hs->in_phone_hash);
-}
-
-/** Connection hash table removal callback function.
- *
- * This function is called whenever a connection is removed from the connection
- * hash table.
- *
- * @param item Connection hash table item being removed.
- *
- */
+        connection_t *conn = hash_table_get_instance(item, connection_t, link);
+        return (key[0] == conn->in_phone_hash);
+}
+
 static void conn_remove(link_t *item)
 {
-        free(hash_table_get_instance(item, connection_t, link));
-}
-
+}
 
 /** Operations for the connection hash table. */
@@ -240 +317 @@
         link_t *tmp = timeout_list.next;
         while (tmp != &timeout_list) {
-                awaiter_t *cur;
-                
-                cur = list_get_instance(tmp, awaiter_t, to_event.link);
+                awaiter_t *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;
         }
@@ -261 +339 @@
  *
  * @return False if the call doesn't match any connection.
- *         True if the call was passed to the respective connection fibril.
+ * @return True if the call was passed to the respective connection fibril.
  *
  */
@@ -352 +430 @@
         
         fid_t fid = fibril_create(notification_fibril, msg);
+        if (fid == 0) {
+                free(msg);
+                futex_up(&async_futex);
+                return false;
+        }
+        
         fibril_add_ready(fid);
         
@@ -398 +482 @@
                          * the first IPC_M_PHONE_HUNGUP call and continues to
                          * call async_get_call_timeout(). Repeat
-                         * IPC_M_PHONE_HUNGUP until the caller notices. 
+                         * IPC_M_PHONE_HUNGUP until the caller notices.
                          */
                         memset(call, 0, sizeof(ipc_call_t));
@@ -405 +489 @@
                         return conn->close_callid;
                 }
-
+                
                 if (usecs)
                         async_insert_timeout(&conn->wdata);
@@ -443 +527 @@
 }
 
-/** Default fibril function that gets called to handle new connection.
- *
- * This function is defined as a weak symbol - to be redefined in user code.
- *
- * @param callid Hash of the incoming call.
- * @param call   Data of the incoming call.
- *
- */
-static void default_client_connection(ipc_callid_t callid, ipc_call_t *call)
-{
-        ipc_answer_0(callid, ENOENT);
-}
-
-/** Default fibril function that gets called to handle interrupt notifications.
- *
- * This function is defined as a weak symbol - to be redefined in user code.
- *
- * @param callid Hash of the incoming call.
- * @param call   Data of the incoming call.
- *
- */
-static void default_interrupt_received(ipc_callid_t callid, ipc_call_t *call)
-{
-}
-
 /** Wrapper for client connection fibril.
  *
@@ -481 +540 @@
 {
         /*
-         * Setup fibril-local connection pointer and call client_connection().
-         *
+         * Setup fibril-local connection pointer.
          */
         FIBRIL_connection = (connection_t *) arg;
+        
+        futex_down(&async_futex);
+        
+        /*
+         * Add our reference for the current connection in the client task
+         * tracking structure. If this is the first reference, create and
+         * hash in a new tracking structure.
+         */
+        
+        unsigned long key = FIBRIL_connection->in_task_hash;
+        link_t *lnk = hash_table_find(&client_hash_table, &key);
+        
+        client_t *client;
+        
+        if (lnk) {
+                client = hash_table_get_instance(lnk, client_t, link);
+                client->refcnt++;
+        } else {
+                client = malloc(sizeof(client_t));
+                if (!client) {
+                        ipc_answer_0(FIBRIL_connection->callid, ENOMEM);
+                        futex_up(&async_futex);
+                        return 0;
+                }
+                
+                client->in_task_hash = FIBRIL_connection->in_task_hash;
+                
+                async_serialize_start();
+                client->data = async_client_data_create();
+                async_serialize_end();
+                
+                client->refcnt = 1;
+                hash_table_insert(&client_hash_table, &key, &client->link);
+        }
+        
+        futex_up(&async_futex);
+        
+        FIBRIL_connection->client = client;
+        
+        /*
+         * Call the connection handler function.
+         */
         FIBRIL_connection->cfibril(FIBRIL_connection->callid,
             &FIBRIL_connection->call);
         
-        /* Remove myself from the connection hash table */
+        /*
+         * Remove the reference for this client task connection.
+         */
+        bool destroy;
+        
         futex_down(&async_futex);
-        unsigned long key = FIBRIL_connection->in_phone_hash;
+        
+        if (--client->refcnt == 0) {
+                hash_table_remove(&client_hash_table, &key, 1);
+                destroy = true;
+        } else
+                destroy = false;
+        
+        futex_up(&async_futex);
+        
+        if (destroy) {
+                if (client->data)
+                        async_client_data_destroy(client->data);
+                
+                free(client);
+        }
+        
+        /*
+         * Remove myself from the connection hash table.
+         */
+        futex_down(&async_futex);
+        key = FIBRIL_connection->in_phone_hash;
         hash_table_remove(&conn_hash_table, &key, 1);
         futex_up(&async_futex);
         
-        /* Answer all remaining messages with EHANGUP */
+        /*
+         * Answer all remaining messages with EHANGUP.
+         */
         while (!list_empty(&FIBRIL_connection->msg_queue)) {
-                msg_t *msg;
-                
-                msg = list_get_instance(FIBRIL_connection->msg_queue.next,
-                    msg_t, link);
+                msg_t *msg =
+                    list_get_instance(FIBRIL_connection->msg_queue.next, msg_t,
+                    link);
+                
                 list_remove(&msg->link);
                 ipc_answer_0(msg->callid, EHANGUP);
@@ -505 +631 @@
         }
         
+        /*
+         * If the connection was hung-up, answer the last call,
+         * i.e. IPC_M_PHONE_HUNGUP.
+         */
         if (FIBRIL_connection->close_callid)
                 ipc_answer_0(FIBRIL_connection->close_callid, EOK);
         
+        free(FIBRIL_connection);
         return 0;
 }
@@ -517 +648 @@
  * particular fibrils.
  *
+ * @param in_task_hash  Identification of the incoming connection.
  * @param in_phone_hash Identification of the incoming connection.
  * @param callid        Hash of the opening IPC_M_CONNECT_ME_TO call.
@@ -529 +661 @@
  *
  */
-fid_t async_new_connection(sysarg_t in_phone_hash, ipc_callid_t callid,
-    ipc_call_t *call, void (*cfibril)(ipc_callid_t, ipc_call_t *))
+fid_t async_new_connection(sysarg_t in_task_hash, sysarg_t in_phone_hash,
+    ipc_callid_t callid, ipc_call_t *call,
+    void (*cfibril)(ipc_callid_t, ipc_call_t *))
 {
         connection_t *conn = malloc(sizeof(*conn));
@@ -536 +669 @@
                 if (callid)
                         ipc_answer_0(callid, ENOMEM);
+                
                 return (uintptr_t) NULL;
         }
         
+        conn->in_task_hash = in_task_hash;
         conn->in_phone_hash = in_phone_hash;
         list_initialize(&conn->msg_queue);
@@ -552 +687 @@
         conn->wdata.fid = fibril_create(connection_fibril, conn);
         
-        if (!conn->wdata.fid) {
+        if (conn->wdata.fid == 0) {
                 free(conn);
+                
                 if (callid)
                         ipc_answer_0(callid, ENOMEM);
+                
                 return (uintptr_t) NULL;
         }
@@ -582 +719 @@
 static void handle_call(ipc_callid_t callid, ipc_call_t *call)
 {
-        /* Unrouted call - do some default behaviour */
+        /* Unrouted call - take some default action */
         if ((callid & IPC_CALLID_NOTIFICATION)) {
                 process_notification(callid, call);
-                goto out;
+                return;
         }
         
@@ -591 +728 @@
         case IPC_M_CONNECT_ME:
         case IPC_M_CONNECT_ME_TO:
-                /* Open new connection with fibril etc. */
-                async_new_connection(IPC_GET_ARG5(*call), callid, call,
-                    client_connection);
-                goto out;
+                /* Open new connection with fibril, etc. */
+                async_new_connection(call->in_task_hash, IPC_GET_ARG5(*call),
+                    callid, call, client_connection);
+                return;
         }
         
         /* Try to route the call through the connection hash table */
         if (route_call(callid, call))
-                goto out;
+                return;
         
         /* Unknown call from unknown phone - hang it up */
         ipc_answer_0(callid, EHANGUP);
-        return;
-        
-out:
-        ;
 }
 
@@ -619 +752 @@
         link_t *cur = timeout_list.next;
         while (cur != &timeout_list) {
-                awaiter_t *waiter;
-                
-                waiter = list_get_instance(cur, awaiter_t, to_event.link);
+                awaiter_t *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->to_event.link);
                 waiter->to_event.inlist = false;
@@ -653 +786 @@
         while (true) {
                 if (fibril_switch(FIBRIL_FROM_MANAGER)) {
-                        futex_up(&async_futex); 
+                        futex_up(&async_futex);
                         /*
                          * async_futex is always held when entering a manager
@@ -676 +809 @@
                                 continue;
                         } else
-                                timeout = tv_sub(&waiter->to_event.expires,
-                                    &tv);
+                                timeout = tv_sub(&waiter->to_event.expires, &tv);
                 } else
                         timeout = SYNCH_NO_TIMEOUT;
                 
                 futex_up(&async_futex);
-
+                
                 atomic_inc(&threads_in_ipc_wait);
                 
@@ -690 +822 @@
                 
                 atomic_dec(&threads_in_ipc_wait);
-
+                
                 if (!callid) {
                         handle_expired_timeouts();
@@ -729 +861 @@
 {
         fid_t fid = fibril_create(async_manager_fibril, NULL);
-        fibril_add_manager(fid);
+        if (fid != 0)
+                fibril_add_manager(fid);
 }
 
@@ -740 +873 @@
 /** Initialize the async framework.
  *
- * @return Zero on success or an error code.
- */
-int __async_init(void)
-{
-        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_CHAINS, 1,
-            &conn_hash_table_ops)) {
-                printf("%s: Cannot create async hash table\n", "libc");
-                return ENOMEM;
-        }
-        
-        return 0;
+ */
+void __async_init(void)
+{
+        if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS, 1,
+            &client_hash_table_ops))
+                abort();
+        
+        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS, 1,
+            &conn_hash_table_ops))
+                abort();
 }
 
@@ -763 +895 @@
  * @param retval Value returned in the answer.
  * @param data   Call data of the answer.
+ *
  */
 static void reply_received(void *arg, int retval, ipc_call_t *data)
@@ -810 +943 @@
     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr)
 {
-        amsg_t *msg = malloc(sizeof(*msg));
+        amsg_t *msg = malloc(sizeof(amsg_t));
         
         if (!msg)
@@ -819 +952 @@
         
         msg->wdata.to_event.inlist = false;
-        /* We may sleep in the next method, but it will use its own mechanism */
+        
+        /*
+         * We may sleep in the next method,
+         * but it will use its own means
+         */
         msg->wdata.active = true;
         
@@ -850 +987 @@
     ipc_call_t *dataptr)
 {
-        amsg_t *msg = malloc(sizeof(*msg));
+        amsg_t *msg = malloc(sizeof(amsg_t));
         
         if (!msg)
@@ -859 +996 @@
         
         msg->wdata.to_event.inlist = false;
-        /* We may sleep in next method, but it will use its own mechanism */
+        
+        /*
+         * We may sleep in the next method,
+         * but it will use its own means
+         */
         msg->wdata.active = true;
         
@@ -958 +1099 @@
 void async_usleep(suseconds_t timeout)
 {
-        amsg_t *msg = malloc(sizeof(*msg));
+        amsg_t *msg = malloc(sizeof(amsg_t));
         
         if (!msg)
@@ -1101 +1242 @@
 }
 
+void async_msg_0(int phone, sysarg_t imethod)
+{
+        ipc_call_async_0(phone, imethod, NULL, NULL, true);
+}
+
+void async_msg_1(int phone, sysarg_t imethod, sysarg_t arg1)
+{
+        ipc_call_async_1(phone, imethod, arg1, NULL, NULL, true);
+}
+
+void async_msg_2(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2)
+{
+        ipc_call_async_2(phone, imethod, arg1, arg2, NULL, NULL, true);
+}
+
+void async_msg_3(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3)
+{
+        ipc_call_async_3(phone, imethod, arg1, arg2, arg3, NULL, NULL, true);
+}
+
+void async_msg_4(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3, sysarg_t arg4)
+{
+        ipc_call_async_4(phone, imethod, arg1, arg2, arg3, arg4, NULL, NULL,
+            true);
+}
+
+void async_msg_5(int phone, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
+{
+        ipc_call_async_5(phone, imethod, arg1, arg2, arg3, arg4, arg5, NULL,
+            NULL, true);
+}
+
+sysarg_t async_answer_0(ipc_callid_t callid, sysarg_t retval)
+{
+        return ipc_answer_0(callid, retval);
+}
+
+sysarg_t async_answer_1(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1)
+{
+        return ipc_answer_1(callid, retval, arg1);
+}
+
+sysarg_t async_answer_2(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
+    sysarg_t arg2)
+{
+        return ipc_answer_2(callid, retval, arg1, arg2);
+}
+
+sysarg_t async_answer_3(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3)
+{
+        return ipc_answer_3(callid, retval, arg1, arg2, arg3);
+}
+
+sysarg_t async_answer_4(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
+{
+        return ipc_answer_4(callid, retval, arg1, arg2, arg3, arg4);
+}
+
+sysarg_t async_answer_5(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
+{
+        return ipc_answer_5(callid, retval, arg1, arg2, arg3, arg4, arg5);
+}
+
+int async_forward_fast(ipc_callid_t callid, int phoneid, sysarg_t imethod,
+    sysarg_t arg1, sysarg_t arg2, unsigned int mode)
+{
+        return ipc_forward_fast(callid, phoneid, imethod, arg1, arg2, mode);
+}
+
+int async_forward_slow(ipc_callid_t callid, int phoneid, sysarg_t imethod,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
+    unsigned int mode)
+{
+        return ipc_forward_slow(callid, phoneid, imethod, arg1, arg2, arg3, arg4,
+            arg5, mode);
+}
+
+/** Wrapper for making IPC_M_CONNECT_TO_ME calls using the async framework.
+ *
+ * Ask through phone for a new connection to some service.
+ *
+ * @param phone           Phone handle used for contacting the other side.
+ * @param arg1            User defined argument.
+ * @param arg2            User defined argument.
+ * @param arg3            User defined argument.
+ * @param client_receiver Connection handing routine.
+ *
+ * @return New phone handle on success or a negative error code.
+ *
+ */
+int async_connect_to_me(int phone, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3, async_client_conn_t client_receiver)
+{
+        sysarg_t task_hash;
+        sysarg_t phone_hash;
+        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
+            NULL, NULL, NULL, &task_hash, &phone_hash);
+        if (rc != EOK)
+                return rc;
+        
+        if (client_receiver != NULL)
+                async_new_connection(task_hash, phone_hash, 0, NULL,
+                    client_receiver);
+        
+        return EOK;
+}
+
 /** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework.
- * 
+ *
  * Ask through phone for a new connection to some service.
  *
- * @param phoneid       Phone handle used for contacting the other side.
- * @param arg1          User defined argument.
- * @param arg2          User defined argument.
- * @param arg3          User defined argument.
- *
- * @return              New phone handle on success or a negative error code.
- */
-int
-async_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
-{
-        int rc;
+ * @param phone Phone handle used for contacting the other side.
+ * @param arg1  User defined argument.
+ * @param arg2  User defined argument.
+ * @param arg3  User defined argument.
+ *
+ * @return New phone handle on success or a negative error code.
+ *
+ */
+int async_connect_me_to(int phone, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3)
+{
         sysarg_t newphid;
-
-        rc = async_req_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, NULL,
-            NULL, NULL, NULL, &newphid);
-        
-        if (rc != EOK)  
+        int rc = async_req_3_5(phone, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+            NULL, NULL, NULL, NULL, &newphid);
+        
+        if (rc != EOK)
                 return rc;
-
+        
         return newphid;
 }
 
 /** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework.
- * 
+ *
  * Ask through phone for a new connection to some service and block until
  * success.
  *
- * @param phoneid       Phone handle used for contacting the other side.
- * @param arg1          User defined argument.
- * @param arg2          User defined argument.
- * @param arg3          User defined argument.
- *
- * @return              New phone handle on success or a negative error code.
- */
-int
-async_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,
+ * @param phoneid Phone handle used for contacting the other side.
+ * @param arg1    User defined argument.
+ * @param arg2    User defined argument.
+ * @param arg3    User defined argument.
+ *
+ * @return New phone handle on success or a negative error code.
+ *
+ */
+int async_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,
     sysarg_t arg3)
 {
-        int rc;
         sysarg_t newphid;
-
-        rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+        int rc = async_req_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
             IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid);
         
-        if (rc != EOK)  
+        if (rc != EOK)
                 return rc;
-
+        
         return newphid;
 }
 
-/** 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.
+/** Connect to a task specified by id.
+ *
+ */
+int async_connect_kbox(task_id_t id)
+{
+        return ipc_connect_kbox(id);
+}
+
+/** Wrapper for ipc_hangup.
+ *
+ * @param phone Phone handle to hung up.
+ *
+ * @return Zero on success or a negative error code.
+ *
+ */
+int async_hangup(int phone)
+{
+        return ipc_hangup(phone);
+}
+
+/** Interrupt one thread of this task from waiting for IPC. */
+void async_poke(void)
+{
+        ipc_poke();
+}
+
+/** Wrapper for 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 for the received flags. 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, sysarg_t arg,
-    int *flags)
-{
-        int res;
+    unsigned int *flags)
+{
         sysarg_t tmp_flags;
-        res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst,
+        int res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst,
             (sysarg_t) size, arg, NULL, &tmp_flags);
+        
         if (flags)
-                *flags = tmp_flags;
+                *flags = (unsigned int) tmp_flags;
+        
         return res;
 }
@@ -1180 +1458 @@
 /** 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.
+ * 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;
-        
+ * @param callid Storage for the hash of the IPC_M_SHARE_IN call.
+ * @param size   Destination address space area size.
+ *
+ * @return True on success, false on failure.
+ *
+ */
+bool async_share_in_receive(ipc_callid_t *callid, size_t *size)
+{
         assert(callid);
         assert(size);
-
+        
+        ipc_call_t data;
         *callid = async_get_call(&data);
+        
         if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_IN)
-                return 0;
+                return false;
+        
         *size = (size_t) IPC_GET_ARG2(data);
-        return 1;
+        return true;
 }
 
 /** 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)
+ * 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, unsigned 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)
+/** Wrapper for 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, unsigned int flags)
 {
         return async_req_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0,
@@ -1237 +1520 @@
 /** 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.
+ * 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;
-        
+ * @param callid Storage for the hash of the IPC_M_SHARE_OUT call.
+ * @param size   Storage for the source address space area size.
+ * @param flags  Storage for the sharing flags.
+ *
+ * @return True on success, false on failure.
+ *
+ */
+bool async_share_out_receive(ipc_callid_t *callid, size_t *size, unsigned int *flags)
+{
         assert(callid);
         assert(size);
         assert(flags);
-
+        
+        ipc_call_t data;
         *callid = async_get_call(&data);
+        
         if (IPC_GET_IMETHOD(data) != IPC_M_SHARE_OUT)
-                return 0;
+                return false;
+        
         *size = (size_t) IPC_GET_ARG2(data);
-        *flags = (int) IPC_GET_ARG3(data);
-        return 1;
+        *flags = (unsigned int) IPC_GET_ARG3(data);
+        return true;
 }
 
 /** 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.
+ * 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)
@@ -1281 +1567 @@
 }
 
-
-/** 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.
+/** Wrapper for 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)
@@ -1298 +1584 @@
 /** 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.
+ * 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)
-{
+ * @param callid Storage for the hash of the IPC_M_DATA_READ.
+ * @param size   Storage for the maximum size. Can be NULL.
+ *
+ * @return True on success, false on failure.
+ *
+ */
+bool async_data_read_receive(ipc_callid_t *callid, size_t *size)
+{
+        assert(callid);
+        
         ipc_call_t data;
-        
-        assert(callid);
-
         *callid = async_get_call(&data);
+        
         if (IPC_GET_IMETHOD(data) != IPC_M_DATA_READ)
-                return 0;
+                return false;
+        
         if (size)
                 *size = (size_t) IPC_GET_ARG2(data);
-        return 1;
+        
+        return true;
 }
 
 /** 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.
+ * 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)
@@ -1342 +1632 @@
 
 /** Wrapper for forwarding any read request
- *
  *
  */
@@ -1375 +1664 @@
 }
 
-/** Wrapper for making IPC_M_DATA_WRITE calls using the async framework.
+/** Wrapper for IPC_M_DATA_WRITE calls using the async framework.
  *
  * @param phoneid Phone that will be used to contact the receiving side.
@@ -1392 +1681 @@
 /** 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.
+ * 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)
-{
+ * @param callid Storage for the hash of the IPC_M_DATA_WRITE.
+ * @param size   Storage for the suggested size. May be NULL.
+ *
+ * @return True on success, false on failure.
+ *
+ */
+bool async_data_write_receive(ipc_callid_t *callid, size_t *size)
+{
+        assert(callid);
+        
         ipc_call_t data;
-        
-        assert(callid);
-        
         *callid = async_get_call(&data);
+        
         if (IPC_GET_IMETHOD(data) != IPC_M_DATA_WRITE)
-                return 0;
+                return false;
         
         if (size)
                 *size = (size_t) IPC_GET_ARG2(data);
         
-        return 1;
+        return true;
 }
 
 /** 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.
+ * 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.
@@ -1520 +1809 @@
  *
  */
-void async_data_write_void(const int retval)
+void async_data_write_void(sysarg_t retval)
 {
         ipc_callid_t callid;
@@ -1528 +1817 @@
 
 /** Wrapper for forwarding any data that is about to be received
- *
  *
  */