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