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