Changeset b800b0e for uspace/lib – HelenOS

uspace/lib/block/block.c

-              r32b3a12
+              rb800b0e
 static LIST_INITIALIZE(dcl);
-#define CACHE_BUCKETS_LOG2  10
-#define CACHE_BUCKETS       (1 << CACHE_BUCKETS_LOG2)
 typedef struct {
 …
+}
+static hash_index_t cache_hash(unsigned long *key)
+{
+        return MERGE_LOUP32(key[0], key[1]) & (CACHE_BUCKETS - 1);
+}
+static int cache_compare(unsigned long *key, hash_count_t keys, link_t *item)
+{
+        block_t *b = hash_table_get_instance(item, block_t, hash_link);
+        return b->lba == MERGE_LOUP32(key[0], key[1]);
+}
+static void cache_remove_callback(link_t *item)
+{
+}
+static hash_table_operations_t cache_ops = {
+static size_t cache_key_hash(void *key)
+{
+        aoff64_t *lba = (aoff64_t*)key;
+        return *lba;
+}
+static size_t cache_hash(const ht_link_t *item)
+{
+        block_t *b = hash_table_get_inst(item, block_t, hash_link);
+        return b->lba;
+}
+static bool cache_key_equal(void *key, const ht_link_t *item)
+{
+        aoff64_t *lba = (aoff64_t*)key;
+        block_t *b = hash_table_get_inst(item, block_t, hash_link);
+        return b->lba == *lba;
+}
+static hash_table_ops_t cache_ops = {
         .hash = cache_hash,
+        .compare = cache_compare,
+        .remove_callback = cache_remove_callback
+        .key_hash = cache_key_hash,
+        .key_equal = cache_key_equal,
+        .equal = NULL,
+        .remove_callback = NULL
 };
 …
         cache->blocks_cluster = cache->lblock_size / devcon->pblock_size;
+        if (!hash_table_create(&cache->block_hash, CACHE_BUCKETS, 2,
+            &cache_ops)) {
+        if (!hash_table_create(&cache->block_hash, 0, 0, &cache_ops)) {
                 free(cache);
                 return ENOMEM;
 …
+                }
+                unsigned long key[2] = {
+                        LOWER32(b->lba),
+                        UPPER32(b->lba)
+                };
+                hash_table_remove(&cache->block_hash, key, 2);
+                hash_table_remove_item(&cache->block_hash, &b->hash_link);
                 free(b->data);
 …
         fibril_rwlock_initialize(&b->contents_lock);
         link_initialize(&b->free_link);
-        link_initialize(&b->hash_link);
+}
 …
         cache_t *cache;
         block_t *b;
+        link_t *l;
+        unsigned long key[2] = {
+                LOWER32(ba),
+                UPPER32(ba)
+        };
+        link_t *link;
         int rc;
 …
         fibril_mutex_lock(&cache->lock);
         l = hash_table_find(&cache->block_hash, key);
         if (l) {
+        ht_link_t *hlink = hash_table_find(&cache->block_hash, &ba);
+        if (hlink) {
 found:
                 /*
                  * We found the block in the cache.
                  */
                 b = hash_table_get_instance(l, block_t, hash_link);
+                b = hash_table_get_inst(hlink, block_t, hash_link);
                 fibril_mutex_lock(&b->lock);
                 if (b->refcnt++ == 0)
 …
                                 goto out;
+                        }
                         l = list_first(&cache->free_list);
                         b = list_get_instance(l, block_t, free_link);
+                        link = list_first(&cache->free_list);
+                        b = list_get_instance(link, block_t, free_link);
                         fibril_mutex_lock(&b->lock);
 …
                                         goto retry;
+                                }
                                 l = hash_table_find(&cache->block_hash, key);
                                 if (l) {
+                                hlink = hash_table_find(&cache->block_hash, &ba);
+                                if (hlink) {
                                         /*
                                          * Someone else must have already
 …
                          */
                         list_remove(&b->free_link);
+                        unsigned long temp_key[2] = {
+                                LOWER32(b->lba),
+                                UPPER32(b->lba)
+                        };
+                        hash_table_remove(&cache->block_hash, temp_key, 2);
+                        hash_table_remove_item(&cache->block_hash, &b->hash_link);
+                }
 …
                 b->lba = ba;
                 b->pba = ba_ltop(devcon, b->lba);
                 hash_table_insert(&cache->block_hash, key, &b->hash_link);
+                hash_table_insert(&cache->block_hash, &b->hash_link);
                 /*
 …
                          * Take the block out of the cache and free it.
                          */
+                        unsigned long key[2] = {
+                                LOWER32(block->lba),
+                                UPPER32(block->lba)
+                        };
+                        hash_table_remove(&cache->block_hash, key, 2);
+                        hash_table_remove_item(&cache->block_hash, &block->hash_link);
                         fibril_mutex_unlock(&block->lock);
                         free(block->data);

uspace/lib/block/block.h

r32b3a12	rb800b0e
84	84	link_t free_link;
85	85	/** Link for placing the block into the block hash table. */
86		link_t hash_link;
	86	ht_link_t hash_link;
87	87	/** Buffer with the block data. */
88	88	void *data;

uspace/lib/c/Makefile

-              r32b3a12
+              rb800b0e
         generic/device/hw_res_parsed.c \
         generic/device/char_dev.c \
+        generic/device/clock_dev.c \
+        generic/device/battery_dev.c \
         generic/device/graph_dev.c \
         generic/device/nic.c \
         generic/device/pci.c \
         generic/device/ahci.c \
+        generic/dlfcn.c \
         generic/elf/elf_load.c \
         generic/event.c \
 …
         generic/io/printf.c \
         generic/io/log.c \
+        generic/io/logctl.c \
         generic/io/klog.c \
         generic/io/snprintf.c \
 …
         generic/adt/list.c \
         generic/adt/hash_table.c \
-        generic/adt/hash_set.c \
         generic/adt/dynamic_fifo.c \
         generic/adt/char_map.c \
 …
 ifeq ($(CONFIG_RTLD),y)
         GENERIC_SOURCES += \
-                generic/dlfcn.c \
                 generic/rtld/rtld.c \
                 generic/rtld/dynamic.c \

uspace/lib/c/arch/abs32le/_link.ld.in

-              r32b3a12
+              rb800b0e
 #ifdef LOADER
         . = 0x70001000 + SIZEOF_HEADERS;
-        .interp : {
-                *(.interp);
-        } :interp :text
 #else
         . = 0x1000 + SIZEOF_HEADERS;
 #endif
-        /* Make sure the code is aligned reasonably */
-        . = ALIGN(., 16);
         .text : {
 …
                 *(.rodata .rodata.*);
         } :text
+#ifdef LOADER
+        .interp : {
+                *(.interp);
+        } :interp :text
+#endif
         . = . + 0x1000;

uspace/lib/c/arch/amd64/_link.ld.in

-              r32b3a12
+              rb800b0e
 #ifdef LOADER
         . = 0x70001000 + SIZEOF_HEADERS;
-        .interp : {
-                *(.interp);
-        } :interp :text
 #else
         . = 0x1000 + SIZEOF_HEADERS;
 #endif
-        /* Make sure the code is aligned reasonably */
-        . = ALIGN(., 16);
         .init : {
 …
                 *(.rodata .rodata.*);
         } :text
+#ifdef LOADER
+        .interp : {
+                *(.interp);
+        } :interp :text
+#endif
         . = . + 0x1000;

uspace/lib/c/arch/arm32/Makefile.common

-              r32b3a12
+              rb800b0e
+#
+GCC_CFLAGS += -ffixed-r9 -mtp=soft -fno-omit-frame-pointer -march=armv4
+BASE_LIBS += $(LIBSOFTFLOAT_PREFIX)/libsoftfloat.a
+GCC_CFLAGS += -ffixed-r9 -mtp=soft -fno-omit-frame-pointer -march=armv4 -mapcs-frame
 ENDIANESS = LE

uspace/lib/c/arch/arm32/_link.ld.in

-              r32b3a12
+              rb800b0e
 #ifdef LOADER
         . = 0x70001000 + SIZEOF_HEADERS;
-        .interp : {
-                *(.interp);
-        } :interp :text
 #else
         . = 0x1000 + SIZEOF_HEADERS;
 #endif
-        /* Make sure the code is aligned reasonably */
-        . = ALIGN(., 8);
         .init : {
 …
                 *(.rodata .rodata.*);
         } :text
+#ifdef LOADER
+        .interp : {
+                *(.interp);
+        } :interp :text
+#endif
         . = . + 0x1000;

uspace/lib/c/arch/ia32/_link.ld.in

-              r32b3a12
+              rb800b0e
         . = 0x1000 + SIZEOF_HEADERS;
 #endif
-#if defined(LOADER) || defined(DLEXE)
-        .interp : {
-                *(.interp);
-        } :interp :text
-#endif
-        /* Make sure the code is aligned reasonably */
-        . = ALIGN(., 16);
         .init : {
 …
         } :text
 #endif
+#if defined(LOADER) || defined(DLEXE)
+        .interp : {
+                *(.interp);
+        } :interp :text
+#endif
         . = . + 0x1000;

uspace/lib/c/arch/ia64/_link.ld.in

-              r32b3a12
+              rb800b0e
 #ifdef LOADER
         . = 0x800000000 + SIZEOF_HEADERS;
-        .interp : {
-                *(.interp);
-        } :interp :text
 #else
         . = 0x4000 + SIZEOF_HEADERS;
 #endif
         /* Make sure the code is aligned reasonably */
+        /* Workaround proper alignment of the .init section */
         . = ALIGN(., 16);
 …
                 *(.rodata .rodata.*);
         } :text
+#ifdef LOADER
+        .interp : {
+                *(.interp);
+        } :interp :text
+#endif
         . = . + 0x4000;

uspace/lib/c/arch/mips32/Makefile.common

r32b3a12	rb800b0e
28	28
29	29	GCC_CFLAGS += -msoft-float -mips3 -mabi=32
	30	BASE_LIBS += $(LIBSOFTFLOAT_PREFIX)/libsoftfloat.a
30	31
31	32	ENDIANESS = LE

uspace/lib/c/arch/mips32/_link.ld.in

-              r32b3a12
+              rb800b0e
 #ifdef LOADER
         . = 0x70004000 + SIZEOF_HEADERS;
-        .interp : {
-                *(.interp);
-        } :interp :text
 #else
         . = 0x4000 + SIZEOF_HEADERS;
 #endif
-        /* Make sure the code is aligned reasonably */
-        . = ALIGN(., 16);
         .init : {
 …
                 *(.rodata .rodata.*);
         } :text
+#ifdef LOADER
+        .interp : {
+                *(.interp);
+        } :interp :text
+#endif
         . = . + 0x4000;

uspace/lib/c/arch/mips32eb/Makefile.common

r32b3a12	rb800b0e
28	28
29	29	GCC_CFLAGS += -msoft-float -mips3 -mabi=32
	30	BASE_LIBS += $(LIBSOFTFLOAT_PREFIX)/libsoftfloat.a
30	31
31	32	ENDIANESS = BE

uspace/lib/c/arch/mips64/Makefile.common

r32b3a12	rb800b0e
28	28
29	29	GCC_CFLAGS += -msoft-float -mips3 -mabi=64
	30	BASE_LIBS += $(LIBSOFTFLOAT_PREFIX)/libsoftfloat.a
30	31	AFLAGS = -64
31	32

uspace/lib/c/arch/mips64/_link.ld.in

-              r32b3a12
+              rb800b0e
 #ifdef LOADER
         . = 0x70004000 + SIZEOF_HEADERS;
-        .interp : {
-                *(.interp);
-        } :interp :text
 #else
         . = 0x4000 + SIZEOF_HEADERS;
 #endif
-        /* Make sure the code is aligned reasonably */
-        . = ALIGN(., 16);
         .init : {
 …
                 *(.rodata .rodata.*);
         } :text
+#ifdef LOADER
+        .interp : {
+                *(.interp);
+        } :interp :text
+#endif
         . = . + 0x4000;

uspace/lib/c/arch/ppc32/Makefile.common

r32b3a12	rb800b0e
28	28
29	29	GCC_CFLAGS += -mcpu=powerpc -msoft-float -m32
	30	BASE_LIBS += $(LIBSOFTFLOAT_PREFIX)/libsoftfloat.a
30	31	AFLAGS = -a32
31	32

uspace/lib/c/arch/ppc32/_link.ld.in

-              r32b3a12
+              rb800b0e
 #ifdef LOADER
         . = 0x70001000 + SIZEOF_HEADERS;
-        .interp : {
-                *(.interp);
-        } :interp :text
 #else
         . = 0x1000 + SIZEOF_HEADERS;
 #endif
-        /* Make sure the code is aligned reasonably */
-        . = ALIGN(., 4);
         .init : {
 …
                 *(.rodata .rodata.*);
         } :text
+#ifdef LOADER
+        .interp : {
+                *(.interp);
+        } :interp :text
+#endif
         . = . + 0x1000;

uspace/lib/c/arch/sparc64/_link.ld.in

-              r32b3a12
+              rb800b0e
 #ifdef LOADER
         . = 0x70004000 + SIZEOF_HEADERS;
-        .interp : {
-                *(.interp);
-        } :interp :text
 #else
         . = 0x4000 + SIZEOF_HEADERS;
 #endif
-        /* Make sure the code is aligned reasonably */
-        . = ALIGN(., 16);
         .init : {
 …
                 *(.rodata .rodata.*);
         } :text
+#ifdef LOADER
+        .interp : {
+                *(.interp);
+        } :interp :text
+#endif
         . = . + 0x4000;

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

-              r32b3a12
+              rb800b0e
 /*
  * 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/async.c

-              r32b3a12
+              rb800b0e
 #include "private/libc.h"
-#define CLIENT_HASH_TABLE_BUCKETS  32
-#define CONN_HASH_TABLE_BUCKETS    32
 /** 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);

uspace/lib/c/generic/dlfcn.c

-              r32b3a12
+              rb800b0e
 #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_synch.c

r32b3a12	rb800b0e
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/log.c

-              r32b3a12
+              rb800b0e
 #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/time.c

-              r32b3a12
+              rb800b0e
 /*
  * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2011 Petr Koupy
+ * Copyright (c) 2011 Jiri Zarevucky
  * All rights reserved.
+ *
 …
 #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/include/adt/hash_table.h

-              r32b3a12
+              rb800b0e
 /*
  * Copyright (c) 2006 Jakub Jermar
+ * Copyright (c) 2012 Adam Hraska
+ *
  * All rights reserved.
+ *
 …
 #include <unistd.h>
 #include <bool.h>
+#include <macros.h>
+typedef unsigned long hash_count_t;
+typedef unsigned long hash_index_t;
+/** Opaque hash table link type. */
+typedef struct ht_link {
+        link_t link;
+} ht_link_t;
 /** Set of operations for hash table. */
 typedef struct {
+        /** Hash function.
+         *
+         * @param key Array of keys needed to compute hash index.
+         *            All keys must be passed.
+         *
+         * @return Index into hash table.
+         *
+         */
+        hash_index_t (*hash)(unsigned long key[]);
+        /** Returns the hash of the key stored in the item (ie its lookup key). */
+        size_t (*hash)(const ht_link_t *item);
+        /** Hash table item comparison function.
+         *
+         * @param key Array of keys that will be compared with item. It is
+         *            not necessary to pass all keys.
+         *
+         * @return True if the keys match, false otherwise.
+         *
+         */
+        int (*compare)(unsigned long key[], hash_count_t keys, link_t *item);
+        /** Returns the hash of the key. */
+        size_t (*key_hash)(void *key);
+        /** True if the items are equal (have the same lookup keys). */
+        bool (*equal)(const ht_link_t *item1, const ht_link_t *item2);
+        /** Returns true if the key is equal to the item's lookup key. */
+        bool (*key_equal)(void *key, const ht_link_t *item);
         /** Hash table item removal callback.
+         *
+         * Must not invoke any mutating functions of the hash table.
+         *
          * @param item Item that was removed from the hash table.
+         *
          */
         void (*remove_callback)(link_t *item);
 } hash_table_operations_t;
+        void (*remove_callback)(ht_link_t *item);
+} hash_table_ops_t;
 /** Hash table structure. */
 typedef struct {
+        list_t *entry;
+        hash_count_t entries;
+        hash_count_t max_keys;
+        hash_table_operations_t *op;
+        hash_table_ops_t *op;
+        list_t *bucket;
+        size_t bucket_cnt;
+        size_t full_item_cnt;
+        size_t item_cnt;
+        size_t max_load;
+        bool apply_ongoing;
 } hash_table_t;
 #define hash_table_get_instance(item, type, member) \
     list_get_instance((item), type, member)
