drivers/tty/tty_ldisc.c

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