Changeset 03362fbd for uspace/lib/c/generic – HelenOS

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

-              rb5d2e57
+              r03362fbd
 /*
  * Copyright (c) 2008 Jakub Jermar
+ * Copyright (c) 2012 Adam Hraska
+ *
  * All rights reserved.
+ *
 …
 /*
+ * This is an implementation of generic chained hash table.
+ * This is an implementation of a generic resizable chained hash table.
+ *
+ * The table grows to 2*n+1 buckets each time, starting at n == 89,
+ * per Thomas Wang's recommendation:
+ * http://www.concentric.net/~Ttwang/tech/hashsize.htm
+ *
+ * This policy produces prime table sizes for the first five resizes
+ * and generally produces table sizes which are either prime or
+ * have fairly large (prime/odd) divisors. Having a prime table size
+ * mitigates the use of suboptimal hash functions and distributes
+ * items over the whole table.
  */
 …
 #include <str.h>
+/* Optimal initial bucket count. See comment above. */
+#define HT_MIN_BUCKETS  89
+/* The table is resized when the average load per bucket exceeds this number. */
+#define HT_MAX_LOAD     2
+static size_t round_up_size(size_t);
+static bool alloc_table(size_t, list_t **);
+static void clear_items(hash_table_t *);
+static void resize(hash_table_t *, size_t);
+static void grow_if_needed(hash_table_t *);
+static void shrink_if_needed(hash_table_t *);
+/* Dummy do nothing callback to invoke in place of remove_callback == NULL. */
+static void nop_remove_callback(ht_link_t *item)
+{
+        /* no-op */
+}
 /** Create chained hash table.
+ *
  * @param h        Hash table structure. Will be initialized by this call.
+ * @param m        Number of hash table buckets.
+ * @param init_size Initial desired number of hash table buckets. Pass zero
+ *                 if you want the default initial size.
  * @param max_keys Maximal number of keys needed to identify an item.
+ * @param op       Hash table operations structure.
+ * @param op       Hash table operations structure. remove_callback()
+ *                 is optional and can be NULL if no action is to be taken
+ *                 upon removal. equal() is optional if and only if
+ *                 hash_table_insert_unique() will never be invoked.
+ *                 All other operations are mandatory.
+ *
  * @return True on success
+ *
  */
 bool hash_table_create(hash_table_t *h, hash_count_t m, hash_count_t max_keys,
     hash_table_operations_t *op)
+bool hash_table_create(hash_table_t *h, size_t init_size, size_t max_load,
+    hash_table_ops_t *op)
+{
         assert(h);
+        assert(op && op->hash && op->compare);
+        assert(max_keys > 0);
+        h->entry = malloc(m * sizeof(list_t));
+        if (!h->entry)
+        assert(op && op->hash && op->key_hash && op->key_equal);
+        /* Check for compulsory ops. */
+        if (!op || !op->hash || !op->key_hash || !op->key_equal)
                 return false;
+        memset((void *) h->entry, 0,  m * sizeof(list_t));
+        hash_count_t i;
+        for (i = 0; i < m; i++)
+                list_initialize(&h->entry[i]);
+        h->entries = m;
+        h->max_keys = max_keys;
+        h->bucket_cnt = round_up_size(init_size);
+        if (!alloc_table(h->bucket_cnt, &h->bucket))
+                return false;
+        h->max_load = (max_load == 0) ? HT_MAX_LOAD : max_load;
+        h->item_cnt = 0;
         h->op = op;
+        h->full_item_cnt = h->max_load * h->bucket_cnt;
+        h->apply_ongoing = false;
+        if (h->op->remove_callback == NULL) {
+                h->op->remove_callback = nop_remove_callback;
+        }
         return true;
+}
+/** Destroy a hash table instance.
+ *
+ * @param h Hash table to be destroyed.
+ *
+ */
+void hash_table_destroy(hash_table_t *h)
+{
+        assert(h && h->bucket);
+        assert(!h->apply_ongoing);
+        clear_items(h);
+        free(h->bucket);
+        h->bucket = 0;
+        h->bucket_cnt = 0;
+}
+/** Returns true if there are no items in the table. */
+bool hash_table_empty(hash_table_t *h)
+{
+        assert(h && h->bucket);
+        return h->item_cnt == 0;
+}
+/** Returns the number of items in the table. */
+size_t hash_table_size(hash_table_t *h)
+{
+        assert(h && h->bucket);
+        return h->item_cnt;
+}
 /** Remove all elements from the hash table
+ *
 …
 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;
+        assert(h && h->bucket);
+        assert(!h->apply_ongoing);
+        clear_items(h);
+        /* Shrink the table to its minimum size if possible. */
+        if (HT_MIN_BUCKETS < h->bucket_cnt) {
+                resize(h, HT_MIN_BUCKETS);
+        }
+}
+/** Unlinks and removes all items but does not resize. */
+static void clear_items(hash_table_t *h)
+{
+        if (h->item_cnt == 0)
+                return;
+        for (size_t idx = 0; idx < h->bucket_cnt; ++idx) {
+                list_foreach_safe(h->bucket[idx], cur, next) {
+                        assert(cur);
+                        ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
                         list_remove(cur);
+                        h->op->remove_callback(cur);
+                }
+        }
+}
+/** Destroy a hash table instance.
+ *
+ * @param h Hash table to be destroyed.
+ *
+ */
+void hash_table_destroy(hash_table_t *h)
+{
+        assert(h);
+        assert(h->entry);
+        free(h->entry);
+                        h->op->remove_callback(cur_link);
+                }
+        }
+        h->item_cnt = 0;
+}
 …
  * @param item Item to be inserted into the hash table.
  */
 void hash_table_insert(hash_table_t *h, unsigned long key[], link_t *item)
+void hash_table_insert(hash_table_t *h, ht_link_t *item)
+{
         assert(item);
+        assert(h && h->op && h->op->hash && h->op->compare);
+        hash_index_t chain = h->op->hash(key);
+        assert(chain < h->entries);
+        list_append(item, &h->entry[chain]);
+        assert(h && h->bucket);
+        assert(!h->apply_ongoing);
+        size_t idx = h->op->hash(item) % h->bucket_cnt;
+        list_append(&item->link, &h->bucket[idx]);
+        ++h->item_cnt;
+        grow_if_needed(h);
+}
+/** Insert item into a hash table if not already present.
+ *
+ * @param h    Hash table.
+ * @param key  Array of all keys necessary to compute hash index.
+ * @param item Item to be inserted into the hash table.
+ *
+ * @return False if such an item had already been inserted.
+ * @return True if the inserted item was the only item with such a lookup key.
+ */
+bool hash_table_insert_unique(hash_table_t *h, ht_link_t *item)
+{
+        assert(item);
+        assert(h && h->bucket && h->bucket_cnt);
+        assert(h->op && h->op->hash && h->op->equal);
+        assert(!h->apply_ongoing);
+        size_t idx = h->op->hash(item) % h->bucket_cnt;
+        /* Check for duplicates. */
+        list_foreach(h->bucket[idx], cur) {
+                /*
+                 * We could filter out items using their hashes first, but
+                 * calling equal() might very well be just as fast.
+                 */
+                ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
+                if (h->op->equal(cur_link, item))
+                        return false;
+        }
+        list_append(&item->link, &h->bucket[idx]);
+        ++h->item_cnt;
+        grow_if_needed(h);
+        return true;
+}
 …
+ *
  */
+link_t *hash_table_find(hash_table_t *h, unsigned long key[])
+{
+        assert(h && h->op && h->op->hash && h->op->compare);
+        hash_index_t chain = h->op->hash(key);
+        assert(chain < h->entries);
+        list_foreach(h->entry[chain], cur) {
+                if (h->op->compare(key, h->max_keys, cur)) {
+                        /*
+                         * The entry is there.
+                         */
+                        return cur;
+                }
+        }
+ht_link_t *hash_table_find(const hash_table_t *h, void *key)
+{
+        assert(h && h->bucket);
+        size_t idx = h->op->key_hash(key) % h->bucket_cnt;
+        list_foreach(h->bucket[idx], cur) {
+                ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
+                /*
+                 * Is this is the item we are looking for? We could have first
+                 * checked if the hashes match but op->key_equal() may very well be
+                 * just as fast as op->hash().
+                 */
+                if (h->op->key_equal(key, cur_link)) {
+                        return cur_link;
+                }
+        }
+        return NULL;
+}
+/** Find the next item equal to item. */
+ht_link_t *hash_table_find_next(const hash_table_t *h, ht_link_t *item)
+{
+        assert(item);
+        assert(h && h->bucket);
+        /* Traverse the circular list until we reach the starting item again. */
+        for (link_t *cur = item->link.next; cur != &item->link; cur = cur->next) {
+                assert(cur);
+                ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
+                /*
+                 * Is this is the item we are looking for? We could have first
+                 * checked if the hashes match but op->equal() may very well be
+                 * just as fast as op->hash().
+                 */
+                if (h->op->equal(cur_link, item)) {
+                        return cur_link;
+                }
+        }
         return NULL;
+}
 …
  *             the hash table.
  * @param keys Number of keys in the 'key' array.
+ *
+ */
+void hash_table_remove(hash_table_t *h, unsigned long key[], hash_count_t keys)
+{
+        assert(h && h->op && h->op->hash && h->op->compare &&
+            h->op->remove_callback);
+        assert(keys <= h->max_keys);
+        if (keys == h->max_keys) {
+                /*
+                 * All keys are known, hash_table_find() can be used to find the
+                 * entry.
+ *
+ * @return Returns the number of removed items.
+ */
+size_t hash_table_remove(hash_table_t *h, void *key)
+{
+        assert(h && h->bucket);
+        assert(!h->apply_ongoing);
+        size_t idx = h->op->key_hash(key) % h->bucket_cnt;
+        size_t removed = 0;
+        list_foreach_safe(h->bucket[idx], cur, next) {
+                ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
+                if (h->op->key_equal(key, cur_link)) {
+                        ++removed;
+                        list_remove(cur);
+                        h->op->remove_callback(cur_link);
+                }
+        }
+        h->item_cnt -= removed;
+        shrink_if_needed(h);
+        return removed;
+}
+/** Removes an item already present in the table. The item must be in the table.*/
+void hash_table_remove_item(hash_table_t *h, ht_link_t *item)
+{
+        assert(item);
+        assert(h && h->bucket);
+        assert(link_in_use(&item->link));
+        list_remove(&item->link);
+        --h->item_cnt;
+        h->op->remove_callback(item);
+        shrink_if_needed(h);
+}
+/** Apply function to all items in hash table.
+ *
+ * @param h   Hash table.
+ * @param f   Function to be applied. Return false if no more items
+ *            should be visited. The functor may only delete the supplied
+ *            item. It must not delete the successor of the item passed
+ *            in the first argument.
+ * @param arg Argument to be passed to the function.
+ */
+void hash_table_apply(hash_table_t *h, bool (*f)(ht_link_t *, void *), void *arg)
+{
+        assert(f);
+        assert(h && h->bucket);
+        if (h->item_cnt == 0)
+                return;
+        h->apply_ongoing = true;
+        for (size_t idx = 0; idx < h->bucket_cnt; ++idx) {
+                list_foreach_safe(h->bucket[idx], cur, next) {
+                        ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
+                        /*
+                         * The next pointer had already been saved. f() may safely
+                         * delete cur (but not next!).
+                         */
+                        if (!f(cur_link, arg))
+                                return;
+                }
+        }
+        h->apply_ongoing = false;
+        shrink_if_needed(h);
+        grow_if_needed(h);
+}
+/** Rounds up size to the nearest suitable table size. */
+static size_t round_up_size(size_t size)
+{
+        size_t rounded_size = HT_MIN_BUCKETS;
+        while (rounded_size < size) {
+                rounded_size = 2 * rounded_size + 1;
+        }
+        return rounded_size;
+}
+/** Allocates and initializes the desired number of buckets. True if successful.*/
+static bool alloc_table(size_t bucket_cnt, list_t **pbuckets)
+{
+        assert(pbuckets && HT_MIN_BUCKETS <= bucket_cnt);
+        list_t *buckets = malloc(bucket_cnt * sizeof(list_t));
+        if (!buckets)
+                return false;
+        for (size_t i = 0; i < bucket_cnt; i++)
+                list_initialize(&buckets[i]);
+        *pbuckets = buckets;
+        return true;
+}
+/** Shrinks the table if the table is only sparely populated. */
+static inline void shrink_if_needed(hash_table_t *h)
+{
+        if (h->item_cnt <= h->full_item_cnt / 4 && HT_MIN_BUCKETS < h->bucket_cnt) {
+                /*
+                 * Keep the bucket_cnt odd (possibly also prime).
+                 * Shrink from 2n + 1 to n. Integer division discards the +1.
                  */
+                link_t *cur = hash_table_find(h, key);
+                if (cur) {
+                        list_remove(cur);
+                        h->op->remove_callback(cur);
+                }
+                size_t new_bucket_cnt = h->bucket_cnt / 2;
+                resize(h, new_bucket_cnt);
+        }
+}
+/** Grows the table if table load exceeds the maximum allowed. */
+static inline void grow_if_needed(hash_table_t *h)
+{
+        /* Grow the table if the average bucket load exceeds the maximum. */
+        if (h->full_item_cnt < h->item_cnt) {
+                /* Keep the bucket_cnt odd (possibly also prime). */
+                size_t new_bucket_cnt = 2 * h->bucket_cnt + 1;
+                resize(h, new_bucket_cnt);
+        }
+}
+/** Allocates and rehashes items to a new table. Frees the old table. */
+static void resize(hash_table_t *h, size_t new_bucket_cnt)
+{
+        assert(h && h->bucket);
+        assert(HT_MIN_BUCKETS <= new_bucket_cnt);
+        /* We are traversing the table and resizing would mess up the buckets. */
+        if (h->apply_ongoing)
                 return;
+        }
+        /*
+         * Fewer keys were passed.
+         * Any partially matching entries are to be removed.
+         */
+        hash_index_t chain;
+        for (chain = 0; chain < h->entries; 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)) {
+                                link_t *hlp;
+                                hlp = cur;
+                                cur = cur->prev;
+                                list_remove(hlp);
+                                h->op->remove_callback(hlp);
+                                continue;
+        list_t *new_buckets;
+        /* Leave the table as is if we cannot resize. */
+        if (!alloc_table(new_bucket_cnt, &new_buckets))
+                return;
+        if (0 < h->item_cnt) {
+                /* Rehash all the items to the new table. */
+                for (size_t old_idx = 0; old_idx < h->bucket_cnt; ++old_idx) {
+                        list_foreach_safe(h->bucket[old_idx], cur, next) {
+                                ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
+                                size_t new_idx = h->op->hash(cur_link) % new_bucket_cnt;
+                                list_remove(cur);
+                                list_append(cur, &new_buckets[new_idx]);
+                        }
+                }
+        }
+}
+/** Apply function to all items in hash table.
+ *
+ * @param h   Hash table.
+ * @param f   Function to be applied.
+ * @param arg Argument to be passed to the function.
+ *
+ */
+void hash_table_apply(hash_table_t *h, void (*f)(link_t *, void *), void *arg)
+{
+        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);
+                }
+        }
+}
+        free(h->bucket);
+        h->bucket = new_buckets;
+        h->bucket_cnt = new_bucket_cnt;
+        h->full_item_cnt = h->max_load * h->bucket_cnt;
+}
 /** @}

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

rb5d2e57	r03362fbd
40	40
41	41	#include <adt/list.h>
42		#include <bool.h>
	42	#include <stdbool.h>
43	43
44	44	/** Check for membership

uspace/lib/c/generic/async.c

-              rb5d2e57
+              r03362fbd
 #include <sys/time.h>
 #include <libarch/barrier.h>
 #include <bool.h>
+#include <stdbool.h>
 #include <malloc.h>
 #include <mem.h>
 #include <stdlib.h>
 #include <macros.h>
+#define CLIENT_HASH_TABLE_BUCKETS  32
+#define CONN_HASH_TABLE_BUCKETS    32
+#include "private/libc.h"
 /** Session data */
 …
 /* Client connection data */
 typedef struct {
         link_t link;
+        ht_link_t link;
         task_id_t in_task_id;
 …
         /** Hash table link. */
         link_t link;
+        ht_link_t link;
         /** Incoming client task ID. */
 …
 static LIST_INITIALIZE(timeout_list);
+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] == LOWER32(client->in_task_id) &&
+            (key[1] == UPPER32(client->in_task_id)));
+}
+static void client_remove(link_t *item)
+{
+}
+static size_t client_key_hash(void *k)
+{
+        task_id_t key = *(task_id_t*)k;
+        return key;
+}
+static size_t client_hash(const ht_link_t *item)
+{
+        client_t *client = hash_table_get_inst(item, client_t, link);
+        return client_key_hash(&client->in_task_id);
+}
+static bool client_key_equal(void *k, const ht_link_t *item)
+{
+        task_id_t key = *(task_id_t*)k;
+        client_t *client = hash_table_get_inst(item, client_t, link);
+        return key == client->in_task_id;
+}
 /** Operations for the client hash table. */
 static hash_table_operations_t client_hash_table_ops = {
+static hash_table_ops_t client_hash_table_ops = {
         .hash = client_hash,
+        .compare = client_compare,
+        .remove_callback = client_remove
+        .key_hash = client_key_hash,
+        .key_equal = client_key_equal,
+        .equal = NULL,
+        .remove_callback = NULL
 };
 …
+ *
  */
+static hash_index_t conn_hash(unsigned long key[])
+{
+        assert(key);
+        return (((key[0]) >> 4) % CONN_HASH_TABLE_BUCKETS);
+}
+/** Compare hash table item with a key.
+ *
+ * @param key  Array containing the source phone hash as the only item.
+ * @param keys Expected 1 but ignored.
+ * @param item Connection hash table item.
+ *
+ * @return True on match, false otherwise.
+ *
+ */
+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);
+}
+static void conn_remove(link_t *item)
+{
+}
+static size_t conn_key_hash(void *key)
+{
+        sysarg_t in_phone_hash  = *(sysarg_t*)key;
+        return in_phone_hash ;
+}
+static size_t conn_hash(const ht_link_t *item)
+{
+        connection_t *conn = hash_table_get_inst(item, connection_t, link);
+        return conn_key_hash(&conn->in_phone_hash);
+}
+static bool conn_key_equal(void *key, const ht_link_t *item)
+{
+        sysarg_t in_phone_hash = *(sysarg_t*)key;
+        connection_t *conn = hash_table_get_inst(item, connection_t, link);
+        return (in_phone_hash == conn->in_phone_hash);
+}
 /** Operations for the connection hash table. */
 static hash_table_operations_t conn_hash_table_ops = {
+static hash_table_ops_t conn_hash_table_ops = {
         .hash = conn_hash,
+        .compare = conn_compare,
+        .remove_callback = conn_remove
+        .key_hash = conn_key_hash,
+        .key_equal = conn_key_equal,
+        .equal = NULL,
+        .remove_callback = NULL
 };
 …
         futex_down(&async_futex);
+        unsigned long key = call->in_phone_hash;
+        link_t *hlp = hash_table_find(&conn_hash_table, &key);
+        ht_link_t *hlp = hash_table_find(&conn_hash_table, &call->in_phone_hash);
         if (!hlp) {
 …
+        }
         connection_t *conn = hash_table_get_instance(hlp, connection_t, link);
+        connection_t *conn = hash_table_get_inst(hlp, connection_t, link);
         msg_t *msg = malloc(sizeof(*msg));
 …
         if (usecs) {
                 gettimeofday(&conn->wdata.to_event.expires, NULL);
+                getuptime(&conn->wdata.to_event.expires);
                 tv_add(&conn->wdata.to_event.expires, usecs);
         } else
 …
 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);
