Index: common/adt/hash_table.c
===================================================================
--- common/adt/hash_table.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ common/adt/hash_table.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -247,15 +247,10 @@
 	assert(h && h->bucket);
 
-	size_t idx = h->op->key_hash(key) % h->bucket_cnt;
+	size_t hash = h->op->key_hash(key);
+	size_t idx = hash % h->bucket_cnt;
 
 	list_foreach(h->bucket[idx], link, ht_link_t, cur_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)) {
+		if (h->op->key_equal(key, hash, cur_link))
 			return cur_link;
-		}
 	}
 
@@ -265,5 +260,5 @@
 /** Find the next item equal to item. */
 ht_link_t *
-hash_table_find_next(const hash_table_t *h, ht_link_t *first, ht_link_t *item)
+hash_table_find_next(const hash_table_t *h, ht_link_t *item)
 {
 	assert(item);
@@ -271,22 +266,13 @@
 
 	size_t idx = h->op->hash(item) % h->bucket_cnt;
-
-	/* Traverse the circular list until we reach the starting item again. */
-	for (link_t *cur = item->link.next; cur != &first->link;
-	    cur = cur->next) {
-		assert(cur);
-
-		if (cur == &h->bucket[idx].head)
-			continue;
-
+	list_t *list = &h->bucket[idx];
+	link_t *cur = list_next(&item->link, list);
+
+	/* Traverse the list until we reach its end. */
+	for (; cur != NULL; cur = list_next(cur, list)) {
 		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)) {
+
+		if (h->op->equal(cur_link, item))
 			return cur_link;
-		}
 	}
 
@@ -309,5 +295,6 @@
 	assert(!h->apply_ongoing);
 
-	size_t idx = h->op->key_hash(key) % h->bucket_cnt;
+	size_t hash = h->op->key_hash(key);
+	size_t idx = hash % h->bucket_cnt;
 
 	size_t removed = 0;
@@ -316,5 +303,5 @@
 		ht_link_t *cur_link = member_to_inst(cur, ht_link_t, link);
 
-		if (h->op->key_equal(key, cur_link)) {
+		if (h->op->key_equal(key, hash, cur_link)) {
 			++removed;
 			list_remove(cur);
Index: common/include/adt/hash.h
===================================================================
--- common/include/adt/hash.h	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ common/include/adt/hash.h	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -108,3 +108,40 @@
 }
 
+/** Hash a NUL-terminated string.
+ * The algorithm may change in the future, so never use it for hashes
+ * that will be stored to a file or sent over a network.
+ */
+static inline size_t hash_string(const char *str)
+{
+	/* djb2 hash + extra mixing at the end */
+
+	char c;
+	size_t hash = 5381;
+
+	while ((c = *(str++)))
+		hash = (hash << 5) + hash + c;
+
+	return hash_mix(hash);
+}
+
+/** Hash an arbitrarily sized sequence of bytes.
+ * The algorithm may change in the future, so never use it for hashes
+ * that will be stored to a file or sent over a network.
+ */
+static inline size_t hash_bytes(const void *b, size_t len)
+{
+	/* djb2 hash + extra mixing at the end */
+
+	// TODO: work in bigger chunks for faster hashing
+
+	const char *str = b;
+
+	size_t hash = 5381;
+
+	for (size_t i = 0; i < len; i++)
+		hash = (hash << 5) + hash + str[i];
+
+	return hash_mix(hash);
+}
+
 #endif
Index: common/include/adt/hash_table.h
===================================================================
--- common/include/adt/hash_table.h	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ common/include/adt/hash_table.h	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -60,5 +60,5 @@
 
 	/** Returns true if the key is equal to the item's lookup key. */
-	bool (*key_equal)(const void *key, const ht_link_t *item);
+	bool (*key_equal)(const void *key, size_t hash, const ht_link_t *item);
 
 	/** Hash table item removal callback.
@@ -85,4 +85,11 @@
 	member_to_inst((item), type, member)
 
+#define hash_table_foreach(ht, key, member, itype, iterator) \
+	for (itype *iterator = NULL; \
+	    iterator == NULL; iterator = (itype *) INTPTR_MAX) \
+		for (ht_link_t *__link = hash_table_find((ht), (key)); \
+		    __link != NULL && ((iterator = member_to_inst(__link, itype, member))); \
+			__link = hash_table_find_next((ht), __link))
+
 extern bool hash_table_create(hash_table_t *, size_t, size_t,
     const hash_table_ops_t *);
@@ -96,6 +103,5 @@
 extern bool hash_table_insert_unique(hash_table_t *, ht_link_t *);
 extern ht_link_t *hash_table_find(const hash_table_t *, const void *);
-extern ht_link_t *hash_table_find_next(const hash_table_t *, ht_link_t *,
-    ht_link_t *);
+extern ht_link_t *hash_table_find_next(const hash_table_t *, ht_link_t *);
 extern size_t hash_table_remove(hash_table_t *, const void *);
 extern void hash_table_remove_item(hash_table_t *, ht_link_t *);
Index: kernel/genarch/src/mm/page_ht.c
===================================================================
--- kernel/genarch/src/mm/page_ht.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ kernel/genarch/src/mm/page_ht.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -55,5 +55,5 @@
 static size_t ht_hash(const ht_link_t *);
 static size_t ht_key_hash(const void *);
-static bool ht_key_equal(const void *, const ht_link_t *);
+static bool ht_key_equal(const void *, size_t, const ht_link_t *);
 static void ht_remove_callback(ht_link_t *);
 
@@ -119,5 +119,5 @@
 
 /** Return true if the key is equal to the item's lookup key. */
-bool ht_key_equal(const void *arg, const ht_link_t *item)
+bool ht_key_equal(const void *arg, size_t hash, const ht_link_t *item)
 {
 	const uintptr_t *key = arg;
Index: kernel/generic/src/cap/cap.c
===================================================================
--- kernel/generic/src/cap/cap.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ kernel/generic/src/cap/cap.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -118,5 +118,5 @@
 }
 
-static bool caps_key_equal(const void *key, const ht_link_t *item)
+static bool caps_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const cap_handle_t *handle = key;
Index: kernel/generic/src/ddi/irq.c
===================================================================
--- kernel/generic/src/ddi/irq.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ kernel/generic/src/ddi/irq.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -75,5 +75,5 @@
 static size_t irq_ht_key_hash(const void *);
 static bool irq_ht_equal(const ht_link_t *, const ht_link_t *);
-static bool irq_ht_key_equal(const void *, const ht_link_t *);
+static bool irq_ht_key_equal(const void *, size_t, const ht_link_t *);
 
 static const hash_table_ops_t irq_ht_ops = {
@@ -141,8 +141,6 @@
 {
 	irq_spinlock_lock(l, false);
-	ht_link_t *first = hash_table_find(h, &inr);
-	for (ht_link_t *lnk = first; lnk;
-	    lnk = hash_table_find_next(h, first, lnk)) {
-		irq_t *irq = hash_table_get_inst(lnk, irq_t, link);
+
+	hash_table_foreach(h, &inr, link, irq_t, irq) {
 		irq_spinlock_lock(&irq->lock, false);
 		if (irq->claim(irq) == IRQ_ACCEPT) {
@@ -153,4 +151,5 @@
 		irq_spinlock_unlock(&irq->lock, false);
 	}
+
 	irq_spinlock_unlock(l, false);
 
@@ -223,5 +222,5 @@
 
 /** Return true if the key is equal to the item's lookup key. */
-bool irq_ht_key_equal(const void *key, const ht_link_t *item)
+bool irq_ht_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const inr_t *inr = key;
Index: kernel/generic/src/lib/ra.c
===================================================================
--- kernel/generic/src/lib/ra.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ kernel/generic/src/lib/ra.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -74,5 +74,5 @@
 
 /** Return true if the key is equal to the item's lookup key */
-static bool used_key_equal(const void *key, const ht_link_t *item)
+static bool used_key_equal(const void *key, size_t, const ht_link_t *item)
 {
 	const uintptr_t *base = key;
Index: uspace/app/hbench/env.c
===================================================================
--- uspace/app/hbench/env.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/app/hbench/env.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -34,4 +34,5 @@
  */
 
+#include <adt/hash.h>
 #include <stdlib.h>
 #include <stdio.h>
@@ -42,4 +43,5 @@
 	ht_link_t link;
 
+	size_t hash;
 	char *key;
 	char *value;
@@ -49,18 +51,20 @@
 {
 	param_t *param = hash_table_get_inst(item, param_t, link);
-	return str_size(param->key);
+	return param->hash;
 }
 
 static size_t param_key_hash(const void *key)
 {
-	const char *key_str = key;
-	return str_size(key_str);
+	return hash_string(key);
 }
 
-static bool param_key_equal(const void *key, const ht_link_t *item)
+static bool param_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	param_t *param = hash_table_get_inst(item, param_t, link);
+
+	if (param->hash != hash)
+		return false;
+
 	const char *key_str = key;
-
 	return str_cmp(param->key, key_str) == 0;
 }
@@ -71,5 +75,5 @@
 	param_t *b = hash_table_get_inst(link_b, param_t, link);
 
-	return str_cmp(a->key, b->key) == 0;
+	return a->hash == b->hash && str_cmp(a->key, b->key) == 0;
 }
 
@@ -116,4 +120,5 @@
 	param->key = str_dup(key);
 	param->value = str_dup(value);
+	param->hash = hash_string(key);
 
 	if ((param->key == NULL) || (param->value == NULL)) {
@@ -132,5 +137,5 @@
 const char *bench_env_param_get(bench_env_t *env, const char *key, const char *default_value)
 {
-	ht_link_t *item = hash_table_find(&env->parameters, (char *) key);
+	ht_link_t *item = hash_table_find(&env->parameters, key);
 
 	if (item == NULL) {
Index: uspace/app/trace/ipcp.c
===================================================================
--- uspace/app/trace/ipcp.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/app/trace/ipcp.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -84,5 +84,5 @@
 }
 
-static bool pending_call_key_equal(const void *key, const ht_link_t *item)
+static bool pending_call_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const cap_call_handle_t *chandle = key;
Index: uspace/app/trace/proto.c
===================================================================
--- uspace/app/trace/proto.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/app/trace/proto.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -69,5 +69,5 @@
 }
 
-static bool srv_proto_key_equal(const void *key, const ht_link_t *item)
+static bool srv_proto_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const int *n = key;
@@ -96,5 +96,5 @@
 }
 
-static bool method_oper_key_equal(const void *key, const ht_link_t *item)
+static bool method_oper_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const int *n = key;
Index: uspace/lib/block/block.c
===================================================================
--- uspace/lib/block/block.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/lib/block/block.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -254,5 +254,5 @@
 }
 
-static bool cache_key_equal(const void *key, const ht_link_t *item)
+static bool cache_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const aoff64_t *lba = key;
Index: uspace/lib/c/generic/async/ports.c
===================================================================
--- uspace/lib/c/generic/async/ports.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/lib/c/generic/async/ports.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -50,5 +50,4 @@
 #include <as.h>
 #include <abi/mm/as.h>
-#include "../private/libc.h"
 #include "../private/fibril.h"
 
@@ -115,5 +114,5 @@
 }
 
-static bool interface_key_equal(const void *key, const ht_link_t *item)
+static bool interface_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const iface_t *iface = key;
@@ -143,5 +142,5 @@
 }
 
-static bool port_key_equal(const void *key, const ht_link_t *item)
+static bool port_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const port_id_t *port_id = key;
Index: uspace/lib/c/generic/async/server.c
===================================================================
--- uspace/lib/c/generic/async/server.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/lib/c/generic/async/server.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -242,5 +242,5 @@
 }
 
-static bool client_key_equal(const void *key, const ht_link_t *item)
+static bool client_key_equal(const void *key, size_t, const ht_link_t *item)
 {
 	const task_id_t *in_task_id = key;
@@ -502,5 +502,5 @@
 }
 
-static bool notification_key_equal(const void *key, const ht_link_t *item)
+static bool notification_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const sysarg_t *id = key;
Index: uspace/lib/ext4/src/ops.c
===================================================================
--- uspace/lib/ext4/src/ops.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/lib/ext4/src/ops.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -113,5 +113,5 @@
 }
 
-static bool open_nodes_key_equal(const void *key_arg, const ht_link_t *item)
+static bool open_nodes_key_equal(const void *key_arg, size_t hash, const ht_link_t *item)
 {
 	const node_key_t *key = key_arg;
Index: uspace/lib/nic/src/nic_addr_db.c
===================================================================
--- uspace/lib/nic/src/nic_addr_db.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/lib/nic/src/nic_addr_db.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -52,6 +52,7 @@
 typedef struct nic_addr_entry {
 	ht_link_t link;
+	size_t hash;
 	uint8_t len;
-	uint8_t addr[1];
+	uint8_t addr[];
 } nic_addr_entry_t;
 
@@ -60,14 +61,14 @@
  */
 typedef struct {
+	size_t hash;
 	size_t len;
 	const uint8_t *addr;
 } addr_key_t;
 
-static bool nic_addr_key_equal(const void *key_arg, const ht_link_t *item)
+static bool nic_addr_key_equal(const void *key_arg, size_t hash, const ht_link_t *item)
 {
 	const addr_key_t *key = key_arg;
 	nic_addr_entry_t *entry = member_to_inst(item, nic_addr_entry_t, link);
-
-	return memcmp(entry->addr, key->addr, entry->len) == 0;
+	return entry->hash == hash && memcmp(entry->addr, key->addr, entry->len) == 0;
 }
 
@@ -86,5 +87,5 @@
 {
 	const addr_key_t *key = k;
-	return addr_hash(key->len, key->addr);
+	return key->hash ? key->hash : addr_hash(key->len, key->addr);
 }
 
@@ -92,5 +93,5 @@
 {
 	nic_addr_entry_t *entry = member_to_inst(item, nic_addr_entry_t, link);
-	return addr_hash(entry->len, entry->addr);
+	return entry->hash;
 }
 
@@ -98,5 +99,4 @@
 {
 	nic_addr_entry_t *entry = member_to_inst(item, nic_addr_entry_t, link);
-
 	free(entry);
 }
@@ -173,5 +173,6 @@
 	addr_key_t key = {
 		.len = db->addr_len,
-		.addr = addr
+		.addr = addr,
+		.hash = addr_hash(db->addr_len, addr),
 	};
 
@@ -179,5 +180,5 @@
 		return EEXIST;
 
-	nic_addr_entry_t *entry = malloc(sizeof(nic_addr_entry_t) + db->addr_len - 1);
+	nic_addr_entry_t *entry = malloc(offsetof(nic_addr_entry_t, addr) + db->addr_len);
 	if (entry == NULL)
 		return ENOMEM;
@@ -185,4 +186,5 @@
 	entry->len = (uint8_t) db->addr_len;
 	memcpy(entry->addr, addr, db->addr_len);
+	entry->hash = key.hash;
 
 	hash_table_insert(&db->set, &entry->link);
Index: uspace/lib/nic/src/nic_wol_virtues.c
===================================================================
--- uspace/lib/nic/src/nic_wol_virtues.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/lib/nic/src/nic_wol_virtues.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -57,5 +57,5 @@
 }
 
-static bool nic_wv_key_equal(const void *key, const ht_link_t *item)
+static bool nic_wv_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const nic_wv_id_t *k = key;
Index: uspace/srv/devman/devtree.c
===================================================================
--- uspace/srv/devman/devtree.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/devman/devtree.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -32,5 +32,4 @@
  */
 
-#include <errno.h>
 #include <io/log.h>
 
@@ -61,5 +60,5 @@
 }
 
-static bool devman_devices_key_equal(const void *key, const ht_link_t *item)
+static bool devman_devices_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const devman_handle_t *handle = key;
@@ -68,5 +67,5 @@
 }
 
-static bool devman_functions_key_equal(const void *key, const ht_link_t *item)
+static bool devman_functions_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const devman_handle_t *handle = key;
@@ -87,5 +86,5 @@
 }
 
-static bool loc_functions_key_equal(const void *key, const ht_link_t *item)
+static bool loc_functions_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const service_id_t *service_id = key;
Index: uspace/srv/fs/cdfs/cdfs_ops.c
===================================================================
--- uspace/srv/fs/cdfs/cdfs_ops.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/fs/cdfs/cdfs_ops.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -298,5 +298,5 @@
 }
 
-static bool nodes_key_equal(const void *k, const ht_link_t *item)
+static bool nodes_key_equal(const void *k, size_t hash, const ht_link_t *item)
 {
 	cdfs_node_t *node = hash_table_get_inst(item, cdfs_node_t, nh_link);
Index: uspace/srv/fs/exfat/exfat_idx.c
===================================================================
--- uspace/srv/fs/exfat/exfat_idx.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/fs/exfat/exfat_idx.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -37,5 +37,4 @@
 
 #include "exfat.h"
-#include "../../vfs/vfs.h"
 #include <errno.h>
 #include <str.h>
@@ -139,5 +138,5 @@
 }
 
-static bool pos_key_equal(const void *key, const ht_link_t *item)
+static bool pos_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const pos_key_t *pos = key;
@@ -180,5 +179,6 @@
 }
 
-static bool idx_key_equal(const void *key_arg, const ht_link_t *item)
+static bool idx_key_equal(const void *key_arg, size_t hash,
+    const ht_link_t *item)
 {
 	exfat_idx_t *fidx = hash_table_get_inst(item, exfat_idx_t, uih_link);
Index: uspace/srv/fs/fat/fat_idx.c
===================================================================
--- uspace/srv/fs/fat/fat_idx.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/fs/fat/fat_idx.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -37,5 +37,4 @@
 
 #include "fat.h"
-#include "../../vfs/vfs.h"
 #include <errno.h>
 #include <str.h>
@@ -139,5 +138,5 @@
 }
 
-static bool pos_key_equal(const void *key, const ht_link_t *item)
+static bool pos_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const pos_key_t *pos = key;
@@ -180,5 +179,6 @@
 }
 
-static bool idx_key_equal(const void *key_arg, const ht_link_t *item)
+static bool idx_key_equal(const void *key_arg, size_t hash,
+    const ht_link_t *item)
 {
 	fat_idx_t *fidx = hash_table_get_inst(item, fat_idx_t, uih_link);
Index: uspace/srv/fs/locfs/locfs_ops.c
===================================================================
--- uspace/srv/fs/locfs/locfs_ops.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/fs/locfs/locfs_ops.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -83,5 +83,6 @@
 }
 
-static bool services_key_equal(const void *key, const ht_link_t *item)
+static bool services_key_equal(const void *key, size_t hash,
+    const ht_link_t *item)
 {
 	const service_id_t *k = key;
Index: uspace/srv/fs/mfs/mfs_ops.c
===================================================================
--- uspace/srv/fs/mfs/mfs_ops.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/fs/mfs/mfs_ops.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -115,5 +115,5 @@
 
 static bool
-open_nodes_key_equal(const void *key, const ht_link_t *item)
+open_nodes_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const node_key_t *node_key = key;
Index: uspace/srv/fs/tmpfs/tmpfs_ops.c
===================================================================
--- uspace/srv/fs/tmpfs/tmpfs_ops.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/fs/tmpfs/tmpfs_ops.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -38,5 +38,4 @@
 
 #include "tmpfs.h"
-#include "../../vfs/vfs.h"
 #include <macros.h>
 #include <stdint.h>
@@ -159,5 +158,6 @@
 }
 
-static bool nodes_key_equal(const void *key_arg, const ht_link_t *item)
+static bool nodes_key_equal(const void *key_arg, size_t hash,
+    const ht_link_t *item)
 {
 	tmpfs_node_t *node = hash_table_get_inst(item, tmpfs_node_t, nh_link);
Index: uspace/srv/fs/udf/udf_idx.c
===================================================================
--- uspace/srv/fs/udf/udf_idx.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/fs/udf/udf_idx.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -35,5 +35,4 @@
  */
 
-#include "../../vfs/vfs.h"
 #include <errno.h>
 #include <str.h>
@@ -69,5 +68,5 @@
 }
 
-static bool udf_idx_key_equal(const void *k, const ht_link_t *item)
+static bool udf_idx_key_equal(const void *k, size_t hash, const ht_link_t *item)
 {
 	const udf_ht_key_t *key = k;
Index: uspace/srv/hid/input/gsp.c
===================================================================
--- uspace/srv/hid/input/gsp.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/hid/input/gsp.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -76,5 +76,5 @@
 }
 
-static bool trans_key_equal(const void *key, const ht_link_t *item)
+static bool trans_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const trans_key_t *trans_key = key;
Index: uspace/srv/ns/service.c
===================================================================
--- uspace/srv/ns/service.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/ns/service.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -79,5 +79,6 @@
 }
 
-static bool service_key_equal(const void *key, const ht_link_t *item)
+static bool service_key_equal(const void *key, size_t hash,
+    const ht_link_t *item)
 {
 	const service_t *srv = key;
@@ -102,5 +103,5 @@
 }
 
-static bool iface_key_equal(const void *key, const ht_link_t *item)
+static bool iface_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const iface_t *kiface = key;
Index: uspace/srv/ns/task.c
===================================================================
--- uspace/srv/ns/task.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/ns/task.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -66,5 +66,5 @@
 }
 
-static bool task_key_equal(const void *key, const ht_link_t *item)
+static bool task_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const task_id_t *tid = key;
@@ -111,5 +111,5 @@
 }
 
-static bool p2i_key_equal(const void *key, const ht_link_t *item)
+static bool p2i_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const sysarg_t *label = key;
Index: uspace/srv/vfs/vfs_node.c
===================================================================
--- uspace/srv/vfs/vfs_node.c	(revision 8f8818ace0c872218dd0662d192937ee82aa966f)
+++ uspace/srv/vfs/vfs_node.c	(revision 0db0df2acaf79a846301b8337ca8d67aee9c1f18)
@@ -62,5 +62,5 @@
 static size_t nodes_key_hash(const void *);
 static size_t nodes_hash(const ht_link_t *);
-static bool nodes_key_equal(const void *, const ht_link_t *);
+static bool nodes_key_equal(const void *, size_t, const ht_link_t *);
 static vfs_triplet_t node_triplet(vfs_node_t *node);
 
@@ -294,5 +294,5 @@
 }
 
-static bool nodes_key_equal(const void *key, const ht_link_t *item)
+static bool nodes_key_equal(const void *key, size_t hash, const ht_link_t *item)
 {
 	const vfs_triplet_t *tri = key;