rhashtable.c 24.5 KB
Newer Older
1 2 3
/*
 * Resizable, Scalable, Concurrent Hash Table
 *
4
 * Copyright (c) 2015 Herbert Xu <herbert@gondor.apana.org.au>
5
 * Copyright (c) 2014-2015 Thomas Graf <tgraf@suug.ch>
6 7 8
 * Copyright (c) 2008-2014 Patrick McHardy <kaber@trash.net>
 *
 * Code partially derived from nft_hash
9 10
 * Rewritten with rehash code from br_multicast plus single list
 * pointer as suggested by Josh Triplett
11 12 13 14 15 16
 *
 * 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.
 */

17
#include <linux/atomic.h>
18 19 20
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/log2.h>
21
#include <linux/sched.h>
22 23 24
#include <linux/slab.h>
#include <linux/vmalloc.h>
#include <linux/mm.h>
25
#include <linux/jhash.h>
26 27
#include <linux/random.h>
#include <linux/rhashtable.h>
28
#include <linux/err.h>
29
#include <linux/export.h>
30 31

#define HASH_DEFAULT_SIZE	64UL
32
#define HASH_MIN_SIZE		4U
33
#define BUCKET_LOCKS_PER_CPU	32UL
34

35
static u32 head_hashfn(struct rhashtable *ht,
36 37
		       const struct bucket_table *tbl,
		       const struct rhash_head *he)
38
{
39
	return rht_head_hashfn(ht, tbl, he, ht->p);
40 41
}

42 43 44 45 46 47 48 49 50 51 52
#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)
{
53
	spinlock_t *lock = rht_bucket_lock(tbl, hash);
54 55 56 57 58 59 60 61 62

	return (debug_locks) ? lockdep_is_held(lock) : 1;
}
EXPORT_SYMBOL_GPL(lockdep_rht_bucket_is_held);
#else
#define ASSERT_RHT_MUTEX(HT)
#endif


63 64
static int alloc_bucket_locks(struct rhashtable *ht, struct bucket_table *tbl,
			      gfp_t gfp)
65 66 67 68 69 70 71 72
{
	unsigned int i, size;
#if defined(CONFIG_PROVE_LOCKING)
	unsigned int nr_pcpus = 2;
#else
	unsigned int nr_pcpus = num_possible_cpus();
#endif

73
	nr_pcpus = min_t(unsigned int, nr_pcpus, 64UL);
74 75
	size = roundup_pow_of_two(nr_pcpus * ht->p.locks_mul);

76 77
	/* Never allocate more than 0.5 locks per bucket */
	size = min_t(unsigned int, size, tbl->size >> 1);
78 79

	if (sizeof(spinlock_t) != 0) {
80
		tbl->locks = NULL;
81
#ifdef CONFIG_NUMA
82 83
		if (size * sizeof(spinlock_t) > PAGE_SIZE &&
		    gfp == GFP_KERNEL)
84 85
			tbl->locks = vmalloc(size * sizeof(spinlock_t));
#endif
86 87 88
		if (gfp != GFP_KERNEL)
			gfp |= __GFP_NOWARN | __GFP_NORETRY;

89 90 91
		if (!tbl->locks)
			tbl->locks = kmalloc_array(size, sizeof(spinlock_t),
						   gfp);
92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109
		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);
}

110 111 112 113 114
static void bucket_table_free_rcu(struct rcu_head *head)
{
	bucket_table_free(container_of(head, struct bucket_table, rcu));
}

115
static struct bucket_table *bucket_table_alloc(struct rhashtable *ht,
116 117
					       size_t nbuckets,
					       gfp_t gfp)
118
{
119
	struct bucket_table *tbl = NULL;
120
	size_t size;
121
	int i;
122 123

	size = sizeof(*tbl) + nbuckets * sizeof(tbl->buckets[0]);
124 125 126 127
	if (size <= (PAGE_SIZE << PAGE_ALLOC_COSTLY_ORDER) ||
	    gfp != GFP_KERNEL)
		tbl = kzalloc(size, gfp | __GFP_NOWARN | __GFP_NORETRY);
	if (tbl == NULL && gfp == GFP_KERNEL)
128 129 130 131 132 133
		tbl = vzalloc(size);
	if (tbl == NULL)
		return NULL;

	tbl->size = nbuckets;

134
	if (alloc_bucket_locks(ht, tbl, gfp) < 0) {
135 136 137
		bucket_table_free(tbl);
		return NULL;
	}
138

139 140
	INIT_LIST_HEAD(&tbl->walkers);

141 142
	get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));

143 144 145
	for (i = 0; i < nbuckets; i++)
		INIT_RHT_NULLS_HEAD(tbl->buckets[i], ht, i);

146
	return tbl;
147 148
}

149 150 151 152 153 154 155 156 157 158 159 160 161
static struct bucket_table *rhashtable_last_table(struct rhashtable *ht,
						  struct bucket_table *tbl)
{
	struct bucket_table *new_tbl;

	do {
		new_tbl = tbl;
		tbl = rht_dereference_rcu(tbl->future_tbl, ht);
	} while (tbl);

	return new_tbl;
}

162
static int rhashtable_rehash_one(struct rhashtable *ht, unsigned int old_hash)
163
{
164
	struct bucket_table *old_tbl = rht_dereference(ht->tbl, ht);
165 166
	struct bucket_table *new_tbl = rhashtable_last_table(ht,
		rht_dereference_rcu(old_tbl->future_tbl, ht));
167 168 169 170
	struct rhash_head __rcu **pprev = &old_tbl->buckets[old_hash];
	int err = -ENOENT;
	struct rhash_head *head, *next, *entry;
	spinlock_t *new_bucket_lock;
171
	unsigned int new_hash;
172 173 174 175 176 177 178

	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;
179

180 181
		pprev = &entry->next;
	}
182

183 184
	if (err)
		goto out;
185

186
	new_hash = head_hashfn(ht, new_tbl, entry);
187

188
	new_bucket_lock = rht_bucket_lock(new_tbl, new_hash);
189

190
	spin_lock_nested(new_bucket_lock, SINGLE_DEPTH_NESTING);
191 192
	head = rht_dereference_bucket(new_tbl->buckets[new_hash],
				      new_tbl, new_hash);
193

194
	RCU_INIT_POINTER(entry->next, head);
195

196 197
	rcu_assign_pointer(new_tbl->buckets[new_hash], entry);
	spin_unlock(new_bucket_lock);
198

199
	rcu_assign_pointer(*pprev, next);
200

201 202 203
out:
	return err;
}
204

205 206
static void rhashtable_rehash_chain(struct rhashtable *ht,
				    unsigned int old_hash)
207 208 209 210
{
	struct bucket_table *old_tbl = rht_dereference(ht->tbl, ht);
	spinlock_t *old_bucket_lock;

211
	old_bucket_lock = rht_bucket_lock(old_tbl, old_hash);
212

213 214 215
	spin_lock_bh(old_bucket_lock);
	while (!rhashtable_rehash_one(ht, old_hash))
		;
216
	old_tbl->rehash++;
217
	spin_unlock_bh(old_bucket_lock);
218 219
}

220 221 222
static int rhashtable_rehash_attach(struct rhashtable *ht,
				    struct bucket_table *old_tbl,
				    struct bucket_table *new_tbl)
223
{
224 225 226 227 228 229 230 231
	/* Protect future_tbl using the first bucket lock. */
	spin_lock_bh(old_tbl->locks);

	/* Did somebody beat us to it? */
	if (rcu_access_pointer(old_tbl->future_tbl)) {
		spin_unlock_bh(old_tbl->locks);
		return -EEXIST;
	}
232

233 234 235
	/* Make insertions go into the new, empty table right away. Deletions
	 * and lookups will be attempted in both tables until we synchronize.
	 */
236
	rcu_assign_pointer(old_tbl->future_tbl, new_tbl);
237

238 239 240 241 242 243 244 245 246 247
	spin_unlock_bh(old_tbl->locks);

	return 0;
}