+#define hash_table_get_inst(item, type, member) \
+        member_to_inst((item), type, member)
+extern bool hash_table_create(hash_table_t *, hash_count_t, hash_count_t,
+    hash_table_operations_t *);
+extern bool hash_table_create(hash_table_t *, size_t, size_t,
+        hash_table_ops_t *);
+extern void hash_table_destroy(hash_table_t *);
+extern bool hash_table_empty(hash_table_t *);
+extern size_t hash_table_size(hash_table_t *);
 extern void hash_table_clear(hash_table_t *);
+extern void hash_table_insert(hash_table_t *, unsigned long [], link_t *);
+extern link_t *hash_table_find(hash_table_t *, unsigned long []);
+extern void hash_table_remove(hash_table_t *, unsigned long [], hash_count_t);
+extern void hash_table_destroy(hash_table_t *);
+extern void hash_table_apply(hash_table_t *, void (*)(link_t *, void *),
+    void *);
+extern void hash_table_insert(hash_table_t *, ht_link_t *);
+extern bool hash_table_insert_unique(hash_table_t *, ht_link_t *);
+extern ht_link_t *hash_table_find(const hash_table_t *, void *);
+extern ht_link_t *hash_table_find_next(const hash_table_t *, ht_link_t *);
+extern size_t hash_table_remove(hash_table_t *, void *);
+extern void hash_table_remove_item(hash_table_t *, ht_link_t *);
+extern void hash_table_apply(hash_table_t *, bool (*)(ht_link_t *, void *),
+        void *);
 #endif

uspace/lib/c/include/adt/list.h

-              r32b3a12
+              rb800b0e
             iterator != &(list).head; iterator = iterator->next)
+/** Unlike list_foreach(), allows removing items while traversing a list.
+ *
+ * @code
+ * list_t mylist;
+ * typedef struct item {
+ *     int value;
+ *     link_t item_link;
+ * } item_t;
+ *
+ * //..
+ *
+ * // Print each list element's value and remove the element from the list.
+ * list_foreach_safe(mylist, cur_link, next_link) {
+ *     item_t *cur_item = list_get_instance(cur_link, item_t, item_link);
+ *     printf("%d\n", cur_item->value);
+ *     list_remove(cur_link);
+ * }
+ * @endcode
+ *
+ * @param list List to traverse.
+ * @param iterator Iterator to the current element of the list.
+ *             The item this iterator points may be safely removed
+ *             from the list.
+ * @param next_iter Iterator to the next element of the list.
+ */
+#define list_foreach_safe(list, iterator, next_iter) \
+        for (link_t *iterator = (list).head.next, \
+                *next_iter = iterator->next; \
+                iterator != &(list).head; \
+                iterator = next_iter, next_iter = iterator->next)
 #define assert_link_not_used(link) \
         assert(((link)->prev == NULL) && ((link)->next == NULL))
+/** Returns true if the link is definitely part of a list. False if not sure. */
+static inline int link_in_use(link_t *link)
+{
+        return link->prev != NULL && link->next != NULL;
+}
 /** Initialize doubly-linked circular list link

uspace/lib/c/include/io/log.h

-              r32b3a12
+              rb800b0e
 #include <stdarg.h>
+#include <inttypes.h>
 #include <io/verify.h>
+/** Log message level. */
 typedef enum {
+        /** Fatal error, program is not able to recover at all. */
         LVL_FATAL,
+        /** Serious error but the program can recover from it. */
         LVL_ERROR,
+        /** Easily recoverable problem. */
         LVL_WARN,
+        /** Information message that ought to be printed by default. */
         LVL_NOTE,
+        /** Debugging purpose message. */
         LVL_DEBUG,
+        /** More detailed debugging message. */
         LVL_DEBUG2,
 …
 } log_level_t;
