Changeset 474afc9 for uspace/lib/c/generic – HelenOS

uspace/lib/c/generic/as.c

-              r89acf204
+              r474afc9
 #include <bitops.h>
 #include <malloc.h>
+/** Last position allocated by as_get_mappable_page */
+static uintptr_t last_allocated = 0;
+#include "private/libc.h"
 /** Create address space area.
 …
+}
 /** Return pointer to some unmapped area, where fits new as_area
+/** Return pointer to unmapped address space area
+ *
  * @param size Requested size of the allocation.
+ *
  * @return pointer to the beginning
+ * @return Pointer to the beginning of unmapped address space area.
+ *
  */
 void *as_get_mappable_page(size_t size)
+{
+        if (size == 0)
+                return NULL;
+        size_t sz = 1 << (fnzb(size - 1) + 1);
+        if (last_allocated == 0)
+                last_allocated = get_max_heap_addr();
+        /*
+         * Make sure we allocate from naturally aligned address.
+         */
+        uintptr_t res = ALIGN_UP(last_allocated, sz);
+        last_allocated = res + ALIGN_UP(size, PAGE_SIZE);
+        return ((void *) res);
+        return (void *) __SYSCALL2(SYS_AS_GET_UNMAPPED_AREA,
+            (sysarg_t) __entry, (sysarg_t) size);
+}

uspace/lib/c/generic/async.c

-              r89acf204
+              r474afc9
  * 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 {
 …
         /** Link to the client tracking structure. */
         client_t *client;
         /** Messages that should be delivered to this fibril. */
         link_t msg_queue;
 …
 /** Identifier of the incoming connection handled by the current fibril. */
 fibril_local connection_t *FIBRIL_connection;
+static fibril_local connection_t *FIBRIL_connection;
 static void *default_client_data_constructor(void)
 …
+{
         assert(FIBRIL_connection);
         return FIBRIL_connection->client->data;
+}
+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);
+/** 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 LIST_INITIALIZE(timeout_list);
 #define CLIENT_HASH_TABLE_BUCKETS       32
 #define CONN_HASH_TABLE_BUCKETS         32
 static hash_index_t client_hash(unsigned long *key)
+#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) >> 4) % CLIENT_HASH_TABLE_BUCKETS);
+        return (((key[0]) >> 4) % CLIENT_HASH_TABLE_BUCKETS);
+}
 static int client_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
         client_t *cl = hash_table_get_instance(item, client_t, link);
         return (key[0] == cl->in_task_hash);
+        client_t *client = hash_table_get_instance(item, client_t, link);
+        return (key[0] == client->in_task_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_BUCKETS);
+        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 hash table removal callback function.
+ *
+ * This function is called whenever a connection is removed from the connection
+ * hash table.
+ *
+ * @param item Connection hash table item being removed.
+ *
+ */
+        connection_t *conn = hash_table_get_instance(item, connection_t, link);
+        return (key[0] == conn->in_phone_hash);
+}
 static void conn_remove(link_t *item)
+{
+        free(hash_table_get_instance(item, connection_t, link));
+}
+}
 /** Operations for the connection hash table. */
 …
         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.
+ *
 …
 static int connection_fibril(void *arg)
