Merge branch 'rhash-cleanups'

 *

 * 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().

 * Will trigger an automatic deferred table resizing if residency in the

 * table grows beyond 70%.

 */

static inline int rhashtable_insert_fast(

	struct rhashtable *ht, struct rhash_head *obj,

 *

 * 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().

 * Will trigger an automatic deferred table resizing if residency in the

 * table grows beyond 70%.

 */

static inline int rhltable_insert_key(

	struct rhltable *hlt, const void *key, struct rhlist_head *list,

 *

 * 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().

 * Will trigger an automatic deferred table resizing if residency in the

 * table grows beyond 70%.

 */

static inline int rhltable_insert(

	struct rhltable *hlt, struct rhlist_head *list,

 *

 * 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().

 * Will trigger an automatic deferred table resizing if residency in the

 * table grows beyond 70%.

 */

static inline int rhashtable_lookup_insert_fast(

	struct rhashtable *ht, struct rhash_head *obj,

 *

 * 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().

 * Will trigger an automatic deferred table resizing if residency in the

 * table grows beyond 70%.

 *

 * Returns zero on success.

 */

 * walk the bucket chain upon removal. The removal operation is thus

 * considerable slow if the hash table is not correctly sized.

 *

 * Will automatically shrink the table via rhashtable_expand() if the

 * shrink_decision function specified at rhashtable_init() returns true.

 * Will automatically shrink the table if permitted when residency drops

 * below 30%.

 *

 * Returns zero on success, -ENOENT if the entry could not be found.

 */

 * walk the bucket chain upon removal. The removal operation is thus

 * considerable slow if the hash table is not correctly sized.

 *

 * Will automatically shrink the table via rhashtable_expand() if the

 * shrink_decision function specified at rhashtable_init() returns true.

 * Will automatically shrink the table if permitted when residency drops

 * below 30%

 *

 * Returns zero on success, -ENOENT if the entry could not be found.

 */

 * 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.

 * This function may be called from any process context, including

 * non-preemptable context, but cannot be called from softirq or

 * hardirq context.

 *

 * You must call rhashtable_walk_exit after this function returns.

 */

 * 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.

 * This function may be called from any process context, including

 * non-preemptable context, but cannot be called from softirq or

 * hardirq context.

 *

 * You must call rhashtable_walk_exit after this function returns.

 */

	__acquires(RCU)

{

	struct rhashtable *ht = iter->ht;

	bool rhlist = ht->rhlist;

	rcu_read_lock();

		list_del(&iter->walker.list);

	spin_unlock(&ht->lock);

	if (!iter->walker.tbl && !iter->end_of_table) {

	if (iter->end_of_table)

		return 0;

	if (!iter->walker.tbl) {

		iter->walker.tbl = rht_dereference_rcu(ht->tbl, ht);

		iter->slot = 0;

		iter->skip = 0;

		return -EAGAIN;

	}

	if (iter->p && !rhlist) {

		/*

		 * We need to validate that 'p' is still in the table, and

		 * if so, update 'skip'

		 */

		struct rhash_head *p;

		int skip = 0;

		rht_for_each_rcu(p, iter->walker.tbl, iter->slot) {

			skip++;

			if (p == iter->p) {

				iter->skip = skip;

				goto found;

			}

		}

		iter->p = NULL;

	} else if (iter->p && rhlist) {

		/* Need to validate that 'list' is still in the table, and

		 * if so, update 'skip' and 'p'.

		 */

		struct rhash_head *p;

		struct rhlist_head *list;

		int skip = 0;

		rht_for_each_rcu(p, iter->walker.tbl, iter->slot) {

			for (list = container_of(p, struct rhlist_head, rhead);

			     list;

			     list = rcu_dereference(list->next)) {

				skip++;

				if (list == iter->list) {

					iter->p = p;

					skip = skip;

					goto found;

				}

			}

		}

		iter->p = NULL;

	}

found:

	return 0;

}

EXPORT_SYMBOL_GPL(rhashtable_walk_start_check);

		iter->walker.tbl = NULL;

	spin_unlock(&ht->lock);

	iter->p = NULL;

out:

	rcu_read_unlock();

}