2014-08-02 03:47:44 -06:00
|
|
|
/*
|
|
|
|
* Resizable, Scalable, Concurrent Hash Table
|
|
|
|
*
|
2015-02-04 18:03:32 -07:00
|
|
|
* Copyright (c) 2014-2015 Thomas Graf <tgraf@suug.ch>
|
2014-08-02 03:47:44 -06:00
|
|
|
* Copyright (c) 2008-2014 Patrick McHardy <kaber@trash.net>
|
|
|
|
*
|
|
|
|
* Based on the following paper:
|
|
|
|
* https://www.usenix.org/legacy/event/atc11/tech/final_files/Triplett.pdf
|
|
|
|
*
|
|
|
|
* Code partially derived from nft_hash
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License version 2 as
|
|
|
|
* published by the Free Software Foundation.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/log2.h>
|
2015-02-26 08:20:34 -07:00
|
|
|
#include <linux/sched.h>
|
2014-08-02 03:47:44 -06:00
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/vmalloc.h>
|
|
|
|
#include <linux/mm.h>
|
2014-12-10 08:33:11 -07:00
|
|
|
#include <linux/jhash.h>
|
2014-08-02 03:47:44 -06:00
|
|
|
#include <linux/random.h>
|
|
|
|
#include <linux/rhashtable.h>
|
2015-02-08 20:04:03 -07:00
|
|
|
#include <linux/err.h>
|
2014-08-02 03:47:44 -06:00
|
|
|
|
|
|
|
#define HASH_DEFAULT_SIZE 64UL
|
2015-03-18 03:01:16 -06:00
|
|
|
#define HASH_MIN_SIZE 4U
|
2015-01-02 15:00:20 -07:00
|
|
|
#define BUCKET_LOCKS_PER_CPU 128UL
|
|
|
|
|
2015-01-02 15:00:21 -07:00
|
|
|
/* Base bits plus 1 bit for nulls marker */
|
|
|
|
#define HASH_RESERVED_SPACE (RHT_BASE_BITS + 1)
|
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
/* The bucket lock is selected based on the hash and protects mutations
|
|
|
|
* on a group of hash buckets.
|
|
|
|
*
|
2015-02-04 18:03:32 -07:00
|
|
|
* A maximum of tbl->size/2 bucket locks is allocated. This ensures that
|
|
|
|
* a single lock always covers both buckets which may both contains
|
|
|
|
* entries which link to the same bucket of the old table during resizing.
|
|
|
|
* This allows to simplify the locking as locking the bucket in both
|
|
|
|
* tables during resize always guarantee protection.
|
|
|
|
*
|
2015-01-02 15:00:20 -07:00
|
|
|
* IMPORTANT: When holding the bucket lock of both the old and new table
|
|
|
|
* during expansions and shrinking, the old bucket lock must always be
|
|
|
|
* acquired first.
|
|
|
|
*/
|
|
|
|
static spinlock_t *bucket_lock(const struct bucket_table *tbl, u32 hash)
|
|
|
|
{
|
|
|
|
return &tbl->locks[hash & tbl->locks_mask];
|
|
|
|
}
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2014-08-13 08:38:30 -06:00
|
|
|
static void *rht_obj(const struct rhashtable *ht, const struct rhash_head *he)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
|
|
|
return (void *) he - ht->p.head_offset;
|
|
|
|
}
|
|
|
|
|
2015-01-02 15:00:14 -07:00
|
|
|
static u32 rht_bucket_index(const struct bucket_table *tbl, u32 hash)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
2015-03-11 21:49:41 -06:00
|
|
|
return (hash >> HASH_RESERVED_SPACE) & (tbl->size - 1);
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
static u32 key_hashfn(struct rhashtable *ht, const struct bucket_table *tbl,
|
2015-03-11 21:49:40 -06:00
|
|
|
const void *key)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
2015-03-11 21:49:40 -06:00
|
|
|
return rht_bucket_index(tbl, ht->p.hashfn(key, ht->p.key_len,
|
2015-03-11 21:49:41 -06:00
|
|
|
tbl->hash_rnd));
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
|
2015-03-09 16:27:55 -06:00
|
|
|
static u32 head_hashfn(struct rhashtable *ht,
|
2015-01-02 15:00:14 -07:00
|
|
|
const struct bucket_table *tbl,
|
|
|
|
const struct rhash_head *he)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
2015-03-11 21:49:41 -06:00
|
|
|
const char *ptr = rht_obj(ht, he);
|
|
|
|
|
|
|
|
return likely(ht->p.key_len) ?
|
|
|
|
key_hashfn(ht, tbl, ptr + ht->p.key_offset) :
|
|
|
|
rht_bucket_index(tbl, ht->p.obj_hashfn(ptr, tbl->hash_rnd));
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
|
2015-02-04 18:03:34 -07:00
|
|
|
#ifdef CONFIG_PROVE_LOCKING
|
|
|
|
#define ASSERT_RHT_MUTEX(HT) BUG_ON(!lockdep_rht_mutex_is_held(HT))
|
|
|
|
|
|
|
|
int lockdep_rht_mutex_is_held(struct rhashtable *ht)
|
|
|
|
{
|
|
|
|
return (debug_locks) ? lockdep_is_held(&ht->mutex) : 1;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(lockdep_rht_mutex_is_held);
|
|
|
|
|
|
|
|
int lockdep_rht_bucket_is_held(const struct bucket_table *tbl, u32 hash)
|
|
|
|
{
|
|
|
|
spinlock_t *lock = bucket_lock(tbl, hash);
|
|
|
|
|
|
|
|
return (debug_locks) ? lockdep_is_held(lock) : 1;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(lockdep_rht_bucket_is_held);
|
|
|
|
#else
|
|
|
|
#define ASSERT_RHT_MUTEX(HT)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
static int alloc_bucket_locks(struct rhashtable *ht, struct bucket_table *tbl)
|
|
|
|
{
|
|
|
|
unsigned int i, size;
|
|
|
|
#if defined(CONFIG_PROVE_LOCKING)
|
|
|
|
unsigned int nr_pcpus = 2;
|
|
|
|
#else
|
|
|
|
unsigned int nr_pcpus = num_possible_cpus();
|
|
|
|
#endif
|
|
|
|
|
|
|
|
nr_pcpus = min_t(unsigned int, nr_pcpus, 32UL);
|
|
|
|
size = roundup_pow_of_two(nr_pcpus * ht->p.locks_mul);
|
|
|
|
|
2015-02-04 18:03:32 -07:00
|
|
|
/* Never allocate more than 0.5 locks per bucket */
|
|
|
|
size = min_t(unsigned int, size, tbl->size >> 1);
|
2015-01-02 15:00:20 -07:00
|
|
|
|
|
|
|
if (sizeof(spinlock_t) != 0) {
|
|
|
|
#ifdef CONFIG_NUMA
|
|
|
|
if (size * sizeof(spinlock_t) > PAGE_SIZE)
|
|
|
|
tbl->locks = vmalloc(size * sizeof(spinlock_t));
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
tbl->locks = kmalloc_array(size, sizeof(spinlock_t),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!tbl->locks)
|
|
|
|
return -ENOMEM;
|
|
|
|
for (i = 0; i < size; i++)
|
|
|
|
spin_lock_init(&tbl->locks[i]);
|
|
|
|
}
|
|
|
|
tbl->locks_mask = size - 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void bucket_table_free(const struct bucket_table *tbl)
|
|
|
|
{
|
|
|
|
if (tbl)
|
|
|
|
kvfree(tbl->locks);
|
|
|
|
|
|
|
|
kvfree(tbl);
|
|
|
|
}
|
|
|
|
|
2015-03-13 20:57:23 -06:00
|
|
|
static void bucket_table_free_rcu(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
bucket_table_free(container_of(head, struct bucket_table, rcu));
|
|
|
|
}
|
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
static struct bucket_table *bucket_table_alloc(struct rhashtable *ht,
|
2015-03-13 20:57:22 -06:00
|
|
|
size_t nbuckets)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
2015-02-19 16:53:38 -07:00
|
|
|
struct bucket_table *tbl = NULL;
|
2014-08-02 03:47:44 -06:00
|
|
|
size_t size;
|
2015-01-02 15:00:21 -07:00
|
|
|
int i;
|
2014-08-02 03:47:44 -06:00
|
|
|
|
|
|
|
size = sizeof(*tbl) + nbuckets * sizeof(tbl->buckets[0]);
|
2015-02-19 16:53:38 -07:00
|
|
|
if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER))
|
|
|
|
tbl = kzalloc(size, GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY);
|
2014-08-02 03:47:44 -06:00
|
|
|
if (tbl == NULL)
|
|
|
|
tbl = vzalloc(size);
|
|
|
|
if (tbl == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
tbl->size = nbuckets;
|
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
if (alloc_bucket_locks(ht, tbl) < 0) {
|
|
|
|
bucket_table_free(tbl);
|
|
|
|
return NULL;
|
|
|
|
}
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-03-13 20:57:20 -06:00
|
|
|
INIT_LIST_HEAD(&tbl->walkers);
|
|
|
|
|
2015-03-13 20:57:22 -06:00
|
|
|
get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));
|
|
|
|
|
2015-01-02 15:00:21 -07:00
|
|
|
for (i = 0; i < nbuckets; i++)
|
|
|
|
INIT_RHT_NULLS_HEAD(tbl->buckets[i], ht, i);
|
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
return tbl;
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rht_grow_above_75 - returns true if nelems > 0.75 * table-size
|
|
|
|
* @ht: hash table
|
2015-03-12 08:28:40 -06:00
|
|
|
* @tbl: current table
|
2014-08-02 03:47:44 -06:00
|
|
|
*/
|
2015-03-12 08:28:40 -06:00
|
|
|
static bool rht_grow_above_75(const struct rhashtable *ht,
|
|
|
|
const struct bucket_table *tbl)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
|
|
|
/* Expand table when exceeding 75% load */
|
2015-03-12 08:28:40 -06:00
|
|
|
return atomic_read(&ht->nelems) > (tbl->size / 4 * 3) &&
|
2015-03-18 03:01:16 -06:00
|
|
|
(!ht->p.max_size || tbl->size < ht->p.max_size);
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rht_shrink_below_30 - returns true if nelems < 0.3 * table-size
|
|
|
|
* @ht: hash table
|
2015-03-12 08:28:40 -06:00
|
|
|
* @tbl: current table
|
2014-08-02 03:47:44 -06:00
|
|
|
*/
|
2015-03-12 08:28:40 -06:00
|
|
|
static bool rht_shrink_below_30(const struct rhashtable *ht,
|
|
|
|
const struct bucket_table *tbl)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
|
|
|
/* Shrink table beneath 30% load */
|
2015-03-12 08:28:40 -06:00
|
|
|
return atomic_read(&ht->nelems) < (tbl->size * 3 / 10) &&
|
2015-03-18 03:01:16 -06:00
|
|
|
tbl->size > ht->p.min_size;
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
static int rhashtable_rehash_one(struct rhashtable *ht, unsigned old_hash)
|
2015-02-04 18:03:32 -07:00
|
|
|
{
|
2015-03-10 16:43:48 -06:00
|
|
|
struct bucket_table *old_tbl = rht_dereference(ht->tbl, ht);
|
2015-03-13 20:57:25 -06:00
|
|
|
struct bucket_table *new_tbl =
|
|
|
|
rht_dereference(old_tbl->future_tbl, ht) ?: old_tbl;
|
2015-03-10 16:43:48 -06:00
|
|
|
struct rhash_head __rcu **pprev = &old_tbl->buckets[old_hash];
|
|
|
|
int err = -ENOENT;
|
|
|
|
struct rhash_head *head, *next, *entry;
|
|
|
|
spinlock_t *new_bucket_lock;
|
|
|
|
unsigned new_hash;
|
|
|
|
|
|
|
|
rht_for_each(entry, old_tbl, old_hash) {
|
|
|
|
err = 0;
|
|
|
|
next = rht_dereference_bucket(entry->next, old_tbl, old_hash);
|
|
|
|
|
|
|
|
if (rht_is_a_nulls(next))
|
|
|
|
break;
|
2015-02-04 18:03:32 -07:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
pprev = &entry->next;
|
|
|
|
}
|
2015-02-04 18:03:32 -07:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
if (err)
|
|
|
|
goto out;
|
2015-01-02 15:00:20 -07:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
new_hash = head_hashfn(ht, new_tbl, entry);
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
new_bucket_lock = bucket_lock(new_tbl, new_hash);
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-03-13 20:57:21 -06:00
|
|
|
spin_lock_nested(new_bucket_lock, SINGLE_DEPTH_NESTING);
|
2015-03-10 16:43:48 -06:00
|
|
|
head = rht_dereference_bucket(new_tbl->buckets[new_hash],
|
|
|
|
new_tbl, new_hash);
|
2015-01-02 15:00:20 -07:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
if (rht_is_a_nulls(head))
|
|
|
|
INIT_RHT_NULLS_HEAD(entry->next, ht, new_hash);
|
|
|
|
else
|
|
|
|
RCU_INIT_POINTER(entry->next, head);
|
2015-02-04 18:03:32 -07:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
rcu_assign_pointer(new_tbl->buckets[new_hash], entry);
|
|
|
|
spin_unlock(new_bucket_lock);
|
2015-01-02 15:00:20 -07:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
rcu_assign_pointer(*pprev, next);
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
out:
|
|
|
|
return err;
|
|
|
|
}
|
2015-01-02 15:00:20 -07:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
static void rhashtable_rehash_chain(struct rhashtable *ht, unsigned old_hash)
|
|
|
|
{
|
|
|
|
struct bucket_table *old_tbl = rht_dereference(ht->tbl, ht);
|
|
|
|
spinlock_t *old_bucket_lock;
|
|
|
|
|
|
|
|
old_bucket_lock = bucket_lock(old_tbl, old_hash);
|
2015-02-04 18:03:32 -07:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
spin_lock_bh(old_bucket_lock);
|
|
|
|
while (!rhashtable_rehash_one(ht, old_hash))
|
|
|
|
;
|
2015-03-13 20:57:24 -06:00
|
|
|
old_tbl->rehash++;
|
2015-03-10 16:43:48 -06:00
|
|
|
spin_unlock_bh(old_bucket_lock);
|
2015-01-02 15:00:20 -07:00
|
|
|
}
|
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
static void rhashtable_rehash(struct rhashtable *ht,
|
|
|
|
struct bucket_table *new_tbl)
|
2015-01-02 15:00:20 -07:00
|
|
|
{
|
2015-03-10 16:43:48 -06:00
|
|
|
struct bucket_table *old_tbl = rht_dereference(ht->tbl, ht);
|
2015-03-13 20:57:20 -06:00
|
|
|
struct rhashtable_walker *walker;
|
2015-03-10 16:43:48 -06:00
|
|
|
unsigned old_hash;
|
2015-02-04 18:03:35 -07:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
/* Make insertions go into the new, empty table right away. Deletions
|
|
|
|
* and lookups will be attempted in both tables until we synchronize.
|
|
|
|
*/
|
2015-03-13 20:57:25 -06:00
|
|
|
rcu_assign_pointer(old_tbl->future_tbl, new_tbl);
|
2015-03-10 16:43:48 -06:00
|
|
|
|
2015-03-12 05:07:49 -06:00
|
|
|
/* Ensure the new table is visible to readers. */
|
|
|
|
smp_wmb();
|
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
for (old_hash = 0; old_hash < old_tbl->size; old_hash++)
|
|
|
|
rhashtable_rehash_chain(ht, old_hash);
|
|
|
|
|
|
|
|
/* Publish the new table pointer. */
|
|
|
|
rcu_assign_pointer(ht->tbl, new_tbl);
|
|
|
|
|
2015-03-13 20:57:20 -06:00
|
|
|
list_for_each_entry(walker, &old_tbl->walkers, list)
|
|
|
|
walker->tbl = NULL;
|
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
/* Wait for readers. All new readers will see the new
|
|
|
|
* table, and thus no references to the old table will
|
|
|
|
* remain.
|
|
|
|
*/
|
2015-03-13 20:57:23 -06:00
|
|
|
call_rcu(&old_tbl->rcu, bucket_table_free_rcu);
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rhashtable_expand - Expand hash table while allowing concurrent lookups
|
|
|
|
* @ht: the hash table to expand
|
|
|
|
*
|
2015-03-10 16:43:48 -06:00
|
|
|
* A secondary bucket array is allocated and the hash entries are migrated.
|
2014-08-02 03:47:44 -06:00
|
|
|
*
|
|
|
|
* This function may only be called in a context where it is safe to call
|
|
|
|
* synchronize_rcu(), e.g. not within a rcu_read_lock() section.
|
|
|
|
*
|
2015-01-02 15:00:20 -07:00
|
|
|
* The caller must ensure that no concurrent resizing occurs by holding
|
|
|
|
* ht->mutex.
|
|
|
|
*
|
|
|
|
* It is valid to have concurrent insertions and deletions protected by per
|
|
|
|
* bucket locks or concurrent RCU protected lookups and traversals.
|
2014-08-02 03:47:44 -06:00
|
|
|
*/
|
2014-11-13 05:45:46 -07:00
|
|
|
int rhashtable_expand(struct rhashtable *ht)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
|
|
|
struct bucket_table *new_tbl, *old_tbl = rht_dereference(ht->tbl, ht);
|
|
|
|
|
|
|
|
ASSERT_RHT_MUTEX(ht);
|
|
|
|
|
2015-03-13 20:57:22 -06:00
|
|
|
new_tbl = bucket_table_alloc(ht, old_tbl->size * 2);
|
2014-08-02 03:47:44 -06:00
|
|
|
if (new_tbl == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
rhashtable_rehash(ht, new_tbl);
|
2014-08-02 03:47:44 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_expand);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rhashtable_shrink - Shrink hash table while allowing concurrent lookups
|
|
|
|
* @ht: the hash table to shrink
|
|
|
|
*
|
|
|
|
* This function may only be called in a context where it is safe to call
|
|
|
|
* synchronize_rcu(), e.g. not within a rcu_read_lock() section.
|
|
|
|
*
|
2015-01-02 15:00:20 -07:00
|
|
|
* The caller must ensure that no concurrent resizing occurs by holding
|
|
|
|
* ht->mutex.
|
|
|
|
*
|
2014-08-02 03:47:44 -06:00
|
|
|
* The caller must ensure that no concurrent table mutations take place.
|
|
|
|
* It is however valid to have concurrent lookups if they are RCU protected.
|
2015-01-02 15:00:20 -07:00
|
|
|
*
|
|
|
|
* It is valid to have concurrent insertions and deletions protected by per
|
|
|
|
* bucket locks or concurrent RCU protected lookups and traversals.
|
2014-08-02 03:47:44 -06:00
|
|
|
*/
|
2014-11-13 05:45:46 -07:00
|
|
|
int rhashtable_shrink(struct rhashtable *ht)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
2015-03-12 08:28:40 -06:00
|
|
|
struct bucket_table *new_tbl, *old_tbl = rht_dereference(ht->tbl, ht);
|
2014-08-02 03:47:44 -06:00
|
|
|
|
|
|
|
ASSERT_RHT_MUTEX(ht);
|
|
|
|
|
2015-03-13 20:57:22 -06:00
|
|
|
new_tbl = bucket_table_alloc(ht, old_tbl->size / 2);
|
2015-01-02 15:00:20 -07:00
|
|
|
if (new_tbl == NULL)
|
2014-08-02 03:47:44 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
rhashtable_rehash(ht, new_tbl);
|
2014-08-02 03:47:44 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_shrink);
|
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
static void rht_deferred_worker(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct rhashtable *ht;
|
|
|
|
struct bucket_table *tbl;
|
|
|
|
|
rhashtable: Fix race in rhashtable_destroy() and use regular work_struct
When we put our declared work task in the global workqueue with
schedule_delayed_work(), its delay parameter is always zero.
Therefore, we should define a regular work in rhashtable structure
instead of a delayed work.
By the way, we add a condition to check whether resizing functions
are NULL before cancelling the work, avoiding to cancel an
uninitialized work.
Lastly, while we wait for all work items we submitted before to run
to completion with cancel_delayed_work(), ht->mutex has been taken in
rhashtable_destroy(). Moreover, cancel_delayed_work() doesn't return
until all work items are accomplished, and when work items are
scheduled, the work's function - rht_deferred_worker() will be called.
However, as rht_deferred_worker() also needs to acquire the lock,
deadlock might happen at the moment as the lock is already held before.
So if the cancel work function is moved out of the lock covered scope,
this will avoid the deadlock.
Fixes: 97defe1 ("rhashtable: Per bucket locks & deferred expansion/shrinking")
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Cc: Thomas Graf <tgraf@suug.ch>
Acked-by: Thomas Graf <tgraf@suug.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-01-15 20:13:09 -07:00
|
|
|
ht = container_of(work, struct rhashtable, run_work);
|
2015-01-02 15:00:20 -07:00
|
|
|
mutex_lock(&ht->mutex);
|
2015-02-03 13:33:22 -07:00
|
|
|
if (ht->being_destroyed)
|
|
|
|
goto unlock;
|
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
tbl = rht_dereference(ht->tbl, ht);
|
|
|
|
|
2015-03-12 08:28:40 -06:00
|
|
|
if (rht_grow_above_75(ht, tbl))
|
2015-01-02 15:00:20 -07:00
|
|
|
rhashtable_expand(ht);
|
2015-03-12 08:28:40 -06:00
|
|
|
else if (rht_shrink_below_30(ht, tbl))
|
2015-01-02 15:00:20 -07:00
|
|
|
rhashtable_shrink(ht);
|
2015-02-03 13:33:22 -07:00
|
|
|
unlock:
|
2015-01-02 15:00:20 -07:00
|
|
|
mutex_unlock(&ht->mutex);
|
|
|
|
}
|
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
static bool __rhashtable_insert(struct rhashtable *ht, struct rhash_head *obj,
|
|
|
|
bool (*compare)(void *, void *), void *arg)
|
2015-01-06 22:41:54 -07:00
|
|
|
{
|
2015-03-10 16:43:48 -06:00
|
|
|
struct bucket_table *tbl, *old_tbl;
|
2015-02-06 09:08:43 -07:00
|
|
|
struct rhash_head *head;
|
2015-03-10 16:43:48 -06:00
|
|
|
bool no_resize_running;
|
|
|
|
unsigned hash;
|
2015-03-16 03:42:26 -06:00
|
|
|
spinlock_t *old_lock;
|
2015-03-10 16:43:48 -06:00
|
|
|
bool success = true;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
old_tbl = rht_dereference_rcu(ht->tbl, ht);
|
2015-03-11 21:49:39 -06:00
|
|
|
hash = head_hashfn(ht, old_tbl, obj);
|
2015-03-16 03:42:26 -06:00
|
|
|
old_lock = bucket_lock(old_tbl, hash);
|
2015-03-10 16:43:48 -06:00
|
|
|
|
2015-03-16 03:42:26 -06:00
|
|
|
spin_lock_bh(old_lock);
|
2015-03-10 16:43:48 -06:00
|
|
|
|
|
|
|
/* Because we have already taken the bucket lock in old_tbl,
|
|
|
|
* if we find that future_tbl is not yet visible then that
|
|
|
|
* guarantees all other insertions of the same entry will
|
|
|
|
* also grab the bucket lock in old_tbl because until the
|
|
|
|
* rehash completes ht->tbl won't be changed.
|
|
|
|
*/
|
2015-03-13 20:57:25 -06:00
|
|
|
tbl = rht_dereference_rcu(old_tbl->future_tbl, ht) ?: old_tbl;
|
2015-03-10 16:43:48 -06:00
|
|
|
if (tbl != old_tbl) {
|
2015-03-11 21:49:39 -06:00
|
|
|
hash = head_hashfn(ht, tbl, obj);
|
2015-03-13 20:57:21 -06:00
|
|
|
spin_lock_nested(bucket_lock(tbl, hash), SINGLE_DEPTH_NESTING);
|
2015-03-10 16:43:48 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (compare &&
|
|
|
|
rhashtable_lookup_compare(ht, rht_obj(ht, obj) + ht->p.key_offset,
|
|
|
|
compare, arg)) {
|
|
|
|
success = false;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
no_resize_running = tbl == old_tbl;
|
2015-02-06 09:08:43 -07:00
|
|
|
|
|
|
|
head = rht_dereference_bucket(tbl->buckets[hash], tbl, hash);
|
2015-01-06 22:41:54 -07:00
|
|
|
|
|
|
|
if (rht_is_a_nulls(head))
|
|
|
|
INIT_RHT_NULLS_HEAD(obj->next, ht, hash);
|
|
|
|
else
|
|
|
|
RCU_INIT_POINTER(obj->next, head);
|
|
|
|
|
|
|
|
rcu_assign_pointer(tbl->buckets[hash], obj);
|
|
|
|
|
|
|
|
atomic_inc(&ht->nelems);
|
2015-03-12 08:28:40 -06:00
|
|
|
if (no_resize_running && rht_grow_above_75(ht, tbl))
|
2015-02-25 08:31:54 -07:00
|
|
|
schedule_work(&ht->run_work);
|
2015-03-10 16:43:48 -06:00
|
|
|
|
|
|
|
exit:
|
2015-03-16 03:42:26 -06:00
|
|
|
if (tbl != old_tbl)
|
2015-03-10 16:43:48 -06:00
|
|
|
spin_unlock(bucket_lock(tbl, hash));
|
|
|
|
|
2015-03-16 03:42:26 -06:00
|
|
|
spin_unlock_bh(old_lock);
|
2015-03-10 16:43:48 -06:00
|
|
|
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return success;
|
2015-01-06 22:41:54 -07:00
|
|
|
}
|
|
|
|
|
2014-08-02 03:47:44 -06:00
|
|
|
/**
|
2015-01-06 22:41:54 -07:00
|
|
|
* rhashtable_insert - insert object into hash table
|
2014-08-02 03:47:44 -06:00
|
|
|
* @ht: hash table
|
|
|
|
* @obj: pointer to hash head inside object
|
|
|
|
*
|
2015-01-02 15:00:20 -07:00
|
|
|
* Will take a per bucket spinlock to protect against mutual mutations
|
|
|
|
* on the same bucket. Multiple insertions may occur in parallel unless
|
|
|
|
* they map to the same bucket lock.
|
2014-08-02 03:47:44 -06:00
|
|
|
*
|
2015-01-02 15:00:20 -07:00
|
|
|
* It is safe to call this function from atomic context.
|
|
|
|
*
|
|
|
|
* Will trigger an automatic deferred table resizing if the size grows
|
|
|
|
* beyond the watermark indicated by grow_decision() which can be passed
|
|
|
|
* to rhashtable_init().
|
2014-08-02 03:47:44 -06:00
|
|
|
*/
|
2014-11-13 05:45:46 -07:00
|
|
|
void rhashtable_insert(struct rhashtable *ht, struct rhash_head *obj)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
2015-03-10 16:43:48 -06:00
|
|
|
__rhashtable_insert(ht, obj, NULL, NULL);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_insert);
|
|
|
|
|
|
|
|
static bool __rhashtable_remove(struct rhashtable *ht,
|
|
|
|
struct bucket_table *tbl,
|
|
|
|
struct rhash_head *obj)
|
|
|
|
{
|
|
|
|
struct rhash_head __rcu **pprev;
|
|
|
|
struct rhash_head *he;
|
|
|
|
spinlock_t * lock;
|
2015-01-02 15:00:20 -07:00
|
|
|
unsigned hash;
|
2015-03-10 16:43:48 -06:00
|
|
|
bool ret = false;
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-03-11 21:49:39 -06:00
|
|
|
hash = head_hashfn(ht, tbl, obj);
|
2015-03-10 16:43:48 -06:00
|
|
|
lock = bucket_lock(tbl, hash);
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
spin_lock_bh(lock);
|
2015-01-02 15:00:20 -07:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
pprev = &tbl->buckets[hash];
|
|
|
|
rht_for_each(he, tbl, hash) {
|
|
|
|
if (he != obj) {
|
|
|
|
pprev = &he->next;
|
|
|
|
continue;
|
|
|
|
}
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
rcu_assign_pointer(*pprev, obj->next);
|
|
|
|
ret = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_bh(lock);
|
|
|
|
|
|
|
|
return ret;
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rhashtable_remove - remove object from hash table
|
|
|
|
* @ht: hash table
|
|
|
|
* @obj: pointer to hash head inside object
|
|
|
|
*
|
|
|
|
* Since the hash chain is single linked, the removal operation needs to
|
|
|
|
* walk the bucket chain upon removal. The removal operation is thus
|
|
|
|
* considerable slow if the hash table is not correctly sized.
|
|
|
|
*
|
2015-01-06 22:41:54 -07:00
|
|
|
* Will automatically shrink the table via rhashtable_expand() if the
|
2014-08-02 03:47:44 -06:00
|
|
|
* shrink_decision function specified at rhashtable_init() returns true.
|
|
|
|
*
|
|
|
|
* The caller must ensure that no concurrent table mutations occur. It is
|
|
|
|
* however valid to have concurrent lookups if they are RCU protected.
|
|
|
|
*/
|
2014-11-13 05:45:46 -07:00
|
|
|
bool rhashtable_remove(struct rhashtable *ht, struct rhash_head *obj)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
2015-03-15 04:12:05 -06:00
|
|
|
struct bucket_table *tbl;
|
2015-03-10 16:43:48 -06:00
|
|
|
bool ret;
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
rcu_read_lock();
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-03-15 04:12:05 -06:00
|
|
|
tbl = rht_dereference_rcu(ht->tbl, ht);
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
/* Because we have already taken (and released) the bucket
|
|
|
|
* lock in old_tbl, if we find that future_tbl is not yet
|
|
|
|
* visible then that guarantees the entry to still be in
|
2015-03-15 04:12:05 -06:00
|
|
|
* the old tbl if it exists.
|
2015-01-21 04:54:01 -07:00
|
|
|
*/
|
2015-03-15 04:12:05 -06:00
|
|
|
while (!(ret = __rhashtable_remove(ht, tbl, obj)) &&
|
|
|
|
(tbl = rht_dereference_rcu(tbl->future_tbl, ht)))
|
|
|
|
;
|
2015-01-21 04:54:01 -07:00
|
|
|
|
|
|
|
if (ret) {
|
|
|
|
atomic_dec(&ht->nelems);
|
2015-03-15 04:12:05 -06:00
|
|
|
if (rht_shrink_below_30(ht, tbl))
|
2015-02-25 08:31:54 -07:00
|
|
|
schedule_work(&ht->run_work);
|
2015-01-21 04:54:01 -07:00
|
|
|
}
|
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
rcu_read_unlock();
|
|
|
|
|
2015-01-21 04:54:01 -07:00
|
|
|
return ret;
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_remove);
|
|
|
|
|
2015-01-06 22:41:52 -07:00
|
|
|
struct rhashtable_compare_arg {
|
|
|
|
struct rhashtable *ht;
|
|
|
|
const void *key;
|
|
|
|
};
|
|
|
|
|
|
|
|
static bool rhashtable_compare(void *ptr, void *arg)
|
|
|
|
{
|
|
|
|
struct rhashtable_compare_arg *x = arg;
|
|
|
|
struct rhashtable *ht = x->ht;
|
|
|
|
|
|
|
|
return !memcmp(ptr + ht->p.key_offset, x->key, ht->p.key_len);
|
|
|
|
}
|
|
|
|
|
2014-08-02 03:47:44 -06:00
|
|
|
/**
|
|
|
|
* rhashtable_lookup - lookup key in hash table
|
|
|
|
* @ht: hash table
|
|
|
|
* @key: pointer to key
|
|
|
|
*
|
|
|
|
* Computes the hash value for the key and traverses the bucket chain looking
|
|
|
|
* for a entry with an identical key. The first matching entry is returned.
|
|
|
|
*
|
|
|
|
* This lookup function may only be used for fixed key hash table (key_len
|
2015-01-06 22:41:54 -07:00
|
|
|
* parameter set). It will BUG() if used inappropriately.
|
2014-08-02 03:47:44 -06:00
|
|
|
*
|
2015-01-02 15:00:20 -07:00
|
|
|
* Lookups may occur in parallel with hashtable mutations and resizing.
|
2014-08-02 03:47:44 -06:00
|
|
|
*/
|
2015-01-02 15:00:20 -07:00
|
|
|
void *rhashtable_lookup(struct rhashtable *ht, const void *key)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
2015-01-06 22:41:52 -07:00
|
|
|
struct rhashtable_compare_arg arg = {
|
|
|
|
.ht = ht,
|
|
|
|
.key = key,
|
|
|
|
};
|
2014-08-02 03:47:44 -06:00
|
|
|
|
|
|
|
BUG_ON(!ht->p.key_len);
|
|
|
|
|
2015-01-06 22:41:52 -07:00
|
|
|
return rhashtable_lookup_compare(ht, key, &rhashtable_compare, &arg);
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_lookup);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rhashtable_lookup_compare - search hash table with compare function
|
|
|
|
* @ht: hash table
|
2015-01-02 15:00:14 -07:00
|
|
|
* @key: the pointer to the key
|
2014-08-02 03:47:44 -06:00
|
|
|
* @compare: compare function, must return true on match
|
|
|
|
* @arg: argument passed on to compare function
|
|
|
|
*
|
|
|
|
* Traverses the bucket chain behind the provided hash value and calls the
|
|
|
|
* specified compare function for each entry.
|
|
|
|
*
|
2015-01-02 15:00:20 -07:00
|
|
|
* Lookups may occur in parallel with hashtable mutations and resizing.
|
2014-08-02 03:47:44 -06:00
|
|
|
*
|
|
|
|
* Returns the first entry on which the compare function returned true.
|
|
|
|
*/
|
2015-01-02 15:00:20 -07:00
|
|
|
void *rhashtable_lookup_compare(struct rhashtable *ht, const void *key,
|
2014-08-02 03:47:44 -06:00
|
|
|
bool (*compare)(void *, void *), void *arg)
|
|
|
|
{
|
2015-03-13 20:57:25 -06:00
|
|
|
const struct bucket_table *tbl;
|
2014-08-02 03:47:44 -06:00
|
|
|
struct rhash_head *he;
|
2015-01-02 15:00:14 -07:00
|
|
|
u32 hash;
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
tbl = rht_dereference_rcu(ht->tbl, ht);
|
2015-01-02 15:00:20 -07:00
|
|
|
restart:
|
2015-03-12 19:54:10 -06:00
|
|
|
hash = key_hashfn(ht, tbl, key);
|
2015-03-11 21:49:38 -06:00
|
|
|
rht_for_each_rcu(he, tbl, hash) {
|
2014-08-02 03:47:44 -06:00
|
|
|
if (!compare(rht_obj(ht, he), arg))
|
|
|
|
continue;
|
2015-01-02 15:00:20 -07:00
|
|
|
rcu_read_unlock();
|
2015-01-02 15:00:15 -07:00
|
|
|
return rht_obj(ht, he);
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
|
2015-03-12 05:07:49 -06:00
|
|
|
/* Ensure we see any new tables. */
|
|
|
|
smp_rmb();
|
|
|
|
|
2015-03-13 20:57:25 -06:00
|
|
|
tbl = rht_dereference_rcu(tbl->future_tbl, ht);
|
|
|
|
if (unlikely(tbl))
|
2015-01-02 15:00:20 -07:00
|
|
|
goto restart;
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
2014-08-02 03:47:44 -06:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_lookup_compare);
|
|
|
|
|
2015-01-06 22:41:54 -07:00
|
|
|
/**
|
|
|
|
* rhashtable_lookup_insert - lookup and insert object into hash table
|
|
|
|
* @ht: hash table
|
|
|
|
* @obj: pointer to hash head inside object
|
|
|
|
*
|
|
|
|
* Locks down the bucket chain in both the old and new table if a resize
|
|
|
|
* is in progress to ensure that writers can't remove from the old table
|
|
|
|
* and can't insert to the new table during the atomic operation of search
|
|
|
|
* and insertion. Searches for duplicates in both the old and new table if
|
|
|
|
* a resize is in progress.
|
|
|
|
*
|
|
|
|
* This lookup function may only be used for fixed key hash table (key_len
|
|
|
|
* parameter set). It will BUG() if used inappropriately.
|
|
|
|
*
|
|
|
|
* It is safe to call this function from atomic context.
|
|
|
|
*
|
|
|
|
* Will trigger an automatic deferred table resizing if the size grows
|
|
|
|
* beyond the watermark indicated by grow_decision() which can be passed
|
|
|
|
* to rhashtable_init().
|
|
|
|
*/
|
|
|
|
bool rhashtable_lookup_insert(struct rhashtable *ht, struct rhash_head *obj)
|
2015-01-11 23:52:22 -07:00
|
|
|
{
|
|
|
|
struct rhashtable_compare_arg arg = {
|
|
|
|
.ht = ht,
|
|
|
|
.key = rht_obj(ht, obj) + ht->p.key_offset,
|
|
|
|
};
|
|
|
|
|
|
|
|
BUG_ON(!ht->p.key_len);
|
|
|
|
|
|
|
|
return rhashtable_lookup_compare_insert(ht, obj, &rhashtable_compare,
|
|
|
|
&arg);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_lookup_insert);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rhashtable_lookup_compare_insert - search and insert object to hash table
|
|
|
|
* with compare function
|
|
|
|
* @ht: hash table
|
|
|
|
* @obj: pointer to hash head inside object
|
|
|
|
* @compare: compare function, must return true on match
|
|
|
|
* @arg: argument passed on to compare function
|
|
|
|
*
|
|
|
|
* Locks down the bucket chain in both the old and new table if a resize
|
|
|
|
* is in progress to ensure that writers can't remove from the old table
|
|
|
|
* and can't insert to the new table during the atomic operation of search
|
|
|
|
* and insertion. Searches for duplicates in both the old and new table if
|
|
|
|
* a resize is in progress.
|
|
|
|
*
|
|
|
|
* Lookups may occur in parallel with hashtable mutations and resizing.
|
|
|
|
*
|
|
|
|
* Will trigger an automatic deferred table resizing if the size grows
|
|
|
|
* beyond the watermark indicated by grow_decision() which can be passed
|
|
|
|
* to rhashtable_init().
|
|
|
|
*/
|
|
|
|
bool rhashtable_lookup_compare_insert(struct rhashtable *ht,
|
|
|
|
struct rhash_head *obj,
|
|
|
|
bool (*compare)(void *, void *),
|
|
|
|
void *arg)
|
2015-01-06 22:41:54 -07:00
|
|
|
{
|
|
|
|
BUG_ON(!ht->p.key_len);
|
|
|
|
|
2015-03-10 16:43:48 -06:00
|
|
|
return __rhashtable_insert(ht, obj, compare, arg);
|
2015-01-06 22:41:54 -07:00
|
|
|
}
|
2015-01-11 23:52:22 -07:00
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_lookup_compare_insert);
|
2015-01-06 22:41:54 -07:00
|
|
|
|
2015-02-03 13:33:23 -07:00
|
|
|
/**
|
|
|
|
* rhashtable_walk_init - Initialise an iterator
|
|
|
|
* @ht: Table to walk over
|
|
|
|
* @iter: Hash table Iterator
|
|
|
|
*
|
|
|
|
* This function prepares a hash table walk.
|
|
|
|
*
|
|
|
|
* Note that if you restart a walk after rhashtable_walk_stop you
|
|
|
|
* may see the same object twice. Also, you may miss objects if
|
|
|
|
* there are removals in between rhashtable_walk_stop and the next
|
|
|
|
* call to rhashtable_walk_start.
|
|
|
|
*
|
|
|
|
* For a completely stable walk you should construct your own data
|
|
|
|
* structure outside the hash table.
|
|
|
|
*
|
|
|
|
* This function may sleep so you must not call it from interrupt
|
|
|
|
* context or with spin locks held.
|
|
|
|
*
|
|
|
|
* You must call rhashtable_walk_exit if this function returns
|
|
|
|
* successfully.
|
|
|
|
*/
|
|
|
|
int rhashtable_walk_init(struct rhashtable *ht, struct rhashtable_iter *iter)
|
|
|
|
{
|
|
|
|
iter->ht = ht;
|
|
|
|
iter->p = NULL;
|
|
|
|
iter->slot = 0;
|
|
|
|
iter->skip = 0;
|
|
|
|
|
|
|
|
iter->walker = kmalloc(sizeof(*iter->walker), GFP_KERNEL);
|
|
|
|
if (!iter->walker)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
mutex_lock(&ht->mutex);
|
2015-03-13 20:57:20 -06:00
|
|
|
iter->walker->tbl = rht_dereference(ht->tbl, ht);
|
|
|
|
list_add(&iter->walker->list, &iter->walker->tbl->walkers);
|
2015-02-03 13:33:23 -07:00
|
|
|
mutex_unlock(&ht->mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_walk_init);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rhashtable_walk_exit - Free an iterator
|
|
|
|
* @iter: Hash table Iterator
|
|
|
|
*
|
|
|
|
* This function frees resources allocated by rhashtable_walk_init.
|
|
|
|
*/
|
|
|
|
void rhashtable_walk_exit(struct rhashtable_iter *iter)
|
|
|
|
{
|
|
|
|
mutex_lock(&iter->ht->mutex);
|
2015-03-13 20:57:20 -06:00
|
|
|
if (iter->walker->tbl)
|
|
|
|
list_del(&iter->walker->list);
|
2015-02-03 13:33:23 -07:00
|
|
|
mutex_unlock(&iter->ht->mutex);
|
|
|
|
kfree(iter->walker);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_walk_exit);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rhashtable_walk_start - Start a hash table walk
|
|
|
|
* @iter: Hash table iterator
|
|
|
|
*
|
|
|
|
* Start a hash table walk. Note that we take the RCU lock in all
|
|
|
|
* cases including when we return an error. So you must always call
|
|
|
|
* rhashtable_walk_stop to clean up.
|
|
|
|
*
|
|
|
|
* Returns zero if successful.
|
|
|
|
*
|
|
|
|
* Returns -EAGAIN if resize event occured. Note that the iterator
|
|
|
|
* will rewind back to the beginning and you may use it immediately
|
|
|
|
* by calling rhashtable_walk_next.
|
|
|
|
*/
|
|
|
|
int rhashtable_walk_start(struct rhashtable_iter *iter)
|
2015-03-16 03:42:27 -06:00
|
|
|
__acquires(RCU)
|
2015-02-03 13:33:23 -07:00
|
|
|
{
|
2015-03-13 20:57:20 -06:00
|
|
|
struct rhashtable *ht = iter->ht;
|
|
|
|
|
|
|
|
mutex_lock(&ht->mutex);
|
|
|
|
|
|
|
|
if (iter->walker->tbl)
|
|
|
|
list_del(&iter->walker->list);
|
|
|
|
|
2015-02-03 13:33:23 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
|
2015-03-13 20:57:20 -06:00
|
|
|
mutex_unlock(&ht->mutex);
|
|
|
|
|
|
|
|
if (!iter->walker->tbl) {
|
|
|
|
iter->walker->tbl = rht_dereference_rcu(ht->tbl, ht);
|
2015-02-03 13:33:23 -07:00
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_walk_start);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rhashtable_walk_next - Return the next object and advance the iterator
|
|
|
|
* @iter: Hash table iterator
|
|
|
|
*
|
|
|
|
* Note that you must call rhashtable_walk_stop when you are finished
|
|
|
|
* with the walk.
|
|
|
|
*
|
|
|
|
* Returns the next object or NULL when the end of the table is reached.
|
|
|
|
*
|
|
|
|
* Returns -EAGAIN if resize event occured. Note that the iterator
|
|
|
|
* will rewind back to the beginning and you may continue to use it.
|
|
|
|
*/
|
|
|
|
void *rhashtable_walk_next(struct rhashtable_iter *iter)
|
|
|
|
{
|
2015-03-13 20:57:20 -06:00
|
|
|
struct bucket_table *tbl = iter->walker->tbl;
|
2015-02-03 13:33:23 -07:00
|
|
|
struct rhashtable *ht = iter->ht;
|
|
|
|
struct rhash_head *p = iter->p;
|
|
|
|
void *obj = NULL;
|
|
|
|
|
|
|
|
if (p) {
|
|
|
|
p = rht_dereference_bucket_rcu(p->next, tbl, iter->slot);
|
|
|
|
goto next;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; iter->slot < tbl->size; iter->slot++) {
|
|
|
|
int skip = iter->skip;
|
|
|
|
|
|
|
|
rht_for_each_rcu(p, tbl, iter->slot) {
|
|
|
|
if (!skip)
|
|
|
|
break;
|
|
|
|
skip--;
|
|
|
|
}
|
|
|
|
|
|
|
|
next:
|
|
|
|
if (!rht_is_a_nulls(p)) {
|
|
|
|
iter->skip++;
|
|
|
|
iter->p = p;
|
|
|
|
obj = rht_obj(ht, p);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
iter->skip = 0;
|
|
|
|
}
|
|
|
|
|
2015-03-13 20:57:25 -06:00
|
|
|
iter->walker->tbl = rht_dereference_rcu(tbl->future_tbl, ht);
|
|
|
|
if (iter->walker->tbl) {
|
2015-02-03 13:33:23 -07:00
|
|
|
iter->slot = 0;
|
|
|
|
iter->skip = 0;
|
|
|
|
return ERR_PTR(-EAGAIN);
|
|
|
|
}
|
|
|
|
|
2015-03-13 20:57:20 -06:00
|
|
|
iter->p = NULL;
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
2015-02-03 13:33:23 -07:00
|
|
|
return obj;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_walk_next);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rhashtable_walk_stop - Finish a hash table walk
|
|
|
|
* @iter: Hash table iterator
|
|
|
|
*
|
|
|
|
* Finish a hash table walk.
|
|
|
|
*/
|
|
|
|
void rhashtable_walk_stop(struct rhashtable_iter *iter)
|
2015-03-16 03:42:27 -06:00
|
|
|
__releases(RCU)
|
2015-02-03 13:33:23 -07:00
|
|
|
{
|
2015-03-13 20:57:20 -06:00
|
|
|
struct rhashtable *ht;
|
|
|
|
struct bucket_table *tbl = iter->walker->tbl;
|
|
|
|
|
|
|
|
if (!tbl)
|
2015-03-15 04:12:04 -06:00
|
|
|
goto out;
|
2015-03-13 20:57:20 -06:00
|
|
|
|
|
|
|
ht = iter->ht;
|
|
|
|
|
|
|
|
mutex_lock(&ht->mutex);
|
2015-03-13 20:57:25 -06:00
|
|
|
if (tbl->rehash < tbl->size)
|
2015-03-13 20:57:20 -06:00
|
|
|
list_add(&iter->walker->list, &tbl->walkers);
|
|
|
|
else
|
|
|
|
iter->walker->tbl = NULL;
|
|
|
|
mutex_unlock(&ht->mutex);
|
|
|
|
|
2015-02-03 13:33:23 -07:00
|
|
|
iter->p = NULL;
|
2015-03-15 04:12:04 -06:00
|
|
|
|
|
|
|
out:
|
|
|
|
rcu_read_unlock();
|
2015-02-03 13:33:23 -07:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_walk_stop);
|
|
|
|
|
2015-03-20 04:56:59 -06:00
|
|
|
static size_t rounded_hashtable_size(const struct rhashtable_params *params)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
2014-09-02 19:22:36 -06:00
|
|
|
return max(roundup_pow_of_two(params->nelem_hint * 4 / 3),
|
2015-03-18 03:01:21 -06:00
|
|
|
(unsigned long)params->min_size);
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rhashtable_init - initialize a new hash table
|
|
|
|
* @ht: hash table to be initialized
|
|
|
|
* @params: configuration parameters
|
|
|
|
*
|
|
|
|
* Initializes a new hash table based on the provided configuration
|
|
|
|
* parameters. A table can be configured either with a variable or
|
|
|
|
* fixed length key:
|
|
|
|
*
|
|
|
|
* Configuration Example 1: Fixed length keys
|
|
|
|
* struct test_obj {
|
|
|
|
* int key;
|
|
|
|
* void * my_member;
|
|
|
|
* struct rhash_head node;
|
|
|
|
* };
|
|
|
|
*
|
|
|
|
* struct rhashtable_params params = {
|
|
|
|
* .head_offset = offsetof(struct test_obj, node),
|
|
|
|
* .key_offset = offsetof(struct test_obj, key),
|
|
|
|
* .key_len = sizeof(int),
|
2014-12-10 08:33:11 -07:00
|
|
|
* .hashfn = jhash,
|
2015-01-02 15:00:21 -07:00
|
|
|
* .nulls_base = (1U << RHT_BASE_SHIFT),
|
2014-08-02 03:47:44 -06:00
|
|
|
* };
|
|
|
|
*
|
|
|
|
* Configuration Example 2: Variable length keys
|
|
|
|
* struct test_obj {
|
|
|
|
* [...]
|
|
|
|
* struct rhash_head node;
|
|
|
|
* };
|
|
|
|
*
|
|
|
|
* u32 my_hash_fn(const void *data, u32 seed)
|
|
|
|
* {
|
|
|
|
* struct test_obj *obj = data;
|
|
|
|
*
|
|
|
|
* return [... hash ...];
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* struct rhashtable_params params = {
|
|
|
|
* .head_offset = offsetof(struct test_obj, node),
|
2014-12-10 08:33:11 -07:00
|
|
|
* .hashfn = jhash,
|
2014-08-02 03:47:44 -06:00
|
|
|
* .obj_hashfn = my_hash_fn,
|
|
|
|
* };
|
|
|
|
*/
|
2015-03-20 04:56:59 -06:00
|
|
|
int rhashtable_init(struct rhashtable *ht,
|
|
|
|
const struct rhashtable_params *params)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
|
|
|
struct bucket_table *tbl;
|
|
|
|
size_t size;
|
|
|
|
|
|
|
|
size = HASH_DEFAULT_SIZE;
|
|
|
|
|
|
|
|
if ((params->key_len && !params->hashfn) ||
|
|
|
|
(!params->key_len && !params->obj_hashfn))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2015-01-02 15:00:21 -07:00
|
|
|
if (params->nulls_base && params->nulls_base < (1U << RHT_BASE_SHIFT))
|
|
|
|
return -EINVAL;
|
|
|
|
|
2014-08-02 03:47:44 -06:00
|
|
|
if (params->nelem_hint)
|
2014-09-02 19:22:36 -06:00
|
|
|
size = rounded_hashtable_size(params);
|
2014-08-02 03:47:44 -06:00
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
memset(ht, 0, sizeof(*ht));
|
|
|
|
mutex_init(&ht->mutex);
|
|
|
|
memcpy(&ht->p, params, sizeof(*params));
|
|
|
|
|
2015-03-19 16:31:13 -06:00
|
|
|
if (params->min_size)
|
|
|
|
ht->p.min_size = roundup_pow_of_two(params->min_size);
|
|
|
|
|
|
|
|
if (params->max_size)
|
|
|
|
ht->p.max_size = rounddown_pow_of_two(params->max_size);
|
|
|
|
|
2015-03-20 04:56:59 -06:00
|
|
|
ht->p.min_size = max(ht->p.min_size, HASH_MIN_SIZE);
|
2015-03-19 16:31:13 -06:00
|
|
|
|
2015-01-02 15:00:20 -07:00
|
|
|
if (params->locks_mul)
|
|
|
|
ht->p.locks_mul = roundup_pow_of_two(params->locks_mul);
|
|
|
|
else
|
|
|
|
ht->p.locks_mul = BUCKET_LOCKS_PER_CPU;
|
|
|
|
|
2015-03-13 20:57:22 -06:00
|
|
|
tbl = bucket_table_alloc(ht, size);
|
2014-08-02 03:47:44 -06:00
|
|
|
if (tbl == NULL)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2015-01-06 22:41:57 -07:00
|
|
|
atomic_set(&ht->nelems, 0);
|
2015-03-12 08:28:40 -06:00
|
|
|
|
2014-08-02 03:47:44 -06:00
|
|
|
RCU_INIT_POINTER(ht->tbl, tbl);
|
|
|
|
|
2015-02-25 08:31:54 -07:00
|
|
|
INIT_WORK(&ht->run_work, rht_deferred_worker);
|
2015-01-02 15:00:20 -07:00
|
|
|
|
2014-08-02 03:47:44 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_init);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* rhashtable_destroy - destroy hash table
|
|
|
|
* @ht: the hash table to destroy
|
|
|
|
*
|
2014-09-01 16:26:05 -06:00
|
|
|
* Frees the bucket array. This function is not rcu safe, therefore the caller
|
|
|
|
* has to make sure that no resizing may happen by unpublishing the hashtable
|
|
|
|
* and waiting for the quiescent cycle before releasing the bucket array.
|
2014-08-02 03:47:44 -06:00
|
|
|
*/
|
2015-01-02 15:00:20 -07:00
|
|
|
void rhashtable_destroy(struct rhashtable *ht)
|
2014-08-02 03:47:44 -06:00
|
|
|
{
|
2015-01-02 15:00:20 -07:00
|
|
|
ht->being_destroyed = true;
|
|
|
|
|
2015-02-25 08:31:54 -07:00
|
|
|
cancel_work_sync(&ht->run_work);
|
2015-01-02 15:00:20 -07:00
|
|
|
|
rhashtable: Fix race in rhashtable_destroy() and use regular work_struct
When we put our declared work task in the global workqueue with
schedule_delayed_work(), its delay parameter is always zero.
Therefore, we should define a regular work in rhashtable structure
instead of a delayed work.
By the way, we add a condition to check whether resizing functions
are NULL before cancelling the work, avoiding to cancel an
uninitialized work.
Lastly, while we wait for all work items we submitted before to run
to completion with cancel_delayed_work(), ht->mutex has been taken in
rhashtable_destroy(). Moreover, cancel_delayed_work() doesn't return
until all work items are accomplished, and when work items are
scheduled, the work's function - rht_deferred_worker() will be called.
However, as rht_deferred_worker() also needs to acquire the lock,
deadlock might happen at the moment as the lock is already held before.
So if the cancel work function is moved out of the lock covered scope,
this will avoid the deadlock.
Fixes: 97defe1 ("rhashtable: Per bucket locks & deferred expansion/shrinking")
Signed-off-by: Ying Xue <ying.xue@windriver.com>
Cc: Thomas Graf <tgraf@suug.ch>
Acked-by: Thomas Graf <tgraf@suug.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>
2015-01-15 20:13:09 -07:00
|
|
|
mutex_lock(&ht->mutex);
|
2015-01-02 15:00:20 -07:00
|
|
|
bucket_table_free(rht_dereference(ht->tbl, ht));
|
|
|
|
mutex_unlock(&ht->mutex);
|
2014-08-02 03:47:44 -06:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(rhashtable_destroy);
|