Changeset 8b5690f for uspace/lib/c/generic – HelenOS

uspace/lib/c/generic/async.c

-              r22027b6e
+              r8b5690f
  * 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):
+ *
 …
  *   int fibril1(void *arg)
  *   {
  *     conn = ipc_connect_me_to();
+ *     conn = async_connect_me_to();
  *     c1 = async_send(conn);
  *     c2 = async_send(conn);
 …
  *   {
  *     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);
 …
  */
+#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>
 …
 #include <arch/barrier.h>
 #include <bool.h>
+#include "private/async.h"
 atomic_t async_futex = FUTEX_INITIALIZER;
 …
 /**
  * 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 {
 …
 typedef struct {
+        sysarg_t in_task_hash;
+        link_t link;
+        int refcnt;
+        void *data;
+} client_t;
+typedef struct {
         awaiter_t wdata;
 …
         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. */
 …
 /** 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);
+}
 /**
 …
  */
 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)
+{
+}
 /**
 …
 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.
 …
+ *
  */
 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);
+}
 …
 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_t *conn = hash_table_get_instance(item, connection_t, link);
+        return (key[0] == conn->in_phone_hash);
+}
 …
         free(hash_table_get_instance(item, connection_t, link));
+}
 /** Operations for the connection hash table. */
 …
         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;
+        }
 …
+ *
  * @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.
+ *
  */
 …
         fid_t fid = fibril_create(notification_fibril, msg);
+        if (fid == 0) {
+                free(msg);
+                futex_up(&async_futex);
+                return false;
+        }
         fibril_add_ready(fid);
 …
                          * 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));
 …
                         return conn->close_callid;
+                }
                 if (usecs)
                         async_insert_timeout(&conn->wdata);
 …
+}
-/** 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.
+ *
 …
+{
         /*
+         * 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);
 …
+        }
+        /*
+         * 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);
 …
  * 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.
 …
+ *
  */
+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));
 …
                 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);
 …
         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;
+        }
 …
 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;
+        }
 …
         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:
+        ;
+}
 …
         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;
 …
         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
 …
                                 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);
 …
                 atomic_dec(&threads_in_ipc_wait);
                 if (!callid) {
                         handle_expired_timeouts();
 …
+{
         fid_t fid = fibril_create(async_manager_fibril, NULL);
+        fibril_add_manager(fid);
+        if (fid != 0)
+                fibril_add_manager(fid);
+}
 …
 /** 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;
+        }
+        _async_sess_init();
+        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();
+}
 …
  * @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)
 …
     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)
 …
         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;
 …
     ipc_call_t *dataptr)
+{
         amsg_t *msg = malloc(sizeof(*msg));
+        amsg_t *msg = malloc(sizeof(amsg_t));
         if (!msg)
 …
         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;
 …
 void async_usleep(suseconds_t timeout)
+{
         amsg_t *msg = malloc(sizeof(*msg));
+        amsg_t *msg = malloc(sizeof(amsg_t));
         if (!msg)
 …
+}
+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;
+}
 …
 /** 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,
 …
 /** 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)
 …
+}
+/** 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)
 …
 /** 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)
 …
 /** Wrapper for forwarding any read request
+ *
+ *
  */
 …
+}
 /** 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.
 …
 /** 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.
 …
+ *
  */
 void async_data_write_void(const int retval)
+void async_data_write_void(sysarg_t retval)
+{
         ipc_callid_t callid;
 …
 /** Wrapper for forwarding any data that is about to be received
+ *
+ *
  */

uspace/lib/c/generic/async_sess.c

-              r22027b6e
+              r8b5690f
 #include <async_sess.h>
-#include <ipc/ipc.h>
 #include <fibril_synch.h>
 #include <adt/list.h>
 …
 #include <errno.h>
 #include <assert.h>
+#include "private/async_sess.h"
 /** An inactive open connection. */
 typedef struct {
         link_t sess_link;       /**< Link for the session list of inactive connections. */
         link_t global_link;     /**< Link for the global list of inactive connectinos. */
+        link_t global_link;     /**< Link for the global list of inactive connections. */
         int data_phone;         /**< Connected data phone. */
 } conn_node_t;
 /**
+ * Mutex protecting the inactive_conn_head list and the session list.
+ * Mutex protecting the inactive_conn_head list, the session list and the
+ * avail_phone condition variable.
  */
 static fibril_mutex_t async_sess_mutex;
 …
 static LIST_INITIALIZE(session_list_head);
+/**
+ * Condition variable used to wait for a phone to become available.
+ */
+static FIBRIL_CONDVAR_INITIALIZE(avail_phone_cv);
 /** Initialize the async_sess subsystem.
+ *
  * Needs to be called prior to any other interface in this file.
+ */
+void _async_sess_init(void)
+ *
+ */
+void __async_sess_init(void)
+{
         fibril_mutex_initialize(&async_sess_mutex);
 …
                 list_remove(&conn->global_link);
                 ipc_hangup(conn->data_phone);
+                async_hangup(conn->data_phone);
                 free(conn);
+        }
+        fibril_condvar_broadcast(&avail_phone_cv);
+}
 …
                         data_phone = conn->data_phone;
                         free(conn);
                         ipc_hangup(data_phone);
+                        async_hangup(data_phone);
                         goto retry;
                 } else {
                         /*
+                         * This is unfortunate. We failed both to find a cached
+                         * connection or to create a new one even after cleaning up
+                         * the cache. This is most likely due to too many
+                         * open sessions (connected session phones).
+                         * Wait for a phone to become available.
                          */
+                        data_phone = ELIMIT;
+                        fibril_condvar_wait(&avail_phone_cv, &async_sess_mutex);
+                        goto retry;
+                }
+        }
 …
         fibril_mutex_lock(&async_sess_mutex);
+        fibril_condvar_signal(&avail_phone_cv);
         conn = (conn_node_t *) malloc(sizeof(conn_node_t));
         if (!conn) {
 …
                  * means that we simply hang up.
                  */
+                async_hangup(data_phone);
                 fibril_mutex_unlock(&async_sess_mutex);
-                ipc_hangup(data_phone);
                 return;
+        }

uspace/lib/c/generic/clipboard.c

-              r22027b6e
+              r8b5690f
 #include <clipboard.h>
+#include <ipc/ns.h>
 #include <ipc/services.h>
 #include <ipc/clipboard.h>
 …
+{
         while (clip_phone < 0)
                 clip_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_CLIPBOARD, 0, 0);
+                clip_phone = service_connect_blocking(SERVICE_CLIPBOARD, 0, 0);
+}

uspace/lib/c/generic/ddi.c

-              r22027b6e
+              r8b5690f
+}
-/** Enable an interrupt.
+ *
- * @param irq the interrupt.
+ *
- * @return Zero on success, negative error code otherwise.
- */
-int interrupt_enable(int irq)
+{
-        return __SYSCALL2(SYS_INTERRUPT_ENABLE, (sysarg_t) irq, 1);
+}
-/** Disable an interrupt.
+ *
- * @param irq the interrupt.
+ *
- * @return Zero on success, negative error code otherwise.
- */
-int interrupt_disable(int irq)
+{
-        return __SYSCALL2(SYS_INTERRUPT_ENABLE, (sysarg_t) irq, 0);
+}
 /** Enable PIO for specified I/O range.
+ *
 …
+}
+/** Register IRQ notification.
+ *
+ * @param inr    IRQ number.
+ * @param devno  Device number of the device generating inr.
+ * @param method Use this method for notifying me.
+ * @param ucode  Top-half pseudocode handler.
+ *
+ * @return Value returned by the kernel.
+ *
+ */
+int register_irq(int inr, int devno, int method, irq_code_t *ucode)
+{
+        return __SYSCALL4(SYS_REGISTER_IRQ, inr, devno, method,
+            (sysarg_t) ucode);
+}
+/** Unregister IRQ notification.
+ *
+ * @param inr   IRQ number.
+ * @param devno Device number of the device generating inr.
+ *
+ * @return Value returned by the kernel.
+ *
+ */
+int unregister_irq(int inr, int devno)
+{
+        return __SYSCALL2(SYS_UNREGISTER_IRQ, inr, devno);
+}
 /** @}
  */

uspace/lib/c/generic/devman.c

-              r22027b6e
+              r8b5690f
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
  /** @addtogroup libc
+/** @addtogroup libc
  * @{
  */
 …
 #include <str.h>
 #include <stdio.h>
-#include <ipc/ipc.h>
 #include <ipc/services.h>
 #include <ipc/devman.h>
 #include <devman.h>
 #include <async.h>
+#include <fibril_synch.h>
 #include <errno.h>
 #include <malloc.h>
 …
 static int devman_phone_client = -1;
+static FIBRIL_MUTEX_INITIALIZE(devman_phone_mutex);
 int devman_get_phone(devman_interface_t iface, unsigned int flags)
