rhashtable.c 25.7 KB
Newer Older
1 2 3
/*
 * Resizable, Scalable, Concurrent Hash Table
 *
4
 * Copyright (c) 2014-2015 Thomas Graf <tgraf@suug.ch>
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 * 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>
E
Eric Dumazet 已提交
20
#include <linux/sched.h>
21 22 23
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mm.h>
24
#include <linux/jhash.h>
25 26
#include <linux/random.h>
#include <linux/rhashtable.h>
27
#include <linux/err.h>
28 29 30

#define HASH_DEFAULT_SIZE	64UL
#define HASH_MIN_SIZE		4UL
31 32
#define BUCKET_LOCKS_PER_CPU   128UL

33 34 35
/* Base bits plus 1 bit for nulls marker */
#define HASH_RESERVED_SPACE	(RHT_BASE_BITS + 1)

36 37 38
/* The bucket lock is selected based on the hash and protects mutations
 * on a group of hash buckets.
 *
39 40 41 42 43 44
 * 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.
 *
45 46 47 48 49 50 51 52
 * 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];
}
53

54
static void *rht_obj(const struct rhashtable *ht, const struct rhash_head *he)
55 56 57 58
{
	return (void *) he - ht->p.head_offset;
}

59
static u32 rht_bucket_index(const struct bucket_table *tbl, u32 hash)
60
{
H
Herbert Xu 已提交
61
	return (hash >> HASH_RESERVED_SPACE) & (tbl->size - 1);
62 63
}

64
static u32 key_hashfn(struct rhashtable *ht, const struct bucket_table *tbl,
65
		      const void *key)
66
{
67
	return rht_bucket_index(tbl, ht->p.hashfn(key, ht->p.key_len,
H
Herbert Xu 已提交
68
						  tbl->hash_rnd));
69 70
}

71
static u32 head_hashfn(struct rhashtable *ht,
72 73
		       const struct bucket_table *tbl,
		       const struct rhash_head *he)
74
{
H
Herbert Xu 已提交
75 76 77 78 79
	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));
80 81
}

82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
#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


103 104 105 106 107 108 109 110 111 112 113 114
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);

115 116
	/* Never allocate more than 0.5 locks per bucket */
	size = min_t(unsigned int, size, tbl->size >> 1);
117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144

	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);
}

static struct bucket_table *bucket_table_alloc(struct rhashtable *ht,
145
					       size_t nbuckets, u32 hash_rnd)
146
{
147
	struct bucket_table *tbl = NULL;
148
	size_t size;
149
	int i;
150 151

	size = sizeof(*tbl) + nbuckets * sizeof(tbl->buckets[0]);
152 153
	if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER))
		tbl = kzalloc(size, GFP_KERNEL | __GFP_NOWARN | __GFP_NORETRY);
154 155 156 157 158 159
	if (tbl == NULL)
		tbl = vzalloc(size);
	if (tbl == NULL)
		return NULL;

	tbl->size = nbuckets;
160 161
	tbl->shift = ilog2(nbuckets);
	tbl->hash_rnd = hash_rnd;
162

163 164 165 166
	if (alloc_bucket_locks(ht, tbl) < 0) {
		bucket_table_free(tbl);
		return NULL;
	}
167

168 169
	INIT_LIST_HEAD(&tbl->walkers);

170 171 172
	for (i = 0; i < nbuckets; i++)
		INIT_RHT_NULLS_HEAD(tbl->buckets[i], ht, i);

173
	return tbl;
174 175 176 177 178
}

/**
 * rht_grow_above_75 - returns true if nelems > 0.75 * table-size
 * @ht:		hash table
179
 * @tbl:	current table
180
 */
181 182
static bool rht_grow_above_75(const struct rhashtable *ht,
			      const struct bucket_table *tbl)
183 184
{
	/* Expand table when exceeding 75% load */
185 186
	return atomic_read(&ht->nelems) > (tbl->size / 4 * 3) &&
	       (!ht->p.max_shift || tbl->shift < ht->p.max_shift);
187 188 189 190 191
}

/**
 * rht_shrink_below_30 - returns true if nelems < 0.3 * table-size
 * @ht:		hash table
192
 * @tbl:	current table
193
 */
194 195
static bool rht_shrink_below_30(const struct rhashtable *ht,
				const struct bucket_table *tbl)
196 197
{
	/* Shrink table beneath 30% load */
198 199
	return atomic_read(&ht->nelems) < (tbl->size * 3 / 10) &&
	       tbl->shift > ht->p.min_shift;
200 201
}

202
static int rhashtable_rehash_one(struct rhashtable *ht, unsigned old_hash)
203
{
204 205 206 207 208 209 210 211 212 213 214 215 216 217
	struct bucket_table *new_tbl = rht_dereference(ht->future_tbl, ht);
	struct bucket_table *old_tbl = rht_dereference(ht->tbl, ht);
	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;
218

219 220
		pprev = &entry->next;
	}
221

222 223
	if (err)
		goto out;
224

225
	new_hash = head_hashfn(ht, new_tbl, entry);
226

227
	new_bucket_lock = bucket_lock(new_tbl, new_hash);
228

229
	spin_lock_nested(new_bucket_lock, SINGLE_DEPTH_NESTING);
230 231
	head = rht_dereference_bucket(new_tbl->buckets[new_hash],
				      new_tbl, new_hash);
232

233 234 235 236
	if (rht_is_a_nulls(head))
		INIT_RHT_NULLS_HEAD(entry->next, ht, new_hash);
	else
		RCU_INIT_POINTER(entry->next, head);
237

238 239
	rcu_assign_pointer(new_tbl->buckets[new_hash], entry);
	spin_unlock(new_bucket_lock);
240

241
	rcu_assign_pointer(*pprev, next);
242

243 244 245
out:
	return err;
}
246

247 248 249 250 251 252
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);
253

254 255 256 257
	spin_lock_bh(old_bucket_lock);
	while (!rhashtable_rehash_one(ht, old_hash))
		;
	spin_unlock_bh(old_bucket_lock);
258 259
}

260 261
static void rhashtable_rehash(struct rhashtable *ht,
			      struct bucket_table *new_tbl)
262
{
263
	struct bucket_table *old_tbl = rht_dereference(ht->tbl, ht);
264
	struct rhashtable_walker *walker;
265
	unsigned old_hash;
266

267 268 269 270 271 272 273 274 275
	get_random_bytes(&new_tbl->hash_rnd, sizeof(new_tbl->hash_rnd));

	/* Make insertions go into the new, empty table right away. Deletions
	 * and lookups will be attempted in both tables until we synchronize.
	 * The synchronize_rcu() guarantees for the new table to be picked up
	 * so no new additions go into the old table while we relink.
	 */
	rcu_assign_pointer(ht->future_tbl, new_tbl);

H
Herbert Xu 已提交
276 277 278
	/* Ensure the new table is visible to readers. */
	smp_wmb();

279 280 281 282 283 284
	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);

285 286 287
	list_for_each_entry(walker, &old_tbl->walkers, list)
		walker->tbl = NULL;

288 289 290 291 292 293 294
	/* Wait for readers. All new readers will see the new
	 * table, and thus no references to the old table will
	 * remain.
	 */
	synchronize_rcu();

	bucket_table_free(old_tbl);
295 296 297 298 299 300
}

/**
 * rhashtable_expand - Expand hash table while allowing concurrent lookups
 * @ht:		the hash table to expand
 *
301
 * A secondary bucket array is allocated and the hash entries are migrated.
302 303 304 305
 *
 * 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.
 *
306 307 308 309 310
 * 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.
311
 */
