tty_io: drag screaming into coding style compliance

Signed-off-by: Alan Cox <alan@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 283 insertions, 278 deletions

diff --git a/drivers/char/tty_io.c b/drivers/char/tty_io.c
index 79c86c47947f..613ec816ce60 100644
--- a/drivers/char/tty_io.c
+++ b/drivers/char/tty_io.c
@@ -19,7 +19,7 @@
  * Also restructured routines so that there is more of a separation
  * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
  * the low-level tty routines (serial.c, pty.c, console.c).  This
- * makes for cleaner and more compact code.  -TYT, 9/17/92 
+ * makes for cleaner and more compact code.  -TYT, 9/17/92
  *
  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
  * which can be dynamically activated and de-activated by the line
@@ -41,7 +41,7 @@
  *
  * New TIOCLINUX variants added.
  *      -- mj@k332.feld.cvut.cz, 19-Nov-95
- * 
+ *
  * Restrict vt switching via ioctl()
  *      -- grif@cs.ucr.edu, 5-Dec-95
  *
@@ -62,7 +62,8 @@
  *      -- Russell King <rmk@arm.linux.org.uk>
  *
  * Move do_SAK() into process context.  Less stack use in devfs functions.
- * alloc_tty_struct() always uses kmalloc() -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
+ * alloc_tty_struct() always uses kmalloc()
+ *                       -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
  */
 
 #include <linux/types.h>
@@ -126,7 +127,7 @@ EXPORT_SYMBOL(tty_std_termios);
 /* This list gets poked at by procfs and various bits of boot up code. This
    could do with some rationalisation such as pulling the tty proc function
    into this file */
-   
+
 LIST_HEAD(tty_drivers);                 /* linked list of tty drivers */
 
 /* Mutex to protect creating and releasing a tty. This is shared with
@@ -136,7 +137,7 @@ EXPORT_SYMBOL(tty_mutex);
 
 #ifdef CONFIG_UNIX98_PTYS
 extern struct tty_driver *ptm_driver;   /* Unix98 pty masters; for /dev/ptmx */
-extern int pty_limit;           /* Config limit on Unix98 ptys */
+extern int pty_limit;                   /* Config limit on Unix98 ptys */
 static DEFINE_IDR(allocated_ptys);
 static DEFINE_MUTEX(allocated_ptys_lock);
 static int ptmx_open(struct inode *, struct file *);
@@ -146,19 +147,20 @@ static void initialize_tty_struct(struct tty_struct *tty);
 
 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
-ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
+ssize_t redirected_tty_write(struct file *, const char __user *,
+                                                        size_t, loff_t *);
 static unsigned int tty_poll(struct file *, poll_table *);
 static int tty_open(struct inode *, struct file *);
 static int tty_release(struct inode *, struct file *);