+{
-        unsigned long key;
-        client_t *cl;
-        link_t *lnk;
-        bool destroy = false;
         /*
          * 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
 …
          * hash in a new tracking structure.
          */
+        futex_down(&async_futex);
+        key = FIBRIL_connection->in_task_hash;
+        lnk = hash_table_find(&client_hash_table, &key);
+        unsigned long key = FIBRIL_connection->in_task_hash;
+        link_t *lnk = hash_table_find(&client_hash_table, &key);
+        client_t *client;
         if (lnk) {
                 cl = hash_table_get_instance(lnk, client_t, link);
                 cl->refcnt++;
+                client = hash_table_get_instance(lnk, client_t, link);
+                client->refcnt++;
         } else {
                 cl = malloc(sizeof(client_t));
                 if (!cl) {
+                client = malloc(sizeof(client_t));
+                if (!client) {
                         ipc_answer_0(FIBRIL_connection->callid, ENOMEM);
                         futex_up(&async_futex);
                         return 0;
+                }
+                cl->in_task_hash = FIBRIL_connection->in_task_hash;
+                client->in_task_hash = FIBRIL_connection->in_task_hash;
                 async_serialize_start();
                 cl->data = async_client_data_create();
+                client->data = async_client_data_create();
                 async_serialize_end();
+                cl->refcnt = 1;
+                hash_table_insert(&client_hash_table, &key, &cl->link);
+        }
+                client->refcnt = 1;
+                hash_table_insert(&client_hash_table, &key, &client->link);
+        }
         futex_up(&async_futex);
         FIBRIL_connection->client = cl;
+        FIBRIL_connection->client = client;
         /*
          * Call the connection handler function.
 …
          * Remove the reference for this client task connection.
          */
+        bool destroy;
         futex_down(&async_futex);
+        if (--cl->refcnt == 0) {
+        if (--client->refcnt == 0) {
                 hash_table_remove(&client_hash_table, &key, 1);
                 destroy = true;
+        }
+        } else
+                destroy = false;
         futex_up(&async_futex);
         if (destroy) {
+                if (cl->data)
+                        async_client_data_destroy(cl->data);
+                free(cl);
+        }
+                if (client->data)
+                        async_client_data_destroy(client->data);
+                free(client);
+        }
         /*
          * Remove myself from the connection hash table.
 …
          */
         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);
 …
                 ipc_answer_0(FIBRIL_connection->close_callid, EOK);
+        free(FIBRIL_connection);
         return 0;
+}
 …
                 if (callid)
                         ipc_answer_0(callid, ENOMEM);
                 return (uintptr_t) NULL;
+        }
 …
         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. */
+                /* Open new connection with fibril, etc. */
                 async_new_connection(call->in_task_hash, IPC_GET_ARG5(*call),
                     callid, call, client_connection);
                 goto out;
+                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)
+ */
+void __async_init(void)
+{
         if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS, 1,
+            &client_hash_table_ops) || !hash_table_create(&conn_hash_table,
+            CONN_HASH_TABLE_BUCKETS, 1, &conn_hash_table_ops)) {
+                return ENOMEM;
+        }
+        _async_sess_init();
+        return 0;
+            &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

-              r89acf204
+              r474afc9
 #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. */
 …
+ *
  * 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);
+        }
 …
                         data_phone = conn->data_phone;
                         free(conn);
                         ipc_hangup(data_phone);
+                        async_hangup(data_phone);
                         goto retry;
                 } else {
 …
                  * means that we simply hang up.
                  */
                 ipc_hangup(data_phone);
+                async_hangup(data_phone);
                 fibril_mutex_unlock(&async_sess_mutex);
                 return;

uspace/lib/c/generic/clipboard.c

-              r89acf204
+              r474afc9
 #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

-              r89acf204
+              r474afc9
+}
+/** 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

-              r89acf204
+              r474afc9
  * 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>
 …
         async_set_client_connection(conn);
         ipc_connect_to_me(phone, 0, 0, 0, NULL, NULL);
+        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

-              r89acf204
+              r474afc9
 #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);
         ipc_connect_to_me(phone, 0, 0, 0, NULL, NULL);
+        async_connect_to_me(phone, 0, 0, 0, NULL);
         async_wait_for(req, &retval);

uspace/lib/c/generic/event.c

-              r89acf204
+              r474afc9
  */
 /** @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

-              r89acf204
+              r474afc9
 #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();
+}
 …
         if (fibril_get_sercount() != 0)
                 core();
+                abort();
         futex_down(&async_futex);
 …
         if (fibril_get_sercount() != 0)
                 core();
+                abort();
         futex_down(&async_futex);
 …
         if (fibril_get_sercount() != 0)
                 core();
+                abort();
         futex_down(&async_futex);

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

-              r89acf204
+              r474afc9
 #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

-              r89acf204
+              r474afc9
 #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 taskhash      Storage where the kernel will store an opaque
+ *                      identifier of the client task.
+ * @param phonehash     Storage where the kernel 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,
+/** 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)
+{
 …
+}
+/** 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)
+/** 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

-              r89acf204
+              r474afc9
 #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

-              r89acf204
+              r474afc9
  */