static int rhashtable_rehash_table(struct rhashtable *ht)
{
	struct bucket_table *old_tbl = rht_dereference(ht->tbl, ht);
	struct bucket_table *new_tbl;
	struct rhashtable_walker *walker;
248
	unsigned int old_hash;
249 250 251 252 253

	new_tbl = rht_dereference(old_tbl->future_tbl, ht);
	if (!new_tbl)
		return 0;

254
	for (old_hash = 0; old_hash < old_tbl->size; old_hash++) {
255
		rhashtable_rehash_chain(ht, old_hash);
256 257
		cond_resched();
	}
258 259 260 261

	/* Publish the new table pointer. */
	rcu_assign_pointer(ht->tbl, new_tbl);

262
	spin_lock(&ht->lock);
263 264
	list_for_each_entry(walker, &old_tbl->walkers, list)
		walker->tbl = NULL;
265
	spin_unlock(&ht->lock);
266

267 268 269 270
	/* Wait for readers. All new readers will see the new
	 * table, and thus no references to the old table will
	 * remain.
	 */
271
	call_rcu(&old_tbl->rcu, bucket_table_free_rcu);
272 273

	return rht_dereference(new_tbl->future_tbl, ht) ? -EAGAIN : 0;
274 275 276 277 278 279
}

/**
 * rhashtable_expand - Expand hash table while allowing concurrent lookups
 * @ht:		the hash table to expand
 *
280
 * A secondary bucket array is allocated and the hash entries are migrated.
281 282 283 284
 *
 * 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.
 *
285 286 287 288 289
 * 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.
290
 */
291
static int rhashtable_expand(struct rhashtable *ht)
292 293
{
	struct bucket_table *new_tbl, *old_tbl = rht_dereference(ht->tbl, ht);
294
	int err;
295 296 297

	ASSERT_RHT_MUTEX(ht);

298 299
	old_tbl = rhashtable_last_table(ht, old_tbl);

300
	new_tbl = bucket_table_alloc(ht, old_tbl->size * 2, GFP_KERNEL);
301 302 303
	if (new_tbl == NULL)
		return -ENOMEM;

304 305 306 307 308
	err = rhashtable_rehash_attach(ht, old_tbl, new_tbl);
	if (err)
		bucket_table_free(new_tbl);

	return err;
309 310 311 312 313 314
}

/**
 * rhashtable_shrink - Shrink hash table while allowing concurrent lookups
 * @ht:		the hash table to shrink
 *
Herbert Xu's avatar
Herbert Xu committed
315 316
 * This function shrinks the hash table to fit, i.e., the smallest
 * size would not cause it to expand right away automatically.
317
 *
318 319 320
 * The caller must ensure that no concurrent resizing occurs by holding
 * ht->mutex.
 *
321 322
 * The caller must ensure that no concurrent table mutations take place.
 * It is however valid to have concurrent lookups if they are RCU protected.
323 324 325
 *
 * It is valid to have concurrent insertions and deletions protected by per
 * bucket locks or concurrent RCU protected lookups and traversals.
326
 */
327
static int rhashtable_shrink(struct rhashtable *ht)
328
{
329
	struct bucket_table *new_tbl, *old_tbl = rht_dereference(ht->tbl, ht);
330 331
	unsigned int nelems = atomic_read(&ht->nelems);
	unsigned int size = 0;
332
	int err;
333 334 335

	ASSERT_RHT_MUTEX(ht);

336 337
	if (nelems)
		size = roundup_pow_of_two(nelems * 3 / 2);
Herbert Xu's avatar
Herbert Xu committed
338 339 340 341 342 343
	if (size < ht->p.min_size)
		size = ht->p.min_size;

	if (old_tbl->size <= size)
		return 0;

344 345 346
	if (rht_dereference(old_tbl->future_tbl, ht))
		return -EEXIST;

347
	new_tbl = bucket_table_alloc(ht, size, GFP_KERNEL);
348
	if (new_tbl == NULL)
349 350
		return -ENOMEM;

351 352 353 354 355
	err = rhashtable_rehash_attach(ht, old_tbl, new_tbl);
	if (err)
		bucket_table_free(new_tbl);

	return err;
356 357
}

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

