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 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 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 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_ldisc_failto        -       helper for ldisc failback
 496  *      @tty: tty to open the ldisc on
 497  *      @ld: ldisc we are trying to fail back to
 498  *
 499  *      Helper to try and recover a tty when switching back to the old
 500  *      ldisc fails and we need something attached.
 501  */
 502
 503 static int tty_ldisc_failto(struct tty_struct *tty, int ld)
 504 {
 505         struct tty_ldisc *disc = tty_ldisc_get(tty, ld);
 506         int r;
 507
 508         if (IS_ERR(disc))
 509                 return PTR_ERR(disc);
 510         tty->ldisc = disc;
 511         tty_set_termios_ldisc(tty, ld);
 512         if ((r = tty_ldisc_open(tty, disc)) < 0)
 513                 tty_ldisc_put(disc);
 514         return r;
 515 }
 516
 517 /**
 518  *      tty_ldisc_restore       -       helper for tty ldisc change
 519  *      @tty: tty to recover
 520  *      @old: previous ldisc
 521  *
 522  *      Restore the previous line discipline or N_TTY when a line discipline
 523  *      change fails due to an open error
 524  */
 525
 526 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
 527 {
 528         /* There is an outstanding reference here so this is safe */
 529         if (tty_ldisc_failto(tty, old->ops->num) < 0) {
 530                 const char *name = tty_name(tty);
 531
 532                 pr_warn("Falling back ldisc for %s.\n", name);
 533                 /* The traditional behaviour is to fall back to N_TTY, we
 534                    want to avoid falling back to N_NULL unless we have no
 535                    choice to avoid the risk of breaking anything */
 536                 if (tty_ldisc_failto(tty, N_TTY) < 0 &&
 537                     tty_ldisc_failto(tty, N_NULL) < 0)
 538                         panic("Couldn't open N_NULL ldisc for %s.", name);
 539         }
 540 }
 541
 542 /**
 543  *      tty_set_ldisc           -       set line discipline
 544  *      @tty: the terminal to set
 545  *      @ldisc: the line discipline
 546  *
 547  *      Set the discipline of a tty line. Must be called from a process
 548  *      context. The ldisc change logic has to protect itself against any
 549  *      overlapping ldisc change (including on the other end of pty pairs),
 550  *      the close of one side of a tty/pty pair, and eventually hangup.
 551  */
 552
 553 int tty_set_ldisc(struct tty_struct *tty, int disc)
 554 {
 555         int retval;
 556         struct tty_ldisc *old_ldisc, *new_ldisc;
 557
 558         new_ldisc = tty_ldisc_get(tty, disc);
 559         if (IS_ERR(new_ldisc))
 560                 return PTR_ERR(new_ldisc);
 561
 562         tty_lock(tty);
 563         retval = tty_ldisc_lock(tty, 5 * HZ);
 564         if (retval)
 565                 goto err;
 566
 567         if (!tty->ldisc) {
 568                 retval = -EIO;
 569                 goto out;
 570         }
 571
 572         /* Check the no-op case */
 573         if (tty->ldisc->ops->num == disc)
 574                 goto out;
 575
 576         if (test_bit(TTY_HUPPED, &tty->flags)) {
 577                 /* We were raced by hangup */
 578                 retval = -EIO;
 579                 goto out;
 580         }
 581
 582         old_ldisc = tty->ldisc;
 583
 584         /* Shutdown the old discipline. */
 585         tty_ldisc_close(tty, old_ldisc);
 586
 587         /* Now set up the new line discipline. */
 588         tty->ldisc = new_ldisc;
 589         tty_set_termios_ldisc(tty, disc);
 590
 591         retval = tty_ldisc_open(tty, new_ldisc);
 592         if (retval < 0) {
 593                 /* Back to the old one or N_TTY if we can't */
 594                 tty_ldisc_put(new_ldisc);
 595                 tty_ldisc_restore(tty, old_ldisc);
 596         }
 597
 598         if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
 599                 down_read(&tty->termios_rwsem);
 600                 tty->ops->set_ldisc(tty);
 601                 up_read(&tty->termios_rwsem);
 602         }
 603
 604         /* At this point we hold a reference to the new ldisc and a
 605            reference to the old ldisc, or we hold two references to
 606            the old ldisc (if it was restored as part of error cleanup
 607            above). In either case, releasing a single reference from
 608            the old ldisc is correct. */
 609         new_ldisc = old_ldisc;
 610 out:
 611         tty_ldisc_unlock(tty);
 612
 613         /* Restart the work queue in case no characters kick it off. Safe if
 614            already running */
 615         tty_buffer_restart_work(tty->port);
 616 err:
 617         tty_ldisc_put(new_ldisc);       /* drop the extra reference */
 618         tty_unlock(tty);
 619         return retval;
 620 }
 621 EXPORT_SYMBOL_GPL(tty_set_ldisc);
 622
 623 /**
 624  *      tty_ldisc_kill  -       teardown ldisc
 625  *      @tty: tty being released
 626  *
 627  *      Perform final close of the ldisc and reset tty->ldisc
 628  */
 629 static void tty_ldisc_kill(struct tty_struct *tty)
 630 {
 631         if (!tty->ldisc)
 632                 return;
 633         /*
 634          * Now kill off the ldisc
 635          */
 636         tty_ldisc_close(tty, tty->ldisc);
 637         tty_ldisc_put(tty->ldisc);
 638         /* Force an oops if we mess this up */
 639         tty->ldisc = NULL;
 640 }
 641
 642 /**
 643  *      tty_reset_termios       -       reset terminal state
 644  *      @tty: tty to reset
 645  *
 646  *      Restore a terminal to the driver default state.
 647  */
 648
 649 static void tty_reset_termios(struct tty_struct *tty)
 650 {
 651         down_write(&tty->termios_rwsem);
 652         tty->termios = tty->driver->init_termios;
 653         tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
 654         tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
 655         up_write(&tty->termios_rwsem);
 656 }
 657
 658
 659 /**
 660  *      tty_ldisc_reinit        -       reinitialise the tty ldisc
 661  *      @tty: tty to reinit
 662  *      @disc: line discipline to reinitialize
 663  *
 664  *      Completely reinitialize the line discipline state, by closing the
 665  *      current instance, if there is one, and opening a new instance. If
 666  *      an error occurs opening the new non-N_TTY instance, the instance
 667  *      is dropped and tty->ldisc reset to NULL. The caller can then retry
 668  *      with N_TTY instead.
 669  *
 670  *      Returns 0 if successful, otherwise error code < 0
 671  */
 672
 673 int tty_ldisc_reinit(struct tty_struct *tty, int disc)
 674 {
 675         struct tty_ldisc *ld;
 676         int retval;
 677
 678         ld = tty_ldisc_get(tty, disc);
 679         if (IS_ERR(ld)) {
 680                 BUG_ON(disc == N_TTY);
 681                 return PTR_ERR(ld);
 682         }
 683
 684         if (tty->ldisc) {
 685                 tty_ldisc_close(tty, tty->ldisc);
 686                 tty_ldisc_put(tty->ldisc);
 687         }
 688
 689         /* switch the line discipline */
 690         tty->ldisc = ld;
 691         tty_set_termios_ldisc(tty, disc);
 692         retval = tty_ldisc_open(tty, tty->ldisc);
 693         if (retval) {
 694                 tty_ldisc_put(tty->ldisc);
 695                 tty->ldisc = NULL;
 696         }
 697         return retval;
 698 }
 699
 700 /**
 701  *      tty_ldisc_hangup                -       hangup ldisc reset
 702  *      @tty: tty being hung up
 703  *
 704  *      Some tty devices reset their termios when they receive a hangup
 705  *      event. In that situation we must also switch back to N_TTY properly
 706  *      before we reset the termios data.
 707  *
 708  *      Locking: We can take the ldisc mutex as the rest of the code is
 709  *      careful to allow for this.
 710  *
 711  *      In the pty pair case this occurs in the close() path of the
 712  *      tty itself so we must be careful about locking rules.
 713  */
 714
 715 void tty_ldisc_hangup(struct tty_struct *tty, bool reinit)
 716 {
 717         struct tty_ldisc *ld;
 718
 719         tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
 720
 721         ld = tty_ldisc_ref(tty);
 722         if (ld != NULL) {
 723                 if (ld->ops->flush_buffer)
 724                         ld->ops->flush_buffer(tty);
 725                 tty_driver_flush_buffer(tty);
 726                 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
 727                     ld->ops->write_wakeup)
 728                         ld->ops->write_wakeup(tty);
 729                 if (ld->ops->hangup)
 730                         ld->ops->hangup(tty);
 731                 tty_ldisc_deref(ld);
 732         }
 733
 734         wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
 735         wake_up_interruptible_poll(&tty->read_wait, EPOLLIN);
 736
 737         /*
 738          * Shutdown the current line discipline, and reset it to
 739          * N_TTY if need be.
 740          *
 741          * Avoid racing set_ldisc or tty_ldisc_release
 742          */
 743         tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
 744
 745         if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
 746                 tty_reset_termios(tty);
 747
 748         if (tty->ldisc) {
 749                 if (reinit) {
 750                         if (tty_ldisc_reinit(tty, tty->termios.c_line) < 0 &&
 751                             tty_ldisc_reinit(tty, N_TTY) < 0)
 752                                 WARN_ON(tty_ldisc_reinit(tty, N_NULL) < 0);
 753                 } else
 754                         tty_ldisc_kill(tty);
 755         }
 756         tty_ldisc_unlock(tty);
 757 }
 758
 759 /**
 760  *      tty_ldisc_setup                 -       open line discipline
 761  *      @tty: tty being shut down
 762  *      @o_tty: pair tty for pty/tty pairs
 763  *
 764  *      Called during the initial open of a tty/pty pair in order to set up the
 765  *      line disciplines and bind them to the tty. This has no locking issues
 766  *      as the device isn't yet active.
 767  */
 768
 769 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
 770 {
 771         int retval = tty_ldisc_open(tty, tty->ldisc);
 772         if (retval)
 773                 return retval;
 774
 775         if (o_tty) {
 776                 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
 777                 if (retval) {
 778                         tty_ldisc_close(tty, tty->ldisc);
 779                         return retval;
 780                 }
 781         }
 782         return 0;
 783 }
 784
 785 /**
 786  *      tty_ldisc_release               -       release line discipline
 787  *      @tty: tty being shut down (or one end of pty pair)
 788  *
 789  *      Called during the final close of a tty or a pty pair in order to shut
 790  *      down the line discpline layer. On exit, each tty's ldisc is NULL.
 791  */
 792
 793 void tty_ldisc_release(struct tty_struct *tty)
 794 {
 795         struct tty_struct *o_tty = tty->link;
 796
 797         /*
 798          * Shutdown this line discipline. As this is the final close,
 799          * it does not race with the set_ldisc code path.
 800          */
 801
 802         tty_ldisc_lock_pair(tty, o_tty);
 803         tty_ldisc_kill(tty);
 804         if (o_tty)
 805                 tty_ldisc_kill(o_tty);
 806         tty_ldisc_unlock_pair(tty, o_tty);
 807
 808         /* And the memory resources remaining (buffers, termios) will be
 809            disposed of when the kref hits zero */
 810
 811         tty_ldisc_debug(tty, "released\n");
 812 }
 813 EXPORT_SYMBOL_GPL(tty_ldisc_release);
 814
 815 /**
 816  *      tty_ldisc_init          -       ldisc setup for new tty
 817  *      @tty: tty being allocated
 818  *
 819  *      Set up the line discipline objects for a newly allocated tty. Note that
 820  *      the tty structure is not completely set up when this call is made.
 821  */
 822
 823 int tty_ldisc_init(struct tty_struct *tty)
 824 {
 825         struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
 826         if (IS_ERR(ld))
 827                 return PTR_ERR(ld);
 828         tty->ldisc = ld;
 829         return 0;
 830 }
 831
 832 /**
 833  *      tty_ldisc_deinit        -       ldisc cleanup for new tty
 834  *      @tty: tty that was allocated recently
 835  *
 836  *      The tty structure must not becompletely set up (tty_ldisc_setup) when
 837  *      this call is made.
 838  */
 839 void tty_ldisc_deinit(struct tty_struct *tty)
 840 {
 841         if (tty->ldisc)
 842                 tty_ldisc_put(tty->ldisc);
 843         tty->ldisc = NULL;
 844 }