+        ht_link_t *lnk = hash_table_find(&client_hash_table, &client_id);
         if (lnk) {
                 client = hash_table_get_instance(lnk, client_t, link);
+                client = hash_table_get_inst(lnk, client_t, link);
                 atomic_inc(&client->refcnt);
         } else if (create) {
 …
                         atomic_set(&client->refcnt, 1);
                         hash_table_insert(&client_hash_table, key, &client->link);
+                        hash_table_insert(&client_hash_table, &client->link);
+                }
+        }
 …
+{
         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);
+                hash_table_remove(&client_hash_table, &client->in_task_id);
                 destroy = true;
         } else
 …
          */
         futex_down(&async_futex);
+        unsigned long key = fibril_connection->in_phone_hash;
+        hash_table_remove(&conn_hash_table, &key, 1);
+        hash_table_remove(&conn_hash_table, &fibril_connection->in_phone_hash);
         futex_up(&async_futex);
 …
         /* Add connection to the connection hash table */
-        unsigned long key = conn->in_phone_hash;
         futex_down(&async_futex);
         hash_table_insert(&conn_hash_table, &key, &conn->link);
+        hash_table_insert(&conn_hash_table, &conn->link);
         futex_up(&async_futex);
 …
+{
         struct timeval tv;
         gettimeofday(&tv, NULL);
+        getuptime(&tv);
         futex_down(&async_futex);
 …
                         struct timeval tv;
                         gettimeofday(&tv, NULL);
+                        getuptime(&tv);
                         if (tv_gteq(&tv, &waiter->to_event.expires)) {
 …
 void __async_init(void)
+{
+        if (!hash_table_create(&client_hash_table, CLIENT_HASH_TABLE_BUCKETS,
+, &client_hash_table_ops))
+        if (!hash_table_create(&client_hash_table, 0, 0, &client_hash_table_ops))
                 abort();
+        if (!hash_table_create(&conn_hash_table, CONN_HASH_TABLE_BUCKETS,
+, &conn_hash_table_ops))
+        if (!hash_table_create(&conn_hash_table, 0, 0, &conn_hash_table_ops))
                 abort();
 …
                 timeout = 0;
         gettimeofday(&msg->wdata.to_event.expires, NULL);
+        getuptime(&msg->wdata.to_event.expires);
         tv_add(&msg->wdata.to_event.expires, timeout);
 …
         msg->wdata.fid = fibril_get_id();
         gettimeofday(&msg->wdata.to_event.expires, NULL);
+        getuptime(&msg->wdata.to_event.expires);
         tv_add(&msg->wdata.to_event.expires, timeout);
 …
 int async_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
+{
+        return ipc_share_in_finalize(callid, src, flags);
+        return ipc_answer_3(callid, EOK, (sysarg_t) src, (sysarg_t) flags,
+            (sysarg_t) __entry);
+}
 …
 int async_share_out_finalize(ipc_callid_t callid, void **dst)
+{
         return ipc_share_out_finalize(callid, dst);
+        return ipc_answer_2(callid, EOK, (sysarg_t) __entry, (sysarg_t) dst);
+}
 …
 int async_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
+{
         return ipc_data_read_finalize(callid, src, size);
+        return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) size);
+}
 …
 int async_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
+{
         return ipc_data_write_finalize(callid, dst, size);
+        return ipc_answer_2(callid, EOK, (sysarg_t) dst, (sysarg_t) size);
+}

uspace/lib/c/generic/ddi.c

-              rb5d2e57
+              r03362fbd
 #include <assert.h>
+#include <atomic.h>
 #include <unistd.h>
+#include <stdio.h>
 #include <errno.h>
 #include <sys/types.h>
 …
 #include "private/libc.h"
 /** Return unique device number.
+ *
 …
+ *
  */
 int iospace_enable(task_id_t id, void *ioaddr, unsigned long size)
+{
         ddi_ioarg_t arg;
         arg.task_id = id;
         arg.ioaddr = ioaddr;
         arg.size = size;
+static int iospace_enable(task_id_t id, void *ioaddr, size_t size)
+{
+        const ddi_ioarg_t arg = {
+                .task_id = id,
+                .ioaddr = ioaddr,
+                .size = size
+        };
         return __SYSCALL1(SYS_IOSPACE_ENABLE, (sysarg_t) &arg);
 …
  * @param size     Size of the I/O region.
  * @param virt     Virtual address for application's
  *                 PIO operations.
+ *                 PIO operations. Can be NULL for PMIO.
+ *
  * @return EOK on success.
 …
 #ifdef IO_SPACE_BOUNDARY
         if (pio_addr < IO_SPACE_BOUNDARY) {
+                *virt = pio_addr;
+                if (virt)
+                        *virt = pio_addr;
                 return iospace_enable(task_get_id(), pio_addr, size);
+        }
+#else
+        (void) iospace_enable;
 #endif
+        if (!virt)
+                return EINVAL;
         void *phys_frame =
             (void *) ALIGN_DOWN((uintptr_t) pio_addr, PAGE_SIZE);
 …
+}
+void pio_write_8(ioport8_t *reg, uint8_t val)
+{
+        pio_trace_log(reg, val, true);
+        arch_pio_write_8(reg, val);
+}
+void pio_write_16(ioport16_t *reg, uint16_t val)
+{
+        pio_trace_log(reg, val, true);
+        arch_pio_write_16(reg, val);
+}
+void pio_write_32(ioport32_t *reg, uint32_t val)
+{
+        pio_trace_log(reg, val, true);
+        arch_pio_write_32(reg, val);
+}
+uint8_t pio_read_8(const ioport8_t *reg)
+{
+        const uint8_t val = arch_pio_read_8(reg);
+        pio_trace_log(reg, val, false);
+        return val;
+}
+uint16_t pio_read_16(const ioport16_t *reg)
+{
+        const uint16_t val = arch_pio_read_16(reg);
+        pio_trace_log(reg, val, false);
+        return val;
+}
+uint32_t pio_read_32(const ioport32_t *reg)
+{
+        const uint32_t val = arch_pio_read_32(reg);
+        pio_trace_log(reg, val, false);
+        return val;
+}
 /** Register IRQ notification.
+ *

uspace/lib/c/generic/device/clock_dev.c

-              rb5d2e57
+              r03362fbd
 /*
+ * Copyright (c) 2007 Michal Kebrt
+ * Copyright (c) 2009 Vineeth Pillai
+ * Copyright (c) 2012 Maurizio Lombardi
  * All rights reserved.
+ *
 …
  */
+/** @addtogroup arm32gxemul GXemul
+ *  @brief GXemul machine specific parts.
+ *  @ingroup arm32
+ /** @addtogroup libc
  * @{
  */
 /** @file
- *  @brief GXemul peripheries drivers declarations.
  */
+#ifndef KERN_arm32_testarm_H_
+#define KERN_arm32_testarm_H_
+#include <ipc/dev_iface.h>
+#include <device/clock_dev.h>
+#include <errno.h>
+#include <async.h>
+#include <time.h>
+#include <arch/machine_func.h>
+/** Read the current time from the device
+ *
+ * @param sess     Session of the device
+ * @param t        The current time that will be read from the device
+ *
+ * @return         EOK on success or a negative error code
+ */
+int
+clock_dev_time_get(async_sess_t *sess, struct tm *t)
+{
+        aid_t req;
+        int ret;
+/** Size of GXemul IRQ number range (starting from 0) */
+#define GXEMUL_IRQ_COUNT        32
+#define GXEMUL_KBD_IRQ          2
+#define GXEMUL_TIMER_IRQ        4
+        async_exch_t *exch = async_exchange_begin(sess);
+/** Timer frequency */
+#define GXEMUL_TIMER_FREQ  100
+        req = async_send_1(exch, DEV_IFACE_ID(CLOCK_DEV_IFACE),
+            CLOCK_DEV_TIME_GET, NULL);
+        ret = async_data_read_start(exch, t, sizeof(*t));
+#define GXEMUL_KBD_ADDRESS   0x10000000
+#define GXEMUL_MP_ADDRESS    0x11000000
+#define GXEMUL_FB_ADDRESS    0x12000000
+#define GXEMUL_RTC_ADDRESS   0x15000000
+#define GXEMUL_IRQC_ADDRESS  0x16000000
+        async_exchange_end(exch);
+extern void *gxemul_kbd;
+extern void *gxemul_rtc;
+extern void *gxemul_irqc;
+        sysarg_t rc;
+        if (ret != EOK) {
+                async_forget(req);
+                return ret;
+        }
+#define GXEMUL_HALT_OFFSET        0x010
+#define GXEMUL_RTC_FREQ_OFFSET    0x100
+#define GXEMUL_MP_MEMSIZE_OFFSET  0x090
+#define GXEMUL_RTC_ACK_OFFSET     0x110
+        async_wait_for(req, &rc);
+        return (int)rc;
+}
+extern void gxemul_init(void);
+extern void gxemul_output_init(void);
+extern void gxemul_input_init(void);
+extern void gxemul_timer_irq_start(void);
+extern void gxemul_cpu_halt(void);
+extern void gxemul_irq_exception(unsigned int, istate_t *);
+extern void gxemul_get_memory_extents(uintptr_t *, size_t *);
+extern void gxemul_frame_init(void);
+extern size_t gxemul_get_irq_count(void);
+extern const char *gxemul_get_platform_name(void);
+/** Set the current time
+ *
+ * @param sess   Session of the device
+ * @param t      The current time that will be written to the device
+ *
+ * @return       EOK on success or a negative error code
+ */
+int
+clock_dev_time_set(async_sess_t *sess, struct tm *t)
+{
+        aid_t req;
+        int ret;
 extern struct arm_machine_ops gxemul_machine_ops;
+        async_exch_t *exch = async_exchange_begin(sess);
+#endif
+        req = async_send_1(exch, DEV_IFACE_ID(CLOCK_DEV_IFACE),
+            CLOCK_DEV_TIME_SET, NULL);
+        ret = async_data_write_start(exch, t, sizeof(*t));
+        async_exchange_end(exch);
+        sysarg_t rc;
+        if (ret != EOK) {
+                async_forget(req);
+                return ret;
+        }
+        async_wait_for(req, &rc);
+        return (int)rc;
+}
 /** @}
  */

uspace/lib/c/generic/devman.c

rb5d2e57	r03362fbd
45	45	#include <errno.h>
46	46	#include <malloc.h>
47		#include <bool.h>
	47	#include <stdbool.h>
48	48
49	49	static FIBRIL_MUTEX_INITIALIZE(devman_driver_block_mutex);

uspace/lib/c/generic/dlfcn.c

-              rb5d2e57
+              r03362fbd
 #include <stdlib.h>
 #include <dlfcn.h>
+#ifdef CONFIG_RTLD
 #include <rtld/module.h>
 …
+}
+#else /* CONFIG_RTLD not defined */
+void *dlopen(const char *path, int flag)
+{
+        return NULL;
+}
+void *dlsym(void *mod, const char *sym_name)
+{
+        return NULL;
+}
+#endif
 /** @}
  */

uspace/lib/c/generic/fibril.c

-              rb5d2e57
+              r03362fbd
 #include <fibril.h>
 #include <thread.h>
+#include <stack.h>
 #include <tls.h>
 #include <malloc.h>
+#include <abi/mm/as.h>
+#include <as.h>
 #include <unistd.h>
 #include <stdio.h>
 …
 #include <assert.h>
 #include <async.h>
-#ifndef FIBRIL_INITIAL_STACK_PAGES_NO
-        #define FIBRIL_INITIAL_STACK_PAGES_NO  1
-#endif
 /**
 …
                                          * stack member filled.
                                          */
                                         free(stack);
+                                        as_area_destroy(stack);
+                                }
                                 fibril_teardown(srcf->clean_after_me);
 …
                 return 0;
+        fibril->stack =
+            (char *) malloc(FIBRIL_INITIAL_STACK_PAGES_NO * getpagesize());
+        if (!fibril->stack) {
+        size_t stack_size = stack_size_get();
+        fibril->stack = as_area_create((void *) -1, stack_size,
+            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |
+            AS_AREA_LATE_RESERVE);
+        if (fibril->stack == (void *) -1) {
                 fibril_teardown(fibril);
                 return 0;
 …
         context_save(&fibril->ctx);
         context_set(&fibril->ctx, FADDR(fibril_main), fibril->stack,
             FIBRIL_INITIAL_STACK_PAGES_NO * getpagesize(), fibril->tcb);
+            stack_size, fibril->tcb);
         return (fid_t) fibril;
 …
         fibril_t *fibril = (fibril_t *) fid;
         free(fibril->stack);
+        as_area_destroy(fibril->stack);
         fibril_teardown(fibril);
+}

uspace/lib/c/generic/fibril_synch.c

