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