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