On 17.10.19 г. 22:39 ч., David Sterba wrote:
> Signed-off-by: David Sterba <dste...@suse.com>
> ---
> fs/btrfs/locking.c | 110 +++++++++++++++++++++++++++++++++++++++------
> 1 file changed, 96 insertions(+), 14 deletions(-)
>
> diff --git a/fs/btrfs/locking.c b/fs/btrfs/locking.c
> index e0e0430577aa..2a0e828b4470 100644
> --- a/fs/btrfs/locking.c
> +++ b/fs/btrfs/locking.c
> @@ -13,6 +13,48 @@
> #include "extent_io.h"
> #include "locking.h"
>
> +/*
> + * Extent buffer locking
> + * ~~~~~~~~~~~~~~~~~~~~~
> + *
> + * The locks use a custom scheme that allows to do more operations than are
> + * available fromt current locking primitives. The building blocks are still
> + * rwlock and wait queues.
> + *
> + * Required semantics:
> + *
> + * - reader/writer exclusion
> + * - writer/writer exclusion
> + * - reader/reader sharing
> + * - spinning lock semantics
> + * - blocking lock semantics
> + * - try-lock semantics for readers and writers
> + * - one level nesting, allowing read lock to be taken by the same thread
> that
> + * already has write lock
> + *
> + * The extent buffer locks (also called tree locks) manage access to eb data.
> + * We want concurrency of many readers and safe updates. The underlying
> locking
> + * is done by read-write spinlock and the blocking part is implemented using
> + * counters and wait queues.
> + *
> + * spinning semantics - the low-level rwlock is held so all other threads
> that
> + * want to take it are spinning on it.
> + *
> + * blocking semantics - the low-level rwlock is not held but the counter
> + * denotes how many times the blocking lock was held;
> + * sleeping is possible
> + *
> + * Write lock always allows only one thread to access the data.
> + *
> + *
> + * Debugging
> + * ~~~~~~~~~
> + *
> + * There are additional state counters that are asserted in various contexts,
> + * removed from non-debug build to reduce extent_buffer size and for
> + * performance reasons.
> + */
> +
> #ifdef CONFIG_BTRFS_DEBUG
> static inline void btrfs_assert_spinning_writers_get(struct extent_buffer
> *eb)
> {
> @@ -80,6 +122,15 @@ static void btrfs_assert_tree_write_locks_get(struct
> extent_buffer *eb) { }
> static void btrfs_assert_tree_write_locks_put(struct extent_buffer *eb) { }
> #endif
>
> +/*
> + * Mark already held read lock as blocking. Can be nested in write lock by
> the
> + * same thread.
> + *
> + * Use when there are potentially long operations ahead so other thread
> waiting
> + * on the lock will not actively spin but sleep instead.
> + *
> + * The rwlock is released and blocking reader counter is increased.
> + */
> void btrfs_set_lock_blocking_read(struct extent_buffer *eb)
> {
I think for this and it's write counterpart a
lockdep_assert_held(eb->lock) will be a better way to document the fact
the lock needs to be held when those functions are called.
> trace_btrfs_set_lock_blocking_read(eb);
<snip>
> /*
> - * drop a blocking read lock
> + * Release read lock, previously set to blocking by a pairing call to
> + * btrfs_set_lock_blocking_read(). Can be nested in write lock by the same
> + * thread.
> + *
> + * State of rwlock is unchanged, last reader wakes waiting threads.
> */
> void btrfs_tree_read_unlock_blocking(struct extent_buffer *eb)
> {
> @@ -279,8 +354,10 @@ void btrfs_tree_read_unlock_blocking(struct
> extent_buffer *eb)
> }
>
> /*
> - * take a spinning write lock. This will wait for both
> - * blocking readers or writers
> + * Lock for write. Wait for all blocking and spinning readers and writers.
> This
> + * starts context where reader lock could be nested by the same thread.
Imo you shouldn't ommit the explicit mention this takes a spinning lock.
> + *
> + * The rwlock is held for write upon exit.
> */
> void btrfs_tree_lock(struct extent_buffer *eb)
> {
> @@ -307,7 +384,12 @@ void btrfs_tree_lock(struct extent_buffer *eb)
> }
>
> /*
> - * drop a spinning or a blocking write lock.
> + * Release the write lock, either blocking or spinning (ie. there's no need
> + * for an explicit blocking unlock, like btrfs_tree_read_unlock_blocking).
> + * This also ends the context for nesting, the read lock must have been
> + * released already.
> + *
> + * Tasks blocked and waiting are woken, rwlock is not held upon exit.
> */
> void btrfs_tree_unlock(struct extent_buffer *eb)
> {
>
