Changeset a33f0a6 for uspace/lib/c/generic – HelenOS

uspace/lib/c/generic/adt/hash_table.c

-              r52a79081
+              ra33f0a6
+ *
  */
 int hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
+bool hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     hash_table_operations_t *op)
+{
 …
         assert(max_keys > 0);
         h->entry = malloc(m * sizeof(link_t));
+        h->entry = malloc(m * sizeof(list_t));
         if (!h->entry)
                 return false;
         memset((void *) h->entry, 0,  m * sizeof(link_t));
+        memset((void *) h->entry, 0,  m * sizeof(list_t));
         hash_count_t i;
 …
         assert(chain < h->entries);
+        link_t *cur;
+        for (cur = h->entry[chain].next; cur != &h->entry[chain];
+            cur = cur->next) {
+        list_foreach(h->entry[chain], cur) {
                 if (h->op->compare(key, h->max_keys, cur)) {
                         /*
 …
         assert(keys <= h->max_keys);
-        link_t *cur;
         if (keys == h->max_keys) {
+                link_t *cur;
                 /*
                  * All keys are known, hash_table_find() can be used to find the
 …
         hash_index_t chain;
         for (chain = 0; chain < h->entries; chain++) {
+                for (cur = h->entry[chain].next; cur != &h->entry[chain];
+                link_t *cur;
+                for (cur = h->entry[chain].head.next; cur != &h->entry[chain].head;
                     cur = cur->next) {
                         if (h->op->compare(key, keys, cur)) {
 …
+{
         hash_index_t bucket;
-        link_t *cur;
         for (bucket = 0; bucket < h->entries; bucket++) {
+                for (cur = h->entry[bucket].next; cur != &h->entry[bucket];
+                    cur = cur->next) {
+                list_foreach(h->entry[bucket], cur) {
                         f(cur, arg);
+                }

uspace/lib/c/generic/adt/list.c

-              r52a79081
+              ra33f0a6
  * @{
  */
+/** @file
+/**
+ * @file
+ * @brief       Functions completing doubly linked circular list implementaion.
+ *
+ * This file contains some of the functions implementing doubly linked circular lists.
+ * However, this ADT is mostly implemented in @ref list.h.
  */
 #include <adt/list.h>
+#include <bool.h>
 /** Check for membership
+ *
  * Check whether link is contained in the list head.
  * The membership is defined as pointer equivalence.
+ * Check whether link is contained in a list.
+ * Membership is defined as pointer equivalence.
+ *
  * @param link Item to look for.
  * @param head List to look in.
+ * @param link  Item to look for.
+ * @param list  List to look in.
+ *
  * @return true if link is contained in head, false otherwise.
+ *
  */
 int list_member(const link_t *link, const link_t *head)
+int list_member(const link_t *link, const list_t *list)
+{
         int found = 0;
         link_t *hlp = head->next;
+        bool found = false;
+        link_t *hlp = list->head.next;
         while (hlp != head) {
+        while (hlp != &list->head) {
                 if (hlp == link) {
                         found = 1;
+                        found = true;
                         break;
+                }
 …
+}
 /** Concatenate two lists
+ *
  * Concatenate lists head1 and head2, producing a single
  * list head1 containing items from both (in head1, head2
  * order) and empty list head2.
+ * Concatenate lists @a list1 and @a list2, producing a single
+ * list @a list1 containing items from both (in @a list1, @a list2
+ * order) and empty list @a list2.
+ *
  * @param head1 First list and concatenated output
  * @param head2 Second list and empty output.
+ * @param list1         First list and concatenated output
+ * @param list2         Second list and empty output.
+ *
  */
 void list_concat(link_t *head1, link_t *head2)
+void list_concat(list_t *list1, list_t *list2)
+{
         if (list_empty(head2))
+        if (list_empty(list2))
                 return;
         head2->next->prev = head1->prev;
         head2->prev->next = head1;
         head1->prev->next = head2->next;
         head1->prev = head2->prev;
         list_initialize(head2);
+        list2->head.next->prev = list1->head.prev;
+        list2->head.prev->next = &list1->head;
+        list1->head.prev->next = list2->head.next;
+        list1->head.prev = list2->head.prev;
+        list_initialize(list2);
+}
 /** Count list items
 …
  * Return the number of items in the list.
+ *
+ * @param link List to count.
+ *
+ * @return Number of items in the list.
+ *
+ * @param list          List to count.
+ * @return              Number of items in the list.
  */
 unsigned int list_count(const link_t *link)
+unsigned int list_count(const list_t *list)
+{
         unsigned int count = 0;
-        link_t *hlp = link->next;
         while (hlp != link) {
+        list_foreach(*list, link) {
                 count++;
-                hlp = hlp->next;
+        }

uspace/lib/c/generic/adt/measured_strings.c

-              r52a79081
+              ra33f0a6
  * size has to be negotiated in advance.
+ *
  * @param[in] phone     The other module phone.
+ * @param[in] exch      Exchange.
  * @param[out] strings  The returned measured strings array.
  * @param[out] data     The measured strings data. This memory block stores the
 …
  * @return              EOK on success.
  * @return              EINVAL if the strings or data parameter is NULL.
  * @return              EINVAL if the phone or count parameter is not positive.
+ * @return              EINVAL if the exch or count parameter is invalid.
  * @return              EINVAL if the sent array differs in size.
  * @return              ENOMEM if there is not enough memory left.
 …
  *                      async_data_read_start() function.
  */
+int
+measured_strings_return(int phone, measured_string_t **strings, uint8_t **data,
+    size_t count)
+int measured_strings_return(async_exch_t *exch, measured_string_t **strings,
+    uint8_t **data, size_t count)
+{
         size_t *lengths;
 …
         int rc;
         if ((phone < 0) || (!strings) || (!data) || (count <= 0))
+        if ((exch == NULL) || (!strings) || (!data) || (count <= 0))
                 return EINVAL;
 …
                 return ENOMEM;
         rc = async_data_read_start(phone, lengths,
+        rc = async_data_read_start(exch, lengths,
             sizeof(size_t) * (count + 1));
         if (rc != EOK) {
 …
                 (*strings)[index].length = lengths[index];
                 if (lengths[index] > 0) {
                         rc = async_data_read_start(phone, next, lengths[index]);
+                        rc = async_data_read_start(exch, next, lengths[index]);
                         if (rc != EOK) {
                                 free(lengths);
 …
  * size has to be negotiated in advance.
+ *
  * @param[in] phone     The other module phone.
+ * @param[in] exch      Exchange.
  * @param[in] strings   The measured strings array to be transferred.
  * @param[in] count     The measured strings array size.
  * @return              EOK on success.
  * @return              EINVAL if the strings parameter is NULL.
  * @return              EINVAL if the phone or count parameter is not positive.
+ * @return              EINVAL if the exch or count parameter is invalid.
  * @return              Other error codes as defined for the
  *                      async_data_write_start() function.
  */
+int
+measured_strings_send(int phone, const measured_string_t *strings,
+int measured_strings_send(async_exch_t *exch, const measured_string_t *strings,
     size_t count)
+{
 …
         int rc;
         if ((phone < 0) || (!strings) || (count <= 0))
+        if ((exch == NULL) || (!strings) || (count <= 0))
                 return EINVAL;
 …
                 return ENOMEM;
         rc = async_data_write_start(phone, lengths,
+        rc = async_data_write_start(exch, lengths,
             sizeof(size_t) * (count + 1));
         if (rc != EOK) {
 …
         for (index = 0; index < count; index++) {
                 if (strings[index].length > 0) {
                         rc = async_data_write_start(phone, strings[index].value,
+                        rc = async_data_write_start(exch, strings[index].value,
                             strings[index].length);
                         if (rc != EOK)
 …
 /** @}
  */

uspace/lib/c/generic/as.c

-              r52a79081
+              ra33f0a6
 #include <as.h>
 #include <libc.h>
+#include <errno.h>
 #include <unistd.h>
 #include <align.h>
 …
+ *
  */
 void *as_area_create(void *address, size_t size, int flags)
+void *as_area_create(void *address, size_t size, unsigned int flags)
+{
         return (void *) __SYSCALL3(SYS_AS_AREA_CREATE, (sysarg_t) address,
 …
+ *
  */
 int as_area_resize(void *address, size_t size, int flags)
+int as_area_resize(void *address, size_t size, unsigned int flags)
+{
         return __SYSCALL3(SYS_AS_AREA_RESIZE, (sysarg_t) address,
 …
+ *
  */
 int as_area_change_flags(void *address, int flags)
+int as_area_change_flags(void *address, unsigned int flags)
+{
         return __SYSCALL2(SYS_AS_AREA_CHANGE_FLAGS, (sysarg_t) address,
 …
+}
+/** Find mapping to physical address.
+ *
+ * @param address Virtual address in question (virtual).
+ * @param[out] frame Frame address (physical).
+ * @return Error code.
+ * @retval EOK No error, @p frame holds the translation.
+ * @retval ENOENT Mapping not found.
+ */
+int as_get_physical_mapping(void *address, uintptr_t *frame)
+{
+        uintptr_t tmp_frame;
+        uintptr_t virt = (uintptr_t) address;
+        int rc = (int) __SYSCALL2(SYS_PAGE_FIND_MAPPING,
+            (sysarg_t) virt, (sysarg_t) &tmp_frame);
+        if (rc != EOK) {
+                return rc;
+        }
+        if (frame != NULL) {
+                *frame = tmp_frame;
+        }
+        return EOK;
+}
 /** @}
  */

uspace/lib/c/generic/assert.c

-              r52a79081
+              ra33f0a6
 #include <assert.h>
 #include <stdio.h>
+#include <io/klog.h>
 #include <stdlib.h>
+#include <atomic.h>
 #include <stacktrace.h>
+#include <stdint.h>
+static atomic_t failed_asserts = {0};
 void assert_abort(const char *cond, const char *file, unsigned int line)
+{
+        /*
+         * Send the message safely to klog. Nested asserts should not occur.
+         */
+        klog_printf("Assertion failed (%s) in file \"%s\", line %u.\n",
+            cond, file, line);
+        /*
+         * Check if this is a nested or parallel assert.
+         */
+        if (atomic_postinc(&failed_asserts))
+                abort();
+        /*
+         * Attempt to print the message to standard output and display
+         * the stack trace. These operations can theoretically trigger nested
+         * assertions.
+         */
         printf("Assertion failed (%s) in file \"%s\", line %u.\n",
             cond, file, line);
         stacktrace_print();
         abort();
+}

uspace/lib/c/generic/async.c

-              r52a79081
+              ra33f0a6
  * programming.
+ *
+ * You should be able to write very simple multithreaded programs, the async
+ * framework will automatically take care of most synchronization problems.
+ * You should be able to write very simple multithreaded programs. The async
+ * framework will automatically take care of most of the synchronization
+ * problems.
+ *
  * Example of use (pseudo C):
 …
  *   int fibril1(void *arg)
  *   {
+ *     conn = async_connect_me_to();
+ *     c1 = async_send(conn);
+ *     c2 = async_send(conn);
+ *     conn = async_connect_me_to(...);
+ *
+ *     exch = async_exchange_begin(conn);
+ *     c1 = async_send(exch);
+ *     async_exchange_end(exch);
+ *
+ *     exch = async_exchange_begin(conn);
+ *     c2 = async_send(exch);
+ *     async_exchange_end(exch);
+ *
  *     async_wait_for(c1);
  *     async_wait_for(c2);
 …
 #include <futex.h>
 #include <fibril.h>
-#include <stdio.h>
 #include <adt/hash_table.h>
 #include <adt/list.h>
 …
 #include <arch/barrier.h>
 #include <bool.h>
+#include <malloc.h>
+#include <mem.h>
 #include <stdlib.h>
-#include <malloc.h>
 #include "private/async.h"
+#define CLIENT_HASH_TABLE_BUCKETS  32
+#define CONN_HASH_TABLE_BUCKETS    32
+/** Async framework global futex */
 atomic_t async_futex = FUTEX_INITIALIZER;
 …
 atomic_t threads_in_ipc_wait = { 0 };
+typedef struct {
+        awaiter_t wdata;
+        /** If reply was received. */
+        bool done;
+        /** Pointer to where the answer data is stored. */
+        ipc_call_t *dataptr;
+        sysarg_t retval;
+} amsg_t;
+/**
+ * Structures of this type are used to group information about
+ * a call and about a message queue link.
+ */
+/** Naming service session */
+async_sess_t *session_ns;
+/** Call data */
 typedef struct {
         link_t link;
         ipc_callid_t callid;
         ipc_call_t call;
 } msg_t;
+/* Client connection data */
 typedef struct {
+        link_t link;
         sysarg_t in_task_hash;
+        link_t link;
+        int refcnt;
+        atomic_t refcnt;
         void *data;
 } client_t;
+/* Server connection data */
 typedef struct {
         awaiter_t wdata;
 …
         /** Incoming client task hash. */
         sysarg_t in_task_hash;
         /** Incoming phone hash. */
         sysarg_t in_phone_hash;
 …
         /** Messages that should be delivered to this fibril. */
         link_t msg_queue;
+        list_t msg_queue;
         /** Identification of the opening call. */
 …
         /** Call data of the opening call. */
         ipc_call_t call;
+        /** Local argument or NULL if none. */
+        void *carg;
         /** Identification of the closing call. */
 …
         /** Fibril function that will be used to handle the connection. */
         void (*cfibril)(ipc_callid_t, ipc_call_t *);
+        async_client_conn_t cfibril;
 } connection_t;
 /** Identifier of the incoming connection handled by the current fibril. */
 static fibril_local connection_t *FIBRIL_connection;
+static fibril_local connection_t *fibril_connection;
 static void *default_client_data_constructor(void)
 …
+}
 void *async_client_data_get(void)
+{
         assert(FIBRIL_connection);
         return FIBRIL_connection->client->data;
+void *async_get_client_data(void)
+{
+        assert(fibril_connection);
+        return fibril_connection->client->data;
+}
 …
  * @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)
+ * @param arg    Local argument
+ *
+ */
+static void default_client_connection(ipc_callid_t callid, ipc_call_t *call,
+    void *arg)
+{
         ipc_answer_0(callid, ENOENT);
+}
-/**
- * Pointer to a fibril function that will be used to handle connections.
- */
-static async_client_conn_t client_connection = default_client_connection;
 /** Default fibril function that gets called to handle interrupt notifications.
 …
  * @param callid Hash of the incoming call.
  * @param call   Data of the incoming call.
+ * @param arg    Local argument.
+ *
  */
 …
+}
+/**
+ * Pointer to a fibril function that will be used to handle interrupt
+ * notifications.
+ */
+static async_client_conn_t interrupt_received = default_interrupt_received;
+static async_client_conn_t client_connection = default_client_connection;
+static async_interrupt_handler_t interrupt_received = default_interrupt_received;
+/** Setter for client_connection function pointer.
+ *
+ * @param conn Function that will implement a new connection fibril.
+ *
+ */
+void async_set_client_connection(async_client_conn_t conn)
+{
+        client_connection = conn;
+}
+/** Setter for interrupt_received function pointer.
+ *
+ * @param intr Function that will implement a new interrupt
+ *             notification fibril.
+ */
+void async_set_interrupt_received(async_interrupt_handler_t intr)
+{
+        interrupt_received = intr;
+}
+/** Mutex protecting inactive_exch_list and avail_phone_cv.
+ *
+ */
+static FIBRIL_MUTEX_INITIALIZE(async_sess_mutex);
+/** List of all currently inactive exchanges.
+ *
+ */
+static LIST_INITIALIZE(inactive_exch_list);
+/** Condition variable to wait for a phone to become available.
+ *
+ */
+static FIBRIL_CONDVAR_INITIALIZE(avail_phone_cv);
 static hash_table_t client_hash_table;
 …
 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[])
+{
         assert(key);
         return (((key[0]) >> 4) % CLIENT_HASH_TABLE_BUCKETS);
+}
 …
 static int client_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
+        assert(key);
+        assert(item);
         client_t *client = hash_table_get_instance(item, client_t, link);
         return (key[0] == client->in_task_hash);
 …
+{
         assert(key);
         return (((key[0]) >> 4) % CONN_HASH_TABLE_BUCKETS);
+}
 …
 static int conn_compare(unsigned long key[], hash_count_t keys, link_t *item)
+{
+        assert(key);
+        assert(item);
         connection_t *conn = hash_table_get_instance(item, connection_t, link);
         return (key[0] == conn->in_phone_hash);
 …
 void async_insert_timeout(awaiter_t *wd)
+{
+        assert(wd);
         wd->to_event.occurred = false;
         wd->to_event.inlist = true;
         link_t *tmp = timeout_list.next;
         while (tmp != &timeout_list) {
+        link_t *tmp = timeout_list.head.next;
+        while (tmp != &timeout_list.head) {
                 awaiter_t *cur
                     = list_get_instance(tmp, awaiter_t, to_event.link);
 …
+        }
         list_append(&wd->to_event.link, tmp);
+        list_insert_before(&wd->to_event.link, tmp);
+}
 …
 static bool route_call(ipc_callid_t callid, ipc_call_t *call)
+{
+        assert(call);
         futex_down(&async_futex);
 …
 static int notification_fibril(void *arg)
+{
+        assert(arg);
         msg_t *msg = (msg_t *) arg;
         interrupt_received(msg->callid, &msg->call);
 …
 static bool process_notification(ipc_callid_t callid, ipc_call_t *call)
+{
+        assert(call);
         futex_down(&async_futex);
 …
 ipc_callid_t async_get_call_timeout(ipc_call_t *call, suseconds_t usecs)
+{
+        assert(FIBRIL_connection);
+        assert(call);
+        assert(fibril_connection);
         /* Why doing this?
          * GCC 4.1.0 coughs on FIBRIL_connection-> dereference.
+         * GCC 4.1.0 coughs on fibril_connection-> dereference.
          * GCC 4.1.1 happilly puts the rdhwr instruction in delay slot.
          *           I would never expect to find so many errors in
          *           a compiler.
          */
         connection_t *conn = FIBRIL_connection;
+        connection_t *conn = fibril_connection;
         futex_down(&async_futex);
 …
+        }
         msg_t *msg = list_get_instance(conn->msg_queue.next, msg_t, link);
+        msg_t *msg = list_get_instance(list_first(&conn->msg_queue), msg_t, link);
         list_remove(&msg->link);
 …
 static int connection_fibril(void *arg)
+{
+        assert(arg);
         /*
          * Setup fibril-local connection pointer.
          */
         FIBRIL_connection = (connection_t *) arg;
+        fibril_connection = (connection_t *) arg;
         futex_down(&async_futex);
 …
          */
         unsigned long key = FIBRIL_connection->in_task_hash;
+        unsigned long key = fibril_connection->in_task_hash;
         link_t *lnk = hash_table_find(&client_hash_table, &key);
 …
         if (lnk) {
                 client = hash_table_get_instance(lnk, client_t, link);
                 client->refcnt++;
+                atomic_inc(&client->refcnt);
         } else {
                 client = malloc(sizeof(client_t));
                 if (!client) {
                         ipc_answer_0(FIBRIL_connection->callid, ENOMEM);
+                        ipc_answer_0(fibril_connection->callid, ENOMEM);
                         futex_up(&async_futex);
                         return 0;
+                }
+                client->in_task_hash = FIBRIL_connection->in_task_hash;
+                async_serialize_start();
+                client->in_task_hash = fibril_connection->in_task_hash;
                 client->data = async_client_data_create();
+                async_serialize_end();
+                client->refcnt = 1;
+                atomic_set(&client->refcnt, 1);
                 hash_table_insert(&client_hash_table, &key, &client->link);
+        }
 …
         futex_up(&async_futex);
         FIBRIL_connection->client = client;
+        fibril_connection->client = client;
         /*
          * Call the connection handler function.
          */
         FIBRIL_connection->cfibril(FIBRIL_connection->callid,
             &FIBRIL_connection->call);
+        fibril_connection->cfibril(fibril_connection->callid,
+            &fibril_connection->call, fibril_connection->carg);
         /*
 …
         futex_down(&async_futex);
         if (--client->refcnt == 0) {
+        if (atomic_predec(&client->refcnt) == 0) {
                 hash_table_remove(&client_hash_table, &key, 1);
                 destroy = true;
 …
          */
         futex_down(&async_futex);
         key = FIBRIL_connection->in_phone_hash;
+        key = fibril_connection->in_phone_hash;
         hash_table_remove(&conn_hash_table, &key, 1);
         futex_up(&async_futex);
 …
          * Answer all remaining messages with EHANGUP.
          */
         while (!list_empty(&FIBRIL_connection->msg_queue)) {
+        while (!list_empty(&fibril_connection->msg_queue)) {
                 msg_t *msg =
                     list_get_instance(FIBRIL_connection->msg_queue.next, msg_t,
                     link);
+                    list_get_instance(list_first(&fibril_connection->msg_queue),
+                    msg_t, link);
                 list_remove(&msg->link);
 …
          * i.e. IPC_M_PHONE_HUNGUP.
          */
         if (FIBRIL_connection->close_callid)
                 ipc_answer_0(FIBRIL_connection->close_callid, EOK);
         free(FIBRIL_connection);
+        if (fibril_connection->close_callid)
+                ipc_answer_0(fibril_connection->close_callid, EOK);
+        free(fibril_connection);
         return 0;
+}
 …
 /** Create a new fibril for a new connection.
+ *
  * Create new fibril for connection, fill in connection structures and inserts
+ * Create new fibril for connection, fill in connection structures and insert
  * it into the hash table, so that later we can easily do routing of messages to
  * particular fibrils.
 …
  * @param cfibril       Fibril function that should be called upon opening the
  *                      connection.
+ * @param carg          Extra argument to pass to the connection fibril
+ *
  * @return New fibril id or NULL on failure.
 …
 fid_t async_new_connection(sysarg_t in_task_hash, sysarg_t in_phone_hash,
     ipc_callid_t callid, ipc_call_t *call,
     void (*cfibril)(ipc_callid_t, ipc_call_t *))
+    async_client_conn_t cfibril, void *carg)
+{
         connection_t *conn = malloc(sizeof(*conn));
 …
         conn->callid = callid;
         conn->close_callid = 0;
+        conn->carg = carg;
         if (call)
 …
 static void handle_call(ipc_callid_t callid, ipc_call_t *call)
+{
+        assert(call);
         /* Unrouted call - take some default action */
         if ((callid & IPC_CALLID_NOTIFICATION)) {
 …
                 /* Open new connection with fibril, etc. */
                 async_new_connection(call->in_task_hash, IPC_GET_ARG5(*call),
                     callid, call, client_connection);
+                    callid, call, client_connection, NULL);
                 return;
+        }
 …
         futex_down(&async_futex);
         link_t *cur = timeout_list.next;
         while (cur != &timeout_list) {
+        link_t *cur = list_first(&timeout_list);
+        while (cur != NULL) {
                 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);
 …
                         fibril_add_ready(waiter->fid);
+                }
+                cur = list_first(&timeout_list);
+        }
 …
                 suseconds_t timeout;
                 if (!list_empty(&timeout_list)) {
                         awaiter_t *waiter = list_get_instance(timeout_list.next,
                             awaiter_t, to_event.link);
+                        awaiter_t *waiter = list_get_instance(
+                            list_first(&timeout_list), awaiter_t, to_event.link);
                         struct timeval tv;
 …
 void __async_init(void)
+{
         if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS, 1,
             &client_hash_table_ops))
+        if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS,
+, &client_hash_table_ops))
                 abort();
         if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS, 1,
             &conn_hash_table_ops))
+        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS,
+, &conn_hash_table_ops))
                 abort();
+        session_ns = (async_sess_t *) malloc(sizeof(async_sess_t));
+        if (session_ns == NULL)
+                abort();
+        session_ns->mgmt = EXCHANGE_ATOMIC;
+        session_ns->phone = PHONE_NS;
+        session_ns->arg1 = 0;
+        session_ns->arg2 = 0;
+        session_ns->arg3 = 0;
+        list_initialize(&session_ns->exch_list);
+        fibril_mutex_initialize(&session_ns->mutex);
+        atomic_set(&session_ns->refcnt, 0);
+}
 …
+ *
  */
+static void reply_received(void *arg, int retval, ipc_call_t *data)
+{
+void reply_received(void *arg, int retval, ipc_call_t *data)
+{
+        assert(arg);
         futex_down(&async_futex);
 …
  * completion.
+ *
  * @param phoneid Handle of the phone that will be used for the send.
  * @param method  Service-defined method.
+ * @param exch    Exchange for sending the message.
+ * @param imethod Service-defined interface and method.
  * @param arg1    Service-defined payload argument.
  * @param arg2    Service-defined payload argument.
 …
+ *
  */
 aid_t async_send_fast(int phoneid, sysarg_t method, sysarg_t arg1,
+aid_t async_send_fast(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr)
+{
+        if (exch == NULL)
+                return 0;
         amsg_t *msg = malloc(sizeof(amsg_t));
+        if (!msg)
+        if (msg == NULL)
                 return 0;
 …
         msg->wdata.active = true;
         ipc_call_async_4(phoneid, method, arg1, arg2, arg3, arg4, msg,
+        ipc_call_async_4(exch->phone, imethod, arg1, arg2, arg3, arg4, msg,
             reply_received, true);
 …
  * completion.
+ *
  * @param phoneid Handle of the phone that will be used for the send.
  * @param method  Service-defined method.
+ * @param exch    Exchange for sending the message.
+ * @param imethod Service-defined interface and method.
  * @param arg1    Service-defined payload argument.
  * @param arg2    Service-defined payload argument.
 …
+ *
  */
 aid_t async_send_slow(int phoneid, sysarg_t method, sysarg_t arg1,
+aid_t async_send_slow(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
     ipc_call_t *dataptr)
+{
+        if (exch == NULL)
+                return 0;
         amsg_t *msg = malloc(sizeof(amsg_t));
         if (!msg)
+        if (msg == NULL)
                 return 0;
 …
         msg->wdata.active = true;
         ipc_call_async_5(phoneid, method, arg1, arg2, arg3, arg4, arg5, msg,
             reply_received, true);
+        ipc_call_async_5(exch->phone, imethod, arg1, arg2, arg3, arg4, arg5,
+            msg, reply_received, true);
         return (aid_t) msg;
 …
 void async_wait_for(aid_t amsgid, sysarg_t *retval)
+{
+        assert(amsgid);
         amsg_t *msg = (amsg_t *) amsgid;
 …
 int async_wait_timeout(aid_t amsgid, sysarg_t *retval, suseconds_t timeout)
+{
+        assert(amsgid);
         amsg_t *msg = (amsg_t *) amsgid;
 …
+}
-/** Setter for client_connection function pointer.
+ *
- * @param conn Function that will implement a new connection fibril.
+ *
- */
-void async_set_client_connection(async_client_conn_t conn)
+{
-        client_connection = conn;
+}
-/** Setter for interrupt_received function pointer.
+ *
- * @param intr Function that will implement a new interrupt
- *             notification fibril.
- */
-void async_set_interrupt_received(async_client_conn_t intr)
+{
-        interrupt_received = intr;
+}
 /** Pseudo-synchronous message sending - fast version.
+ *
 …
  * transferring more arguments, see the slower async_req_slow().
+ *
  * @param phoneid Hash of the phone through which to make the call.
  * @param method  Method of the call.
+ * @param exch    Exchange for sending the message.
+ * @param imethod Interface and method of the call.
  * @param arg1    Service-defined payload argument.
  * @param arg2    Service-defined payload argument.
 …
+ *
  */
 sysarg_t async_req_fast(int phoneid, sysarg_t method, sysarg_t arg1,
+sysarg_t async_req_fast(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t *r1, sysarg_t *r2,
     sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
+{
+        if (exch == NULL)
+                return ENOENT;
         ipc_call_t result;
         aid_t eid = async_send_4(phoneid, method, arg1, arg2, arg3, arg4,
+        aid_t aid = async_send_4(exch, imethod, arg1, arg2, arg3, arg4,
             &result);
         sysarg_t rc;
         async_wait_for(eid, &rc);
+        async_wait_for(aid, &rc);
         if (r1)
 …
  * Send message asynchronously and return only after the reply arrives.
+ *
  * @param phoneid Hash of the phone through which to make the call.
  * @param method  Method of the call.
+ * @param exch    Exchange for sending the message.
+ * @param imethod Interface and method of the call.
  * @param arg1    Service-defined payload argument.
  * @param arg2    Service-defined payload argument.
 …
+ *
  */
 sysarg_t async_req_slow(int phoneid, sysarg_t method, sysarg_t arg1,
+sysarg_t async_req_slow(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
     sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5, sysarg_t *r1,
     sysarg_t *r2, sysarg_t *r3, sysarg_t *r4, sysarg_t *r5)
+{
+        if (exch == NULL)
+                return ENOENT;
         ipc_call_t result;
         aid_t eid = async_send_5(phoneid, method, arg1, arg2, arg3, arg4, arg5,
+        aid_t aid = async_send_5(exch, imethod, arg1, arg2, arg3, arg4, arg5,
             &result);
         sysarg_t rc;
         async_wait_for(eid, &rc);
+        async_wait_for(aid, &rc);
         if (r1)
 …
+}
+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);
+void async_msg_0(async_exch_t *exch, sysarg_t imethod)
+{
+        if (exch != NULL)
+                ipc_call_async_0(exch->phone, imethod, NULL, NULL, true);
+}
+void async_msg_1(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1)
+{
+        if (exch != NULL)
+                ipc_call_async_1(exch->phone, imethod, arg1, NULL, NULL, true);
+}
+void async_msg_2(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2)
+{
+        if (exch != NULL)
+                ipc_call_async_2(exch->phone, imethod, arg1, arg2, NULL, NULL,
+                    true);
+}
+void async_msg_3(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3)
+{
+        if (exch != NULL)
+                ipc_call_async_3(exch->phone, imethod, arg1, arg2, arg3, NULL,
+                    NULL, true);
+}
+void async_msg_4(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4)
+{
+        if (exch != NULL)
+                ipc_call_async_4(exch->phone, imethod, arg1, arg2, arg3, arg4,
+                    NULL, NULL, true);
+}
+void async_msg_5(async_exch_t *exch, sysarg_t imethod, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5)
+{
+        if (exch != NULL)
+                ipc_call_async_5(exch->phone, imethod, arg1, arg2, arg3, arg4,
+                    arg5, NULL, NULL, true);
+}
 …
+}
+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);
+int async_forward_fast(ipc_callid_t callid, async_exch_t *exch,
+    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, unsigned int mode)
+{
+        if (exch == NULL)
+                return ENOENT;
+        return ipc_forward_fast(callid, exch->phone, imethod, arg1, arg2, mode);
+}
+int async_forward_slow(ipc_callid_t callid, async_exch_t *exch,
+    sysarg_t imethod, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
+    sysarg_t arg4, sysarg_t arg5, unsigned int mode)
+{
+        if (exch == NULL)
+                return ENOENT;
+        return ipc_forward_slow(callid, exch->phone, imethod, arg1, arg2, arg3,
+            arg4, arg5, mode);
+}
 …
  * Ask through phone for a new connection to some service.
+ *
  * @param phone           Phone handle used for contacting the other side.
+ * @param exch            Exchange for sending the message.
  * @param arg1            User defined argument.
  * @param arg2            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)
+{
+ * @return Zero on success or a negative error code.
+ *
+ */
+int async_connect_to_me(async_exch_t *exch, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3, async_client_conn_t client_receiver, void *carg)
+{
+        if (exch == NULL)
+                return ENOENT;
         sysarg_t task_hash;
         sysarg_t phone_hash;
         int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
+        int rc = async_req_3_5(exch, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
             NULL, NULL, NULL, &task_hash, &phone_hash);
         if (rc != EOK)
 …
         if (client_receiver != NULL)
                 async_new_connection(task_hash, phone_hash, 0, NULL,
                     client_receiver);
+                    client_receiver, carg);
         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 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;
+        int rc = async_req_3_5(phone, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
+            NULL, NULL, NULL, NULL, &newphid);
+/** Wrapper for making IPC_M_CONNECT_ME calls using the async framework.
+ *
+ * Ask through for a cloned connection to some service.
+ *
+ * @param mgmt Exchange management style.
+ * @param exch Exchange for sending the message.
+ *
+ * @return New session on success or NULL on error.
+ *
+ */
+async_sess_t *async_connect_me(exch_mgmt_t mgmt, async_exch_t *exch)
+{
+        if (exch == NULL) {
+                errno = ENOENT;
+                return NULL;
+        }
+        async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
+        if (sess == NULL) {
+                errno = ENOMEM;
+                return NULL;
+        }
+        ipc_call_t result;
+        amsg_t *msg = malloc(sizeof(amsg_t));
+        if (msg == NULL) {
+                free(sess);
+                errno = ENOMEM;
+                return NULL;
+        }
+        msg->done = false;
+        msg->dataptr = &result;
+        msg->wdata.to_event.inlist = false;
+        /*
+         * We may sleep in the next method,
+         * but it will use its own means
+         */
+        msg->wdata.active = true;
+        ipc_call_async_0(exch->phone, IPC_M_CONNECT_ME, msg,
+            reply_received, true);
+        sysarg_t rc;
+        async_wait_for((aid_t) msg, &rc);
+        if (rc != EOK) {
+                errno = rc;
+                free(sess);
+                return NULL;
+        }
+        int phone = (int) IPC_GET_ARG5(result);
+        if (phone < 0) {
+                errno = phone;
+                free(sess);
+                return NULL;
+        }
+        sess->mgmt = mgmt;
+        sess->phone = phone;
+        sess->arg1 = 0;
+        sess->arg2 = 0;
+        sess->arg3 = 0;
+        list_initialize(&sess->exch_list);
+        fibril_mutex_initialize(&sess->mutex);
+        atomic_set(&sess->refcnt, 0);
+        return sess;
+}
+static int async_connect_me_to_internal(int phone, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3, sysarg_t arg4)
+{
+        ipc_call_t result;
+        amsg_t *msg = malloc(sizeof(amsg_t));
+        if (msg == NULL)
+                return ENOENT;
+        msg->done = false;
+        msg->dataptr = &result;
+        msg->wdata.to_event.inlist = false;
+        /*
+         * We may sleep in the next method,
+         * but it will use its own means
+         */
+        msg->wdata.active = true;
+        ipc_call_async_4(phone, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3, arg4,
+            msg, reply_received, true);
+        sysarg_t rc;
+        async_wait_for((aid_t) msg, &rc);
         if (rc != EOK)
                 return rc;
+        return newphid;
+        return (int) IPC_GET_ARG5(result);
+}
+/** Wrapper for making IPC_M_CONNECT_ME_TO calls using the async framework.
+ *
+ * Ask through for a new connection to some service.
+ *
+ * @param mgmt Exchange management style.
+ * @param exch Exchange for sending the message.
+ * @param arg1 User defined argument.
+ * @param arg2 User defined argument.
+ * @param arg3 User defined argument.
+ *
+ * @return New session on success or NULL on error.
+ *
+ */
+async_sess_t *async_connect_me_to(exch_mgmt_t mgmt, async_exch_t *exch,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
+{
+        if (exch == NULL) {
+                errno = ENOENT;
+                return NULL;
+        }
+        async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
+        if (sess == NULL) {
+                errno = ENOMEM;
+                return NULL;
+        }
+        int phone = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
+);
+        if (phone < 0) {
+                errno = phone;
+                free(sess);
+                return NULL;
+        }
+        sess->mgmt = mgmt;
+        sess->phone = phone;
+        sess->arg1 = arg1;
+        sess->arg2 = arg2;
+        sess->arg3 = arg3;
+        list_initialize(&sess->exch_list);
+        fibril_mutex_initialize(&sess->mutex);
+        atomic_set(&sess->refcnt, 0);
+        return sess;
+}
 …
  * 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,
+    sysarg_t arg3)
+{
+        sysarg_t newphid;
+        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)
+                return rc;
+        return newphid;
+ * @param mgmt Exchange management style.
+ * @param exch Exchange for sending the message.
+ * @param arg1 User defined argument.
+ * @param arg2 User defined argument.
+ * @param arg3 User defined argument.
+ *
+ * @return New session on success or NULL on error.
+ *
+ */
+async_sess_t *async_connect_me_to_blocking(exch_mgmt_t mgmt, async_exch_t *exch,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
+{
+        if (exch == NULL) {
+                errno = ENOENT;
+                return NULL;
+        }
+        async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
+        if (sess == NULL) {
+                errno = ENOMEM;
+                return NULL;
+        }
+        int phone = async_connect_me_to_internal(exch->phone, arg1, arg2, arg3,
+            IPC_FLAG_BLOCKING);
+        if (phone < 0) {
+                errno = phone;
+                free(sess);
+                return NULL;
+        }
+        sess->mgmt = mgmt;
+        sess->phone = phone;
+        sess->arg1 = arg1;
+        sess->arg2 = arg2;
+        sess->arg3 = arg3;
+        list_initialize(&sess->exch_list);
+        fibril_mutex_initialize(&sess->mutex);
+        atomic_set(&sess->refcnt, 0);
+        return sess;
+}
 …
+ *
  */
+int async_connect_kbox(task_id_t id)
+{
+        return ipc_connect_kbox(id);
+async_sess_t *async_connect_kbox(task_id_t id)
+{
+        async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
+        if (sess == NULL) {
+                errno = ENOMEM;
+                return NULL;
+        }
+        int phone = ipc_connect_kbox(id);
+        if (phone < 0) {
+                errno = phone;
+                free(sess);
+                return NULL;
+        }
+        sess->mgmt = EXCHANGE_ATOMIC;
+        sess->phone = phone;
+        sess->arg1 = 0;
+        sess->arg2 = 0;
+        sess->arg3 = 0;
+        list_initialize(&sess->exch_list);
+        fibril_mutex_initialize(&sess->mutex);
+        atomic_set(&sess->refcnt, 0);
+        return sess;
+}
+static int async_hangup_internal(int phone)
+{
+        return ipc_hangup(phone);
+}
 /** Wrapper for ipc_hangup.
+ *
  * @param phone Phone handle to hung up.
+ * @param sess Session to hung up.
+ *
  * @return Zero on success or a negative error code.
+ *
  */
+int async_hangup(int phone)
+{
+        return ipc_hangup(phone);
+int async_hangup(async_sess_t *sess)
+{
+        assert(sess);
+        if (atomic_get(&sess->refcnt) > 0)
+                return EBUSY;
+        int rc = async_hangup_internal(sess->phone);
+        if (rc == EOK)
+                free(sess);
+        return rc;
+}
 …
+}
+/** Start new exchange in a session.
+ *
+ * @param session Session.
+ *
+ * @return New exchange or NULL on error.
+ *
+ */
+async_exch_t *async_exchange_begin(async_sess_t *sess)
+{
+        if (sess == NULL)
+                return NULL;
+        async_exch_t *exch;
+        fibril_mutex_lock(&async_sess_mutex);
+        if (!list_empty(&sess->exch_list)) {
+                /*
+                 * There are inactive exchanges in the session.
+                 */
+                exch = (async_exch_t *)
+                    list_get_instance(list_first(&sess->exch_list),
+                    async_exch_t, sess_link);
+                list_remove(&exch->sess_link);
+                list_remove(&exch->global_link);
+        } else {
+                /*
+                 * There are no available exchanges in the session.
+                 */
+                if ((sess->mgmt == EXCHANGE_ATOMIC) ||
+                    (sess->mgmt == EXCHANGE_SERIALIZE)) {
+                        exch = (async_exch_t *) malloc(sizeof(async_exch_t));
+                        if (exch != NULL) {
+                                link_initialize(&exch->sess_link);
+                                link_initialize(&exch->global_link);
+                                exch->sess = sess;
+                                exch->phone = sess->phone;
+                        }
+                } else {  /* EXCHANGE_PARALLEL */
+                        /*
+                         * Make a one-time attempt to connect a new data phone.
+                         */
+                        int phone;
+retry:
+                        phone = async_connect_me_to_internal(sess->phone, sess->arg1,
+                            sess->arg2, sess->arg3, 0);
+                        if (phone >= 0) {
+                                exch = (async_exch_t *) malloc(sizeof(async_exch_t));
+                                if (exch != NULL) {
+                                        link_initialize(&exch->sess_link);
+                                        link_initialize(&exch->global_link);
+                                        exch->sess = sess;
+                                        exch->phone = phone;
+                                } else
+                                        async_hangup_internal(phone);
+                        } else if (!list_empty(&inactive_exch_list)) {
+                                /*
+                                 * We did not manage to connect a new phone. But we
+                                 * can try to close some of the currently inactive
+                                 * connections in other sessions and try again.
+                                 */
+                                exch = (async_exch_t *)
+                                    list_get_instance(list_first(&inactive_exch_list),
+                                    async_exch_t, global_link);
+                                list_remove(&exch->sess_link);
+                                list_remove(&exch->global_link);
+                                async_hangup_internal(exch->phone);
+                                free(exch);
+                                goto retry;
+                        } else {
+                                /*
+                                 * Wait for a phone to become available.
+                                 */
+                                fibril_condvar_wait(&avail_phone_cv, &async_sess_mutex);
+                                goto retry;
+                        }
+                }
+        }
+        fibril_mutex_unlock(&async_sess_mutex);
+        if (exch != NULL) {
+                atomic_inc(&sess->refcnt);
+                if (sess->mgmt == EXCHANGE_SERIALIZE)
+                        fibril_mutex_lock(&sess->mutex);
+        }
+        return exch;
+}
+/** Finish an exchange.
+ *
+ * @param exch Exchange to finish.
+ *
+ */
+void async_exchange_end(async_exch_t *exch)
+{
+        if (exch == NULL)
+                return;
+        async_sess_t *sess = exch->sess;
+        atomic_dec(&sess->refcnt);
+        if (sess->mgmt == EXCHANGE_SERIALIZE)
+                fibril_mutex_unlock(&sess->mutex);
+        fibril_mutex_lock(&async_sess_mutex);
+        list_append(&exch->sess_link, &sess->exch_list);
+        list_append(&exch->global_link, &inactive_exch_list);
+        fibril_condvar_signal(&avail_phone_cv);
+        fibril_mutex_unlock(&async_sess_mutex);
+}
 /** 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.
+ * @param exch  Exchange for sending the message.
+ * @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,
+    unsigned int *flags)
+{
+int async_share_in_start(async_exch_t *exch, void *dst, size_t size,
+    sysarg_t arg, unsigned int *flags)
+{
+        if (exch == NULL)
+                return ENOENT;
         sysarg_t tmp_flags;
         int res = async_req_3_2(phoneid, IPC_M_SHARE_IN, (sysarg_t) dst,
+        int res = async_req_3_2(exch, IPC_M_SHARE_IN, (sysarg_t) dst,
             (sysarg_t) size, arg, NULL, &tmp_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.
+ * @param exch  Exchange for sending the message.
+ * @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,
+int async_share_out_start(async_exch_t *exch, void *src, unsigned int flags)
+{
+        if (exch == NULL)
+                return ENOENT;
+        return async_req_3_0(exch, IPC_M_SHARE_OUT, (sysarg_t) src, 0,
             (sysarg_t) flags);
+}
 …
+}
+/** Start IPC_M_DATA_READ using the async framework.
+ *
+ * @param exch    Exchange for sending the message.
+ * @param dst     Address of the beginning of the destination buffer.
+ * @param size    Size of the destination buffer (in bytes).
+ * @param dataptr Storage of call data (arg 2 holds actual data size).
+ *
+ * @return Hash of the sent message or 0 on error.
+ *
+ */
+aid_t async_data_read(async_exch_t *exch, void *dst, size_t size,
+    ipc_call_t *dataptr)
+{
+        return async_send_2(exch, IPC_M_DATA_READ, (sysarg_t) dst,
+            (sysarg_t) size, dataptr);
+}
 /** 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.
+ * @param flags   Flags to control the data transfer.
+ * @param exch Exchange for sending the message.
+ * @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_generic(int phoneid, void *dst, size_t size, int flags)
+{
+        return async_req_3_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
+            (sysarg_t) size, (sysarg_t) flags);
+int async_data_read_start(async_exch_t *exch, void *dst, size_t size)
+{
+        if (exch == NULL)
+                return ENOENT;
+        return async_req_2_0(exch, IPC_M_DATA_READ, (sysarg_t) dst,
+            (sysarg_t) size);
+}
 …
+ *
  */
+int async_data_read_forward_fast(int phoneid, sysarg_t method, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr)
+{
+int async_data_read_forward_fast(async_exch_t *exch, sysarg_t imethod,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4,
+    ipc_call_t *dataptr)
+{
+        if (exch == NULL)
+                return ENOENT;
         ipc_callid_t callid;
         if (!async_data_read_receive(&callid, NULL)) {
 …
+        }
         aid_t msg = async_send_fast(phoneid, method, arg1, arg2, arg3, arg4,
+        aid_t msg = async_send_fast(exch, imethod, arg1, arg2, arg3, arg4,
             dataptr);
         if (msg == 0) {
 …
+        }
         int retval = ipc_forward_fast(callid, phoneid, 0, 0, 0,
+        int retval = ipc_forward_fast(callid, exch->phone, 0, 0, 0,
             IPC_FF_ROUTE_FROM_ME);
         if (retval != EOK) {
 …
 /** Wrapper for IPC_M_DATA_WRITE calls using the async framework.
+ *
+ * @param phoneid Phone that will be used to contact the receiving side.
+ * @param src     Address of the beginning of the source buffer.
+ * @param size    Size of the source buffer.
+ * @param flags   Flags to control the data transfer.
+ * @param exch Exchange for sending the message.
+ * @param src  Address of the beginning of the source buffer.
+ * @param size Size of the source buffer.
+ *
  * @return Zero on success or a negative error code from errno.h.
+ *
  */
+int
+async_data_write_start_generic(int phoneid, const void *src, size_t size,
+    int flags)
+{
+        return async_req_3_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src,
+            (sysarg_t) size, (sysarg_t) flags);
+int async_data_write_start(async_exch_t *exch, const void *src, size_t size)
+{
+        if (exch == NULL)
+                return ENOENT;
+        return async_req_2_0(exch, IPC_M_DATA_WRITE, (sysarg_t) src,
+            (sysarg_t) size);
+}
 …
     size_t *received)
+{
+        assert(data);
         ipc_callid_t callid;
         size_t size;
 …
+ *
  */
+int async_data_write_forward_fast(int phoneid, sysarg_t method, sysarg_t arg1,
+    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, ipc_call_t *dataptr)
+{
+int async_data_write_forward_fast(async_exch_t *exch, sysarg_t imethod,
+    sysarg_t arg1, sysarg_t arg2, sysarg_t arg3, sysarg_t arg4,
+    ipc_call_t *dataptr)
+{
+        if (exch == NULL)
+                return ENOENT;
         ipc_callid_t callid;
         if (!async_data_write_receive(&callid, NULL)) {
 …
+        }
         aid_t msg = async_send_fast(phoneid, method, arg1, arg2, arg3, arg4,
+        aid_t msg = async_send_fast(exch, imethod, arg1, arg2, arg3, arg4,
             dataptr);
         if (msg == 0) {
 …
+        }
         int retval = ipc_forward_fast(callid, phoneid, 0, 0, 0,
+        int retval = ipc_forward_fast(callid, exch->phone, 0, 0, 0,
             IPC_FF_ROUTE_FROM_ME);
         if (retval != EOK) {
 …
+}
+/** Wrapper for sending an exchange over different exchange for cloning
+ *
+ * @param exch       Exchange to be used for sending.
+ * @param clone_exch Exchange to be cloned.
+ *
+ */
+int async_exchange_clone(async_exch_t *exch, async_exch_t *clone_exch)
+{
+        return async_req_1_0(exch, IPC_M_CONNECTION_CLONE, clone_exch->phone);
+}
+/** Wrapper for receiving the IPC_M_CONNECTION_CLONE calls.
+ *
+ * If the current call is IPC_M_CONNECTION_CLONE then a new
+ * async session is created for the accepted phone.
+ *
+ * @param mgmt Exchange management style.
+ *
+ * @return New async session or NULL on failure.
+ *
+ */
+async_sess_t *async_clone_receive(exch_mgmt_t mgmt)
+{
+        /* Accept the phone */
+        ipc_call_t call;
+        ipc_callid_t callid = async_get_call(&call);
+        int phone = (int) IPC_GET_ARG1(call);
+        if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECTION_CLONE) ||
+            (phone < 0)) {
+                async_answer_0(callid, EINVAL);
+                return NULL;
+        }
+        async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
+        if (sess == NULL) {
+                async_answer_0(callid, ENOMEM);
+                return NULL;
+        }
+        sess->mgmt = mgmt;
+        sess->phone = phone;
+        sess->arg1 = 0;
+        sess->arg2 = 0;
+        sess->arg3 = 0;
+        list_initialize(&sess->exch_list);
+        fibril_mutex_initialize(&sess->mutex);
+        atomic_set(&sess->refcnt, 0);
+        /* Acknowledge the cloned phone */
+        async_answer_0(callid, EOK);
+        return sess;
+}
+/** Wrapper for receiving the IPC_M_CONNECT_TO_ME calls.
+ *
+ * If the current call is IPC_M_CONNECT_TO_ME then a new
+ * async session is created for the accepted phone.
+ *
+ * @param mgmt Exchange management style.
+ *
+ * @return New async session.
+ * @return NULL on failure.
+ *
+ */
+async_sess_t *async_callback_receive(exch_mgmt_t mgmt)
+{
+        /* Accept the phone */
+        ipc_call_t call;
+        ipc_callid_t callid = async_get_call(&call);
+        int phone = (int) IPC_GET_ARG5(call);
+        if ((IPC_GET_IMETHOD(call) != IPC_M_CONNECT_TO_ME) ||
+            (phone < 0)) {
+                async_answer_0(callid, EINVAL);
+                return NULL;
+        }
+        async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
+        if (sess == NULL) {
+                async_answer_0(callid, ENOMEM);
+                return NULL;
+        }
+        sess->mgmt = mgmt;
+        sess->phone = phone;
+        sess->arg1 = 0;
+        sess->arg2 = 0;
+        sess->arg3 = 0;
+        list_initialize(&sess->exch_list);
+        fibril_mutex_initialize(&sess->mutex);
+        atomic_set(&sess->refcnt, 0);
+        /* Acknowledge the connected phone */
+        async_answer_0(callid, EOK);
+        return sess;
+}
+/** Wrapper for receiving the IPC_M_CONNECT_TO_ME calls.
+ *
+ * If the call is IPC_M_CONNECT_TO_ME then a new
+ * async session is created. However, the phone is
+ * not accepted automatically.
+ *
+ * @param mgmt   Exchange management style.
+ * @param call   Call data.
+ *
+ * @return New async session.
+ * @return NULL on failure.
+ * @return NULL if the call is not IPC_M_CONNECT_TO_ME.
+ *
+ */
+async_sess_t *async_callback_receive_start(exch_mgmt_t mgmt, ipc_call_t *call)
+{
+        int phone = (int) IPC_GET_ARG5(*call);
+        if ((IPC_GET_IMETHOD(*call) != IPC_M_CONNECT_TO_ME) ||
+            (phone < 0))
+                return NULL;
+        async_sess_t *sess = (async_sess_t *) malloc(sizeof(async_sess_t));
+        if (sess == NULL)
+                return NULL;
+        sess->mgmt = mgmt;
+        sess->phone = phone;
+        sess->arg1 = 0;
+        sess->arg2 = 0;
+        sess->arg3 = 0;
+        list_initialize(&sess->exch_list);
+        fibril_mutex_initialize(&sess->mutex);
+        atomic_set(&sess->refcnt, 0);
+        return sess;
+}
 /** @}
  */

uspace/lib/c/generic/clipboard.c

-              r52a79081
+              ra33f0a6
 #include <clipboard.h>
 #include <ipc/ns.h>
+#include <ns.h>
 #include <ipc/services.h>
 #include <ipc/clipboard.h>
+#include <fibril_synch.h>
 #include <async.h>
 #include <str.h>
 …
 #include <malloc.h>
+static int clip_phone = -1;
+/** Connect to clipboard server
+ *
+ */
+static void clip_connect(void)
+{
+        while (clip_phone < 0)
+                clip_phone = service_connect_blocking(SERVICE_CLIPBOARD, 0, 0);
+static FIBRIL_MUTEX_INITIALIZE(clip_mutex);
+static async_sess_t *clip_sess = NULL;
+/** Start an async exchange on the clipboard session.
+ *
+ * @return New exchange.
+ *
+ */
+static async_exch_t *clip_exchange_begin(void)
+{
+        fibril_mutex_lock(&clip_mutex);
+        while (clip_sess == NULL)
+                clip_sess = service_connect_blocking(EXCHANGE_SERIALIZE,
+                    SERVICE_CLIPBOARD, 0, 0);
+        fibril_mutex_unlock(&clip_mutex);
+        return async_exchange_begin(clip_sess);
+}
+/** Finish an async exchange on the clipboard session.
+ *
+ * @param exch Exchange to be finished.
+ *
+ */
+static void clip_exchange_end(async_exch_t *exch)
+{
+        async_exchange_end(exch);
+}
 …
         if (size == 0) {
+                async_serialize_start();
+                clip_connect();
+                sysarg_t rc = async_req_1_0(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_NONE);
+                async_serialize_end();
+                async_exch_t *exch = clip_exchange_begin();
+                sysarg_t rc = async_req_1_0(exch, CLIPBOARD_PUT_DATA,
+                    CLIPBOARD_TAG_NONE);
+                clip_exchange_end(exch);
                 return (int) rc;
         } else {
+                async_serialize_start();
+                clip_connect();
+                aid_t req = async_send_1(clip_phone, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA, NULL);
+                sysarg_t rc = async_data_write_start(clip_phone, (void *) str, size);
+                async_exch_t *exch = clip_exchange_begin();
+                aid_t req = async_send_1(exch, CLIPBOARD_PUT_DATA, CLIPBOARD_TAG_DATA,
+                    NULL);
+                sysarg_t rc = async_data_write_start(exch, (void *) str, size);
+                clip_exchange_end(exch);
                 if (rc != EOK) {
                         sysarg_t rc_orig;
                         async_wait_for(req, &rc_orig);
-                        async_serialize_end();
                         if (rc_orig == EOK)
                                 return (int) rc;
 …
                 async_wait_for(req, &rc);
-                async_serialize_end();
                 return (int) rc;
 …
         /* Loop until clipboard read succesful */
         while (true) {
+                async_serialize_start();
+                clip_connect();
+                async_exch_t *exch = clip_exchange_begin();
                 sysarg_t size;
                 sysarg_t tag;
                 sysarg_t rc = async_req_0_2(clip_phone, CLIPBOARD_CONTENT, &size, &tag);
                 async_serialize_end();
+                sysarg_t rc = async_req_0_2(exch, CLIPBOARD_CONTENT, &size, &tag);
+                clip_exchange_end(exch);
                 if (rc != EOK)
 …
                                 return ENOMEM;
+                        async_serialize_start();
+                        aid_t req = async_send_1(clip_phone, CLIPBOARD_GET_DATA, tag, NULL);
+                        rc = async_data_read_start(clip_phone, (void *) sbuf, size);
+                        exch = clip_exchange_begin();
+                        aid_t req = async_send_1(exch, CLIPBOARD_GET_DATA, tag, NULL);
+                        rc = async_data_read_start(exch, (void *) sbuf, size);
+                        clip_exchange_end(exch);
                         if ((int) rc == EOVERFLOW) {
                                 /*
 …
                                  * the last call of CLIPBOARD_CONTENT
                                  */
-                                async_serialize_end();
                                 break;
+                        }
 …
                                 sysarg_t rc_orig;
                                 async_wait_for(req, &rc_orig);
-                                async_serialize_end();
                                 if (rc_orig == EOK)
                                         return (int) rc;
 …
                         async_wait_for(req, &rc);
-                        async_serialize_end();
                         if (rc == EOK) {

uspace/lib/c/generic/device/char_dev.c

-              r52a79081
+              ra33f0a6
  * using its character interface.
+ *
  * @param dev_phone     Phone to the device.
  * @param buf           Buffer for the data read from or written to the device.
  * @param size          Maximum size of data (in bytes) to be read or written.
  * @param read          Read from the device if true, write to it otherwise.
+ * @param sess Session to the device.
+ * @param buf  Buffer for the data read from or written to the device.
+ * @param size Maximum size of data (in bytes) to be read or written.
+ * @param read Read from the device if true, write to it otherwise.
+ *
+ * @return              Non-negative number of bytes actually read from or
+ *                      written to the device on success, negative error number
+ *                      otherwise.
+ * @return Non-negative number of bytes actually read from or
+ *         written to the device on success, negative error number
+ *         otherwise.
+ *
  */
 static ssize_t char_dev_rw(int dev_phone, void *buf, size_t size, bool read)
+static ssize_t char_dev_rw(async_sess_t *sess, void *buf, size_t size, bool read)
+{
-        async_serialize_start();
         ipc_call_t answer;
         aid_t req;
         int ret;
+        async_exch_t *exch = async_exchange_begin(sess);
         if (read) {
                 req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE),
+                req = async_send_1(exch, DEV_IFACE_ID(CHAR_DEV_IFACE),
                     CHAR_DEV_READ, &answer);
                 ret = async_data_read_start(dev_phone, buf, size);
+                ret = async_data_read_start(exch, buf, size);
         } else {
                 req = async_send_1(dev_phone, DEV_IFACE_ID(CHAR_DEV_IFACE),
+                req = async_send_1(exch, DEV_IFACE_ID(CHAR_DEV_IFACE),
                     CHAR_DEV_WRITE, &answer);
                 ret = async_data_write_start(dev_phone, buf, size);
+                ret = async_data_write_start(exch, buf, size);
+        }
+        async_exchange_end(exch);
         sysarg_t rc;
         if (ret != EOK) {
                 async_wait_for(req, &rc);
-                async_serialize_end();
                 if (rc == EOK)
                         return (ssize_t) ret;
 …
         async_wait_for(req, &rc);
-        async_serialize_end();
         ret = (int) rc;
 …
 /** Read from character device.
+ *
  * @param dev_phone     Phone to the device.
  * @param buf           Output buffer for the data read from the device.
  * @param size          Maximum size (in bytes) of the data to be read.
+ * @param sess Session to the device.
+ * @param buf  Output buffer for the data read from the device.
+ * @param size Maximum size (in bytes) of the data to be read.
+ *
+ * @return              Non-negative number of bytes actually read from the
+ *                      device on success, negative error number otherwise.
+ * @return Non-negative number of bytes actually read from the
+ *         device on success, negative error number otherwise.
+ *
  */
 ssize_t char_dev_read(int dev_phone, void *buf, size_t size)
+ssize_t char_dev_read(async_sess_t *sess, void *buf, size_t size)
+{
         return char_dev_rw(dev_phone, buf, size, true);
+        return char_dev_rw(sess, buf, size, true);
+}
 /** Write to character device.
+ *
  * @param dev_phone     Phone to the device.
  * @param buf           Input buffer containg the data to be written to the
  *                      device.
  * @param size          Maximum size (in bytes) of the data to be written.
+ * @param sess Session to the device.
+ * @param buf  Input buffer containg the data to be written to the
+ *             device.
+ * @param size Maximum size (in bytes) of the data to be written.
+ *
+ * @return              Non-negative number of bytes actually written to the
+ *                      device on success, negative error number otherwise.
+ * @return Non-negative number of bytes actually written to the
+ *         device on success, negative error number otherwise.
+ *
  */
 ssize_t char_dev_write(int dev_phone, void *buf, size_t size)
+ssize_t char_dev_write(async_sess_t *sess, void *buf, size_t size)
+{
         return char_dev_rw(dev_phone, buf, size, false);
+        return char_dev_rw(sess, buf, size, false);
+}

uspace/lib/c/generic/device/hw_res.c

-              r52a79081
+              ra33f0a6
 #include <malloc.h>
+int hw_res_get_resource_list(int dev_phone, hw_resource_list_t *hw_resources)
+int hw_res_get_resource_list(async_sess_t *sess,
+    hw_resource_list_t *hw_resources)
+{
         sysarg_t count = 0;
+        int rc = async_req_1_1(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE),
+        async_exch_t *exch = async_exchange_begin(sess);
+        int rc = async_req_1_1(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
             HW_RES_GET_RESOURCE_LIST, &count);
         hw_resources->count = count;
         if (rc != EOK)
+        if (rc != EOK) {
+                async_exchange_end(exch);
                 return rc;
+        }
         size_t size = count * sizeof(hw_resource_t);
+        hw_resources->resources = (hw_resource_t *)malloc(size);
+        if (!hw_resources->resources)
+        hw_resource_t *resources = (hw_resource_t *) malloc(size);
+        if (resources == NULL) {
+                // FIXME: This is protocol violation
+                async_exchange_end(exch);
                 return ENOMEM;
+        }
+        rc = async_data_read_start(dev_phone, hw_resources->resources, size);
+        rc = async_data_read_start(exch, resources, size);
+        async_exchange_end(exch);
         if (rc != EOK) {
+                free(hw_resources->resources);
+                hw_resources->resources = NULL;
+                free(resources);
                 return rc;
+        }
+        hw_resources->resources = resources;
+        hw_resources->count = count;
         return EOK;
+}
 bool hw_res_enable_interrupt(int dev_phone)
+bool hw_res_enable_interrupt(async_sess_t *sess)
+{
+        int rc = async_req_1_0(dev_phone, DEV_IFACE_ID(HW_RES_DEV_IFACE),
+        async_exch_t *exch = async_exchange_begin(sess);
+        int rc = async_req_1_0(exch, DEV_IFACE_ID(HW_RES_DEV_IFACE),
             HW_RES_ENABLE_INTERRUPT);
+        return rc == EOK;
+        async_exchange_end(exch);
+        return (rc == EOK);
+}

uspace/lib/c/generic/devman.c

-              r52a79081
+              ra33f0a6
  */
+#include <adt/list.h>
 #include <str.h>
-#include <stdio.h>
 #include <ipc/services.h>
+#include <ns.h>
 #include <ipc/devman.h>
 #include <devman.h>
+#include <fibril_synch.h>
 #include <async.h>
-#include <fibril_synch.h>
 #include <errno.h>
 #include <malloc.h>
 #include <bool.h>
+#include <adt/list.h>
+static int devman_phone_driver = -1;
+static int devman_phone_client = -1;
+static FIBRIL_MUTEX_INITIALIZE(devman_phone_mutex);
+int devman_get_phone(devman_interface_t iface, unsigned int flags)
+static FIBRIL_MUTEX_INITIALIZE(devman_driver_block_mutex);
+static FIBRIL_MUTEX_INITIALIZE(devman_client_block_mutex);
+static FIBRIL_MUTEX_INITIALIZE(devman_driver_mutex);
+static FIBRIL_MUTEX_INITIALIZE(devman_client_mutex);
+static async_sess_t *devman_driver_block_sess = NULL;
+static async_sess_t *devman_client_block_sess = NULL;
+static async_sess_t *devman_driver_sess = NULL;
+static async_sess_t *devman_client_sess = NULL;
+static void clone_session(fibril_mutex_t *mtx, async_sess_t *src,
+    async_sess_t **dst)
+{
+        fibril_mutex_lock(mtx);
+        if ((*dst == NULL) && (src != NULL))
+                *dst = src;
+        fibril_mutex_unlock(mtx);
+}
+/** Start an async exchange on the devman session (blocking).
+ *
+ * @param iface Device manager interface to choose
+ *
+ * @return New exchange.
+ *
+ */
+async_exch_t *devman_exchange_begin_blocking(devman_interface_t iface)
+{
         switch (iface) {
         case DEVMAN_DRIVER:
+                fibril_mutex_lock(&devman_phone_mutex);
+                if (devman_phone_driver >= 0) {
+                        fibril_mutex_unlock(&devman_phone_mutex);
+                        return devman_phone_driver;
+                fibril_mutex_lock(&devman_driver_block_mutex);
+                while (devman_driver_block_sess == NULL) {
+                        clone_session(&devman_driver_mutex, devman_driver_sess,
+                            &devman_driver_block_sess);
+                        if (devman_driver_block_sess == NULL)
+                                devman_driver_block_sess =
+                                    service_connect_blocking(EXCHANGE_SERIALIZE,
+                                    SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
+                }
+                if (flags & IPC_FLAG_BLOCKING)
+                        devman_phone_driver = async_connect_me_to_blocking(
+                            PHONE_NS, SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
+                else
+                        devman_phone_driver = async_connect_me_to(PHONE_NS,
+                            SERVICE_DEVMAN, DEVMAN_DRIVER, 0);
+                fibril_mutex_unlock(&devman_phone_mutex);
+                return devman_phone_driver;
+                fibril_mutex_unlock(&devman_driver_block_mutex);
+                clone_session(&devman_driver_mutex, devman_driver_block_sess,
+                    &devman_driver_sess);
+                return async_exchange_begin(devman_driver_block_sess);
         case DEVMAN_CLIENT:
+                fibril_mutex_lock(&devman_phone_mutex);
+                if (devman_phone_client >= 0) {
+                        fibril_mutex_unlock(&devman_phone_mutex);
+                        return devman_phone_client;
+                fibril_mutex_lock(&devman_client_block_mutex);
+                while (devman_client_block_sess == NULL) {
+                        clone_session(&devman_client_mutex, devman_client_sess,
+                            &devman_client_block_sess);
+                        if (devman_client_block_sess == NULL)
+                                devman_client_block_sess =
+                                    service_connect_blocking(EXCHANGE_SERIALIZE,
+                                    SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
+                }
+                if (flags & IPC_FLAG_BLOCKING) {
+                        devman_phone_client = async_connect_me_to_blocking(
+                            PHONE_NS, SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
+                } else {
+                        devman_phone_client = async_connect_me_to(PHONE_NS,
+                            SERVICE_DEVMAN, DEVMAN_CLIENT, 0);
+                }
+                fibril_mutex_unlock(&devman_phone_mutex);
+                return devman_phone_client;
+                fibril_mutex_unlock(&devman_client_block_mutex);
+                clone_session(&devman_client_mutex, devman_client_block_sess,
+                    &devman_client_sess);
+                return async_exchange_begin(devman_client_block_sess);
         default:
+                return -1;
+        }
+                return NULL;
+        }
+}
+/** Start an async exchange on the devman session.
+ *
+ * @param iface Device manager interface to choose
+ *
+ * @return New exchange.
+ *
+ */
+async_exch_t *devman_exchange_begin(devman_interface_t iface)
+{
+        switch (iface) {
+        case DEVMAN_DRIVER:
+                fibril_mutex_lock(&devman_driver_mutex);
+                if (devman_driver_sess == NULL)
+                        devman_driver_sess =
+                            service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAN,
+                            DEVMAN_DRIVER, 0);
+                fibril_mutex_unlock(&devman_driver_mutex);
+                if (devman_driver_sess == NULL)
+                        return NULL;
+                return async_exchange_begin(devman_driver_sess);
+        case DEVMAN_CLIENT:
+                fibril_mutex_lock(&devman_client_mutex);
+                if (devman_client_sess == NULL)
+                        devman_client_sess =
+                            service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAN,
+                            DEVMAN_CLIENT, 0);
+                fibril_mutex_unlock(&devman_client_mutex);
+                if (devman_client_sess == NULL)
+                        return NULL;
+                return async_exchange_begin(devman_client_sess);
+        default:
+                return NULL;
+        }
+}
+/** Finish an async exchange on the devman session.
+ *
+ * @param exch Exchange to be finished.
+ *
+ */
+void devman_exchange_end(async_exch_t *exch)
+{
+        async_exchange_end(exch);
+}
 …
 int devman_driver_register(const char *name, async_client_conn_t conn)
+{
+        int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
+        if (phone < 0)
+                return phone;
+        async_serialize_start();
+        ipc_call_t answer;
+        aid_t req = async_send_2(phone, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
+        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return -1;
+        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
+        ipc_call_t answer;
+        aid_t req = async_send_2(exch, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
+        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
+        devman_exchange_end(exch);
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                return retval;
+        }
         async_set_client_connection(conn);
+        async_connect_to_me(phone, 0, 0, 0, NULL);
+        exch = devman_exchange_begin(DEVMAN_DRIVER);
+        async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
+        devman_exchange_end(exch);
         async_wait_for(req, &retval);
-        async_serialize_end();
         return retval;
+}
-static int devman_send_match_id(int phone, match_id_t *match_id)
+{
-        ipc_call_t answer;
-        aid_t req = async_send_1(phone, DEVMAN_ADD_MATCH_ID, match_id->score,
-            &answer);
-        int retval = async_data_write_start(phone, match_id->id,
-            str_size(match_id->id));
-        async_wait_for(req, NULL);
-        return retval;
+}
-static int devman_send_match_ids(int phone, match_id_list_t *match_ids)
+{
-        link_t *link = match_ids->ids.next;
-        match_id_t *match_id = NULL;
-        int ret = EOK;
-        while (link != &match_ids->ids) {
-                match_id = list_get_instance(link, match_id_t, link);
-                ret = devman_send_match_id(phone, match_id);
-                if (ret != EOK) {
-                        return ret;
+                }
-                link = link->next;
+        }
-        return ret;
+}
 …
  * this driver task.
+ *
+ * @param name          Name of the new function
+ * @param ftype         Function type, fun_inner or fun_exposed
+ * @param match_ids     Match IDs (should be empty for fun_exposed)
+ * @param devh          Devman handle of the device
+ * @param funh          Place to store handle of the new function
+ *
+ * @return              EOK on success or negative error code.
+ * @param name      Name of the new function
+ * @param ftype     Function type, fun_inner or fun_exposed
+ * @param match_ids Match IDs (should be empty for fun_exposed)
+ * @param devh      Devman handle of the device
+ * @param funh      Place to store handle of the new function
+ *
+ * @return EOK on success or negative error code.
+ *
  */
 int devman_add_function(const char *name, fun_type_t ftype,
     match_id_list_t *match_ids, devman_handle_t devh, devman_handle_t *funh)
+{
-        int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
-        int fun_handle;
-        if (phone < 0)
-                return phone;
-        async_serialize_start();
         int match_count = list_count(&match_ids->ids);
+        ipc_call_t answer;
+        aid_t req = async_send_3(phone, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
+        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
+        ipc_call_t answer;
+        aid_t req = async_send_3(exch, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
             devh, match_count, &answer);
+        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return retval;
+        }
+        int match_ids_rc = devman_send_match_ids(phone, match_ids);
+        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
+        if (retval != EOK) {
+                devman_exchange_end(exch);
+                async_wait_for(req, NULL);
+                return retval;
+        }
+        match_id_t *match_id = NULL;
+        list_foreach(match_ids->ids, link) {
+                match_id = list_get_instance(link, match_id_t, link);
+                ipc_call_t answer2;
+                aid_t req2 = async_send_1(exch, DEVMAN_ADD_MATCH_ID,
+                    match_id->score, &answer2);
+                retval = async_data_write_start(exch, match_id->id,
+                    str_size(match_id->id));
+                if (retval != EOK) {
+                        devman_exchange_end(exch);
+                        async_wait_for(req2, NULL);
+                        async_wait_for(req, NULL);
+                        return retval;
+                }
+                async_wait_for(req2, &retval);
+                if (retval != EOK) {
+                        devman_exchange_end(exch);
+                        async_wait_for(req, NULL);
+                        return retval;
+                }
+        }
+        devman_exchange_end(exch);
         async_wait_for(req, &retval);
+        async_serialize_end();
+        /* Prefer the answer to DEVMAN_ADD_FUNCTION in case of errors. */
+        if ((match_ids_rc != EOK) && (retval == EOK)) {
+                retval = match_ids_rc;
+        }
+        if (retval == EOK)
+                fun_handle = (int) IPC_GET_ARG1(answer);
+        else
+                fun_handle = -1;
+        *funh = fun_handle;
+        if (retval == EOK) {
+                if (funh != NULL)
+                        *funh = (int) IPC_GET_ARG1(answer);
+        } else {
+                if (funh != NULL)
+                        *funh = -1;
+        }
         return retval;
+}
 …
     const char *class_name)
+{
+        int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
+        if (phone < 0)
+                return phone;
+        async_serialize_start();
+        ipc_call_t answer;
+        aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS,
+        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, DEVMAN_ADD_DEVICE_TO_CLASS,
             devman_handle, &answer);
+        sysarg_t retval = async_data_write_start(phone, class_name,
+        sysarg_t retval = async_data_write_start(exch, class_name,
             str_size(class_name));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+        devman_exchange_end(exch);
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
                 return retval;
+        }
         async_wait_for(req, &retval);
-        async_serialize_end();
         return retval;
+}
+void devman_hangup_phone(devman_interface_t iface)
+{
+        switch (iface) {
+        case DEVMAN_DRIVER:
+                if (devman_phone_driver >= 0) {
+                        async_hangup(devman_phone_driver);
+                        devman_phone_driver = -1;
+                }
+                break;
+        case DEVMAN_CLIENT:
+                if (devman_phone_client >= 0) {
+                        async_hangup(devman_phone_client);
+                        devman_phone_client = -1;
+                }
+                break;
+        default:
+                break;
+        }
+}
+int devman_device_connect(devman_handle_t handle, unsigned int flags)
+{
+        int phone;
+        if (flags & IPC_FLAG_BLOCKING) {
+                phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN,
+                    DEVMAN_CONNECT_TO_DEVICE, handle);
+        } else {
+                phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAN,
+                    DEVMAN_CONNECT_TO_DEVICE, handle);
+        }
+        return phone;
+}
+int devman_parent_device_connect(devman_handle_t handle, unsigned int flags)
+{
+        int phone;
+        if (flags & IPC_FLAG_BLOCKING) {
+                phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAN,
+                    DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
+        } else {
+                phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAN,
+                    DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
+        }
+        return phone;
+async_sess_t *devman_device_connect(exch_mgmt_t mgmt, devman_handle_t handle,
+    unsigned int flags)
+{
+        async_sess_t *sess;
+        if (flags & IPC_FLAG_BLOCKING)
+                sess = service_connect_blocking(mgmt, SERVICE_DEVMAN,
+                            DEVMAN_CONNECT_TO_DEVICE, handle);
+        else
+                sess = service_connect(mgmt, SERVICE_DEVMAN,
+                            DEVMAN_CONNECT_TO_DEVICE, handle);
+        return sess;
+}
+async_sess_t *devman_parent_device_connect(exch_mgmt_t mgmt,
+    devman_handle_t handle, unsigned int flags)
+{
+        async_sess_t *sess;
+        if (flags & IPC_FLAG_BLOCKING)
+                sess = service_connect_blocking(mgmt, SERVICE_DEVMAN,
+                            DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
+        else
+                sess = service_connect(mgmt, SERVICE_DEVMAN,
+                            DEVMAN_CONNECT_TO_PARENTS_DEVICE, handle);
+        return sess;
+}
 …
     unsigned int flags)
+{
+        int phone = devman_get_phone(DEVMAN_CLIENT, flags);
+        if (phone < 0)
+                return phone;
+        async_serialize_start();
+        ipc_call_t answer;
+        aid_t req = async_send_2(phone, DEVMAN_DEVICE_GET_HANDLE, flags, 0,
+        async_exch_t *exch;
+        if (flags & IPC_FLAG_BLOCKING)
+                exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
+        else {
+                exch = devman_exchange_begin(DEVMAN_CLIENT);
+                if (exch == NULL)
+                        return errno;
+        }
+        ipc_call_t answer;
+        aid_t req = async_send_2(exch, DEVMAN_DEVICE_GET_HANDLE, flags, 0,
             &answer);
+        sysarg_t retval = async_data_write_start(phone, pathname,
+        sysarg_t retval = async_data_write_start(exch, pathname,
             str_size(pathname));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+        devman_exchange_end(exch);
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
                 return retval;
+        }
         async_wait_for(req, &retval);
-        async_serialize_end();
         if (retval != EOK) {
                 if (handle != NULL)
                         *handle = (devman_handle_t) -1;
                 return retval;
+        }
 …
     const char *devname, devman_handle_t *handle, unsigned int flags)
+{
+        int phone = devman_get_phone(DEVMAN_CLIENT, flags);
+        if (phone < 0)
+                return phone;
+        async_serialize_start();
+        ipc_call_t answer;
+        aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
+        async_exch_t *exch;
+        if (flags & IPC_FLAG_BLOCKING)
+                exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
+        else {
+                exch = devman_exchange_begin(DEVMAN_CLIENT);
+                if (exch == NULL)
+                        return errno;
+        }
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
             flags, &answer);
+        sysarg_t retval = async_data_write_start(phone, classname,
+        sysarg_t retval = async_data_write_start(exch, classname,
             str_size(classname));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return retval;
+        }
+        retval = async_data_write_start(phone, devname,
+        if (retval != EOK) {
+                devman_exchange_end(exch);
+                async_wait_for(req, NULL);
+                return retval;
+        }
+        retval = async_data_write_start(exch, devname,
             str_size(devname));
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return retval;
+        }
+        devman_exchange_end(exch);
+        if (retval != EOK) {
+                async_wait_for(req, NULL);
+                return retval;
+        }
         async_wait_for(req, &retval);
+        async_serialize_end();
         if (retval != EOK) {
                 if (handle != NULL)
                         *handle = (devman_handle_t) -1;
+                return retval;
+        }
+                return retval;
+        }
         if (handle != NULL)
                 *handle = (devman_handle_t) IPC_GET_ARG1(answer);
         return retval;
+}
+int devman_get_device_path(devman_handle_t handle, char *path, size_t path_size)
+{
+        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+        if (exch == NULL)
+                return errno;
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, DEVMAN_DEVICE_GET_DEVICE_PATH,
+            handle, &answer);
+        ipc_call_t data_request_call;
+        aid_t data_request = async_data_read(exch, path, path_size,
+            &data_request_call);
+        devman_exchange_end(exch);
+        if (data_request == 0) {
+                async_wait_for(req, NULL);
+                return ENOMEM;
+        }
+        sysarg_t data_request_rc;
+        async_wait_for(data_request, &data_request_rc);
+        sysarg_t opening_request_rc;
+        async_wait_for(req, &opening_request_rc);
+        if (data_request_rc != EOK) {
+                /* Prefer the return code of the opening request. */
+                if (opening_request_rc != EOK)
+                        return (int) opening_request_rc;
+                else
+                        return (int) data_request_rc;
+        }
+        if (opening_request_rc != EOK)
+                return (int) opening_request_rc;
+        /* To be on the safe-side. */
+        path[path_size - 1] = 0;
+        size_t transferred_size = IPC_GET_ARG2(data_request_call);
+        if (transferred_size >= path_size)
+                return ELIMIT;
+        /* Terminate the string (trailing 0 not send over IPC). */
+        path[transferred_size] = 0;
+        return EOK;
+}
 /** @}

uspace/lib/c/generic/devmap.c

-              r52a79081
+              ra33f0a6
 #include <str.h>
 #include <ipc/services.h>
 #include <ipc/ns.h>
+#include <ns.h>
 #include <ipc/devmap.h>
 #include <devmap.h>
+#include <fibril_synch.h>
 #include <async.h>
 #include <errno.h>
 …
 #include <bool.h>
+static int devmap_phone_driver = -1;
+static int devmap_phone_client = -1;
+/** Get phone to device mapper task. */
+int devmap_get_phone(devmap_interface_t iface, unsigned int flags)
+static FIBRIL_MUTEX_INITIALIZE(devmap_driver_block_mutex);
+static FIBRIL_MUTEX_INITIALIZE(devmap_client_block_mutex);
+static FIBRIL_MUTEX_INITIALIZE(devmap_driver_mutex);
+static FIBRIL_MUTEX_INITIALIZE(devmap_client_mutex);
+static async_sess_t *devmap_driver_block_sess = NULL;
+static async_sess_t *devmap_client_block_sess = NULL;
+static async_sess_t *devmap_driver_sess = NULL;
+static async_sess_t *devmap_client_sess = NULL;
+static void clone_session(fibril_mutex_t *mtx, async_sess_t *src,
+    async_sess_t **dst)
+{
+        fibril_mutex_lock(mtx);
+        if ((*dst == NULL) && (src != NULL))
+                *dst = src;
+        fibril_mutex_unlock(mtx);
+}
+/** Start an async exchange on the devmap session (blocking).
+ *
+ * @param iface Device mapper interface to choose
+ *
+ * @return New exchange.
+ *
+ */
+async_exch_t *devmap_exchange_begin_blocking(devmap_interface_t iface)
+{
         switch (iface) {
         case DEVMAP_DRIVER:
+                if (devmap_phone_driver >= 0)
+                        return devmap_phone_driver;
+                if (flags & IPC_FLAG_BLOCKING)
+                        devmap_phone_driver = service_connect_blocking(SERVICE_DEVMAP,
+                            DEVMAP_DRIVER, 0);
+                else
+                        devmap_phone_driver = service_connect(SERVICE_DEVMAP,
+                            DEVMAP_DRIVER, 0);
+                return devmap_phone_driver;
+                fibril_mutex_lock(&devmap_driver_block_mutex);
+                while (devmap_driver_block_sess == NULL) {
+                        clone_session(&devmap_driver_mutex, devmap_driver_sess,
+                            &devmap_driver_block_sess);
+                        if (devmap_driver_block_sess == NULL)
+                                devmap_driver_block_sess =
+                                    service_connect_blocking(EXCHANGE_SERIALIZE,
+                                    SERVICE_DEVMAP, DEVMAP_DRIVER, 0);
+                }
+                fibril_mutex_unlock(&devmap_driver_block_mutex);
+                clone_session(&devmap_driver_mutex, devmap_driver_block_sess,
+                    &devmap_driver_sess);
+                return async_exchange_begin(devmap_driver_block_sess);
         case DEVMAP_CLIENT:
+                if (devmap_phone_client >= 0)
+                        return devmap_phone_client;
+                if (flags & IPC_FLAG_BLOCKING)
+                        devmap_phone_client = service_connect_blocking(SERVICE_DEVMAP,
+                            DEVMAP_CLIENT, 0);
+                else
+                        devmap_phone_client = service_connect(SERVICE_DEVMAP,
+                            DEVMAP_CLIENT, 0);
+                return devmap_phone_client;
+                fibril_mutex_lock(&devmap_client_block_mutex);
+                while (devmap_client_block_sess == NULL) {
+                        clone_session(&devmap_client_mutex, devmap_client_sess,
+                            &devmap_client_block_sess);
+                        if (devmap_client_block_sess == NULL)
+                                devmap_client_block_sess =
+                                    service_connect_blocking(EXCHANGE_SERIALIZE,
+                                    SERVICE_DEVMAP, DEVMAP_CLIENT, 0);
+                }
+                fibril_mutex_unlock(&devmap_client_block_mutex);
+                clone_session(&devmap_client_mutex, devmap_client_block_sess,
+                    &devmap_client_sess);
+                return async_exchange_begin(devmap_client_block_sess);
         default:
+                return -1;
+        }
+}
+void devmap_hangup_phone(devmap_interface_t iface)
+                return NULL;
+        }
+}
+/** Start an async exchange on the devmap session.
+ *
+ * @param iface Device mapper interface to choose
+ *
+ * @return New exchange.
+ *
+ */
+async_exch_t *devmap_exchange_begin(devmap_interface_t iface)
+{
         switch (iface) {
         case DEVMAP_DRIVER:
+                if (devmap_phone_driver >= 0) {
+                        async_hangup(devmap_phone_driver);
+                        devmap_phone_driver = -1;
+                }
+                break;
+                fibril_mutex_lock(&devmap_driver_mutex);
+                if (devmap_driver_sess == NULL)
+                        devmap_driver_sess =
+                            service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAP,
+                            DEVMAP_DRIVER, 0);
+                fibril_mutex_unlock(&devmap_driver_mutex);
+                if (devmap_driver_sess == NULL)
+                        return NULL;
+                return async_exchange_begin(devmap_driver_sess);
         case DEVMAP_CLIENT:
+                if (devmap_phone_client >= 0) {
+                        async_hangup(devmap_phone_client);
+                        devmap_phone_client = -1;
+                }
+                break;
+                fibril_mutex_lock(&devmap_client_mutex);
+                if (devmap_client_sess == NULL)
+                        devmap_client_sess =
+                            service_connect(EXCHANGE_SERIALIZE, SERVICE_DEVMAP,
+                            DEVMAP_CLIENT, 0);
+                fibril_mutex_unlock(&devmap_client_mutex);
+                if (devmap_client_sess == NULL)
+                        return NULL;
+                return async_exchange_begin(devmap_client_sess);
         default:
+                break;
+        }
+                return NULL;
+        }
+}
+/** Finish an async exchange on the devmap session.
+ *
+ * @param exch Exchange to be finished.
+ *
+ */
+void devmap_exchange_end(async_exch_t *exch)
+{
+        async_exchange_end(exch);
+}
 …
 int devmap_driver_register(const char *name, async_client_conn_t conn)
+{
+        int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
+        if (phone < 0)
+                return phone;
+        async_serialize_start();
+        async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_DRIVER);
         ipc_call_t answer;
+        aid_t req = async_send_2(phone, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
+        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
+        aid_t req = async_send_2(exch, DEVMAP_DRIVER_REGISTER, 0, 0, &answer);
+        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
+        devmap_exchange_end(exch);
         if (retval != EOK) {
                 async_wait_for(req, NULL);
+                async_serialize_end();
+                return -1;
+                return retval;
+        }
         async_set_client_connection(conn);
+        async_connect_to_me(phone, 0, 0, 0, NULL);
+        exch = devmap_exchange_begin(DEVMAP_DRIVER);
+        async_connect_to_me(exch, 0, 0, 0, NULL, NULL);
+        devmap_exchange_end(exch);
         async_wait_for(req, &retval);
-        async_serialize_end();
         return retval;
+}
 …
  * If not 0, the first argument is the interface and the second argument
  * is the devmap handle of the device.
+ *
  * When the interface is zero (default), the first argument is directly
  * the handle (to ensure backward compatibility).
+ *
  * @param fqdn Fully qualified device name.
  * @param[out] handle Handle to the created instance of device.
  * @param interface Interface when forwarding.
+ * @param      fqdn      Fully qualified device name.
+ * @param[out] handle    Handle to the created instance of device.
+ * @param      interface Interface when forwarding.
+ *
  */
 …
     devmap_handle_t *handle, sysarg_t interface)
+{
+        int phone = devmap_get_phone(DEVMAP_DRIVER, IPC_FLAG_BLOCKING);
+        if (phone < 0)
+                return phone;
+        async_serialize_start();
+        async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_DRIVER);
         ipc_call_t answer;
         aid_t req = async_send_2(phone, DEVMAP_DEVICE_REGISTER, interface, 0,
+        aid_t req = async_send_2(exch, DEVMAP_DEVICE_REGISTER, interface, 0,
             &answer);
+        sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
+        sysarg_t retval = async_data_write_start(exch, fqdn, str_size(fqdn));
+        devmap_exchange_end(exch);
         if (retval != EOK) {
                 async_wait_for(req, NULL);
-                async_serialize_end();
                 return retval;
+        }
         async_wait_for(req, &retval);
-        async_serialize_end();
         if (retval != EOK) {
                 if (handle != NULL)
                         *handle = -1;
                 return retval;
+        }
 …
 /** Register new device.
+ *
  * @param fqdn      Fully qualified device name.
  * @param handle    Output: Handle to the created instance of device.
+ * @param fqdn   Fully qualified device name.
+ * @param handle Output: Handle to the created instance of device.
+ *
  */
 …
+}
+int devmap_device_get_handle(const char *fqdn, devmap_handle_t *handle, unsigned int flags)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, flags);
+        if (phone < 0)
+                return phone;
+        async_serialize_start();
+int devmap_device_get_handle(const char *fqdn, devmap_handle_t *handle,
+    unsigned int flags)
+{
+        async_exch_t *exch;
+        if (flags & IPC_FLAG_BLOCKING)
+                exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT);
+        else {
+                exch = devmap_exchange_begin(DEVMAP_CLIENT);
+                if (exch == NULL)
+                        return errno;
+        }
         ipc_call_t answer;
         aid_t req = async_send_2(phone, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
+        aid_t req = async_send_2(exch, DEVMAP_DEVICE_GET_HANDLE, flags, 0,
             &answer);
+        sysarg_t retval = async_data_write_start(phone, fqdn, str_size(fqdn));
+        sysarg_t retval = async_data_write_start(exch, fqdn, str_size(fqdn));
+        devmap_exchange_end(exch);
         if (retval != EOK) {
                 async_wait_for(req, NULL);
-                async_serialize_end();
                 return retval;
+        }
         async_wait_for(req, &retval);
-        async_serialize_end();
         if (retval != EOK) {
                 if (handle != NULL)
                         *handle = (devmap_handle_t) -1;
                 return retval;
+        }
 …
+}
+int devmap_namespace_get_handle(const char *name, devmap_handle_t *handle, unsigned int flags)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, flags);
+        if (phone < 0)
+                return phone;
+        async_serialize_start();
+int devmap_namespace_get_handle(const char *name, devmap_handle_t *handle,
+    unsigned int flags)
+{
+        async_exch_t *exch;
+        if (flags & IPC_FLAG_BLOCKING)
+                exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT);
+        else {
+                exch = devmap_exchange_begin(DEVMAP_CLIENT);
+                if (exch == NULL)
+                        return errno;
+        }
         ipc_call_t answer;
         aid_t req = async_send_2(phone, DEVMAP_NAMESPACE_GET_HANDLE, flags, 0,
+        aid_t req = async_send_2(exch, DEVMAP_NAMESPACE_GET_HANDLE, flags, 0,
             &answer);
+        sysarg_t retval = async_data_write_start(phone, name, str_size(name));
+        sysarg_t retval = async_data_write_start(exch, name, str_size(name));
+        devmap_exchange_end(exch);
         if (retval != EOK) {
                 async_wait_for(req, NULL);
-                async_serialize_end();
                 return retval;
+        }
         async_wait_for(req, &retval);
-        async_serialize_end();
         if (retval != EOK) {
                 if (handle != NULL)
                         *handle = (devmap_handle_t) -1;
                 return retval;
+        }
 …
 devmap_handle_type_t devmap_handle_probe(devmap_handle_t handle)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+        if (phone < 0)
+                return phone;
+        async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT);
         sysarg_t type;
+        int retval = async_req_1_1(phone, DEVMAP_HANDLE_PROBE, handle, &type);
+        int retval = async_req_1_1(exch, DEVMAP_HANDLE_PROBE, handle, &type);
+        devmap_exchange_end(exch);
         if (retval != EOK)
                 return DEV_HANDLE_NONE;
 …
+}
+int devmap_device_connect(devmap_handle_t handle, unsigned int flags)
+{
+        int phone;
+        if (flags & IPC_FLAG_BLOCKING) {
+                phone = async_connect_me_to_blocking(PHONE_NS, SERVICE_DEVMAP,
+async_sess_t *devmap_device_connect(exch_mgmt_t mgmt, devmap_handle_t handle,
+    unsigned int flags)
+{
+        async_sess_t *sess;
+        if (flags & IPC_FLAG_BLOCKING)
+                sess = service_connect_blocking(mgmt, SERVICE_DEVMAP,
                     DEVMAP_CONNECT_TO_DEVICE, handle);
         } else {
                 phone = async_connect_me_to(PHONE_NS, SERVICE_DEVMAP,
+        else
+                sess = service_connect(mgmt, SERVICE_DEVMAP,
                     DEVMAP_CONNECT_TO_DEVICE, handle);
+        }
+        return phone;
+        return sess;
+}
 int devmap_null_create(void)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+        if (phone < 0)
+                return -1;
+        async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT);
         sysarg_t null_id;
+        int retval = async_req_0_1(phone, DEVMAP_NULL_CREATE, &null_id);
+        int retval = async_req_0_1(exch, DEVMAP_NULL_CREATE, &null_id);
+        devmap_exchange_end(exch);
         if (retval != EOK)
                 return -1;
 …
 void devmap_null_destroy(int null_id)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+        if (phone < 0)
+                return;
+        async_req_1_0(phone, DEVMAP_NULL_DESTROY, (sysarg_t) null_id);
+}
+static size_t devmap_count_namespaces_internal(int phone)
+        async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT);
+        async_req_1_0(exch, DEVMAP_NULL_DESTROY, (sysarg_t) null_id);
+        devmap_exchange_end(exch);
+}
+static size_t devmap_count_namespaces_internal(async_exch_t *exch)
+{
         sysarg_t count;
         int retval = async_req_0_1(phone, DEVMAP_GET_NAMESPACE_COUNT, &count);
+        int retval = async_req_0_1(exch, DEVMAP_GET_NAMESPACE_COUNT, &count);
         if (retval != EOK)
                 return 0;
 …
+}
+static size_t devmap_count_devices_internal(int phone, devmap_handle_t ns_handle)
+static size_t devmap_count_devices_internal(async_exch_t *exch,
+    devmap_handle_t ns_handle)
+{
         sysarg_t count;
+        int retval = async_req_1_1(phone, DEVMAP_GET_DEVICE_COUNT, ns_handle, &count);
+        int retval = async_req_1_1(exch, DEVMAP_GET_DEVICE_COUNT, ns_handle,
+            &count);
         if (retval != EOK)
                 return 0;
 …
 size_t devmap_count_namespaces(void)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+        if (phone < 0)
+                return 0;
+        return devmap_count_namespaces_internal(phone);
+        async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT);
+        size_t size = devmap_count_namespaces_internal(exch);
+        devmap_exchange_end(exch);
+        return size;
+}
 size_t devmap_count_devices(devmap_handle_t ns_handle)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+        if (phone < 0)
+                return 0;
+        return devmap_count_devices_internal(phone, ns_handle);
+        async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT);
+        size_t size = devmap_count_devices_internal(exch, ns_handle);
+        devmap_exchange_end(exch);
+        return size;
+}
 size_t devmap_get_namespaces(dev_desc_t **data)
+{
-        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
-        if (phone < 0)
-                return 0;
         /* Loop until namespaces read succesful */
         while (true) {
+                size_t count = devmap_count_namespaces_internal(phone);
+                async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT);
+                size_t count = devmap_count_namespaces_internal(exch);
+                devmap_exchange_end(exch);
                 if (count == 0)
                         return 0;
 …
                         return 0;
                 async_serialize_start();
+                exch = devmap_exchange_begin(DEVMAP_CLIENT);
                 ipc_call_t answer;
+                aid_t req = async_send_0(phone, DEVMAP_GET_NAMESPACES, &answer);
+                int rc = async_data_read_start(phone, devs, count * sizeof(dev_desc_t));
+                aid_t req = async_send_0(exch, DEVMAP_GET_NAMESPACES, &answer);
+                int rc = async_data_read_start(exch, devs, count * sizeof(dev_desc_t));
+                devmap_exchange_end(exch);
                 if (rc == EOVERFLOW) {
                         /*
 …
                          * the last call of DEVMAP_DEVICE_GET_NAMESPACE_COUNT
                          */
-                        async_serialize_end();
                         free(devs);
                         continue;
 …
                 if (rc != EOK) {
                         async_wait_for(req, NULL);
-                        async_serialize_end();
                         free(devs);
                         return 0;
 …
                 sysarg_t retval;
                 async_wait_for(req, &retval);
-                async_serialize_end();
                 if (retval != EOK)
 …
 size_t devmap_get_devices(devmap_handle_t ns_handle, dev_desc_t **data)
+{
+        int phone = devmap_get_phone(DEVMAP_CLIENT, IPC_FLAG_BLOCKING);
+        if (phone < 0)
+                return 0;
+        /* Loop until namespaces read succesful */
+        /* Loop until devices read succesful */
         while (true) {
+                size_t count = devmap_count_devices_internal(phone, ns_handle);
+                async_exch_t *exch = devmap_exchange_begin_blocking(DEVMAP_CLIENT);
+                size_t count = devmap_count_devices_internal(exch, ns_handle);
+                devmap_exchange_end(exch);
                 if (count == 0)
                         return 0;
 …
                         return 0;
                 async_serialize_start();
+                exch = devmap_exchange_begin(DEVMAP_CLIENT);
                 ipc_call_t answer;
+                aid_t req = async_send_1(phone, DEVMAP_GET_DEVICES, ns_handle, &answer);
+                int rc = async_data_read_start(phone, devs, count * sizeof(dev_desc_t));
+                aid_t req = async_send_1(exch, DEVMAP_GET_DEVICES, ns_handle, &answer);
+                int rc = async_data_read_start(exch, devs, count * sizeof(dev_desc_t));
+                devmap_exchange_end(exch);
                 if (rc == EOVERFLOW) {
                         /*
 …
                          * the last call of DEVMAP_DEVICE_GET_DEVICE_COUNT
                          */
-                        async_serialize_end();
                         free(devs);
                         continue;
 …
                 if (rc != EOK) {
                         async_wait_for(req, NULL);
-                        async_serialize_end();
                         free(devs);
                         return 0;
 …
                 sysarg_t retval;
                 async_wait_for(req, &retval);
-                async_serialize_end();
                 if (retval != EOK)

uspace/lib/c/generic/elf/elf_load.c

-              r52a79081
+              ra33f0a6
  * Copyright (c) 2006 Sergey Bondari
  * Copyright (c) 2006 Jakub Jermar
  * Copyright (c) 2008 Jiri Svoboda
+ * Copyright (c) 2011 Jiri Svoboda
  * All rights reserved.
+ *
 …
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #include <assert.h>
 #include <as.h>
+#include <elf/elf.h>
 #include <unistd.h>
 #include <fcntl.h>
 #include <smc.h>
 #include <loader/pcb.h>
+#include "elf.h"
+#include "elf_load.h"
+#include "arch.h"
+#include <entry_point.h>
+#include <elf/elf_load.h>
 #define DPRINTF(...)
 …
 static int load_segment(elf_ld_t *elf, elf_segment_header_t *entry);
-/** Read until the buffer is read in its entirety. */
-static int my_read(int fd, void *buf, size_t len)
+{
-        int cnt = 0;
-        do {
-                buf += cnt;
-                len -= cnt;
-                cnt = read(fd, buf, len);
-        } while ((cnt > 0) && ((len - cnt) > 0));
-        return cnt;
+}
 /** Load ELF binary from a file.
+ *
 …
+ *
  */
+int elf_load_file(const char *file_name, size_t so_bias, elf_info_t *info)
+int elf_load_file(const char *file_name, size_t so_bias, eld_flags_t flags,
+    elf_info_t *info)
+{
         elf_ld_t elf;
 …
         elf.fd = fd;
         elf.info = info;
+        elf.flags = flags;
         rc = elf_load(&elf, so_bias);
 …
         return rc;
+}
-/** Run an ELF executable.
+ *
- * Transfers control to the entry point of an ELF executable loaded
- * earlier with elf_load_file(). This function does not return.
+ *
- * @param info Info structure filled earlier by elf_load_file()
+ *
- */
-void elf_run(elf_info_t *info, pcb_t *pcb)
+{
-        program_run(info->entry, pcb);
-        /* not reached */
+}
 …
         pcb->entry = info->entry;
         pcb->dynamic = info->dynamic;
+        pcb->rtld_runtime = NULL;
+}
 …
         int i, rc;
         rc = my_read(elf->fd, header, sizeof(elf_header_t));
         if (rc < 0) {
+        rc = read_all(elf->fd, header, sizeof(elf_header_t));
+        if (rc != sizeof(elf_header_t)) {
                 DPRINTF("Read error.\n");
                 return EE_INVALID;
 …
                         + i * sizeof(elf_segment_header_t), SEEK_SET);
                 rc = my_read(elf->fd, &segment_hdr,
+                rc = read_all(elf->fd, &segment_hdr,
                     sizeof(elf_segment_header_t));
                 if (rc < 0) {
+                if (rc != sizeof(elf_segment_header_t)) {
                         DPRINTF("Read error.\n");
                         return EE_INVALID;
 …
                     + i * sizeof(elf_section_header_t), SEEK_SET);
                 rc = my_read(elf->fd, &section_hdr,
+                rc = read_all(elf->fd, &section_hdr,
                     sizeof(elf_section_header_t));
                 if (rc < 0) {
+                if (rc != sizeof(elf_section_header_t)) {
                         DPRINTF("Read error.\n");
                         return EE_INVALID;
 …
                 break;
         case PT_INTERP:
                 /* Assume silently interp == "/rtld.so" */
                 elf->info->interp = "/rtld.so";
+                /* Assume silently interp == "/app/dload" */
+                elf->info->interp = "/app/dload";
                 break;
         case PT_DYNAMIC:
+                /* Record pointer to dynamic section into info structure */
+                elf->info->dynamic =
+                    (void *)((uint8_t *)entry->p_vaddr + elf->bias);
+                DPRINTF("dynamic section found at 0x%x\n",
+                        (uintptr_t)elf->info->dynamic);
+                break;
+        case 0x70000000:
+                /* FIXME: MIPS reginfo */
+                break;
         case PT_SHLIB:
         case PT_LOPROC:
         case PT_HIPROC:
+//      case PT_LOPROC:
+//      case PT_HIPROC:
         default:
                 DPRINTF("Segment p_type %d unknown.\n", entry->p_type);
 …
         uintptr_t seg_addr;
         size_t mem_sz;
         int rc;
+        ssize_t rc;
         bias = elf->bias;
 …
             AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
         if (a == (void *)(-1)) {
+                DPRINTF("Memory mapping failed.\n");
+                DPRINTF("memory mapping failed (0x%x, %d)\n",
+                        base+bias, mem_sz);
                 return EE_MEMORY;
+        }
 …
                 if (now > left) now = left;
                 rc = my_read(elf->fd, dp, now);
                 if (rc < 0) {
+                rc = read_all(elf->fd, dp, now);
+                if (rc != (ssize_t) now) {
                         DPRINTF("Read error.\n");
                         return EE_INVALID;
 …
+        }
+        /*
+         * The caller wants to modify the segments first. He will then
+         * need to set the right access mode and ensure SMC coherence.
+         */
+        if ((elf->flags & ELDF_RW) != 0) return EE_OK;
+//      printf("set area flags to %d\n", flags);
         rc = as_area_change_flags(seg_ptr, flags);
         if (rc != 0) {

uspace/lib/c/generic/event.c

-              r52a79081
+              ra33f0a6
 #include <kernel/ipc/event_types.h>
 /** Subscribe for event notifications.
+/** Subscribe event notifications.
+ *
  * @param evno   Event number.
  * @param method Use this method for notifying me.
+ * @param evno    Event type to subscribe.
+ * @param imethod Use this interface and method for notifying me.
+ *
  * @return Value returned by the kernel.
+ *
  */
 int event_subscribe(event_type_t e, sysarg_t method)
+int event_subscribe(event_type_t evno, sysarg_t imethod)
+{
+        return __SYSCALL2(SYS_EVENT_SUBSCRIBE, (sysarg_t) e, (sysarg_t) method);
+        return __SYSCALL2(SYS_EVENT_SUBSCRIBE, (sysarg_t) evno,
+            (sysarg_t) imethod);
+}
+/** Unmask event notifications.
+ *
+ * @param evno Event type to unmask.
+ *
+ * @return Value returned by the kernel.
+ *
+ */
+int event_unmask(event_type_t evno)
+{
+        return __SYSCALL1(SYS_EVENT_UNMASK, (sysarg_t) evno);
+}

uspace/lib/c/generic/fibril.c

-              r52a79081
+              ra33f0a6
         fibril_t *dstf;
         if ((stype == FIBRIL_TO_MANAGER) || (stype == FIBRIL_FROM_DEAD)) {
+                dstf = list_get_instance(manager_list.next, fibril_t, link);
+                dstf = list_get_instance(list_first(&manager_list), fibril_t,
+                    link);
                 if (serialization_count && stype == FIBRIL_TO_MANAGER) {
                         serialized_threads++;
 …
         } else {
                 if (!list_empty(&serialized_list)) {
                         dstf = list_get_instance(serialized_list.next, fibril_t,
                             link);
+                        dstf = list_get_instance(list_first(&serialized_list),
+                            fibril_t, link);
                         serialized_threads--;
                 } else {
                         dstf = list_get_instance(ready_list.next, fibril_t,
                             link);
+                        dstf = list_get_instance(list_first(&ready_list),
+                            fibril_t, link);
+                }
+        }
 …
         if (!list_empty(&manager_list))
                 list_remove(manager_list.next);
+                list_remove(list_first(&manager_list));
         futex_up(&fibril_futex);

uspace/lib/c/generic/fibril_synch.c

-              r52a79081
+              ra33f0a6
                 fibril_t *f;
                 assert(!list_empty(&fm->waiters));
                 tmp = fm->waiters.next;
+                tmp = list_first(&fm->waiters);
+                assert(tmp != NULL);
                 wdp = list_get_instance(tmp, awaiter_t, wu_event.link);
                 wdp->active = true;
 …
         while (!list_empty(&frw->waiters)) {
                 link_t *tmp = frw->waiters.next;
+                link_t *tmp = list_first(&frw->waiters);
                 awaiter_t *wdp;
                 fibril_t *f;
 …
         futex_down(&async_futex);
         while (!list_empty(&fcv->waiters)) {
                 tmp = fcv->waiters.next;
+                tmp = list_first(&fcv->waiters);
                 wdp = list_get_instance(tmp, awaiter_t, wu_event.link);
                 list_remove(&wdp->wu_event.link);

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

-              r52a79081
+              ra33f0a6
 #include <libc.h>
 #include <async.h>
+#include <errno.h>
+#include <stdio.h>
+#include <malloc.h>
+#include <vfs/vfs_sess.h>
 #include <io/console.h>
 #include <ipc/console.h>
+void console_clear(int phone)
+{
+        async_msg_0(phone, CONSOLE_CLEAR);
+}
+int console_get_size(int phone, sysarg_t *cols, sysarg_t *rows)
+{
+        return async_req_0_2(phone, CONSOLE_GET_SIZE, cols, rows);
+}
+void console_set_style(int phone, uint8_t style)
+{
+        async_msg_1(phone, CONSOLE_SET_STYLE, style);
+}
+void console_set_color(int phone, uint8_t fg_color, uint8_t bg_color,
+console_ctrl_t *console_init(FILE *ifile, FILE *ofile)
+{
+        console_ctrl_t *ctrl = malloc(sizeof(console_ctrl_t));
+        if (!ctrl)
+                return NULL;
+        ctrl->input_sess = fsession(EXCHANGE_SERIALIZE, ifile);
+        if (!ctrl->input_sess) {
+                free(ctrl);
+                return NULL;
+        }
+        ctrl->output_sess = fsession(EXCHANGE_SERIALIZE, ofile);
+        if (!ctrl->output_sess) {
+                free(ctrl);
+                return NULL;
+        }
+        ctrl->input = ifile;
+        ctrl->output = ofile;
+        ctrl->input_aid = 0;
+        return ctrl;
+}
+void console_done(console_ctrl_t *ctrl)
+{
+        free(ctrl);
+}
+bool console_kcon(void)
+{
+        return __SYSCALL0(SYS_DEBUG_ACTIVATE_CONSOLE);
+}
+void console_flush(console_ctrl_t *ctrl)
+{
+        fflush(ctrl->output);
+}
+void console_clear(console_ctrl_t *ctrl)
+{
+        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
+        async_msg_0(exch, CONSOLE_CLEAR);
+        async_exchange_end(exch);
+}
+int console_get_size(console_ctrl_t *ctrl, sysarg_t *cols, sysarg_t *rows)
+{
+        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
+        int rc = async_req_0_2(exch, CONSOLE_GET_SIZE, cols, rows);
+        async_exchange_end(exch);
+        return rc;
+}
+void console_set_style(console_ctrl_t *ctrl, uint8_t style)
+{
+        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
+        async_msg_1(exch, CONSOLE_SET_STYLE, style);
+        async_exchange_end(exch);
+}
+void console_set_color(console_ctrl_t *ctrl, uint8_t fg_color, uint8_t bg_color,
     uint8_t flags)
+{
+        async_msg_3(phone, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
+}
+void console_set_rgb_color(int phone, uint32_t fg_color, uint32_t bg_color)
+{
+        async_msg_2(phone, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
+}
+void console_cursor_visibility(int phone, bool show)
+{
+        async_msg_1(phone, CONSOLE_CURSOR_VISIBILITY, (show != false));
+}
+int console_get_color_cap(int phone, sysarg_t *ccap)
+{
+        return async_req_0_1(phone, CONSOLE_GET_COLOR_CAP, ccap);
+}
+void console_kcon_enable(int phone)
+{
+        async_msg_0(phone, CONSOLE_KCON_ENABLE);
+}
+int console_get_pos(int phone, sysarg_t *col, sysarg_t *row)
+{
+        return async_req_0_2(phone, CONSOLE_GET_POS, col, row);
+}
+void console_set_pos(int phone, sysarg_t col, sysarg_t row)
+{
+        async_msg_2(phone, CONSOLE_GOTO, col, row);
+}
+bool console_get_event(int phone, console_event_t *event)
+{
+        sysarg_t type;
+        sysarg_t key;
+        sysarg_t mods;
+        sysarg_t c;
+        int rc = async_req_0_4(phone, CONSOLE_GET_EVENT, &type, &key, &mods, &c);
+        if (rc < 0)
+        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
+        async_msg_3(exch, CONSOLE_SET_COLOR, fg_color, bg_color, flags);
+        async_exchange_end(exch);
+}
+void console_set_rgb_color(console_ctrl_t *ctrl, uint32_t fg_color,
+    uint32_t bg_color)
+{
+        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
+        async_msg_2(exch, CONSOLE_SET_RGB_COLOR, fg_color, bg_color);
+        async_exchange_end(exch);
+}
+void console_cursor_visibility(console_ctrl_t *ctrl, bool show)
+{
+        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
+        async_msg_1(exch, CONSOLE_CURSOR_VISIBILITY, (show != false));
+        async_exchange_end(exch);
+}
+int console_get_color_cap(console_ctrl_t *ctrl, sysarg_t *ccap)
+{
+        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
+        int rc = async_req_0_1(exch, CONSOLE_GET_COLOR_CAP, ccap);
+        async_exchange_end(exch);
+        return rc;
+}
+int console_get_pos(console_ctrl_t *ctrl, sysarg_t *col, sysarg_t *row)
+{
+        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
+        int rc = async_req_0_2(exch, CONSOLE_GET_POS, col, row);
+        async_exchange_end(exch);
+        return rc;
+}
+void console_set_pos(console_ctrl_t *ctrl, sysarg_t col, sysarg_t row)
+{
+        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
+        async_msg_2(exch, CONSOLE_GOTO, col, row);
+        async_exchange_end(exch);
+}
+bool console_get_kbd_event(console_ctrl_t *ctrl, kbd_event_t *event)
+{
+        if (ctrl->input_aid == 0) {
+                sysarg_t type;
+                sysarg_t key;
+                sysarg_t mods;
+                sysarg_t c;
+                async_exch_t *exch = async_exchange_begin(ctrl->input_sess);
+                int rc = async_req_0_4(exch, CONSOLE_GET_EVENT, &type, &key, &mods, &c);
+                async_exchange_end(exch);
+                if (rc != EOK) {
+                        errno = rc;
+                        return false;
+                }
+                event->type = type;
+                event->key = key;
+                event->mods = mods;
+                event->c = c;
+        } else {
+                sysarg_t retval;
+                async_wait_for(ctrl->input_aid, &retval);
+                ctrl->input_aid = 0;
+                if (retval != EOK) {
+                        errno = (int) retval;
+                        return false;
+                }
+                event->type = IPC_GET_ARG1(ctrl->input_call);
+                event->key = IPC_GET_ARG2(ctrl->input_call);
+                event->mods = IPC_GET_ARG3(ctrl->input_call);
+                event->c = IPC_GET_ARG4(ctrl->input_call);
+        }
+        return true;
+}
+bool console_get_kbd_event_timeout(console_ctrl_t *ctrl, kbd_event_t *event,
+    suseconds_t *timeout)
+{
+        struct timeval t0;
+        gettimeofday(&t0, NULL);
+        if (ctrl->input_aid == 0) {
+                async_exch_t *exch = async_exchange_begin(ctrl->input_sess);
+                ctrl->input_aid = async_send_0(exch, CONSOLE_GET_EVENT,
+                    &ctrl->input_call);
+                async_exchange_end(exch);
+        }
+        sysarg_t retval;
+        int rc = async_wait_timeout(ctrl->input_aid, &retval, *timeout);
+        if (rc != EOK) {
+                *timeout = 0;
+                errno = rc;
                 return false;
+        event->type = type;
+        event->key = key;
+        event->mods = mods;
+        event->c = c;
+        }
+        ctrl->input_aid = 0;
+        if (retval != EOK) {
+                errno = (int) retval;
+                return false;
+        }
+        event->type = IPC_GET_ARG1(ctrl->input_call);
+        event->key = IPC_GET_ARG2(ctrl->input_call);
+        event->mods = IPC_GET_ARG3(ctrl->input_call);
+        event->c = IPC_GET_ARG4(ctrl->input_call);
+        /* Update timeout */
+        struct timeval t1;
+        gettimeofday(&t1, NULL);
+        *timeout -= tv_sub(&t1, &t0);
         return true;

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

-              r52a79081
+              ra33f0a6
 #include <io/klog.h>
 #include <vfs/vfs.h>
+#include <vfs/vfs_sess.h>
 #include <ipc/devmap.h>
 #include <adt/list.h>
 #include "../private/io.h"
+#include "../private/stdio.h"
 static void _ffillbuf(FILE *stream);
 …
         .eof = true,
         .klog = false,
         .phone = -1,
+        .sess = NULL,
         .btype = _IONBF,
         .buf = NULL,
 …
         .eof = false,
         .klog = true,
         .phone = -1,
+        .sess = NULL,
         .btype = _IOLBF,
         .buf = NULL,
 …
         .eof = false,
         .klog = true,
         .phone = -1,
+        .sess = NULL,
         .btype = _IONBF,
         .buf = NULL,
 …
 void __stdio_done(void)
+{
+        link_t *link = files.next;
+        while (link != &files) {
+                FILE *file = list_get_instance(link, FILE, link);
+        while (!list_empty(&files)) {
+                FILE *file = list_get_instance(list_first(&files), FILE, link);
                 fclose(file);
-                link = files.next;
+        }
+}
 …
         stream->eof = false;
         stream->klog = false;
         stream->phone = -1;
+        stream->sess = NULL;
         stream->need_sync = false;
         _setvbuf(stream);
 …
         stream->eof = false;
         stream->klog = false;
         stream->phone = -1;
+        stream->sess = NULL;
         stream->need_sync = false;
         _setvbuf(stream);
 …
         stream->eof = false;
         stream->klog = false;
         stream->phone = -1;
+        stream->sess = NULL;
         stream->need_sync = false;
         _setvbuf(stream);
 …
         fflush(stream);
         if (stream->phone >= 0)
                 async_hangup(stream->phone);
+        if (stream->sess != NULL)
+                async_hangup(stream->sess);
         if (stream->fd >= 0)
 …
+                }
                 buf += now;
+                data += now;
                 stream->buf_head += now;
                 buf_free -= now;
                 bytes_left -= now;
                 total_written += now;
+                stream->buf_state = _bs_write;
                 if (buf_free == 0) {
 …
+                }
+        }
-        if (total_written > 0)
-                stream->buf_state = _bs_write;
         if (need_flush)
 …
 off64_t ftell(FILE *stream)
+{
+        _fflushbuf(stream);
         return lseek(stream->fd, 0, SEEK_CUR);
+}
 …
+        }
         if (stream->fd >= 0 && stream->need_sync) {
+        if ((stream->fd >= 0) && (stream->need_sync)) {
                 /**
                  * Better than syncing always, but probably still not the
 …
+}
 int fphone(FILE *stream)
+async_sess_t *fsession(exch_mgmt_t mgmt, FILE *stream)
+{
         if (stream->fd >= 0) {
                 if (stream->phone < 0)
                         stream->phone = fd_phone(stream->fd);
                 return stream->phone;
+        }
         return -1;
+                if (stream->sess == NULL)
+                        stream->sess = fd_session(mgmt, stream->fd);
+                return stream->sess;
+        }
+        return NULL;
+}

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

-              r52a79081
+              ra33f0a6
 #include <sys/types.h>
 #include <unistd.h>
+#include <errno.h>
 #include <io/klog.h>
+#include <io/printf_core.h>
 size_t klog_write(const void *buf, size_t size)
 …
+}
+/** Print formatted text to klog.
+ *
+ * @param fmt Format string
+ *
+ * \see For more details about format string see printf_core.
+ *
+ */
+int klog_printf(const char *fmt, ...)
+{
+        va_list args;
+        va_start(args, fmt);
+        int ret = klog_vprintf(fmt, args);
+        va_end(args);
+        return ret;
+}
+static int klog_vprintf_str_write(const char *str, size_t size, void *data)
+{
+        size_t wr = klog_write(str, size);
+        return str_nlength(str, wr);
+}
+static int klog_vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
+{
+        size_t offset = 0;
+        size_t chars = 0;
+        while (offset < size) {
+                char buf[STR_BOUNDS(1)];
+                size_t sz = 0;
+                if (chr_encode(str[chars], buf, &sz, STR_BOUNDS(1)) == EOK)
+                        klog_write(buf, sz);
+                chars++;
+                offset += sizeof(wchar_t);
+        }
+        return chars;
+}
+/** Print formatted text to klog.
+ *
+ * @param fmt Format string
+ * @param ap  Format parameters
+ *
+ * \see For more details about format string see printf_core.
+ *
+ */
+int klog_vprintf(const char *fmt, va_list ap)
+{
+        printf_spec_t ps = {
+                klog_vprintf_str_write,
+                klog_vprintf_wstr_write,
+                NULL
+        };
+        return printf_core(fmt, &ps, ap);
+}
 /** @}
  */

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

-              r52a79081
+              ra33f0a6
 /** Print formatted text to stdout.
+ *
+ * @param file Output stream
+ * @param fmt  Format string
+ * @param ap   Format parameters
+ * @param fmt Format string
+ * @param ap  Format parameters
+ *
  * \see For more details about format string see printf_core.

uspace/lib/c/generic/ipc.c

-              r52a79081
+              ra33f0a6
         while (!list_empty(&queued_calls)) {
                 async_call_t *call =
                     list_get_instance(queued_calls.next, async_call_t, list);
+                    list_get_instance(list_first(&queued_calls), async_call_t, list);
                 ipc_callid_t callid =
                     ipc_call_async_internal(call->u.msg.phoneid, &call->u.msg.data);
 …
         link_t *item;
         for (item = dispatched_calls.next; item != &dispatched_calls;
+        for (item = dispatched_calls.head.next; item != &dispatched_calls.head;
             item = item->next) {
                 async_call_t *call =
 …
+}
+/** Request cloned connection.
+ *
+ * @param phoneid Phone handle used for contacting the other side.
+ *
+ * @return Cloned phone handle on success or a negative error code.
+ *
+ */
+int ipc_connect_me(int phoneid)
+{
+        sysarg_t newphid;
+        int res = ipc_call_sync_0_5(phoneid, IPC_M_CONNECT_ME, NULL, NULL,
+            NULL, NULL, &newphid);
+        if (res)
+                return res;
+        return newphid;
+}
 /** Request new connection.
+ *

uspace/lib/c/generic/libc.c

-              r52a79081
+              ra33f0a6
 #include "private/libc.h"
 #include "private/async.h"
-#include "private/async_sess.h"
 #include "private/malloc.h"
 #include "private/io.h"
+#ifdef CONFIG_RTLD
+#include <rtld/rtld.h>
+#endif
 static bool env_setup = false;
 …
         __malloc_init();
         __async_init();
-        __async_sess_init();
         fibril_t *fibril = fibril_setup();
 …
         char **argv;
+#ifdef __IN_SHARED_LIBC__
+        if (__pcb != NULL && __pcb->rtld_runtime != NULL) {
+                runtime_env = (runtime_env_t *) __pcb->rtld_runtime;
+        }
+#endif
         /*
          * Get command line arguments and initialize

uspace/lib/c/generic/loader.c

-              r52a79081
+              ra33f0a6
 #include <ipc/loader.h>
 #include <ipc/services.h>
 #include <ipc/ns.h>
+#include <ns.h>
 #include <libc.h>
 #include <task.h>
 …
 #include <vfs/vfs.h>
 #include <loader/loader.h>
+#include "private/loader.h"
 /** Connect to a new program loader.
 …
 loader_t *loader_connect(void)
+{
-        int phone_id = service_connect_blocking(SERVICE_LOAD, 0, 0);
-        if (phone_id < 0)
-                return NULL;
         loader_t *ldr = malloc(sizeof(loader_t));
         if (ldr == NULL)
                 return NULL;
+        ldr->phone_id = phone_id;
+        async_sess_t *sess =
+            service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOAD, 0, 0);
+        if (sess == NULL) {
+                free(ldr);
+                return NULL;
+        }
+        ldr->sess = sess;
         return ldr;
+}
 …
+{
         /* Get task ID. */
+        ipc_call_t answer;
+        aid_t req = async_send_0(ldr->phone_id, LOADER_GET_TASKID, &answer);
+        int rc = async_data_read_start(ldr->phone_id, task_id, sizeof(task_id_t));
+        if (rc != EOK) {
+                async_wait_for(req, NULL);
+                return rc;
+        }
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        return (int) retval;
+        async_exch_t *exch = async_exchange_begin(ldr->sess);
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, LOADER_GET_TASKID, &answer);
+        sysarg_t rc = async_data_read_start(exch, task_id, sizeof(task_id_t));
+        async_exchange_end(exch);
+        if (rc != EOK) {
+                async_wait_for(req, NULL);
+                return (int) rc;
+        }
+        async_wait_for(req, &rc);
+        return (int) rc;
+}
 …
 int loader_set_cwd(loader_t *ldr)
+{
+        char *cwd;
+        size_t len;
+        cwd = (char *) malloc(MAX_PATH_LEN + 1);
+        char *cwd = (char *) malloc(MAX_PATH_LEN + 1);
         if (!cwd)
                 return ENOMEM;
         if (!getcwd(cwd, MAX_PATH_LEN + 1))
+                str_cpy(cwd, MAX_PATH_LEN + 1, "/");
+        len = str_length(cwd);
+        ipc_call_t answer;
+        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_CWD, &answer);
+        int rc = async_data_write_start(ldr->phone_id, cwd, len);
+                str_cpy(cwd, MAX_PATH_LEN + 1, "/");
+        size_t len = str_length(cwd);
+        async_exch_t *exch = async_exchange_begin(ldr->sess);
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, LOADER_SET_CWD, &answer);
+        sysarg_t rc = async_data_write_start(exch, cwd, len);
+        async_exchange_end(exch);
         free(cwd);
         if (rc != EOK) {
                 async_wait_for(req, NULL);
                 return rc;
+        }
         sysarg_t retval;
         async_wait_for(req, &retval);
         return (int) retval;
+        if (rc != EOK) {
+                async_wait_for(req, NULL);
+                return (int) rc;
+        }
+        async_wait_for(req, &rc);
+        return (int) rc;
+}
 …
         char *pa = absolutize(path, &pa_len);
         if (!pa)
                 return 0;
+                return ENOMEM;
         /* Send program pathname */
+        ipc_call_t answer;
+        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_PATHNAME, &answer);
+        int rc = async_data_write_start(ldr->phone_id, (void *) pa, pa_len);
+        if (rc != EOK) {
+                free(pa);
+                async_wait_for(req, NULL);
+                return rc;
+        }
+        async_exch_t *exch = async_exchange_begin(ldr->sess);
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, LOADER_SET_PATHNAME, &answer);
+        sysarg_t rc = async_data_write_start(exch, (void *) pa, pa_len);
+        async_exchange_end(exch);
         free(pa);
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        return (int) retval;
+        if (rc != EOK) {
+                async_wait_for(req, NULL);
+                return (int) rc;
+        }
+        async_wait_for(req, &rc);
+        return (int) rc;
+}
 …
         /* Send serialized arguments to the loader */
+        ipc_call_t answer;
+        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_ARGS, &answer);
+        sysarg_t rc = async_data_write_start(ldr->phone_id, (void *) arg_buf, buffer_size);
+        if (rc != EOK) {
+                async_wait_for(req, NULL);
+                return rc;
+        }
+        async_wait_for(req, &rc);
+        if (rc != EOK)
+                return rc;
+        /* Free temporary buffer */
+        async_exch_t *exch = async_exchange_begin(ldr->sess);
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, LOADER_SET_ARGS, &answer);
+        sysarg_t rc = async_data_write_start(exch, (void *) arg_buf,
+            buffer_size);
+        async_exchange_end(exch);
         free(arg_buf);
+        return EOK;
+        if (rc != EOK) {
+                async_wait_for(req, NULL);
+                return (int) rc;
+        }
+        async_wait_for(req, &rc);
+        return (int) rc;
+}
 …
         /* Send serialized files to the loader */
+        ipc_call_t answer;
+        aid_t req = async_send_0(ldr->phone_id, LOADER_SET_FILES, &answer);
+        sysarg_t rc = async_data_write_start(ldr->phone_id, (void *) files_buf,
+        async_exch_t *exch = async_exchange_begin(ldr->sess);
+        ipc_call_t answer;
+        aid_t req = async_send_0(exch, LOADER_SET_FILES, &answer);
+        sysarg_t rc = async_data_write_start(exch, (void *) files_buf,
             count * sizeof(fdi_node_t));
+        if (rc != EOK) {
+                async_wait_for(req, NULL);
+                return rc;
+        }
+        async_wait_for(req, &rc);
+        if (rc != EOK)
+                return rc;
+        /* Free temporary buffer */
+        async_exchange_end(exch);
         free(files_buf);
+        return EOK;
+        if (rc != EOK) {
+                async_wait_for(req, NULL);
+                return (int) rc;
+        }
+        async_wait_for(req, &rc);
+        return (int) rc;
+}
 …
 int loader_load_program(loader_t *ldr)
+{
+        return (int) async_req_0_0(ldr->phone_id, LOADER_LOAD);
+        async_exch_t *exch = async_exchange_begin(ldr->sess);
+        int rc = async_req_0_0(exch, LOADER_LOAD);
+        async_exchange_end(exch);
+        return rc;
+}
 …
  * the task and its thread is stopped.
+ *
  * After using this function, no further operations must be performed
  * on the loader structure. It should be de-allocated using free().
+ * After using this function, no further operations can be performed
+ * on the loader structure and it is deallocated.
+ *
  * @param ldr Loader connection structure.
 …
 int loader_run(loader_t *ldr)
+{
+        int rc = async_req_0_0(ldr->phone_id, LOADER_RUN);
+        async_exch_t *exch = async_exchange_begin(ldr->sess);
+        int rc = async_req_0_0(exch, LOADER_RUN);
+        async_exchange_end(exch);
         if (rc != EOK)
                 return rc;
+        async_hangup(ldr->phone_id);
+        ldr->phone_id = 0;
+        async_hangup(ldr->sess);
+        free(ldr);
         return EOK;
+}
 …
 /** Cancel the loader session.
+ *
  * Tells the loader not to load any program and terminate.
  * After using this function, no further operations must be performed
  * on the loader structure. It should be de-allocated using free().
+ * Tell the loader not to load any program and terminate.
+ * After using this function, no further operations can be performed
+ * on the loader structure and it is deallocated.
+ *
  * @param ldr Loader connection structure.
 …
 void loader_abort(loader_t *ldr)
+{
         async_hangup(ldr->phone_id);
         ldr->phone_id = 0;
+        async_hangup(ldr->sess);
+        free(ldr);
+}

uspace/lib/c/generic/malloc.c

-              r52a79081
+              ra33f0a6
 #define BASE_ALIGN  16
+/** Heap shrink granularity
+ *
+ * Try not to pump and stress the heap to much
+ * by shrinking and enlarging it too often.
+ * A heap area won't shrunk if it the released
+ * free block is smaller than this constant.
+ *
+ */
+#define SHRINK_GRANULARITY  (64 * PAGE_SIZE)
 /** Overhead of each heap block. */
 #define STRUCT_OVERHEAD \
         (sizeof(heap_block_head_t) + sizeof(heap_block_foot_t))
+/** Overhead of each area. */
+#define AREA_OVERHEAD(size) \
+        (ALIGN_UP(size + sizeof(heap_area_t), BASE_ALIGN))
 /** Calculate real size of a heap block.
+ *
 …
+ *
  */
 #define AREA_FIRST_BLOCK(area) \
+#define AREA_FIRST_BLOCK_HEAD(area) \
         (ALIGN_UP(((uintptr_t) (area)) + sizeof(heap_area_t), BASE_ALIGN))
+/** Get last block in heap area.
+ *
+ */
+#define AREA_LAST_BLOCK_FOOT(area) \
+        (((uintptr_t) (area)->end) - sizeof(heap_block_foot_t))
+/** Get header in heap block.
+ *
+ */
+#define BLOCK_HEAD(foot) \
+        ((heap_block_head_t *) \
+            (((uintptr_t) (foot)) + sizeof(heap_block_foot_t) - (foot)->size))
 /** Get footer in heap block.
 …
 #define BLOCK_FOOT(head) \
         ((heap_block_foot_t *) \
             (((uintptr_t) head) + head->size - sizeof(heap_block_foot_t)))
+            (((uintptr_t) (head)) + (head)->size - sizeof(heap_block_foot_t)))
 /** Heap area.
 …
         void *end;
+        /** Previous heap area */
+        struct heap_area *prev;
         /** Next heap area */
         struct heap_area *next;
 …
 /** Next heap block to examine (next fit algorithm) */
 static heap_block_head_t *next = NULL;
+static heap_block_head_t *next_fit = NULL;
 /** Futex for thread-safe heap manipulation */
 static futex_t malloc_futex = FUTEX_INITIALIZER;
+#ifndef NDEBUG
+#define malloc_assert(expr) \
+        do { \
+                if (!(expr)) {\
+                        futex_up(&malloc_futex); \
+                        assert_abort(#expr, __FILE__, __LINE__); \
+                } \
+        } while (0)
+#else /* NDEBUG */
+#define malloc_assert(expr)
+#endif /* NDEBUG */
 /** Initialize a heap block
 …
         heap_block_head_t *head = (heap_block_head_t *) addr;
         assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
+        malloc_assert(head->magic == HEAP_BLOCK_HEAD_MAGIC);
         heap_block_foot_t *foot = BLOCK_FOOT(head);
         assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
         assert(head->size == foot->size);
+        malloc_assert(foot->magic == HEAP_BLOCK_FOOT_MAGIC);
+        malloc_assert(head->size == foot->size);
+}
 /** Check a heap area structure
+ *
+ * Should be called only inside the critical section.
+ *
  * @param addr Address of the heap area.
+ *
 …
         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);
+        malloc_assert(area->magic == HEAP_AREA_MAGIC);
+        malloc_assert(addr == area->start);
+        malloc_assert(area->start < area->end);
+        malloc_assert(((uintptr_t) area->start % PAGE_SIZE) == 0);
+        malloc_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.
+ * Should be called only inside the critical section.
+ *
+ * @param size Size of the area.
+ *
  */
 …
         area->start = astart;
         area->end = (void *)
             ALIGN_DOWN((uintptr_t) astart + asize, BASE_ALIGN);
+        area->end = (void *) ((uintptr_t) astart + asize);
+        area->prev = NULL;
         area->next = NULL;
         area->magic = HEAP_AREA_MAGIC;
         void *block = (void *) AREA_FIRST_BLOCK(area);
+        void *block = (void *) AREA_FIRST_BLOCK_HEAD(area);
         size_t bsize = (size_t) (area->end - block);
 …
                 last_heap_area = area;
         } else {
+                area->prev = last_heap_area;
                 last_heap_area->next = area;
                 last_heap_area = area;
 …
 /** Try to enlarge a heap area
+ *
+ * Should be called only inside the critical section.
+ *
  * @param area Heap area to grow.
+ * @param size Gross size of item to allocate (bytes).
+ * @param size Gross size to grow (bytes).
+ *
+ * @return True if successful.
+ *
  */
 …
         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);
+        size_t gross_size = (size_t) (area->end - area->start) + size;
+        size_t asize = ALIGN_UP(gross_size, PAGE_SIZE);
+        void *end = (void *) ((uintptr_t) area->start + asize);
         /* Check for overflow */
 …
         /* Add new free block */
+        block_init(area->end, (size_t) (end - area->end), true, area);
+        size_t net_size = (size_t) (end - area->end);
+        if (net_size > 0)
+                block_init(area->end, net_size, true, area);
         /* Update heap area parameters */
 …
 /** Try to enlarge any of the heap areas
+ *
+ * Should be called only inside the critical section.
+ *
  * @param size Gross size of item to allocate (bytes).
+ *
 …
         /* First try to enlarge some existing area */
         heap_area_t *area;
         for (area = first_heap_area; area != NULL; area = area->next) {
+        for (heap_area_t *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
+ *
+        return area_create(AREA_OVERHEAD(size));
+}
+/** Try to shrink heap
+ *
+ * Should be called only inside the critical section.
  * In all cases the next pointer is reset.
+ *
+ */
+static void heap_shrink(void)
+{
+        next = NULL;
+ * @param area Last modified heap area.
+ *
+ */
+static void heap_shrink(heap_area_t *area)
+{
+        area_check(area);
+        heap_block_foot_t *last_foot =
+            (heap_block_foot_t *) AREA_LAST_BLOCK_FOOT(area);
+        heap_block_head_t *last_head = BLOCK_HEAD(last_foot);
+        block_check((void *) last_head);
+        malloc_assert(last_head->area == area);
+        if (last_head->free) {
+                /*
+                 * The last block of the heap area is
+                 * unused. The area might be potentially
+                 * shrunk.
+                 */
+                heap_block_head_t *first_head =
+                    (heap_block_head_t *) AREA_FIRST_BLOCK_HEAD(area);
+                block_check((void *) first_head);
+                malloc_assert(first_head->area == area);
+                size_t shrink_size = ALIGN_DOWN(last_head->size, PAGE_SIZE);
+                if (first_head == last_head) {
+                        /*
+                         * The entire heap area consists of a single
+                         * free heap block. This means we can get rid
+                         * of it entirely.
+                         */
+                        heap_area_t *prev = area->prev;
+                        heap_area_t *next = area->next;
+                        if (prev != NULL) {
+                                area_check(prev);
+                                prev->next = next;
+                        } else
+                                first_heap_area = next;
+                        if (next != NULL) {
+                                area_check(next);
+                                next->prev = prev;
+                        } else
+                                last_heap_area = prev;
+                        as_area_destroy(area->start);
+                } else if (shrink_size >= SHRINK_GRANULARITY) {
+                        /*
+                         * Make sure that we always shrink the area
+                         * by a multiple of page size and update
+                         * the block layout accordingly.
+                         */
+                        size_t asize = (size_t) (area->end - area->start) - shrink_size;
+                        void *end = (void *) ((uintptr_t) area->start + asize);
+                        /* Resize the address space area */
+                        int ret = as_area_resize(area->start, asize, 0);
+                        if (ret != EOK)
+                                abort();
+                        /* Update heap area parameters */
+                        area->end = end;
+                        size_t excess = ((size_t) area->end) - ((size_t) last_head);
+                        if (excess > 0) {
+                                if (excess >= STRUCT_OVERHEAD) {
+                                        /*
+                                         * The previous block cannot be free and there
+                                         * is enough free space left in the area to
+                                         * create a new free block.
+                                         */
+                                        block_init((void *) last_head, excess, true, area);
+                                } else {
+                                        /*
+                                         * The excess is small. Therefore just enlarge
+                                         * the previous block.
+                                         */
+                                        heap_block_foot_t *prev_foot = (heap_block_foot_t *)
+                                            (((uintptr_t) last_head) - sizeof(heap_block_foot_t));
+                                        heap_block_head_t *prev_head = BLOCK_HEAD(prev_foot);
+                                        block_check((void *) prev_head);
+                                        block_init(prev_head, prev_head->size + excess,
+                                            prev_head->free, area);
+                                }
+                        }
+                }
+        }
+        next_fit = NULL;
+}
 …
 static void split_mark(heap_block_head_t *cur, const size_t size)
+{
         assert(cur->size >= size);
+        malloc_assert(cur->size >= size);
         /* See if we should split the block. */
 …
+{
         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;
+        malloc_assert((void *) first_block >= (void *) AREA_FIRST_BLOCK_HEAD(area));
+        malloc_assert((void *) first_block < area->end);
+        for (heap_block_head_t *cur = first_block; (void *) cur < area->end;
             cur = (heap_block_head_t *) (((void *) cur) + cur->size)) {
                 block_check(cur);
 …
                                 split_mark(cur, real_size);
                                 next = cur;
+                                next_fit = cur;
                                 return addr;
                         } else {
 …
                                          * data in (including alignment).
                                          */
                                         if ((void *) cur > (void *) AREA_FIRST_BLOCK(area)) {
+                                        if ((void *) cur > (void *) AREA_FIRST_BLOCK_HEAD(area)) {
                                                 /*
                                                  * There is a block before the current block.
 …
                                                 split_mark(next_head, real_size);
                                                 next = next_head;
+                                                next_fit = next_head;
                                                 return aligned;
                                         } else {
 …
                                                         size_t reduced_size = cur->size - excess;
                                                         cur = (heap_block_head_t *)
                                                             (AREA_FIRST_BLOCK(area) + excess);
+                                                            (AREA_FIRST_BLOCK_HEAD(area) + excess);
                                                         block_init((void *) AREA_FIRST_BLOCK(area), excess,
                                                             true, area);
+                                                        block_init((void *) AREA_FIRST_BLOCK_HEAD(area),
+                                                            excess, true, area);
                                                         block_init(cur, reduced_size, true, area);
                                                         split_mark(cur, real_size);
                                                         next = cur;
+                                                        next_fit = cur;
                                                         return aligned;
+                                                }
 …
 static void *malloc_internal(const size_t size, const size_t align)
+{
         assert(first_heap_area != NULL);
+        malloc_assert(first_heap_area != NULL);
         if (align == 0)
 …
         /* Try the next fit approach */
         split = next;
+        split = next_fit;
         if (split != NULL) {
 …
         /* Search the entire heap */
         heap_area_t *area;
         for (area = first_heap_area; area != NULL; area = area->next) {
+        for (heap_area_t *area = first_heap_area; area != NULL;
+            area = area->next) {
                 heap_block_head_t *first = (heap_block_head_t *)
                     AREA_FIRST_BLOCK(area);
+                    AREA_FIRST_BLOCK_HEAD(area);
                 void *addr = malloc_area(area, first, split, real_size,
 …
         block_check(head);
         assert(!head->free);
+        malloc_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);
+        malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
+        malloc_assert((void *) head < area->end);
         void *ptr = NULL;
 …
                         block_init((void *) head + real_size,
                             orig_size - real_size, true, area);
                         heap_shrink();
+                        heap_shrink(area);
+                }
 …
                         ptr = ((void *) head) + sizeof(heap_block_head_t);
                         next = NULL;
+                        next_fit = NULL;
                 } else
                         reloc = true;
 …
         block_check(head);
         assert(!head->free);
+        malloc_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);
+        malloc_assert((void *) head >= (void *) AREA_FIRST_BLOCK_HEAD(area));
+        malloc_assert((void *) head < area->end);
         /* Mark the block itself as free. */
 …
         /* Look at the previous block. If it is free, merge the two. */
         if ((void *) head > (void *) AREA_FIRST_BLOCK(area)) {
+        if ((void *) head > (void *) AREA_FIRST_BLOCK_HEAD(area)) {
                 heap_block_foot_t *prev_foot =
                     (heap_block_foot_t *) (((void *) head) - sizeof(heap_block_foot_t));
 …
+        }
         heap_shrink();
+        heap_shrink(area);
         futex_up(&malloc_futex);
+}
+void *heap_check(void)
+{
+        futex_down(&malloc_futex);
+        if (first_heap_area == NULL) {
+                futex_up(&malloc_futex);
+                return (void *) -1;
+        }
+        /* Walk all heap areas */
+        for (heap_area_t *area = first_heap_area; area != NULL;
+            area = area->next) {
+                /* Check heap area consistency */
+                if ((area->magic != HEAP_AREA_MAGIC) ||
+                    ((void *) area != area->start) ||
+                    (area->start >= area->end) ||
+                    (((uintptr_t) area->start % PAGE_SIZE) != 0) ||
+                    (((uintptr_t) area->end % PAGE_SIZE) != 0)) {
+                        futex_up(&malloc_futex);
+                        return (void *) area;
+                }
+                /* Walk all heap blocks */
+                for (heap_block_head_t *head = (heap_block_head_t *)
+                    AREA_FIRST_BLOCK_HEAD(area); (void *) head < area->end;
+                    head = (heap_block_head_t *) (((void *) head) + head->size)) {
+                        /* Check heap block consistency */
+                        if (head->magic != HEAP_BLOCK_HEAD_MAGIC) {
+                                futex_up(&malloc_futex);
+                                return (void *) head;
+                        }
+                        heap_block_foot_t *foot = BLOCK_FOOT(head);
+                        if ((foot->magic != HEAP_BLOCK_FOOT_MAGIC) ||
+                            (head->size != foot->size)) {
+                                futex_up(&malloc_futex);
+                                return (void *) foot;
+                        }
+                }
+        }
+        futex_up(&malloc_futex);
+        return NULL;
+}
 /** @}
  */

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

-              r52a79081
+              ra33f0a6
  * timeout occurs.
+ *
  * @param[in] icmp_phone The ICMP module phone used for (semi)remote calls.
+ * @param[in] sess The ICMP session.
  * @param[in] size      The message data length in bytes.
  * @param[in] timeout   The timeout in milliseconds.
 …
  */
 int
 icmp_echo_msg(int icmp_phone, size_t size, mseconds_t timeout, ip_ttl_t ttl,
+icmp_echo_msg(async_sess_t *sess, size_t size, mseconds_t timeout, ip_ttl_t ttl,
     ip_tos_t tos, int dont_fragment, const struct sockaddr *addr,
     socklen_t addrlen)
 …
         if (addrlen <= 0)
                 return EINVAL;
+        message_id = async_send_5(icmp_phone, NET_ICMP_ECHO, size, timeout, ttl,
+        async_exch_t *exch = async_exchange_begin(sess);
+        message_id = async_send_5(exch, NET_ICMP_ECHO, size, timeout, ttl,
             tos, (sysarg_t) dont_fragment, NULL);
         /* Send the address */
+        async_data_write_start(icmp_phone, addr, (size_t) addrlen);
+        async_data_write_start(exch, addr, (size_t) addrlen);
+        async_exchange_end(exch);
         async_wait_for(message_id, &result);

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

r52a79081	ra33f0a6
45	45	/** Connect to the ICMP module.
46	46	*
47		* @param[in] timeout Connection timeout in microseconds, zero
48		* for no timeout.
49		*
50		* @return ICMP module phone on success.
51		* @return ETIMEOUT if the connection timeouted.
	47	* @return ICMP module session.
52	48	*
53	49	*/
54		~~int icmp_connect_module(suseconds_t timeout~~)
	50	async_sess_t *icmp_connect_module(void)
55	51	{
56		return connect_to_service~~_timeout(SERVICE_ICMP, timeout~~);
	52	return connect_to_service(SERVICE_ICMP);
57	53	}
58	54

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

-              r52a79081
+              ra33f0a6
 #include <ipc/services.h>
 #include <net/modules.h>
+/** The time between connect requests in microseconds. */
+#define MODULE_WAIT_TIME        (10 * 1000)
+#include <ns.h>
 /** Answer a call.
 …
+}
 /** Create bidirectional connection with the needed module service and registers
+/** Create bidirectional connection with the needed module service and register
  * the message receiver.
+ *
+ * @param[in] need      The needed module service.
+ * @param[in] arg1      The first parameter.
+ * @param[in] arg2      The second parameter.
+ * @param[in] arg3      The third parameter.
+ * @param[in] client_receiver The message receiver.
+ *
+ * @return              The phone of the needed service.
+ * @return              Other error codes as defined for the ipc_connect_to_me()
+ *                      function.
+ */
+int bind_service(services_t need, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
+    async_client_conn_t client_receiver)
+{
+        return bind_service_timeout(need, arg1, arg2, arg3, client_receiver, 0);
+}
+/** Create bidirectional connection with the needed module service and registers
+ * the message receiver.
+ *
+ * @param[in] need      The needed module service.
+ * @param[in] arg1      The first parameter.
+ * @param[in] arg2      The second parameter.
+ * @param[in] arg3      The third parameter.
+ * @param[in] client_receiver The message receiver.
+ * @param[in] timeout   The connection timeout in microseconds. No timeout if
+ *                      set to zero (0).
+ *
+ * @return              The phone of the needed service.
+ * @return              ETIMEOUT if the connection timeouted.
+ * @return              Other error codes as defined for the ipc_connect_to_me()
+ *                      function.
+ *
+ */
+int bind_service_timeout(services_t need, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3, async_client_conn_t client_receiver, suseconds_t timeout)
+ * @param[in] need            Needed module service.
+ * @param[in] arg1            First parameter.
+ * @param[in] arg2            Second parameter.
+ * @param[in] arg3            Third parameter.
+ * @param[in] client_receiver Message receiver.
+ *
+ * @return Session to the needed service.
+ * @return Other error codes as defined for the async_connect_to_me()
+ *         function.
+ *
+ */
+async_sess_t *bind_service(services_t need, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3, async_client_conn_t client_receiver)
+{
         /* Connect to the needed service */
         int phone = connect_to_service_timeout(need, timeout);
         if (phone >= 0) {
+        async_sess_t *sess = connect_to_service(need);
+        if (sess != NULL) {
                 /* Request the bidirectional connection */
+                int rc = async_connect_to_me(phone, arg1, arg2, arg3, client_receiver);
+                async_exch_t *exch = async_exchange_begin(sess);
+                int rc = async_connect_to_me(exch, arg1, arg2, arg3,
+                    client_receiver, NULL);
+                async_exchange_end(exch);
                 if (rc != EOK) {
+                        async_hangup(phone);
+                        return rc;
+                        async_hangup(sess);
+                        errno = rc;
+                        return NULL;
+                }
+        }
+        return phone;
+}
+/** Connects to the needed module.
+ *
+ * @param[in] need      The needed module service.
+ * @return              The phone of the needed service.
+ */
+int connect_to_service(services_t need)
+{
+        return connect_to_service_timeout(need, 0);
+}
+/** Connects to the needed module.
+ *
+ *  @param[in] need     The needed module service.
+ *  @param[in] timeout  The connection timeout in microseconds. No timeout if
+ *                      set to zero (0).
+ *  @return             The phone of the needed service.
+ *  @return             ETIMEOUT if the connection timeouted.
+ */
+int connect_to_service_timeout(services_t need, suseconds_t timeout)
+{
+        int phone;
+        /* If no timeout is set */
+        if (timeout <= 0)
+                return async_connect_me_to_blocking(PHONE_NS, need, 0, 0);
+        while (true) {
+                phone = async_connect_me_to(PHONE_NS, need, 0, 0);
+                if ((phone >= 0) || (phone != ENOENT))
+                        return phone;
+                /* Abort if no time is left */
+                if (timeout <= 0)
+                        return ETIMEOUT;
+                /* Wait the minimum of the module wait time and the timeout */
+                usleep((timeout <= MODULE_WAIT_TIME) ?
+                    timeout : MODULE_WAIT_TIME);
+                timeout -= MODULE_WAIT_TIME;
+        }
+}
+/** Replies the data to the other party.
+ *
+ * @param[in] data      The data buffer to be sent.
+        return sess;
+}
+/** Connect to the needed module.
+ *
+ * @param[in] need Needed module service.
+ *
+ * @return Session to the needed service.
+ * @return NULL if the connection timeouted.
+ *
+ */
+async_sess_t *connect_to_service(services_t need)
+{
+        return service_connect_blocking(EXCHANGE_SERIALIZE, need, 0, 0);
+}
+/** Reply the data to the other party.
+ *
+ * @param[in] data        The data buffer to be sent.
  * @param[in] data_length The buffer length.
+ * @return              EOK on success.
+ * @return              EINVAL if the client does not expect the data.
+ * @return              EOVERFLOW if the client does not expect all the data.
+ *                      Only partial data are transfered.
+ * @return              Other error codes as defined for the
+ *                      async_data_read_finalize() function.
+ *
+ * @return EOK on success.
+ * @return EINVAL if the client does not expect the data.
+ * @return EOVERFLOW if the client does not expect all the data.
+ *         Only partial data are transfered.
+ * @return Other error codes as defined for the
+ *         async_data_read_finalize() function.
+ *
  */
 int data_reply(void *data, size_t data_length)
 …
         size_t length;
         ipc_callid_t callid;
         /* Fetch the request */
         if (!async_data_read_receive(&callid, &length))
                 return EINVAL;
         /* Check the requested data size */
         if (length < data_length) {
 …
                 return EOVERFLOW;
+        }
         /* Send the data */
         return async_data_read_finalize(callid, data, data_length);

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

-              r52a79081
+              ra33f0a6
 #define SOCKET_MAX_ACCEPTED_SIZE        0
-/** Default timeout for connections in microseconds. */
-#define SOCKET_CONNECT_TIMEOUT  (1 * 1000 * 1000)
 /**
  * Maximum number of random attempts to find a new socket identifier before
 …
         /** Socket identifier. */
         int socket_id;
         /** Parent module phone. */
         int phone;
+        /** Parent module session. */
+        async_sess_t *sess;
         /** Parent module service. */
         services_t service;
 …
 /** Socket client library global data. */
 static struct socket_client_globals {
+        /** TCP module phone. */
+        int tcp_phone;
+        /** UDP module phone. */
+        int udp_phone;
+//      /** The last socket identifier.
+//       */
+//      int last_id;
+        /** TCP module session. */
+        async_sess_t *tcp_sess;
+        /** UDP module session. */
+        async_sess_t *udp_sess;
         /** Active sockets. */
 …
         fibril_rwlock_t lock;
 } socket_globals = {
+        .tcp_phone = -1,
+        .udp_phone = -1,
+//      .last_id = 0,
+        .tcp_sess = NULL,
+        .udp_sess = NULL,
         .sockets = NULL,
         .lock = FIBRIL_RWLOCK_INITIALIZER(socket_globals.lock)
 …
  * @param[in] iid       The initial message identifier.
  * @param[in] icall     The initial message call structure.
+ */
+static void socket_connection(ipc_callid_t iid, ipc_call_t * icall)
+ * @param[in] arg       Local argument.
+ */
+static void socket_connection(ipc_callid_t iid, ipc_call_t * icall, void *arg)
+{
         ipc_callid_t callid;
 …
+}
+/** Returns the TCP module phone.
+ *
+ * Connects to the TCP module if necessary.
+ *
+ * @return              The TCP module phone.
+ * @return              Other error codes as defined for the
+ *                      bind_service_timeout() function.
+ */
+static int socket_get_tcp_phone(void)
+{
+        if (socket_globals.tcp_phone < 0) {
+                socket_globals.tcp_phone = bind_service_timeout(SERVICE_TCP,
+, 0, SERVICE_TCP, socket_connection,
+                    SOCKET_CONNECT_TIMEOUT);
+        }
+        return socket_globals.tcp_phone;
+}
+/** Returns the UDP module phone.
+ *
+ * Connects to the UDP module if necessary.
+ *
+ * @return              The UDP module phone.
+ * @return              Other error codes as defined for the
+ *                      bind_service_timeout() function.
+ */
+static int socket_get_udp_phone(void)
+{
+        if (socket_globals.udp_phone < 0) {
+                socket_globals.udp_phone = bind_service_timeout(SERVICE_UDP,
+, 0, SERVICE_UDP, socket_connection,
+                    SOCKET_CONNECT_TIMEOUT);
+        }
+        return socket_globals.udp_phone;
+/** Return the TCP module session.
+ *
+ * Connect to the TCP module if necessary.
+ *
+ * @return The TCP module session.
+ *
+ */
+static async_sess_t *socket_get_tcp_sess(void)
+{
+        if (socket_globals.tcp_sess == NULL) {
+                socket_globals.tcp_sess = bind_service(SERVICE_TCP,
+, 0, SERVICE_TCP, socket_connection);
+        }
+        return socket_globals.tcp_sess;
+}
+/** Return the UDP module session.
+ *
+ * Connect to the UDP module if necessary.
+ *
+ * @return The UDP module session.
+ *
+ */
+static async_sess_t *socket_get_udp_sess(void)
+{
+        if (socket_globals.udp_sess == NULL) {
+                socket_globals.udp_sess = bind_service(SERVICE_UDP,
+, 0, SERVICE_UDP, socket_connection);
+        }
+        return socket_globals.udp_sess;
+}
 …
         sockets = socket_get_sockets();
         count = 0;
-//      socket_id = socket_globals.last_id;
         do {
 …
                         if (socket_id < INT_MAX) {
                                 ++socket_id;
+/*                      } else if(socket_globals.last_id) {
+ *                              socket_globals.last_id = 0;
+ *                              socket_id = 1;
+ */                     } else {
+                        } else {
                                 return ELIMIT;
+                        }
+                }
         } while (sockets_find(sockets, socket_id));
+//      last_id = socket_id
         return socket_id;
+}
 …
+ *
  * @param[in,out] socket The socket to be initialized.
+ * @param[in] socket_id The new socket identifier.
+ * @param[in] phone     The parent module phone.
+ * @param[in] service   The parent module service.
+ */
+static void
+socket_initialize(socket_t *socket, int socket_id, int phone,
+    services_t service)
+ * @param[in] socket_id  The new socket identifier.
+ * @param[in] sess       The parent module session.
+ * @param[in] service    The parent module service.
+ */
+static void socket_initialize(socket_t *socket, int socket_id,
+    async_sess_t *sess, services_t service)
+{
         socket->socket_id = socket_id;
         socket->phone = phone;
+        socket->sess = sess;
         socket->service = service;
         dyn_fifo_initialize(&socket->received, SOCKET_INITIAL_RECEIVED_SIZE);
 …
  * @return              Other error codes as defined for the NET_SOCKET message.
  * @return              Other error codes as defined for the
  *                      bind_service_timeout() function.
+ *                      bind_service() function.
  */
 int socket(int domain, int type, int protocol)
+{
         socket_t *socket;
         int phone;
+        async_sess_t *sess;
         int socket_id;
         services_t service;
 …
                         switch (protocol) {
                         case IPPROTO_TCP:
                                 phone = socket_get_tcp_phone();
+                                sess = socket_get_tcp_sess();
                                 service = SERVICE_TCP;
                                 break;
 …
                         switch (protocol) {
                         case IPPROTO_UDP:
                                 phone = socket_get_udp_phone();
+                                sess = socket_get_udp_sess();
                                 service = SERVICE_UDP;
                                 break;
 …
+        }
         if (phone < 0)
                 return phone;
+        if (sess == NULL)
+                return ENOENT;
         /* Create a new socket structure */
 …
                 return socket_id;
+        }
+        rc = (int) async_req_3_3(phone, NET_SOCKET, socket_id, 0, service, NULL,
+        async_exch_t *exch = async_exchange_begin(sess);
+        rc = (int) async_req_3_3(exch, NET_SOCKET, socket_id, 0, service, NULL,
             &fragment_size, &header_size);
+        async_exchange_end(exch);
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&socket_globals.lock);
 …
         /* Finish the new socket initialization */
         socket_initialize(socket, socket_id, phone, service);
+        socket_initialize(socket, socket_id, sess, service);
         /* Store the new socket */
         rc = sockets_add(socket_get_sockets(), socket_id, socket);
 …
                 dyn_fifo_destroy(&socket->accepted);
                 free(socket);
+                async_msg_3(phone, NET_SOCKET_CLOSE, (sysarg_t) socket_id, 0,
+                exch = async_exchange_begin(sess);
+                async_msg_3(exch, NET_SOCKET_CLOSE, (sysarg_t) socket_id, 0,
                     service);
+                async_exchange_end(exch);
                 return rc;
+        }
 …
         /* Request the message */
+        message_id = async_send_3(socket->phone, message,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        message_id = async_send_3(exch, message,
             (sysarg_t) socket->socket_id, arg2, socket->service, NULL);
         /* Send the address */
+        async_data_write_start(socket->phone, data, datalength);
+        async_data_write_start(exch, data, datalength);
+        async_exchange_end(exch);
         fibril_rwlock_read_unlock(&socket_globals.lock);
 …
         /* Request listen backlog change */
+        result = (int) async_req_3_0(socket->phone, NET_SOCKET_LISTEN,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        result = (int) async_req_3_0(exch, NET_SOCKET_LISTEN,
             (sysarg_t) socket->socket_id, (sysarg_t) backlog, socket->service);
+        async_exchange_end(exch);
         fibril_rwlock_read_unlock(&socket_globals.lock);
 …
                 return socket_id;
+        }
         socket_initialize(new_socket, socket_id, socket->phone,
+        socket_initialize(new_socket, socket_id, socket->sess,
             socket->service);
         result = sockets_add(socket_get_sockets(), new_socket->socket_id,
 …
         /* Request accept */
+        message_id = async_send_5(socket->phone, NET_SOCKET_ACCEPT,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        message_id = async_send_5(exch, NET_SOCKET_ACCEPT,
             (sysarg_t) socket->socket_id, 0, socket->service, 0,
             new_socket->socket_id, &answer);
         /* Read address */
+        async_data_read_start(socket->phone, cliaddr, *addrlen);
+        async_data_read_start(exch, cliaddr, *addrlen);
+        async_exchange_end(exch);
         fibril_rwlock_write_unlock(&socket_globals.lock);
         async_wait_for(message_id, &ipc_result);
 …
         /* Request close */
+        rc = (int) async_req_3_0(socket->phone, NET_SOCKET_CLOSE,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        rc = (int) async_req_3_0(exch, NET_SOCKET_CLOSE,
             (sysarg_t) socket->socket_id, 0, socket->service);
+        async_exchange_end(exch);
         if (rc != EOK) {
                 fibril_rwlock_write_unlock(&socket_globals.lock);
 …
         /* Request send */
+        message_id = async_send_5(socket->phone, message,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        message_id = async_send_5(exch, message,
             (sysarg_t) socket->socket_id,
             (fragments == 1 ? datalength : socket->data_fragment_size),
 …
         /* Send the address if given */
         if (!toaddr ||
             (async_data_write_start(socket->phone, toaddr, addrlen) == EOK)) {
+            (async_data_write_start(exch, toaddr, addrlen) == EOK)) {
                 if (fragments == 1) {
                         /* Send all if only one fragment */
                         async_data_write_start(socket->phone, data, datalength);
+                        async_data_write_start(exch, data, datalength);
                 } else {
                         /* Send the first fragment */
                         async_data_write_start(socket->phone, data,
+                        async_data_write_start(exch, data,
                             socket->data_fragment_size - socket->header_size);
                         data = ((const uint8_t *) data) +
 …
                         /* Send the middle fragments */
                         while (--fragments > 1) {
                                 async_data_write_start(socket->phone, data,
+                                async_data_write_start(exch, data,
                                     socket->data_fragment_size);
                                 data = ((const uint8_t *) data) +
 …
                         /* Send the last fragment */
                         async_data_write_start(socket->phone, data,
+                        async_data_write_start(exch, data,
                             (datalength + socket->header_size) %
                             socket->data_fragment_size);
+                }
+        }
+        async_exchange_end(exch);
         async_wait_for(message_id, &result);
 …
                 return 0;
+        }
+        async_exch_t *exch = async_exchange_begin(socket->sess);
         /* Prepare lengths if more fragments */
 …
                 /* Request packet data */
                 message_id = async_send_4(socket->phone, message,
+                message_id = async_send_4(exch, message,
                     (sysarg_t) socket->socket_id, 0, socket->service,
                     (sysarg_t) flags, &answer);
 …
                 /* Read the address if desired */
                 if(!fromaddr ||
                     (async_data_read_start(socket->phone, fromaddr,
+                    (async_data_read_start(exch, fromaddr,
                     *addrlen) == EOK)) {
                         /* Read the fragment lengths */
                         if (async_data_read_start(socket->phone, lengths,
+                        if (async_data_read_start(exch, lengths,
                             sizeof(int) * (fragments + 1)) == EOK) {
                                 if (lengths[fragments] <= datalength) {
 …
                                         for (index = 0; index < fragments;
                                             ++index) {
+                                                async_data_read_start(
+                                                    socket->phone, data,
+                                                async_data_read_start(exch, data,
                                                     lengths[index]);
                                                 data = ((uint8_t *) data) +
 …
         } else { /* fragments == 1 */
                 /* Request packet data */
                 message_id = async_send_4(socket->phone, message,
+                message_id = async_send_4(exch, message,
                     (sysarg_t) socket->socket_id, 0, socket->service,
                     (sysarg_t) flags, &answer);
 …
                 /* Read the address if desired */
                 if (!fromaddr ||
+                    (async_data_read_start(socket->phone, fromaddr,
+                        *addrlen) == EOK)) {
+                    (async_data_read_start(exch, fromaddr, *addrlen) == EOK)) {
                         /* Read all if only one fragment */
                         async_data_read_start(socket->phone, data, datalength);
+                        async_data_read_start(exch, data, datalength);
+                }
+        }
+        async_exchange_end(exch);
         async_wait_for(message_id, &ipc_result);
 …
         /* Request option value */
+        message_id = async_send_3(socket->phone, NET_SOCKET_GETSOCKOPT,
+        async_exch_t *exch = async_exchange_begin(socket->sess);
+        message_id = async_send_3(exch, NET_SOCKET_GETSOCKOPT,
             (sysarg_t) socket->socket_id, (sysarg_t) optname, socket->service,
             NULL);
         /* Read the length */
         if (async_data_read_start(socket->phone, optlen,
+        if (async_data_read_start(exch, optlen,
             sizeof(*optlen)) == EOK) {
                 /* Read the value */
+                async_data_read_start(socket->phone, value, *optlen);
+        }
+                async_data_read_start(exch, value, *optlen);
+        }
+        async_exchange_end(exch);
         fibril_rwlock_read_unlock(&socket_globals.lock);

uspace/lib/c/generic/ns_obsolete.c

-              r52a79081
+              ra33f0a6
 #include <async.h>
+#include <ipc/ns.h>
+#include <async_obsolete.h>
+#include <ns_obsolete.h>
+#include <kernel/ipc/ipc_methods.h>
 int service_register(sysarg_t service)
+int service_obsolete_connect(sysarg_t service, sysarg_t arg2, sysarg_t arg3)
+{
         return async_connect_to_me(PHONE_NS, service, 0, 0, NULL);
+        return async_obsolete_connect_me_to(PHONE_NS, service, arg2, arg3);
+}
 int service_connect(sysarg_t service, sysarg_t arg2, sysarg_t arg3)
+int service_obsolete_connect_blocking(sysarg_t service, sysarg_t arg2, sysarg_t arg3)
+{
+        return async_connect_me_to(PHONE_NS, service, arg2, arg3);
+}
+int service_connect_blocking(sysarg_t service, sysarg_t arg2, sysarg_t arg3)
+{
+        return async_connect_me_to_blocking(PHONE_NS, service, arg2, arg3);
+        return async_obsolete_connect_me_to_blocking(PHONE_NS, service, arg2, arg3);
+}

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

-              r52a79081
+              ra33f0a6
 } awaiter_t;
+/** Message data */
+typedef struct {
+        awaiter_t wdata;
+        /** If reply was received. */
+        bool done;
+        /** Pointer to where the answer data is stored. */
+        ipc_call_t *dataptr;
+        sysarg_t retval;
+} amsg_t;
 extern void __async_init(void);
 extern void async_insert_timeout(awaiter_t *);
+extern void reply_received(void *, int, ipc_call_t *);
 #endif

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

-              r52a79081
+              ra33f0a6
  */
 #ifndef LIBC_PRIVATE_ASYNC_SESS_H_
 #define LIBC_PRIVATE_ASYNC_SESS_H_
+#ifndef LIBC_PRIVATE_NS_H_
+#define LIBC_PRIVATE_NS_H_
+extern void __async_sess_init(void);
+#include <async.h>
+extern async_sess_t *session_ns;
 #endif

uspace/lib/c/generic/str.c

-              r52a79081
+              ra33f0a6
         dstr_size = str_size(dest);
+        if (dstr_size >= size)
+                return;
         str_cpy(dest + dstr_size, size - dstr_size, src);
+}
+/** Convert space-padded ASCII to string.
+ *
+ * Common legacy text encoding in hardware is 7-bit ASCII fitted into
+ * a fixed-with byte buffer (bit 7 always zero), right-padded with spaces
+ * (ASCII 0x20). Convert space-padded ascii to string representation.
+ *
+ * If the text does not fit into the destination buffer, the function converts
+ * as many characters as possible and returns EOVERFLOW.
+ *
+ * If the text contains non-ASCII bytes (with bit 7 set), the whole string is
+ * converted anyway and invalid characters are replaced with question marks
+ * (U_SPECIAL) and the function returns EIO.
+ *
+ * Regardless of return value upon return @a dest will always be well-formed.
+ *
+ * @param dest          Destination buffer
+ * @param size          Size of destination buffer
+ * @param src           Space-padded ASCII.
+ * @param n             Size of the source buffer in bytes.
+ *
+ * @return              EOK on success, EOVERFLOW if the text does not fit
+ *                      destination buffer, EIO if the text contains
+ *                      non-ASCII bytes.
+ */
+int spascii_to_str(char *dest, size_t size, const uint8_t *src, size_t n)
+{
+        size_t sidx;
+        size_t didx;
+        size_t dlast;
+        uint8_t byte;
+        int rc;
+        int result;
+        /* There must be space for a null terminator in the buffer. */
+        assert(size > 0);
+        result = EOK;
+        didx = 0;
+        dlast = 0;
+        for (sidx = 0; sidx < n; ++sidx) {
+                byte = src[sidx];
+                if (!ascii_check(byte)) {
+                        byte = U_SPECIAL;
+                        result = EIO;
+                }
+                rc = chr_encode(byte, dest, &didx, size - 1);
+                if (rc != EOK) {
+                        assert(rc == EOVERFLOW);
+                        dest[didx] = '\0';
+                        return rc;
+                }
+                /* Remember dest index after last non-empty character */
+                if (byte != 0x20)
+                        dlast = didx;
+        }
+        /* Terminate string after last non-empty character */
+        dest[dlast] = '\0';
+        return result;
+}

uspace/lib/c/generic/str_error.c

-              r52a79081
+              ra33f0a6
  */
+#include <errno.h>
 #include <str_error.h>
 #include <stdio.h>
 …
 static fibril_local char noerr[NOERR_LEN];
 const char *str_error(const int errno)
+const char *str_error(const int e)
+{
         if ((errno <= 0) && (errno >= MIN_ERRNO))
                 return err_desc[-errno];
+        if ((e <= 0) && (e >= MIN_ERRNO))
+                return err_desc[-e];
+        snprintf(noerr, NOERR_LEN, "Unkown error code %d", errno);
+        /* Ad hoc descriptions of error codes interesting for USB. */
+        // FIXME: integrate these as first-class error values
+        switch (e) {
+                case EBADCHECKSUM:
+                        return "Bad checksum";
+                case ESTALL:
+                        return "Operation stalled";
+                case EAGAIN:
+                        return "Resource temporarily unavailable";
+                case EEMPTY:
+                        return "Resource is empty";
+                default:
+                        break;
+        }
+        snprintf(noerr, NOERR_LEN, "Unkown error code %d", e);
         return noerr;
+}

uspace/lib/c/generic/task.c

-              r52a79081
+              ra33f0a6
 #include <task.h>
-#include <libc.h>
-#include <stdlib.h>
-#include <errno.h>
 #include <loader/loader.h>
 #include <stdarg.h>
 …
 #include <ipc/ns.h>
 #include <macros.h>
+#include <assert.h>
 #include <async.h>
+#include <errno.h>
+#include <malloc.h>
+#include <libc.h>
+#include "private/ns.h"
 task_id_t task_get_id(void)
 …
 int task_set_name(const char *name)
+{
+        assert(name);
         return __SYSCALL2(SYS_TASK_SET_NAME, (sysarg_t) name, str_size(name));
+}
 …
  * loader API. Arguments are passed as a null-terminated array of strings.
+ *
+ * @param id    If not NULL, the ID of the task is stored here on success.
+ * @param path  Pathname of the binary to execute.
+ * @param argv  Command-line arguments.
+ *
+ * @return      Zero on success or negative error code.
+ * @param id   If not NULL, the ID of the task is stored here on success.
+ * @param path Pathname of the binary to execute.
+ * @param argv Command-line arguments.
+ *
+ * @return Zero on success or negative error code.
+ *
  */
 int task_spawnv(task_id_t *id, const char *path, const char *const args[])
+{
-        loader_t *ldr;
-        task_id_t task_id;
-        int rc;
-        /* Connect to a program loader. */
-        ldr = loader_connect();
-        if (ldr == NULL)
-                return EREFUSED;
-        /* Get task ID. */
-        rc = loader_get_task_id(ldr, &task_id);
-        if (rc != EOK)
-                goto error;
-        /* Send spawner's current working directory. */
-        rc = loader_set_cwd(ldr);
-        if (rc != EOK)
-                goto error;
-        /* Send program pathname. */
-        rc = loader_set_pathname(ldr, path);
-        if (rc != EOK)
-                goto error;
-        /* Send arguments. */
-        rc = loader_set_args(ldr, args);
-        if (rc != EOK)
-                goto error;
         /* Send default files */
         fdi_node_t *files[4];
 …
         files[3] = NULL;
+        return task_spawnvf(id, path, args, files);
+}
+/** Create a new task by running an executable from the filesystem.
+ *
+ * This is really just a convenience wrapper over the more complicated
+ * loader API. Arguments are passed as a null-terminated array of strings.
+ * Files are passed as null-terminated array of pointers to fdi_node_t.
+ *
+ * @param id    If not NULL, the ID of the task is stored here on success.
+ * @param path  Pathname of the binary to execute.
+ * @param argv  Command-line arguments.
+ * @param files Standard files to use.
+ *
+ * @return Zero on success or negative error code.
+ *
+ */
+int task_spawnvf(task_id_t *id, const char *path, const char *const args[],
+    fdi_node_t *const files[])
+{
+        /* Connect to a program loader. */
+        loader_t *ldr = loader_connect();
+        if (ldr == NULL)
+                return EREFUSED;
+        /* Get task ID. */
+        task_id_t task_id;
+        int rc = loader_get_task_id(ldr, &task_id);
+        if (rc != EOK)
+                goto error;
+        /* Send spawner's current working directory. */
+        rc = loader_set_cwd(ldr);
+        if (rc != EOK)
+                goto error;
+        /* Send program pathname. */
+        rc = loader_set_pathname(ldr, path);
+        if (rc != EOK)
+                goto error;
+        /* Send arguments. */
+        rc = loader_set_args(ldr, args);
+        if (rc != EOK)
+                goto error;
+        /* Send files */
         rc = loader_set_files(ldr, files);
         if (rc != EOK)
 …
         /* Success */
-        free(ldr);
         if (id != NULL)
                 *id = task_id;
 …
         /* Error exit */
         loader_abort(ldr);
-        free(ldr);
         return rc;
+}
 …
  * loader API. Arguments are passed as a null-terminated list of arguments.
+ *
+ * @param id    If not NULL, the ID of the task is stored here on success.
+ * @param path  Pathname of the binary to execute.
+ * @param ...   Command-line arguments.
+ *
+ * @return      Zero on success or negative error code.
+ * @param id   If not NULL, the ID of the task is stored here on success.
+ * @param path Pathname of the binary to execute.
+ * @param ...  Command-line arguments.
+ *
+ * @return Zero on success or negative error code.
+ *
  */
 int task_spawnl(task_id_t *task_id, const char *path, ...)
+{
+        /* Count the number of arguments. */
         va_list ap;
-        int rc, cnt;
         const char *arg;
         const char **arglist;
+        /* Count the number of arguments. */
+        cnt = 0;
+        int cnt = 0;
         va_start(ap, path);
         do {
 …
         } while (arg != NULL);
         va_end(ap);
         /* Allocate argument list. */
         arglist = malloc(cnt * sizeof(const char *));
         if (arglist == NULL)
                 return ENOMEM;
         /* Fill in arguments. */
         cnt = 0;
 …
         } while (arg != NULL);
         va_end(ap);
         /* Spawn task. */
         rc = task_spawnv(task_id, path, arglist);
+        int rc = task_spawnv(task_id, path, arglist);
         /* Free argument list. */
         free(arglist);
 …
 int task_wait(task_id_t id, task_exit_t *texit, int *retval)
+{
+        assert(texit);
+        assert(retval);
+        async_exch_t *exch = async_exchange_begin(session_ns);
         sysarg_t te, rv;
+        int rc;
+        rc = (int) async_req_2_2(PHONE_NS, NS_TASK_WAIT, LOWER32(id),
+        int rc = (int) async_req_2_2(exch, NS_TASK_WAIT, LOWER32(id),
             UPPER32(id), &te, &rv);
+        async_exchange_end(exch);
         *texit = te;
         *retval = rv;
         return rc;
+}
 …
 int task_retval(int val)
+{
+        return (int) async_req_1_0(PHONE_NS, NS_RETVAL, val);
+        async_exch_t *exch = async_exchange_begin(session_ns);
+        int rc = (int) async_req_1_0(exch, NS_RETVAL, val);
+        async_exchange_end(exch);
+        return rc;
+}

uspace/lib/c/generic/thread.c

r52a79081	ra33f0a6
44	44
45	45	#ifndef THREAD_INITIAL_STACK_PAGES_NO
46		#define THREAD_INITIAL_STACK_PAGES_NO 1
	46	#define THREAD_INITIAL_STACK_PAGES_NO 2
47	47	#endif
48	48

uspace/lib/c/generic/time.c

r52a79081	ra33f0a6
207	207	}
208	208
	209	void udelay(useconds_t time)
	210	{
	211	(void) __SYSCALL1(SYS_THREAD_UDELAY, (sysarg_t) time);
	212	}
	213
	214
209	215	/** Wait unconditionally for specified number of seconds
210	216	*

uspace/lib/c/generic/udebug.c

-              r52a79081
+              ra33f0a6
 #include <udebug.h>
 #include <sys/types.h>
+#include <kernel/ipc/ipc_methods.h>
 #include <async.h>
 int udebug_begin(int phoneid)
+int udebug_begin(async_sess_t *sess)
+{
+        return async_req_1_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_BEGIN);
+        async_exch_t *exch = async_exchange_begin(sess);
+        return async_req_1_0(exch, IPC_M_DEBUG, UDEBUG_M_BEGIN);
+}
 int udebug_end(int phoneid)
+int udebug_end(async_sess_t *sess)
+{
+        return async_req_1_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_END);
+        async_exch_t *exch = async_exchange_begin(sess);
+        return async_req_1_0(exch, IPC_M_DEBUG, UDEBUG_M_END);
+}
 int udebug_set_evmask(int phoneid, udebug_evmask_t mask)
+int udebug_set_evmask(async_sess_t *sess, udebug_evmask_t mask)
+{
         return async_req_2_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_SET_EVMASK,
                 mask);
+        async_exch_t *exch = async_exchange_begin(sess);
+        return async_req_2_0(exch, IPC_M_DEBUG, UDEBUG_M_SET_EVMASK, mask);
+}
 int udebug_thread_read(int phoneid, void *buffer, size_t n,
         size_t *copied, size_t *needed)
+int udebug_thread_read(async_sess_t *sess, void *buffer, size_t n,
+    size_t *copied, size_t *needed)
+{
         sysarg_t a_copied, a_needed;
         int rc;
         rc = async_req_3_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_THREAD_READ,
                 (sysarg_t)buffer, n, NULL, &a_copied, &a_needed);
         *copied = (size_t)a_copied;
         *needed = (size_t)a_needed;
+        async_exch_t *exch = async_exchange_begin(sess);
+        int rc = async_req_3_3(exch, IPC_M_DEBUG, UDEBUG_M_THREAD_READ,
+            (sysarg_t) buffer, n, NULL, &a_copied, &a_needed);
+        *copied = (size_t) a_copied;
+        *needed = (size_t) a_needed;
         return rc;
+}
 int udebug_name_read(int phoneid, void *buffer, size_t n,
         size_t *copied, size_t *needed)
+int udebug_name_read(async_sess_t *sess, void *buffer, size_t n,
+    size_t *copied, size_t *needed)
+{
         sysarg_t a_copied, a_needed;
         int rc;
         rc = async_req_3_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_NAME_READ,
                 (sysarg_t)buffer, n, NULL, &a_copied, &a_needed);
         *copied = (size_t)a_copied;
         *needed = (size_t)a_needed;
+        async_exch_t *exch = async_exchange_begin(sess);
+        int rc = async_req_3_3(exch, IPC_M_DEBUG, UDEBUG_M_NAME_READ,
+            (sysarg_t) buffer, n, NULL, &a_copied, &a_needed);
+        *copied = (size_t) a_copied;
+        *needed = (size_t) a_needed;
         return rc;
+}
 int udebug_areas_read(int phoneid, void *buffer, size_t n,
         size_t *copied, size_t *needed)
+int udebug_areas_read(async_sess_t *sess, void *buffer, size_t n,
+    size_t *copied, size_t *needed)
+{
         sysarg_t a_copied, a_needed;
         int rc;
         rc = async_req_3_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_AREAS_READ,
                 (sysarg_t)buffer, n, NULL, &a_copied, &a_needed);
         *copied = (size_t)a_copied;
         *needed = (size_t)a_needed;
+        async_exch_t *exch = async_exchange_begin(sess);
+        int rc = async_req_3_3(exch, IPC_M_DEBUG, UDEBUG_M_AREAS_READ,
+            (sysarg_t) buffer, n, NULL, &a_copied, &a_needed);
+        *copied = (size_t) a_copied;
+        *needed = (size_t) a_needed;
         return rc;
+}
 int udebug_mem_read(int phoneid, void *buffer, uintptr_t addr, size_t n)
+int udebug_mem_read(async_sess_t *sess, void *buffer, uintptr_t addr, size_t n)
+{
+        return async_req_4_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_MEM_READ,
+            (sysarg_t)buffer, addr, n);
+        async_exch_t *exch = async_exchange_begin(sess);
+        return async_req_4_0(exch, IPC_M_DEBUG, UDEBUG_M_MEM_READ,
+            (sysarg_t) buffer, addr, n);
+}
 int udebug_args_read(int phoneid, thash_t tid, sysarg_t *buffer)
+int udebug_args_read(async_sess_t *sess, thash_t tid, sysarg_t *buffer)
+{
+        return async_req_3_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_ARGS_READ,
+            tid, (sysarg_t)buffer);
+        async_exch_t *exch = async_exchange_begin(sess);
+        return async_req_3_0(exch, IPC_M_DEBUG, UDEBUG_M_ARGS_READ,
+            tid, (sysarg_t) buffer);
+}
 int udebug_regs_read(int phoneid, thash_t tid, void *buffer)
+int udebug_regs_read(async_sess_t *sess, thash_t tid, void *buffer)
+{
+        return async_req_3_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_REGS_READ,
+            tid, (sysarg_t)buffer);
+        async_exch_t *exch = async_exchange_begin(sess);
+        return async_req_3_0(exch, IPC_M_DEBUG, UDEBUG_M_REGS_READ,
+            tid, (sysarg_t) buffer);
+}
 int udebug_go(int phoneid, thash_t tid, udebug_event_t *ev_type,
+int udebug_go(async_sess_t *sess, thash_t tid, udebug_event_t *ev_type,
     sysarg_t *val0, sysarg_t *val1)
+{
         sysarg_t a_ev_type;
         int rc;
         rc =  async_req_2_3(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_GO,
+        async_exch_t *exch = async_exchange_begin(sess);
+        int rc = async_req_2_3(exch, IPC_M_DEBUG, UDEBUG_M_GO,
             tid, &a_ev_type, val0, val1);
         *ev_type = a_ev_type;
         return rc;
+}
 int udebug_stop(int phoneid, thash_t tid)
+int udebug_stop(async_sess_t *sess, thash_t tid)
+{
         return async_req_2_0(phoneid, IPC_M_DEBUG_ALL, UDEBUG_M_STOP,
             tid);
+        async_exch_t *exch = async_exchange_begin(sess);
+        return async_req_2_0(exch, IPC_M_DEBUG, UDEBUG_M_STOP, tid);
+}

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

-              r52a79081
+              ra33f0a6
  */
+#include <vfs/canonify.h>
 #include <vfs/vfs.h>
 #include <vfs/canonify.h>
+#include <vfs/vfs_sess.h>
 #include <macros.h>
 #include <stdlib.h>
 …
 #include <sys/types.h>
 #include <ipc/services.h>
 #include <ipc/ns.h>
+#include <ns.h>
 #include <async.h>
 #include <fibril_synch.h>
 …
 #include <ipc/devmap.h>
+static async_sess_t vfs_session;
+static FIBRIL_MUTEX_INITIALIZE(vfs_phone_mutex);
+static int vfs_phone = -1;
+static FIBRIL_MUTEX_INITIALIZE(vfs_mutex);
+static async_sess_t *vfs_sess = NULL;
 static FIBRIL_MUTEX_INITIALIZE(cwd_mutex);
 …
 static size_t cwd_size = 0;
+/** Start an async exchange on the VFS session.
+ *
+ * @return New exchange.
+ *
+ */
+static async_exch_t *vfs_exchange_begin(void)
+{
+        fibril_mutex_lock(&vfs_mutex);
+        while (vfs_sess == NULL)
+                vfs_sess = service_connect_blocking(EXCHANGE_PARALLEL, SERVICE_VFS,
+, 0);
+        fibril_mutex_unlock(&vfs_mutex);
+        return async_exchange_begin(vfs_sess);
+}
+/** Finish an async exchange on the VFS session.
+ *
+ * @param exch Exchange to be finished.
+ *
+ */
+static void vfs_exchange_end(async_exch_t *exch)
+{
+        async_exchange_end(exch);
+}
 char *absolutize(const char *path, size_t *retlen)
+{
         char *ncwd_path;
         char *ncwd_path_nc;
-        size_t total_size;
         fibril_mutex_lock(&cwd_mutex);
 …
                         return NULL;
+                }
+                total_size = cwd_size + 1 + size + 1;
+                ncwd_path_nc = malloc(total_size);
+                ncwd_path_nc = malloc(cwd_size + 1 + size + 1);
                 if (!ncwd_path_nc) {
                         fibril_mutex_unlock(&cwd_mutex);
                         return NULL;
+                }
                 str_cpy(ncwd_path_nc, total_size, cwd_path);
+                str_cpy(ncwd_path_nc, cwd_size + 1 + size + 1, cwd_path);
                 ncwd_path_nc[cwd_size] = '/';
                 ncwd_path_nc[cwd_size + 1] = '\0';
         } else {
+                total_size = size + 1;
+                ncwd_path_nc = malloc(total_size);
+                ncwd_path_nc = malloc(size + 1);
                 if (!ncwd_path_nc) {
                         fibril_mutex_unlock(&cwd_mutex);
 …
                 ncwd_path_nc[0] = '\0';
+        }
         str_append(ncwd_path_nc, total_size, path);
+        str_append(ncwd_path_nc, cwd_size + 1 + size + 1, path);
         ncwd_path = canonify(ncwd_path_nc, retlen);
         if (!ncwd_path) {
 …
+}
-/** Connect to VFS service and create session. */
-static void vfs_connect(void)
+{
-        while (vfs_phone < 0)
-                vfs_phone = service_connect_blocking(SERVICE_VFS, 0, 0);
-        async_session_create(&vfs_session, vfs_phone, 0);
+}
-/** Start an async exchange on the VFS session.
+ *
- * @return              New phone to be used during the exchange.
- */
-static int vfs_exchange_begin(void)
+{
-        fibril_mutex_lock(&vfs_phone_mutex);
-        if (vfs_phone < 0)
-                vfs_connect();
-        fibril_mutex_unlock(&vfs_phone_mutex);
-        return async_exchange_begin(&vfs_session);
+}
-/** End an async exchange on the VFS session.
+ *
- * @param phone         Phone used during the exchange.
- */
-static void vfs_exchange_end(int phone)
+{
-        async_exchange_end(&vfs_session, phone);
+}
 int mount(const char *fs_name, const char *mp, const char *fqdn,
     const char *opts, unsigned int flags)
 …
+        }
         int vfs_phone = vfs_exchange_begin();
+        async_exch_t *exch = vfs_exchange_begin();
         sysarg_t rc_orig;
         aid_t req = async_send_2(vfs_phone, VFS_IN_MOUNT, devmap_handle, flags, NULL);
         sysarg_t rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        aid_t req = async_send_2(exch, VFS_IN_MOUNT, devmap_handle, flags, NULL);
+        sysarg_t rc = async_data_write_start(exch, (void *) mpa, mpa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 free(mpa);
                 async_wait_for(req, &rc_orig);
 …
+        }
         rc = async_data_write_start(vfs_phone, (void *) opts, str_size(opts));
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        rc = async_data_write_start(exch, (void *) opts, str_size(opts));
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 free(mpa);
                 async_wait_for(req, &rc_orig);
 …
+        }
         rc = async_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        rc = async_data_write_start(exch, (void *) fs_name, str_size(fs_name));
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 free(mpa);
                 async_wait_for(req, &rc_orig);
 …
         /* Ask VFS whether it likes fs_name. */
         rc = async_req_0_0(vfs_phone, IPC_M_PING);
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        rc = async_req_0_0(exch, VFS_IN_PING);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 free(mpa);
                 async_wait_for(req, &rc_orig);
 …
+        }
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         free(mpa);
         async_wait_for(req, &rc);
 …
                 return ENOMEM;
         int vfs_phone = vfs_exchange_begin();
         req = async_send_0(vfs_phone, VFS_IN_UNMOUNT, NULL);
         rc = async_data_write_start(vfs_phone, (void *) mpa, mpa_size);
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_0(exch, VFS_IN_UNMOUNT, NULL);
+        rc = async_data_write_start(exch, (void *) mpa, mpa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 free(mpa);
                 async_wait_for(req, &rc_orig);
 …
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         free(mpa);
         async_wait_for(req, &rc);
 …
 static int open_internal(const char *abs, size_t abs_size, int lflag, int oflag)
+{
         int vfs_phone = vfs_exchange_begin();
+        async_exch_t *exch = vfs_exchange_begin();
         ipc_call_t answer;
         aid_t req = async_send_3(vfs_phone, VFS_IN_OPEN, lflag, oflag, 0, &answer);
         sysarg_t rc = async_data_write_start(vfs_phone, abs, abs_size);
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        aid_t req = async_send_3(exch, VFS_IN_OPEN, lflag, oflag, 0, &answer);
+        sysarg_t rc = async_data_write_start(exch, abs, abs_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 sysarg_t rc_orig;
 …
+        }
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         async_wait_for(req, &rc);
 …
 int open_node(fdi_node_t *node, int oflag)
+{
         int vfs_phone = vfs_exchange_begin();
+        async_exch_t *exch = vfs_exchange_begin();
         ipc_call_t answer;
         aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle,
+        aid_t req = async_send_4(exch, VFS_IN_OPEN_NODE, node->fs_handle,
             node->devmap_handle, node->index, oflag, &answer);
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         sysarg_t rc;
 …
         sysarg_t rc;
+        int vfs_phone = vfs_exchange_begin();
+        rc = async_req_1_0(vfs_phone, VFS_IN_CLOSE, fildes);
+        vfs_exchange_end(vfs_phone);
+        return (int)rc;
+        async_exch_t *exch = vfs_exchange_begin();
+        rc = async_req_1_0(exch, VFS_IN_CLOSE, fildes);
+        vfs_exchange_end(exch);
+        return (int) rc;
+}
 …
         ipc_call_t answer;
         aid_t req;
+        int vfs_phone = vfs_exchange_begin();
+        req = async_send_1(vfs_phone, VFS_IN_READ, fildes, &answer);
+        rc = async_data_read_start_generic(vfs_phone, (void *) buf, nbyte,
+            IPC_XF_RESTRICT);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_1(exch, VFS_IN_READ, fildes, &answer);
+        rc = async_data_read_start(exch, (void *)buf, nbyte);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 sysarg_t rc_orig;
 …
                         return (ssize_t) rc_orig;
+        }
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         async_wait_for(req, &rc);
         if (rc == EOK)
 …
         ipc_call_t answer;
         aid_t req;
+        int vfs_phone = vfs_exchange_begin();
+        req = async_send_1(vfs_phone, VFS_IN_WRITE, fildes, &answer);
+        rc = async_data_write_start_generic(vfs_phone, (void *) buf, nbyte,
+            IPC_XF_RESTRICT);
+        if (rc != EOK) {
+                vfs_exchange_end(vfs_phone);
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_1(exch, VFS_IN_WRITE, fildes, &answer);
+        rc = async_data_write_start(exch, (void *)buf, nbyte);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 sysarg_t rc_orig;
 …
                         return (ssize_t) rc_orig;
+        }
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         async_wait_for(req, &rc);
         if (rc == EOK)
 …
+}
+/** Read entire buffer.
+ *
+ * In face of short reads this function continues reading until either
+ * the entire buffer is read or no more data is available (at end of file).
+ *
+ * @param fildes        File descriptor
+ * @param buf           Buffer, @a nbytes bytes long
+ * @param nbytes        Number of bytes to read
+ *
+ * @return              On success, positive number of bytes read.
+ *                      On failure, negative error code from read().
+ */
+ssize_t read_all(int fildes, void *buf, size_t nbyte)
+{
+        ssize_t cnt = 0;
+        size_t nread = 0;
+        uint8_t *bp = (uint8_t *) buf;
+        do {
+                bp += cnt;
+                nread += cnt;
+                cnt = read(fildes, bp, nbyte - nread);
+        } while (cnt > 0 && (nbyte - nread - cnt) > 0);
+        if (cnt < 0)
+                return cnt;
+        return nread + cnt;
+}
+/** Write entire buffer.
+ *
+ * This function fails if it cannot write exactly @a len bytes to the file.
+ *
+ * @param fildes        File descriptor
+ * @param buf           Data, @a nbytes bytes long
+ * @param nbytes        Number of bytes to write
+ *
+ * @return              EOK on error, return value from write() if writing
+ *                      failed.
+ */
+ssize_t write_all(int fildes, const void *buf, size_t nbyte)
+{
+        ssize_t cnt = 0;
+        ssize_t nwritten = 0;
+        const uint8_t *bp = (uint8_t *) buf;
+        do {
+                bp += cnt;
+                nwritten += cnt;
+                cnt = write(fildes, bp, nbyte - nwritten);
+        } while (cnt > 0 && ((ssize_t )nbyte - nwritten - cnt) > 0);
+        if (cnt < 0)
+                return cnt;
+        if ((ssize_t)nbyte - nwritten - cnt > 0)
+                return EIO;
+        return nbyte;
+}
 int fsync(int fildes)
+{
+        int vfs_phone = vfs_exchange_begin();
+        sysarg_t rc = async_req_1_0(vfs_phone, VFS_IN_SYNC, fildes);
+        vfs_exchange_end(vfs_phone);
+        async_exch_t *exch = vfs_exchange_begin();
+        sysarg_t rc = async_req_1_0(exch, VFS_IN_SYNC, fildes);
+        vfs_exchange_end(exch);
         return (int) rc;
 …
 off64_t lseek(int fildes, off64_t offset, int whence)
+{
         int vfs_phone = vfs_exchange_begin();
+        async_exch_t *exch = vfs_exchange_begin();
         sysarg_t newoff_lo;
         sysarg_t newoff_hi;
         sysarg_t rc = async_req_4_2(vfs_phone, VFS_IN_SEEK, fildes,
+        sysarg_t rc = async_req_4_2(exch, VFS_IN_SEEK, fildes,
             LOWER32(offset), UPPER32(offset), whence,
             &newoff_lo, &newoff_hi);
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         if (rc != EOK)
 …
         sysarg_t rc;
+        int vfs_phone = vfs_exchange_begin();
+        rc = async_req_3_0(vfs_phone, VFS_IN_TRUNCATE, fildes,
+        async_exch_t *exch = vfs_exchange_begin();
+        rc = async_req_3_0(exch, VFS_IN_TRUNCATE, fildes,
             LOWER32(length), UPPER32(length));
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         return (int) rc;
 …
         sysarg_t rc;
         aid_t req;
         int vfs_phone = vfs_exchange_begin();
         req = async_send_1(vfs_phone, VFS_IN_FSTAT, fildes, NULL);
         rc = async_data_read_start(vfs_phone, (void *) stat, sizeof(struct stat));
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_1(exch, VFS_IN_FSTAT, fildes, NULL);
+        rc = async_data_read_start(exch, (void *) stat, sizeof(struct stat));
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 sysarg_t rc_orig;
 …
                         return (ssize_t) rc_orig;
+        }
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         async_wait_for(req, &rc);
 …
                 return ENOMEM;
         int vfs_phone = vfs_exchange_begin();
         req = async_send_0(vfs_phone, VFS_IN_STAT, NULL);
         rc = async_data_write_start(vfs_phone, pa, pa_size);
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_0(exch, VFS_IN_STAT, NULL);
+        rc = async_data_write_start(exch, pa, pa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 free(pa);
                 async_wait_for(req, &rc_orig);
 …
                         return (int) rc_orig;
+        }
         rc = async_data_read_start(vfs_phone, stat, sizeof(struct stat));
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        rc = async_data_read_start(exch, stat, sizeof(struct stat));
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 free(pa);
                 async_wait_for(req, &rc_orig);
 …
                         return (int) rc_orig;
+        }
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         free(pa);
         async_wait_for(req, &rc);
 …
                 return ENOMEM;
         int vfs_phone = vfs_exchange_begin();
         req = async_send_1(vfs_phone, VFS_IN_MKDIR, mode, NULL);
         rc = async_data_write_start(vfs_phone, pa, pa_size);
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_1(exch, VFS_IN_MKDIR, mode, NULL);
+        rc = async_data_write_start(exch, pa, pa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 free(pa);
 …
                         return (int) rc_orig;
+        }
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         free(pa);
         async_wait_for(req, &rc);
 …
         if (!pa)
                 return ENOMEM;
         int vfs_phone = vfs_exchange_begin();
         req = async_send_0(vfs_phone, VFS_IN_UNLINK, NULL);
         rc = async_data_write_start(vfs_phone, pa, pa_size);
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_0(exch, VFS_IN_UNLINK, NULL);
+        rc = async_data_write_start(exch, pa, pa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 free(pa);
 …
                         return (int) rc_orig;
+        }
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         free(pa);
         async_wait_for(req, &rc);
 …
                 return ENOMEM;
+        }
         int vfs_phone = vfs_exchange_begin();
         req = async_send_0(vfs_phone, VFS_IN_RENAME, NULL);
         rc = async_data_write_start(vfs_phone, olda, olda_size);
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_0(exch, VFS_IN_RENAME, NULL);
+        rc = async_data_write_start(exch, olda, olda_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 free(olda);
                 free(newa);
 …
                         return (int) rc_orig;
+        }
         rc = async_data_write_start(vfs_phone, newa, newa_size);
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+        rc = async_data_write_start(exch, newa, newa_size);
+        if (rc != EOK) {
+                vfs_exchange_end(exch);
                 free(olda);
                 free(newa);
 …
                         return (int) rc_orig;
+        }
         vfs_exchange_end(vfs_phone);
+        vfs_exchange_end(exch);
         free(olda);
         free(newa);
 …
+}
 int fd_phone(int fildes)
+async_sess_t *fd_session(exch_mgmt_t mgmt, int fildes)
+{
         struct stat stat;
         int rc = fstat(fildes, &stat);
+        if (rc != 0)
+                return rc;
+        if (!stat.device)
+                return -1;
+        return devmap_device_connect(stat.device, 0);
+        if (rc != 0) {
+                errno = rc;
+                return NULL;
+        }
+        if (!stat.device) {
+                errno = ENOENT;
+                return NULL;
+        }
+        return devmap_device_connect(mgmt, stat.device, 0);
+}
 …
+{
         struct stat stat;
+        int rc;
+        rc = fstat(fildes, &stat);
+        int rc = fstat(fildes, &stat);
         if (rc == EOK) {
 …
 int dup2(int oldfd, int newfd)
+{
         int vfs_phone = vfs_exchange_begin();
+        async_exch_t *exch = vfs_exchange_begin();
         sysarg_t ret;
         sysarg_t rc = async_req_2_1(vfs_phone, VFS_IN_DUP, oldfd, newfd, &ret);
         vfs_exchange_end(vfs_phone);
+        sysarg_t rc = async_req_2_1(exch, VFS_IN_DUP, oldfd, newfd, &ret);
+        vfs_exchange_end(exch);
         if (rc == EOK)

Context Navigation

Changeset a33f0a6 in mainline for uspace/lib/c/generic

Legend:

Download in other formats: