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        struct tty_ldisc *ldisc;
2144        unsigned long flags;
2145        int retval = 0;
2146
2147        if (tty_paranoia_check(tty, file_inode(filp), "tty_fasync"))
2148                goto out;
2149
2150        retval = fasync_helper(fd, filp, on, &tty->fasync);
2151        if (retval <= 0)
2152                goto out;
2153
2154        ldisc = tty_ldisc_ref(tty);
2155        if (ldisc) {
2156                if (ldisc->ops->fasync)
2157                        ldisc->ops->fasync(tty, on);
2158                tty_ldisc_deref(ldisc);
2159        }
2160
2161        if (on) {
2162                enum pid_type type;
2163                struct pid *pid;
2164
2165                spin_lock_irqsave(&tty->ctrl_lock, flags);
2166                if (tty->pgrp) {
2167                        pid = tty->pgrp;
2168                        type = PIDTYPE_PGID;
2169                } else {
2170                        pid = task_pid(current);
2171                        type = PIDTYPE_PID;
2172                }
2173                get_pid(pid);
2174                spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2175                retval = __f_setown(filp, pid, type, 0);
2176                put_pid(pid);
2177        }
2178out:
2179        return retval;
2180}
2181
2182static int tty_fasync(int fd, struct file *filp, int on)
2183{
2184        struct tty_struct *tty = file_tty(filp);
2185        int retval;
2186
2187        tty_lock(tty);
2188        retval = __tty_fasync(fd, filp, on);
2189        tty_unlock(tty);
2190
2191        return retval;
2192}
2193
2194/**
2195 *      tiocsti                 -       fake input character
2196 *      @tty: tty to fake input into
2197 *      @p: pointer to character
2198 *
2199 *      Fake input to a tty device. Does the necessary locking and
2200 *      input management.
2201 *
2202 *      FIXME: does not honour flow control ??
2203 *
2204 *      Locking:
2205 *              Called functions take tty_ldisc_lock
2206 *              current->signal->tty check is safe without locks
2207 *
2208 *      FIXME: may race normal receive processing
2209 */
2210
2211static int tiocsti(struct tty_struct *tty, char __user *p)
2212{
2213        char ch, mbz = 0;
2214        struct tty_ldisc *ld;
2215
2216        if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
2217                return -EPERM;
2218        if (get_user(ch, p))
2219                return -EFAULT;
2220        tty_audit_tiocsti(tty, ch);
2221        ld = tty_ldisc_ref_wait(tty);
2222        ld->ops->receive_buf(tty, &ch, &mbz, 1);
2223        tty_ldisc_deref(ld);
2224        return 0;
2225}
2226
2227/**
2228 *      tiocgwinsz              -       implement window query ioctl
2229 *      @tty; tty
2230 *      @arg: user buffer for result
2231 *
2232 *      Copies the kernel idea of the window size into the user buffer.
2233 *
2234 *      Locking: tty->termios_mutex is taken to ensure the winsize data
2235 *              is consistent.
2236 */
2237
2238static int tiocgwinsz(struct tty_struct *tty, struct winsize __user *arg)
2239{
2240        int err;
2241
2242        mutex_lock(&tty->termios_mutex);
2243        err = copy_to_user(arg, &tty->winsize, sizeof(*arg));
2244        mutex_unlock(&tty->termios_mutex);
2245
2246        return err ? -EFAULT: 0;
2247}
2248
2249/**
2250 *      tty_do_resize           -       resize event
2251 *      @tty: tty being resized
2252 *      @rows: rows (character)
2253 *      @cols: cols (character)
2254 *
2255 *      Update the termios variables and send the necessary signals to
2256 *      peform a terminal resize correctly
2257 */
2258
2259int tty_do_resize(struct tty_struct *tty, struct winsize *ws)
2260{
2261        struct pid *pgrp;
2262        unsigned long flags;
2263
2264        /* Lock the tty */
2265        mutex_lock(&tty->termios_mutex);
2266        if (!memcmp(ws, &tty->winsize, sizeof(*ws)))
2267                goto done;
2268        /* Get the PID values and reference them so we can
2269           avoid holding the tty ctrl lock while sending signals */
2270        spin_lock_irqsave(&tty->ctrl_lock, flags);
2271        pgrp = get_pid(tty->pgrp);
2272        spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2273
2274        if (pgrp)
2275                kill_pgrp(pgrp, SIGWINCH, 1);
2276        put_pid(pgrp);
2277
2278        tty->winsize = *ws;
2279done:
2280        mutex_unlock(&tty->termios_mutex);
2281        return 0;
2282}
2283EXPORT_SYMBOL(tty_do_resize);
2284
2285/**
2286 *      tiocswinsz              -       implement window size set ioctl
2287 *      @tty; tty side of tty
2288 *      @arg: user buffer for result
2289 *
2290 *      Copies the user idea of the window size to the kernel. Traditionally
2291 *      this is just advisory information but for the Linux console it
2292 *      actually has driver level meaning and triggers a VC resize.
2293 *
2294 *      Locking:
2295 *              Driver dependent. The default do_resize method takes the
2296 *      tty termios mutex and ctrl_lock. The console takes its own lock
2297 *      then calls into the default method.
2298 */
2299
2300static int tiocswinsz(struct tty_struct *tty, struct winsize __user *arg)
2301{
2302        struct winsize tmp_ws;
2303        if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
2304                return -EFAULT;
2305
2306        if (tty->ops->resize)
2307                return tty->ops->resize(tty, &tmp_ws);
2308        else
2309                return tty_do_resize(tty, &tmp_ws);
2310}
2311
2312/**
2313 *      tioccons        -       allow admin to move logical console
2314 *      @file: the file to become console
2315 *
2316 *      Allow the administrator to move the redirected console device
2317 *
2318 *      Locking: uses redirect_lock to guard the redirect information
2319 */
2320
2321static int tioccons(struct file *file)
2322{
2323        if (!capable(CAP_SYS_ADMIN))
2324                return -EPERM;
2325        if (file->f_op->write == redirected_tty_write) {
2326                struct file *f;
2327                spin_lock(&redirect_lock);
2328                f = redirect;
2329                redirect = NULL;
2330                spin_unlock(&redirect_lock);
2331                if (f)
2332                        fput(f);
2333                return 0;
2334        }
2335        spin_lock(&redirect_lock);
2336        if (redirect) {
2337                spin_unlock(&redirect_lock);
2338                return -EBUSY;
2339        }
2340        redirect = get_file(file);
2341        spin_unlock(&redirect_lock);
2342        return 0;
2343}
2344
2345/**
2346 *      fionbio         -       non blocking ioctl
2347 *      @file: file to set blocking value
2348 *      @p: user parameter
2349 *
2350 *      Historical tty interfaces had a blocking control ioctl before
2351 *      the generic functionality existed. This piece of history is preserved
2352 *      in the expected tty API of posix OS's.
2353 *
2354 *      Locking: none, the open file handle ensures it won't go away.
2355 */
2356
2357static int fionbio(struct file *file, int __user *p)
2358{
2359        int nonblock;
2360
2361        if (get_user(nonblock, p))
2362                return -EFAULT;
2363
2364        spin_lock(&file->f_lock);
2365        if (nonblock)
2366                file->f_flags |= O_NONBLOCK;
2367        else
2368                file->f_flags &= ~O_NONBLOCK;
2369        spin_unlock(&file->f_lock);
2370        return 0;
2371}
2372
2373/**
2374 *      tiocsctty       -       set controlling tty
2375 *      @tty: tty structure
2376 *      @arg: user argument
2377 *
2378 *      This ioctl is used to manage job control. It permits a session
2379 *      leader to set this tty as the controlling tty for the session.
2380 *
2381 *      Locking:
2382 *              Takes tty_mutex() to protect tty instance
2383 *              Takes tasklist_lock internally to walk sessions
2384 *              Takes ->siglock() when updating signal->tty
2385 */
2386
2387static int tiocsctty(struct tty_struct *tty, int arg)
2388{
2389        int ret = 0;
2390        if (current->signal->leader && (task_session(current) == tty->session))
2391                return ret;
2392
2393        mutex_lock(&tty_mutex);
2394        /*
2395         * The process must be a session leader and
2396         * not have a controlling tty already.
2397         */
2398        if (!current->signal->leader || current->signal->tty) {
2399                ret = -EPERM;
2400                goto unlock;
2401        }
2402
2403        if (tty->session) {
2404                /*
2405                 * This tty is already the controlling
2406                 * tty for another session group!
2407                 */
2408                if (arg == 1 && capable(CAP_SYS_ADMIN)) {
2409                        /*
2410                         * Steal it away
2411                         */
2412                        read_lock(&tasklist_lock);
2413                        session_clear_tty(tty->session);
2414                        read_unlock(&tasklist_lock);
2415                } else {
2416                        ret = -EPERM;
2417                        goto unlock;
2418                }
2419        }
2420        proc_set_tty(current, tty);
2421unlock:
2422        mutex_unlock(&tty_mutex);
2423        return ret;
2424}
2425
2426/**
2427 *      tty_get_pgrp    -       return a ref counted pgrp pid
2428 *      @tty: tty to read
2429 *
2430 *      Returns a refcounted instance of the pid struct for the process
2431 *      group controlling the tty.
2432 */
2433
2434struct pid *tty_get_pgrp(struct tty_struct *tty)
2435{
2436        unsigned long flags;
2437        struct pid *pgrp;
2438
2439        spin_lock_irqsave(&tty->ctrl_lock, flags);
2440        pgrp = get_pid(tty->pgrp);
2441        spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2442
2443        return pgrp;
2444}
2445EXPORT_SYMBOL_GPL(tty_get_pgrp);
2446
2447/**
2448 *      tiocgpgrp               -       get process group
2449 *      @tty: tty passed by user
2450 *      @real_tty: tty side of the tty passed by the user if a pty else the tty
2451 *      @p: returned pid
2452 *
2453 *      Obtain the process group of the tty. If there is no process group
2454 *      return an error.
2455 *
2456 *      Locking: none. Reference to current->signal->tty is safe.
2457 */
2458
2459static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2460{
2461        struct pid *pid;
2462        int ret;
2463        /*
2464         * (tty == real_tty) is a cheap way of
2465         * testing if the tty is NOT a master pty.
2466         */
2467        if (tty == real_tty && current->signal->tty != real_tty)
2468                return -ENOTTY;
2469        pid = tty_get_pgrp(real_tty);
2470        ret =  put_user(pid_vnr(pid), p);
2471        put_pid(pid);
2472        return ret;
2473}
2474
2475/**
2476 *      tiocspgrp               -       attempt to set process group
2477 *      @tty: tty passed by user
2478 *      @real_tty: tty side device matching tty passed by user
2479 *      @p: pid pointer
2480 *
2481 *      Set the process group of the tty to the session passed. Only
2482 *      permitted where the tty session is our session.
2483 *
2484 *      Locking: RCU, ctrl lock
2485 */
2486
2487static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2488{
2489        struct pid *pgrp;
2490        pid_t pgrp_nr;
2491        int retval = tty_check_change(real_tty);
2492        unsigned long flags;
2493
2494        if (retval == -EIO)
2495                return -ENOTTY;
2496        if (retval)
2497                return retval;
2498        if (!current->signal->tty ||
2499            (current->signal->tty != real_tty) ||
2500            (real_tty->session != task_session(current)))
2501                return -ENOTTY;
2502        if (get_user(pgrp_nr, p))
2503                return -EFAULT;
2504        if (pgrp_nr < 0)
2505                return -EINVAL;
2506        rcu_read_lock();
2507        pgrp = find_vpid(pgrp_nr);
2508        retval = -ESRCH;
2509        if (!pgrp)
2510                goto out_unlock;
2511        retval = -EPERM;
2512        if (session_of_pgrp(pgrp) != task_session(current))
2513                goto out_unlock;
2514        retval = 0;
2515        spin_lock_irqsave(&tty->ctrl_lock, flags);
2516        put_pid(real_tty->pgrp);
2517        real_tty->pgrp = get_pid(pgrp);
2518        spin_unlock_irqrestore(&tty->ctrl_lock, flags);
2519out_unlock:
2520        rcu_read_unlock();
2521        return retval;
2522}
2523
2524/**
2525 *      tiocgsid                -       get session id
2526 *      @tty: tty passed by user
2527 *      @real_tty: tty side of the tty passed by the user if a pty else the tty
2528 *      @p: pointer to returned session id
2529 *
2530 *      Obtain the session id of the tty. If there is no session
2531 *      return an error.
2532 *
2533 *      Locking: none. Reference to current->signal->tty is safe.
2534 */
2535
2536static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2537{
2538        /*
2539         * (tty == real_tty) is a cheap way of
2540         * testing if the tty is NOT a master pty.
2541        */
2542        if (tty == real_tty && current->signal->tty != real_tty)
2543                return -ENOTTY;
2544        if (!real_tty->session)
2545                return -ENOTTY;
2546        return put_user(pid_vnr(real_tty->session), p);
2547}
2548
2549/**
2550 *      tiocsetd        -       set line discipline
2551 *      @tty: tty device
2552 *      @p: pointer to user data
2553 *
2554 *      Set the line discipline according to user request.
2555 *
2556 *      Locking: see tty_set_ldisc, this function is just a helper
2557 */
2558
2559static int tiocsetd(struct tty_struct *tty, int __user *p)
2560{
2561        int ldisc;
2562        int ret;
2563
2564        if (get_user(ldisc, p))
2565                return -EFAULT;
2566
2567        ret = tty_set_ldisc(tty, ldisc);
2568
2569        return ret;
2570}
2571
2572/**
2573 *      send_break      -       performed time break
2574 *      @tty: device to break on
2575 *      @duration: timeout in mS
2576 *
2577 *      Perform a timed break on hardware that lacks its own driver level
2578 *      timed break functionality.
2579 *
2580 *      Locking:
2581 *              atomic_write_lock serializes
2582 *
2583 */
2584
2585static int send_break(struct tty_struct *tty, unsigned int duration)
2586{
2587        int retval;
2588
2589        if (tty->ops->break_ctl == NULL)
2590                return 0;
2591
2592        if (tty->driver->flags & TTY_DRIVER_HARDWARE_BREAK)
2593                retval = tty->ops->break_ctl(tty, duration);
2594        else {
2595                /* Do the work ourselves */
2596                if (tty_write_lock(tty, 0) < 0)
2597                        return -EINTR;
2598                retval = tty->ops->break_ctl(tty, -1);
2599                if (retval)
2600                        goto out;
2601                if (!signal_pending(current))
2602                        msleep_interruptible(duration);
2603                retval = tty->ops->break_ctl(tty, 0);
2604out:
2605                tty_write_unlock(tty);
2606                if (signal_pending(current))
2607                        retval = -EINTR;
2608        }
2609        return retval;
2610}
2611
2612/**
2613 *      tty_tiocmget            -       get modem status
2614 *      @tty: tty device
2615 *      @file: user file pointer
2616 *      @p: pointer to result
2617 *
2618 *      Obtain the modem status bits from the tty driver if the feature
2619 *      is supported. Return -EINVAL if it is not available.
2620 *
2621 *      Locking: none (up to the driver)
2622 */
2623
2624static int tty_tiocmget(struct tty_struct *tty, int __user *p)
2625{
2626        int retval = -EINVAL;
2627
2628        if (tty->ops->tiocmget) {
2629                retval = tty->ops->tiocmget(tty);
2630
2631                if (retval >= 0)
2632                        retval = put_user(retval, p);
2633        }
2634        return retval;
2635}
2636
2637/**
2638 *      tty_tiocmset            -       set modem status
2639 *      @tty: tty device
2640 *      @cmd: command - clear bits, set bits or set all
2641 *      @p: pointer to desired bits
2642 *
2643 *      Set the modem status bits from the tty driver if the feature
2644 *      is supported. Return -EINVAL if it is not available.
2645 *
2646 *      Locking: none (up to the driver)
2647 */
2648
2649static int tty_tiocmset(struct tty_struct *tty, unsigned int cmd,
2650             unsigned __user *p)
2651{
2652        int retval;
2653        unsigned int set, clear, val;
2654
2655        if (tty->ops->tiocmset == NULL)
2656                return -EINVAL;
2657
2658        retval = get_user(val, p);
2659        if (retval)
2660                return retval;
2661        set = clear = 0;
2662        switch (cmd) {
2663        case TIOCMBIS:
2664                set = val;
2665                break;
2666        case TIOCMBIC:
2667                clear = val;
2668                break;
2669        case TIOCMSET:
2670                set = val;
2671                clear = ~val;
2672                break;
2673        }
2674        set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2675        clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2676        return tty->ops->tiocmset(tty, set, clear);
2677}
2678
2679static int tty_tiocgicount(struct tty_struct *tty, void __user *arg)
2680{
2681        int retval = -EINVAL;
2682        struct serial_icounter_struct icount;
2683        memset(&icount, 0, sizeof(icount));
2684        if (tty->ops->get_icount)
2685                retval = tty->ops->get_icount(tty, &icount);
2686        if (retval != 0)
2687                return retval;
2688        if (copy_to_user(arg, &icount, sizeof(icount)))
2689                return -EFAULT;
2690        return 0;
2691}
2692
2693struct tty_struct *tty_pair_get_tty(struct tty_struct *tty)
2694{
2695        if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2696            tty->driver->subtype == PTY_TYPE_MASTER)
2697                tty = tty->link;
2698        return tty;
2699}
2700EXPORT_SYMBOL(tty_pair_get_tty);
2701
2702struct tty_struct *tty_pair_get_pty(struct tty_struct *tty)
2703{
2704        if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2705            tty->driver->subtype == PTY_TYPE_MASTER)
2706            return tty;
2707        return tty->link;
2708}
2709EXPORT_SYMBOL(tty_pair_get_pty);
2710
2711/*
2712 * Split this up, as gcc can choke on it otherwise..
2713 */
2714long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2715{
2716        struct tty_struct *tty = file_tty(file);
2717        struct tty_struct *real_tty;
2718        void __user *p = (void __user *)arg;
2719        int retval;
2720        struct tty_ldisc *ld;
2721
2722        if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
2723                return -EINVAL;
2724
2725        real_tty = tty_pair_get_tty(tty);
2726
2727        /*
2728         * Factor out some common prep work
2729         */
2730        switch (cmd) {
2731        case TIOCSETD:
2732        case TIOCSBRK:
2733        case TIOCCBRK:
2734        case TCSBRK:
2735        case TCSBRKP:
2736                retval = tty_check_change(tty);
2737                if (retval)
2738                        return retval;
2739                if (cmd != TIOCCBRK) {
2740                        tty_wait_until_sent(tty, 0);
2741                        if (signal_pending(current))
2742                                return -EINTR;
2743                }
2744                break;
2745        }
2746
2747        /*
2748         *      Now do the stuff.
2749         */
2750        switch (cmd) {
2751        case TIOCSTI:
2752                return tiocsti(tty, p);
2753        case TIOCGWINSZ:
2754                return tiocgwinsz(real_tty, p);
2755        case TIOCSWINSZ:
2756                return tiocswinsz(real_tty, p);
2757        case TIOCCONS:
2758                return real_tty != tty ? -EINVAL : tioccons(file);
2759        case FIONBIO:
2760                return fionbio(file, p);
2761        case TIOCEXCL:
2762                set_bit(TTY_EXCLUSIVE, &tty->flags);
2763                return 0;
2764        case TIOCNXCL:
2765                clear_bit(TTY_EXCLUSIVE, &tty->flags);
2766                return 0;
2767        case TIOCGEXCL:
2768        {
2769                int excl = test_bit(TTY_EXCLUSIVE, &tty->flags);
2770                return put_user(excl, (int __user *)p);
2771        }
2772        case TIOCNOTTY:
2773                if (current->signal->tty != tty)
2774                        return -ENOTTY;
2775                no_tty();
2776                return 0;
2777        case TIOCSCTTY:
2778                return tiocsctty(tty, arg);
2779        case TIOCGPGRP:
2780                return tiocgpgrp(tty, real_tty, p);
2781        case TIOCSPGRP:
2782                return tiocspgrp(tty, real_tty, p);
2783        case TIOCGSID:
2784                return tiocgsid(tty, real_tty, p);
2785        case TIOCGETD:
2786                return put_user(tty->ldisc->ops->num, (int __user *)p);
2787        case TIOCSETD:
2788                return tiocsetd(tty, p);
2789        case TIOCVHANGUP:
2790                if (!capable(CAP_SYS_ADMIN))
2791                        return -EPERM;
2792                tty_vhangup(tty);
2793                return 0;
2794        case TIOCGDEV:
2795        {
2796                unsigned int ret = new_encode_dev(tty_devnum(real_tty));
2797                return put_user(ret, (unsigned int __user *)p);
2798        }
2799        /*
2800         * Break handling
2801         */
2802        case TIOCSBRK:  /* Turn break on, unconditionally */
2803                if (tty->ops->break_ctl)
2804                        return tty->ops->break_ctl(tty, -1);
2805                return 0;
2806        case TIOCCBRK:  /* Turn break off, unconditionally */
2807                if (tty->ops->break_ctl)
2808                        return tty->ops->break_ctl(tty, 0);
2809                return 0;
2810        case TCSBRK:   /* SVID version: non-zero arg --> no break */
2811                /* non-zero arg means wait for all output data
2812                 * to be sent (performed above) but don't send break.
2813                 * This is used by the tcdrain() termios function.
2814                 */
2815                if (!arg)
2816                        return send_break(tty, 250);
2817                return 0;
2818        case TCSBRKP:   /* support for POSIX tcsendbreak() */
2819                return send_break(tty, arg ? arg*100 : 250);
2820
2821        case TIOCMGET:
2822                return tty_tiocmget(tty, p);
2823        case TIOCMSET:
2824        case TIOCMBIC:
2825        case TIOCMBIS:
2826                return tty_tiocmset(tty, cmd, p);
2827        case TIOCGICOUNT:
2828                retval = tty_tiocgicount(tty, p);
2829                /* For the moment allow fall through to the old method */
2830                if (retval != -EINVAL)
2831                        return retval;
2832                break;
2833        case TCFLSH:
2834                switch (arg) {
2835                case TCIFLUSH:
2836                case TCIOFLUSH:
2837                /* flush tty buffer and allow ldisc to process ioctl */
2838                        tty_buffer_flush(tty);
2839                        break;
2840                }
2841                break;
2842        }
2843        if (tty->ops->ioctl) {
2844                retval = (tty->ops->ioctl)(tty, cmd, arg);
2845                if (retval != -ENOIOCTLCMD)
2846                        return retval;
2847        }
2848        ld = tty_ldisc_ref_wait(tty);
2849        retval = -EINVAL;
2850        if (ld->ops->ioctl) {
2851                retval = ld->ops->ioctl(tty, file, cmd, arg);
2852                if (retval == -ENOIOCTLCMD)
2853                        retval = -ENOTTY;
2854        }
2855        tty_ldisc_deref(ld);
2856        return retval;
2857}
2858
2859#ifdef CONFIG_COMPAT
2860static long tty_compat_ioctl(struct file *file, unsigned int cmd,
2861                                unsigned long arg)
2862{
2863        struct tty_struct *tty = file_tty(file);
2864        struct tty_ldisc *ld;
2865        int retval = -ENOIOCTLCMD;
2866
2867        if (tty_paranoia_check(tty, file_inode(file), "tty_ioctl"))
2868                return -EINVAL;
2869
2870        if (tty->ops->compat_ioctl) {
2871                retval = (tty->ops->compat_ioctl)(tty, cmd, arg);
2872                if (retval != -ENOIOCTLCMD)
2873                        return retval;
2874        }
2875
2876        ld = tty_ldisc_ref_wait(tty);
2877        if (ld->ops->compat_ioctl)
2878                retval = ld->ops->compat_ioctl(tty, file, cmd, arg);
2879        else
2880                retval = n_tty_compat_ioctl_helper(tty, file, cmd, arg);
2881        tty_ldisc_deref(ld);
2882
2883        return retval;
2884}
2885#endif
2886
2887static int this_tty(const void *t, struct file *file, unsigned fd)
2888{
2889        if (likely(file->f_op->read != tty_read))
2890                return 0;
2891        return file_tty(file) != t ? 0 : fd + 1;
2892}
2893        
2894/*
2895 * This implements the "Secure Attention Key" ---  the idea is to
2896 * prevent trojan horses by killing all processes associated with this
2897 * tty when the user hits the "Secure Attention Key".  Required for
2898 * super-paranoid applications --- see the Orange Book for more details.
2899 *
2900 * This code could be nicer; ideally it should send a HUP, wait a few
2901 * seconds, then send a INT, and then a KILL signal.  But you then
2902 * have to coordinate with the init process, since all processes associated
2903 * with the current tty must be dead before the new getty is allowed
2904 * to spawn.
2905 *
2906 * Now, if it would be correct ;-/ The current code has a nasty hole -
2907 * it doesn't catch files in flight. We may send the descriptor to ourselves
2908 * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2909 *
2910 * Nasty bug: do_SAK is being called in interrupt context.  This can
2911 * deadlock.  We punt it up to process context.  AKPM - 16Mar2001
2912 */
2913void __do_SAK(struct tty_struct *tty)
2914{
2915#ifdef TTY_SOFT_SAK
2916        tty_hangup(tty);
2917#else
2918        struct task_struct *g, *p;
2919        struct pid *session;
2920        int             i;
2921
2922        if (!tty)
2923                return;
2924        session = tty->session;
2925
2926        tty_ldisc_flush(tty);
2927
2928        tty_driver_flush_buffer(tty);
2929
2930        read_lock(&tasklist_lock);
2931        /* Kill the entire session */
2932        do_each_pid_task(session, PIDTYPE_SID, p) {
2933                printk(KERN_NOTICE "SAK: killed process %d"
2934                        " (%s): task_session(p)==tty->session\n",
2935                        task_pid_nr(p), p->comm);
2936                send_sig(SIGKILL, p, 1);
2937        } while_each_pid_task(session, PIDTYPE_SID, p);
2938        /* Now kill any processes that happen to have the
2939         * tty open.
2940         */
2941        do_each_thread(g, p) {
2942                if (p->signal->tty == tty) {
2943                        printk(KERN_NOTICE "SAK: killed process %d"
2944                            " (%s): task_session(p)==tty->session\n",
2945                            task_pid_nr(p), p->comm);
2946                        send_sig(SIGKILL, p, 1);
2947                        continue;
2948                }
2949                task_lock(p);
2950                i = iterate_fd(p->files, 0, this_tty, tty);
2951                if (i != 0) {
2952                        printk(KERN_NOTICE "SAK: killed process %d"
2953                            " (%s): fd#%d opened to the tty\n",
2954                                    task_pid_nr(p), p->comm, i - 1);
2955                        force_sig(SIGKILL, p);
2956                }
2957                task_unlock(p);
2958        } while_each_thread(g, p);
2959        read_unlock(&tasklist_lock);
2960#endif
2961}
2962
2963static void do_SAK_work(struct work_struct *work)
2964{
2965        struct tty_struct *tty =
2966                container_of(work, struct tty_struct, SAK_work);
2967        __do_SAK(tty);
2968}
2969
2970/*
2971 * The tq handling here is a little racy - tty->SAK_work may already be queued.
2972 * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2973 * the values which we write to it will be identical to the values which it
2974 * already has. --akpm
2975 */
2976void do_SAK(struct tty_struct *tty)
2977{
2978        if (!tty)
2979                return;
2980        schedule_work(&tty->SAK_work);
2981}
2982
2983EXPORT_SYMBOL(do_SAK);
2984
2985static int dev_match_devt(struct device *dev, const void *data)
2986{
2987        const dev_t *devt = data;
2988        return dev->devt == *devt;
2989}
2990
2991/* Must put_device() after it's unused! */
2992static struct device *tty_get_device(struct tty_struct *tty)
2993{
2994        dev_t devt = tty_devnum(tty);
2995        return class_find_device(tty_class, NULL, &devt, dev_match_devt);
2996}
2997
2998
2999/**
3000 *      initialize_tty_struct
3001 *      @tty: tty to initialize
3002 *
3003 *      This subroutine initializes a tty structure that has been newly
3004 *      allocated.
3005 *
3006 *      Locking: none - tty in question must not be exposed at this point
3007 */
3008
3009void initialize_tty_struct(struct tty_struct *tty,
3010                struct tty_driver *driver, int idx)
3011{
3012        memset(tty, 0, sizeof(struct tty_struct));
3013        kref_init(&tty->kref);
3014        tty->magic = TTY_MAGIC;
3015        tty_ldisc_init(tty);
3016        tty->session = NULL;
3017        tty->pgrp = NULL;
3018        mutex_init(&tty->legacy_mutex);
3019        mutex_init(&tty->termios_mutex);
3020        mutex_init(&tty->ldisc_mutex);
3021        init_waitqueue_head(&tty->write_wait);
3022        init_waitqueue_head(&tty->read_wait);
3023        INIT_WORK(&tty->hangup_work, do_tty_hangup);
3024        mutex_init(&tty->atomic_write_lock);
3025        spin_lock_init(&tty->ctrl_lock);
3026        INIT_LIST_HEAD(&tty->tty_files);
3027        INIT_WORK(&tty->SAK_work, do_SAK_work);
3028
3029        tty->driver = driver;
3030        tty->ops = driver->ops;
3031        tty->index = idx;
3032        tty_line_name(driver, idx, tty->name);
3033        tty->dev = tty_get_device(tty);
3034}
3035
3036/**
3037 *      deinitialize_tty_struct
3038 *      @tty: tty to deinitialize
3039 *
3040 *      This subroutine deinitializes a tty structure that has been newly
3041 *      allocated but tty_release cannot be called on that yet.
3042 *
3043 *      Locking: none - tty in question must not be exposed at this point
3044 */
3045void deinitialize_tty_struct(struct tty_struct *tty)
3046{
3047        tty_ldisc_deinit(tty);
3048}
3049
3050/**
3051 *      tty_put_char    -       write one character to a tty
3052 *      @tty: tty
3053 *      @ch: character
3054 *
3055 *      Write one byte to the tty using the provided put_char method
3056 *      if present. Returns the number of characters successfully output.
3057 *
3058 *      Note: the specific put_char operation in the driver layer may go
3059 *      away soon. Don't call it directly, use this method
3060 */
3061
3062int tty_put_char(struct tty_struct *tty, unsigned char ch)
3063{
3064        if (tty->ops->put_char)
3065                return tty->ops->put_char(tty, ch);
3066        return tty->ops->write(tty, &ch, 1);
3067}
3068EXPORT_SYMBOL_GPL(tty_put_char);
3069
3070struct class *tty_class;
3071
3072static int tty_cdev_add(struct tty_driver *driver, dev_t dev,
3073                unsigned int index, unsigned int count)
3074{
3075        /* init here, since reused cdevs cause crashes */
3076        cdev_init(&driver->cdevs[index], &tty_fops);
3077        driver->cdevs[index].owner = driver->owner;
3078        return cdev_add(&driver->cdevs[index], dev, count);
3079}
3080
3081/**
3082 *      tty_register_device - register a tty device
3083 *      @driver: the tty driver that describes the tty device
3084 *      @index: the index in the tty driver for this tty device
3085 *      @device: a struct device that is associated with this tty device.
3086 *              This field is optional, if there is no known struct device
3087 *              for this tty device it can be set to NULL safely.
3088 *
3089 *      Returns a pointer to the struct device for this tty device
3090 *      (or ERR_PTR(-EFOO) on error).
3091 *
3092 *      This call is required to be made to register an individual tty device
3093 *      if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set.  If
3094 *      that bit is not set, this function should not be called by a tty
3095 *      driver.
3096 *
3097 *      Locking: ??
3098 */
3099
3100struct device *tty_register_device(struct tty_driver *driver, unsigned index,
3101                                   struct device *device)
3102{
3103        return tty_register_device_attr(driver, index, device, NULL, NULL);
3104}
3105EXPORT_SYMBOL(tty_register_device);
3106
3107static void tty_device_create_release(struct device *dev)
3108{
3109        pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
3110        kfree(dev);
3111}
3112
3113/**
3114 *      tty_register_device_attr - register a tty device
3115 *      @driver: the tty driver that describes the tty device
3116 *      @index: the index in the tty driver for this tty device
3117 *      @device: a struct device that is associated with this tty device.
3118 *              This field is optional, if there is no known struct device
3119 *              for this tty device it can be set to NULL safely.
3120 *      @drvdata: Driver data to be set to device.
3121 *      @attr_grp: Attribute group to be set on device.
3122 *
3123 *      Returns a pointer to the struct device for this tty device
3124 *      (or ERR_PTR(-EFOO) on error).
3125 *
3126 *      This call is required to be made to register an individual tty device
3127 *      if the tty driver's flags have the TTY_DRIVER_DYNAMIC_DEV bit set.  If
3128 *      that bit is not set, this function should not be called by a tty
3129 *      driver.
3130 *
3131 *      Locking: ??
3132 */
3133struct device *tty_register_device_attr(struct tty_driver *driver,
3134                                   unsigned index, struct device *device,
3135                                   void *drvdata,
3136                                   const struct attribute_group **attr_grp)
3137{
3138        char name[64];
3139        dev_t devt = MKDEV(driver->major, driver->minor_start) + index;
3140        struct device *dev = NULL;
3141        int retval = -ENODEV;
3142        bool cdev = false;
3143
3144        if (index >= driver->num) {
3145                printk(KERN_ERR "Attempt to register invalid tty line number "
3146                       " (%d).\n", index);
3147                return ERR_PTR(-EINVAL);
3148        }
3149
3150        if (driver->type == TTY_DRIVER_TYPE_PTY)
3151                pty_line_name(driver, index, name);
3152        else
3153                tty_line_name(driver, index, name);
3154
3155        if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3156                retval = tty_cdev_add(driver, devt, index, 1);
3157                if (retval)
3158                        goto error;
3159                cdev = true;
3160        }
3161
3162        dev = kzalloc(sizeof(*dev), GFP_KERNEL);
3163        if (!dev) {
3164                retval = -ENOMEM;
3165                goto error;
3166        }
3167
3168        dev->devt = devt;
3169        dev->class = tty_class;
3170        dev->parent = device;
3171        dev->release = tty_device_create_release;
3172        dev_set_name(dev, "%s", name);
3173        dev->groups = attr_grp;
3174        dev_set_drvdata(dev, drvdata);
3175
3176        retval = device_register(dev);
3177        if (retval)
3178                goto error;
3179
3180        return dev;
3181
3182error:
3183        put_device(dev);
3184        if (cdev)
3185                cdev_del(&driver->cdevs[index]);
3186        return ERR_PTR(retval);
3187}
3188EXPORT_SYMBOL_GPL(tty_register_device_attr);
3189
3190/**
3191 *      tty_unregister_device - unregister a tty device
3192 *      @driver: the tty driver that describes the tty device
3193 *      @index: the index in the tty driver for this tty device
3194 *
3195 *      If a tty device is registered with a call to tty_register_device() then
3196 *      this function must be called when the tty device is gone.
3197 *
3198 *      Locking: ??
3199 */
3200
3201void tty_unregister_device(struct tty_driver *driver, unsigned index)
3202{
3203        device_destroy(tty_class,
3204                MKDEV(driver->major, driver->minor_start) + index);
3205        if (!(driver->flags & TTY_DRIVER_DYNAMIC_ALLOC))
3206                cdev_del(&driver->cdevs[index]);
3207}
3208EXPORT_SYMBOL(tty_unregister_device);
3209
3210/**
3211 * __tty_alloc_driver -- allocate tty driver
3212 * @lines: count of lines this driver can handle at most
3213 * @owner: module which is repsonsible for this driver
3214 * @flags: some of TTY_DRIVER_* flags, will be set in driver->flags
3215 *
3216 * This should not be called directly, some of the provided macros should be
3217 * used instead. Use IS_ERR and friends on @retval.
3218 */
3219struct tty_driver *__tty_alloc_driver(unsigned int lines, struct module *owner,
3220                unsigned long flags)
3221{
3222        struct tty_driver *driver;
3223        unsigned int cdevs = 1;
3224        int err;
3225
3226        if (!lines || (flags & TTY_DRIVER_UNNUMBERED_NODE && lines > 1))
3227                return ERR_PTR(-EINVAL);
3228
3229        driver = kzalloc(sizeof(struct tty_driver), GFP_KERNEL);
3230        if (!driver)
3231                return ERR_PTR(-ENOMEM);
3232
3233        kref_init(&driver->kref);
3234        driver->magic = TTY_DRIVER_MAGIC;
3235        driver->num = lines;
3236        driver->owner = owner;
3237        driver->flags = flags;
3238
3239        if (!(flags & TTY_DRIVER_DEVPTS_MEM)) {
3240                driver->ttys = kcalloc(lines, sizeof(*driver->ttys),
3241                                GFP_KERNEL);
3242                driver->termios = kcalloc(lines, sizeof(*driver->termios),
3243                                GFP_KERNEL);
3244                if (!driver->ttys || !driver->termios) {
3245                        err = -ENOMEM;
3246                        goto err_free_all;
3247                }
3248        }
3249
3250        if (!(flags & TTY_DRIVER_DYNAMIC_ALLOC)) {
3251                driver->ports = kcalloc(lines, sizeof(*driver->ports),
3252                                GFP_KERNEL);
3253                if (!driver->ports) {
3254                        err = -ENOMEM;
3255                        goto err_free_all;
3256                }
3257                cdevs = lines;
3258        }
3259
3260        driver->cdevs = kcalloc(cdevs, sizeof(*driver->cdevs), GFP_KERNEL);
3261        if (!driver->cdevs) {
3262                err = -ENOMEM;
3263                goto err_free_all;
3264        }
3265
3266        return driver;
3267err_free_all:
3268        kfree(driver->ports);
3269        kfree(driver->ttys);
3270        kfree(driver->termios);
3271        kfree(driver);
3272        return ERR_PTR(err);
3273}
3274EXPORT_SYMBOL(__tty_alloc_driver);
3275
3276static void destruct_tty_driver(struct kref *kref)
3277{
3278        struct tty_driver *driver = container_of(kref, struct tty_driver, kref);
3279        int i;
3280        struct ktermios *tp;
3281
3282        if (driver->flags & TTY_DRIVER_INSTALLED) {
3283                /*
3284                 * Free the termios and termios_locked structures because
3285                 * we don't want to get memory leaks when modular tty
3286                 * drivers are removed from the kernel.
3287                 */
3288                for (i = 0; i < driver->num; i++) {
3289                        tp = driver->termios[i];
3290                        if (tp) {
3291                                driver->termios[i] = NULL;
3292                                kfree(tp);
3293                        }
3294                        if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV))
3295                                tty_unregister_device(driver, i);
3296                }
3297                proc_tty_unregister_driver(driver);
3298                if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC)
3299                        cdev_del(&driver->cdevs[0]);
3300        }
3301        kfree(driver->cdevs);
3302        kfree(driver->ports);
3303        kfree(driver->termios);
3304        kfree(driver->ttys);
3305        kfree(driver);
3306}
3307
3308void tty_driver_kref_put(struct tty_driver *driver)
3309{
3310        kref_put(&driver->kref, destruct_tty_driver);
3311}
3312EXPORT_SYMBOL(tty_driver_kref_put);
3313
3314void tty_set_operations(struct tty_driver *driver,
3315                        const struct tty_operations *op)
3316{
3317        driver->ops = op;
3318};
3319EXPORT_SYMBOL(tty_set_operations);
3320
3321void put_tty_driver(struct tty_driver *d)
3322{
3323        tty_driver_kref_put(d);
3324}
3325EXPORT_SYMBOL(put_tty_driver);
3326
3327/*
3328 * Called by a tty driver to register itself.
3329 */
3330int tty_register_driver(struct tty_driver *driver)
3331{
3332        int error;
3333        int i;
3334        dev_t dev;
3335        struct device *d;
3336
3337        if (!driver->major) {
3338                error = alloc_chrdev_region(&dev, driver->minor_start,
3339                                                driver->num, driver->name);
3340                if (!error) {
3341                        driver->major = MAJOR(dev);
3342                        driver->minor_start = MINOR(dev);
3343                }
3344        } else {
3345                dev = MKDEV(driver->major, driver->minor_start);
3346                error = register_chrdev_region(dev, driver->num, driver->name);
3347        }
3348        if (error < 0)
3349                goto err;
3350
3351        if (driver->flags & TTY_DRIVER_DYNAMIC_ALLOC) {
3352                error = tty_cdev_add(driver, dev, 0, driver->num);
3353                if (error)
3354                        goto err_unreg_char;
3355        }
3356
3357        mutex_lock(&tty_mutex);
3358        list_add(&driver->tty_drivers, &tty_drivers);
3359        mutex_unlock(&tty_mutex);
3360
3361        if (!(driver->flags & TTY_DRIVER_DYNAMIC_DEV)) {
3362                for (i = 0; i < driver->num; i++) {
3363                        d = tty_register_device(driver, i, NULL);
3364                        if (IS_ERR(d)) {
3365                                error = PTR_ERR(d);
3366                                goto err_unreg_devs;
3367                        }
3368                }
3369        }
3370        proc_tty_register_driver(driver);
3371        driver->flags |= TTY_DRIVER_INSTALLED;
3372        return 0;
3373
3374err_unreg_devs:
3375        for (i--; i >= 0; i--)
3376                tty_unregister_device(driver, i);
3377
3378        mutex_lock(&tty_mutex);
3379        list_del(&driver->tty_drivers);
3380        mutex_unlock(&tty_mutex);
3381
3382err_unreg_char:
3383        unregister_chrdev_region(dev, driver->num);
3384err:
3385        return error;
3386}
3387EXPORT_SYMBOL(tty_register_driver);
3388
3389/*
3390 * Called by a tty driver to unregister itself.
3391 */
3392int tty_unregister_driver(struct tty_driver *driver)
3393{
3394#if 0
3395        /* FIXME */
3396        if (driver->refcount)
3397                return -EBUSY;
3398#endif
3399        unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
3400                                driver->num);
3401        mutex_lock(&tty_mutex);
3402        list_del(&driver->tty_drivers);
3403        mutex_unlock(&tty_mutex);
3404        return 0;
3405}
3406
3407EXPORT_SYMBOL(tty_unregister_driver);
3408
3409dev_t tty_devnum(struct tty_struct *tty)
3410{
3411        return MKDEV(tty->driver->major, tty->driver->minor_start) + tty->index;
3412}
3413EXPORT_SYMBOL(tty_devnum);
3414
3415void proc_clear_tty(struct task_struct *p)
3416{
3417        unsigned long flags;
3418        struct tty_struct *tty;
3419        spin_lock_irqsave(&p->sighand->siglock, flags);
3420        tty = p->signal->tty;
3421        p->signal->tty = NULL;
3422        spin_unlock_irqrestore(&p->sighand->siglock, flags);
3423        tty_kref_put(tty);
3424}
3425
3426/* Called under the sighand lock */
3427
3428static void __proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3429{
3430        if (tty) {
3431                unsigned long flags;
3432                /* We should not have a session or pgrp to put here but.... */
3433                spin_lock_irqsave(&tty->ctrl_lock, flags);
3434                put_pid(tty->session);
3435                put_pid(tty->pgrp);
3436                tty->pgrp = get_pid(task_pgrp(tsk));
3437                spin_unlock_irqrestore(&tty->ctrl_lock, flags);
3438                tty->session = get_pid(task_session(tsk));
3439                if (tsk->signal->tty) {
3440                        printk(KERN_DEBUG "tty not NULL!!\n");
3441                        tty_kref_put(tsk->signal->tty);
3442                }
3443        }
3444        put_pid(tsk->signal->tty_old_pgrp);
3445        tsk->signal->tty = tty_kref_get(tty);
3446        tsk->signal->tty_old_pgrp = NULL;
3447}
3448
3449static void proc_set_tty(struct task_struct *tsk, struct tty_struct *tty)
3450{
3451        spin_lock_irq(&tsk->sighand->siglock);
3452        __proc_set_tty(tsk, tty);
3453        spin_unlock_irq(&tsk->sighand->siglock);
3454}
3455
3456struct tty_struct *get_current_tty(void)
3457{
3458        struct tty_struct *tty;
3459        unsigned long flags;
3460
3461        spin_lock_irqsave(&current->sighand->siglock, flags);
3462        tty = tty_kref_get(current->signal->tty);
3463        spin_unlock_irqrestore(&current->sighand->siglock, flags);
3464        return tty;
3465}
3466EXPORT_SYMBOL_GPL(get_current_tty);
3467
3468void tty_default_fops(struct file_operations *fops)
3469{
3470        *fops = tty_fops;
3471}
3472
3473/*
3474 * Initialize the console device. This is called *early*, so
3475 * we can't necessarily depend on lots of kernel help here.
3476 * Just do some early initializations, and do the complex setup
3477 * later.
3478 */
3479void __init console_init(void)
3480{
3481        initcall_t *call;
3482
3483        /* Setup the default TTY line discipline. */
3484        tty_ldisc_begin();
3485
3486        /*
3487         * set up the console device so that later boot sequences can
3488         * inform about problems etc..
3489         */
3490        call = __con_initcall_start;
3491        while (call < __con_initcall_end) {
3492                (*call)();
3493                call++;
3494        }
3495}
3496
3497static char *tty_devnode(struct device *dev, umode_t *mode)
3498{
3499        if (!mode)
3500                return NULL;
3501        if (dev->devt == MKDEV(TTYAUX_MAJOR, 0) ||
3502            dev->devt == MKDEV(TTYAUX_MAJOR, 2))
3503                *mode = 0666;
3504        return NULL;
3505}
3506
3507static int __init tty_class_init(void)
3508{
3509        tty_class = class_create(THIS_MODULE, "tty");
3510        if (IS_ERR(tty_class))
3511                return PTR_ERR(tty_class);
3512        tty_class->devnode = tty_devnode;
3513        return 0;
3514}
3515
3516postcore_initcall(tty_class_init);
3517
3518/* 3/2004 jmc: why do these devices exist? */
3519static struct cdev tty_cdev, console_cdev;
3520
3521static ssize_t show_cons_active(struct device *dev,
3522                                struct device_attribute *attr, char *buf)
3523{
3524        struct console *cs[16];
3525        int i = 0;
3526        struct console *c;
3527        ssize_t count = 0;
3528
3529        console_lock();
3530        for_each_console(c) {
3531                if (!c->device)
3532                        continue;
3533                if (!c->write)
3534                        continue;
3535                if ((c->flags & CON_ENABLED) == 0)
3536                        continue;
3537                cs[i++] = c;
3538                if (i >= ARRAY_SIZE(cs))
3539                        break;
3540        }
3541        while (i--)
3542                count += sprintf(buf + count, "%s%d%c",
3543                                 cs[i]->name, cs[i]->index, i ? ' ':'\n');
3544        console_unlock();
3545
3546        return count;
3547}
3548static DEVICE_ATTR(active, S_IRUGO, show_cons_active, NULL);
3549
3550static struct device *consdev;
3551
3552void console_sysfs_notify(void)
3553{
3554        if (consdev)
3555                sysfs_notify(&consdev->kobj, NULL, "active");
3556}
3557
3558/*
3559 * Ok, now we can initialize the rest of the tty devices and can count
3560 * on memory allocations, interrupts etc..
3561 */
3562int __init tty_init(void)
3563{
3564        cdev_init(&tty_cdev, &tty_fops);
3565        if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
3566            register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
3567                panic("Couldn't register /dev/tty driver\n");
3568        device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
3569
3570        cdev_init(&console_cdev, &console_fops);
3571        if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
3572            register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
3573                panic("Couldn't register /dev/console driver\n");
3574        consdev = device_create(tty_class, NULL, MKDEV(TTYAUX_MAJOR, 1), NULL,
3575                              "console");
3576        if (IS_ERR(consdev))
3577                consdev = NULL;
3578        else
3579                WARN_ON(device_create_file(consdev, &dev_attr_active) < 0);
3580
3581#ifdef CONFIG_VT
3582        vty_init(&console_fops);
3583#endif
3584        return 0;
3585}
3586
3587
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.