locking/qrwlock: Use atomic_cond_read_acquire() when spinning in qrwlock

The qrwlock slowpaths involve spinning when either a prospective reader
is waiting for a concurrent writer to drain, or a prospective writer is
waiting for concurrent readers to drain. In both of these situations,
atomic_cond_read_acquire() can be used to avoid busy-waiting and make use
of any backoff functionality provided by the architecture.

This patch replaces the open-code loops and rspin_until_writer_unlock()
implementation with atomic_cond_read_acquire(). The write mode transition
zero to _QW_WAITING is left alone, since (a) this doesn't need acquire
semantics and (b) should be fast.

Tested-by: Waiman Long <longman@redhat.com>
Tested-by: Jeremy Linton <jeremy.linton@arm.com>
Tested-by: Adam Wallis <awallis@codeaurora.org>
Tested-by: Jan Glauber <jglauber@cavium.com>
Signed-off-by: Will Deacon <will.deacon@arm.com>
Acked-by: Peter Zijlstra <peterz@infradead.org>
Cc: Boqun Feng <boqun.feng@gmail.com>
Cc: Jeremy.Linton@arm.com
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Paul E. McKenney <paulmck@linux.vnet.ibm.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-arm-kernel@lists.infradead.org
Link: http://lkml.kernel.org/r/1507810851-306-4-git-send-email-will.deacon@arm.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>

diff --git a/include/asm-generic/qrwlock.h b/include/asm-generic/qrwlock.h
index 02c0a768e6b085296a81af52e6f0e0dfbe7801a6..c716b02e8fd72b1cb95faaea0390b09cdcc7a75c 100644 (file)
--- a/include/asm-generic/qrwlock.h
+++ b/include/asm-generic/qrwlock.h
@@ -49,7 +49,7 @@
 /*
  * External function declarations
  */
-extern void queued_read_lock_slowpath(struct qrwlock *lock, u32 cnts);
+extern void queued_read_lock_slowpath(struct qrwlock *lock);
 extern void queued_write_lock_slowpath(struct qrwlock *lock);
 
 /**
@@ -100,7 +100,7 @@ static inline void queued_read_lock(struct qrwlock *lock)
                return;
 
        /* The slowpath will decrement the reader count, if necessary. */
-       queued_read_lock_slowpath(lock, cnts);
+       queued_read_lock_slowpath(lock);
 }
 
 /**

diff --git a/kernel/locking/qrwlock.c b/kernel/locking/qrwlock.c
index 1af791e3734893789682b8eed1b9cdf0c2ae10da..5825e0fc1a8eec6f1cf504b3582b8773e4676afd 100644 (file)
--- a/kernel/locking/qrwlock.c
+++ b/kernel/locking/qrwlock.c
@@ -23,29 +23,11 @@
 #include <linux/spinlock.h>
 #include <asm/qrwlock.h>
 
-/**
- * rspin_until_writer_unlock - inc reader count & spin until writer is gone
- * @lock  : Pointer to queue rwlock structure
- * @writer: Current queue rwlock writer status byte
- *
- * In interrupt context or at the head of the queue, the reader will just
- * increment the reader count & wait until the writer releases the lock.
- */
-static __always_inline void
-rspin_until_writer_unlock(struct qrwlock *lock, u32 cnts)
-{
-       while ((cnts & _QW_WMASK) == _QW_LOCKED) {
-               cpu_relax();
-               cnts = atomic_read_acquire(&lock->cnts);
-       }
-}
-
 /**
  * queued_read_lock_slowpath - acquire read lock of a queue rwlock
  * @lock: Pointer to queue rwlock structure
- * @cnts: Current qrwlock lock value
  */
-void queued_read_lock_slowpath(struct qrwlock *lock, u32 cnts)
+void queued_read_lock_slowpath(struct qrwlock *lock)
 {
        /*
         * Readers come here when they cannot get the lock without waiting
@@ -53,13 +35,12 @@ void queued_read_lock_slowpath(struct qrwlock *lock, u32 cnts)
        if (unlikely(in_interrupt())) {
                /*
                 * Readers in interrupt context will get the lock immediately
-                * if the writer is just waiting (not holding the lock yet).
-                * The rspin_until_writer_unlock() function returns immediately
-                * in this case. Otherwise, they will spin (with ACQUIRE
-                * semantics) until the lock is available without waiting in
-                * the queue.
+                * if the writer is just waiting (not holding the lock yet),
+                * so spin with ACQUIRE semantics until the lock is available
+                * without waiting in the queue.
                 */
-               rspin_until_writer_unlock(lock, cnts);
+               atomic_cond_read_acquire(&lock->cnts, (VAL & _QW_WMASK)
+                                        != _QW_LOCKED);
                return;
        }
        atomic_sub(_QR_BIAS, &lock->cnts);
@@ -68,14 +49,14 @@ void queued_read_lock_slowpath(struct qrwlock *lock, u32 cnts)
         * Put the reader into the wait queue
         */
        arch_spin_lock(&lock->wait_lock);
+       atomic_add(_QR_BIAS, &lock->cnts);
 
        /*
         * The ACQUIRE semantics of the following spinning code ensure
         * that accesses can't leak upwards out of our subsequent critical
         * section in the case that the lock is currently held for write.
         */
-       cnts = atomic_fetch_add_acquire(_QR_BIAS, &lock->cnts);
-       rspin_until_writer_unlock(lock, cnts);
+       atomic_cond_read_acquire(&lock->cnts, (VAL & _QW_WMASK) != _QW_LOCKED);
 
        /*
         * Signal the next one in queue to become queue head
@@ -90,8 +71,6 @@ EXPORT_SYMBOL(queued_read_lock_slowpath);
  */
 void queued_write_lock_slowpath(struct qrwlock *lock)
 {
-       u32 cnts;
-
        /* Put the writer into the wait queue */
        arch_spin_lock(&lock->wait_lock);
 
@@ -113,15 +92,10 @@ void queued_write_lock_slowpath(struct qrwlock *lock)
        }
 
        /* When no more readers, set the locked flag */
-       for (;;) {
-               cnts = atomic_read(&lock->cnts);
-               if ((cnts == _QW_WAITING) &&
-                   (atomic_cmpxchg_acquire(&lock->cnts, _QW_WAITING,
-                                           _QW_LOCKED) == _QW_WAITING))
-                       break;
-
-               cpu_relax();
-       }
+       do {
+               atomic_cond_read_acquire(&lock->cnts, VAL == _QW_WAITING);
+       } while (atomic_cmpxchg_relaxed(&lock->cnts, _QW_WAITING,
+                                       _QW_LOCKED) != _QW_WAITING);
 unlock:
        arch_spin_unlock(&lock->wait_lock);
 }