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