tty: Add safe tty throttle/unthrottle functions

The tty driver can become stuck throttled due to race conditions
between throttle and unthrottle, when the decision to throttle
or unthrottle is conditional. The following example helps to
illustrate the race:

  CPU 0                        |  CPU 1
                               |
if (condition A)               |
                               | <processing such that A not true>
                               | if (!condition A)
                               |     unthrottle()
    throttle()                 |
                               |

Note the converse is also possible; ie.,

  CPU 0                        |  CPU 1
                               |
                               | if (!condition A)
<processing such that A true>  |
if (condition A)               |
    throttle()                 |
                               |     unthrottle()
                               |

Add new throttle/unthrottle functions based on the familiar model
of task state and schedule/wake. For example,

    while (1) {
        tty_set_flow_change(tty, TTY_THROTTLE_SAFE);
        if (!condition)
            break;
        if (!tty_throttle_safe(tty))
            break;
    }
    __tty_set_flow_change(tty, 0);

In this example, if an unthrottle occurs after the condition is
evaluated but before tty_throttle_safe(), then tty_throttle_safe()
will return non-zero, looping and forcing the re-evaluation of
condition.

Reported-by: Vincent Pillet <vincentx.pillet@intel.com>
Signed-off-by: Peter Hurley <peter@hurleysoftware.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/tty/tty_ioctl.c b/drivers/tty/tty_ioctl.c
index d58b92cc187cc21b05229ee9cdd7e936519fffb8..132d452578bbd948639c6247735fb58965fa32c9 100644 (file)
--- a/drivers/tty/tty_ioctl.c
+++ b/drivers/tty/tty_ioctl.c
@@ -106,6 +106,7 @@ void tty_throttle(struct tty_struct *tty)
        if (!test_and_set_bit(TTY_THROTTLED, &tty->flags) &&
            tty->ops->throttle)
                tty->ops->throttle(tty);
+       tty->flow_change = 0;
        mutex_unlock(&tty->termios_mutex);
 }
 EXPORT_SYMBOL(tty_throttle);
@@ -129,10 +130,73 @@ void tty_unthrottle(struct tty_struct *tty)
        if (test_and_clear_bit(TTY_THROTTLED, &tty->flags) &&
            tty->ops->unthrottle)
                tty->ops->unthrottle(tty);
+       tty->flow_change = 0;
        mutex_unlock(&tty->termios_mutex);
 }
 EXPORT_SYMBOL(tty_unthrottle);
 
+/**
+ *     tty_throttle_safe       -       flow control
+ *     @tty: terminal
+ *
+ *     Similar to tty_throttle() but will only attempt throttle
+ *     if tty->flow_change is TTY_THROTTLE_SAFE. Prevents an accidental
+ *     throttle due to race conditions when throttling is conditional
+ *     on factors evaluated prior to throttling.
+ *
+ *     Returns 0 if tty is throttled (or was already throttled)
+ */
+
+int tty_throttle_safe(struct tty_struct *tty)
+{
+       int ret = 0;
+
+       mutex_lock(&tty->termios_mutex);
+       if (!test_bit(TTY_THROTTLED, &tty->flags)) {
+               if (tty->flow_change != TTY_THROTTLE_SAFE)
+                       ret = 1;
+               else {
+                       __set_bit(TTY_THROTTLED, &tty->flags);
+                       if (tty->ops->throttle)
+                               tty->ops->throttle(tty);
+               }
+       }
+       mutex_unlock(&tty->termios_mutex);
+
+       return ret;
+}
+
+/**
+ *     tty_unthrottle_safe     -       flow control
+ *     @tty: terminal
+ *
+ *     Similar to tty_unthrottle() but will only attempt unthrottle
+ *     if tty->flow_change is TTY_UNTHROTTLE_SAFE. Prevents an accidental
+ *     unthrottle due to race conditions when unthrottling is conditional
+ *     on factors evaluated prior to unthrottling.
+ *
+ *     Returns 0 if tty is unthrottled (or was already unthrottled)
+ */
+
+int tty_unthrottle_safe(struct tty_struct *tty)
+{
+       int ret = 0;
+
+       mutex_lock(&tty->termios_mutex);
+       if (test_bit(TTY_THROTTLED, &tty->flags)) {
+               if (tty->flow_change != TTY_UNTHROTTLE_SAFE)
+                       ret = 1;
+               else {
+                       __clear_bit(TTY_THROTTLED, &tty->flags);
+                       if (tty->ops->unthrottle)
+                               tty->ops->unthrottle(tty);
+               }
+       }
+       mutex_unlock(&tty->termios_mutex);
+
+       return ret;
+}
+
 /**
  *     tty_wait_until_sent     -       wait for I/O to finish
  *     @tty: tty we are waiting for

diff --git a/include/linux/tty.h b/include/linux/tty.h
index c75d886b03078dce545a10ea83ac654e0a4335c4..189ca80494d13816d1b79c1a645ba5d1eae82e46 100644 (file)
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -258,6 +258,7 @@ struct tty_struct {
        unsigned char warned:1;
        unsigned char ctrl_status;      /* ctrl_lock */
        unsigned int receive_room;      /* Bytes free for queue */
+       int flow_change;
 
        struct tty_struct *link;
        struct fasync_struct *fasync;
@@ -318,6 +319,21 @@ struct tty_file_private {
 
 #define TTY_WRITE_FLUSH(tty) tty_write_flush((tty))
 
+/* Values for tty->flow_change */
+#define TTY_THROTTLE_SAFE 1
+#define TTY_UNTHROTTLE_SAFE 2
+
+static inline void __tty_set_flow_change(struct tty_struct *tty, int val)
+{
+       tty->flow_change = val;
+}
+
+static inline void tty_set_flow_change(struct tty_struct *tty, int val)
+{
+       tty->flow_change = val;
+       smp_mb();
+}
+
 #ifdef CONFIG_TTY
 extern void console_init(void);
 extern void tty_kref_put(struct tty_struct *tty);
@@ -400,6 +416,8 @@ extern int tty_write_room(struct tty_struct *tty);
 extern void tty_driver_flush_buffer(struct tty_struct *tty);
 extern void tty_throttle(struct tty_struct *tty);
 extern void tty_unthrottle(struct tty_struct *tty);
+extern int tty_throttle_safe(struct tty_struct *tty);
+extern int tty_unthrottle_safe(struct tty_struct *tty);
 extern int tty_do_resize(struct tty_struct *tty, struct winsize *ws);
 extern void tty_driver_remove_tty(struct tty_driver *driver,
                                  struct tty_struct *tty);