+extern int log_init(const char *, log_level_t);
+extern void log_msg(log_level_t, const char *, ...)
+    PRINTF_ATTRIBUTE(2, 3);
+extern void log_msgv(log_level_t, const char *, va_list);
+/** Log itself (logging target). */
+typedef sysarg_t log_t;
+/** Formatting directive for printing log_t. */
+#define PRIlogctx PRIxn
+/** Default log (target). */
+#define LOG_DEFAULT ((log_t) -1)
+/** Use when creating new top-level log. */
+#define LOG_NO_PARENT ((log_t) 0)
+extern const char *log_level_str(log_level_t);
+extern int log_level_from_str(const char *, log_level_t *);
+extern int log_init(const char *);
+extern log_t log_create(const char *, log_t);
+extern void log_msg(log_t, log_level_t, const char *, ...)
+    PRINTF_ATTRIBUTE(3, 4);
+extern void log_msgv(log_t, log_level_t, const char *, va_list);
 #endif

uspace/lib/c/include/ipc/dev_iface.h

-              r32b3a12
+              rb800b0e
         /** Interface provided by USB HID devices. */
         USBHID_DEV_IFACE,
+        /** Interface provided by Real Time Clock devices */
+        CLOCK_DEV_IFACE,
+        /** Interface provided by battery powered devices */
+        BATTERY_DEV_IFACE,
         /** Interface provided by AHCI devices. */
         AHCI_DEV_IFACE,

uspace/lib/c/include/ipc/logger.h

-              r32b3a12
+              rb800b0e
 /*
+ * Copyright (c) 2006 Jakub Jermar
+ * Copyright (c) 2011 Radim Vansa
+ * Copyright (c) 2012 Vojtech Horky
  * All rights reserved.
+ *
 …
  * @{
  */
-/** @file
- */
 #ifndef LIBC_HASH_SET_H_
 #define LIBC_HASH_SET_H_
+#ifndef LIBC_IPC_LOGGER_H_
+#define LIBC_IPC_LOGGER_H_
+#include <adt/list.h>
+#include <unistd.h>
+#include <ipc/common.h>
+#define HASH_SET_MIN_SIZE  8
+typedef enum {
+        /** Set (global) default displayed logging level.
+         *
+         * Arguments: new log level.
+         * Returns: error code
+         */
+        LOGGER_CONTROL_SET_DEFAULT_LEVEL = IPC_FIRST_USER_METHOD,
+        /** Set displayed level for given log.
+         *
+         * Arguments: new log level.
+         * Returns: error code
+         * Followed by: string with full log name.
+         */
+        LOGGER_CONTROL_SET_LOG_LEVEL
+} logger_control_request_t;
+typedef unsigned long (*hash_set_hash)(const link_t *);
+typedef int (*hash_set_equals)(const link_t *, const link_t *);
+typedef enum {
+        /** Create new log.
+         *
+         * Arguments: parent log id (0 for top-level log).
+         * Returns: error code, log id
+         * Followed by: string with log name.
+         */
+        LOGGER_WRITER_CREATE_LOG = IPC_FIRST_USER_METHOD,
+        /** Write a message to a given log.
+         *
+         * Arguments: log id, message severity level (log_level_t)
+         * Returns: error code
+         * Followed by: string with the message.
+         */
+        LOGGER_WRITER_MESSAGE
+} logger_writer_request_t;
+/** Hash table structure. */
+typedef struct {
+        list_t *table;
+        /** Current table size */
+        size_t size;
+        /**
+         * Current number of entries. If count > size,
+         * the table is rehashed into table with double
+         * size. If (4 * count < size) && (size > min_size),
+         * the table is rehashed into table with half the size.
+         */
+        size_t count;
+        /** Hash function */
+        hash_set_hash hash;
+        /** Hash table item equals function */
+        hash_set_equals equals;
+} hash_set_t;
+extern int hash_set_init(hash_set_t *, hash_set_hash, hash_set_equals, size_t);
+extern int hash_set_insert(hash_set_t *, link_t *);
+extern link_t *hash_set_find(hash_set_t *, const link_t *);
+extern int hash_set_contains(const hash_set_t *, const link_t *);
+extern size_t hash_set_count(const hash_set_t *);
+extern link_t *hash_set_remove(hash_set_t *, const link_t *);
+extern void hash_set_remove_selected(hash_set_t *,
+    int (*)(link_t *, void *), void *);
+extern void hash_set_destroy(hash_set_t *);
+extern void hash_set_apply(hash_set_t *, void (*)(link_t *, void *), void *);
+extern void hash_set_clear(hash_set_t *, void (*)(link_t *, void *), void *);
+typedef enum {
+        /** Interface for controlling logger behavior. */
+        LOGGER_INTERFACE_CONTROL,
+        /** Interface for servers writing to the log. */
+        LOGGER_INTERFACE_WRITER
+} logger_interface_t;
 #endif

uspace/lib/c/include/ipc/services.h

r32b3a12	rb800b0e
45	45	SERVICE_VFS = FOURCC('v', 'f', 's', ' '),
46	46	SERVICE_LOC = FOURCC('l', 'o', 'c', ' '),
	47	SERVICE_LOGGER = FOURCC('l', 'o', 'g', 'g'),
47	48	SERVICE_DEVMAN = FOURCC('d', 'e', 'v', 'n'),
48	49	SERVICE_IRC = FOURCC('i', 'r', 'c', ' '),

uspace/lib/c/include/macros.h

-              r32b3a12
+              rb800b0e
             | ((((uint64_t) (up)) & 0xffffffff) << 32))
+#ifndef member_to_inst
+#define member_to_inst(ptr_member, type, member_identif) \
+        ((type*) (((void*)(ptr_member)) - ((void*)&(((type*)0)->member_identif))))
+#endif
 #endif

uspace/lib/c/include/sys/time.h

-              r32b3a12
+              rb800b0e
 /*
  * Copyright (c) 2006 Ondrej Palkovsky
+ * Copyright (c) 2011 Petr Koupy
+ * Copyright (c) 2011 Jiri Zarevucky
  * All rights reserved.
+ *
 …
 #define DST_NONE 0
+#define ASCTIME_BUF_LEN 26
 typedef long time_t;
 …
 typedef uint32_t useconds_t;
 typedef uint32_t mseconds_t;
+struct tm {
+        int tm_sec;         /* Seconds [0,60]. */
+        int tm_min;         /* Minutes [0,59]. */
+        int tm_hour;        /* Hour [0,23]. */
+        int tm_mday;        /* Day of month [1,31]. */
+        int tm_mon;         /* Month of year [0,11]. */
+        int tm_year;        /* Years since 1900. */
+        int tm_wday;        /* Day of week [0,6] (Sunday = 0). */
+        int tm_yday;        /* Day of year [0,365]. */
+        int tm_isdst;       /* Daylight Savings flag. */
+};
 struct timeval {
 …
 extern int tv_gteq(struct timeval *tv1, struct timeval *tv2);
 extern int gettimeofday(struct timeval *tv, struct timezone *tz);
+extern int getuptime(struct timeval *tv);
 extern void udelay(useconds_t);
+extern time_t mktime(struct tm *tm);
+extern int time_utc2tm(const time_t time, struct tm *result);
+extern int time_utc2str(const time_t time, char *buf);
+extern void time_tm2str(const struct tm *timeptr, char *buf);
+extern int time_local2tm(const time_t time, struct tm *result);
+extern int time_local2str(const time_t time, char *buf);
+extern double difftime(time_t time1, time_t time0);
+extern size_t strftime(char *restrict s, size_t maxsize,
+    const char *restrict format, const struct tm *restrict tm);
 #endif

uspace/lib/drv/Makefile

r32b3a12	rb800b0e
46	46	generic/remote_usbhc.c \
47	47	generic/remote_usbhid.c \
	48	generic/remote_clock_dev.c \
	49	generic/remote_battery_dev.c \
48	50	generic/remote_ahci.c
49	51

uspace/lib/drv/generic/dev_iface.c

-              r32b3a12
+              rb800b0e
 #include "remote_hw_res.h"
 #include "remote_char_dev.h"
+#include "remote_clock_dev.h"
+#include "remote_battery_dev.h"
 #include "remote_graph_dev.h"
 #include "remote_nic.h"
 …
                 &remote_usbhc_iface,
                 &remote_usbhid_iface,
+                &remote_clock_dev_iface,
+                &remote_battery_dev_iface,
                 &remote_ahci_iface
+        }

uspace/lib/drv/generic/log.c

r32b3a12	rb800b0e
38	38	*
39	39	* @param drv_name Driver name, will be printed as part of message
40		* @param level Minimum message level to print
41	40	*
42	41	*/
43		int ddf_log_init(const char *drv_name~~, log_level_t level~~)
	42	int ddf_log_init(const char *drv_name)
44	43	{
45		return log_init(drv_name~~, level~~);
	44	return log_init(drv_name);
46	45	}
47	46
…	…
59	58
60	59	va_start(args, fmt);
61		log_msgv(level, fmt, args);
	60	log_msgv(LOG_DEFAULT, level, fmt, args);
62	61	va_end(args);
63	62	}

uspace/lib/drv/include/ddf/log.h

r32b3a12	rb800b0e
37	37	#include <io/verify.h>
38	38
39		extern int ddf_log_init(const char *~~, log_level_t~~);
	39	extern int ddf_log_init(const char *);
40	40	extern void ddf_msg(log_level_t, const char *, ...)
41	41	PRINTF_ATTRIBUTE(2, 3);

uspace/lib/ext4/libext4_crc.c

-              r32b3a12
+              rb800b0e
 /**
  * @file  libext4_crc.c
- * @brief CRC checksumming implementation from Linux.
  */
-#include <byteorder.h>
 #include "libext4.h"