-#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

-              r89acf204
+              r474afc9
 #include <futex.h>
 #include <adt/gcdlcm.h>
+/* Magic used in heap headers. */
+#define HEAP_BLOCK_HEAD_MAGIC  0xBEEF0101
+/* Magic used in heap footers. */
+#define HEAP_BLOCK_FOOT_MAGIC  0xBEEF0202
+/** Allocation alignment (this also covers the alignment of fields
+    in the heap header and footer) */
+#include "private/malloc.h"
+/** Magic used in heap headers. */
+#define HEAP_BLOCK_HEAD_MAGIC  UINT32_C(0xBEEF0101)
+/** Magic used in heap footers. */
+#define HEAP_BLOCK_FOOT_MAGIC  UINT32_C(0xBEEF0202)
+/** Magic used in heap descriptor. */
+#define HEAP_AREA_MAGIC  UINT32_C(0xBEEFCAFE)
+/** Allocation alignment.
+ *
+ * This also covers the alignment of fields
+ * in the heap header and footer.
+ *
+ */
 #define BASE_ALIGN  16
+/**
+ * Either 4 * 256M on 32-bit architecures or 16 * 256M on 64-bit architectures
+ */
+#define MAX_HEAP_SIZE  (sizeof(uintptr_t) << 28)
+/**
+ *
+ */
+#define STRUCT_OVERHEAD  (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t))
+/**
+ * Calculate real size of a heap block (with header and footer)
+/** Overhead of each heap block. */
+#define STRUCT_OVERHEAD \
+        (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t))
+/** Calculate real size of a heap block.
+ *
+ * Add header and footer size.
+ *
  */
 #define GROSS_SIZE(size)  ((size) + STRUCT_OVERHEAD)
+/**
+ * Calculate net size of a heap block (without header and footer)
+/** Calculate net size of a heap block.
+ *
+ * Subtract header and footer size.
+ *
  */
 #define NET_SIZE(size)  ((size) - STRUCT_OVERHEAD)
+/** Get first block in heap area.
+ *
+ */
+#define AREA_FIRST_BLOCK(area) \
+        (ALIGN_UP(((uintptr_t) (area)) + sizeof(heap_area_t), BASE_ALIGN))
+/** Get footer in heap block.
+ *
+ */
+#define BLOCK_FOOT(head) \
+        ((heap_block_foot_t *) \
+            (((uintptr_t) head) + head->size - sizeof(heap_block_foot_t)))
+/** Heap area.
+ *
+ * The memory managed by the heap allocator is divided into
+ * multiple discontinuous heaps. Each heap is represented
+ * by a separate address space area which has this structure
+ * at its very beginning.
+ *
+ */
+typedef struct heap_area {
+        /** Start of the heap area (including this structure)
+         *
+         * Aligned on page boundary.
+         *
+         */
+        void *start;
+        /** End of the heap area (aligned on page boundary) */
+        void *end;
+        /** Next heap area */
+        struct heap_area *next;
+        /** A magic value */
+        uint32_t magic;
+} heap_area_t;
 /** Header of a heap block
 …
         bool free;
+        /** Heap area this block belongs to */
+        heap_area_t *area;
         /* A magic value to detect overwrite of heap header */
         uint32_t magic;
 …
 } heap_block_foot_t;
+/** Linker heap symbol */
+extern char _heap;
+/** First heap area */
+static heap_area_t *first_heap_area = NULL;
+/** Last heap area */
+static heap_area_t *last_heap_area = NULL;
+/** Next heap block to examine (next fit algorithm) */
+static heap_block_head_t *next = NULL;
 /** Futex for thread-safe heap manipulation */
 static futex_t malloc_futex = FUTEX_INITIALIZER;