364
	ht = container_of(work, struct rhashtable, run_work);
365
	mutex_lock(&ht->mutex);
366

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

370
	if (rht_grow_above_75(ht, tbl))
371
		rhashtable_expand(ht);
372
	else if (ht->p.automatic_shrinking && rht_shrink_below_30(ht, tbl))
373
		rhashtable_shrink(ht);
374 375 376

	err = rhashtable_rehash_table(ht);

377
	mutex_unlock(&ht->mutex);
378 379 380

	if (err)
		schedule_work(&ht->run_work);
381 382
}

383 384
static int rhashtable_insert_rehash(struct rhashtable *ht,
				    struct bucket_table *tbl)
385 386 387 388 389 390 391 392 393 394
{
	struct bucket_table *old_tbl;
	struct bucket_table *new_tbl;
	unsigned int size;
	int err;

	old_tbl = rht_dereference_rcu(ht->tbl, ht);

	size = tbl->size;

395 396
	err = -EBUSY;

397 398
	if (rht_grow_above_75(ht, tbl))
		size *= 2;
399 400
	/* Do not schedule more than one rehash */
	else if (old_tbl != tbl)
401 402 403
		goto fail;

	err = -ENOMEM;
404 405

	new_tbl = bucket_table_alloc(ht, size, GFP_ATOMIC);
406 407
	if (new_tbl == NULL)
		goto fail;
408 409 410 411 412 413 414 415 416 417

	err = rhashtable_rehash_attach(ht, tbl, new_tbl);
	if (err) {
		bucket_table_free(new_tbl);
		if (err == -EEXIST)
			err = 0;
	} else
		schedule_work(&ht->run_work);

	return err;
418 419 420 421 422 423 424 425 426 427 428

fail:
	/* Do not fail the insert if someone else did a rehash. */
	if (likely(rcu_dereference_raw(tbl->future_tbl)))
		return 0;

	/* Schedule async rehash to retry allocation in process context. */
	if (err == -ENOMEM)
		schedule_work(&ht->run_work);

	return err;
429 430
}

431 432 433
static void *rhashtable_lookup_one(struct rhashtable *ht,
				   struct bucket_table *tbl, unsigned int hash,
				   const void *key, struct rhash_head *obj)
434
{
435 436 437 438 439
	struct rhashtable_compare_arg arg = {
		.ht = ht,
		.key = key,
	};
	struct rhash_head __rcu **pprev;
440
	struct rhash_head *head;
441
	int elasticity;
442

443 444 445 446 447 448 449 450 451 452
	elasticity = ht->elasticity;
	pprev = &tbl->buckets[hash];
	rht_for_each(head, tbl, hash) {
		struct rhlist_head *list;
		struct rhlist_head *plist;

		elasticity--;
		if (!key ||
		    (ht->p.obj_cmpfn ?
		     ht->p.obj_cmpfn(&arg, rht_obj(ht, head)) :
453 454
		     rhashtable_compare(&arg, rht_obj(ht, head)))) {
			pprev = &head->next;
455
			continue;
456
		}
457 458 459 460 461 462 463 464 465 466 467 468 469

		if (!ht->rhlist)
			return rht_obj(ht, head);

		list = container_of(obj, struct rhlist_head, rhead);
		plist = container_of(head, struct rhlist_head, rhead);

		RCU_INIT_POINTER(list->next, plist);
		head = rht_dereference_bucket(head->next, tbl, hash);
		RCU_INIT_POINTER(list->rhead.next, head);
		rcu_assign_pointer(*pprev, obj);

		return NULL;
470
	}
471

472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488
	if (elasticity <= 0)
		return ERR_PTR(-EAGAIN);

	return ERR_PTR(-ENOENT);
}

