Refactor snapshot vs nocow writers locking
Subsystems (2)
v3 cover Refactor snapshot vs nocow writers locking
Here is v3 of the DRW locking patches.
Main changes in this verison:
* Removed EXPORT_SYMBOL for function since I do not intend to submit the locktorture patch
* Added high-level comment as per David's request.
V2:
* Fixed all checkpatch warnings (Andrea Parri)
* Properly call write_unlock in btrfs_drw_try_write_lock (Filipe Manana)
* Comment fix.
* Stress tested it via locktorture. Survived for 8 straight days on a 4 socket 48 thread machine.
Nikolay Borisov (2):
btrfs: convert snapshot/nocow exlcusion to drw lock
btrfs: Hook btrfs' DRW lock to locktorture infrastructure
fs/btrfs/ctree.h | 9 +---- fs/btrfs/disk-io.c | 46 ++++++--------------- fs/btrfs/extent-tree.c | 44 --------------------- fs/btrfs/file.c | 11 +++--- fs/btrfs/inode.c | 8 ++-- fs/btrfs/ioctl.c | 10 ++--- fs/btrfs/locking.c | 5 +++ fs/btrfs/locking.h | 1 + kernel/locking/locktorture.c | 77 +++++++++++++++++++++++++++++++++++- 9 files changed, 107 insertions(+), 104 deletions(-)
--
2.17.1
PATCH v3 1/2 btrfs: convert snapshot/nocow exlcusion to drw lock
This patch removes all haphazard code implementing nocow writers exclusion from pending snapshot creation and switches to using the drw lock to ensure this invariant still holds. "Readers" are snapshot creators from create_snapshot and 'writers' are nocow writers from buffered write path or btrfs_setsize. This locking scheme allows for multiple snapshots to happen while any nocow writers are blocked, since writes to page cache in the nocow path will make snapshots inconsistent.
So for performance reasons we'd like to have the ability to run multiple concurrent snapshots and also favors readers in this case. And in case there aren't pending snapshots (which will be the majority of the cases) we rely on the percpu's writers counter to avoid cacheline contention.
The main gain from using the drw is it's now a lot easier to reason about the guarantees of the locking scheme and whether there is some silent breakage lurking.
--- fs/btrfs/ctree.h | 9 ++------- fs/btrfs/disk-io.c | 46 ++++++++++-------------------------------- fs/btrfs/extent-tree.c | 44 ---------------------------------------- fs/btrfs/file.c | 11 +++++----- fs/btrfs/inode.c | 8 ++++---- fs/btrfs/ioctl.c | 10 +++------ 6 files changed, 25 insertions(+), 103 deletions(-)
fs/btrfs/ctree.h +2 -7
@@ -957,11 +957,6 @@ static inline struct btrfs_fs_info *btrfs_sb(struct super_block *sb)return sb->s_fs_info; } -struct btrfs_subvolume_writers { -struct percpu_counter counter; -wait_queue_head_t wait; -}; -/* * The state of btrfs root */
@@ -1133,8 +1128,8 @@ struct btrfs_root {* root_item_lock. */ int dedupe_in_progress; -struct btrfs_subvolume_writers *subv_writers; -atomic_t will_be_snapshotted; +struct btrfs_drw_lock snapshot_lock; +atomic_t snapshot_force_cow;/* For qgroup metadata reserved space */
fs/btrfs/disk-io.c +11 -35
77 lines not on this page · raw message
fs/btrfs/extent-tree.c +0 -44
47 lines not on this page · raw message
fs/btrfs/file.c +5 -6
@@ -1553,8 +1553,7 @@ static noinline int check_can_nocow(struct btrfs_inode *inode, loff_t pos,u64 num_bytes;int ret; - ret =btrfs_start_write_no_snapshotting (root); -if (!ret) +if (!btrfs_drw_try_write_lock (&root->snapshot_lock))return -EAGAIN ; lockstart =round_down (pos, fs_info->sectorsize);
@@ -1569,7 +1568,7 @@ static noinline int check_can_nocow(struct btrfs_inode *inode, loff_t pos, NULL, NULL, NULL);if (ret <=0 ) { ret =0 ; -btrfs_end_write_no_snapshotting (root); +btrfs_drw_write_unlock (&root->snapshot_lock); }else { *write_bytes =min_t (size_t, *write_bytes , num_bytes - pos + lockstart);
@@ -1675,7 +1674,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, data_reserved, pos, write_bytes); else -btrfs_end_write_no_snapshotting (root ); + btrfs_drw_write_unlock(&root->snapshot_lock);break ; }
@@ -1779,7 +1778,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb, release_bytes =0 ;if (only_release_metadata) -btrfs_end_write_no_snapshotting (root); +btrfs_drw_write_unlock (&root->snapshot_lock);if (only_release_metadata && copied >0 ) { lockstart = round_down(pos,
@@ -1808,7 +1807,7 @@ static noinline ssize_t btrfs_buffered_write(struct kiocb *iocb,if (release_bytes) {if (only_release_metadata) { -btrfs_end_write_no_snapshotting (root); +btrfs_drw_write_unlock (&root->snapshot_lock);btrfs_delalloc_release_metadata (BTRFS_I (inode), release_bytes, true); }else {
fs/btrfs/inode.c +4 -4
@@ -4726,16 +4726,16 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)* truncation, it must capture all writes that happened before * this truncation. */ -btrfs_wait_for_snapshot_creation (root); +btrfs_drw_write_lock (&root->snapshot_lock); ret =btrfs_cont_expand (inode, oldsize, newsize);if (ret) { -btrfs_end_write_no_snapshotting (root); +btrfs_drw_write_unlock (&root->snapshot_lock);return ret; } trans =btrfs_start_transaction (root,1 );if (IS_ERR (trans)) { -btrfs_end_write_no_snapshotting (root); +btrfs_drw_write_unlock (&root->snapshot_lock);return PTR_ERR (trans); }
@@ -4743,7 +4743,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)btrfs_inode_safe_disk_i_size_write (inode,0 );pagecache_isize_extended (inode, oldsize, newsize); ret =btrfs_update_inode (trans, root, inode); -btrfs_end_write_no_snapshotting (root); +btrfs_drw_write_unlock (&root->snapshot_lock);btrfs_end_transaction (trans); }else {
fs/btrfs/ioctl.c +3 -7
@@ -790,11 +790,7 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir,* possible. This is to avoid later writeback (running dealloc) to * fallback to COW mode and unexpectedly fail with ENOSPC. */ -atomic_inc (&root->will_be_snapshotted); -smp_mb__after_atomic (); -/* wait for no snapshot writes */ -wait_event (root->subv_writers->wait, -percpu_counter_sum (&root->subv_writers->counter) ==0 ); +btrfs_drw_read_lock (&root->snapshot_lock); ret =btrfs_start_delalloc_snapshot (root);if (ret)
@@ -875,8 +871,8 @@ static int create_snapshot(struct btrfs_root *root, struct inode *dir, dec_and_free:if (snapshot_force_cow)atomic_dec (&root->snapshot_force_cow); -if (atomic_dec_and_test (&root->will_be_snapshotted)) -wake_up_var (&root->will_be_snapshotted); +btrfs_drw_read_unlock (&root->snapshot_lock); + free_pending:kfree (pending_snapshot->root_item);btrfs_free_path (pending_snapshot->path);
Signature · 1 line
2.17.1
PATCH v3 1/2 btrfs: Implement DRW lock
In reply to Nikolay BorisovA (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).
--- fs/btrfs/ctree.h | 1 + fs/btrfs/locking.c | 90 ++++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/locking.h | 21 +++++++++++ 3 files changed, 112 insertions(+)
fs/btrfs/ctree.h +1 -0
@@ -33,6 +33,7 @@#include "extent_map.h" #include "async-thread.h" #include "block-rsv.h" +#include "locking.h" struct btrfs_trans_handle ;struct btrfs_transaction ;
fs/btrfs/locking.c +90 -0
93 lines not on this page · raw message
fs/btrfs/locking.h +21 -0
@@ -7,12 +7,17 @@#define BTRFS_LOCKING_H #include "extent_io.h" +#include <linux/atomic.h> +#include <linux/wait.h> +#include <linux/percpu_counter.h> #define BTRFS_WRITE_LOCK 1#define BTRFS_READ_LOCK 2#define BTRFS_WRITE_LOCK_BLOCKING 3#define BTRFS_READ_LOCK_BLOCKING 4 +struct btrfs_path ; +void btrfs_tree_lock (struct extent_buffer *eb);void btrfs_tree_unlock (struct extent_buffer *eb);
@@ -48,4 +53,20 @@ static inline void btrfs_tree_unlock_rw(struct extent_buffer *eb, int rw) BUG(); } + +struct btrfs_drw_lock { +atomic_t readers; +struct percpu_counter writers; +wait_queue_head_t pending_writers; +wait_queue_head_t pending_readers; +}; + +int 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
Signature · 1 line
2.17.1
PATCH v3 2/2 btrfs: Hook btrfs' DRW lock to locktorture infrastructure
In reply to Nikolay Borisov--- fs/btrfs/locking.c | 5 +++ fs/btrfs/locking.h | 1 + kernel/locking/locktorture.c | 77 +++++++++++++++++++++++++++++++++++- 3 files changed, 82 insertions(+), 1 deletion(-)
fs/btrfs/locking.c +5 -0
@@ -614,6 +614,7 @@ bool btrfs_drw_try_write_lock(struct btrfs_drw_lock *lock)return true; } +EXPORT_SYMBOL (btrfs_drw_try_write_lock);void btrfs_drw_write_lock (struct btrfs_drw_lock *lock) {
@@ -623,12 +624,14 @@ void btrfs_drw_write_lock(struct btrfs_drw_lock *lock)wait_event (lock->pending_writers, !atomic_read (&lock->readers)); } } +EXPORT_SYMBOL (btrfs_drw_write_lock);void btrfs_drw_write_unlock (struct btrfs_drw_lock *lock) {percpu_counter_dec (&lock->writers);cond_wake_up (&lock->pending_readers); } +EXPORT_SYMBOL (btrfs_drw_write_unlock);void btrfs_drw_read_lock (struct btrfs_drw_lock *lock) {
@@ -645,6 +648,7 @@ void btrfs_drw_read_lock(struct btrfs_drw_lock *lock)wait_event (lock->pending_readers,percpu_counter_sum (&lock->writers) ==0 ); } +EXPORT_SYMBOL (btrfs_drw_read_lock);void btrfs_drw_read_unlock (struct btrfs_drw_lock *lock) {
@@ -655,3 +659,4 @@ void btrfs_drw_read_unlock(struct btrfs_drw_lock *lock)if (atomic_dec_and_test (&lock->readers))wake_up (&lock->pending_writers); } +EXPORT_SYMBOL (btrfs_drw_read_unlock);
fs/btrfs/locking.h +1 -0
@@ -10,6 +10,7 @@#include <linux/atomic.h> #include <linux/wait.h> #include <linux/percpu_counter.h> +#include "extent_io.h" #define BTRFS_WRITE_LOCK 1#define BTRFS_READ_LOCK 2
kernel/locking/locktorture.c +76 -1
113 lines not on this page · raw message
Signature · 1 line
2.17.1
Re: [PATCH v3 2/2] btrfs: Hook btrfs' DRW lock to locktorture infrastructure
Quoted 1 line · Nikolay Borisov
Signed-off-by Nikolay Borisov <[email protected]>
Ignore this one and instead replace it with the Implement DRW locking that I just sent ...
Quoted 1 line · Nikolay Borisov
Here is v3 of the DRW locking patches.
As discussed, let's rename it to DREW locks, where E stands for
exclusion: double reader/writer exclusion.