-/** Address of heap start */
-static void *heap_start = 0;
-/** Address of heap end */
-static void *heap_end = 0;
-/** Maximum heap size */
-static size_t max_heap_size = (size_t) -1;
-/** Current number of pages of heap area */
-static size_t heap_pages = 0;
 /** Initialize a heap block
+ *
  * Fills in the structures related to a heap block.
+ * Fill in the structures related to a heap block.
  * Should be called only inside the critical section.
+ *
 …
  * @param size Size of the block including the header and the footer.
  * @param free Indication of a free block.
+ *
+ */
+static void block_init(void *addr, size_t size, bool free)
+ * @param area Heap area the block belongs to.
+ *
+ */
+static void block_init(void *addr, size_t size, bool free, heap_area_t *area)
+{
         /* Calculate the position of the header and the footer */
         heap_block_head_t *head = (heap_block_head_t *) addr;
-        heap_block_foot_t *foot =
-            (heap_block_foot_t *) (addr + size - sizeof(heap_block_foot_t));
         head->size = size;
         head->free = free;
+        head->area = area;
         head->magic = HEAP_BLOCK_HEAD_MAGIC;
+        heap_block_foot_t *foot = BLOCK_FOOT(head);
         foot->size = size;
 …
         assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
+        heap_block_foot_t *foot =
+            (heap_block_foot_t *) (addr + head->size - sizeof(heap_block_foot_t));
+        heap_block_foot_t *foot = BLOCK_FOOT(head);
         assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
 …
+}
+/** Increase the heap area size
+ *
+ * Should be called only inside the critical section.
+ *
+ * @param size Number of bytes to grow the heap by.
+ *
+ */
+static bool grow_heap(size_t size)
+/** Check a heap area structure
+ *
+ * @param addr Address of the heap area.
+ *
+ */
+static void area_check(void *addr)
+{
+        heap_area_t *area = (heap_area_t *) addr;
+        assert(area->magic == HEAP_AREA_MAGIC);
+        assert(area->start < area->end);
+        assert(((uintptr_t) area->start % PAGE_SIZE) == 0);
+        assert(((uintptr_t) area->end % PAGE_SIZE) == 0);
+}
+/** Create new heap area
+ *
+ * @param start Preffered starting address of the new area.
+ * @param size  Size of the area.
+ *
+ */
+static bool area_create(size_t size)
+{
+        void *start = as_get_mappable_page(size);
+        if (start == NULL)
+                return false;
+        /* Align the heap area on page boundary */
+        void *astart = (void *) ALIGN_UP((uintptr_t) start, PAGE_SIZE);
+        size_t asize = ALIGN_UP(size, PAGE_SIZE);
+        astart = as_area_create(astart, asize, AS_AREA_WRITE | AS_AREA_READ);
+        if (astart == (void *) -1)
+                return false;
+        heap_area_t *area = (heap_area_t *) astart;
+        area->start = astart;
+        area->end = (void *)
+            ALIGN_DOWN((uintptr_t) astart + asize, BASE_ALIGN);
+        area->next = NULL;
+        area->magic = HEAP_AREA_MAGIC;
+        void *block = (void *) AREA_FIRST_BLOCK(area);
+        size_t bsize = (size_t) (area->end - block);
+        block_init(block, bsize, true, area);
+        if (last_heap_area == NULL) {
+                first_heap_area = area;
+                last_heap_area = area;
+        } else {
+                last_heap_area->next = area;
+                last_heap_area = area;
+        }
+        return true;
+}
+/** Try to enlarge a heap area
+ *
+ * @param area Heap area to grow.
+ * @param size Gross size of item to allocate (bytes).
+ *
+ */
+static bool area_grow(heap_area_t *area, size_t size)
+{
         if (size == 0)
+                return true;
+        area_check(area);
+        size_t asize = ALIGN_UP((size_t) (area->end - area->start) + size,
+            PAGE_SIZE);
+        /* New heap area size */
+        void *end = (void *)
+            ALIGN_DOWN((uintptr_t) area->start + asize, BASE_ALIGN);
+        /* Check for overflow */
+        if (end < area->start)
                 return false;
+        if ((heap_start + size < heap_start) || (heap_end + size < heap_end))
+        /* Resize the address space area */
+        int ret = as_area_resize(area->start, asize, 0);
+        if (ret != EOK)
                 return false;
+        size_t heap_size = (size_t) (heap_end - heap_start);
+        if ((max_heap_size != (size_t) -1) && (heap_size + size > max_heap_size))
+                return false;
+        size_t pages = (size - 1) / PAGE_SIZE + 1;
+        if (as_area_resize((void *) &_heap, (heap_pages + pages) * PAGE_SIZE, 0)
+            == EOK) {
+                void *end = (void *) ALIGN_DOWN(((uintptr_t) &_heap) +
+                    (heap_pages + pages) * PAGE_SIZE, BASE_ALIGN);
+                block_init(heap_end, end - heap_end, true);
+                heap_pages += pages;
+                heap_end = end;
+        /* Add new free block */
+        block_init(area->end, (size_t) (end - area->end), true, area);
+        /* Update heap area parameters */
+        area->end = end;
+        return true;
+}
+/** Try to enlarge any of the heap areas
+ *
+ * @param size Gross size of item to allocate (bytes).
+ *
+ */
+static bool heap_grow(size_t size)
+{
+        if (size == 0)
                 return true;
+        }
+        return false;
+}
+/** Decrease the heap area
+ *
+ * Should be called only inside the critical section.
+ *
+ * @param size Number of bytes to shrink the heap by.
+ *
+ */
+static void shrink_heap(void)
+{
+        // TODO
+        /* First try to enlarge some existing area */
+        heap_area_t *area;
+        for (area = first_heap_area; area != NULL; area = area->next) {
+                if (area_grow(area, size))
+                        return true;
+        }
+        /* Eventually try to create a new area */
+        return area_create(AREA_FIRST_BLOCK(size));
+}
+/** Try to shrink heap space
+ *
+ * In all cases the next pointer is reset.
+ *
+ */
+static void heap_shrink(void)
+{
+        next = NULL;
+}
 /** 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);
+}
+/** Get maximum heap address
+ *
+ */
+uintptr_t get_max_heap_addr(void)
+{
+        futex_down(&malloc_futex);
+        if (max_heap_size == (size_t) -1)
+                max_heap_size =
+                    max((size_t) (heap_end - heap_start), MAX_HEAP_SIZE);
+        uintptr_t max_heap_addr = (uintptr_t) heap_start + max_heap_size;
+        futex_up(&malloc_futex);
+        return max_heap_addr;
+ * 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 (!area_create(PAGE_SIZE))
+                abort();
+}
 …
                 /* Block big enough -> split. */
                 void *next = ((void *) cur) + size;
                 block_init(next, cur->size - size, true);
                 block_init(cur, size, false);
