drivers/char/tty_io.c

   1 /*
   2  *  linux/drivers/char/tty_io.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6
   7 /*
   8  * 'tty_io.c' gives an orthogonal feeling to tty's, be they consoles
   9  * or rs-channels. It also implements echoing, cooked mode etc.
  10  *
  11  * Kill-line thanks to John T Kohl, who also corrected VMIN = VTIME = 0.
  12  *
  13  * Modified by Theodore Ts'o, 9/14/92, to dynamically allocate the
  14  * tty_struct and tty_queue structures.  Previously there was an array
  15  * of 256 tty_struct's which was statically allocated, and the
  16  * tty_queue structures were allocated at boot time.  Both are now
  17  * dynamically allocated only when the tty is open.
  18  *
  19  * Also restructured routines so that there is more of a separation
  20  * between the high-level tty routines (tty_io.c and tty_ioctl.c) and
  21  * the low-level tty routines (serial.c, pty.c, console.c).  This
  22  * makes for cleaner and more compact code.  -TYT, 9/17/92
  23  *
  24  * Modified by Fred N. van Kempen, 01/29/93, to add line disciplines
  25  * which can be dynamically activated and de-activated by the line
  26  * discipline handling modules (like SLIP).
  27  *
  28  * NOTE: pay no attention to the line discipline code (yet); its
  29  * interface is still subject to change in this version...
  30  * -- TYT, 1/31/92
  31  *
  32  * Added functionality to the OPOST tty handling.  No delays, but all
  33  * other bits should be there.
  34  *      -- Nick Holloway <alfie@dcs.warwick.ac.uk>, 27th May 1993.
  35  *
  36  * Rewrote canonical mode and added more termios flags.
  37  *      -- julian@uhunix.uhcc.hawaii.edu (J. Cowley), 13Jan94
  38  *
  39  * Reorganized FASYNC support so mouse code can share it.
  40  *      -- ctm@ardi.com, 9Sep95
  41  *
  42  * New TIOCLINUX variants added.
  43  *      -- mj@k332.feld.cvut.cz, 19-Nov-95
  44  *
  45  * Restrict vt switching via ioctl()
  46  *      -- grif@cs.ucr.edu, 5-Dec-95
  47  *
  48  * Move console and virtual terminal code to more appropriate files,
  49  * implement CONFIG_VT and generalize console device interface.
  50  *      -- Marko Kohtala <Marko.Kohtala@hut.fi>, March 97
  51  *
  52  * Rewrote init_dev and release_dev to eliminate races.
  53  *      -- Bill Hawes <whawes@star.net>, June 97
  54  *
  55  * Added devfs support.
  56  *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 13-Jan-1998
  57  *
  58  * Added support for a Unix98-style ptmx device.
  59  *      -- C. Scott Ananian <cananian@alumni.princeton.edu>, 14-Jan-1998
  60  *
  61  * Reduced memory usage for older ARM systems
  62  *      -- Russell King <rmk@arm.linux.org.uk>
  63  *
  64  * Move do_SAK() into process context.  Less stack use in devfs functions.
  65  * alloc_tty_struct() always uses kmalloc() -- Andrew Morton <andrewm@uow.edu.eu> 17Mar01
  66  */
  67
  68 #include <linux/config.h>
  69 #include <linux/types.h>
  70 #include <linux/major.h>
  71 #include <linux/errno.h>
  72 #include <linux/signal.h>
  73 #include <linux/fcntl.h>
  74 #include <linux/sched.h>
  75 #include <linux/interrupt.h>
  76 #include <linux/tty.h>
  77 #include <linux/tty_driver.h>
  78 #include <linux/tty_flip.h>
  79 #include <linux/devpts_fs.h>
  80 #include <linux/file.h>
  81 #include <linux/console.h>
  82 #include <linux/timer.h>
  83 #include <linux/ctype.h>
  84 #include <linux/kd.h>
  85 #include <linux/mm.h>
  86 #include <linux/string.h>
  87 #include <linux/slab.h>
  88 #include <linux/poll.h>
  89 #include <linux/proc_fs.h>
  90 #include <linux/init.h>
  91 #include <linux/module.h>
  92 #include <linux/smp_lock.h>
  93 #include <linux/device.h>
  94 #include <linux/idr.h>
  95 #include <linux/wait.h>
  96
  97 #include <asm/uaccess.h>
  98 #include <asm/system.h>
  99 #include <asm/bitops.h>
 100
 101 #include <linux/kbd_kern.h>
 102 #include <linux/vt_kern.h>
 103 #include <linux/selection.h>
 104 #include <linux/devfs_fs_kernel.h>
 105 #include <linux/vs_cvirt.h>
 106
 107 #include <linux/kmod.h>
 108
 109 #undef TTY_DEBUG_HANGUP
 110
 111 #define TTY_PARANOIA_CHECK 1
 112 #define CHECK_TTY_COUNT 1
 113
 114 struct termios tty_std_termios = {      /* for the benefit of tty drivers  */
 115         .c_iflag = ICRNL | IXON,
 116         .c_oflag = OPOST | ONLCR,
 117         .c_cflag = B38400 | CS8 | CREAD | HUPCL,
 118         .c_lflag = ISIG | ICANON | ECHO | ECHOE | ECHOK |
 119                    ECHOCTL | ECHOKE | IEXTEN,
 120         .c_cc = INIT_C_CC
 121 };
 122
 123 EXPORT_SYMBOL(tty_std_termios);
 124
 125 /* This list gets poked at by procfs and various bits of boot up code. This
 126    could do with some rationalisation such as pulling the tty proc function
 127    into this file */
 128
 129 LIST_HEAD(tty_drivers);                 /* linked list of tty drivers */
 130
 131 /* Semaphore to protect creating and releasing a tty. This is shared with
 132    vt.c for deeply disgusting hack reasons */
 133 DECLARE_MUTEX(tty_sem);
 134
 135 #ifdef CONFIG_UNIX98_PTYS
 136 extern struct tty_driver *ptm_driver;   /* Unix98 pty masters; for /dev/ptmx */
 137 extern int pty_limit;           /* Config limit on Unix98 ptys */
 138 static DEFINE_IDR(allocated_ptys);
 139 static DECLARE_MUTEX(allocated_ptys_lock);
 140 #endif
 141
 142 extern void disable_early_printk(void);
 143
 144 static void initialize_tty_struct(struct tty_struct *tty);
 145
 146 static ssize_t tty_read(struct file *, char __user *, size_t, loff_t *);
 147 static ssize_t tty_write(struct file *, const char __user *, size_t, loff_t *);
 148 ssize_t redirected_tty_write(struct file *, const char __user *, size_t, loff_t *);
 149 static unsigned int tty_poll(struct file *, poll_table *);
 150 static int tty_open(struct inode *, struct file *);
 151 static int ptmx_open(struct inode *, struct file *);
 152 static int tty_release(struct inode *, struct file *);
 153 int tty_ioctl(struct inode * inode, struct file * file,
 154               unsigned int cmd, unsigned long arg);
 155 static int tty_fasync(int fd, struct file * filp, int on);
 156 extern void rs_360_init(void);
 157 static void release_mem(struct tty_struct *tty, int idx);
 158
 159
 160 static struct tty_struct *alloc_tty_struct(void)
 161 {
 162         struct tty_struct *tty;
 163
 164         tty = kmalloc(sizeof(struct tty_struct), GFP_KERNEL);
 165         if (tty)
 166                 memset(tty, 0, sizeof(struct tty_struct));
 167         return tty;
 168 }
 169
 170 static inline void free_tty_struct(struct tty_struct *tty)
 171 {
 172         kfree(tty);
 173 }
 174
 175 #define TTY_NUMBER(tty) ((tty)->index + (tty)->driver->name_base)
 176
 177 char *tty_name(struct tty_struct *tty, char *buf)
 178 {
 179         if (!tty) /* Hmm.  NULL pointer.  That's fun. */
 180                 strcpy(buf, "NULL tty");
 181         else
 182                 strcpy(buf, tty->name);
 183         return buf;
 184 }
 185
 186 EXPORT_SYMBOL(tty_name);
 187
 188 inline int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
 189                               const char *routine)
 190 {
 191 #ifdef TTY_PARANOIA_CHECK
 192         if (!tty) {
 193                 printk(KERN_WARNING
 194                         "null TTY for (%d:%d) in %s\n",
 195                         imajor(inode), iminor(inode), routine);
 196                 return 1;
 197         }
 198         if (tty->magic != TTY_MAGIC) {
 199                 printk(KERN_WARNING
 200                         "bad magic number for tty struct (%d:%d) in %s\n",
 201                         imajor(inode), iminor(inode), routine);
 202                 return 1;
 203         }
 204 #endif
 205         return 0;
 206 }
 207
 208 static int check_tty_count(struct tty_struct *tty, const char *routine)
 209 {
 210 #ifdef CHECK_TTY_COUNT
 211         struct list_head *p;
 212         int count = 0;
 213
 214         file_list_lock();
 215         list_for_each(p, &tty->tty_files) {
 216                 count++;
 217         }
 218         file_list_unlock();
 219         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
 220             tty->driver->subtype == PTY_TYPE_SLAVE &&
 221             tty->link && tty->link->count)
 222                 count++;
 223         if (tty->count != count) {
 224                 printk(KERN_WARNING "Warning: dev (%s) tty->count(%d) "
 225                                     "!= #fd's(%d) in %s\n",
 226                        tty->name, tty->count, count, routine);
 227                 return count;
 228        }
 229 #endif
 230         return 0;
 231 }
 232
 233 /*
 234  *      This is probably overkill for real world processors but
 235  *      they are not on hot paths so a little discipline won't do
 236  *      any harm.
 237  */
 238
 239 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
 240 {
 241         down(&tty->termios_sem);
 242         tty->termios->c_line = num;
 243         up(&tty->termios_sem);
 244 }
 245
 246 /*
 247  *      This guards the refcounted line discipline lists. The lock
 248  *      must be taken with irqs off because there are hangup path
 249  *      callers who will do ldisc lookups and cannot sleep.
 250  */
 251
 252 static spinlock_t tty_ldisc_lock = SPIN_LOCK_UNLOCKED;
 253 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
 254 static struct tty_ldisc tty_ldiscs[NR_LDISCS];  /* line disc dispatch table     */
 255
 256 int tty_register_ldisc(int disc, struct tty_ldisc *new_ldisc)
 257 {
 258         unsigned long flags;
 259         int ret = 0;
 260
 261         if (disc < N_TTY || disc >= NR_LDISCS)
 262                 return -EINVAL;
 263
 264         spin_lock_irqsave(&tty_ldisc_lock, flags);
 265         if (new_ldisc) {
 266                 tty_ldiscs[disc] = *new_ldisc;
 267                 tty_ldiscs[disc].num = disc;
 268                 tty_ldiscs[disc].flags |= LDISC_FLAG_DEFINED;
 269                 tty_ldiscs[disc].refcount = 0;
 270         } else {
 271                 if(tty_ldiscs[disc].refcount)
 272                         ret = -EBUSY;
 273                 else
 274                         tty_ldiscs[disc].flags &= ~LDISC_FLAG_DEFINED;
 275         }
 276         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 277
 278         return ret;
 279 }
 280
 281 EXPORT_SYMBOL(tty_register_ldisc);
 282
 283 struct tty_ldisc *tty_ldisc_get(int disc)
 284 {
 285         unsigned long flags;
 286         struct tty_ldisc *ld;
 287
 288         if (disc < N_TTY || disc >= NR_LDISCS)
 289                 return NULL;
 290
 291         spin_lock_irqsave(&tty_ldisc_lock, flags);
 292
 293         ld = &tty_ldiscs[disc];
 294         /* Check the entry is defined */
 295         if(ld->flags & LDISC_FLAG_DEFINED)
 296         {
 297                 /* If the module is being unloaded we can't use it */
 298                 if (!try_module_get(ld->owner))
 299                         ld = NULL;
 300                 else /* lock it */
 301                         ld->refcount++;
 302         }
 303         else
 304                 ld = NULL;
 305         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 306         return ld;
 307 }
 308
 309 EXPORT_SYMBOL_GPL(tty_ldisc_get);
 310
 311 void tty_ldisc_put(int disc)
 312 {
 313         struct tty_ldisc *ld;
 314         unsigned long flags;
 315
 316         if (disc < N_TTY || disc >= NR_LDISCS)
 317                 BUG();
 318
 319         spin_lock_irqsave(&tty_ldisc_lock, flags);
 320         ld = &tty_ldiscs[disc];
 321         if(ld->refcount == 0)
 322                 BUG();
 323         ld->refcount --;
 324         module_put(ld->owner);
 325         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 326 }
 327
 328 EXPORT_SYMBOL_GPL(tty_ldisc_put);
 329
 330 void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
 331 {
 332         tty->ldisc = *ld;
 333         tty->ldisc.refcount = 0;
 334 }
 335
 336 /**
 337  *      tty_ldisc_try           -       internal helper
 338  *      @tty: the tty
 339  *
 340  *      Make a single attempt to grab and bump the refcount on
 341  *      the tty ldisc. Return 0 on failure or 1 on success. This is
 342  *      used to implement both the waiting and non waiting versions
 343  *      of tty_ldisc_ref
 344  */
 345
 346 static int tty_ldisc_try(struct tty_struct *tty)
 347 {
 348         unsigned long flags;
 349         struct tty_ldisc *ld;
 350         int ret = 0;
 351
 352         spin_lock_irqsave(&tty_ldisc_lock, flags);
 353         ld = &tty->ldisc;
 354         if(test_bit(TTY_LDISC, &tty->flags))
 355         {
 356                 ld->refcount++;
 357                 ret = 1;
 358         }
 359         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 360         return ret;
 361 }
 362
 363 /**
 364  *      tty_ldisc_ref_wait      -       wait for the tty ldisc
 365  *      @tty: tty device
 366  *
 367  *      Dereference the line discipline for the terminal and take a
 368  *      reference to it. If the line discipline is in flux then
 369  *      wait patiently until it changes.
 370  *
 371  *      Note: Must not be called from an IRQ/timer context. The caller
 372  *      must also be careful not to hold other locks that will deadlock
 373  *      against a discipline change, such as an existing ldisc reference
 374  *      (which we check for)
 375  */
 376
 377 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
 378 {
 379         /* wait_event is a macro */
 380         wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
 381         if(tty->ldisc.refcount == 0)
 382                 printk(KERN_ERR "tty_ldisc_ref_wait\n");
 383         return &tty->ldisc;
 384 }
 385
 386 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
 387
 388 /**
 389  *      tty_ldisc_ref           -       get the tty ldisc
 390  *      @tty: tty device
 391  *
 392  *      Dereference the line discipline for the terminal and take a
 393  *      reference to it. If the line discipline is in flux then
 394  *      return NULL. Can be called from IRQ and timer functions.
 395  */
 396
 397 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
 398 {
 399         if(tty_ldisc_try(tty))
 400                 return &tty->ldisc;
 401         return NULL;
 402 }
 403
 404 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
 405
 406 /**
 407  *      tty_ldisc_deref         -       free a tty ldisc reference
 408  *      @ld: reference to free up
 409  *
 410  *      Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
 411  *      be called in IRQ context.
 412  */
 413
 414 void tty_ldisc_deref(struct tty_ldisc *ld)
 415 {
 416         unsigned long flags;
 417
 418         if(ld == NULL)
 419                 BUG();
 420
 421         spin_lock_irqsave(&tty_ldisc_lock, flags);
 422         if(ld->refcount == 0)
 423                 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
 424         else
 425                 ld->refcount--;
 426         if(ld->refcount == 0)
 427                 wake_up(&tty_ldisc_wait);
 428         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 429 }
 430
 431 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
 432
 433 /**
 434  *      tty_ldisc_enable        -       allow ldisc use
 435  *      @tty: terminal to activate ldisc on
 436  *
 437  *      Set the TTY_LDISC flag when the line discipline can be called
 438  *      again. Do neccessary wakeups for existing sleepers.
 439  *
 440  *      Note: nobody should set this bit except via this function. Clearing
 441  *      directly is allowed.
 442  */
 443
 444 static void tty_ldisc_enable(struct tty_struct *tty)
 445 {
 446         set_bit(TTY_LDISC, &tty->flags);
 447         wake_up(&tty_ldisc_wait);
 448 }
 449
 450 /**
 451  *      tty_set_ldisc           -       set line discipline
 452  *      @tty: the terminal to set
 453  *      @ldisc: the line discipline
 454  *
 455  *      Set the discipline of a tty line. Must be called from a process
 456  *      context.
 457  */
 458
 459 static int tty_set_ldisc(struct tty_struct *tty, int ldisc)
 460 {
 461         int     retval = 0;
 462         struct  tty_ldisc o_ldisc;
 463         char buf[64];
 464         int work;
 465         unsigned long flags;
 466         struct tty_ldisc *ld;
 467
 468         if ((ldisc < N_TTY) || (ldisc >= NR_LDISCS))
 469                 return -EINVAL;
 470
 471 restart:
 472
 473         if (tty->ldisc.num == ldisc)
 474                 return 0;       /* We are already in the desired discipline */
 475
 476         ld = tty_ldisc_get(ldisc);
 477         /* Eduardo Blanco <ejbs@cs.cs.com.uy> */
 478         /* Cyrus Durgin <cider@speakeasy.org> */
 479         if (ld == NULL) {
 480                 request_module("tty-ldisc-%d", ldisc);
 481                 ld = tty_ldisc_get(ldisc);
 482         }
 483         if (ld == NULL)
 484                 return -EINVAL;
 485
 486         o_ldisc = tty->ldisc;
 487
 488         tty_wait_until_sent(tty, 0);
 489
 490         /*
 491          *      Make sure we don't change while someone holds a
 492          *      reference to the line discipline. The TTY_LDISC bit
 493          *      prevents anyone taking a reference once it is clear.
 494          *      We need the lock to avoid racing reference takers.
 495          */
 496
 497         spin_lock_irqsave(&tty_ldisc_lock, flags);
 498         if(tty->ldisc.refcount)
 499         {
 500                 /* Free the new ldisc we grabbed. Must drop the lock
 501                    first. */
 502                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 503                 tty_ldisc_put(ldisc);
 504                 /*
 505                  * There are several reasons we may be busy, including
 506                  * random momentary I/O traffic. We must therefore
 507                  * retry. We could distinguish between blocking ops
 508                  * and retries if we made tty_ldisc_wait() smarter. That
 509                  * is up for discussion.
 510                  */
 511                 if(wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
 512                         return -ERESTARTSYS;
 513                 goto restart;
 514         }
 515         clear_bit(TTY_LDISC, &tty->flags);
 516         clear_bit(TTY_DONT_FLIP, &tty->flags);
 517         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 518
 519         /*
 520          *      From this point on we know nobody has an ldisc
 521          *      usage reference, nor can they obtain one until
 522          *      we say so later on.
 523          */
 524
 525         work = cancel_delayed_work(&tty->flip.work);
 526         /*
 527          * Wait for ->hangup_work and ->flip.work handlers to terminate
 528          */
 529
 530         flush_scheduled_work();
 531         /* Shutdown the current discipline. */
 532         if (tty->ldisc.close)
 533                 (tty->ldisc.close)(tty);
 534
 535         /* Now set up the new line discipline. */
 536         tty_ldisc_assign(tty, ld);
 537         tty_set_termios_ldisc(tty, ldisc);
 538         if (tty->ldisc.open)
 539                 retval = (tty->ldisc.open)(tty);
 540         if (retval < 0) {
 541                 tty_ldisc_put(ldisc);
 542                 /* There is an outstanding reference here so this is safe */
 543                 tty_ldisc_assign(tty, tty_ldisc_get(o_ldisc.num));
 544                 tty_set_termios_ldisc(tty, tty->ldisc.num);
 545                 if (tty->ldisc.open && (tty->ldisc.open(tty) < 0)) {
 546                         tty_ldisc_put(o_ldisc.num);
 547                         /* This driver is always present */
 548                         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
 549                         tty_set_termios_ldisc(tty, N_TTY);
 550                         if (tty->ldisc.open) {
 551                                 int r = tty->ldisc.open(tty);
 552
 553                                 if (r < 0)
 554                                         panic("Couldn't open N_TTY ldisc for "
 555                                               "%s --- error %d.",
 556                                               tty_name(tty, buf), r);
 557                         }
 558                 }
 559         }
 560         /* At this point we hold a reference to the new ldisc and a
 561            a reference to the old ldisc. If we ended up flipping back
 562            to the existing ldisc we have two references to it */
 563
 564         if (tty->ldisc.num != o_ldisc.num && tty->driver->set_ldisc)
 565                 tty->driver->set_ldisc(tty);
 566
 567         tty_ldisc_put(o_ldisc.num);
 568
 569         /*
 570          *      Allow ldisc referencing to occur as soon as the driver
 571          *      ldisc callback completes.
 572          */
 573
 574         tty_ldisc_enable(tty);
 575
 576         /* Restart it in case no characters kick it off. Safe if
 577            already running */
 578         if(work)
 579                 schedule_delayed_work(&tty->flip.work, 1);
 580         return retval;
 581 }
 582
 583 /*
 584  * This routine returns a tty driver structure, given a device number
 585  */
 586 struct tty_driver *get_tty_driver(dev_t device, int *index)
 587 {
 588         struct tty_driver *p;
 589
 590         list_for_each_entry(p, &tty_drivers, tty_drivers) {
 591                 dev_t base = MKDEV(p->major, p->minor_start);
 592                 if (device < base || device >= base + p->num)
 593                         continue;
 594                 *index = device - base;
 595                 return p;
 596         }
 597         return NULL;
 598 }
 599
 600 /*
 601  * If we try to write to, or set the state of, a terminal and we're
 602  * not in the foreground, send a SIGTTOU.  If the signal is blocked or
 603  * ignored, go ahead and perform the operation.  (POSIX 7.2)
 604  */
 605 int tty_check_change(struct tty_struct * tty)
 606 {
 607         if (current->signal->tty != tty)
 608                 return 0;
 609         if (tty->pgrp <= 0) {
 610                 printk(KERN_WARNING "tty_check_change: tty->pgrp <= 0!\n");
 611                 return 0;
 612         }
 613         if (process_group(current) == tty->pgrp)
 614                 return 0;
 615         if (is_ignored(SIGTTOU))
 616                 return 0;
 617         if (is_orphaned_pgrp(process_group(current)))
 618                 return -EIO;
 619         (void) kill_pg(process_group(current), SIGTTOU, 1);
 620         return -ERESTARTSYS;
 621 }
 622
 623 EXPORT_SYMBOL(tty_check_change);
 624
 625 static ssize_t hung_up_tty_read(struct file * file, char __user * buf,
 626                                 size_t count, loff_t *ppos)
 627 {
 628         return 0;
 629 }
 630
 631 static ssize_t hung_up_tty_write(struct file * file, const char __user * buf,
 632                                  size_t count, loff_t *ppos)
 633 {
 634         return -EIO;
 635 }
 636
 637 /* No kernel lock held - none needed ;) */
 638 static unsigned int hung_up_tty_poll(struct file * filp, poll_table * wait)
 639 {
 640         return POLLIN | POLLOUT | POLLERR | POLLHUP | POLLRDNORM | POLLWRNORM;
 641 }
 642
 643 static int hung_up_tty_ioctl(struct inode * inode, struct file * file,
 644                              unsigned int cmd, unsigned long arg)
 645 {
 646         return cmd == TIOCSPGRP ? -ENOTTY : -EIO;
 647 }
 648
 649 static struct file_operations tty_fops = {
 650         .llseek         = no_llseek,
 651         .read           = tty_read,
 652         .write          = tty_write,
 653         .poll           = tty_poll,
 654         .ioctl          = tty_ioctl,
 655         .open           = tty_open,
 656         .release        = tty_release,
 657         .fasync         = tty_fasync,
 658 };
 659
 660 #ifdef CONFIG_UNIX98_PTYS
 661 static struct file_operations ptmx_fops = {
 662         .llseek         = no_llseek,
 663         .read           = tty_read,
 664         .write          = tty_write,
 665         .poll           = tty_poll,
 666         .ioctl          = tty_ioctl,
 667         .open           = ptmx_open,
 668         .release        = tty_release,
 669         .fasync         = tty_fasync,
 670 };
 671 #endif
 672
 673 static struct file_operations console_fops = {
 674         .llseek         = no_llseek,
 675         .read           = tty_read,
 676         .write          = redirected_tty_write,
 677         .poll           = tty_poll,
 678         .ioctl          = tty_ioctl,
 679         .open           = tty_open,
 680         .release        = tty_release,
 681         .fasync         = tty_fasync,
 682 };
 683
 684 static struct file_operations hung_up_tty_fops = {
 685         .llseek         = no_llseek,
 686         .read           = hung_up_tty_read,
 687         .write          = hung_up_tty_write,
 688         .poll           = hung_up_tty_poll,
 689         .ioctl          = hung_up_tty_ioctl,
 690         .release        = tty_release,
 691 };
 692
 693 static spinlock_t redirect_lock = SPIN_LOCK_UNLOCKED;
 694 static struct file *redirect;
 695
 696 /**
 697  *      tty_wakeup      -       request more data
 698  *      @tty: terminal
 699  *
 700  *      Internal and external helper for wakeups of tty. This function
 701  *      informs the line discipline if present that the driver is ready
 702  *      to receive more output data.
 703  */
 704
 705 void tty_wakeup(struct tty_struct *tty)
 706 {
 707         struct tty_ldisc *ld;
 708
 709         if (test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) {
 710                 ld = tty_ldisc_ref(tty);
 711                 if(ld) {
 712                         if(ld->write_wakeup)
 713                                 ld->write_wakeup(tty);
 714                         tty_ldisc_deref(ld);
 715                 }
 716         }
 717         wake_up_interruptible(&tty->write_wait);
 718 }
 719
 720 EXPORT_SYMBOL_GPL(tty_wakeup);
 721
 722 /**
 723  *      tty_ldisc_flush -       flush line discipline queue
 724  *      @tty: tty
 725  *
 726  *      Flush the line discipline queue (if any) for this tty. If there
 727  *      is no line discipline active this is a no-op.
 728  */
 729
 730 void tty_ldisc_flush(struct tty_struct *tty)
 731 {
 732         struct tty_ldisc *ld = tty_ldisc_ref(tty);
 733         if(ld) {
 734                 if(ld->flush_buffer)
 735                         ld->flush_buffer(tty);
 736                 tty_ldisc_deref(ld);
 737         }
 738 }
 739
 740 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
 741
 742 /*
 743  * This can be called by the "eventd" kernel thread.  That is process synchronous,
 744  * but doesn't hold any locks, so we need to make sure we have the appropriate
 745  * locks for what we're doing..
 746  */
 747 void do_tty_hangup(void *data)
 748 {
 749         struct tty_struct *tty = (struct tty_struct *) data;
 750         struct file * cons_filp = NULL;
 751         struct file *filp, *f = NULL;
 752         struct task_struct *p;
 753         struct tty_ldisc *ld;
 754         int    closecount = 0, n;
 755
 756         if (!tty)
 757                 return;
 758
 759         /* inuse_filps is protected by the single kernel lock */
 760         lock_kernel();
 761
 762         spin_lock(&redirect_lock);
 763         if (redirect && redirect->private_data == tty) {
 764                 f = redirect;
 765                 redirect = NULL;
 766         }
 767         spin_unlock(&redirect_lock);
 768
 769         check_tty_count(tty, "do_tty_hangup");
 770         file_list_lock();
 771         /* This breaks for file handles being sent over AF_UNIX sockets ? */
 772         list_for_each_entry(filp, &tty->tty_files, f_list) {
 773                 if (filp->f_op->write == redirected_tty_write)
 774                         cons_filp = filp;
 775                 if (filp->f_op->write != tty_write)
 776                         continue;
 777                 closecount++;
 778                 tty_fasync(-1, filp, 0);        /* can't block */
 779                 filp->f_op = &hung_up_tty_fops;
 780         }
 781         file_list_unlock();
 782
 783         /* FIXME! What are the locking issues here? This may me overdoing things..
 784          * this question is especially important now that we've removed the irqlock. */
 785
 786         ld = tty_ldisc_ref(tty);
 787         if(ld != NULL)  /* We may have no line discipline at this point */
 788         {
 789                 if (ld->flush_buffer)
 790                         ld->flush_buffer(tty);
 791                 if (tty->driver->flush_buffer)
 792                         tty->driver->flush_buffer(tty);
 793                 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
 794                     ld->write_wakeup)
 795                         ld->write_wakeup(tty);
 796                 if (ld->hangup)
 797                         ld->hangup(tty);
 798         }
 799
 800         /* FIXME: Once we trust the LDISC code better we can wait here for
 801            ldisc completion and fix the driver call race */
 802
 803         wake_up_interruptible(&tty->write_wait);
 804         wake_up_interruptible(&tty->read_wait);
 805
 806         /*
 807          * Shutdown the current line discipline, and reset it to
 808          * N_TTY.
 809          */
 810         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
 811         {
 812                 down(&tty->termios_sem);
 813                 *tty->termios = tty->driver->init_termios;
 814                 up(&tty->termios_sem);
 815         }
 816
 817         /* Defer ldisc switch */
 818         /* tty_deferred_ldisc_switch(N_TTY);
 819
 820           This should get done automatically when the port closes and
 821           tty_release is called */
 822
 823         read_lock(&tasklist_lock);
 824         if (tty->session > 0) {
 825                 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
 826                         if (p->signal->tty == tty)
 827                                 p->signal->tty = NULL;
 828                         if (!p->signal->leader)
 829                                 continue;
 830                         send_group_sig_info(SIGHUP, SEND_SIG_PRIV, p);
 831                         send_group_sig_info(SIGCONT, SEND_SIG_PRIV, p);
 832                         if (tty->pgrp > 0)
 833                                 p->signal->tty_old_pgrp = tty->pgrp;
 834                 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
 835         }
 836         read_unlock(&tasklist_lock);
 837
 838         tty->flags = 0;
 839         tty->session = 0;
 840         tty->pgrp = -1;
 841         tty->ctrl_status = 0;
 842         /*
 843          *      If one of the devices matches a console pointer, we
 844          *      cannot just call hangup() because that will cause
 845          *      tty->count and state->count to go out of sync.
 846          *      So we just call close() the right number of times.
 847          */
 848         if (cons_filp) {
 849                 if (tty->driver->close)
 850                         for (n = 0; n < closecount; n++)
 851                                 tty->driver->close(tty, cons_filp);
 852         } else if (tty->driver->hangup)
 853                 (tty->driver->hangup)(tty);
 854
 855         /* We don't want to have driver/ldisc interactions beyond
 856            the ones we did here. The driver layer expects no
 857            calls after ->hangup() from the ldisc side. However we
 858            can't yet guarantee all that */
 859
 860         set_bit(TTY_HUPPED, &tty->flags);
 861         if (ld) {
 862                 tty_ldisc_enable(tty);
 863                 tty_ldisc_deref(ld);
 864         }
 865         unlock_kernel();
 866         if (f)
 867                 fput(f);
 868 }
 869
 870 void tty_hangup(struct tty_struct * tty)
 871 {
 872 #ifdef TTY_DEBUG_HANGUP
 873         char    buf[64];
 874
 875         printk(KERN_DEBUG "%s hangup...\n", tty_name(tty, buf));
 876 #endif
 877         schedule_work(&tty->hangup_work);
 878 }
 879
 880 EXPORT_SYMBOL(tty_hangup);
 881
 882 void tty_vhangup(struct tty_struct * tty)
 883 {
 884 #ifdef TTY_DEBUG_HANGUP
 885         char    buf[64];
 886
 887         printk(KERN_DEBUG "%s vhangup...\n", tty_name(tty, buf));
 888 #endif
 889         do_tty_hangup((void *) tty);
 890 }
 891 EXPORT_SYMBOL(tty_vhangup);
 892
 893 int tty_hung_up_p(struct file * filp)
 894 {
 895         return (filp->f_op == &hung_up_tty_fops);
 896 }
 897
 898 EXPORT_SYMBOL(tty_hung_up_p);
 899
 900 /*
 901  * This function is typically called only by the session leader, when
 902  * it wants to disassociate itself from its controlling tty.
 903  *
 904  * It performs the following functions:
 905  *      (1)  Sends a SIGHUP and SIGCONT to the foreground process group
 906  *      (2)  Clears the tty from being controlling the session
 907  *      (3)  Clears the controlling tty for all processes in the
 908  *              session group.
 909  *
 910  * The argument on_exit is set to 1 if called when a process is
 911  * exiting; it is 0 if called by the ioctl TIOCNOTTY.
 912  */
 913 void disassociate_ctty(int on_exit)
 914 {
 915         struct tty_struct *tty;
 916         struct task_struct *p;
 917         int tty_pgrp = -1;
 918
 919         lock_kernel();
 920
 921         tty = current->signal->tty;
 922         if (tty) {
 923                 tty_pgrp = tty->pgrp;
 924                 if (on_exit && tty->driver->type != TTY_DRIVER_TYPE_PTY)
 925                         tty_vhangup(tty);
 926         } else {
 927                 if (current->signal->tty_old_pgrp) {
 928                         kill_pg(current->signal->tty_old_pgrp, SIGHUP, on_exit);
 929                         kill_pg(current->signal->tty_old_pgrp, SIGCONT, on_exit);
 930                 }
 931                 unlock_kernel();
 932                 return;
 933         }
 934         if (tty_pgrp > 0) {
 935                 kill_pg(tty_pgrp, SIGHUP, on_exit);
 936                 if (!on_exit)
 937                         kill_pg(tty_pgrp, SIGCONT, on_exit);
 938         }
 939
 940         current->signal->tty_old_pgrp = 0;
 941         tty->session = 0;
 942         tty->pgrp = -1;
 943
 944         read_lock(&tasklist_lock);
 945         do_each_task_pid(current->signal->session, PIDTYPE_SID, p) {
 946                 p->signal->tty = NULL;
 947         } while_each_task_pid(current->signal->session, PIDTYPE_SID, p);
 948         read_unlock(&tasklist_lock);
 949         unlock_kernel();
 950 }
 951
 952 void stop_tty(struct tty_struct *tty)
 953 {
 954         if (tty->stopped)
 955                 return;
 956         tty->stopped = 1;
 957         if (tty->link && tty->link->packet) {
 958                 tty->ctrl_status &= ~TIOCPKT_START;
 959                 tty->ctrl_status |= TIOCPKT_STOP;
 960                 wake_up_interruptible(&tty->link->read_wait);
 961         }
 962         if (tty->driver->stop)
 963                 (tty->driver->stop)(tty);
 964 }
 965
 966 EXPORT_SYMBOL(stop_tty);
 967
 968 void start_tty(struct tty_struct *tty)
 969 {
 970         if (!tty->stopped || tty->flow_stopped)
 971                 return;
 972         tty->stopped = 0;
 973         if (tty->link && tty->link->packet) {
 974                 tty->ctrl_status &= ~TIOCPKT_STOP;
 975                 tty->ctrl_status |= TIOCPKT_START;
 976                 wake_up_interruptible(&tty->link->read_wait);
 977         }
 978         if (tty->driver->start)
 979                 (tty->driver->start)(tty);
 980
 981         /* If we have a running line discipline it may need kicking */
 982         tty_wakeup(tty);
 983         wake_up_interruptible(&tty->write_wait);
 984 }
 985
 986 EXPORT_SYMBOL(start_tty);
 987
 988 static ssize_t tty_read(struct file * file, char __user * buf, size_t count,
 989                         loff_t *ppos)
 990 {
 991         int i;
 992         struct tty_struct * tty;
 993         struct inode *inode;
 994         struct tty_ldisc *ld;
 995
 996         tty = (struct tty_struct *)file->private_data;
 997         inode = file->f_dentry->d_inode;
 998         if (tty_paranoia_check(tty, inode, "tty_read"))
 999                 return -EIO;
1000         if (!tty || (test_bit(TTY_IO_ERROR, &tty->flags)))
1001                 return -EIO;
1002
1003         /* We want to wait for the line discipline to sort out in this
1004            situation */
1005         ld = tty_ldisc_ref_wait(tty);
1006         lock_kernel();
1007         if (ld->read)
1008                 i = (ld->read)(tty,file,buf,count);
1009         else
1010                 i = -EIO;
1011         tty_ldisc_deref(ld);
1012         unlock_kernel();
1013         if (i > 0)
1014                 inode->i_atime = CURRENT_TIME;
1015         return i;
1016 }
1017
1018 /*
1019  * Split writes up in sane blocksizes to avoid
1020  * denial-of-service type attacks
1021  */
1022 static inline ssize_t do_tty_write(
1023         ssize_t (*write)(struct tty_struct *, struct file *, const unsigned char __user *, size_t),
1024         struct tty_struct *tty,
1025         struct file *file,
1026         const unsigned char __user *buf,
1027         size_t count)
1028 {
1029         ssize_t ret = 0, written = 0;
1030
1031         if (down_interruptible(&tty->atomic_write)) {
1032                 return -ERESTARTSYS;
1033         }
1034         if ( test_bit(TTY_NO_WRITE_SPLIT, &tty->flags) ) {
1035                 lock_kernel();
1036                 written = write(tty, file, buf, count);
1037                 unlock_kernel();
1038         } else {
1039                 for (;;) {
1040                         unsigned long size = max((unsigned long)PAGE_SIZE*2, 16384UL);
1041                         if (size > count)
1042                                 size = count;
1043                         lock_kernel();
1044                         ret = write(tty, file, buf, size);
1045                         unlock_kernel();
1046                         if (ret <= 0)
1047                                 break;
1048                         written += ret;
1049                         buf += ret;
1050                         count -= ret;
1051                         if (!count)
1052                                 break;
1053                         ret = -ERESTARTSYS;
1054                         if (signal_pending(current))
1055                                 break;
1056                         cond_resched();
1057                 }
1058         }
1059         if (written) {
1060                 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
1061                 ret = written;
1062         }
1063         up(&tty->atomic_write);
1064         return ret;
1065 }
1066
1067
1068 static ssize_t tty_write(struct file * file, const char __user * buf, size_t count,
1069                          loff_t *ppos)
1070 {
1071         struct tty_struct * tty;
1072         struct inode *inode = file->f_dentry->d_inode;
1073         ssize_t ret;
1074         struct tty_ldisc *ld;
1075
1076         tty = (struct tty_struct *)file->private_data;
1077         if (tty_paranoia_check(tty, inode, "tty_write"))
1078                 return -EIO;
1079         if (!tty || !tty->driver->write || (test_bit(TTY_IO_ERROR, &tty->flags)))
1080                 return -EIO;
1081
1082         ld = tty_ldisc_ref_wait(tty);
1083         if (!ld->write)
1084                 ret = -EIO;
1085         else
1086                 ret = do_tty_write(ld->write, tty, file,
1087                             (const unsigned char __user *)buf, count);
1088         tty_ldisc_deref(ld);
1089         return ret;
1090 }
1091
1092 ssize_t redirected_tty_write(struct file * file, const char __user * buf, size_t count,
1093                          loff_t *ppos)
1094 {
1095         struct file *p = NULL;
1096
1097         spin_lock(&redirect_lock);
1098         if (redirect) {
1099                 get_file(redirect);
1100                 p = redirect;
1101         }
1102         spin_unlock(&redirect_lock);
1103
1104         if (p) {
1105                 ssize_t res;
1106                 res = vfs_write(p, buf, count, &p->f_pos);
1107                 fput(p);
1108                 return res;
1109         }
1110
1111         return tty_write(file, buf, count, ppos);
1112 }
1113
1114 static char ptychar[] = "pqrstuvwxyzabcde";
1115
1116 static inline void pty_line_name(struct tty_driver *driver, int index, char *p)
1117 {
1118         int i = index + driver->name_base;
1119         /* ->name is initialized to "ttyp", but "tty" is expected */
1120         sprintf(p, "%s%c%x",
1121                         driver->subtype == PTY_TYPE_SLAVE ? "tty" : driver->name,
1122                         ptychar[i >> 4 & 0xf], i & 0xf);
1123 }
1124
1125 static inline void tty_line_name(struct tty_driver *driver, int index, char *p)
1126 {
1127         sprintf(p, "%s%d", driver->name, index + driver->name_base);
1128 }
1129
1130 /*
1131  * WSH 06/09/97: Rewritten to remove races and properly clean up after a
1132  * failed open.  The new code protects the open with a semaphore, so it's
1133  * really quite straightforward.  The semaphore locking can probably be
1134  * relaxed for the (most common) case of reopening a tty.
1135  */
1136 static int init_dev(struct tty_driver *driver, int idx,
1137         struct tty_struct **ret_tty)
1138 {
1139         struct tty_struct *tty, *o_tty;
1140         struct termios *tp, **tp_loc, *o_tp, **o_tp_loc;
1141         struct termios *ltp, **ltp_loc, *o_ltp, **o_ltp_loc;
1142         int retval=0;
1143
1144         /*
1145          * Check whether we need to acquire the tty semaphore to avoid
1146          * race conditions.  For now, play it safe.
1147          */
1148         down(&tty_sem);
1149
1150         /* check whether we're reopening an existing tty */
1151         if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1152                 tty = devpts_get_tty(idx);
1153                 if (tty && driver->subtype == PTY_TYPE_MASTER)
1154                         tty = tty->link;
1155         } else {
1156                 tty = driver->ttys[idx];
1157         }
1158         if (tty) goto fast_track;
1159
1160         /*
1161          * First time open is complex, especially for PTY devices.
1162          * This code guarantees that either everything succeeds and the
1163          * TTY is ready for operation, or else the table slots are vacated
1164          * and the allocated memory released.  (Except that the termios
1165          * and locked termios may be retained.)
1166          */
1167
1168         if (!try_module_get(driver->owner)) {
1169                 retval = -ENODEV;
1170                 goto end_init;
1171         }
1172
1173         o_tty = NULL;
1174         tp = o_tp = NULL;
1175         ltp = o_ltp = NULL;
1176
1177         tty = alloc_tty_struct();
1178         if(!tty)
1179                 goto fail_no_mem;
1180         initialize_tty_struct(tty);
1181         tty->driver = driver;
1182         tty->index = idx;
1183         tty_line_name(driver, idx, tty->name);
1184
1185         if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1186                 tp_loc = &tty->termios;
1187                 ltp_loc = &tty->termios_locked;
1188         } else {
1189                 tp_loc = &driver->termios[idx];
1190                 ltp_loc = &driver->termios_locked[idx];
1191         }
1192
1193         if (!*tp_loc) {
1194                 tp = (struct termios *) kmalloc(sizeof(struct termios),
1195                                                 GFP_KERNEL);
1196                 if (!tp)
1197                         goto free_mem_out;
1198                 *tp = driver->init_termios;
1199         }
1200
1201         if (!*ltp_loc) {
1202                 ltp = (struct termios *) kmalloc(sizeof(struct termios),
1203                                                  GFP_KERNEL);
1204                 if (!ltp)
1205                         goto free_mem_out;
1206                 memset(ltp, 0, sizeof(struct termios));
1207         }
1208
1209         if (driver->type == TTY_DRIVER_TYPE_PTY) {
1210                 o_tty = alloc_tty_struct();
1211                 if (!o_tty)
1212                         goto free_mem_out;
1213                 initialize_tty_struct(o_tty);
1214                 o_tty->driver = driver->other;
1215                 o_tty->index = idx;
1216                 tty_line_name(driver->other, idx, o_tty->name);
1217
1218                 if (driver->flags & TTY_DRIVER_DEVPTS_MEM) {
1219                         o_tp_loc = &o_tty->termios;
1220                         o_ltp_loc = &o_tty->termios_locked;
1221                 } else {
1222                         o_tp_loc = &driver->other->termios[idx];
1223                         o_ltp_loc = &driver->other->termios_locked[idx];
1224                 }
1225
1226                 if (!*o_tp_loc) {
1227                         o_tp = (struct termios *)
1228                                 kmalloc(sizeof(struct termios), GFP_KERNEL);
1229                         if (!o_tp)
1230                                 goto free_mem_out;
1231                         *o_tp = driver->other->init_termios;
1232                 }
1233
1234                 if (!*o_ltp_loc) {
1235                         o_ltp = (struct termios *)
1236                                 kmalloc(sizeof(struct termios), GFP_KERNEL);
1237                         if (!o_ltp)
1238                                 goto free_mem_out;
1239                         memset(o_ltp, 0, sizeof(struct termios));
1240                 }
1241
1242                 /*
1243                  * Everything allocated ... set up the o_tty structure.
1244                  */
1245                 if (!(driver->other->flags & TTY_DRIVER_DEVPTS_MEM)) {
1246                         driver->other->ttys[idx] = o_tty;
1247                 }
1248                 if (!*o_tp_loc)
1249                         *o_tp_loc = o_tp;
1250                 if (!*o_ltp_loc)
1251                         *o_ltp_loc = o_ltp;
1252                 o_tty->termios = *o_tp_loc;
1253                 o_tty->termios_locked = *o_ltp_loc;
1254                 driver->other->refcount++;
1255                 if (driver->subtype == PTY_TYPE_MASTER)
1256                         o_tty->count++;
1257
1258                 /* Establish the links in both directions */
1259                 tty->link   = o_tty;
1260                 o_tty->link = tty;
1261         }
1262
1263         /*
1264          * All structures have been allocated, so now we install them.
1265          * Failures after this point use release_mem to clean up, so
1266          * there's no need to null out the local pointers.
1267          */
1268         if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1269                 driver->ttys[idx] = tty;
1270         }
1271
1272         if (!*tp_loc)
1273                 *tp_loc = tp;
1274         if (!*ltp_loc)
1275                 *ltp_loc = ltp;
1276         tty->termios = *tp_loc;
1277         tty->termios_locked = *ltp_loc;
1278         driver->refcount++;
1279         tty->count++;
1280
1281         /*
1282          * Structures all installed ... call the ldisc open routines.
1283          * If we fail here just call release_mem to clean up.  No need
1284          * to decrement the use counts, as release_mem doesn't care.
1285          */
1286
1287         if (tty->ldisc.open) {
1288                 retval = (tty->ldisc.open)(tty);
1289                 if (retval)
1290                         goto release_mem_out;
1291         }
1292         if (o_tty && o_tty->ldisc.open) {
1293                 retval = (o_tty->ldisc.open)(o_tty);
1294                 if (retval) {
1295                         if (tty->ldisc.close)
1296                                 (tty->ldisc.close)(tty);
1297                         goto release_mem_out;
1298                 }
1299                 tty_ldisc_enable(o_tty);
1300         }
1301         tty_ldisc_enable(tty);
1302         goto success;
1303
1304         /*
1305          * This fast open can be used if the tty is already open.
1306          * No memory is allocated, and the only failures are from
1307          * attempting to open a closing tty or attempting multiple
1308          * opens on a pty master.
1309          */
1310 fast_track:
1311         if (test_bit(TTY_CLOSING, &tty->flags)) {
1312                 retval = -EIO;
1313                 goto end_init;
1314         }
1315         if (driver->type == TTY_DRIVER_TYPE_PTY &&
1316             driver->subtype == PTY_TYPE_MASTER) {
1317                 /*
1318                  * special case for PTY masters: only one open permitted,
1319                  * and the slave side open count is incremented as well.
1320                  */
1321                 if (tty->count) {
1322                         retval = -EIO;
1323                         goto end_init;
1324                 }
1325                 tty->link->count++;
1326         }
1327         tty->count++;
1328         tty->driver = driver; /* N.B. why do this every time?? */
1329
1330         /* FIXME */
1331         if(!test_bit(TTY_LDISC, &tty->flags))
1332                 printk(KERN_ERR "init_dev but no ldisc\n");
1333 success:
1334         *ret_tty = tty;
1335
1336         /* All paths come through here to release the semaphore */
1337 end_init:
1338         up(&tty_sem);
1339         return retval;
1340
1341         /* Release locally allocated memory ... nothing placed in slots */
1342 free_mem_out:
1343         if (o_tp)
1344                 kfree(o_tp);
1345         if (o_tty)
1346                 free_tty_struct(o_tty);
1347         if (ltp)
1348                 kfree(ltp);
1349         if (tp)
1350                 kfree(tp);
1351         free_tty_struct(tty);
1352
1353 fail_no_mem:
1354         module_put(driver->owner);
1355         retval = -ENOMEM;
1356         goto end_init;
1357
1358         /* call the tty release_mem routine to clean out this slot */
1359 release_mem_out:
1360         printk(KERN_INFO "init_dev: ldisc open failed, "
1361                          "clearing slot %d\n", idx);
1362         release_mem(tty, idx);
1363         goto end_init;
1364 }
1365
1366 /*
1367  * Releases memory associated with a tty structure, and clears out the
1368  * driver table slots.
1369  */
1370 static void release_mem(struct tty_struct *tty, int idx)
1371 {
1372         struct tty_struct *o_tty;
1373         struct termios *tp;
1374         int devpts = tty->driver->flags & TTY_DRIVER_DEVPTS_MEM;
1375
1376         if ((o_tty = tty->link) != NULL) {
1377                 if (!devpts)
1378                         o_tty->driver->ttys[idx] = NULL;
1379                 if (o_tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1380                         tp = o_tty->termios;
1381                         if (!devpts)
1382                                 o_tty->driver->termios[idx] = NULL;
1383                         kfree(tp);
1384
1385                         tp = o_tty->termios_locked;
1386                         if (!devpts)
1387                                 o_tty->driver->termios_locked[idx] = NULL;
1388                         kfree(tp);
1389                 }
1390                 o_tty->magic = 0;
1391                 o_tty->driver->refcount--;
1392                 file_list_lock();
1393                 list_del_init(&o_tty->tty_files);
1394                 file_list_unlock();
1395                 free_tty_struct(o_tty);
1396         }
1397
1398         if (!devpts)
1399                 tty->driver->ttys[idx] = NULL;
1400         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS) {
1401                 tp = tty->termios;
1402                 if (!devpts)
1403                         tty->driver->termios[idx] = NULL;
1404                 kfree(tp);
1405
1406                 tp = tty->termios_locked;
1407                 if (!devpts)
1408                         tty->driver->termios_locked[idx] = NULL;
1409                 kfree(tp);
1410         }
1411
1412         tty->magic = 0;
1413         tty->driver->refcount--;
1414         file_list_lock();
1415         list_del_init(&tty->tty_files);
1416         file_list_unlock();
1417         module_put(tty->driver->owner);
1418         free_tty_struct(tty);
1419 }
1420
1421 /*
1422  * Even releasing the tty structures is a tricky business.. We have
1423  * to be very careful that the structures are all released at the
1424  * same time, as interrupts might otherwise get the wrong pointers.
1425  *
1426  * WSH 09/09/97: rewritten to avoid some nasty race conditions that could
1427  * lead to double frees or releasing memory still in use.
1428  */
1429 static void release_dev(struct file * filp)
1430 {
1431         struct tty_struct *tty, *o_tty;
1432         int     pty_master, tty_closing, o_tty_closing, do_sleep;
1433         int     devpts_master, devpts;
1434         int     idx;
1435         char    buf[64];
1436         unsigned long flags;
1437
1438         tty = (struct tty_struct *)filp->private_data;
1439         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "release_dev"))
1440                 return;
1441
1442         check_tty_count(tty, "release_dev");
1443
1444         tty_fasync(-1, filp, 0);
1445
1446         idx = tty->index;
1447         pty_master = (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1448                       tty->driver->subtype == PTY_TYPE_MASTER);
1449         devpts = (tty->driver->flags & TTY_DRIVER_DEVPTS_MEM) != 0;
1450         devpts_master = pty_master && devpts;
1451         o_tty = tty->link;
1452
1453 #ifdef TTY_PARANOIA_CHECK
1454         if (idx < 0 || idx >= tty->driver->num) {
1455                 printk(KERN_DEBUG "release_dev: bad idx when trying to "
1456                                   "free (%s)\n", tty->name);
1457                 return;
1458         }
1459         if (!(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1460                 if (tty != tty->driver->ttys[idx]) {
1461                         printk(KERN_DEBUG "release_dev: driver.table[%d] not tty "
1462                                "for (%s)\n", idx, tty->name);
1463                         return;
1464                 }
1465                 if (tty->termios != tty->driver->termios[idx]) {
1466                         printk(KERN_DEBUG "release_dev: driver.termios[%d] not termios "
1467                                "for (%s)\n",
1468                                idx, tty->name);
1469                         return;
1470                 }
1471                 if (tty->termios_locked != tty->driver->termios_locked[idx]) {
1472                         printk(KERN_DEBUG "release_dev: driver.termios_locked[%d] not "
1473                                "termios_locked for (%s)\n",
1474                                idx, tty->name);
1475                         return;
1476                 }
1477         }
1478 #endif
1479
1480 #ifdef TTY_DEBUG_HANGUP
1481         printk(KERN_DEBUG "release_dev of %s (tty count=%d)...",
1482                tty_name(tty, buf), tty->count);
1483 #endif
1484
1485 #ifdef TTY_PARANOIA_CHECK
1486         if (tty->driver->other &&
1487              !(tty->driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
1488                 if (o_tty != tty->driver->other->ttys[idx]) {
1489                         printk(KERN_DEBUG "release_dev: other->table[%d] "
1490                                           "not o_tty for (%s)\n",
1491                                idx, tty->name);
1492                         return;
1493                 }
1494                 if (o_tty->termios != tty->driver->other->termios[idx]) {
1495                         printk(KERN_DEBUG "release_dev: other->termios[%d] "
1496                                           "not o_termios for (%s)\n",
1497                                idx, tty->name);
1498                         return;
1499                 }
1500                 if (o_tty->termios_locked !=
1501                       tty->driver->other->termios_locked[idx]) {
1502                         printk(KERN_DEBUG "release_dev: other->termios_locked["
1503                                           "%d] not o_termios_locked for (%s)\n",
1504                                idx, tty->name);
1505                         return;
1506                 }
1507                 if (o_tty->link != tty) {
1508                         printk(KERN_DEBUG "release_dev: bad pty pointers\n");
1509                         return;
1510                 }
1511         }
1512 #endif
1513         if (tty->driver->close)
1514                 tty->driver->close(tty, filp);
1515
1516         /*
1517          * Sanity check: if tty->count is going to zero, there shouldn't be
1518          * any waiters on tty->read_wait or tty->write_wait.  We test the
1519          * wait queues and kick everyone out _before_ actually starting to
1520          * close.  This ensures that we won't block while releasing the tty
1521          * structure.
1522          *
1523          * The test for the o_tty closing is necessary, since the master and
1524          * slave sides may close in any order.  If the slave side closes out
1525          * first, its count will be one, since the master side holds an open.
1526          * Thus this test wouldn't be triggered at the time the slave closes,
1527          * so we do it now.
1528          *
1529          * Note that it's possible for the tty to be opened again while we're
1530          * flushing out waiters.  By recalculating the closing flags before
1531          * each iteration we avoid any problems.
1532          */
1533         while (1) {
1534                 tty_closing = tty->count <= 1;
1535                 o_tty_closing = o_tty &&
1536                         (o_tty->count <= (pty_master ? 1 : 0));
1537                 do_sleep = 0;
1538
1539                 if (tty_closing) {
1540                         if (waitqueue_active(&tty->read_wait)) {
1541                                 wake_up(&tty->read_wait);
1542                                 do_sleep++;
1543                         }
1544                         if (waitqueue_active(&tty->write_wait)) {
1545                                 wake_up(&tty->write_wait);
1546                                 do_sleep++;
1547                         }
1548                 }
1549                 if (o_tty_closing) {
1550                         if (waitqueue_active(&o_tty->read_wait)) {
1551                                 wake_up(&o_tty->read_wait);
1552                                 do_sleep++;
1553                         }
1554                         if (waitqueue_active(&o_tty->write_wait)) {
1555                                 wake_up(&o_tty->write_wait);
1556                                 do_sleep++;
1557                         }
1558                 }
1559                 if (!do_sleep)
1560                         break;
1561
1562                 printk(KERN_WARNING "release_dev: %s: read/write wait queue "
1563                                     "active!\n", tty_name(tty, buf));
1564                 schedule();
1565         }
1566
1567         /*
1568          * The closing flags are now consistent with the open counts on
1569          * both sides, and we've completed the last operation that could
1570          * block, so it's safe to proceed with closing.
1571          */
1572         if (pty_master) {
1573                 if (--o_tty->count < 0) {
1574                         printk(KERN_WARNING "release_dev: bad pty slave count "
1575                                             "(%d) for %s\n",
1576                                o_tty->count, tty_name(o_tty, buf));
1577                         o_tty->count = 0;
1578                 }
1579         }
1580         if (--tty->count < 0) {
1581                 printk(KERN_WARNING "release_dev: bad tty->count (%d) for %s\n",
1582                        tty->count, tty_name(tty, buf));
1583                 tty->count = 0;
1584         }
1585
1586         /*
1587          * We've decremented tty->count, so we need to remove this file
1588          * descriptor off the tty->tty_files list; this serves two
1589          * purposes:
1590          *  - check_tty_count sees the correct number of file descriptors
1591          *    associated with this tty.
1592          *  - do_tty_hangup no longer sees this file descriptor as
1593          *    something that needs to be handled for hangups.
1594          */
1595         file_kill(filp);
1596         filp->private_data = NULL;
1597
1598         /*
1599          * Perform some housekeeping before deciding whether to return.
1600          *
1601          * Set the TTY_CLOSING flag if this was the last open.  In the
1602          * case of a pty we may have to wait around for the other side
1603          * to close, and TTY_CLOSING makes sure we can't be reopened.
1604          */
1605         if(tty_closing)
1606                 set_bit(TTY_CLOSING, &tty->flags);
1607         if(o_tty_closing)
1608                 set_bit(TTY_CLOSING, &o_tty->flags);
1609
1610         /*
1611          * If _either_ side is closing, make sure there aren't any
1612          * processes that still think tty or o_tty is their controlling
1613          * tty.
1614          */
1615         if (tty_closing || o_tty_closing) {
1616                 struct task_struct *p;
1617
1618                 read_lock(&tasklist_lock);
1619                 do_each_task_pid(tty->session, PIDTYPE_SID, p) {
1620                         p->signal->tty = NULL;
1621                 } while_each_task_pid(tty->session, PIDTYPE_SID, p);
1622                 if (o_tty)
1623                         do_each_task_pid(o_tty->session, PIDTYPE_SID, p) {
1624                                 p->signal->tty = NULL;
1625                         } while_each_task_pid(o_tty->session, PIDTYPE_SID, p);
1626                 read_unlock(&tasklist_lock);
1627         }
1628
1629         /* check whether both sides are closing ... */
1630         if (!tty_closing || (o_tty && !o_tty_closing))
1631                 return;
1632
1633 #ifdef TTY_DEBUG_HANGUP
1634         printk(KERN_DEBUG "freeing tty structure...");
1635 #endif
1636         /*
1637          * Prevent flush_to_ldisc() from rescheduling the work for later.  Then
1638          * kill any delayed work. As this is the final close it does not
1639          * race with the set_ldisc code path.
1640          */
1641         clear_bit(TTY_LDISC, &tty->flags);
1642         clear_bit(TTY_DONT_FLIP, &tty->flags);
1643         cancel_delayed_work(&tty->flip.work);
1644
1645         /*
1646          * Wait for ->hangup_work and ->flip.work handlers to terminate
1647          */
1648
1649         flush_scheduled_work();
1650
1651         /*
1652          * Wait for any short term users (we know they are just driver
1653          * side waiters as the file is closing so user count on the file
1654          * side is zero.
1655          */
1656         spin_lock_irqsave(&tty_ldisc_lock, flags);
1657         while(tty->ldisc.refcount)
1658         {
1659                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1660                 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
1661                 spin_lock_irqsave(&tty_ldisc_lock, flags);
1662         }
1663         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
1664         /*
1665          * Shutdown the current line discipline, and reset it to N_TTY.
1666          * N.B. why reset ldisc when we're releasing the memory??
1667          *
1668          * FIXME: this MUST get fixed for the new reflocking
1669          */
1670         if (tty->ldisc.close)
1671                 (tty->ldisc.close)(tty);
1672         tty_ldisc_put(tty->ldisc.num);
1673
1674         /*
1675          *      Switch the line discipline back
1676          */
1677         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
1678         tty_set_termios_ldisc(tty,N_TTY);
1679         if (o_tty) {
1680                 /* FIXME: could o_tty be in setldisc here ? */
1681                 clear_bit(TTY_LDISC, &o_tty->flags);
1682                 if (o_tty->ldisc.close)
1683                         (o_tty->ldisc.close)(o_tty);
1684                 tty_ldisc_put(o_tty->ldisc.num);
1685                 tty_ldisc_assign(o_tty, tty_ldisc_get(N_TTY));
1686                 tty_set_termios_ldisc(o_tty,N_TTY);
1687         }
1688         /*
1689          * The release_mem function takes care of the details of clearing
1690          * the slots and preserving the termios structure.
1691          */
1692         release_mem(tty, idx);
1693
1694 #ifdef CONFIG_UNIX98_PTYS
1695         /* Make this pty number available for reallocation */
1696         if (devpts) {
1697                 down(&allocated_ptys_lock);
1698                 idr_remove(&allocated_ptys, idx);
1699                 up(&allocated_ptys_lock);
1700         }
1701 #endif
1702
1703 }
1704
1705 /*
1706  * tty_open and tty_release keep up the tty count that contains the
1707  * number of opens done on a tty. We cannot use the inode-count, as
1708  * different inodes might point to the same tty.
1709  *
1710  * Open-counting is needed for pty masters, as well as for keeping
1711  * track of serial lines: DTR is dropped when the last close happens.
1712  * (This is not done solely through tty->count, now.  - Ted 1/27/92)
1713  *
1714  * The termios state of a pty is reset on first open so that
1715  * settings don't persist across reuse.
1716  */
1717 static int tty_open(struct inode * inode, struct file * filp)
1718 {
1719         struct tty_struct *tty;
1720         int noctty, retval;
1721         struct tty_driver *driver;
1722         int index;
1723         dev_t device = inode->i_rdev;
1724         unsigned short saved_flags = filp->f_flags;
1725
1726         nonseekable_open(inode, filp);
1727
1728 retry_open:
1729         noctty = filp->f_flags & O_NOCTTY;
1730         index  = -1;
1731         retval = 0;
1732
1733         if (device == MKDEV(TTYAUX_MAJOR,0)) {
1734                 if (!current->signal->tty)
1735                         return -ENXIO;
1736                 driver = current->signal->tty->driver;
1737                 index = current->signal->tty->index;
1738                 filp->f_flags |= O_NONBLOCK; /* Don't let /dev/tty block */
1739                 /* noctty = 1; */
1740                 goto got_driver;
1741         }
1742 #ifdef CONFIG_VT
1743         if (device == MKDEV(TTY_MAJOR,0)) {
1744                 extern int fg_console;
1745                 extern struct tty_driver *console_driver;
1746                 driver = console_driver;
1747                 index = fg_console;
1748                 noctty = 1;
1749                 goto got_driver;
1750         }
1751 #endif
1752         if (device == MKDEV(TTYAUX_MAJOR,1)) {
1753                 driver = console_device(&index);
1754                 if (driver) {
1755                         /* Don't let /dev/console block */
1756                         filp->f_flags |= O_NONBLOCK;
1757                         noctty = 1;
1758                         goto got_driver;
1759                 }
1760                 return -ENODEV;
1761         }
1762
1763         driver = get_tty_driver(device, &index);
1764         if (!driver)
1765                 return -ENODEV;
1766 got_driver:
1767         retval = init_dev(driver, index, &tty);
1768         if (retval)
1769                 return retval;
1770
1771         filp->private_data = tty;
1772         file_move(filp, &tty->tty_files);
1773         check_tty_count(tty, "tty_open");
1774         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
1775             tty->driver->subtype == PTY_TYPE_MASTER)
1776                 noctty = 1;
1777 #ifdef TTY_DEBUG_HANGUP
1778         printk(KERN_DEBUG "opening %s...", tty->name);
1779 #endif
1780         if (!retval) {
1781                 if (tty->driver->open)
1782                         retval = tty->driver->open(tty, filp);
1783                 else
1784                         retval = -ENODEV;
1785         }
1786         filp->f_flags = saved_flags;
1787
1788         if (!retval && test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
1789                 retval = -EBUSY;
1790
1791         if (retval) {
1792 #ifdef TTY_DEBUG_HANGUP
1793                 printk(KERN_DEBUG "error %d in opening %s...", retval,
1794                        tty->name);
1795 #endif
1796                 release_dev(filp);
1797                 if (retval != -ERESTARTSYS)
1798                         return retval;
1799                 if (signal_pending(current))
1800                         return retval;
1801                 schedule();
1802                 /*
1803                  * Need to reset f_op in case a hangup happened.
1804                  */
1805                 if (filp->f_op == &hung_up_tty_fops)
1806                         filp->f_op = &tty_fops;
1807                 goto retry_open;
1808         }
1809         if (!noctty &&
1810             current->signal->leader &&
1811             !current->signal->tty &&
1812             tty->session == 0) {
1813                 task_lock(current);
1814                 current->signal->tty = tty;
1815                 task_unlock(current);
1816                 current->signal->tty_old_pgrp = 0;
1817                 tty->session = current->signal->session;
1818                 tty->pgrp = process_group(current);
1819         }
1820         return 0;
1821 }
1822
1823 #ifdef CONFIG_UNIX98_PTYS
1824 static int ptmx_open(struct inode * inode, struct file * filp)
1825 {
1826         struct tty_struct *tty;
1827         int retval;
1828         int index;
1829         int idr_ret;
1830
1831         nonseekable_open(inode, filp);
1832
1833         /* find a device that is not in use. */
1834         down(&allocated_ptys_lock);
1835         if (!idr_pre_get(&allocated_ptys, GFP_KERNEL)) {
1836                 up(&allocated_ptys_lock);
1837                 return -ENOMEM;
1838         }
1839         idr_ret = idr_get_new(&allocated_ptys, NULL, &index);
1840         if (idr_ret < 0) {
1841                 up(&allocated_ptys_lock);
1842                 if (idr_ret == -EAGAIN)
1843                         return -ENOMEM;
1844                 return -EIO;
1845         }
1846         if (index >= pty_limit) {
1847                 idr_remove(&allocated_ptys, index);
1848                 up(&allocated_ptys_lock);
1849                 return -EIO;
1850         }
1851         up(&allocated_ptys_lock);
1852
1853         retval = init_dev(ptm_driver, index, &tty);
1854         if (retval)
1855                 goto out;
1856
1857         set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
1858         filp->private_data = tty;
1859         file_move(filp, &tty->tty_files);
1860
1861         retval = -ENOMEM;
1862         if (devpts_pty_new(tty->link))
1863                 goto out1;
1864
1865         check_tty_count(tty, "tty_open");
1866         retval = ptm_driver->open(tty, filp);
1867         if (!retval)
1868                 return 0;
1869 out1:
1870         release_dev(filp);
1871 out:
1872         down(&allocated_ptys_lock);
1873         idr_remove(&allocated_ptys, index);
1874         up(&allocated_ptys_lock);
1875         return retval;
1876 }
1877 #endif
1878
1879 static int tty_release(struct inode * inode, struct file * filp)
1880 {
1881         lock_kernel();
1882         release_dev(filp);
1883         unlock_kernel();
1884         return 0;
1885 }
1886
1887 /* No kernel lock held - fine */
1888 static unsigned int tty_poll(struct file * filp, poll_table * wait)
1889 {
1890         struct tty_struct * tty;
1891         struct tty_ldisc *ld;
1892         int ret = 0;
1893
1894         tty = (struct tty_struct *)filp->private_data;
1895         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_poll"))
1896                 return 0;
1897
1898         ld = tty_ldisc_ref_wait(tty);
1899         if (ld->poll)
1900                 ret = (ld->poll)(tty, filp, wait);
1901         tty_ldisc_deref(ld);
1902         return ret;
1903 }
1904
1905 static int tty_fasync(int fd, struct file * filp, int on)
1906 {
1907         struct tty_struct * tty;
1908         int retval;
1909
1910         tty = (struct tty_struct *)filp->private_data;
1911         if (tty_paranoia_check(tty, filp->f_dentry->d_inode, "tty_fasync"))
1912                 return 0;
1913
1914         retval = fasync_helper(fd, filp, on, &tty->fasync);
1915         if (retval <= 0)
1916                 return retval;
1917
1918         if (on) {
1919                 if (!waitqueue_active(&tty->read_wait))
1920                         tty->minimum_to_wake = 1;
1921                 retval = f_setown(filp, (-tty->pgrp) ? : current->pid, 0);
1922                 if (retval)
1923                         return retval;
1924         } else {
1925                 if (!tty->fasync && !waitqueue_active(&tty->read_wait))
1926                         tty->minimum_to_wake = N_TTY_BUF_SIZE;
1927         }
1928         return 0;
1929 }
1930
1931 static int tiocsti(struct tty_struct *tty, char __user *p)
1932 {
1933         char ch, mbz = 0;
1934         struct tty_ldisc *ld;
1935
1936         if ((current->signal->tty != tty) && !capable(CAP_SYS_ADMIN))
1937                 return -EPERM;
1938         if (get_user(ch, p))
1939                 return -EFAULT;
1940         ld = tty_ldisc_ref_wait(tty);
1941         ld->receive_buf(tty, &ch, &mbz, 1);
1942         tty_ldisc_deref(ld);
1943         return 0;
1944 }
1945
1946 static int tiocgwinsz(struct tty_struct *tty, struct winsize __user * arg)
1947 {
1948         if (copy_to_user(arg, &tty->winsize, sizeof(*arg)))
1949                 return -EFAULT;
1950         return 0;
1951 }
1952
1953 static int tiocswinsz(struct tty_struct *tty, struct tty_struct *real_tty,
1954         struct winsize __user * arg)
1955 {
1956         struct winsize tmp_ws;
1957
1958         if (copy_from_user(&tmp_ws, arg, sizeof(*arg)))
1959                 return -EFAULT;
1960         if (!memcmp(&tmp_ws, &tty->winsize, sizeof(*arg)))
1961                 return 0;
1962 #ifdef CONFIG_VT
1963         if (tty->driver->type == TTY_DRIVER_TYPE_CONSOLE) {
1964                 unsigned int currcons = tty->index;
1965                 int rc;
1966
1967                 acquire_console_sem();
1968                 rc = vc_resize(currcons, tmp_ws.ws_col, tmp_ws.ws_row);
1969                 release_console_sem();
1970                 if (rc)
1971                         return -ENXIO;
1972         }
1973 #endif
1974         if (tty->pgrp > 0)
1975                 kill_pg(tty->pgrp, SIGWINCH, 1);
1976         if ((real_tty->pgrp != tty->pgrp) && (real_tty->pgrp > 0))
1977                 kill_pg(real_tty->pgrp, SIGWINCH, 1);
1978         tty->winsize = tmp_ws;
1979         real_tty->winsize = tmp_ws;
1980         return 0;
1981 }
1982
1983 static int tioccons(struct file *file)
1984 {
1985         if (file->f_op->write == redirected_tty_write) {
1986                 struct file *f;
1987                 if (!capable(CAP_SYS_ADMIN))
1988                         return -EPERM;
1989                 spin_lock(&redirect_lock);
1990                 f = redirect;
1991                 redirect = NULL;
1992                 spin_unlock(&redirect_lock);
1993                 if (f)
1994                         fput(f);
1995                 return 0;
1996         }
1997         spin_lock(&redirect_lock);
1998         if (redirect) {
1999                 spin_unlock(&redirect_lock);
2000                 return -EBUSY;
2001         }
2002         get_file(file);
2003         redirect = file;
2004         spin_unlock(&redirect_lock);
2005         return 0;
2006 }
2007
2008
2009 static int fionbio(struct file *file, int __user *p)
2010 {
2011         int nonblock;
2012
2013         if (get_user(nonblock, p))
2014                 return -EFAULT;
2015
2016         if (nonblock)
2017                 file->f_flags |= O_NONBLOCK;
2018         else
2019                 file->f_flags &= ~O_NONBLOCK;
2020         return 0;
2021 }
2022
2023 static int tiocsctty(struct tty_struct *tty, int arg)
2024 {
2025         task_t *p;
2026
2027         if (current->signal->leader &&
2028             (current->signal->session == tty->session))
2029                 return 0;
2030         /*
2031          * The process must be a session leader and
2032          * not have a controlling tty already.
2033          */
2034         if (!current->signal->leader || current->signal->tty)
2035                 return -EPERM;
2036         if (tty->session > 0) {
2037                 /*
2038                  * This tty is already the controlling
2039                  * tty for another session group!
2040                  */
2041                 if ((arg == 1) && capable(CAP_SYS_ADMIN)) {
2042                         /*
2043                          * Steal it away
2044                          */
2045
2046                         read_lock(&tasklist_lock);
2047                         do_each_task_pid(tty->session, PIDTYPE_SID, p) {
2048                                 p->signal->tty = NULL;
2049                         } while_each_task_pid(tty->session, PIDTYPE_SID, p);
2050                         read_unlock(&tasklist_lock);
2051                 } else
2052                         return -EPERM;
2053         }
2054         task_lock(current);
2055         current->signal->tty = tty;
2056         task_unlock(current);
2057         current->signal->tty_old_pgrp = 0;
2058         tty->session = current->signal->session;
2059         tty->pgrp = process_group(current);
2060         return 0;
2061 }
2062
2063 static int tiocgpgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2064 {
2065         pid_t pgrp;
2066         /*
2067          * (tty == real_tty) is a cheap way of
2068          * testing if the tty is NOT a master pty.
2069          */
2070         if (tty == real_tty && current->signal->tty != real_tty)
2071                 return -ENOTTY;
2072
2073         pgrp = vx_map_pid(real_tty->pgrp);
2074         return put_user(pgrp, p);
2075 }
2076
2077 static int tiocspgrp(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2078 {
2079         pid_t pgrp;
2080         int retval = tty_check_change(real_tty);
2081
2082         if (retval == -EIO)
2083                 return -ENOTTY;
2084         if (retval)
2085                 return retval;
2086         if (!current->signal->tty ||
2087             (current->signal->tty != real_tty) ||
2088             (real_tty->session != current->signal->session))
2089                 return -ENOTTY;
2090         if (get_user(pgrp, p))
2091                 return -EFAULT;
2092
2093         pgrp = vx_rmap_pid(pgrp);
2094         if (pgrp < 0)
2095                 return -EINVAL;
2096         if (session_of_pgrp(pgrp) != current->signal->session)
2097                 return -EPERM;
2098         real_tty->pgrp = pgrp;
2099         return 0;
2100 }
2101
2102 static int tiocgsid(struct tty_struct *tty, struct tty_struct *real_tty, pid_t __user *p)
2103 {
2104         /*
2105          * (tty == real_tty) is a cheap way of
2106          * testing if the tty is NOT a master pty.
2107         */
2108         if (tty == real_tty && current->signal->tty != real_tty)
2109                 return -ENOTTY;
2110         if (real_tty->session <= 0)
2111                 return -ENOTTY;
2112         return put_user(real_tty->session, p);
2113 }
2114
2115 static int tiocsetd(struct tty_struct *tty, int __user *p)
2116 {
2117         int ldisc;
2118
2119         if (get_user(ldisc, p))
2120                 return -EFAULT;
2121         return tty_set_ldisc(tty, ldisc);
2122 }
2123
2124 static int send_break(struct tty_struct *tty, int duration)
2125 {
2126         set_current_state(TASK_INTERRUPTIBLE);
2127
2128         tty->driver->break_ctl(tty, -1);
2129         if (!signal_pending(current))
2130                 schedule_timeout(duration);
2131         tty->driver->break_ctl(tty, 0);
2132         if (signal_pending(current))
2133                 return -EINTR;
2134         return 0;
2135 }
2136
2137 static int
2138 tty_tiocmget(struct tty_struct *tty, struct file *file, int __user *p)
2139 {
2140         int retval = -EINVAL;
2141
2142         if (tty->driver->tiocmget) {
2143                 retval = tty->driver->tiocmget(tty, file);
2144
2145                 if (retval >= 0)
2146                         retval = put_user(retval, p);
2147         }
2148         return retval;
2149 }
2150
2151 static int
2152 tty_tiocmset(struct tty_struct *tty, struct file *file, unsigned int cmd,
2153              unsigned __user *p)
2154 {
2155         int retval = -EINVAL;
2156
2157         if (tty->driver->tiocmset) {
2158                 unsigned int set, clear, val;
2159
2160                 retval = get_user(val, p);
2161                 if (retval)
2162                         return retval;
2163
2164                 set = clear = 0;
2165                 switch (cmd) {
2166                 case TIOCMBIS:
2167                         set = val;
2168                         break;
2169                 case TIOCMBIC:
2170                         clear = val;
2171                         break;
2172                 case TIOCMSET:
2173                         set = val;
2174                         clear = ~val;
2175                         break;
2176                 }
2177
2178                 set &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2179                 clear &= TIOCM_DTR|TIOCM_RTS|TIOCM_OUT1|TIOCM_OUT2|TIOCM_LOOP;
2180
2181                 retval = tty->driver->tiocmset(tty, file, set, clear);
2182         }
2183         return retval;
2184 }
2185
2186 /*
2187  * Split this up, as gcc can choke on it otherwise..
2188  */
2189 int tty_ioctl(struct inode * inode, struct file * file,
2190               unsigned int cmd, unsigned long arg)
2191 {
2192         struct tty_struct *tty, *real_tty;
2193         void __user *p = (void __user *)arg;
2194         int retval;
2195         struct tty_ldisc *ld;
2196
2197         tty = (struct tty_struct *)file->private_data;
2198         if (tty_paranoia_check(tty, inode, "tty_ioctl"))
2199                 return -EINVAL;
2200
2201         real_tty = tty;
2202         if (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
2203             tty->driver->subtype == PTY_TYPE_MASTER)
2204                 real_tty = tty->link;
2205
2206         /*
2207          * Break handling by driver
2208          */
2209         if (!tty->driver->break_ctl) {
2210                 switch(cmd) {
2211                 case TIOCSBRK:
2212                 case TIOCCBRK:
2213                         if (tty->driver->ioctl)
2214                                 return tty->driver->ioctl(tty, file, cmd, arg);
2215                         return -EINVAL;
2216
2217                 /* These two ioctl's always return success; even if */
2218                 /* the driver doesn't support them. */
2219                 case TCSBRK:
2220                 case TCSBRKP:
2221                         if (!tty->driver->ioctl)
2222                                 return 0;
2223                         retval = tty->driver->ioctl(tty, file, cmd, arg);
2224                         if (retval == -ENOIOCTLCMD)
2225                                 retval = 0;
2226                         return retval;
2227                 }
2228         }
2229
2230         /*
2231          * Factor out some common prep work
2232          */
2233         switch (cmd) {
2234         case TIOCSETD:
2235         case TIOCSBRK:
2236         case TIOCCBRK:
2237         case TCSBRK:
2238         case TCSBRKP:
2239                 retval = tty_check_change(tty);
2240                 if (retval)
2241                         return retval;
2242                 if (cmd != TIOCCBRK) {
2243                         tty_wait_until_sent(tty, 0);
2244                         if (signal_pending(current))
2245                                 return -EINTR;
2246                 }
2247                 break;
2248         }
2249
2250         switch (cmd) {
2251                 case TIOCSTI:
2252                         return tiocsti(tty, p);
2253                 case TIOCGWINSZ:
2254                         return tiocgwinsz(tty, p);
2255                 case TIOCSWINSZ:
2256                         return tiocswinsz(tty, real_tty, p);
2257                 case TIOCCONS:
2258                         return real_tty!=tty ? -EINVAL : tioccons(file);
2259                 case FIONBIO:
2260                         return fionbio(file, p);
2261                 case TIOCEXCL:
2262                         set_bit(TTY_EXCLUSIVE, &tty->flags);
2263                         return 0;
2264                 case TIOCNXCL:
2265                         clear_bit(TTY_EXCLUSIVE, &tty->flags);
2266                         return 0;
2267                 case TIOCNOTTY:
2268                         if (current->signal->tty != tty)
2269                                 return -ENOTTY;
2270                         if (current->signal->leader)
2271                                 disassociate_ctty(0);
2272                         task_lock(current);
2273                         current->signal->tty = NULL;
2274                         task_unlock(current);
2275                         return 0;
2276                 case TIOCSCTTY:
2277                         return tiocsctty(tty, arg);
2278                 case TIOCGPGRP:
2279                         return tiocgpgrp(tty, real_tty, p);
2280                 case TIOCSPGRP:
2281                         return tiocspgrp(tty, real_tty, p);
2282                 case TIOCGSID:
2283                         return tiocgsid(tty, real_tty, p);
2284                 case TIOCGETD:
2285                         /* FIXME: check this is ok */
2286                         return put_user(tty->ldisc.num, (int __user *)p);
2287                 case TIOCSETD:
2288                         return tiocsetd(tty, p);
2289 #ifdef CONFIG_VT
2290                 case TIOCLINUX:
2291                         return tioclinux(tty, arg);
2292 #endif
2293                 /*
2294                  * Break handling
2295                  */
2296                 case TIOCSBRK:  /* Turn break on, unconditionally */
2297                         tty->driver->break_ctl(tty, -1);
2298                         return 0;
2299
2300                 case TIOCCBRK:  /* Turn break off, unconditionally */
2301                         tty->driver->break_ctl(tty, 0);
2302                         return 0;
2303                 case TCSBRK:   /* SVID version: non-zero arg --> no break */
2304                         /*
2305                          * XXX is the above comment correct, or the
2306                          * code below correct?  Is this ioctl used at
2307                          * all by anyone?
2308                          */
2309                         if (!arg)
2310                                 return send_break(tty, HZ/4);
2311                         return 0;
2312                 case TCSBRKP:   /* support for POSIX tcsendbreak() */
2313                         return send_break(tty, arg ? arg*(HZ/10) : HZ/4);
2314
2315                 case TIOCMGET:
2316                         return tty_tiocmget(tty, file, p);
2317
2318                 case TIOCMSET:
2319                 case TIOCMBIC:
2320                 case TIOCMBIS:
2321                         return tty_tiocmset(tty, file, cmd, p);
2322         }
2323         if (tty->driver->ioctl) {
2324                 retval = (tty->driver->ioctl)(tty, file, cmd, arg);
2325                 if (retval != -ENOIOCTLCMD)
2326                         return retval;
2327         }
2328         ld = tty_ldisc_ref_wait(tty);
2329         retval = -EINVAL;
2330         if (ld->ioctl) {
2331                 retval = ld->ioctl(tty, file, cmd, arg);
2332                 if (retval == -ENOIOCTLCMD)
2333                         retval = -EINVAL;
2334         }
2335         tty_ldisc_deref(ld);
2336         return retval;
2337 }
2338
2339
2340 /*
2341  * This implements the "Secure Attention Key" ---  the idea is to
2342  * prevent trojan horses by killing all processes associated with this
2343  * tty when the user hits the "Secure Attention Key".  Required for
2344  * super-paranoid applications --- see the Orange Book for more details.
2345  *
2346  * This code could be nicer; ideally it should send a HUP, wait a few
2347  * seconds, then send a INT, and then a KILL signal.  But you then
2348  * have to coordinate with the init process, since all processes associated
2349  * with the current tty must be dead before the new getty is allowed
2350  * to spawn.
2351  *
2352  * Now, if it would be correct ;-/ The current code has a nasty hole -
2353  * it doesn't catch files in flight. We may send the descriptor to ourselves
2354  * via AF_UNIX socket, close it and later fetch from socket. FIXME.
2355  *
2356  * Nasty bug: do_SAK is being called in interrupt context.  This can
2357  * deadlock.  We punt it up to process context.  AKPM - 16Mar2001
2358  */
2359 static void __do_SAK(void *arg)
2360 {
2361 #ifdef TTY_SOFT_SAK
2362         tty_hangup(tty);
2363 #else
2364         struct tty_struct *tty = arg;
2365         struct task_struct *p;
2366         int session;
2367         int             i;
2368         struct file     *filp;
2369         struct tty_ldisc *disc;
2370
2371         if (!tty)
2372                 return;
2373         session  = tty->session;
2374
2375         /* We don't want an ldisc switch during this */
2376         disc = tty_ldisc_ref(tty);
2377         if (disc && disc->flush_buffer)
2378                 disc->flush_buffer(tty);
2379         tty_ldisc_deref(disc);
2380
2381         if (tty->driver->flush_buffer)
2382                 tty->driver->flush_buffer(tty);
2383
2384         read_lock(&tasklist_lock);
2385         do_each_task_pid(session, PIDTYPE_SID, p) {
2386                 if (p->signal->tty == tty || session > 0) {
2387                         printk(KERN_NOTICE "SAK: killed process %d"
2388                             " (%s): p->signal->session==tty->session\n",
2389                             p->pid, p->comm);
2390                         send_sig(SIGKILL, p, 1);
2391                         continue;
2392                 }
2393                 task_lock(p);
2394                 if (p->files) {
2395                         spin_lock(&p->files->file_lock);
2396                         for (i=0; i < p->files->max_fds; i++) {
2397                                 filp = fcheck_files(p->files, i);
2398                                 if (!filp)
2399                                         continue;
2400                                 if (filp->f_op->read == tty_read &&
2401                                     filp->private_data == tty) {
2402                                         printk(KERN_NOTICE "SAK: killed process %d"
2403                                             " (%s): fd#%d opened to the tty\n",
2404                                             p->pid, p->comm, i);
2405                                         send_sig(SIGKILL, p, 1);
2406                                         break;
2407                                 }
2408                         }
2409                         spin_unlock(&p->files->file_lock);
2410                 }
2411                 task_unlock(p);
2412         } while_each_task_pid(session, PIDTYPE_SID, p);
2413         read_unlock(&tasklist_lock);
2414 #endif
2415 }
2416
2417 /*
2418  * The tq handling here is a little racy - tty->SAK_work may already be queued.
2419  * Fortunately we don't need to worry, because if ->SAK_work is already queued,
2420  * the values which we write to it will be identical to the values which it
2421  * already has. --akpm
2422  */
2423 void do_SAK(struct tty_struct *tty)
2424 {
2425         if (!tty)
2426                 return;
2427         PREPARE_WORK(&tty->SAK_work, __do_SAK, tty);
2428         schedule_work(&tty->SAK_work);
2429 }
2430
2431 EXPORT_SYMBOL(do_SAK);
2432
2433 /*
2434  * This routine is called out of the software interrupt to flush data
2435  * from the flip buffer to the line discipline.
2436  */
2437
2438 static void flush_to_ldisc(void *private_)
2439 {
2440         struct tty_struct *tty = (struct tty_struct *) private_;
2441         unsigned char   *cp;
2442         char            *fp;
2443         int             count;
2444         unsigned long   flags;
2445         struct tty_ldisc *disc;
2446
2447         disc = tty_ldisc_ref(tty);
2448         if (disc == NULL)       /*  !TTY_LDISC */
2449                 return;
2450
2451         if (test_bit(TTY_DONT_FLIP, &tty->flags)) {
2452                 /*
2453                  * Do it after the next timer tick:
2454                  */
2455                 schedule_delayed_work(&tty->flip.work, 1);
2456                 goto out;
2457         }
2458         spin_lock_irqsave(&tty->read_lock, flags);
2459         if (tty->flip.buf_num) {
2460                 cp = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2461                 fp = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2462                 tty->flip.buf_num = 0;
2463                 tty->flip.char_buf_ptr = tty->flip.char_buf;
2464                 tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2465         } else {
2466                 cp = tty->flip.char_buf;
2467                 fp = tty->flip.flag_buf;
2468                 tty->flip.buf_num = 1;
2469                 tty->flip.char_buf_ptr = tty->flip.char_buf + TTY_FLIPBUF_SIZE;
2470                 tty->flip.flag_buf_ptr = tty->flip.flag_buf + TTY_FLIPBUF_SIZE;
2471         }
2472         count = tty->flip.count;
2473         tty->flip.count = 0;
2474         spin_unlock_irqrestore(&tty->read_lock, flags);
2475
2476         disc->receive_buf(tty, cp, fp, count);
2477 out:
2478         tty_ldisc_deref(disc);
2479 }
2480
2481 /*
2482  *      Call the ldisc flush directly from a driver. This function may
2483  *      return an error and need retrying by the user.
2484  */
2485
2486 int tty_push_data(struct tty_struct *tty, unsigned char *cp, unsigned char *fp, int count)
2487 {
2488         int ret = 0;
2489         struct tty_ldisc *disc;
2490
2491         disc = tty_ldisc_ref(tty);
2492         if(test_bit(TTY_DONT_FLIP, &tty->flags))
2493                 ret = -EAGAIN;
2494         else if(disc == NULL)
2495                 ret = -EIO;
2496         else
2497                 disc->receive_buf(tty, cp, fp, count);
2498         tty_ldisc_deref(disc);
2499         return ret;
2500
2501 }
2502
2503 /*
2504  * Routine which returns the baud rate of the tty
2505  *
2506  * Note that the baud_table needs to be kept in sync with the
2507  * include/asm/termbits.h file.
2508  */
2509 static int baud_table[] = {
2510         0, 50, 75, 110, 134, 150, 200, 300, 600, 1200, 1800, 2400, 4800,
2511         9600, 19200, 38400, 57600, 115200, 230400, 460800,
2512 #ifdef __sparc__
2513         76800, 153600, 307200, 614400, 921600
2514 #else
2515         500000, 576000, 921600, 1000000, 1152000, 1500000, 2000000,
2516         2500000, 3000000, 3500000, 4000000
2517 #endif
2518 };
2519
2520 static int n_baud_table = ARRAY_SIZE(baud_table);
2521
2522 /**
2523  *      tty_termios_baud_rate
2524  *      @termios: termios structure
2525  *
2526  *      Convert termios baud rate data into a speed. This should be called
2527  *      with the termios lock held if this termios is a terminal termios
2528  *      structure. May change the termios data.
2529  */
2530
2531 int tty_termios_baud_rate(struct termios *termios)
2532 {
2533         unsigned int cbaud;
2534
2535         cbaud = termios->c_cflag & CBAUD;
2536
2537         if (cbaud & CBAUDEX) {
2538                 cbaud &= ~CBAUDEX;
2539
2540                 if (cbaud < 1 || cbaud + 15 > n_baud_table)
2541                         termios->c_cflag &= ~CBAUDEX;
2542                 else
2543                         cbaud += 15;
2544         }
2545         return baud_table[cbaud];
2546 }
2547
2548 EXPORT_SYMBOL(tty_termios_baud_rate);
2549
2550 /**
2551  *      tty_get_baud_rate       -       get tty bit rates
2552  *      @tty: tty to query
2553  *
2554  *      Returns the baud rate as an integer for this terminal. The
2555  *      termios lock must be held by the caller and the terminal bit
2556  *      flags may be updated.
2557  */
2558
2559 int tty_get_baud_rate(struct tty_struct *tty)
2560 {
2561         int baud = tty_termios_baud_rate(tty->termios);
2562
2563         if (baud == 38400 && tty->alt_speed) {
2564                 if (!tty->warned) {
2565                         printk(KERN_WARNING "Use of setserial/setrocket to "
2566                                             "set SPD_* flags is deprecated\n");
2567                         tty->warned = 1;
2568                 }
2569                 baud = tty->alt_speed;
2570         }
2571
2572         return baud;
2573 }
2574
2575 EXPORT_SYMBOL(tty_get_baud_rate);
2576
2577 /**
2578  *      tty_flip_buffer_push    -       terminal
2579  *      @tty: tty to push
2580  *
2581  *      Queue a push of the terminal flip buffers to the line discipline. This
2582  *      function must not be called from IRQ context if tty->low_latency is set.
2583  *
2584  *      In the event of the queue being busy for flipping the work will be
2585  *      held off and retried later.
2586  */
2587
2588 void tty_flip_buffer_push(struct tty_struct *tty)
2589 {
2590         if (tty->low_latency)
2591                 flush_to_ldisc((void *) tty);
2592         else
2593                 schedule_delayed_work(&tty->flip.work, 1);
2594 }
2595
2596 EXPORT_SYMBOL(tty_flip_buffer_push);
2597
2598 /*
2599  * This subroutine initializes a tty structure.
2600  */
2601 static void initialize_tty_struct(struct tty_struct *tty)
2602 {
2603         memset(tty, 0, sizeof(struct tty_struct));
2604         tty->magic = TTY_MAGIC;
2605         tty_ldisc_assign(tty, tty_ldisc_get(N_TTY));
2606         tty->pgrp = -1;
2607         tty->flip.char_buf_ptr = tty->flip.char_buf;
2608         tty->flip.flag_buf_ptr = tty->flip.flag_buf;
2609         INIT_WORK(&tty->flip.work, flush_to_ldisc, tty);
2610         init_MUTEX(&tty->flip.pty_sem);
2611         init_MUTEX(&tty->termios_sem);
2612         init_waitqueue_head(&tty->write_wait);
2613         init_waitqueue_head(&tty->read_wait);
2614         INIT_WORK(&tty->hangup_work, do_tty_hangup, tty);
2615         sema_init(&tty->atomic_read, 1);
2616         sema_init(&tty->atomic_write, 1);
2617         spin_lock_init(&tty->read_lock);
2618         INIT_LIST_HEAD(&tty->tty_files);
2619         INIT_WORK(&tty->SAK_work, NULL, NULL);
2620 }
2621
2622 /*
2623  * The default put_char routine if the driver did not define one.
2624  */
2625 static void tty_default_put_char(struct tty_struct *tty, unsigned char ch)
2626 {
2627         tty->driver->write(tty, 0, &ch, 1);
2628 }
2629
2630 static struct class_simple *tty_class;
2631
2632 /**
2633  * tty_register_device - register a tty device
2634  * @driver: the tty driver that describes the tty device
2635  * @index: the index in the tty driver for this tty device
2636  * @device: a struct device that is associated with this tty device.
2637  *      This field is optional, if there is no known struct device for this
2638  *      tty device it can be set to NULL safely.
2639  *
2640  * This call is required to be made to register an individual tty device if
2641  * the tty driver's flags have the TTY_DRIVER_NO_DEVFS bit set.  If that
2642  * bit is not set, this function should not be called.
2643  */
2644 void tty_register_device(struct tty_driver *driver, unsigned index,
2645                          struct device *device)
2646 {
2647         char name[64];
2648         dev_t dev = MKDEV(driver->major, driver->minor_start) + index;
2649
2650         if (index >= driver->num) {
2651                 printk(KERN_ERR "Attempt to register invalid tty line number "
2652                        " (%d).\n", index);
2653                 return;
2654         }
2655
2656         devfs_mk_cdev(dev, S_IFCHR | S_IRUSR | S_IWUSR,
2657                         "%s%d", driver->devfs_name, index + driver->name_base);
2658
2659         if (driver->type == TTY_DRIVER_TYPE_PTY)
2660                 pty_line_name(driver, index, name);
2661         else
2662                 tty_line_name(driver, index, name);
2663         class_simple_device_add(tty_class, dev, device, name);
2664 }
2665
2666 /**
2667  * tty_unregister_device - unregister a tty device
2668  * @driver: the tty driver that describes the tty device
2669  * @index: the index in the tty driver for this tty device
2670  *
2671  * If a tty device is registered with a call to tty_register_device() then
2672  * this function must be made when the tty device is gone.
2673  */
2674 void tty_unregister_device(struct tty_driver *driver, unsigned index)
2675 {
2676         devfs_remove("%s%d", driver->devfs_name, index + driver->name_base);
2677         class_simple_device_remove(MKDEV(driver->major, driver->minor_start) + index);
2678 }
2679
2680 EXPORT_SYMBOL(tty_register_device);
2681 EXPORT_SYMBOL(tty_unregister_device);
2682
2683 struct tty_driver *alloc_tty_driver(int lines)
2684 {
2685         struct tty_driver *driver;
2686
2687         driver = kmalloc(sizeof(struct tty_driver), GFP_KERNEL);
2688         if (driver) {
2689                 memset(driver, 0, sizeof(struct tty_driver));
2690                 driver->magic = TTY_DRIVER_MAGIC;
2691                 driver->num = lines;
2692                 /* later we'll move allocation of tables here */
2693         }
2694         return driver;
2695 }
2696
2697 void put_tty_driver(struct tty_driver *driver)
2698 {
2699         kfree(driver);
2700 }
2701
2702 void tty_set_operations(struct tty_driver *driver, struct tty_operations *op)
2703 {
2704         driver->open = op->open;
2705         driver->close = op->close;
2706         driver->write = op->write;
2707         driver->put_char = op->put_char;
2708         driver->flush_chars = op->flush_chars;
2709         driver->write_room = op->write_room;
2710         driver->chars_in_buffer = op->chars_in_buffer;
2711         driver->ioctl = op->ioctl;
2712         driver->set_termios = op->set_termios;
2713         driver->throttle = op->throttle;
2714         driver->unthrottle = op->unthrottle;
2715         driver->stop = op->stop;
2716         driver->start = op->start;
2717         driver->hangup = op->hangup;
2718         driver->break_ctl = op->break_ctl;
2719         driver->flush_buffer = op->flush_buffer;
2720         driver->set_ldisc = op->set_ldisc;
2721         driver->wait_until_sent = op->wait_until_sent;
2722         driver->send_xchar = op->send_xchar;
2723         driver->read_proc = op->read_proc;
2724         driver->write_proc = op->write_proc;
2725         driver->tiocmget = op->tiocmget;
2726         driver->tiocmset = op->tiocmset;
2727 }
2728
2729
2730 EXPORT_SYMBOL(alloc_tty_driver);
2731 EXPORT_SYMBOL(put_tty_driver);
2732 EXPORT_SYMBOL(tty_set_operations);
2733
2734 /*
2735  * Called by a tty driver to register itself.
2736  */
2737 int tty_register_driver(struct tty_driver *driver)
2738 {
2739         int error;
2740         int i;
2741         dev_t dev;
2742         void **p = NULL;
2743
2744         if (driver->flags & TTY_DRIVER_INSTALLED)
2745                 return 0;
2746
2747         if (!(driver->flags & TTY_DRIVER_DEVPTS_MEM)) {
2748                 p = kmalloc(driver->num * 3 * sizeof(void *), GFP_KERNEL);
2749                 if (!p)
2750                         return -ENOMEM;
2751                 memset(p, 0, driver->num * 3 * sizeof(void *));
2752         }
2753
2754         if (!driver->major) {
2755                 error = alloc_chrdev_region(&dev, driver->minor_start, driver->num,
2756                                                 (char*)driver->name);
2757                 if (!error) {
2758                         driver->major = MAJOR(dev);
2759                         driver->minor_start = MINOR(dev);
2760                 }
2761         } else {
2762                 dev = MKDEV(driver->major, driver->minor_start);
2763                 error = register_chrdev_region(dev, driver->num,
2764                                                 (char*)driver->name);
2765         }
2766         if (error < 0) {
2767                 kfree(p);
2768                 return error;
2769         }
2770
2771         if (p) {
2772                 driver->ttys = (struct tty_struct **)p;
2773                 driver->termios = (struct termios **)(p + driver->num);
2774                 driver->termios_locked = (struct termios **)(p + driver->num * 2);
2775         } else {
2776                 driver->ttys = NULL;
2777                 driver->termios = NULL;
2778                 driver->termios_locked = NULL;
2779         }
2780
2781         cdev_init(&driver->cdev, &tty_fops);
2782         driver->cdev.owner = driver->owner;
2783         error = cdev_add(&driver->cdev, dev, driver->num);
2784         if (error) {
2785                 cdev_del(&driver->cdev);
2786                 unregister_chrdev_region(dev, driver->num);
2787                 driver->ttys = NULL;
2788                 driver->termios = driver->termios_locked = NULL;
2789                 kfree(p);
2790                 return error;
2791         }
2792
2793         if (!driver->put_char)
2794                 driver->put_char = tty_default_put_char;
2795
2796         list_add(&driver->tty_drivers, &tty_drivers);
2797
2798         if ( !(driver->flags & TTY_DRIVER_NO_DEVFS) ) {
2799                 for(i = 0; i < driver->num; i++)
2800                     tty_register_device(driver, i, NULL);
2801         }
2802         proc_tty_register_driver(driver);
2803         return 0;
2804 }
2805
2806 EXPORT_SYMBOL(tty_register_driver);
2807
2808 /*
2809  * Called by a tty driver to unregister itself.
2810  */
2811 int tty_unregister_driver(struct tty_driver *driver)
2812 {
2813         int i;
2814         struct termios *tp;
2815         void *p;
2816
2817         if (driver->refcount)
2818                 return -EBUSY;
2819
2820         unregister_chrdev_region(MKDEV(driver->major, driver->minor_start),
2821                                 driver->num);
2822
2823         list_del(&driver->tty_drivers);
2824
2825         /*
2826          * Free the termios and termios_locked structures because
2827          * we don't want to get memory leaks when modular tty
2828          * drivers are removed from the kernel.
2829          */
2830         for (i = 0; i < driver->num; i++) {
2831                 tp = driver->termios[i];
2832                 if (tp) {
2833                         driver->termios[i] = NULL;
2834                         kfree(tp);
2835                 }
2836                 tp = driver->termios_locked[i];
2837                 if (tp) {
2838                         driver->termios_locked[i] = NULL;
2839                         kfree(tp);
2840                 }
2841                 if (!(driver->flags & TTY_DRIVER_NO_DEVFS))
2842                         tty_unregister_device(driver, i);
2843         }
2844         p = driver->ttys;
2845         proc_tty_unregister_driver(driver);
2846         driver->ttys = NULL;
2847         driver->termios = driver->termios_locked = NULL;
2848         kfree(p);
2849         cdev_del(&driver->cdev);
2850         return 0;
2851 }
2852
2853 EXPORT_SYMBOL(tty_unregister_driver);
2854
2855
2856 /*
2857  * Initialize the console device. This is called *early*, so
2858  * we can't necessarily depend on lots of kernel help here.
2859  * Just do some early initializations, and do the complex setup
2860  * later.
2861  */
2862 void __init console_init(void)
2863 {
2864         initcall_t *call;
2865
2866         /* Setup the default TTY line discipline. */
2867         (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
2868
2869         /*
2870          * set up the console device so that later boot sequences can
2871          * inform about problems etc..
2872          */
2873 #ifdef CONFIG_EARLY_PRINTK
2874         disable_early_printk();
2875 #endif
2876 #ifdef CONFIG_SERIAL_68360
2877         /* This is not a console initcall. I know not what it's doing here.
2878            So I haven't moved it. dwmw2 */
2879         rs_360_init();
2880 #endif
2881         call = &__con_initcall_start;
2882         while (call < &__con_initcall_end) {
2883                 (*call)();
2884                 call++;
2885         }
2886 }
2887
2888 #ifdef CONFIG_VT
2889 extern int vty_init(void);
2890 #endif
2891
2892 static int __init tty_class_init(void)
2893 {
2894         tty_class = class_simple_create(THIS_MODULE, "tty");
2895         if (IS_ERR(tty_class))
2896                 return PTR_ERR(tty_class);
2897         return 0;
2898 }
2899
2900 postcore_initcall(tty_class_init);
2901
2902 /* 3/2004 jmc: why do these devices exist? */
2903
2904 static struct cdev tty_cdev, console_cdev;
2905 #ifdef CONFIG_UNIX98_PTYS
2906 static struct cdev ptmx_cdev;
2907 #endif
2908 #ifdef CONFIG_VT
2909 static struct cdev vc0_cdev;
2910 #endif
2911
2912 /*
2913  * Ok, now we can initialize the rest of the tty devices and can count
2914  * on memory allocations, interrupts etc..
2915  */
2916 static int __init tty_init(void)
2917 {
2918         cdev_init(&tty_cdev, &tty_fops);
2919         if (cdev_add(&tty_cdev, MKDEV(TTYAUX_MAJOR, 0), 1) ||
2920             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 0), 1, "/dev/tty") < 0)
2921                 panic("Couldn't register /dev/tty driver\n");
2922         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 0), S_IFCHR|S_IRUGO|S_IWUGO, "tty");
2923         class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 0), NULL, "tty");
2924
2925         cdev_init(&console_cdev, &console_fops);
2926         if (cdev_add(&console_cdev, MKDEV(TTYAUX_MAJOR, 1), 1) ||
2927             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 1), 1, "/dev/console") < 0)
2928                 panic("Couldn't register /dev/console driver\n");
2929         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 1), S_IFCHR|S_IRUSR|S_IWUSR, "console");
2930         class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 1), NULL, "console");
2931
2932 #ifdef CONFIG_UNIX98_PTYS
2933         cdev_init(&ptmx_cdev, &ptmx_fops);
2934         if (cdev_add(&ptmx_cdev, MKDEV(TTYAUX_MAJOR, 2), 1) ||
2935             register_chrdev_region(MKDEV(TTYAUX_MAJOR, 2), 1, "/dev/ptmx") < 0)
2936                 panic("Couldn't register /dev/ptmx driver\n");
2937         devfs_mk_cdev(MKDEV(TTYAUX_MAJOR, 2), S_IFCHR|S_IRUGO|S_IWUGO, "ptmx");
2938         class_simple_device_add(tty_class, MKDEV(TTYAUX_MAJOR, 2), NULL, "ptmx");
2939 #endif
2940
2941 #ifdef CONFIG_VT
2942         cdev_init(&vc0_cdev, &console_fops);
2943         if (cdev_add(&vc0_cdev, MKDEV(TTY_MAJOR, 0), 1) ||
2944             register_chrdev_region(MKDEV(TTY_MAJOR, 0), 1, "/dev/vc/0") < 0)
2945                 panic("Couldn't register /dev/tty0 driver\n");
2946         devfs_mk_cdev(MKDEV(TTY_MAJOR, 0), S_IFCHR|S_IRUSR|S_IWUSR, "vc/0");
2947         class_simple_device_add(tty_class, MKDEV(TTY_MAJOR, 0), NULL, "tty0");
2948
2949         vty_init();
2950 #endif
2951         return 0;
2952 }
2953 module_init(tty_init);