btrfs: Annotate wait events with lockdep
v3 cover btrfs: Annotate wait events with lockdep
Hello,
With this patch series we annotate wait events in btrfs with lockdep to catch deadlocks involving these wait events.
Recently the btrfs developers fixed a non trivial deadlock involving wait events
https://lore.kernel.org/linux-btrfs/[email protected]/
Currently lockdep is unable to catch these deadlocks since it does not support wait events by default.
With our lockdep annotations we train lockdep to track these wait events and catch more potential deadlocks.
Specifically, we annotate the below wait events in fs/btrfs/transaction.c and in fs/btrfs/ordered-data.c:
1) The num_writers wait event
2) The num_extwriters wait event
3) The transaction states wait events
4) The pending_ordered wait event
5) The ordered extents wait event
Changes from v2:
1) Added macros to initialize the lockdep maps so that the code is cleaner.
2) Added comments related to the acquisition of the lockdep maps by threads either as readers or writers.
3) Moved the transaction states annotation in wait_for_commit() in fs/btrfs/transaction.c to make the code cleaner.
4) Separated the lockdep class change of invalidate_lock and the ordered extents wait event annotation into 2 patches.
Changes from v1:
1) Added 2 labels in the cleanup code of btrfs_commit_transaction() in fs/btrfs/transaction.c so that btrfs_lockdep_release() is not called multiple times during the error paths.
2) Added lockdep annotations for the btrfs transaction states wait events.
3) Added a lockdep annotation for the pending_ordered wait event.
4) Added a lockdep annotation for the ordered extents wait event.
Ioannis Angelakopoulos (6):
btrfs: Add a lockdep model for the num_writers wait event
btrfs: Add a lockdep model for the num_extwriters wait event
btrfs: Add lockdep models for the transaction states wait events
btrfs: Add a lockdep model for the pending_ordered wait event
btrfs: Change the lockdep class of struct inode's invalidate_lock
btrfs: Add a lockdep model for the ordered extents wait event
fs/btrfs/ctree.h | 82 ++++++++++++++++++++++++++++ fs/btrfs/disk-io.c | 13 +++++ fs/btrfs/free-space-cache.c | 11 ++++ fs/btrfs/inode.c | 13 +++++ fs/btrfs/ordered-data.c | 21 +++++++ fs/btrfs/transaction.c | 106 ++++++++++++++++++++++++++++++++---- 6 files changed, 235 insertions(+), 11 deletions(-)
Signature · 1 line
2.30.2
PATCH v3 1/6 btrfs: Add a lockdep model for the num_writers wait event
Annotate the num_writers wait event in fs/btrfs/transaction.c with lockdep in order to catch deadlocks involving this wait event.
Use a read/write lockdep map for the annotation. A thread starting/joining the transaction acquires the map as a reader when it increments cur_trans->num_writers and it acquires the map as a writer before it blocks on the wait event.
--- fs/btrfs/ctree.h | 47 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/disk-io.c | 2 ++ fs/btrfs/transaction.c | 37 ++++++++++++++++++++++++++++----- 3 files changed, 81 insertions(+), 5 deletions(-)
fs/btrfs/ctree.h +47 -0
@@ -1095,6 +1095,8 @@ struct btrfs_fs_info {/* Updates are not protected by any lock */ struct btrfs_commit_stats commit_stats; +struct lockdep_map btrfs_trans_num_writers_map; +#ifdef CONFIG_BTRFS_FS_REF_VERIFY spinlock_t ref_verify_lock;struct rb_root block_tree;
@@ -1175,6 +1177,51 @@ enum { BTRFS_ROOT_UNFINISHED_DROP, }; +/* +* Lockdep annotation for wait events. +* +* @b: The struct where the lockdep map is defined +* @lock: The lockdep map corresponding to a wait event +* +* This macro is used to annotate a wait event. In this case a thread acquires +* the lockdep map as writer (exclusive lock) because it has to block until all +* the threads that hold the lock as readers signal the condition for the wait +* event and release their locks. +*/ +#define btrfs_might_wait_for_event (b, lock) \ + do { \ + rwsem_acquire(&b->lock##_map, 0, 0, _THIS_IP_); \ + rwsem_release(&b->lock##_map, _THIS_IP_); \ + } while (0) + +/* +* Protection for the resource/condition of a wait event. +* +* @b: The struct where the lockdep map is defined +* @lock: The lockdep map corresponding to a wait event +* +* Many threads can modify the condition for the wait event at the same time +* and signal the threads that block on the wait event. The threads that +* modify the condition and do the signaling acquire the lock as readers +* (shared lock). +*/ +#define btrfs_lockdep_acquire (b, lock) \ + rwsem_acquire_read(&b->lock##_map, 0, 0, _THIS_IP_) + +/* +* Used after signaling the condition for a wait event to release the +* lockdep map held by a reader thread. +*/ +#define btrfs_lockdep_release (b, lock) \ + rwsem_release(&b->lock##_map, _THIS_IP_) + +/* Initialization of the lockdep map */ +#define btrfs_lockdep_init_map (b, lock) \ + do { \ + static struct lock_class_key lock##_key; \ + lockdep_init_map(&b->lock##_map, #lock, &lock##_key, 0); \ + } while (0) +static inline void btrfs_wake_unfinished_drop (struct btrfs_fs_info *fs_info) {clear_and_wake_up_bit (BTRFS_FS_UNFINISHED_DROPS , &fs_info->flags);
fs/btrfs/disk-io.c +2 -0
@@ -3074,6 +3074,8 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)mutex_init (&fs_info->zoned_data_reloc_io_lock);seqlock_init (&fs_info->profiles_lock); +btrfs_lockdep_init_map (fs_info, btrfs_trans_num_writers); +INIT_LIST_HEAD (&fs_info->dirty_cowonly_roots);INIT_LIST_HEAD (&fs_info->space_info);INIT_LIST_HEAD (&fs_info->tree_mod_seq_list);
fs/btrfs/transaction.c +32 -5
@@ -313,6 +313,7 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,atomic_inc (&cur_trans->num_writers);extwriter_counter_inc (cur_trans, type);spin_unlock (&fs_info->trans_lock); +btrfs_lockdep_acquire (fs_info, btrfs_trans_num_writers);return 0 ; }spin_unlock (&fs_info->trans_lock);
@@ -334,16 +335,20 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,if (!cur_trans)return -ENOMEM ; +btrfs_lockdep_acquire (fs_info, btrfs_trans_num_writers); +spin_lock (&fs_info->trans_lock);if (fs_info->running_transaction) {/* * someone started a transaction after we unlocked. Make sure * to redo the checks above */ +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers);kfree (cur_trans); goto loop; }else if (BTRFS_FS_ERROR (fs_info)) {spin_unlock (&fs_info->trans_lock); +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers);kfree (cur_trans);return -EROFS ; }
@@ -1022,6 +1027,9 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,extwriter_counter_dec (cur_trans, trans->type);cond_wake_up (&cur_trans->writer_wait); + +btrfs_lockdep_release (info, btrfs_trans_num_writers); +btrfs_put_transaction (cur_trans);if (current->journal_info == trans)
@@ -1994,6 +2002,12 @@ static void cleanup_transaction(struct btrfs_trans_handle *trans, int err)if (cur_trans == fs_info->running_transaction) { cur_trans->state =TRANS_STATE_COMMIT_DOING ;spin_unlock (&fs_info->trans_lock); + +/* +* The thread has already released the lockdep map as reader already in +* btrfs_commit_transaction(). +*/ +btrfs_might_wait_for_event (fs_info, btrfs_trans_num_writers);wait_event (cur_trans->writer_wait,atomic_read (&cur_trans->num_writers) ==1 );
@@ -2222,7 +2236,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)btrfs_put_transaction (prev_trans);if (ret) - goto cleanup_transaction; + goto lockdep_release; }else {spin_unlock (&fs_info->trans_lock); }
@@ -2236,7 +2250,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)*/ if (BTRFS_FS_ERROR (fs_info)) { ret = -EROFS ; - goto cleanup_transaction; + goto lockdep_release; } }
@@ -2250,19 +2264,21 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans) ret =btrfs_start_delalloc_flush (fs_info);if (ret) - goto cleanup_transaction; + goto lockdep_release; ret =btrfs_run_delayed_items (trans);if (ret) - goto cleanup_transaction; + goto lockdep_release;wait_event (cur_trans->writer_wait,extwriter_counter_read (cur_trans) ==0 );/* some pending stuffs might be added after the previous flush. */ ret =btrfs_run_delayed_items (trans); -if (ret) +if (ret) { +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers); goto cleanup_transaction; + }btrfs_wait_delalloc_flush (fs_info);
@@ -2284,6 +2300,14 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)add_pending_snapshot (trans); cur_trans->state =TRANS_STATE_COMMIT_DOING ;spin_unlock (&fs_info->trans_lock); + +/* +* The thread has started/joined the transaction thus it holds the lockdep +* map as a reader. It has to release it before acquiring the lockdep map +* as a writer. +*/ +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers); +btrfs_might_wait_for_event (fs_info, btrfs_trans_num_writers);wait_event (cur_trans->writer_wait,atomic_read (&cur_trans->num_writers) ==1 );
@@ -2515,6 +2539,9 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)cleanup_transaction (trans, ret);return ret; +lockdep_release: +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers); + goto cleanup_transaction; }/*
Signature · 1 line
2.30.2
Re: [PATCH v3 1/6] btrfs: Add a lockdep model for the num_writers wait event
Hi,
Quoted 208 lines
Annotate the
num_writerswait event infs/btrfs/transaction.cwith lockdep in order to catch deadlocks involving this wait event.Use a read/write lockdep map for the annotation. A thread starting/joining the transaction acquires the map as a reader when it increments
cur_trans->num_writersand it acquires the map as a writer before it blocks on the wait event.Signed-off-by Ioannis Angelakopoulos <[email protected]>--- fs/btrfs/ctree.h | 47 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/disk-io.c | 2 ++ fs/btrfs/transaction.c | 37 ++++++++++++++++++++++++++++----- 3 files changed, 81 insertions(+), 5 deletions(-)fs/btrfs/ctree.h +47
-0@@ -1095,6 +1095,8 @@ struct btrfs_fs_info {/* Updates are not protected by any lock */ struct btrfs_commit_stats commit_stats; +struct lockdep_map btrfs_trans_num_writers_map; +#ifdef CONFIG_BTRFS_FS_REF_VERIFY spinlock_t ref_verify_lock;struct rb_root block_tree;@@ -1175,6 +1177,51 @@ enum { BTRFS_ROOT_UNFINISHED_DROP, }; +/* +* Lockdep annotation for wait events. +* +* @b: The struct where the lockdep map is defined +* @lock: The lockdep map corresponding to a wait event +* +* This macro is used to annotate a wait event. In this case a thread acquires +* the lockdep map as writer (exclusive lock) because it has to block until all +* the threads that hold the lock as readers signal the condition for the wait +* event and release their locks. +*/ +#define btrfs_might_wait_for_event (b, lock) \ + do { \ + rwsem_acquire(&b->lock##_map, 0, 0, _THIS_IP_); \ + rwsem_release(&b->lock##_map, _THIS_IP_); \ + } while (0) + +/* +* Protection for the resource/condition of a wait event. +* +* @b: The struct where the lockdep map is defined +* @lock: The lockdep map corresponding to a wait event +* +* Many threads can modify the condition for the wait event at the same time +* and signal the threads that block on the wait event. The threads that +* modify the condition and do the signaling acquire the lock as readers +* (shared lock). +*/ +#define btrfs_lockdep_acquire (b, lock) \ + rwsem_acquire_read(&b->lock##_map, 0, 0, _THIS_IP_) + +/* +* Used after signaling the condition for a wait event to release the +* lockdep map held by a reader thread. +*/ +#define btrfs_lockdep_release (b, lock) \ + rwsem_release(&b->lock##_map, _THIS_IP_) + +/* Initialization of the lockdep map */ +#define btrfs_lockdep_init_map (b, lock) \ + do { \ + static struct lock_class_key lock##_key; \ + lockdep_init_map(&b->lock##_map, #lock, &lock##_key, 0); \ + } while (0) +static inline void btrfs_wake_unfinished_drop (struct btrfs_fs_info *fs_info) {clear_and_wake_up_bit (BTRFS_FS_UNFINISHED_DROPS , &fs_info->flags);fs/btrfs/disk-io.c +2
-0@@ -3074,6 +3074,8 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)mutex_init (&fs_info->zoned_data_reloc_io_lock);seqlock_init (&fs_info->profiles_lock); +btrfs_lockdep_init_map (fs_info, btrfs_trans_num_writers); +INIT_LIST_HEAD (&fs_info->dirty_cowonly_roots);INIT_LIST_HEAD (&fs_info->space_info);INIT_LIST_HEAD (&fs_info->tree_mod_seq_list);fs/btrfs/transaction.c +29
-5@@ -313,6 +313,7 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,atomic_inc (&cur_trans->num_writers);extwriter_counter_inc (cur_trans, type);spin_unlock (&fs_info->trans_lock); +btrfs_lockdep_acquire (fs_info, btrfs_trans_num_writers);return 0 ; }spin_unlock (&fs_info->trans_lock);@@ -334,16 +335,20 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,if (!cur_trans)return -ENOMEM ; +btrfs_lockdep_acquire (fs_info, btrfs_trans_num_writers); +spin_lock (&fs_info->trans_lock);if (fs_info->running_transaction) {/* * someone started a transaction after we unlocked. Make sure * to redo the checks above */ +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers);kfree (cur_trans); goto loop; }else if (BTRFS_FS_ERROR (fs_info)) {spin_unlock (&fs_info->trans_lock); +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers);kfree (cur_trans);return -EROFS ; }@@ -1022,6 +1027,9 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,extwriter_counter_dec (cur_trans, trans->type);cond_wake_up (&cur_trans->writer_wait); + +btrfs_lockdep_release (info, btrfs_trans_num_writers); +btrfs_put_transaction (cur_trans);if (current->journal_info == trans)@@ -1994,6 +2002,12 @@ static void cleanup_transaction(struct btrfs_trans_handle *trans, int err)if (cur_trans == fs_info->running_transaction) { cur_trans->state =TRANS_STATE_COMMIT_DOING ;spin_unlock (&fs_info->trans_lock); + +/* +* The thread has already released the lockdep map as reader already in +* btrfs_commit_transaction(). +*/ +btrfs_might_wait_for_event (fs_info, btrfs_trans_num_writers);wait_event (cur_trans->writer_wait,atomic_read (&cur_trans->num_writers) ==1 );@@ -2222,7 +2236,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)btrfs_put_transaction (prev_trans);if (ret) - goto cleanup_transaction; + goto lockdep_release; }else {spin_unlock (&fs_info->trans_lock); }@@ -2236,7 +2250,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)*/ if (BTRFS_FS_ERROR (fs_info)) { ret = -EROFS ; - goto cleanup_transaction; + goto lockdep_release; } }@@ -2250,19 +2264,21 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans) ret =btrfs_start_delalloc_flush (fs_info);if (ret) - goto cleanup_transaction; + goto lockdep_release; ret =btrfs_run_delayed_items (trans);if (ret) - goto cleanup_transaction; + goto lockdep_release;wait_event (cur_trans->writer_wait,extwriter_counter_read (cur_trans) ==0 );/* some pending stuffs might be added after the previous flush. */ ret =btrfs_run_delayed_items (trans); -if (ret) +if (ret) { +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers); goto cleanup_transaction; + }btrfs_wait_delalloc_flush (fs_info);@@ -2284,6 +2300,14 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)add_pending_snapshot (trans); cur_trans->state =TRANS_STATE_COMMIT_DOING ;spin_unlock (&fs_info->trans_lock); + +/* +* The thread has started/joined the transaction thus it holds the lockdep +* map as a reader. It has to release it before acquiring the lockdep map +* as a writer. +*/ +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers); +btrfs_might_wait_for_event (fs_info, btrfs_trans_num_writers);wait_event (cur_trans->writer_wait,atomic_read (&cur_trans->num_writers) ==1 );
fs/btrfs/transaction.c int btrfs_commit_transaction(struct btrfs_trans_handle *trans) · line 2545
Quoted 7 lines
fs/btrfs/transaction.c +3
-0@@ -2515,6 +2539,9 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)cleanup_transaction (trans, ret);return ret; +lockdep_release: +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers); + goto cleanup_transaction; }
Could we rename 'lockdep_release' to 'cleanup_transaction_with_lockdep_release', and put it just before 'cleanup_transaction:'?
Best Regards
Wang Yugui ([email protected])
2022/07/21
Re: [PATCH v3 1/6] btrfs: Add a lockdep model for the num_writers wait event
Quoted 223 lines · Wang Yugui
Hi,
Quoted 208 lines
Annotate the
num_writerswait event infs/btrfs/transaction.cwith lockdep in order to catch deadlocks involving this wait event.Use a read/write lockdep map for the annotation. A thread starting/joining the transaction acquires the map as a reader when it increments
cur_trans->num_writersand it acquires the map as a writer before it blocks on the wait event.Signed-off-by Ioannis Angelakopoulos <[email protected]>--- fs/btrfs/ctree.h | 47 ++++++++++++++++++++++++++++++++++++++++++ fs/btrfs/disk-io.c | 2 ++ fs/btrfs/transaction.c | 37 ++++++++++++++++++++++++++++----- 3 files changed, 81 insertions(+), 5 deletions(-)fs/btrfs/ctree.h +47
-0@@ -1095,6 +1095,8 @@ struct btrfs_fs_info {/* Updates are not protected by any lock */ struct btrfs_commit_stats commit_stats; +struct lockdep_map btrfs_trans_num_writers_map; +#ifdef CONFIG_BTRFS_FS_REF_VERIFY spinlock_t ref_verify_lock;struct rb_root block_tree;@@ -1175,6 +1177,51 @@ enum { BTRFS_ROOT_UNFINISHED_DROP, }; +/* +* Lockdep annotation for wait events. +* +* @b: The struct where the lockdep map is defined +* @lock: The lockdep map corresponding to a wait event +* +* This macro is used to annotate a wait event. In this case a thread acquires +* the lockdep map as writer (exclusive lock) because it has to block until all +* the threads that hold the lock as readers signal the condition for the wait +* event and release their locks. +*/ +#define btrfs_might_wait_for_event (b, lock) \ + do { \ + rwsem_acquire(&b->lock##_map, 0, 0, _THIS_IP_); \ + rwsem_release(&b->lock##_map, _THIS_IP_); \ + } while (0) + +/* +* Protection for the resource/condition of a wait event. +* +* @b: The struct where the lockdep map is defined +* @lock: The lockdep map corresponding to a wait event +* +* Many threads can modify the condition for the wait event at the same time +* and signal the threads that block on the wait event. The threads that +* modify the condition and do the signaling acquire the lock as readers +* (shared lock). +*/ +#define btrfs_lockdep_acquire (b, lock) \ + rwsem_acquire_read(&b->lock##_map, 0, 0, _THIS_IP_) + +/* +* Used after signaling the condition for a wait event to release the +* lockdep map held by a reader thread. +*/ +#define btrfs_lockdep_release (b, lock) \ + rwsem_release(&b->lock##_map, _THIS_IP_) + +/* Initialization of the lockdep map */ +#define btrfs_lockdep_init_map (b, lock) \ + do { \ + static struct lock_class_key lock##_key; \ + lockdep_init_map(&b->lock##_map, #lock, &lock##_key, 0); \ + } while (0) +static inline void btrfs_wake_unfinished_drop (struct btrfs_fs_info *fs_info) {clear_and_wake_up_bit (BTRFS_FS_UNFINISHED_DROPS , &fs_info->flags);fs/btrfs/disk-io.c +2
-0@@ -3074,6 +3074,8 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)mutex_init (&fs_info->zoned_data_reloc_io_lock);seqlock_init (&fs_info->profiles_lock); +btrfs_lockdep_init_map (fs_info, btrfs_trans_num_writers); +INIT_LIST_HEAD (&fs_info->dirty_cowonly_roots);INIT_LIST_HEAD (&fs_info->space_info);INIT_LIST_HEAD (&fs_info->tree_mod_seq_list);fs/btrfs/transaction.c +29
-5@@ -313,6 +313,7 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,atomic_inc (&cur_trans->num_writers);extwriter_counter_inc (cur_trans, type);spin_unlock (&fs_info->trans_lock); +btrfs_lockdep_acquire (fs_info, btrfs_trans_num_writers);return 0 ; }spin_unlock (&fs_info->trans_lock);@@ -334,16 +335,20 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,if (!cur_trans)return -ENOMEM ; +btrfs_lockdep_acquire (fs_info, btrfs_trans_num_writers); +spin_lock (&fs_info->trans_lock);if (fs_info->running_transaction) {/* * someone started a transaction after we unlocked. Make sure * to redo the checks above */ +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers);kfree (cur_trans); goto loop; }else if (BTRFS_FS_ERROR (fs_info)) {spin_unlock (&fs_info->trans_lock); +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers);kfree (cur_trans);return -EROFS ; }@@ -1022,6 +1027,9 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,extwriter_counter_dec (cur_trans, trans->type);cond_wake_up (&cur_trans->writer_wait); + +btrfs_lockdep_release (info, btrfs_trans_num_writers); +btrfs_put_transaction (cur_trans);if (current->journal_info == trans)@@ -1994,6 +2002,12 @@ static void cleanup_transaction(struct btrfs_trans_handle *trans, int err)if (cur_trans == fs_info->running_transaction) { cur_trans->state =TRANS_STATE_COMMIT_DOING ;spin_unlock (&fs_info->trans_lock); + +/* +* The thread has already released the lockdep map as reader already in +* btrfs_commit_transaction(). +*/ +btrfs_might_wait_for_event (fs_info, btrfs_trans_num_writers);wait_event (cur_trans->writer_wait,atomic_read (&cur_trans->num_writers) ==1 );@@ -2222,7 +2236,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)btrfs_put_transaction (prev_trans);if (ret) - goto cleanup_transaction; + goto lockdep_release; }else {spin_unlock (&fs_info->trans_lock); }@@ -2236,7 +2250,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)*/ if (BTRFS_FS_ERROR (fs_info)) { ret = -EROFS ; - goto cleanup_transaction; + goto lockdep_release; } }@@ -2250,19 +2264,21 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans) ret =btrfs_start_delalloc_flush (fs_info);if (ret) - goto cleanup_transaction; + goto lockdep_release; ret =btrfs_run_delayed_items (trans);if (ret) - goto cleanup_transaction; + goto lockdep_release;wait_event (cur_trans->writer_wait,extwriter_counter_read (cur_trans) ==0 );/* some pending stuffs might be added after the previous flush. */ ret =btrfs_run_delayed_items (trans); -if (ret) +if (ret) { +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers); goto cleanup_transaction; + }btrfs_wait_delalloc_flush (fs_info);@@ -2284,6 +2300,14 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)add_pending_snapshot (trans); cur_trans->state =TRANS_STATE_COMMIT_DOING ;spin_unlock (&fs_info->trans_lock); + +/* +* The thread has started/joined the transaction thus it holds the lockdep +* map as a reader. It has to release it before acquiring the lockdep map +* as a writer. +*/ +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers); +btrfs_might_wait_for_event (fs_info, btrfs_trans_num_writers);wait_event (cur_trans->writer_wait,atomic_read (&cur_trans->num_writers) ==1 );fs/btrfs/transaction.c int btrfs_commit_transaction(struct btrfs_trans_handle *trans) · line 2545
Quoted 7 lines
fs/btrfs/transaction.c +3
-0@@ -2515,6 +2539,9 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)cleanup_transaction (trans, ret);return ret; +lockdep_release: +btrfs_lockdep_release (fs_info, btrfs_trans_num_writers); + goto cleanup_transaction; }Could we rename '
lockdep_release' to 'cleanup_transaction_with_lockdep_release', and put it just before 'cleanup_transaction:'?
Quoted 4 lines
Best Regards
Wang Yugui ([email protected])
2022/07/21
Unfortunately no, since there are error paths within btrfs_commit_transaction() that jump to labels prior to cleanup_transaction after the btrfs_trans_num_writers lock is already released. Moving the lockdep_release label above cleanup_transaction would result in lockdep complaining about double lock release.
Thanks,
Ioannis
Quoted 2 lines
PATCH v3 2/6 btrfs: Add a lockdep model for the num_extwriters wait event
In reply to Ioannis AngelakopoulosSimilarly to the num_writers wait event in fs/btrfs/transaction.c add a lockdep annotation for the num_extwriters wait event.
Use a read/write lockdep map for the annotation. A thread starting/joining the transaction acquires the map as a reader when it increments cur_trans->num_writers and it acquires the map as a writer before it blocks on the wait event.
--- fs/btrfs/ctree.h | 1 + fs/btrfs/disk-io.c | 1 + fs/btrfs/transaction.c | 13 +++++++++++++ 3 files changed, 15 insertions(+)
fs/btrfs/ctree.h +1 -0
@@ -1096,6 +1096,7 @@ struct btrfs_fs_info {struct btrfs_commit_stats commit_stats;struct lockdep_map btrfs_trans_num_writers_map; +struct lockdep_map btrfs_trans_num_extwriters_map;#ifdef CONFIG_BTRFS_FS_REF_VERIFY spinlock_t ref_verify_lock;
fs/btrfs/disk-io.c +1 -0
@@ -3075,6 +3075,7 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)seqlock_init (&fs_info->profiles_lock);btrfs_lockdep_init_map (fs_info, btrfs_trans_num_writers); +btrfs_lockdep_init_map (fs_info, btrfs_trans_num_extwriters);INIT_LIST_HEAD (&fs_info->dirty_cowonly_roots);INIT_LIST_HEAD (&fs_info->space_info);
fs/btrfs/transaction.c +13 -0
@@ -314,6 +314,7 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,extwriter_counter_inc (cur_trans, type);spin_unlock (&fs_info->trans_lock);btrfs_lockdep_acquire (fs_info, btrfs_trans_num_writers); +btrfs_lockdep_acquire (fs_info, btrfs_trans_num_extwriters);return 0 ; }spin_unlock (&fs_info->trans_lock);
@@ -336,6 +337,7 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,return -ENOMEM ;btrfs_lockdep_acquire (fs_info, btrfs_trans_num_writers); +btrfs_lockdep_acquire (fs_info, btrfs_trans_num_extwriters);spin_lock (&fs_info->trans_lock);if (fs_info->running_transaction) {
@@ -343,11 +345,13 @@ static noinline int join_transaction(struct btrfs_fs_info *fs_info,* someone started a transaction after we unlocked. Make sure * to redo the checks above */ +btrfs_lockdep_release (fs_info, btrfs_trans_num_extwriters);btrfs_lockdep_release (fs_info, btrfs_trans_num_writers);kfree (cur_trans); goto loop; }else if (BTRFS_FS_ERROR (fs_info)) {spin_unlock (&fs_info->trans_lock); +btrfs_lockdep_release (fs_info, btrfs_trans_num_extwriters);btrfs_lockdep_release (fs_info, btrfs_trans_num_writers);kfree (cur_trans);return -EROFS ;
@@ -1028,6 +1032,7 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,cond_wake_up (&cur_trans->writer_wait); +btrfs_lockdep_release (info, btrfs_trans_num_extwriters);btrfs_lockdep_release (info, btrfs_trans_num_writers);btrfs_put_transaction (cur_trans);
@@ -2270,6 +2275,13 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)if (ret) goto lockdep_release; +/* +* The thread has started/joined the transaction thus it holds the lockdep +* map as a reader. It has to release it before acquiring the lockdep map +* as a writer. +*/ +btrfs_lockdep_release (fs_info, btrfs_trans_num_extwriters); +btrfs_might_wait_for_event (fs_info, btrfs_trans_num_extwriters);wait_event (cur_trans->writer_wait,extwriter_counter_read (cur_trans) ==0 );
@@ -2540,6 +2552,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)return ret; lockdep_release: +btrfs_lockdep_release (fs_info, btrfs_trans_num_extwriters);btrfs_lockdep_release (fs_info, btrfs_trans_num_writers); goto cleanup_transaction; }
Signature · 1 line
2.30.2
PATCH v3 3/6 btrfs: Add lockdep models for the transaction states wait events
In reply to Ioannis AngelakopoulosAdd a lockdep annotation for the transaction states that have wait events; 1) TRANS_STATE_COMMIT_START, 2) TRANS_STATE_UNBLOCKED, 3) TRANS_STATE_SUPER_COMMITTED, and 4) TRANS_STATE_COMPLETED in fs/btrfs/transaction.c.
With the exception of the lockdep annotation for TRANS_STATE_COMMIT_START the transaction thread has to acquire the lockdep maps for the transaction states as reader after the lockdep map for num_writers is released so that lockdep does not complain.
--- fs/btrfs/ctree.h | 32 ++++++++++++++++++++++++ fs/btrfs/disk-io.c | 8 ++++++ fs/btrfs/transaction.c | 55 +++++++++++++++++++++++++++++++++++++----- 3 files changed, 89 insertions(+), 6 deletions(-)
fs/btrfs/ctree.h +32 -0
@@ -1097,6 +1097,7 @@ struct btrfs_fs_info {struct lockdep_map btrfs_trans_num_writers_map;struct lockdep_map btrfs_trans_num_extwriters_map; +struct lockdep_map btrfs_state_change_map[4 ];#ifdef CONFIG_BTRFS_FS_REF_VERIFY spinlock_t ref_verify_lock;
@@ -1178,6 +1179,13 @@ enum { BTRFS_ROOT_UNFINISHED_DROP, }; +enum btrfs_lockdep_trans_states { +BTRFS_LOCKDEP_TRANS_COMMIT_START , +BTRFS_LOCKDEP_TRANS_UNBLOCKED , +BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED , +BTRFS_LOCKDEP_TRANS_COMPLETED , +}; +/* * Lockdep annotation for wait events. *
@@ -1216,6 +1224,22 @@ enum {#define btrfs_lockdep_release (b, lock) \ rwsem_release(&b->lock##_map, _THIS_IP_) +/* +* Macros for the transaction states wait events, similar to the generic wait +* event macros. +*/ +#define btrfs_might_wait_for_state (b, i) \ + do { \ + rwsem_acquire(&b->btrfs_state_change_map[i], 0, 0, _THIS_IP_); \ + rwsem_release(&b->btrfs_state_change_map[i], _THIS_IP_); \ + } while (0) + +#define btrfs_trans_state_lockdep_acquire (b, i) \ + rwsem_acquire_read(&b->btrfs_state_change_map[i], 0, 0, _THIS_IP_) + +#define btrfs_trans_state_lockdep_release (b, i) \ + rwsem_release(&b->btrfs_state_change_map[i], _THIS_IP_) +/* Initialization of the lockdep map */ #define btrfs_lockdep_init_map (b, lock) \ do { \
@@ -1223,6 +1247,14 @@ enum { lockdep_init_map(&b->lock##_map, #lock, &lock##_key, 0); \ } while (0) +/* Initialization of the transaction states lockdep maps. */ +#define btrfs_state_lockdep_init_map (b, lock, state) \ + do { \ + static struct lock_class_key lock##_key; \ + lockdep_init_map(&b->btrfs_state_change_map[state], #lock, \ + &lock##_key, 0); \ + } while (0) +static inline void btrfs_wake_unfinished_drop (struct btrfs_fs_info *fs_info) {clear_and_wake_up_bit (BTRFS_FS_UNFINISHED_DROPS , &fs_info->flags);
fs/btrfs/disk-io.c +8 -0
@@ -3076,6 +3076,14 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)btrfs_lockdep_init_map (fs_info, btrfs_trans_num_writers);btrfs_lockdep_init_map (fs_info, btrfs_trans_num_extwriters); +btrfs_state_lockdep_init_map (fs_info, btrfs_trans_commit_start, +BTRFS_LOCKDEP_TRANS_COMMIT_START ); +btrfs_state_lockdep_init_map (fs_info, btrfs_trans_unblocked, +BTRFS_LOCKDEP_TRANS_UNBLOCKED ); +btrfs_state_lockdep_init_map (fs_info, btrfs_trans_super_committed, +BTRFS_LOCKDEP_TRANS_SUPER_COMMITTED ); +btrfs_state_lockdep_init_map (fs_info, btrfs_trans_completed, +BTRFS_LOCKDEP_TRANS_COMPLETED );INIT_LIST_HEAD (&fs_info->dirty_cowonly_roots);INIT_LIST_HEAD (&fs_info->space_info);
fs/btrfs/transaction.c +49 -6
152 lines not on this page · raw message
Signature · 1 line
2.30.2
PATCH v3 4/6 btrfs: Add a lockdep model for the pending_ordered wait event
In reply to Ioannis AngelakopoulosIn contrast to the num_writers and num_extwriters wait events, the condition for the pending ordered wait event is signaled in a different context from the wait event itself. The condition signaling occurs in btrfs_remove_ordered_extent() in fs/btrfs/ordered-data.c while the wait event is implemented in btrfs_commit_transaction() in fs/btrfs/transaction.c
Thus the thread signaling the condition has to acquire the lockdep map as a reader at the start of btrfs_remove_ordered_extent() and release it after it has signaled the condition. In this case some dependencies might be left out due to the placement of the annotation, but it is better than no annotation at all.
--- fs/btrfs/ctree.h | 1 + fs/btrfs/disk-io.c | 1 + fs/btrfs/ordered-data.c | 3 +++ fs/btrfs/transaction.c | 1 + 4 files changed, 6 insertions(+)
fs/btrfs/ctree.h +1 -0
@@ -1098,6 +1098,7 @@ struct btrfs_fs_info {struct lockdep_map btrfs_trans_num_writers_map;struct lockdep_map btrfs_trans_num_extwriters_map;struct lockdep_map btrfs_state_change_map[4 ]; +struct lockdep_map btrfs_trans_pending_ordered_map;#ifdef CONFIG_BTRFS_FS_REF_VERIFY spinlock_t ref_verify_lock;
fs/btrfs/disk-io.c +1 -0
@@ -3076,6 +3076,7 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)btrfs_lockdep_init_map (fs_info, btrfs_trans_num_writers);btrfs_lockdep_init_map (fs_info, btrfs_trans_num_extwriters); +btrfs_lockdep_init_map (fs_info, btrfs_trans_pending_ordered);btrfs_state_lockdep_init_map (fs_info, btrfs_trans_commit_start,BTRFS_LOCKDEP_TRANS_COMMIT_START ); btrfs_state_lockdep_init_map(fs_info, btrfs_trans_unblocked,
fs/btrfs/ordered-data.c +3 -0
@@ -525,6 +525,7 @@ void btrfs_remove_ordered_extent(struct btrfs_inode *btrfs_inode,struct rb_node *node;bool pending; +btrfs_lockdep_acquire (fs_info, btrfs_trans_pending_ordered);/* This is paired with btrfs_add_ordered_extent. */ spin_lock (&btrfs_inode->lock);btrfs_mod_outstanding_extents (btrfs_inode,-1 );
@@ -580,6 +581,8 @@ void btrfs_remove_ordered_extent(struct btrfs_inode *btrfs_inode, } } +btrfs_lockdep_release (fs_info, btrfs_trans_pending_ordered); +spin_lock (&root->ordered_extent_lock);list_del_init (&entry->root_extent_list); root->nr_ordered_extents--;
fs/btrfs/transaction.c +1 -0
@@ -2316,6 +2316,7 @@ int btrfs_commit_transaction(struct btrfs_trans_handle *trans)* transaction. Otherwise if this transaction commits before the ordered * extents complete we lose logged data after a power failure. */ +btrfs_might_wait_for_event (fs_info, btrfs_trans_pending_ordered);wait_event (cur_trans->pending_wait,atomic_read (&cur_trans->pending_ordered) ==0 );
Signature · 1 line
2.30.2
PATCH v3 5/6 btrfs: Change the lockdep class of struct inode's invalidate_lock
In reply to Ioannis AngelakopoulosReinitialize the class of the lockdep map for inode->mapping->invalidate_lock in load_free_space_cache() function in fs/btrfs/free-space-cache.c This will prevent lockdep from producing false positives related to execution paths that make use of free space inodes and paths that make use of normal inodes.
Specifically, with this change lockdep will create separate lock dependencies that include the invalidate_lock, in the case that free space inodes are used and in the case that normal inodes are used.
--- fs/btrfs/free-space-cache.c | 11 +++++++++++ 1 file changed, 11 insertions(+)
fs/btrfs/free-space-cache.c +11 -0
@@ -914,6 +914,8 @@ static int copy_free_space_cache(struct btrfs_block_group *block_group,return ret; } +static struct lock_class_key btrfs_free_space_inode_key; +int load_free_space_cache (struct btrfs_block_group *block_group) {struct btrfs_fs_info *fs_info = block_group->fs_info;
@@ -924,6 +926,7 @@ int load_free_space_cache(struct btrfs_block_group *block_group)int ret =0 ;bool matched;u64 used = block_group->used; +struct address_space *mapping;/* * Because we could potentially discard our loaded free space, we want
@@ -983,6 +986,14 @@ int load_free_space_cache(struct btrfs_block_group *block_group) }spin_unlock (&block_group->lock); +/* +* Reinitialize the class of the inode->mapping->invalidate_lock for free +* space inodes to prevent false positives related to locks for normal +* inodes. +*/ + mapping = &inode->i_data; +lockdep_set_class (&mapping->invalidate_lock, &btrfs_free_space_inode_key); + ret =__load_free_space_cache (fs_info->tree_root, inode, &tmp_ctl, path, block_group->start);btrfs_free_path (path);
Signature · 1 line
2.30.2
PATCH v3 6/6 btrfs: Add a lockdep model for the ordered extents wait event
In reply to Ioannis AngelakopoulosThis wait event is very similar to the pending ordered wait event in the sense that it occurs in a different context than the condition signaling for the event. The signaling occurs in btrfs_remove_ordered_extent() while the wait event is implemented in btrfs_start_ordered_extent() in fs/btrfs/ordered-data.c
However, in this case a thread must not acquire the lockdep map for the ordered extents wait event when the ordered extent is related to a free space inode. That is because lockdep creates dependencies between locks acquired both in execution paths related to normal inodes and paths related to free space inodes, thus leading to false positives.
--- fs/btrfs/ctree.h | 1 + fs/btrfs/disk-io.c | 1 + fs/btrfs/inode.c | 13 +++++++++++++ fs/btrfs/ordered-data.c | 18 ++++++++++++++++++ 4 files changed, 33 insertions(+)
fs/btrfs/ctree.h +1 -0
@@ -1099,6 +1099,7 @@ struct btrfs_fs_info {struct lockdep_map btrfs_trans_num_extwriters_map;struct lockdep_map btrfs_state_change_map[4 ];struct lockdep_map btrfs_trans_pending_ordered_map; +struct lockdep_map btrfs_ordered_extent_map;#ifdef CONFIG_BTRFS_FS_REF_VERIFY spinlock_t ref_verify_lock;
fs/btrfs/disk-io.c +1 -0
@@ -3077,6 +3077,7 @@ void btrfs_init_fs_info(struct btrfs_fs_info *fs_info)btrfs_lockdep_init_map (fs_info, btrfs_trans_num_writers);btrfs_lockdep_init_map (fs_info, btrfs_trans_num_extwriters);btrfs_lockdep_init_map (fs_info, btrfs_trans_pending_ordered); +btrfs_lockdep_init_map (fs_info, btrfs_ordered_extent);btrfs_state_lockdep_init_map (fs_info, btrfs_trans_commit_start,BTRFS_LOCKDEP_TRANS_COMMIT_START ); btrfs_state_lockdep_init_map(fs_info, btrfs_trans_unblocked,
fs/btrfs/inode.c +13 -0
@@ -3223,6 +3223,8 @@ int btrfs_finish_ordered_io(struct btrfs_ordered_extent *ordered_extent) clear_bits |=EXTENT_DELALLOC_NEW ; freespace_inode =btrfs_is_free_space_inode (inode); +if (!freespace_inode) +btrfs_lockdep_acquire (fs_info, btrfs_ordered_extent);if (test_bit (BTRFS_ORDERED_IOERR , &ordered_extent->flags)) { ret = -EIO ;
@@ -8952,6 +8954,7 @@ void btrfs_destroy_inode(struct inode *vfs_inode)struct btrfs_ordered_extent *ordered;struct btrfs_inode *inode =BTRFS_I (vfs_inode);struct btrfs_root *root = inode->root; +bool freespace_inode;WARN_ON (!hlist_empty (&vfs_inode->i_dentry));WARN_ON (vfs_inode->i_data.nrpages);
@@ -8973,6 +8976,12 @@ void btrfs_destroy_inode(struct inode *vfs_inode)if (!root)return ; +/* +* If this is a free space inode do not take the ordered extents lockdep +* map. +*/ + freespace_inode =btrfs_is_free_space_inode (inode); +while (1 ) { ordered =btrfs_lookup_first_ordered_extent (inode, (u64)-1 );if (!ordered)
@@ -8981,6 +8990,10 @@ void btrfs_destroy_inode(struct inode *vfs_inode)btrfs_err (root->fs_info,"found ordered extent %llu %llu on inode cleanup" , ordered->file_offset, ordered->num_bytes); + +if (!freespace_inode) +btrfs_lockdep_acquire (root->fs_info, btrfs_ordered_extent); +btrfs_remove_ordered_extent (inode, ordered);btrfs_put_ordered_extent (ordered);btrfs_put_ordered_extent (ordered);
fs/btrfs/ordered-data.c +18 -0
@@ -524,6 +524,13 @@ void btrfs_remove_ordered_extent(struct btrfs_inode *btrfs_inode,struct btrfs_fs_info *fs_info = root->fs_info;struct rb_node *node;bool pending; +bool freespace_inode; + +/* +* If this is a free space inode the thread has not acquired the ordered +* extents lockdep map. +*/ + freespace_inode =btrfs_is_free_space_inode (btrfs_inode);btrfs_lockdep_acquire (fs_info, btrfs_trans_pending_ordered);/* This is paired with btrfs_add_ordered_extent. */
@@ -597,6 +604,8 @@ void btrfs_remove_ordered_extent(struct btrfs_inode *btrfs_inode, }spin_unlock (&root->ordered_extent_lock);wake_up (&entry->wait); +if (!freespace_inode) +btrfs_lockdep_release (fs_info, btrfs_ordered_extent); }static void btrfs_run_ordered_extent_work (struct btrfs_work *work)
@@ -715,9 +724,16 @@ void btrfs_start_ordered_extent(struct btrfs_ordered_extent *entry, int wait)u64 start = entry->file_offset;u64 end = start + entry->num_bytes -1 ;struct btrfs_inode *inode =BTRFS_I (entry->inode); +bool freespace_inode;trace_btrfs_ordered_extent_start (inode, entry); +/* +* If this is a free space inode do not take the ordered extents lockdep +* map. +*/ + freespace_inode =btrfs_is_free_space_inode (inode); +/* * pages in the range can be dirty, clean or writeback. We * start IO on any dirty ones so the wait doesn't stall waiting
@@ -726,6 +742,8 @@ void btrfs_start_ordered_extent(struct btrfs_ordered_extent *entry, int wait)if (!test_bit (BTRFS_ORDERED_DIRECT , &entry->flags))filemap_fdatawrite_range (inode->vfs_inode.i_mapping, start, end);if (wait) { +if (!freespace_inode) +btrfs_might_wait_for_event (inode->root->fs_info, btrfs_ordered_extent);wait_event (entry->wait,test_bit (BTRFS_ORDERED_COMPLETE , &entry->flags)); }
Signature · 1 line
2.30.2
Quoted 15 lines · Ioannis Angelakopoulos
Hello,
With this patch series we annotate wait events in btrfs with lockdep to catch deadlocks involving these wait events.
Recently the btrfs developers fixed a non trivial deadlock involving wait events
https://lore.kernel.org/linux-btrfs/[email protected]/Currently lockdep is unable to catch these deadlocks since it does not support wait events by default.
With our lockdep annotations we train lockdep to track these wait events and catch more potential deadlocks.
Quoted 9 lines
Specifically, we annotate the below wait events in
fs/btrfs/transaction.cand infs/btrfs/ordered-data.c:1) The
num_writerswait event
2) Thenum_extwriterswait event
3) The transaction states wait events
4) Thepending_orderedwait event
5) The ordered extents wait event
You can add
to the series, thanks,
Josef