Merge branch 'x86-debug-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git...

[firefly-linux-kernel-4.4.55.git] / drivers / tty / tty_ldisc.c

diff --git a/drivers/tty/tty_ldisc.c b/drivers/tty/tty_ldisc.c
index 328ff5b544a5622405d98bf6c1da9107bdf74ef6..1afe192bef6a7e8a795c91a3cf38a26615b6f2a1 100644 (file)
--- a/drivers/tty/tty_ldisc.c
+++ b/drivers/tty/tty_ldisc.c
@@ -42,44 +42,6 @@ static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
 /* Line disc dispatch table */
 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
 
-static inline struct tty_ldisc *get_ldisc(struct tty_ldisc *ld)
-{
-       if (ld)
-               atomic_inc(&ld->users);
-       return ld;
-}
-
-static void put_ldisc(struct tty_ldisc *ld)
-{
-       unsigned long flags;
-
-       if (WARN_ON_ONCE(!ld))
-               return;
-
-       /*
-        * If this is the last user, free the ldisc, and
-        * release the ldisc ops.
-        *
-        * We really want an "atomic_dec_and_raw_lock_irqsave()",
-        * but we don't have it, so this does it by hand.
-        */
-       raw_spin_lock_irqsave(&tty_ldisc_lock, flags);
-       if (atomic_dec_and_test(&ld->users)) {
-               struct tty_ldisc_ops *ldo = ld->ops;
-
-               ldo->refcount--;
-               module_put(ldo->owner);
-               raw_spin_unlock_irqrestore(&tty_ldisc_lock, flags);
-
-               kfree(ld);
-               return;
-       }
-       raw_spin_unlock_irqrestore(&tty_ldisc_lock, flags);
-
-       if (waitqueue_active(&ld->wq_idle))
-               wake_up(&ld->wq_idle);
-}
-
 /**
  *     tty_register_ldisc      -       install a line discipline
  *     @disc: ldisc number
@@ -217,6 +179,29 @@ static struct tty_ldisc *tty_ldisc_get(int disc)
        return ld;
 }
 
+/**
+ *     tty_ldisc_put           -       release the ldisc
+ *
+ *     Complement of tty_ldisc_get().
+ */
+static inline void tty_ldisc_put(struct tty_ldisc *ld)
+{
+       unsigned long flags;
+
+       if (WARN_ON_ONCE(!ld))
+               return;
+
+       raw_spin_lock_irqsave(&tty_ldisc_lock, flags);
+
+       /* unreleased reader reference(s) will cause this WARN */
+       WARN_ON(!atomic_dec_and_test(&ld->users));
+
+       ld->ops->refcount--;
+       module_put(ld->ops->owner);
+       kfree(ld);
+       raw_spin_unlock_irqrestore(&tty_ldisc_lock, flags);
+}
+
 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
 {
        return (*pos < NR_LDISCS) ? pos : NULL;
@@ -265,24 +250,6 @@ const struct file_operations tty_ldiscs_proc_fops = {
        .release        = seq_release,
 };
 
-/**
- *     tty_ldisc_assign        -       set ldisc on a tty
- *     @tty: tty to assign
- *     @ld: line discipline
- *
- *     Install an instance of a line discipline into a tty structure. The
- *     ldisc must have a reference count above zero to ensure it remains.
- *     The tty instance refcount starts at zero.
- *
- *     Locking:
- *             Caller must hold references
- */
-
-static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
-{
-       tty->ldisc = ld;
-}
-
 /**
  *     tty_ldisc_try           -       internal helper
  *     @tty: the tty
@@ -300,10 +267,13 @@ static struct tty_ldisc *tty_ldisc_try(struct tty_struct *tty)
        unsigned long flags;
        struct tty_ldisc *ld;
 
+       /* FIXME: this allows reference acquire after TTY_LDISC is cleared */
        raw_spin_lock_irqsave(&tty_ldisc_lock, flags);
        ld = NULL;
-       if (test_bit(TTY_LDISC, &tty->flags))
-               ld = get_ldisc(tty->ldisc);
+       if (test_bit(TTY_LDISC, &tty->flags) && tty->ldisc) {
+               ld = tty->ldisc;
+               atomic_inc(&ld->users);
+       }
        raw_spin_unlock_irqrestore(&tty_ldisc_lock, flags);
        return ld;
 }
