kernel hashtable.h dynamic size of hash table - c

Question

I have written the module which uses < linux/hashtable.h > at the moment, it works perfectly fine, however I would like to change it from static hash table size to configurable one.
How should I change initialization from this:
DEFINE_HASHTABLE(my_hash_table, 10);
to dynamic one so I can pass the size of hash table when module is loaded as parameter
I have tried with
struct hlist_head* my_hash_table and its corresponding kmallocs() but with no success and give me these errors:
include/linux/bug.h:33:45: error: negative width in bit-field ‘<anonymous>’
#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))
^
include/linux/hashtable.h:27:35: note: in definition of macro ‘hash_min’
(sizeof(val) <= 4 ? hash_32(val, bits) : hash_long(val, bits))
^
include/linux/hashtable.h:23:25: note: in expansion of macro ‘ilog2’
#define HASH_BITS(name) ilog2(HASH_SIZE(name))
^
include/linux/compiler-gcc.h:44:28: note: in expansion of macro ‘BUILD_BUG_ON_ZERO’
#define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
^
include/linux/kernel.h:54:59: note: in expansion of macro ‘__must_be_array’
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
^
include/linux/hashtable.h:22:26: note: in expansion of macro ‘ARRAY_SIZE’
#define HASH_SIZE(name) (ARRAY_SIZE(name))
^
include/linux/hashtable.h:23:31: note: in expansion of macro ‘HASH_SIZE’
#define HASH_BITS(name) ilog2(HASH_SIZE(name))
^
include/linux/hashtable.h:56:48: note: in expansion of macro ‘HASH_BITS’
hlist_add_head(node, &hashtable[hash_min(key, HASH_BITS(hashtable))])
^
HashTable.c:103:9: note: in expansion of macro ‘hash_add’
hash_add(my_hash_table, &entry->entry, entry->hashed_key);

Answer 1

The kernel already has support for "dynamic" hashtables. And it's called - relativistic hash tables. More information and explanation how it works/how to use it can be found in the following very good LWN articles: Part 1 and Part 2

Answer 2

In order to change ...
DEFINE_HASHTABLE(my_hash_table, 10);
... to a dynamically allocated equivalent you would use something like this:
#define MY_HT_SZ 1024
struct hlist_head *my_hash_table;
int i;
my_hash_table = kmalloc(MY_HT_SZ * sizeof(struct hlist_head), GFP_KERNEL);
if (!my_hash_table)
goto error_handler;
for (i = 0; i < MY_HT_SZ; i++)
INIT_HLIST_HEAD(&my_hash_table[i]);

Answer 3

Same problem. I have solved this like that:
hashtable declaration.
/*
* example: struct hlist_head tbl[1 << (bits)];
* DECLARE_HASHTABLE(tbl, bits);
*/
//struct hlist_head tbl[1 << bits];
struct hlist_head *tbl = malloc((1 << bits) * sizeof(struct hlist_head) );
Initialization.
// Initialize the hashtable.
//hash_init(tbl);
__hash_init(tbl, 1 << bits);
Than i'have added all MACRO that uses HASH_BITS(hastable) HASH_SIZE(hashtable) with the same _bits version MACRO.
/**
* hash_add - add an object to a hashtable
* #hashtable: hashtable to add to
* #node: the &struct hlist_node of the object to be added
* #key: the key of the object to be added
*/
#define hash_add(hashtable, node, key) \
hlist_add_head(node, &hashtable[hash_32(key, HASH_BITS(hashtable))])
#define hash_add_bits(hashtable, bits, node, key) \
hlist_add_head(node, &hashtable[hash_32(key, bits)])
Same for others:
/**
* hash_for_each - iterate over a hashtable
* #name: hashtable to iterate
* #bkt: integer to use as bucket loop cursor
* #obj: the type * to use as a loop cursor for each entry
* #member: the name of the hlist_node within the struct
*/
#define hash_for_each(name, bkt, obj, member) \
for ((bkt) = 0, obj = NULL; obj == NULL && (bkt) < HASH_SIZE(name);\
(bkt)++)\
hlist_for_each_entry(obj, &name[bkt], member)
#define hash_for_each_bits(name, bits, bkt, obj, member) \
for ((bkt) = 0, obj = NULL; obj == NULL && (bkt) < (1 << bits);\
(bkt)++)\
hlist_for_each_entry(obj, &name[bkt], member)
You can take a look here:
https://github.com/legale/hashtable-linux-kernel