312
int rhashtable_expand(struct rhashtable *ht)
313 314 315 316 317
{
	struct bucket_table *new_tbl, *old_tbl = rht_dereference(ht->tbl, ht);

	ASSERT_RHT_MUTEX(ht);

318
	new_tbl = bucket_table_alloc(ht, old_tbl->size * 2, old_tbl->hash_rnd);
319 320 321
	if (new_tbl == NULL)
		return -ENOMEM;

322
	rhashtable_rehash(ht, new_tbl);
323 324 325 326 327 328 329 330 331 332 333
	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.
 *
334 335 336
 * The caller must ensure that no concurrent resizing occurs by holding
 * ht->mutex.
 *
337 338
 * The caller must ensure that no concurrent table mutations take place.
 * It is however valid to have concurrent lookups if they are RCU protected.
339 340 341
 *
 * It is valid to have concurrent insertions and deletions protected by per
 * bucket locks or concurrent RCU protected lookups and traversals.
342
 */
343
int rhashtable_shrink(struct rhashtable *ht)
344
{
345
	struct bucket_table *new_tbl, *old_tbl = rht_dereference(ht->tbl, ht);
346 347 348

	ASSERT_RHT_MUTEX(ht);

349
	new_tbl = bucket_table_alloc(ht, old_tbl->size / 2, old_tbl->hash_rnd);
350
	if (new_tbl == NULL)
351 352
		return -ENOMEM;

353
	rhashtable_rehash(ht, new_tbl);
354 355 356 357
	return 0;
}
EXPORT_SYMBOL_GPL(rhashtable_shrink);

358 359 360 361 362
static void rht_deferred_worker(struct work_struct *work)
{
	struct rhashtable *ht;
	struct bucket_table *tbl;

363
	ht = container_of(work, struct rhashtable, run_work);
364
	mutex_lock(&ht->mutex);
365 366 367
	if (ht->being_destroyed)
		goto unlock;

368 369
	tbl = rht_dereference(ht->tbl, ht);

370
	if (rht_grow_above_75(ht, tbl))
371
		rhashtable_expand(ht);
372
	else if (rht_shrink_below_30(ht, tbl))
373
		rhashtable_shrink(ht);
374
unlock:
375 376 377
	mutex_unlock(&ht->mutex);
}

378 379
static bool __rhashtable_insert(struct rhashtable *ht, struct rhash_head *obj,
				bool (*compare)(void *, void *), void *arg)
380
{
381
	struct bucket_table *tbl, *old_tbl;
382
	struct rhash_head *head;
383 384 385 386 387 388 389
	bool no_resize_running;
	unsigned hash;
	bool success = true;

	rcu_read_lock();

	old_tbl = rht_dereference_rcu(ht->tbl, ht);
390
	hash = head_hashfn(ht, old_tbl, obj);
391 392 393 394 395 396 397 398 399 400 401

	spin_lock_bh(bucket_lock(old_tbl, hash));

	/* 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.
	 */
	tbl = rht_dereference_rcu(ht->future_tbl, ht);
	if (tbl != old_tbl) {
402
		hash = head_hashfn(ht, tbl, obj);
403
		spin_lock_nested(bucket_lock(tbl, hash), SINGLE_DEPTH_NESTING);
404 405 406 407 408 409 410 411 412 413
	}

	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;
414 415

	head = rht_dereference_bucket(tbl->buckets[hash], tbl, hash);
416 417 418 419 420 421 422 423 424

	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);
425
	if (no_resize_running && rht_grow_above_75(ht, tbl))
426
		schedule_work(&ht->run_work);
427 428 429

exit:
	if (tbl != old_tbl) {
430
		hash = head_hashfn(ht, tbl, obj);
431 432 433
		spin_unlock(bucket_lock(tbl, hash));
	}

434
	hash = head_hashfn(ht, old_tbl, obj);
435 436 437 438 439
	spin_unlock_bh(bucket_lock(old_tbl, hash));

	rcu_read_unlock();

	return success;
440 441
}

442
/**
443
 * rhashtable_insert - insert object into hash table
444 445 446
 * @ht:		hash table
 * @obj:	pointer to hash head inside object
 *
447 448 449
 * 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.
450
 *
451 452 453 454 455
 * 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().
456
 */
457
void rhashtable_insert(struct rhashtable *ht, struct rhash_head *obj)
458
{
459 460 461 462 463 464 465 466 467 468 469
	__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;
470
	unsigned hash;
471
	bool ret = false;
472

473
	hash = head_hashfn(ht, tbl, obj);
474
	lock = bucket_lock(tbl, hash);
475

476
	spin_lock_bh(lock);
477

478 479 480 481 482 483
	pprev = &tbl->buckets[hash];
	rht_for_each(he, tbl, hash) {
		if (he != obj) {
			pprev = &he->next;
			continue;
		}
484

485 486 487 488 489 490 491 492
		rcu_assign_pointer(*pprev, obj->next);
		ret = true;
		break;
	}

	spin_unlock_bh(lock);

	return ret;
493 494 495 496 497 498 499 500 501 502 503
}

/**
 * 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.
 *
504
 * Will automatically shrink the table via rhashtable_expand() if the
505 506 507 508 509
 * 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.
 */
