linux/drivers/tty/tty_io.c
<<
>>
Prefs
   1/*
   2 *  Copyright (C) 1991, 1992  Linus Torvalds
   3 */
   4
   5/*
   6 * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
   7 * or rs-channels. It also implements echoing, cooked mode etc.
   8 *
   9 * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
  10 *
  11 * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
  12 * tty_struct and tty_queue structures.  Previously there was an array
  13 * of 256 tty_struct's which was statically allocated, and the
  14 * tty_queue structures were allocated at boot time.  Both are now
  15 * dynamically allocated only when the tty is open.
  16 *
  17 * Also restructured routines so that there is more of a separation
  18 * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
  19 * the low-level tty routines (serial.c, pty.c, console.c).  This
  20 * makes for cleaner and more compact code.  -TYT, 9/17/92
  21 *
  22 * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
  23 * which can be dynamically activated and de-activated by the line
  24 * discipline handling modules (like SLIP).
  25 *
  26 * NOTE: pay no attention to the line discipline code (yet); its
  27 * interface is still subject to change in this version...
  28 * -- TYT, 1/31/92
  29 *
  30 * Added functionality to the OPOST tty handling.  No delays, but all
  31 * other bits should be there.
  32 *      -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
  33 *
  34 * Rewrote canonical mode and added more termios flags.
  35 *      -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
  36 *
  37 * Reorganized FASYNC support so mouse code can share it.
  38 *      -- ctm@ardi.com, 9Sep95
  39 *
  40 * New TIOCLINUX variants added.
  41 *      -- mj@k332.feld.cvut.cz, 19-Nov-95
  42 *
  43 * Restrict vt switching via ioctl()
  44 *      -- grif@cs.ucr.edu, 5-Dec-95
  45 *
  46 * Move console and virtual terminal code to more appropriate files,
  47 * implement CONFIG_VT and generalize console device interface.
  48 *      -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
  49 *
  50 * Rewrote tty_init_dev and tty_release_dev to eliminate races.
  51 *      -- Bill Hawes <whawes@star.net>, June 97
  52 *
  53 * Added devfs support.
  54 *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
  55 *
  56 * Added support for a Unix98-style ptmx device.
  57 *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
  58 *
  59 * Reduced memory usage for older ARM systems
  60 *      -- Russell King <rmk@arm.linux.org.uk>
  61 *
  62 * Move do_SAK() into process context.  Less stack use in devfs functions.
  63 * alloc_tty_struct() always uses kmalloc()
  64 *                       -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
  65 */
  66
  67#include <linux/types.h>
  68#include <linux/major.h>
  69#include <linux/errno.h>
  70#include <linux/signal.h>
  71#include <linux/fcntl.h>
  72#include <linux/sched.h>
  73#include <linux/interrupt.h>
  74#include <linux/tty.h>
  75#include <linux/tty_driver.h>
  76#include <linux/tty_flip.h>
  77#include <linux/devpts_fs.h>
  78#include <linux/file.h>
  79#include <linux/fdtable.h>
  80#include <linux/console.h>
  81#include <linux/timer.h>
  82#include <linux/ctype.h>
  83#include <linux/kd.h>
  84#include <linux/mm.h>
  85#include <linux/string.h>
  86#include <linux/slab.h>
  87#include <linux/poll.h>
  88#include <linux/proc_fs.h>
  89#include <linux/init.h>
  90#include <linux/module.h>
  91#include <linux/device.h>
  92#include <linux/wait.h>
  93#include <linux/bitops.h>
  94#include <linux/delay.h>
  95#include <linux/seq_file.h>
  96#include <linux/serial.h>
  97#include <linux/ratelimit.h>
  98
  99#include <linux/uaccess.h>
 100
 101#include <linux/kbd_kern.h>
 102#include <linux/vt_kern.h>
 103#include <linux/selection.h>
 104
 105#include <linux/kmod.h>
 106#include <linux/nsproxy.h>
 107
 108#undef TTY_DEBUG_HANGUP
 109
 110#define TTY_PARANOIA_CHECK 1
 111#define CHECK_TTY_COUNT 1
 112
 113struct ktermios tty_std_termios = {     /* for the benefit of tty drivers  */
 114        .c_iflag = ICRNL | IXON,
 115        .c_oflag = OPOST | ONLCR,
 116        .c_cflag = B38400 | CS8 | CREAD | HUPCL,
 117        .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
 118                   ECHOCTL | ECHOKE | IEXTEN,
 119        .c_cc = INIT_C_CC,
 120        .c_ispeed = 38400,
 121        .c_ospeed = 38400
 122};
 123
 124EXPORT_SYMBOL(tty_std_termios);
 125
 126/* This list gets poked at by procfs and various bits of boot up code. This
 127   could do with some rationalisation such as pulling the tty proc function
 128   into this file */
 129
 130LIST_HEAD(tty_drivers);                 /* linked list of tty drivers */
 131
 132/* Mutex to protect creating and releasing a tty. This is shared with
 133   vt.c for deeply disgusting hack reasons */
 134DEFINE_MUTEX(tty_mutex);
 135EXPORT_SYMBOL(tty_mutex);
 136
 137/* Spinlock to protect the tty->tty_files list */
 138DEFINE_SPINLOCK(tty_files_lock);
 139
 140static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
 141static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
 142ssize_t redirected_tty_write(struct file *, const char __user *,
 143                                                        size_t, loff_t *);
 144static unsigned int tty_poll(struct file *, poll_table *);
 145static int tty_open(struct inode *, struct file *);
 146long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 147#ifdef CONFIG_COMPAT
 148static long tty_compat_ioctl(struct file *file, unsigned int cmd,
 149                                unsigned long arg);
 150#else
 151#define tty_compat_ioctl NULL
 152#endif
 153static int __tty_fasync(int fd, struct file *filp, int on);
 154static int tty_fasync(int fd, struct file *filp, int on);
 155static void release_tty(struct tty_struct *tty, int idx);
 156static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
 157static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty);
 158
 159/**
 160 *      alloc_tty_struct        -       allocate a tty object
 161 *
 162 *      Return a new empty tty structure. The data fields have not
 163 *      been initialized in any way but has been zeroed
 164 *
 165 *      Locking: none
 166 */
 167
 168struct tty_struct *alloc_tty_struct(void)
 169{
 170        return kzalloc(sizeof(struct tty_struct), GFP_KERNEL);
 171}
 172
 173/**
 174 *      free_tty_struct         -       free a disused tty
 175 *      @tty: tty struct to free
 176 *
 177 *      Free the write buffers, tty queue and tty memory itself.
 178 *
 179 *      Locking: none. Must be called after tty is definitely unused
 180 */
 181
 182void free_tty_struct(struct tty_struct *tty)
 183{
 184        if (!tty)
 185                return;
 186        if (tty->dev)
 187                put_device(tty->dev);
 188        kfree(tty->write_buf);
 189        tty->magic = 0xDEADDEAD;
 190        kfree(tty);
 191}
 192
 193static inline struct tty_struct *file_tty(struct file *file)
 194{
 195        return ((struct tty_file_private *)file->private_data)->tty;
 196}
 197
 198int tty_alloc_file(struct file *file)
 199{
 200        struct tty_file_private *priv;
 201
 202        priv = kmalloc(sizeof(*priv), GFP_KERNEL);
 203        if (!priv)
 204                return -ENOMEM;
 205
 206        file->private_data = priv;
 207
 208        return 0;
 209}
 210
 211/* Associate a new file with the tty structure */
 212void tty_add_file(struct tty_struct *tty, struct file *file)
 213{
 214        struct tty_file_private *priv = file->private_data;
 215
 216        priv->tty = tty;
 217        priv->file = file;
 218
 219        spin_lock(&tty_files_lock);
 220        list_add(&priv->list, &tty->tty_files);
 221        spin_unlock(&tty_files_lock);
 222}
 223
 224/**
 225 * tty_free_file - free file->private_data
 226 *
 227 * This shall be used only for fail path handling when tty_add_file was not
 228 * called yet.
 229 */
 230void tty_free_file(struct file *file)
 231{
 232        struct tty_file_private *priv = file->private_data;
 233
 234        file->private_data = NULL;
 235        kfree(priv);
 236}
 237
 238/* Delete file from its tty */
 239static void tty_del_file(struct file *file)
 240{
 241        struct tty_file_private *priv = file->private_data;
 242
 243        spin_lock(&tty_files_lock);
 244        list_del(&priv->list);
 245        spin_unlock(&tty_files_lock);
 246        tty_free_file(file);
 247}
 248
 249
 250#define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
 251
 252/**
 253 *      tty_name        -       return tty naming
 254 *      @tty: tty structure
 255 *      @buf: buffer for output
 256 *
 257 *      Convert a tty structure into a name. The name reflects the kernel
 258 *      naming policy and if udev is in use may not reflect user space
 259 *
 260 *      Locking: none
 261 */
 262
 263char *tty_name(struct tty_struct *tty, char *buf)
 264{
 265        if (!tty) /* Hmm.  NULL pointer.  That's fun. */
 266                strcpy(buf, "NULL tty");
 267        else
 268                strcpy(buf, tty->name);
 269        return buf;
 270}
 271
 272EXPORT_SYMBOL(tty_name);
 273
 274int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
 275                              const char *routine)
 276{
 277#ifdef TTY_PARANOIA_CHECK
 278        if (!tty) {
 279                printk(KERN_WARNING
 280                        "null TTY for (%d:%d) in %s\n",
 281                        imajor(inode), iminor(inode), routine);
 282                return 1;
 283        }
 284        if (tty->magic != TTY_MAGIC) {
 285                printk(KERN_WARNING
 286                        "bad magic number for tty struct (%d:%d) in %s\n",
 287                        imajor(inode), iminor(inode), routine);
 288                return 1;
 289        }
 290#endif
 291        return 0;
 292}
 293
 294static int check_tty_count(struct tty_struct *tty, const char *routine)
 295{
 296#ifdef CHECK_TTY_COUNT
 297        struct list_head *p;
 298        int count = 0;
 299
 300        spin_lock(&tty_files_lock);
 301        list_for_each(p, &tty->tty_files) {
 302                count++;
 303        }
 304        spin_unlock(&tty_files_lock);
 305        if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 306            tty->driver->subtype == PTY_TYPE_SLAVE &&
 307            tty->link && tty->link->count)
 308                count++;
 309        if (tty->count != count) {
 310                printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
 311                                    "!= #fd's(%d) in %s\n",
 312                       tty->name, tty->count, count, routine);
 313                return count;
 314        }
 315#endif
 316        return 0;
 317}
 318
 319/**
 320 *      get_tty_driver          -       find device of a tty
 321 *      @dev_t: device identifier
 322 *      @index: returns the index of the tty
 323 *
 324 *      This routine returns a tty driver structure, given a device number
 325 *      and also passes back the index number.
 326 *
 327 *      Locking: caller must hold tty_mutex
 328 */
 329
 330static struct tty_driver *get_tty_driver(dev_t device, int *index)
 331{
 332        struct tty_driver *p;
 333
 334        list_for_each_entry(p, &tty_drivers, tty_drivers) {
 335                dev_t base = MKDEV(p->major, p->minor_start);
 336                if (device < base || device >= base + p->num)
 337                        continue;
 338                *index = device - base;
 339                return tty_driver_kref_get(p);
 340        }
 341        return NULL;
 342}
 343
 344#ifdef CONFIG_CONSOLE_POLL
 345
 346/**
 347 *      tty_find_polling_driver -       find device of a polled tty
 348 *      @name: name string to match
 349 *      @line: pointer to resulting tty line nr
 350 *
 351 *      This routine returns a tty driver structure, given a name
 352 *      and the condition that the tty driver is capable of polled
 353 *      operation.
 354 */
 355struct tty_driver *tty_find_polling_driver(char *name, int *line)
 356{
 357        struct tty_driver *p, *res = NULL;
 358        int tty_line = 0;
 359        int len;
 360        char *str, *stp;
 361
 362        for (str = name; *str; str++)
 363                if ((*str >= '0' && *str <= '9') || *str == ',')
 364                        break;
 365        if (!*str)
 366                return NULL;
 367
 368        len = str - name;
 369        tty_line = simple_strtoul(str, &str, 10);
 370
 371        mutex_lock(&tty_mutex);
 372        /* Search through the tty devices to look for a match */
 373        list_for_each_entry(p, &tty_drivers, tty_drivers) {
 374                if (strncmp(name, p->name, len) != 0)
 375                        continue;
 376                stp = str;
 377                if (*stp == ',')
 378                        stp++;
 379                if (*stp == '\0')
 380                        stp = NULL;
 381
 382                if (tty_line >= 0 && tty_line < p->num && p->ops &&
 383                    p->ops->poll_init && !p->ops->poll_init(p, tty_line, stp)) {
 384                        res = tty_driver_kref_get(p);
 385                        *line = tty_line;
 386                        break;
 387                }
 388        }
 389        mutex_unlock(&tty_mutex);
 390
 391        return res;
 392}
 393EXPORT_SYMBOL_GPL(tty_find_polling_driver);
 394#endif
 395
 396/**
 397 *      tty_check_change        -       check for POSIX terminal changes
 398 *      @tty: tty to check
 399 *
 400 *      If we try to write to, or set the state of, a terminal and we're
 401 *      not in the foreground, send a SIGTTOU.  If the signal is blocked or
 402 *      ignored, go ahead and perform the operation.  (POSIX 7.2)
 403 *
 404 *      Locking: ctrl_lock
 405 */
 406
 407int tty_check_change(struct tty_struct *tty)
 408{
 409        unsigned long flags;
 410        int ret = 0;
 411
 412        if (current->signal->tty != tty)
 413                return 0;
 414
 415        spin_lock_irqsave(&tty->ctrl_lock, flags);
 416
 417        if (!tty->pgrp) {
 418                printk(KERN_WARNING "tty_check_change: tty->pgrp == NULL!\n");
 419                goto out_unlock;
 420        }
 421        if (task_pgrp(current) == tty->pgrp)
 422                goto out_unlock;
 423        spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 424        if (is_ignored(SIGTTOU))
 425                goto out;
 426        if (is_current_pgrp_orphaned()) {
 427                ret = -EIO;
 428                goto out;
 429        }
 430        kill_pgrp(task_pgrp(current), SIGTTOU, 1);
 431        set_thread_flag(TIF_SIGPENDING);
 432        ret = -ERESTARTSYS;
 433out:
 434        return ret;
 435out_unlock:
 436        spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 437        return ret;
 438}
 439
 440EXPORT_SYMBOL(tty_check_change);
 441
 442static ssize_t hung_up_tty_read(struct file *file, char __user *buf,
 443                                size_t count, loff_t *ppos)
 444{
 445        return 0;
 446}
 447
 448static ssize_t hung_up_tty_write(struct file *file, const char __user *buf,
 449                                 size_t count, loff_t *ppos)
 450{
 451        return -EIO;
 452}
 453
 454/* No kernel lock held - none needed ;) */
 455static unsigned int hung_up_tty_poll(struct file *filp, poll_table *wait)
 456{
 457        return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
 458}
 459
 460static long hung_up_tty_ioctl(struct file *file, unsigned int cmd,
 461                unsigned long arg)
 462{
 463        return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
 464}
 465
 466static long hung_up_tty_compat_ioctl(struct file *file,
 467                                     unsigned int cmd, unsigned long arg)
 468{
 469        return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
 470}
 471
 472static const struct file_operations tty_fops = {
 473        .llseek         = no_llseek,
 474        .read           = tty_read,
 475        .write          = tty_write,
 476        .poll           = tty_poll,
 477        .unlocked_ioctl = tty_ioctl,
 478        .compat_ioctl   = tty_compat_ioctl,
 479        .open           = tty_open,
 480        .release        = tty_release,
 481        .fasync         = tty_fasync,
 482};
 483
 484static const struct file_operations console_fops = {
 485        .llseek         = no_llseek,
 486        .read           = tty_read,
 487        .write          = redirected_tty_write,
 488        .poll           = tty_poll,
 489        .unlocked_ioctl = tty_ioctl,
 490        .compat_ioctl   = tty_compat_ioctl,
 491        .open           = tty_open,
 492        .release        = tty_release,
 493        .fasync         = tty_fasync,
 494};
 495
 496static const struct file_operations hung_up_tty_fops = {
 497        .llseek         = no_llseek,
 498        .read           = hung_up_tty_read,
 499        .write          = hung_up_tty_write,
 500        .poll           = hung_up_tty_poll,
 501        .unlocked_ioctl = hung_up_tty_ioctl,
 502        .compat_ioctl   = hung_up_tty_compat_ioctl,
 503        .release        = tty_release,
 504};
 505
 506static DEFINE_SPINLOCK(redirect_lock);
 507static struct file *redirect;
 508
 509/**
 510 *      tty_wakeup      -       request more data
 511 *      @tty: terminal
 512 *
 513 *      Internal and external helper for wakeups of tty. This function
 514 *      informs the line discipline if present that the driver is ready
 515 *      to receive more output data.
 516 */
 517
 518void tty_wakeup(struct tty_struct *tty)
 519{
 520        struct tty_ldisc *ld;
 521
 522        if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
 523                ld = tty_ldisc_ref(tty);
 524                if (ld) {
 525                        if (ld->ops->write_wakeup)
 526                                ld->ops->write_wakeup(tty);
 527                        tty_ldisc_deref(ld);
 528                }
 529        }
 530        wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
 531}
 532
 533EXPORT_SYMBOL_GPL(tty_wakeup);
 534
 535/**
 536 *      tty_signal_session_leader       - sends SIGHUP to session leader
 537 *      @tty            controlling tty
 538 *      @exit_session   if non-zero, signal all foreground group processes
 539 *
 540 *      Send SIGHUP and SIGCONT to the session leader and its process group.
 541 *      Optionally, signal all processes in the foreground process group.
 542 *
 543 *      Returns the number of processes in the session with this tty
 544 *      as their controlling terminal. This value is used to drop
 545 *      tty references for those processes.
 546 */
 547static int tty_signal_session_leader(struct tty_struct *tty, int exit_session)
 548{
 549        struct task_struct *p;
 550        int refs = 0;
 551        struct pid *tty_pgrp = NULL;
 552
 553        read_lock(&tasklist_lock);
 554        if (tty->session) {
 555                do_each_pid_task(tty->session, PIDTYPE_SID, p) {
 556                        spin_lock_irq(&p->sighand->siglock);
 557                        if (p->signal->tty == tty) {
 558                                p->signal->tty = NULL;
 559                                /* We defer the dereferences outside fo
 560                                   the tasklist lock */
 561                                refs++;
 562                        }
 563                        if (!p->signal->leader) {
 564                                spin_unlock_irq(&p->sighand->siglock);
 565                                continue;
 566                        }
 567                        __group_send_sig_info(SIGHUP, SEND_SIG_PRIV, p);
 568                        __group_send_sig_info(SIGCONT, SEND_SIG_PRIV, p);
 569                        put_pid(p->signal->tty_old_pgrp);  /* A noop */
 570                        spin_lock(&tty->ctrl_lock);
 571                        tty_pgrp = get_pid(tty->pgrp);
 572                        if (tty->pgrp)
 573                                p->signal->tty_old_pgrp = get_pid(tty->pgrp);
 574                        spin_unlock(&tty->ctrl_lock);
 575                        spin_unlock_irq(&p->sighand->siglock);
 576                } while_each_pid_task(tty->session, PIDTYPE_SID, p);
 577        }
 578        read_unlock(&tasklist_lock);
 579
 580        if (tty_pgrp) {
 581                if (exit_session)
 582                        kill_pgrp(tty_pgrp, SIGHUP, exit_session);
 583                put_pid(tty_pgrp);
 584        }
 585
 586        return refs;
 587}
 588
 589/**
 590 *      __tty_hangup            -       actual handler for hangup events
 591 *      @work: tty device
 592 *
 593 *      This can be called by a "kworker" kernel thread.  That is process
 594 *      synchronous but doesn't hold any locks, so we need to make sure we
 595 *      have the appropriate locks for what we're doing.
 596 *
 597 *      The hangup event clears any pending redirections onto the hung up
 598 *      device. It ensures future writes will error and it does the needed
 599 *      line discipline hangup and signal delivery. The tty object itself
 600 *      remains intact.
 601 *
 602 *      Locking:
 603 *              BTM
 604 *                redirect lock for undoing redirection
 605 *                file list lock for manipulating list of ttys
 606 *                tty_ldisc_lock from called functions
 607 *                termios_mutex resetting termios data
 608 *                tasklist_lock to walk task list for hangup event
 609 *                  ->siglock to protect ->signal/->sighand
 610 */
 611static void __tty_hangup(struct tty_struct *tty, int exit_session)
 612{
 613        struct file *cons_filp = NULL;
 614        struct file *filp, *f = NULL;
 615        struct tty_file_private *priv;
 616        int    closecount = 0, n;
 617        int refs;
 618
 619        if (!tty)
 620                return;
 621
 622
 623        spin_lock(&redirect_lock);
 624        if (redirect && file_tty(redirect) == tty) {
 625                f = redirect;
 626                redirect = NULL;
 627        }
 628        spin_unlock(&redirect_lock);
 629
 630        tty_lock(tty);
 631
 632        /* some functions below drop BTM, so we need this bit */
 633        set_bit(TTY_HUPPING, &tty->flags);
 634
 635        /* inuse_filps is protected by the single tty lock,
 636           this really needs to change if we want to flush the
 637           workqueue with the lock held */
 638        check_tty_count(tty, "tty_hangup");
 639
 640        spin_lock(&tty_files_lock);
 641        /* This breaks for file handles being sent over AF_UNIX sockets ? */
 642        list_for_each_entry(priv, &tty->tty_files, list) {
 643                filp = priv->file;
 644                if (filp->f_op->write == redirected_tty_write)
 645                        cons_filp = filp;
 646                if (filp->f_op->write != tty_write)
 647                        continue;
 648                closecount++;
 649                __tty_fasync(-1, filp, 0);      /* can't block */
 650                filp->f_op = &hung_up_tty_fops;
 651        }
 652        spin_unlock(&tty_files_lock);
 653
 654        refs = tty_signal_session_leader(tty, exit_session);
 655        /* Account for the p->signal references we killed */
 656        while (refs--)
 657                tty_kref_put(tty);
 658
 659        /*
 660         * it drops BTM and thus races with reopen
 661         * we protect the race by TTY_HUPPING
 662         */
 663        tty_ldisc_hangup(tty);
 664
 665        spin_lock_irq(&tty->ctrl_lock);
 666        clear_bit(TTY_THROTTLED, &tty->flags);
 667        clear_bit(TTY_PUSH, &tty->flags);
 668        clear_bit(TTY_DO_WRITE_WAKEUP, &tty->flags);
 669        put_pid(tty->session);
 670        put_pid(tty->pgrp);
 671        tty->session = NULL;
 672        tty->pgrp = NULL;
 673        tty->ctrl_status = 0;
 674        spin_unlock_irq(&tty->ctrl_lock);
 675
 676        /*
 677         * If one of the devices matches a console pointer, we
 678         * cannot just call hangup() because that will cause
 679         * tty->count and state->count to go out of sync.
 680         * So we just call close() the right number of times.
 681         */
 682        if (cons_filp) {
 683                if (tty->ops->close)
 684                        for (n = 0; n < closecount; n++)
 685                                tty->ops->close(tty, cons_filp);
 686        } else if (tty->ops->hangup)
 687                (tty->ops->hangup)(tty);
 688        /*
 689         * We don't want to have driver/ldisc interactions beyond
 690         * the ones we did here. The driver layer expects no
 691         * calls after ->hangup() from the ldisc side. However we
 692         * can't yet guarantee all that.
 693         */
 694        set_bit(TTY_HUPPED, &tty->flags);
 695        clear_bit(TTY_HUPPING, &tty->flags);
 696
 697        tty_unlock(tty);
 698
 699        if (f)
 700                fput(f);
 701}
 702
 703static void do_tty_hangup(struct work_struct *work)
 704{
 705        struct tty_struct *tty =
 706                container_of(work, struct tty_struct, hangup_work);
 707
 708        __tty_hangup(tty, 0);
 709}
 710
 711/**
 712 *      tty_hangup              -       trigger a hangup event
 713 *      @tty: tty to hangup
 714 *
 715 *      A carrier loss (virtual or otherwise) has occurred on this like
 716 *      schedule a hangup sequence to run after this event.
 717 */
 718
 719void tty_hangup(struct tty_struct *tty)
 720{
 721#ifdef TTY_DEBUG_HANGUP
 722        char    buf[64];
 723        printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
 724#endif
 725        schedule_work(&tty->hangup_work);
 726}
 727
 728EXPORT_SYMBOL(tty_hangup);
 729
 730/**
 731 *      tty_vhangup             -       process vhangup
 732 *      @tty: tty to hangup
 733 *
 734 *      The user has asked via system call for the terminal to be hung up.
 735 *      We do this synchronously so that when the syscall returns the process
 736 *      is complete. That guarantee is necessary for security reasons.
 737 */
 738
 739void tty_vhangup(struct tty_struct *tty)
 740{
 741#ifdef TTY_DEBUG_HANGUP
 742        char    buf[64];
 743
 744        printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
 745#endif
 746        __tty_hangup(tty, 0);
 747}
 748
 749EXPORT_SYMBOL(tty_vhangup);
 750
 751
 752/**
 753 *      tty_vhangup_self        -       process vhangup for own ctty
 754 *
 755 *      Perform a vhangup on the current controlling tty
 756 */
 757
 758void tty_vhangup_self(void)
 759{
 760        struct tty_struct *tty;
 761
 762        tty = get_current_tty();
 763        if (tty) {
 764                tty_vhangup(tty);
 765                tty_kref_put(tty);
 766        }
 767}
 768
 769/**
 770 *      tty_vhangup_session             -       hangup session leader exit
 771 *      @tty: tty to hangup
 772 *
 773 *      The session leader is exiting and hanging up its controlling terminal.
 774 *      Every process in the foreground process group is signalled SIGHUP.
 775 *
 776 *      We do this synchronously so that when the syscall returns the process
 777 *      is complete. That guarantee is necessary for security reasons.
 778 */
 779
 780static void tty_vhangup_session(struct tty_struct *tty)
 781{
 782#ifdef TTY_DEBUG_HANGUP
 783        char    buf[64];
 784
 785        printk(KERN_DEBUG "%s vhangup session...\n", tty_name(tty, buf));
 786#endif
 787        __tty_hangup(tty, 1);
 788}
 789
 790/**
 791 *      tty_hung_up_p           -       was tty hung up
 792 *      @filp: file pointer of tty
 793 *
 794 *      Return true if the tty has been subject to a vhangup or a carrier
 795 *      loss
 796 */
 797
 798int tty_hung_up_p(struct file *filp)
 799{
 800        return (filp->f_op == &hung_up_tty_fops);
 801}
 802
 803EXPORT_SYMBOL(tty_hung_up_p);
 804
 805static void session_clear_tty(struct pid *session)
 806{
 807        struct task_struct *p;
 808        do_each_pid_task(session, PIDTYPE_SID, p) {
 809                proc_clear_tty(p);
 810        } while_each_pid_task(session, PIDTYPE_SID, p);
 811}
 812
 813/**
 814 *      disassociate_ctty       -       disconnect controlling tty
 815 *      @on_exit: true if exiting so need to "hang up" the session
 816 *
 817 *      This function is typically called only by the session leader, when
 818 *      it wants to disassociate itself from its controlling tty.
 819 *
 820 *      It performs the following functions:
 821 *      (1)  Sends a SIGHUP and SIGCONT to the foreground process group
 822 *      (2)  Clears the tty from being controlling the session
 823 *      (3)  Clears the controlling tty for all processes in the
 824 *              session group.
 825 *
 826 *      The argument on_exit is set to 1 if called when a process is
 827 *      exiting; it is 0 if called by the ioctl TIOCNOTTY.
 828 *
 829 *      Locking:
 830 *              BTM is taken for hysterical raisins, and held when
 831 *                called from no_tty().
 832 *                tty_mutex is taken to protect tty
 833 *                ->siglock is taken to protect ->signal/->sighand
 834 *                tasklist_lock is taken to walk process list for sessions
 835 *                  ->siglock is taken to protect ->signal/->sighand
 836 */
 837
 838void disassociate_ctty(int on_exit)
 839{
 840        struct tty_struct *tty;
 841
 842        if (!current->signal->leader)
 843                return;
 844
 845        tty = get_current_tty();
 846        if (tty) {
 847                if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY) {
 848                        tty_vhangup_session(tty);
 849                } else {
 850                        struct pid *tty_pgrp = tty_get_pgrp(tty);
 851                        if (tty_pgrp) {
 852                                kill_pgrp(tty_pgrp, SIGHUP, on_exit);
 853                                kill_pgrp(tty_pgrp, SIGCONT, on_exit);
 854                                put_pid(tty_pgrp);
 855                        }
 856                }
 857                tty_kref_put(tty);
 858
 859        } else if (on_exit) {
 860                struct pid *old_pgrp;
 861                spin_lock_irq(&current->sighand->siglock);
 862                old_pgrp = current->signal->tty_old_pgrp;
 863                current->signal->tty_old_pgrp = NULL;
 864                spin_unlock_irq(&current->sighand->siglock);
 865                if (old_pgrp) {
 866                        kill_pgrp(old_pgrp, SIGHUP, on_exit);
 867                        kill_pgrp(old_pgrp, SIGCONT, on_exit);
 868                        put_pid(old_pgrp);
 869                }
 870                return;
 871        }
 872
 873        spin_lock_irq(&current->sighand->siglock);
 874        put_pid(current->signal->tty_old_pgrp);
 875        current->signal->tty_old_pgrp = NULL;
 876        spin_unlock_irq(&current->sighand->siglock);
 877
 878        tty = get_current_tty();
 879        if (tty) {
 880                unsigned long flags;
 881                spin_lock_irqsave(&tty->ctrl_lock, flags);
 882                put_pid(tty->session);
 883                put_pid(tty->pgrp);
 884                tty->session = NULL;
 885                tty->pgrp = NULL;
 886                spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 887                tty_kref_put(tty);
 888        } else {
 889#ifdef TTY_DEBUG_HANGUP
 890                printk(KERN_DEBUG "error attempted to write to tty [0x%p]"
 891                       " = NULL", tty);
 892#endif
 893        }
 894
 895        /* Now clear signal->tty under the lock */
 896        read_lock(&tasklist_lock);
 897        session_clear_tty(task_session(current));
 898        read_unlock(&tasklist_lock);
 899}
 900
 901/**
 902 *
 903 *      no_tty  - Ensure the current process does not have a controlling tty
 904 */
 905void no_tty(void)
 906{
 907        /* FIXME: Review locking here. The tty_lock never covered any race
 908           between a new association and proc_clear_tty but possible we need
 909           to protect against this anyway */
 910        struct task_struct *tsk = current;
 911        disassociate_ctty(0);
 912        proc_clear_tty(tsk);
 913}
 914
 915
 916/**
 917 *      stop_tty        -       propagate flow control
 918 *      @tty: tty to stop
 919 *
 920 *      Perform flow control to the driver. For PTY/TTY pairs we
 921 *      must also propagate the TIOCKPKT status. May be called
 922 *      on an already stopped device and will not re-call the driver
 923 *      method.
 924 *
 925 *      This functionality is used by both the line disciplines for
 926 *      halting incoming flow and by the driver. It may therefore be
 927 *      called from any context, may be under the tty atomic_write_lock
 928 *      but not always.
 929 *
 930 *      Locking:
 931 *              Uses the tty control lock internally
 932 */
 933
 934void stop_tty(struct tty_struct *tty)
 935{
 936        unsigned long flags;
 937        spin_lock_irqsave(&tty->ctrl_lock, flags);
 938        if (tty->stopped) {
 939                spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 940                return;
 941        }
 942        tty->stopped = 1;
 943        if (tty->link && tty->link->packet) {
 944                tty->ctrl_status &= ~TIOCPKT_START;
 945                tty->ctrl_status |= TIOCPKT_STOP;
 946                wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
 947        }
 948        spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 949        if (tty->ops->stop)
 950                (tty->ops->stop)(tty);
 951}
 952
 953EXPORT_SYMBOL(stop_tty);
 954
 955/**
 956 *      start_tty       -       propagate flow control
 957 *      @tty: tty to start
 958 *
 959 *      Start a tty that has been stopped if at all possible. Perform
 960 *      any necessary wakeups and propagate the TIOCPKT status. If this
 961 *      is the tty was previous stopped and is being started then the
 962 *      driver start method is invoked and the line discipline woken.
 963 *
 964 *      Locking:
 965 *              ctrl_lock
 966 */
 967
 968void start_tty(struct tty_struct *tty)
 969{
 970        unsigned long flags;
 971        spin_lock_irqsave(&tty->ctrl_lock, flags);
 972        if (!tty->stopped || tty->flow_stopped) {
 973                spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 974                return;
 975        }
 976        tty->stopped = 0;
 977        if (tty->link && tty->link->packet) {
 978                tty->ctrl_status &= ~TIOCPKT_STOP;
 979                tty->ctrl_status |= TIOCPKT_START;
 980                wake_up_interruptible_poll(&tty->link->read_wait, POLLIN);
 981        }
 982        spin_unlock_irqrestore(&tty->ctrl_lock, flags);
 983        if (tty->ops->start)
 984                (tty->ops->start)(tty);
 985        /* If we have a running line discipline it may need kicking */
 986        tty_wakeup(tty);
 987}
 988
 989EXPORT_SYMBOL(start_tty);
 990
 991/* We limit tty time update visibility to every 8 seconds or so. */
 992static void tty_update_time(struct timespec *time)
 993{
 994        unsigned long sec = get_seconds() & ~7;
 995        if ((long)(sec - time->tv_sec) > 0)
 996                time->tv_sec = sec;
 997}
 998
 999/**
1000 *      tty_read        -       read method for tty device files
1001 *      @file: pointer to tty file
1002 *      @buf: user buffer
1003 *      @count: size of user buffer
1004 *      @ppos: unused
1005 *
1006 *      Perform the read system call function on this terminal device. Checks
1007 *      for hung up devices before calling the line discipline method.
1008 *
1009 *      Locking:
1010 *              Locks the line discipline internally while needed. Multiple
1011 *      read calls may be outstanding in parallel.
1012 */
1013
1014static ssize_t tty_read(struct file *file, char __user *buf, size_t count,
1015                        loff_t *ppos)
1016{
1017        int i;
1018        struct inode *inode = file_inode(file);
1019        struct tty_struct *tty = file_tty(file);
1020        struct tty_ldisc *ld;
1021
1022        if (tty_paranoia_check(tty, inode, "tty_read"))
1023                return -EIO;
1024        if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1025                return -EIO;
1026
1027        /* We want to wait for the line discipline to sort out in this
1028           situation */
1029        ld = tty_ldisc_ref_wait(tty);
1030        if (ld->ops->read)
1031                i = (ld->ops->read)(tty, file, buf, count);
1032        else
1033                i = -EIO;
1034        tty_ldisc_deref(ld);
1035
1036        if (i > 0)
1037                tty_update_time(&inode->i_atime);
1038
1039        return i;
1040}
1041
1042void tty_write_unlock(struct tty_struct *tty)
1043        __releases(&tty->atomic_write_lock)
1044{
1045        mutex_unlock(&tty->atomic_write_lock);
1046        wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
1047}
1048
1049int tty_write_lock(struct tty_struct *tty, int ndelay)
1050        __acquires(&tty->atomic_write_lock)
1051{
1052        if (!mutex_trylock(&tty->atomic_write_lock)) {
1053                if (ndelay)
1054                        return -EAGAIN;
1055                if (mutex_lock_interruptible(&tty->atomic_write_lock))
1056                        return -ERESTARTSYS;
1057        }
1058        return 0;
1059}
1060
1061/*
1062 * Split writes up in sane blocksizes to avoid
1063 * denial-of-service type attacks
1064 */
1065static inline ssize_t do_tty_write(
1066        ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char *, size_t),
1067        struct tty_struct *tty,
1068        struct file *file,
1069        const char __user *buf,
1070        size_t count)
1071{
1072        ssize_t ret, written = 0;
1073        unsigned int chunk;
1074
1075        ret = tty_write_lock(tty, file->f_flags & O_NDELAY);
1076        if (ret < 0)
1077                return ret;
1078
1079        /*
1080         * We chunk up writes into a temporary buffer. This
1081         * simplifies low-level drivers immensely, since they
1082         * don't have locking issues and user mode accesses.
1083         *
1084         * But if TTY_NO_WRITE_SPLIT is set, we should use a
1085         * big chunk-size..
1086         *
1087         * The default chunk-size is 2kB, because the NTTY
1088         * layer has problems with bigger chunks. It will
1089         * claim to be able to handle more characters than
1090         * it actually does.
1091         *
1092         * FIXME: This can probably go away now except that 64K chunks
1093         * are too likely to fail unless switched to vmalloc...
1094         */
1095        chunk = 2048;
1096        if (test_bit(TTY_NO_WRITE_SPLIT, &tty->flags))
1097                chunk = 65536;
1098        if (count < chunk)
1099                chunk = count;
1100
1101        /* write_buf/write_cnt is protected by the atomic_write_lock mutex */
1102        if (tty->write_cnt < chunk) {
1103                unsigned char *buf_chunk;
1104
1105                if (chunk < 1024)
1106                        chunk = 1024;
1107
1108                buf_chunk = kmalloc(chunk, GFP_KERNEL);
1109                if (!buf_chunk) {
1110                        ret = -ENOMEM;
1111                        goto out;
1112                }
1113                kfree(tty->write_buf);
1114                tty->write_cnt = chunk;
1115                tty->write_buf = buf_chunk;
1116        }
1117
1118        /* Do the write .. */
1119        for (;;) {
1120                size_t size = count;
1121                if (size > chunk)
1122                        size = chunk;
1123                ret = -EFAULT;
1124                if (copy_from_user(tty->write_buf, buf, size))
1125                        break;
1126                ret = write(tty, file, tty->write_buf, size);
1127                if (ret <= 0)
1128                        break;
1129                written += ret;
1130                buf += ret;
1131                count -= ret;
1132                if (!count)
1133                        break;
1134                ret = -ERESTARTSYS;
1135                if (signal_pending(current))
1136                        break;
1137                cond_resched();
1138        }
1139        if (written) {
1140                tty_update_time(&file_inode(file)->i_mtime);
1141                ret = written;
1142        }
1143out:
1144        tty_write_unlock(tty);
1145        return ret;
1146}
1147
1148/**
1149 * tty_write_message - write a message to a certain tty, not just the console.
1150 * @tty: the destination tty_struct
1151 * @msg: the message to write
1152 *
1153 * This is used for messages that need to be redirected to a specific tty.
1154 * We don't put it into the syslog queue right now maybe in the future if
1155 * really needed.
1156 *
1157 * We must still hold the BTM and test the CLOSING flag for the moment.
1158 */
1159
1160void tty_write_message(struct tty_struct *tty, char *msg)
1161{
1162        if (tty) {
1163                mutex_lock(&tty->atomic_write_lock);
1164                tty_lock(tty);
1165                if (tty->ops->write && !test_bit(TTY_CLOSING, &tty->flags)) {
1166                        tty_unlock(tty);
1167                        tty->ops->write(tty, msg, strlen(msg));
1168                } else
1169                        tty_unlock(tty);
1170                tty_write_unlock(tty);
1171        }
1172        return;
1173}
1174
1175
1176/**
1177 *      tty_write               -       write method for tty device file
1178 *      @file: tty file pointer
1179 *      @buf: user data to write
1180 *      @count: bytes to write
1181 *      @ppos: unused
1182 *
1183 *      Write data to a tty device via the line discipline.
1184 *
1185 *      Locking:
1186 *              Locks the line discipline as required
1187 *              Writes to the tty driver are serialized by the atomic_write_lock
1188 *      and are then processed in chunks to the device. The line discipline
1189 *      write method will not be invoked in parallel for each device.
1190 */
1191
1192static ssize_t tty_write(struct file *file, const char __user *buf,
1193                                                size_t count, loff_t *ppos)
1194{
1195        struct tty_struct *tty = file_tty(file);
1196        struct tty_ldisc *ld;
1197        ssize_t ret;
1198
1199        if (tty_paranoia_check(tty, file_inode(file), "tty_write"))
1200                return -EIO;
1201        if (!tty || !tty->ops->write ||
1202                (test_bit(TTY_IO_ERROR, &tty->flags)))
1203                        return -EIO;
1204        /* Short term debug to catch buggy drivers */
1205        if (tty->ops->write_room == NULL)
1206                printk(KERN_ERR "tty driver %s lacks a write_room method.\n",
1207                        tty->driver->name);
1208        ld = tty_ldisc_ref_wait(tty);
1209        if (!ld->ops->write)
1210                ret = -EIO;
1211        else
1212                ret = do_tty_write(ld->ops->write, tty, file, buf, count);
1213        tty_ldisc_deref(ld);
1214        return ret;
1215}
1216
1217ssize_t redirected_tty_write(struct file *file, const char __user *buf,
1218                                                size_t count, loff_t *ppos)
1219{
1220        struct file *p = NULL;
1221
1222        spin_lock(&redirect_lock);
1223        if (redirect)
1224                p = get_file(redirect);
1225        spin_unlock(&redirect_lock);
1226
1227        if (p) {
1228                ssize_t res;
1229                res = vfs_write(p, buf, count, &p->f_pos);
1230                fput(p);
1231                return res;
1232        }
1233        return tty_write(file, buf, count, ppos);
1234}
1235
1236static char ptychar[] = "pqrstuvwxyzabcde";
1237
1238/**
1239 *      pty_line_name   -       generate name for a pty
1240 *      @driver: the tty driver in use
1241 *      @index: the minor number
1242 *      @p: output buffer of at least 6 bytes
1243 *
1244 *      Generate a name from a driver reference and write it to the output
1245 *      buffer.
1246 *
1247 *      Locking: None
1248 */
1249static void pty_line_name(struct tty_driver *driver, int index, char *p)
1250{
1251        int i = index + driver->name_base;
1252        /* ->name is initialized to "ttyp", but "tty" is expected */
1253        sprintf(p, "%s%c%x",
1254                driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1255                ptychar[i >> 4 & 0xf], i & 0xf);
1256}
1257
1258/**
1259 *      tty_line_name   -       generate name for a tty
1260 *      @driver: the tty driver in use
1261 *      @index: the minor number
1262 *      @p: output buffer of at least 7 bytes
1263 *
1264 *      Generate a name from a driver reference and write it to the output
1265 *      buffer.
1266 *
1267 *      Locking: None
1268 */
1269static void tty_line_name(struct tty_driver *driver, int index, char *p)
1270{
1271        if (driver->flags & TTY_DRIVER_UNNUMBERED_NODE)
1272                strcpy(p, driver->name);
1273        else
1274                sprintf(p, "%s%d", driver->name, index + driver->name_base);
1275}
1276
1277/**
1278 *      tty_driver_lookup_tty() - find an existing tty, if any
1279 *      @driver: the driver for the tty
1280 *      @idx:    the minor number
1281 *
1282 *      Return the tty, if found or ERR_PTR() otherwise.
1283 *
1284 *      Locking: tty_mutex must be held. If tty is found, the mutex must
1285 *      be held until the 'fast-open' is also done. Will change once we
1286 *      have refcounting in the driver and per driver locking
1287 */
1288static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
1289                struct inode *inode, int idx)
1290{
1291        if (driver->ops->lookup)
1292                return driver->ops->lookup(driver, inode, idx);
1293
1294        return driver->ttys[idx];
1295}
1296
1297/**
1298 *      tty_init_termios        -  helper for termios setup
1299 *      @tty: the tty to set up
1300 *
1301 *      Initialise the termios structures for this tty. Thus runs under
1302 *      the tty_mutex currently so we can be relaxed about ordering.
1303 */
1304
1305int tty_init_termios(struct tty_struct *tty)
1306{
1307        struct ktermios *tp;
1308        int idx = tty->index;
1309
1310        if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1311                tty->termios = tty->driver->init_termios;
1312        else {
1313                /* Check for lazy saved data */
1314                tp = tty->driver->termios[idx];
1315                if (tp != NULL)
1316                        tty->termios = *tp;
1317                else
1318                        tty->termios = tty->driver->init_termios;
1319        }
1320        /* Compatibility until drivers always set this */
1321        tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
1322        tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
1323        return 0;
1324}
1325EXPORT_SYMBOL_GPL(tty_init_termios);
1326
1327int tty_standard_install(struct tty_driver *driver, struct tty_struct *tty)
1328{
1329        int ret = tty_init_termios(tty);
1330        if (ret)
1331                return ret;
1332
1333        tty_driver_kref_get(driver);
1334        tty->count++;
1335        driver->ttys[tty->index] = tty;
1336        return 0;
1337}
1338EXPORT_SYMBOL_GPL(tty_standard_install);
1339
1340/**
1341 *      tty_driver_install_tty() - install a tty entry in the driver
1342 *      @driver: the driver for the tty
1343 *      @tty: the tty
1344 *
1345 *      Install a tty object into the driver tables. The tty->index field
1346 *      will be set by the time this is called. This method is responsible
1347 *      for ensuring any need additional structures are allocated and
1348 *      configured.
1349 *
1350 *      Locking: tty_mutex for now
1351 */
1352static int tty_driver_install_tty(struct tty_driver *driver,
1353                                                struct tty_struct *tty)
1354{
1355        return driver->ops->install ? driver->ops->install(driver, tty) :
1356                tty_standard_install(driver, tty);
1357}
1358
1359/**
1360 *      tty_driver_remove_tty() - remove a tty from the driver tables
1361 *      @driver: the driver for the tty
1362 *      @idx:    the minor number
1363 *
1364 *      Remvoe a tty object from the driver tables. The tty->index field
1365 *      will be set by the time this is called.
1366 *
1367 *      Locking: tty_mutex for now
1368 */
1369void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *tty)
1370{
1371        if (driver->ops->remove)
1372                driver->ops->remove(driver, tty);
1373        else
1374                driver->ttys[tty->index] = NULL;
1375}
1376
1377/*
1378 *      tty_reopen()    - fast re-open of an open tty
1379 *      @tty    - the tty to open
1380 *
1381 *      Return 0 on success, -errno on error.
1382 *
1383 *      Locking: tty_mutex must be held from the time the tty was found
1384 *               till this open completes.
1385 */
1386static int tty_reopen(struct tty_struct *tty)
1387{
1388        struct tty_driver *driver = tty->driver;
1389
1390        if (test_bit(TTY_CLOSING, &tty->flags) ||
1391                        test_bit(TTY_HUPPING, &tty->flags) ||
1392                        test_bit(TTY_LDISC_CHANGING, &tty->flags))
1393                return -EIO;
1394
1395        if (driver->type == TTY_DRIVER_TYPE_PTY &&
1396            driver->subtype == PTY_TYPE_MASTER) {
1397                /*
1398                 * special case for PTY masters: only one open permitted,
1399                 * and the slave side open count is incremented as well.
1400                 */
1401                if (tty->count)
1402                        return -EIO;
1403
1404                tty->link->count++;
1405        }
1406        tty->count++;
1407
1408        WARN_ON(!test_bit(TTY_LDISC, &tty->flags));
1409
1410        return 0;
1411}
1412
1413/**
1414 *      tty_init_dev            -       initialise a tty device
1415 *      @driver: tty driver we are opening a device on
1416 *      @idx: device index
1417 *      @ret_tty: returned tty structure
1418 *
1419 *      Prepare a tty device. This may not be a "new" clean device but
1420 *      could also be an active device. The pty drivers require special
1421 *      handling because of this.
1422 *
1423 *      Locking:
1424 *              The function is called under the tty_mutex, which
1425 *      protects us from the tty struct or driver itself going away.
1426 *
1427 *      On exit the tty device has the line discipline attached and
1428 *      a reference count of 1. If a pair was created for pty/tty use
1429 *      and the other was a pty master then it too has a reference count of 1.
1430 *
1431 * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1432 * failed open.  The new code protects the open with a mutex, so it's
1433 * really quite straightforward.  The mutex locking can probably be
1434 * relaxed for the (most common) case of reopening a tty.
1435 */
1436
1437struct tty_struct *tty_init_dev(struct tty_driver *driver, int idx)
1438{
1439        struct tty_struct *tty;
1440        int retval;
1441
1442        /*
1443         * First time open is complex, especially for PTY devices.
1444         * This code guarantees that either everything succeeds and the
1445         * TTY is ready for operation, or else the table slots are vacated
1446         * and the allocated memory released.  (Except that the termios
1447         * and locked termios may be retained.)
1448         */
1449
1450        if (!try_module_get(driver->owner))
1451                return ERR_PTR(-ENODEV);
1452
1453        tty = alloc_tty_struct();
1454        if (!tty) {
1455                retval = -ENOMEM;
1456                goto err_module_put;
1457        }
1458        initialize_tty_struct(tty, driver, idx);
1459
1460        tty_lock(tty);
1461        retval = tty_driver_install_tty(driver, tty);
1462        if (retval < 0)
1463                goto err_deinit_tty;
1464
1465        if (!tty->port)
1466                tty->port = driver->ports[idx];
1467
1468        WARN_RATELIMIT(!tty->port,
1469                        "%s: %s driver does not set tty->port. This will crash the kernel later. Fix the driver!\n",
1470                        __func__, tty->driver->name);
1471
1472        tty->port->itty = tty;
1473
1474        /*
1475         * Structures all installed ... call the ldisc open routines.
1476         * If we fail here just call release_tty to clean up.  No need
1477         * to decrement the use counts, as release_tty doesn't care.
1478         */
1479        retval = tty_ldisc_setup(tty, tty->link);
1480        if (retval)
1481                goto err_release_tty;
1482        /* Return the tty locked so that it cannot vanish under the caller */
1483        return tty;
1484
1485err_deinit_tty:
1486        tty_unlock(tty);
1487        deinitialize_tty_struct(tty);
1488        free_tty_struct(tty);
1489err_module_put:
1490        module_put(driver->owner);
1491        return ERR_PTR(retval);
1492
1493        /* call the tty release_tty routine to clean out this slot */
1494err_release_tty:
1495        tty_unlock(tty);
1496        printk_ratelimited(KERN_INFO "tty_init_dev: ldisc open failed, "
1497                                 "clearing slot %d\n", idx);
1498        release_tty(tty, idx);
1499        return ERR_PTR(retval);
1500}
1501
1502void tty_free_termios(struct tty_struct *tty)
1503{
1504        struct ktermios *tp;
1505        int idx = tty->index;
1506
1507        /* If the port is going to reset then it has no termios to save */
1508        if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
1509                return;
1510
1511        /* Stash the termios data */
1512        tp = tty->driver->termios[idx];
1513        if (tp == NULL) {
1514                tp = kmalloc(sizeof(struct ktermios), GFP_KERNEL);
1515                if (tp == NULL) {
1516                        pr_warn("tty: no memory to save termios state.\n");
1517                        return;
1518                }
1519                tty->driver->termios[idx] = tp;
1520        }
1521        *tp = tty->termios;
1522}
1523EXPORT_SYMBOL(tty_free_termios);
1524
1525/**
1526 *      tty_flush_works         -       flush all works of a tty
1527 *      @tty: tty device to flush works for
1528 *
1529 *      Sync flush all works belonging to @tty.
1530 */
1531static void tty_flush_works(struct tty_struct *tty)
1532{
1533        flush_work(&tty->SAK_work);
1534        flush_work(&tty->hangup_work);
1535}
1536
1537/**
1538 *      release_one_tty         -       release tty structure memory
1539 *      @kref: kref of tty we are obliterating
1540 *
1541 *      Releases memory associated with a tty structure, and clears out the
1542 *      driver table slots. This function is called when a device is no longer
1543 *      in use. It also gets called when setup of a device fails.
1544 *
1545 *      Locking:
1546 *              takes the file list lock internally when working on the list
1547 *      of ttys that the driver keeps.
1548 *
1549 *      This method gets called from a work queue so that the driver private
1550 *      cleanup ops can sleep (needed for USB at least)
1551 */
1552static void release_one_tty(struct work_struct *work)
1553{
1554        struct tty_struct *tty =
1555                container_of(work, struct tty_struct, hangup_work);
1556        struct tty_driver *driver = tty->driver;
1557
1558        if (tty->ops->cleanup)
1559                tty->ops->cleanup(tty);
1560
1561        tty->magic = 0;
1562        tty_driver_kref_put(driver);
1563        module_put(driver->owner);
1564
1565        spin_lock(&tty_files_lock);
1566        list_del_init(&tty->tty_files);
1567        spin_unlock(&tty_files_lock);
1568
1569        put_pid(tty->pgrp);
1570        put_pid(tty->session);
1571        free_tty_struct(tty);
1572}
1573
1574static void queue_release_one_tty(struct kref *kref)
1575{
1576        struct tty_struct *tty = container_of(kref, struct tty_struct, kref);
1577
1578        /* The hangup queue is now free so we can reuse it rather than
1579           waste a chunk of memory for each port */
1580        INIT_WORK(&tty->hangup_work, release_one_tty);
1581        schedule_work(&tty->hangup_work);
1582}
1583
1584/**
1585 *      tty_kref_put            -       release a tty kref
1586 *      @tty: tty device
1587 *
1588 *      Release a reference to a tty device and if need be let the kref
1589 *      layer destruct the object for us
1590 */
1591
1592void tty_kref_put(struct tty_struct *tty)
1593{
1594        if (tty)
1595                kref_put(&tty->kref, queue_release_one_tty);
1596}
1597EXPORT_SYMBOL(tty_kref_put);
1598
1599/**
1600 *      release_tty             -       release tty structure memory
1601 *
1602 *      Release both @tty and a possible linked partner (think pty pair),
1603 *      and decrement the refcount of the backing module.
1604 *
1605 *      Locking:
1606 *              tty_mutex
1607 *              takes the file list lock internally when working on the list
1608 *      of ttys that the driver keeps.
1609 *
1610 */
1611static void release_tty(struct tty_struct *tty, int idx)
1612{
1613        /* This should always be true but check for the moment */
1614        WARN_ON(tty->index != idx);
1615        WARN_ON(!mutex_is_locked(&tty_mutex));
1616        if (tty->ops->shutdown)
1617                tty->ops->shutdown(tty);
1618        tty_free_termios(tty);
1619        tty_driver_remove_tty(tty->driver, tty);
1620        tty->port->itty = NULL;
1621        if (tty->link)
1622                tty->link->port->itty = NULL;
1623        cancel_work_sync(&tty->port->buf.work);
1624
1625        if (tty->link)
1626                tty_kref_put(tty->link);
1627        tty_kref_put(tty);
1628}
1629
1630/**
1631 *      tty_release_checks - check a tty before real release
1632 *      @tty: tty to check
1633 *      @o_tty: link of @tty (if any)
1634 *      @idx: index of the tty
1635 *
1636 *      Performs some paranoid checking before true release of the @tty.
1637 *      This is a no-op unless TTY_PARANOIA_CHECK is defined.
1638 */
1639static int tty_release_checks(struct tty_struct *tty, struct tty_struct *o_tty,
1640                int idx)
1641{
1642#ifdef TTY_PARANOIA_CHECK
1643        if (idx < 0 || idx >= tty->driver->num) {
1644                printk(KERN_DEBUG "%s: bad idx when trying to free (%s)\n",
1645                                __func__, tty->name);
1646                return -1;
1647        }
1648
1649        /* not much to check for devpts */
1650        if (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)
1651                return 0;
1652
1653        if (tty != tty->driver->ttys[idx]) {
1654                printk(KERN_DEBUG "%s: driver.table[%d] not tty for (%s)\n",
1655                                __func__, idx, tty->name);
1656                return -1;
1657        }
1658        if (tty->driver->other) {
1659                if (o_tty != tty->driver->other->ttys[idx]) {
1660                        printk(KERN_DEBUG "%s: other->table[%d] not o_tty for (%s)\n",
1661                                        __func__, idx, tty->name);
1662                        return -1;
1663                }
1664                if (o_tty->link != tty) {
1665                        printk(KERN_DEBUG "%s: bad pty pointers\n", __func__);
1666                        return -1;
1667                }
1668        }
1669#endif
1670        return 0;
1671}
1672
1673/**
1674 *      tty_release             -       vfs callback for close
1675 *      @inode: inode of tty
1676 *      @filp: file pointer for handle to tty
1677 *
1678 *      Called the last time each file handle is closed that references
1679 *      this tty. There may however be several such references.
1680 *
1681 *      Locking:
1682 *              Takes bkl. See tty_release_dev
1683 *
1684 * Even releasing the tty structures is a tricky business.. We have
1685 * to be very careful that the structures are all released at the
1686 * same time, as interrupts might otherwise get the wrong pointers.
1687 *
1688 * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1689 * lead to double frees or releasing memory still in use.
1690 */
1691
1692int tty_release(struct inode *inode, struct file *filp)
1693{
1694        struct tty_struct *tty = file_tty(filp);
1695        struct tty_struct *o_tty;
1696        int     pty_master, tty_closing, o_tty_closing, do_sleep;
1697        int     idx;
1698        char    buf[64];
1699
1700        if (tty_paranoia_check(tty, inode, __func__))
1701                return 0;
1702
1703        tty_lock(tty);
1704        check_tty_count(tty, __func__);
1705
1706        __tty_fasync(-1, filp, 0);
1707
1708        idx = tty->index;
1709        pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1710                      tty->driver->subtype == PTY_TYPE_MASTER);
1711        /* Review: parallel close */
1712        o_tty = tty->link;
1713
1714        if (tty_release_checks(tty, o_tty, idx)) {
1715                tty_unlock(tty);
1716                return 0;
1717        }
1718
1719#ifdef TTY_DEBUG_HANGUP
1720        printk(KERN_DEBUG "%s: %s (tty count=%d)...\n", __func__,
1721                        tty_name(tty, buf), tty->count);
1722#endif
1723
1724        if (tty->ops->close)
1725                tty->ops->close(tty, filp);
1726
1727        tty_unlock(tty);
1728        /*
1729         * Sanity check: if tty->count is going to zero, there shouldn't be
1730         * any waiters on tty->read_wait or tty->write_wait.  We test the
1731         * wait queues and kick everyone out _before_ actually starting to
1732         * close.  This ensures that we won't block while releasing the tty
1733         * structure.
1734         *
1735         * The test for the o_tty closing is necessary, since the master and
1736         * slave sides may close in any order.  If the slave side closes out
1737         * first, its count will be one, since the master side holds an open.
1738         * Thus this test wouldn't be triggered at the time the slave closes,
1739         * so we do it now.
1740         *
1741         * Note that it's possible for the tty to be opened again while we're
1742         * flushing out waiters.  By recalculating the closing flags before
1743         * each iteration we avoid any problems.
1744         */
1745        while (1) {
1746                /* Guard against races with tty->count changes elsewhere and
1747                   opens on /dev/tty */
1748
1749                mutex_lock(&tty_mutex);
1750                tty_lock_pair(tty, o_tty);
1751                tty_closing = tty->count <= 1;
1752                o_tty_closing = o_tty &&
1753                        (o_tty->count <= (pty_master ? 1 : 0));
1754                do_sleep = 0;
1755
1756                if (tty_closing) {
1757                        if (waitqueue_active(&tty->read_wait)) {
1758                                wake_up_poll(&tty->read_wait, POLLIN);
1759                                do_sleep++;
1760                        }
1761                        if (waitqueue_active(&tty->write_wait)) {
1762                                wake_up_poll(&tty->write_wait, POLLOUT);
1763                                do_sleep++;
1764                        }
1765                }
1766                if (o_tty_closing) {
1767                        if (waitqueue_active(&o_tty->read_wait)) {
1768                                wake_up_poll(&o_tty->read_wait, POLLIN);
1769                                do_sleep++;
1770                        }
1771                        if (waitqueue_active(&o_tty->write_wait)) {
1772                                wake_up_poll(&o_tty->write_wait, POLLOUT);
1773                                do_sleep++;
1774                        }
1775                }
1776                if (!do_sleep)
1777                        break;
1778
1779                printk(KERN_WARNING "%s: %s: read/write wait queue active!\n",
1780                                __func__, tty_name(tty, buf));
1781                tty_unlock_pair(tty, o_tty);
1782                mutex_unlock(&tty_mutex);
1783                schedule();
1784        }
1785
1786        /*
1787         * The closing flags are now consistent with the open counts on
1788         * both sides, and we've completed the last operation that could
1789         * block, so it's safe to proceed with closing.
1790         *
1791         * We must *not* drop the tty_mutex until we ensure that a further
1792         * entry into tty_open can not pick up this tty.
1793         */
1794        if (pty_master) {
1795                if (--o_tty->count < 0) {
1796                        printk(KERN_WARNING "%s: bad pty slave count (%d) for %s\n",
1797                                __func__, o_tty->count, tty_name(o_tty, buf));
1798                        o_tty->count = 0;
1799                }
1800        }
1801        if (--tty->count < 0) {
1802                printk(KERN_WARNING "%s: bad tty->count (%d) for %s\n",
1803                                __func__, tty->count, tty_name(tty, buf));
1804                tty->count = 0;
1805        }
1806
1807        /*
1808         * We've decremented tty->count, so we need to remove this file
1809         * descriptor off the tty->tty_files list; this serves two
1810         * purposes:
1811         *  - check_tty_count sees the correct number of file descriptors
1812         *    associated with this tty.
1813         *  - do_tty_hangup no longer sees this file descriptor as
1814         *    something that needs to be handled for hangups.
1815         */
1816        tty_del_file(filp);
1817
1818        /*
1819         * Perform some housekeeping before deciding whether to return.
1820         *
1821         * Set the TTY_CLOSING flag if this was the last open.  In the
1822         * case of a pty we may have to wait around for the other side
1823         * to close, and TTY_CLOSING makes sure we can't be reopened.
1824         */
1825        if (tty_closing)
1826                set_bit(TTY_CLOSING, &tty->flags);
1827        if (o_tty_closing)
1828                set_bit(TTY_CLOSING, &o_tty->flags);
1829
1830        /*
1831         * If _either_ side is closing, make sure there aren't any
1832         * processes that still think tty or o_tty is their controlling
1833         * tty.
1834         */
1835        if (tty_closing || o_tty_closing) {
1836                read_lock(&tasklist_lock);
1837                session_clear_tty(tty->session);
1838                if (o_tty)
1839                        session_clear_tty(o_tty->session);
1840                read_unlock(&tasklist_lock);
1841        }
1842
1843        mutex_unlock(&tty_mutex);
1844        tty_unlock_pair(tty, o_tty);
1845        /* At this point the TTY_CLOSING flag should ensure a dead tty
1846           cannot be re-opened by a racing opener */
1847
1848        /* check whether both sides are closing ... */
1849        if (!tty_closing || (o_tty && !o_tty_closing))
1850                return 0;
1851
1852#ifdef TTY_DEBUG_HANGUP
1853        printk(KERN_DEBUG "%s: %s: final close\n", __func__, tty_name(tty, buf));
1854#endif
1855        /*
1856         * Ask the line discipline code to release its structures
1857         */
1858        tty_ldisc_release(tty, o_tty);
1859
1860        /* Wait for pending work before tty destruction commmences */
1861        tty_flush_works(tty);
1862        if (o_tty)
1863                tty_flush_works(o_tty);
1864
1865#ifdef TTY_DEBUG_HANGUP
1866        printk(KERN_DEBUG "%s: %s: freeing structure...\n", __func__, tty_name(tty, buf));
1867#endif
1868        /*
1869         * The release_tty function takes care of the details of clearing
1870         * the slots and preserving the termios structure. The tty_unlock_pair
1871         * should be safe as we keep a kref while the tty is locked (so the
1872         * unlock never unlocks a freed tty).
1873         */
1874        mutex_lock(&tty_mutex);
1875        release_tty(tty, idx);
1876        mutex_unlock(&tty_mutex);
1877
1878        return 0;
1879}
1880
1881/**
1882 *      tty_open_current_tty - get tty of current task for open
1883 *      @device: device number
1884 *      @filp: file pointer to tty
1885 *      @return: tty of the current task iff @device is /dev/tty
1886 *
1887 *      We cannot return driver and index like for the other nodes because
1888 *      devpts will not work then. It expects inodes to be from devpts FS.
1889 *
1890 *      We need to move to returning a refcounted object from all the lookup
1891 *      paths including this one.
1892 */
1893static struct tty_struct *tty_open_current_tty(dev_t device, struct file *filp)
1894{
1895        struct tty_struct *tty;
1896
1897        if (device != MKDEV(TTYAUX_MAJOR, 0))
1898                return NULL;
1899
1900        tty = get_current_tty();
1901        if (!tty)
1902                return ERR_PTR(-ENXIO);
1903
1904        filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1905        /* noctty = 1; */
1906        tty_kref_put(tty);
1907        /* FIXME: we put a reference and return a TTY! */
1908        /* This is only safe because the caller holds tty_mutex */
1909        return tty;
1910}
1911
1912/**
1913 *      tty_lookup_driver - lookup a tty driver for a given device file
1914 *      @device: device number
1915 *      @filp: file pointer to tty
1916 *      @noctty: set if the device should not become a controlling tty
1917 *      @index: index for the device in the @return driver
1918 *      @return: driver for this inode (with increased refcount)
1919 *
1920 *      If @return is not erroneous, the caller is responsible to decrement the
1921 *      refcount by tty_driver_kref_put.
1922 *
1923 *      Locking: tty_mutex protects get_tty_driver
1924 */
1925static struct tty_driver *tty_lookup_driver(dev_t device, struct file *filp,
1926                int *noctty, int *index)
1927{
1928        struct tty_driver *driver;
1929
1930        switch (device) {
1931#ifdef CONFIG_VT
1932        case MKDEV(TTY_MAJOR, 0): {
1933                extern struct tty_driver *console_driver;
1934                driver = tty_driver_kref_get(console_driver);
1935                *index = fg_console;
1936                *noctty = 1;
1937                break;
1938        }
1939#endif
1940        case MKDEV(TTYAUX_MAJOR, 1): {
1941                struct tty_driver *console_driver = console_device(index);
1942                if (console_driver) {
1943                        driver = tty_driver_kref_get(console_driver);
1944                        if (driver) {
1945                                /* Don't let /dev/console block */
1946                                filp->f_flags |= O_NONBLOCK;
1947                                *noctty = 1;
1948                                break;
1949                        }
1950                }
1951                return ERR_PTR(-ENODEV);
1952        }
1953        default:
1954                driver = get_tty_driver(device, index);
1955                if (!driver)
1956                        return ERR_PTR(-ENODEV);
1957                break;
1958        }
1959        return driver;
1960}
1961
1962/**
1963 *      tty_open                -       open a tty device
1964 *      @inode: inode of device file
1965 *      @filp: file pointer to tty
1966 *
1967 *      tty_open and tty_release keep up the tty count that contains the
1968 *      number of opens done on a tty. We cannot use the inode-count, as
1969 *      different inodes might point to the same tty.
1970 *
1971 *      Open-counting is needed for pty masters, as well as for keeping
1972 *      track of serial lines: DTR is dropped when the last close happens.
1973 *      (This is not done solely through tty->count, now.  - Ted 1/27/92)
1974 *
1975 *      The termios state of a pty is reset on first open so that
1976 *      settings don't persist across reuse.
1977 *
1978 *      Locking: tty_mutex protects tty, tty_lookup_driver and tty_init_dev.
1979 *               tty->count should protect the rest.
1980 *               ->siglock protects ->signal/->sighand
1981 *
1982 *      Note: the tty_unlock/lock cases without a ref are only safe due to
1983 *      tty_mutex
1984 */
1985
1986static int tty_open(struct inode *inode, struct file *filp)
1987{
1988        struct tty_struct *tty;
1989        int noctty, retval;
1990        struct tty_driver *driver = NULL;
1991        int index;
1992        dev_t device = inode->i_rdev;
1993        unsigned saved_flags = filp->f_flags;
1994
1995        nonseekable_open(inode, filp);
1996
1997retry_open:
1998        retval = tty_alloc_file(filp);
1999        if (retval)
2000                return -ENOMEM;
2001
2002        noctty = filp->f_flags & O_NOCTTY;
2003        index  = -1;
2004        retval = 0;
2005
2006        mutex_lock(&tty_mutex);
2007        /* This is protected by the tty_mutex */
2008        tty = tty_open_current_tty(device, filp);
2009        if (IS_ERR(tty)) {
2010                retval = PTR_ERR(tty);
2011                goto err_unlock;
2012        } else if (!tty) {
2013                driver = tty_lookup_driver(device, filp, &noctty, &index);
2014                if (IS_ERR(driver)) {
2015                        retval = PTR_ERR(driver);
2016                        goto err_unlock;
2017                }
2018
2019                /* check whether we're reopening an existing tty */
2020                tty = tty_driver_lookup_tty(driver, inode, index);
2021                if (IS_ERR(tty)) {
2022                        retval = PTR_ERR(tty);
2023                        goto err_unlock;
2024                }
2025        }
2026
2027        if (tty) {
2028                tty_lock(tty);
2029                retval = tty_reopen(tty);
2030                if (retval < 0) {
2031                        tty_unlock(tty);
2032                        tty = ERR_PTR(retval);
2033                }
2034        } else  /* Returns with the tty_lock held for now */
2035                tty = tty_init_dev(driver, index);
2036
2037        mutex_unlock(&tty_mutex);
2038        if (driver)
2039                tty_driver_kref_put(driver);
2040        if (IS_ERR(tty)) {
2041                retval = PTR_ERR(tty);
2042                goto err_file;
2043        }
2044
2045        tty_add_file(tty, filp);
2046
2047        check_tty_count(tty, __func__);
2048        if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2049            tty->driver->subtype == PTY_TYPE_MASTER)
2050                noctty = 1;
2051#ifdef TTY_DEBUG_HANGUP
2052        printk(KERN_DEBUG "%s: opening %s...\n", __func__, tty->name);
2053#endif
2054        if (tty->ops->open)
2055                retval = tty->ops->open(tty, filp);
2056        else
2057                retval = -ENODEV;
2058        filp->f_flags = saved_flags;
2059
2060        if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) &&
2061                                                !capable(CAP_SYS_ADMIN))
2062                retval = -EBUSY;
2063
2064        if (retval) {
2065#ifdef TTY_DEBUG_HANGUP
2066                printk(KERN_DEBUG "%s: error %d in opening %s...\n", __func__,
2067                                retval, tty->name);
2068#endif
2069                tty_unlock(tty); /* need to call tty_release without BTM */
2070                tty_release(inode, filp);
2071                if (retval != -ERESTARTSYS)
2072                        return retval;
2073
2074                if (signal_pending(current))
2075                        return retval;
2076
2077                schedule();
2078                /*
2079                 * Need to reset f_op in case a hangup happened.
2080                 */
2081                if (filp->f_op == &hung_up_tty_fops)
2082                        filp->f_op = &tty_fops;
2083                goto retry_open;
2084        }
2085        tty_unlock(tty);
2086
2087
2088        mutex_lock(&tty_mutex);
2089        tty_lock(tty);
2090        spin_lock_irq(&current->sighand->siglock);
2091        if (!noctty &&
2092            current->signal->leader &&
2093            !current->signal->tty &&
2094            tty->session == NULL)
2095                __proc_set_tty(current, tty);
2096        spin_unlock_irq(&current->sighand->siglock);
2097        tty_unlock(tty);
2098        mutex_unlock(&tty_mutex);
2099        return 0;
2100err_unlock:
2101        mutex_unlock(&tty_mutex);
2102        /* after locks to avoid deadlock */
2103        if (!IS_ERR_OR_NULL(driver))
2104                tty_driver_kref_put(driver);
2105err_file:
2106        tty_free_file(filp);
2107        return retval;
2108}
2109
2110
2111
2112/**
2113 *      tty_poll        -       check tty status
2114 *      @filp: file being polled
2115 *      @wait: poll wait structures to update
2116 *
2117 *      Call the line discipline polling method to obtain the poll
2118 *      status of the device.
2119 *
2120 *      Locking: locks called line discipline but ldisc poll method
2121 *      may be re-entered freely by other callers.
2122 */
2123
2124static unsigned int tty_poll(struct file *filp, poll_table *wait)
2125{
2126        struct tty_struct *tty = file_tty(filp);
2127        struct tty_ldisc *ld;
2128        int ret = 0;
2129
2130        if (tty_paranoia_check(tty, file_inode(filp), "tty_poll"))
2131                return 0;
2132
2133        ld = tty_ldisc_ref_wait(tty);
2134        if (ld->ops->poll)
2135                ret = (ld->ops->poll)(tty, filp, wait);
2136        tty_ldisc_deref(ld);
2137        return ret;
2138}
2139
2140static int __tty_fasync(int fd, struct file *filp, int on)
2141{
2142        struct tty_struct *tty = file_tty(filp);
2143        unsigned long flags;
2144        int retval = 0;
2145
2146        if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
2147                goto out;
2148
2149        retval = fasync_helper(fd, filp, on, &tty->fasync);
2150        if (retval <= 0)
2151                goto out;
2152
2153        if (on) {
2154                enum pid_type type;
2155                struct pid *pid;
2156                if (!waitqueue_active(&tty->read_wait))
2157                        tty->minimum_to_wake = 1;
2158                spin_lock_irqsave(&tty->ctrl_lock, flags);
2159                if (tty->pgrp) {
2160                        pid = tty->pgrp;
2161                        type = PIDTYPE_PGID;
2162                } else {
2163                        pid = task_pid(current);
2164                        type = PIDTYPE_PID;
2165                }
2166                get_pid(pid);
2167                spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2168                retval = __f_setown(filp, pid, type, 0);
2169                put_pid(pid);
2170                if (retval)
2171                        goto out;
2172        } else {
2173                if (!tty->fasync && !waitqueue_active(&tty->read_wait))
2174                        tty->minimum_to_wake = N_TTY_BUF_SIZE;
2175        }
2176        retval = 0;
2177out:
2178        return retval;
2179}
2180
2181static int tty_fasync(int fd, struct file *filp, int on)
2182{
2183        struct tty_struct *tty = file_tty(filp);
2184        int retval;
2185
2186        tty_lock(tty);
2187        retval = __tty_fasync(fd, filp, on);
2188        tty_unlock(tty);
2189
2190        return retval;
2191}
2192
2193/**
2194 *      tiocsti                 -       fake input character
2195 *      @tty: tty to fake input into
2196 *      @p: pointer to character
2197 *
2198 *      Fake input to a tty device. Does the necessary locking and
2199 *      input management.
2200 *
2201 *      FIXME: does not honour flow control ??
2202 *
2203 *      Locking:
2204 *              Called functions take tty_ldisc_lock
2205 *              current->signal->tty check is safe without locks
2206 *
2207 *      FIXME: may race normal receive processing
2208 */
2209
2210static int tiocsti(struct tty_struct *tty, char __user *p)
2211{
2212        char ch, mbz = 0;
2213        struct tty_ldisc *ld;
2214
2215        if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2216                return -EPERM;
2217        if (get_user(ch, p))
2218                return -EFAULT;
2219        tty_audit_tiocsti(tty, ch);
2220        ld = tty_ldisc_ref_wait(tty);
2221        ld->ops->receive_buf(tty, &ch, &mbz, 1);
2222        tty_ldisc_deref(ld);
2223        return 0;
2224}
2225
2226/**
2227 *      tiocgwinsz              -       implement window query ioctl
2228 *      @tty; tty
2229 *      @arg: user buffer for result
2230 *
2231 *      Copies the kernel idea of the window size into the user buffer.
2232 *
2233 *      Locking: tty->termios_mutex is taken to ensure the winsize data
2234 *              is consistent.
2235 */
2236
2237static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
2238{
2239        int err;
2240
2241        mutex_lock(&tty->termios_mutex);
2242        err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2243        mutex_unlock(&tty->termios_mutex);
2244
2245        return err ? -EFAULT: 0;
2246}
2247
2248/**
2249 *      tty_do_resize           -       resize event
2250 *      @tty: tty being resized
2251 *      @rows: rows (character)
2252 *      @cols: cols (character)
2253 *
2254 *      Update the termios variables and send the necessary signals to
2255 *      peform a terminal resize correctly
2256 */
2257
2258int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
2259{
2260        struct pid *pgrp;
2261        unsigned long flags;
2262
2263        /* Lock the tty */
2264        mutex_lock(&tty->termios_mutex);
2265        if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
2266                goto done;
2267        /* Get the PID values and reference them so we can
2268           avoid holding the tty ctrl lock while sending signals */
2269        spin_lock_irqsave(&tty->ctrl_lock, flags);
2270        pgrp = get_pid(tty->pgrp);
2271        spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2272
2273        if (pgrp)
2274                kill_pgrp(pgrp, SIGWINCH, 1);
2275        put_pid(pgrp);
2276
2277        tty->winsize = *ws;
2278done:
2279        mutex_unlock(&tty->termios_mutex);
2280        return 0;
2281}
2282EXPORT_SYMBOL(tty_do_resize);
2283
2284/**
2285 *      tiocswinsz              -       implement window size set ioctl
2286 *      @tty; tty side of tty
2287 *      @arg: user buffer for result
2288 *
2289 *      Copies the user idea of the window size to the kernel. Traditionally
2290 *      this is just advisory information but for the Linux console it
2291 *      actually has driver level meaning and triggers a VC resize.
2292 *
2293 *      Locking:
2294 *              Driver dependent. The default do_resize method takes the
2295 *      tty termios mutex and ctrl_lock. The console takes its own lock
2296 *      then calls into the default method.
2297 */
2298
2299static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
2300{
2301        struct winsize tmp_ws;
2302        if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2303                return -EFAULT;
2304
2305        if (tty->ops->resize)
2306                return tty->ops->resize(tty, &tmp_ws);
2307        else
2308                return tty_do_resize(tty, &tmp_ws);
2309}
2310
2311/**
2312 *      tioccons        -       allow admin to move logical console
2313 *      @file: the file to become console
2314 *
2315 *      Allow the administrator to move the redirected console device
2316 *
2317 *      Locking: uses redirect_lock to guard the redirect information
2318 */
2319
2320static int tioccons(struct file *file)
2321{
2322        if (!capable(CAP_SYS_ADMIN))
2323                return -EPERM;
2324        if (file->f_op->write == redirected_tty_write) {
2325                struct file *f;
2326                spin_lock(&redirect_lock);
2327                f = redirect;
2328                redirect = NULL;
2329                spin_unlock(&redirect_lock);
2330                if (f)
2331                        fput(f);
2332                return 0;
2333        }
2334        spin_lock(&redirect_lock);
2335        if (redirect) {
2336                spin_unlock(&redirect_lock);
2337                return -EBUSY;
2338        }
2339        redirect = get_file(file);
2340        spin_unlock(&redirect_lock);
2341        return 0;
2342}
2343
2344/**
2345 *      fionbio         -       non blocking ioctl
2346 *      @file: file to set blocking value
2347 *      @p: user parameter
2348 *
2349 *      Historical tty interfaces had a blocking control ioctl before
2350 *      the generic functionality existed. This piece of history is preserved
2351 *      in the expected tty API of posix OS's.
2352 *
2353 *      Locking: none, the open file handle ensures it won't go away.
2354 */
2355
2356static int fionbio(struct file *file, int __user *p)
2357{
2358        int nonblock;
2359
2360        if (get_user(nonblock, p))
2361                return -EFAULT;
2362
2363        spin_lock(&file->f_lock);
2364        if (nonblock)
2365                file->f_flags |= O_NONBLOCK;
2366        else
2367                file->f_flags &= ~O_NONBLOCK;
2368        spin_unlock(&file->f_lock);
2369        return 0;
2370}
2371
2372/**
2373 *      tiocsctty       -       set controlling tty
2374 *      @tty: tty structure
2375 *      @arg: user argument
2376 *
2377 *      This ioctl is used to manage job control. It permits a session
2378 *      leader to set this tty as the controlling tty for the session.
2379 *
2380 *      Locking:
2381 *              Takes tty_mutex() to protect tty instance
2382 *              Takes tasklist_lock internally to walk sessions
2383 *              Takes ->siglock() when updating signal->tty
2384 */
2385
2386static int tiocsctty(struct tty_struct *tty, int arg)
2387{
2388        int ret = 0;
2389        if (current->signal->leader && (task_session(current) == tty->session))
2390                return ret;
2391
2392        mutex_lock(&tty_mutex);
2393        /*
2394         * The process must be a session leader and
2395         * not have a controlling tty already.
2396         */
2397        if (!current->signal->leader || current->signal->tty) {
2398                ret = -EPERM;
2399                goto unlock;
2400        }
2401
2402        if (tty->session) {
2403                /*
2404                 * This tty is already the controlling
2405                 * tty for another session group!
2406                 */
2407                if (arg == 1 && capable(CAP_SYS_ADMIN)) {
2408                        /*
2409                         * Steal it away
2410                         */
2411                        read_lock(&tasklist_lock);
2412                        session_clear_tty(tty->session);
2413                        read_unlock(&tasklist_lock);
2414                } else {
2415                        ret = -EPERM;
2416                        goto unlock;
2417                }
2418        }
2419        proc_set_tty(current, tty);
2420unlock:
2421        mutex_unlock(&tty_mutex);
2422        return ret;
2423}
2424
2425/**
2426 *      tty_get_pgrp    -       return a ref counted pgrp pid
2427 *      @tty: tty to read
2428 *
2429 *      Returns a refcounted instance of the pid struct for the process
2430 *      group controlling the tty.
2431 */
2432
2433struct pid *tty_get_pgrp(struct tty_struct *tty)
2434{
2435        unsigned long flags;
2436        struct pid *pgrp;
2437
2438        spin_lock_irqsave(&tty->ctrl_lock, flags);
2439        pgrp = get_pid(tty->pgrp);
2440        spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2441
2442        return pgrp;
2443}
2444EXPORT_SYMBOL_GPL(tty_get_pgrp);
2445
2446/**
2447 *      tiocgpgrp               -       get process group
2448 *      @tty: tty passed by user
2449 *      @real_tty: tty side of the tty passed by the user if a pty else the tty
2450 *      @p: returned pid
2451 *
2452 *      Obtain the process group of the tty. If there is no process group
2453 *      return an error.
2454 *
2455 *      Locking: none. Reference to current->signal->tty is safe.
2456 */
2457
2458static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2459{
2460        struct pid *pid;
2461        int ret;
2462        /*
2463         * (tty == real_tty) is a cheap way of
2464         * testing if the tty is NOT a master pty.
2465         */
2466        if (tty == real_tty && current->signal->tty != real_tty)
2467                return -ENOTTY;
2468        pid = tty_get_pgrp(real_tty);
2469        ret =  put_user(pid_vnr(pid), p);
2470        put_pid(pid);
2471        return ret;
2472}
2473
2474/**
2475 *      tiocspgrp               -       attempt to set process group
2476 *      @tty: tty passed by user
2477 *      @real_tty: tty side device matching tty passed by user
2478 *      @p: pid pointer
2479 *
2480 *      Set the process group of the tty to the session passed. Only
2481 *      permitted where the tty session is our session.
2482 *
2483 *      Locking: RCU, ctrl lock
2484 */
2485
2486static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2487{
2488        struct pid *pgrp;
2489        pid_t pgrp_nr;
2490        int retval = tty_check_change(real_tty);
2491        unsigned long flags;
2492
2493        if (retval == -EIO)
2494                return -ENOTTY;
2495        if (retval)
2496                return retval;
2497        if (!current->signal->tty ||
2498            (current->signal->tty != real_tty) ||
2499            (real_tty->session != task_session(current)))
2500                return -ENOTTY;
2501        if (get_user(pgrp_nr, p))
2502                return -EFAULT;
2503        if (pgrp_nr < 0)
2504                return -EINVAL;
2505        rcu_read_lock();
2506        pgrp = find_vpid(pgrp_nr);
2507        retval = -ESRCH;
2508        if (!pgrp)
2509                goto out_unlock;
2510        retval = -EPERM;
2511        if (session_of_pgrp(pgrp) != task_session(current))
2512                goto out_unlock;
2513        retval = 0;
2514        spin_lock_irqsave(&tty->ctrl_lock, flags);
2515        put_pid(real_tty->pgrp);
2516        real_tty->pgrp = get_pid(pgrp);
2517        spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2518out_unlock:
2519        rcu_read_unlock();
2520        return retval;
2521}
2522
2523/**
2524 *      tiocgsid                -       get session id
2525 *      @tty: tty passed by user
2526 *      @real_tty: tty side of the tty passed by the user if a pty else the tty
2527 *      @p: pointer to returned session id
2528 *
2529 *      Obtain the session id of the tty. If there is no session
2530 *      return an error.
2531 *
2532 *      Locking: none. Reference to current->signal->tty is safe.
2533 */
2534
2535static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2536{
2537        /*
2538         * (tty == real_tty) is a cheap way of
2539         * testing if the tty is NOT a master pty.
2540        */
2541        if (tty == real_tty && current->signal->tty != real_tty)
2542                return -ENOTTY;
2543        if (!real_tty->session)
2544                return -ENOTTY;
2545        return put_user(pid_vnr(real_tty->session), p);
2546}
2547
2548/**
2549 *      tiocsetd        -       set line discipline
2550 *      @tty: tty device
2551 *      @p: pointer to user data
2552 *
2553 *      Set the line discipline according to user request.
2554 *
2555 *      Locking: see tty_set_ldisc, this function is just a helper
2556 */
2557
2558static int tiocsetd(struct tty_struct *tty, int __user *p)
2559{
2560        int ldisc;
2561        int ret;
2562
2563        if (get_user(ldisc, p))
2564                return -EFAULT;
2565
2566        ret = tty_set_ldisc(tty, ldisc);
2567
2568        return ret;
2569}
2570
2571/**
2572 *      send_break      -       performed time break
2573 *      @tty: device to break on
2574 *      @duration: timeout in mS
2575 *
2576 *      Perform a timed break on hardware that lacks its own driver level
2577 *      timed break functionality.
2578 *
2579 *      Locking:
2580 *              atomic_write_lock serializes
2581 *
2582 */
2583
2584static int send_break(struct tty_struct *tty, unsigned int duration)
2585{
2586        int retval;
2587
2588        if (tty->ops->break_ctl == NULL)
2589                return 0;
2590
2591        if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2592                retval = tty->ops->break_ctl(tty, duration);
2593        else {
2594                /* Do the work ourselves */
2595                if (tty_write_lock(tty, 0) < 0)
2596                        return -EINTR;
2597                retval = tty->ops->break_ctl(tty, -1);
2598                if (retval)
2599                        goto out;
2600                if (!signal_pending(current))
2601                        msleep_interruptible(duration);
2602                retval = tty->ops->break_ctl(tty, 0);
2603out:
2604                tty_write_unlock(tty);
2605                if (signal_pending(current))
2606                        retval = -EINTR;
2607        }
2608        return retval;
2609}
2610
2611/**
2612 *      tty_tiocmget            -       get modem status
2613 *      @tty: tty device
2614 *      @file: user file pointer
2615 *      @p: pointer to result
2616 *
2617 *      Obtain the modem status bits from the tty driver if the feature
2618 *      is supported. Return -EINVAL if it is not available.
2619 *
2620 *      Locking: none (up to the driver)
2621 */
2622
2623static int tty_tiocmget(struct tty_struct *tty, int __user *p)
2624{
2625        int retval = -EINVAL;
2626
2627        if (tty->ops->tiocmget) {
2628                retval = tty->ops->tiocmget(tty);
2629
2630                if (retval >= 0)
2631                        retval = put_user(retval, p);
2632        }
2633        return retval;
2634}
2635
2636/**
2637 *      tty_tiocmset            -       set modem status
2638 *      @tty: tty device
2639 *      @cmd: command - clear bits, set bits or set all
2640 *      @p: pointer to desired bits
2641 *
2642 *      Set the modem status bits from the tty driver if the feature
2643 *      is supported. Return -EINVAL if it is not available.
2644 *
2645 *      Locking: none (up to the driver)
2646 */
2647
2648static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
2649             unsigned __user *p)
2650{
2651        int retval;
2652        unsigned int set, clear, val;
2653
2654        if (tty->ops->tiocmset == NULL)
2655                return -EINVAL;
2656
2657        retval = get_user(val, p);
2658        if (retval)
2659                return retval;
2660        set = clear = 0;
2661        switch (cmd) {
2662        case TIOCMBIS:
2663                set = val;
2664                break;
2665        case TIOCMBIC:
2666                clear = val;
2667                break;
2668        case TIOCMSET:
2669                set = val;
2670                clear = ~val;
2671                break;
2672        }
2673        set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2674        clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2675        return tty->ops->tiocmset(tty, set, clear);
2676}
2677
2678static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2679{
2680        int retval = -EINVAL;
2681        struct serial_icounter_struct icount;
2682        memset(&icount, 0, sizeof(icount));
2683        if (tty->ops->get_icount)
2684                retval = tty->ops->get_icount(tty, &icount);
2685        if (retval != 0)
2686                return retval;
2687        if (copy_to_user(arg, &icount, sizeof(icount)))
2688                return -EFAULT;
2689        return 0;
2690}
2691
2692struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2693{
2694        if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2695            tty->driver->subtype == PTY_TYPE_MASTER)
2696                tty = tty->link;
2697        return tty;
2698}
2699EXPORT_SYMBOL(tty_pair_get_tty);
2700
2701struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2702{
2703        if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2704            tty->driver->subtype == PTY_TYPE_MASTER)
2705            return tty;
2706        return tty->link;
2707}
2708EXPORT_SYMBOL(tty_pair_get_pty);
2709
2710/*
2711 * Split this up, as gcc can choke on it otherwise..
2712 */
2713long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2714{
2715        struct tty_struct *tty = file_tty(file);
2716        struct tty_struct *real_tty;
2717        void __user *p = (void __user *)arg;
2718        int retval;
2719        struct tty_ldisc *ld;
2720
2721        if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
2722                return -EINVAL;
2723
2724        real_tty = tty_pair_get_tty(tty);
2725
2726        /*
2727         * Factor out some common prep work
2728         */
2729        switch (cmd) {
2730        case TIOCSETD:
2731        case TIOCSBRK:
2732        case TIOCCBRK:
2733        case TCSBRK:
2734        case TCSBRKP:
2735                retval = tty_check_change(tty);
2736                if (retval)
2737                        return retval;
2738                if (cmd != TIOCCBRK) {
2739                        tty_wait_until_sent(tty, 0);
2740                        if (signal_pending(current))
2741                                return -EINTR;
2742                }
2743                break;
2744        }
2745
2746        /*
2747         *      Now do the stuff.
2748         */
2749        switch (cmd) {
2750        case TIOCSTI:
2751                return tiocsti(tty, p);
2752        case TIOCGWINSZ:
2753                return tiocgwinsz(real_tty, p);
2754        case TIOCSWINSZ:
2755                return tiocswinsz(real_tty, p);
2756        case TIOCCONS:
2757                return real_tty != tty ? -EINVAL : tioccons(file);
2758        case FIONBIO:
2759                return fionbio(file, p);
2760        case TIOCEXCL:
2761                set_bit(TTY_EXCLUSIVE, &tty->flags);
2762                return 0;
2763        case TIOCNXCL:
2764                clear_bit(TTY_EXCLUSIVE, &tty->flags);
2765                return 0;
2766        case TIOCGEXCL:
2767        {
2768                int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
2769                return put_user(excl, (int __user *)p);
2770        }
2771        case TIOCNOTTY:
2772                if (current->signal->tty != tty)
2773                        return -ENOTTY;
2774                no_tty();
2775                return 0;
2776        case TIOCSCTTY:
2777                return tiocsctty(tty, arg);
2778        case TIOCGPGRP:
2779                return tiocgpgrp(tty, real_tty, p);
2780        case TIOCSPGRP:
2781                return tiocspgrp(tty, real_tty, p);
2782        case TIOCGSID:
2783                return tiocgsid(tty, real_tty, p);
2784        case TIOCGETD:
2785                return put_user(tty->ldisc->ops->num, (int __user *)p);
2786        case TIOCSETD:
2787                return tiocsetd(tty, p);
2788        case TIOCVHANGUP:
2789                if (!capable(CAP_SYS_ADMIN))
2790                        return -EPERM;
2791                tty_vhangup(tty);
2792                return 0;
2793        case TIOCGDEV:
2794        {
2795                unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2796                return put_user(ret, (unsigned int __user *)p);
2797        }
2798        /*
2799         * Break handling
2800         */
2801        case TIOCSBRK:  /* Turn break on, unconditionally */
2802                if (tty->ops->break_ctl)
2803                        return tty->ops->break_ctl(tty, -1);
2804                return 0;
2805        case TIOCCBRK:  /* Turn break off, unconditionally */
2806                if (tty->ops->break_ctl)
2807                        return tty->ops->break_ctl(tty, 0);
2808                return 0;
2809        case TCSBRK:   /* SVID version: non-zero arg --> no break */
2810                /* non-zero arg means wait for all output data
2811                 * to be sent (performed above) but don't send break.
2812                 * This is used by the tcdrain() termios function.
2813                 */
2814                if (!arg)
2815                        return send_break(tty, 250);
2816                return 0;
2817        case TCSBRKP:   /* support for POSIX tcsendbreak() */
2818                return send_break(tty, arg ? arg*100 : 250);
2819
2820        case TIOCMGET:
2821                return tty_tiocmget(tty, p);
2822        case TIOCMSET:
2823        case TIOCMBIC:
2824        case TIOCMBIS:
2825                return tty_tiocmset(tty, cmd, p);
2826        case TIOCGICOUNT:
2827                retval = tty_tiocgicount(tty, p);
2828                /* For the moment allow fall through to the old method */
2829                if (retval != -EINVAL)
2830                        return retval;
2831                break;
2832        case TCFLSH:
2833                switch (arg) {
2834                case TCIFLUSH:
2835                case TCIOFLUSH:
2836                /* flush tty buffer and allow ldisc to process ioctl */
2837                        tty_buffer_flush(tty);
2838                        break;
2839                }
2840                break;
2841        }
2842        if (tty->ops->ioctl) {
2843                retval = (tty->ops->ioctl)(tty, cmd, arg);
2844                if (retval != -ENOIOCTLCMD)
2845                        return retval;
2846        }
2847        ld = tty_ldisc_ref_wait(tty);
2848        retval = -EINVAL;
2849        if (ld->ops->ioctl) {
2850                retval = ld->ops->ioctl(tty, file, cmd, arg);
2851                if (retval == -ENOIOCTLCMD)
2852                        retval = -ENOTTY;
2853        }
2854        tty_ldisc_deref(ld);
2855        return retval;
2856}
2857
2858#ifdef CONFIG_COMPAT
2859static long tty_compat_ioctl(struct file *file, unsigned int cmd,
2860                                unsigned long arg)
2861{
2862        struct tty_struct *tty = file_tty(file);
2863        struct tty_ldisc *ld;
2864        int retval = -ENOIOCTLCMD;
2865
2866        if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
2867                return -EINVAL;
2868
2869        if (tty->ops->compat_ioctl) {
2870                retval = (tty->ops->compat_ioctl)(tty, cmd, arg);
2871                if (retval != -ENOIOCTLCMD)
2872                        return retval;
2873        }
2874
2875        ld = tty_ldisc_ref_wait(tty);
2876        if (ld->ops->compat_ioctl)
2877                retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
2878        else
2879                retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
2880        tty_ldisc_deref(ld);
2881
2882        return retval;
2883}
2884#endif
2885
2886static int this_tty(const void *t, struct file *file, unsigned fd)
2887{
2888        if (likely(file->f_op->read != tty_read))
2889                return 0;
2890        return file_tty(file) != t ? 0 : fd + 1;
2891}
2892        
2893/*
2894 * This implements the "Secure Attention Key" ---  the idea is to
2895 * prevent trojan horses by killing all processes associated with this
2896 * tty when the user hits the "Secure Attention Key".  Required for
2897 * super-paranoid applications --- see the Orange Book for more details.
2898 *
2899 * This code could be nicer; ideally it should send a HUP, wait a few
2900 * seconds, then send a INT, and then a KILL signal.  But you then
2901 * have to coordinate with the init process, since all processes associated
2902 * with the current tty must be dead before the new getty is allowed
2903 * to spawn.
2904 *
2905 * Now, if it would be correct ;-/ The current code has a nasty hole -
2906 * it doesn't catch files in flight. We may send the descriptor to ourselves
2907 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2908 *
2909 * Nasty bug: do_SAK is being called in interrupt context.  This can
2910 * deadlock.  We punt it up to process context.  AKPM - 16Mar2001
2911 */
2912void __do_SAK(struct tty_struct *tty)
2913{
2914#ifdef TTY_SOFT_SAK
2915        tty_hangup(tty);
2916#else
2917        struct task_struct *g, *p;
2918        struct pid *session;
2919        int             i;
2920
2921        if (!tty)
2922                return;
2923        session = tty->session;
2924
2925        tty_ldisc_flush(tty);
2926
2927        tty_driver_flush_buffer(tty);
2928
2929        read_lock(&tasklist_lock);
2930        /* Kill the entire session */
2931        do_each_pid_task(session, PIDTYPE_SID, p) {
2932                printk(KERN_NOTICE "SAK: killed process %d"
2933                        " (%s): task_session(p)==tty->session\n",
2934                        task_pid_nr(p), p->comm);
2935                send_sig(SIGKILL, p, 1);
2936        } while_each_pid_task(session, PIDTYPE_SID, p);
2937        /* Now kill any processes that happen to have the
2938         * tty open.
2939         */
2940        do_each_thread(g, p) {
2941                if (p->signal->tty == tty) {
2942                        printk(KERN_NOTICE "SAK: killed process %d"
2943                            " (%s): task_session(p)==tty->session\n",
2944                            task_pid_nr(p), p->comm);
2945                        send_sig(SIGKILL, p, 1);
2946                        continue;
2947                }
2948                task_lock(p);
2949                i = iterate_fd(p->files, 0, this_tty, tty);
2950                if (i != 0) {
2951                        printk(KERN_NOTICE "SAK: killed process %d"
2952                            " (%s): fd#%d opened to the tty\n",
2953                                    task_pid_nr(p), p->comm, i - 1);
2954                        force_sig(SIGKILL, p);
2955                }
2956                task_unlock(p);
2957        } while_each_thread(g, p);
2958        read_unlock(&tasklist_lock);
2959#endif
2960}
2961
2962static void do_SAK_work(struct work_struct *work)
2963{
2964        struct tty_struct *tty =
2965                container_of(work, struct tty_struct, SAK_work);
2966        __do_SAK(tty);
2967}
2968
2969/*
2970 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2971 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2972 * the values which we write to it will be identical to the values which it
2973 * already has. --akpm
2974 */
2975void do_SAK(struct tty_struct *tty)
2976{
2977        if (!tty)
2978                return;
2979        schedule_work(&tty->SAK_work);
2980}
2981
2982EXPORT_SYMBOL(do_SAK);
2983
2984static int dev_match_devt(struct device *dev, const void *data)
2985{
2986        const dev_t *devt = data;
2987        return dev->devt == *devt;
2988}
2989
2990/* Must put_device() after it's unused! */
2991static struct device *tty_get_device(struct tty_struct *tty)
2992{
2993        dev_t devt = tty_devnum(tty);
2994        return class_find_device(tty_class, NULL, &devt, dev_match_devt);
2995}
2996
2997
2998/**
2999 *      initialize_tty_struct
3000 *      @tty: tty to initialize
3001 *
3002 *      This subroutine initializes a tty structure that has been newly
3003 *      allocated.
3004 *
3005 *      Locking: none - tty in question must not be exposed at this point
3006 */
3007
3008void initialize_tty_struct(struct tty_struct *tty,
3009                struct tty_driver *driver, int idx)
3010{
3011        memset(tty, 0, sizeof(struct tty_struct));
3012        kref_init(&tty->kref);
3013        tty->magic = TTY_MAGIC;
3014        tty_ldisc_init(tty);
3015        tty->session = NULL;
3016        tty->pgrp = NULL;
3017        mutex_init(&tty->legacy_mutex);
3018        mutex_init(&tty->termios_mutex);
3019        mutex_init(&tty->ldisc_mutex);
3020        init_waitqueue_head(&tty->write_wait);
3021        init_waitqueue_head(&tty->read_wait);
3022        INIT_WORK(&tty->hangup_work, do_tty_hangup);
3023        mutex_init(&tty->atomic_write_lock);
3024        spin_lock_init(&tty->ctrl_lock);
3025        INIT_LIST_HEAD(&tty->tty_files);
3026        INIT_WORK(&tty->SAK_work, do_SAK_work);
3027
3028        tty->driver = driver;
3029        tty->ops = driver->ops;
3030        tty->index = idx;
3031        tty_line_name(driver, idx, tty->name);
3032        tty->dev = tty_get_device(tty);
3033}
3034
3035/**
3036 *      deinitialize_tty_struct
3037 *      @tty: tty to deinitialize
3038 *
3039 *      This subroutine deinitializes a tty structure that has been newly
3040 *      allocated but tty_release cannot be called on that yet.
3041 *
3042 *      Locking: none - tty in question must not be exposed at this point
3043 */
3044void deinitialize_tty_struct(struct tty_struct *tty)
3045{
3046        tty_ldisc_deinit(tty);
3047}
3048
3049/**
3050 *      tty_put_char    -       write one character to a tty
3051 *      @tty: tty
3052 *      @ch: character
3053 *
3054 *      Write one byte to the tty using the provided put_char method
3055 *      if present. Returns the number of characters successfully output.
3056 *
3057 *      Note: the specific put_char operation in the driver layer may go
3058 *      away soon. Don't call it directly, use this method
3059 */
3060
3061int tty_put_char(struct tty_struct *tty, unsigned char ch)
3062{
3063        if (tty->ops->put_char)
3064                return tty->ops->put_char(tty, ch);
3065        return tty->ops->write(tty, &ch, 1);
3066}
3067EXPORT_SYMBOL_GPL(tty_put_char);
3068
3069struct class *tty_class;
3070
3071static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
3072                unsigned int index, unsigned int count)
3073{
3074        /* init here, since reused cdevs cause crashes */
3075        cdev_init(&driver->cdevs[index], &tty_fops);
3076        driver->cdevs[index].owner = driver->owner;
3077        return cdev_add(&driver->cdevs[index], dev, count);
3078}
3079
3080/**
3081 *      tty_register_device - register a tty device
3082 *      @driver: the tty driver that describes the tty device
3083 *      @index: the index in the tty driver for this tty device
3084 *      @device: a struct device that is associated with this tty device.
3085 *              This field is optional, if there is no known struct device
3086 *              for this tty device it can be set to NULL safely.
3087 *
3088 *      Returns a pointer to the struct device for this tty device
3089 *      (or ERR_PTR(-EFOO) on error).
3090 *
3091 *      This call is required to be made to register an individual tty device
3092 *      if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set.  If
3093 *      that bit is not set, this function should not be called by a tty
3094 *      driver.
3095 *
3096 *      Locking: ??
3097 */
3098
3099struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3100                                   struct device *device)
3101{
3102        return tty_register_device_attr(driver, index, device, NULL, NULL);
3103}
3104EXPORT_SYMBOL(tty_register_device);
3105
3106static void tty_device_create_release(struct device *dev)
3107{
3108        pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
3109        kfree(dev);
3110}
3111
3112/**
3113 *      tty_register_device_attr - register a tty device
3114 *      @driver: the tty driver that describes the tty device
3115 *      @index: the index in the tty driver for this tty device
3116 *      @device: a struct device that is associated with this tty device.
3117 *              This field is optional, if there is no known struct device
3118 *              for this tty device it can be set to NULL safely.
3119 *      @drvdata: Driver data to be set to device.
3120 *      @attr_grp: Attribute group to be set on device.
3121 *
3122 *      Returns a pointer to the struct device for this tty device
3123 *      (or ERR_PTR(-EFOO) on error).
3124 *
3125 *      This call is required to be made to register an individual tty device
3126 *      if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set.  If
3127 *      that bit is not set, this function should not be called by a tty
3128 *      driver.
3129 *
3130 *      Locking: ??
3131 */
3132struct device *tty_register_device_attr(struct tty_driver *driver,
3133                                   unsigned index, struct device *device,
3134                                   void *drvdata,
3135                                   const struct attribute_group **attr_grp)
3136{
3137        char name[64];
3138        dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
3139        struct device *dev = NULL;
3140        int retval = -ENODEV;
3141        bool cdev = false;
3142
3143        if (index >= driver->num) {
3144                printk(KERN_ERR "Attempt to register invalid tty line number "
3145                       " (%d).\n", index);
3146                return ERR_PTR(-EINVAL);
3147        }
3148
3149        if (driver->type == TTY_DRIVER_TYPE_PTY)
3150                pty_line_name(driver, index, name);
3151        else
3152                tty_line_name(driver, index, name);
3153
3154        if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3155                retval = tty_cdev_add(driver, devt, index, 1);
3156                if (retval)
3157                        goto error;
3158                cdev = true;
3159        }
3160
3161        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3162        if (!dev) {
3163                retval = -ENOMEM;
3164                goto error;
3165        }
3166
3167        dev->devt = devt;
3168        dev->class = tty_class;
3169        dev->parent = device;
3170        dev->release = tty_device_create_release;
3171        dev_set_name(dev, "%s", name);
3172        dev->groups = attr_grp;
3173        dev_set_drvdata(dev, drvdata);
3174
3175        retval = device_register(dev);
3176        if (retval)
3177                goto error;
3178
3179        return dev;
3180
3181error:
3182        put_device(dev);
3183        if (cdev)
3184                cdev_del(&driver->cdevs[index]);
3185        return ERR_PTR(retval);
3186}
3187EXPORT_SYMBOL_GPL(tty_register_device_attr);
3188
3189/**
3190 *      tty_unregister_device - unregister a tty device
3191 *      @driver: the tty driver that describes the tty device
3192 *      @index: the index in the tty driver for this tty device
3193 *
3194 *      If a tty device is registered with a call to tty_register_device() then
3195 *      this function must be called when the tty device is gone.
3196 *
3197 *      Locking: ??
3198 */
3199
3200void tty_unregister_device(struct tty_driver *driver, unsigned index)
3201{
3202        device_destroy(tty_class,
3203                MKDEV(driver->major, driver->minor_start) + index);
3204        if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC))
3205                cdev_del(&driver->cdevs[index]);
3206}
3207EXPORT_SYMBOL(tty_unregister_device);
3208
3209/**
3210 * __tty_alloc_driver -- allocate tty driver
3211 * @lines: count of lines this driver can handle at most
3212 * @owner: module which is repsonsible for this driver
3213 * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
3214 *
3215 * This should not be called directly, some of the provided macros should be
3216 * used instead. Use IS_ERR and friends on @retval.
3217 */
3218struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
3219                unsigned long flags)
3220{
3221        struct tty_driver *driver;
3222        unsigned int cdevs = 1;
3223        int err;
3224
3225        if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
3226                return ERR_PTR(-EINVAL);
3227
3228        driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
3229        if (!driver)
3230                return ERR_PTR(-ENOMEM);
3231
3232        kref_init(&driver->kref);
3233        driver->magic = TTY_DRIVER_MAGIC;
3234        driver->num = lines;
3235        driver->owner = owner;
3236        driver->flags = flags;
3237
3238        if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3239                driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3240                                GFP_KERNEL);
3241                driver->termios = kcalloc(lines, sizeof(*driver->termios),
3242                                GFP_KERNEL);
3243                if (!driver->ttys || !driver->termios) {
3244                        err = -ENOMEM;
3245                        goto err_free_all;
3246                }
3247        }
3248
3249        if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3250                driver->ports = kcalloc(lines, sizeof(*driver->ports),
3251                                GFP_KERNEL);
3252                if (!driver->ports) {
3253                        err = -ENOMEM;
3254                        goto err_free_all;
3255                }
3256                cdevs = lines;
3257        }
3258
3259        driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3260        if (!driver->cdevs) {
3261                err = -ENOMEM;
3262                goto err_free_all;
3263        }
3264
3265        return driver;
3266err_free_all:
3267        kfree(driver->ports);
3268        kfree(driver->ttys);
3269        kfree(driver->termios);
3270        kfree(driver);
3271        return ERR_PTR(err);
3272}
3273EXPORT_SYMBOL(__tty_alloc_driver);
3274
3275static void destruct_tty_driver(struct kref *kref)
3276{
3277        struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3278        int i;
3279        struct ktermios *tp;
3280
3281        if (driver->flags & TTY_DRIVER_INSTALLED) {
3282                /*
3283                 * Free the termios and termios_locked structures because
3284                 * we don't want to get memory leaks when modular tty
3285                 * drivers are removed from the kernel.
3286                 */
3287                for (i = 0; i < driver->num; i++) {
3288                        tp = driver->termios[i];
3289                        if (tp) {
3290                                driver->termios[i] = NULL;
3291                                kfree(tp);
3292                        }
3293                        if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3294                                tty_unregister_device(driver, i);
3295                }
3296                proc_tty_unregister_driver(driver);
3297                if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
3298                        cdev_del(&driver->cdevs[0]);
3299        }
3300        kfree(driver->cdevs);
3301        kfree(driver->ports);
3302        kfree(driver->termios);
3303        kfree(driver->ttys);
3304        kfree(driver);
3305}
3306
3307void tty_driver_kref_put(struct tty_driver *driver)
3308{
3309        kref_put(&driver->kref, destruct_tty_driver);
3310}
3311EXPORT_SYMBOL(tty_driver_kref_put);
3312
3313void tty_set_operations(struct tty_driver *driver,
3314                        const struct tty_operations *op)
3315{
3316        driver->ops = op;
3317};
3318EXPORT_SYMBOL(tty_set_operations);
3319
3320void put_tty_driver(struct tty_driver *d)
3321{
3322        tty_driver_kref_put(d);
3323}
3324EXPORT_SYMBOL(put_tty_driver);
3325
3326/*
3327 * Called by a tty driver to register itself.
3328 */
3329int tty_register_driver(struct tty_driver *driver)
3330{
3331        int error;
3332        int i;
3333        dev_t dev;
3334        struct device *d;
3335
3336        if (!driver->major) {
3337                error = alloc_chrdev_region(&dev, driver->minor_start,
3338                                                driver->num, driver->name);
3339                if (!error) {
3340                        driver->major = MAJOR(dev);
3341                        driver->minor_start = MINOR(dev);
3342                }
3343        } else {
3344                dev = MKDEV(driver->major, driver->minor_start);
3345                error = register_chrdev_region(dev, driver->num, driver->name);
3346        }
3347        if (error < 0)
3348                goto err;
3349
3350        if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3351                error = tty_cdev_add(driver, dev, 0, driver->num);
3352                if (error)
3353                        goto err_unreg_char;
3354        }
3355
3356        mutex_lock(&tty_mutex);
3357        list_add(&driver->tty_drivers, &tty_drivers);
3358        mutex_unlock(&tty_mutex);
3359
3360        if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
3361                for (i = 0; i < driver->num; i++) {
3362                        d = tty_register_device(driver, i, NULL);
3363                        if (IS_ERR(d)) {
3364                                error = PTR_ERR(d);
3365                                goto err_unreg_devs;
3366                        }
3367                }
3368        }
3369        proc_tty_register_driver(driver);
3370        driver->flags |= TTY_DRIVER_INSTALLED;
3371        return 0;
3372
3373err_unreg_devs:
3374        for (i--; i >= 0; i--)
3375                tty_unregister_device(driver, i);
3376
3377        mutex_lock(&tty_mutex);
3378        list_del(&driver->tty_drivers);
3379        mutex_unlock(&tty_mutex);
3380
3381err_unreg_char:
3382        unregister_chrdev_region(dev, driver->num);
3383err:
3384        return error;
3385}
3386EXPORT_SYMBOL(tty_register_driver);
3387
3388/*
3389 * Called by a tty driver to unregister itself.
3390 */
3391int tty_unregister_driver(struct tty_driver *driver)
3392{
3393#if 0
3394        /* FIXME */
3395        if (driver->refcount)
3396                return -EBUSY;
3397#endif
3398        unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3399                                driver->num);
3400        mutex_lock(&tty_mutex);
3401        list_del(&driver->tty_drivers);
3402        mutex_unlock(&tty_mutex);
3403        return 0;
3404}
3405
3406EXPORT_SYMBOL(tty_unregister_driver);
3407
3408dev_t tty_devnum(struct tty_struct *tty)
3409{
3410        return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3411}
3412EXPORT_SYMBOL(tty_devnum);
3413
3414void proc_clear_tty(struct task_struct *p)
3415{
3416        unsigned long flags;
3417        struct tty_struct *tty;
3418        spin_lock_irqsave(&p->sighand->siglock, flags);
3419        tty = p->signal->tty;
3420        p->signal->tty = NULL;
3421        spin_unlock_irqrestore(&p->sighand->siglock, flags);
3422        tty_kref_put(tty);
3423}
3424
3425/* Called under the sighand lock */
3426
3427static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3428{
3429        if (tty) {
3430                unsigned long flags;
3431                /* We should not have a session or pgrp to put here but.... */
3432                spin_lock_irqsave(&tty->ctrl_lock, flags);
3433                put_pid(tty->session);
3434                put_pid(tty->pgrp);
3435                tty->pgrp = get_pid(task_pgrp(tsk));
3436                spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3437                tty->session = get_pid(task_session(tsk));
3438                if (tsk->signal->tty) {
3439                        printk(KERN_DEBUG "tty not NULL!!\n");
3440                        tty_kref_put(tsk->signal->tty);
3441                }
3442        }
3443        put_pid(tsk->signal->tty_old_pgrp);
3444        tsk->signal->tty = tty_kref_get(tty);
3445        tsk->signal->tty_old_pgrp = NULL;
3446}
3447
3448static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3449{
3450        spin_lock_irq(&tsk->sighand->siglock);
3451        __proc_set_tty(tsk, tty);
3452        spin_unlock_irq(&tsk->sighand->siglock);
3453}
3454
3455struct tty_struct *get_current_tty(void)
3456{
3457        struct tty_struct *tty;
3458        unsigned long flags;
3459
3460        spin_lock_irqsave(&current->sighand->siglock, flags);
3461        tty = tty_kref_get(current->signal->tty);
3462        spin_unlock_irqrestore(&current->sighand->siglock, flags);
3463        return tty;
3464}
3465EXPORT_SYMBOL_GPL(get_current_tty);
3466
3467void tty_default_fops(struct file_operations *fops)
3468{
3469        *fops = tty_fops;
3470}
3471
3472/*
3473 * Initialize the console device. This is called *early*, so
3474 * we can't necessarily depend on lots of kernel help here.
3475 * Just do some early initializations, and do the complex setup
3476 * later.
3477 */
3478void __init console_init(void)
3479{
3480        initcall_t *call;
3481
3482        /* Setup the default TTY line discipline. */
3483        tty_ldisc_begin();
3484
3485        /*
3486         * set up the console device so that later boot sequences can
3487         * inform about problems etc..
3488         */
3489        call = __con_initcall_start;
3490        while (call < __con_initcall_end) {
3491                (*call)();
3492                call++;
3493        }
3494}
3495
3496static char *tty_devnode(struct device *dev, umode_t *mode)
3497{
3498        if (!mode)
3499                return NULL;
3500        if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3501            dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3502                *mode = 0666;
3503        return NULL;
3504}
3505
3506static int __init tty_class_init(void)
3507{
3508        tty_class = class_create(THIS_MODULE, "tty");
3509        if (IS_ERR(tty_class))
3510                return PTR_ERR(tty_class);
3511        tty_class->devnode = tty_devnode;
3512        return 0;
3513}
3514
3515postcore_initcall(tty_class_init);
3516
3517/* 3/2004 jmc: why do these devices exist? */
3518static struct cdev tty_cdev, console_cdev;
3519
3520static ssize_t show_cons_active(struct device *dev,
3521                                struct device_attribute *attr, char *buf)
3522{
3523        struct console *cs[16];
3524        int i = 0;
3525        struct console *c;
3526        ssize_t count = 0;
3527
3528        console_lock();
3529        for_each_console(c) {
3530                if (!c->device)
3531                        continue;
3532                if (!c->write)
3533                        continue;
3534                if ((c->flags & CON_ENABLED) == 0)
3535                        continue;
3536                cs[i++] = c;
3537                if (i >= ARRAY_SIZE(cs))
3538                        break;
3539        }
3540        while (i--)
3541                count += sprintf(buf + count, "%s%d%c",
3542                                 cs[i]->name, cs[i]->index, i ? ' ':'\n');
3543        console_unlock();
3544
3545        return count;
3546}
3547static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3548
3549static struct device *consdev;
3550
3551void console_sysfs_notify(void)
3552{
3553        if (consdev)
3554                sysfs_notify(&consdev->kobj, NULL, "active");
3555}
3556
3557/*
3558 * Ok, now we can initialize the rest of the tty devices and can count
3559 * on memory allocations, interrupts etc..
3560 */
3561int __init tty_init(void)
3562{
3563        cdev_init(&tty_cdev, &tty_fops);
3564        if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3565            register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3566                panic("Couldn't register /dev/tty driver\n");
3567        device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3568
3569        cdev_init(&console_cdev, &console_fops);
3570        if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3571            register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3572                panic("Couldn't register /dev/console driver\n");
3573        consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
3574                              "console");
3575        if (IS_ERR(consdev))
3576                consdev = NULL;
3577        else
3578                WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
3579
3580#ifdef CONFIG_VT
3581        vty_init(&console_fops);
3582#endif
3583        return 0;
3584}
3585
3586
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.