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