linux-toradex.git/include/linux/rhashtable.h, branch v5.17-rc1

rhashtable: Restore RCU marking on rhash_lock_head

2020-07-29T00:09:49+00:00

This patch restores the RCU marking on bucket_table->buckets as
it really does need RCU protection.  Its removal had led to a fatal
bug.

Signed-off-by: Herbert Xu 
Signed-off-by: David S. Miller

rhashtable: Fix unprotected RCU dereference in __rht_ptr

2020-07-29T00:09:49+00:00

The rcu_dereference call in rht_ptr_rcu is completely bogus because
we've already dereferenced the value in __rht_ptr and operated on it.
This causes potential double readings which could be fatal.  The RCU
dereference must occur prior to the comparison in __rht_ptr.

This patch changes the order of RCU dereference so that it is done
first and the result is then fed to __rht_ptr.  The RCU marking
changes have been minimised using casts which will be removed in
a follow-up patch.

Fixes: ba6306e3f648 ("rhashtable: Remove RCU marking from...")
Reported-by: "Gong, Sishuai" 
Signed-off-by: Herbert Xu 
Signed-off-by: David S. Miller

rhashtable: drop duplicated word in

2020-07-18T01:34:18+00:00

Drop the doubled word "be" in a comment.

Signed-off-by: Randy Dunlap 
Cc: Thomas Graf 
Cc: Herbert Xu 
Cc: netdev@vger.kernel.org
Signed-off-by: David S. Miller

rhashtable: Document the right function parameters

2020-03-07T06:33:38+00:00

rhashtable_lookup_get_insert_key doesn't have a parameter `data`. It
does have a parameter `key`, however.

Signed-off-by: Jonathan Neuschäfer 
Acked-by: Herbert Xu 
Signed-off-by: David S. Miller

rhashtable: Add rht_ptr_rcu and improve rht_ptr

2019-05-29T20:27:08+00:00

This patch moves common code between rht_ptr and rht_ptr_exclusive
into __rht_ptr.  It also adds a new helper rht_ptr_rcu exclusively
for the RCU case.  This way rht_ptr becomes a lock-only construct
so we can use the lighter rcu_dereference_protected primitive.

Signed-off-by: Herbert Xu 
Signed-off-by: David S. Miller

rhashtable: Remove RCU marking from rhash_lock_head

2019-05-16T16:45:20+00:00

The opaque type rhash_lock_head should not be marked with __rcu
because it can never be dereferenced.  We should apply the RCU
marking when we turn it into a pointer which can be dereferenced.

This patch does exactly that.  This fixes a number of sparse
warnings as well as getting rid of some unnecessary RCU checking.

Signed-off-by: Herbert Xu 
Signed-off-by: David S. Miller

rhashtable: use BIT(0) for locking.

2019-04-13T00:34:45+00:00

As reported by Guenter Roeck, the new bit-locking using
BIT(1) doesn't work on the m68k architecture.  m68k only requires
2-byte alignment for words and longwords, so there is only one
unused bit in pointers to structs - We current use two, one for the
NULLS marker at the end of the linked list, and one for the bit-lock
in the head of the list.

The two uses don't need to conflict as we never need the head of the
list to be a NULLS marker - the marker is only needed to check if an
object has moved to a different table, and the bucket head cannot
move.  The NULLS marker is only needed in a ->next pointer.

As we already have different types for the bucket head pointer (struct
rhash_lock_head) and the ->next pointers (struct rhash_head), it is
fairly easy to treat the lsb differently in each.

So: Initialize buckets heads to NULL, and use the lsb for locking.
When loading the pointer from the bucket head, if it is NULL (ignoring
the lock big), report as being the expected NULLS marker.
When storing a value into a bucket head, if it is a NULLS marker,
store NULL instead.

And convert all places that used bit 1 for locking, to use bit 0.

Fixes: 8f0db018006a ("rhashtable: use bit_spin_locks to protect hash bucket.")
Reported-by: Guenter Roeck 
Tested-by: Guenter Roeck 
Signed-off-by: NeilBrown 
Signed-off-by: David S. Miller

rhashtable: replace rht_ptr_locked() with rht_assign_locked()

2019-04-13T00:34:45+00:00

The only times rht_ptr_locked() is used, it is to store a new
value in a bucket-head.  This is the only time it makes sense
to use it too.  So replace it by a function which does the
whole task:  Sets the lock bit and assigns to a bucket head.

Signed-off-by: NeilBrown 
Signed-off-by: David S. Miller

rhashtable: move dereference inside rht_ptr()

2019-04-13T00:34:45+00:00

Rather than dereferencing a pointer to a bucket and then passing the
result to rht_ptr(), we now pass in the pointer and do the dereference
in rht_ptr().

This requires that we pass in the tbl and hash as well to support RCU
checks, and means that the various rht_for_each functions can expect a
pointer that can be dereferenced without further care.

There are two places where we dereference a bucket pointer
where there is no testable protection - in each case we know
that we much have exclusive access without having taken a lock.
The previous code used rht_dereference() to pretend that holding
the mutex provided protects, but holding the mutex never provides
protection for accessing buckets.

So instead introduce rht_ptr_exclusive() that can be used when
there is known to be exclusive access without holding any locks.

Signed-off-by: NeilBrown 
Signed-off-by: David S. Miller

rhashtable: reorder some inline functions and macros.

2019-04-13T00:34:45+00:00

This patch only moves some code around, it doesn't
change the code at all.
A subsequent patch will benefit from this as it needs
to add calls to functions which are now defined before the
call-site, but weren't before.

Signed-off-by: NeilBrown 
Signed-off-by: David S. Miller