tty_lock: Localise the lock

In each remaining case the tty_lock is associated with a specific tty. This
means we can now lock on a per tty basis. We do need tty_lock_pair() for
the pty case. Uglier but still a step in the right direction.

[fixed up calls in 3 missing drivers - gregkh]

Signed-off-by: Alan Cox <alan@linux.intel.com>
Acked-by: Arnd Bergmann <arnd@arndb.de>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

1 files changed, 45 insertions, 15 deletions

diff --git a/drivers/tty/tty_mutex.c b/drivers/tty/tty_mutex.c
index 9ff986c32a21..69adc80c98cd 100644
--- a/drivers/tty/tty_mutex.c
+++ b/drivers/tty/tty_mutex.c
@@ -4,29 +4,59 @@
 #include <linux/semaphore.h>
 #include <linux/sched.h>
 
-/*
- * The 'big tty mutex'
- *
- * This mutex is taken and released by tty_lock() and tty_unlock(),
- * replacing the older big kernel lock.
- * It can no longer be taken recursively, and does not get
- * released implicitly while sleeping.
- *
- * Don't use in new code.
- */
-static DEFINE_MUTEX(big_tty_mutex);
+/* Legacy tty mutex glue */
 
 /*
  * Getting the big tty mutex.
  */
-void __lockfunc tty_lock(void)
+
+void __lockfunc tty_lock(struct tty_struct *tty)
 {
-        mutex_lock(&big_tty_mutex);
+        if (tty->magic != TTY_MAGIC) {
+                printk(KERN_ERR "L Bad %p\n", tty);
+                WARN_ON(1);
+                return;
+        }
+        tty_kref_get(tty);
+        mutex_lock(&tty->legacy_mutex);
 }
 EXPORT_SYMBOL(tty_lock);
 
-void __lockfunc tty_unlock(void)
+void __lockfunc tty_unlock(struct tty_struct *tty)
 {
-        mutex_unlock(&big_tty_mutex);
+        if (tty->magic != TTY_MAGIC) {
+                printk(KERN_ERR "U Bad %p\n", tty);
+                WARN_ON(1);
+                return;
+        }
+        mutex_unlock(&tty->legacy_mutex);
+        tty_kref_put(tty);
 }
 EXPORT_SYMBOL(tty_unlock);
+
+/*
+ * Getting the big tty mutex for a pair of ttys with lock ordering
+ * On a non pty/tty pair tty2 can be NULL which is just fine.
+ */
+void __lockfunc tty_lock_pair(struct tty_struct *tty,
+                                        struct tty_struct *tty2)
+{
+        if (tty < tty2) {
+                tty_lock(tty);
+                tty_lock(tty2);
+        } else {
+                if (tty2 && tty2 != tty)
+                        tty_lock(tty2);
+                tty_lock(tty);
+        }
+}
+EXPORT_SYMBOL(tty_lock_pair);
+
+void __lockfunc tty_unlock_pair(struct tty_struct *tty,
+                                                struct tty_struct *tty2)
+{
+        tty_unlock(tty);
+        if (tty2 && tty2 != tty)
+                tty_unlock(tty2);
+}
+EXPORT_SYMBOL(tty_unlock_pair);