static struct bucket_table *rhashtable_insert_one(struct rhashtable *ht,
						  struct bucket_table *tbl,
						  unsigned int hash,
						  struct rhash_head *obj,
						  void *data)
{
	struct bucket_table *new_tbl;
	struct rhash_head *head;

	if (!IS_ERR_OR_NULL(data))
		return ERR_PTR(-EEXIST);
489

490 491
	if (PTR_ERR(data) != -EAGAIN && PTR_ERR(data) != -ENOENT)
		return ERR_CAST(data);
492

493 494 495 496 497 498 499 500 501 502 503 504
	new_tbl = rcu_dereference(tbl->future_tbl);
	if (new_tbl)
		return new_tbl;

	if (PTR_ERR(data) != -ENOENT)
		return ERR_CAST(data);

	if (unlikely(rht_grow_above_max(ht, tbl)))
		return ERR_PTR(-E2BIG);

	if (unlikely(rht_grow_above_100(ht, tbl)))
		return ERR_PTR(-EAGAIN);
505 506 507 508

	head = rht_dereference_bucket(tbl->buckets[hash], tbl, hash);

	RCU_INIT_POINTER(obj->next, head);
509 510 511 512 513 514
	if (ht->rhlist) {
		struct rhlist_head *list;

		list = container_of(obj, struct rhlist_head, rhead);
		RCU_INIT_POINTER(list->next, NULL);
	}
515 516 517 518

	rcu_assign_pointer(tbl->buckets[hash], obj);

	atomic_inc(&ht->nelems);
519 520
	if (rht_grow_above_75(ht, tbl))
		schedule_work(&ht->run_work);
521

522 523
	return NULL;
}
524

525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590
static void *rhashtable_try_insert(struct rhashtable *ht, const void *key,
				   struct rhash_head *obj)
{
	struct bucket_table *new_tbl;
	struct bucket_table *tbl;
	unsigned int hash;
	spinlock_t *lock;
	void *data;

	tbl = rcu_dereference(ht->tbl);

	/* All insertions must grab the oldest table containing
	 * the hashed bucket that is yet to be rehashed.
	 */
	for (;;) {
		hash = rht_head_hashfn(ht, tbl, obj, ht->p);
		lock = rht_bucket_lock(tbl, hash);
		spin_lock_bh(lock);

		if (tbl->rehash <= hash)
			break;

		spin_unlock_bh(lock);
		tbl = rcu_dereference(tbl->future_tbl);
	}

	data = rhashtable_lookup_one(ht, tbl, hash, key, obj);
	new_tbl = rhashtable_insert_one(ht, tbl, hash, obj, data);
	if (PTR_ERR(new_tbl) != -EEXIST)
		data = ERR_CAST(new_tbl);

	while (!IS_ERR_OR_NULL(new_tbl)) {
		tbl = new_tbl;
		hash = rht_head_hashfn(ht, tbl, obj, ht->p);
		spin_lock_nested(rht_bucket_lock(tbl, hash),
				 SINGLE_DEPTH_NESTING);

		data = rhashtable_lookup_one(ht, tbl, hash, key, obj);
		new_tbl = rhashtable_insert_one(ht, tbl, hash, obj, data);
		if (PTR_ERR(new_tbl) != -EEXIST)
			data = ERR_CAST(new_tbl);

		spin_unlock(rht_bucket_lock(tbl, hash));
	}

	spin_unlock_bh(lock);

	if (PTR_ERR(data) == -EAGAIN)
		data = ERR_PTR(rhashtable_insert_rehash(ht, tbl) ?:
			       -EAGAIN);

	return data;
}

void *rhashtable_insert_slow(struct rhashtable *ht, const void *key,
			     struct rhash_head *obj)
{
	void *data;

	do {
		rcu_read_lock();
		data = rhashtable_try_insert(ht, key, obj);
		rcu_read_unlock();
	} while (PTR_ERR(data) == -EAGAIN);