-/** CRC table for the CRC-16.
+ *
- * The poly is 0x8005 (x^16 + x^15 + x^2 + 1).
+ *
- */
-uint16_t const crc16_table[256] = {
-x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241,
-xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440,
-xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40,
-x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841,
-xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40,
-x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41,
-x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641,
-xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040,
-xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240,
-x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441,
-x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41,
-xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840,
-x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41,
-xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40,
-xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640,
-x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041,
-xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240,
-x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441,
-x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41,
-xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840,
-x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41,
-xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40,
-xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640,
-x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041,
-x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241,
-x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440,
-x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40,
-x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841,
-x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40,
-x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41,
-x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641,
-x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040
-};
-/** Modify CRC value.
+ *
- * @param crc   Current CRC value
- * @param data  New byte of data to be "added" to CRC
+ *
- * @return Updated CRC value
+ *
- */
-static inline uint16_t crc16_byte(uint16_t crc, const uint8_t data)
+{
-        return (crc >> 8) ^ crc16_table[(crc ^ data) & 0xff];
+}
-/** Compute the CRC-16 for the data buffer.
+ *
- * @param crc    Previous CRC value
- * @param buffer Data pointer
- * @param len    Number of bytes in the buffer
+ *
- * @return Updated CRC value
+ *
- */
 uint16_t crc16(uint16_t crc, const uint8_t *buffer, size_t len)
+{
+        while (len--)
+                crc = crc16_byte(crc, *buffer++);
+        return crc;
+        // TODO
+        return 0;
+}

uspace/lib/ext4/libext4_filesystem.c

r32b3a12	rb800b0e
471	471
472	472	/** Compute checksum of block group descriptor.
473		*
474		* It uses crc functions from Linux kernel implementation.
475	473	*
476	474	* @param sb Superblock

uspace/lib/ext4/libext4_hash.c

-              r32b3a12
+              rb800b0e
  */
+#include "libext4.h"
 #include <errno.h>
-#include <mem.h>
-#include "libext4.h"
-#define TEA_DELTA  0x9E3779B9
-/* F, G and H are basic MD4 functions: selection, majority, parity */
-#define F(x, y, z)  ((z) ^ ((x) & ((y) ^ (z))))
-#define G(x, y, z)  (((x) & (y)) + (((x) ^ (y)) & (z)))
-#define H(x, y, z)  ((x) ^ (y) ^ (z))
-/*
- * The generic round function.  The application is so specific that
- * we don't bother protecting all the arguments with parens, as is generally
- * good macro practice, in favor of extra legibility.
- * Rotation is separate from addition to prevent recomputation
- */
-#define ROUND(f, a, b, c, d, x, s) \
-        (a += f(b, c, d) + x, a = (a << s) | (a >> (32 - s)))
-#define K1  0
-#define K2  013240474631UL
-#define K3  015666365641UL
-static void tea_transform(uint32_t buf[4], uint32_t const in[])
+{
-        uint32_t sum = 0;
-        uint32_t b0 = buf[0];
-        uint32_t b1 = buf[1];
-        uint32_t a = in[0];
-        uint32_t b = in[1];
-        uint32_t c = in[2];
-        uint32_t d = in[3];
-        int n = 16;
-        do {
-                sum += TEA_DELTA;
-                b0 += ((b1 << 4) + a) ^ (b1 + sum) ^ ((b1 >> 5) + b);
-                b1 += ((b0 << 4) + c) ^ (b0 + sum) ^ ((b0 >> 5) + d);
-        } while (--n);
-        buf[0] += b0;
-        buf[1] += b1;
+}
-static void half_md4_transform(uint32_t buf[4], const uint32_t in[8])
+{
-        uint32_t a = buf[0], b = buf[1], c = buf[2], d = buf[3];
-        /* Round 1 */
-        ROUND(F, a, b, c, d, in[0] + K1,  3);
-        ROUND(F, d, a, b, c, in[1] + K1,  7);
-        ROUND(F, c, d, a, b, in[2] + K1, 11);
-        ROUND(F, b, c, d, a, in[3] + K1, 19);
-        ROUND(F, a, b, c, d, in[4] + K1,  3);
-        ROUND(F, d, a, b, c, in[5] + K1,  7);
-        ROUND(F, c, d, a, b, in[6] + K1, 11);
-        ROUND(F, b, c, d, a, in[7] + K1, 19);
-        /* Round 2 */
-        ROUND(G, a, b, c, d, in[1] + K2,  3);
-        ROUND(G, d, a, b, c, in[3] + K2,  5);
-        ROUND(G, c, d, a, b, in[5] + K2,  9);
-        ROUND(G, b, c, d, a, in[7] + K2, 13);
-        ROUND(G, a, b, c, d, in[0] + K2,  3);
-        ROUND(G, d, a, b, c, in[2] + K2,  5);
-        ROUND(G, c, d, a, b, in[4] + K2,  9);
-        ROUND(G, b, c, d, a, in[6] + K2, 13);
-        /* Round 3 */
-        ROUND(H, a, b, c, d, in[3] + K3,  3);
-        ROUND(H, d, a, b, c, in[7] + K3,  9);
-        ROUND(H, c, d, a, b, in[2] + K3, 11);
-        ROUND(H, b, c, d, a, in[6] + K3, 15);
-        ROUND(H, a, b, c, d, in[1] + K3,  3);
-        ROUND(H, d, a, b, c, in[5] + K3,  9);
-        ROUND(H, c, d, a, b, in[0] + K3, 11);
-        ROUND(H, b, c, d, a, in[4] + K3, 15);
-        buf[0] += a;
-        buf[1] += b;
-        buf[2] += c;
-        buf[3] += d;
+}
-static uint32_t hash_unsigned(const char *name, int len)
+{
-        uint32_t hash;
-        uint32_t hash0 = 0x12a3fe2d;
-        uint32_t hash1 = 0x37abe8f9;
-        const unsigned char *ucp = (const unsigned char *) name;
-        while (len--) {
-                hash = hash1 + (hash0 ^ (((int) *ucp++) * 7152373));
-                if (hash & 0x80000000)
-                        hash -= 0x7fffffff;
-                hash1 = hash0;
-                hash0 = hash;
+        }
-        return hash0 << 1;
+}
-static uint32_t hash_signed(const char *name, int len)
+{
-        uint32_t hash;
-        uint32_t hash0 = 0x12a3fe2d;
-        uint32_t hash1 = 0x37abe8f9;
-        const signed char *scp = (const signed char *) name;
-        while (len--) {
-                hash = hash1 + (hash0 ^ (((int) *scp++) * 7152373));
-                if (hash & 0x80000000)
-                        hash -= 0x7fffffff;
-                hash1 = hash0;
-                hash0 = hash;
+        }
-        return hash0 << 1;
+}
-static void str2hashbuf_signed(const char *msg, int len, uint32_t *buf, int num)
+{
-        uint32_t pad, val;
-        int i;
-        const signed char *scp = (const signed char *) msg;
-        pad = (uint32_t) len | ((uint32_t) len << 8);
-        pad |= pad << 16;
-        val = pad;
-        if (len > num * 4)
-                len = num * 4;
-        for (i = 0; i < len; i++) {
-                if ((i % 4) == 0)
-                        val = pad;
-                val = ((int) scp[i]) + (val << 8);
-                if ((i % 4) == 3) {
-                        *buf++ = val;
-                        val = pad;
-                        num--;
+                }
+        }
-        if (--num >= 0)
-                *buf++ = val;
-        while (--num >= 0)
-                *buf++ = pad;
+}
-static void str2hashbuf_unsigned(const char *msg, int len, uint32_t *buf,
-    int num)
+{
-        uint32_t pad, val;
-        int i;
-        const unsigned char *ucp = (const unsigned char *) msg;
-        pad = (uint32_t) len | ((uint32_t) len << 8);
-        pad |= pad << 16;
-        val = pad;
-        if (len > num * 4)
-                len = num * 4;
-        for (i = 0; i < len; i++) {
-                if ((i % 4) == 0)
-                        val = pad;
-                val = ((int) ucp[i]) + (val << 8);
-                if ((i % 4) == 3) {
-                        *buf++ = val;
-                        val = pad;
-                        num--;
+                }
+        }
-        if (--num >= 0)
-                *buf++ = val;
-        while (--num >= 0)
-                *buf++ = pad;
+}
-/** Compute hash value of the string.
+ *
- * @param hinfo Hash info structure with information about
- *              the algorithm, hash seed and with the place
- *              for the output hash value
- * @param len  Length of the name
- * @param name Name to be hashed
+ *
- * @return Error code
+ *
- */
 int ext4_hash_string(ext4_hash_info_t *hinfo, int len, const char *name)
+{
+        uint32_t hash = 0;
+        uint32_t minor_hash = 0;
+        const char *p;
+        int i;
+        uint32_t in[8], buf[4];
+        void (*str2hashbuf)(const char *, int, uint32_t *, int) =
+            str2hashbuf_signed;
+        /* Initialize the default seed for the hash checksum functions */
+        buf[0] = 0x67452301;
+        buf[1] = 0xefcdab89;
+        buf[2] = 0x98badcfe;
+        buf[3] = 0x10325476;
+        /* Check if the seed is all zero's */
+        if (hinfo->seed) {
+                for (i = 0; i < 4; i++) {
+                        if (hinfo->seed[i] != 0)
+                                break;
+                }
+                if (i < 4)
+                        memcpy(buf, hinfo->seed, sizeof(buf));
+        }
+        switch (hinfo->hash_version) {
+        case EXT4_HASH_VERSION_LEGACY_UNSIGNED:
+                hash = hash_unsigned(name, len);
+                break;
+        case EXT4_HASH_VERSION_LEGACY:
+                hash = hash_signed(name, len);
+                break;
+        case EXT4_HASH_VERSION_HALF_MD4_UNSIGNED:
+                str2hashbuf = str2hashbuf_unsigned;
+        case EXT4_HASH_VERSION_HALF_MD4:
+                p = name;
+                while (len > 0) {
+                        (*str2hashbuf)(p, len, in, 8);
+                        half_md4_transform(buf, in);
+                        len -= 32;
+                        p += 32;
+                }
+                minor_hash = buf[2];
+                hash = buf[1];
+                break;
+        case EXT4_HASH_VERSION_TEA_UNSIGNED:
+                str2hashbuf = str2hashbuf_unsigned;
+        case EXT4_HASH_VERSION_TEA:
+                p = name;
+                while (len > 0) {
+                        (*str2hashbuf)(p, len, in, 4);
+                        tea_transform(buf, in);
+                        len -= 16;
+                        p += 16;
+                }
+                hash = buf[0];
+                minor_hash = buf[1];
+                break;
+        default:
+                hinfo->hash = 0;
+                return EINVAL;
+        }
+        hash = hash & ~1;
+        if (hash == (EXT4_DIRECTORY_HTREE_EOF << 1))
+                hash = (EXT4_DIRECTORY_HTREE_EOF - 1) << 1;
+        hinfo->hash = hash;
+        hinfo->minor_hash = minor_hash;
+        return EOK;
+        // TODO
+        hinfo->hash = 0;
+        return ENOTSUP;
+}

