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