	return data;
591 592 593
}
EXPORT_SYMBOL_GPL(rhashtable_insert_slow);

594
/**
595
 * rhashtable_walk_enter - Initialise an iterator
596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611
 * @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.
 *
612
 * You must call rhashtable_walk_exit after this function returns.
613
 */
614
void rhashtable_walk_enter(struct rhashtable *ht, struct rhashtable_iter *iter)
615 616 617 618 619 620
{
	iter->ht = ht;
	iter->p = NULL;
	iter->slot = 0;
	iter->skip = 0;

621
	spin_lock(&ht->lock);
622
	iter->walker.tbl =
623
		rcu_dereference_protected(ht->tbl, lockdep_is_held(&ht->lock));
624
	list_add(&iter->walker.list, &iter->walker.tbl->walkers);
625
	spin_unlock(&ht->lock);
626
}
627
EXPORT_SYMBOL_GPL(rhashtable_walk_enter);
628 629 630 631 632 633 634 635 636

/**
 * 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)
{
637
	spin_lock(&iter->ht->lock);
638 639
	if (iter->walker.tbl)
		list_del(&iter->walker.list);
640
	spin_unlock(&iter->ht->lock);
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658
}
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)
659
	__acquires(RCU)
660
{
661 662
	struct rhashtable *ht = iter->ht;

663
	rcu_read_lock();
664

665
	spin_lock(&ht->lock);
666 667
	if (iter->walker.tbl)
		list_del(&iter->walker.list);
668
	spin_unlock(&ht->lock);
669

670 671
	if (!iter->walker.tbl) {
		iter->walker.tbl = rht_dereference_rcu(ht->tbl, ht);
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692
		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)
{
693
	struct bucket_table *tbl = iter->walker.tbl;
694
	struct rhlist_head *list = iter->list;
695 696
	struct rhashtable *ht = iter->ht;
	struct rhash_head *p = iter->p;
697
	bool rhlist = ht->rhlist;
698 699

	if (p) {
700 701 702 703
		if (!rhlist || !(list = rcu_dereference(list->next))) {
			p = rcu_dereference(p->next);
			list = container_of(p, struct rhlist_head, rhead);
		}
704 705 706 707 708 709 710
		goto next;
	}

	for (; iter->slot < tbl->size; iter->slot++) {
		int skip = iter->skip;

		rht_for_each_rcu(p, tbl, iter->slot) {
711 712 713 714 715 716 717 718 719 720 721 722
			if (rhlist) {
				list = container_of(p, struct rhlist_head,
						    rhead);
				do {
					if (!skip)
						goto next;
					skip--;
					list = rcu_dereference(list->next);
				} while (list);

				continue;
			}
723 724 725 726 727 728 729 730 731
			if (!skip)
				break;
			skip--;
		}

next:
		if (!rht_is_a_nulls(p)) {
			iter->skip++;
			iter->p = p;
732 733
			iter->list = list;
			return rht_obj(ht, rhlist ? &list->rhead : p);
734 735 736 737 738
		}

		iter->skip = 0;
	}

739 740
	iter->p = NULL;

741 742 743
	/* Ensure we see any new tables. */
	smp_rmb();

744 745
	iter->walker.tbl = rht_dereference_rcu(tbl->future_tbl, ht);
	if (iter->walker.tbl) {
746 747 748 749 750
		iter->slot = 0;
		iter->skip = 0;
		return ERR_PTR(-EAGAIN);
	}

751
	return NULL;
752 753 754 755 756 757 758 759 760 761
}
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)
762
	__releases(RCU)
763
{
764
	struct rhashtable *ht;
765
	struct bucket_table *tbl = iter->walker.tbl;
766 767

	if (!tbl)
768
		goto out;
769 770 771

	ht = iter->ht;

772
	spin_lock(&ht->lock);
773
	if (tbl->rehash < tbl->size)
774
		list_add(&iter->walker.list, &tbl->walkers);
775
	else
776
		iter->walker.tbl = NULL;
777
	spin_unlock(&ht->lock);
778

779
	iter->p = NULL;
780 781 782

out:
	rcu_read_unlock();
783 784 785
}
EXPORT_SYMBOL_GPL(rhashtable_walk_stop);