+                block_init(next, cur->size - size, true, cur->area);
+                block_init(cur, size, false, cur->area);
         } else {
                 /* Block too small -> use as is. */
 …
+}
 /** Allocate a memory block
+/** Allocate memory from heap area starting from given block
+ *
  * Should be called only inside the critical section.
+ *
  * @param size  The size of the block to allocate.
  * @param align Memory address alignment.
+ *
  * @return the address of the block or NULL when not enough memory.
+ *
  */
+static void *malloc_internal(const size_t size, const size_t align)
+{
+        if (align == 0)
+                return NULL;
+        size_t falign = lcm(align, BASE_ALIGN);
+        size_t real_size = GROSS_SIZE(ALIGN_UP(size, falign));
+        bool grown = false;
         void *result;
+loop:
         result = NULL;
         heap_block_head_t *cur = (heap_block_head_t *) heap_start;
         while ((result == NULL) && ((void *) cur < heap_end)) {
+ * As a side effect this function also sets the current
+ * pointer on successful allocation.
+ *
+ * @param area        Heap area where to allocate from.
+ * @param first_block Starting heap block.
+ * @param final_block Heap block where to finish the search
+ *                    (may be NULL).
+ * @param real_size   Gross number of bytes to allocate.
+ * @param falign      Physical alignment of the block.
+ *
+ * @return Address of the allocated block or NULL on not enough memory.
+ *
+ */
+static void *malloc_area(heap_area_t *area, heap_block_head_t *first_block,
+    heap_block_head_t *final_block, size_t real_size, size_t falign)
+{
+        area_check((void *) area);
+        assert((void *) first_block >= (void *) AREA_FIRST_BLOCK(area));
+        assert((void *) first_block < area->end);
+        heap_block_head_t *cur;
+        for (cur = first_block; (void *) cur < area->end;
+            cur = (heap_block_head_t *) (((void *) cur) + cur->size)) {
                 block_check(cur);
+                /* Finish searching on the final block */
+                if ((final_block != NULL) && (cur == final_block))
+                        break;
                 /* Try to find a block that is free and large enough. */
                 if ((cur->free) && (cur->size >= real_size)) {
+                        /* We have found a suitable block.
+                           Check for alignment properties. */
+                        void *addr = ((void *) cur) + sizeof(heap_block_head_t);
+                        void *aligned = (void *) ALIGN_UP(addr, falign);
+                        /*
+                         * We have found a suitable block.
+                         * Check for alignment properties.
+                         */
+                        void *addr = (void *)
+                            ((uintptr_t) cur + sizeof(heap_block_head_t));
+                        void *aligned = (void *)
+                            ALIGN_UP((uintptr_t) addr, falign);
                         if (addr == aligned) {
                                 /* Exact block start including alignment. */
                                 split_mark(cur, real_size);
+                                result = addr;
+                                next = cur;
+                                return addr;
                         } else {
                                 /* Block start has to be aligned */
 …
                                 if (cur->size >= real_size + excess) {
+                                        /* The current block is large enough to fit
+                                           data in including alignment */
+                                        if ((void *) cur > heap_start) {
+                                                /* There is a block before the current block.
+                                                   This previous block can be enlarged to compensate
+                                                   for the alignment excess */
+                                                heap_block_foot_t *prev_foot =
+                                                    ((void *) cur) - sizeof(heap_block_foot_t);
+                                        /*
+                                         * The current block is large enough to fit
+                                         * data in (including alignment).
+                                         */
+                                        if ((void *) cur > (void *) AREA_FIRST_BLOCK(area)) {
+                                                /*
+                                                 * There is a block before the current block.
+                                                 * This previous block can be enlarged to
+                                                 * compensate for the alignment excess.
+                                                 */
+                                                heap_block_foot_t *prev_foot = (heap_block_foot_t *)
+                                                    ((void *) cur - sizeof(heap_block_foot_t));
                                                 heap_block_head_t *prev_head =
                                                     (heap_block_head_t *) (((void *) cur) - prev_foot->size);
+                                                heap_block_head_t *prev_head = (heap_block_head_t *)
+                                                    ((void *) cur - prev_foot->size);
                                                 block_check(prev_head);
 …
                                                 heap_block_head_t *next_head = ((void *) cur) + excess;
+                                                if ((!prev_head->free) && (excess >= STRUCT_OVERHEAD)) {
+                                                        /* The previous block is not free and there is enough
+                                                           space to fill in a new free block between the previous
+                                                           and current block */
+                                                        block_init(cur, excess, true);
+                                                if ((!prev_head->free) &&
+                                                    (excess >= STRUCT_OVERHEAD)) {
+                                                        /*
+                                                         * The previous block is not free and there
+                                                         * is enough free space left to fill in
+                                                         * a new free block between the previous
+                                                         * and current block.
+                                                         */
+                                                        block_init(cur, excess, true, area);
                                                 } else {
+                                                        /* The previous block is free (thus there is no need to
+                                                           induce additional fragmentation to the heap) or the
+                                                           excess is small, thus just enlarge the previous block */
+                                                        block_init(prev_head, prev_head->size + excess, prev_head->free);
+                                                        /*
+                                                         * The previous block is free (thus there
+                                                         * is no need to induce additional
+                                                         * fragmentation to the heap) or the
+                                                         * excess is small. Therefore just enlarge
+                                                         * the previous block.
+                                                         */
+                                                        block_init(prev_head, prev_head->size + excess,
+                                                            prev_head->free, area);
+                                                }
                                                 block_init(next_head, reduced_size, true);
+                                                block_init(next_head, reduced_size, true, area);
                                                 split_mark(next_head, real_size);
+                                                result = aligned;
+                                                cur = next_head;
+                                                next = next_head;
+                                                return aligned;
                                         } else {
+                                                /* The current block is the first block on the heap.
+                                                   We have to make sure that the alignment excess
+                                                   is large enough to fit a new free block just
+                                                   before the current block */
+                                                /*
+                                                 * The current block is the first block
+                                                 * in the heap area. We have to make sure
+                                                 * that the alignment excess is large enough
+                                                 * to fit a new free block just before the
+                                                 * current block.
+                                                 */
                                                 while (excess < STRUCT_OVERHEAD) {
                                                         aligned += falign;
 …
                                                 if (cur->size >= real_size + excess) {
                                                         size_t reduced_size = cur->size - excess;
+                                                        cur = (heap_block_head_t *) (heap_start + excess);
+                                                        cur = (heap_block_head_t *)
+                                                            (AREA_FIRST_BLOCK(area) + excess);
+                                                        block_init(heap_start, excess, true);
+                                                        block_init(cur, reduced_size, true);
+                                                        block_init((void *) AREA_FIRST_BLOCK(area), excess,
+                                                            true, area);
+                                                        block_init(cur, reduced_size, true, area);
                                                         split_mark(cur, real_size);
+                                                        result = aligned;
+                                                        next = cur;
+                                                        return aligned;
+                                                }
+                                        }
 …
+                        }
+                }
+                /* Advance to the next block. */
+                cur = (heap_block_head_t *) (((void *) cur) + cur->size);
+        }
+        if ((result == NULL) && (!grown)) {
+                if (grow_heap(real_size)) {
+                        grown = true;
+        }
+        return NULL;
+}
+/** Allocate a memory block
+ *
+ * Should be called only inside the critical section.
+ *
+ * @param size  The size of the block to allocate.
+ * @param align Memory address alignment.
+ *
+ * @return Address of the allocated block or NULL on not enough memory.
+ *
+ */
+static void *malloc_internal(const size_t size, const size_t align)
+{
+        assert(first_heap_area != NULL);
+        if (align == 0)
+                return NULL;
+        size_t falign = lcm(align, BASE_ALIGN);
+        size_t real_size = GROSS_SIZE(ALIGN_UP(size, falign));
+        bool retry = false;
+        heap_block_head_t *split;
+loop:
+        /* Try the next fit approach */
+        split = next;
+        if (split != NULL) {
+                void *addr = malloc_area(split->area, split, NULL, real_size,
+                    falign);
+                if (addr != NULL)
+                        return addr;
+        }
+        /* Search the entire heap */
+        heap_area_t *area;
+        for (area = first_heap_area; area != NULL; area = area->next) {
+                heap_block_head_t *first = (heap_block_head_t *)
+                    AREA_FIRST_BLOCK(area);
+                void *addr = malloc_area(area, first, split, real_size,
+                    falign);
+                if (addr != NULL)
+                        return addr;
+        }
+        if (!retry) {
+                /* Try to grow the heap space */
+                if (heap_grow(real_size)) {
+                        retry = true;
                         goto loop;
+                }
+        }
         return result;
+        return NULL;
+}
 …
             (heap_block_head_t *) (addr - sizeof(heap_block_head_t));
-        assert((void *) head >= heap_start);
-        assert((void *) head < heap_end);
         block_check(head);
         assert(!head->free);
+        heap_area_t *area = head->area;
+        area_check(area);
+        assert((void *) head >= (void *) AREA_FIRST_BLOCK(area));
+        assert((void *) head < area->end);
         void *ptr = NULL;
 …
                 /* Shrink */
                 if (orig_size - real_size >= STRUCT_OVERHEAD) {
+                        /* Split the original block to a full block
+                           and a trailing free block */
+                        block_init((void *) head, real_size, false);
+                        /*
+                         * Split the original block to a full block
+                         * and a trailing free block.
+                         */
+                        block_init((void *) head, real_size, false, area);
                         block_init((void *) head + real_size,
                             orig_size - real_size, true);
                         shrink_heap();
+                            orig_size - real_size, true, area);
+                        heap_shrink();
+                }
                 ptr = ((void *) head) + sizeof(heap_block_head_t);
         } else {
+                /* Look at the next block. If it is free and the size is
+                   sufficient then merge the two. Otherwise just allocate
+                   a new block, copy the original data into it and
+                   free the original block. */
+                /*
+                 * Look at the next block. If it is free and the size is
+                 * sufficient then merge the two. Otherwise just allocate
+                 * a new block, copy the original data into it and
+                 * free the original block.
+                 */
                 heap_block_head_t *next_head =
                     (heap_block_head_t *) (((void *) head) + head->size);
                 if (((void *) next_head < heap_end) &&
+                if (((void *) next_head < area->end) &&
                     (head->size + next_head->size >= real_size) &&
                     (next_head->free)) {
                         block_check(next_head);
                         block_init(head, head->size + next_head->size, false);
+                        block_init(head, head->size + next_head->size, false, area);
                         split_mark(head, real_size);
                         ptr = ((void *) head) + sizeof(heap_block_head_t);
+                        next = NULL;
                 } else
                         reloc = true;
 …
             = (heap_block_head_t *) (addr - sizeof(heap_block_head_t));
-        assert((void *) head >= heap_start);
-        assert((void *) head < heap_end);
         block_check(head);
         assert(!head->free);
+        heap_area_t *area = head->area;
+        area_check(area);
+        assert((void *) head >= (void *) AREA_FIRST_BLOCK(area));
+        assert((void *) head < area->end);
         /* Mark the block itself as free. */
 …
             = (heap_block_head_t *) (((void *) head) + head->size);
         if ((void *) next_head < heap_end) {
+        if ((void *) next_head < area->end) {
                 block_check(next_head);
                 if (next_head->free)
                         block_init(head, head->size + next_head->size, true);
+                        block_init(head, head->size + next_head->size, true, area);
+        }
         /* Look at the previous block. If it is free, merge the two. */
         if ((void *) head > heap_start) {
+        if ((void *) head > (void *) AREA_FIRST_BLOCK(area)) {
                 heap_block_foot_t *prev_foot =
                     (heap_block_foot_t *) (((void *) head) - sizeof(heap_block_foot_t));
 …
                 if (prev_head->free)
+                        block_init(prev_head, prev_head->size + head->size, true);
+        }
+        shrink_heap();
+                        block_init(prev_head, prev_head->size + head->size, true,
+                            area);
+        }
+        heap_shrink();
         futex_up(&malloc_futex);

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

-              r89acf204
+              r474afc9
 #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/modules.c

-              r89acf204
+              r474afc9
 #include <errno.h>
 #include <sys/time.h>
-#include <ipc/ipc.h>
 #include <ipc/services.h>
 #include <net/modules.h>
 …
                 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 taskhash;
+                sysarg_t phonehash;
+                rc = ipc_connect_to_me(phone, arg1, arg2, arg3, &taskhash,
+                    &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(taskhash, phonehash, 0, NULL,
-                    client_receiver);
+        }

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

-              r89acf204
+              r474afc9
 #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

-              r89acf204
+              r474afc9
  */
 #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

-              r89acf204
+              r474afc9
 /*
  * 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/thread.c

-              r89acf204
+              r474afc9
  */
 /** @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

-              r89acf204
+              r474afc9
 #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

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

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

-              r89acf204
+              r474afc9
 /*
  * 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 <fibril_synch.h>
 …
 static void vfs_connect(void)
+{
+        while (vfs_phone < 0) {
+                vfs_phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_VFS,
+, 0);
+        }
+        while (vfs_phone < 0)
+                vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0);
         async_session_create(&vfs_session, vfs_phone, 0);

Context Navigation

Changeset 474afc9 in mainline for uspace/lib/c/generic

Legend:

uspace/lib/c/generic/as.c

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/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/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: