diff --git a/src/kernel/core/khash.c b/src/kernel/core/khash.c
index c6a0b778d0..84d179f611 100644
--- a/src/kernel/core/khash.c
+++ b/src/kernel/core/khash.c
@@ -1,5 +1,5 @@
-/* Generic hash table. No real clue where hash_elem is defined...*/
-/*
+/* Generic hash table
+**
 ** Copyright 2001, Travis Geiselbrecht. All rights reserved.
 ** Distributed under the terms of the NewOS License.
 */
@@ -10,17 +10,21 @@
 #include <string.h>
 #include <khash.h>
 
+// ToDo: this file apparently contains two different hash implementations
+//		get rid of one of them, and update the external code.
+
+// ToDo: remove these
 #define malloc kmalloc
 #define free kfree
 
 struct hash_table {
 	struct hash_elem **table;
-	int next_ptr_offset;
-	unsigned int table_size;
-	int num_elems;
-	int flags;
-	int (*compare_func)(void *e, const void *key);
-	unsigned int (*hash_func)(void *e, const void *key, unsigned int range);
+	int				next_ptr_offset;
+	unsigned int	table_size;
+	int				num_elems;
+	int				flags;
+	int				(*compare_func)(void *e, const void *key);
+	unsigned int	(*hash_func)(void *e, const void *key, unsigned int range);
 };
 
 // XXX gross hack
@@ -28,7 +32,9 @@ struct hash_table {
 #define NEXT(t, e) ((void *)(*(unsigned long *)NEXT_ADDR(t, e)))
 #define PUT_IN_NEXT(t, e, val) (*(unsigned long *)NEXT_ADDR(t, e) = (long)(val))
 
-void *hash_init(unsigned int table_size, int next_ptr_offset,
+
+void *
+hash_init(unsigned int table_size, int next_ptr_offset,
 	int compare_func(void *e, const void *key),
 	unsigned int hash_func(void *e, const void *key, unsigned int range))
 {
@@ -36,12 +42,11 @@ void *hash_init(unsigned int table_size, int next_ptr_offset,
 	unsigned int i;
 
 	t = (struct hash_table *)malloc(sizeof(struct hash_table));
-	if(t == NULL) {
+	if (t == NULL)
 		return NULL;
-	}
 
 	t->table = (struct hash_elem **)malloc(sizeof(void *) * table_size);
-	for(i = 0; i<table_size; i++)
+	for (i = 0; i<table_size; i++)
 		t->table[i] = NULL;
 	t->table_size = table_size;
 	t->next_ptr_offset = next_ptr_offset;
@@ -56,7 +61,9 @@ void *hash_init(unsigned int table_size, int next_ptr_offset,
 	return t;
 }
 
-int hash_uninit(void *_hash_table)
+
+int
+hash_uninit(void *_hash_table)
 {
 	struct hash_table *t = (struct hash_table *)_hash_table;
 
@@ -72,7 +79,9 @@ int hash_uninit(void *_hash_table)
 	return 0;
 }
 
-int hash_insert(void *_hash_table, void *e)
+
+int
+hash_insert(void *_hash_table, void *e)
 {
 	struct hash_table *t = (struct hash_table *)_hash_table;
 	unsigned int hash;
@@ -87,6 +96,7 @@ int hash_insert(void *_hash_table, void *e)
 	return 0;
 }
 
+
 int hash_remove(void *_hash_table, void *e)
 {
 	struct hash_table *t = (struct hash_table *)_hash_table;
@@ -95,9 +105,9 @@ int hash_remove(void *_hash_table, void *e)
 
 	hash = t->hash_func(e, NULL, t->table_size);
 	last_i = NULL;
-	for(i = t->table[hash]; i != NULL; last_i = i, i = NEXT(t, i)) {
-		if(i == e) {
-			if(last_i != NULL)
+	for (i = t->table[hash]; i != NULL; last_i = i, i = NEXT(t, i)) {
+		if (i == e) {
+			if (last_i != NULL)
 				PUT_IN_NEXT(t, last_i, NEXT(t, i));
 			else
 				t->table[hash] = (struct hash_elem *)NEXT(t, i);
@@ -109,48 +119,52 @@ int hash_remove(void *_hash_table, void *e)
 	return B_ERROR;
 }
 
-void *hash_find(void *_hash_table, void *e)
+
+void *
+hash_find(void *_hash_table, void *e)
 {
 	struct hash_table *t = (struct hash_table *)_hash_table;
 	void *i;
 	unsigned int hash;
 
 	hash = t->hash_func(e, NULL, t->table_size);
-	for(i = t->table[hash]; i != NULL; i = NEXT(t, i)) {
-		if(i == e) {
+	for (i = t->table[hash]; i != NULL; i = NEXT(t, i)) {
+		if (i == e)
 			return i;
-		}
 	}
 
 	return NULL;
 }
 
-void *hash_lookup(void *_hash_table, const void *key)
+
+void *
+hash_lookup(void *_hash_table, const void *key)
 {
 	struct hash_table *t = (struct hash_table *)_hash_table;
 	void *i;
 	unsigned int hash;
 
-	if(t->compare_func == NULL)
+	if (t->compare_func == NULL)
 		return NULL;
 
 	hash = t->hash_func(NULL, key, t->table_size);
-	for(i = t->table[hash]; i != NULL; i = NEXT(t, i)) {
-		if(t->compare_func(i, key) == 0) {
+	for (i = t->table[hash]; i != NULL; i = NEXT(t, i)) {
+		if (t->compare_func(i, key) == 0)
 			return i;
-		}
 	}
 
 	return NULL;
 }
 
-struct hash_iterator *hash_open(void *_hash_table, struct hash_iterator *i)
+
+struct hash_iterator *
+hash_open(void *_hash_table, struct hash_iterator *i)
 {
 	struct hash_table *t = (struct hash_table *)_hash_table;
 
-	if(i == NULL) {
+	if (i == NULL) {
 		i = (struct hash_iterator *)malloc(sizeof(struct hash_iterator));
-		if(i == NULL)
+		if (i == NULL)
 			return NULL;
 	}
 
@@ -159,27 +173,33 @@ struct hash_iterator *hash_open(void *_hash_table, struct hash_iterator *i)
 	return i;
 }
 
-void hash_close(void *_hash_table, struct hash_iterator *i, bool free_iterator)
+
+void
+hash_close(void *_hash_table, struct hash_iterator *i, bool freeIterator)
 {
-	if(free_iterator)
+	if (freeIterator)
 		free(i);
 }
 
-void hash_rewind(void *_hash_table, struct hash_iterator *i)
+
+void
+hash_rewind(void *_hash_table, struct hash_iterator *i)
 {
 	i->ptr = NULL;
 	i->bucket = -1;
 }
 
-void *hash_next(void *_hash_table, struct hash_iterator *i)
+
+void *
+hash_next(void *_hash_table, struct hash_iterator *i)
 {
 	struct hash_table *t = (struct hash_table *)_hash_table;
 	unsigned int index;
 
 restart:
-	if(!i->ptr) {
-		for(index = (unsigned int)(i->bucket + 1); index < t->table_size; index++) {
-			if(t->table[index]) {
+	if (!i->ptr) {
+		for (index = (unsigned int)(i->bucket + 1); index < t->table_size; index++) {
+			if (t->table[index]) {
 				i->bucket = index;
 				i->ptr = t->table[index];
 				break;
@@ -187,25 +207,27 @@ restart:
 		}
 	} else {
 		i->ptr = NEXT(t, i->ptr);
-		if(!i->ptr)
+		if (!i->ptr)
 			goto restart;
 	}
 
 	return i->ptr;
 }
 
-unsigned int hash_hash_str( const char *str )
+
+unsigned int
+hash_hash_str( const char *str )
 {
 	char ch;
 	unsigned int hash = 0;
-	
+
 	// we assume hash to be at least 32 bits
-	while( (ch = *str++) != 0 ) {
+	while ((ch = *str++) != 0) {
 		hash ^= hash >> 28;
 		hash <<= 4;
 		hash ^= ch;
 	}
-	
+
 	return hash;
 }
 
@@ -221,12 +243,13 @@ static void nhash_this(hash_table_index *hi, const void **key, ssize_t *klen,
 }
 */
 
-new_hash_table *hash_make(void)
+
+new_hash_table *
+hash_make(void)
 {
 	new_hash_table *nn;
-	
-	 nn = (new_hash_table *)kmalloc(sizeof(new_hash_table));
 
+	nn = (new_hash_table *)kmalloc(sizeof(new_hash_table));
 	if (!nn)
 		return NULL;
 
@@ -241,7 +264,9 @@ new_hash_table *hash_make(void)
 	return nn;
 }
 
-static hash_index *new_hash_next(hash_index *hi)
+
+static hash_index *
+new_hash_next(hash_index *hi)
 {
 	hi->this_idx = hi->next;
 	while (!hi->this_idx) {
@@ -253,7 +278,9 @@ static hash_index *new_hash_next(hash_index *hi)
 	return hi;
 }
 
-static hash_index *new_hash_first(new_hash_table *nh)
+
+static hash_index *
+new_hash_first(new_hash_table *nh)
 {
         hash_index *hi = &nh->iterator;
         hi->nh = nh;
@@ -262,7 +289,9 @@ static hash_index *new_hash_first(new_hash_table *nh)
         return new_hash_next(hi);
 }
 
-static void expand_array(new_hash_table *nh)
+
+static void
+expand_array(new_hash_table *nh)
 {
 	hash_index *hi;
 	hash_entry **new_array;
@@ -282,8 +311,8 @@ static void expand_array(new_hash_table *nh)
 }
 
 
-static hash_entry **find_entry(new_hash_table *nh, const void *key,
-                               ssize_t klen, const void *val)
+static hash_entry **
+find_entry(new_hash_table *nh, const void *key, ssize_t klen, const void *val)
 {
 	hash_entry **hep;
 	hash_entry *he;
@@ -294,11 +323,10 @@ static hash_entry **find_entry(new_hash_table *nh, const void *key,
 	if (!nh)
 		return NULL;
 
-	for (p=key, i=klen; i; i--, p++) 
+	for (p = key, i = klen; i; i--, p++) 
 		hash = hash * 33 + *p;
 
-	for (hep = &nh->array[hash & nh->max], he = *hep; he; 
-				hep = &he->next, he = *hep) {
+	for (hep = &nh->array[hash & nh->max], he = *hep; he; hep = &he->next, he = *hep) {
 		if (he->hash == hash && he->klen == klen
 			&& memcmp(he->key, key, klen) == 0) {
 				break;
@@ -320,17 +348,21 @@ static hash_entry **find_entry(new_hash_table *nh, const void *key,
 	return hep;
 }
 
-void *hash_get(new_hash_table *nh, const void *key, ssize_t klen)
+
+void *
+hash_get(new_hash_table *nh, const void *key, ssize_t klen)
 {
 	hash_entry *he;
 	he = *find_entry(nh, key, klen, NULL);
 	if (he)
 		return (void*)he->val;
-	else
-		return NULL;
+
+	return NULL;
 }
 
-void hash_set(new_hash_table *nh, const void *key, ssize_t klen, const void *val)
+
+void
+hash_set(new_hash_table *nh, const void *key, ssize_t klen, const void *val)
 {
 	hash_entry **hep;
 	hash_entry *old;