drivers/char/tty_ldisc.c

   1 #include <linux/types.h>
   2 #include <linux/major.h>
   3 #include <linux/errno.h>
   4 #include <linux/signal.h>
   5 #include <linux/fcntl.h>
   6 #include <linux/sched.h>
   7 #include <linux/interrupt.h>
   8 #include <linux/tty.h>
   9 #include <linux/tty_driver.h>
  10 #include <linux/tty_flip.h>
  11 #include <linux/devpts_fs.h>
  12 #include <linux/file.h>
  13 #include <linux/fdtable.h>
  14 #include <linux/console.h>
  15 #include <linux/timer.h>
  16 #include <linux/ctype.h>
  17 #include <linux/kd.h>
  18 #include <linux/mm.h>
  19 #include <linux/string.h>
  20 #include <linux/slab.h>
  21 #include <linux/poll.h>
  22 #include <linux/proc_fs.h>
  23 #include <linux/init.h>
  24 #include <linux/module.h>
  25 #include <linux/smp_lock.h>
  26 #include <linux/device.h>
  27 #include <linux/wait.h>
  28 #include <linux/bitops.h>
  29 #include <linux/delay.h>
  30 #include <linux/seq_file.h>
  31
  32 #include <linux/uaccess.h>
  33 #include <asm/system.h>
  34
  35 #include <linux/kbd_kern.h>
  36 #include <linux/vt_kern.h>
  37 #include <linux/selection.h>
  38
  39 #include <linux/kmod.h>
  40 #include <linux/nsproxy.h>
  41
  42 /*
  43  *      This guards the refcounted line discipline lists. The lock
  44  *      must be taken with irqs off because there are hangup path
  45  *      callers who will do ldisc lookups and cannot sleep.
  46  */
  47
  48 static DEFINE_SPINLOCK(tty_ldisc_lock);
  49 static DECLARE_WAIT_QUEUE_HEAD(tty_ldisc_wait);
  50 /* Line disc dispatch table */
  51 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
  52
  53 /**
  54  *      tty_register_ldisc      -       install a line discipline
  55  *      @disc: ldisc number
  56  *      @new_ldisc: pointer to the ldisc object
  57  *
  58  *      Installs a new line discipline into the kernel. The discipline
  59  *      is set up as unreferenced and then made available to the kernel
  60  *      from this point onwards.
  61  *
  62  *      Locking:
  63  *              takes tty_ldisc_lock to guard against ldisc races
  64  */
  65
  66 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
  67 {
  68         unsigned long flags;
  69         int ret = 0;
  70
  71         if (disc < N_TTY || disc >= NR_LDISCS)
  72                 return -EINVAL;
  73
  74         spin_lock_irqsave(&tty_ldisc_lock, flags);
  75         tty_ldiscs[disc] = new_ldisc;
  76         new_ldisc->num = disc;
  77         new_ldisc->refcount = 0;
  78         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
  79
  80         return ret;
  81 }
  82 EXPORT_SYMBOL(tty_register_ldisc);
  83
  84 /**
  85  *      tty_unregister_ldisc    -       unload a line discipline
  86  *      @disc: ldisc number
  87  *      @new_ldisc: pointer to the ldisc object
  88  *
  89  *      Remove a line discipline from the kernel providing it is not
  90  *      currently in use.
  91  *
  92  *      Locking:
  93  *              takes tty_ldisc_lock to guard against ldisc races
  94  */
  95
  96 int tty_unregister_ldisc(int disc)
  97 {
  98         unsigned long flags;
  99         int ret = 0;
 100
 101         if (disc < N_TTY || disc >= NR_LDISCS)
 102                 return -EINVAL;
 103
 104         spin_lock_irqsave(&tty_ldisc_lock, flags);
 105         if (tty_ldiscs[disc]->refcount)
 106                 ret = -EBUSY;
 107         else
 108                 tty_ldiscs[disc] = NULL;
 109         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 110
 111         return ret;
 112 }
 113 EXPORT_SYMBOL(tty_unregister_ldisc);
 114
 115
 116 /**
 117  *      tty_ldisc_try_get       -       try and reference an ldisc
 118  *      @disc: ldisc number
 119  *      @ld: tty ldisc structure to complete
 120  *
 121  *      Attempt to open and lock a line discipline into place. Return
 122  *      the line discipline refcounted and assigned in ld. On an error
 123  *      report the error code back
 124  */
 125
 126 static int tty_ldisc_try_get(int disc, struct tty_ldisc *ld)
 127 {
 128         unsigned long flags;
 129         struct tty_ldisc_ops *ldops;
 130         int err = -EINVAL;
 131
 132         spin_lock_irqsave(&tty_ldisc_lock, flags);
 133         ld->ops = NULL;
 134         ldops = tty_ldiscs[disc];
 135         /* Check the entry is defined */
 136         if (ldops) {
 137                 /* If the module is being unloaded we can't use it */
 138                 if (!try_module_get(ldops->owner))
 139                         err = -EAGAIN;
 140                 else {
 141                         /* lock it */
 142                         ldops->refcount++;
 143                         ld->ops = ldops;
 144                         err = 0;
 145                 }
 146         }
 147         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 148         return err;
 149 }
 150
 151 /**
 152  *      tty_ldisc_get           -       take a reference to an ldisc
 153  *      @disc: ldisc number
 154  *      @ld: tty line discipline structure to use
 155  *
 156  *      Takes a reference to a line discipline. Deals with refcounts and
 157  *      module locking counts. Returns NULL if the discipline is not available.
 158  *      Returns a pointer to the discipline and bumps the ref count if it is
 159  *      available
 160  *
 161  *      Locking:
 162  *              takes tty_ldisc_lock to guard against ldisc races
 163  */
 164
 165 static int tty_ldisc_get(int disc, struct tty_ldisc *ld)
 166 {
 167         int err;
 168
 169         if (disc < N_TTY || disc >= NR_LDISCS)
 170                 return -EINVAL;
 171         err = tty_ldisc_try_get(disc, ld);
 172         if (err < 0) {
 173                 request_module("tty-ldisc-%d", disc);
 174                 err = tty_ldisc_try_get(disc, ld);
 175         }
 176         return err;
 177 }
 178
 179 /**
 180  *      tty_ldisc_put           -       drop ldisc reference
 181  *      @disc: ldisc number
 182  *
 183  *      Drop a reference to a line discipline. Manage refcounts and
 184  *      module usage counts
 185  *
 186  *      Locking:
 187  *              takes tty_ldisc_lock to guard against ldisc races
 188  */
 189
 190 static void tty_ldisc_put(struct tty_ldisc_ops *ld)
 191 {
 192         unsigned long flags;
 193         int disc = ld->num;
 194
 195         BUG_ON(disc < N_TTY || disc >= NR_LDISCS);
 196
 197         spin_lock_irqsave(&tty_ldisc_lock, flags);
 198         ld = tty_ldiscs[disc];
 199         BUG_ON(ld->refcount == 0);
 200         ld->refcount--;
 201         module_put(ld->owner);
 202         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 203 }
 204
 205 static void * tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
 206 {
 207         return (*pos < NR_LDISCS) ? pos : NULL;
 208 }
 209
 210 static void * tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
 211 {
 212         (*pos)++;
 213         return (*pos < NR_LDISCS) ? pos : NULL;
 214 }
 215
 216 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
 217 {
 218 }
 219
 220 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
 221 {
 222         int i = *(loff_t *)v;
 223         struct tty_ldisc ld;
 224
 225         if (tty_ldisc_get(i, &ld) < 0)
 226                 return 0;
 227         seq_printf(m, "%-10s %2d\n", ld.ops->name ? ld.ops->name : "???", i);
 228         tty_ldisc_put(ld.ops);
 229         return 0;
 230 }
 231
 232 static const struct seq_operations tty_ldiscs_seq_ops = {
 233         .start  = tty_ldiscs_seq_start,
 234         .next   = tty_ldiscs_seq_next,
 235         .stop   = tty_ldiscs_seq_stop,
 236         .show   = tty_ldiscs_seq_show,
 237 };
 238
 239 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
 240 {
 241         return seq_open(file, &tty_ldiscs_seq_ops);
 242 }
 243
 244 const struct file_operations tty_ldiscs_proc_fops = {
 245         .owner          = THIS_MODULE,
 246         .open           = proc_tty_ldiscs_open,
 247         .read           = seq_read,
 248         .llseek         = seq_lseek,
 249         .release        = seq_release,
 250 };
 251
 252 /**
 253  *      tty_ldisc_assign        -       set ldisc on a tty
 254  *      @tty: tty to assign
 255  *      @ld: line discipline
 256  *
 257  *      Install an instance of a line discipline into a tty structure. The
 258  *      ldisc must have a reference count above zero to ensure it remains/
 259  *      The tty instance refcount starts at zero.
 260  *
 261  *      Locking:
 262  *              Caller must hold references
 263  */
 264
 265 static void tty_ldisc_assign(struct tty_struct *tty, struct tty_ldisc *ld)
 266 {
 267         ld->refcount = 0;
 268         tty->ldisc = *ld;
 269 }
 270
 271 /**
 272  *      tty_ldisc_try           -       internal helper
 273  *      @tty: the tty
 274  *
 275  *      Make a single attempt to grab and bump the refcount on
 276  *      the tty ldisc. Return 0 on failure or 1 on success. This is
 277  *      used to implement both the waiting and non waiting versions
 278  *      of tty_ldisc_ref
 279  *
 280  *      Locking: takes tty_ldisc_lock
 281  */
 282
 283 static int tty_ldisc_try(struct tty_struct *tty)
 284 {
 285         unsigned long flags;
 286         struct tty_ldisc *ld;
 287         int ret = 0;
 288
 289         spin_lock_irqsave(&tty_ldisc_lock, flags);
 290         ld = &tty->ldisc;
 291         if (test_bit(TTY_LDISC, &tty->flags)) {
 292                 ld->refcount++;
 293                 ret = 1;
 294         }
 295         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 296         return ret;
 297 }
 298
 299 /**
 300  *      tty_ldisc_ref_wait      -       wait for the tty ldisc
 301  *      @tty: tty device
 302  *
 303  *      Dereference the line discipline for the terminal and take a
 304  *      reference to it. If the line discipline is in flux then
 305  *      wait patiently until it changes.
 306  *
 307  *      Note: Must not be called from an IRQ/timer context. The caller
 308  *      must also be careful not to hold other locks that will deadlock
 309  *      against a discipline change, such as an existing ldisc reference
 310  *      (which we check for)
 311  *
 312  *      Locking: call functions take tty_ldisc_lock
 313  */
 314
 315 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
 316 {
 317         /* wait_event is a macro */
 318         wait_event(tty_ldisc_wait, tty_ldisc_try(tty));
 319         if (tty->ldisc.refcount == 0)
 320                 printk(KERN_ERR "tty_ldisc_ref_wait\n");
 321         return &tty->ldisc;
 322 }
 323
 324 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
 325
 326 /**
 327  *      tty_ldisc_ref           -       get the tty ldisc
 328  *      @tty: tty device
 329  *
 330  *      Dereference the line discipline for the terminal and take a
 331  *      reference to it. If the line discipline is in flux then
 332  *      return NULL. Can be called from IRQ and timer functions.
 333  *
 334  *      Locking: called functions take tty_ldisc_lock
 335  */
 336
 337 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
 338 {
 339         if (tty_ldisc_try(tty))
 340                 return &tty->ldisc;
 341         return NULL;
 342 }
 343
 344 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
 345
 346 /**
 347  *      tty_ldisc_deref         -       free a tty ldisc reference
 348  *      @ld: reference to free up
 349  *
 350  *      Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
 351  *      be called in IRQ context.
 352  *
 353  *      Locking: takes tty_ldisc_lock
 354  */
 355
 356 void tty_ldisc_deref(struct tty_ldisc *ld)
 357 {
 358         unsigned long flags;
 359
 360         BUG_ON(ld == NULL);
 361
 362         spin_lock_irqsave(&tty_ldisc_lock, flags);
 363         if (ld->refcount == 0)
 364                 printk(KERN_ERR "tty_ldisc_deref: no references.\n");
 365         else
 366                 ld->refcount--;
 367         if (ld->refcount == 0)
 368                 wake_up(&tty_ldisc_wait);
 369         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 370 }
 371
 372 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
 373
 374 /**
 375  *      tty_ldisc_enable        -       allow ldisc use
 376  *      @tty: terminal to activate ldisc on
 377  *
 378  *      Set the TTY_LDISC flag when the line discipline can be called
 379  *      again. Do necessary wakeups for existing sleepers.
 380  *
 381  *      Note: nobody should set this bit except via this function. Clearing
 382  *      directly is allowed.
 383  */
 384
 385 void tty_ldisc_enable(struct tty_struct *tty)
 386 {
 387         set_bit(TTY_LDISC, &tty->flags);
 388         wake_up(&tty_ldisc_wait);
 389 }
 390
 391 /**
 392  *      tty_set_termios_ldisc           -       set ldisc field
 393  *      @tty: tty structure
 394  *      @num: line discipline number
 395  *
 396  *      This is probably overkill for real world processors but
 397  *      they are not on hot paths so a little discipline won't do
 398  *      any harm.
 399  *
 400  *      Locking: takes termios_mutex
 401  */
 402
 403 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
 404 {
 405         mutex_lock(&tty->termios_mutex);
 406         tty->termios->c_line = num;
 407         mutex_unlock(&tty->termios_mutex);
 408 }
 409
 410
 411 /**
 412  *      tty_ldisc_restore       -       helper for tty ldisc change
 413  *      @tty: tty to recover
 414  *      @old: previous ldisc
 415  *
 416  *      Restore the previous line discipline or N_TTY when a line discipline
 417  *      change fails due to an open error
 418  */
 419
 420 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
 421 {
 422         char buf[64];
 423         struct tty_ldisc new_ldisc;
 424
 425         /* There is an outstanding reference here so this is safe */
 426         tty_ldisc_get(old->ops->num, old);
 427         tty_ldisc_assign(tty, old);
 428         tty_set_termios_ldisc(tty, old->ops->num);
 429         if (old->ops->open && (old->ops->open(tty) < 0)) {
 430                 tty_ldisc_put(old->ops);
 431                 /* This driver is always present */
 432                 if (tty_ldisc_get(N_TTY, &new_ldisc) < 0)
 433                         panic("n_tty: get");
 434                 tty_ldisc_assign(tty, &new_ldisc);
 435                 tty_set_termios_ldisc(tty, N_TTY);
 436                 if (new_ldisc.ops->open) {
 437                         int r = new_ldisc.ops->open(tty);
 438                                 if (r < 0)
 439                                 panic("Couldn't open N_TTY ldisc for "
 440                                       "%s --- error %d.",
 441                                       tty_name(tty, buf), r);
 442                 }
 443         }
 444 }
 445
 446 /**
 447  *      tty_set_ldisc           -       set line discipline
 448  *      @tty: the terminal to set
 449  *      @ldisc: the line discipline
 450  *
 451  *      Set the discipline of a tty line. Must be called from a process
 452  *      context.
 453  *
 454  *      Locking: takes tty_ldisc_lock.
 455  *               called functions take termios_mutex
 456  */
 457
 458 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
 459 {
 460         int retval;
 461         struct tty_ldisc o_ldisc, new_ldisc;
 462         int work;
 463         unsigned long flags;
 464         struct tty_struct *o_tty;
 465
 466 restart:
 467         /* This is a bit ugly for now but means we can break the 'ldisc
 468            is part of the tty struct' assumption later */
 469         retval = tty_ldisc_get(ldisc, &new_ldisc);
 470         if (retval)
 471                 return retval;
 472
 473         /*
 474          *      Problem: What do we do if this blocks ?
 475          */
 476
 477         tty_wait_until_sent(tty, 0);
 478
 479         if (tty->ldisc.ops->num == ldisc) {
 480                 tty_ldisc_put(new_ldisc.ops);
 481                 return 0;
 482         }
 483
 484         /*
 485          *      No more input please, we are switching. The new ldisc
 486          *      will update this value in the ldisc open function
 487          */
 488
 489         tty->receive_room = 0;
 490
 491         o_ldisc = tty->ldisc;
 492         o_tty = tty->link;
 493
 494         /*
 495          *      Make sure we don't change while someone holds a
 496          *      reference to the line discipline. The TTY_LDISC bit
 497          *      prevents anyone taking a reference once it is clear.
 498          *      We need the lock to avoid racing reference takers.
 499          */
 500
 501         spin_lock_irqsave(&tty_ldisc_lock, flags);
 502         if (tty->ldisc.refcount || (o_tty && o_tty->ldisc.refcount)) {
 503                 if (tty->ldisc.refcount) {
 504                         /* Free the new ldisc we grabbed. Must drop the lock
 505                            first. */
 506                         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 507                         tty_ldisc_put(o_ldisc.ops);
 508                         /*
 509                          * There are several reasons we may be busy, including
 510                          * random momentary I/O traffic. We must therefore
 511                          * retry. We could distinguish between blocking ops
 512                          * and retries if we made tty_ldisc_wait() smarter.
 513                          * That is up for discussion.
 514                          */
 515                         if (wait_event_interruptible(tty_ldisc_wait, tty->ldisc.refcount == 0) < 0)
 516                                 return -ERESTARTSYS;
 517                         goto restart;
 518                 }
 519                 if (o_tty && o_tty->ldisc.refcount) {
 520                         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 521                         tty_ldisc_put(o_tty->ldisc.ops);
 522                         if (wait_event_interruptible(tty_ldisc_wait, o_tty->ldisc.refcount == 0) < 0)
 523                                 return -ERESTARTSYS;
 524                         goto restart;
 525                 }
 526         }
 527         /*
 528          *      If the TTY_LDISC bit is set, then we are racing against
 529          *      another ldisc change
 530          */
 531         if (!test_bit(TTY_LDISC, &tty->flags)) {
 532                 struct tty_ldisc *ld;
 533                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 534                 tty_ldisc_put(new_ldisc.ops);
 535                 ld = tty_ldisc_ref_wait(tty);
 536                 tty_ldisc_deref(ld);
 537                 goto restart;
 538         }
 539
 540         clear_bit(TTY_LDISC, &tty->flags);
 541         if (o_tty)
 542                 clear_bit(TTY_LDISC, &o_tty->flags);
 543         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 544
 545         /*
 546          *      From this point on we know nobody has an ldisc
 547          *      usage reference, nor can they obtain one until
 548          *      we say so later on.
 549          */
 550
 551         work = cancel_delayed_work(&tty->buf.work);
 552         /*
 553          * Wait for ->hangup_work and ->buf.work handlers to terminate
 554          * MUST NOT hold locks here.
 555          */
 556         flush_scheduled_work();
 557         /* Shutdown the current discipline. */
 558         if (o_ldisc.ops->close)
 559                 (o_ldisc.ops->close)(tty);
 560
 561         /* Now set up the new line discipline. */
 562         tty_ldisc_assign(tty, &new_ldisc);
 563         tty_set_termios_ldisc(tty, ldisc);
 564         if (new_ldisc.ops->open)
 565                 retval = (new_ldisc.ops->open)(tty);
 566         if (retval < 0) {
 567                 tty_ldisc_put(new_ldisc.ops);
 568                 tty_ldisc_restore(tty, &o_ldisc);
 569         }
 570         /* At this point we hold a reference to the new ldisc and a
 571            a reference to the old ldisc. If we ended up flipping back
 572            to the existing ldisc we have two references to it */
 573
 574         if (tty->ldisc.ops->num != o_ldisc.ops->num && tty->ops->set_ldisc)
 575                 tty->ops->set_ldisc(tty);
 576
 577         tty_ldisc_put(o_ldisc.ops);
 578
 579         /*
 580          *      Allow ldisc referencing to occur as soon as the driver
 581          *      ldisc callback completes.
 582          */
 583
 584         tty_ldisc_enable(tty);
 585         if (o_tty)
 586                 tty_ldisc_enable(o_tty);
 587
 588         /* Restart it in case no characters kick it off. Safe if
 589            already running */
 590         if (work)
 591                 schedule_delayed_work(&tty->buf.work, 1);
 592         return retval;
 593 }
 594
 595
 596 /**
 597  *      tty_ldisc_setup                 -       open line discipline
 598  *      @tty: tty being shut down
 599  *      @o_tty: pair tty for pty/tty pairs
 600  *
 601  *      Called during the initial open of a tty/pty pair in order to set up the
 602  *      line discplines and bind them to the tty.
 603  */
 604
 605 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
 606 {
 607         struct tty_ldisc *ld = &tty->ldisc;
 608         int retval;
 609
 610         if (ld->ops->open) {
 611                 retval = (ld->ops->open)(tty);
 612                 if (retval)
 613                         return retval;
 614         }
 615         if (o_tty && o_tty->ldisc.ops->open) {
 616                 retval = (o_tty->ldisc.ops->open)(o_tty);
 617                 if (retval) {
 618                         if (ld->ops->close)
 619                                 (ld->ops->close)(tty);
 620                         return retval;
 621                 }
 622                 tty_ldisc_enable(o_tty);
 623         }
 624         tty_ldisc_enable(tty);
 625         return 0;
 626 }
 627
 628 /**
 629  *      tty_ldisc_release               -       release line discipline
 630  *      @tty: tty being shut down
 631  *      @o_tty: pair tty for pty/tty pairs
 632  *
 633  *      Called during the final close of a tty/pty pair in order to shut down the
 634  *      line discpline layer.
 635  */
 636
 637 void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
 638 {
 639         unsigned long flags;
 640         struct tty_ldisc ld;
 641         /*
 642          * Prevent flush_to_ldisc() from rescheduling the work for later.  Then
 643          * kill any delayed work. As this is the final close it does not
 644          * race with the set_ldisc code path.
 645          */
 646         clear_bit(TTY_LDISC, &tty->flags);
 647         cancel_delayed_work(&tty->buf.work);
 648
 649         /*
 650          * Wait for ->hangup_work and ->buf.work handlers to terminate
 651          */
 652
 653         flush_scheduled_work();
 654
 655         /*
 656          * Wait for any short term users (we know they are just driver
 657          * side waiters as the file is closing so user count on the file
 658          * side is zero.
 659          */
 660         spin_lock_irqsave(&tty_ldisc_lock, flags);
 661         while (tty->ldisc.refcount) {
 662                 spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 663                 wait_event(tty_ldisc_wait, tty->ldisc.refcount == 0);
 664                 spin_lock_irqsave(&tty_ldisc_lock, flags);
 665         }
 666         spin_unlock_irqrestore(&tty_ldisc_lock, flags);
 667         /*
 668          * Shutdown the current line discipline, and reset it to N_TTY.
 669          *
 670          * FIXME: this MUST get fixed for the new reflocking
 671          */
 672         if (tty->ldisc.ops->close)
 673                 (tty->ldisc.ops->close)(tty);
 674         tty_ldisc_put(tty->ldisc.ops);
 675
 676         /*
 677          *      Switch the line discipline back
 678          */
 679         WARN_ON(tty_ldisc_get(N_TTY, &ld));
 680         tty_ldisc_assign(tty, &ld);
 681         tty_set_termios_ldisc(tty, N_TTY);
 682         if (o_tty) {
 683                 /* FIXME: could o_tty be in setldisc here ? */
 684                 clear_bit(TTY_LDISC, &o_tty->flags);
 685                 if (o_tty->ldisc.ops->close)
 686                         (o_tty->ldisc.ops->close)(o_tty);
 687                 tty_ldisc_put(o_tty->ldisc.ops);
 688                 WARN_ON(tty_ldisc_get(N_TTY, &ld));
 689                 tty_ldisc_assign(o_tty, &ld);
 690                 tty_set_termios_ldisc(o_tty, N_TTY);
 691         }
 692 }
 693
 694 /**
 695  *      tty_ldisc_init          -       ldisc setup for new tty
 696  *      @tty: tty being allocated
 697  *
 698  *      Set up the line discipline objects for a newly allocated tty. Note that
 699  *      the tty structure is not completely set up when this call is made.
 700  */
 701
 702 void tty_ldisc_init(struct tty_struct *tty)
 703 {
 704         struct tty_ldisc ld;
 705         if (tty_ldisc_get(N_TTY, &ld) < 0)
 706                 panic("n_tty: init_tty");
 707         tty_ldisc_assign(tty, &ld);
 708 }
 709
 710 void tty_ldisc_begin(void)
 711 {
 712         /* Setup the default TTY line discipline. */
 713         (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
 714 }