btrfs: replace waitqueue_actvie with cond_wake_up

Use the wrappers and reduce the amount of low-level details about the
waitqueue management.

Reviewed-by: Nikolay Borisov <nborisov@suse.com>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/compression.c b/fs/btrfs/compression.c
index 1061575..d3e447b 100644 (file)
--- a/fs/btrfs/compression.c
+++ b/fs/btrfs/compression.c
@@ -990,12 +990,7 @@ static void __free_workspace(int type, struct list_head *workspace,
                btrfs_compress_op[idx]->free_workspace(workspace);
        atomic_dec(total_ws);
 wake:
-       /*
-        * Make sure counter is updated before we wake up waiters.
-        */
-       smp_mb();
-       if (waitqueue_active(ws_wait))
-               wake_up(ws_wait);
+       cond_wake_up(ws_wait);
 }
 
 static void free_workspace(int type, struct list_head *ws)

diff --git a/fs/btrfs/delayed-inode.c b/fs/btrfs/delayed-inode.c
index a8d492d..fe6caa7 100644 (file)
--- a/fs/btrfs/delayed-inode.c
+++ b/fs/btrfs/delayed-inode.c
@@ -460,13 +460,10 @@ static void finish_one_item(struct btrfs_delayed_root *delayed_root)
 {
        int seq = atomic_inc_return(&delayed_root->items_seq);
 
-       /*
-        * atomic_dec_return implies a barrier for waitqueue_active
-        */
+       /* atomic_dec_return implies a barrier */
        if ((atomic_dec_return(&delayed_root->items) <
-           BTRFS_DELAYED_BACKGROUND || seq % BTRFS_DELAYED_BATCH == 0) &&
-           waitqueue_active(&delayed_root->wait))
-               wake_up(&delayed_root->wait);
+           BTRFS_DELAYED_BACKGROUND || seq % BTRFS_DELAYED_BATCH == 0))
+               cond_wake_up_nomb(&delayed_root->wait);
 }
 
 static void __btrfs_remove_delayed_item(struct btrfs_delayed_item *delayed_item)

diff --git a/fs/btrfs/dev-replace.c b/fs/btrfs/dev-replace.c
index 12f703e..8994628 100644 (file)
--- a/fs/btrfs/dev-replace.c
+++ b/fs/btrfs/dev-replace.c
@@ -1009,9 +1009,9 @@ void btrfs_dev_replace_clear_lock_blocking(
        ASSERT(atomic_read(&dev_replace->read_locks) > 0);
        ASSERT(atomic_read(&dev_replace->blocking_readers) > 0);
        read_lock(&dev_replace->lock);
-       if (atomic_dec_and_test(&dev_replace->blocking_readers) &&
-           waitqueue_active(&dev_replace->read_lock_wq))
-               wake_up(&dev_replace->read_lock_wq);
+       /* Barrier implied by atomic_dec_and_test */
+       if (atomic_dec_and_test(&dev_replace->blocking_readers))
+               cond_wake_up_nomb(&dev_replace->read_lock_wq);
 }
 
 void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info *fs_info)
@@ -1022,9 +1022,7 @@ void btrfs_bio_counter_inc_noblocked(struct btrfs_fs_info *fs_info)
 void btrfs_bio_counter_sub(struct btrfs_fs_info *fs_info, s64 amount)
 {
        percpu_counter_sub(&fs_info->bio_counter, amount);
-
-       if (waitqueue_active(&fs_info->replace_wait))
-               wake_up(&fs_info->replace_wait);
+       cond_wake_up_nomb(&fs_info->replace_wait);
 }
 
 void btrfs_bio_counter_inc_blocked(struct btrfs_fs_info *fs_info)

diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
index 5be54ce..fa2ed14 100644 (file)
--- a/fs/btrfs/extent-tree.c
+++ b/fs/btrfs/extent-tree.c
@@ -11081,12 +11081,7 @@ int btrfs_trim_fs(struct btrfs_fs_info *fs_info, struct fstrim_range *range)
 void btrfs_end_write_no_snapshotting(struct btrfs_root *root)
 {
        percpu_counter_dec(&root->subv_writers->counter);
-       /*
-        * Make sure counter is updated before we wake up waiters.
-        */
-       smp_mb();
-       if (waitqueue_active(&root->subv_writers->wait))
-               wake_up(&root->subv_writers->wait);
+       cond_wake_up(&root->subv_writers->wait);
 }
 
 int btrfs_start_write_no_snapshotting(struct btrfs_root *root)

diff --git a/fs/btrfs/inode.c b/fs/btrfs/inode.c
index 6757fe1..563e63f 100644 (file)
--- a/fs/btrfs/inode.c
+++ b/fs/btrfs/inode.c
@@ -1156,13 +1156,10 @@ static noinline void async_cow_submit(struct btrfs_work *work)
        nr_pages = (async_cow->end - async_cow->start + PAGE_SIZE) >>
                PAGE_SHIFT;
 
-       /*
-        * atomic_sub_return implies a barrier for waitqueue_active
-        */
+       /* atomic_sub_return implies a barrier */
        if (atomic_sub_return(nr_pages, &fs_info->async_delalloc_pages) <
-           5 * SZ_1M &&
-           waitqueue_active(&fs_info->async_submit_wait))
-               wake_up(&fs_info->async_submit_wait);
+           5 * SZ_1M)
+               cond_wake_up_nomb(&fs_info->async_submit_wait);
 
        if (async_cow->inode)
                submit_compressed_extents(async_cow->inode, async_cow);

diff --git a/fs/btrfs/locking.c b/fs/btrfs/locking.c
index e4faefa..1da768e 100644 (file)
--- a/fs/btrfs/locking.c
+++ b/fs/btrfs/locking.c
@@ -66,22 +66,16 @@ void btrfs_clear_lock_blocking_rw(struct extent_buffer *eb, int rw)
                write_lock(&eb->lock);
                WARN_ON(atomic_read(&eb->spinning_writers));
                atomic_inc(&eb->spinning_writers);
-               /*
-                * atomic_dec_and_test implies a barrier for waitqueue_active
-                */
-               if (atomic_dec_and_test(&eb->blocking_writers) &&
-                   waitqueue_active(&eb->write_lock_wq))
-                       wake_up(&eb->write_lock_wq);
+               /* atomic_dec_and_test implies a barrier */
+               if (atomic_dec_and_test(&eb->blocking_writers))
+                       cond_wake_up_nomb(&eb->write_lock_wq);
        } else if (rw == BTRFS_READ_LOCK_BLOCKING) {
                BUG_ON(atomic_read(&eb->blocking_readers) == 0);
                read_lock(&eb->lock);
                atomic_inc(&eb->spinning_readers);
-               /*
-                * atomic_dec_and_test implies a barrier for waitqueue_active
-                */
-               if (atomic_dec_and_test(&eb->blocking_readers) &&
-                   waitqueue_active(&eb->read_lock_wq))
-                       wake_up(&eb->read_lock_wq);
+               /* atomic_dec_and_test implies a barrier */
+               if (atomic_dec_and_test(&eb->blocking_readers))
+                       cond_wake_up_nomb(&eb->read_lock_wq);
        }
 }
 
@@ -221,12 +215,9 @@ void btrfs_tree_read_unlock_blocking(struct extent_buffer *eb)
        }
        btrfs_assert_tree_read_locked(eb);
        WARN_ON(atomic_read(&eb->blocking_readers) == 0);
-       /*
-        * atomic_dec_and_test implies a barrier for waitqueue_active
-        */
-       if (atomic_dec_and_test(&eb->blocking_readers) &&
-           waitqueue_active(&eb->read_lock_wq))
-               wake_up(&eb->read_lock_wq);
+       /* atomic_dec_and_test implies a barrier */
+       if (atomic_dec_and_test(&eb->blocking_readers))
+               cond_wake_up_nomb(&eb->read_lock_wq);
        atomic_dec(&eb->read_locks);
 }
 
@@ -275,12 +266,9 @@ void btrfs_tree_unlock(struct extent_buffer *eb)
        if (blockers) {
                WARN_ON(atomic_read(&eb->spinning_writers));
                atomic_dec(&eb->blocking_writers);
-               /*
-                * Make sure counter is updated before we wake up waiters.
-                */
+               /* Use the lighter barrier after atomic */
                smp_mb__after_atomic();
-               if (waitqueue_active(&eb->write_lock_wq))
-                       wake_up(&eb->write_lock_wq);
+               cond_wake_up_nomb(&eb->write_lock_wq);
        } else {
                WARN_ON(atomic_read(&eb->spinning_writers) != 1);
                atomic_dec(&eb->spinning_writers);

diff --git a/fs/btrfs/ordered-data.c b/fs/btrfs/ordered-data.c
index 6db8bb2..2e1a169 100644 (file)
--- a/fs/btrfs/ordered-data.c
+++ b/fs/btrfs/ordered-data.c
@@ -343,11 +343,8 @@ int btrfs_dec_test_first_ordered_pending(struct inode *inode,
 
        if (entry->bytes_left == 0) {
                ret = test_and_set_bit(BTRFS_ORDERED_IO_DONE, &entry->flags);
-               /*
-                * Implicit memory barrier after test_and_set_bit
-                */
-               if (waitqueue_active(&entry->wait))
-                       wake_up(&entry->wait);
+               /* test_and_set_bit implies a barrier */
+               cond_wake_up_nomb(&entry->wait);
        } else {
                ret = 1;
        }
@@ -410,11 +407,8 @@ have_entry:
 
        if (entry->bytes_left == 0) {
                ret = test_and_set_bit(BTRFS_ORDERED_IO_DONE, &entry->flags);
-               /*
-                * Implicit memory barrier after test_and_set_bit
-                */
-               if (waitqueue_active(&entry->wait))
-                       wake_up(&entry->wait);
+               /* test_and_set_bit implies a barrier */
+               cond_wake_up_nomb(&entry->wait);
        } else {
                ret = 1;
        }

diff --git a/fs/btrfs/transaction.c b/fs/btrfs/transaction.c
index c944b47..ff841ab 100644 (file)
--- a/fs/btrfs/transaction.c
+++ b/fs/btrfs/transaction.c
@@ -877,12 +877,7 @@ static int __btrfs_end_transaction(struct btrfs_trans_handle *trans,
        atomic_dec(&cur_trans->num_writers);
        extwriter_counter_dec(cur_trans, trans->type);
 
-       /*
-        * Make sure counter is updated before we wake up waiters.
-        */
-       smp_mb();
-       if (waitqueue_active(&cur_trans->writer_wait))
-               wake_up(&cur_trans->writer_wait);
+       cond_wake_up(&cur_trans->writer_wait);
        btrfs_put_transaction(cur_trans);
 
        if (current->journal_info == trans)

diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c
index 2009cea..f8220ec 100644 (file)
--- a/fs/btrfs/tree-log.c
+++ b/fs/btrfs/tree-log.c
@@ -222,11 +222,8 @@ int btrfs_pin_log_trans(struct btrfs_root *root)
 void btrfs_end_log_trans(struct btrfs_root *root)
 {
        if (atomic_dec_and_test(&root->log_writers)) {
-               /*
-                * Implicit memory barrier after atomic_dec_and_test
-                */
-               if (waitqueue_active(&root->log_writer_wait))
-                       wake_up(&root->log_writer_wait);
+               /* atomic_dec_and_test implies a barrier */
+               cond_wake_up_nomb(&root->log_writer_wait);
        }
 }
 
@@ -2988,11 +2985,8 @@ int btrfs_sync_log(struct btrfs_trans_handle *trans,
 
        mutex_lock(&log_root_tree->log_mutex);
        if (atomic_dec_and_test(&log_root_tree->log_writers)) {
-               /*
-                * Implicit memory barrier after atomic_dec_and_test
-                */
-               if (waitqueue_active(&log_root_tree->log_writer_wait))
-                       wake_up(&log_root_tree->log_writer_wait);
+               /* atomic_dec_and_test implies a barrier */
+               cond_wake_up_nomb(&log_root_tree->log_writer_wait);
        }
 
        if (ret) {
@@ -3116,13 +3110,11 @@ out_wake_log_root:
        mutex_unlock(&log_root_tree->log_mutex);
 
        /*
-        * The barrier before waitqueue_active is needed so all the updates
-        * above are seen by the woken threads. It might not be necessary, but
-        * proving that seems to be hard.
+        * The barrier before waitqueue_active (in cond_wake_up) is needed so
+        * all the updates above are seen by the woken threads. It might not be
+        * necessary, but proving that seems to be hard.
         */
-       smp_mb();
-       if (waitqueue_active(&log_root_tree->log_commit_wait[index2]))
-               wake_up(&log_root_tree->log_commit_wait[index2]);
+       cond_wake_up(&log_root_tree->log_commit_wait[index2]);
 out:
        mutex_lock(&root->log_mutex);
        btrfs_remove_all_log_ctxs(root, index1, ret);
@@ -3131,13 +3123,11 @@ out:
        mutex_unlock(&root->log_mutex);
 
        /*
-        * The barrier before waitqueue_active is needed so all the updates
-        * above are seen by the woken threads. It might not be necessary, but
-        * proving that seems to be hard.
+        * The barrier before waitqueue_active (in cond_wake_up) is needed so
+        * all the updates above are seen by the woken threads. It might not be
+        * necessary, but proving that seems to be hard.
         */
-       smp_mb();
-       if (waitqueue_active(&root->log_commit_wait[index1]))
-               wake_up(&root->log_commit_wait[index1]);
+       cond_wake_up(&root->log_commit_wait[index1]);
        return ret;
 }