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  *      Note: Must not be called from an IRQ/timer context. The caller
 261  *      must also be careful not to hold other locks that will deadlock
 262  *      against a discipline change, such as an existing ldisc reference
 263  *      (which we check for)
 264  *
 265  *      Note: a file_operations routine (read/poll/write) should use this
 266  *      function to wait for any ldisc lifetime events to finish.
 267  */
 268
 269 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
 270 {
 271         ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
 272         if (!tty->ldisc)
 273                 ldsem_up_read(&tty->ldisc_sem);
 274         return tty->ldisc;
 275 }
 276 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
 277
 278 /**
 279  *      tty_ldisc_ref           -       get the tty ldisc
 280  *      @tty: tty device
 281  *
 282  *      Dereference the line discipline for the terminal and take a
 283  *      reference to it. If the line discipline is in flux then
 284  *      return NULL. Can be called from IRQ and timer functions.
 285  */
 286
 287 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
 288 {
 289         struct tty_ldisc *ld = NULL;
 290
 291         if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
 292                 ld = tty->ldisc;
 293                 if (!ld)
 294                         ldsem_up_read(&tty->ldisc_sem);
 295         }
 296         return ld;
 297 }
 298 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
 299
 300 /**
 301  *      tty_ldisc_deref         -       free a tty ldisc reference
 302  *      @ld: reference to free up
 303  *
 304  *      Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
 305  *      be called in IRQ context.
 306  */
 307
 308 void tty_ldisc_deref(struct tty_ldisc *ld)
 309 {
 310         ldsem_up_read(&ld->tty->ldisc_sem);
 311 }
 312 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
 313
 314
 315 static inline int
 316 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
 317 {
 318         return ldsem_down_write(&tty->ldisc_sem, timeout);
 319 }
 320
 321 static inline int
 322 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
 323 {
 324         return ldsem_down_write_nested(&tty->ldisc_sem,
 325                                        LDISC_SEM_OTHER, timeout);
 326 }
 327
 328 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
 329 {
 330         ldsem_up_write(&tty->ldisc_sem);
 331 }
 332
 333 static int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
 334 {
 335         int ret;
 336
 337         ret = __tty_ldisc_lock(tty, timeout);
 338         if (!ret)
 339                 return -EBUSY;
 340         set_bit(TTY_LDISC_HALTED, &tty->flags);
 341         return 0;
 342 }
 343
 344 static void tty_ldisc_unlock(struct tty_struct *tty)
 345 {
 346         clear_bit(TTY_LDISC_HALTED, &tty->flags);
 347         __tty_ldisc_unlock(tty);
 348 }
 349
 350 static int
 351 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
 352                             unsigned long timeout)
 353 {
 354         int ret;
 355
 356         if (tty < tty2) {
 357                 ret = __tty_ldisc_lock(tty, timeout);
 358                 if (ret) {
 359                         ret = __tty_ldisc_lock_nested(tty2, timeout);
 360                         if (!ret)
 361                                 __tty_ldisc_unlock(tty);
 362                 }
 363         } else {
 364                 /* if this is possible, it has lots of implications */
 365                 WARN_ON_ONCE(tty == tty2);
 366                 if (tty2 && tty != tty2) {
 367                         ret = __tty_ldisc_lock(tty2, timeout);
 368                         if (ret) {
 369                                 ret = __tty_ldisc_lock_nested(tty, timeout);
 370                                 if (!ret)
 371                                         __tty_ldisc_unlock(tty2);
 372                         }
 373                 } else
 374                         ret = __tty_ldisc_lock(tty, timeout);
 375         }
 376
 377         if (!ret)
 378                 return -EBUSY;
 379
 380         set_bit(TTY_LDISC_HALTED, &tty->flags);
 381         if (tty2)
 382                 set_bit(TTY_LDISC_HALTED, &tty2->flags);
 383         return 0;
 384 }
 385
 386 static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
 387 {
 388         tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
 389 }
 390
 391 static void tty_ldisc_unlock_pair(struct tty_struct *tty,
 392                                   struct tty_struct *tty2)
 393 {
 394         __tty_ldisc_unlock(tty);
 395         if (tty2)
 396                 __tty_ldisc_unlock(tty2);
 397 }
 398
 399 /**
 400  *      tty_ldisc_flush -       flush line discipline queue
 401  *      @tty: tty
 402  *
 403  *      Flush the line discipline queue (if any) and the tty flip buffers
 404  *      for this tty.
 405  */
 406
 407 void tty_ldisc_flush(struct tty_struct *tty)
 408 {
 409         struct tty_ldisc *ld = tty_ldisc_ref(tty);
 410
 411         tty_buffer_flush(tty, ld);
 412         if (ld)
 413                 tty_ldisc_deref(ld);
 414 }
 415 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
 416
 417 /**
 418  *      tty_set_termios_ldisc           -       set ldisc field
 419  *      @tty: tty structure
 420  *      @num: line discipline number
 421  *
 422  *      This is probably overkill for real world processors but
 423  *      they are not on hot paths so a little discipline won't do
 424  *      any harm.
 425  *
 426  *      The line discipline-related tty_struct fields are reset to
 427  *      prevent the ldisc driver from re-using stale information for
 428  *      the new ldisc instance.
 429  *
 430  *      Locking: takes termios_rwsem
 431  */
 432
 433 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
 434 {
 435         down_write(&tty->termios_rwsem);
 436         tty->termios.c_line = num;
 437         up_write(&tty->termios_rwsem);
 438
 439         tty->disc_data = NULL;
 440         tty->receive_room = 0;
 441 }
 442
 443 /**
 444  *      tty_ldisc_open          -       open a line discipline
 445  *      @tty: tty we are opening the ldisc on
 446  *      @ld: discipline to open
 447  *
 448  *      A helper opening method. Also a convenient debugging and check
 449  *      point.
 450  *
 451  *      Locking: always called with BTM already held.
 452  */
 453
 454 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
 455 {
 456         WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
 457         if (ld->ops->open) {
 458                 int ret;
 459                 /* BTM here locks versus a hangup event */
 460                 ret = ld->ops->open(tty);
 461                 if (ret)
 462                         clear_bit(TTY_LDISC_OPEN, &tty->flags);
 463
 464                 tty_ldisc_debug(tty, "%p: opened\n", ld);
 465                 return ret;
 466         }
 467         return 0;
 468 }
 469
 470 /**
 471  *      tty_ldisc_close         -       close a line discipline
 472  *      @tty: tty we are opening the ldisc on
 473  *      @ld: discipline to close
 474  *
 475  *      A helper close method. Also a convenient debugging and check
 476  *      point.
 477  */
 478
 479 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
 480 {
 481         WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
 482         clear_bit(TTY_LDISC_OPEN, &tty->flags);
 483         if (ld->ops->close)
 484                 ld->ops->close(tty);
 485         tty_ldisc_debug(tty, "%p: closed\n", ld);
 486 }
 487
 488 /**
 489  *      tty_ldisc_restore       -       helper for tty ldisc change
 490  *      @tty: tty to recover
 491  *      @old: previous ldisc
 492  *
 493  *      Restore the previous line discipline or N_TTY when a line discipline
 494  *      change fails due to an open error
 495  */
 496
 497 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
 498 {
 499         struct tty_ldisc *new_ldisc;
 500         int r;
 501
 502         /* There is an outstanding reference here so this is safe */
 503         old = tty_ldisc_get(tty, old->ops->num);
 504         WARN_ON(IS_ERR(old));
 505         tty->ldisc = old;
 506         tty_set_termios_ldisc(tty, old->ops->num);
 507         if (tty_ldisc_open(tty, old) < 0) {
 508                 tty_ldisc_put(old);
 509                 /* This driver is always present */
 510                 new_ldisc = tty_ldisc_get(tty, N_TTY);
 511                 if (IS_ERR(new_ldisc))
 512                         panic("n_tty: get");
 513                 tty->ldisc = new_ldisc;
 514                 tty_set_termios_ldisc(tty, N_TTY);
 515                 r = tty_ldisc_open(tty, new_ldisc);
 516                 if (r < 0)
 517                         panic("Couldn't open N_TTY ldisc for "
 518                               "%s --- error %d.",
 519                               tty_name(tty), r);
 520         }
 521 }
 522
 523 /**
 524  *      tty_set_ldisc           -       set line discipline
 525  *      @tty: the terminal to set
 526  *      @ldisc: the line discipline
 527  *
 528  *      Set the discipline of a tty line. Must be called from a process
 529  *      context. The ldisc change logic has to protect itself against any
 530  *      overlapping ldisc change (including on the other end of pty pairs),
 531  *      the close of one side of a tty/pty pair, and eventually hangup.
 532  */
 533
 534 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
 535 {
 536         int retval;
 537         struct tty_ldisc *old_ldisc, *new_ldisc;
 538
 539         new_ldisc = tty_ldisc_get(tty, ldisc);
 540         if (IS_ERR(new_ldisc))
 541                 return PTR_ERR(new_ldisc);
 542
 543         tty_lock(tty);
 544         retval = tty_ldisc_lock(tty, 5 * HZ);
 545         if (retval)
 546                 goto err;
 547
 548         if (!tty->ldisc) {
 549                 retval = -EIO;
 550                 goto out;
 551         }
 552
 553         /* Check the no-op case */
 554         if (tty->ldisc->ops->num == ldisc)
 555                 goto out;
 556
 557         if (test_bit(TTY_HUPPED, &tty->flags)) {
 558                 /* We were raced by hangup */
 559                 retval = -EIO;
 560                 goto out;
 561         }
 562
 563         old_ldisc = tty->ldisc;
 564
 565         /* Shutdown the old discipline. */
 566         tty_ldisc_close(tty, old_ldisc);
 567
 568         /* Now set up the new line discipline. */
 569         tty->ldisc = new_ldisc;
 570         tty_set_termios_ldisc(tty, ldisc);
 571
 572         retval = tty_ldisc_open(tty, new_ldisc);
 573         if (retval < 0) {
 574                 /* Back to the old one or N_TTY if we can't */
 575                 tty_ldisc_put(new_ldisc);
 576                 tty_ldisc_restore(tty, old_ldisc);
 577         }
 578
 579         if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
 580                 down_read(&tty->termios_rwsem);
 581                 tty->ops->set_ldisc(tty);
 582                 up_read(&tty->termios_rwsem);
 583         }
 584
 585         /* At this point we hold a reference to the new ldisc and a
 586            reference to the old ldisc, or we hold two references to
 587            the old ldisc (if it was restored as part of error cleanup
 588            above). In either case, releasing a single reference from
 589            the old ldisc is correct. */
 590         new_ldisc = old_ldisc;
 591 out:
 592         tty_ldisc_unlock(tty);
 593
 594         /* Restart the work queue in case no characters kick it off. Safe if
 595            already running */
 596         tty_buffer_restart_work(tty->port);
 597 err:
 598         tty_ldisc_put(new_ldisc);       /* drop the extra reference */
 599         tty_unlock(tty);
 600         return retval;
 601 }
 602
 603 /**
 604  *      tty_ldisc_kill  -       teardown ldisc
 605  *      @tty: tty being released
 606  *
 607  *      Perform final close of the ldisc and reset tty->ldisc
 608  */
 609 static void tty_ldisc_kill(struct tty_struct *tty)
 610 {
 611         if (!tty->ldisc)
 612                 return;
 613         /*
 614          * Now kill off the ldisc
 615          */
 616         tty_ldisc_close(tty, tty->ldisc);
 617         tty_ldisc_put(tty->ldisc);
 618         /* Force an oops if we mess this up */
 619         tty->ldisc = NULL;
 620 }
 621
 622 /**
 623  *      tty_reset_termios       -       reset terminal state
 624  *      @tty: tty to reset
 625  *
 626  *      Restore a terminal to the driver default state.
 627  */
 628
 629 static void tty_reset_termios(struct tty_struct *tty)
 630 {
 631         down_write(&tty->termios_rwsem);
 632         tty->termios = tty->driver->init_termios;
 633         tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
 634         tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
 635         up_write(&tty->termios_rwsem);
 636 }
 637
 638
 639 /**
 640  *      tty_ldisc_reinit        -       reinitialise the tty ldisc
 641  *      @tty: tty to reinit
 642  *      @ldisc: line discipline to reinitialize
 643  *
 644  *      Switch the tty to a line discipline and leave the ldisc
 645  *      state closed
 646  */
 647
 648 static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
 649 {
 650         struct tty_ldisc *ld = tty_ldisc_get(tty, ldisc);
 651
 652         if (IS_ERR(ld))
 653                 return -1;
 654
 655         tty_ldisc_close(tty, tty->ldisc);
 656         tty_ldisc_put(tty->ldisc);
 657         /*
 658          *      Switch the line discipline back
 659          */
 660         tty->ldisc = ld;
 661         tty_set_termios_ldisc(tty, ldisc);
 662
 663         return 0;
 664 }
 665
 666 /**
 667  *      tty_ldisc_hangup                -       hangup ldisc reset
 668  *      @tty: tty being hung up
 669  *
 670  *      Some tty devices reset their termios when they receive a hangup
 671  *      event. In that situation we must also switch back to N_TTY properly
 672  *      before we reset the termios data.
 673  *
 674  *      Locking: We can take the ldisc mutex as the rest of the code is
 675  *      careful to allow for this.
 676  *
 677  *      In the pty pair case this occurs in the close() path of the
 678  *      tty itself so we must be careful about locking rules.
 679  */
 680
 681 void tty_ldisc_hangup(struct tty_struct *tty)
 682 {
 683         struct tty_ldisc *ld;
 684         int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
 685         int err = 0;
 686
 687         tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
 688
 689         ld = tty_ldisc_ref(tty);
 690         if (ld != NULL) {
 691                 if (ld->ops->flush_buffer)
 692                         ld->ops->flush_buffer(tty);
 693                 tty_driver_flush_buffer(tty);
 694                 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
 695                     ld->ops->write_wakeup)
 696                         ld->ops->write_wakeup(tty);
 697                 if (ld->ops->hangup)
 698                         ld->ops->hangup(tty);
 699                 tty_ldisc_deref(ld);
 700         }
 701
 702         wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
 703         wake_up_interruptible_poll(&tty->read_wait, POLLIN);
 704
 705         /*
 706          * Shutdown the current line discipline, and reset it to
 707          * N_TTY if need be.
 708          *
 709          * Avoid racing set_ldisc or tty_ldisc_release
 710          */
 711         tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
 712
 713         if (tty->ldisc) {
 714
 715                 /* At this point we have a halted ldisc; we want to close it and
 716                    reopen a new ldisc. We could defer the reopen to the next
 717                    open but it means auditing a lot of other paths so this is
 718                    a FIXME */
 719                 if (reset == 0) {
 720
 721                         if (!tty_ldisc_reinit(tty, tty->termios.c_line))
 722                                 err = tty_ldisc_open(tty, tty->ldisc);
 723                         else
 724                                 err = 1;
 725                 }
 726                 /* If the re-open fails or we reset then go to N_TTY. The
 727                    N_TTY open cannot fail */
 728                 if (reset || err) {
 729                         BUG_ON(tty_ldisc_reinit(tty, N_TTY));
 730                         WARN_ON(tty_ldisc_open(tty, tty->ldisc));
 731                 }
 732         }
 733         tty_ldisc_unlock(tty);
 734         if (reset)
 735                 tty_reset_termios(tty);
 736
 737         tty_ldisc_debug(tty, "%p: re-opened\n", tty->ldisc);
 738 }
 739
 740 /**
 741  *      tty_ldisc_setup                 -       open line discipline
 742  *      @tty: tty being shut down
 743  *      @o_tty: pair tty for pty/tty pairs
 744  *
 745  *      Called during the initial open of a tty/pty pair in order to set up the
 746  *      line disciplines and bind them to the tty. This has no locking issues
 747  *      as the device isn't yet active.
 748  */
 749
 750 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
 751 {
 752         struct tty_ldisc *ld = tty->ldisc;
 753         int retval;
 754
 755         retval = tty_ldisc_open(tty, ld);
 756         if (retval)
 757                 return retval;
 758
 759         if (o_tty) {
 760                 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
 761                 if (retval) {
 762                         tty_ldisc_close(tty, ld);
 763                         return retval;
 764                 }
 765         }
 766         return 0;
 767 }
 768
 769 /**
 770  *      tty_ldisc_release               -       release line discipline
 771  *      @tty: tty being shut down (or one end of pty pair)
 772  *
 773  *      Called during the final close of a tty or a pty pair in order to shut
 774  *      down the line discpline layer. On exit, each tty's ldisc is NULL.
 775  */
 776
 777 void tty_ldisc_release(struct tty_struct *tty)
 778 {
 779         struct tty_struct *o_tty = tty->link;
 780
 781         /*
 782          * Shutdown this line discipline. As this is the final close,
 783          * it does not race with the set_ldisc code path.
 784          */
 785
 786         tty_ldisc_lock_pair(tty, o_tty);
 787         tty_ldisc_kill(tty);
 788         if (o_tty)
 789                 tty_ldisc_kill(o_tty);
 790         tty_ldisc_unlock_pair(tty, o_tty);
 791
 792         /* And the memory resources remaining (buffers, termios) will be
 793            disposed of when the kref hits zero */
 794
 795         tty_ldisc_debug(tty, "released\n");
 796 }
 797
 798 /**
 799  *      tty_ldisc_init          -       ldisc setup for new tty
 800  *      @tty: tty being allocated
 801  *
 802  *      Set up the line discipline objects for a newly allocated tty. Note that
 803  *      the tty structure is not completely set up when this call is made.
 804  */
 805
 806 void tty_ldisc_init(struct tty_struct *tty)
 807 {
 808         struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
 809         if (IS_ERR(ld))
 810                 panic("n_tty: init_tty");
 811         tty->ldisc = ld;
 812 }
 813
 814 /**
 815  *      tty_ldisc_deinit        -       ldisc cleanup for new tty
 816  *      @tty: tty that was allocated recently
 817  *
 818  *      The tty structure must not becompletely set up (tty_ldisc_setup) when
 819  *      this call is made.
 820  */
 821 void tty_ldisc_deinit(struct tty_struct *tty)
 822 {
 823         if (tty->ldisc)
 824                 tty_ldisc_put(tty->ldisc);
 825         tty->ldisc = NULL;
 826 }
 827
 828 void tty_ldisc_begin(void)
 829 {
 830         /* Setup the default TTY line discipline. */
 831         (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
 832 }