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 #if defined(CONFIG_LDISC_AUTOLOAD)
 159         #define INITIAL_AUTOLOAD_STATE  1
 160 #else
 161         #define INITIAL_AUTOLOAD_STATE  0
 162 #endif
 163 static int tty_ldisc_autoload = INITIAL_AUTOLOAD_STATE;
 164
 165 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
 166 {
 167         struct tty_ldisc *ld;
 168         struct tty_ldisc_ops *ldops;
 169
 170         if (disc < N_TTY || disc >= NR_LDISCS)
 171                 return ERR_PTR(-EINVAL);
 172
 173         /*
 174          * Get the ldisc ops - we may need to request them to be loaded
 175          * dynamically and try again.
 176          */
 177         ldops = get_ldops(disc);
 178         if (IS_ERR(ldops)) {
 179                 if (!capable(CAP_SYS_MODULE) && !tty_ldisc_autoload)
 180                         return ERR_PTR(-EPERM);
 181                 request_module("tty-ldisc-%d", disc);
 182                 ldops = get_ldops(disc);
 183                 if (IS_ERR(ldops))
 184                         return ERR_CAST(ldops);
 185         }
 186
 187         /*
 188          * There is no way to handle allocation failure of only 16 bytes.
 189          * Let's simplify error handling and save more memory.
 190          */
 191         ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL | __GFP_NOFAIL);
 192         ld->ops = ldops;
 193         ld->tty = tty;
 194
 195         return ld;
 196 }
 197
 198 /**
 199  *      tty_ldisc_put           -       release the ldisc
 200  *
 201  *      Complement of tty_ldisc_get().
 202  */
 203 static void tty_ldisc_put(struct tty_ldisc *ld)
 204 {
 205         if (WARN_ON_ONCE(!ld))
 206                 return;
 207
 208         put_ldops(ld->ops);
 209         kfree(ld);
 210 }
 211
 212 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
 213 {
 214         return (*pos < NR_LDISCS) ? pos : NULL;
 215 }
 216
 217 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
 218 {
 219         (*pos)++;
 220         return (*pos < NR_LDISCS) ? pos : NULL;
 221 }
 222
 223 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
 224 {
 225 }
 226
 227 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
 228 {
 229         int i = *(loff_t *)v;
 230         struct tty_ldisc_ops *ldops;
 231
 232         ldops = get_ldops(i);
 233         if (IS_ERR(ldops))
 234                 return 0;
 235         seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
 236         put_ldops(ldops);
 237         return 0;
 238 }
 239
 240 static const struct seq_operations tty_ldiscs_seq_ops = {
 241         .start  = tty_ldiscs_seq_start,
 242         .next   = tty_ldiscs_seq_next,
 243         .stop   = tty_ldiscs_seq_stop,
 244         .show   = tty_ldiscs_seq_show,
 245 };
 246
 247 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
 248 {
 249         return seq_open(file, &tty_ldiscs_seq_ops);
 250 }
 251
 252 const struct file_operations tty_ldiscs_proc_fops = {
 253         .owner          = THIS_MODULE,
 254         .open           = proc_tty_ldiscs_open,
 255         .read           = seq_read,
 256         .llseek         = seq_lseek,
 257         .release        = seq_release,
 258 };
 259
 260 /**
 261  *      tty_ldisc_ref_wait      -       wait for the tty ldisc
 262  *      @tty: tty device
 263  *
 264  *      Dereference the line discipline for the terminal and take a
 265  *      reference to it. If the line discipline is in flux then
 266  *      wait patiently until it changes.
 267  *
 268  *      Returns: NULL if the tty has been hungup and not re-opened with
 269  *               a new file descriptor, otherwise valid ldisc reference
 270  *
 271  *      Note: Must not be called from an IRQ/timer context. The caller
 272  *      must also be careful not to hold other locks that will deadlock
 273  *      against a discipline change, such as an existing ldisc reference
 274  *      (which we check for)
 275  *
 276  *      Note: a file_operations routine (read/poll/write) should use this
 277  *      function to wait for any ldisc lifetime events to finish.
 278  */
 279
 280 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
 281 {
 282         struct tty_ldisc *ld;
 283
 284         ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
 285         ld = tty->ldisc;
 286         if (!ld)
 287                 ldsem_up_read(&tty->ldisc_sem);
 288         return ld;
 289 }
 290 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
 291
 292 /**
 293  *      tty_ldisc_ref           -       get the tty ldisc
 294  *      @tty: tty device
 295  *
 296  *      Dereference the line discipline for the terminal and take a
 297  *      reference to it. If the line discipline is in flux then
 298  *      return NULL. Can be called from IRQ and timer functions.
 299  */
 300
 301 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
 302 {
 303         struct tty_ldisc *ld = NULL;
 304
 305         if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
 306                 ld = tty->ldisc;
 307                 if (!ld)
 308                         ldsem_up_read(&tty->ldisc_sem);
 309         }
 310         return ld;
 311 }
 312 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
 313
 314 /**
 315  *      tty_ldisc_deref         -       free a tty ldisc reference
 316  *      @ld: reference to free up
 317  *
 318  *      Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
 319  *      be called in IRQ context.
 320  */
 321
 322 void tty_ldisc_deref(struct tty_ldisc *ld)
 323 {
 324         ldsem_up_read(&ld->tty->ldisc_sem);
 325 }
 326 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
 327
 328
 329 static inline int
 330 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
 331 {
 332         return ldsem_down_write(&tty->ldisc_sem, timeout);
 333 }
 334
 335 static inline int
 336 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
 337 {
 338         return ldsem_down_write_nested(&tty->ldisc_sem,
 339                                        LDISC_SEM_OTHER, timeout);
 340 }
 341
 342 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
 343 {
 344         ldsem_up_write(&tty->ldisc_sem);
 345 }
 346
 347 int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
 348 {
 349         int ret;
 350
 351         /* Kindly asking blocked readers to release the read side */
 352         set_bit(TTY_LDISC_CHANGING, &tty->flags);
 353         wake_up_interruptible_all(&tty->read_wait);
 354         wake_up_interruptible_all(&tty->write_wait);
 355
 356         ret = __tty_ldisc_lock(tty, timeout);
 357         if (!ret)
 358                 return -EBUSY;
 359         set_bit(TTY_LDISC_HALTED, &tty->flags);
 360         return 0;
 361 }
 362
 363 void tty_ldisc_unlock(struct tty_struct *tty)
 364 {
 365         clear_bit(TTY_LDISC_HALTED, &tty->flags);
 366         /* Can be cleared here - ldisc_unlock will wake up writers firstly */
 367         clear_bit(TTY_LDISC_CHANGING, &tty->flags);
 368         __tty_ldisc_unlock(tty);
 369 }
 370
 371 static int
 372 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
 373                             unsigned long timeout)
 374 {
 375         int ret;
 376
 377         if (tty < tty2) {
 378                 ret = __tty_ldisc_lock(tty, timeout);
 379                 if (ret) {
 380                         ret = __tty_ldisc_lock_nested(tty2, timeout);
 381                         if (!ret)
 382                                 __tty_ldisc_unlock(tty);
 383                 }
 384         } else {
 385                 /* if this is possible, it has lots of implications */
 386                 WARN_ON_ONCE(tty == tty2);
 387                 if (tty2 && tty != tty2) {
 388                         ret = __tty_ldisc_lock(tty2, timeout);
 389                         if (ret) {
 390                                 ret = __tty_ldisc_lock_nested(tty, timeout);
 391                                 if (!ret)
 392                                         __tty_ldisc_unlock(tty2);
 393                         }
 394                 } else
 395                         ret = __tty_ldisc_lock(tty, timeout);
 396         }
 397
 398         if (!ret)
 399                 return -EBUSY;
 400
 401         set_bit(TTY_LDISC_HALTED, &tty->flags);
 402         if (tty2)
 403                 set_bit(TTY_LDISC_HALTED, &tty2->flags);
 404         return 0;
 405 }
 406
 407 static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
 408 {
 409         tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
 410 }
 411
 412 static void tty_ldisc_unlock_pair(struct tty_struct *tty,
 413                                   struct tty_struct *tty2)
 414 {
 415         __tty_ldisc_unlock(tty);
 416         if (tty2)
 417                 __tty_ldisc_unlock(tty2);
 418 }
 419
 420 /**
 421  *      tty_ldisc_flush -       flush line discipline queue
 422  *      @tty: tty
 423  *
 424  *      Flush the line discipline queue (if any) and the tty flip buffers
 425  *      for this tty.
 426  */
 427
 428 void tty_ldisc_flush(struct tty_struct *tty)
 429 {
 430         struct tty_ldisc *ld = tty_ldisc_ref(tty);
 431
 432         tty_buffer_flush(tty, ld);
 433         if (ld)
 434                 tty_ldisc_deref(ld);
 435 }
 436 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
 437
 438 /**
 439  *      tty_set_termios_ldisc           -       set ldisc field
 440  *      @tty: tty structure
 441  *      @disc: line discipline number
 442  *
 443  *      This is probably overkill for real world processors but
 444  *      they are not on hot paths so a little discipline won't do
 445  *      any harm.
 446  *
 447  *      The line discipline-related tty_struct fields are reset to
 448  *      prevent the ldisc driver from re-using stale information for
 449  *      the new ldisc instance.
 450  *
 451  *      Locking: takes termios_rwsem
 452  */
 453
 454 static void tty_set_termios_ldisc(struct tty_struct *tty, int disc)
 455 {
 456         down_write(&tty->termios_rwsem);
 457         tty->termios.c_line = disc;
 458         up_write(&tty->termios_rwsem);
 459
 460         tty->disc_data = NULL;
 461         tty->receive_room = 0;
 462 }
 463
 464 /**
 465  *      tty_ldisc_open          -       open a line discipline
 466  *      @tty: tty we are opening the ldisc on
 467  *      @ld: discipline to open
 468  *
 469  *      A helper opening method. Also a convenient debugging and check
 470  *      point.
 471  *
 472  *      Locking: always called with BTM already held.
 473  */
 474
 475 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
 476 {
 477         WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
 478         if (ld->ops->open) {
 479                 int ret;
 480                 /* BTM here locks versus a hangup event */
 481                 ret = ld->ops->open(tty);
 482                 if (ret)
 483                         clear_bit(TTY_LDISC_OPEN, &tty->flags);
 484
 485                 tty_ldisc_debug(tty, "%p: opened\n", ld);
 486                 return ret;
 487         }
 488         return 0;
 489 }
 490
 491 /**
 492  *      tty_ldisc_close         -       close a line discipline
 493  *      @tty: tty we are opening the ldisc on
 494  *      @ld: discipline to close
 495  *
 496  *      A helper close method. Also a convenient debugging and check
 497  *      point.
 498  */
 499
 500 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
 501 {
 502         WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
 503         clear_bit(TTY_LDISC_OPEN, &tty->flags);
 504         if (ld->ops->close)
 505                 ld->ops->close(tty);
 506         tty_ldisc_debug(tty, "%p: closed\n", ld);
 507 }
 508
 509 /**
 510  *      tty_set_ldisc           -       set line discipline
 511  *      @tty: the terminal to set
 512  *      @ldisc: the line discipline
 513  *
 514  *      Set the discipline of a tty line. Must be called from a process
 515  *      context. The ldisc change logic has to protect itself against any
 516  *      overlapping ldisc change (including on the other end of pty pairs),
 517  *      the close of one side of a tty/pty pair, and eventually hangup.
 518  */
 519
 520 int tty_set_ldisc(struct tty_struct *tty, int disc)
 521 {
 522         int retval, old_disc;
 523
 524         tty_lock(tty);
 525         retval = tty_ldisc_lock(tty, 5 * HZ);
 526         if (retval)
 527                 goto err;
 528
 529         if (!tty->ldisc) {
 530                 retval = -EIO;
 531                 goto out;
 532         }
 533
 534         /* Check the no-op case */
 535         old_disc = tty->ldisc->ops->num;
 536         if (old_disc == disc)
 537                 goto out;
 538
 539         if (test_bit(TTY_HUPPED, &tty->flags)) {
 540                 /* We were raced by hangup */
 541                 retval = -EIO;
 542                 goto out;
 543         }
 544
 545         retval = tty_ldisc_reinit(tty, disc);
 546         if (retval < 0) {
 547                 /* Back to the old one or N_TTY if we can't */
 548                 if (tty_ldisc_reinit(tty, old_disc) < 0) {
 549                         pr_err("tty: TIOCSETD failed, reinitializing N_TTY\n");
 550                         if (tty_ldisc_reinit(tty, N_TTY) < 0) {
 551                                 /* At this point we have tty->ldisc == NULL. */
 552                                 pr_err("tty: reinitializing N_TTY failed\n");
 553                         }
 554                 }
 555         }
 556
 557         if (tty->ldisc && tty->ldisc->ops->num != old_disc &&
 558             tty->ops->set_ldisc) {
 559                 down_read(&tty->termios_rwsem);
 560                 tty->ops->set_ldisc(tty);
 561                 up_read(&tty->termios_rwsem);
 562         }
 563
 564 out:
 565         tty_ldisc_unlock(tty);
 566
 567         /* Restart the work queue in case no characters kick it off. Safe if
 568            already running */
 569         tty_buffer_restart_work(tty->port);
 570 err:
 571         tty_unlock(tty);
 572         return retval;
 573 }
 574
 575 /**
 576  *      tty_ldisc_kill  -       teardown ldisc
 577  *      @tty: tty being released
 578  *
 579  *      Perform final close of the ldisc and reset tty->ldisc
 580  */
 581 static void tty_ldisc_kill(struct tty_struct *tty)
 582 {
 583         if (!tty->ldisc)
 584                 return;
 585         /*
 586          * Now kill off the ldisc
 587          */
 588         tty_ldisc_close(tty, tty->ldisc);
 589         tty_ldisc_put(tty->ldisc);
 590         /* Force an oops if we mess this up */
 591         tty->ldisc = NULL;
 592 }
 593
 594 /**
 595  *      tty_reset_termios       -       reset terminal state
 596  *      @tty: tty to reset
 597  *
 598  *      Restore a terminal to the driver default state.
 599  */
 600
 601 static void tty_reset_termios(struct tty_struct *tty)
 602 {
 603         down_write(&tty->termios_rwsem);
 604         tty->termios = tty->driver->init_termios;
 605         tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
 606         tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
 607         up_write(&tty->termios_rwsem);
 608 }
 609
 610
 611 /**
 612  *      tty_ldisc_reinit        -       reinitialise the tty ldisc
 613  *      @tty: tty to reinit
 614  *      @disc: line discipline to reinitialize
 615  *
 616  *      Completely reinitialize the line discipline state, by closing the
 617  *      current instance, if there is one, and opening a new instance. If
 618  *      an error occurs opening the new non-N_TTY instance, the instance
 619  *      is dropped and tty->ldisc reset to NULL. The caller can then retry
 620  *      with N_TTY instead.
 621  *
 622  *      Returns 0 if successful, otherwise error code < 0
 623  */
 624
 625 int tty_ldisc_reinit(struct tty_struct *tty, int disc)
 626 {
 627         struct tty_ldisc *ld;
 628         int retval;
 629
 630         ld = tty_ldisc_get(tty, disc);
 631         if (IS_ERR(ld))
 632                 return PTR_ERR(ld);
 633
 634         if (tty->ldisc) {
 635                 tty_ldisc_close(tty, tty->ldisc);
 636                 tty_ldisc_put(tty->ldisc);
 637         }
 638
 639         /* switch the line discipline */
 640         tty->ldisc = ld;
 641         tty_set_termios_ldisc(tty, disc);
 642         retval = tty_ldisc_open(tty, tty->ldisc);
 643         if (retval) {
 644                 tty_ldisc_put(tty->ldisc);
 645                 tty->ldisc = NULL;
 646         }
 647         return retval;
 648 }
 649
 650 /**
 651  *      tty_ldisc_hangup                -       hangup ldisc reset
 652  *      @tty: tty being hung up
 653  *
 654  *      Some tty devices reset their termios when they receive a hangup
 655  *      event. In that situation we must also switch back to N_TTY properly
 656  *      before we reset the termios data.
 657  *
 658  *      Locking: We can take the ldisc mutex as the rest of the code is
 659  *      careful to allow for this.
 660  *
 661  *      In the pty pair case this occurs in the close() path of the
 662  *      tty itself so we must be careful about locking rules.
 663  */
 664
 665 void tty_ldisc_hangup(struct tty_struct *tty, bool reinit)
 666 {
 667         struct tty_ldisc *ld;
 668
 669         tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
 670
 671         ld = tty_ldisc_ref(tty);
 672         if (ld != NULL) {
 673                 if (ld->ops->flush_buffer)
 674                         ld->ops->flush_buffer(tty);
 675                 tty_driver_flush_buffer(tty);
 676                 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
 677                     ld->ops->write_wakeup)
 678                         ld->ops->write_wakeup(tty);
 679                 if (ld->ops->hangup)
 680                         ld->ops->hangup(tty);
 681                 tty_ldisc_deref(ld);
 682         }
 683
 684         wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
 685         wake_up_interruptible_poll(&tty->read_wait, POLLIN);
 686
 687         /*
 688          * Shutdown the current line discipline, and reset it to
 689          * N_TTY if need be.
 690          *
 691          * Avoid racing set_ldisc or tty_ldisc_release
 692          */
 693         tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
 694
 695         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
 696                 tty_reset_termios(tty);
 697
 698         if (tty->ldisc) {
 699                 if (reinit) {
 700                         if (tty_ldisc_reinit(tty, tty->termios.c_line) < 0)
 701                                 tty_ldisc_reinit(tty, N_TTY);
 702                 } else
 703                         tty_ldisc_kill(tty);
 704         }
 705         tty_ldisc_unlock(tty);
 706 }
 707
 708 /**
 709  *      tty_ldisc_setup                 -       open line discipline
 710  *      @tty: tty being shut down
 711  *      @o_tty: pair tty for pty/tty pairs
 712  *
 713  *      Called during the initial open of a tty/pty pair in order to set up the
 714  *      line disciplines and bind them to the tty. This has no locking issues
 715  *      as the device isn't yet active.
 716  */
 717
 718 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
 719 {
 720         int retval = tty_ldisc_open(tty, tty->ldisc);
 721         if (retval)
 722                 return retval;
 723
 724         if (o_tty) {
 725                 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
 726                 if (retval) {
 727                         tty_ldisc_close(tty, tty->ldisc);
 728                         return retval;
 729                 }
 730         }
 731         return 0;
 732 }
 733
 734 /**
 735  *      tty_ldisc_release               -       release line discipline
 736  *      @tty: tty being shut down (or one end of pty pair)
 737  *
 738  *      Called during the final close of a tty or a pty pair in order to shut
 739  *      down the line discpline layer. On exit, each tty's ldisc is NULL.
 740  */
 741
 742 void tty_ldisc_release(struct tty_struct *tty)
 743 {
 744         struct tty_struct *o_tty = tty->link;
 745
 746         /*
 747          * Shutdown this line discipline. As this is the final close,
 748          * it does not race with the set_ldisc code path.
 749          */
 750
 751         tty_ldisc_lock_pair(tty, o_tty);
 752         tty_ldisc_kill(tty);
 753         if (o_tty)
 754                 tty_ldisc_kill(o_tty);
 755         tty_ldisc_unlock_pair(tty, o_tty);
 756
 757         /* And the memory resources remaining (buffers, termios) will be
 758            disposed of when the kref hits zero */
 759
 760         tty_ldisc_debug(tty, "released\n");
 761 }
 762
 763 /**
 764  *      tty_ldisc_init          -       ldisc setup for new tty
 765  *      @tty: tty being allocated
 766  *
 767  *      Set up the line discipline objects for a newly allocated tty. Note that
 768  *      the tty structure is not completely set up when this call is made.
 769  */
 770
 771 int tty_ldisc_init(struct tty_struct *tty)
 772 {
 773         struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
 774         if (IS_ERR(ld))
 775                 return PTR_ERR(ld);
 776         tty->ldisc = ld;
 777         return 0;
 778 }
 779
 780 /**
 781  *      tty_ldisc_deinit        -       ldisc cleanup for new tty
 782  *      @tty: tty that was allocated recently
 783  *
 784  *      The tty structure must not becompletely set up (tty_ldisc_setup) when
 785  *      this call is made.
 786  */
 787 void tty_ldisc_deinit(struct tty_struct *tty)
 788 {
 789         if (tty->ldisc)
 790                 tty_ldisc_put(tty->ldisc);
 791         tty->ldisc = NULL;
 792 }
 793
 794 static int zero;
 795 static int one = 1;
 796 static struct ctl_table tty_table[] = {
 797         {
 798                 .procname       = "ldisc_autoload",
 799                 .data           = &tty_ldisc_autoload,
 800                 .maxlen         = sizeof(tty_ldisc_autoload),
 801                 .mode           = 0644,
 802                 .proc_handler   = proc_dointvec,
 803                 .extra1         = &zero,
 804                 .extra2         = &one,
 805         },
 806         { }
 807 };
 808
 809 static struct ctl_table tty_dir_table[] = {
 810         {
 811                 .procname       = "tty",
 812                 .mode           = 0555,
 813                 .child          = tty_table,
 814         },
 815         { }
 816 };
 817
 818 static struct ctl_table tty_root_table[] = {
 819         {
 820                 .procname       = "dev",
 821                 .mode           = 0555,
 822                 .child          = tty_dir_table,
 823         },
 824         { }
 825 };
 826
 827 void tty_sysctl_init(void)
 828 {
 829         register_sysctl_table(tty_root_table);
 830 }