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 inline 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 __lockfunc
 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 __lockfunc
 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 __lockfunc
 326 tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
 327 {
 328         int ret;
 329
 330         ret = __tty_ldisc_lock(tty, timeout);
 331         if (!ret)
 332                 return -EBUSY;
 333         set_bit(TTY_LDISC_HALTED, &tty->flags);
 334         return 0;
 335 }
 336
 337 static void tty_ldisc_unlock(struct tty_struct *tty)
 338 {
 339         clear_bit(TTY_LDISC_HALTED, &tty->flags);
 340         __tty_ldisc_unlock(tty);
 341 }
 342
 343 static int __lockfunc
 344 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
 345                             unsigned long timeout)
 346 {
 347         int ret;
 348
 349         if (tty < tty2) {
 350                 ret = __tty_ldisc_lock(tty, timeout);
 351                 if (ret) {
 352                         ret = __tty_ldisc_lock_nested(tty2, timeout);
 353                         if (!ret)
 354                                 __tty_ldisc_unlock(tty);
 355                 }
 356         } else {
 357                 /* if this is possible, it has lots of implications */
 358                 WARN_ON_ONCE(tty == tty2);
 359                 if (tty2 && tty != tty2) {
 360                         ret = __tty_ldisc_lock(tty2, timeout);
 361                         if (ret) {
 362                                 ret = __tty_ldisc_lock_nested(tty, timeout);
 363                                 if (!ret)
 364                                         __tty_ldisc_unlock(tty2);
 365                         }
 366                 } else
 367                         ret = __tty_ldisc_lock(tty, timeout);
 368         }
 369
 370         if (!ret)
 371                 return -EBUSY;
 372
 373         set_bit(TTY_LDISC_HALTED, &tty->flags);
 374         if (tty2)
 375                 set_bit(TTY_LDISC_HALTED, &tty2->flags);
 376         return 0;
 377 }
 378
 379 static void __lockfunc
 380 tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
 381 {
 382         tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
 383 }
 384
 385 static void __lockfunc tty_ldisc_unlock_pair(struct tty_struct *tty,
 386                                              struct tty_struct *tty2)
 387 {
 388         __tty_ldisc_unlock(tty);
 389         if (tty2)
 390                 __tty_ldisc_unlock(tty2);
 391 }
 392
 393 /**
 394  *      tty_ldisc_flush -       flush line discipline queue
 395  *      @tty: tty
 396  *
 397  *      Flush the line discipline queue (if any) and the tty flip buffers
 398  *      for this tty.
 399  */
 400
 401 void tty_ldisc_flush(struct tty_struct *tty)
 402 {
 403         struct tty_ldisc *ld = tty_ldisc_ref(tty);
 404
 405         tty_buffer_flush(tty, ld);
 406         if (ld)
 407                 tty_ldisc_deref(ld);
 408 }
 409 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
 410
 411 /**
 412  *      tty_set_termios_ldisc           -       set ldisc field
 413  *      @tty: tty structure
 414  *      @num: line discipline number
 415  *
 416  *      This is probably overkill for real world processors but
 417  *      they are not on hot paths so a little discipline won't do
 418  *      any harm.
 419  *
 420  *      The line discipline-related tty_struct fields are reset to
 421  *      prevent the ldisc driver from re-using stale information for
 422  *      the new ldisc instance.
 423  *
 424  *      Locking: takes termios_rwsem
 425  */
 426
 427 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
 428 {
 429         down_write(&tty->termios_rwsem);
 430         tty->termios.c_line = num;
 431         up_write(&tty->termios_rwsem);
 432
 433         tty->disc_data = NULL;
 434         tty->receive_room = 0;
 435 }
 436
 437 /**
 438  *      tty_ldisc_open          -       open a line discipline
 439  *      @tty: tty we are opening the ldisc on
 440  *      @ld: discipline to open
 441  *
 442  *      A helper opening method. Also a convenient debugging and check
 443  *      point.
 444  *
 445  *      Locking: always called with BTM already held.
 446  */
 447
 448 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
 449 {
 450         WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
 451         if (ld->ops->open) {
 452                 int ret;
 453                 /* BTM here locks versus a hangup event */
 454                 ret = ld->ops->open(tty);
 455                 if (ret)
 456                         clear_bit(TTY_LDISC_OPEN, &tty->flags);
 457
 458                 tty_ldisc_debug(tty, "%p: opened\n", tty->ldisc);
 459                 return ret;
 460         }
 461         return 0;
 462 }
 463
 464 /**
 465  *      tty_ldisc_close         -       close a line discipline
 466  *      @tty: tty we are opening the ldisc on
 467  *      @ld: discipline to close
 468  *
 469  *      A helper close method. Also a convenient debugging and check
 470  *      point.
 471  */
 472
 473 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
 474 {
 475         WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
 476         clear_bit(TTY_LDISC_OPEN, &tty->flags);
 477         if (ld->ops->close)
 478                 ld->ops->close(tty);
 479         tty_ldisc_debug(tty, "%p: closed\n", tty->ldisc);
 480 }
 481
 482 /**
 483  *      tty_ldisc_restore       -       helper for tty ldisc change
 484  *      @tty: tty to recover
 485  *      @old: previous ldisc
 486  *
 487  *      Restore the previous line discipline or N_TTY when a line discipline
 488  *      change fails due to an open error
 489  */
 490
 491 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
 492 {
 493         struct tty_ldisc *new_ldisc;
 494         int r;
 495
 496         /* There is an outstanding reference here so this is safe */
 497         old = tty_ldisc_get(tty, old->ops->num);
 498         WARN_ON(IS_ERR(old));
 499         tty->ldisc = old;
 500         tty_set_termios_ldisc(tty, old->ops->num);
 501         if (tty_ldisc_open(tty, old) < 0) {
 502                 tty_ldisc_put(old);
 503                 /* This driver is always present */
 504                 new_ldisc = tty_ldisc_get(tty, N_TTY);
 505                 if (IS_ERR(new_ldisc))
 506                         panic("n_tty: get");
 507                 tty->ldisc = new_ldisc;
 508                 tty_set_termios_ldisc(tty, N_TTY);
 509                 r = tty_ldisc_open(tty, new_ldisc);
 510                 if (r < 0)
 511                         panic("Couldn't open N_TTY ldisc for "
 512                               "%s --- error %d.",
 513                               tty_name(tty), r);
 514         }
 515 }
 516
 517 /**
 518  *      tty_set_ldisc           -       set line discipline
 519  *      @tty: the terminal to set
 520  *      @ldisc: the line discipline
 521  *
 522  *      Set the discipline of a tty line. Must be called from a process
 523  *      context. The ldisc change logic has to protect itself against any
 524  *      overlapping ldisc change (including on the other end of pty pairs),
 525  *      the close of one side of a tty/pty pair, and eventually hangup.
 526  */
 527
 528 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
 529 {
 530         int retval;
 531         struct tty_ldisc *old_ldisc, *new_ldisc;
 532
 533         new_ldisc = tty_ldisc_get(tty, ldisc);
 534         if (IS_ERR(new_ldisc))
 535                 return PTR_ERR(new_ldisc);
 536
 537         tty_lock(tty);
 538         retval = tty_ldisc_lock(tty, 5 * HZ);
 539         if (retval) {
 540                 tty_ldisc_put(new_ldisc);
 541                 tty_unlock(tty);
 542                 return retval;
 543         }
 544
 545         /*
 546          *      Check the no-op case
 547          */
 548
 549         if (tty->ldisc->ops->num == ldisc) {
 550                 tty_ldisc_unlock(tty);
 551                 tty_ldisc_put(new_ldisc);
 552                 tty_unlock(tty);
 553                 return 0;
 554         }
 555
 556         old_ldisc = tty->ldisc;
 557
 558         if (test_bit(TTY_HUPPED, &tty->flags)) {
 559                 /* We were raced by the hangup method. It will have stomped
 560                    the ldisc data and closed the ldisc down */
 561                 tty_ldisc_unlock(tty);
 562                 tty_ldisc_put(new_ldisc);
 563                 tty_unlock(tty);
 564                 return -EIO;
 565         }
 566
 567         /* Shutdown the old discipline. */
 568         tty_ldisc_close(tty, old_ldisc);
 569
 570         /* Now set up the new line discipline. */
 571         tty->ldisc = new_ldisc;
 572         tty_set_termios_ldisc(tty, ldisc);
 573
 574         retval = tty_ldisc_open(tty, new_ldisc);
 575         if (retval < 0) {
 576                 /* Back to the old one or N_TTY if we can't */
 577                 tty_ldisc_put(new_ldisc);
 578                 tty_ldisc_restore(tty, old_ldisc);
 579         }
 580
 581         if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
 582                 down_read(&tty->termios_rwsem);
 583                 tty->ops->set_ldisc(tty);
 584                 up_read(&tty->termios_rwsem);
 585         }
 586
 587         /* At this point we hold a reference to the new ldisc and a
 588            reference to the old ldisc, or we hold two references to
 589            the old ldisc (if it was restored as part of error cleanup
 590            above). In either case, releasing a single reference from
 591            the old ldisc is correct. */
 592
 593         tty_ldisc_put(old_ldisc);
 594
 595         /*
 596          *      Allow ldisc referencing to occur again
 597          */
 598         tty_ldisc_unlock(tty);
 599
 600         /* Restart the work queue in case no characters kick it off. Safe if
 601            already running */
 602         tty_buffer_restart_work(tty->port);
 603
 604         tty_unlock(tty);
 605         return retval;
 606 }
 607
 608 /**
 609  *      tty_reset_termios       -       reset terminal state
 610  *      @tty: tty to reset
 611  *
 612  *      Restore a terminal to the driver default state.
 613  */
 614
 615 static void tty_reset_termios(struct tty_struct *tty)
 616 {
 617         down_write(&tty->termios_rwsem);
 618         tty->termios = tty->driver->init_termios;
 619         tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
 620         tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
 621         up_write(&tty->termios_rwsem);
 622 }
 623
 624
 625 /**
 626  *      tty_ldisc_reinit        -       reinitialise the tty ldisc
 627  *      @tty: tty to reinit
 628  *      @ldisc: line discipline to reinitialize
 629  *
 630  *      Switch the tty to a line discipline and leave the ldisc
 631  *      state closed
 632  */
 633
 634 static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
 635 {
 636         struct tty_ldisc *ld = tty_ldisc_get(tty, ldisc);
 637
 638         if (IS_ERR(ld))
 639                 return -1;
 640
 641         tty_ldisc_close(tty, tty->ldisc);
 642         tty_ldisc_put(tty->ldisc);
 643         /*
 644          *      Switch the line discipline back
 645          */
 646         tty->ldisc = ld;
 647         tty_set_termios_ldisc(tty, ldisc);
 648
 649         return 0;
 650 }
 651
 652 /**
 653  *      tty_ldisc_hangup                -       hangup ldisc reset
 654  *      @tty: tty being hung up
 655  *
 656  *      Some tty devices reset their termios when they receive a hangup
 657  *      event. In that situation we must also switch back to N_TTY properly
 658  *      before we reset the termios data.
 659  *
 660  *      Locking: We can take the ldisc mutex as the rest of the code is
 661  *      careful to allow for this.
 662  *
 663  *      In the pty pair case this occurs in the close() path of the
 664  *      tty itself so we must be careful about locking rules.
 665  */
 666
 667 void tty_ldisc_hangup(struct tty_struct *tty)
 668 {
 669         struct tty_ldisc *ld;
 670         int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
 671         int err = 0;
 672
 673         tty_ldisc_debug(tty, "%p: closing\n", tty->ldisc);
 674
 675         ld = tty_ldisc_ref(tty);
 676         if (ld != NULL) {
 677                 if (ld->ops->flush_buffer)
 678                         ld->ops->flush_buffer(tty);
 679                 tty_driver_flush_buffer(tty);
 680                 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
 681                     ld->ops->write_wakeup)
 682                         ld->ops->write_wakeup(tty);
 683                 if (ld->ops->hangup)
 684                         ld->ops->hangup(tty);
 685                 tty_ldisc_deref(ld);
 686         }
 687
 688         wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
 689         wake_up_interruptible_poll(&tty->read_wait, POLLIN);
 690
 691         /*
 692          * Shutdown the current line discipline, and reset it to
 693          * N_TTY if need be.
 694          *
 695          * Avoid racing set_ldisc or tty_ldisc_release
 696          */
 697         tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
 698
 699         if (tty->ldisc) {
 700
 701                 /* At this point we have a halted ldisc; we want to close it and
 702                    reopen a new ldisc. We could defer the reopen to the next
 703                    open but it means auditing a lot of other paths so this is
 704                    a FIXME */
 705                 if (reset == 0) {
 706
 707                         if (!tty_ldisc_reinit(tty, tty->termios.c_line))
 708                                 err = tty_ldisc_open(tty, tty->ldisc);
 709                         else
 710                                 err = 1;
 711                 }
 712                 /* If the re-open fails or we reset then go to N_TTY. The
 713                    N_TTY open cannot fail */
 714                 if (reset || err) {
 715                         BUG_ON(tty_ldisc_reinit(tty, N_TTY));
 716                         WARN_ON(tty_ldisc_open(tty, tty->ldisc));
 717                 }
 718         }
 719         tty_ldisc_unlock(tty);
 720         if (reset)
 721                 tty_reset_termios(tty);
 722
 723         tty_ldisc_debug(tty, "%p: re-opened\n", tty->ldisc);
 724 }
 725
 726 /**
 727  *      tty_ldisc_setup                 -       open line discipline
 728  *      @tty: tty being shut down
 729  *      @o_tty: pair tty for pty/tty pairs
 730  *
 731  *      Called during the initial open of a tty/pty pair in order to set up the
 732  *      line disciplines and bind them to the tty. This has no locking issues
 733  *      as the device isn't yet active.
 734  */
 735
 736 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
 737 {
 738         struct tty_ldisc *ld = tty->ldisc;
 739         int retval;
 740
 741         retval = tty_ldisc_open(tty, ld);
 742         if (retval)
 743                 return retval;
 744
 745         if (o_tty) {
 746                 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
 747                 if (retval) {
 748                         tty_ldisc_close(tty, ld);
 749                         return retval;
 750                 }
 751         }
 752         return 0;
 753 }
 754
 755 static void tty_ldisc_kill(struct tty_struct *tty)
 756 {
 757         /*
 758          * Now kill off the ldisc
 759          */
 760         tty_ldisc_close(tty, tty->ldisc);
 761         tty_ldisc_put(tty->ldisc);
 762         /* Force an oops if we mess this up */
 763         tty->ldisc = NULL;
 764
 765         /* Ensure the next open requests the N_TTY ldisc */
 766         tty_set_termios_ldisc(tty, N_TTY);
 767 }
 768
 769 /**
 770  *      tty_ldisc_release               -       release line discipline
 771  *      @tty: tty being shut down (or one end of pty pair)
 772  *
 773  *      Called during the final close of a tty or a pty pair in order to shut
 774  *      down the line discpline layer. On exit, each ldisc assigned is N_TTY and
 775  *      each ldisc has not been opened.
 776  */
 777
 778 void tty_ldisc_release(struct tty_struct *tty)
 779 {
 780         struct tty_struct *o_tty = tty->link;
 781
 782         /*
 783          * Shutdown this line discipline. As this is the final close,
 784          * it does not race with the set_ldisc code path.
 785          */
 786
 787         tty_ldisc_lock_pair(tty, o_tty);
 788         tty_ldisc_kill(tty);
 789         if (o_tty)
 790                 tty_ldisc_kill(o_tty);
 791         tty_ldisc_unlock_pair(tty, o_tty);
 792
 793         /* And the memory resources remaining (buffers, termios) will be
 794            disposed of when the kref hits zero */
 795
 796         tty_ldisc_debug(tty, "released\n");
 797 }
 798
 799 /**
 800  *      tty_ldisc_init          -       ldisc setup for new tty
 801  *      @tty: tty being allocated
 802  *
 803  *      Set up the line discipline objects for a newly allocated tty. Note that
 804  *      the tty structure is not completely set up when this call is made.
 805  */
 806
 807 void tty_ldisc_init(struct tty_struct *tty)
 808 {
 809         struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
 810         if (IS_ERR(ld))
 811                 panic("n_tty: init_tty");
 812         tty->ldisc = ld;
 813 }
 814
 815 /**
 816  *      tty_ldisc_init          -       ldisc cleanup for new tty
 817  *      @tty: tty that was allocated recently
 818  *
 819  *      The tty structure must not becompletely set up (tty_ldisc_setup) when
 820  *      this call is made.
 821  */
 822 void tty_ldisc_deinit(struct tty_struct *tty)
 823 {
 824         tty_ldisc_put(tty->ldisc);
 825         tty->ldisc = NULL;
 826 }
 827
 828 void tty_ldisc_begin(void)
 829 {
 830         /* Setup the default TTY line discipline. */
 831         (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);
 832 }