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