rb5d2e57	r03362fbd
379	379	futex_down(&async_futex);
380	380	if (timeout) {
381		get~~timeofday(&wdata.to_event.expires, NULL~~);
	381	getuptime(&wdata.to_event.expires);
382	382	tv_add(&wdata.to_event.expires, timeout);
383	383	async_insert_timeout(&wdata);

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

-              rb5d2e57
+              r03362fbd
  */
 /** @addtogroup console
+/** @addtogroup libc
  * @{
  */
 …
 #include <unistd.h>
 #include <assert.h>
 #include <bool.h>
+#include <stdbool.h>
 #include <as.h>
+#include "screenbuffer.h"
+/** Structure for buffering state of one virtual console.
+ *
+ */
+struct screenbuffer {
+        size_t size;                /**< Structure size */
+        screenbuffer_flag_t flags;  /**< Screenbuffer flags */
+        sysarg_t cols;              /**< Number of columns */
+        sysarg_t rows;              /**< Number of rows */
+        sysarg_t col;               /**< Current column */
+        sysarg_t row;               /**< Current row */
+        bool cursor_visible;        /**< Cursor visibility */
+        char_attrs_t attrs;         /**< Current attributes */
+        sysarg_t top_row;           /**< The first row in the cyclic buffer */
+        charfield_t data[];         /**< Screen contents (cyclic buffer) */
+};
+/** Create a screenbuffer.
+#include <io/chargrid.h>
+/** Create a chargrid.
+ *
  * @param[in] cols  Number of columns.
  * @param[in] rows  Number of rows.
  * @param[in] flags Screenbuffer flags.
+ *
  * @return New screenbuffer.
+ * @param[in] flags Chargrid flags.
+ *
+ * @return New chargrid.
  * @return NULL on failure.
+ *
  */
 screenbuffer_t *screenbuffer_create(sysarg_t cols, sysarg_t rows,
     screenbuffer_flag_t flags)
+chargrid_t *chargrid_create(sysarg_t cols, sysarg_t rows,
+    chargrid_flag_t flags)
+{
         size_t size =
             sizeof(screenbuffer_t) + cols * rows * sizeof(charfield_t);
         screenbuffer_t *scrbuf;
         if ((flags & SCREENBUFFER_FLAG_SHARED) == SCREENBUFFER_FLAG_SHARED) {
                 scrbuf = (screenbuffer_t *) as_area_create(AS_AREA_ANY, size,
+            sizeof(chargrid_t) + cols * rows * sizeof(charfield_t);
+        chargrid_t *scrbuf;
+        if ((flags & CHARGRID_FLAG_SHARED) == CHARGRID_FLAG_SHARED) {
+                scrbuf = (chargrid_t *) as_area_create(AS_AREA_ANY, size,
                     AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
                 if (scrbuf == AS_MAP_FAILED)
                         return NULL;
         } else {
                 scrbuf = (screenbuffer_t *) malloc(size);
+                scrbuf = (chargrid_t *) malloc(size);
                 if (scrbuf == NULL)
                         return NULL;
 …
         scrbuf->top_row = 0;
         screenbuffer_clear(scrbuf);
+        chargrid_clear(scrbuf);
         return scrbuf;
+}
+/** Return keyfield by coordinates
+ *
+ * The back buffer is organized as a cyclic buffer.
+ * Therefore we must take into account the topmost column.
+ *
+ * @param scrbuf Screenbuffer
+ * @param col    Column position on screen
+ * @param row    Row position on screen
+ *
+ * @return Keyfield structure on (row, col)
+ *
+ */
+charfield_t *screenbuffer_field_at(screenbuffer_t *scrbuf, sysarg_t col,
+    sysarg_t row)
+{
+        return scrbuf->data +
+            ((row + scrbuf->top_row) % scrbuf->rows) * scrbuf->cols +
+            col;
+}
+bool screenbuffer_cursor_at(screenbuffer_t *scrbuf, sysarg_t col, sysarg_t row)
+void chargrid_destroy(chargrid_t *srcbuf)
+{
+        // TODO
+}
+bool chargrid_cursor_at(chargrid_t *scrbuf, sysarg_t col, sysarg_t row)
+{
         return ((scrbuf->cursor_visible) && (scrbuf->col == col) &&
 …
+}
 sysarg_t screenbuffer_get_top_row(screenbuffer_t *scrbuf)
+sysarg_t chargrid_get_top_row(chargrid_t *scrbuf)
+{
         return scrbuf->top_row;
+}
 static sysarg_t screenbuffer_update_rows(screenbuffer_t *scrbuf)
+static sysarg_t chargrid_update_rows(chargrid_t *scrbuf)
+{
         if (scrbuf->row == scrbuf->rows) {
                 scrbuf->row = scrbuf->rows - 1;
                 scrbuf->top_row = (scrbuf->top_row + 1) % scrbuf->rows;
                 screenbuffer_clear_row(scrbuf, scrbuf->row);
+                chargrid_clear_row(scrbuf, scrbuf->row);
                 return scrbuf->rows;
 …
+}
 static sysarg_t screenbuffer_update_cols(screenbuffer_t *scrbuf)
+static sysarg_t chargrid_update_cols(chargrid_t *scrbuf)
+{
         /* Column overflow */
 …
                 scrbuf->col = 0;
                 scrbuf->row++;
                 return screenbuffer_update_rows(scrbuf);
+                return chargrid_update_rows(scrbuf);
+        }
 …
+}
 /** Store one character to screenbuffer.
+/** Store one character to chargrid.
+ *
  * Its position is determined by scrbuf->col
  * and scrbuf->row.
+ *
  * @param scrbuf Screenbuffer.
+ * @param scrbuf Chargrid.
  * @param ch     Character to store.
  * @param update Update coordinates.
 …
+ *
  */
 sysarg_t screenbuffer_putchar(screenbuffer_t *scrbuf, wchar_t ch, bool update)
+sysarg_t chargrid_putchar(chargrid_t *scrbuf, wchar_t ch, bool update)
+{
         assert(scrbuf->col < scrbuf->cols);
 …
         charfield_t *field =
             screenbuffer_field_at(scrbuf, scrbuf->col, scrbuf->row);
+            chargrid_charfield_at(scrbuf, scrbuf->col, scrbuf->row);
         field->ch = ch;
 …
         if (update) {
                 scrbuf->col++;
                 return screenbuffer_update_cols(scrbuf);
+                return chargrid_update_cols(scrbuf);
+        }
 …
+}
 /** Jump to a new row in screenbuffer.
+ *
  * @param scrbuf Screenbuffer.
+/** Jump to a new row in chargrid.
+ *
+ * @param scrbuf Chargrid.
+ *
  * @return Number of rows which have been affected. In usual
 …
+ *
  */
 sysarg_t screenbuffer_newline(screenbuffer_t *scrbuf)
+sysarg_t chargrid_newline(chargrid_t *scrbuf)
+{
         assert(scrbuf->col < scrbuf->cols);
 …
         scrbuf->row++;
         return screenbuffer_update_rows(scrbuf);
+}
 /** Jump to a new row in screenbuffer.
+ *
  * @param scrbuf   Screenbuffer.
+        return chargrid_update_rows(scrbuf);
+}
+/** Jump to a new row in chargrid.
+ *
+ * @param scrbuf   Chargrid.
  * @param tab_size Tab size.
+ *
 …
+ *
  */
 sysarg_t screenbuffer_tabstop(screenbuffer_t *scrbuf, sysarg_t tab_size)
+sysarg_t chargrid_tabstop(chargrid_t *scrbuf, sysarg_t tab_size)
+{
         assert(scrbuf->col < scrbuf->cols);
 …
         for (sysarg_t i = 0; i < spaces; i++)
                 flush += screenbuffer_putchar(scrbuf, ' ', true) - 1;
+                flush += chargrid_putchar(scrbuf, ' ', true) - 1;
         return flush;
+}
 /** Jump to the previous character in screenbuffer.
+/** Jump to the previous character in chargrid.
+ *
  * Currently no scrollback is supported.
+ *
  * @param scrbuf Screenbuffer.
+ * @param scrbuf Chargrid.
+ *
  * @return Number of rows which have been affected. In usual
 …
+ *
  */
 sysarg_t screenbuffer_backspace(screenbuffer_t *scrbuf)
+sysarg_t chargrid_backspace(chargrid_t *scrbuf)
+{
         assert(scrbuf->col < scrbuf->cols);
 …
                 scrbuf->row--;
                 screenbuffer_putchar(scrbuf, ' ', false);
+                chargrid_putchar(scrbuf, ' ', false);
                 return 2;
+        }
         scrbuf->col--;
         screenbuffer_putchar(scrbuf, ' ', false);
+        chargrid_putchar(scrbuf, ' ', false);
         return 1;
+}
 /** Clear the screenbuffer.
+ *
  * @param scrbuf Screenbuffer.
+ *
  */
 void screenbuffer_clear(screenbuffer_t *scrbuf)
+/** Clear the chargrid.
+ *
+ * @param scrbuf Chargrid.
+ *
+ */
+void chargrid_clear(chargrid_t *scrbuf)
+{
         for (size_t pos = 0; pos < (scrbuf->cols * scrbuf->rows); pos++) {
 …
+}
 /** Update current screenbuffer coordinates
+ *
  * @param scrbuf Screenbuffer.
+/** Update current chargrid coordinates
+ *
+ * @param scrbuf Chargrid.
  * @param col    New column.
  * @param row    New row.
+ *
  */
 void screenbuffer_set_cursor(screenbuffer_t *scrbuf, sysarg_t col, sysarg_t row)
+void chargrid_set_cursor(chargrid_t *scrbuf, sysarg_t col, sysarg_t row)
+{
         scrbuf->col = col;
 …
+}
 void screenbuffer_set_cursor_visibility(screenbuffer_t *scrbuf, bool visible)
+void chargrid_set_cursor_visibility(chargrid_t *scrbuf, bool visible)
+{
         scrbuf->cursor_visible = visible;
+}
 /** Get current screenbuffer coordinates
+ *
  * @param scrbuf Screenbuffer.
+/** Get current chargrid coordinates
+ *
+ * @param scrbuf Chargrid.
  * @param col    Column.
  * @param row    Row.
+ *
  */
 void screenbuffer_get_cursor(screenbuffer_t *scrbuf, sysarg_t *col,
+void chargrid_get_cursor(chargrid_t *scrbuf, sysarg_t *col,
     sysarg_t *row)
+{
 …
+}
 bool screenbuffer_get_cursor_visibility(screenbuffer_t *scrbuf)
+bool chargrid_get_cursor_visibility(chargrid_t *scrbuf)
+{
         return scrbuf->cursor_visible;
 …
 /** Clear one buffer row.
+ *
  * @param scrbuf Screenbuffer.
+ * @param scrbuf Chargrid.
  * @param row    Row to clear.
+ *
  */
 void screenbuffer_clear_row(screenbuffer_t *scrbuf, sysarg_t row)
+void chargrid_clear_row(chargrid_t *scrbuf, sysarg_t row)
+{
         for (sysarg_t col = 0; col < scrbuf->cols; col++) {
                 charfield_t *field =
                     screenbuffer_field_at(scrbuf, col, row);
+                    chargrid_charfield_at(scrbuf, col, row);
                 field->ch = 0;
 …
+}
 /** Set screenbuffer style.
+ *
  * @param scrbuf Screenbuffer.
+/** Set chargrid style.
+ *
+ * @param scrbuf Chargrid.
  * @param style  Style.
+ *
  */
 void screenbuffer_set_style(screenbuffer_t *scrbuf, console_style_t style)
+void chargrid_set_style(chargrid_t *scrbuf, console_style_t style)
+{
         scrbuf->attrs.type = CHAR_ATTR_STYLE;
 …
+}
 /** Set screenbuffer color.
+ *
  * @param scrbuf  Screenbuffer.
+/** Set chargrid color.
+ *
+ * @param scrbuf  Chargrid.
  * @param bgcolor Background color.
  * @param fgcolor Foreground color.
 …
+ *
  */
 void screenbuffer_set_color(screenbuffer_t *scrbuf, console_color_t bgcolor,
+void chargrid_set_color(chargrid_t *scrbuf, console_color_t bgcolor,
     console_color_t fgcolor, console_color_attr_t attr)
+{
 …
+}
 /** Set screenbuffer RGB color.
+ *
  * @param scrbuf  Screenbuffer.
+/** Set chargrid RGB color.
+ *
+ * @param scrbuf  Chargrid.
  * @param bgcolor Background color.
  * @param fgcolor Foreground color.
+ *
  */
 void screenbuffer_set_rgb_color(screenbuffer_t *scrbuf, pixel_t bgcolor,
+void chargrid_set_rgb_color(chargrid_t *scrbuf, pixel_t bgcolor,
     pixel_t fgcolor)
+{

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

-              rb5d2e57
+              r03362fbd
 #include <async.h>
 #include <errno.h>
-#include <stdio.h>
 #include <malloc.h>
 #include <vfs/vfs_sess.h>
 …
+{
         async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
         async_req_1_0(exch, CONSOLE_CURSOR_VISIBILITY, (show != false));
+        async_req_1_0(exch, CONSOLE_SET_CURSOR_VISIBILITY, (show != false));
         async_exchange_end(exch);
+}
 …
+{
         async_exch_t *exch = async_exchange_begin(ctrl->output_sess);
         async_req_2_0(exch, CONSOLE_GOTO, col, row);
+        async_req_2_0(exch, CONSOLE_SET_POS, col, row);
         async_exchange_end(exch);
+}

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

rb5d2e57	r03362fbd
39	39	#include <str.h>
40	40	#include <errno.h>
41		#include <bool.h>
	41	#include <stdbool.h>
42	42	#include <malloc.h>
43	43	#include <async.h>

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

-              rb5d2e57
+              r03362fbd
 #include <unistd.h>
 #include <errno.h>
+#include <abi/klog.h>
 #include <io/klog.h>
 #include <io/printf_core.h>
 …
 size_t klog_write(const void *buf, size_t size)
+{
         ssize_t ret = (ssize_t) __SYSCALL3(SYS_KLOG, 1, (sysarg_t) buf, size);
+        ssize_t ret = (ssize_t) __SYSCALL3(SYS_KLOG, KLOG_WRITE, (sysarg_t) buf, size);
         if (ret >= 0)
 …
 void klog_update(void)
+{
+        (void) __SYSCALL3(SYS_KLOG, 1, (uintptr_t) NULL, 0);
+        (void) __SYSCALL3(SYS_KLOG, KLOG_UPDATE, (uintptr_t) NULL, 0);
+}
+void klog_command(const void *buf, size_t size)
+{
+        (void) __SYSCALL3(SYS_KLOG, KLOG_COMMAND, (sysarg_t) buf, (sysarg_t) size);
+}

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

-              rb5d2e57
+              r03362fbd
 #include <stdlib.h>
 #include <stdio.h>
+#include <async.h>
 #include <io/log.h>
+/** Serialization mutex for logging functions. */
+static FIBRIL_MUTEX_INITIALIZE(log_serializer);
+/** Current log level. */
+static log_level_t log_level;
+static FILE *log_stream;
+#include <ipc/logger.h>
+#include <ns.h>
+/** Id of the first log we create at logger. */
+static sysarg_t default_log_id;
+/** Log messages are printed under this name. */
 static const char *log_prog_name;
 /** Prefixes for individual logging levels. */
+/** Names of individual log levels. */
 static const char *log_level_names[] = {
+        [LVL_FATAL] = "Fatal error",
+        [LVL_ERROR] = "Error",
+        [LVL_WARN] = "Warning",
+        [LVL_NOTE] = "Note",
+        [LVL_DEBUG] = "Debug",
+        [LVL_DEBUG2] = "Debug2"
+        "fatal",
+        "error",
+        "warn",
+        "note",
+        "debug",
+        "debug2",
+        NULL
 };
+/** IPC session with the logger service. */
+static async_sess_t *logger_session;
+/** Maximum length of a single log message (in bytes). */
+#define MESSAGE_BUFFER_SIZE 4096
+/** Send formatted message to the logger service.
+ *
+ * @param session Initialized IPC session with the logger.
+ * @param log Log to use.
+ * @param level Verbosity level of the message.
+ * @param message The actual message.
+ * @return Error code of the conversion or EOK on success.
+ */
+static int logger_message(async_sess_t *session, log_t log, log_level_t level, char *message)
+{
+        async_exch_t *exchange = async_exchange_begin(session);
+        if (exchange == NULL) {
+                return ENOMEM;
+        }
+        if (log == LOG_DEFAULT)
+                log = default_log_id;
+        // FIXME: remove when all USB drivers use libc logging explicitly
+        str_rtrim(message, '\n');
+        aid_t reg_msg = async_send_2(exchange, LOGGER_WRITER_MESSAGE,
+            log, level, NULL);
+        int rc = async_data_write_start(exchange, message, str_size(message));
+        sysarg_t reg_msg_rc;
+        async_wait_for(reg_msg, &reg_msg_rc);
+        async_exchange_end(exchange);
+        /*
+         * Getting ENAK means no-one wants our message. That is not an
+         * error at all.
+         */
+        if (rc == ENAK)
+                rc = EOK;
+        if (rc != EOK) {
+                return rc;
+        }
+        return reg_msg_rc;
+}
+/** Get name of the log level.
+ *
+ * @param level The log level.
+ * @return String name or "unknown".
+ */
+const char *log_level_str(log_level_t level)
+{
+        if (level >= LVL_LIMIT)
+                return "unknown";
+        else
+                return log_level_names[level];
+}
+/** Convert log level name to the enum.
+ *
+ * @param[in] name Log level name or log level number.
+ * @param[out] level_out Where to store the result (set to NULL to ignore).
+ * @return Error code of the conversion or EOK on success.
+ */
+int log_level_from_str(const char *name, log_level_t *level_out)
+{
+        log_level_t level = LVL_FATAL;
+        while (log_level_names[level] != NULL) {
+                if (str_cmp(name, log_level_names[level]) == 0) {
+                        if (level_out != NULL)
+                                *level_out = level;
+                        return EOK;
+                }
+                level++;
+        }
+        /* Maybe user specified number directly. */
+        char *end_ptr;
+        int level_int = strtol(name, &end_ptr, 0);
+        if ((end_ptr == name) || (str_length(end_ptr) != 0))
+                return EINVAL;
+        if (level_int < 0)
+                return ERANGE;
+        if (level_int >= (int) LVL_LIMIT)
+                return ERANGE;
+        if (level_out != NULL)
+                *level_out = (log_level_t) level_int;
+        return EOK;
+}
 /** Initialize the logging system.
+ *
+ * @param prog_name     Program name, will be printed as part of message
+ * @param level         Minimum message level to print
+ */
+int log_init(const char *prog_name, log_level_t level)
+{
+        assert(level < LVL_LIMIT);
+        log_level = level;
+        log_stream = stdout;
+ * @param prog_name Program name, will be printed as part of message
+ */
+int log_init(const char *prog_name)
+{
         log_prog_name = str_dup(prog_name);
         if (log_prog_name == NULL)
                 return ENOMEM;
+        logger_session = service_connect_blocking(EXCHANGE_SERIALIZE, SERVICE_LOGGER, LOGGER_INTERFACE_WRITER, 0);
+        if (logger_session == NULL) {
+                return ENOMEM;
+        }
+        default_log_id = log_create(prog_name, LOG_NO_PARENT);
         return EOK;
+}
+/** Create a new (sub-) log.
+ *
+ * This function always returns a valid log_t. In case of errors,
+ * @c parent is returned and errors are silently ignored.
+ *
+ * @param name Log name under which message will be reported (appended to parents name).
+ * @param parent Parent log.
+ * @return Opaque identifier of the newly created log.
+ */
+log_t log_create(const char *name, log_t parent)
+{
+        async_exch_t *exchange = async_exchange_begin(logger_session);
+        if (exchange == NULL)
+                return parent;
+        if (parent == LOG_DEFAULT)
+                parent = default_log_id;
+        ipc_call_t answer;
+        aid_t reg_msg = async_send_1(exchange, LOGGER_WRITER_CREATE_LOG,
+            parent, &answer);
+        int rc = async_data_write_start(exchange, name, str_size(name));
+        sysarg_t reg_msg_rc;
+        async_wait_for(reg_msg, &reg_msg_rc);
+        async_exchange_end(exchange);
+        if ((rc != EOK) || (reg_msg_rc != EOK))
+                return parent;
+        return IPC_GET_ARG1(answer);
+}
 /** Write an entry to the log.
+ *
+ * @param level         Message verbosity level. Message is only printed
+ *                      if verbosity is less than or equal to current
+ *                      reporting level.
+ * @param fmt           Format string (no traling newline).
+ */
+void log_msg(log_level_t level, const char *fmt, ...)
+ * The message is printed only if the verbosity level is less than or
+ * equal to currently set reporting level of the log.
+ *
+ * @param ctx Log to use (use LOG_DEFAULT if you have no idea what it means).
+ * @param level Severity level of the message.
+ * @param fmt Format string in printf-like format (without trailing newline).
+ */
+void log_msg(log_t ctx, log_level_t level, const char *fmt, ...)
+{
         va_list args;
         va_start(args, fmt);
         log_msgv(level, fmt, args);
+        log_msgv(ctx, level, fmt, args);
         va_end(args);
+}
 …
 /** Write an entry to the log (va_list variant).
+ *
  * @param level         Message verbosity level. Message is only printed
  *                      if verbosity is less than or equal to current
  *                      reporting level.
  * @param fmt           Format string (no trailing newline)
  */
 void log_msgv(log_level_t level, const char *fmt, va_list args)
+ * @param ctx Log to use (use LOG_DEFAULT if you have no idea what it means).
+ * @param level Severity level of the message.
+ * @param fmt Format string in printf-like format (without trailing newline).
+ * @param args Arguments.
+ */
+void log_msgv(log_t ctx, log_level_t level, const char *fmt, va_list args)
+{
         assert(level < LVL_LIMIT);
+        /* Higher number means higher verbosity. */
+        if (level <= log_level) {
+                fibril_mutex_lock(&log_serializer);
+                fprintf(log_stream, "%s: %s: ", log_prog_name,
+                    log_level_names[level]);
+                vfprintf(log_stream, fmt, args);
+                fputc('\n', log_stream);
+                fflush(log_stream);
+                fibril_mutex_unlock(&log_serializer);
+        }
+        char *message_buffer = malloc(MESSAGE_BUFFER_SIZE);
+        if (message_buffer == NULL)
+                return;
+        vsnprintf(message_buffer, MESSAGE_BUFFER_SIZE, fmt, args);
+        logger_message(logger_session, ctx, level, message_buffer);
+        free(message_buffer);
+}

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

-              rb5d2e57
+              r03362fbd
 #include <ctype.h>
 #include <str.h>
+#include <double_to_str.h>
+#include <ieee_double.h>
+#include <assert.h>
+#include <macros.h>
 /** show prefixes 0x or 0 */
 #define __PRINTF_FLAG_PREFIX       0x00000001
+/** show the decimal point even if no fractional digits present */
+#define __PRINTF_FLAG_DECIMALPT    0x00000001
 /** signed / unsigned number */
 #define __PRINTF_FLAG_SIGNED       0x00000002
 …
 /** number has - sign */
 #define __PRINTF_FLAG_NEGATIVE     0x00000100
+/** don't print trailing zeros in the fractional part */
+#define __PRINTF_FLAG_NOFRACZEROS  0x00000200
 /**
 …
 static const char invalch = U_SPECIAL;
+/** Unformatted double number string representation. */
+typedef struct {
+        /** Buffer with len digits, no sign or leading zeros. */
+        char *str;
+        /** Number of digits in str. */
+        int len;
+        /** Decimal exponent, ie number = str * 10^dec_exp */
+        int dec_exp;
+        /** True if negative. */
+        bool neg;
+} double_str_t;
+/** Returns the sign character or 0 if no sign should be printed. */
+static int get_sign_char(bool negative, uint32_t flags)
+{
+        if (negative) {
+                return '-';
+        } else if (flags & __PRINTF_FLAG_SHOWPLUS) {
+                return '+';
+        } else if (flags & __PRINTF_FLAG_SPACESIGN) {
+                return ' ';
+        } else {
+                return 0;
+        }
+}
+/** Prints count times character ch. */
+static int print_padding(char ch, int count, printf_spec_t *ps)
+{
+        for (int i = 0; i < count; ++i) {
+                if (ps->str_write(&ch, 1, ps->data) < 0) {
+                        return -1;
+                }
+        }
+        return count;
+}
 /** Print one or more characters without adding newline.
+ *
 …
                 return printf_putstr(nullstr, ps);
-        /* Print leading spaces. */
         size_t strw = str_length(str);
+        /* Precision unspecified - print everything. */
         if ((precision == 0) || (precision > strw))
                 precision = strw;
 …
                 return printf_putstr(nullstr, ps);
-        /* Print leading spaces. */
         size_t strw = wstr_length(str);
+        /* Precision not specified - print everything. */
         if ((precision == 0) || (precision > strw))
                 precision = strw;
 …
     uint32_t flags, printf_spec_t *ps)
+{
+        /* Precision not specified. */
+        if (precision < 0) {
+                precision = 0;
+        }
         const char *digits;
         if (flags & __PRINTF_FLAG_BIGCHARS)
 …
         return ((int) counter);
+}
+/** Prints a special double (ie NaN, infinity) padded to width characters. */
+static int print_special(ieee_double_t val, int width, uint32_t flags,
+        printf_spec_t *ps)
+{
+        assert(val.is_special);
+        char sign = get_sign_char(val.is_negative, flags);
+        const int str_len = 3;
+        const char *str;
+        if (flags & __PRINTF_FLAG_BIGCHARS) {
+                str = val.is_infinity ? "INF" : "NAN";
+        } else {
+                str = val.is_infinity ? "inf" : "nan";
+        }
+        int padding_len = max(0, width - ((sign ? 1 : 0) + str_len));
+        int counter = 0;
+        int ret;
+        /* Leading padding. */
+        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
+                if ((ret = print_padding(' ', padding_len, ps)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        if (sign) {
+                if ((ret = ps->str_write(&sign, 1, ps->data)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        if ((ret = ps->str_write(str, str_len, ps->data)) < 0)
+                return -1;
+        counter += ret;
+        /* Trailing padding. */
+        if (flags & __PRINTF_FLAG_LEFTALIGNED) {
+                if ((ret = print_padding(' ', padding_len, ps)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        return counter;
+}
+/** Trims trailing zeros but leaves a single "0" intact. */
+static void fp_trim_trailing_zeros(char *buf, int *len, int *dec_exp)
+{
+        /* Cut the zero off by adjusting the exponent. */
+        while (2 <= *len && '0' == buf[*len - 1]) {
+                --*len;
+                ++*dec_exp;
+        }
+}
+/** Textually round up the last digit thereby eliminating it. */
+static void fp_round_up(char *buf, int *len, int *dec_exp)
+{
+        assert(1 <= *len);
+        char *last_digit = &buf[*len - 1];
+        int carry = ('5' <= *last_digit);
+        /* Cut the digit off by adjusting the exponent. */
+        --*len;
+        ++*dec_exp;
+        --last_digit;
+        if (carry) {
+                /* Skip all the digits to cut off/round to zero. */
+                while (buf <= last_digit && '9' == *last_digit) {
+                        --last_digit;
+                }
+                /* last_digit points to the last digit to round but not '9' */
+                if (buf <= last_digit) {
+                        *last_digit += 1;
+                        int new_len = last_digit - buf + 1;
+                        *dec_exp += *len - new_len;
+                        *len = new_len;
+                } else {
+                        /* All len digits rounded to 0. */
+                        buf[0] = '1';
+                        *dec_exp += *len;
+                        *len = 1;
+                }
+        } else {
+                /* The only digit was rounded to 0. */
+                if (last_digit < buf) {
+                        buf[0] = '0';
+                        *dec_exp = 0;
+                        *len = 1;
+                }
+        }
+}
+/** Format and print the double string repressentation according
+ *  to the %f specifier.
+ */
+static int print_double_str_fixed(double_str_t *val_str, int precision, int width,
+        uint32_t flags, printf_spec_t *ps)
+{
+        int len = val_str->len;
+        char *buf = val_str->str;
+        int dec_exp = val_str->dec_exp;
+        assert(0 < len);
+        assert(0 <= precision);
+        assert(0 <= dec_exp || -dec_exp <= precision);
+        /* Number of integral digits to print (at least leading zero). */
+        int int_len = max(1, len + dec_exp);
+        char sign = get_sign_char(val_str->neg, flags);
+        /* Fractional portion lengths. */
+        int last_frac_signif_pos = max(0, -dec_exp);
+        int leading_frac_zeros = max(0, last_frac_signif_pos - len);
+        int signif_frac_figs = min(last_frac_signif_pos, len);
+        int trailing_frac_zeros = precision - last_frac_signif_pos;
+        char *buf_frac = buf + len - signif_frac_figs;
+        if (flags & __PRINTF_FLAG_NOFRACZEROS) {
+                trailing_frac_zeros = 0;
+        }
+        int frac_len = leading_frac_zeros + signif_frac_figs + trailing_frac_zeros;
+        bool has_decimal_pt = (0 < frac_len) || (flags & __PRINTF_FLAG_DECIMALPT);
+        /* Number of non-padding chars to print. */
+        int num_len = (sign ? 1 : 0) + int_len + (has_decimal_pt ? 1 : 0) + frac_len;
+        int padding_len = max(0, width - num_len);
+        int ret = 0;
+        int counter = 0;
+        /* Leading padding and sign. */
+        if (!(flags & (__PRINTF_FLAG_LEFTALIGNED | __PRINTF_FLAG_ZEROPADDED))) {
+                if ((ret = print_padding(' ', padding_len, ps)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        if (sign) {
+                if ((ret = ps->str_write(&sign, 1, ps->data)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        if (flags & __PRINTF_FLAG_ZEROPADDED) {
+                if ((ret = print_padding('0', padding_len, ps)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        /* Print the intergral part of the buffer. */
+        int buf_int_len = min(len, len + dec_exp);
+        if (0 < buf_int_len) {
+                if ((ret = ps->str_write(buf, buf_int_len, ps->data)) < 0)
+                        return -1;
+                counter += ret;
+                /* Print trailing zeros of the integral part of the number. */
+                if ((ret = print_padding('0', int_len - buf_int_len, ps)) < 0)
+                        return -1;
+        } else {
+                /* Single leading integer 0. */
+                char ch = '0';
+                if ((ret = ps->str_write(&ch, 1, ps->data)) < 0)
+                        return -1;
+        }
+        counter += ret;
+        /* Print the decimal point and the fractional part. */
+        if (has_decimal_pt) {
+                char ch = '.';
+                if ((ret = ps->str_write(&ch, 1, ps->data)) < 0)
+                        return -1;
+                counter += ret;
+                /* Print leading zeros of the fractional part of the number. */
+                if ((ret = print_padding('0', leading_frac_zeros, ps)) < 0)
+                        return -1;
+                counter += ret;
+                /* Print significant digits of the fractional part of the number. */
+                if (0 < signif_frac_figs) {
+                        if ((ret = ps->str_write(buf_frac, signif_frac_figs, ps->data)) < 0)
+                                return -1;
+                        counter += ret;
+                }
+                /* Print trailing zeros of the fractional part of the number. */
+                if ((ret = print_padding('0', trailing_frac_zeros, ps)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        /* Trailing padding. */
+        if (flags & __PRINTF_FLAG_LEFTALIGNED) {
+                if ((ret = print_padding(' ', padding_len, ps)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        return counter;
+}
+/** Convert, format and print a double according to the %f specifier.
+ *
+ * @param g     Double to print.
+ * @param precision Number of fractional digits to print. If 0 no
+ *              decimal point will be printed unless the flag
+ *              __PRINTF_FLAG_DECIMALPT is specified.
+ * @param width Minimum number of characters to display. Pads
+ *              with '0' or ' ' depending on the set flags;
+ * @param flags Printf flags.
+ * @param ps    Printing functions.
+ *
+ * @return The number of characters printed; negative on failure.
+ */
+static int print_double_fixed(double g, int precision, int width, uint32_t flags,
+        printf_spec_t *ps)
+{
+        if (flags & __PRINTF_FLAG_LEFTALIGNED) {
+                flags &= ~__PRINTF_FLAG_ZEROPADDED;
+        }
+        if (flags & __PRINTF_FLAG_DECIMALPT) {
+                flags &= ~__PRINTF_FLAG_NOFRACZEROS;
+        }
+        ieee_double_t val = extract_ieee_double(g);
+        if (val.is_special) {
+                return print_special(val, width, flags, ps);
+        }
+        char buf[MAX_DOUBLE_STR_BUF_SIZE];
+        const size_t buf_size = MAX_DOUBLE_STR_BUF_SIZE;
+        double_str_t val_str;
+        val_str.str = buf;
+        val_str.neg = val.is_negative;
+        if (0 <= precision) {
+                /*
+                 * Request one more digit so we can round the result. The last
+                 * digit it returns may have an error of at most +/- 1.
+                 */
+                val_str.len = double_to_fixed_str(val, -1, precision + 1, buf, buf_size,
+                        &val_str.dec_exp);
+                /*
+                 * Round using the last digit to produce precision fractional digits.
+                 * If less than precision+1 fractional digits were output the last
+                 * digit is definitely inaccurate so also round to get rid of it.
+                 */
+                fp_round_up(buf, &val_str.len, &val_str.dec_exp);
+                /* Rounding could have introduced trailing zeros. */
+                if (flags & __PRINTF_FLAG_NOFRACZEROS) {
+                        fp_trim_trailing_zeros(buf, &val_str.len, &val_str.dec_exp);
+                }
+        } else {
+                /* Let the implementation figure out the proper precision. */
+                val_str.len = double_to_short_str(val, buf, buf_size, &val_str.dec_exp);
+                /* Precision needed for the last significant digit. */
+                precision = max(0, -val_str.dec_exp);
+        }
+        return print_double_str_fixed(&val_str, precision, width, flags, ps);
+}
+/** Prints the decimal exponent part of a %e specifier formatted number. */
+static int print_exponent(int exp_val, uint32_t flags, printf_spec_t *ps)
+{
+        int counter = 0;
+        int ret;
+        char exp_ch = (flags & __PRINTF_FLAG_BIGCHARS) ? 'E' : 'e';
+        if ((ret = ps->str_write(&exp_ch, 1, ps->data)) < 0)
+                return -1;
+        counter += ret;
+        char exp_sign = (exp_val < 0) ? '-' : '+';
+        if ((ret = ps->str_write(&exp_sign, 1, ps->data)) < 0)
+                return -1;
+        counter += ret;
+        /* Print the exponent. */
+        exp_val = abs(exp_val);
+        char exp_str[4] = { 0 };
+        exp_str[0] = '0' + exp_val / 100;
+        exp_str[1] = '0' + (exp_val % 100) / 10 ;
+        exp_str[2] = '0' + (exp_val % 10);
+        int exp_len = (exp_str[0] == '0') ? 2 : 3;
+        const char *exp_str_start = &exp_str[3] - exp_len;
+        if ((ret = ps->str_write(exp_str_start, exp_len, ps->data)) < 0)
+                return -1;
+        counter += ret;
+        return counter;
+}
+/** Format and print the double string repressentation according
+ *  to the %e specifier.
+ */
+static int print_double_str_scient(double_str_t *val_str, int precision,
+        int width, uint32_t flags, printf_spec_t *ps)
+{
+        int len = val_str->len;
+        int dec_exp = val_str->dec_exp;
+        char *buf  = val_str->str;
+        assert(0 < len);
+        char sign = get_sign_char(val_str->neg, flags);
+        bool has_decimal_pt = (0 < precision) || (flags & __PRINTF_FLAG_DECIMALPT);
+        int dec_pt_len = has_decimal_pt ? 1 : 0;
+        /* Fractional part lengths. */
+        int signif_frac_figs = len - 1;
+        int trailing_frac_zeros = precision - signif_frac_figs;
+        if (flags & __PRINTF_FLAG_NOFRACZEROS) {
+                trailing_frac_zeros = 0;
+        }
+        int frac_len = signif_frac_figs + trailing_frac_zeros;
+        int exp_val = dec_exp + len - 1;
+        /* Account for exponent sign and 'e'; minimum 2 digits. */
+        int exp_len = 2 + (abs(exp_val) >= 100 ? 3 : 2);
+        /* Number of non-padding chars to print. */
+        int num_len = (sign ? 1 : 0) + 1 + dec_pt_len + frac_len + exp_len;
+        int padding_len = max(0, width - num_len);
+        int ret = 0;
+        int counter = 0;
+        if (!(flags & (__PRINTF_FLAG_LEFTALIGNED | __PRINTF_FLAG_ZEROPADDED))) {
+                if ((ret = print_padding(' ', padding_len, ps)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        if (sign) {
+                if ((ret = ps->str_write(&sign, 1, ps->data)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        if (flags & __PRINTF_FLAG_ZEROPADDED) {
+                if ((ret = print_padding('0', padding_len, ps)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        /* Single leading integer. */
+        if ((ret = ps->str_write(buf, 1, ps->data)) < 0)
+                return -1;
+        counter += ret;
+        /* Print the decimal point and the fractional part. */
+        if (has_decimal_pt) {
+                char ch = '.';
+                if ((ret = ps->str_write(&ch, 1, ps->data)) < 0)
+                        return -1;
+                counter += ret;
+                /* Print significant digits of the fractional part of the number. */
+                if (0 < signif_frac_figs) {
+                        if ((ret = ps->str_write(buf + 1, signif_frac_figs, ps->data)) < 0)
+                                return -1;
+                        counter += ret;
+                }
+                /* Print trailing zeros of the fractional part of the number. */
+                if ((ret = print_padding('0', trailing_frac_zeros, ps)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        /* Print the exponent. */
+        if ((ret = print_exponent(exp_val, flags, ps)) < 0)
+                return -1;
+        counter += ret;
+        if (flags & __PRINTF_FLAG_LEFTALIGNED) {
+                if ((ret = print_padding(' ', padding_len, ps)) < 0)
+                        return -1;
+                counter += ret;
+        }
+        return counter;
+}
+/** Convert, format and print a double according to the %e specifier.
+ *
+ * Note that if g is large, the output may be huge (3e100 prints
+ * with at least 100 digits).
+ *
+ * %e style: [-]d.dddde+dd
+ *  left-justified:  [-]d.dddde+dd[space_pad]
+ *  right-justified: [space_pad][-][zero_pad]d.dddde+dd
+ *
+ * @param g     Double to print.
+ * @param precision Number of fractional digits to print, ie
+ *              precision + 1 significant digits to display. If 0 no
+ *              decimal point will be printed unless the flag
+ *              __PRINTF_FLAG_DECIMALPT is specified. If negative
+ *              the shortest accurate number will be printed.
+ * @param width Minimum number of characters to display. Pads
+ *              with '0' or ' ' depending on the set flags;
+ * @param flags Printf flags.
+ * @param ps    Printing functions.
+ *
+ * @return The number of characters printed; negative on failure.
+ */
+static int print_double_scientific(double g, int precision, int width,
+        uint32_t flags, printf_spec_t *ps)
+{
+        if (flags & __PRINTF_FLAG_LEFTALIGNED) {
+                flags &= ~__PRINTF_FLAG_ZEROPADDED;
+        }
+        ieee_double_t val = extract_ieee_double(g);
+        if (val.is_special) {
+                return print_special(val, width, flags, ps);
+        }
+        char buf[MAX_DOUBLE_STR_BUF_SIZE];
+        const size_t buf_size = MAX_DOUBLE_STR_BUF_SIZE;
+        double_str_t val_str;
+        val_str.str = buf;
+        val_str.neg = val.is_negative;
+        if (0 <= precision) {
+                /*
+                 * Request one more digit (in addition to the leading integer)
+                 * so we can round the result. The last digit it returns may
+                 * have an error of at most +/- 1.
+                 */
+                val_str.len = double_to_fixed_str(val, precision + 2, -1, buf, buf_size,
+                        &val_str.dec_exp);
+                /*
+                 * Round the extra digit to produce precision+1 significant digits.
+                 * If less than precision+2 significant digits were returned the last
+                 * digit is definitely inaccurate so also round to get rid of it.
+                 */
+                fp_round_up(buf, &val_str.len, &val_str.dec_exp);
+                /* Rounding could have introduced trailing zeros. */
+                if (flags & __PRINTF_FLAG_NOFRACZEROS) {
+                        fp_trim_trailing_zeros(buf, &val_str.len, &val_str.dec_exp);
+                }
+        } else {
+                /* Let the implementation figure out the proper precision. */
+                val_str.len = double_to_short_str(val, buf, buf_size, &val_str.dec_exp);
+                /* Use all produced digits. */
+                precision = val_str.len - 1;
+        }
+        return print_double_str_scient(&val_str, precision, width, flags, ps);
+}
+/** Convert, format and print a double according to the %g specifier.
+ *
+ * %g style chooses between %f and %e.
+ *
+ * @param g     Double to print.
+ * @param precision Number of significant digits to display; excluding
+ *              any leading zeros from this count. If negative
+ *              the shortest accurate number will be printed.
+ * @param width Minimum number of characters to display. Pads
+ *              with '0' or ' ' depending on the set flags;
+ * @param flags Printf flags.
+ * @param ps    Printing functions.
+ *
+ * @return The number of characters printed; negative on failure.
+ */
+static int print_double_generic(double g, int precision, int width,
+        uint32_t flags, printf_spec_t *ps)
+{
+        ieee_double_t val = extract_ieee_double(g);
+        if (val.is_special) {
+                return print_special(val, width, flags, ps);
+        }
+        char buf[MAX_DOUBLE_STR_BUF_SIZE];
+        const size_t buf_size = MAX_DOUBLE_STR_BUF_SIZE;
+        int dec_exp;
+        int len;
+        /* Honor the user requested number of significant digits. */
+        if (0 <= precision) {
+                /*
+                 * Do a quick and dirty conversion of a single digit to determine
+                 * the decimal exponent.
+                 */
+                len = double_to_fixed_str(val, 1, -1, buf, buf_size, &dec_exp);
+                assert(0 < len);
+                precision = max(1, precision);
+                if (-4 <= dec_exp && dec_exp < precision) {
+                        precision = precision - (dec_exp + 1);
+                        return print_double_fixed(g, precision, width,
+                                flags | __PRINTF_FLAG_NOFRACZEROS, ps);
+                } else {
+                        --precision;
+                        return print_double_scientific(g, precision, width,
+                                flags | __PRINTF_FLAG_NOFRACZEROS, ps);
+                }
+        } else {
+                /* Convert to get the decimal exponent and digit count.*/
+                len = double_to_short_str(val, buf, buf_size, &dec_exp);
+                assert(0 < len);
+                if (flags & __PRINTF_FLAG_LEFTALIGNED) {
+                        flags &= ~__PRINTF_FLAG_ZEROPADDED;
+                }
+                double_str_t val_str;
+                val_str.str = buf;
+                val_str.len = len;
+                val_str.neg = val.is_negative;
+                val_str.dec_exp = dec_exp;
+                int first_digit_pos = len + dec_exp;
+                int last_digit_pos = dec_exp;
+                /* The whole number (15 digits max) fits between dec places 15 .. -6 */
+                if (len <= 15 && -6 <= last_digit_pos && first_digit_pos <= 15) {
+                        /* Precision needed for the last significant digit. */
+                        precision = max(0, -val_str.dec_exp);
+                        return print_double_str_fixed(&val_str, precision, width, flags, ps);
+                } else {
+                        /* Use all produced digits. */
+                        precision = val_str.len - 1;
+                        return print_double_str_scient(&val_str, precision, width, flags, ps);
+                }
+        }
+}
+/** Convert, format and print a double according to the specifier.
+ *
+ * Depending on the specifier it prints the double using the styles
+ * %g, %f or %e by means of print_double_generic(), print_double_fixed(),
+ * print_double_scientific().
+ *
+ * @param g     Double to print.
+ * @param spec  Specifier of the style to print in; one of: 'g','G','f','F',
+ *              'e','E'.
+ * @param precision Number of fractional digits to display. If negative
+ *              the shortest accurate number will be printed for style %g;
+ *              negative precision defaults to 6 for styles %f, %e.
+ * @param width Minimum number of characters to display. Pads
+ *              with '0' or ' ' depending on the set flags;
+ * @param flags Printf flags.
+ * @param ps    Printing functions.
+ *
+ * @return The number of characters printed; negative on failure.
+ */
+static int print_double(double g, char spec, int precision, int width,
+        uint32_t flags, printf_spec_t *ps)
+{
+        switch (spec) {
+        case 'F':
+                flags |= __PRINTF_FLAG_BIGCHARS;
+                /* Fall through.*/
+        case 'f':
+                precision = (precision < 0) ? 6 : precision;
+                return print_double_fixed(g, precision, width, flags, ps);
+        case 'E':
+                flags |= __PRINTF_FLAG_BIGCHARS;
+                /* Fall through.*/
+        case 'e':
+                precision = (precision < 0) ? 6 : precision;
+                return print_double_scientific(g, precision, width, flags, ps);
+        case 'G':
+                flags |= __PRINTF_FLAG_BIGCHARS;
+                /* Fall through.*/
+        case 'g':
+                return print_double_generic(g, precision, width, flags, ps);
+        default:
+                assert(false);
+                return -1;
+        }
+}
 …
                                 case '#':
                                         flags |= __PRINTF_FLAG_PREFIX;
+                                        flags |= __PRINTF_FLAG_DECIMALPT;
                                         break;
                                 case '-':
 …
                         /* Precision and '*' operator */
                         int precision = 0;
+                        int precision = -1;
                         if (uc == '.') {
                                 i = nxt;
                                 uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                 if (isdigit(uc)) {
+                                        precision = 0;
                                         while (true) {
                                                 precision *= 10;
 …
                                         precision = (int) va_arg(ap, int);
                                         if (precision < 0) {
                                                 /* Ignore negative precision */
                                                 precision = 0;
+                                                /* Ignore negative precision - use default instead */
+                                                precision = -1;
+                                        }
+                                }
 …
                          */
                         case 's':
+                                precision = max(0,  precision);
                                 if (qualifier == PrintfQualifierLong)
                                         retval = print_wstr(va_arg(ap, wchar_t *), width, precision, flags, ps);
 …
                                         goto out;
                                 };
+                                counter += retval;
+                                j = nxt;
+                                goto next_char;
+                        /*
+                         * Floating point values
+                         */
+                        case 'G':
+                        case 'g':
+                        case 'F':
+                        case 'f':
+                        case 'E':
+                        case 'e':
+                                retval = print_double(va_arg(ap, double), uc, precision,
+                                        width, flags, ps);
+                                if (retval < 0) {
+                                        counter = -counter;
+                                        goto out;
+                                }
                                 counter += retval;

uspace/lib/c/generic/ipc.c

-              rb5d2e57
+              r03362fbd
 #include <fibril.h>
 #include <macros.h>
-#include "private/libc.h"
 /**
 …
 static atomic_t ipc_futex = FUTEX_INITIALIZER;
-/** Fast synchronous call.
+ *
- * Only three payload arguments can be passed using this function. However,
- * this function is faster than the generic ipc_call_sync_slow() because
- * the payload is passed directly in registers.
+ *
- * @param phoneid Phone handle for the call.
- * @param method  Requested method.
- * @param arg1    Service-defined payload argument.
- * @param arg2    Service-defined payload argument.
- * @param arg3    Service-defined payload argument.
- * @param result1 If non-NULL, the return ARG1 will be stored there.
- * @param result2 If non-NULL, the return ARG2 will be stored there.
- * @param result3 If non-NULL, the return ARG3 will be stored there.
- * @param result4 If non-NULL, the return ARG4 will be stored there.
- * @param result5 If non-NULL, the return ARG5 will be stored there.
+ *
- * @return Negative values representing IPC errors.
- * @return Otherwise the RETVAL of the answer.
+ *
- */
-int ipc_call_sync_fast(int phoneid, sysarg_t method, sysarg_t arg1,
-    sysarg_t arg2, sysarg_t arg3, sysarg_t *result1, sysarg_t *result2,
-    sysarg_t *result3, sysarg_t *result4, sysarg_t *result5)
+{
-        ipc_call_t resdata;
-        int callres = __SYSCALL6(SYS_IPC_CALL_SYNC_FAST, phoneid, method, arg1,
-            arg2, arg3, (sysarg_t) &resdata);
-        if (callres)
-                return callres;
-        if (result1)
-                *result1 = IPC_GET_ARG1(resdata);
-        if (result2)
-                *result2 = IPC_GET_ARG2(resdata);
-        if (result3)
-                *result3 = IPC_GET_ARG3(resdata);
-        if (result4)
-                *result4 = IPC_GET_ARG4(resdata);
-        if (result5)
-                *result5 = IPC_GET_ARG5(resdata);
-        return IPC_GET_RETVAL(resdata);
+}
-/** Synchronous call transmitting 5 arguments of payload.
+ *
- * @param phoneid Phone handle for the call.
- * @param imethod Requested interface and method.
- * @param arg1    Service-defined payload argument.
- * @param arg2    Service-defined payload argument.
- * @param arg3    Service-defined payload argument.
- * @param arg4    Service-defined payload argument.
- * @param arg5    Service-defined payload argument.
- * @param result1 If non-NULL, storage for the first return argument.
- * @param result2 If non-NULL, storage for the second return argument.
- * @param result3 If non-NULL, storage for the third return argument.
- * @param result4 If non-NULL, storage for the fourth return argument.
- * @param result5 If non-NULL, storage for the fifth return argument.
+ *
- * @return Negative values representing IPC errors.
- * @return Otherwise the RETVAL of the answer.
+ *
- */
-int ipc_call_sync_slow(int phoneid, sysarg_t imethod, sysarg_t arg1,
-    sysarg_t arg2, sysarg_t arg3, sysarg_t arg4, sysarg_t arg5,
-    sysarg_t *result1, sysarg_t *result2, sysarg_t *result3, sysarg_t *result4,
-    sysarg_t *result5)
+{
-        ipc_call_t data;
-        IPC_SET_IMETHOD(data, imethod);
-        IPC_SET_ARG1(data, arg1);
-        IPC_SET_ARG2(data, arg2);
-        IPC_SET_ARG3(data, arg3);
-        IPC_SET_ARG4(data, arg4);
-        IPC_SET_ARG5(data, arg5);
-        int callres = __SYSCALL3(SYS_IPC_CALL_SYNC_SLOW, phoneid,
-            (sysarg_t) &data, (sysarg_t) &data);
-        if (callres)
-                return callres;
-        if (result1)
-                *result1 = IPC_GET_ARG1(data);
-        if (result2)
-                *result2 = IPC_GET_ARG2(data);
-        if (result3)
-                *result3 = IPC_GET_ARG3(data);
-        if (result4)
-                *result4 = IPC_GET_ARG4(data);
-        if (result5)
-                *result5 = IPC_GET_ARG5(data);
-        return IPC_GET_RETVAL(data);
+}
 /** Send asynchronous message via syscall.
 …
+}
-/** Request callback connection.
+ *
- * The @a task_id and @a phonehash identifiers returned
- * by the kernel can be used for connection tracking.
+ *
- * @param phoneid   Phone handle used for contacting the other side.
- * @param arg1      User defined argument.
- * @param arg2      User defined argument.
- * @param arg3      User defined argument.
- * @param task_id   Identifier of the client task.
- * @param phonehash Opaque identifier of the phone that will
- *                  be used for incoming calls.
+ *
- * @return Zero on success or a negative error code.
+ *
- */
-int ipc_connect_to_me(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3,
-    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_clone_establish(int phoneid)
+{
-        sysarg_t newphid;
-        int res = ipc_call_sync_0_5(phoneid, IPC_M_CLONE_ESTABLISH, NULL,
-            NULL, NULL, NULL, &newphid);
-        if (res)
-                return res;
-        return newphid;
+}
-/** Request new connection.
+ *
- * @param phoneid Phone handle used for contacting the other side.
- * @param arg1    User defined argument.
- * @param arg2    User defined argument.
- * @param arg3    User defined argument.
+ *
- * @return New phone handle on success or a negative error code.
+ *
- */
-int ipc_connect_me_to(int phoneid, sysarg_t arg1, sysarg_t arg2, sysarg_t arg3)
+{
-        sysarg_t newphid;
-        int res = ipc_call_sync_3_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
-            NULL, NULL, NULL, NULL, &newphid);
-        if (res)
-                return res;
-        return newphid;
+}
-/** Request new connection (blocking)
+ *
- * If the connection is not available at the moment, the
- * call should block. This has to be, however, implemented
- * on the server side.
+ *
- * @param phoneid Phone handle used for contacting the other side.
- * @param arg1    User defined argument.
- * @param arg2    User defined argument.
- * @param arg3    User defined argument.
+ *
- * @return New phone handle on success or a negative error code.
+ *
- */
-int ipc_connect_me_to_blocking(int phoneid, sysarg_t arg1, sysarg_t arg2,
-    sysarg_t arg3)
+{
-        sysarg_t newphid;
-        int res = ipc_call_sync_4_5(phoneid, IPC_M_CONNECT_ME_TO, arg1, arg2, arg3,
-            IPC_FLAG_BLOCKING, NULL, NULL, NULL, NULL, &newphid);
-        if (res)
-                return res;
-        return newphid;
+}
 /** Hang up a phone.
+ *
 …
+}
-/** Wrapper for IPC_M_SHARE_IN calls.
+ *
- * @param phoneid Phone that will be used to contact the receiving side.
- * @param size    Size of the destination address space area.
- * @param arg     User defined argument.
- * @param flags   Storage for received flags. Can be NULL.
- * @param dst     Destination address space area base. Cannot be NULL.
+ *
- * @return Zero on success or a negative error code from errno.h.
+ *
- */
-int ipc_share_in_start(int phoneid, size_t size, sysarg_t arg,
-    unsigned int *flags, void **dst)
+{
-        sysarg_t _flags = 0;
-        sysarg_t _dst = (sysarg_t) -1;
-        int res = ipc_call_sync_2_4(phoneid, IPC_M_SHARE_IN, (sysarg_t) size,
-            arg, NULL, &_flags, NULL, &_dst);
-        if (flags)
-                *flags = (unsigned int) _flags;
-        *dst = (void *) _dst;
-        return res;
+}
-/** Wrapper for answering the IPC_M_SHARE_IN calls.
+ *
- * This wrapper only makes it more comfortable to answer IPC_M_SHARE_IN
- * calls so that the user doesn't have to remember the meaning of each
- * IPC argument.
+ *
- * @param callid Hash of the IPC_M_DATA_READ call to answer.
- * @param src    Source address space base.
- * @param flags Flags to be used for sharing. Bits can be only cleared.
+ *
- * @return Zero on success or a value from @ref errno.h on failure.
+ *
- */
-int ipc_share_in_finalize(ipc_callid_t callid, void *src, unsigned int flags)
+{
-        return ipc_answer_3(callid, EOK, (sysarg_t) src, (sysarg_t) flags,
-            (sysarg_t) __entry);
+}
-/** Wrapper for IPC_M_SHARE_OUT calls.
+ *
- * @param phoneid Phone that will be used to contact the receiving side.
- * @param src     Source address space area base address.
- * @param flags   Flags to be used for sharing. Bits can be only cleared.
+ *
- * @return Zero on success or a negative error code from errno.h.
+ *
- */
-int ipc_share_out_start(int phoneid, void *src, unsigned int flags)
+{
-        return ipc_call_sync_3_0(phoneid, IPC_M_SHARE_OUT, (sysarg_t) src, 0,
-            (sysarg_t) flags);
+}
-/** Wrapper for answering the IPC_M_SHARE_OUT calls.
+ *
- * This wrapper only makes it more comfortable to answer IPC_M_SHARE_OUT
- * calls so that the user doesn't have to remember the meaning of each
- * IPC argument.
+ *
- * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
- * @param dst    Destination address space area base address.
+ *
- * @return Zero on success or a value from @ref errno.h on failure.
+ *
- */
-int ipc_share_out_finalize(ipc_callid_t callid, void **dst)
+{
-        return ipc_answer_2(callid, EOK, (sysarg_t) __entry, (sysarg_t) dst);
+}
-/** Wrapper for IPC_M_DATA_READ calls.
+ *
- * @param phoneid Phone that will be used to contact the receiving side.
- * @param dst     Address of the beginning of the destination buffer.
- * @param size    Size of the destination buffer.
+ *
- * @return Zero on success or a negative error code from errno.h.
+ *
- */
-int ipc_data_read_start(int phoneid, void *dst, size_t size)
+{
-        return ipc_call_sync_2_0(phoneid, IPC_M_DATA_READ, (sysarg_t) dst,
-            (sysarg_t) size);
+}
-/** Wrapper for answering the IPC_M_DATA_READ calls.
+ *
- * This wrapper only makes it more comfortable to answer IPC_M_DATA_READ
- * calls so that the user doesn't have to remember the meaning of each
- * IPC argument.
+ *
- * @param callid Hash of the IPC_M_DATA_READ call to answer.
- * @param src    Source address for the IPC_M_DATA_READ call.
- * @param size   Size for the IPC_M_DATA_READ call. Can be smaller than
- *               the maximum size announced by the sender.
+ *
- * @return Zero on success or a value from @ref errno.h on failure.
+ *
- */
-int ipc_data_read_finalize(ipc_callid_t callid, const void *src, size_t size)
+{
-        return ipc_answer_2(callid, EOK, (sysarg_t) src, (sysarg_t) size);
+}
-/** Wrapper for IPC_M_DATA_WRITE calls.
+ *
- * @param phoneid Phone that will be used to contact the receiving side.
- * @param src     Address of the beginning of the source buffer.
- * @param size    Size of the source buffer.
+ *
- * @return Zero on success or a negative error code from errno.h.
+ *
- */
-int ipc_data_write_start(int phoneid, const void *src, size_t size)
+{
-        return ipc_call_sync_2_0(phoneid, IPC_M_DATA_WRITE, (sysarg_t) src,
-            (sysarg_t) size);
+}
-/** Wrapper for answering the IPC_M_DATA_WRITE calls.
+ *
- * This wrapper only makes it more comfortable to answer IPC_M_DATA_WRITE
- * calls so that the user doesn't have to remember the meaning of each
- * IPC argument.
+ *
- * @param callid Hash of the IPC_M_DATA_WRITE call to answer.
- * @param dst    Final destination address for the IPC_M_DATA_WRITE call.
- * @param size   Final size for the IPC_M_DATA_WRITE call.
+ *
- * @return Zero on success or a value from @ref errno.h on failure.
+ *
- */
-int ipc_data_write_finalize(ipc_callid_t callid, void *dst, size_t size)
+{
-        return ipc_answer_2(callid, EOK, (sysarg_t) dst, (sysarg_t) size);
+}
 /** Connect to a task specified by id.
+ *

uspace/lib/c/generic/iplink_srv.c

-              rb5d2e57
+              r03362fbd
                 if (!method) {
                         /* The other side has hung up */
+                        fibril_mutex_lock(&srv->lock);
+                        srv->connected = false;
+                        fibril_mutex_unlock(&srv->lock);
                         async_answer_0(callid, EOK);
                         break;

uspace/lib/c/generic/loc.c

rb5d2e57	r03362fbd
37	37	#include <errno.h>
38	38	#include <malloc.h>
39		#include <bool.h>
	39	#include <stdbool.h>
40	40
41	41	static FIBRIL_MUTEX_INITIALIZE(loc_supp_block_mutex);

uspace/lib/c/generic/malloc.c

-              rb5d2e57
+              r03362fbd
 #include <malloc.h>
 #include <bool.h>
+#include <stdbool.h>
 #include <as.h>
 #include <align.h>
 …
         (((uintptr_t) (area)->end) - sizeof(heap_block_foot_t))
+#define AREA_LAST_BLOCK_HEAD(area) \
+        ((uintptr_t) BLOCK_HEAD(((heap_block_foot_t *) AREA_LAST_BLOCK_FOOT(area))))
 /** Get header in heap block.
+ *
 …
         size_t asize = ALIGN_UP(size, PAGE_SIZE);
         void *astart = as_area_create(AS_AREA_ANY, asize,
             AS_AREA_WRITE | AS_AREA_READ);
+            AS_AREA_WRITE | AS_AREA_READ | AS_AREA_CACHEABLE);
         if (astart == AS_MAP_FAILED)
                 return false;
 …
                 return false;
+        /* Add new free block */
+        size_t net_size = (size_t) (end - area->end);
+        if (net_size > 0)
+                block_init(area->end, net_size, true, area);
+        heap_block_head_t *last_head =
+            (heap_block_head_t *) AREA_LAST_BLOCK_HEAD(area);
+        if (last_head->free) {
+                /* Add the new space to the last block. */
+                size_t net_size = (size_t) (end - area->end) + last_head->size;
+                malloc_assert(net_size > 0);
+                block_init(last_head, net_size, true, area);
+        } else {
+                /* Add new free block */
+                size_t net_size = (size_t) (end - area->end);
+                if (net_size > 0)
+                        block_init(area->end, net_size, true, area);
+        }
         /* Update heap area parameters */
 …
         return true;
+}
-/** Try to enlarge any of the heap areas
+ *
- * Should be called only inside the critical section.
+ *
- * @param size Gross size of item to allocate (bytes).
+ *
- */
-static bool heap_grow(size_t size)
+{
-        if (size == 0)
-                return true;
-        /* First try to enlarge some existing area */
-        for (heap_area_t *area = first_heap_area; area != NULL;
-            area = area->next) {
-                if (area_grow(area, size))
-                        return true;
+        }
-        /* Eventually try to create a new area */
-        return area_create(AREA_OVERHEAD(size));
+}
 …
+}
+/** Try to enlarge any of the heap areas.
+ *
+ * If successful, allocate block of the given size in the area.
+ * Should be called only inside the critical section.
+ *
+ * @param size  Gross size of item to allocate (bytes).
+ * @param align Memory address alignment.
+ *
+ * @return Allocated block.
+ * @return NULL on failure.
+ *
+ */
+static void *heap_grow_and_alloc(size_t size, size_t align)
+{
+        if (size == 0)
+                return NULL;
+        /* First try to enlarge some existing area */
+        for (heap_area_t *area = first_heap_area; area != NULL;
+            area = area->next) {
+                if (area_grow(area, size + align)) {
+                        heap_block_head_t *first =
+                            (heap_block_head_t *) AREA_LAST_BLOCK_HEAD(area);
+                        void *addr =
+                            malloc_area(area, first, NULL, size, align);
+                        malloc_assert(addr != NULL);
+                        return addr;
+                }
+        }
+        /* Eventually try to create a new area */
+        if (area_create(AREA_OVERHEAD(size + align))) {
+                heap_block_head_t *first =
+                    (heap_block_head_t *) AREA_FIRST_BLOCK_HEAD(last_heap_area);
+                void *addr =
+                    malloc_area(last_heap_area, first, NULL, size, align);
+                malloc_assert(addr != NULL);
+                return addr;
+        }
+        return NULL;
+}
 /** Allocate a memory block
+ *
 …
         size_t falign = lcm(align, BASE_ALIGN);
+        size_t real_size = GROSS_SIZE(ALIGN_UP(size, falign));
+        bool retry = false;
+        heap_block_head_t *split;
+loop:
+        /* Check for integer overflow. */
+        if (falign < align)
+                return NULL;
+        /*
+         * The size of the allocated block needs to be naturally
+         * aligned, because the footer structure also needs to reside
+         * on a naturally aligned address in order to avoid unaligned
+         * memory accesses.
+         */
+        size_t gross_size = GROSS_SIZE(ALIGN_UP(size, BASE_ALIGN));
         /* Try the next fit approach */
         split = next_fit;
+        heap_block_head_t *split = next_fit;
         if (split != NULL) {
                 void *addr = malloc_area(split->area, split, NULL, real_size,
+                void *addr = malloc_area(split->area, split, NULL, gross_size,
                     falign);
 …
                     AREA_FIRST_BLOCK_HEAD(area);
                 void *addr = malloc_area(area, first, split, real_size,
+                void *addr = malloc_area(area, first, split, gross_size,
                     falign);
 …
+        }
+        if (!retry) {
+                /* Try to grow the heap space */
+                if (heap_grow(real_size)) {
+                        retry = true;
+                        goto loop;
+                }
+        }
+        return NULL;
+        /* Finally, try to grow heap space and allocate in the new area. */
+        return heap_grow_and_alloc(gross_size, falign);
+}
 …
 void *calloc(const size_t nmemb, const size_t size)
+{
+        // FIXME: Check for overflow
         void *block = malloc(nmemb * size);
         if (block == NULL)
 …
         if (addr == NULL)
                 return;
         futex_down(&malloc_futex);

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

rb5d2e57	r03362fbd
41	41	#include <fibril_synch.h>
42	42	#include <sys/time.h>
43		#include <bool.h>
	43	#include <stdbool.h>
44	44
45	45	/** Structures of this type are used to track the timeout events. */

uspace/lib/c/generic/stdlib.c

rb5d2e57	r03362fbd
39	39	long int random(void)
40	40	{
41		return glbl_seed = ((1366*glbl_seed + 150889) % RAND_MAX);
	41	return glbl_seed = ((1366 * glbl_seed + 150889) % RAND_MAX);
42	42	}
43	43
44	44	void srandom(unsigned int seed)
45	45	{
46		glbl_seed = seed;
	46	glbl_seed = seed % RAND_MAX;
47	47	}
48	48

uspace/lib/c/generic/str.c

-              rb5d2e57
+              r03362fbd
+}
+/** Decode a single character from a string to the left.
+ *
+ * Decode a single character from a string of size @a size. Decoding starts
+ * at @a offset and this offset is moved to the beginning of the previous
+ * character. In case of decoding error, offset generally decreases at least
+ * by one. However, offset is never moved before 0.
+ *
+ * @param str    String (not necessarily NULL-terminated).
+ * @param offset Byte offset in string where to start decoding.
+ * @param size   Size of the string (in bytes).
+ *
+ * @return Value of decoded character, U_SPECIAL on decoding error or
+ *         NULL if attempt to decode beyond @a start of str.
+ *
+ */
+wchar_t str_decode_reverse(const char *str, size_t *offset, size_t size)
+{
+        if (*offset == 0)
+                return 0;
+        size_t processed = 0;
+        /* Continue while continuation bytes found */
+        while (*offset > 0 && processed < 4) {
+                uint8_t b = (uint8_t) str[--(*offset)];
+                if (processed == 0 && (b & 0x80) == 0) {
+                        /* 0xxxxxxx (Plain ASCII) */
+                        return b & 0x7f;
+                }
+                else if ((b & 0xe0) == 0xc0 || (b & 0xf0) == 0xe0 ||
+                    (b & 0xf8) == 0xf0) {
+                        /* Start byte */
+                        size_t start_offset = *offset;
+                        return str_decode(str, &start_offset, size);
+                }
+                else if ((b & 0xc0) != 0x80) {
+                        /* Not a continuation byte */
+                        return U_SPECIAL;
+                }
+                processed++;
+        }
+        /* Too many continuation bytes */
+        return U_SPECIAL;
+}
 /** Encode a single character to string representation.
+ *
 …
+}
+/** Get character display width on a character cell display.
+ *
+ * @param ch    Character
+ * @return      Width of character in cells.
+ */
+size_t chr_width(wchar_t ch)
+{
+        return 1;
+}
+/** Get string display width on a character cell display.
+ *
+ * @param str   String
+ * @return      Width of string in cells.
+ */
+size_t str_width(const char *str)
+{
+        size_t width = 0;
+        size_t offset = 0;
+        wchar_t ch;
+        while ((ch = str_decode(str, &offset, STR_NO_LIMIT)) != 0)
+                width += chr_width(ch);
+        return width;
+}
 /** Check whether character is plain ASCII.
+ *
 …
+ *
  * Do a char-by-char comparison of two NULL-terminated strings.
+ * The strings are considered equal iff they consist of the same
+ * characters on the minimum of their lengths.
+ * The strings are considered equal iff their length is equal
+ * and both strings consist of the same sequence of characters.
+ *
+ * A string S1 is less than another string S2 if it has a character with
+ * lower value at the first character position where the strings differ.
+ * If the strings differ in length, the shorter one is treated as if
+ * padded by characters with a value of zero.
+ *
  * @param s1 First string to compare.
  * @param s2 Second string to compare.
+ *
  * @return 0 if the strings are equal, -1 if first is smaller,
  *         1 if second smaller.
+ * @return 0 if the strings are equal, -1 if the first is less than the second,
+ *         1 if the second is less than the first.
+ *
  */
 …
+ *
  * Do a char-by-char comparison of two NULL-terminated strings.
+ * The strings are considered equal iff they consist of the same
+ * characters on the minimum of their lengths and the length limit.
+ * The strings are considered equal iff
+ * min(str_length(s1), max_len) == min(str_length(s2), max_len)
+ * and both strings consist of the same sequence of characters,
+ * up to max_len characters.
+ *
+ * A string S1 is less than another string S2 if it has a character with
+ * lower value at the first character position where the strings differ.
+ * If the strings differ in length, the shorter one is treated as if
+ * padded by characters with a value of zero. Only the first max_len
+ * characters are considered.
+ *
  * @param s1      First string to compare.
 …
  * @param max_len Maximum number of characters to consider.
+ *
  * @return 0 if the strings are equal, -1 if first is smaller,
  *         1 if second smaller.
+ * @return 0 if the strings are equal, -1 if the first is less than the second,
+ *         1 if the second is less than the first.
+ *
  */
 …
         return 0;
+}
+/** Test whether p is a prefix of s.
+ *
+ * Do a char-by-char comparison of two NULL-terminated strings
+ * and determine if p is a prefix of s.
+ *
+ * @param s The string in which to look
+ * @param p The string to check if it is a prefix of s
+ *
+ * @return true iff p is prefix of s else false
+ *
+ */
+bool str_test_prefix(const char *s, const char *p)
+{
+        wchar_t c1 = 0;
+        wchar_t c2 = 0;
+        size_t off1 = 0;
+        size_t off2 = 0;
+        while (true) {
+                c1 = str_decode(s, &off1, STR_NO_LIMIT);
+                c2 = str_decode(p, &off2, STR_NO_LIMIT);
+                if (c2 == 0)
+                        return true;
+                if (c1 != c2)
+                        return false;
+                if (c1 == 0)
+                        break;
+        }
+        return false;
+}
 …
                 c = (c >= 'a' ? c - 'a' + 10 : (c >= 'A' ? c - 'A' + 10 :
                     (c <= '9' ? c - '0' : 0xff)));
                 if (c > base) {
+                if (c >= base) {
                         break;
+                }

uspace/lib/c/generic/sysinfo.c

rb5d2e57	r03362fbd
38	38	#include <errno.h>
39	39	#include <malloc.h>
40		#include <bool.h>
	40	#include <stdbool.h>
41	41	#include <unistd.h>
42	42

uspace/lib/c/generic/task.c

-              rb5d2e57
+              r03362fbd
+ *
  * This is really just a convenience wrapper over the more complicated
+ * loader API. Arguments are passed in a va_list.
+ *
+ * @param id   If not NULL, the ID of the task is stored here on success.
+ * @param path Pathname of the binary to execute.
+ * @param cnt  Number of arguments.
+ * @param ap   Command-line arguments.
+ *
+ * @return Zero on success or negative error code.
+ *
+ */
+int task_spawn(task_id_t *task_id, const char *path, int cnt, va_list ap)
+{
+        /* Allocate argument list. */
+        const char **arglist = malloc(cnt * sizeof(const char *));
+        if (arglist == NULL)
+                return ENOMEM;
+        /* Fill in arguments. */
+        const char *arg;
+        cnt = 0;
+        do {
+                arg = va_arg(ap, const char *);
+                arglist[cnt++] = arg;
+        } while (arg != NULL);
+        /* Spawn task. */
+        int rc = task_spawnv(task_id, path, arglist);
+        /* Free argument list. */
+        free(arglist);
+        return rc;
+}
+/** 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 list of arguments.
+ *
 …
         va_list ap;
         const char *arg;
-        const char **arglist;
         int cnt = 0;
 …
         va_end(ap);
-        /* Allocate argument list. */
-        arglist = malloc(cnt * sizeof(const char *));
-        if (arglist == NULL)
-                return ENOMEM;
-        /* Fill in arguments. */
-        cnt = 0;
         va_start(ap, path);
+        do {
+                arg = va_arg(ap, const char *);
+                arglist[cnt++] = arg;
+        } while (arg != NULL);
+        int rc = task_spawn(task_id, path, cnt, ap);
         va_end(ap);
-        /* Spawn task. */
-        int rc = task_spawnv(task_id, path, arglist);
-        /* Free argument list. */
-        free(arglist);
         return rc;
+}

uspace/lib/c/generic/thread.c

-              rb5d2e57
+              r03362fbd
 #include <abi/proc/uarg.h>
 #include <fibril.h>
+#include <stack.h>
 #include <str.h>
 #include <async.h>
 …
 #include <as.h>
 #include "private/thread.h"
-#ifndef THREAD_INITIAL_STACK_PAGES
-        #define THREAD_INITIAL_STACK_PAGES  2
-#endif
 /** Main thread function.
 …
                 return ENOMEM;
         size_t stack_size = getpagesize() * THREAD_INITIAL_STACK_PAGES;
+        size_t stack_size = stack_size_get();
         void *stack = as_area_create(AS_AREA_ANY, stack_size,
+            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE);
+            AS_AREA_READ | AS_AREA_WRITE | AS_AREA_CACHEABLE | AS_AREA_GUARD |
+            AS_AREA_LATE_RESERVE);
         if (stack == AS_MAP_FAILED) {
                 free(uarg);

uspace/lib/c/generic/time.c

-              rb5d2e57
+              r03362fbd
 /*
  * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2011 Petr Koupy
+ * Copyright (c) 2011 Jiri Zarevucky
  * All rights reserved.
+ *
 …
 #include <sys/time.h>
 #include <time.h>
 #include <bool.h>
+#include <stdbool.h>
 #include <libarch/barrier.h>
 #include <macros.h>
 …
 #include <ddi.h>
 #include <libc.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <ctype.h>
+#include <assert.h>
 #include <unistd.h>
+#include <loc.h>
+#include <device/clock_dev.h>
+#include <malloc.h>
+#define ASCTIME_BUF_LEN 26
 /** Pointer to kernel shared variables with time */
 …
 } *ktime = NULL;
+/* Helper functions ***********************************************************/
+#define HOURS_PER_DAY (24)
+#define MINS_PER_HOUR (60)
+#define SECS_PER_MIN (60)
+#define MINS_PER_DAY (MINS_PER_HOUR * HOURS_PER_DAY)
+#define SECS_PER_HOUR (SECS_PER_MIN * MINS_PER_HOUR)
+#define SECS_PER_DAY (SECS_PER_HOUR * HOURS_PER_DAY)
+/**
+ * Checks whether the year is a leap year.
+ *
+ * @param year Year since 1900 (e.g. for 1970, the value is 70).
+ * @return true if year is a leap year, false otherwise
+ */
+static bool _is_leap_year(time_t year)
+{
+        year += 1900;
+        if (year % 400 == 0)
+                return true;
+        if (year % 100 == 0)
+                return false;
+        if (year % 4 == 0)
+                return true;
+        return false;
+}
+/**
+ * Returns how many days there are in the given month of the given year.
+ * Note that year is only taken into account if month is February.
+ *
+ * @param year Year since 1900 (can be negative).
+ * @param mon Month of the year. 0 for January, 11 for December.
+ * @return Number of days in the specified month.
+ */
+static int _days_in_month(time_t year, time_t mon)
+{
+        assert(mon >= 0 && mon <= 11);
+        static int month_days[] =
+                { 31, 0, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
+        if (mon == 1) {
+                year += 1900;
+                /* february */
+                return _is_leap_year(year) ? 29 : 28;
+        } else {
+                return month_days[mon];
+        }
+}
+/**
+ * For specified year, month and day of month, returns which day of that year
+ * it is.
+ *
+ * For example, given date 2011-01-03, the corresponding expression is:
+ *     _day_of_year(111, 0, 3) == 2
+ *
+ * @param year Year (year 1900 = 0, can be negative).
+ * @param mon Month (January = 0).
+ * @param mday Day of month (First day is 1).
+ * @return Day of year (First day is 0).
+ */
+static int _day_of_year(time_t year, time_t mon, time_t mday)
+{
+        static int mdays[] =
+            { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334 };
+        static int leap_mdays[] =
+            { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335 };
+        return (_is_leap_year(year) ? leap_mdays[mon] : mdays[mon]) + mday - 1;
+}
+/**
+ * Integer division that rounds to negative infinity.
+ * Used by some functions in this file.
+ *
+ * @param op1 Dividend.
+ * @param op2 Divisor.
+ * @return Rounded quotient.
+ */
+static time_t _floor_div(time_t op1, time_t op2)
+{
+        if (op1 >= 0 || op1 % op2 == 0) {
+                return op1 / op2;
+        } else {
+                return op1 / op2 - 1;
+        }
+}
+/**
+ * Modulo that rounds to negative infinity.
+ * Used by some functions in this file.
+ *
+ * @param op1 Dividend.
+ * @param op2 Divisor.
+ * @return Remainder.
+ */
+static time_t _floor_mod(time_t op1, time_t op2)
+{
+        int div = _floor_div(op1, op2);
+        /* (a / b) * b + a % b == a */
+        /* thus, a % b == a - (a / b) * b */
+        int result = op1 - div * op2;
+        /* Some paranoid checking to ensure I didn't make a mistake here. */
+        assert(result >= 0);
+        assert(result < op2);
+        assert(div * op2 + result == op1);
+        return result;
+}
+/**
+ * Number of days since the Epoch.
+ * Epoch is 1970-01-01, which is also equal to day 0.
+ *
+ * @param year Year (year 1900 = 0, may be negative).
+ * @param mon Month (January = 0).
+ * @param mday Day of month (first day = 1).
+ * @return Number of days since the Epoch.
+ */
+static time_t _days_since_epoch(time_t year, time_t mon, time_t mday)
+{
+        return (year - 70) * 365 + _floor_div(year - 69, 4) -
+            _floor_div(year - 1, 100) + _floor_div(year + 299, 400) +
+            _day_of_year(year, mon, mday);
+}
+/**
+ * Seconds since the Epoch. see also _days_since_epoch().
+ *
+ * @param tm Normalized broken-down time.
+ * @return Number of seconds since the epoch, not counting leap seconds.
+ */
+static time_t _secs_since_epoch(const struct tm *tm)
+{
+        return _days_since_epoch(tm->tm_year, tm->tm_mon, tm->tm_mday) *
+            SECS_PER_DAY + tm->tm_hour * SECS_PER_HOUR +
+            tm->tm_min * SECS_PER_MIN + tm->tm_sec;
+}
+/**
+ * Which day of week the specified date is.
+ *
+ * @param year Year (year 1900 = 0).
+ * @param mon Month (January = 0).
+ * @param mday Day of month (first = 1).
+ * @return Day of week (Sunday = 0).
+ */
+static int _day_of_week(time_t year, time_t mon, time_t mday)
+{
+        /* 1970-01-01 is Thursday */
+        return _floor_mod((_days_since_epoch(year, mon, mday) + 4), 7);
+}
+/**
+ * Normalizes the broken-down time and optionally adds specified amount of
+ * seconds.
+ *
+ * @param tm Broken-down time to normalize.
+ * @param sec_add Seconds to add.
+ * @return 0 on success, -1 on overflow
+ */
+static int _normalize_time(struct tm *tm, time_t sec_add)
+{
+        // TODO: DST correction
+        /* Set initial values. */
+        time_t sec = tm->tm_sec + sec_add;
+        time_t min = tm->tm_min;
+        time_t hour = tm->tm_hour;
+        time_t day = tm->tm_mday - 1;
+        time_t mon = tm->tm_mon;
+        time_t year = tm->tm_year;
+        /* Adjust time. */
+        min += _floor_div(sec, SECS_PER_MIN);
+        sec = _floor_mod(sec, SECS_PER_MIN);
+        hour += _floor_div(min, MINS_PER_HOUR);
+        min = _floor_mod(min, MINS_PER_HOUR);
+        day += _floor_div(hour, HOURS_PER_DAY);
+        hour = _floor_mod(hour, HOURS_PER_DAY);
+        /* Adjust month. */
+        year += _floor_div(mon, 12);
+        mon = _floor_mod(mon, 12);
+        /* Now the difficult part - days of month. */
+        /* First, deal with whole cycles of 400 years = 146097 days. */
+        year += _floor_div(day, 146097) * 400;
+        day = _floor_mod(day, 146097);
+        /* Then, go in one year steps. */
+        if (mon <= 1) {
+                /* January and February. */
+                while (day > 365) {
+                        day -= _is_leap_year(year) ? 366 : 365;
+                        year++;
+                }
+        } else {
+                /* Rest of the year. */
+                while (day > 365) {
+                        day -= _is_leap_year(year + 1) ? 366 : 365;
+                        year++;
+                }
+        }
+        /* Finally, finish it off month per month. */
+        while (day >= _days_in_month(year, mon)) {
+                day -= _days_in_month(year, mon);
+                mon++;
+                if (mon >= 12) {
+                        mon -= 12;
+                        year++;
+                }
+        }
+        /* Calculate the remaining two fields. */
+        tm->tm_yday = _day_of_year(year, mon, day + 1);
+        tm->tm_wday = _day_of_week(year, mon, day + 1);
+        /* And put the values back to the struct. */
+        tm->tm_sec = (int) sec;
+        tm->tm_min = (int) min;
+        tm->tm_hour = (int) hour;
+        tm->tm_mday = (int) day + 1;
+        tm->tm_mon = (int) mon;
+        /* Casts to work around libc brain-damage. */
+        if (year > ((int)INT_MAX) || year < ((int)INT_MIN)) {
+                tm->tm_year = (year < 0) ? ((int)INT_MIN) : ((int)INT_MAX);
+                return -1;
+        }
+        tm->tm_year = (int) year;
+        return 0;
+}
+/**
+ * Which day the week-based year starts on, relative to the first calendar day.
+ * E.g. if the year starts on December 31st, the return value is -1.
+ *
+ * @param Year since 1900.
+ * @return Offset of week-based year relative to calendar year.
+ */
+static int _wbyear_offset(int year)
+{
+        int start_wday = _day_of_week(year, 0, 1);
+        return _floor_mod(4 - start_wday, 7) - 3;
+}
+/**
+ * Returns week-based year of the specified time.
+ *
+ * @param tm Normalized broken-down time.
+ * @return Week-based year.
+ */
+static int _wbyear(const struct tm *tm)
+{
+        int day = tm->tm_yday - _wbyear_offset(tm->tm_year);
+        if (day < 0) {
+                /* Last week of previous year. */
+                return tm->tm_year - 1;
+        }
+        if (day > 364 + _is_leap_year(tm->tm_year)) {
+                /* First week of next year. */
+                return tm->tm_year + 1;
+        }
+        /* All the other days are in the calendar year. */
+        return tm->tm_year;
+}
+/**
+ * Week number of the year, assuming weeks start on sunday.
+ * The first Sunday of January is the first day of week 1;
+ * days in the new year before this are in week 0.
+ *
+ * @param tm Normalized broken-down time.
+ * @return The week number (0 - 53).
+ */
+static int _sun_week_number(const struct tm *tm)
+{
+        int first_day = (7 - _day_of_week(tm->tm_year, 0, 1)) % 7;
+        return (tm->tm_yday - first_day + 7) / 7;
+}
+/**
+ * Week number of the year, assuming weeks start on monday.
+ * If the week containing January 1st has four or more days in the new year,
+ * then it is considered week 1. Otherwise, it is the last week of the previous
+ * year, and the next week is week 1. Both January 4th and the first Thursday
+ * of January are always in week 1.
+ *
+ * @param tm Normalized broken-down time.
+ * @return The week number (1 - 53).
+ */
+static int _iso_week_number(const struct tm *tm)
+{
+        int day = tm->tm_yday - _wbyear_offset(tm->tm_year);
+        if (day < 0) {
+                /* Last week of previous year. */
+                return 53;
+        }
+        if (day > 364 + _is_leap_year(tm->tm_year)) {
+                /* First week of next year. */
+                return 1;
+        }
+        /* All the other days give correct answer. */
+        return (day / 7 + 1);
+}
+/**
+ * Week number of the year, assuming weeks start on monday.
+ * The first Monday of January is the first day of week 1;
+ * days in the new year before this are in week 0.
+ *
+ * @param tm Normalized broken-down time.
+ * @return The week number (0 - 53).
+ */
+static int _mon_week_number(const struct tm *tm)
+{
+        int first_day = (1 - _day_of_week(tm->tm_year, 0, 1)) % 7;
+        return (tm->tm_yday - first_day + 7) / 7;
+}
+/******************************************************************************/
 /** Add microseconds to given timeval.
+ *
 …
  */
 int gettimeofday(struct timeval *tv, struct timezone *tz)
+{
+        int rc;
+        struct tm t;
+        category_id_t cat_id;
+        size_t svc_cnt;
+        service_id_t *svc_ids = NULL;
+        service_id_t svc_id;
+        char *svc_name = NULL;
+        static async_sess_t *clock_conn = NULL;
+        if (tz) {
+                tz->tz_minuteswest = 0;
+                tz->tz_dsttime = DST_NONE;
+        }
+        if (clock_conn == NULL) {
+                rc = loc_category_get_id("clock", &cat_id, IPC_FLAG_BLOCKING);
+                if (rc != EOK)
+                        goto ret_uptime;
+                rc = loc_category_get_svcs(cat_id, &svc_ids, &svc_cnt);
+                if (rc != EOK)
+                        goto ret_uptime;
+                if (svc_cnt == 0)
+                        goto ret_uptime;
+                rc = loc_service_get_name(svc_ids[0], &svc_name);
+                if (rc != EOK)
+                        goto ret_uptime;
+                rc = loc_service_get_id(svc_name, &svc_id, 0);
+                if (rc != EOK)
+                        goto ret_uptime;
+                clock_conn = loc_service_connect(EXCHANGE_SERIALIZE,
+                    svc_id, IPC_FLAG_BLOCKING);
+                if (!clock_conn)
+                        goto ret_uptime;
+        }
+        rc = clock_dev_time_get(clock_conn, &t);
+        if (rc != EOK)
+                goto ret_uptime;
+        tv->tv_usec = 0;
+        tv->tv_sec = mktime(&t);
+        free(svc_name);
+        free(svc_ids);
+        return EOK;
+ret_uptime:
+        free(svc_name);
+        free(svc_ids);
+        return getuptime(tv);
+}
+int getuptime(struct timeval *tv)
+{
         if (ktime == NULL) {
 …
+        }
-        if (tz) {
-                tz->tz_minuteswest = 0;
-                tz->tz_dsttime = DST_NONE;
+        }
         sysarg_t s2 = ktime->seconds2;
 …
         } else
                 tv->tv_sec = s1;
         return 0;
+}
 …
+}
+/**
+ * This function first normalizes the provided broken-down time
+ * (moves all values to their proper bounds) and then tries to
+ * calculate the appropriate time_t representation.
+ *
+ * @param tm Broken-down time.
+ * @return time_t representation of the time, undefined value on overflow.
+ */
+time_t mktime(struct tm *tm)
+{
+        // TODO: take DST flag into account
+        // TODO: detect overflow
+        _normalize_time(tm, 0);
+        return _secs_since_epoch(tm);
+}
+/**
+ * Convert time and date to a string, based on a specified format and
+ * current locale.
+ *
+ * @param s Buffer to write string to.
+ * @param maxsize Size of the buffer.
+ * @param format Format of the output.
+ * @param tm Broken-down time to format.
+ * @return Number of bytes written.
+ */
+size_t strftime(char *restrict s, size_t maxsize,
+    const char *restrict format, const struct tm *restrict tm)
+{
+        assert(s != NULL);
+        assert(format != NULL);
+        assert(tm != NULL);
+        // TODO: use locale
+        static const char *wday_abbr[] = {
+                "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+        };
+        static const char *wday[] = {
+                "Sunday", "Monday", "Tuesday", "Wednesday",
+                "Thursday", "Friday", "Saturday"
+        };
+        static const char *mon_abbr[] = {
+                "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+        };
+        static const char *mon[] = {
+                "January", "February", "March", "April", "May", "June", "July",
+                "August", "September", "October", "November", "December"
+        };
+        if (maxsize < 1) {
+                return 0;
+        }
+        char *ptr = s;
+        size_t consumed;
+        size_t remaining = maxsize;
+        #define append(...) { \
+                /* FIXME: this requires POSIX-correct snprintf */ \
+                /*        otherwise it won't work with non-ascii chars */ \
+                consumed = snprintf(ptr, remaining, __VA_ARGS__); \
+                if (consumed >= remaining) { \
+                        return 0; \
+                } \
+                ptr += consumed; \
+                remaining -= consumed; \
+        }
+        #define recurse(fmt) { \
+                consumed = strftime(ptr, remaining, fmt, tm); \
+                if (consumed == 0) { \
+                        return 0; \
+                } \
+                ptr += consumed; \
+                remaining -= consumed; \
+        }
+        #define TO_12H(hour) (((hour) > 12) ? ((hour) - 12) : \
+            (((hour) == 0) ? 12 : (hour)))
+        while (*format != '\0') {
+                if (*format != '%') {
+                        append("%c", *format);
+                        format++;
+                        continue;
+                }
+                format++;
+                if (*format == '0' || *format == '+') {
+                        // TODO: padding
+                        format++;
+                }
+                while (isdigit(*format)) {
+                        // TODO: padding
+                        format++;
+                }
+                if (*format == 'O' || *format == 'E') {
+                        // TODO: locale's alternative format
+                        format++;
+                }
+                switch (*format) {
+                case 'a':
+                        append("%s", wday_abbr[tm->tm_wday]); break;
+                case 'A':
+                        append("%s", wday[tm->tm_wday]); break;
+                case 'b':
+                        append("%s", mon_abbr[tm->tm_mon]); break;
+                case 'B':
+                        append("%s", mon[tm->tm_mon]); break;
+                case 'c':
+                        // TODO: locale-specific datetime format
+                        recurse("%Y-%m-%d %H:%M:%S"); break;
+                case 'C':
+                        append("%02d", (1900 + tm->tm_year) / 100); break;
+                case 'd':
+                        append("%02d", tm->tm_mday); break;
+                case 'D':
+                        recurse("%m/%d/%y"); break;
+                case 'e':
+                        append("%2d", tm->tm_mday); break;
+                case 'F':
+                        recurse("%+4Y-%m-%d"); break;
+                case 'g':
+                        append("%02d", _wbyear(tm) % 100); break;
+                case 'G':
+                        append("%d", _wbyear(tm)); break;
+                case 'h':
+                        recurse("%b"); break;
+                case 'H':
+                        append("%02d", tm->tm_hour); break;
+                case 'I':
+                        append("%02d", TO_12H(tm->tm_hour)); break;
+                case 'j':
+                        append("%03d", tm->tm_yday); break;
+                case 'k':
+                        append("%2d", tm->tm_hour); break;
+                case 'l':
+                        append("%2d", TO_12H(tm->tm_hour)); break;
+                case 'm':
+                        append("%02d", tm->tm_mon); break;
+                case 'M':
+                        append("%02d", tm->tm_min); break;
+                case 'n':
+                        append("\n"); break;
+                case 'p':
+                        append("%s", tm->tm_hour < 12 ? "AM" : "PM"); break;
+                case 'P':
+                        append("%s", tm->tm_hour < 12 ? "am" : "PM"); break;
+                case 'r':
+                        recurse("%I:%M:%S %p"); break;
+                case 'R':
+                        recurse("%H:%M"); break;
+                case 's':
+                        append("%ld", _secs_since_epoch(tm)); break;
+                case 'S':
+                        append("%02d", tm->tm_sec); break;
+                case 't':
+                        append("\t"); break;
+                case 'T':
+                        recurse("%H:%M:%S"); break;
+                case 'u':
+                        append("%d", (tm->tm_wday == 0) ? 7 : tm->tm_wday);
+                        break;
+                case 'U':
+                        append("%02d", _sun_week_number(tm)); break;
+                case 'V':
+                        append("%02d", _iso_week_number(tm)); break;
+                case 'w':
+                        append("%d", tm->tm_wday); break;
+                case 'W':
+                        append("%02d", _mon_week_number(tm)); break;
+                case 'x':
+                        // TODO: locale-specific date format
+                        recurse("%Y-%m-%d"); break;
+                case 'X':
+                        // TODO: locale-specific time format
+                        recurse("%H:%M:%S"); break;
+                case 'y':
+                        append("%02d", tm->tm_year % 100); break;
+                case 'Y':
+                        append("%d", 1900 + tm->tm_year); break;
+                case 'z':
+                        // TODO: timezone
+                        break;
+                case 'Z':
+                        // TODO: timezone
+                        break;
+                case '%':
+                        append("%%");
+                        break;
+                default:
+                        /* Invalid specifier, print verbatim. */
+                        while (*format != '%') {
+                                format--;
+                        }
+                        append("%%");
+                        break;
+                }
+                format++;
+        }
+        #undef append
+        #undef recurse
+        return maxsize - remaining;
+}
+/** Converts a time value to a broken-down UTC time
+ *
+ * @param time    Time to convert
+ * @param result  Structure to store the result to
+ *
+ * @return        EOK or a negative error code
+ */
+int time_utc2tm(const time_t time, struct tm *restrict result)
+{
+        assert(result != NULL);
+        /* Set result to epoch. */
+        result->tm_sec = 0;
+        result->tm_min = 0;
+        result->tm_hour = 0;
+        result->tm_mday = 1;
+        result->tm_mon = 0;
+        result->tm_year = 70; /* 1970 */
+        if (_normalize_time(result, time) == -1)
+                return EOVERFLOW;
+        return EOK;
+}
+/** Converts a time value to a null terminated string of the form
+ *  "Wed Jun 30 21:49:08 1993\n" expressed in UTC.
+ *
+ * @param time   Time to convert.
+ * @param buf    Buffer to store the string to, must be at least
+ *               ASCTIME_BUF_LEN bytes long.
+ *
+ * @return       EOK or a negative error code.
+ */
+int time_utc2str(const time_t time, char *restrict buf)
+{
+        struct tm t;
+        int r;
+        if ((r = time_utc2tm(time, &t)) != EOK)
+                return r;
+        time_tm2str(&t, buf);
+        return EOK;
+}
+/**
+ * Converts broken-down time to a string in format
+ * "Sun Jan 1 00:00:00 1970\n". (Obsolete)
+ *
+ * @param timeptr Broken-down time structure.
+ * @param buf     Buffer to store string to, must be at least ASCTIME_BUF_LEN
+ *                bytes long.
+ */
+void time_tm2str(const struct tm *restrict timeptr, char *restrict buf)
+{
+        assert(timeptr != NULL);
+        assert(buf != NULL);
+        static const char *wday[] = {
+                "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
+        };
+        static const char *mon[] = {
+                "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
+        };
+        snprintf(buf, ASCTIME_BUF_LEN, "%s %s %2d %02d:%02d:%02d %d\n",
+            wday[timeptr->tm_wday],
+            mon[timeptr->tm_mon],
+            timeptr->tm_mday, timeptr->tm_hour,
+            timeptr->tm_min, timeptr->tm_sec,
++ timeptr->tm_year);
+}
+/**
+ * Converts a time value to a broken-down local time, expressed relative
+ * to the user's specified timezone.
+ *
+ * @param timer     Time to convert.
+ * @param result    Structure to store the result to.
+ *
+ * @return          EOK on success or a negative error code.
+ */
+int time_local2tm(const time_t time, struct tm *restrict result)
+{
+        // TODO: deal with timezone
+        // currently assumes system and all times are in GMT
+        /* Set result to epoch. */
+        result->tm_sec = 0;
+        result->tm_min = 0;
+        result->tm_hour = 0;
+        result->tm_mday = 1;
+        result->tm_mon = 0;
+        result->tm_year = 70; /* 1970 */
+        if (_normalize_time(result, time) == -1)
+                return EOVERFLOW;
+        return EOK;
+}
+/**
+ * Converts the calendar time to a null terminated string
+ * of the form "Wed Jun 30 21:49:08 1993\n" expressed relative to the
+ * user's specified timezone.
+ *
+ * @param timer  Time to convert.
+ * @param buf    Buffer to store the string to. Must be at least
+ *               ASCTIME_BUF_LEN bytes long.
+ *
+ * @return       EOK on success or a negative error code.
+ */
+int time_local2str(const time_t time, char *buf)
+{
+        struct tm loctime;
+        int r;
+        if ((r = time_local2tm(time, &loctime)) != EOK)
+                return r;
+        time_tm2str(&loctime, buf);
+        return EOK;
+}
+/**
+ * Calculate the difference between two times, in seconds.
+ *
+ * @param time1 First time.
+ * @param time0 Second time.
+ * @return Time in seconds.
+ */
+double difftime(time_t time1, time_t time0)
+{
+        return (double) (time1 - time0);
+}
 /** @}
  */

uspace/lib/c/generic/tls.c

-              rb5d2e57
+              r03362fbd
 #include <str.h>
 #include <align.h>
+#include <unistd.h>
 /** Create TLS (Thread Local Storage) data structures.
 …
         tcb = __alloc_tls(&data, tls_size);
+        if (!tcb)
+                return NULL;
         /*
 …
         result = malloc(sizeof(tcb_t) + size);
+        if (!result)
+                return NULL;
         *data = ((void *)result) + sizeof(tcb_t);
         return result;
+}
 …
         size = ALIGN_UP(size, &_tls_alignment);
         *data = memalign((uintptr_t) &_tls_alignment, sizeof(tcb_t) + size);
+        if (!*data)
+                return NULL;
         tcb = (tcb_t *) (*data + size);
         tcb->self = tcb;

Context Navigation

Changeset 03362fbd in mainline for uspace/lib/c/generic

Legend:

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

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

uspace/lib/c/generic/async.c

uspace/lib/c/generic/ddi.c

uspace/lib/c/generic/device/clock_dev.c

uspace/lib/c/generic/devman.c

uspace/lib/c/generic/dlfcn.c

uspace/lib/c/generic/fibril.c

uspace/lib/c/generic/fibril_synch.c

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

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

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

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

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

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

uspace/lib/c/generic/ipc.c

uspace/lib/c/generic/iplink_srv.c

uspace/lib/c/generic/loc.c

uspace/lib/c/generic/malloc.c

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

uspace/lib/c/generic/stdlib.c

uspace/lib/c/generic/str.c

uspace/lib/c/generic/sysinfo.c

uspace/lib/c/generic/task.c

uspace/lib/c/generic/thread.c

uspace/lib/c/generic/time.c

uspace/lib/c/generic/tls.c

Download in other formats: