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