drivers/tty/tty_ldisc.c

   1 #include <linux/types.h>
   2 #include <linux/errno.h>
   3 #include <linux/kmod.h>
   4 #include <linux/sched.h>
   5 #include <linux/interrupt.h>
   6 #include <linux/tty.h>
   7 #include <linux/tty_driver.h>
   8 #include <linux/file.h>
   9 #include <linux/mm.h>
  10 #include <linux/string.h>
  11 #include <linux/slab.h>
  12 #include <linux/poll.h>
  13 #include <linux/proc_fs.h>
  14 #include <linux/module.h>
  15 #include <linux/device.h>
  16 #include <linux/wait.h>
  17 #include <linux/bitops.h>
  18 #include <linux/seq_file.h>
  19 #include <linux/uaccess.h>
  20 #include <linux/ratelimit.h>
  21
  22 #undef LDISC_DEBUG_HANGUP
  23
  24 #ifdef LDISC_DEBUG_HANGUP
  25 #define tty_ldisc_debug(tty, f, args...)        tty_debug(tty, f, ##args)
  26 #else
  27 #define tty_ldisc_debug(tty, f, args...)
  28 #endif
  29
  30 /* lockdep nested classes for tty->ldisc_sem */
  31 enum {
  32         LDISC_SEM_NORMAL,
  33         LDISC_SEM_OTHER,
  34 };
  35
  36
  37 /*
  38  *      This guards the refcounted line discipline lists. The lock
  39  *      must be taken with irqs off because there are hangup path
  40  *      callers who will do ldisc lookups and cannot sleep.
  41  */
  42
  43 static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock);
  44 /* Line disc dispatch table */
  45 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
  46
  47 /**
  48  *      tty_register_ldisc      -       install a line discipline
  49  *      @disc: ldisc number
  50  *      @new_ldisc: pointer to the ldisc object
  51  *
  52  *      Installs a new line discipline into the kernel. The discipline
  53  *      is set up as unreferenced and then made available to the kernel
  54  *      from this point onwards.
  55  *
  56  *      Locking:
  57  *              takes tty_ldiscs_lock to guard against ldisc races
  58  */
  59
  60 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
  61 {
  62         unsigned long flags;
  63         int ret = 0;
  64
  65         if (disc < N_TTY || disc >= NR_LDISCS)
  66                 return -EINVAL;
  67
  68         raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
  69         tty_ldiscs[disc] = new_ldisc;
  70         new_ldisc->num = disc;
  71         new_ldisc->refcount = 0;
  72         raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
  73
  74         return ret;
  75 }
  76 EXPORT_SYMBOL(tty_register_ldisc);
  77
  78 /**
  79  *      tty_unregister_ldisc    -       unload a line discipline
  80  *      @disc: ldisc number
  81  *      @new_ldisc: pointer to the ldisc object
  82  *
  83  *      Remove a line discipline from the kernel providing it is not
  84  *      currently in use.
  85  *
  86  *      Locking:
  87  *              takes tty_ldiscs_lock to guard against ldisc races
  88  */
  89
  90 int tty_unregister_ldisc(int disc)
  91 {
  92         unsigned long flags;
  93         int ret = 0;
  94
  95         if (disc < N_TTY || disc >= NR_LDISCS)
  96                 return -EINVAL;
  97
  98         raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
  99         if (tty_ldiscs[disc]->refcount)
 100                 ret = -EBUSY;
 101         else
 102                 tty_ldiscs[disc] = NULL;
 103         raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
 104
 105         return ret;
 106 }
 107 EXPORT_SYMBOL(tty_unregister_ldisc);
 108
 109 static struct tty_ldisc_ops *get_ldops(int disc)
 110 {
 111         unsigned long flags;
 112         struct tty_ldisc_ops *ldops, *ret;
 113
 114         raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
 115         ret = ERR_PTR(-EINVAL);
 116         ldops = tty_ldiscs[disc];
 117         if (ldops) {
 118                 ret = ERR_PTR(-EAGAIN);
 119                 if (try_module_get(ldops->owner)) {
 120                         ldops->refcount++;
 121                         ret = ldops;
 122                 }
 123         }
 124         raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
 125         return ret;
 126 }
 127
 128 static void put_ldops(struct tty_ldisc_ops *ldops)
 129 {
 130         unsigned long flags;
 131
 132         raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
 133         ldops->refcount--;
 134         module_put(ldops->owner);
 135         raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
 136 }
 137
 138 /**
 139  *      tty_ldisc_get           -       take a reference to an ldisc
 140  *      @disc: ldisc number
 141  *
 142  *      Takes a reference to a line discipline. Deals with refcounts and
 143  *      module locking counts.
 144  *
 145  *      Returns: -EINVAL if the discipline index is not [N_TTY..NR_LDISCS] or
 146  *                       if the discipline is not registered
 147  *               -EAGAIN if request_module() failed to load or register the
 148  *                       the discipline
 149  *               -ENOMEM if allocation failure
 150  *
 151  *               Otherwise, returns a pointer to the discipline and bumps the
 152  *               ref count
 153  *
 154  *      Locking:
 155  *              takes tty_ldiscs_lock to guard against ldisc races
 156  */
 157
 158 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
 159 {
 160         struct tty_ldisc *ld;
 161         struct tty_ldisc_ops *ldops;
 162
 163         if (disc < N_TTY || disc >= NR_LDISCS)
 164                 return ERR_PTR(-EINVAL);
 165
 166         /*
 167          * Get the ldisc ops - we may need to request them to be loaded
 168          * dynamically and try again.
 169          */
 170         ldops = get_ldops(disc);
 171         if (IS_ERR(ldops)) {
 172                 request_module("tty-ldisc-%d", disc);
 173                 ldops = get_ldops(disc);
 174                 if (IS_ERR(ldops))
 175                         return ERR_CAST(ldops);
 176         }
 177
 178         ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
 179         if (ld == NULL) {
 180                 put_ldops(ldops);
 181                 return ERR_PTR(-ENOMEM);
 182         }
 183
 184         ld->ops = ldops;
 185         ld->tty = tty;
 186
 187         return ld;
 188 }
 189
 190 /**
 191  *      tty_ldisc_put           -       release the ldisc
 192  *
 193  *      Complement of tty_ldisc_get().
 194  */
 195 static void tty_ldisc_put(struct tty_ldisc *ld)
 196 {
 197         if (WARN_ON_ONCE(!ld))
 198                 return;
 199
 200         put_ldops(ld->ops);
 201         kfree(ld);
 202 }
 203
 204 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
 205 {
 206         return (*pos < NR_LDISCS) ? pos : NULL;
 207 }
 208
 209 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
 210 {
 211         (*pos)++;
 212         return (*pos < NR_LDISCS) ? pos : NULL;
 213 }
 214
 215 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
 216 {
 217 }
 218
 219 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
 220 {
 221         int i = *(loff_t *)v;
 222         struct tty_ldisc_ops *ldops;
 223
 224         ldops = get_ldops(i);
 225         if (IS_ERR(ldops))
 226                 return 0;
 227         seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
 228         put_ldops(ldops);
 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_ref_wait      -       wait for the tty ldisc
 254  *      @tty: tty device
 255  *
 256  *      Dereference the line discipline for the terminal and take a
 257  *      reference to it. If the line discipline is in flux then
 258  *      wait patiently until it changes.
 259  *
 260  *      Returns: NULL if the tty has been hungup and not re-opened with
 261  *               a new file descriptor, otherwise valid ldisc reference
 262  *
 263  *      Note: Must not be called from an IRQ/timer context. The caller
 264  *      must also be careful not to hold other locks that will deadlock
 265  *      against a discipline change, such as an existing ldisc reference
 266  *      (which we check for)
 267  *
 268  *      Note: a file_operations routine (read/poll/write) should use this
 269  *      function to wait for any ldisc lifetime events to finish.
 270  */
 271
 272 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
 273 {
 274         struct tty_ldisc *ld;
 275
 276         ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
 277         ld = tty->ldisc;
 278         if (!ld)
 279                 ldsem_up_read(&tty->ldisc_sem);
 280         return ld;
 281 }
 282 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
 283
 284 /**
 285  *      tty_ldisc_ref           -       get the tty ldisc
 286  *      @tty: tty device
 287  *
 288  *      Dereference the line discipline for the terminal and take a
 289  *      reference to it. If the line discipline is in flux then
 290  *      return NULL. Can be called from IRQ and timer functions.
 291  */
 292
 293 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
 294 {
 295         struct tty_ldisc *ld = NULL;
 296
 297         if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
 298                 ld = tty->ldisc;
 299                 if (!ld)
 300                         ldsem_up_read(&tty->ldisc_sem);
 301         }
 302         return ld;
 303 }
 304 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
 305
 306 /**
 307  *      tty_ldisc_deref         -       free a tty ldisc reference
 308  *      @ld: reference to free up
 309  *
 310  *      Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
 311  *      be called in IRQ context.
 312  */
 313
 314 void tty_ldisc_deref(struct tty_ldisc *ld)
 315 {
 316         ldsem_up_read(&ld->tty->ldisc_sem);
 317 }
 318 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
 319
 320
 321 static inline int
 322 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
 323 {
 324         return ldsem_down_write(&tty->ldisc_sem, timeout);
 325 }
 326
 327 static inline int
 328 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
 329 {
 330         return ldsem_down_write_nested(&tty->ldisc_sem,
 331                                        LDISC_SEM_OTHER, timeout);
 332 }
 333
 334 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
 335 {
 336         ldsem_up_write(&tty->ldisc_sem);
 337 }
 338
 339 static int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
 340 {
 341         int ret;
 342
 343         ret = __tty_ldisc_lock(tty, timeout);
 344         if (!ret)
 345                 return -EBUSY;
 346         set_bit(TTY_LDISC_HALTED, &tty->flags);
 347         return 0;
 348 }
 349
 350 static void tty_ldisc_unlock(struct tty_struct *tty)
 351 {
 352         clear_bit(TTY_LDISC_HALTED, &tty->flags);
 353         __tty_ldisc_unlock(tty);
 354 }
 355
 356 static int
 357 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
 358                             unsigned long timeout)
 359 {
 360         int ret;
 361
 362         if (tty < tty2) {
 363                 ret = __tty_ldisc_lock(tty, timeout);
 364                 if (ret) {
 365                         ret = __tty_ldisc_lock_nested(tty2, timeout);
 366                         if (!ret)
 367                                 __tty_ldisc_unlock(tty);
 368                 }
 369         } else {
 370                 /* if this is possible, it has lots of implications */
 371                 WARN_ON_ONCE(tty == tty2);
 372                 if (tty2 && tty != tty2) {
 373                         ret = __tty_ldisc_lock(tty2, timeout);
 374                         if (ret) {
 375                                 ret = __tty_ldisc_lock_nested(tty, timeout);
 376                                 if (!ret)
 377                                         __tty_ldisc_unlock(tty2);
 378                         }
 379                 } else
 380                         ret = __tty_ldisc_lock(tty, timeout);
 381         }
 382
 383         if (!ret)
 384                 return -EBUSY;
 385
 386         set_bit(TTY_LDISC_HALTED, &tty->flags);
 387         if (tty2)
 388                 set_bit(TTY_LDISC_HALTED, &tty2->flags);
 389         return 0;
 390 }
 391
 392 static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
 393 {
 394         tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
 395 }
 396
 397 static void tty_ldisc_unlock_pair(struct tty_struct *tty,
 398                                   struct tty_struct *tty2)
 399 {
 400         __tty_ldisc_unlock(tty);
 401         if (tty2)
 402                 __tty_ldisc_unlock(tty2);
 403 }
 404
 405 /**
 406  *      tty_ldisc_flush -       flush line discipline queue
 407  *      @tty: tty
 408  *
 409  *      Flush the line discipline queue (if any) and the tty flip buffers
 410  *      for this tty.
 411  */
 412
 413 void tty_ldisc_flush(struct tty_struct *tty)
 414 {
 415         struct tty_ldisc *ld = tty_ldisc_ref(tty);
 416
 417         tty_buffer_flush(tty, ld);
 418         if (ld)
 419                 tty_ldisc_deref(ld);
 420 }
 421 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
 422
 423 /**
 424  *      tty_set_termios_ldisc           -       set ldisc field
 425  *      @tty: tty structure
 426  *      @disc: line discipline number
 427  *
 428  *      This is probably overkill for real world processors but
 429  *      they are not on hot paths so a little discipline won't do
 430  *      any harm.
 431  *
 432  *      The line discipline-related tty_struct fields are reset to
 433  *      prevent the ldisc driver from re-using stale information for
 434  *      the new ldisc instance.
 435  *
 436  *      Locking: takes termios_rwsem
 437  */
 438
 439 static void tty_set_termios_ldisc(struct tty_struct *tty, int disc)
 440 {
 441         down_write(&tty->termios_rwsem);
 442         tty->termios.c_line = disc;
 443         up_write(&tty->termios_rwsem);
 444
 445         tty->disc_data = NULL;
 446         tty->receive_room = 0;
 447 }
 448
 449 /**
 450  *      tty_ldisc_open          -       open a line discipline
 451  *      @tty: tty we are opening the ldisc on
 452  *      @ld: discipline to open
 453  *
 454  *      A helper opening method. Also a convenient debugging and check
 455  *      point.
 456  *
 457  *      Locking: always called with BTM already held.
 458  */
 459
 460 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
 461 {
 462         WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
 463         if (ld->ops->open) {
 464                 int ret;
 465                 /* BTM here locks versus a hangup event */
 466                 ret = ld->ops->open(tty);
 467                 if (ret)
 468                         clear_bit(TTY_LDISC_OPEN, &tty->flags);
 469
 470                 tty_ldisc_debug(tty, "%p: opened\n", ld);
 471                 return ret;
 472         }
 473         return 0;
 474 }
 475
 476 /**
 477  *      tty_ldisc_close         -       close a line discipline
 478  *      @tty: tty we are opening the ldisc on
 479  *      @ld: discipline to close
 480  *
 481  *      A helper close method. Also a convenient debugging and check
 482  *      point.
 483  */
 484
 485 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
 486 {
 487         WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
 488         clear_bit(TTY_LDISC_OPEN, &tty->flags);
 489         if (ld->ops->close)
 490                 ld->ops->close(tty);
 491         tty_ldisc_debug(tty, "%p: closed\n", ld);
 492 }
 493
 494 /**
 495  *      tty_set_ldisc           -       set line discipline
 496  *      @tty: the terminal to set
 497  *      @ldisc: the line discipline
 498  *
 499  *      Set the discipline of a tty line. Must be called from a process
 500  *      context. The ldisc change logic has to protect itself against any
 501  *      overlapping ldisc change (including on the other end of pty pairs),
 502  *      the close of one side of a tty/pty pair, and eventually hangup.
 503  */
 504
 505 int tty_set_ldisc(struct tty_struct *tty, int disc)
 506 {
 507         int retval, old_disc;
 508
 509         tty_lock(tty);
 510         retval = tty_ldisc_lock(tty, 5 * HZ);
 511         if (retval)
 512                 goto err;
 513
 514         if (!tty->ldisc) {
 515                 retval = -EIO;
 516                 goto out;
 517         }
 518
 519         /* Check the no-op case */
 520         old_disc = tty->ldisc->ops->num;
 521         if (old_disc == disc)
 522                 goto out;
 523
 524         if (test_bit(TTY_HUPPED, &tty->flags)) {
 525                 /* We were raced by hangup */
 526                 retval = -EIO;
 527                 goto out;
 528         }
 529
 530         retval = tty_ldisc_reinit(tty, disc);
 531         if (retval < 0) {
 532                 /* Back to the old one or N_TTY if we can't */
 533                 if (tty_ldisc_reinit(tty, old_disc) < 0) {
 534                         pr_err("tty: TIOCSETD failed, reinitializing N_TTY\n");
 535                         if (tty_ldisc_reinit(tty, N_TTY) < 0) {
 536                                 /* At this point we have tty->ldisc == NULL. */
 537                                 pr_err("tty: reinitializing N_TTY failed\n");
 538                         }
 539                 }
 540         }
 541
 542         if (tty->ldisc && tty->ldisc->ops->num != old_disc &&
 543             tty->ops->set_ldisc) {
 544                 down_read(&tty->termios_rwsem);
 545                 tty->ops->set_ldisc(tty);
 546                 up_read(&tty->termios_rwsem);
 547         }
 548
 549 out:
 550         tty_ldisc_unlock(tty);
 551
 552         /* Restart the work queue in case no characters kick it off. Safe if
 553            already running */
 554         tty_buffer_restart_work(tty->port);
 555 err:
 556         tty_unlock(tty);
 557         return retval;
 558 }
 559
 560 /**
 561  *      tty_ldisc_kill  -       teardown ldisc
 562  *      @tty: tty being released
 563  *
 564  *      Perform final close of the ldisc and reset tty->ldisc
 565  */
 566 static void tty_ldisc_kill(struct tty_struct *tty)
 567 {
 568         if (!tty->ldisc)
 569                 return;
 570         /*
 571          * Now kill off the ldisc
 572          */
 573         tty_ldisc_close(tty, tty->ldisc);
 574         tty_ldisc_put(tty->ldisc);
 575         /* Force an oops if we mess this up */
 576         tty->ldisc = NULL;
 577 }
 578
 579 /**
 580  *      tty_reset_termios       -       reset terminal state
 581  *      @tty: tty to reset
 582  *
 583  *      Restore a terminal to the driver default state.
 584  */
 585
 586 static void tty_reset_termios(struct tty_struct *tty)
 587 {
 588         down_write(&tty->termios_rwsem);
 589         tty->termios = tty->driver->init_termios;
 590         tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
 591         tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
 592         up_write(&tty->termios_rwsem);
 593 }
 594
 595
 596 /**
 597  *      tty_ldisc_reinit        -       reinitialise the tty ldisc
 598  *      @tty: tty to reinit
 599  *      @disc: line discipline to reinitialize
 600  *
 601  *      Completely reinitialize the line discipline state, by closing the
 602  *      current instance, if there is one, and opening a new instance. If
 603  *      an error occurs opening the new non-N_TTY instance, the instance
 604  *      is dropped and tty->ldisc reset to NULL. The caller can then retry
 605  *      with N_TTY instead.
 606  *
 607  *      Returns 0 if successful, otherwise error code < 0
 608  */
 609
 610 int tty_ldisc_reinit(struct tty_struct *tty, int disc)
 611 {
 612         struct tty_ldisc *ld;
 613         int retval;
 614
 615         ld = tty_ldisc_get(tty, disc);
 616         if (IS_ERR(ld))
 617                 return PTR_ERR(ld);
 618
 619         if (tty->ldisc) {
 620                 tty_ldisc_close(tty, tty->ldisc);
 621                 tty_ldisc_put(tty->ldisc);
 622         }
 623
 624         /* switch the line discipline */
 625         tty->ldisc = ld;
 626         tty_set_termios_ldisc(tty, disc);
 627         retval = tty_ldisc_open(tty, tty->ldisc);
 628         if (retval) {
 629                 tty_ldisc_put(tty->ldisc);
 630                 tty->ldisc = NULL;
 631         }
 632         return retval;
 633 }
 634
 635 /**
 636  *      tty_ldisc_hangup                -       hangup ldisc reset
 637  *      @tty: tty being hung up
 638  *
 639  *      Some tty devices reset their termios when they receive a hangup
 640  *      event. In that situation we must also switch back to N_TTY properly
 641  *      before we reset the termios data.
 642  *
 643  *      Locking: We can take the ldisc mutex as the rest of the code is
 644  *      careful to allow for this.
 645  *
 646  *      In the pty pair case this occurs in the close() path of the
 647  *      tty itself so we must be careful about locking rules.
 648  */
 649
 650 void tty_ldisc_hangup(struct tty_struct *tty, bool reinit)
 651 {
 652         struct tty_ldisc *ld;
 653
 654         tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
 655
 656         ld = tty_ldisc_ref(tty);
 657         if (ld != NULL) {
 658                 if (ld->ops->flush_buffer)
 659                         ld->ops->flush_buffer(tty);
 660                 tty_driver_flush_buffer(tty);
 661                 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
 662                     ld->ops->write_wakeup)
 663                         ld->ops->write_wakeup(tty);
 664                 if (ld->ops->hangup)
 665                         ld->ops->hangup(tty);
 666                 tty_ldisc_deref(ld);
 667         }
 668
 669         wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
 670         wake_up_interruptible_poll(&tty->read_wait, POLLIN);
 671
 672         /*
 673          * Shutdown the current line discipline, and reset it to
 674          * N_TTY if need be.
 675          *
 676          * Avoid racing set_ldisc or tty_ldisc_release
 677          */
 678         tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
 679
 680         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
 681                 tty_reset_termios(tty);
 682
 683         if (tty->ldisc) {
 684                 if (reinit) {
 685                         if (tty_ldisc_reinit(tty, tty->termios.c_line) < 0)
 686                                 tty_ldisc_reinit(tty, N_TTY);
 687                 } else
 688                         tty_ldisc_kill(tty);
 689         }
 690         tty_ldisc_unlock(tty);
 691 }
 692
 693 /**
 694  *      tty_ldisc_setup                 -       open line discipline
 695  *      @tty: tty being shut down
 696  *      @o_tty: pair tty for pty/tty pairs
 697  *
 698  *      Called during the initial open of a tty/pty pair in order to set up the
 699  *      line disciplines and bind them to the tty. This has no locking issues
 700  *      as the device isn't yet active.
 701  */
 702
 703 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
 704 {
 705         int retval = tty_ldisc_open(tty, tty->ldisc);
 706         if (retval)
 707                 return retval;
 708
 709         if (o_tty) {
 710                 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
 711                 if (retval) {
 712                         tty_ldisc_close(tty, tty->ldisc);
 713                         return retval;
 714                 }
 715         }
 716         return 0;
 717 }
 718
 719 /**
 720  *      tty_ldisc_release               -       release line discipline
 721  *      @tty: tty being shut down (or one end of pty pair)
 722  *
 723  *      Called during the final close of a tty or a pty pair in order to shut
 724  *      down the line discpline layer. On exit, each tty's ldisc is NULL.
 725  */
 726
 727 void tty_ldisc_release(struct tty_struct *tty)
 728 {
 729         struct tty_struct *o_tty = tty->link;
 730
 731         /*
 732          * Shutdown this line discipline. As this is the final close,
 733          * it does not race with the set_ldisc code path.
 734          */
 735
 736         tty_ldisc_lock_pair(tty, o_tty);
 737         tty_ldisc_kill(tty);
 738         if (o_tty)
 739                 tty_ldisc_kill(o_tty);
 740         tty_ldisc_unlock_pair(tty, o_tty);
 741
 742         /* And the memory resources remaining (buffers, termios) will be
 743            disposed of when the kref hits zero */
 744
 745         tty_ldisc_debug(tty, "released\n");
 746 }
 747
 748 /**
 749  *      tty_ldisc_init          -       ldisc setup for new tty
 750  *      @tty: tty being allocated
 751  *
 752  *      Set up the line discipline objects for a newly allocated tty. Note that
 753  *      the tty structure is not completely set up when this call is made.
 754  */
 755
 756 void tty_ldisc_init(struct tty_struct *tty)
 757 {
 758         struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
 759         if (IS_ERR(ld))
 760                 panic("n_tty: init_tty");
 761         tty->ldisc = ld;
 762 }
 763
 764 /**
 765  *      tty_ldisc_deinit        -       ldisc cleanup for new tty
 766  *      @tty: tty that was allocated recently
 767  *
 768  *      The tty structure must not becompletely set up (tty_ldisc_setup) when
 769  *      this call is made.
 770  */
 771 void tty_ldisc_deinit(struct tty_struct *tty)
 772 {
 773         if (tty->ldisc)
 774                 tty_ldisc_put(tty->ldisc);
 775         tty->ldisc = NULL;
 776 }