Re: [PATCH 1/2] btrfs: Implement DRW lock

["Paul E. McKenney" <paulmck@linux.ibm.com>]

On Fri, Jun 07, 2019 at 02:59:34PM +0300, Nikolay Borisov wrote:
> 
> 
> On 7.06.19 г. 13:52 ч., Paul E. McKenney wrote:
> > On Thu, Jun 06, 2019 at 04:52:18PM +0300, Nikolay Borisov wrote:
> >> A (D)ouble (R)eader (W)riter lock is a locking primitive that allows
> >> to have multiple readers or multiple writers but not multiple readers
> >> and writers holding it concurrently. The code is factored out from
> >> the existing open-coded locking scheme used to exclude pending
> >> snapshots from nocow writers and vice-versa. Current implementation
> >> actually favors Readers (that is snapshot creaters) to writers (nocow
> >> writers of the filesystem).
> >>
> >> Signed-off-by: Nikolay Borisov <nborisov@suse.com>
> > 
> > A preliminary question...
> > 
> > What prevents the following sequence of events from happening?
> > 
> > o	btrfs_drw_write_lock() invokes btrfs_drw_try_write_lock(),
> > 	which sees that lock->readers is zero and thus executes
> > 	percpu_counter_inc(&lock->writers).
> > 
> > o	btrfs_drw_read_lock() increments lock->readers, does the
> > 	smp_mb__after_atomic(), and then does the wait_event().
> > 	Because btrfs_drw_try_write_lock() incremented its CPU's
> > 	lock->writers, the sum is the value one, so it blocks.
> > 
> > o	btrfs_drw_try_write_lock() checks lock->readers, sees that
> > 	it is now nonzero, and thus invokes btrfs_drw_read_unlock()
> > 	(which decrements the current CPU's counter, so that a future
> > 	sum would get zero), and returns false.
> 
> btrfs_drw_read_unlock is actually btrfs_drw_write_unlock, my bad, Filipe
> already pointed that out and I've fixed it.

Ah!  I must then ask what you are using to test this.  kernel/locktorture.c?

> The idea here is that if a reader came after we've incremented out
> percpu counter then it would have blocked, the writer would see that and
> invoke btrfs_drw_write_unlock which will decrement the percpu counter
> and will wakeup the reader that is now blocked on pending_readers.

OK, I will await your next version.

							Thanx, Paul