510
bool rhashtable_remove(struct rhashtable *ht, struct rhash_head *obj)
511
{
512 513
	struct bucket_table *tbl, *old_tbl;
	bool ret;
514

515
	rcu_read_lock();
516

517 518
	old_tbl = rht_dereference_rcu(ht->tbl, ht);
	ret = __rhashtable_remove(ht, old_tbl, obj);
519

520 521 522 523
	/* 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
	 * old_tbl if it exists.
524
	 */
525 526 527
	tbl = rht_dereference_rcu(ht->future_tbl, ht);
	if (!ret && old_tbl != tbl)
		ret = __rhashtable_remove(ht, tbl, obj);
528 529

	if (ret) {
530
		bool no_resize_running = tbl == old_tbl;
531

532
		atomic_dec(&ht->nelems);
533
		if (no_resize_running && rht_shrink_below_30(ht, tbl))
534
			schedule_work(&ht->run_work);
535 536
	}

537 538
	rcu_read_unlock();

539
	return ret;
540 541 542
}
EXPORT_SYMBOL_GPL(rhashtable_remove);

543 544 545 546 547 548 549 550 551 552 553 554 555
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);
}

556 557 558 559 560 561 562 563 564
/**
 * 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
565
 * parameter set). It will BUG() if used inappropriately.
566
 *
567
 * Lookups may occur in parallel with hashtable mutations and resizing.
568
 */
569
void *rhashtable_lookup(struct rhashtable *ht, const void *key)
570
{
571 572 573 574
	struct rhashtable_compare_arg arg = {
		.ht = ht,
		.key = key,
	};
575 576 577

	BUG_ON(!ht->p.key_len);

578
	return rhashtable_lookup_compare(ht, key, &rhashtable_compare, &arg);
579 580 581 582 583 584
}
EXPORT_SYMBOL_GPL(rhashtable_lookup);

/**
 * rhashtable_lookup_compare - search hash table with compare function
 * @ht:		hash table
585
 * @key:	the pointer to the key
586 587 588 589 590 591
 * @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.
 *
592
 * Lookups may occur in parallel with hashtable mutations and resizing.
593 594 595
 *
 * Returns the first entry on which the compare function returned true.
 */
596
void *rhashtable_lookup_compare(struct rhashtable *ht, const void *key,
597 598
				bool (*compare)(void *, void *), void *arg)
{
599
	const struct bucket_table *tbl, *old_tbl;
600
	struct rhash_head *he;
601
	u32 hash;
602

603 604
	rcu_read_lock();

605
	tbl = rht_dereference_rcu(ht->tbl, ht);
606
restart:
607
	hash = key_hashfn(ht, tbl, key);
608
	rht_for_each_rcu(he, tbl, hash) {
609 610
		if (!compare(rht_obj(ht, he), arg))
			continue;
611
		rcu_read_unlock();
612
		return rht_obj(ht, he);
613 614
	}

H
Herbert Xu 已提交
615 616 617
	/* Ensure we see any new tables. */
	smp_rmb();

618 619 620
	old_tbl = tbl;
	tbl = rht_dereference_rcu(ht->future_tbl, ht);
	if (unlikely(tbl != old_tbl))
621 622 623
		goto restart;
	rcu_read_unlock();

624 625 626 627
	return NULL;
}
EXPORT_SYMBOL_GPL(rhashtable_lookup_compare);