uspace/lib/fs/libfs.c

-              r32b3a12
+              rb800b0e
                                                 async_answer_0(rid, rc);
                                         } else {
+                                                aoff64_t size = ops->size_get(fn);
+                                                async_answer_5(rid, fs_handle,
+                                                    service_id,
+                                                    ops->index_get(fn),
+                                                    LOWER32(size),
+                                                    UPPER32(size),
+                                                    ops->lnkcnt_get(fn));
+                                                (void) ops->node_put(fn);
+                                                (void) ops->node_put(cur);
+                                                cur = fn;
+                                                goto out_with_answer;
+                                        }
                                 } else
 …
                                         async_answer_0(rid, rc);
                                 } else {
+                                        aoff64_t size = ops->size_get(fn);
+                                        async_answer_5(rid, fs_handle,
+                                            service_id,
+                                            ops->index_get(fn),
+                                            LOWER32(size),
+                                            UPPER32(size),
+                                            ops->lnkcnt_get(fn));
+                                        (void) ops->node_put(fn);
+                                        (void) ops->node_put(cur);
+                                        cur = fn;
+                                        goto out_with_answer;
+                                }
                         } else

uspace/lib/nic/include/nic.h

-              r32b3a12
+              rb800b0e
 #include <adt/list.h>
+#include <adt/hash_table.h>
 #include <ddf/driver.h>
 #include <device/hw_res_parsed.h>
 …
  */
 typedef struct nic_wol_virtue {
         link_t item;
+        ht_link_t item;
         nic_wv_id_t id;
         nic_wv_type_t type;

uspace/lib/nic/include/nic_addr_db.h

-              r32b3a12
+              rb800b0e
 #endif
+#include <adt/hash_set.h>
+/**
+ * Initial size of DB's hash set
+ */
+#define NIC_ADDR_DB_INIT_SIZE   8
+/**
+ * Maximal length of addresses in the DB (in bytes).
+ */
+#define NIC_ADDR_MAX_LENGTH             16
+#include <adt/hash_table.h>
 /**
 …
  */
 typedef struct nic_addr_db {
         hash_set_t set;
+        hash_table_t set;
         size_t addr_len;
 } nic_addr_db_t;
-/**
- * Helper structure for keeping the address in the hash set.
- */
-typedef struct nic_addr_entry {
-        link_t item;
-        size_t addr_len;
-        uint8_t addr[NIC_ADDR_MAX_LENGTH];
-} nic_addr_entry_t;
 extern int nic_addr_db_init(nic_addr_db_t *db, size_t addr_len);
 extern void nic_addr_db_clear(nic_addr_db_t *db);
 extern void nic_addr_db_destroy(nic_addr_db_t *db);
-extern size_t nic_addr_db_count(const nic_addr_db_t *db);
 extern int nic_addr_db_insert(nic_addr_db_t *db, const uint8_t *addr);
 extern int nic_addr_db_remove(nic_addr_db_t *db, const uint8_t *addr);
-extern void nic_addr_db_remove_selected(nic_addr_db_t *db,
-        int (*func)(const uint8_t *, void *), void *arg);
 extern int nic_addr_db_contains(const nic_addr_db_t *db, const uint8_t *addr);
 extern void nic_addr_db_foreach(const nic_addr_db_t *db,

uspace/lib/nic/include/nic_wol_virtues.h

r32b3a12	rb800b0e
51	51	* Operations for table
52	52	*/
53		hash_table_op~~eration~~s_t table_operations;
	53	hash_table_ops_t table_operations;
54	54	/**
55	55	* WOL virtues hashed by their ID's.

uspace/lib/nic/src/nic_addr_db.c

-              r32b3a12
+              rb800b0e
  * @brief Generic hash-set based database of addresses
  */
+#include "nic_addr_db.h"
+#include "libarch/common.h"
 #include <assert.h>
 #include <stdlib.h>
 …
 #include <errno.h>
 #include <mem.h>
+#include "nic_addr_db.h"
+/**
+ * Hash set helper function
+ */
+static int nic_addr_equals(const link_t *item1, const link_t *item2)
+{
+        assert(item1 && item2);
+        size_t addr_len = ((const nic_addr_entry_t *) item1)->addr_len;
+        assert(addr_len == ((const nic_addr_entry_t *) item2)->addr_len);
+        size_t i;
+        for (i = 0; i < addr_len; ++i) {
+                if (((nic_addr_entry_t *) item1)->addr[i] !=
+                        ((nic_addr_entry_t *) item2)->addr[i])
+                        return false;
+#include <adt/hash_table.h>
+#include <macros.h>
+#include <stdint.h>
+/**
+ * Helper structure for keeping the address in the hash set.
+ */
+typedef struct nic_addr_entry {
+        ht_link_t link;
+        uint8_t len;
+        uint8_t addr[1];
+} nic_addr_entry_t;
+/*
+ * Hash table helper functions
+ */
+typedef struct {
+        size_t len;
+        const uint8_t *addr;
+} addr_key_t;
+static bool nic_addr_key_equal(void *key_arg, const ht_link_t *item)
+{
+        addr_key_t *key = (addr_key_t*)key_arg;
+        nic_addr_entry_t *entry = member_to_inst(item, nic_addr_entry_t, link);
+        return 0 == bcmp(entry->addr, key->addr, entry->len);
+}
+static size_t addr_hash(size_t len, const uint8_t *addr)
+{
+        size_t hash = 0;
+        for (size_t i = 0; i < len; ++i) {
+                hash = (hash << 5) ^ addr[i];
+        }
+        return true;
+}
+/**
+ * Hash set helper function
+ */
+static unsigned long nic_addr_hash(const link_t *item)
+{
+        assert(item);
+        const nic_addr_entry_t *entry = (const nic_addr_entry_t *) item;
+        unsigned long hash = 0;
+        size_t i;
+        for (i = 0; i < entry->addr_len; ++i) {
+                hash = (hash << 8) ^ (hash >> 24) ^ entry->addr[i];
+        }
         return hash;
+}
+/**
+ * Helper wrapper
+ */
+static void nic_addr_destroy(link_t *item, void *unused)
+{
+        free(item);
+}
+static size_t nic_addr_key_hash(void *k)
+{
+        addr_key_t *key = (addr_key_t*)k;
+        return addr_hash(key->len, key->addr);
+}
+static size_t nic_addr_hash(const ht_link_t *item)
+{
+        nic_addr_entry_t *entry = member_to_inst(item, nic_addr_entry_t, link);
+        return addr_hash(entry->len, entry->addr);
+}
+static void nic_addr_removed(ht_link_t *item)
+{
+        nic_addr_entry_t *entry = member_to_inst(item, nic_addr_entry_t, link);
+        free(entry);
+}
+static hash_table_ops_t set_ops = {
+        .hash = nic_addr_hash,
+        .key_hash = nic_addr_key_hash,
+        .key_equal = nic_addr_key_equal,
+        .equal = NULL,
+        .remove_callback = nic_addr_removed
+};
 /**
 …
+{
         assert(db);
+        if (addr_len > NIC_ADDR_MAX_LENGTH) {
+        if (addr_len > UCHAR_MAX)
                 return EINVAL;
+        }
+        if (!hash_set_init(&db->set, nic_addr_hash, nic_addr_equals,
+                NIC_ADDR_DB_INIT_SIZE)) {
+        if (!hash_table_create(&db->set, 0, 0, &set_ops))
                 return ENOMEM;
+        }
         db->addr_len = addr_len;
         return EOK;
 …
+{
         assert(db);
         hash_set_clear(&db->set, nic_addr_destroy, NULL);
+        hash_table_clear(&db->set);
+}
 …
+{
         assert(db);
+        hash_set_apply(&db->set, nic_addr_destroy, NULL);
+        hash_set_destroy(&db->set);
+}
+/**
+ * Get number of addresses in the db
+ *
+ * @param       db
+ *
+ * @return Number of adresses
+ */
+size_t nic_addr_db_count(const nic_addr_db_t *db)
+{
+        assert(db);
+        return hash_set_count(&db->set);
+}
+        hash_table_destroy(&db->set);
+}
 /**
 …
+{
         assert(db && addr);
+        nic_addr_entry_t *entry = malloc(sizeof (nic_addr_entry_t));
+        if (entry == NULL) {
+        addr_key_t key = {
+                .len = db->addr_len,
+                .addr = addr
+        };
+        if (hash_table_find(&db->set, &key))
+                return EEXIST;
+        nic_addr_entry_t *entry = malloc(sizeof(nic_addr_entry_t) + db->addr_len - 1);
+        if (entry == NULL)
                 return ENOMEM;
+        }
         entry->addr_len = db->addr_len;
+        entry->len = (uint8_t) db->addr_len;
         memcpy(entry->addr, addr, db->addr_len);
+        return hash_set_insert(&db->set, &entry->item) ? EOK : EEXIST;
+        hash_table_insert(&db->set, &entry->link);
+        return EOK;
+}
 …
+{
         assert(db && addr);
+        nic_addr_entry_t entry;
+        entry.addr_len = db->addr_len;
+        memcpy(entry.addr, addr, db->addr_len);
+        link_t *removed = hash_set_remove(&db->set, &entry.item);
+        free(removed);
+        return removed != NULL ? EOK : ENOENT;
+        addr_key_t key = {
+                .len = db->addr_len,
+                .addr = addr
+        };
+        if (hash_table_remove(&db->set, &key))
+                return EOK;
+        else
+                return ENOENT;
+}
 …
+{
         assert(db && addr);
+        nic_addr_entry_t entry;
+        entry.addr_len = db->addr_len;
+        memcpy(entry.addr, addr, db->addr_len);
+        return hash_set_contains(&db->set, &entry.item);
+        addr_key_t key = {
+                .len = db->addr_len,
+                .addr = addr
+        };
+        return 0 != hash_table_find(&db->set, &key);
+}
 …
  * Helper function for nic_addr_db_foreach
  */
+static void nic_addr_db_fe_helper(link_t *item, void *arg) {
+static bool nic_addr_db_fe_helper(ht_link_t *item, void *arg)
+{
         nic_addr_db_fe_arg_t *hs = (nic_addr_db_fe_arg_t *) arg;
+        hs->func(((nic_addr_entry_t *) item)->addr, hs->arg);
+        nic_addr_entry_t *entry = member_to_inst(item, nic_addr_entry_t, link);
+        hs->func(entry->addr, hs->arg);
+        return true;
+}
 …
+{
         nic_addr_db_fe_arg_t hs = { .func = func, .arg = arg };
+        hash_set_apply((hash_set_t *) &db->set, nic_addr_db_fe_helper, &hs);
+}
+/**
+ * Helper structure for nic_addr_db_remove_selected
+ */
+typedef struct {
+        int (*func)(const uint8_t *, void *);
+        void *arg;
+} nic_addr_db_rs_arg_t;
+/**
+ * Helper function for nic_addr_db_foreach
+ */
+static int nic_addr_db_rs_helper(link_t *item, void *arg) {
+        nic_addr_db_rs_arg_t *hs = (nic_addr_db_rs_arg_t *) arg;
+        int retval = hs->func(((nic_addr_entry_t *) item)->addr, hs->arg);
+        if (retval) {
+                free(item);
+        }
+        return retval;
+}
+/**
+ * Removes all addresses for which the function returns non-zero.
+ *
+ * @param       db
+ * @param       func    User-defined function
+ * @param       arg             Custom argument passed to the function
+ */
+void nic_addr_db_remove_selected(nic_addr_db_t *db,
+        int (*func)(const uint8_t *, void *), void *arg)
+{
+        nic_addr_db_rs_arg_t hs = { .func = func, .arg = arg };
+        hash_set_remove_selected(&db->set, nic_addr_db_rs_helper, &hs);
+        hash_table_apply((hash_table_t*)&db->set, nic_addr_db_fe_helper, &hs);
+}

uspace/lib/nic/src/nic_wol_virtues.c

-              r32b3a12
+              rb800b0e
 #include "nic_wol_virtues.h"
+#include "nic.h"
 #include <assert.h>
 #include <errno.h>
+#define NIC_WV_HASH_COUNT 32
+/**
+ * Hash table helper function
+ */
+static int nic_wv_compare(unsigned long key[], hash_count_t keys,
+        link_t *item)
+/*
+ * Hash table helper functions
+ */
+static size_t nic_wv_key_hash(void *key)
+{
+        return *(nic_wv_id_t*) key;
+}
+static size_t nic_wv_hash(const ht_link_t *item)
+{
         nic_wol_virtue_t *virtue = (nic_wol_virtue_t *) item;
+        return (virtue->id == (nic_wv_id_t) key[0]);
+}
+/**
+ * Hash table helper function
+ */
+static void nic_wv_rc(link_t *item)
+{
+}
+/**
+ * Hash table helper function
+ */
+static hash_index_t nic_wv_hash(unsigned long keys[])
+{
+        return keys[0] % NIC_WV_HASH_COUNT;
+        return virtue->id;
+}
+static bool nic_wv_key_equal(void *key, const ht_link_t *item)
+{
+        nic_wol_virtue_t *virtue = (nic_wol_virtue_t *) item;
+        return (virtue->id == *(nic_wv_id_t*) key);
+}
 …
 int nic_wol_virtues_init(nic_wol_virtues_t *wvs)
+{
+        bzero(wvs, sizeof (nic_wol_virtues_t));
+        wvs->table_operations.compare = nic_wv_compare;
+        bzero(wvs, sizeof(nic_wol_virtues_t));
         wvs->table_operations.hash = nic_wv_hash;
+        wvs->table_operations.remove_callback = nic_wv_rc;
+        if (!hash_table_create(&wvs->table, NIC_WV_HASH_COUNT, 1,
+                &wvs->table_operations)) {
+        wvs->table_operations.key_hash = nic_wv_key_hash;
+        wvs->table_operations.key_equal = nic_wv_key_equal;
+        wvs->table_operations.equal = 0;
+        wvs->table_operations.remove_callback = 0;
+        if (!hash_table_create(&wvs->table, 0, 0, &wvs->table_operations)) {
                 return ENOMEM;
+        }
 …
         do {
                 virtue->id = wvs->next_id++;
+        } while (NULL !=
+                hash_table_find(&wvs->table, (unsigned long *) &virtue->id));
+        hash_table_insert(&wvs->table,
+                (unsigned long *) &virtue->id, &virtue->item);
+        } while (NULL != hash_table_find(&wvs->table, &virtue->id));
+        hash_table_insert(&wvs->table, &virtue->item);
         virtue->next = wvs->lists[virtue->type];
         wvs->lists[virtue->type] = virtue;
 …
 nic_wol_virtue_t *nic_wol_virtues_remove(nic_wol_virtues_t *wvs, nic_wv_id_t id)
+{
         nic_wol_virtue_t *virtue = (nic_wol_virtue_t *)
                 hash_table_find(&wvs->table, (unsigned long *) &id);
+        nic_wol_virtue_t *virtue =
+                (nic_wol_virtue_t *) hash_table_find(&wvs->table, &id);
         if (virtue == NULL) {
                 return NULL;
 …
         /* Remove from filter_table */
         hash_table_remove(&wvs->table, (unsigned long *) &id, 1);
+        hash_table_remove_item(&wvs->table, &virtue->item);
         /* Remove from filter_types */
 …
          * constant virtue the retyping is correct.
          */
+        link_t *virtue = hash_table_find(
+                &((nic_wol_virtues_t *) wvs)->table, (unsigned long *) &id);
+        ht_link_t *virtue = hash_table_find(&((nic_wol_virtues_t *) wvs)->table, &id);
         return (const nic_wol_virtue_t *) virtue;
+}

uspace/lib/posix/include/posix/time.h

-              r32b3a12
+              rb800b0e
 #endif
-#undef ASCTIME_BUF_LEN
-#define ASCTIME_BUF_LEN 26
 #undef CLOCK_REALTIME
 #define CLOCK_REALTIME ((posix_clockid_t) 0)
-struct posix_tm {
-        int tm_sec;         /* Seconds [0,60]. */
-        int tm_min;         /* Minutes [0,59]. */
-        int tm_hour;        /* Hour [0,23]. */
-        int tm_mday;        /* Day of month [1,31]. */
-        int tm_mon;         /* Month of year [0,11]. */
-        int tm_year;        /* Years since 1900. */
-        int tm_wday;        /* Day of week [0,6] (Sunday = 0). */
-        int tm_yday;        /* Day of year [0,365]. */
-        int tm_isdst;       /* Daylight Savings flag. */
-};
 struct posix_timespec {
 …
 extern void posix_tzset(void);
-/* Elapsed Time */
-extern double posix_difftime(time_t time1, time_t time0);
 /* Broken-down Time */
+extern time_t posix_mktime(struct posix_tm *tm);
+extern struct posix_tm *posix_gmtime(const time_t *timer);
+extern struct posix_tm *posix_gmtime_r(const time_t *restrict timer,
+    struct posix_tm *restrict result);
+extern struct posix_tm *posix_localtime(const time_t *timer);
+extern struct posix_tm *posix_localtime_r(const time_t *restrict timer,
+    struct posix_tm *restrict result);
+extern struct tm *posix_gmtime_r(const time_t *restrict timer,
+    struct tm *restrict result);
+extern struct tm *posix_gmtime(const time_t *restrict timep);
+extern struct tm *posix_localtime_r(const time_t *restrict timer,
+    struct tm *restrict result);
+extern struct tm *posix_localtime(const time_t *restrict timep);
 /* Formatting Calendar Time */
+extern char *posix_asctime(const struct posix_tm *timeptr);
+extern char *posix_asctime_r(const struct posix_tm *restrict timeptr,
+extern char *posix_asctime_r(const struct tm *restrict timeptr,
     char *restrict buf);
+extern char *posix_asctime(const struct tm *restrict timeptr);
+extern char *posix_ctime_r(const time_t *timer, char *buf);
 extern char *posix_ctime(const time_t *timer);
-extern char *posix_ctime_r(const time_t *timer, char *buf);
-extern size_t posix_strftime(char *restrict s, size_t maxsize,
-    const char *restrict format, const struct posix_tm *restrict tm);
 /* Clocks */
 …
 #ifndef LIBPOSIX_INTERNAL
+        #define tm posix_tm
+        #define timespec posix_timespec
+        #define itimerspec posix_itimerspec
+        #define timer_t posix_timer_t
+        #define timespec    posix_timespec
+        #define itimerspec  posix_itimerspec
+        #define timer_t     posix_timer_t
         #define daylight posix_daylight
         #define timezone posix_timezone
         #define tzname posix_tzname
         #define tzset posix_tzset
+        #define daylight    posix_daylight
+        #define timezone    posix_timezone
+        #define tzname      posix_tzname
+        #define tzset       posix_tzset
+        #define difftime posix_difftime
+        #define gmtime_r    posix_gmtime_r
+        #define gmtime      posix_gmtime
+        #define localtime_r posix_localtime_r
+        #define localtime   posix_localtime
+        #define mktime posix_mktime
+        #define gmtime posix_gmtime
+        #define gmtime_r posix_gmtime_r
+        #define localtime posix_localtime
+        #define localtime_r posix_localtime_r
+        #define asctime posix_asctime
+        #define asctime_r posix_asctime_r
+        #define ctime posix_ctime
+        #define ctime_r posix_ctime_r
+        #define strftime posix_strftime
+        #define asctime_r   posix_asctime_r
+        #define asctime     posix_asctime
+        #define ctime_r     posix_ctime_r
+        #define ctime       posix_ctime
         #define clock_getres posix_clock_getres

uspace/lib/posix/source/time.c

-              r32b3a12
+              rb800b0e
  */
-/* 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 Divident.
- * @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 Divident.
- * @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 posix_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 posix_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 posix_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 posix_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 posix_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 posix_tm *tm)
+{
-        int first_day = (1 - _day_of_week(tm->tm_year, 0, 1)) % 7;
-        return (tm->tm_yday - first_day + 7) / 7;
+}
-/******************************************************************************/
 int posix_daylight;
 long posix_timezone;
 …
 /**
- * Calculate the difference between two times, in seconds.
+ *
- * @param time1 First time.
- * @param time0 Second time.
- * @return Time in seconds.
- */
-double posix_difftime(time_t time1, time_t time0)
+{
-        return (double) (time1 - time0);
+}
-/**
- * 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 posix_mktime(struct posix_tm *tm)
+{
-        // TODO: take DST flag into account
-        // TODO: detect overflow
-        _normalize_time(tm, 0);
-        return _secs_since_epoch(tm);
+}
-/**
- * Converts a time value to a broken-down UTC time.
+ *
- * @param timer Time to convert.
- * @return Normalized broken-down time in UTC, NULL on overflow.
- */
-struct posix_tm *posix_gmtime(const time_t *timer)
+{
-        assert(timer != NULL);
-        static struct posix_tm result;
-        return posix_gmtime_r(timer, &result);
+}
-/**
  * Converts a time value to a broken-down UTC time.
+ *
 …
  * @return Value of result on success, NULL on overflow.
  */
+struct posix_tm *posix_gmtime_r(const time_t *restrict timer,
+    struct posix_tm *restrict result)
+{
+        assert(timer != NULL);
+        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, *timer) == -1) {
+                errno = EOVERFLOW;
+struct tm *posix_gmtime_r(const time_t *restrict timer,
+    struct tm *restrict result)
+{
+        int rc = time_utc2tm(*timer, result);
+        if (rc != EOK) {
+                errno = rc;
                 return NULL;
+        }
 …
 /**
+ * Converts a time value to a broken-down local time.
+ *
+ * @param timer Time to convert.
+ * @return Normalized broken-down time in local timezone, NULL on overflow.
+ */
+struct posix_tm *posix_localtime(const time_t *timer)
+{
+        static struct posix_tm result;
+        return posix_localtime_r(timer, &result);
+ * Converts a time value to a broken-down UTC time.
+ * (non reentrant version)
+ *
+ * @param timep  Time to convert
+ * @return       Pointer to a statically allocated structure that stores
+ *               the result, NULL in case of error.
+ */
+struct tm *posix_gmtime(const time_t *restrict timep)
+{
+        static struct tm result;
+        return posix_gmtime_r(timep, &result);
+}
 …
  * @return Value of result on success, NULL on overflow.
  */
 struct posix_tm *posix_localtime_r(const time_t *restrict timer,
     struct posix_tm *restrict result)
+struct tm *posix_localtime_r(const time_t *restrict timer,
+    struct tm *restrict result)
+{
         // TODO: deal with timezone
 …
 /**
+ * Converts broken-down time to a string in format
+ * "Sun Jan 1 00:00:00 1970\n". (Obsolete)
+ *
+ * @param timeptr Broken-down time structure.
+ * @return Pointer to a statically allocated string.
+ */
+char *posix_asctime(const struct posix_tm *timeptr)
+{
+        static char buf[ASCTIME_BUF_LEN];
+        return posix_asctime_r(timeptr, buf);
+ * Converts a time value to a broken-down local time.
+ * (non reentrant version)
+ *
+ * @param timep    Time to convert.
+ * @return         Pointer to a statically allocated structure that stores
+ *                 the result, NULL in case of error.
+ */
+struct tm *posix_localtime(const time_t *restrict timep)
+{
+        static struct tm result;
+        return posix_localtime_r(timep, &result);
+}
 …
  * @return Value of buf.
  */
 char *posix_asctime_r(const struct posix_tm *restrict timeptr,
+char *posix_asctime_r(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);
+        time_tm2str(timeptr, buf);
         return buf;
+}
 /**
+ * Equivalent to asctime(localtime(clock)).
+ *
+ * @param timer Time to convert.
+ * @return Pointer to a statically allocated string holding the date.
+ */
+char *posix_ctime(const time_t *timer)
+{
+        struct posix_tm *loctime = posix_localtime(timer);
+        if (loctime == NULL) {
+                return NULL;
+        }
+        return posix_asctime(loctime);
+}
+/**
+ * Reentrant variant of ctime().
+ * Convers broken-down time to a string in format
+ * "Sun Jan 1 00:00:00 1970\n". (Obsolete)
+ * (non reentrant version)
+ *
+ * @param timeptr    Broken-down time structure.
+ * @return           Pointer to a statically allocated buffer that stores
+ *                   the result, NULL in case of error.
+ */
+char *posix_asctime(const struct tm *restrict timeptr)
+{
+        static char buf[ASCTIME_BUF_LEN];
+        return posix_asctime_r(timeptr, buf);
+}
+/**
+ * Converts the calendar time to a string in format
+ * "Sun Jan 1 00:00:00 1970\n" (Obsolete)
+ *
  * @param timer Time to convert.
  * @param buf Buffer to store string to. Must be at least ASCTIME_BUF_LEN
  *     bytes long.
  * @return Pointer to buf on success, NULL on falure.
+ * @return Pointer to buf on success, NULL on failure.
  */
 char *posix_ctime_r(const time_t *timer, char *buf)
+{
+        struct posix_tm loctime;
+        if (posix_localtime_r(timer, &loctime) == NULL) {
+        int r = time_local2str(*timer, buf);
+        if (r != EOK) {
+                errno = r;
                 return NULL;
+        }
+        return posix_asctime_r(&loctime, buf);
+}
+/**
+ * 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 posix_strftime(char *restrict s, size_t maxsize,
+    const char *restrict format, const struct posix_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 = posix_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;
+        return buf;
+}
+/**
+ * Converts the calendar time to a string in format
+ * "Sun Jan 1 00:00:00 1970\n" (Obsolete)
+ * (non reentrant version)
+ *
+ * @param timep    Time to convert.
+ * @return         Pointer to a statically allocated buffer that stores
+ *                 the result, NULL in case of error.
+ */
+char *posix_ctime(const time_t *timep)
+{
+        static char buf[ASCTIME_BUF_LEN];
+        return posix_ctime_r(timep, buf);
+}
 …
         stats_task_t *task_stats = stats_get_task(task_get_id());
         if (task_stats) {
+                total_cycles = (posix_clock_t) (task_stats->kcycles + task_stats->ucycles);
+                total_cycles = (posix_clock_t) (task_stats->kcycles +
+                    task_stats->ucycles);
                 free(task_stats);
                 task_stats = 0;

uspace/lib/softfloat/Makefile

-              r32b3a12
+              rb800b0e
 USPACE_PREFIX = ../..
-EXTRA_CFLAGS = -Iinclude
 LIBRARY = libsoftfloat
 SOURCES = \
         generic/add.c \
         generic/common.c \
         generic/comparison.c \
         generic/conversion.c \
         generic/div.c \
         generic/mul.c \
         generic/other.c \
         generic/softfloat.c \
         generic/sub.c
+        softfloat.c \
+        common.c \
+        add.c \
+        sub.c \
+        div.c \
+        mul.c \
+        comparison.c \
+        conversion.c \
+        other.c
 include $(USPACE_PREFIX)/Makefile.common

uspace/lib/softfloat/add.c

-              r32b3a12
+              rb800b0e
  */
 #include <sftypes.h>
 #include <add.h>
 #include <comparison.h>
 #include <common.h>
+#include "sftypes.h"
+#include "add.h"
+#include "comparison.h"
+#include "common.h"
 /** Add two single-precision floats with the same sign.
 …
                 /* both are denormalized */
                 frac1 += frac2;
                 if (frac1 & FLOAT32_HIDDEN_BIT_MASK ) {
+                if (frac1 & FLOAT32_HIDDEN_BIT_MASK) {
                         /* result is not denormalized */
                         a.parts.exp = 1;
 …
         frac2 <<= 6;
         if (expdiff < (FLOAT32_FRACTION_SIZE + 2) ) {
+        if (expdiff < (FLOAT32_FRACTION_SIZE + 2)) {
                 frac2 >>= expdiff;
                 frac1 += frac2;
 …
+        }
         if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7) ) {
+        if (frac1 & (FLOAT32_HIDDEN_BIT_MASK << 7)) {
                 ++exp1;
                 frac1 >>= 1;
 …
+        }
         if ((exp1 == FLOAT32_MAX_EXPONENT ) || (exp2 > exp1)) {
+        if ((exp1 == FLOAT32_MAX_EXPONENT) || (exp2 > exp1)) {
                 /* overflow - set infinity as result */
                 a.parts.exp = FLOAT32_MAX_EXPONENT;
 …
+        }
         if ((exp1 == FLOAT64_MAX_EXPONENT ) || (exp2 > exp1)) {
+        if ((exp1 == FLOAT64_MAX_EXPONENT) || (exp2 > exp1)) {
                 /* overflow - set infinity as result */
                 a.parts.exp = FLOAT64_MAX_EXPONENT;
 …
         a.parts.exp = exp1;
         /* Clear hidden bit and shift */
         a.parts.fraction = ((frac1 >> 6 ) & (~FLOAT64_HIDDEN_BIT_MASK));
+        a.parts.fraction = ((frac1 >> 6) & (~FLOAT64_HIDDEN_BIT_MASK));
         return a;
+}

uspace/lib/softfloat/common.c

-              r32b3a12
+              rb800b0e
  */
 #include <sftypes.h>
 #include <common.h>
+#include "sftypes.h"
+#include "common.h"
 /* Table for fast leading zeroes counting. */
 …
 };
 /**
+/**
  * Take fraction shifted by 10 bits to the left, round it, normalize it
  * and detect exceptions
 …
         while ((cexp > 0) && (cfrac) &&
             (!(cfrac & (FLOAT64_HIDDEN_BIT_MASK << (64 - FLOAT64_FRACTION_SIZE - 1))))) {
                 cexp--;
+                cexp--;
                 cfrac <<= 1;
                 /* TODO: fix underflow */
 …
                 ++cexp;
                 cfrac >>= 1;
+        }
+        }
         /* check overflow */

uspace/lib/softfloat/common.h

r32b3a12	rb800b0e
37	37	#define __COMMON_H__
38	38
39		#include ~~<sftypes.h>~~
	39	#include "sftypes.h"
40	40
41	41	extern float64 finish_float64(int32_t, uint64_t, char);

uspace/lib/softfloat/comparison.c

-              r32b3a12
+              rb800b0e
  */
 #include <sftypes.h>
 #include <comparison.h>
 #include <common.h>
+#include "sftypes.h"
+#include "comparison.h"
+#include "common.h"
 /**

uspace/lib/softfloat/conversion.c

-              r32b3a12
+              rb800b0e
  */
 #include <sftypes.h>
 #include <conversion.h>
 #include <comparison.h>
 #include <common.h>
+#include "sftypes.h"
+#include "conversion.h"
+#include "comparison.h"
+#include "common.h"
 float64 float32_to_float64(float32 a)

uspace/lib/softfloat/div.c

-              r32b3a12
+              rb800b0e
  */
 #include <sftypes.h>
 #include <add.h>
 #include <div.h>
 #include <comparison.h>
 #include <mul.h>
 #include <common.h>
+#include "sftypes.h"
+#include "add.h"
+#include "div.h"
+#include "comparison.h"
+#include "mul.h"
+#include "common.h"
 /** Divide two single-precision floats.

uspace/lib/softfloat/mul.c

-              r32b3a12
+              rb800b0e
  */
 #include <sftypes.h>
 #include <mul.h>
 #include <comparison.h>
 #include <common.h>
+#include "sftypes.h"
+#include "mul.h"
+#include "comparison.h"
+#include "common.h"
 /** Multiply two single-precision floats.

uspace/lib/softfloat/softfloat.c

-              r32b3a12
+              rb800b0e
  */
+#include <softfloat.h>
+#include <sftypes.h>
+#include <add.h>
+#include <sub.h>
+#include <mul.h>
+#include <div.h>
+#include <conversion.h>
+#include <comparison.h>
+#include <other.h>
+#include "softfloat.h"
+#include "sftypes.h"
+#include "add.h"
+#include "sub.h"
+#include "mul.h"
+#include "div.h"
+#include "conversion.h"
+#include "comparison.h"
+#include "other.h"
 /* Arithmetic functions */
 …
+}
+int __aeabi_f2iz(float a)
+{
+        return __fixsfsi(a);
+}
 int __aeabi_d2iz(double a)
+{
 …
+{
         return __ltdf2(a, b);
+}
+int __aeabi_dcmpeq(double a, double b)
+{
+        return __eqdf2(a, b);
+}
+float __aeabi_fadd(float a, float b)
+{
+        return __addsf3(a, b);
+}
+float __aeabi_fsub(float a, float b)
+{
+        return __subsf3(a, b);
+}
+float __aeabi_fmul(float a, float b)
+{
+        return __mulsf3(a, b);
+}
+float __aeabi_fdiv(float a, float b)
+{
+        return __divsf3(a, b);
+}

uspace/lib/softfloat/softfloat.h

-              r32b3a12
+              rb800b0e
 extern double __aeabi_ui2d(unsigned int);
 extern unsigned int __aeabi_d2uiz(double);
+extern int __aeabi_f2iz(float);
 extern int __aeabi_d2iz(double);
 …
 extern int __aeabi_dcmpgt(double, double);
 extern int __aeabi_dcmplt(double, double);
+extern int __aeabi_dcmpeq(double, double);
+extern float __aeabi_fadd(float, float);
+extern float __aeabi_fsub(float, float);
+extern float __aeabi_fmul(float, float);
+extern float __aeabi_fdiv(float, float);
 extern double __aeabi_dadd(double, double);

uspace/lib/softfloat/sub.c

-              r32b3a12
+              rb800b0e
  */
 #include <sftypes.h>
 #include <sub.h>
 #include <comparison.h>
 #include <common.h>
+#include "sftypes.h"
+#include "sub.h"
+#include "comparison.h"
+#include "common.h"
 /** Subtract two single-precision floats with the same sign.

uspace/lib/usb/include/usb/debug.h

-              r32b3a12
+              rb800b0e
 #include <inttypes.h>
 #include <usb/usb.h>
+#include <io/log.h>
 #include <assert.h>
 …
     const uint8_t *, size_t);
+/** Logging level. */
+typedef enum {
+        /** Fatal, unrecoverable, error.
+         * Such error prevents the driver from working at all.
+         */
+        USB_LOG_LEVEL_FATAL,
+#define USB_LOG_LEVEL_FATAL LVL_FATAL
+#define USB_LOG_LEVEL_ERROR LVL_ERROR
+#define USB_LOG_LEVEL_WARNING LVL_WARN
+#define USB_LOG_LEVEL_INFO LVL_NOTE
+#define USB_LOG_LEVEL_DEBUG LVL_DEBUG
+#define USB_LOG_LEVEL_DEBUG2 LVL_DEBUG2
+        /** Serious but recoverable error
+         * Shall be used for errors fatal for single device but not for
+         * driver itself.
+         */
+        USB_LOG_LEVEL_ERROR,
+        /** Warning.
+         * Problems from which the driver is able to recover gracefully.
+         */
+        USB_LOG_LEVEL_WARNING,
+        /** Information message.
+         * This should be the last level that is printed by default to
+         * the screen.
+         * Typical usage is to inform that new device was found and what
+         * are its capabilities.
+         * Do not use for repetitive actions (such as device polling).
+         */
+        USB_LOG_LEVEL_INFO,
+        /** Debugging message. */
+        USB_LOG_LEVEL_DEBUG,
+        /** More detailed debugging message. */
+        USB_LOG_LEVEL_DEBUG2,
+        /** Terminating constant for logging levels. */
+        USB_LOG_LEVEL_MAX
+} usb_log_level_t;
+/** Default log level. */
+#ifdef CONFIG_USB_VERBOSE
+        #define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_DEBUG
+#else
+        #define USB_LOG_LEVEL_DEFAULT USB_LOG_LEVEL_INFO
+#endif
+void usb_log_enable(usb_log_level_t, const char *);
+void usb_log_printf(usb_log_level_t, const char *, ...)
+        PRINTF_ATTRIBUTE(2, 3);
+#define usb_log_printf(level, format, ...) \
+        log_msg(LOG_DEFAULT, level, format, ##__VA_ARGS__)
 /** Log fatal error. */

uspace/lib/usb/src/debug.c

-              r32b3a12
+              rb800b0e
 #include <ddf/log.h>
 #include <usb/debug.h>
-/** Level of logging messages. */
-static usb_log_level_t log_level = USB_LOG_LEVEL_WARNING;
-/** Prefix for logging messages. */
-static const char *log_prefix = "usb";
-/** Serialization mutex for logging functions. */
-static FIBRIL_MUTEX_INITIALIZE(log_serializer);
-/** File where to store the log. */
-static FILE *log_stream = NULL;
-/** Enable logging.
+ *
- * @param level Maximal enabled level (including this one).
- * @param message_prefix Prefix for each printed message.
- */
-void usb_log_enable(usb_log_level_t level, const char *message_prefix)
+{
-        log_prefix = message_prefix;
-        log_level = level;
-        if (log_stream == NULL) {
-                char *fname;
-                int rc = asprintf(&fname, "/log/%s", message_prefix);
-                if (rc > 0) {
-                        log_stream = fopen(fname, "w");
-                        if (log_stream != NULL)
-                                setvbuf(log_stream, NULL, _IOFBF, BUFSIZ);
-                        free(fname);
+                }
+        }
+}
-/** Get log level name prefix.
+ *
- * @param level Log level.
- * @return String prefix for the message.
- */
-static const char *log_level_name(usb_log_level_t level)
+{
-        switch (level) {
-                case USB_LOG_LEVEL_FATAL:
-                        return " FATAL";
-                case USB_LOG_LEVEL_ERROR:
-                        return " ERROR";
-                case USB_LOG_LEVEL_WARNING:
-                        return " WARN";
-                case USB_LOG_LEVEL_INFO:
-                        return " info";
-                default:
-                        return "";
+        }
+}
-/** Print logging message.
+ *
- * @param level Verbosity level of the message.
- * @param format Formatting directive.
- */
-void usb_log_printf(usb_log_level_t level, const char *format, ...)
+{
-        FILE *screen_stream = NULL;
-        switch (level) {
-                case USB_LOG_LEVEL_FATAL:
-                case USB_LOG_LEVEL_ERROR:
-                        screen_stream = stderr;
-                        break;
-                default:
-                        screen_stream = stdout;
-                        break;
+        }
-        assert(screen_stream != NULL);
-        va_list args;
-        /*
-         * Serialize access to log files.
-         * Print to screen only messages with higher level than the one
-         * specified during logging initialization.
-         * Print also to file, to it print one more (lower) level as well.
-         */
-        fibril_mutex_lock(&log_serializer);
-        const char *level_name = log_level_name(level);
-        if ((log_stream != NULL) && (level <= log_level + 1)) {
-                va_start(args, format);
-                fprintf(log_stream, "[%s]%s: ", log_prefix, level_name);
-                vfprintf(log_stream, format, args);
-                fflush(log_stream);
-                va_end(args);
+        }
-        if (level <= log_level) {
-                va_start(args, format);
-                fprintf(screen_stream, "[%s]%s: ", log_prefix, level_name);
-                vfprintf(screen_stream, format, args);
-                fflush(screen_stream);
-                va_end(args);
+        }
-        fibril_mutex_unlock(&log_serializer);
+}
 #define REMAINDER_STR_FMT " (%zu)..."

Context Navigation

Changeset b800b0e in mainline for uspace/lib

Legend:

Download in other formats: