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

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

-              r2bdf8313
+              rb0f00a9
+ *
  */
 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;
 …
+}
+/** Remove all elements from the hash table
+ *
+ * @param h Hash table to be cleared
+ */
+void hash_table_clear(hash_table_t *h)
+{
+        for (hash_count_t chain = 0; chain < h->entries; ++chain) {
+                link_t *cur;
+                link_t *next;
+                for (cur = h->entry[chain].head.next;
+                    cur != &h->entry[chain].head;
+                    cur = next) {
+                        next = cur->next;
+                        list_remove(cur);
+                        h->op->remove_callback(cur);
+                }
+        }
+}
 /** Destroy a hash table instance.
+ *
 …
         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)) {
                         /*
 …
             h->op->remove_callback);
         assert(keys <= h->max_keys);
-        link_t *cur;
         if (keys == h->max_keys) {
 …
                  */
                 cur = hash_table_find(h, key);
+                link_t *cur = hash_table_find(h, key);
                 if (cur) {
                         list_remove(cur);
 …
         hash_index_t chain;
         for (chain = 0; chain < h->entries; chain++) {
+                for (cur = h->entry[chain].next; cur != &h->entry[chain];
+                for (link_t *cur = h->entry[chain].head.next;
+                    cur != &h->entry[chain].head;
                     cur = cur->next) {
                         if (h->op->compare(key, keys, cur)) {
 …
+}
 /** Apply fucntion to all items in hash table.
+/** Apply function to all items in hash table.
+ *
  * @param h   Hash table.
 …
  */
 void hash_table_apply(hash_table_t *h, void (*f)(link_t *, void *), void *arg)
+{
+        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) {
+{
+        for (hash_index_t bucket = 0; bucket < h->entries; bucket++) {
+                link_t *cur;
+                link_t *next;
+                for (cur = h->entry[bucket].head.next; cur != &h->entry[bucket].head;
+                    cur = next) {
+                        /*
+                         * The next pointer must be stored prior to the functor
+                         * call to allow using destructor as the functor (the
+                         * free function could overwrite the cur->next pointer).
+                         */
+                        next = cur->next;
                         f(cur, arg);
+                }

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

-              r2bdf8313
+              rb0f00a9
  * @{
  */
+/** @file
+/**
+ * @file
+ * @brief       Functions completing doubly linked circular list implementation.
+ *
+ * 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.
+ * @return true if link is contained in list, 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

-              r2bdf8313
+              rb0f00a9
  * 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/adt/prodcons.c

r2bdf8313	rb0f00a9
61	61	fibril_condvar_wait(&pc->cv, &pc->mtx);
62	62
63		link_t *head = ~~pc->list.next~~;
	63	link_t *head = list_first(&pc->list);
64	64	list_remove(head);
65	65

uspace/lib/c/generic/as.c

-              r2bdf8313
+              rb0f00a9
 #include <as.h>
 #include <libc.h>
+#include <errno.h>
 #include <unistd.h>
 #include <align.h>
 …
+}
+/** 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(const 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

-              r2bdf8313
+              rb0f00a9
 #include <atomic.h>
 #include <stacktrace.h>
+#include <stdint.h>
+#define MSG_START       "Assertion failed ("
+#define MSG_FILE        ") in file \""
+#define MSG_LINE        "\", line "
+#define MSG_END         ".\n"
+static atomic_t failed_asserts = {0};
+static atomic_t failed_asserts;
+void assert_abort(const char *cond, const char *file, const char *line)
+void assert_abort(const char *cond, const char *file, unsigned int line)
+{
         /*
          * Send the message safely to klog. Nested asserts should not occur.
          */
+        klog_write(MSG_START, str_size(MSG_START));
+        klog_write(cond, str_size(cond));
+        klog_write(MSG_FILE, str_size(MSG_FILE));
+        klog_write(file, str_size(file));
+        klog_write(MSG_LINE, str_size(MSG_LINE));
+        klog_write(line, str_size(line));
+        klog_write(MSG_END, str_size(MSG_END));
+        klog_printf("Assertion failed (%s) in file \"%s\", line %u.\n",
+            cond, file, line);
         /*
          * Check if this is a nested or parallel assert.
 …
          * assertions.
          */
         printf(MSG_START "%s" MSG_FILE "%s" MSG_LINE "%s" MSG_END,
+        printf("Assertion failed (%s) in file \"%s\", line %u.\n",
             cond, file, line);
         stacktrace_print();
         abort();
+}

uspace/lib/c/generic/async.c

-              r2bdf8313
+              rb0f00a9
  * 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 <ipc/ipc.h>
 #include <async.h>
+#include "private/async.h"
 #undef LIBC_ASYNC_C_
 #include <futex.h>
 #include <fibril.h>
-#include <stdio.h>
 #include <adt/hash_table.h>
 #include <adt/list.h>
 …
 #include <errno.h>
 #include <sys/time.h>
 #include <arch/barrier.h>
+#include <libarch/barrier.h>
 #include <bool.h>
+#include <malloc.h>
+#include <mem.h>
 #include <stdlib.h>
+#include <malloc.h>
+#include "private/async.h"
+#include <macros.h>
+#define CLIENT_HASH_TABLE_BUCKETS  32
+#define CONN_HASH_TABLE_BUCKETS    32
+/** Session data */
+struct async_sess {
+        /** List of inactive exchanges */
+        list_t exch_list;
+        /** Exchange management style */
+        exch_mgmt_t mgmt;
+        /** Session identification */
+        int phone;
+        /** First clone connection argument */
+        sysarg_t arg1;
+        /** Second clone connection argument */
+        sysarg_t arg2;
+        /** Third clone connection argument */
+        sysarg_t arg3;
+        /** Exchange mutex */
+        fibril_mutex_t mutex;
+        /** Number of opened exchanges */
+        atomic_t refcnt;
+        /** Mutex for stateful connections */
+        fibril_mutex_t remote_state_mtx;
+        /** Data for stateful connections */
+        void *remote_state_data;
+};
+/** Exchange data */
+struct async_exch {
+        /** Link into list of inactive exchanges */
+        link_t sess_link;
+        /** Link into global list of inactive exchanges */
+        link_t global_link;
+        /** Session pointer */
+        async_sess_t *sess;
+        /** Exchange identification */
+        int phone;
+};
+/** 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;
+/** Message data */
 typedef struct {
+        sysarg_t in_task_hash;
+        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;
+/* Client connection data */
+typedef struct {
         link_t link;
+        int refcnt;
+        task_id_t in_task_id;
+        atomic_t refcnt;
         void *data;
 } client_t;
+/* Server connection data */
 typedef struct {
         awaiter_t wdata;
 …
         link_t link;
+        /** Incoming client task hash. */
+        sysarg_t in_task_hash;
+        /** Incoming client task ID. */
+        task_id_t in_task_id;
         /** 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;
+}
 /** Default fibril function that gets called to handle new connection.
+ *
 …
  * @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(keys == 2);
+        assert(item);
         client_t *client = hash_table_get_instance(item, client_t, link);
+        return (key[0] == client->in_task_hash);
+        return (key[0] == LOWER32(client->in_task_id) &&
+            (key[1] == UPPER32(client->in_task_id)));
+}
 …
+{
         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 client_t *async_client_get(task_id_t client_id, bool create)
+{
+        unsigned long key[2] = {
+                LOWER32(client_id),
+                UPPER32(client_id),
+        };
+        client_t *client = NULL;
+        futex_down(&async_futex);
+        link_t *lnk = hash_table_find(&client_hash_table, key);
+        if (lnk) {
+                client = hash_table_get_instance(lnk, client_t, link);
+                atomic_inc(&client->refcnt);
+        } else if (create) {
+                client = malloc(sizeof(client_t));
+                if (client) {
+                        client->in_task_id = client_id;
+                        client->data = async_client_data_create();
+                        atomic_set(&client->refcnt, 1);
+                        hash_table_insert(&client_hash_table, key, &client->link);
+                }
+        }
+        futex_up(&async_futex);
+        return client;
+}
+static void async_client_put(client_t *client)
+{
+        bool destroy;
+        unsigned long key[2] = {
+                LOWER32(client->in_task_id),
+                UPPER32(client->in_task_id)
+        };
+        futex_down(&async_futex);
+        if (atomic_predec(&client->refcnt) == 0) {
+                hash_table_remove(&client_hash_table, key, 2);
+                destroy = true;
+        } else
+                destroy = false;
+        futex_up(&async_futex);
+        if (destroy) {
+                if (client->data)
+                        async_client_data_destroy(client->data);
+                free(client);
+        }
+}
+void *async_get_client_data(void)
+{
+        assert(fibril_connection);
+        return fibril_connection->client->data;
+}
+void *async_get_client_data_by_id(task_id_t client_id)
+{
+        client_t *client = async_client_get(client_id, false);
+        if (!client)
+                return NULL;
+        if (!client->data) {
+                async_client_put(client);
+                return NULL;
+        }
+        return client->data;
+}
+void async_put_client_data_by_id(task_id_t client_id)
+{
+        client_t *client = async_client_get(client_id, false);
+        assert(client);
+        assert(client->data);
+        /* Drop the reference we got in async_get_client_data_by_hash(). */
+        async_client_put(client);
+        /* Drop our own reference we got at the beginning of this function. */
+        async_client_put(client);
+}
 /** Wrapper for client connection fibril.
+ *
 …
 static int connection_fibril(void *arg)
+{
+        assert(arg);
         /*
          * Setup fibril-local connection pointer.
          */
+        FIBRIL_connection = (connection_t *) arg;
+        futex_down(&async_futex);
+        fibril_connection = (connection_t *) arg;
         /*
 …
          * hash in a new tracking structure.
          */
+        unsigned long key = FIBRIL_connection->in_task_hash;
+        link_t *lnk = hash_table_find(&client_hash_table, &key);
+        client_t *client;
+        if (lnk) {
+                client = hash_table_get_instance(lnk, client_t, link);
+                client->refcnt++;
+        } else {
+                client = malloc(sizeof(client_t));
+                if (!client) {
+                        ipc_answer_0(FIBRIL_connection->callid, ENOMEM);
+                        futex_up(&async_futex);
+                        return 0;
+                }
+                client->in_task_hash = FIBRIL_connection->in_task_hash;
+                async_serialize_start();
+                client->data = async_client_data_create();
+                async_serialize_end();
+                client->refcnt = 1;
+                hash_table_insert(&client_hash_table, &key, &client->link);
+        }
+        futex_up(&async_futex);
+        FIBRIL_connection->client = client;
+        client_t *client = async_client_get(fibril_connection->in_task_id, true);
+        if (!client) {
+                ipc_answer_0(fibril_connection->callid, ENOMEM);
+                return 0;
+        }
+        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);
         /*
          * Remove the reference for this client task connection.
          */
+        bool destroy;
+        futex_down(&async_futex);
+        if (--client->refcnt == 0) {
+                hash_table_remove(&client_hash_table, &key, 1);
+                destroy = true;
+        } else
+                destroy = false;
+        futex_up(&async_futex);
+        if (destroy) {
+                if (client->data)
+                        async_client_data_destroy(client->data);
+                free(client);
+        }
+        async_client_put(client);
         /*
 …
          */
         futex_down(&async_futex);
         key = FIBRIL_connection->in_phone_hash;
+        unsigned long 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 in_task_hash  Identification of the incoming connection.
+ * @param in_task_id    Identification of the incoming connection.
  * @param in_phone_hash Identification of the incoming connection.
  * @param callid        Hash of the opening IPC_M_CONNECT_ME_TO call.
 …
  * @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,
+fid_t async_new_connection(task_id_t in_task_id, 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->in_task_hash = in_task_hash;
+        conn->in_task_id = in_task_id;
         conn->in_phone_hash = in_phone_hash;
         list_initialize(&conn->msg_queue);
         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)) {
 …
         case IPC_M_CONNECT_ME_TO:
                 /* Open new connection with fibril, etc. */
                 async_new_connection(call->in_task_hash, IPC_GET_ARG5(*call),
                     callid, call, client_connection);
+                async_new_connection(call->in_task_id, IPC_GET_ARG5(*call),
+                    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;
+        fibril_mutex_initialize(&session_ns->remote_state_mtx);
+        session_ns->remote_state_data = NULL;
+        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)
+{
+        sysarg_t task_hash;
+ * @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 phone_hash;
+        int rc = async_req_3_5(phone, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
+            NULL, NULL, NULL, &task_hash, &phone_hash);
+        sysarg_t rc;
+        aid_t req;
+        ipc_call_t answer;
+        req = async_send_3(exch, IPC_M_CONNECT_TO_ME, arg1, arg2, arg3,
+            &answer);
+        async_wait_for(req, &rc);
+        if (rc != EOK)
+                return (int) rc;
+        phone_hash = IPC_GET_ARG5(answer);
+        if (client_receiver != NULL)
+                async_new_connection(answer.in_task_id, phone_hash, 0, NULL,
+                    client_receiver, carg);
+        return EOK;
+}
+/** 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;
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        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;
+        if (client_receiver != NULL)
+                async_new_connection(task_hash, phone_hash, 0, NULL,
+                    client_receiver);
+        return EOK;
+        return (int) IPC_GET_ARG5(result);
+}
 /** 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,
+ * 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;
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        list_initialize(&sess->exch_list);
+        fibril_mutex_initialize(&sess->mutex);
+        atomic_set(&sess->refcnt, 0);
+        return sess;
+}
+/** Set arguments for new connections.
+ *
+ * FIXME This is an ugly hack to work around the problem that parallel
+ * exchanges are implemented using parallel connections. When we create
+ * a callback session, the framework does not know arguments for the new
+ * connections.
+ *
+ * The proper solution seems to be to implement parallel exchanges using
+ * tagging.
+ */
+void async_sess_args_set(async_sess_t *sess, 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);
+        if (rc != EOK)
+                return rc;
+        return newphid;
+        sess->arg1 = arg1;
+        sess->arg2 = arg2;
+        sess->arg3 = arg3;
+}
 …
  * 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;
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        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;
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        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)
+{
+        async_exch_t *exch;
+        assert(sess);
+        if (atomic_get(&sess->refcnt) > 0)
+                return EBUSY;
+        fibril_mutex_lock(&async_sess_mutex);
+        int rc = async_hangup_internal(sess->phone);
+        while (!list_empty(&sess->exch_list)) {
+                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);
+                async_hangup_internal(exch->phone);
+                free(exch);
+        }
+        free(sess);
+        fibril_mutex_unlock(&async_sess_mutex);
+        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;
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        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;
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        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;
+        fibril_mutex_initialize(&sess->remote_state_mtx);
+        sess->remote_state_data = NULL;
+        list_initialize(&sess->exch_list);
+        fibril_mutex_initialize(&sess->mutex);
+        atomic_set(&sess->refcnt, 0);
+        return sess;
+}
+int async_state_change_start(async_exch_t *exch, sysarg_t arg1, sysarg_t arg2,
+    sysarg_t arg3, async_exch_t *other_exch)
+{
+        return async_req_5_0(exch, IPC_M_STATE_CHANGE_AUTHORIZE,
+            arg1, arg2, arg3, 0, other_exch->phone);
+}
+bool async_state_change_receive(ipc_callid_t *callid, sysarg_t *arg1,
+    sysarg_t *arg2, sysarg_t *arg3)
+{
+        assert(callid);
+        ipc_call_t call;
+        *callid = async_get_call(&call);
+        if (IPC_GET_IMETHOD(call) != IPC_M_STATE_CHANGE_AUTHORIZE)
+                return false;
+        if (arg1)
+                *arg1 = IPC_GET_ARG1(call);
+        if (arg2)
+                *arg2 = IPC_GET_ARG2(call);
+        if (arg3)
+                *arg3 = IPC_GET_ARG3(call);
+        return true;
+}
+int async_state_change_finalize(ipc_callid_t callid, async_exch_t *other_exch)
+{
+        return ipc_answer_1(callid, EOK, other_exch->phone);
+}
+/** Lock and get session remote state
+ *
+ * Lock and get the local replica of the remote state
+ * in stateful sessions. The call should be paired
+ * with async_remote_state_release*().
+ *
+ * @param[in] sess Stateful session.
+ *
+ * @return Local replica of the remote state.
+ *
+ */
+void *async_remote_state_acquire(async_sess_t *sess)
+{
+        fibril_mutex_lock(&sess->remote_state_mtx);
+        return sess->remote_state_data;
+}
+/** Update the session remote state
+ *
+ * Update the local replica of the remote state
+ * in stateful sessions. The remote state must
+ * be already locked.
+ *
+ * @param[in] sess  Stateful session.
+ * @param[in] state New local replica of the remote state.
+ *
+ */
+void async_remote_state_update(async_sess_t *sess, void *state)
+{
+        assert(fibril_mutex_is_locked(&sess->remote_state_mtx));
+        sess->remote_state_data = state;
+}
+/** Release the session remote state
+ *
+ * Unlock the local replica of the remote state
+ * in stateful sessions.
+ *
+ * @param[in] sess Stateful session.
+ *
+ */
+void async_remote_state_release(async_sess_t *sess)
+{
+        assert(fibril_mutex_is_locked(&sess->remote_state_mtx));
+        fibril_mutex_unlock(&sess->remote_state_mtx);
+}
+/** Release the session remote state and end an exchange
+ *
+ * Unlock the local replica of the remote state
+ * in stateful sessions. This is convenience function
+ * which gets the session pointer from the exchange
+ * and also ends the exchange.
+ *
+ * @param[in] exch Stateful session's exchange.
+ *
+ */
+void async_remote_state_release_exchange(async_exch_t *exch)
+{
+        if (exch == NULL)
+                return;
+        async_sess_t *sess = exch->sess;
+        assert(fibril_mutex_is_locked(&sess->remote_state_mtx));
+        async_exchange_end(exch);
+        fibril_mutex_unlock(&sess->remote_state_mtx);
+}
 /** @}
  */

uspace/lib/c/generic/clipboard.c

-              r2bdf8313
+              rb0f00a9
 #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/ddi.c

-              r2bdf8313
+              rb0f00a9
  */
 /** @file
  */
+ */
+#include <sys/types.h>
+#include <abi/ddi/arg.h>
 #include <ddi.h>
 #include <libarch/ddi.h>
 …
 #include <align.h>
 #include <libarch/config.h>
-#include <kernel/ddi/ddi_arg.h>
 /** Return unique device number.

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

-              r2bdf8313
+              rb0f00a9
  * 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

-              r2bdf8313
+              rb0f00a9
 #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

-              r2bdf8313
+              rb0f00a9
 /*
  * Copyright (c) 2007 Josef Cejka
  * Copyright (c) 2009 Jiri Svoboda
+ * Copyright (c) 2011 Jiri Svoboda
  * Copyright (c) 2010 Lenka Trochtova
  * All rights reserved.
 …
  */
+#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_PARALLEL,
+                                    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_PARALLEL, 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();
+        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
         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));
+        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);
+                async_serialize_end();
+                return -1;
+                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, conn, 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);
+        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
         ipc_call_t answer;
+        aid_t req = async_send_3(phone, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
+        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));
+        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);
+        if (retval == EOK) {
+                if (funh != NULL)
+                        *funh = (int) IPC_GET_ARG1(answer);
+        } else {
+                if (funh != NULL)
+                        *funh = -1;
+        }
+        return retval;
+}
+int devman_add_device_to_category(devman_handle_t devman_handle,
+    const char *cat_name)
+{
+        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_CATEGORY,
+            devman_handle, &answer);
+        sysarg_t retval = async_data_write_start(exch, cat_name,
+            str_size(cat_name));
+        devman_exchange_end(exch);
         if (retval != EOK) {
                 async_wait_for(req, NULL);
+                async_serialize_end();
+                return retval;
+        }
+        int match_ids_rc = devman_send_match_ids(phone, match_ids);
+                return retval;
+        }
         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);