+{
         switch (iface) {
         case DEVMAN_DRIVER:
+                if (devman_phone_driver >= 0)
+                fibril_mutex_lock(&devman_phone_mutex);
+                if (devman_phone_driver >= 0) {
+                        fibril_mutex_unlock(&devman_phone_mutex);
                         return devman_phone_driver;
+                }
                 if (flags & IPC_FLAG_BLOCKING)
 …
                             SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
+                fibril_mutex_unlock(&devman_phone_mutex);
                 return devman_phone_driver;
         case DEVMAN_CLIENT:
+                if (devman_phone_client >= 0)
+                fibril_mutex_lock(&devman_phone_mutex);
+                if (devman_phone_client >= 0) {
+                        fibril_mutex_unlock(&devman_phone_mutex);
                         return devman_phone_client;
+                if (flags & IPC_FLAG_BLOCKING)
+                }
+                if (flags & IPC_FLAG_BLOCKING) {
                         devman_phone_client = async_connect_me_to_blocking(
                             PHONE_NS, SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
                 else
+                } else {
                         devman_phone_client = async_connect_me_to(PHONE_NS,
                             SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
+                }
+                fibril_mutex_unlock(&devman_phone_mutex);
                 return devman_phone_client;
         default:
 …
         async_set_client_connection(conn);
+        sysarg_t callback_phonehash;
+        ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
+        async_connect_to_me(phone, 0, 0, 0, NULL);
         async_wait_for(req, &retval);
 …
         case DEVMAN_DRIVER:
                 if (devman_phone_driver >= 0) {
                         ipc_hangup(devman_phone_driver);
+                        async_hangup(devman_phone_driver);
                         devman_phone_driver = -1;
+                }
 …
         case DEVMAN_CLIENT:
                 if (devman_phone_client >= 0) {
                         ipc_hangup(devman_phone_client);
+                        async_hangup(devman_phone_client);
                         devman_phone_client = -1;
+                }

uspace/lib/c/generic/devmap.c

-              r22027b6e
+              r8b5690f
 #include <str.h>
-#include <ipc/ipc.h>
 #include <ipc/services.h>
+#include <ipc/ns.h>
 #include <ipc/devmap.h>
 #include <devmap.h>
 …
                 if (flags & IPC_FLAG_BLOCKING)
                         devmap_phone_driver = ipc_connect_me_to_blocking(PHONE_NS,
                             SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
+                        devmap_phone_driver = service_connect_blocking(SERVICE_DEVMAP,
+                            DEVMAP_DRIVER, 0);
                 else
                         devmap_phone_driver = ipc_connect_me_to(PHONE_NS,
                             SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
+                        devmap_phone_driver = service_connect(SERVICE_DEVMAP,
+                            DEVMAP_DRIVER, 0);
                 return devmap_phone_driver;
 …
                 if (flags & IPC_FLAG_BLOCKING)
                         devmap_phone_client = ipc_connect_me_to_blocking(PHONE_NS,
                             SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
+                        devmap_phone_client = service_connect_blocking(SERVICE_DEVMAP,
+                            DEVMAP_CLIENT, 0);
                 else
                         devmap_phone_client = ipc_connect_me_to(PHONE_NS,
                             SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
+                        devmap_phone_client = service_connect(SERVICE_DEVMAP,
+                            DEVMAP_CLIENT, 0);
                 return devmap_phone_client;
 …
         case DEVMAP_DRIVER:
                 if (devmap_phone_driver >= 0) {
                         ipc_hangup(devmap_phone_driver);
+                        async_hangup(devmap_phone_driver);
                         devmap_phone_driver = -1;
+                }
 …
         case DEVMAP_CLIENT:
                 if (devmap_phone_client >= 0) {
                         ipc_hangup(devmap_phone_client);
+                        async_hangup(devmap_phone_client);
                         devmap_phone_client = -1;
+                }
 …
         async_set_client_connection(conn);
+        sysarg_t callback_phonehash;
+        ipc_connect_to_me(phone, 0, 0, 0, &callback_phonehash);
+        async_connect_to_me(phone, 0, 0, 0, NULL);
         async_wait_for(req, &retval);

uspace/lib/c/generic/event.c

-              r22027b6e
+              r8b5690f
  */
 /** @file
  */
+ */
 #include <libc.h>
 #include <event.h>
 #include <kernel/ipc/event_types.h>
-#include <ipc/ipc.h>
 /** Subscribe for event notifications.

uspace/lib/c/generic/fibril_synch.c

-              r22027b6e
+              r8b5690f
 #include <fibril.h>
 #include <async.h>
-#include <async_priv.h>
 #include <adt/list.h>
 #include <futex.h>
 …
 #include <stacktrace.h>
 #include <stdlib.h>
+#include "private/async.h"
 static void optimize_execution_power(void)
 …
          */
         if (atomic_get(&threads_in_ipc_wait) > 0)
                 ipc_poke();
+                async_poke();
+}
 …
+{
         fibril_t *f = (fibril_t *) fibril_get_id();
+        if (fibril_get_sercount() != 0)
+                abort();
         futex_down(&async_futex);
 …
         fibril_t *f = (fibril_t *) fibril_get_id();
+        if (fibril_get_sercount() != 0)
+                abort();
         futex_down(&async_futex);
         if (frw->writers) {
 …
         fibril_t *f = (fibril_t *) fibril_get_id();
+        if (fibril_get_sercount() != 0)
+                abort();
         futex_down(&async_futex);
         if (frw->writers || frw->readers) {

uspace/lib/c/generic/io/io.c

-              r22027b6e
+              r8b5690f
 #include <bool.h>
 #include <malloc.h>
+#include <async.h>
 #include <io/klog.h>
 #include <vfs/vfs.h>
 #include <ipc/devmap.h>
 #include <adt/list.h>
+#include "../private/io.h"
 static void _ffillbuf(FILE *stream);
 …
         if (stream->phone >= 0)
                 ipc_hangup(stream->phone);
+                async_hangup(stream->phone);
         if (stream->fd >= 0)

uspace/lib/c/generic/ipc.c

-              r22027b6e
+              r8b5690f
 #include <errno.h>
 #include <adt/list.h>
-#include <stdio.h>
-#include <unistd.h>
 #include <futex.h>
-#include <kernel/synch/synch.h>
-#include <async.h>
 #include <fibril.h>
-#include <assert.h>
 /**
  * Structures of this type are used for keeping track of sent asynchronous calls
  * and queing unsent calls.
+ * Structures of this type are used for keeping track
+ * of sent asynchronous calls and queing unsent calls.
  */
 typedef struct {
         link_t list;
         ipc_async_callback_t callback;
         void *private;
         union {
                 ipc_callid_t callid;
 …
                 } msg;
         } u;
+        fid_t fid;      /**< Fibril waiting for sending this call. */
+        /** Fibril waiting for sending this call. */
+        fid_t fid;
 } async_call_t;
 …
 /** List of asynchronous calls that were not accepted by kernel.
+ *
+ * It is protected by async_futex, because if the call cannot be sent into the
+ * kernel, the async framework is used automatically.
+ * Protected by async_futex, because if the call is not accepted
+ * by the kernel, the async framework is used automatically.
+ *
  */
 LIST_INITIALIZE(queued_calls);
 …
 static atomic_t ipc_futex = FUTEX_INITIALIZER;
 /** Make a fast synchronous call.
+ *
  * Only three payload arguments can be passed using this function. However, this
  * function is faster than the generic ipc_call_sync_slow() because the payload
  * is passed directly in registers.
+ *
  * @param phoneid       Phone handle for the call.
  * @param method        Requested method.
  * @param arg1          Service-defined payload argument.
  * @param arg2          Service-defined payload argument.
  * @param arg3          Service-defined payload argument.
  * @param result1       If non-NULL, the return ARG1 will be stored there.
  * @param result2       If non-NULL, the return ARG2 will be stored there.
  * @param result3       If non-NULL, the return ARG3 will be stored there.
  * @param result4       If non-NULL, the return ARG4 will be stored there.
  * @param result5       If non-NULL, the return ARG5 will be stored there.
+ *
  * @return              Negative values represent errors returned by IPC.
  *                      Otherwise the RETVAL of the answer is returned.
  */
+int
 ipc_call_sync_fast(int phoneid, sysarg_t method, sysarg_t arg1, sysarg_t arg2,
     sysarg_t arg3, sysarg_t *result1, sysarg_t *result2, sysarg_t *result3,
     sysarg_t *result4, sysarg_t *result5)
+/** Fast synchronous call.
+ *
+ * Only three payload arguments can be passed using this function. However,
+ * this function is faster than the generic ipc_call_sync_slow() because
+ * the payload is passed directly in registers.
+ *
+ * @param phoneid Phone handle for the call.
+ * @param method  Requested method.
+ * @param arg1    Service-defined payload argument.
+ * @param arg2    Service-defined payload argument.
+ * @param arg3    Service-defined payload argument.
+ * @param result1 If non-NULL, the return ARG1 will be stored there.
+ * @param result2 If non-NULL, the return ARG2 will be stored there.
+ * @param result3 If non-NULL, the return ARG3 will be stored there.
+ * @param result4 If non-NULL, the return ARG4 will be stored there.
+ * @param result5 If non-NULL, the return ARG5 will be stored there.
+ *
+ * @return Negative values representing IPC errors.
+ * @return Otherwise the RETVAL of the answer.
+ *
+ */
+int ipc_call_sync_fast(int phoneid, sysarg_t method, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t *result1, sysarg_t *result2,
+    sysarg_t *result3, sysarg_t *result4, sysarg_t *result5)
+{
         ipc_call_t resdata;
+        int callres;
+        callres = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
+        int callres = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
             arg2, arg3, (sysarg_t) &resdata);
         if (callres)
                 return callres;
         if (result1)
                 *result1 = IPC_GET_ARG1(resdata);
 …
         if (result5)
                 *result5 = IPC_GET_ARG5(resdata);
         return IPC_GET_RETVAL(resdata);
+}
 /** Make a synchronous call transmitting 5 arguments of payload.
+/** Synchronous call transmitting 5 arguments of payload.
+ *
  * @param phoneid Phone handle for the call.
 …
  * @param result5 If non-NULL, storage for the fifth return argument.
+ *
  * @return Negative value means IPC error.
  *         Otherwise the RETVAL of the answer.
+ *
  */
 int
 ipc_call_sync_slow(int phoneid, sysarg_t imethod, sysarg_t arg1, sysarg_t arg2,
     sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *result1,
     sysarg_t *result2, sysarg_t *result3, sysarg_t *result4, sysarg_t *result5)
+ * @return Negative values representing IPC errors.
+ * @return Otherwise the RETVAL of the answer.
+ *
+ */
+int ipc_call_sync_slow(int phoneid, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
+    sysarg_t *result1, sysarg_t *result2, sysarg_t *result3, sysarg_t *result4,
+    sysarg_t *result5)
+{
         ipc_call_t data;
 …
+}
 /** Syscall to send asynchronous message.
+/** Send asynchronous message via syscall.
+ *
  * @param phoneid Phone handle for the call.
 …
+ *
  */
 static ipc_callid_t _ipc_call_async(int phoneid, ipc_call_t *data)
+static ipc_callid_t ipc_call_async_internal(int phoneid, ipc_call_t *data)
+{
         return __SYSCALL2(SYS_IPC_CALL_ASYNC_SLOW, phoneid, (sysarg_t) data);
+}
+/** Prolog to ipc_call_async_*() functions.
+ *
+ * @param private       Argument for the answer/error callback.
+ * @param callback      Answer/error callback.
+ *
+ * @return              New, partially initialized async_call structure or NULL.
+/** Prolog for ipc_call_async_*() functions.
+ *
+ * @param private  Argument for the answer/error callback.
+ * @param callback Answer/error callback.
+ *
+ * @return New, partially initialized async_call structure or NULL.
+ *
  */
 static inline async_call_t *ipc_prepare_async(void *private,
     ipc_async_callback_t callback)
+{
+        async_call_t *call;
+        call = malloc(sizeof(*call));
+        async_call_t *call =
+            (async_call_t *) malloc(sizeof(async_call_t));
         if (!call) {
                 if (callback)
                         callback(private, ENOMEM, NULL);
                 return NULL;
+        }
         call->callback = callback;
         call->private = private;
         return call;
+}
+/** Epilogue of ipc_call_async_*() functions.
+ *
+ * @param callid        Value returned by the SYS_IPC_CALL_ASYNC_* syscall.
+ * @param phoneid       Phone handle through which the call was made.
+ * @param call          async_call structure returned by ipc_prepare_async().
+ * @param can_preempt   If non-zero, the current fibril can be preempted in this
+ *                      call.
+/** Epilog for ipc_call_async_*() functions.
+ *
+ * @param callid      Value returned by the SYS_IPC_CALL_ASYNC_* syscall.
+ * @param phoneid     Phone handle through which the call was made.
+ * @param call        Structure returned by ipc_prepare_async().
+ * @param can_preempt If true, the current fibril can be preempted
+ *                    in this call.
+ *
  */
 static inline void ipc_finish_async(ipc_callid_t callid, int phoneid,
+    async_call_t *call, int can_preempt)
+{
+        if (!call) { /* Nothing to do regardless if failed or not */
+    async_call_t *call, bool can_preempt)
+{
+        if (!call) {
+                /* Nothing to do regardless if failed or not */
                 futex_up(&ipc_futex);
                 return;
+        }
         if (callid == (ipc_callid_t) IPC_CALLRET_FATAL) {
                 futex_up(&ipc_futex);
                 /* Call asynchronous handler with error code */
                 if (call->callback)
                         call->callback(call->private, ENOENT, NULL);
                 free(call);
                 return;
+        }
         if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) {
                 futex_up(&ipc_futex);
                 call->u.msg.phoneid = phoneid;
                 futex_down(&async_futex);
                 list_append(&call->list, &queued_calls);
                 if (can_preempt) {
                         call->fid = fibril_get_id();
 …
                         futex_up(&async_futex);
+                }
                 return;
+        }
         call->u.callid = callid;
         /* Add call to the list of dispatched calls */
         list_append(&call->list, &dispatched_calls);
         futex_up(&ipc_futex);
+}
+/** Make a fast asynchronous call.
+}
+/** Fast asynchronous call.
+ *
  * This function can only handle four arguments of payload. It is, however,
 …
+ *
  * Note that this function is a void function.
+ * During normal opertation, answering this call will trigger the callback.
+ * In case of fatal error, call the callback handler with the proper error code.
+ * If the call cannot be temporarily made, queue it.
+ *
+ * During normal operation, answering this call will trigger the callback.
+ * In case of fatal error, the callback handler is called with the proper
+ * error code. If the call cannot be temporarily made, it is queued.
+ *
  * @param phoneid     Phone handle for the call.
 …
  * @param private     Argument to be passed to the answer/error callback.
  * @param callback    Answer or error callback.
  * @param can_preempt If non-zero, the current fibril will be preempted in
+ * @param can_preempt If true, the current fibril will be preempted in
  *                    case the kernel temporarily refuses to accept more
  *                    asynchronous calls.
 …
 void ipc_call_async_fast(int phoneid, sysarg_t imethod, sysarg_t arg1,
     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, void *private,
     ipc_async_callback_t callback, int can_preempt)
+    ipc_async_callback_t callback, bool can_preempt)
+{
         async_call_t *call = NULL;
 …
         /*
          * We need to make sure that we get callid before another thread
          * accesses the queue again.
+         * We need to make sure that we get callid
+         * before another thread accesses the queue again.
          */
         futex_down(&ipc_futex);
         ipc_callid_t callid = __SYSCALL6(SYS_IPC_CALL_ASYNC_FAST, phoneid,
 …
                                 return;
+                }
                 IPC_SET_IMETHOD(call->u.msg.data, imethod);
                 IPC_SET_ARG1(call->u.msg.data, arg1);
 …
                 IPC_SET_ARG3(call->u.msg.data, arg3);
                 IPC_SET_ARG4(call->u.msg.data, arg4);
                 /*
                  * To achieve deterministic behavior, we always zero out the
                  * arguments that are beyond the limits of the fast version.
                  */
                 IPC_SET_ARG5(call->u.msg.data, 0);
+        }
         ipc_finish_async(callid, phoneid, call, can_preempt);
+}
 /** Make an asynchronous call transmitting the entire payload.
+/** Asynchronous call transmitting the entire payload.
+ *
  * Note that this function is a void function.
+ * During normal opertation, answering this call will trigger the callback.
+ * In case of fatal error, call the callback handler with the proper error code.
+ * If the call cannot be temporarily made, queue it.
+ *
+ * During normal operation, answering this call will trigger the callback.
+ * In case of fatal error, the callback handler is called with the proper
+ * error code. If the call cannot be temporarily made, it is queued.
+ *
  * @param phoneid     Phone handle for the call.
 …
  * @param private     Argument to be passed to the answer/error callback.
  * @param callback    Answer or error callback.
  * @param can_preempt If non-zero, the current fibril will be preempted in
+ * @param can_preempt If true, the current fibril will be preempted in
  *                    case the kernel temporarily refuses to accept more
  *                    asynchronous calls.
 …
 void ipc_call_async_slow(int phoneid, sysarg_t imethod, sysarg_t arg1,
     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, void *private,
+    ipc_async_callback_t callback, int can_preempt)
+{
+        async_call_t *call;
+        ipc_callid_t callid;
+        call = ipc_prepare_async(private, callback);
+    ipc_async_callback_t callback, bool can_preempt)
+{
+        async_call_t *call = ipc_prepare_async(private, callback);
         if (!call)
                 return;
         IPC_SET_IMETHOD(call->u.msg.data, imethod);
         IPC_SET_ARG1(call->u.msg.data, arg1);
 …
         IPC_SET_ARG4(call->u.msg.data, arg4);
         IPC_SET_ARG5(call->u.msg.data, arg5);
         /*
          * We need to make sure that we get callid before another thread
          * accesses the queue again.
+         * We need to make sure that we get callid
+         * before another threadaccesses the queue again.
          */
         futex_down(&ipc_futex);
+        callid = _ipc_call_async(phoneid, &call->u.msg.data);
+        ipc_callid_t callid =
+            ipc_call_async_internal(phoneid, &call->u.msg.data);
         ipc_finish_async(callid, phoneid, call, can_preempt);
+}
+/** Answer a received call - fast version.
+/** Answer received call (fast version).
+ *
  * The fast answer makes use of passing retval and first four arguments in
  * registers. If you need to return more, use the ipc_answer_slow() instead.
+ *
+ * @param callid        Hash of the call being answered.
+ * @param retval        Return value.
+ * @param arg1          First return argument.
+ * @param arg2          Second return argument.
+ * @param arg3          Third return argument.
+ * @param arg4          Fourth return argument.
+ *
+ * @return              Zero on success or a value from @ref errno.h on failure.
+ * @param callid Hash of the call being answered.
+ * @param retval Return value.
+ * @param arg1   First return argument.
+ * @param arg2   Second return argument.
+ * @param arg3   Third return argument.
+ * @param arg4   Fourth return argument.
+ *
+ * @return Zero on success.
+ * @return Value from @ref errno.h on failure.
+ *
  */
 sysarg_t ipc_answer_fast(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
 …
+}
+/** Answer a received call - slow full version.
+ *
+ * @param callid        Hash of the call being answered.
+ * @param retval        Return value.
+ * @param arg1          First return argument.
+ * @param arg2          Second return argument.
+ * @param arg3          Third return argument.
+ * @param arg4          Fourth return argument.
+ * @param arg5          Fifth return argument.
+ *
+ * @return              Zero on success or a value from @ref errno.h on failure.
+/** Answer received call (entire payload).
+ *
+ * @param callid Hash of the call being answered.
+ * @param retval Return value.
+ * @param arg1   First return argument.
+ * @param arg2   Second return argument.
+ * @param arg3   Third return argument.
+ * @param arg4   Fourth return argument.
+ * @param arg5   Fifth return argument.
+ *
+ * @return Zero on success.
+ * @return Value from @ref errno.h on failure.
+ *
  */
 sysarg_t ipc_answer_slow(ipc_callid_t callid, sysarg_t retval, sysarg_t arg1,
 …
+{
         ipc_call_t data;
         IPC_SET_RETVAL(data, retval);
         IPC_SET_ARG1(data, arg1);
 …
         IPC_SET_ARG4(data, arg4);
         IPC_SET_ARG5(data, arg5);
         return __SYSCALL2(SYS_IPC_ANSWER_SLOW, callid, (sysarg_t) &data);
+}
+/** Try to dispatch queued calls from the async queue. */
+static void try_dispatch_queued_calls(void)
+{
+        async_call_t *call;
+        ipc_callid_t callid;
+/** Try to dispatch queued calls from the async queue.
+ *
+ */
+static void dispatch_queued_calls(void)
+{
         /** @todo
          * Integrate intelligently ipc_futex, so that it is locked during
          * ipc_call_async_*(), until it is added to dispatched_calls.
+         * Integrate intelligently ipc_futex so that it is locked during
+         * ipc_call_async_*() until it is added to dispatched_calls.
          */
         futex_down(&async_futex);
         while (!list_empty(&queued_calls)) {
+                call = list_get_instance(queued_calls.next, async_call_t, list);
+                callid = _ipc_call_async(call->u.msg.phoneid,
+                    &call->u.msg.data);
+                if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY) {
+                async_call_t *call =
+                    list_get_instance(queued_calls.next, async_call_t, list);
+                ipc_callid_t callid =
+                    ipc_call_async_internal(call->u.msg.phoneid, &call->u.msg.data);
+                if (callid == (ipc_callid_t) IPC_CALLRET_TEMPORARY)
                         break;
+                }
                 list_remove(&call->list);
                 futex_up(&async_futex);
                 if (call->fid)
                         fibril_add_ready(call->fid);
 …
                         if (call->callback)
                                 call->callback(call->private, ENOENT, NULL);
                         free(call);
                 } else {
                         call->u.callid = callid;
                         futex_down(&ipc_futex);
                         list_append(&call->list, &dispatched_calls);
                         futex_up(&ipc_futex);
+                }
                 futex_down(&async_futex);
+        }
         futex_up(&async_futex);
+}
 /** Handle a received answer.
+/** Handle received answer.
+ *
  * Find the hash of the answer and call the answer callback.
+ *
+ * @todo Make it use hash table.
+ *
+ * @param callid        Hash of the received answer.
+ *                      The answer has the same hash as the request OR'ed with
+ *                      the IPC_CALLID_ANSWERED bit.
+ * @param data          Call data of the answer.
+ * The answer has the same hash as the request OR'ed with
+ * the IPC_CALLID_ANSWERED bit.
+ *
+ * @todo Use hash table.
+ *
+ * @param callid Hash of the received answer.
+ * @param data   Call data of the answer.
+ *
  */
 static void handle_answer(ipc_callid_t callid, ipc_call_t *data)
+{
+        callid &= ~IPC_CALLID_ANSWERED;
+        futex_down(&ipc_futex);
         link_t *item;
-        async_call_t *call;
-        callid &= ~IPC_CALLID_ANSWERED;
-        futex_down(&ipc_futex);
         for (item = dispatched_calls.next; item != &dispatched_calls;
             item = item->next) {
+                call = list_get_instance(item, async_call_t, list);
+                async_call_t *call =
+                    list_get_instance(item, async_call_t, list);
                 if (call->u.callid == callid) {
                         list_remove(&call->list);
                         futex_up(&ipc_futex);
                         if (call->callback)
                                 call->callback(call->private,
+                                call->callback(call->private,
                                     IPC_GET_RETVAL(*data), data);
                         free(call);
                         return;
+                }
+        }
         futex_up(&ipc_futex);
+}
+/** Wait for a first call to come.
+ *
  * @param call          Storage where the incoming call data will be stored.
  * @param usec          Timeout in microseconds
  * @param flags         Flags passed to SYS_IPC_WAIT (blocking, nonblocking).
+ *
  * @return              Hash of the call. Note that certain bits have special
  *                      meaning. IPC_CALLID_ANSWERED will be set in an answer
  *                      and IPC_CALLID_NOTIFICATION is used for notifications.
+ *
+ */
 ipc_callid_t ipc_wait_cycle(ipc_call_t *call, uint32_t usec, int flags)
+{
         ipc_callid_t callid;
         callid = __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
+/** Wait for first IPC call to come.
+ *
+ * @param call  Incoming call storage.
+ * @param usec  Timeout in microseconds
+ * @param flags Flags passed to SYS_IPC_WAIT (blocking, nonblocking).
+ *
+ * @return Hash of the call. Note that certain bits have special
+ *         meaning: IPC_CALLID_ANSWERED is set in an answer
+ *         and IPC_CALLID_NOTIFICATION is used for notifications.
+ *
+ */
+ipc_callid_t ipc_wait_cycle(ipc_call_t *call, sysarg_t usec,
+    unsigned int flags)
+{
+        ipc_callid_t callid =
+            __SYSCALL3(SYS_IPC_WAIT, (sysarg_t) call, usec, flags);
         /* Handle received answers */
         if (callid & IPC_CALLID_ANSWERED) {
                 handle_answer(callid, call);
                 try_dispatch_queued_calls();
+                dispatch_queued_calls();
+        }
         return callid;
+}
+/** Wait some time for an IPC call.
+ *
+ * The call will return after an answer is received.
+ *
+ * @param call          Storage where the incoming call data will be stored.
+ * @param usec          Timeout in microseconds.
+ *
+ * @return              Hash of the answer.
+ */
+ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, uint32_t usec)
+/** Interrupt one thread of this task from waiting for IPC.
+ *
+ */
+void ipc_poke(void)
+{
+        __SYSCALL0(SYS_IPC_POKE);
+}
+/** Wait for first IPC call to come.
+ *
+ * Only requests are returned, answers are processed internally.
+ *
+ * @param call Incoming call storage.
+ * @param usec Timeout in microseconds
+ *
+ * @return Hash of the call.
+ *
+ */
+ipc_callid_t ipc_wait_for_call_timeout(ipc_call_t *call, sysarg_t usec)
+{
         ipc_callid_t callid;
         do {
                 callid = ipc_wait_cycle(call, usec, SYNCH_FLAGS_NONE);
         } while (callid & IPC_CALLID_ANSWERED);
         return callid;
+}
 …
 /** Check if there is an IPC call waiting to be picked up.
+ *
+ * @param call          Storage where the incoming call will be stored.
+ * @return              Hash of the answer.
+ * Only requests are returned, answers are processed internally.
+ *
+ * @param call Incoming call storage.
+ *
+ * @return Hash of the call.
+ *
  */
 ipc_callid_t ipc_trywait_for_call(ipc_call_t *call)
+{
         ipc_callid_t callid;
         do {
                 callid = ipc_wait_cycle(call, SYNCH_NO_TIMEOUT,
                     SYNCH_FLAGS_NON_BLOCKING);
         } while (callid & IPC_CALLID_ANSWERED);
         return callid;
+}
+/** Interrupt one thread of this task from waiting for IPC. */
+void ipc_poke(void)
+{
+        __SYSCALL0(SYS_IPC_POKE);
+}
+/** Ask destination to do a callback connection.
+ *
+ * @param phoneid       Phone handle used for contacting the other side.
+ * @param arg1          Service-defined argument.
+ * @param arg2          Service-defined argument.
+ * @param arg3          Service-defined argument.
+ * @param phonehash     Storage where the library will store an opaque
+ *                      identifier of the phone that will be used for incoming
+ *                      calls. This identifier can be used for connection
+ *                      tracking.
+ *
+ * @return              Zero on success or a negative error code.
+ */
+int ipc_connect_to_me(int phoneid, int arg1, int arg2, int arg3,
+    sysarg_t *phonehash)
+/** Request callback connection.
+ *
+ * The @a taskhash and @a phonehash identifiers returned
+ * by the kernel can be used for connection tracking.
+ *
+ * @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.
+ * @param taskhash  Opaque identifier of the client task.
+ * @param phonehash Opaque identifier of the phone that will
+ *                  be used for incoming calls.
+ *
+ * @return Zero on success or a negative error code.
+ *
+ */
+int ipc_connect_to_me(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
+    sysarg_t *taskhash, sysarg_t *phonehash)
+{
         return ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_TO_ME, arg1, arg2,
+            arg3, NULL, NULL, NULL, NULL, phonehash);
+}
+/** 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 ipc_connect_me_to(int phoneid, int arg1, int arg2, int arg3)
+            arg3, NULL, NULL, NULL, taskhash, phonehash);
+}
+/** Request new connection.
+ *
+ * @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 ipc_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
+{
         sysarg_t newphid;
+        int res;
+        res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+        int res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
             NULL, NULL, NULL, NULL, &newphid);
         if (res)
                 return res;
         return newphid;
+}
 /** Ask through phone for a new connection to some service.
+/** Request new connection (blocking)
+ *
  * If the connection is not available at the moment, the
+ * call will block.
+ *
+ * @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 ipc_connect_me_to_blocking(int phoneid, int arg1, int arg2, int arg3)
+ * call should block. This has to be, however, implemented
+ * on the server side.
+ *
+ * @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 ipc_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3)
+{
         sysarg_t newphid;
+        int res;
+        res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+        int res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
             IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid);
         if (res)
                 return res;
         return newphid;
+}
 …
 /** Hang up a phone.
+ *
+ * @param phoneid       Handle of the phone to be hung up.
+ *
+ * @return              Zero on success or a negative error code.
+ * @param phoneid Handle of the phone to be hung up.
+ *
+ * @return Zero on success or a negative error code.
+ *
  */
 int ipc_hangup(int phoneid)
 …
+}
-/** Register IRQ notification.
+ *
- * @param inr           IRQ number.
- * @param devno         Device number of the device generating inr.
- * @param method        Use this method for notifying me.
- * @param ucode         Top-half pseudocode handler.
+ *
- * @return              Value returned by the kernel.
- */
-int ipc_register_irq(int inr, int devno, int method, irq_code_t *ucode)
+{
-        return __SYSCALL4(SYS_IPC_REGISTER_IRQ, inr, devno, method,
-            (sysarg_t) ucode);
+}
-/** Unregister IRQ notification.
+ *
- * @param inr           IRQ number.
- * @param devno         Device number of the device generating inr.
+ *
- * @return              Value returned by the kernel.
- */
-int ipc_unregister_irq(int inr, int devno)
+{
-        return __SYSCALL2(SYS_IPC_UNREGISTER_IRQ, inr, devno);
+}
 /** Forward a received call to another destination.
+ *
+ * For non-system methods, the old method, arg1 and arg2 are rewritten
+ * by the new values. For system methods, the new method, arg1 and arg2
+ * are written to the old arg1, arg2 and arg3, respectivelly. Calls with
+ * immutable methods are forwarded verbatim.
+ *
  * @param callid  Hash of the call to forward.
 …
  * @return Zero on success or an error code.
+ *
+ * For non-system methods, the old method, arg1 and arg2 are rewritten by the
+ * new values. For system methods, the new method, arg1 and arg2 are written
+ * to the old arg1, arg2 and arg3, respectivelly. Calls with immutable
+ * methods are forwarded verbatim.
+ */
+int ipc_forward_fast(ipc_callid_t callid, int phoneid, int imethod,
+    sysarg_t arg1, sysarg_t arg2, int mode)
+ */
+int ipc_forward_fast(ipc_callid_t callid, int phoneid, sysarg_t imethod,
+    sysarg_t arg1, sysarg_t arg2, unsigned int mode)
+{
         return __SYSCALL6(SYS_IPC_FORWARD_FAST, callid, phoneid, imethod, arg1,
 …
+}
+int ipc_forward_slow(ipc_callid_t callid, int phoneid, int imethod,
+int ipc_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,
     int mode)
+    unsigned int mode)
+{
         ipc_call_t data;
 …
         IPC_SET_ARG5(data, arg5);
+        return __SYSCALL4(SYS_IPC_FORWARD_SLOW, callid, phoneid, (sysarg_t) &data, mode);
+}
+/** Wrapper for making IPC_M_SHARE_IN calls.
+ *
+ * @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.
+        return __SYSCALL4(SYS_IPC_FORWARD_SLOW, callid, phoneid, (sysarg_t) &data,
+            mode);
+}
+/** Wrapper for IPC_M_SHARE_IN calls.
+ *
+ * @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 received flags. Can be NULL.
+ *
+ * @return Zero on success or a negative error code from errno.h.
+ *
  */
 int ipc_share_in_start(int phoneid, void *dst, size_t size, sysarg_t arg,
     int *flags)
+    unsigned int *flags)
+{
         sysarg_t tmp_flags = 0;
 …
         if (flags)
                 *flags = tmp_flags;
+                *flags = (unsigned int) tmp_flags;
         return res;
 …
 /** Wrapper for answering the IPC_M_SHARE_IN calls.
+ *
+ * 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 ipc_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 ipc_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
+{
         return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) flags);
+}
+/** Wrapper for making IPC_M_SHARE_OUT calls.
+ *
+ * @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 ipc_share_out_start(int phoneid, void *src, int flags)
+/** Wrapper for IPC_M_SHARE_OUT calls.
+ *
+ * @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 ipc_share_out_start(int phoneid, void *src, unsigned int flags)
+{
         return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0,
 …
 /** Wrapper for answering the IPC_M_SHARE_OUT calls.
+ *
+ * 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 ipc_share_out_finalize(ipc_callid_t callid, void *dst)
 …
+}
+/** Wrapper for making IPC_M_DATA_READ calls.
+ *
  * @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.
+ *
+ * @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 ipc_data_read_start(int phoneid, void *dst, size_t size)
 …
 /** Wrapper for answering the IPC_M_DATA_READ calls.
+ *
+ * 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 ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
 …
+}
+/** Wrapper for making IPC_M_DATA_WRITE calls.
+ *
+ * @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.
+/** Wrapper for IPC_M_DATA_WRITE calls.
+ *
+ * @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 ipc_data_write_start(int phoneid, const void *src, size_t size)
 …
 /** Wrapper for answering the IPC_M_DATA_WRITE calls.
+ *
+ * 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.
+ * 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 ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)

uspace/lib/c/generic/libc.c

-              r22027b6e
+              r8b5690f
 #include <libc.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <malloc.h>
+#include <stdlib.h>
 #include <tls.h>
-#include <thread.h>
 #include <fibril.h>
+#include <ipc/ipc.h>
+#include <async.h>
+#include <as.h>
+#include <task.h>
 #include <loader/pcb.h>
+#include "private/libc.h"
+#include "private/async.h"
+#include "private/async_sess.h"
+#include "private/malloc.h"
+#include "private/io.h"
+extern int main(int argc, char *argv[]);
+void _exit(int status)
+{
+        thread_exit(status);
+}
+static bool env_setup = false;
 void __main(void *pcb_ptr)
+{
         /* Initialize user task run-time environment */
         __heap_init();
+        __malloc_init();
         __async_init();
+        __async_sess_init();
         fibril_t *fibril = fibril_setup();
+        if (fibril == NULL)
+                abort();
         __tcb_set(fibril->tcb);
 …
         __pcb = (pcb_t *) pcb_ptr;
+        /* The basic run-time environment is setup */
+        env_setup = true;
         int argc;
         char **argv;
+        /* Get command line arguments and initialize
+           standard input and output */
+        /*
+         * Get command line arguments and initialize
+         * standard input and output
+         */
         if (__pcb == NULL) {
                 argc = 0;
 …
+        }
+        /* Run main() and set task return value
+           according the result */
+        (void) task_retval(main(argc, argv));
+        /*
+         * Run main() and set task return value
+         * according the result
+         */
+        int retval = main(argc, argv);
+        exit(retval);
+}
 void __exit(void)
+void exit(int status)
+{
+        __stdio_done();
+        fibril_teardown(__tcb_get()->fibril_data);
+        _exit(0);
+        if (env_setup) {
+                __stdio_done();
+                task_retval(status);
+                fibril_teardown(__tcb_get()->fibril_data);
+        }
+        __SYSCALL1(SYS_TASK_EXIT, false);
+        /* Unreachable */
+        while (1);
+}
+void abort(void)
+{
+        __SYSCALL1(SYS_TASK_EXIT, true);
+        /* Unreachable */
+        while (1);
+}

uspace/lib/c/generic/loader.c

-              r22027b6e
+              r8b5690f
  */
-#include <ipc/ipc.h>
 #include <ipc/loader.h>
 #include <ipc/services.h>
+#include <ipc/ns.h>
 #include <libc.h>
 #include <task.h>
 …
 loader_t *loader_connect(void)
+{
         int phone_id = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_LOAD, 0, 0);
+        int phone_id = service_connect_blocking(SERVICE_LOAD, 0, 0);
         if (phone_id < 0)
                 return NULL;
 …
                 return rc;
         ipc_hangup(ldr->phone_id);
+        async_hangup(ldr->phone_id);
         ldr->phone_id = 0;
         return EOK;
 …
 void loader_abort(loader_t *ldr)
+{
         ipc_hangup(ldr->phone_id);
+        async_hangup(ldr->phone_id);
         ldr->phone_id = 0;
+}

uspace/lib/c/generic/malloc.c

-              r22027b6e
+              r8b5690f
 #include <futex.h>
 #include <adt/gcdlcm.h>
+#include "private/malloc.h"
 /* Magic used in heap headers. */
 …
 /** Initialize the heap allocator
+ *
+ * Find how much physical memory we have and create
+ * the heap management structures that mark the whole
+ * physical memory as a single free block.
+ *
+ */
+void __heap_init(void)
+{
+        futex_down(&malloc_futex);
+        if (as_area_create((void *) &_heap, PAGE_SIZE,
+            AS_AREA_WRITE | AS_AREA_READ)) {
+                heap_pages = 1;
+                heap_start = (void *) ALIGN_UP((uintptr_t) &_heap, BASE_ALIGN);
+                heap_end =
+                    (void *) ALIGN_DOWN(((uintptr_t) &_heap) + PAGE_SIZE, BASE_ALIGN);
+                /* Make the entire area one large block. */
+                block_init(heap_start, heap_end - heap_start, true);
+        }
+        futex_up(&malloc_futex);
+ * Create initial heap memory area. This routine is
+ * only called from libc initialization, thus we do not
+ * take any locks.
+ *
+ */
+void __malloc_init(void)
+{
+        if (!as_area_create((void *) &_heap, PAGE_SIZE,
+            AS_AREA_WRITE | AS_AREA_READ))
+                abort();
+        heap_pages = 1;
+        heap_start = (void *) ALIGN_UP((uintptr_t) &_heap, BASE_ALIGN);
+        heap_end =
+            (void *) ALIGN_DOWN(((uintptr_t) &_heap) + PAGE_SIZE, BASE_ALIGN);
+        /* Make the entire area one large block. */
+        block_init(heap_start, heap_end - heap_start, true);
+}

uspace/lib/c/generic/net/icmp_api.c

-              r22027b6e
+              r8b5690f
 #include <net/modules.h>
 #include <net/ip_codes.h>
 #include <async.h>
 #include <sys/types.h>
 #include <sys/time.h>
 #include <errno.h>
-#include <ipc/ipc.h>
 #include <ipc/services.h>
 #include <ipc/icmp.h>

uspace/lib/c/generic/net/icmp_common.c

-              r22027b6e
+              r8b5690f
  */
 /** @addtogroup libc
+/** @addtogroup libc
  *  @{
  */
 …
 #include <net/modules.h>
 #include <net/icmp_common.h>
 #include <ipc/services.h>
 #include <ipc/icmp.h>
 #include <sys/time.h>
 #include <async.h>
 /** Connects to the ICMP module.
+/** Connect to the ICMP module.
+ *
+ * @param service       The ICMP module service. Ignored parameter.
+ * @param[in] timeout   The connection timeout in microseconds. No timeout if
+ *                      set to zero.
+ * @return              The ICMP module phone on success.
+ * @return              ETIMEOUT if the connection timeouted.
+ * @param[in] timeout Connection timeout in microseconds, zero
+ *                    for no timeout.
+ *
+ * @return ICMP module phone on success.
+ * @return ETIMEOUT if the connection timeouted.
+ *
  */
 int icmp_connect_module(services_t service, suseconds_t timeout)
+int icmp_connect_module(suseconds_t timeout)
+{
+        int phone;
+        phone = connect_to_service_timeout(SERVICE_ICMP, timeout);
+        if (phone >= 0)
+                async_req_0_0(phone, NET_ICMP_INIT);
+        return phone;
+        return connect_to_service_timeout(SERVICE_ICMP, timeout);
+}

uspace/lib/c/generic/net/modules.c

-              r22027b6e
+              r8b5690f
 /** @file
  * Generic module functions implementation.
+ * Generic module functions implementation.
+ *
  * @todo MAKE IT POSSIBLE TO REMOVE THIS FILE VIA EITHER REPLACING PART OF ITS
 …
 #include <errno.h>
 #include <sys/time.h>
-#include <ipc/ipc.h>
 #include <ipc/services.h>
 #include <net/modules.h>
 …
 #define MODULE_WAIT_TIME        (10 * 1000)
 /** Answers the call.
+ *
  * @param[in] callid    The call identifier.
  * @param[in] result    The message processing result.
  * @param[in] answer    The message processing answer.
  * @param[in] answer_count The number of answer parameters.
  */
+void
 answer_call(ipc_callid_t callid, int result, ipc_call_t *answer,
     int answer_count)
+{
         /* Choose the most efficient answer function */
         if (answer || (!answer_count)) {
                 switch (answer_count) {
+/** Answer a call.
+ *
+ * @param[in] callid Call identifier.
+ * @param[in] result Message processing result.
+ * @param[in] answer Message processing answer.
+ * @param[in] count  Number of answer parameters.
+ *
+ */
+void answer_call(ipc_callid_t callid, int result, ipc_call_t *answer,
+    size_t count)
+{
+        /* Choose the most efficient function */
+        if ((answer != NULL) || (count == 0)) {
+                switch (count) {
                 case 0:
                         ipc_answer_0(callid, (sysarg_t) result);
+                        async_answer_0(callid, (sysarg_t) result);
                         break;
                 case 1:
                         ipc_answer_1(callid, (sysarg_t) result,
+                        async_answer_1(callid, (sysarg_t) result,
                             IPC_GET_ARG1(*answer));
                         break;
                 case 2:
                         ipc_answer_2(callid, (sysarg_t) result,
+                        async_answer_2(callid, (sysarg_t) result,
                             IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer));
                         break;
                 case 3:
                         ipc_answer_3(callid, (sysarg_t) result,
+                        async_answer_3(callid, (sysarg_t) result,
                             IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
                             IPC_GET_ARG3(*answer));
                         break;
                 case 4:
                         ipc_answer_4(callid, (sysarg_t) result,
+                        async_answer_4(callid, (sysarg_t) result,
                             IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
                             IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer));
 …
                 case 5:
                 default:
                         ipc_answer_5(callid, (sysarg_t) result,
+                        async_answer_5(callid, (sysarg_t) result,
                             IPC_GET_ARG1(*answer), IPC_GET_ARG2(*answer),
                             IPC_GET_ARG3(*answer), IPC_GET_ARG4(*answer),
 …
     sysarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout)
+{
-        int rc;
         /* Connect to the needed service */
         int phone = connect_to_service_timeout(need, timeout);
         if (phone >= 0) {
                 /* Request the bidirectional connection */
+                sysarg_t phonehash;
+                rc = ipc_connect_to_me(phone, arg1, arg2, arg3, &phonehash);
+                int rc = async_connect_to_me(phone, arg1, arg2, arg3, client_receiver);
                 if (rc != EOK) {
                         ipc_hangup(phone);
+                        async_hangup(phone);
                         return rc;
+                }
-                async_new_connection(phonehash, 0, NULL, client_receiver);
+        }
 …
+}
+/** Refreshes answer structure and parameters count.
+ *
+ * Erases all attributes.
+ *
+ * @param[in,out] answer The message processing answer structure.
+ * @param[in,out] answer_count The number of answer parameters.
+ */
+void refresh_answer(ipc_call_t *answer, int *answer_count)
+{
+        if (answer_count)
+                *answer_count = 0;
+        if (answer) {
+/** Refresh answer structure and argument count.
+ *
+ * Erase all arguments.
+ *
+ * @param[in,out] answer Message processing answer structure.
+ * @param[in,out] count  Number of answer arguments.
+ *
+ */
+void refresh_answer(ipc_call_t *answer, size_t *count)
+{
+        if (count != NULL)
+                *count = 0;
+        if (answer != NULL) {
                 IPC_SET_RETVAL(*answer, 0);
-                /* Just to be precise */
                 IPC_SET_IMETHOD(*answer, 0);
                 IPC_SET_ARG1(*answer, 0);

uspace/lib/c/generic/net/socket_client.c

-              r22027b6e
+              r8b5690f
 #include <stdlib.h>
 #include <errno.h>
+#include <task.h>
 #include <ipc/services.h>
 #include <ipc/socket.h>
 #include <net/modules.h>
 #include <net/in.h>
 …
+        }
         ipc_answer_0(callid, (sysarg_t) rc);
+        async_answer_0(callid, (sysarg_t) rc);
         goto loop;
+}
 …
         /* Read address */
         ipc_data_read_start(socket->phone, cliaddr, *addrlen);
+        async_data_read_start(socket->phone, cliaddr, *addrlen);
         fibril_rwlock_write_unlock(&socket_globals.lock);
         async_wait_for(message_id, &ipc_result);

uspace/lib/c/generic/private/async.h

-              r22027b6e
+              r8b5690f
  */
 #ifndef LIBC_ASYNC_PRIV_H_
 #define LIBC_ASYNC_PRIV_H_
+#ifndef LIBC_PRIVATE_ASYNC_H_
+#define LIBC_PRIVATE_ASYNC_H_
 #include <adt/list.h>
 …
         /** If true, we have timed out. */
         bool occurred;
         /** Expiration time. */
         struct timeval expires;
 …
 } wu_event_t;
 /** Structures of this type represent a waiting fibril. */
 typedef struct {
 …
         /** If true, this fibril is currently active. */
         bool active;
         /** Timeout wait data. */
         to_event_t to_event;
 …
 } awaiter_t;
+extern void async_insert_timeout(awaiter_t *wd);
+extern void __async_init(void);
+extern void async_insert_timeout(awaiter_t *);
 #endif

uspace/lib/c/generic/private/async_sess.h

-              r22027b6e
+              r8b5690f
 /*
  * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2011 Martin Decky
  * All rights reserved.
+ *
 …
  */
 #include <stdio.h>
 #include <stdlib.h>
+#ifndef LIBC_PRIVATE_ASYNC_SESS_H_
+#define LIBC_PRIVATE_ASYNC_SESS_H_
+/* TODO
+void errx(int __status, __const char *__format, ...)
+{
+        _exit(0);
+}
+*/
+extern void __async_sess_init(void);
+#endif
 /** @}

uspace/lib/c/generic/private/io.h

-              r22027b6e
+              r8b5690f
 /*
  * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2011 Martin Decky
  * All rights reserved.
+ *
 …
  */
 /** @addtogroup ip
+/** @addtogroup libc
  * @{
  */
 /** @file
- * IP module functions.
- * The functions are used as IP module entry points.
  */
 #ifndef NET_IP_MODULE_H_
 #define NET_IP_MODULE_H_
+#ifndef LIBC_PRIVATE_IO_H_
+#define LIBC_PRIVATE_IO_H_
 #include <ipc/ipc.h>
+#include <vfs/vfs.h>
+extern int ip_initialize(async_client_conn_t);
+extern int ip_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
+    int *);
+extern void __stdio_init(int filc, fdi_node_t *filv[]);
+extern void __stdio_done(void);
 #endif

uspace/lib/c/generic/private/libc.h

-              r22027b6e
+              r8b5690f
 /*
  * Copyright (c) 2009 Lukas Mejdrech
+ * Copyright (c) 2011 Martin Decky
  * All rights reserved.
+ *
 …
  */
 /** @addtogroup arp
+/** @addtogroup libc
  * @{
  */
 /** @file
- * ARP module functions.
- * The functions are used as ARP module entry points.
  */
 #ifndef NET_ARP_MODULE_H_
 #define NET_ARP_MODULE_H_
+#ifndef LIBC_PRIVATE_LIBC_H_
+#define LIBC_PRIVATE_LIBC_H_
+#include <ipc/ipc.h>
+#include <async.h>
+extern int arp_initialize(async_client_conn_t);
+extern int arp_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
+    int *);
+extern int main(int, char *[]);
+extern void __main(void *) __attribute__((noreturn));
 #endif

uspace/lib/c/generic/private/thread.h

-              r22027b6e
+              r8b5690f
 /*
  * Copyright (c) 2008 Lukas Mejdrech
+ * Copyright (c) 2011 Martin Decky
  * All rights reserved.
+ *
 …
  */
 /** @addtogroup tcp
+/** @addtogroup libc
  * @{
  */
 /** @file
- * TCP module functions.
- * The functions are used as TCP module entry points.
  */
 #ifndef NET_TCP_MODULE_H_
 #define NET_TCP_MODULE_H_
+#ifndef LIBC_PRIVATE_THREAD_H_
+#define LIBC_PRIVATE_THREAD_H_
+#include <async.h>
+#include <ipc/ipc.h>
+#include <kernel/proc/uarg.h>
+extern int tcp_initialize(async_client_conn_t);
+extern int tcp_message_standalone(ipc_callid_t, ipc_call_t *, ipc_call_t *,
+    int *);
+extern void __thread_entry(void);
+extern void __thread_main(uspace_arg_t *);
 #endif

uspace/lib/c/generic/stats.c

-              r22027b6e
+              r8b5690f
 #include <stats.h>
 #include <sysinfo.h>
-#include <assert.h>
 #include <errno.h>
 #include <stdio.h>
 #include <inttypes.h>
+#include <malloc.h>
 #define SYSINFO_STATS_MAX_PATH  64
 …
             (stats_cpu_t *) sysinfo_get_data("system.cpus", &size);
+        assert((size % sizeof(stats_cpu_t)) == 0);
+        if ((size % sizeof(stats_cpu_t)) != 0) {
+                if (stats_cpus != NULL)
+                        free(stats_cpus);
+                *count = 0;
+                return NULL;
+        }
         *count = size / sizeof(stats_cpu_t);
 …
             (stats_physmem_t *) sysinfo_get_data("system.physmem", &size);
+        assert((size == sizeof(stats_physmem_t)) || (size == 0));
+        if (size != sizeof(stats_physmem_t)) {
+                if (stats_physmem != NULL)
+                        free(stats_physmem);
+                return NULL;
+        }
         return stats_physmem;
 …
             (stats_task_t *) sysinfo_get_data("system.tasks", &size);
+        assert((size % sizeof(stats_task_t)) == 0);
+        if ((size % sizeof(stats_task_t)) != 0) {
+                if (stats_tasks != NULL)
+                        free(stats_tasks);
+                *count = 0;
+                return NULL;
+        }
         *count = size / sizeof(stats_task_t);
 …
             (stats_task_t *) sysinfo_get_data(name, &size);
+        assert((size == sizeof(stats_task_t)) || (size == 0));
+        if (size != sizeof(stats_task_t)) {
+                if (stats_task != NULL)
+                        free(stats_task);
+                return NULL;
+        }
         return stats_task;
 …
             (stats_thread_t *) sysinfo_get_data("system.threads", &size);
+        assert((size % sizeof(stats_thread_t)) == 0);
+        if ((size % sizeof(stats_thread_t)) != 0) {
+                if (stats_threads != NULL)
+                        free(stats_threads);
+                *count = 0;
+                return NULL;
+        }
         *count = size / sizeof(stats_thread_t);
 …
             (stats_thread_t *) sysinfo_get_data(name, &size);
+        assert((size == sizeof(stats_thread_t)) || (size == 0));
+        if (size != sizeof(stats_thread_t)) {
+                if (stats_thread != NULL)
+                        free(stats_thread);
+                return NULL;
+        }
         return stats_thread;
 …
             (stats_exc_t *) sysinfo_get_data("system.exceptions", &size);
+        assert((size % sizeof(stats_exc_t)) == 0);
+        if ((size % sizeof(stats_exc_t)) != 0) {
+                if (stats_exceptions != NULL)
+                        free(stats_exceptions);
+                *count = 0;
+                return NULL;
+        }
         *count = size / sizeof(stats_exc_t);
 …
+{
         char name[SYSINFO_STATS_MAX_PATH];
         snprintf(name, SYSINFO_STATS_MAX_PATH, "system.exceptionss.%u", excn);
+        snprintf(name, SYSINFO_STATS_MAX_PATH, "system.exceptions.%u", excn);
         size_t size = 0;
 …
             (stats_exc_t *) sysinfo_get_data(name, &size);
+        assert((size == sizeof(stats_exc_t)) || (size == 0));
+        if (size != sizeof(stats_exc_t)) {
+                if (stats_exception != NULL)
+                        free(stats_exception);
+                return NULL;
+        }
         return stats_exception;
 …
             (load_t *) sysinfo_get_data("system.load", &size);
+        assert((size % sizeof(load_t)) == 0);
+        if ((size % sizeof(load_t)) != 0) {
+                if (load != NULL)
+                        free(load);
+                *count = 0;
+                return NULL;
+        }
         *count = size / sizeof(load_t);

uspace/lib/c/generic/sysinfo.c

-              r22027b6e
+              r8b5690f
 void *sysinfo_get_data(const char *path, size_t *size)
+{
+        /* The binary data size might change during time.
+           Unfortunatelly we cannot allocate the buffer
+           and transfer the data as a single atomic operation.
+        /*
+         * The binary data size might change during time.
+         * Unfortunatelly we cannot allocate the buffer
+         * and transfer the data as a single atomic operation.
+         */
+           Let's hope that the number of iterations is bounded
+           in common cases. */
+        void *data = NULL;
+        while (true) {
+                /* Get the binary data size */
+                int ret = sysinfo_get_data_size(path, size);
+                if ((ret != EOK) || (size == 0)) {
+                        /* Not a binary data item
+                           or an empty item */
+                        break;
+                }
+                data = realloc(data, *size);
+                if (data == NULL)
+                        break;
+                /* Get the data */
+                ret = __SYSCALL4(SYS_SYSINFO_GET_DATA, (sysarg_t) path,
+                    (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size);
+                if (ret == EOK)
+                        return data;
+                if (ret != ENOMEM) {
+                        /* The failure to get the data was not caused
+                           by wrong buffer size */
+                        break;
+                }
+        /* Get the binary data size */
+        int ret = sysinfo_get_data_size(path, size);
+        if ((ret != EOK) || (size == 0)) {
+                /*
+                 * Not a binary data item
+                 * or an empty item.
+                 */
+                *size = 0;
+                return NULL;
+        }
+        if (data != NULL)
+                free(data);
+        void *data = malloc(*size);
+        if (data == NULL) {
+                *size = 0;
+                return NULL;
+        }
+        /* Get the data */
+        size_t sz;
+        ret = __SYSCALL5(SYS_SYSINFO_GET_DATA, (sysarg_t) path,
+            (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size,
+            (sysarg_t) &sz);
+        if (ret == EOK) {
+                *size = sz;
+                return data;
+        }
+        free(data);
         *size = 0;
         return NULL;

uspace/lib/c/generic/thread.c

-              r22027b6e
+              r8b5690f
  */
 /** @file
  */
+ */
 #include <thread.h>
 …
 #include <str.h>
 #include <async.h>
+#include "private/thread.h"
 #ifndef THREAD_INITIAL_STACK_PAGES_NO
 …
  * This function is called from __thread_entry() and is used
  * to call the thread's implementing function and perform cleanup
+ * and exit when thread returns back. Do not call this function
+ * directly.
+ * and exit when thread returns back.
+ *
  * @param uarg Pointer to userspace argument structure.
+ *
  */
 void __thread_main(uspace_arg_t *uarg)
+{
+        fibril_t *f;
+        f = fibril_setup();
+        __tcb_set(f->tcb);
+        fibril_t *fibril = fibril_setup();
+        if (fibril == NULL)
+                thread_exit(0);
+        __tcb_set(fibril->tcb);
         uarg->uspace_thread_function(uarg->uspace_thread_arg);
+        /* XXX: we cannot free the userspace stack while running on it */
+//      free(uarg->uspace_stack);
+//      free(uarg);
+        /* XXX: we cannot free the userspace stack while running on it
+                free(uarg->uspace_stack);
+                free(uarg);
+        */
         /* If there is a manager, destroy it */
         async_destroy_manager();
         fibril_teardown(f);
+        fibril_teardown(fibril);
         thread_exit(0);
+}
 …
+ *
  * @param status Exit status. Currently not used.
+ *
  */
 void thread_exit(int status)
+{
         __SYSCALL1(SYS_THREAD_EXIT, (sysarg_t) status);
+        for (;;)
+                ;
+        /* Unreachable */
+        while (1);
+}

uspace/lib/c/generic/time.c

-              r22027b6e
+              r8b5690f
 #include <sys/time.h>
+#include <unistd.h>
+#include <ipc/ipc.h>
+#include <stdio.h>
+#include <time.h>
+#include <bool.h>
 #include <arch/barrier.h>
+#include <unistd.h>
+#include <atomic.h>
+#include <sysinfo.h>
+#include <ipc/services.h>
+#include <libc.h>
+#include <macros.h>
+#include <errno.h>
 #include <sysinfo.h>
 #include <as.h>
 #include <ddi.h>
+#include <time.h>
+/* Pointers to public variables with time */
+#include <libc.h>
+/** Pointer to kernel shared variables with time */
 struct {
         volatile sysarg_t seconds1;
 …
 /** Add microseconds to given timeval.
+ *
+ * @param tv            Destination timeval.
+ * @param usecs         Number of microseconds to add.
+ * @param tv    Destination timeval.
+ * @param usecs Number of microseconds to add.
+ *
  */
 void tv_add(struct timeval *tv, suseconds_t usecs)
 …
         tv->tv_sec += usecs / 1000000;
         tv->tv_usec += usecs % 1000000;
         if (tv->tv_usec > 1000000) {
                 tv->tv_sec++;
 …
 /** Subtract two timevals.
+ *
+ * @param tv1           First timeval.
+ * @param tv2           Second timeval.
+ *
+ * @return              Return difference between tv1 and tv2 (tv1 - tv2) in
+ *                      microseconds.
+ * @param tv1 First timeval.
+ * @param tv2 Second timeval.
+ *
+ * @return Difference between tv1 and tv2 (tv1 - tv2) in
+ *         microseconds.
+ *
  */
 suseconds_t tv_sub(struct timeval *tv1, struct timeval *tv2)
+{
+        suseconds_t result;
+        result = tv1->tv_usec - tv2->tv_usec;
+        result += (tv1->tv_sec - tv2->tv_sec) * 1000000;
+        return result;
+        return (tv1->tv_usec - tv2->tv_usec) +
+            ((tv1->tv_sec - tv2->tv_sec) * 1000000);
+}
 /** Decide if one timeval is greater than the other.
+ *
+ * @param t1            First timeval.
+ * @param t2            Second timeval.
+ *
+ * @return              Return true tv1 is greater than tv2. Otherwise return
+ *                      false.
+ * @param t1 First timeval.
+ * @param t2 Second timeval.
+ *
+ * @return True if tv1 is greater than tv2.
+ * @return False otherwise.
+ *
  */
 int tv_gt(struct timeval *tv1, struct timeval *tv2)
+{
         if (tv1->tv_sec > tv2->tv_sec)
+                return 1;
+        if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec > tv2->tv_usec)
+                return 1;
+        return 0;
+                return true;
+        if ((tv1->tv_sec == tv2->tv_sec) && (tv1->tv_usec > tv2->tv_usec))
+                return true;
+        return false;
+}
 /** Decide if one timeval is greater than or equal to the other.
+ *
+ * @param tv1           First timeval.
+ * @param tv2           Second timeval.
+ *
+ * @return              Return true if tv1 is greater than or equal to tv2.
+ *                      Otherwise return false.
+ * @param tv1 First timeval.
+ * @param tv2 Second timeval.
+ *
+ * @return True if tv1 is greater than or equal to tv2.
+ * @return False otherwise.
+ *
  */
 int tv_gteq(struct timeval *tv1, struct timeval *tv2)
+{
         if (tv1->tv_sec > tv2->tv_sec)
+                return 1;
+        if (tv1->tv_sec == tv2->tv_sec && tv1->tv_usec >= tv2->tv_usec)
+                return 1;
+        return 0;
+}
+/** POSIX gettimeofday
+ *
+ * The time variables are memory mapped(RO) from kernel, which updates
+ * them periodically. As it is impossible to read 2 values atomically, we
+ * use a trick: First read a seconds, then read microseconds, then
+ * read seconds again. If a second elapsed in the meantime, set it to zero.
+ * This provides assurance, that at least the
+ * sequence of subsequent gettimeofday calls is ordered.
+                return true;
+        if ((tv1->tv_sec == tv2->tv_sec) && (tv1->tv_usec >= tv2->tv_usec))
+                return true;
+        return false;
+}
+/** Get time of day
+ *
+ * The time variables are memory mapped (read-only) from kernel which
+ * updates them periodically.
+ *
+ * As it is impossible to read 2 values atomically, we use a trick:
+ * First we read the seconds, then we read the microseconds, then we
+ * read the seconds again. If a second elapsed in the meantime, set
+ * the microseconds to zero.
+ *
+ * This assures that the values returned by two subsequent calls
+ * to gettimeofday() are monotonous.
+ *
  */
 int gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+        void *mapping;
+        sysarg_t s1, s2;
+        int rights;
+        int res;
+        if (!ktime) {
+                mapping = as_get_mappable_page(PAGE_SIZE);
+                /* Get the mapping of kernel clock */
+                res = ipc_share_in_start_1_1(PHONE_NS, mapping, PAGE_SIZE,
+                    SERVICE_MEM_REALTIME, &rights);
+                if (res) {
+                        printf("Failed to initialize timeofday memarea\n");
+                        _exit(1);
+        if (ktime == NULL) {
+                uintptr_t faddr;
+                int rc = sysinfo_get_value("clock.faddr", &faddr);
+                if (rc != EOK) {
+                        errno = rc;
+                        return -1;
+                }
                 if (!(rights & AS_AREA_READ)) {
                         printf("Received bad rights on time area: %X\n",
                             rights);
                         as_area_destroy(mapping);
                         _exit(1);
+                void *addr = as_get_mappable_page(PAGE_SIZE);
+                if (addr == NULL) {
+                        errno = ENOMEM;
+                        return -1;
+                }
+                ktime = mapping;
+        }
+                rc = physmem_map((void *) faddr, addr, 1,
+                    AS_AREA_READ | AS_AREA_CACHEABLE);
+                if (rc != EOK) {
+                        as_area_destroy(addr);
+                        errno = rc;
+                        return -1;
+                }
+                ktime = addr;
+        }
         if (tz) {
                 tz->tz_minuteswest = 0;
                 tz->tz_dsttime = DST_NONE;
+        }
+        s2 = ktime->seconds2;
+        sysarg_t s2 = ktime->seconds2;
         read_barrier();
         tv->tv_usec = ktime->useconds;
         read_barrier();
+        s1 = ktime->seconds1;
+        sysarg_t s1 = ktime->seconds1;
         if (s1 != s2) {
+                tv->tv_sec = max(s1, s2);
                 tv->tv_usec = 0;
-                tv->tv_sec = s1 > s2 ? s1 : s2;
         } else
                 tv->tv_sec = s1;
         return 0;
+}
 …
+{
         struct timeval tv;
         if (gettimeofday(&tv, NULL))
                 return (time_t) -1;
         if (tloc)
                 *tloc = tv.tv_sec;
         return tv.tv_sec;
+}
+/** Wait unconditionally for specified number of microseconds */
+/** Wait unconditionally for specified number of microseconds
+ *
+ */
 int usleep(useconds_t usec)
+{
 …
+}
+/** Wait unconditionally for specified number of seconds */
+/** Wait unconditionally for specified number of seconds
+ *
+ */
 unsigned int sleep(unsigned int sec)
+{
+        /* Sleep in 1000 second steps to support
+           full argument range */
+        /*
+         * Sleep in 1000 second steps to support
+         * full argument range
+         */
         while (sec > 0) {
                 unsigned int period = (sec > 1000) ? 1000 : sec;
                 usleep(period * 1000000);
                 sec -= period;
+        }
         return 0;
+}

uspace/lib/c/generic/udebug.c

-              r22027b6e
+              r8b5690f
  */
 /** @file
  */
+ */
 #include <udebug.h>
 #include <sys/types.h>
-#include <ipc/ipc.h>
 #include <async.h>

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

-              r22027b6e
+              r8b5690f
 /*
  * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2008 Jakub Jermar
  * All rights reserved.
+ *
 …
 #include <sys/stat.h>
 #include <sys/types.h>
-#include <ipc/ipc.h>
 #include <ipc/services.h>
+#include <ipc/ns.h>
 #include <async.h>
+#include <atomic.h>
+#include <futex.h>
+#include <fibril_synch.h>
 #include <errno.h>
+#include <assert.h>
 #include <str.h>
 #include <devmap.h>
 …
 #include <ipc/devmap.h>
+static async_sess_t vfs_session;
+static FIBRIL_MUTEX_INITIALIZE(vfs_phone_mutex);
 static int vfs_phone = -1;
+static futex_t vfs_phone_futex = FUTEX_INITIALIZER;
 static futex_t cwd_futex = FUTEX_INITIALIZER;
+static FIBRIL_MUTEX_INITIALIZE(cwd_mutex);
 static int cwd_fd = -1;
 …
         char *ncwd_path_nc;
         futex_down(&cwd_futex);
+        fibril_mutex_lock(&cwd_mutex);
         size_t size = str_size(path);
         if (*path != '/') {
                 if (!cwd_path) {
                         futex_up(&cwd_futex);
+                        fibril_mutex_unlock(&cwd_mutex);
                         return NULL;
+                }
                 ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
                 if (!ncwd_path_nc) {
                         futex_up(&cwd_futex);
+                        fibril_mutex_unlock(&cwd_mutex);
                         return NULL;
+                }
 …
                 ncwd_path_nc = malloc(size + 1);
                 if (!ncwd_path_nc) {
                         futex_up(&cwd_futex);
+                        fibril_mutex_unlock(&cwd_mutex);
                         return NULL;
+                }
 …
         ncwd_path = canonify(ncwd_path_nc, retlen);
         if (!ncwd_path) {
                 futex_up(&cwd_futex);
+                fibril_mutex_unlock(&cwd_mutex);
                 free(ncwd_path_nc);
                 return NULL;
 …
         free(ncwd_path_nc);
         if (!ncwd_path) {
                 futex_up(&cwd_futex);
+                fibril_mutex_unlock(&cwd_mutex);
                 return NULL;
+        }
         futex_up(&cwd_futex);
+        fibril_mutex_unlock(&cwd_mutex);
         return ncwd_path;
+}
+/** Connect to VFS service and create session. */
 static void vfs_connect(void)
+{
         while (vfs_phone < 0)
+                vfs_phone = ipc_connect_me_to_blocking(PHONE_NS, SERVICE_VFS, 0, 0);
+                vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0);
+        async_session_create(&vfs_session, vfs_phone, 0);
+}
+/** Start an async exchange on the VFS session.
+ *
+ * @return              New phone to be used during the exchange.
+ */
+static int vfs_exchange_begin(void)
+{
+        fibril_mutex_lock(&vfs_phone_mutex);
+        if (vfs_phone < 0)
+                vfs_connect();
+        fibril_mutex_unlock(&vfs_phone_mutex);
+        return async_exchange_begin(&vfs_session);
+}
+/** End an async exchange on the VFS session.
+ *
+ * @param phone         Phone used during the exchange.
+ */
+static void vfs_exchange_end(int phone)
+{
+        async_exchange_end(&vfs_session, phone);
+}
 …
+        }
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         sysarg_t rc_orig;
         aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, devmap_handle, flags, NULL);
         sysarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
         if (rc != EOK) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                vfs_exchange_end(vfs_phone);
                 free(mpa);
+                async_wait_for(req, &rc_orig);
                 if (null_id != -1)
 …
         rc = async_data_write_start(vfs_phone, (void *) opts, str_size(opts));
         if (rc != EOK) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                vfs_exchange_end(vfs_phone);
                 free(mpa);
+                async_wait_for(req, &rc_orig);
                 if (null_id != -1)
 …
         rc = async_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
         if (rc != EOK) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                vfs_exchange_end(vfs_phone);
                 free(mpa);
+                async_wait_for(req, &rc_orig);
                 if (null_id != -1)
 …
         rc = async_req_0_0(vfs_phone, IPC_M_PING);
         if (rc != EOK) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                vfs_exchange_end(vfs_phone);
                 free(mpa);
+                async_wait_for(req, &rc_orig);
                 if (null_id != -1)
 …
+        }
+        async_wait_for(req, &rc);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        vfs_exchange_end(vfs_phone);
         free(mpa);
+        async_wait_for(req, &rc);
         if ((rc != EOK) && (null_id != -1))
 …
                 return ENOMEM;
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         req = async_send_0(vfs_phone, VFS_IN_UNMOUNT, NULL);
         rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
         if (rc != EOK) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                vfs_exchange_end(vfs_phone);
                 free(mpa);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        async_wait_for(req, &rc);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
         free(mpa);
+        async_wait_for(req, &rc);
         return (int) rc;
 …
 static int open_internal(const char *abs, size_t abs_size, int lflag, int oflag)
+{
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         ipc_call_t answer;
 …
         if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
                 sysarg_t rc_orig;
                 async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        async_wait_for(req, &rc);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
+        async_wait_for(req, &rc);
         if (rc != EOK)
 …
 int open_node(fdi_node_t *node, int oflag)
+{
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         ipc_call_t answer;
 …
             node->devmap_handle, node->index, oflag, &answer);
         sysarg_t rc;
+        async_wait_for(req, &rc);
         async_serialize_end();
         futex_up(&vfs_phone_futex);
+        vfs_exchange_end(vfs_phone);
+        sysarg_t rc;
+        async_wait_for(req, &rc);
         if (rc != EOK)
 …
         sysarg_t rc;
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         rc = async_req_1_0(vfs_phone, VFS_IN_CLOSE, fildes);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        vfs_exchange_end(vfs_phone);
         return (int)rc;
 …
         aid_t req;
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
         rc = async_data_read_start(vfs_phone, (void *)buf, nbyte);
         if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
                 sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
                 if (rc_orig == EOK)
                         return (ssize_t) rc;
 …
                         return (ssize_t) rc_orig;
+        }
+        async_wait_for(req, &rc);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        vfs_exchange_end(vfs_phone);
+        async_wait_for(req, &rc);
         if (rc == EOK)
                 return (ssize_t) IPC_GET_ARG1(answer);
 …
         aid_t req;
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
         rc = async_data_write_start(vfs_phone, (void *)buf, nbyte);
         if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
                 sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
                 if (rc_orig == EOK)
                         return (ssize_t) rc;
 …
                         return (ssize_t) rc_orig;
+        }
+        async_wait_for(req, &rc);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        vfs_exchange_end(vfs_phone);
+        async_wait_for(req, &rc);
         if (rc == EOK)
                 return (ssize_t) IPC_GET_ARG1(answer);
 …
 int fsync(int fildes)
+{
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         sysarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        vfs_exchange_end(vfs_phone);
         return (int) rc;
 …
 off64_t lseek(int fildes, off64_t offset, int whence)
+{
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         sysarg_t newoff_lo;
 …
             &newoff_lo, &newoff_hi);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        vfs_exchange_end(vfs_phone);
         if (rc != EOK)
 …
         sysarg_t rc;
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         rc = async_req_3_0(vfs_phone, VFS_IN_TRUNCATE, fildes,
             LOWER32(length), UPPER32(length));
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        vfs_exchange_end(vfs_phone);
         return (int) rc;
 …
         aid_t req;
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL);
         rc = async_data_read_start(vfs_phone, (void *) stat, sizeof(struct stat));
         if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
                 sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
                 if (rc_orig == EOK)
                         return (ssize_t) rc;
 …
                         return (ssize_t) rc_orig;
+        }
+        async_wait_for(req, &rc);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        vfs_exchange_end(vfs_phone);
+        async_wait_for(req, &rc);
         return rc;
 …
                 return ENOMEM;
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         req = async_send_0(vfs_phone, VFS_IN_STAT, NULL);
         rc = async_data_write_start(vfs_phone, pa, pa_size);
         if (rc != EOK) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                vfs_exchange_end(vfs_phone);
                 free(pa);
+                async_wait_for(req, &rc_orig);
                 if (rc_orig == EOK)
                         return (int) rc;
 …
         rc = async_data_read_start(vfs_phone, stat, sizeof(struct stat));
         if (rc != EOK) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                vfs_exchange_end(vfs_phone);
                 free(pa);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        async_wait_for(req, &rc);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
         free(pa);
+        async_wait_for(req, &rc);
         return rc;
+}
 …
                 return ENOMEM;
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL);
         rc = async_data_write_start(vfs_phone, pa, pa_size);
         if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+                free(pa);
                 sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                free(pa);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        async_wait_for(req, &rc);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
         free(pa);
+        async_wait_for(req, &rc);
         return rc;
+}
 …
                 return ENOMEM;
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL);
         rc = async_data_write_start(vfs_phone, pa, pa_size);
         if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+                free(pa);
                 sysarg_t rc_orig;
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                free(pa);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        async_wait_for(req, &rc);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
         free(pa);
+        async_wait_for(req, &rc);
         return rc;
+}
 …
+        }
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL);
         rc = async_data_write_start(vfs_phone, olda, olda_size);
         if (rc != EOK) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                vfs_exchange_end(vfs_phone);
                 free(olda);
                 free(newa);
+                async_wait_for(req, &rc_orig);
                 if (rc_orig == EOK)
                         return (int) rc;
 …
         rc = async_data_write_start(vfs_phone, newa, newa_size);
         if (rc != EOK) {
+                async_wait_for(req, &rc_orig);
+                async_serialize_end();
+                futex_up(&vfs_phone_futex);
+                vfs_exchange_end(vfs_phone);
                 free(olda);
                 free(newa);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        async_wait_for(req, &rc);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+                async_wait_for(req, &rc_orig);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(vfs_phone);
         free(olda);
         free(newa);
+        async_wait_for(req, &rc);
         return rc;
+}
 …
+        }
         futex_down(&cwd_futex);
+        fibril_mutex_lock(&cwd_mutex);
         if (cwd_fd >= 0)
 …
         cwd_size = abs_size;
         futex_up(&cwd_futex);
+        fibril_mutex_unlock(&cwd_mutex);
         return EOK;
+}
 …
                 return NULL;
         futex_down(&cwd_futex);
+        fibril_mutex_lock(&cwd_mutex);
         if ((cwd_size == 0) || (size < cwd_size + 1)) {
                 futex_up(&cwd_futex);
+                fibril_mutex_unlock(&cwd_mutex);
                 return NULL;
+        }
         str_cpy(buf, size, cwd_path);
         futex_up(&cwd_futex);
+        fibril_mutex_unlock(&cwd_mutex);
         return buf;
 …
 int dup2(int oldfd, int newfd)
+{
+        futex_down(&vfs_phone_futex);
+        async_serialize_start();
+        vfs_connect();
+        int vfs_phone = vfs_exchange_begin();
         sysarg_t ret;
         sysarg_t rc = async_req_2_1(vfs_phone, VFS_IN_DUP, oldfd, newfd, &ret);
+        async_serialize_end();
+        futex_up(&vfs_phone_futex);
+        vfs_exchange_end(vfs_phone);
         if (rc == EOK)

Context Navigation

Changeset 8b5690f in mainline for uspace/lib/c/generic

Legend:

uspace/lib/c/generic/async.c

uspace/lib/c/generic/async_sess.c

uspace/lib/c/generic/clipboard.c

uspace/lib/c/generic/ddi.c

uspace/lib/c/generic/devman.c

uspace/lib/c/generic/devmap.c

uspace/lib/c/generic/event.c

uspace/lib/c/generic/fibril_synch.c

uspace/lib/c/generic/io/io.c

uspace/lib/c/generic/ipc.c

uspace/lib/c/generic/libc.c

uspace/lib/c/generic/loader.c

uspace/lib/c/generic/malloc.c

uspace/lib/c/generic/net/icmp_api.c

uspace/lib/c/generic/net/icmp_common.c

uspace/lib/c/generic/net/modules.c

uspace/lib/c/generic/net/socket_client.c

uspace/lib/c/generic/private/async.h

uspace/lib/c/generic/private/async_sess.h

uspace/lib/c/generic/private/io.h

uspace/lib/c/generic/private/libc.h

uspace/lib/c/generic/private/thread.h

uspace/lib/c/generic/stats.c

uspace/lib/c/generic/sysinfo.c

uspace/lib/c/generic/thread.c

uspace/lib/c/generic/time.c

uspace/lib/c/generic/udebug.c

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

Download in other formats: