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