o generic hash table to store void *'s, not efficient, but adequate for LVM.

lib/datastruct/hash.c

@@ -0,0 +1,186 @@
+/*
+ * tools/lib/datastruct/hash.h
+ *
+ * Copyright (C) 2001 Sistina Software
+ *
+ * This file is released under the GPL.
+ */
+
+
+#include "hash.h"
+#include "dbg_malloc.h"
+#include "log.h"
+
+struct hash_node {
+	struct hash_node *next;
+	void *data;
+	char key[1];
+};
+
+struct hash_table {
+	int num_nodes;
+	int num_slots;
+	struct hash_node **slots;
+};
+
+/* Permutation of the Integers 0 through 255 */
+static unsigned char _nums[] = {
+	1, 14,110, 25, 97,174,132,119,138,170,125,118, 27,233,140, 51,
+	87,197,177,107,234,169, 56, 68, 30,  7,173, 73,188, 40, 36, 65,
+	49,213,104,190, 57,211,148,223, 48,115, 15,  2, 67,186,210, 28,
+	12,181,103, 70, 22, 58, 75, 78,183,167,238,157,124,147,172,144,
+	176,161,141, 86, 60, 66,128, 83,156,241, 79, 46,168,198, 41,254,
+	178, 85,253,237,250,154,133, 88, 35,206, 95,116,252,192, 54,221,
+	102,218,255,240, 82,106,158,201, 61,  3, 89,  9, 42,155,159, 93,
+	166, 80, 50, 34,175,195,100, 99, 26,150, 16,145,  4, 33,  8,189,
+	121, 64, 77, 72,208,245,130,122,143, 55,105,134, 29,164,185,194,
+	193,239,101,242,  5,171,126, 11, 74, 59,137,228,108,191,232,139,
+	6, 24, 81, 20,127, 17, 91, 92,251,151,225,207, 21, 98,113,112,
+	84,226, 18,214,199,187, 13, 32, 94,220,224,212,247,204,196, 43,
+	249,236, 45,244,111,182,153,136,129, 90,217,202, 19,165,231, 71,
+	230,142, 96,227, 62,179,246,114,162, 53,160,215,205,180, 47,109,
+	44, 38, 31,149,135,  0,216, 52, 63, 23, 37, 69, 39,117,146,184,
+	163,200,222,235,248,243,219, 10,152,131,123,229,203, 76,120,209
+};
+
+static struct hash_node *_create_node(const char *str)
+{
+	/* remember sizeof(n) includes an extra char from key[1],
+	   so not adding 1 to the strlen as you would expect */
+	struct hash_node *n = dbg_malloc(sizeof(*n) + strlen(str));
+
+	if (n)
+		strcpy(n->key, str);
+
+	return n;
+}
+
+static unsigned _hash(const char *str)
+{
+	unsigned long int h = 0, g;
+	while (*str) {
+		h <<= 4;
+		h += _nums[(int) *str++];
+		g = h & ((unsigned long) 0xf << 16u);
+		if (g) {
+			h ^= g >> 16u;
+			h ^= g >> 5u;
+		}
+	}
+	return h;
+}
+
+hash_table_t create_hash_table(unsigned size_hint)
+{
+	size_t len;
+	unsigned new_size = 16u;
+	struct hash_c *hc = dbg_malloc(sizeof(*hc));
+
+	if (!hc) {
+		stack;
+		return 0;
+	}
+
+	memset(hc, 0, sizeof(*hc));
+
+	/* round size hint up to a power of two */
+	while (new_size < size_hint)
+		new_size  = new_size << 1;
+
+	hc->num_slots = new_size;
+	len = sizeof(*(hc->slots)) * new_size;
+	if (!(hc->slots = dbg_malloc(len))) {
+		stack;
+		goto bad;
+	}
+	memset(hc->slots, 0, len);
+	return (hash_table_t) hc;
+
+ bad:
+	dbg_free(hc->slots);
+	dbg_free(hc);
+	return 0;
+}
+
+void destroy_hash_table(struct hash_table *t)
+{
+	struct hash_node **c, *n;
+	int i;
+
+	for (i = 0; i < t->num_slots; i++)
+		for (c = t->slots[i]; c; c = n) {
+			n = c->next;
+			dbg_free(c);
+		}
+
+	dbg_free(hc->slots);
+	dbg_free(hc);
+}
+
+static inline struct hash_node **_find(struct hash_table *t, const char *key)
+{
+	unsigned h = _hash(key) & (t->num_slots - 1);
+	struct hash_node **c;
+
+	for(c = &t->slots[h]; *c; c = &((*c)->next))
+		if(!strcmp(key, *c->key))
+			break;
+
+	return c
+}
+
+char *hash_lookup(struct hash_table *t, const char *key)
+{
+	struct hash_node **c = _find(t, key);
+	return *c ? (*c)->data : 0;
+}
+
+int hash_insert(struct hash_table *t, const char *key, void *data)
+{
+	struct hash_node **c = _find(t, key);
+
+	if(*c)
+		(*c)->data = data;
+	else {
+		struct hash_node *n = _create_node(key);
+
+		if (!n)
+			return 0;
+
+		n->data = data;
+		n->next = 0;
+		*c = n;
+		t->num_nodes++;
+	}
+
+	return 1;
+}
+
+void hash_remove(struct hash_table *t, const char *key)
+{
+	struct hash_node **c = _find(t, key);
+
+	if (*c) {
+		struct hash_node *old = *c;
+		*c = *c->next;
+		dbg_free(*old);
+		t->num_nodes--;
+	}
+}
+
+unsigned hash_get_num_entries(struct hash_table *t)
+{
+	return t->num_nodes;
+}
+
+void hash_iterate(struct hash_table *t, iterate_fn f)
+{
+	struct hash_node *c;
+	int i;
+
+	for (i = 0; i < t->num_slots; i++)
+		for (c = t->slots[i]; c; c = c->next)
+			f(c->data);
+}
+
+

lib/datastruct/hash.h

@@ -0,0 +1,26 @@
+/*
+ * tools/lib/datastruct/hash.h
+ *
+ * Copyright (C) 2001 Sistina Software
+ *
+ * This file is released under the GPL.
+ */
+
+#ifndef HASH_H
+#define HASH_H
+
+struct hash_table;
+typedef void (*iterate_fn)(void *data);
+
+struct hash_table *create_hash_table(unsigned size_hint);
+void destroy_hash_table(struct hash_table *t);
+
+char *hash_lookup(struct hash_table *t, const char *key);
+void hash_insert(struct hash_table *t, const char *key, void *data);
+void hash_remove(struct hash_table *t, const char *key);
+
+unsigned hash_get_num_entries(struct hash_table *t);
+void hash_iterate(struct hash_table *t, iterate_fn f);
+
+#endif
+