> > o	btrfs_drw_write_lock() therefore does its wait_event().
> > 	Because lock->readers is nonzero, it blocks.
> > 
> > o	Both tasks are now blocked.  In the absence of future calls
> > 	to these functions (and perhaps even given such future calls),
> > 	we have deadlock.
> > 
> > So what am I missing here?
> > 
> > 							Thanx, Paul
> > 
> >> ---
> >>  fs/btrfs/Makefile   |  2 +-
> >>  fs/btrfs/drw_lock.c | 71 +++++++++++++++++++++++++++++++++++++++++++++
> >>  fs/btrfs/drw_lock.h | 23 +++++++++++++++
> >>  3 files changed, 95 insertions(+), 1 deletion(-)
> >>  create mode 100644 fs/btrfs/drw_lock.c
> >>  create mode 100644 fs/btrfs/drw_lock.h
> >>
> >> diff --git a/fs/btrfs/Makefile b/fs/btrfs/Makefile
> >> index ca693dd554e9..dc60127791e6 100644
> >> --- a/fs/btrfs/Makefile
> >> +++ b/fs/btrfs/Makefile
> >> @@ -10,7 +10,7 @@ btrfs-y += super.o ctree.o extent-tree.o print-tree.o root-tree.o dir-item.o \
> >>  	   export.o tree-log.o free-space-cache.o zlib.o lzo.o zstd.o \
> >>  	   compression.o delayed-ref.o relocation.o delayed-inode.o scrub.o \
> >>  	   reada.o backref.o ulist.o qgroup.o send.o dev-replace.o raid56.o \
> >> -	   uuid-tree.o props.o free-space-tree.o tree-checker.o
> >> +	   uuid-tree.o props.o free-space-tree.o tree-checker.o drw_lock.o
> >>  
> >>  btrfs-$(CONFIG_BTRFS_FS_POSIX_ACL) += acl.o
> >>  btrfs-$(CONFIG_BTRFS_FS_CHECK_INTEGRITY) += check-integrity.o
> >> diff --git a/fs/btrfs/drw_lock.c b/fs/btrfs/drw_lock.c
> >> new file mode 100644
> >> index 000000000000..9681bf7544be
> >> --- /dev/null
> >> +++ b/fs/btrfs/drw_lock.c
> >> @@ -0,0 +1,71 @@
> >> +#include "drw_lock.h"
> >> +#include "ctree.h"
> >> +
> >> +void btrfs_drw_lock_init(struct btrfs_drw_lock *lock)
> >> +{
> >> +	atomic_set(&lock->readers, 0);
> >> +	percpu_counter_init(&lock->writers, 0, GFP_KERNEL);
> >> +	init_waitqueue_head(&lock->pending_readers);
> >> +	init_waitqueue_head(&lock->pending_writers);
> >> +}
> >> +
> >> +void btrfs_drw_lock_destroy(struct btrfs_drw_lock *lock)
> >> +{
> >> +	percpu_counter_destroy(&lock->writers);
> >> +}
> >> +
> >> +bool btrfs_drw_try_write_lock(struct btrfs_drw_lock *lock)
> >> +{
> >> +	if (atomic_read(&lock->readers))
> >> +		return false;
> >> +
> >> +	percpu_counter_inc(&lock->writers);
> >> +
> >> +	/*
> >> +	 * Ensure writers count is updated before we check for
> >> +	 * pending readers
> >> +	 */
> >> +	smp_mb();
> >> +	if (atomic_read(&lock->readers)) {
> >> +		btrfs_drw_read_unlock(lock);
> >> +		return false;
> >> +	}
> >> +
> >> +	return true;
> >> +}
> >> +
> >> +void btrfs_drw_write_lock(struct btrfs_drw_lock *lock)
> >> +{
> >> +	while(true) {
> >> +		if (btrfs_drw_try_write_lock(lock))
> >> +			return;
> >> +		wait_event(lock->pending_writers, !atomic_read(&lock->readers));
> >> +	}
> >> +}
> >> +
> >> +void btrfs_drw_write_unlock(struct btrfs_drw_lock *lock)
> >> +{
> >> +	percpu_counter_dec(&lock->writers);
> >> +	cond_wake_up(&lock->pending_readers);
> >> +}
> >> +
> >> +void btrfs_drw_read_lock(struct btrfs_drw_lock *lock)
> >> +{
> >> +	atomic_inc(&lock->readers);
> >> +	smp_mb__after_atomic();
> >> +
> >> +	wait_event(lock->pending_readers,
> >> +		   percpu_counter_sum(&lock->writers) == 0);
> >> +}
> >> +
> >> +void btrfs_drw_read_unlock(struct btrfs_drw_lock *lock)
> >> +{
> >> +	/*
> >> +	 * Atomic RMW operations imply full barrier, so woken up writers
> >> +	 * are guaranteed to see the decrement
> >> +	 */
> >> +	if (atomic_dec_and_test(&lock->readers))
> >> +		wake_up(&lock->pending_writers);
> >> +}
> >> +
> >> +
> >> diff --git a/fs/btrfs/drw_lock.h b/fs/btrfs/drw_lock.h
> >> new file mode 100644
> >> index 000000000000..baff59561c06
> >> --- /dev/null
> >> +++ b/fs/btrfs/drw_lock.h
> >> @@ -0,0 +1,23 @@
> >> +#ifndef BTRFS_DRW_LOCK_H
> >> +#define BTRFS_DRW_LOCK_H
> >> +
> >> +#include <linux/atomic.h>
> >> +#include <linux/wait.h>
> >> +#include <linux/percpu_counter.h>
> >> +
> >> +struct btrfs_drw_lock {
> >> +	atomic_t readers;
> >> +	struct percpu_counter writers;
> >> +	wait_queue_head_t pending_writers;
> >> +	wait_queue_head_t pending_readers;
> >> +};
> >> +
> >> +void btrfs_drw_lock_init(struct btrfs_drw_lock *lock);
> >> +void btrfs_drw_lock_destroy(struct btrfs_drw_lock *lock);
> >> +void btrfs_drw_write_lock(struct btrfs_drw_lock *lock);
> >> +bool btrfs_drw_try_write_lock(struct btrfs_drw_lock *lock);
> >> +void btrfs_drw_write_unlock(struct btrfs_drw_lock *lock);
> >> +void btrfs_drw_read_lock(struct btrfs_drw_lock *lock);
> >> +void btrfs_drw_read_unlock(struct btrfs_drw_lock *lock);
> >> +
> >> +#endif
> >> -- 
> >> 2.17.1
> >>
> > 
> > 
>