include/linux/rhashtable.h

36  * the hash bucket.  This allows us to be sure we've found the end
38  * The value stored in the hash bucket has BIT(0) used as a lock bit.
42  * pointer stored in the bucket.  This struct needs to be defined so
68  * @rehash: Current bucket being rehashed
308  * We lock a bucket by setting BIT(0) in the pointer - this is always
309  * zero in real pointers.  The NULLS mark is never stored in the bucket,
310  * rather we store NULL if the bucket is empty.
312  * of the hashtable design is to achieve minimum per-bucket contention.
313  * A nested hash table might not have a bucket pointer.  In that case
314  * we cannot get a lock.  For remove and replace the bucket cannot be
316  * For insert we allocate the bucket if this is the last bucket_table,
318  * Sometimes we unlock a bucket by writing a new pointer there.  In that
323  * When we write to a bucket without unlocking, we use rht_assign_locked().
338 					struct rhash_lock_head __rcu **bucket,
344 	bit_spin_lock(0, (unsigned long *)bucket);
367  * Where 'bkt' is a bucket and might be locked:
369  *   rht_ptr() dereferences in a context where the bucket is locked.
420  * @hash:	the hash value / bucket index
431  * @hash:	the hash value / bucket index
443  * @hash:	the hash value / bucket index
456  * @hash:	the hash value / bucket index
470  * @hash:	the hash value / bucket index
490  * @hash:	the hash value / bucket index
506  * @hash:	the hash value / bucket index
524  * @hash:	the hash value / bucket index
542  * @hash:	the hash value / bucket index
635  * Computes the hash value for the key and traverses the bucket chain looking
657  * Computes the hash value for the key and traverses the bucket chain looking
684  * Computes the hash value for the key and traverses the bucket chain looking
819  * Will take the per bucket bitlock to protect against mutual mutations
820  * on the same bucket. Multiple insertions may occur in parallel unless
821  * they map to the same bucket.
848  * Will take the per bucket bitlock to protect against mutual mutations
849  * on the same bucket. Multiple insertions may occur in parallel unless
850  * they map to the same bucket.
871  * Will take the per bucket bitlock to protect against mutual mutations
872  * on the same bucket. Multiple insertions may occur in parallel unless
873  * they map to the same bucket.
1088 	/* Because we have already taken (and released) the bucket
1110  * walk the bucket chain upon removal. The removal operation is thus
1132  * walk the bucket chain upon removal. The removal operation is thus
1205  * or bucket, so we don't need to worry about shrinking or expanding the
1223 	/* Because we have already taken (and released) the bucket