628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
/**
 * 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)
649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
{
	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)
686 687 688
{
	BUG_ON(!ht->p.key_len);

689
	return __rhashtable_insert(ht, obj, compare, arg);
690
}
691
EXPORT_SYMBOL_GPL(rhashtable_lookup_compare_insert);
692

693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
/**
 * 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);
726 727
	iter->walker->tbl = rht_dereference(ht->tbl, ht);
	list_add(&iter->walker->list, &iter->walker->tbl->walkers);
728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
	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);
743 744
	if (iter->walker->tbl)
		list_del(&iter->walker->list);
745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765
	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)
{
766 767 768 769 770 771 772
	struct rhashtable *ht = iter->ht;

	mutex_lock(&ht->mutex);

	if (iter->walker->tbl)
		list_del(&iter->walker->list);

773 774
	rcu_read_lock();

775 776 777 778
	mutex_unlock(&ht->mutex);

	if (!iter->walker->tbl) {
		iter->walker->tbl = rht_dereference_rcu(ht->tbl, ht);
779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799
		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)
{
800
	struct bucket_table *tbl = iter->walker->tbl;
801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829
	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;
	}

830 831
	iter->walker->tbl = rht_dereference_rcu(ht->future_tbl, ht);
	if (iter->walker->tbl != tbl) {
832 833 834 835 836
		iter->slot = 0;
		iter->skip = 0;
		return ERR_PTR(-EAGAIN);
	}

837 838 839 840 841
	iter->walker->tbl = NULL;
	iter->p = NULL;

out:

842 843 844 845 846 847 848 849 850 851 852 853
	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)
{
854 855 856
	struct rhashtable *ht;
	struct bucket_table *tbl = iter->walker->tbl;

857
	rcu_read_unlock();
858 859 860 861 862 863 864 865 866 867 868 869 870 871

	if (!tbl)
		return;

	ht = iter->ht;

	mutex_lock(&ht->mutex);
	if (rht_dereference(ht->tbl, ht) == tbl ||
	    rht_dereference(ht->future_tbl, ht) == tbl)
		list_add(&iter->walker->list, &tbl->walkers);
	else
		iter->walker->tbl = NULL;
	mutex_unlock(&ht->mutex);

872 873 874 875
	iter->p = NULL;
}
EXPORT_SYMBOL_GPL(rhashtable_walk_stop);

876
static size_t rounded_hashtable_size(struct rhashtable_params *params)
877
{
878 879
	return max(roundup_pow_of_two(params->nelem_hint * 4 / 3),
		   1UL << params->min_shift);
880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901
}

/**
 * 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),
902
 *	.hashfn = jhash,
903
 *	.nulls_base = (1U << RHT_BASE_SHIFT),
904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920
 * };
 *
 * 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),
921
 *	.hashfn = jhash,
922 923 924 925 926 927 928
 *	.obj_hashfn = my_hash_fn,
 * };
 */
int rhashtable_init(struct rhashtable *ht, struct rhashtable_params *params)
{
	struct bucket_table *tbl;
	size_t size;
929
	u32 hash_rnd;
930 931 932 933 934 935 936

	size = HASH_DEFAULT_SIZE;

	if ((params->key_len && !params->hashfn) ||
	    (!params->key_len && !params->obj_hashfn))
		return -EINVAL;

937 938 939
	if (params->nulls_base && params->nulls_base < (1U << RHT_BASE_SHIFT))
		return -EINVAL;

940 941 942
	params->min_shift = max_t(size_t, params->min_shift,
				  ilog2(HASH_MIN_SIZE));

943
	if (params->nelem_hint)
944
		size = rounded_hashtable_size(params);
945

946 947 948 949 950 951 952 953 954
	memset(ht, 0, sizeof(*ht));
	mutex_init(&ht->mutex);
	memcpy(&ht->p, params, sizeof(*params));

	if (params->locks_mul)
		ht->p.locks_mul = roundup_pow_of_two(params->locks_mul);
	else
		ht->p.locks_mul = BUCKET_LOCKS_PER_CPU;

955 956 957
	get_random_bytes(&hash_rnd, sizeof(hash_rnd));

	tbl = bucket_table_alloc(ht, size, hash_rnd);
958 959 960
	if (tbl == NULL)
		return -ENOMEM;

961
	atomic_set(&ht->nelems, 0);
962

963
	RCU_INIT_POINTER(ht->tbl, tbl);
964
	RCU_INIT_POINTER(ht->future_tbl, tbl);
965

966
	INIT_WORK(&ht->run_work, rht_deferred_worker);
967

968 969 970 971 972 973 974 975
	return 0;
}
EXPORT_SYMBOL_GPL(rhashtable_init);

/**
 * rhashtable_destroy - destroy hash table
 * @ht:		the hash table to destroy
 *
976 977 978
 * 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.
979
 */
980
void rhashtable_destroy(struct rhashtable *ht)
981
{
982 983
	ht->being_destroyed = true;

984
	cancel_work_sync(&ht->run_work);
985

986
	mutex_lock(&ht->mutex);
987 988
	bucket_table_free(rht_dereference(ht->tbl, ht));
	mutex_unlock(&ht->mutex);
989 990
}
EXPORT_SYMBOL_GPL(rhashtable_destroy);