+        return retval;
+}
+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
+                fun_handle = -1;
+        *funh = fun_handle;
+        return retval;
+}
+int devman_add_device_to_class(devman_handle_t devman_handle,
+    const char *class_name)
+{
+        int phone = devman_get_phone(DEVMAN_DRIVER, IPC_FLAG_BLOCKING);
+        if (phone < 0)
+                return phone;
+        async_serialize_start();
+                sess = service_connect(mgmt, SERVICE_DEVMAN,
+                            DEVMAN_CONNECT_TO_DEVICE, handle);
+        return sess;
+}
+/** Remove function from device.
+ *
+ * Request devman to remove function owned by this driver task.
+ * @param funh      Devman handle of the function
+ *
+ * @return EOK on success or negative error code.
+ */
+int devman_remove_function(devman_handle_t funh)
+{
+        async_exch_t *exch;
+        sysarg_t retval;
+        exch = devman_exchange_begin_blocking(DEVMAN_DRIVER);
+        retval = async_req_1_0(exch, DEVMAN_REMOVE_FUNCTION, (sysarg_t) funh);
+        devman_exchange_end(exch);
+        return (int) retval;
+}
+int devman_drv_fun_online(devman_handle_t funh)
+{
+        async_exch_t *exch = devman_exchange_begin(DEVMAN_DRIVER);
+        if (exch == NULL)
+                return ENOMEM;
+        sysarg_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_ONLINE, funh);
+        devman_exchange_end(exch);
+        return (int) retval;
+}
+int devman_drv_fun_offline(devman_handle_t funh)
+{
+        async_exch_t *exch = devman_exchange_begin(DEVMAN_DRIVER);
+        if (exch == NULL)
+                return ENOMEM;
+        sysarg_t retval = async_req_1_0(exch, DEVMAN_DRV_FUN_OFFLINE, funh);
+        devman_exchange_end(exch);
+        return (int) retval;
+}
+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;
+}
+int devman_fun_get_handle(const char *pathname, devman_handle_t *handle,
+    unsigned int flags)
+{
+        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 ENOMEM;
+        }
         ipc_call_t answer;
