btrfs: use assertion helpers for extent buffer read lock counters

[sfrench/cifs-2.6.git] / fs / btrfs / locking.c

diff --git a/fs/btrfs/locking.c b/fs/btrfs/locking.c
index 82b84e4daad1f336fc8b6de895d445682308f3ef..1088cf322fdde2909e7db70d462118990dcce14e 100644 (file)
--- a/fs/btrfs/locking.c
+++ b/fs/btrfs/locking.c
@@ -12,7 +12,60 @@
 #include "extent_io.h"
 #include "locking.h"
 
-static void btrfs_assert_tree_read_locked(struct extent_buffer *eb);
+#ifdef CONFIG_BTRFS_DEBUG
+static void btrfs_assert_spinning_writers_get(struct extent_buffer *eb)
+{
+       WARN_ON(atomic_read(&eb->spinning_writers));
+       atomic_inc(&eb->spinning_writers);
+}
+
+static void btrfs_assert_spinning_writers_put(struct extent_buffer *eb)
+{
+       WARN_ON(atomic_read(&eb->spinning_writers) != 1);
+       atomic_dec(&eb->spinning_writers);
+}
+
+static void btrfs_assert_no_spinning_writers(struct extent_buffer *eb)
+{
+       WARN_ON(atomic_read(&eb->spinning_writers));
+}
+
+static void btrfs_assert_spinning_readers_get(struct extent_buffer *eb)
+{
+       atomic_inc(&eb->spinning_readers);
+}
+
+static void btrfs_assert_spinning_readers_put(struct extent_buffer *eb)
+{
+       WARN_ON(atomic_read(&eb->spinning_readers) == 0);
+       atomic_dec(&eb->spinning_readers);
+}
+
+static void btrfs_assert_tree_read_locks_get(struct extent_buffer *eb)
+{
+       atomic_inc(&eb->read_locks);
+}
+
+static void btrfs_assert_tree_read_locks_put(struct extent_buffer *eb)
+{
+       atomic_dec(&eb->read_locks);
+}
+
+static void btrfs_assert_tree_read_locked(struct extent_buffer *eb)
+{
+       BUG_ON(!atomic_read(&eb->read_locks));
+}
+
+#else
+static void btrfs_assert_spinning_writers_get(struct extent_buffer *eb) { }
+static void btrfs_assert_spinning_writers_put(struct extent_buffer *eb) { }
+static void btrfs_assert_no_spinning_writers(struct extent_buffer *eb) { }
+static void btrfs_assert_spinning_readers_put(struct extent_buffer *eb) { }
+static void btrfs_assert_spinning_readers_get(struct extent_buffer *eb) { }
+static void btrfs_assert_tree_read_locked(struct extent_buffer *eb) { }
+static void btrfs_assert_tree_read_locks_get(struct extent_buffer *eb) { }
+static void btrfs_assert_tree_read_locks_put(struct extent_buffer *eb) { }
+#endif
 
 void btrfs_set_lock_blocking_read(struct extent_buffer *eb)
 {
@@ -25,8 +78,7 @@ void btrfs_set_lock_blocking_read(struct extent_buffer *eb)
                return;
        btrfs_assert_tree_read_locked(eb);
        atomic_inc(&eb->blocking_readers);
-       WARN_ON(atomic_read(&eb->spinning_readers) == 0);
-       atomic_dec(&eb->spinning_readers);
+       btrfs_assert_spinning_readers_put(eb);
        read_unlock(&eb->lock);
 }
 
@@ -40,8 +92,7 @@ void btrfs_set_lock_blocking_write(struct extent_buffer *eb)
        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_spinning_writers_put(eb);
                btrfs_assert_tree_locked(eb);
                atomic_inc(&eb->blocking_writers);
                write_unlock(&eb->lock);
@@ -59,7 +110,7 @@ void btrfs_clear_lock_blocking_read(struct extent_buffer *eb)
                return;
        BUG_ON(atomic_read(&eb->blocking_readers) == 0);
        read_lock(&eb->lock);
-       atomic_inc(&eb->spinning_readers);
+       btrfs_assert_spinning_readers_get(eb);
        /* atomic_dec_and_test implies a barrier */
        if (atomic_dec_and_test(&eb->blocking_readers))
                cond_wake_up_nomb(&eb->read_lock_wq);
@@ -77,8 +128,7 @@ void btrfs_clear_lock_blocking_write(struct extent_buffer *eb)
                return;
        BUG_ON(atomic_read(&eb->blocking_writers) != 1);
        write_lock(&eb->lock);
-       WARN_ON(atomic_read(&eb->spinning_writers));
-       atomic_inc(&eb->spinning_writers);
+       btrfs_assert_spinning_writers_get(eb);
        /* atomic_dec_and_test implies a barrier */
        if (atomic_dec_and_test(&eb->blocking_writers))
                cond_wake_up_nomb(&eb->write_lock_wq);
@@ -114,8 +164,8 @@ again:
                           atomic_read(&eb->blocking_writers) == 0);
                goto again;
        }
-       atomic_inc(&eb->read_locks);
-       atomic_inc(&eb->spinning_readers);
+       btrfs_assert_tree_read_locks_get(eb);
+       btrfs_assert_spinning_readers_get(eb);
 }
 
 /*
@@ -133,8 +183,8 @@ int btrfs_tree_read_lock_atomic(struct extent_buffer *eb)
                read_unlock(&eb->lock);
                return 0;
        }
-       atomic_inc(&eb->read_locks);
-       atomic_inc(&eb->spinning_readers);
+       btrfs_assert_tree_read_locks_get(eb);
+       btrfs_assert_spinning_readers_get(eb);
        return 1;
 }
 
@@ -154,8 +204,8 @@ int btrfs_try_tree_read_lock(struct extent_buffer *eb)
                read_unlock(&eb->lock);
                return 0;
        }
-       atomic_inc(&eb->read_locks);
-       atomic_inc(&eb->spinning_readers);
+       btrfs_assert_tree_read_locks_get(eb);
+       btrfs_assert_spinning_readers_get(eb);
        return 1;
 }
 
@@ -176,7 +226,7 @@ int btrfs_try_tree_write_lock(struct extent_buffer *eb)
                return 0;
        }
        atomic_inc(&eb->write_locks);
-       atomic_inc(&eb->spinning_writers);
+       btrfs_assert_spinning_writers_get(eb);
        eb->lock_owner = current->pid;
        return 1;
 }
@@ -197,9 +247,8 @@ void btrfs_tree_read_unlock(struct extent_buffer *eb)
                return;
        }
        btrfs_assert_tree_read_locked(eb);
-       WARN_ON(atomic_read(&eb->spinning_readers) == 0);
-       atomic_dec(&eb->spinning_readers);
-       atomic_dec(&eb->read_locks);
+       btrfs_assert_spinning_readers_put(eb);
+       btrfs_assert_tree_read_locks_put(eb);
        read_unlock(&eb->lock);
 }
 
@@ -223,7 +272,7 @@ void btrfs_tree_read_unlock_blocking(struct extent_buffer *eb)
        /* 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);
+       btrfs_assert_tree_read_locks_put(eb);
 }
 
 /*
@@ -242,8 +291,7 @@ again:
                write_unlock(&eb->lock);
                goto again;
        }
-       WARN_ON(atomic_read(&eb->spinning_writers));
-       atomic_inc(&eb->spinning_writers);
+       btrfs_assert_spinning_writers_get(eb);
        atomic_inc(&eb->write_locks);
        eb->lock_owner = current->pid;
 }
@@ -262,14 +310,13 @@ void btrfs_tree_unlock(struct extent_buffer *eb)
        atomic_dec(&eb->write_locks);
 
        if (blockers) {
-               WARN_ON(atomic_read(&eb->spinning_writers));
+               btrfs_assert_no_spinning_writers(eb);
                atomic_dec(&eb->blocking_writers);
                /* Use the lighter barrier after atomic */
                smp_mb__after_atomic();
                cond_wake_up_nomb(&eb->write_lock_wq);
        } else {
-               WARN_ON(atomic_read(&eb->spinning_writers) != 1);
-               atomic_dec(&eb->spinning_writers);
+               btrfs_assert_spinning_writers_put(eb);
                write_unlock(&eb->lock);
        }
 }
@@ -278,8 +325,3 @@ void btrfs_assert_tree_locked(struct extent_buffer *eb)
 {
        BUG_ON(!atomic_read(&eb->write_locks));
 }
-
-static void btrfs_assert_tree_read_locked(struct extent_buffer *eb)
-{
-       BUG_ON(!atomic_read(&eb->read_locks));
-}