786
static size_t rounded_hashtable_size(const struct rhashtable_params *params)
787
{
788 789 790 791 792 793 794 795 796 797
	size_t retsize;

	if (params->nelem_hint)
		retsize = max(roundup_pow_of_two(params->nelem_hint * 4 / 3),
			      (unsigned long)params->min_size);
	else
		retsize = max(HASH_DEFAULT_SIZE,
			      (unsigned long)params->min_size);

	return retsize;
798 799
}

800 801 802 803 804
static u32 rhashtable_jhash2(const void *key, u32 length, u32 seed)
{
	return jhash2(key, length, seed);
}

805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824
/**
 * 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),
825
 *	.hashfn = jhash,
826
 *	.nulls_base = (1U << RHT_BASE_SHIFT),
827 828 829 830 831 832 833 834
 * };
 *
 * Configuration Example 2: Variable length keys
 * struct test_obj {
 *	[...]
 *	struct rhash_head	node;
 * };
 *
835
 * u32 my_hash_fn(const void *data, u32 len, u32 seed)
836 837 838 839 840 841 842 843
 * {
 *	struct test_obj *obj = data;
 *
 *	return [... hash ...];
 * }
 *
 * struct rhashtable_params params = {
 *	.head_offset = offsetof(struct test_obj, node),
844
 *	.hashfn = jhash,
845 846 847
 *	.obj_hashfn = my_hash_fn,
 * };
 */
848 849
int rhashtable_init(struct rhashtable *ht,
		    const struct rhashtable_params *params)
850 851 852 853
{
	struct bucket_table *tbl;
	size_t size;

854
	if ((!params->key_len && !params->obj_hashfn) ||
855
	    (params->obj_hashfn && !params->obj_cmpfn))
856 857
		return -EINVAL;

858 859 860
	if (params->nulls_base && params->nulls_base < (1U << RHT_BASE_SHIFT))
		return -EINVAL;

861 862
	memset(ht, 0, sizeof(*ht));
	mutex_init(&ht->mutex);
863
	spin_lock_init(&ht->lock);
864 865
	memcpy(&ht->p, params, sizeof(*params));

866 867 868 869 870 871
	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);

872 873 874 875 876 877
	if (params->insecure_max_entries)
		ht->p.insecure_max_entries =
			rounddown_pow_of_two(params->insecure_max_entries);
	else
		ht->p.insecure_max_entries = ht->p.max_size * 2;

878
	ht->p.min_size = max(ht->p.min_size, HASH_MIN_SIZE);
879

880
	size = rounded_hashtable_size(&ht->p);
881

882 883 884 885 886 887 888 889 890 891 892 893
	/* The maximum (not average) chain length grows with the
	 * size of the hash table, at a rate of (log N)/(log log N).
	 * The value of 16 is selected so that even if the hash
	 * table grew to 2^32 you would not expect the maximum
	 * chain length to exceed it unless we are under attack
	 * (or extremely unlucky).
	 *
	 * As this limit is only to detect attacks, we don't need
	 * to set it to a lower value as you'd need the chain
	 * length to vastly exceed 16 to have any real effect
	 * on the system.
	 */
894 895 896
	if (!params->insecure_elasticity)
		ht->elasticity = 16;

897 898 899 900 901
	if (params->locks_mul)
		ht->p.locks_mul = roundup_pow_of_two(params->locks_mul);
	else
		ht->p.locks_mul = BUCKET_LOCKS_PER_CPU;

902 903 904 905 906 907 908 909 910 911
	ht->key_len = ht->p.key_len;
	if (!params->hashfn) {
		ht->p.hashfn = jhash;

		if (!(ht->key_len & (sizeof(u32) - 1))) {
			ht->key_len /= sizeof(u32);
			ht->p.hashfn = rhashtable_jhash2;
		}
	}

