Commit 7beceebf authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'rhashtable-next' 



Thomas Graf says:

====================
rhashtable: Per bucket locks & deferred table resizing

Prepares for and introduces per bucket spinlocks and deferred table
resizing. This allows for parallel table mutations in different hash
buckets from atomic context. The resizing occurs in the background
in a separate worker thread while lookups, inserts, and removals can
continue.

Also modified the chain linked list to be terminated with a special
nulls marker to allow entries to move between multiple lists.

Last but not least, reintroduces lockless netlink_lookup() with
deferred Netlink socket destruction to avoid the side effect of
increased netlink_release() runtime.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents dd955398 21e4902a

include/linux/list_nulls.h

+2 −1
Original line number Diff line number Diff line
@@ -21,8 +21,9 @@ struct hlist_nulls_head { 
struct hlist_nulls_node {

	struct hlist_nulls_node *next, **pprev;

};

#define NULLS_MARKER(value) (1UL | (((long)value) << 1))

#define INIT_HLIST_NULLS_HEAD(ptr, nulls) \

	((ptr)->first = (struct hlist_nulls_node *) (1UL | (((long)nulls) << 1)))

	((ptr)->first = (struct hlist_nulls_node *) NULLS_MARKER(nulls))



#define hlist_nulls_entry(ptr, type, member) container_of(ptr,type,member)

/**

include/linux/rhashtable.h

+182 −76
Original line number Diff line number Diff line
@@ -18,16 +18,43 @@ 
#ifndef _LINUX_RHASHTABLE_H

#define _LINUX_RHASHTABLE_H



#include <linux/rculist.h>

#include <linux/list_nulls.h>

#include <linux/workqueue.h>



/*

 * The end of the chain is marked with a special nulls marks which has

 * the following format:

 *

 * +-------+-----------------------------------------------------+-+

 * | Base  |                      Hash                           |1|

 * +-------+-----------------------------------------------------+-+

 *

 * Base (4 bits) : Reserved to distinguish between multiple tables.

 *                 Specified via &struct rhashtable_params.nulls_base.

 * Hash (27 bits): Full hash (unmasked) of first element added to bucket

 * 1 (1 bit)     : Nulls marker (always set)

 *

 * The remaining bits of the next pointer remain unused for now.

 */

#define RHT_BASE_BITS		4

#define RHT_HASH_BITS		27

#define RHT_BASE_SHIFT		RHT_HASH_BITS



struct rhash_head {

	struct rhash_head __rcu		*next;

};



#define INIT_HASH_HEAD(ptr) ((ptr)->next = NULL)



/**

 * struct bucket_table - Table of hash buckets

 * @size: Number of hash buckets

 * @locks_mask: Mask to apply before accessing locks[]

 * @locks: Array of spinlocks protecting individual buckets

 * @buckets: size * hash buckets

 */

struct bucket_table {

	size_t				size;

	unsigned int			locks_mask;

	spinlock_t			*locks;

	struct rhash_head __rcu		*buckets[];

};
@@ -45,11 +72,12 @@ struct rhashtable; 
 * @hash_rnd: Seed to use while hashing

 * @max_shift: Maximum number of shifts while expanding

 * @min_shift: Minimum number of shifts while shrinking

 * @nulls_base: Base value to generate nulls marker

 * @locks_mul: Number of bucket locks to allocate per cpu (default: 128)

 * @hashfn: Function to hash key

 * @obj_hashfn: Function to hash object

 * @grow_decision: If defined, may return true if table should expand

 * @shrink_decision: If defined, may return true if table should shrink

 * @mutex_is_held: Must return true if protecting mutex is held

 */

struct rhashtable_params {

	size_t			nelem_hint;
@@ -59,36 +87,67 @@ struct rhashtable_params { 
	u32			hash_rnd;

	size_t			max_shift;

	size_t			min_shift;

	u32			nulls_base;

	size_t			locks_mul;

	rht_hashfn_t		hashfn;

	rht_obj_hashfn_t	obj_hashfn;

	bool			(*grow_decision)(const struct rhashtable *ht,

						 size_t new_size);

	bool			(*shrink_decision)(const struct rhashtable *ht,

						   size_t new_size);

#ifdef CONFIG_PROVE_LOCKING

	int			(*mutex_is_held)(void *parent);

	void			*parent;

#endif

};



/**

 * struct rhashtable - Hash table handle

 * @tbl: Bucket table

 * @future_tbl: Table under construction during expansion/shrinking

 * @nelems: Number of elements in table

 * @shift: Current size (1 << shift)

 * @p: Configuration parameters

 * @run_work: Deferred worker to expand/shrink asynchronously

 * @mutex: Mutex to protect current/future table swapping

 * @being_destroyed: True if table is set up for destruction

 */

struct rhashtable {

	struct bucket_table __rcu	*tbl;

	size_t				nelems;

	struct bucket_table __rcu       *future_tbl;

	atomic_t			nelems;

	size_t				shift;

	struct rhashtable_params	p;

	struct delayed_work             run_work;

	struct mutex                    mutex;

	bool                            being_destroyed;

};



static inline unsigned long rht_marker(const struct rhashtable *ht, u32 hash)

{

	return NULLS_MARKER(ht->p.nulls_base + hash);

}



#define INIT_RHT_NULLS_HEAD(ptr, ht, hash) \

	((ptr) = (typeof(ptr)) rht_marker(ht, hash))



static inline bool rht_is_a_nulls(const struct rhash_head *ptr)

{

	return ((unsigned long) ptr & 1);

}



static inline unsigned long rht_get_nulls_value(const struct rhash_head *ptr)

{

	return ((unsigned long) ptr) >> 1;

}



#ifdef CONFIG_PROVE_LOCKING

int lockdep_rht_mutex_is_held(const struct rhashtable *ht);

int lockdep_rht_mutex_is_held(struct rhashtable *ht);

int lockdep_rht_bucket_is_held(const struct bucket_table *tbl, u32 hash);

#else

static inline int lockdep_rht_mutex_is_held(const struct rhashtable *ht)

static inline int lockdep_rht_mutex_is_held(struct rhashtable *ht)

{

	return 1;

}



static inline int lockdep_rht_bucket_is_held(const struct bucket_table *tbl,

					     u32 hash)

{

	return 1;

}
@@ -96,13 +155,8 @@ static inline int lockdep_rht_mutex_is_held(const struct rhashtable *ht) 


int rhashtable_init(struct rhashtable *ht, struct rhashtable_params *params);



u32 rhashtable_hashfn(const struct rhashtable *ht, const void *key, u32 len);

u32 rhashtable_obj_hashfn(const struct rhashtable *ht, void *ptr);



void rhashtable_insert(struct rhashtable *ht, struct rhash_head *node);

bool rhashtable_remove(struct rhashtable *ht, struct rhash_head *node);

void rhashtable_remove_pprev(struct rhashtable *ht, struct rhash_head *obj,

			     struct rhash_head __rcu **pprev);



bool rht_grow_above_75(const struct rhashtable *ht, size_t new_size);

bool rht_shrink_below_30(const struct rhashtable *ht, size_t new_size);
@@ -110,11 +164,11 @@ bool rht_shrink_below_30(const struct rhashtable *ht, size_t new_size); 
int rhashtable_expand(struct rhashtable *ht);

int rhashtable_shrink(struct rhashtable *ht);



void *rhashtable_lookup(const struct rhashtable *ht, const void *key);

void *rhashtable_lookup_compare(const struct rhashtable *ht, u32 hash,

void *rhashtable_lookup(struct rhashtable *ht, const void *key);

void *rhashtable_lookup_compare(struct rhashtable *ht, const void *key,

				bool (*compare)(void *, void *), void *arg);



void rhashtable_destroy(const struct rhashtable *ht);

void rhashtable_destroy(struct rhashtable *ht);



#define rht_dereference(p, ht) \

	rcu_dereference_protected(p, lockdep_rht_mutex_is_held(ht))
@@ -122,92 +176,144 @@ void rhashtable_destroy(const struct rhashtable *ht); 
#define rht_dereference_rcu(p, ht) \

	rcu_dereference_check(p, lockdep_rht_mutex_is_held(ht))



#define rht_entry(ptr, type, member) container_of(ptr, type, member)

#define rht_entry_safe(ptr, type, member) \

({ \

	typeof(ptr) __ptr = (ptr); \

	   __ptr ? rht_entry(__ptr, type, member) : NULL; \

})

#define rht_dereference_bucket(p, tbl, hash) \

	rcu_dereference_protected(p, lockdep_rht_bucket_is_held(tbl, hash))



#define rht_next_entry_safe(pos, ht, member) \

({ \

	pos ? rht_entry_safe(rht_dereference((pos)->member.next, ht), \

			     typeof(*(pos)), member) : NULL; \

})

#define rht_dereference_bucket_rcu(p, tbl, hash) \

	rcu_dereference_check(p, lockdep_rht_bucket_is_held(tbl, hash))



#define rht_entry(tpos, pos, member) \

	({ tpos = container_of(pos, typeof(*tpos), member); 1; })



/**

 * rht_for_each_continue - continue iterating over hash chain

 * @pos:	the &struct rhash_head to use as a loop cursor.

 * @head:	the previous &struct rhash_head to continue from

 * @tbl:	the &struct bucket_table

 * @hash:	the hash value / bucket index

 */

#define rht_for_each_continue(pos, head, tbl, hash) \

	for (pos = rht_dereference_bucket(head, tbl, hash); \

	     !rht_is_a_nulls(pos); \

	     pos = rht_dereference_bucket((pos)->next, tbl, hash))



/**

 * rht_for_each - iterate over hash chain

 * @pos:	&struct rhash_head to use as a loop cursor.

 * @head:	head of the hash chain (struct rhash_head *)

 * @ht:		pointer to your struct rhashtable

 * @pos:	the &struct rhash_head to use as a loop cursor.

 * @tbl:	the &struct bucket_table

 * @hash:	the hash value / bucket index

 */

#define rht_for_each(pos, head, ht) \

	for (pos = rht_dereference(head, ht); \

	     pos; \

	     pos = rht_dereference((pos)->next, ht))

#define rht_for_each(pos, tbl, hash) \

	rht_for_each_continue(pos, (tbl)->buckets[hash], tbl, hash)



/**

 * rht_for_each_entry_continue - continue iterating over hash chain

 * @tpos:	the type * to use as a loop cursor.

 * @pos:	the &struct rhash_head to use as a loop cursor.

 * @head:	the previous &struct rhash_head to continue from

 * @tbl:	the &struct bucket_table

 * @hash:	the hash value / bucket index

 * @member:	name of the &struct rhash_head within the hashable struct.

 */

#define rht_for_each_entry_continue(tpos, pos, head, tbl, hash, member)	\

	for (pos = rht_dereference_bucket(head, tbl, hash);		\

	     (!rht_is_a_nulls(pos)) && rht_entry(tpos, pos, member);	\

	     pos = rht_dereference_bucket((pos)->next, tbl, hash))



/**

 * rht_for_each_entry - iterate over hash chain of given type

 * @pos:	type * to use as a loop cursor.

 * @head:	head of the hash chain (struct rhash_head *)

 * @ht:		pointer to your struct rhashtable

 * @member:	name of the rhash_head within the hashable struct.

 * @tpos:	the type * to use as a loop cursor.

 * @pos:	the &struct rhash_head to use as a loop cursor.

 * @tbl:	the &struct bucket_table

 * @hash:	the hash value / bucket index

 * @member:	name of the &struct rhash_head within the hashable struct.

 */

#define rht_for_each_entry(pos, head, ht, member) \

	for (pos = rht_entry_safe(rht_dereference(head, ht), \

				   typeof(*(pos)), member); \

	     pos; \

	     pos = rht_next_entry_safe(pos, ht, member))

#define rht_for_each_entry(tpos, pos, tbl, hash, member)		\

	rht_for_each_entry_continue(tpos, pos, (tbl)->buckets[hash],	\

				    tbl, hash, member)



/**

 * rht_for_each_entry_safe - safely iterate over hash chain of given type

 * @pos:	type * to use as a loop cursor.

 * @n:		type * to use for temporary next object storage

 * @head:	head of the hash chain (struct rhash_head *)

 * @ht:		pointer to your struct rhashtable

 * @member:	name of the rhash_head within the hashable struct.

 * @tpos:	the type * to use as a loop cursor.

 * @pos:	the &struct rhash_head to use as a loop cursor.

 * @next:	the &struct rhash_head to use as next in loop cursor.

 * @tbl:	the &struct bucket_table

 * @hash:	the hash value / bucket index

 * @member:	name of the &struct rhash_head within the hashable struct.

 *

 * This hash chain list-traversal primitive allows for the looped code to

 * remove the loop cursor from the list.

 */

#define rht_for_each_entry_safe(pos, n, head, ht, member)		\

	for (pos = rht_entry_safe(rht_dereference(head, ht), \

				  typeof(*(pos)), member), \

	     n = rht_next_entry_safe(pos, ht, member); \

	     pos; \

	     pos = n, \

	     n = rht_next_entry_safe(pos, ht, member))

#define rht_for_each_entry_safe(tpos, pos, next, tbl, hash, member)	    \

	for (pos = rht_dereference_bucket((tbl)->buckets[hash], tbl, hash), \

	     next = !rht_is_a_nulls(pos) ?				    \

		       rht_dereference_bucket(pos->next, tbl, hash) : NULL; \

	     (!rht_is_a_nulls(pos)) && rht_entry(tpos, pos, member);	    \

	     pos = next)



/**

 * rht_for_each_rcu_continue - continue iterating over rcu hash chain

 * @pos:	the &struct rhash_head to use as a loop cursor.

 * @head:	the previous &struct rhash_head to continue from

 * @tbl:	the &struct bucket_table

 * @hash:	the hash value / bucket index

 *

 * This hash chain list-traversal primitive may safely run concurrently with

 * the _rcu mutation primitives such as rhashtable_insert() as long as the

 * traversal is guarded by rcu_read_lock().

 */

#define rht_for_each_rcu_continue(pos, head, tbl, hash)			\

	for (({barrier(); }),						\

	     pos = rht_dereference_bucket_rcu(head, tbl, hash);		\

	     !rht_is_a_nulls(pos);					\

	     pos = rcu_dereference_raw(pos->next))



/**

 * rht_for_each_rcu - iterate over rcu hash chain

 * @pos:	&struct rhash_head to use as a loop cursor.

 * @head:	head of the hash chain (struct rhash_head *)

 * @ht:		pointer to your struct rhashtable

 * @pos:	the &struct rhash_head to use as a loop cursor.

 * @tbl:	the &struct bucket_table

 * @hash:	the hash value / bucket index

 *

 * This hash chain list-traversal primitive may safely run concurrently with

 * the _rcu mutation primitives such as rhashtable_insert() as long as the

 * traversal is guarded by rcu_read_lock().

 */

#define rht_for_each_rcu(pos, tbl, hash)				\

	rht_for_each_rcu_continue(pos, (tbl)->buckets[hash], tbl, hash)



/**

 * rht_for_each_entry_rcu_continue - continue iterating over rcu hash chain

 * @tpos:	the type * to use as a loop cursor.

 * @pos:	the &struct rhash_head to use as a loop cursor.

 * @head:	the previous &struct rhash_head to continue from

 * @tbl:	the &struct bucket_table

 * @hash:	the hash value / bucket index

 * @member:	name of the &struct rhash_head within the hashable struct.

 *

 * This hash chain list-traversal primitive may safely run concurrently with

 * the _rcu fkht mutation primitives such as rht_insert() as long as the

 * the _rcu mutation primitives such as rhashtable_insert() as long as the

 * traversal is guarded by rcu_read_lock().

 */

#define rht_for_each_rcu(pos, head, ht) \

	for (pos = rht_dereference_rcu(head, ht); \

	     pos; \

	     pos = rht_dereference_rcu((pos)->next, ht))

#define rht_for_each_entry_rcu_continue(tpos, pos, head, tbl, hash, member) \

	for (({barrier(); }),						    \

	     pos = rht_dereference_bucket_rcu(head, tbl, hash);		    \

	     (!rht_is_a_nulls(pos)) && rht_entry(tpos, pos, member);	    \

	     pos = rht_dereference_bucket_rcu(pos->next, tbl, hash))



/**

 * rht_for_each_entry_rcu - iterate over rcu hash chain of given type

 * @pos:	type * to use as a loop cursor.

 * @head:	head of the hash chain (struct rhash_head *)

 * @member:	name of the rhash_head within the hashable struct.

 * @tpos:	the type * to use as a loop cursor.

 * @pos:	the &struct rhash_head to use as a loop cursor.

 * @tbl:	the &struct bucket_table

 * @hash:	the hash value / bucket index

 * @member:	name of the &struct rhash_head within the hashable struct.

 *

 * This hash chain list-traversal primitive may safely run concurrently with

 * the _rcu fkht mutation primitives such as rht_insert() as long as the

 * the _rcu mutation primitives such as rhashtable_insert() as long as the

 * traversal is guarded by rcu_read_lock().

 */

#define rht_for_each_entry_rcu(pos, head, member) \

	for (pos = rht_entry_safe(rcu_dereference_raw(head), \

				  typeof(*(pos)), member); \

	     pos; \

	     pos = rht_entry_safe(rcu_dereference_raw((pos)->member.next), \

				  typeof(*(pos)), member))

#define rht_for_each_entry_rcu(tpos, pos, tbl, hash, member)		\

	rht_for_each_entry_rcu_continue(tpos, pos, (tbl)->buckets[hash],\

					tbl, hash, member)



#endif /* _LINUX_RHASHTABLE_H */

include/linux/spinlock.h

+8 −0
Original line number Diff line number Diff line
@@ -190,6 +190,8 @@ static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock) 
#ifdef CONFIG_DEBUG_LOCK_ALLOC

# define raw_spin_lock_nested(lock, subclass) \

	_raw_spin_lock_nested(lock, subclass)

# define raw_spin_lock_bh_nested(lock, subclass) \

	_raw_spin_lock_bh_nested(lock, subclass)



# define raw_spin_lock_nest_lock(lock, nest_lock)			\

	 do {								\
@@ -205,6 +207,7 @@ static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock) 
# define raw_spin_lock_nested(lock, subclass)		\

	_raw_spin_lock(((void)(subclass), (lock)))

# define raw_spin_lock_nest_lock(lock, nest_lock)	_raw_spin_lock(lock)

# define raw_spin_lock_bh_nested(lock, subclass)	_raw_spin_lock_bh(lock)

#endif



#if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
@@ -324,6 +327,11 @@ do { \ 
	raw_spin_lock_nested(spinlock_check(lock), subclass);	\

} while (0)



#define spin_lock_bh_nested(lock, subclass)			\

do {								\

	raw_spin_lock_bh_nested(spinlock_check(lock), subclass);\

} while (0)



#define spin_lock_nest_lock(lock, nest_lock)				\

do {									\

	raw_spin_lock_nest_lock(spinlock_check(lock), nest_lock);	\

include/linux/spinlock_api_smp.h

+2 −0
Original line number Diff line number Diff line
@@ -22,6 +22,8 @@ int in_lock_functions(unsigned long addr); 
void __lockfunc _raw_spin_lock(raw_spinlock_t *lock)		__acquires(lock);

void __lockfunc _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass)

								__acquires(lock);

void __lockfunc _raw_spin_lock_bh_nested(raw_spinlock_t *lock, int subclass)

								__acquires(lock);

void __lockfunc

_raw_spin_lock_nest_lock(raw_spinlock_t *lock, struct lockdep_map *map)

								__acquires(lock);

include/linux/spinlock_api_up.h

+1 −0
Original line number Diff line number Diff line
@@ -57,6 +57,7 @@ 


#define _raw_spin_lock(lock)			__LOCK(lock)

#define _raw_spin_lock_nested(lock, subclass)	__LOCK(lock)

#define _raw_spin_lock_bh_nested(lock, subclass) __LOCK(lock)

#define _raw_read_lock(lock)			__LOCK(lock)

#define _raw_write_lock(lock)			__LOCK(lock)

#define _raw_spin_lock_bh(lock)			__LOCK_BH(lock)

CRA Git | Maintained and supported by SUSTech CRA and CCSE