Refactor snapshot vs nocow writers locking
cover Refactor snapshot vs nocow writers locking
This patchset first factors out the open code which essentially implements a lock that allows to have either multiple reader or multiple writers but not both. Then patch 2 just converts the code to using the newly introduced lock.
The individual patch descriptions contain more information about the technical details and invariants that the lock provide.
I have also CC'ed a copule of the maintainer of linux memory model since my patches just factor out the code and I would really like someone proficient enough in the usage/semantics of memory barries to review it as well.
Nikolay Borisov (2):
btrfs: Implement DRW lock
btrfs: convert snapshot/nocow exlcusion to drw lock
fs/btrfs/Makefile | 2 +- fs/btrfs/ctree.h | 10 ++---- fs/btrfs/disk-io.c | 39 ++--------------------- fs/btrfs/drw_lock.c | 71 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/drw_lock.h | 23 ++++++++++++++ fs/btrfs/extent-tree.c | 35 --------------------- fs/btrfs/file.c | 12 +++---- fs/btrfs/inode.c | 8 ++--- fs/btrfs/ioctl.c | 10 ++---- 9 files changed, 114 insertions(+), 96 deletions(-) create mode 100644 fs/btrfs/drw_lock.c create mode 100644 fs/btrfs/drw_lock.h
Signature · 1 line
2.17.1
PATCH 1/2 btrfs: Implement DRW lock
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).
--- 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
fs/btrfs/Makefile +1 -1
@@ -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
fs/btrfs/drw_lock.c new file +71 -0
71 lines not on this page · raw message
fs/btrfs/drw_lock.h new file +23 -0
@@ -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
Signature · 1 line
2.17.1
Re: [PATCH 1/2] btrfs: Implement DRW lock
Quoted 7 lines · Nikolay Borisov
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).
Any reason not to move it to lib/ under a new option so that other users could reuse it as needed?
Re: [PATCH 1/2] btrfs: Implement DRW lock
Quoted 9 lines · Christoph Hellwig
Quoted 7 lines · Nikolay Borisov
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).
Quoted 3 lines
Any reason not to move it to
lib/under a new option so that other users could reuse it as needed?
Yes, I think it's rather specific to btrfs. I don't care honestly if there is demand I wouldn't mind.
Re: [PATCH 1/2] btrfs: Implement DRW lock
Quoted 12 lines · Nikolay Borisov
Quoted 9 lines · Christoph Hellwig
Quoted 7 lines · Nikolay Borisov
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).
Quoted 6 lines
Quoted 3 lines
Any reason not to move it to
lib/under a new option so that other users could reuse it as needed?Yes, I think it's rather specific to btrfs. I don't care honestly if there is demand I wouldn't mind.
Ok, just keep it in btrfs for now, we can always move it later. It just looks like very generic code.
v2 cover Refactor snapshot vs nocow writers locking
In reply to Nikolay BorisovHello,
Here is the second version of the DRW lock for btrfs. Main changes from v1:
* 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.
I'm resending this one since it's been quite a while. Additionally Valentin Schneider has created a more accurate spec of the algorithm than the one I had initially submitted. It can be found here
https://lore.kernel.org/lkml/[email protected]/
I've been running with those patches on my custoom tree for a couple of months and haven't observed any issues.
Nikolay Borisov (2):
btrfs: Implement DRW lock
btrfs: convert snapshot/nocow exlcusion to drw lock
fs/btrfs/ctree.h | 10 ++--- 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 | 87 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/locking.h | 21 ++++++++++ 8 files changed, 134 insertions(+), 103 deletions(-)
--
2.17.1
Quoted 3 lines · Nikolay Borisov
Hello,
Here is the second version of the DRW lock for btrfs. Main changes from v1:
As the code is wrapping the existing code I think we're good to add it to misc-next soon so we have more coverage.
Please add comments with the lock semantics overview and to all the public functions. Having more assertions would be also good, like the tree locks do. Thanks.
Quoted 3 lines · David Sterba
Please add comments with the lock semantics overview and to all the public functions. Having more assertions would be also good, like the tree locks do. Thanks.
The patches started to conflict with others so I've removed it from for-next until the updated version with comments arrives.
PATCH v2 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 | 87 ++++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/locking.h | 21 +++++++++++ 3 files changed, 109 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 +87 -0
90 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
Re: [PATCH v2 1/2] btrfs: Implement DRW lock
Quoted 41 lines · Nikolay Borisov
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 <[email protected]>--- fs/btrfs/ctree.h | 1 + fs/btrfs/locking.c | 87 ++++++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/locking.h | 21 +++++++++++ 3 files changed, 109 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 +6
-0@@ -523,3 +523,90 @@ void btrfs_unlock_up_safe(struct btrfs_path *path, int level) path->locks[i] =0 ; } } + +int btrfs_drw_lock_init (struct btrfs_drw_lock *lock) +{ +int ret; + + ret =percpu_counter_init (&lock->writers,0 ,GFP_KERNEL );
fs/btrfs/locking.c void btrfs_unlock_up_safe(struct btrfs_path *path, int level) · line 541
Quoted 10 lines
fs/btrfs/locking.c +10
-0+if (ret) +return ret; + +atomic_set (&lock->readers,0 ); +init_waitqueue_head (&lock->pending_readers); +init_waitqueue_head (&lock->pending_writers); + +return 0 ; +} +EXPORT_SYMBOL (btrfs_drw_lock_init);
I have the functions EXPORT_SYMBOL since I have an internal patch which is hooking this code to locktorture. SO they can be removed.
Re: [PATCH v2 1/2] btrfs: Implement DRW lock
Quoted 10 lines · Nikolay Borisov
Quoted 10 lines
fs/btrfs/locking.c +10
-0+int btrfs_drw_lock_init (struct btrfs_drw_lock *lock) +{ +int ret; + + ret =percpu_counter_init (&lock->writers,0 ,GFP_KERNEL ); +if (ret) +return ret; + +atomic_set (&lock->readers,0 ); +init_waitqueue_head (&lock->pending_readers);
Quoted 8 lines
fs/btrfs/locking.c void btrfs_unlock_up_safe(struct btrfs_path *path, int level) · line 541
Quoted 5 lines
fs/btrfs/locking.c +5
-0+init_waitqueue_head (&lock->pending_writers); + +return 0 ; +} +EXPORT_SYMBOL (btrfs_drw_lock_init);I have the functions
EXPORT_SYMBOLsince I have an internal patch which is hooking this code to locktorture. SO they can be removed.
You can make the exports conditional, #ifdef LOCKTORTURE.
Re: [PATCH v2 1/2] btrfs: Implement DRW lock
Quoted 20 lines · David Sterba
Quoted 10 lines · Nikolay Borisov
Quoted 10 lines
fs/btrfs/locking.c +10
-0+int btrfs_drw_lock_init (struct btrfs_drw_lock *lock) +{ +int ret; + + ret =percpu_counter_init (&lock->writers,0 ,GFP_KERNEL ); +if (ret) +return ret; + +atomic_set (&lock->readers,0 ); +init_waitqueue_head (&lock->pending_readers);Quoted 8 lines
fs/btrfs/locking.c void btrfs_unlock_up_safe(struct btrfs_path *path, int level) · line 541
Quoted 5 lines
fs/btrfs/locking.c +5
-0+init_waitqueue_head (&lock->pending_writers); + +return 0 ; +} +EXPORT_SYMBOL (btrfs_drw_lock_init);I have the functions
EXPORT_SYMBOLsince I have an internal patch which is hooking this code to locktorture. SO they can be removed.
Quoted 2 lines
You can make the exports conditional, #ifdef LOCKTORTURE.
I don't think I will be submitting that patch unless the lock is moved to lib/. I guess I will just remove it in v3 after review.
PATCH v2 2/2 btrfs: convert snapshot/nocow exlcusion to drw lock
In reply to Nikolay BorisovThis 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
@@ -958,11 +958,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 */
@@ -1134,8 +1129,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
@@ -1552,8 +1552,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);
@@ -1568,7 +1567,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);
@@ -1674,7 +1673,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 ; }
@@ -1778,7 +1777,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,
@@ -1807,7 +1806,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
@@ -4594,16 +4594,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); }
@@ -4611,7 +4611,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)btrfs_ordered_update_i_size (inode,i_size_read (inode),NULL );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
@@ -789,11 +789,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)
@@ -873,8 +869,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 2/2 btrfs: convert snapshot/nocow exlcusion to drw lock
In reply to Nikolay BorisovThis 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 | 10 +++------- fs/btrfs/disk-io.c | 39 +++------------------------------------ fs/btrfs/extent-tree.c | 35 ----------------------------------- fs/btrfs/file.c | 12 ++++++------ fs/btrfs/inode.c | 8 ++++---- fs/btrfs/ioctl.c | 10 +++------- 6 files changed, 19 insertions(+), 95 deletions(-)
fs/btrfs/ctree.h +3 -7
@@ -32,6 +32,7 @@#include "extent_io.h" #include "extent_map.h" #include "async-thread.h" +#include "drw_lock.h" struct btrfs_trans_handle ;struct btrfs_transaction ;
@@ -1174,11 +1175,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 */
@@ -1350,8 +1346,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 +3 -36
@@ -1125,32 +1125,6 @@ void btrfs_clean_tree_block(struct extent_buffer *buf) } } -static struct btrfs_subvolume_writers *btrfs_alloc_subvolume_writers (void ) -{ -struct btrfs_subvolume_writers *writers; -int ret; - - writers =kmalloc (sizeof (*writers),GFP_NOFS ); -if (!writers) -return ERR_PTR (-ENOMEM ); - - ret =percpu_counter_init (&writers->counter,0 ,GFP_NOFS ); -if (ret <0 ) { -kfree (writers); -return ERR_PTR (ret); - } - -init_waitqueue_head (&writers->wait); -return writers; -} - -static void -btrfs_free_subvolume_writers (struct btrfs_subvolume_writers *writers) -{ -percpu_counter_destroy (&writers->counter); -kfree (writers); -} -static void __setup_root (struct btrfs_root *root,struct btrfs_fs_info *fs_info,u64 objectid) {
@@ -1198,7 +1172,6 @@ static void __setup_root(struct btrfs_root *root, struct btrfs_fs_info *fs_info,atomic_set (&root->log_writers,0 );atomic_set (&root->log_batch,0 );refcount_set (&root->refs,1 ); -atomic_set (&root->will_be_snapshotted,0 );atomic_set (&root->snapshot_force_cow,0 );atomic_set (&root->nr_swapfiles,0 ); root->log_transid =0 ;
@@ -1487,7 +1460,6 @@ struct btrfs_root *btrfs_read_fs_root(struct btrfs_root *tree_root,int btrfs_init_fs_root (struct btrfs_root *root) {int ret; -struct btrfs_subvolume_writers *writers; root->free_ino_ctl =kzalloc (sizeof (*root->free_ino_ctl),GFP_NOFS ); root->free_ino_pinned = kzalloc(sizeof(*root->free_ino_pinned),
@@ -1497,12 +1469,8 @@ int btrfs_init_fs_root(struct btrfs_root *root) goto fail; } - writers =btrfs_alloc_subvolume_writers (); -if (IS_ERR (writers)) { - ret =PTR_ERR (writers); - goto fail; - } - root->subv_writers = writers; + +btrfs_drw_lock_init (&root->snapshot_lock);btrfs_init_free_ino_ctl (root);spin_lock_init (&root->ino_cache_lock);
@@ -3873,8 +3841,7 @@ void btrfs_free_fs_root(struct btrfs_root *root)WARN_ON (!RB_EMPTY_ROOT (&root->inode_tree));if (root->anon_dev)free_anon_bdev (root->anon_dev); -if (root->subv_writers) -btrfs_free_subvolume_writers (root->subv_writers); +btrfs_drw_lock_destroy (&root->snapshot_lock);free_extent_buffer (root->node);free_extent_buffer (root->commit_root);kfree (root->free_ino_ctl);
fs/btrfs/extent-tree.c +0 -35
@@ -11322,41 +11322,6 @@ int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range)* operations while snapshotting is ongoing and that cause the snapshot to be * inconsistent (writes followed by expanding truncates for example). */ -void btrfs_end_write_no_snapshotting (struct btrfs_root *root) -{ -percpu_counter_dec (&root->subv_writers->counter); -cond_wake_up (&root->subv_writers->wait); -} - -int btrfs_start_write_no_snapshotting (struct btrfs_root *root) -{ -if (atomic_read (&root->will_be_snapshotted)) -return 0 ; - -percpu_counter_inc (&root->subv_writers->counter); -/* -* Make sure counter is updated before we check for snapshot creation. -*/ -smp_mb (); -if (atomic_read (&root->will_be_snapshotted)) { -btrfs_end_write_no_snapshotting (root); -return 0 ; - } -return 1 ; -} - -void btrfs_wait_for_snapshot_creation (struct btrfs_root *root) -{ -while (true) { -int ret; - - ret =btrfs_start_write_no_snapshotting (root); -if (ret) -break ; -wait_var_event (&root->will_be_snapshotted, - !atomic_read (&root->will_be_snapshotted)); - } -}void btrfs_mark_bg_unused (struct btrfs_block_group_cache *bg) {
fs/btrfs/file.c +6 -6
@@ -26,6 +26,7 @@#include "volumes.h" #include "qgroup.h" #include "compression.h" +#include "drw_lock.h" static struct kmem_cache *btrfs_inode_defrag_cachep;/*
@@ -1554,8 +1555,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);
@@ -1570,7 +1570,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 +1675,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 ; }
@@ -1769,7 +1769,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,
@@ -1799,7 +1799,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
@@ -5102,16 +5102,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); }
@@ -5119,7 +5119,7 @@ static int btrfs_setsize(struct inode *inode, struct iattr *attr)btrfs_ordered_update_i_size (inode,i_size_read (inode),NULL );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
@@ -791,11 +791,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