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