+        aid_t req = async_send_1(phone, DEVMAN_ADD_DEVICE_TO_CLASS,
+            devman_handle, &answer);
+        sysarg_t retval = async_data_write_start(phone, class_name,
+            str_size(class_name));
+        aid_t req = async_send_2(exch, DEVMAN_DEVICE_GET_HANDLE, flags, 0,
+            &answer);
+        sysarg_t retval = async_data_write_start(exch, pathname,
+            str_size(pathname));
+        devman_exchange_end(exch);
         if (retval != EOK) {
                 async_wait_for(req, NULL);
-                async_serialize_end();
                 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;
+}
-int devman_device_get_handle(const char *pathname, 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_2(phone, DEVMAN_DEVICE_GET_HANDLE, flags, 0,
-            &answer);
-        sysarg_t retval = async_data_write_start(phone, pathname,
-            str_size(pathname));
-        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 = (devman_handle_t) -1;
                 return retval;
+        }
 …
+}
 int devman_device_get_handle_by_class(const char *classname,
     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();
+static int devman_get_str_internal(sysarg_t method, sysarg_t arg1, char *buf,
+    size_t buf_size)
+{
+        async_exch_t *exch;
+        ipc_call_t dreply;
+        size_t act_size;
+        sysarg_t dretval;
+        exch = devman_exchange_begin_blocking(LOC_PORT_CONSUMER);
         ipc_call_t answer;
+        aid_t req = async_send_1(phone, DEVMAN_DEVICE_GET_HANDLE_BY_CLASS,
+            flags, &answer);
+        sysarg_t retval = async_data_write_start(phone, classname,
+            str_size(classname));
+        aid_t req = async_send_1(exch, method, arg1, &answer);
+        aid_t dreq = async_data_read(exch, buf, buf_size - 1, &dreply);
+        async_wait_for(dreq, &dretval);
+        devman_exchange_end(exch);
+        if (dretval != EOK) {
+                async_wait_for(req, NULL);
+                return dretval;
+        }
+        sysarg_t retval;
+        async_wait_for(req, &retval);
+        if (retval != EOK)
+                return retval;
+        act_size = IPC_GET_ARG2(dreply);
+        assert(act_size <= buf_size - 1);
+        buf[act_size] = '\0';
+        return EOK;
+}
+int devman_fun_get_path(devman_handle_t handle, char *buf, size_t buf_size)
+{
+        return devman_get_str_internal(DEVMAN_FUN_GET_PATH, handle, buf,
+            buf_size);
+}
+int devman_fun_get_name(devman_handle_t handle, char *buf, size_t buf_size)
+{
+        return devman_get_str_internal(DEVMAN_FUN_GET_NAME, handle, buf,
+            buf_size);
+}
+int devman_fun_online(devman_handle_t funh)
+{
+        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+        if (exch == NULL)
+                return ENOMEM;
+        sysarg_t retval = async_req_1_0(exch, DEVMAN_FUN_ONLINE, funh);
+        devman_exchange_end(exch);
+        return (int) retval;
+}
+int devman_fun_offline(devman_handle_t funh)
+{
+        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+        if (exch == NULL)
+                return ENOMEM;
+        sysarg_t retval = async_req_1_0(exch, DEVMAN_FUN_OFFLINE, funh);
+        devman_exchange_end(exch);
+        return (int) retval;
+}
+static int devman_get_handles_once(sysarg_t method, sysarg_t arg1,
+    devman_handle_t *handle_buf, size_t buf_size, size_t *act_size)
+{
+        async_exch_t *exch = devman_exchange_begin_blocking(DEVMAN_CLIENT);
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, method, arg1, &answer);
+        int rc = async_data_read_start(exch, handle_buf, buf_size);
+        devman_exchange_end(exch);
+        if (rc != EOK) {
+                async_wait_for(req, NULL);
+                return rc;
+        }
+        sysarg_t retval;
+        async_wait_for(req, &retval);
         if (retval != EOK) {
+                async_wait_for(req, NULL);
+                async_serialize_end();
+                return retval;
+        }
+        retval = async_data_write_start(phone, devname,
+            str_size(devname));
+        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 = (devman_handle_t) -1;
+                return retval;
+        }
+        if (handle != NULL)
+                *handle = (devman_handle_t) IPC_GET_ARG1(answer);
+        return retval;
+}
+                return retval;
+        }
+        *act_size = IPC_GET_ARG1(answer);
+        return EOK;
+}
+/** Get list of handles.
+ *
+ * Returns an allocated array of handles.
+ *
+ * @param method        IPC method
+ * @param arg1          IPC argument 1
+ * @param data          Place to store pointer to array of handles
+ * @param count         Place to store number of handles
+ * @return              EOK on success or negative error code
+ */
+static int devman_get_handles_internal(sysarg_t method, sysarg_t arg1,
+    devman_handle_t **data, size_t *count)
+{
+        devman_handle_t *handles;
+        size_t act_size;
+        size_t alloc_size;
+        int rc;
+        *data = NULL;
+        act_size = 0;   /* silence warning */
+        rc = devman_get_handles_once(method, arg1, NULL, 0,
+            &act_size);
+        if (rc != EOK)
+                return rc;
+        alloc_size = act_size;
+        handles = malloc(alloc_size);
+        if (handles == NULL)
+                return ENOMEM;
+        while (true) {
+                rc = devman_get_handles_once(method, arg1, handles, alloc_size,
+                    &act_size);
+                if (rc != EOK)
+                        return rc;
+                if (act_size <= alloc_size)
+                        break;
+                alloc_size *= 2;
+                free(handles);
+                handles = malloc(alloc_size);
+                if (handles == NULL)
+                        return ENOMEM;
+        }
+        *count = act_size / sizeof(devman_handle_t);
+        *data = handles;
+        return EOK;
+}
+int devman_fun_get_child(devman_handle_t funh, devman_handle_t *devh)
+{
+        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+        if (exch == NULL)
+                return ENOMEM;
+        sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_GET_CHILD,
+            funh, devh);
+        devman_exchange_end(exch);
+        return (int) retval;
+}
+int devman_dev_get_functions(devman_handle_t devh, devman_handle_t **funcs,
+    size_t *count)
+{
+        return devman_get_handles_internal(DEVMAN_DEV_GET_FUNCTIONS,
+            devh, funcs, count);
+}
+int devman_fun_sid_to_handle(service_id_t sid, devman_handle_t *handle)
+{
+        async_exch_t *exch = devman_exchange_begin(DEVMAN_CLIENT);
+        if (exch == NULL)
+                return ENOMEM;
+        sysarg_t retval = async_req_1_1(exch, DEVMAN_FUN_SID_TO_HANDLE,
+            sid, handle);
+        devman_exchange_end(exch);
+        return (int) retval;
+}
 /** @}

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

-              r2bdf8313
+              rb0f00a9
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 …
 #include <assert.h>
 #include <as.h>
+#include <elf/elf.h>
 #include <unistd.h>
 #include <fcntl.h>
 …
 #include <entry_point.h>
+#include "elf.h"
+#include "elf_load.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 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;
 …
         uintptr_t seg_addr;
         size_t mem_sz;
         int rc;
+        ssize_t rc;
         bias = elf->bias;
 …
                 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;

uspace/lib/c/generic/event.c

-              r2bdf8313
+              rb0f00a9
 #include <libc.h>
 #include <event.h>
-#include <kernel/ipc/event_types.h>
 /** Subscribe event notifications.
 …
  */
 int event_subscribe(event_type_t evno, sysarg_t imethod)
