1 files changed, 95 insertions, 170 deletions

diff --git a/drivers/tty/tty_buffer.c b/drivers/tty/tty_buffer.c
index 45d916198f7..6c9b7cd6778 100644
--- a/drivers/tty/tty_buffer.c
+++ b/drivers/tty/tty_buffer.c
@@ -27,21 +27,19 @@
  *      Locking: none
  */
 
-void tty_buffer_free_all(struct tty_port *port)
+void tty_buffer_free_all(struct tty_struct *tty)
 {
-        struct tty_bufhead *buf = &port->buf;
         struct tty_buffer *thead;
-
-        while ((thead = buf->head) != NULL) {
-                buf->head = thead->next;
+        while ((thead = tty->buf.head) != NULL) {
+                tty->buf.head = thead->next;
                 kfree(thead);
         }
-        while ((thead = buf->free) != NULL) {
-                buf->free = thead->next;
+        while ((thead = tty->buf.free) != NULL) {
+                tty->buf.free = thead->next;
                 kfree(thead);
         }
-        buf->tail = NULL;
-        buf->memory_used = 0;
+        tty->buf.tail = NULL;
+        tty->buf.memory_used = 0;
 }
 
 /**
@@ -56,11 +54,11 @@ void tty_buffer_free_all(struct tty_port *port)
  *      Locking: Caller must hold tty->buf.lock
  */
 
-static struct tty_buffer *tty_buffer_alloc(struct tty_port *port, size_t size)
+static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
 {
         struct tty_buffer *p;
 
-        if (port->buf.memory_used + size > 65536)
+        if (tty->buf.memory_used + size > 65536)
                 return NULL;
         p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
         if (p == NULL)
@@ -72,7 +70,7 @@ static struct tty_buffer *tty_buffer_alloc(struct tty_port *port, size_t size)
         p->read = 0;
         p->char_buf_ptr = (char *)(p->data);
         p->flag_buf_ptr = (unsigned char *)p->char_buf_ptr + size;
-        port->buf.memory_used += size;
+        tty->buf.memory_used += size;
         return p;
 }
 
@@ -87,19 +85,17 @@ static struct tty_buffer *tty_buffer_alloc(struct tty_port *port, size_t size)
  *      Locking: Caller must hold tty->buf.lock
  */
 
-static void tty_buffer_free(struct tty_port *port, struct tty_buffer *b)
+static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
 {
-        struct tty_bufhead *buf = &port->buf;
-
         /* Dumb strategy for now - should keep some stats */
-        buf->memory_used -= b->size;
-        WARN_ON(buf->memory_used < 0);
+        tty->buf.memory_used -= b->size;
+        WARN_ON(tty->buf.memory_used < 0);
 
         if (b->size >= 512)
                 kfree(b);
         else {
-                b->next = buf->free;
-                buf->free = b;
+                b->next = tty->buf.free;
+                tty->buf.free = b;
         }
 }
 
@@ -114,16 +110,15 @@ static void tty_buffer_free(struct tty_port *port, struct tty_buffer *b)
  *      Locking: Caller must hold tty->buf.lock
  */
 
-static void __tty_buffer_flush(struct tty_port *port)
+static void __tty_buffer_flush(struct tty_struct *tty)
 {
-        struct tty_bufhead *buf = &port->buf;
         struct tty_buffer *thead;
 
-        while ((thead = buf->head) != NULL) {
-                buf->head = thead->next;
-                tty_buffer_free(port, thead);
+        while ((thead = tty->buf.head) != NULL) {
+                tty->buf.head = thead->next;
+                tty_buffer_free(tty, thead);
         }
-        buf->tail = NULL;
+        tty->buf.tail = NULL;
 }
 
 /**
@@ -139,24 +134,21 @@ static void __tty_buffer_flush(struct tty_port *port)
 
 void tty_buffer_flush(struct tty_struct *tty)
 {
-        struct tty_port *port = tty->port;
-        struct tty_bufhead *buf = &port->buf;
         unsigned long flags;
-
-        spin_lock_irqsave(&buf->lock, flags);
+        spin_lock_irqsave(&tty->buf.lock, flags);
 
         /* If the data is being pushed to the tty layer then we can't
            process it here. Instead set a flag and the flush_to_ldisc
            path will process the flush request before it exits */
-        if (test_bit(TTYP_FLUSHING, &port->iflags)) {
-                set_bit(TTYP_FLUSHPENDING, &port->iflags);
-                spin_unlock_irqrestore(&buf->lock, flags);
+        if (test_bit(TTY_FLUSHING, &tty->flags)) {
+                set_bit(TTY_FLUSHPENDING, &tty->flags);
+                spin_unlock_irqrestore(&tty->buf.lock, flags);
                 wait_event(tty->read_wait,
-                                test_bit(TTYP_FLUSHPENDING, &port->iflags) == 0);
+                                test_bit(TTY_FLUSHPENDING, &tty->flags) == 0);
                 return;
         } else
-                __tty_buffer_flush(port);
-        spin_unlock_irqrestore(&buf->lock, flags);
+                __tty_buffer_flush(tty);
+        spin_unlock_irqrestore(&tty->buf.lock, flags);
 }
 
 /**
@@ -171,9 +163,9 @@ void tty_buffer_flush(struct tty_struct *tty)
  *      Locking: Caller must hold tty->buf.lock
  */
 
-static struct tty_buffer *tty_buffer_find(struct tty_port *port, size_t size)
+static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
 {
-        struct tty_buffer **tbh = &port->buf.free;
+        struct tty_buffer **tbh = &tty->buf.free;
         while ((*tbh) != NULL) {
                 struct tty_buffer *t = *tbh;
                 if (t->size >= size) {
@@ -182,78 +174,60 @@ static struct tty_buffer *tty_buffer_find(struct tty_port *port, size_t size)
                         t->used = 0;
                         t->commit = 0;
                         t->read = 0;
-                        port->buf.memory_used += t->size;
+                        tty->buf.memory_used += t->size;
                         return t;
                 }
                 tbh = &((*tbh)->next);
         }
         /* Round the buffer size out */
         size = (size + 0xFF) & ~0xFF;
-        return tty_buffer_alloc(port, size);
+        return tty_buffer_alloc(tty, size);
         /* Should possibly check if this fails for the largest buffer we
            have queued and recycle that ? */
 }
+
 /**
- *      __tty_buffer_request_room               -       grow tty buffer if needed
+ *      tty_buffer_request_room         -       grow tty buffer if needed
  *      @tty: tty structure
  *      @size: size desired
  *
  *      Make at least size bytes of linear space available for the tty
  *      buffer. If we fail return the size we managed to find.
- *      Locking: Caller must hold port->buf.lock
+ *
+ *      Locking: Takes tty->buf.lock
  */
-static int __tty_buffer_request_room(struct tty_port *port, size_t size)
+int tty_buffer_request_room(struct tty_struct *tty, size_t size)
 {
-        struct tty_bufhead *buf = &port->buf;
         struct tty_buffer *b, *n;
         int left;
+        unsigned long flags;
+
+        spin_lock_irqsave(&tty->buf.lock, flags);
+
         /* OPTIMISATION: We could keep a per tty "zero" sized buffer to
            remove this conditional if its worth it. This would be invisible
            to the callers */
-        b = buf->tail;
-        if (b != NULL)
+        if ((b = tty->buf.tail) != NULL)
                 left = b->size - b->used;
         else
                 left = 0;
 
         if (left < size) {
                 /* This is the slow path - looking for new buffers to use */
-                if ((n = tty_buffer_find(port, size)) != NULL) {
+                if ((n = tty_buffer_find(tty, size)) != NULL) {
                         if (b != NULL) {
                                 b->next = n;
                                 b->commit = b->used;
                         } else
-                                buf->head = n;
-                        buf->tail = n;
+                                tty->buf.head = n;
+                        tty->buf.tail = n;
                 } else
                         size = left;
         }
 
+        spin_unlock_irqrestore(&tty->buf.lock, flags);
         return size;
 }
-
-
-/**
- *      tty_buffer_request_room         -       grow tty buffer if needed
- *      @tty: tty structure
- *      @size: size desired
- *
- *      Make at least size bytes of linear space available for the tty
- *      buffer. If we fail return the size we managed to find.
- *
- *      Locking: Takes port->buf.lock
- */
-int tty_buffer_request_room(struct tty_struct *tty, size_t size)
-{
-        struct tty_port *port = tty->port;
-        unsigned long flags;
-        int length;
-
-        spin_lock_irqsave(&port->buf.lock, flags);
-        length = __tty_buffer_request_room(port, size);
-        spin_unlock_irqrestore(&port->buf.lock, flags);
-        return length;
-}
 EXPORT_SYMBOL_GPL(tty_buffer_request_room);
 
 /**
@@ -266,32 +240,23 @@ EXPORT_SYMBOL_GPL(tty_buffer_request_room);
  *      Queue a series of bytes to the tty buffering. All the characters
  *      passed are marked with the supplied flag. Returns the number added.
  *
- *      Locking: Called functions may take port->buf.lock
+ *      Locking: Called functions may take tty->buf.lock
  */
 
 int tty_insert_flip_string_fixed_flag(struct tty_struct *tty,
                 const unsigned char *chars, char flag, size_t size)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
         int copied = 0;
         do {
                 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
-                int space;
-                unsigned long flags;
-                struct tty_buffer *tb;
-
-                spin_lock_irqsave(&buf->lock, flags);
-                space = __tty_buffer_request_room(tty->port, goal);
-                tb = buf->tail;
+                int space = tty_buffer_request_room(tty, goal);
+                struct tty_buffer *tb = tty->buf.tail;
                 /* If there is no space then tb may be NULL */
-                if (unlikely(space == 0)) {
-                        spin_unlock_irqrestore(&buf->lock, flags);
+                if (unlikely(space == 0))
                         break;
-                }
                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
                 memset(tb->flag_buf_ptr + tb->used, flag, space);
                 tb->used += space;
-                spin_unlock_irqrestore(&buf->lock, flags);
                 copied += space;
                 chars += space;
                 /* There is a small chance that we need to split the data over
@@ -312,32 +277,23 @@ EXPORT_SYMBOL(tty_insert_flip_string_fixed_flag);
  *      the flags array indicates the status of the character. Returns the
  *      number added.
  *
- *      Locking: Called functions may take port->buf.lock
+ *      Locking: Called functions may take tty->buf.lock
  */
 
 int tty_insert_flip_string_flags(struct tty_struct *tty,
                 const unsigned char *chars, const char *flags, size_t size)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
         int copied = 0;
         do {
                 int goal = min_t(size_t, size - copied, TTY_BUFFER_PAGE);
-                int space;
-                unsigned long __flags;
-                struct tty_buffer *tb;
-
-                spin_lock_irqsave(&buf->lock, __flags);
-                space = __tty_buffer_request_room(tty->port, goal);
-                tb = buf->tail;
+                int space = tty_buffer_request_room(tty, goal);
+                struct tty_buffer *tb = tty->buf.tail;
                 /* If there is no space then tb may be NULL */
-                if (unlikely(space == 0)) {
-                        spin_unlock_irqrestore(&buf->lock, __flags);
+                if (unlikely(space == 0))
                         break;
-                }
                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
                 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
                 tb->used += space;
-                spin_unlock_irqrestore(&buf->lock, __flags);
                 copied += space;
                 chars += space;
                 flags += space;
@@ -355,23 +311,18 @@ EXPORT_SYMBOL(tty_insert_flip_string_flags);
  *      Takes any pending buffers and transfers their ownership to the
  *      ldisc side of the queue. It then schedules those characters for
  *      processing by the line discipline.
- *      Note that this function can only be used when the low_latency flag
- *      is unset. Otherwise the workqueue won't be flushed.
  *
- *      Locking: Takes port->buf.lock
+ *      Locking: Takes tty->buf.lock
  */
 
 void tty_schedule_flip(struct tty_struct *tty)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
         unsigned long flags;
-        WARN_ON(tty->low_latency);
-
-        spin_lock_irqsave(&buf->lock, flags);
-        if (buf->tail != NULL)
-                buf->tail->commit = buf->tail->used;
-        spin_unlock_irqrestore(&buf->lock, flags);
-        schedule_work(&buf->work);
+        spin_lock_irqsave(&tty->buf.lock, flags);
+        if (tty->buf.tail != NULL)
+                tty->buf.tail->commit = tty->buf.tail->used;
+        spin_unlock_irqrestore(&tty->buf.lock, flags);
+        schedule_work(&tty->buf.work);
 }
 EXPORT_SYMBOL(tty_schedule_flip);
 
@@ -387,27 +338,19 @@ EXPORT_SYMBOL(tty_schedule_flip);
  *      that need their own block copy routines into the buffer. There is no
  *      guarantee the buffer is a DMA target!
  *
- *      Locking: May call functions taking port->buf.lock
+ *      Locking: May call functions taking tty->buf.lock
  */
 
 int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars,
-                size_t size)
+                                                                size_t size)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
-        int space;
-        unsigned long flags;
-        struct tty_buffer *tb;
-
-        spin_lock_irqsave(&buf->lock, flags);
-        space = __tty_buffer_request_room(tty->port, size);
-
-        tb = buf->tail;
+        int space = tty_buffer_request_room(tty, size);
         if (likely(space)) {
+                struct tty_buffer *tb = tty->buf.tail;
                 *chars = tb->char_buf_ptr + tb->used;
                 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
                 tb->used += space;
         }
-        spin_unlock_irqrestore(&buf->lock, flags);
         return space;
 }
 EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
@@ -425,27 +368,19 @@ EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
  *      that need their own block copy routines into the buffer. There is no
  *      guarantee the buffer is a DMA target!
  *
- *      Locking: May call functions taking port->buf.lock
+ *      Locking: May call functions taking tty->buf.lock
  */
 
 int tty_prepare_flip_string_flags(struct tty_struct *tty,
                         unsigned char **chars, char **flags, size_t size)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
-        int space;
-        unsigned long __flags;
-        struct tty_buffer *tb;
-
-        spin_lock_irqsave(&buf->lock, __flags);
-        space = __tty_buffer_request_room(tty->port, size);
-
-        tb = buf->tail;
+        int space = tty_buffer_request_room(tty, size);
         if (likely(space)) {
+                struct tty_buffer *tb = tty->buf.tail;
                 *chars = tb->char_buf_ptr + tb->used;
                 *flags = tb->flag_buf_ptr + tb->used;
                 tb->used += space;
         }
-        spin_unlock_irqrestore(&buf->lock, __flags);
         return space;
 }
 EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
@@ -466,25 +401,20 @@ EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
 
 static void flush_to_ldisc(struct work_struct *work)
 {
-        struct tty_port *port = container_of(work, struct tty_port, buf.work);
-        struct tty_bufhead *buf = &port->buf;
-        struct tty_struct *tty;
+        struct tty_struct *tty =
+                container_of(work, struct tty_struct, buf.work);
         unsigned long   flags;
         struct tty_ldisc *disc;
 
-        tty = port->itty;
-        if (WARN_RATELIMIT(tty == NULL, "tty is NULL\n"))
-                return;
-
         disc = tty_ldisc_ref(tty);
         if (disc == NULL)       /*  !TTY_LDISC */
                 return;
 
-        spin_lock_irqsave(&buf->lock, flags);
+        spin_lock_irqsave(&tty->buf.lock, flags);
 
-        if (!test_and_set_bit(TTYP_FLUSHING, &port->iflags)) {
+        if (!test_and_set_bit(TTY_FLUSHING, &tty->flags)) {
                 struct tty_buffer *head;
-                while ((head = buf->head) != NULL) {
+                while ((head = tty->buf.head) != NULL) {
                         int count;
                         char *char_buf;
                         unsigned char *flag_buf;
@@ -493,14 +423,14 @@ static void flush_to_ldisc(struct work_struct *work)
                         if (!count) {
                                 if (head->next == NULL)
                                         break;
-                                buf->head = head->next;
-                                tty_buffer_free(port, head);
+                                tty->buf.head = head->next;
+                                tty_buffer_free(tty, head);
                                 continue;
                         }
                         /* Ldisc or user is trying to flush the buffers
                            we are feeding to the ldisc, stop feeding the
                            line discipline as we want to empty the queue */
-                        if (test_bit(TTYP_FLUSHPENDING, &port->iflags))
+                        if (test_bit(TTY_FLUSHPENDING, &tty->flags))
                                 break;
                         if (!tty->receive_room)
                                 break;
@@ -509,22 +439,22 @@ static void flush_to_ldisc(struct work_struct *work)
                         char_buf = head->char_buf_ptr + head->read;
                         flag_buf = head->flag_buf_ptr + head->read;
                         head->read += count;
-                        spin_unlock_irqrestore(&buf->lock, flags);
+                        spin_unlock_irqrestore(&tty->buf.lock, flags);
                         disc->ops->receive_buf(tty, char_buf,
                                                         flag_buf, count);
-                        spin_lock_irqsave(&buf->lock, flags);
+                        spin_lock_irqsave(&tty->buf.lock, flags);
                 }
-                clear_bit(TTYP_FLUSHING, &port->iflags);
+                clear_bit(TTY_FLUSHING, &tty->flags);
         }
 
         /* We may have a deferred request to flush the input buffer,
            if so pull the chain under the lock and empty the queue */
-        if (test_bit(TTYP_FLUSHPENDING, &port->iflags)) {
-                __tty_buffer_flush(port);
-                clear_bit(TTYP_FLUSHPENDING, &port->iflags);
+        if (test_bit(TTY_FLUSHPENDING, &tty->flags)) {
+                __tty_buffer_flush(tty);
+                clear_bit(TTY_FLUSHPENDING, &tty->flags);
                 wake_up(&tty->read_wait);
         }
-        spin_unlock_irqrestore(&buf->lock, flags);
+        spin_unlock_irqrestore(&tty->buf.lock, flags);
 
         tty_ldisc_deref(disc);
 }
@@ -539,8 +469,7 @@ static void flush_to_ldisc(struct work_struct *work)
  */
 void tty_flush_to_ldisc(struct tty_struct *tty)
 {
-        if (!tty->low_latency)
-                flush_work(&tty->port->buf.work);
+        flush_work(&tty->buf.work);
 }
 
 /**
@@ -558,18 +487,16 @@ void tty_flush_to_ldisc(struct tty_struct *tty)
 
 void tty_flip_buffer_push(struct tty_struct *tty)
 {
-        struct tty_bufhead *buf = &tty->port->buf;
         unsigned long flags;
-
-        spin_lock_irqsave(&buf->lock, flags);
-        if (buf->tail != NULL)
-                buf->tail->commit = buf->tail->used;
-        spin_unlock_irqrestore(&buf->lock, flags);
+        spin_lock_irqsave(&tty->buf.lock, flags);
+        if (tty->buf.tail != NULL)
+                tty->buf.tail->commit = tty->buf.tail->used;
+        spin_unlock_irqrestore(&tty->buf.lock, flags);
 
         if (tty->low_latency)
-                flush_to_ldisc(&buf->work);
+                flush_to_ldisc(&tty->buf.work);
         else
-                schedule_work(&buf->work);
+                schedule_work(&tty->buf.work);
 }
 EXPORT_SYMBOL(tty_flip_buffer_push);
 
@@ -583,15 +510,13 @@ EXPORT_SYMBOL(tty_flip_buffer_push);
  *      Locking: none
  */
 
-void tty_buffer_init(struct tty_port *port)
+void tty_buffer_init(struct tty_struct *tty)
 {
-        struct tty_bufhead *buf = &port->buf;
-
-        spin_lock_init(&buf->lock);
-        buf->head = NULL;
-        buf->tail = NULL;
-        buf->free = NULL;
-        buf->memory_used = 0;
-        INIT_WORK(&buf->work, flush_to_ldisc);
+        spin_lock_init(&tty->buf.lock);
+        tty->buf.head = NULL;
+        tty->buf.tail = NULL;
+        tty->buf.free = NULL;
+        tty->buf.memory_used = 0;
+        INIT_WORK(&tty->buf.work, flush_to_ldisc);
 }