-int tty_ioctl(struct inode * inode, struct file * file,
+int tty_ioctl(struct inode *inode, struct file *file,
               unsigned int cmd, unsigned long arg);
 #ifdef CONFIG_COMPAT
-static long tty_compat_ioctl(struct file * file, unsigned int cmd,
+static long tty_compat_ioctl(struct file *file, unsigned int cmd,
                                 unsigned long arg);
 #else
 #define tty_compat_ioctl NULL
 #endif
-static int tty_fasync(int fd, struct file * filp, int on);
+static int tty_fasync(int fd, struct file *filp, int on);
 static void release_tty(struct tty_struct *tty, int idx);
 static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
 static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
@@ -244,7 +246,7 @@ static int check_tty_count(struct tty_struct *tty, const char *routine)
 #ifdef CHECK_TTY_COUNT
         struct list_head *p;
         int count = 0;
-        
+
         file_list_lock();
         list_for_each(p, &tty->tty_files) {
                 count++;
@@ -281,11 +283,11 @@ static int check_tty_count(struct tty_struct *tty, const char *routine)
 static void tty_buffer_free_all(struct tty_struct *tty)
 {
         struct tty_buffer *thead;
-        while((thead = tty->buf.head) != NULL) {
+        while ((thead = tty->buf.head) != NULL) {
                 tty->buf.head = thead->next;
                 kfree(thead);
         }
-        while((thead = tty->buf.free) != NULL) {
+        while ((thead = tty->buf.free) != NULL) {
                 tty->buf.free = thead->next;
                 kfree(thead);
         }
@@ -331,7 +333,7 @@ static struct tty_buffer *tty_buffer_alloc(struct tty_struct *tty, size_t size)
         if (tty->buf.memory_used + size > 65536)
                 return NULL;
         p = kmalloc(sizeof(struct tty_buffer) + 2 * size, GFP_ATOMIC);
-        if(p == NULL)
+        if (p == NULL)
                 return NULL;
         p->used = 0;
         p->size = size;
@@ -361,7 +363,7 @@ static void tty_buffer_free(struct tty_struct *tty, struct tty_buffer *b)
         tty->buf.memory_used -= b->size;
         WARN_ON(tty->buf.memory_used < 0);
 
-        if(b->size >= 512)
+        if (b->size >= 512)
                 kfree(b);
         else {
                 b->next = tty->buf.free;
@@ -384,7 +386,7 @@ static void __tty_buffer_flush(struct tty_struct *tty)
 {
         struct tty_buffer *thead;
 
-        while((thead = tty->buf.head) != NULL) {
+        while ((thead = tty->buf.head) != NULL) {
                 tty->buf.head = thead->next;
                 tty_buffer_free(tty, thead);
         }
@@ -436,9 +438,9 @@ static void tty_buffer_flush(struct tty_struct *tty)
 static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
 {
         struct tty_buffer **tbh = &tty->buf.free;
-        while((*tbh) != NULL) {
+        while ((*tbh) != NULL) {
                 struct tty_buffer *t = *tbh;
-                if(t->size >= size) {
+                if (t->size >= size) {
                         *tbh = t->next;
                         t->next = NULL;
                         t->used = 0;
@@ -450,7 +452,7 @@ static struct tty_buffer *tty_buffer_find(struct tty_struct *tty, size_t size)
                 tbh = &((*tbh)->next);
         }
         /* Round the buffer size out */
-        size = (size + 0xFF) & ~ 0xFF;
+        size = (size + 0xFF) & ~0xFF;
         return tty_buffer_alloc(tty, size);
         /* Should possibly check if this fails for the largest buffer we
            have queued and recycle that ? */
@@ -520,7 +522,7 @@ int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars,
                 int space = tty_buffer_request_room(tty, size - copied);
                 struct tty_buffer *tb = tty->buf.tail;
                 /* If there is no space then tb may be NULL */
-                if(unlikely(space == 0))
+                if (unlikely(space == 0))
                         break;
                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
                 memset(tb->flag_buf_ptr + tb->used, TTY_NORMAL, space);
@@ -556,7 +558,7 @@ int tty_insert_flip_string_flags(struct tty_struct *tty,
                 int space = tty_buffer_request_room(tty, size - copied);
                 struct tty_buffer *tb = tty->buf.tail;
                 /* If there is no space then tb may be NULL */
-                if(unlikely(space == 0))
+                if (unlikely(space == 0))
                         break;
                 memcpy(tb->char_buf_ptr + tb->used, chars, space);
                 memcpy(tb->flag_buf_ptr + tb->used, flags, space);
@@ -608,7 +610,8 @@ EXPORT_SYMBOL(tty_schedule_flip);
  *      Locking: May call functions taking tty->buf.lock
  */
 
-int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size)
+int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars,
+                                                                size_t size)
 {
         int space = tty_buffer_request_room(tty, size);
         if (likely(space)) {
@@ -638,7 +641,8 @@ EXPORT_SYMBOL_GPL(tty_prepare_flip_string);
  *      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)
+int tty_prepare_flip_string_flags(struct tty_struct *tty,
+                        unsigned char **chars, char **flags, size_t size)
 {
         int space = tty_buffer_request_room(tty, size);
         if (likely(space)) {
@@ -660,12 +664,12 @@ EXPORT_SYMBOL_GPL(tty_prepare_flip_string_flags);
  *      @num: line discipline number
  *
  *      This is probably overkill for real world processors but
- *      they are not on hot paths so a little discipline won't do 
+ *      they are not on hot paths so a little discipline won't do
  *      any harm.
  *
  *      Locking: takes termios_mutex
  */
- 
+
 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
 {
         mutex_lock(&tty->termios_mutex);
@@ -678,10 +682,11 @@ static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
  *      must be taken with irqs off because there are hangup path
  *      callers who will do ldisc lookups and cannot sleep.
  */
- 
+
 static DEFINE_SPINLOCK(tty_ldisc_lock);
 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
-static struct tty_ldisc tty_ldiscs[NR_LDISCS];  /* line disc dispatch table */
+/* Line disc dispatch table */
+static struct tty_ldisc tty_ldiscs[NR_LDISCS];
 
 /**
  *      tty_register_ldisc      -       install a line discipline
@@ -700,17 +705,17 @@ int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
 {
         unsigned long flags;
         int ret = 0;
-        
+
         if (disc < N_TTY || disc >= NR_LDISCS)
                 return -EINVAL;
-        
+
         spin_lock_irqsave(&tty_ldisc_lock, flags);
         tty_ldiscs[disc] = *new_ldisc;
         tty_ldiscs[disc].num = disc;
         tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
         tty_ldiscs[disc].refcount = 0;
         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
-        
+
         return ret;
 }
 EXPORT_SYMBOL(tty_register_ldisc);
@@ -766,20 +771,18 @@ struct tty_ldisc *tty_ldisc_get(int disc)
 
         if (disc < N_TTY || disc >= NR_LDISCS)
                 return NULL;
-        
+
         spin_lock_irqsave(&tty_ldisc_lock, flags);
 
         ld = &tty_ldiscs[disc];
         /* Check the entry is defined */
-        if(ld->flags & LDISC_FLAG_DEFINED)
-        {
+        if (ld->flags & LDISC_FLAG_DEFINED) {
                 /* If the module is being unloaded we can't use it */
                 if (!try_module_get(ld->owner))
-                        ld = NULL;
+                        ld = NULL;
                 else /* lock it */
                         ld->refcount++;
-        }
-        else
+        } else
                 ld = NULL;
         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
         return ld;
@@ -802,9 +805,9 @@ void tty_ldisc_put(int disc)
 {
         struct tty_ldisc *ld;
         unsigned long flags;
-        
+
         BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
-                
+
         spin_lock_irqsave(&tty_ldisc_lock, flags);
         ld = &tty_ldiscs[disc];
         BUG_ON(ld->refcount == 0);
@@ -812,7 +815,7 @@ void tty_ldisc_put(int disc)
         module_put(ld->owner);
         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 }
-        
+
 EXPORT_SYMBOL_GPL(tty_ldisc_put);
 
 /**
@@ -851,11 +854,10 @@ static int tty_ldisc_try(struct tty_struct *tty)
         unsigned long flags;
         struct tty_ldisc *ld;
         int ret = 0;
-        
+
         spin_lock_irqsave(&tty_ldisc_lock, flags);
         ld = &tty->ldisc;
-        if(test_bit(TTY_LDISC, &tty->flags))
-        {
+        if (test_bit(TTY_LDISC, &tty->flags)) {
                 ld->refcount++;
                 ret = 1;
         }
@@ -867,8 +869,8 @@ static int tty_ldisc_try(struct tty_struct *tty)
  *      tty_ldisc_ref_wait      -       wait for the tty ldisc
  *      @tty: tty device
  *
- *      Dereference the line discipline for the terminal and take a 
- *      reference to it. If the line discipline is in flux then 
+ *      Dereference the line discipline for the terminal and take a
+ *      reference to it. If the line discipline is in flux then
  *      wait patiently until it changes.
  *
  *      Note: Must not be called from an IRQ/timer context. The caller
@@ -878,12 +880,12 @@ static int tty_ldisc_try(struct tty_struct *tty)
  *
  *      Locking: call functions take tty_ldisc_lock
  */
- 
+
 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
 {
         /* wait_event is a macro */
         wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
-        if(tty->ldisc.refcount == 0)
+        if (tty->ldisc.refcount == 0)
                 printk(KERN_ERR "tty_ldisc_ref_wait\n");
         return &tty->ldisc;
 }
@@ -894,16 +896,16 @@ EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
  *      tty_ldisc_ref           -       get the tty ldisc
  *      @tty: tty device
  *
- *      Dereference the line discipline for the terminal and take a 
- *      reference to it. If the line discipline is in flux then 
+ *      Dereference the line discipline for the terminal and take a
+ *      reference to it. If the line discipline is in flux then
  *      return NULL. Can be called from IRQ and timer functions.
  *
  *      Locking: called functions take tty_ldisc_lock
  */
- 
+
 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
 {
-        if(tty_ldisc_try(tty))
+        if (tty_ldisc_try(tty))
                 return &tty->ldisc;
         return NULL;
 }
@@ -919,19 +921,19 @@ EXPORT_SYMBOL_GPL(tty_ldisc_ref);
  *
  *      Locking: takes tty_ldisc_lock
  */
- 
+
 void tty_ldisc_deref(struct tty_ldisc *ld)
 {
         unsigned long flags;
 
         BUG_ON(ld == NULL);
-                
+
         spin_lock_irqsave(&tty_ldisc_lock, flags);
-        if(ld->refcount == 0)
+        if (ld->refcount == 0)
                 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
         else
                 ld->refcount--;
-        if(ld->refcount == 0)
+        if (ld->refcount == 0)
                 wake_up(&tty_ldisc_wait);
         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 }
@@ -954,7 +956,7 @@ static void tty_ldisc_enable(struct tty_struct *tty)
         set_bit(TTY_LDISC, &tty->flags);
         wake_up(&tty_ldisc_wait);
 }
-        
+
 /**
  *      tty_set_ldisc           -       set line discipline
  *      @tty: the terminal to set
@@ -966,7 +968,7 @@ static void tty_ldisc_enable(struct tty_struct *tty)
  *      Locking: takes tty_ldisc_lock.
  *               called functions take termios_mutex
  */
- 
+
 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
 {
         int retval = 0;
@@ -1022,7 +1024,7 @@ restart:
 
         spin_lock_irqsave(&tty_ldisc_lock, flags);
         if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
-                if(tty->ldisc.refcount) {
+                if (tty->ldisc.refcount) {
                         /* Free the new ldisc we grabbed. Must drop the lock
                            first. */
                         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
@@ -1031,14 +1033,14 @@ restart:
                          * There are several reasons we may be busy, including
                          * random momentary I/O traffic. We must therefore
                          * retry. We could distinguish between blocking ops
-                         * and retries if we made tty_ldisc_wait() smarter. That
-                         * is up for discussion.
+                         * and retries if we made tty_ldisc_wait() smarter.
+                         * That is up for discussion.
                          */
                         if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
                                 return -ERESTARTSYS;
                         goto restart;
                 }
-                if(o_tty && o_tty->ldisc.refcount) {
+                if (o_tty && o_tty->ldisc.refcount) {
                         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
                         tty_ldisc_put(ldisc);
                         if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
@@ -1046,9 +1048,10 @@ restart:
                         goto restart;
                 }
         }
-
-        /* if the TTY_LDISC bit is set, then we are racing against another ldisc change */
-
+        /*
+         *      If the TTY_LDISC bit is set, then we are racing against
+         *      another ldisc change
+         */
         if (!test_bit(TTY_LDISC, &tty->flags)) {
                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
                 tty_ldisc_put(ldisc);
@@ -1072,7 +1075,6 @@ restart:
         /*
          * Wait for ->hangup_work and ->buf.work handlers to terminate
          */
-         
         flush_scheduled_work();
         /* Shutdown the current discipline. */
         if (tty->ldisc.close)
@@ -1106,21 +1108,21 @@ restart:
         /* At this point we hold a reference to the new ldisc and a
            a reference to the old ldisc. If we ended up flipping back
            to the existing ldisc we have two references to it */
-        
+
         if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
                 tty->driver->set_ldisc(tty);
-                
+
         tty_ldisc_put(o_ldisc.num);
-        
+
         /*
          *      Allow ldisc referencing to occur as soon as the driver
          *      ldisc callback completes.
          */
-         
+
         tty_ldisc_enable(tty);
         if (o_tty)
                 tty_ldisc_enable(o_tty);
-        
+
         /* Restart it in case no characters kick it off. Safe if
            already running */
         if (work)
@@ -1164,7 +1166,7 @@ static struct tty_driver *get_tty_driver(dev_t device, int *index)
  *      Locking: none
  */
 
-int tty_check_change(struct tty_struct * tty)
+int tty_check_change(struct tty_struct *tty)
 {
         if (current->signal->tty != tty)
                 return 0;
@@ -1185,31 +1187,31 @@ int tty_check_change(struct tty_struct * tty)
 
 EXPORT_SYMBOL(tty_check_change);
 
-static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
+static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
                                 size_t count, loff_t *ppos)
 {
         return 0;
 }
 
-static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
+static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
                                  size_t count, loff_t *ppos)
 {
         return -EIO;
 }
 
 /* No kernel lock held - none needed ;) */
-static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
+static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
 {
         return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
 }
 
-static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
+static int hung_up_tty_ioctl(struct inode *inode, struct file *file,
                              unsigned int cmd, unsigned long arg)
 {
         return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
 }
 
-static long hung_up_tty_compat_ioctl(struct file * file,
+static long hung_up_tty_compat_ioctl(struct file *file,
                                      unsigned int cmd, unsigned long arg)
 {
         return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
@@ -1274,15 +1276,15 @@ static struct file *redirect;
  *      informs the line discipline if present that the driver is ready
  *      to receive more output data.
  */
- 
+
 void tty_wakeup(struct tty_struct *tty)
 {
         struct tty_ldisc *ld;
-        
+
         if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
                 ld = tty_ldisc_ref(tty);
-                if(ld) {
-                        if(ld->write_wakeup)
+                if (ld) {
+                        if (ld->write_wakeup)
                                 ld->write_wakeup(tty);
                         tty_ldisc_deref(ld);
                 }
@@ -1299,12 +1301,12 @@ EXPORT_SYMBOL_GPL(tty_wakeup);
  *      Flush the line discipline queue (if any) for this tty. If there
  *      is no line discipline active this is a no-op.
  */
- 
+
 void tty_ldisc_flush(struct tty_struct *tty)
 {
         struct tty_ldisc *ld = tty_ldisc_ref(tty);
-        if(ld) {
-                if(ld->flush_buffer)
+        if (ld) {
+                if (ld->flush_buffer)
                         ld->flush_buffer(tty);
                 tty_ldisc_deref(ld);
         }
@@ -1328,7 +1330,7 @@ static void tty_reset_termios(struct tty_struct *tty)
         tty->termios->c_ospeed = tty_termios_baud_rate(tty->termios);
         mutex_unlock(&tty->termios_mutex);
 }
-        
+
 /**
  *      do_tty_hangup           -       actual handler for hangup events
  *      @work: tty device
@@ -1355,7 +1357,7 @@ static void do_tty_hangup(struct work_struct *work)
 {
         struct tty_struct *tty =
                 container_of(work, struct tty_struct, hangup_work);
-        struct file * cons_filp = NULL;
+        struct file *cons_filp = NULL;
         struct file *filp, *f = NULL;
         struct task_struct *p;
         struct tty_ldisc *ld;
@@ -1373,7 +1375,7 @@ static void do_tty_hangup(struct work_struct *work)
                 redirect = NULL;
         }
         spin_unlock(&redirect_lock);
-        
+
         check_tty_count(tty, "do_tty_hangup");
         file_list_lock();
         /* This breaks for file handles being sent over AF_UNIX sockets ? */
@@ -1387,13 +1389,14 @@ static void do_tty_hangup(struct work_struct *work)
                 filp->f_op = &hung_up_tty_fops;
         }
         file_list_unlock();
-        
-        /* FIXME! What are the locking issues here? This may me overdoing things..
-         * this question is especially important now that we've removed the irqlock. */
-
+        /*
+         * FIXME! What are the locking issues here? This may me overdoing
+         * things... This question is especially important now that we've
+         * removed the irqlock.
+         */
         ld = tty_ldisc_ref(tty);
-        if(ld != NULL)  /* We may have no line discipline at this point */
-        {
+        if (ld != NULL) {
+                /* We may have no line discipline at this point */
                 if (ld->flush_buffer)
                         ld->flush_buffer(tty);
                 if (tty->driver->flush_buffer)
@@ -1404,26 +1407,24 @@ static void do_tty_hangup(struct work_struct *work)
                 if (ld->hangup)
                         ld->hangup(tty);
         }
-
-        /* FIXME: Once we trust the LDISC code better we can wait here for
-           ldisc completion and fix the driver call race */
-           
+        /*
+         * FIXME: Once we trust the LDISC code better we can wait here for
+         * ldisc completion and fix the driver call race
+         */
         wake_up_interruptible(&tty->write_wait);
         wake_up_interruptible(&tty->read_wait);
-
         /*
          * Shutdown the current line discipline, and reset it to
          * N_TTY.
          */
         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
                 tty_reset_termios(tty);
-        
         /* Defer ldisc switch */
         /* tty_deferred_ldisc_switch(N_TTY);
-        
+
           This should get done automatically when the port closes and
           tty_release is called */
-        
+
         read_lock(&tasklist_lock);
         if (tty->session) {
                 do_each_pid_task(tty->session, PIDTYPE_SID, p) {
@@ -1451,10 +1452,10 @@ static void do_tty_hangup(struct work_struct *work)
         tty->pgrp = NULL;
         tty->ctrl_status = 0;
         /*
-         *      If one of the devices matches a console pointer, we
-         *      cannot just call hangup() because that will cause
-         *      tty->count and state->count to go out of sync.
-         *      So we just call close() the right number of times.
+         * If one of the devices matches a console pointer, we
+         * cannot just call hangup() because that will cause
+         * tty->count and state->count to go out of sync.
+         * So we just call close() the right number of times.
          */
         if (cons_filp) {
                 if (tty->driver->close)
@@ -1462,12 +1463,12 @@ static void do_tty_hangup(struct work_struct *work)
                                 tty->driver->close(tty, cons_filp);
         } else if (tty->driver->hangup)
                 (tty->driver->hangup)(tty);
-                
-        /* We don't want to have driver/ldisc interactions beyond
-           the ones we did here. The driver layer expects no
-           calls after ->hangup() from the ldisc side. However we
-           can't yet guarantee all that */
-
+        /*
+         * We don't want to have driver/ldisc interactions beyond
+         * the ones we did here. The driver layer expects no
+         * calls after ->hangup() from the ldisc side. However we
+         * can't yet guarantee all that.
+         */
         set_bit(TTY_HUPPED, &tty->flags);
         if (ld) {
                 tty_ldisc_enable(tty);
@@ -1486,11 +1487,10 @@ static void do_tty_hangup(struct work_struct *work)
  *      schedule a hangup sequence to run after this event.
  */
 
-void tty_hangup(struct tty_struct * tty)
+void tty_hangup(struct tty_struct *tty)
 {
 #ifdef TTY_DEBUG_HANGUP
         char    buf[64];
-        
         printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
 #endif
         schedule_work(&tty->hangup_work);
@@ -1507,7 +1507,7 @@ EXPORT_SYMBOL(tty_hangup);
  *      is complete. That guarantee is necessary for security reasons.
  */
 
-void tty_vhangup(struct tty_struct * tty)
+void tty_vhangup(struct tty_struct *tty)
 {
 #ifdef TTY_DEBUG_HANGUP
         char    buf[64];
@@ -1516,6 +1516,7 @@ void tty_vhangup(struct tty_struct * tty)
 #endif
         do_tty_hangup(&tty->hangup_work);
 }
+
 EXPORT_SYMBOL(tty_vhangup);
 
 /**
@@ -1526,7 +1527,7 @@ EXPORT_SYMBOL(tty_vhangup);
  *      loss
  */
 
-int tty_hung_up_p(struct file * filp)
+int tty_hung_up_p(struct file *filp)
 {
         return (filp->f_op == &hung_up_tty_fops);
 }
@@ -1534,8 +1535,12 @@ int tty_hung_up_p(struct file * filp)
 EXPORT_SYMBOL(tty_hung_up_p);
 
 /**
- * is_tty       -       checker whether file is a TTY
+ *      is_tty  -       checker whether file is a TTY
+ *      @filp:          file handle that may be a tty
+ *
+ *      Check if the file handle is a tty handle.
  */
+
 int is_tty(struct file *filp)
 {
         return filp->f_op->read == tty_read
@@ -1601,7 +1606,7 @@ void disassociate_ctty(int on_exit)
                         put_pid(old_pgrp);
                 }
                 mutex_unlock(&tty_mutex);
-                unlock_kernel();        
+                unlock_kernel();
                 return;
         }
         if (tty_pgrp) {
@@ -1711,7 +1716,6 @@ void start_tty(struct tty_struct *tty)
         }
         if (tty->driver->start)
                 (tty->driver->start)(tty);
-
         /* If we have a running line discipline it may need kicking */
         tty_wakeup(tty);
 }
@@ -1735,11 +1739,11 @@ EXPORT_SYMBOL(start_tty);
  *      in new code. Multiple read calls may be outstanding in parallel.
  */
 
-static ssize_t tty_read(struct file * file, char __user * buf, size_t count, 
+static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
                         loff_t *ppos)
 {
         int i;
-        struct tty_struct * tty;
+        struct tty_struct *tty;
         struct inode *inode;
         struct tty_ldisc *ld;
 
@@ -1755,7 +1759,7 @@ static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
         ld = tty_ldisc_ref_wait(tty);
         lock_kernel();
         if (ld->read)
-                i = (ld->read)(tty,file,buf,count);
+                i = (ld->read)(tty, file, buf, count);
         else
                 i = -EIO;
         tty_ldisc_deref(ld);
@@ -1795,7 +1799,7 @@ static inline ssize_t do_tty_write(
 {
         ssize_t ret, written = 0;
         unsigned int chunk;
-        
+
         ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
         if (ret < 0)
                 return ret;
@@ -1891,21 +1895,22 @@ out:
  *      kernel lock for historical reasons. New code should not rely on this.
  */
 
-static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
-                         loff_t *ppos)
+static ssize_t tty_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
-        struct tty_struct * tty;
+        struct tty_struct *tty;
         struct inode *inode = file->f_path.dentry->d_inode;
         ssize_t ret;
         struct tty_ldisc *ld;
-        
+
         tty = (struct tty_struct *)file->private_data;
         if (tty_paranoia_check(tty, inode, "tty_write"))
                 return -EIO;
-        if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
-                return -EIO;
+        if (!tty || !tty->driver->write ||
+                (test_bit(TTY_IO_ERROR, &tty->flags)))
+                        return -EIO;
 
-        ld = tty_ldisc_ref_wait(tty);           
+        ld = tty_ldisc_ref_wait(tty);
         if (!ld->write)
                 ret = -EIO;
         else
@@ -1914,8 +1919,8 @@ static ssize_t tty_write(struct file * file, const char __user * buf, size_t cou
         return ret;
 }
 
-ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
-                         loff_t *ppos)
+ssize_t redirected_tty_write(struct file *file, const char __user *buf,
+                                                size_t count, loff_t *ppos)
 {
         struct file *p = NULL;
 
@@ -1932,7 +1937,6 @@ ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t
                 fput(p);
                 return res;
         }
-
         return tty_write(file, buf, count, ppos);
 }
 
@@ -1954,8 +1958,8 @@ static void pty_line_name(struct tty_driver *driver, int index, char *p)
         int i = index + driver->name_base;
         /* ->name is initialized to "ttyp", but "tty" is expected */
         sprintf(p, "%s%c%x",
-                        driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
-                        ptychar[i >> 4 & 0xf], i & 0xf);
+                driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
+                ptychar[i >> 4 & 0xf], i & 0xf);
 }
 
 /**
@@ -2034,7 +2038,7 @@ static int init_dev(struct tty_driver *driver, int idx,
          * First time open is complex, especially for PTY devices.
          * This code guarantees that either everything succeeds and the
          * TTY is ready for operation, or else the table slots are vacated
-         * and the allocated memory released.  (Except that the termios 
+         * and the allocated memory released.  (Except that the termios
          * and locked termios may be retained.)
          */
 
@@ -2048,7 +2052,7 @@ static int init_dev(struct tty_driver *driver, int idx,
         ltp = o_ltp = NULL;
 
         tty = alloc_tty_struct();
-        if(!tty)
+        if (!tty)
                 goto fail_no_mem;
         initialize_tty_struct(tty);
         tty->driver = driver;
@@ -2109,9 +2113,8 @@ static int init_dev(struct tty_driver *driver, int idx,
                 /*
                  * Everything allocated ... set up the o_tty structure.
                  */
-                if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
+                if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM))
                         driver->other->ttys[idx] = o_tty;
-                }
                 if (!*o_tp_loc)
                         *o_tp_loc = o_tp;
                 if (!*o_ltp_loc)
@@ -2127,15 +2130,14 @@ static int init_dev(struct tty_driver *driver, int idx,
                 o_tty->link = tty;
         }
 
-        /* 
+        /*
          * All structures have been allocated, so now we install them.
          * Failures after this point use release_tty to clean up, so
          * there's no need to null out the local pointers.
          */
-        if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
+        if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM))
                 driver->ttys[idx] = tty;
-        }
-        
+
         if (!*tp_loc)
                 *tp_loc = tp;
         if (!*ltp_loc)
@@ -2148,7 +2150,7 @@ static int init_dev(struct tty_driver *driver, int idx,
         driver->refcount++;
         tty->count++;
 
-        /* 
+        /*
          * Structures all installed ... call the ldisc open routines.
          * If we fail here just call release_tty to clean up.  No need
          * to decrement the use counts, as release_tty doesn't care.
@@ -2185,7 +2187,7 @@ fast_track:
         if (driver->type == TTY_DRIVER_TYPE_PTY &&
             driver->subtype == PTY_TYPE_MASTER) {
                 /*
-                 * special case for PTY masters: only one open permitted, 
+                 * special case for PTY masters: only one open permitted,
                  * and the slave side open count is incremented as well.
                  */
                 if (tty->count) {
@@ -2198,11 +2200,11 @@ fast_track:
         tty->driver = driver; /* N.B. why do this every time?? */
 
         /* FIXME */
-        if(!test_bit(TTY_LDISC, &tty->flags))
+        if (!test_bit(TTY_LDISC, &tty->flags))
                 printk(KERN_ERR "init_dev but no ldisc\n");
 success:
         *ret_tty = tty;
-        
+
         /* All paths come through here to release the mutex */
 end_init:
         return retval;
@@ -2304,7 +2306,7 @@ static void release_tty(struct tty_struct *tty, int idx)
  * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
  * lead to double frees or releasing memory still in use.
  */
-static void release_dev(struct file * filp)
+static void release_dev(struct file *filp)
 {
         struct tty_struct *tty, *o_tty;
         int     pty_master, tty_closing, o_tty_closing, do_sleep;
@@ -2312,9 +2314,10 @@ static void release_dev(struct file * filp)
         int     idx;
         char    buf[64];
         unsigned long flags;
-        
+
         tty = (struct tty_struct *)filp->private_data;
-        if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "release_dev"))
+        if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode,
+                                                        "release_dev"))
                 return;
 
         check_tty_count(tty, "release_dev");
@@ -2374,7 +2377,7 @@ static void release_dev(struct file * filp)
                                idx, tty->name);
                         return;
                 }
-                if (o_tty->termios_locked != 
+                if (o_tty->termios_locked !=
                       tty->driver->other->termios_locked[idx]) {
                         printk(KERN_DEBUG "release_dev: other->termios_locked["
                                           "%d] not o_termios_locked for (%s)\n",
@@ -2410,7 +2413,7 @@ static void release_dev(struct file * filp)
         while (1) {
                 /* Guard against races with tty->count changes elsewhere and
                    opens on /dev/tty */
-                   
+
                 mutex_lock(&tty_mutex);
                 tty_closing = tty->count <= 1;
                 o_tty_closing = o_tty &&
@@ -2444,11 +2447,11 @@ static void release_dev(struct file * filp)
                                     "active!\n", tty_name(tty, buf));
                 mutex_unlock(&tty_mutex);
                 schedule();
-        }       
+        }
 
         /*
-         * The closing flags are now consistent with the open counts on 
-         * both sides, and we've completed the last operation that could 
+         * The closing flags are now consistent with the open counts on
+         * both sides, and we've completed the last operation that could
          * block, so it's safe to proceed with closing.
          */
         if (pty_master) {
@@ -2464,7 +2467,7 @@ static void release_dev(struct file * filp)
                        tty->count, tty_name(tty, buf));
                 tty->count = 0;
         }
-        
+
         /*
          * We've decremented tty->count, so we need to remove this file
          * descriptor off the tty->tty_files list; this serves two
@@ -2484,9 +2487,9 @@ static void release_dev(struct file * filp)
          * case of a pty we may have to wait around for the other side
          * to close, and TTY_CLOSING makes sure we can't be reopened.
          */
-        if(tty_closing)
+        if (tty_closing)
                 set_bit(TTY_CLOSING, &tty->flags);
-        if(o_tty_closing)
+        if (o_tty_closing)
                 set_bit(TTY_CLOSING, &o_tty->flags);
 
         /*
@@ -2507,7 +2510,7 @@ static void release_dev(struct file * filp)
         /* check whether both sides are closing ... */
         if (!tty_closing || (o_tty && !o_tty_closing))
                 return;
-        
+
 #ifdef TTY_DEBUG_HANGUP
         printk(KERN_DEBUG "freeing tty structure...");
 #endif
@@ -2522,17 +2525,16 @@ static void release_dev(struct file * filp)
         /*
          * Wait for ->hangup_work and ->buf.work handlers to terminate
          */
-         
+
         flush_scheduled_work();
-        
+
         /*
          * Wait for any short term users (we know they are just driver
          * side waiters as the file is closing so user count on the file
          * side is zero.
          */
         spin_lock_irqsave(&tty_ldisc_lock, flags);
-        while(tty->ldisc.refcount)
-        {
+        while (tty->ldisc.refcount) {
                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
                 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
                 spin_lock_irqsave(&tty_ldisc_lock, flags);
@@ -2547,12 +2549,12 @@ static void release_dev(struct file * filp)
         if (tty->ldisc.close)
                 (tty->ldisc.close)(tty);
         tty_ldisc_put(tty->ldisc.num);
-        
+
         /*
          *      Switch the line discipline back
          */
         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
-        tty_set_termios_ldisc(tty,N_TTY); 
+        tty_set_termios_ldisc(tty, N_TTY);
         if (o_tty) {
                 /* FIXME: could o_tty be in setldisc here ? */
                 clear_bit(TTY_LDISC, &o_tty->flags);
@@ -2560,7 +2562,7 @@ static void release_dev(struct file * filp)
                         (o_tty->ldisc.close)(o_tty);
                 tty_ldisc_put(o_tty->ldisc.num);
                 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
-                tty_set_termios_ldisc(o_tty,N_TTY); 
+                tty_set_termios_ldisc(o_tty, N_TTY);
         }
         /*
          * The release_tty function takes care of the details of clearing
@@ -2600,7 +2602,7 @@ static void release_dev(struct file * filp)
  *               ->siglock protects ->signal/->sighand
  */
 
-static int tty_open(struct inode * inode, struct file * filp)
+static int tty_open(struct inode *inode, struct file *filp)
 {
         struct tty_struct *tty;
         int noctty, retval;
@@ -2610,15 +2612,15 @@ static int tty_open(struct inode * inode, struct file * filp)
         unsigned short saved_flags = filp->f_flags;
 
         nonseekable_open(inode, filp);
-        
+
 retry_open:
         noctty = filp->f_flags & O_NOCTTY;
         index  = -1;
         retval = 0;
-        
+
         mutex_lock(&tty_mutex);
 
-        if (device == MKDEV(TTYAUX_MAJOR,0)) {
+        if (device == MKDEV(TTYAUX_MAJOR, 0)) {
                 tty = get_current_tty();
                 if (!tty) {
                         mutex_unlock(&tty_mutex);
@@ -2631,7 +2633,7 @@ retry_open:
                 goto got_driver;
         }
 #ifdef CONFIG_VT
-        if (device == MKDEV(TTY_MAJOR,0)) {
+        if (device == MKDEV(TTY_MAJOR, 0)) {
                 extern struct tty_driver *console_driver;
                 driver = console_driver;
                 index = fg_console;
@@ -2639,7 +2641,7 @@ retry_open:
                 goto got_driver;
         }
 #endif
-        if (device == MKDEV(TTYAUX_MAJOR,1)) {
+        if (device == MKDEV(TTYAUX_MAJOR, 1)) {
                 driver = console_device(&index);
                 if (driver) {
                         /* Don't let /dev/console block */
@@ -2679,7 +2681,8 @@ got_driver:
         }
         filp->f_flags = saved_flags;
 
-        if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
+        if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
+                                                !capable(CAP_SYS_ADMIN))
                 retval = -EBUSY;
 
         if (retval) {
@@ -2723,11 +2726,11 @@ got_driver:
  *      Allocate a unix98 pty master device from the ptmx driver.
  *
  *      Locking: tty_mutex protects theinit_dev work. tty->count should
-                protect the rest.
+ *              protect the rest.
  *              allocated_ptys_lock handles the list of free pty numbers
  */
 
-static int ptmx_open(struct inode * inode, struct file * filp)
+static int ptmx_open(struct inode *inode, struct file *filp)
 {
         struct tty_struct *tty;
         int retval;
@@ -2759,7 +2762,7 @@ static int ptmx_open(struct inode * inode, struct file * filp)
         mutex_lock(&tty_mutex);
         retval = init_dev(ptm_driver, index, &tty);
         mutex_unlock(&tty_mutex);
-        
+
         if (retval)
                 goto out;
 
@@ -2800,7 +2803,7 @@ out:
  *              Takes bkl. See release_dev
  */
 
-static int tty_release(struct inode * inode, struct file * filp)
+static int tty_release(struct inode *inode, struct file *filp)
 {
         lock_kernel();
         release_dev(filp);
@@ -2820,16 +2823,16 @@ static int tty_release(struct inode * inode, struct file * filp)
  *      may be re-entered freely by other callers.
  */
 
-static unsigned int tty_poll(struct file * filp, poll_table * wait)
+static unsigned int tty_poll(struct file *filp, poll_table *wait)
 {
-        struct tty_struct * tty;
+        struct tty_struct *tty;
         struct tty_ldisc *ld;
         int ret = 0;
 
         tty = (struct tty_struct *)filp->private_data;
         if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_poll"))
                 return 0;
-                
+
         ld = tty_ldisc_ref_wait(tty);
         if (ld->poll)
                 ret = (ld->poll)(tty, filp, wait);
@@ -2837,15 +2840,15 @@ static unsigned int tty_poll(struct file * filp, poll_table * wait)
         return ret;
 }
 
-static int tty_fasync(int fd, struct file * filp, int on)
+static int tty_fasync(int fd, struct file *filp, int on)
 {
-        struct tty_struct * tty;
+        struct tty_struct *tty;
         int retval;
 
         tty = (struct tty_struct *)filp->private_data;
         if (tty_paranoia_check(tty, filp->f_path.dentry->d_inode, "tty_fasync"))
                 return 0;
-        
+
         retval = fasync_helper(fd, filp, on, &tty->fasync);
         if (retval <= 0)
                 return retval;
@@ -2893,7 +2896,7 @@ static int tiocsti(struct tty_struct *tty, char __user *p)
 {
         char ch, mbz = 0;
         struct tty_ldisc *ld;
-        
+
         if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
                 return -EPERM;
         if (get_user(ch, p))
@@ -2915,7 +2918,7 @@ static int tiocsti(struct tty_struct *tty, char __user *p)
  *              is consistent.
  */
 
-static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
+static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
 {
         int err;
 
@@ -2944,7 +2947,7 @@ static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
  */
 
 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
-        struct winsize __user * arg)
+        struct winsize __user *arg)
 {
         struct winsize tmp_ws;
 
@@ -2960,7 +2963,7 @@ static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
                 if (vc_lock_resize(tty->driver_data, tmp_ws.ws_col,
                                         tmp_ws.ws_row)) {
                         mutex_unlock(&tty->termios_mutex);
-                        return -ENXIO;
+                        return -ENXIO;
                 }
         }
 #endif
@@ -3070,7 +3073,7 @@ static int tiocsctty(struct tty_struct *tty, int arg)
                  * This tty is already the controlling
                  * tty for another session group!
                  */
-                if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
+                if (arg == 1 && capable(CAP_SYS_ADMIN)) {
                         /*
                          * Steal it away
                          */
@@ -3303,14 +3306,14 @@ static int tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int
 /*
  * Split this up, as gcc can choke on it otherwise..
  */
-int tty_ioctl(struct inode * inode, struct file * file,
+int tty_ioctl(struct inode *inode, struct file *file,
               unsigned int cmd, unsigned long arg)
 {
         struct tty_struct *tty, *real_tty;
         void __user *p = (void __user *)arg;
         int retval;
         struct tty_ldisc *ld;
-        
+
         tty = (struct tty_struct *)file->private_data;
         if (tty_paranoia_check(tty, inode, "tty_ioctl"))
                 return -EINVAL;
@@ -3326,13 +3329,13 @@ int tty_ioctl(struct inode * inode, struct file * file,
          * Break handling by driver
          */
         if (!tty->driver->break_ctl) {
-                switch(cmd) {
+                switch (cmd) {
                 case TIOCSBRK:
                 case TIOCCBRK:
                         if (tty->driver->ioctl)
                                 return tty->driver->ioctl(tty, file, cmd, arg);
                         return -EINVAL;
-                        
+
                 /* These two ioctl's always return success; even if */
                 /* the driver doesn't support them. */
                 case TCSBRK:
@@ -3354,7 +3357,7 @@ int tty_ioctl(struct inode * inode, struct file * file,
         case TIOCSBRK:
         case TIOCCBRK:
         case TCSBRK:
-        case TCSBRKP:                   
+        case TCSBRKP:
                 retval = tty_check_change(tty);
                 if (retval)
                         return retval;
@@ -3367,81 +3370,80 @@ int tty_ioctl(struct inode * inode, struct file * file,
         }
 
         switch (cmd) {
-                case TIOCSTI:
-                        return tiocsti(tty, p);
-                case TIOCGWINSZ:
-                        return tiocgwinsz(tty, p);
-                case TIOCSWINSZ:
-                        return tiocswinsz(tty, real_tty, p);
-                case TIOCCONS:
-                        return real_tty!=tty ? -EINVAL : tioccons(file);
-                case FIONBIO:
-                        return fionbio(file, p);
-                case TIOCEXCL:
-                        set_bit(TTY_EXCLUSIVE, &tty->flags);
-                        return 0;
-                case TIOCNXCL:
-                        clear_bit(TTY_EXCLUSIVE, &tty->flags);
-                        return 0;
-                case TIOCNOTTY:
-                        if (current->signal->tty != tty)
-                                return -ENOTTY;
-                        no_tty();
-                        return 0;
-                case TIOCSCTTY:
-                        return tiocsctty(tty, arg);
-                case TIOCGPGRP:
-                        return tiocgpgrp(tty, real_tty, p);
-                case TIOCSPGRP:
-                        return tiocspgrp(tty, real_tty, p);
-                case TIOCGSID:
-                        return tiocgsid(tty, real_tty, p);
-                case TIOCGETD:
-                        /* FIXME: check this is ok */
-                        return put_user(tty->ldisc.num, (int __user *)p);
-                case TIOCSETD:
-                        return tiocsetd(tty, p);
+        case TIOCSTI:
+                return tiocsti(tty, p);
+        case TIOCGWINSZ:
+                return tiocgwinsz(tty, p);
+        case TIOCSWINSZ:
+                return tiocswinsz(tty, real_tty, p);
+        case TIOCCONS:
+                return real_tty != tty ? -EINVAL : tioccons(file);
+        case FIONBIO:
+                return fionbio(file, p);
+        case TIOCEXCL:
+                set_bit(TTY_EXCLUSIVE, &tty->flags);
+                return 0;
+        case TIOCNXCL:
+                clear_bit(TTY_EXCLUSIVE, &tty->flags);
+                return 0;
+        case TIOCNOTTY:
+                if (current->signal->tty != tty)
+                        return -ENOTTY;
+                no_tty();
+                return 0;
+        case TIOCSCTTY:
+                return tiocsctty(tty, arg);
+        case TIOCGPGRP:
+                return tiocgpgrp(tty, real_tty, p);
+        case TIOCSPGRP:
+                return tiocspgrp(tty, real_tty, p);
+        case TIOCGSID:
+                return tiocgsid(tty, real_tty, p);
+        case TIOCGETD:
+                /* FIXME: check this is ok */
+                return put_user(tty->ldisc.num, (int __user *)p);
+        case TIOCSETD:
+                return tiocsetd(tty, p);
 #ifdef CONFIG_VT
-                case TIOCLINUX:
-                        return tioclinux(tty, arg);
+        case TIOCLINUX:
+                return tioclinux(tty, arg);
 #endif
-                /*
-                 * Break handling
-                 */
-                case TIOCSBRK:  /* Turn break on, unconditionally */
-                        tty->driver->break_ctl(tty, -1);
-                        return 0;
-                        
-                case TIOCCBRK:  /* Turn break off, unconditionally */
-                        tty->driver->break_ctl(tty, 0);
-                        return 0;
-                case TCSBRK:   /* SVID version: non-zero arg --> no break */
-                        /* non-zero arg means wait for all output data
-                         * to be sent (performed above) but don't send break.
-                         * This is used by the tcdrain() termios function.
-                         */
-                        if (!arg)
-                                return send_break(tty, 250);
-                        return 0;
-                case TCSBRKP:   /* support for POSIX tcsendbreak() */   
-                        return send_break(tty, arg ? arg*100 : 250);
-
-                case TIOCMGET:
-                        return tty_tiocmget(tty, file, p);
+        /*
+         * Break handling
+         */
+        case TIOCSBRK:  /* Turn break on, unconditionally */
+                tty->driver->break_ctl(tty, -1);
+                return 0;
 
-                case TIOCMSET:
-                case TIOCMBIC:
-                case TIOCMBIS:
-                        return tty_tiocmset(tty, file, cmd, p);
-                case TCFLSH:
-                        switch (arg) {
-                        case TCIFLUSH:
-                        case TCIOFLUSH:
-                                /* flush tty buffer and allow ldisc to process ioctl */
-                                tty_buffer_flush(tty);
-                                break;
-                        }
+        case TIOCCBRK:  /* Turn break off, unconditionally */
+                tty->driver->break_ctl(tty, 0);
+                return 0;
+        case TCSBRK:   /* SVID version: non-zero arg --> no break */
+                /* non-zero arg means wait for all output data
+                 * to be sent (performed above) but don't send break.
+                 * This is used by the tcdrain() termios function.
+                 */
+                if (!arg)
+                        return send_break(tty, 250);
+                return 0;
+        case TCSBRKP:   /* support for POSIX tcsendbreak() */
+                return send_break(tty, arg ? arg*100 : 250);
+
+        case TIOCMGET:
+                return tty_tiocmget(tty, file, p);
+        case TIOCMSET:
+        case TIOCMBIC:
+        case TIOCMBIS:
+                return tty_tiocmset(tty, file, cmd, p);
+        case TCFLSH:
+                switch (arg) {
+                case TCIFLUSH:
+                case TCIOFLUSH:
+                /* flush tty buffer and allow ldisc to process ioctl */
+                        tty_buffer_flush(tty);
                         break;
+                }
+                break;
         }
         if (tty->driver->ioctl) {
                 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
@@ -3460,7 +3462,7 @@ int tty_ioctl(struct inode * inode, struct file * file,
 }
 
 #ifdef CONFIG_COMPAT
-static long tty_compat_ioctl(struct file * file, unsigned int cmd,
+static long tty_compat_ioctl(struct file *file, unsigned int cmd,
                                 unsigned long arg)
 {
         struct inode *inode = file->f_dentry->d_inode;
@@ -3491,7 +3493,7 @@ static long tty_compat_ioctl(struct file * file, unsigned int cmd,
  * prevent trojan horses by killing all processes associated with this
  * tty when the user hits the "Secure Attention Key".  Required for
  * super-paranoid applications --- see the Orange Book for more details.
- * 
+ *
  * This code could be nicer; ideally it should send a HUP, wait a few
  * seconds, then send a INT, and then a KILL signal.  But you then
  * have to coordinate with the init process, since all processes associated
@@ -3515,16 +3517,16 @@ void __do_SAK(struct tty_struct *tty)
         int             i;
         struct file     *filp;
         struct fdtable *fdt;
-        
+
         if (!tty)
                 return;
         session = tty->session;
-        
+
         tty_ldisc_flush(tty);
 
         if (tty->driver->flush_buffer)
                 tty->driver->flush_buffer(tty);
-        
+
         read_lock(&tasklist_lock);
         /* Kill the entire session */
         do_each_pid_task(session, PIDTYPE_SID, p) {
@@ -3552,7 +3554,7 @@ void __do_SAK(struct tty_struct *tty)
                          */
                         spin_lock(&p->files->file_lock);
                         fdt = files_fdtable(p->files);
-                        for (i=0; i < fdt->max_fds; i++) {
+                        for (i = 0; i < fdt->max_fds; i++) {
                                 filp = fcheck_files(p->files, i);
                                 if (!filp)
                                         continue;
@@ -3606,7 +3608,7 @@ EXPORT_SYMBOL(do_SAK);
  *      while invoking the line discipline receive_buf method. The
  *      receive_buf method is single threaded for each tty instance.
  */
- 
+
 static void flush_to_ldisc(struct work_struct *work)
 {
         struct tty_struct *tty =
@@ -3622,7 +3624,8 @@ static void flush_to_ldisc(struct work_struct *work)
                 return;
 
         spin_lock_irqsave(&tty->buf.lock, flags);
-        set_bit(TTY_FLUSHING, &tty->flags);     /* So we know a flush is running */
+        /* So we know a flush is running */
+        set_bit(TTY_FLUSHING, &tty->flags);
         head = tty->buf.head;
         if (head != NULL) {
                 tty->buf.head = NULL;
@@ -3795,7 +3798,8 @@ struct device *tty_register_device(struct tty_driver *driver, unsigned index,
 
 void tty_unregister_device(struct tty_driver *driver, unsigned index)
 {
-        device_destroy(tty_class, MKDEV(driver->major, driver->minor_start) + index);
+        device_destroy(tty_class,
+                MKDEV(driver->major, driver->minor_start) + index);
 }
 
 EXPORT_SYMBOL(tty_register_device);
@@ -3859,7 +3863,7 @@ EXPORT_SYMBOL(tty_set_operations);
 int tty_register_driver(struct tty_driver *driver)
 {
         int error;
-        int i;
+        int i;
         dev_t dev;
         void **p = NULL;
 
@@ -3873,8 +3877,8 @@ int tty_register_driver(struct tty_driver *driver)
         }
 
         if (!driver->major) {
-                error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
-                                                driver->name);
+                error = alloc_chrdev_region(&dev, driver->minor_start,
+                                                driver->num, driver->name);
                 if (!error) {
                         driver->major = MAJOR(dev);
                         driver->minor_start = MINOR(dev);
@@ -3891,7 +3895,8 @@ int tty_register_driver(struct tty_driver *driver)
         if (p) {
                 driver->ttys = (struct tty_struct **)p;
                 driver->termios = (struct ktermios **)(p + driver->num);
-                driver->termios_locked = (struct ktermios **)(p + driver->num * 2);
+                driver->termios_locked = (struct ktermios **)
+                                                        (p + driver->num * 2);
         } else {
                 driver->ttys = NULL;
                 driver->termios = NULL;
@@ -3911,13 +3916,13 @@ int tty_register_driver(struct tty_driver *driver)
 
         if (!driver->put_char)
                 driver->put_char = tty_default_put_char;
-        
+
         mutex_lock(&tty_mutex);
         list_add(&driver->tty_drivers, &tty_drivers);
         mutex_unlock(&tty_mutex);
-        
-        if ( !(driver->flags & TTY_DRIVER_DYNAMIC_DEV) ) {
-                for(i = 0; i < driver->num; i++)
+
+        if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
+                for (i = 0; i < driver->num; i++)
                     tty_register_device(driver, i, NULL);
         }
         proc_tty_register_driver(driver);
@@ -4037,7 +4042,7 @@ void __init console_init(void)
         (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
 
         /*
-         * set up the console device so that later boot sequences can 
+         * set up the console device so that later boot sequences can
          * inform about problems etc..
          */
         call = __con_initcall_start;