btrfs: split btrfs_set_lock_blocking_rw to read and write helpers

There are many callers that hardcode the desired lock type so we can
avoid the switch and call them directly. Split the current function to
two but leave a helper that still takes the variable lock type to make
current code compile.  The call sites will be converted in followup
patches.

Reviewed-by: Johannes Thumshirn <jthumshirn@suse.de>
Signed-off-by: David Sterba <dsterba@suse.com>

diff --git a/fs/btrfs/locking.c b/fs/btrfs/locking.c
index 1da768e5ef75bda36142c084d6ba7c2b5c4bc809..7201d000f61d08e3e1e9c0d2d74529ec608777fc 100644 (file)
--- a/fs/btrfs/locking.c
+++ b/fs/btrfs/locking.c
@@ -14,35 +14,37 @@
 
 static void btrfs_assert_tree_read_locked(struct extent_buffer *eb);
 
-/*
- * if we currently have a spinning reader or writer lock
- * (indicated by the rw flag) this will bump the count
- * of blocking holders and drop the spinlock.
- */
-void btrfs_set_lock_blocking_rw(struct extent_buffer *eb, int rw)
+void btrfs_set_lock_blocking_read(struct extent_buffer *eb)
 {
        /*
-        * no lock is required.  The lock owner may change if
-        * we have a read lock, but it won't change to or away
-        * from us.  If we have the write lock, we are the owner
-        * and it'll never change.
+        * No lock is required.  The lock owner may change if we have a read
+        * lock, but it won't change to or away from us.  If we have the write
+        * lock, we are the owner and it'll never change.
         */
        if (eb->lock_nested && current->pid == eb->lock_owner)
                return;
-       if (rw == BTRFS_WRITE_LOCK) {
-               if (atomic_read(&eb->blocking_writers) == 0) {
-                       WARN_ON(atomic_read(&eb->spinning_writers) != 1);
-                       atomic_dec(&eb->spinning_writers);
-                       btrfs_assert_tree_locked(eb);
-                       atomic_inc(&eb->blocking_writers);
-                       write_unlock(&eb->lock);
-               }
-       } else if (rw == BTRFS_READ_LOCK) {
-               btrfs_assert_tree_read_locked(eb);
-               atomic_inc(&eb->blocking_readers);
-               WARN_ON(atomic_read(&eb->spinning_readers) == 0);
-               atomic_dec(&eb->spinning_readers);
-               read_unlock(&eb->lock);
+       btrfs_assert_tree_read_locked(eb);
+       atomic_inc(&eb->blocking_readers);
+       WARN_ON(atomic_read(&eb->spinning_readers) == 0);
+       atomic_dec(&eb->spinning_readers);
+       read_unlock(&eb->lock);
+}
+
+void btrfs_set_lock_blocking_write(struct extent_buffer *eb)
+{
+       /*
+        * No lock is required.  The lock owner may change if we have a read
+        * lock, but it won't change to or away from us.  If we have the write
+        * lock, we are the owner and it'll never change.
+        */
+       if (eb->lock_nested && current->pid == eb->lock_owner)
+               return;
+       if (atomic_read(&eb->blocking_writers) == 0) {
+               WARN_ON(atomic_read(&eb->spinning_writers) != 1);
+               atomic_dec(&eb->spinning_writers);
+               btrfs_assert_tree_locked(eb);
+               atomic_inc(&eb->blocking_writers);
+               write_unlock(&eb->lock);
        }
 }
 

diff --git a/fs/btrfs/locking.h b/fs/btrfs/locking.h
index 29135def468e97ab240ddf11d0c51c2555dbb5dc..0453a47976933202b48ee54a8682448202c3aac7 100644 (file)
--- a/fs/btrfs/locking.h
+++ b/fs/btrfs/locking.h
@@ -17,7 +17,8 @@ void btrfs_tree_unlock(struct extent_buffer *eb);
 void btrfs_tree_read_lock(struct extent_buffer *eb);
 void btrfs_tree_read_unlock(struct extent_buffer *eb);
 void btrfs_tree_read_unlock_blocking(struct extent_buffer *eb);
-void btrfs_set_lock_blocking_rw(struct extent_buffer *eb, int rw);
+void btrfs_set_lock_blocking_read(struct extent_buffer *eb);
+void btrfs_set_lock_blocking_write(struct extent_buffer *eb);
 void btrfs_clear_lock_blocking_rw(struct extent_buffer *eb, int rw);
 void btrfs_assert_tree_locked(struct extent_buffer *eb);
 int btrfs_try_tree_read_lock(struct extent_buffer *eb);
@@ -37,6 +38,18 @@ static inline void btrfs_tree_unlock_rw(struct extent_buffer *eb, int rw)
                BUG();
 }
 
+/*
+ * If we currently have a spinning reader or writer lock (indicated by the rw
+ * flag) this will bump the count of blocking holders and drop the spinlock.
+ */
+static inline void btrfs_set_lock_blocking_rw(struct extent_buffer *eb, int rw)
+{
+       if (rw == BTRFS_WRITE_LOCK)
+               btrfs_set_lock_blocking_write(eb);
+       else if (rw == BTRFS_READ_LOCK)
+               btrfs_set_lock_blocking_read(eb);
+}
+
 static inline void btrfs_set_lock_blocking(struct extent_buffer *eb)
 {
        btrfs_set_lock_blocking_rw(eb, BTRFS_WRITE_LOCK);