+{
+        return __SYSCALL2(SYS_EVENT_SUBSCRIBE, (sysarg_t) evno,
+            (sysarg_t) imethod);
+}
+int event_task_subscribe(event_task_type_t evno, sysarg_t imethod)
+{
         return __SYSCALL2(SYS_EVENT_SUBSCRIBE, (sysarg_t) evno,
 …
+}
+int event_task_unmask(event_task_type_t evno)
+{
+        return __SYSCALL1(SYS_EVENT_UNMASK, (sysarg_t) evno);
+}
 /** @}
  */

uspace/lib/c/generic/fibril.c

-              r2bdf8313
+              rb0f00a9
 #include <unistd.h>
 #include <stdio.h>
 #include <arch/barrier.h>
+#include <libarch/barrier.h>
 #include <libarch/faddr.h>
 #include <futex.h>
 …
         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

-              r2bdf8313
+              rb0f00a9
                 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

-              r2bdf8313
+              rb0f00a9
 #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_req_0_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_req_1_0(exch, CONSOLE_SET_STYLE, style);
+        async_exchange_end(exch);
+}
+void console_set_color(console_ctrl_t *ctrl, uint8_t bgcolor, uint8_t fgcolor,
     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_req_3_0(exch, CONSOLE_SET_COLOR, bgcolor, fgcolor, flags);
+        async_exchange_end(exch);
+}
+void console_set_rgb_color(console_ctrl_t *ctrl, uint32_t bgcolor,
+    uint32_t fgcolor)
+{
+        async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
+        async_req_2_0(exch, CONSOLE_SET_RGB_COLOR, bgcolor, fgcolor);
+        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_req_1_0(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_req_2_0(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

-              r2bdf8313
+              rb0f00a9
 #include <io/klog.h>
 #include <vfs/vfs.h>
+#include <ipc/devmap.h>
+#include <vfs/vfs_sess.h>
+#include <ipc/loc.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,
 …
 static LIST_INITIALIZE(files);
 void __stdio_init(int filc, fdi_node_t *filv[])
+void __stdio_init(int filc)
+{
         if (filc > 0) {
                 stdin = fopen_node(filv[0], "r");
+                stdin = fdopen(0, "r");
         } else {
                 stdin = &stdin_null;
 …
         if (filc > 1) {
                 stdout = fopen_node(filv[1], "w");
+                stdout = fdopen(1, "w");
         } else {
                 stdout = &stdout_klog;
 …
         if (filc > 2) {
                 stderr = fopen_node(filv[2], "w");
+                stderr = fdopen(2, "w");
         } else {
                 stderr = &stderr_klog;
 …
 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);
 …
+}
-FILE *fopen_node(fdi_node_t *node, const char *mode)
+{
-        int flags;
-        if (!parse_mode(mode, &flags))
-                return NULL;
-        /* Open file. */
-        FILE *stream = malloc(sizeof(FILE));
-        if (stream == NULL) {
-                errno = ENOMEM;
-                return NULL;
+        }
-        stream->fd = open_node(node, flags);
-        if (stream->fd < 0) {
-                /* errno was set by open_node() */
-                free(stream);
-                return NULL;
+        }
-        stream->error = false;
-        stream->eof = false;
-        stream->klog = false;
-        stream->phone = -1;
-        stream->need_sync = false;
-        _setvbuf(stream);
-        list_append(&stream->link, &files);
-        return stream;
+}
 int fclose(FILE *stream)
+{
 …
         fflush(stream);
         if (stream->phone >= 0)
                 async_hangup(stream->phone);
+        if (stream->sess != NULL)
+                async_hangup(stream->sess);
         if (stream->fd >= 0)
 …
         bytes_used = stream->buf_head - stream->buf_tail;
-        if (bytes_used == 0)
-                return;
         /* If buffer has prefetched read data, we need to seek back. */
         if (stream->buf_state == _bs_read)
+        if (bytes_used > 0 && stream->buf_state == _bs_read)
                 lseek(stream->fd, - (ssize_t) bytes_used, SEEK_CUR);
         /* If buffer has unwritten data, we need to write them out. */
         if (stream->buf_state == _bs_write)
+        if (bytes_used > 0 && stream->buf_state == _bs_write)
                 (void) _fwrite(stream->buf_tail, 1, bytes_used, stream);
 …
+                }
                 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;
+}
+int fnode(FILE *stream, fdi_node_t *node)
+{
+        if (stream->fd >= 0)
+                return fd_node(stream->fd, node);
+                if (stream->sess == NULL)
+                        stream->sess = fd_session(mgmt, stream->fd);
+                return stream->sess;
+        }
+        return NULL;
+}
+int fhandle(FILE *stream, int *handle)
+{
+        if (stream->fd >= 0) {
+                *handle = stream->fd;
+                return EOK;
+        }
         return ENOENT;

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

-              r2bdf8313
+              rb0f00a9
 #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/printf_core.c

-              r2bdf8313
+              rb0f00a9
 #define PRINT_NUMBER_BUFFER_SIZE  (64 + 5)
+/** Get signed or unsigned integer argument */
+#define PRINTF_GET_INT_ARGUMENT(type, ap, flags) \
+        ({ \
+                unsigned type res; \
+                \
+                if ((flags) & __PRINTF_FLAG_SIGNED) { \
+                        signed type arg = va_arg((ap), signed type); \
+                        \
+                        if (arg < 0) { \
+                                res = -arg; \
+                                (flags) |= __PRINTF_FLAG_NEGATIVE; \
+                        } else \
+                                res = arg; \
+                } else \
+                        res = va_arg((ap), unsigned type); \
+                \
+                res; \
+        })
 /** Enumeration of possible arguments types.
  */
 …
+        }
         return (int) (counter + 1);
+        return (int) (counter);
+}
 …
+        }
         return (int) (counter + 1);
+        return (int) (counter);
+}
 …
                         size_t size;
                         uint64_t number;
                         switch (qualifier) {
                         case PrintfQualifierByte:
                                 size = sizeof(unsigned char);
                                 number = (uint64_t) va_arg(ap, unsigned int);
+                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
                                 break;
                         case PrintfQualifierShort:
                                 size = sizeof(unsigned short);
                                 number = (uint64_t) va_arg(ap, unsigned int);
+                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
                                 break;
                         case PrintfQualifierInt:
                                 size = sizeof(unsigned int);
                                 number = (uint64_t) va_arg(ap, unsigned int);
+                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
                                 break;
                         case PrintfQualifierLong:
                                 size = sizeof(unsigned long);
                                 number = (uint64_t) va_arg(ap, unsigned long);
+                                number = PRINTF_GET_INT_ARGUMENT(long, ap, flags);
                                 break;
                         case PrintfQualifierLongLong:
                                 size = sizeof(unsigned long long);
                                 number = (uint64_t) va_arg(ap, unsigned long long);
+                                number = PRINTF_GET_INT_ARGUMENT(long long, ap, flags);
                                 break;
                         case PrintfQualifierPointer:
 …
                                 counter = -counter;
                                 goto out;
+                        }
-                        if (flags & __PRINTF_FLAG_SIGNED) {
-                                if (number & (0x1 << (size * 8 - 1))) {
-                                        flags |= __PRINTF_FLAG_NEGATIVE;
-                                        if (size == sizeof(uint64_t)) {
-                                                number = -((int64_t) number);
-                                        } else {
-                                                number = ~number;
-                                                number &=
-                                                    ~(0xFFFFFFFFFFFFFFFFll <<
-                                                    (size * 8));
-                                                number++;
+                                        }
+                                }
+                        }

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

-              r2bdf8313
+              rb0f00a9
 /** 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

-              r2bdf8313
+              rb0f00a9
 #include <futex.h>
 #include <fibril.h>
+#include <macros.h>
 /**
 …
         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 callback connection.
+ *
  * The @a taskhash and @a phonehash identifiers returned
+ * The @a task_id and @a phonehash identifiers returned
  * by the kernel can be used for connection tracking.
+ *
 …
  * @param arg2      User defined argument.
  * @param arg3      User defined argument.
  * @param taskhash  Opaque identifier of the client task.
+ * @param task_id   Identifier of the client task.
  * @param phonehash Opaque identifier of the phone that will
  *                  be used for incoming calls.
 …
  */
 int ipc_connect_to_me(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
+    sysarg_t *taskhash, sysarg_t *phonehash)
+{
+        return ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_TO_ME, arg1, arg2,
+            arg3, NULL, NULL, NULL, taskhash, phonehash);
+    task_id_t *task_id, sysarg_t *phonehash)
+{
+        ipc_call_t data;
+        int rc = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid,
+            IPC_M_CONNECT_TO_ME, arg1, arg2, arg3, (sysarg_t) &data);
+        if (rc == EOK) {
+                *task_id = data.in_task_id;
+                *phonehash = IPC_GET_ARG5(data);
+        }
+        return rc;
+}
+/** 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;
+}

uspace/lib/c/generic/libc.c

-              r2bdf8313
+              rb0f00a9
 #include "private/libc.h"
 #include "private/async.h"
-#include "private/async_sess.h"
 #include "private/malloc.h"
 #include "private/io.h"
 …
         __malloc_init();
         __async_init();
-        __async_sess_init();
         fibril_t *fibril = fibril_setup();
 …
                 argc = 0;
                 argv = NULL;
                 __stdio_init(0, NULL);
+                __stdio_init(0);
         } else {
                 argc = __pcb->argc;
                 argv = __pcb->argv;
                 __stdio_init(__pcb->filc, __pcb->filv);
+                __stdio_init(__pcb->filc);
                 (void) chdir(__pcb->cwd);
+        }

uspace/lib/c/generic/loader.c

-              r2bdf8313
+              rb0f00a9
 #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;
+}
 …
+ *
  */
