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