912
	tbl = bucket_table_alloc(ht, size, GFP_KERNEL);
913 914 915
	if (tbl == NULL)
		return -ENOMEM;

916
	atomic_set(&ht->nelems, 0);
917

918 919
	RCU_INIT_POINTER(ht->tbl, tbl);

920
	INIT_WORK(&ht->run_work, rht_deferred_worker);
921

922 923 924 925
	return 0;
}
EXPORT_SYMBOL_GPL(rhashtable_init);

926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967
/**
 * rhltable_init - initialize a new hash list table
 * @hlt:	hash list table to be initialized
 * @params:	configuration parameters
 *
 * Initializes a new hash list table.
 *
 * See documentation for rhashtable_init.
 */
int rhltable_init(struct rhltable *hlt, const struct rhashtable_params *params)
{
	int err;

	/* No rhlist NULLs marking for now. */
	if (params->nulls_base)
		return -EINVAL;

	err = rhashtable_init(&hlt->ht, params);
	hlt->ht.rhlist = true;
	return err;
}
EXPORT_SYMBOL_GPL(rhltable_init);

static void rhashtable_free_one(struct rhashtable *ht, struct rhash_head *obj,
				void (*free_fn)(void *ptr, void *arg),
				void *arg)
{
	struct rhlist_head *list;

	if (!ht->rhlist) {
		free_fn(rht_obj(ht, obj), arg);
		return;
	}

	list = container_of(obj, struct rhlist_head, rhead);
	do {
		obj = &list->rhead;
		list = rht_dereference(list->next, ht);
		free_fn(rht_obj(ht, obj), arg);
	} while (list);
}

968
/**
969
 * rhashtable_free_and_destroy - free elements and destroy hash table
970
 * @ht:		the hash table to destroy
971 972
 * @free_fn:	callback to release resources of element
 * @arg:	pointer passed to free_fn
973
 *
974 975 976 977 978 979 980 981
 * Stops an eventual async resize. If defined, invokes free_fn for each
 * element to releasal resources. Please note that RCU protected
 * readers may still be accessing the elements. Releasing of resources
 * must occur in a compatible manner. Then frees the bucket array.
 *
 * This function will eventually sleep to wait for an async resize
 * to complete. The caller is responsible that no further write operations
 * occurs in parallel.
982
 */
983 984 985
void rhashtable_free_and_destroy(struct rhashtable *ht,
				 void (*free_fn)(void *ptr, void *arg),
				 void *arg)
986
{
987 988
	const struct bucket_table *tbl;
	unsigned int i;
989

990
	cancel_work_sync(&ht->run_work);
991

992
	mutex_lock(&ht->mutex);
993 994 995 996 997
	tbl = rht_dereference(ht->tbl, ht);
	if (free_fn) {
		for (i = 0; i < tbl->size; i++) {
			struct rhash_head *pos, *next;

998
			cond_resched();
999 1000 1001 1002 1003 1004 1005
			for (pos = rht_dereference(tbl->buckets[i], ht),
			     next = !rht_is_a_nulls(pos) ?
					rht_dereference(pos->next, ht) : NULL;
			     !rht_is_a_nulls(pos);
			     pos = next,
			     next = !rht_is_a_nulls(pos) ?
					rht_dereference(pos->next, ht) : NULL)
1006
				rhashtable_free_one(ht, pos, free_fn, arg);
1007 1008 1009 1010
		}
	}

	bucket_table_free(tbl);
1011
	mutex_unlock(&ht->mutex);
1012
}
1013 1014 1015 1016 1017 1018
EXPORT_SYMBOL_GPL(rhashtable_free_and_destroy);

void rhashtable_destroy(struct rhashtable *ht)
{
	return rhashtable_free_and_destroy(ht, NULL, NULL);
}
1019
EXPORT_SYMBOL_GPL(rhashtable_destroy);