@@ -363,14 +333,23 @@ EXPORT_SYMBOL_GPL(tty_ldisc_ref);
 
 void tty_ldisc_deref(struct tty_ldisc *ld)
 {
-       put_ldisc(ld);
-}
-EXPORT_SYMBOL_GPL(tty_ldisc_deref);
+       unsigned long flags;
 
-static inline void tty_ldisc_put(struct tty_ldisc *ld)
-{
-       put_ldisc(ld);
+       if (WARN_ON_ONCE(!ld))
+               return;
+
+       raw_spin_lock_irqsave(&tty_ldisc_lock, flags);
+       /*
+        * WARNs if one-too-many reader references were released
+        * - the last reference must be released with tty_ldisc_put
+        */
+       WARN_ON(atomic_dec_and_test(&ld->users));
+       raw_spin_unlock_irqrestore(&tty_ldisc_lock, flags);
+
+       if (waitqueue_active(&ld->wq_idle))
+               wake_up(&ld->wq_idle);
 }
+EXPORT_SYMBOL_GPL(tty_ldisc_deref);
 
 /**
  *     tty_ldisc_enable        -       allow ldisc use
@@ -491,7 +470,7 @@ static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
        /* There is an outstanding reference here so this is safe */
        old = tty_ldisc_get(old->ops->num);
        WARN_ON(IS_ERR(old));
-       tty_ldisc_assign(tty, old);
+       tty->ldisc = old;
        tty_set_termios_ldisc(tty, old->ops->num);
        if (tty_ldisc_open(tty, old) < 0) {
                tty_ldisc_put(old);
@@ -499,7 +478,7 @@ static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
                new_ldisc = tty_ldisc_get(N_TTY);
                if (IS_ERR(new_ldisc))
                        panic("n_tty: get");
-               tty_ldisc_assign(tty, new_ldisc);
+               tty->ldisc = new_ldisc;
                tty_set_termios_ldisc(tty, N_TTY);
                r = tty_ldisc_open(tty, new_ldisc);
                if (r < 0)
@@ -646,15 +625,6 @@ int tty_set_ldisc(struct tty_struct *tty, int ldisc)
                return 0;
        }
 
-       tty_unlock(tty);
-       /*
-        *      Problem: What do we do if this blocks ?
-        *      We could deadlock here
-        */
-
-       tty_wait_until_sent(tty, 0);
-
-       tty_lock(tty);
        mutex_lock(&tty->ldisc_mutex);
 
        /*
@@ -728,7 +698,7 @@ int tty_set_ldisc(struct tty_struct *tty, int ldisc)
        tty_ldisc_close(tty, o_ldisc);
 
        /* Now set up the new line discipline. */
-       tty_ldisc_assign(tty, new_ldisc);
+       tty->ldisc = new_ldisc;
        tty_set_termios_ldisc(tty, ldisc);
 
        retval = tty_ldisc_open(tty, new_ldisc);
@@ -802,11 +772,10 @@ static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
 
        tty_ldisc_close(tty, tty->ldisc);
        tty_ldisc_put(tty->ldisc);
-       tty->ldisc = NULL;
        /*
         *      Switch the line discipline back
         */
-       tty_ldisc_assign(tty, ld);
+       tty->ldisc = ld;
        tty_set_termios_ldisc(tty, ldisc);
 
        return 0;
@@ -989,7 +958,7 @@ void tty_ldisc_init(struct tty_struct *tty)
        struct tty_ldisc *ld = tty_ldisc_get(N_TTY);
        if (IS_ERR(ld))
                panic("n_tty: init_tty");
-       tty_ldisc_assign(tty, ld);
+       tty->ldisc = ld;
 }
 
 /**
@@ -1001,8 +970,8 @@ void tty_ldisc_init(struct tty_struct *tty)
  */
 void tty_ldisc_deinit(struct tty_struct *tty)
 {
-       put_ldisc(tty->ldisc);
-       tty_ldisc_assign(tty, NULL);
+       tty_ldisc_put(tty->ldisc);
+       tty->ldisc = NULL;
 }
 
 void tty_ldisc_begin(void)