+int loader_set_files(loader_t *ldr, fdi_node_t *const files[])
+{
+        /*
+         * Serialize the arguments into a single array. First
+         * compute size of the buffer needed.
+         */
+        fdi_node_t *const *ap = files;
+        size_t count = 0;
+        while (*ap != NULL) {
+                count++;
+                ap++;
+        }
+        fdi_node_t *files_buf;
+        files_buf = (fdi_node_t *) malloc(count * sizeof(fdi_node_t));
+        if (files_buf == NULL)
+                return ENOMEM;
+        /* Fill the buffer */
+        size_t i;
+        for (i = 0; i < count; i++)
+                files_buf[i] = *files[i];
+int loader_set_files(loader_t *ldr, int * const files[])
+{
         /* 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,
+            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 */
+        free(files_buf);
+        return EOK;
+        async_exch_t *exch = async_exchange_begin(ldr->sess);
+        async_exch_t *vfs_exch = vfs_exchange_begin();
+        int i;
+        for (i = 0; files[i]; i++);
+        ipc_call_t answer;
+        aid_t req = async_send_1(exch, LOADER_SET_FILES, i, &answer);
+        sysarg_t rc = EOK;
+        for (i = 0; files[i]; i++) {
+                rc = async_state_change_start(exch, VFS_PASS_HANDLE, *files[i],
+, vfs_exch);
+                if (rc != EOK)
+                        break;
+        }
+        vfs_exchange_end(vfs_exch);
+        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_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

-              r2bdf8313
+              rb0f00a9
         (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.
+ *
 …
 /** 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 */
 …
                 if (!(expr)) {\
                         futex_up(&malloc_futex); \
                         assert_abort(#expr, __FILE__, STR2(__LINE__)); \
+                        assert_abort(#expr, __FILE__, __LINE__); \
                 } \
         } while (0)
 …
         /* Eventually try to create a new area */
         return area_create(AREA_FIRST_BLOCK_HEAD(size));
+        return area_create(AREA_OVERHEAD(size));
+}
 …
                         /* Update heap area parameters */
                         area->end = end;
+                        /* Update block layout */
+                        void *last = (void *) last_head;
+                        size_t excess = (size_t) (area->end - last);
+                        size_t excess = ((size_t) area->end) - ((size_t) last_head);
                         if (excess > 0) {
 …
                                          * create a new free block.
                                          */
                                         block_init(last, excess, true, area);
+                                        block_init((void *) last_head, excess, true, area);
                                 } else {
                                         /*
 …
+        }
         next = NULL;
+        next_fit = NULL;
+}
 …
                                 split_mark(cur, real_size);
                                 next = cur;
+                                next_fit = cur;
                                 return addr;
                         } else {
 …
                                                 split_mark(next_head, real_size);
                                                 next = next_head;
+                                                next_fit = next_head;
                                                 return aligned;
                                         } else {
 …
                                                         split_mark(cur, real_size);
                                                         next = cur;
+                                                        next_fit = cur;
                                                         return aligned;
+                                                }
 …
         /* Try the next fit approach */
         split = next;
+        split = next_fit;
         if (split != NULL) {
 …
                         ptr = ((void *) head) + sizeof(heap_block_head_t);
                         next = NULL;
+                        next_fit = NULL;
                 } else
                         reloc = true;
 …
 void free(const void *addr)
+{
+        if (addr == NULL)
+                return;
         futex_down(&malloc_futex);

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

-              r2bdf8313
+              rb0f00a9
  * 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

r2bdf8313	rb0f00a9
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

-              r2bdf8313
+              rb0f00a9
 #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/packet.c

-              r2bdf8313
+              rb0f00a9
  */
+#include <assert.h>
 #include <malloc.h>
 #include <mem.h>
 …
 #include <sys/mman.h>
 #include <adt/generic_field.h>
+#include <adt/hash_table.h>
 #include <net/packet.h>
 #include <net/packet_header.h>
+/** Packet map page size. */
+#define PACKET_MAP_SIZE 100
+/** Returns the packet map page index.
+ * @param[in] packet_id The packet identifier.
+ */
+#define PACKET_MAP_PAGE(packet_id)      (((packet_id) - 1) / PACKET_MAP_SIZE)
+/** Returns the packet index in the corresponding packet map page.
+ *  @param[in] packet_id The packet identifier.
+ */
+#define PACKET_MAP_INDEX(packet_id)     (((packet_id) - 1) % PACKET_MAP_SIZE)
+/** Type definition of the packet map page. */
+typedef packet_t *packet_map_t[PACKET_MAP_SIZE];
+/** Packet map.
+ * Maps packet identifiers to the packet references.
+ * @see generic_field.h
+ */
+GENERIC_FIELD_DECLARE(gpm, packet_map_t);
+/** Packet hash table size. */
+#define PACKET_HASH_TABLE_SIZE  128
 /** Packet map global data. */
 …
         fibril_rwlock_t lock;
         /** Packet map. */
+        gpm_t packet_map;
+        hash_table_t packet_map;
+        /** Packet map operations */
+        hash_table_operations_t operations;
 } pm_globals;
+GENERIC_FIELD_IMPLEMENT(gpm, packet_map_t);
+typedef struct {
+        link_t link;
+        packet_t *packet;
+} pm_entry_t;
+/**
+ * Hash function for the packet mapping hash table
+ */
+static hash_index_t pm_hash(unsigned long key[])
+{
+        return (hash_index_t) key[0] % PACKET_HASH_TABLE_SIZE;
+}
+/**
+ * Key compare function for the packet mapping hash table
+ */
+static int pm_compare(unsigned long key[], hash_count_t keys, link_t *link)
+{
+        pm_entry_t *entry = list_get_instance(link, pm_entry_t, link);
+        return entry->packet->packet_id == key[0];
+}
+/**
+ * Remove callback for the packet mapping hash table
+ */
+static void pm_remove_callback(link_t *link)
+{
+        pm_entry_t *entry = list_get_instance(link, pm_entry_t, link);
+        free(entry);
+}
+/**
+ * Wrapper used when destroying the whole table
+ */
+static void pm_free_wrapper(link_t *link, void *ignored)
+{
+        pm_entry_t *entry = list_get_instance(link, pm_entry_t, link);
+        free(entry);
+}
 /** Initializes the packet map.
 …
 int pm_init(void)
+{
         int rc;
+        int rc = EOK;
         fibril_rwlock_initialize(&pm_globals.lock);
         fibril_rwlock_write_lock(&pm_globals.lock);
+        rc = gpm_initialize(&pm_globals.packet_map);
+        pm_globals.operations.hash = pm_hash;
+        pm_globals.operations.compare = pm_compare;
+        pm_globals.operations.remove_callback = pm_remove_callback;
+        if (!hash_table_create(&pm_globals.packet_map, PACKET_HASH_TABLE_SIZE, 1,
+            &pm_globals.operations))
+                rc = ENOMEM;
         fibril_rwlock_write_unlock(&pm_globals.lock);
 …
 /** Finds the packet mapping.
+ *
+ * @param[in] packet_id The packet identifier to be found.
+ * @return              The found packet reference.
+ * @return              NULL if the mapping does not exist.
+ * @param[in] packet_id Packet identifier to be found.
+ *
+ * @return The found packet reference.
+ * @return NULL if the mapping does not exist.
+ *
  */
 packet_t *pm_find(packet_id_t packet_id)
+{
-        packet_map_t *map;
-        packet_t *packet;
         if (!packet_id)
                 return NULL;
         fibril_rwlock_read_lock(&pm_globals.lock);
+        if (packet_id > PACKET_MAP_SIZE * gpm_count(&pm_globals.packet_map)) {
+                fibril_rwlock_read_unlock(&pm_globals.lock);
+                return NULL;
+        }
+        map = gpm_get_index(&pm_globals.packet_map, PACKET_MAP_PAGE(packet_id));
+        if (!map) {
+                fibril_rwlock_read_unlock(&pm_globals.lock);
+                return NULL;
+        }
+        packet = (*map) [PACKET_MAP_INDEX(packet_id)];
+        unsigned long key = packet_id;
+        link_t *link = hash_table_find(&pm_globals.packet_map, &key);
+        packet_t *packet;
+        if (link != NULL) {
+                pm_entry_t *entry =
+                    hash_table_get_instance(link, pm_entry_t, link);
+                packet = entry->packet;
+        } else
+                packet = NULL;
         fibril_rwlock_read_unlock(&pm_globals.lock);
         return packet;
 …
 /** Adds the packet mapping.
+ *
+ * @param[in] packet    The packet to be remembered.
+ * @return              EOK on success.
+ * @return              EINVAL if the packet is not valid.
+ * @return              EINVAL if the packet map is not initialized.
+ * @return              ENOMEM if there is not enough memory left.
+ * @param[in] packet Packet to be remembered.
+ *
+ * @return EOK on success.
+ * @return EINVAL if the packet is not valid.
+ * @return ENOMEM if there is not enough memory left.
+ *
  */
 int pm_add(packet_t *packet)
+{
-        packet_map_t *map;
-        int rc;
         if (!packet_is_valid(packet))
                 return EINVAL;
         fibril_rwlock_write_lock(&pm_globals.lock);
+        if (PACKET_MAP_PAGE(packet->packet_id) <
+            gpm_count(&pm_globals.packet_map)) {
+                map = gpm_get_index(&pm_globals.packet_map,
+                    PACKET_MAP_PAGE(packet->packet_id));
+        } else {
+                do {
+                        map = (packet_map_t *) malloc(sizeof(packet_map_t));
+                        if (!map) {
+                                fibril_rwlock_write_unlock(&pm_globals.lock);
+                                return ENOMEM;
+                        }
+                        bzero(map, sizeof(packet_map_t));
+                        rc = gpm_add(&pm_globals.packet_map, map);
+                        if (rc < 0) {
+                                fibril_rwlock_write_unlock(&pm_globals.lock);
+                                free(map);
+                                return rc;
+                        }
+                } while (PACKET_MAP_PAGE(packet->packet_id) >=
+                    gpm_count(&pm_globals.packet_map));
+        pm_entry_t *entry = malloc(sizeof(pm_entry_t));
+        if (entry == NULL) {
+                fibril_rwlock_write_unlock(&pm_globals.lock);
+                return ENOMEM;
+        }
+        (*map) [PACKET_MAP_INDEX(packet->packet_id)] = packet;
+        entry->packet = packet;
+        unsigned long key = packet->packet_id;
+        hash_table_insert(&pm_globals.packet_map, &key, &entry->link);
         fibril_rwlock_write_unlock(&pm_globals.lock);
         return EOK;
+}
+/** Releases the packet map. */
+/** Remove the packet mapping
+ *
+ * @param[in] packet The packet to be removed
+ *
+ */
+void pm_remove(packet_t *packet)
+{
+        assert(packet_is_valid(packet));
+        fibril_rwlock_write_lock(&pm_globals.lock);
+        unsigned long key = packet->packet_id;
+        hash_table_remove(&pm_globals.packet_map, &key, 1);
+        fibril_rwlock_write_unlock(&pm_globals.lock);
+}
+/** Release the packet map. */
 void pm_destroy(void)
+{
-        int count;
-        int index;
-        packet_map_t *map;
-        packet_t *packet;
         fibril_rwlock_write_lock(&pm_globals.lock);
+        count = gpm_count(&pm_globals.packet_map);
+        while (count > 0) {
+                map = gpm_get_index(&pm_globals.packet_map, count - 1);
+                for (index = PACKET_MAP_SIZE - 1; index >= 0; --index) {
+                        packet = (*map)[index];
+                        if (packet_is_valid(packet))
+                                munmap(packet, packet->length);
+                }
+        }
+        gpm_destroy(&pm_globals.packet_map, free);
+        /* leave locked */
+        hash_table_apply(&pm_globals.packet_map, pm_free_wrapper, NULL);
+        hash_table_destroy(&pm_globals.packet_map);
+        /* Leave locked */
+}
 …
  * The packet is inserted right before the packets of the same order value.
+ *
+ * @param[in,out] first The first packet of the queue. Sets the first packet of
+ *                      the queue. The original first packet may be shifted by
+ *                      the new packet.
+ * @param[in] packet    The packet to be added.
+ * @param[in] order     The packet order value.
+ * @param[in] metric    The metric value of the packet.
+ * @return              EOK on success.
+ * @return              EINVAL if the first parameter is NULL.
+ * @return              EINVAL if the packet is not valid.
+ * @param[in,out] first First packet of the queue. Sets the first
+ *                      packet of the queue. The original first packet
+ *                      may be shifted by the new packet.
+ * @param[in] packet    Packet to be added.
+ * @param[in] order     Packet order value.
+ * @param[in] metric    Metric value of the packet.
+ *
+ * @return EOK on success.
+ * @return EINVAL if the first parameter is NULL.
+ * @return EINVAL if the packet is not valid.
+ *
  */
 int pq_add(packet_t **first, packet_t *packet, size_t order, size_t metric)
+{
+        packet_t *item;
+        if (!first || !packet_is_valid(packet))
+        if ((!first) || (!packet_is_valid(packet)))
                 return EINVAL;
         pq_set_order(packet, order, metric);
         if (packet_is_valid(*first)) {
+                item = * first;
+                packet_t *cur = *first;
                 do {
+                        if (item->order < order) {
+                                if (item->next) {
+                                        item = pm_find(item->next);
+                                } else {
+                                        item->next = packet->packet_id;
+                                        packet->previous = item->packet_id;
+                        if (cur->order < order) {
+                                if (cur->next)
+                                        cur = pm_find(cur->next);
+                                else {
+                                        cur->next = packet->packet_id;
+                                        packet->previous = cur->packet_id;
                                         return EOK;
+                                }
                         } else {
+                                packet->previous = item->previous;
+                                packet->next = item->packet_id;
+                                item->previous = packet->packet_id;
+                                item = pm_find(packet->previous);
+                                if (item)
+                                        item->next = packet->packet_id;
+                                packet->previous = cur->previous;
+                                packet->next = cur->packet_id;
+                                cur->previous = packet->packet_id;
+                                cur = pm_find(packet->previous);
+                                if (cur)
+                                        cur->next = packet->packet_id;
                                 else
                                         *first = packet;
                                 return EOK;
+                        }
                 } while (packet_is_valid(item));
+                } while (packet_is_valid(cur));
+        }
         *first = packet;
         return EOK;
 …
         next = pm_find(packet->next);
         if (next) {
+        if (next)
                 next->previous = packet->previous;
+                previous = pm_find(next->previous);
+                if (previous)
+                        previous->next = next->packet_id;
+        }
+        previous = pm_find(packet->previous);
+        if (previous)
+                previous->next = packet->next ;
         packet->previous = 0;
         packet->next = 0;

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

-              r2bdf8313
+              rb0f00a9
 #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/private/async.h

-              r2bdf8313
+              rb0f00a9
 #define LIBC_PRIVATE_ASYNC_H_
+#include <async.h>
 #include <adt/list.h>
 #include <fibril.h>
+#include <fibril_synch.h>
 #include <sys/time.h>
 #include <bool.h>
 …
 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/io.h

-              r2bdf8313
+              rb0f00a9
 #define LIBC_PRIVATE_IO_H_
+#include <vfs/vfs.h>
+extern void __stdio_init(int filc, fdi_node_t *filv[]);
+extern void __stdio_init(int);
 extern void __stdio_done(void);

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

-              r2bdf8313
+              rb0f00a9
  */
 #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/private/stdio.h

-              r2bdf8313
+              rb0f00a9
 /*
+ * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2008 Martin Decky
+ * Copyright (c) 2011 Martin Decky
  * All rights reserved.
+ *
 …
  */
+/** @defgroup msimfb MSIM text console
+ * @brief HelenOS MSIM text console.
+ * @ingroup fbs
+/** @addtogroup libc
  * @{
  */
 …
  */
+#ifndef LIBC_PRIVATE_STDIO_H_
+#define LIBC_PRIVATE_STDIO_H_
+#include <adt/list.h>
+#include <stdio.h>
 #include <async.h>
-#include <libc.h>
-#include <sysinfo.h>
-#include <as.h>
-#include <ddi.h>
-#include <errno.h>
+#include "serial_console.h"
+#include "msim.h"
+struct _IO_FILE {
+        /** Linked list pointer. */
+        link_t link;
+        /** Underlying file descriptor. */
+        int fd;
+        /** Error indicator. */
+        int error;
+        /** End-of-file indicator. */
+        int eof;
+        /** Klog indicator */
+        int klog;
+        /** Session to the file provider */
+        async_sess_t *sess;
+        /**
+         * Non-zero if the stream needs sync on fflush(). XXX change
+         * console semantics so that sync is not needed.
+         */
+        int need_sync;
+        /** Buffering type */
+        enum _buffer_type btype;
+        /** Buffer */
+        uint8_t *buf;
+        /** Buffer size */
+        size_t buf_size;
+        /** Buffer state */
+        enum _buffer_state buf_state;
+        /** Buffer I/O pointer */
+        uint8_t *buf_head;
+        /** Points to end of occupied space when in read mode. */
+        uint8_t *buf_tail;
+};
+#define WIDTH 80
+#define HEIGHT 24
+static char *virt_addr;
+static void msim_putc(const char c)
+{
+        *virt_addr = c;
+}
+int msim_init(void)
+{
+        sysarg_t phys_addr;
+        if (sysinfo_get_value("fb.address.physical", &phys_addr) != EOK)
+                return -1;
+        virt_addr = (char *) as_get_mappable_page(1);
+        if (physmem_map((void *) phys_addr, virt_addr, 1,
+            AS_AREA_READ | AS_AREA_WRITE) != 0)
+                return -1;
+        serial_console_init(msim_putc, WIDTH, HEIGHT);
+        async_set_client_connection(serial_client_connection);
+        return 0;
+}
+#endif
 /** @}

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

r2bdf8313	rb0f00a9
36	36	#define LIBC_PRIVATE_THREAD_H_
37	37
38		#include <~~kernel~~/proc/uarg.h>
	38	#include <abi/proc/uarg.h>
39	39
40	40	extern void __thread_entry(void);

uspace/lib/c/generic/rtld/module.c

-              r2bdf8313
+              rb0f00a9
  */
+#include <adt/list.h>
+#include <elf/elf_load.h>
+#include <fcntl.h>
+#include <loader/pcb.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
-#include <fcntl.h>
-#include <adt/list.h>
-#include <loader/pcb.h>
 #include <rtld/rtld.h>
 …
 #include <rtld/rtld_arch.h>
 #include <rtld/module.h>
-#include <elf_load.h>
 /** (Eagerly) process all relocation tables in a module.
 …
 module_t *module_find(const char *name)
+{
-        link_t *head = &runtime_env->modules_head;
-        link_t *cur;
         module_t *m;
         const char *p, *soname;
 …
         /* Traverse list of all modules. Not extremely fast, but simple */
+        DPRINTF("head = %p\n", head);
+        for (cur = head->next; cur != head; cur = cur->next) {
+        list_foreach(runtime_env->modules, cur) {
                 DPRINTF("cur = %p\n", cur);
                 m = list_get_instance(cur, module_t, modules_link);
 …
         /* Insert into the list of loaded modules */
         list_append(&m->modules_link, &runtime_env->modules_head);
+        list_append(&m->modules_link, &runtime_env->modules);
         return m;
 …
 void modules_process_relocs(module_t *start)
+{
+        link_t *head = &runtime_env->modules_head;
+        link_t *cur;
+        module_t *m;
+        for (cur = head->next; cur != head; cur = cur->next) {
+        module_t *m;
+        list_foreach(runtime_env->modules, cur) {
                 m = list_get_instance(cur, module_t, modules_link);
 …
 void modules_untag(void)
+{
+        link_t *head = &runtime_env->modules_head;
+        link_t *cur;
+        module_t *m;
+        for (cur = head->next; cur != head; cur = cur->next) {
+        module_t *m;
+        list_foreach(runtime_env->modules, cur) {
                 m = list_get_instance(cur, module_t, modules_link);
                 m->bfs_tag = false;

uspace/lib/c/generic/rtld/rtld.c

r2bdf8313	rb0f00a9
44	44	{
45	45	runtime_env = &rt_env_static;
46		list_initialize(&runtime_env->modules~~_head~~);
	46	list_initialize(&runtime_env->modules);
47	47	runtime_env->next_bias = 0x2000000;
48	48	runtime_env->program = NULL;

uspace/lib/c/generic/rtld/symbol.c

-              r2bdf8313
+              rb0f00a9
 #include <stdlib.h>
+#include <elf/elf.h>
 #include <rtld/rtld.h>
 #include <rtld/rtld_debug.h>
 #include <rtld/symbol.h>
-#include <elf.h>
 /*
 …
         module_t *m, *dm;
         elf_symbol_t *sym, *s;
         link_t queue_head;
+        list_t queue;
         size_t i;
 …
         /* Insert root (the program) into the queue and tag it */
         list_initialize(&queue_head);
+        list_initialize(&queue);
         start->bfs_tag = true;
         list_append(&start->queue_link, &queue_head);
+        list_append(&start->queue_link, &queue);
         /* If the symbol is found, it will be stored in 'sym' */
 …
         /* While queue is not empty */
         while (!list_empty(&queue_head)) {
+        while (!list_empty(&queue)) {
                 /* Pop first element from the queue */
                 m = list_get_instance(queue_head.next, module_t, queue_link);
+                m = list_get_instance(list_first(&queue), module_t, queue_link);
                 list_remove(&m->queue_link);
 …
                         if (dm->bfs_tag == false) {
                                 dm->bfs_tag = true;
                                 list_append(&dm->queue_link, &queue_head);
+                                list_append(&dm->queue_link, &queue);
+                        }
+                }
 …
         /* Empty the queue so that we leave it in a clean state */
         while (!list_empty(&queue_head))
                 list_remove(queue_head.next);
+        while (!list_empty(&queue))
+                list_remove(list_first(&queue));
         if (!sym) {

uspace/lib/c/generic/str.c

-              r2bdf8313
+              rb0f00a9
  * Copyright (c) 2005 Martin Decky
  * Copyright (c) 2008 Jiri Svoboda
+ * Copyright (c) 2011 Martin Sucha
+ * Copyright (c) 2011 Oleg Romanenko
  * All rights reserved.
+ *
 …
         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-width 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;
+}
 …
         dest[dest_off] = '\0';
+}
+/** Convert UTF16 string to string.
+ *
+ * Convert utf16 string @a src to string. The output is written to the buffer
+ * specified by @a dest and @a size. @a size must be non-zero and the string
+ * written will always be well-formed. Surrogate pairs also supported.
+ *
+ * @param dest  Destination buffer.
+ * @param size  Size of the destination buffer.
+ * @param src   Source utf16 string.
+ *
+ * @return EOK, if success, negative otherwise.
+ */
+int utf16_to_str(char *dest, size_t size, const uint16_t *src)
+{
+        size_t idx = 0, dest_off = 0;
+        wchar_t ch;
+        int rc = EOK;
+        /* There must be space for a null terminator in the buffer. */
+        assert(size > 0);
+        while (src[idx]) {
+                if ((src[idx] & 0xfc00) == 0xd800) {
+                        if (src[idx + 1] && (src[idx + 1] & 0xfc00) == 0xdc00) {
+                                ch = 0x10000;
+                                ch += (src[idx] & 0x03FF) << 10;
+                                ch += (src[idx + 1] & 0x03FF);
+                                idx += 2;
+                        }
+                        else
+                                break;
+                } else {
+                        ch = src[idx];
+                        idx++;
+                }
+                rc = chr_encode(ch, dest, &dest_off, size - 1);
+                if (rc != EOK)
+                        break;
+        }
+        dest[dest_off] = '\0';
+        return rc;
+}
+int str_to_utf16(uint16_t *dest, size_t size, const char *src)
+{
+        int rc = EOK;
+        size_t offset = 0;
+        size_t idx = 0;
+        wchar_t c;
+        assert(size > 0);
+        while ((c = str_decode(src, &offset, STR_NO_LIMIT)) != 0) {
+                if (c > 0x10000) {
+                        if (idx + 2 >= size - 1) {
+                                rc = EOVERFLOW;
+                                break;
+                        }
+                        c = (c - 0x10000);
+                        dest[idx] = 0xD800 | (c >> 10);
+                        dest[idx + 1] = 0xDC00 | (c & 0x3FF);
+                        idx++;
+                } else {
+                         dest[idx] = c;
+                }
+                idx++;
+                if (idx >= size - 1) {
+                        rc = EOVERFLOW;
+                        break;
+                }
+        }
+        dest[idx] = '\0';
+        return rc;
+}
 /** Convert wide string to new string.
 …
+}
+/** Convert string to wide string.
+ *
+ * Convert string @a src to wide string. A new wide NULL-terminated
+ * string will be allocated on the heap.
+ *
+ * @param src   Source string.
+ */
+wchar_t *str_to_awstr(const char *str)
+{
+        size_t len = str_length(str);
+        wchar_t *wstr = calloc(len+1, sizeof(wchar_t));
+        if (wstr == NULL)
+                return NULL;
+        str_to_wstr(wstr, len + 1, str);
+        return wstr;
+}
 /** Find first occurence of character in string.
+ *
 …
         return NULL;
+}
+/** Removes specified trailing characters from a string.
+ *
+ * @param str String to remove from.
+ * @param ch  Character to remove.
+ */
+void str_rtrim(char *str, wchar_t ch)
+{
+        size_t off = 0;
+        size_t pos = 0;
+        wchar_t c;
+        bool update_last_chunk = true;
+        char *last_chunk = NULL;
+        while ((c = str_decode(str, &off, STR_NO_LIMIT))) {
+                if (c != ch) {
+                        update_last_chunk = true;
+                        last_chunk = NULL;
+                } else if (update_last_chunk) {
+                        update_last_chunk = false;
+                        last_chunk = (str + pos);
+                }
+                pos = off;
+        }
+        if (last_chunk)
+                *last_chunk = '\0';
+}
+/** Removes specified leading characters from a string.
+ *
+ * @param str String to remove from.
+ * @param ch  Character to remove.
+ */
+void str_ltrim(char *str, wchar_t ch)
+{
+        wchar_t acc;
+        size_t off = 0;
+        size_t pos = 0;
+        size_t str_sz = str_size(str);
+        while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
+                if (acc != ch)
+                        break;
+                else
+                        pos = off;
+        }
+        if (pos > 0) {
+                memmove(str, &str[pos], str_sz - pos);
+                pos = str_sz - pos;
+                str[str_sz - pos] = '\0';
+        }
+}
 …
         return dest;
+}
 /** Convert initial part of string to unsigned long according to given base.
 …
+}
+/** Convert string to uint8_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+int str_uint8_t(const char *nptr, char **endptr, unsigned int base,
+    bool strict, uint8_t *result)
+{
+        assert(result != NULL);
+        bool neg;
+        char *lendptr;
+        uint64_t res;
+        int ret = str_uint(nptr, &lendptr, base, &neg, &res);
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+        if (ret != EOK)
+                return ret;
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+        /* Check whether we are at the end of
+           the string in strict mode */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+        /* Check for overflow */
+        uint8_t _res = (uint8_t) res;
+        if (_res != res)
+                return EOVERFLOW;
+        *result = _res;
+        return EOK;
+}
+/** Convert string to uint16_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+int str_uint16_t(const char *nptr, char **endptr, unsigned int base,
+    bool strict, uint16_t *result)
+{
+        assert(result != NULL);
+        bool neg;
+        char *lendptr;
+        uint64_t res;
+        int ret = str_uint(nptr, &lendptr, base, &neg, &res);
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+        if (ret != EOK)
+                return ret;
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+        /* Check whether we are at the end of
+           the string in strict mode */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+        /* Check for overflow */
+        uint16_t _res = (uint16_t) res;
+        if (_res != res)
+                return EOVERFLOW;
+        *result = _res;
+        return EOK;
+}
+/** Convert string to uint32_t.
+ *
+ * @param nptr   Pointer to string.
+ * @param endptr If not NULL, pointer to the first invalid character
+ *               is stored here.
+ * @param base   Zero or number between 2 and 36 inclusive.
+ * @param strict Do not allow any trailing characters.
+ * @param result Result of the conversion.
+ *
+ * @return EOK if conversion was successful.
+ *
+ */
+int str_uint32_t(const char *nptr, char **endptr, unsigned int base,
+    bool strict, uint32_t *result)
+{
+        assert(result != NULL);
+        bool neg;
+        char *lendptr;
+        uint64_t res;
+        int ret = str_uint(nptr, &lendptr, base, &neg, &res);
+        if (endptr != NULL)
+                *endptr = (char *) lendptr;
+        if (ret != EOK)
+                return ret;
+        /* Do not allow negative values */
+        if (neg)
+                return EINVAL;
+        /* Check whether we are at the end of
+           the string in strict mode */
+        if ((strict) && (*lendptr != 0))
+                return EINVAL;
+        /* Check for overflow */
+        uint32_t _res = (uint32_t) res;
+        if (_res != res)
+                return EOVERFLOW;
+        *result = _res;
+        return EOK;
+}
 /** Convert string to uint64_t.
+ *

uspace/lib/c/generic/str_error.c

-              r2bdf8313
+              rb0f00a9
  */
+#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/sysinfo.c

r2bdf8313	rb0f00a9
47	47	*
48	48	*/
49		sysinfo_item_~~tag_t sysinfo_get_tag~~(const char *path)
	49	sysinfo_item_val_type_t sysinfo_get_val_type(const char *path)
50	50	{
51		return (sysinfo_item_~~tag_t) __SYSCALL2(SYS_SYSINFO_GET_TAG~~,
	51	return (sysinfo_item_val_type_t) __SYSCALL2(SYS_SYSINFO_GET_VAL_TYPE,
52	52	(sysarg_t) path, (sysarg_t) str_size(path));
53	53	}

uspace/lib/c/generic/task.c

-              r2bdf8313
+              rb0f00a9
 #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"
+#include <vfs/vfs.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;
+        /* Send default files */
+        int *files[4];
+        int fd_stdin;
+        int fd_stdout;
+        int fd_stderr;
+        if ((stdin != NULL) && (fhandle(stdin, &fd_stdin) == EOK))
+                files[0] = &fd_stdin;
+        else
+                files[0] = NULL;
+        if ((stdout != NULL) && (fhandle(stdout, &fd_stdout) == EOK))
+                files[1] = &fd_stdout;
+        else
+                files[1] = NULL;
+        if ((stderr != NULL) && (fhandle(stderr, &fd_stderr) == EOK))
+                files[2] = &fd_stderr;
+        else
+                files[2] = NULL;
+        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[],
+    int *const files[])
+{
         /* Connect to a program loader. */
         ldr = loader_connect();
+        loader_t *ldr = loader_connect();
         if (ldr == NULL)
                 return EREFUSED;
         /* Get task ID. */
+        rc = loader_get_task_id(ldr, &task_id);
+        task_id_t task_id;
+        int rc = loader_get_task_id(ldr, &task_id);
         if (rc != EOK)
                 goto error;
 …
                 goto error;
+        /* Send default files */
+        fdi_node_t *files[4];
+        fdi_node_t stdin_node;
+        fdi_node_t stdout_node;
+        fdi_node_t stderr_node;
+        if ((stdin != NULL) && (fnode(stdin, &stdin_node) == EOK))
+                files[0] = &stdin_node;
+        else
+                files[0] = NULL;
+        if ((stdout != NULL) && (fnode(stdout, &stdout_node) == EOK))
+                files[1] = &stdout_node;
+        else
+                files[1] = NULL;
+        if ((stderr != NULL) && (fnode(stderr, &stderr_node) == EOK))
+                files[2] = &stderr_node;
+        else
+                files[2] = NULL;
+        files[3] = NULL;
+        /* 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

-              r2bdf8313
+              rb0f00a9
 #include <stdlib.h>
 #include <libarch/faddr.h>
 #include <kernel/proc/uarg.h>
+#include <abi/proc/uarg.h>
 #include <fibril.h>
 #include <str.h>
 …
 #ifndef THREAD_INITIAL_STACK_PAGES_NO
 #define THREAD_INITIAL_STACK_PAGES_NO 1
+#define THREAD_INITIAL_STACK_PAGES_NO   2
 #endif

uspace/lib/c/generic/time.c

-              r2bdf8313
+              rb0f00a9
 #include <time.h>
 #include <bool.h>
 #include <arch/barrier.h>
+#include <libarch/barrier.h>
 #include <macros.h>
 #include <errno.h>
 …
+}
+void udelay(useconds_t time)
+{
+        (void) __SYSCALL1(SYS_THREAD_UDELAY, (sysarg_t) time);
+}
 /** Wait unconditionally for specified number of seconds
+ *

uspace/lib/c/generic/udebug.c

-              r2bdf8313
+              rb0f00a9
 #include <udebug.h>
 #include <sys/types.h>
+#include <abi/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

-              r2bdf8313
+              rb0f00a9
  */
+#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 <assert.h>
 #include <str.h>
 #include <devmap.h>
+#include <loc.h>
 #include <ipc/vfs.h>
+#include <ipc/devmap.h>
+static async_sess_t vfs_session;
+static FIBRIL_MUTEX_INITIALIZE(vfs_phone_mutex);
+static int vfs_phone = -1;
+#include <ipc/loc.h>
+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.
+ *
+ */
+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.
+ *
+ */
+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 mount(const char *fs_name, const char *mp, const char *fqsn,
+    const char *opts, unsigned int flags, unsigned int instance)
+{
         int null_id = -1;
         char null[DEVMAP_NAME_MAXLEN];
         if (str_cmp(fqdn, "") == 0) {
+        char null[LOC_NAME_MAXLEN];
+        if (str_cmp(fqsn, "") == 0) {
                 /* No device specified, create a fresh
                    null/%d device instead */
                 null_id = devmap_null_create();
+                null_id = loc_null_create();
                 if (null_id == -1)
                         return ENOMEM;
                 snprintf(null, DEVMAP_NAME_MAXLEN, "null/%d", null_id);
                 fqdn = null;
+        }
         devmap_handle_t devmap_handle;
         int res = devmap_device_get_handle(fqdn, &devmap_handle, flags);
+                snprintf(null, LOC_NAME_MAXLEN, "null/%d", null_id);
+                fqsn = null;
+        }
+        service_id_t service_id;
+        int res = loc_service_get_id(fqsn, &service_id, flags);
         if (res != EOK) {
                 if (null_id != -1)
                         devmap_null_destroy(null_id);
+                        loc_null_destroy(null_id);
                 return res;
 …
         if (!mpa) {
                 if (null_id != -1)
                         devmap_null_destroy(null_id);
+                        loc_null_destroy(null_id);
                 return ENOMEM;
+        }
         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_3(exch, VFS_IN_MOUNT, service_id, flags,
+            instance, 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);
                 if (null_id != -1)
                         devmap_null_destroy(null_id);
                 if (rc_orig == EOK)
                         return (int) rc;
                 else
                         return (int) rc_orig;
+        }
         rc = async_data_write_start(vfs_phone, (void *) opts, str_size(opts));
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+                        loc_null_destroy(null_id);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        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);
                 if (null_id != -1)
                         devmap_null_destroy(null_id);
                 if (rc_orig == EOK)
                         return (int) rc;
                 else
                         return (int) rc_orig;
+        }
         rc = async_data_write_start(vfs_phone, (void *) fs_name, str_size(fs_name));
         if (rc != EOK) {
                 vfs_exchange_end(vfs_phone);
+                        loc_null_destroy(null_id);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        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);
                 if (null_id != -1)
                         devmap_null_destroy(null_id);
+                        loc_null_destroy(null_id);
                 if (rc_orig == EOK)
 …
         /* 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);
                 if (null_id != -1)
                         devmap_null_destroy(null_id);
                 if (rc_orig == EOK)
                         return (int) rc;
                 else
                         return (int) rc_orig;
+        }
         vfs_exchange_end(vfs_phone);
+                        loc_null_destroy(null_id);
+                if (rc_orig == EOK)
+                        return (int) rc;
+                else
+                        return (int) rc_orig;
+        }
+        vfs_exchange_end(exch);
         free(mpa);
         async_wait_for(req, &rc);
         if ((rc != EOK) && (null_id != -1))
                 devmap_null_destroy(null_id);
+                loc_null_destroy(null_id);
         return (int) 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();
-        ipc_call_t answer;
-        aid_t req = async_send_4(vfs_phone, VFS_IN_OPEN_NODE, node->fs_handle,
-            node->devmap_handle, node->index, oflag, &answer);
-        vfs_exchange_end(vfs_phone);
-        sysarg_t rc;
-        async_wait_for(req, &rc);
-        if (rc != EOK)
-                return (int) rc;
-        return (int) IPC_GET_ARG1(answer);
+}
 int close(int fildes)
+{
         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_1(exch, VFS_IN_UNLINK, lflag, 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);
+}
+int fd_node(int fildes, fdi_node_t *node)
+{
+        struct stat stat;
+        int rc;
+        rc = fstat(fildes, &stat);
+        if (rc == EOK) {
+                node->fs_handle = stat.fs_handle;
+                node->devmap_handle = stat.devmap_handle;
+                node->index = stat.index;
+        }
+        return rc;
+        if (rc != 0) {
+                errno = rc;
+                return NULL;
+        }
+        if (!stat.service) {
+                errno = ENOENT;
+                return NULL;
+        }
+        return loc_service_connect(mgmt, stat.service, 0);
+}
 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)
 …
+}
+int fd_wait(void)
+{
+        async_exch_t *exch = vfs_exchange_begin();
+        sysarg_t ret;
+        sysarg_t rc = async_req_0_1(exch, VFS_IN_WAIT_HANDLE, &ret);
+        vfs_exchange_end(exch);
+        if (rc == EOK)
+                return (int) ret;
+        return (int) rc;
+}
+int get_mtab_list(list_t *mtab_list)
+{
+        sysarg_t rc;
+        aid_t req;
+        size_t i;
+        sysarg_t num_mounted_fs;
+        async_exch_t *exch = vfs_exchange_begin();
+        req = async_send_0(exch, VFS_IN_MTAB_GET, NULL);
+        /* Ask VFS how many filesystems are mounted */
+        rc = async_req_0_1(exch, VFS_IN_PING, &num_mounted_fs);
+        if (rc != EOK)
+                goto exit;
+        for (i = 0; i < num_mounted_fs; ++i) {
+                mtab_ent_t *mtab_ent;
+                mtab_ent = malloc(sizeof(mtab_ent_t));
+                if (!mtab_ent) {
+                        rc = ENOMEM;
+                        goto exit;
+                }
+                memset(mtab_ent, 0, sizeof(mtab_ent_t));
+                rc = async_data_read_start(exch, (void *) mtab_ent->mp,
+                    MAX_PATH_LEN);
+                if (rc != EOK)
+                        goto exit;
+                rc = async_data_read_start(exch, (void *) mtab_ent->opts,
+                        MAX_MNTOPTS_LEN);
+                if (rc != EOK)
+                        goto exit;
+                rc = async_data_read_start(exch, (void *) mtab_ent->fs_name,
+                        FS_NAME_MAXLEN);
+                if (rc != EOK)
+                        goto exit;
+                sysarg_t p[2];
+                rc = async_req_0_2(exch, VFS_IN_PING, &p[0], &p[1]);
+                if (rc != EOK)
+                        goto exit;
+                mtab_ent->instance = p[0];
+                mtab_ent->service_id = p[1];
+                link_initialize(&mtab_ent->link);
+                list_append(&mtab_ent->link, mtab_list);
+        }
+exit:
+        async_wait_for(req, &rc);
+        vfs_exchange_end(exch);
+        return rc;
+}
 /** @}
  */

Context Navigation

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

Legend:

Download in other formats: