BKL: revert back to the old spinlock implementation

The generic semaphore rewrite had a huge performance regression on AIM7
(and potentially other BKL-heavy benchmarks) because the generic
semaphores had been rewritten to be simple to understand and fair.  The
latter, in particular, turns a semaphore-based BKL implementation into a
mess of scheduling.

The attempt to fix the performance regression failed miserably (see the
previous commit 00b41ec2611dc98f87f30753ee00a53db648d662 'Revert
"semaphore: fix"'), and so for now the simple and sane approach is to
instead just go back to the old spinlock-based BKL implementation that
never had any issues like this.

This patch also has the advantage of being reported to fix the
regression completely according to Yanmin Zhang, unlike the semaphore
hack which still left a couple percentage point regression.

As a spinlock, the BKL obviously has the potential to be a latency
issue, but it's not really any different from any other spinlock in that
respect.  We do want to get rid of the BKL asap, but that has been the
plan for several years.

These days, the biggest users are in the tty layer (open/release in
particular) and Alan holds out some hope:

  "tty release is probably a few months away from getting cured - I'm
   afraid it will almost certainly be the very last user of the BKL in
   tty to get fixed as it depends on everything else being sanely locked."

so while we're not there yet, we do have a plan of action.

Tested-by: Yanmin Zhang <yanmin_zhang@linux.intel.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Andi Kleen <andi@firstfloor.org>
Cc: Matthew Wilcox <matthew@wil.cx>
Cc: Alexander Viro <viro@ftp.linux.org.uk>
Cc: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 81 insertions, 39 deletions

diff --git a/lib/kernel_lock.c b/lib/kernel_lock.c
index cd3e82530b03..01a3c22c1b5a 100644
--- a/lib/kernel_lock.c
+++ b/lib/kernel_lock.c
@@ -11,79 +11,121 @@
 #include <linux/semaphore.h>
 
 /*
- * The 'big kernel semaphore'
+ * The 'big kernel lock'
  *
- * This mutex is taken and released recursively by lock_kernel()
+ * This spinlock is taken and released recursively by lock_kernel()
  * and unlock_kernel().  It is transparently dropped and reacquired
  * over schedule().  It is used to protect legacy code that hasn't
  * been migrated to a proper locking design yet.
  *
- * Note: code locked by this semaphore will only be serialized against
- * other code using the same locking facility. The code guarantees that
- * the task remains on the same CPU.
- *
  * Don't use in new code.
  */
-static DECLARE_MUTEX(kernel_sem);
+static  __cacheline_aligned_in_smp DEFINE_SPINLOCK(kernel_flag);
+
 
 /*
- * Re-acquire the kernel semaphore.
+ * Acquire/release the underlying lock from the scheduler.
  *
- * This function is called with preemption off.
+ * This is called with preemption disabled, and should
+ * return an error value if it cannot get the lock and
+ * TIF_NEED_RESCHED gets set.
  *
- * We are executing in schedule() so the code must be extremely careful
- * about recursion, both due to the down() and due to the enabling of
- * preemption. schedule() will re-check the preemption flag after
- * reacquiring the semaphore.
+ * If it successfully gets the lock, it should increment
+ * the preemption count like any spinlock does.
+ *
+ * (This works on UP too - _raw_spin_trylock will never
+ * return false in that case)
  */
 int __lockfunc __reacquire_kernel_lock(void)
 {
-        struct task_struct *task = current;
-        int saved_lock_depth = task->lock_depth;
-
-        BUG_ON(saved_lock_depth < 0);
-
-        task->lock_depth = -1;
-        preempt_enable_no_resched();
-
-        down(&kernel_sem);
-
+        while (!_raw_spin_trylock(&kernel_flag)) {
+                if (test_thread_flag(TIF_NEED_RESCHED))
+                        return -EAGAIN;
+                cpu_relax();
+        }
         preempt_disable();
-        task->lock_depth = saved_lock_depth;
-
         return 0;
 }
 
 void __lockfunc __release_kernel_lock(void)
 {
-        up(&kernel_sem);
+        _raw_spin_unlock(&kernel_flag);
+        preempt_enable_no_resched();
 }
 
 /*
- * Getting the big kernel semaphore.
+ * These are the BKL spinlocks - we try to be polite about preemption.
+ * If SMP is not on (ie UP preemption), this all goes away because the
+ * _raw_spin_trylock() will always succeed.
  */
-void __lockfunc lock_kernel(void)
+#ifdef CONFIG_PREEMPT
+static inline void __lock_kernel(void)
 {
-        struct task_struct *task = current;
-        int depth = task->lock_depth + 1;
+        preempt_disable();
+        if (unlikely(!_raw_spin_trylock(&kernel_flag))) {
+                /*
+                 * If preemption was disabled even before this
+                 * was called, there's nothing we can be polite
+                 * about - just spin.
+                 */
+                if (preempt_count() > 1) {
+                        _raw_spin_lock(&kernel_flag);
+                        return;
+                }
 
-        if (likely(!depth))
                 /*
-                 * No recursion worries - we set up lock_depth _after_
+                 * Otherwise, let's wait for the kernel lock
+                 * with preemption enabled..
                  */
-                down(&kernel_sem);
+                do {
+                        preempt_enable();
+                        while (spin_is_locked(&kernel_flag))
+                                cpu_relax();
+                        preempt_disable();
+                } while (!_raw_spin_trylock(&kernel_flag));
+        }
+}
 
-        task->lock_depth = depth;
+#else
+
+/*
+ * Non-preemption case - just get the spinlock
+ */
+static inline void __lock_kernel(void)
+{
+        _raw_spin_lock(&kernel_flag);
 }
+#endif
 
-void __lockfunc unlock_kernel(void)
+static inline void __unlock_kernel(void)
 {
-        struct task_struct *task = current;
+        /*
+         * the BKL is not covered by lockdep, so we open-code the
+         * unlocking sequence (and thus avoid the dep-chain ops):
+         */
+        _raw_spin_unlock(&kernel_flag);
+        preempt_enable();
+}
 
-        BUG_ON(task->lock_depth < 0);
+/*
+ * Getting the big kernel lock.
+ *
+ * This cannot happen asynchronously, so we only need to
+ * worry about other CPU's.
+ */
+void __lockfunc lock_kernel(void)
+{
+        int depth = current->lock_depth+1;
+        if (likely(!depth))
+                __lock_kernel();
+        current->lock_depth = depth;
+}
 
-        if (likely(--task->lock_depth < 0))
-                up(&kernel_sem);
+void __lockfunc unlock_kernel(void)
+{
+        BUG_ON(current->lock_depth < 0);
+        if (likely(--current->lock_depth < 0))
+                __unlock_kernel();
 }
 
 EXPORT_SYMBOL(lock_kernel);