int uncopied;
 
        if (n > size) {
-               tty_audit_add_data(tty, from, size, ldata->icanon);
+               tty_audit_add_data(tty, from, size);
                uncopied = copy_to_user(to, from, size);
                if (uncopied)
                        return uncopied;
                from = ldata->read_buf;
        }
 
-       tty_audit_add_data(tty, from, n, ldata->icanon);
+       tty_audit_add_data(tty, from, n);
        return copy_to_user(to, from, n);
 }
 
                retval = copy_to_user(*b, from, n);
                n -= retval;
                is_eof = n == 1 && *from == EOF_CHAR(tty);
-               tty_audit_add_data(tty, from, n, ldata->icanon);
+               tty_audit_add_data(tty, from, n);
                smp_store_release(&ldata->read_tail, ldata->read_tail + n);
                /* Turn single EOF into zero-length read */
                if (L_EXTPROC(tty) && ldata->icanon && is_eof &&
 
        unsigned char *data;    /* Allocated size N_TTY_BUF_SIZE */
 };
 
-static struct tty_audit_buf *tty_audit_buf_alloc(int major, int minor,
-                                                unsigned icanon)
+static struct tty_audit_buf *tty_audit_buf_alloc(struct tty_struct *tty)
 {
        struct tty_audit_buf *buf;
 
                goto err_buf;
        atomic_set(&buf->count, 1);
        mutex_init(&buf->mutex);
-       buf->major = major;
-       buf->minor = minor;
-       buf->icanon = icanon;
+       buf->major = tty->driver->major;
+       buf->minor = tty->driver->minor_start + tty->index;
+       buf->icanon = !!L_ICANON(tty);
        buf->valid = 0;
        return buf;
 
  *     if TTY auditing is disabled or out of memory.  Otherwise, return a new
  *     reference to the buffer.
  */
-static struct tty_audit_buf *tty_audit_buf_get(struct tty_struct *tty,
-               unsigned icanon)
+static struct tty_audit_buf *tty_audit_buf_get(struct tty_struct *tty)
 {
        struct tty_audit_buf *buf, *buf2;
        unsigned long flags;
        }
        spin_unlock_irqrestore(¤t->sighand->siglock, flags);
 
-       buf2 = tty_audit_buf_alloc(tty->driver->major,
-                                  tty->driver->minor_start + tty->index,
-                                  icanon);
+       buf2 = tty_audit_buf_alloc(tty);
        if (buf2 == NULL) {
                audit_log_lost("out of memory in TTY auditing");
                return NULL;
  *
  *     Audit @data of @size from @tty, if necessary.
  */
-void tty_audit_add_data(struct tty_struct *tty, const void *data,
-                       size_t size, unsigned icanon)
+void tty_audit_add_data(struct tty_struct *tty, const void *data, size_t size)
 {
        struct tty_audit_buf *buf;
        int major, minor;
        int audit_log_tty_passwd;
        unsigned long flags;
+       unsigned int icanon = !!L_ICANON(tty);
 
        if (unlikely(size == 0))
                return;
        if (!audit_log_tty_passwd && icanon && !L_ECHO(tty))
                return;
 
-       buf = tty_audit_buf_get(tty, icanon);
+       buf = tty_audit_buf_get(tty);
        if (!buf)
                return;
 
 
 /* tty_audit.c */
 #ifdef CONFIG_AUDIT
 extern void tty_audit_add_data(struct tty_struct *tty, const void *data,
-                              size_t size, unsigned icanon);
+                              size_t size);
 extern void tty_audit_exit(void);
 extern void tty_audit_fork(struct signal_struct *sig);
 extern void tty_audit_tiocsti(struct tty_struct *tty, char ch);
 extern int tty_audit_push_current(void);
 #else
 static inline void tty_audit_add_data(struct tty_struct *tty, const void *data,
-                                     size_t size, unsigned icanon)
+                                     size_t size)
 {
 }
 static inline void tty_audit_tiocsti(struct tty_struct *tty, char ch)