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>
8 #include <linux/tty_driver.h>
9 #include <linux/file.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>
24 #undef LDISC_DEBUG_HANGUP
26 #ifdef LDISC_DEBUG_HANGUP
27 #define tty_ldisc_debug(tty, f, args...) tty_debug(tty, f, ##args)
29 #define tty_ldisc_debug(tty, f, args...)
32 /* lockdep nested classes for tty->ldisc_sem */
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.
45 static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock);
46 /* Line disc dispatch table */
47 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
50 * tty_register_ldisc - install a line discipline
52 * @new_ldisc: pointer to the ldisc object
54 * Installs a new line discipline into the kernel. The discipline
55 * is set up as unreferenced and then made available to the kernel
56 * from this point onwards.
59 * takes tty_ldiscs_lock to guard against ldisc races
62 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
67 if (disc < N_TTY || disc >= NR_LDISCS)
70 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
71 tty_ldiscs[disc] = new_ldisc;
72 new_ldisc->num = disc;
73 new_ldisc->refcount = 0;
74 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
78 EXPORT_SYMBOL(tty_register_ldisc);
81 * tty_unregister_ldisc - unload a line discipline
84 * Remove a line discipline from the kernel providing it is not
88 * takes tty_ldiscs_lock to guard against ldisc races
91 int tty_unregister_ldisc(int disc)
96 if (disc < N_TTY || disc >= NR_LDISCS)
99 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
100 if (tty_ldiscs[disc]->refcount)
103 tty_ldiscs[disc] = NULL;
104 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
108 EXPORT_SYMBOL(tty_unregister_ldisc);
110 static struct tty_ldisc_ops *get_ldops(int disc)
113 struct tty_ldisc_ops *ldops, *ret;
115 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
116 ret = ERR_PTR(-EINVAL);
117 ldops = tty_ldiscs[disc];
119 ret = ERR_PTR(-EAGAIN);
120 if (try_module_get(ldops->owner)) {
125 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
129 static void put_ldops(struct tty_ldisc_ops *ldops)
133 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
135 module_put(ldops->owner);
136 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
139 static int tty_ldisc_autoload = IS_BUILTIN(CONFIG_LDISC_AUTOLOAD);
141 * tty_ldisc_get - take a reference to an ldisc
143 * @disc: ldisc number
145 * Takes a reference to a line discipline. Deals with refcounts and
146 * module locking counts.
148 * Returns: -EINVAL if the discipline index is not [N_TTY..NR_LDISCS] or
149 * if the discipline is not registered
150 * -EAGAIN if request_module() failed to load or register the
152 * -ENOMEM if allocation failure
154 * Otherwise, returns a pointer to the discipline and bumps the
158 * takes tty_ldiscs_lock to guard against ldisc races
161 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
163 struct tty_ldisc *ld;
164 struct tty_ldisc_ops *ldops;
166 if (disc < N_TTY || disc >= NR_LDISCS)
167 return ERR_PTR(-EINVAL);
170 * Get the ldisc ops - we may need to request them to be loaded
171 * dynamically and try again.
173 ldops = get_ldops(disc);
175 if (!capable(CAP_SYS_MODULE) && !tty_ldisc_autoload)
176 return ERR_PTR(-EPERM);
177 request_module("tty-ldisc-%d", disc);
178 ldops = get_ldops(disc);
180 return ERR_CAST(ldops);
184 * There is no way to handle allocation failure of only 16 bytes.
185 * Let's simplify error handling and save more memory.
187 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL | __GFP_NOFAIL);
195 * tty_ldisc_put - release the ldisc
197 * Complement of tty_ldisc_get().
199 static void tty_ldisc_put(struct tty_ldisc *ld)
201 if (WARN_ON_ONCE(!ld))
208 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
210 return (*pos < NR_LDISCS) ? pos : NULL;
213 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
216 return (*pos < NR_LDISCS) ? pos : NULL;
219 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
223 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
225 int i = *(loff_t *)v;
226 struct tty_ldisc_ops *ldops;
228 ldops = get_ldops(i);
231 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
236 const struct seq_operations tty_ldiscs_seq_ops = {
237 .start = tty_ldiscs_seq_start,
238 .next = tty_ldiscs_seq_next,
239 .stop = tty_ldiscs_seq_stop,
240 .show = tty_ldiscs_seq_show,
244 * tty_ldisc_ref_wait - wait for the tty ldisc
247 * Dereference the line discipline for the terminal and take a
248 * reference to it. If the line discipline is in flux then
249 * wait patiently until it changes.
251 * Returns: NULL if the tty has been hungup and not re-opened with
252 * a new file descriptor, otherwise valid ldisc reference
254 * Note 1: Must not be called from an IRQ/timer context. The caller
255 * must also be careful not to hold other locks that will deadlock
256 * against a discipline change, such as an existing ldisc reference
257 * (which we check for)
259 * Note 2: a file_operations routine (read/poll/write) should use this
260 * function to wait for any ldisc lifetime events to finish.
263 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
265 struct tty_ldisc *ld;
267 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
270 ldsem_up_read(&tty->ldisc_sem);
273 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
276 * tty_ldisc_ref - get the tty ldisc
279 * Dereference the line discipline for the terminal and take a
280 * reference to it. If the line discipline is in flux then
281 * return NULL. Can be called from IRQ and timer functions.
284 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
286 struct tty_ldisc *ld = NULL;
288 if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
291 ldsem_up_read(&tty->ldisc_sem);
295 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
298 * tty_ldisc_deref - free a tty ldisc reference
299 * @ld: reference to free up
301 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
302 * be called in IRQ context.
305 void tty_ldisc_deref(struct tty_ldisc *ld)
307 ldsem_up_read(&ld->tty->ldisc_sem);
309 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
313 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
315 return ldsem_down_write(&tty->ldisc_sem, timeout);
319 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
321 return ldsem_down_write_nested(&tty->ldisc_sem,
322 LDISC_SEM_OTHER, timeout);
325 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
327 ldsem_up_write(&tty->ldisc_sem);
330 int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
334 /* Kindly asking blocked readers to release the read side */
335 set_bit(TTY_LDISC_CHANGING, &tty->flags);
336 wake_up_interruptible_all(&tty->read_wait);
337 wake_up_interruptible_all(&tty->write_wait);
339 ret = __tty_ldisc_lock(tty, timeout);
342 set_bit(TTY_LDISC_HALTED, &tty->flags);
346 void tty_ldisc_unlock(struct tty_struct *tty)
348 clear_bit(TTY_LDISC_HALTED, &tty->flags);
349 /* Can be cleared here - ldisc_unlock will wake up writers firstly */
350 clear_bit(TTY_LDISC_CHANGING, &tty->flags);
351 __tty_ldisc_unlock(tty);
355 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
356 unsigned long timeout)
361 ret = __tty_ldisc_lock(tty, timeout);
363 ret = __tty_ldisc_lock_nested(tty2, timeout);
365 __tty_ldisc_unlock(tty);
368 /* if this is possible, it has lots of implications */
369 WARN_ON_ONCE(tty == tty2);
370 if (tty2 && tty != tty2) {
371 ret = __tty_ldisc_lock(tty2, timeout);
373 ret = __tty_ldisc_lock_nested(tty, timeout);
375 __tty_ldisc_unlock(tty2);
378 ret = __tty_ldisc_lock(tty, timeout);
384 set_bit(TTY_LDISC_HALTED, &tty->flags);
386 set_bit(TTY_LDISC_HALTED, &tty2->flags);
390 static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
392 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
395 static void tty_ldisc_unlock_pair(struct tty_struct *tty,
396 struct tty_struct *tty2)
398 __tty_ldisc_unlock(tty);
400 __tty_ldisc_unlock(tty2);
404 * tty_ldisc_flush - flush line discipline queue
407 * Flush the line discipline queue (if any) and the tty flip buffers
411 void tty_ldisc_flush(struct tty_struct *tty)
413 struct tty_ldisc *ld = tty_ldisc_ref(tty);
415 tty_buffer_flush(tty, ld);
419 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
422 * tty_set_termios_ldisc - set ldisc field
423 * @tty: tty structure
424 * @disc: line discipline number
426 * This is probably overkill for real world processors but
427 * they are not on hot paths so a little discipline won't do
430 * The line discipline-related tty_struct fields are reset to
431 * prevent the ldisc driver from re-using stale information for
432 * the new ldisc instance.
434 * Locking: takes termios_rwsem
437 static void tty_set_termios_ldisc(struct tty_struct *tty, int disc)
439 down_write(&tty->termios_rwsem);
440 tty->termios.c_line = disc;
441 up_write(&tty->termios_rwsem);
443 tty->disc_data = NULL;
444 tty->receive_room = 0;
448 * tty_ldisc_open - open a line discipline
449 * @tty: tty we are opening the ldisc on
450 * @ld: discipline to open
452 * A helper opening method. Also a convenient debugging and check
455 * Locking: always called with BTM already held.
458 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
460 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
463 /* BTM here locks versus a hangup event */
464 ret = ld->ops->open(tty);
466 clear_bit(TTY_LDISC_OPEN, &tty->flags);
468 tty_ldisc_debug(tty, "%p: opened\n", ld);
475 * tty_ldisc_close - close a line discipline
476 * @tty: tty we are opening the ldisc on
477 * @ld: discipline to close
479 * A helper close method. Also a convenient debugging and check
483 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
485 lockdep_assert_held_write(&tty->ldisc_sem);
486 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
487 clear_bit(TTY_LDISC_OPEN, &tty->flags);
490 tty_ldisc_debug(tty, "%p: closed\n", ld);
494 * tty_ldisc_failto - helper for ldisc failback
495 * @tty: tty to open the ldisc on
496 * @ld: ldisc we are trying to fail back to
498 * Helper to try and recover a tty when switching back to the old
499 * ldisc fails and we need something attached.
502 static int tty_ldisc_failto(struct tty_struct *tty, int ld)
504 struct tty_ldisc *disc = tty_ldisc_get(tty, ld);
507 lockdep_assert_held_write(&tty->ldisc_sem);
509 return PTR_ERR(disc);
511 tty_set_termios_ldisc(tty, ld);
512 r = tty_ldisc_open(tty, disc);
519 * tty_ldisc_restore - helper for tty ldisc change
520 * @tty: tty to recover
521 * @old: previous ldisc
523 * Restore the previous line discipline or N_TTY when a line discipline
524 * change fails due to an open error
527 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
529 /* There is an outstanding reference here so this is safe */
530 if (tty_ldisc_failto(tty, old->ops->num) < 0) {
531 const char *name = tty_name(tty);
533 pr_warn("Falling back ldisc for %s.\n", name);
535 * The traditional behaviour is to fall back to N_TTY, we
536 * want to avoid falling back to N_NULL unless we have no
537 * choice to avoid the risk of breaking anything
539 if (tty_ldisc_failto(tty, N_TTY) < 0 &&
540 tty_ldisc_failto(tty, N_NULL) < 0)
541 panic("Couldn't open N_NULL ldisc for %s.", name);
546 * tty_set_ldisc - set line discipline
547 * @tty: the terminal to set
548 * @disc: the line discipline number
550 * Set the discipline of a tty line. Must be called from a process
551 * context. The ldisc change logic has to protect itself against any
552 * overlapping ldisc change (including on the other end of pty pairs),
553 * the close of one side of a tty/pty pair, and eventually hangup.
556 int tty_set_ldisc(struct tty_struct *tty, int disc)
559 struct tty_ldisc *old_ldisc, *new_ldisc;
561 new_ldisc = tty_ldisc_get(tty, disc);
562 if (IS_ERR(new_ldisc))
563 return PTR_ERR(new_ldisc);
566 retval = tty_ldisc_lock(tty, 5 * HZ);
575 /* Check the no-op case */
576 if (tty->ldisc->ops->num == disc)
579 if (test_bit(TTY_HUPPED, &tty->flags)) {
580 /* We were raced by hangup */
585 old_ldisc = tty->ldisc;
587 /* Shutdown the old discipline. */
588 tty_ldisc_close(tty, old_ldisc);
590 /* Now set up the new line discipline. */
591 tty->ldisc = new_ldisc;
592 tty_set_termios_ldisc(tty, disc);
594 retval = tty_ldisc_open(tty, new_ldisc);
596 /* Back to the old one or N_TTY if we can't */
597 tty_ldisc_put(new_ldisc);
598 tty_ldisc_restore(tty, old_ldisc);
601 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
602 down_read(&tty->termios_rwsem);
603 tty->ops->set_ldisc(tty);
604 up_read(&tty->termios_rwsem);
608 * At this point we hold a reference to the new ldisc and a
609 * reference to the old ldisc, or we hold two references to
610 * the old ldisc (if it was restored as part of error cleanup
611 * above). In either case, releasing a single reference from
612 * the old ldisc is correct.
614 new_ldisc = old_ldisc;
616 tty_ldisc_unlock(tty);
619 * Restart the work queue in case no characters kick it off. Safe if
622 tty_buffer_restart_work(tty->port);
624 tty_ldisc_put(new_ldisc); /* drop the extra reference */
628 EXPORT_SYMBOL_GPL(tty_set_ldisc);
631 * tty_ldisc_kill - teardown ldisc
632 * @tty: tty being released
634 * Perform final close of the ldisc and reset tty->ldisc
636 static void tty_ldisc_kill(struct tty_struct *tty)
638 lockdep_assert_held_write(&tty->ldisc_sem);
642 * Now kill off the ldisc
644 tty_ldisc_close(tty, tty->ldisc);
645 tty_ldisc_put(tty->ldisc);
646 /* Force an oops if we mess this up */
651 * tty_reset_termios - reset terminal state
654 * Restore a terminal to the driver default state.
657 static void tty_reset_termios(struct tty_struct *tty)
659 down_write(&tty->termios_rwsem);
660 tty->termios = tty->driver->init_termios;
661 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
662 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
663 up_write(&tty->termios_rwsem);
668 * tty_ldisc_reinit - reinitialise the tty ldisc
669 * @tty: tty to reinit
670 * @disc: line discipline to reinitialize
672 * Completely reinitialize the line discipline state, by closing the
673 * current instance, if there is one, and opening a new instance. If
674 * an error occurs opening the new non-N_TTY instance, the instance
675 * is dropped and tty->ldisc reset to NULL. The caller can then retry
676 * with N_TTY instead.
678 * Returns 0 if successful, otherwise error code < 0
681 int tty_ldisc_reinit(struct tty_struct *tty, int disc)
683 struct tty_ldisc *ld;
686 lockdep_assert_held_write(&tty->ldisc_sem);
687 ld = tty_ldisc_get(tty, disc);
689 BUG_ON(disc == N_TTY);
694 tty_ldisc_close(tty, tty->ldisc);
695 tty_ldisc_put(tty->ldisc);
698 /* switch the line discipline */
700 tty_set_termios_ldisc(tty, disc);
701 retval = tty_ldisc_open(tty, tty->ldisc);
703 tty_ldisc_put(tty->ldisc);
710 * tty_ldisc_hangup - hangup ldisc reset
711 * @tty: tty being hung up
712 * @reinit: whether to re-initialise the tty
714 * Some tty devices reset their termios when they receive a hangup
715 * event. In that situation we must also switch back to N_TTY properly
716 * before we reset the termios data.
718 * Locking: We can take the ldisc mutex as the rest of the code is
719 * careful to allow for this.
721 * In the pty pair case this occurs in the close() path of the
722 * tty itself so we must be careful about locking rules.
725 void tty_ldisc_hangup(struct tty_struct *tty, bool reinit)
727 struct tty_ldisc *ld;
729 tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
731 ld = tty_ldisc_ref(tty);
733 if (ld->ops->flush_buffer)
734 ld->ops->flush_buffer(tty);
735 tty_driver_flush_buffer(tty);
736 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
737 ld->ops->write_wakeup)
738 ld->ops->write_wakeup(tty);
740 ld->ops->hangup(tty);
744 wake_up_interruptible_poll(&tty->write_wait, EPOLLOUT);
745 wake_up_interruptible_poll(&tty->read_wait, EPOLLIN);
748 * Shutdown the current line discipline, and reset it to
751 * Avoid racing set_ldisc or tty_ldisc_release
753 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
755 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
756 tty_reset_termios(tty);
760 if (tty_ldisc_reinit(tty, tty->termios.c_line) < 0 &&
761 tty_ldisc_reinit(tty, N_TTY) < 0)
762 WARN_ON(tty_ldisc_reinit(tty, N_NULL) < 0);
766 tty_ldisc_unlock(tty);
770 * tty_ldisc_setup - open line discipline
771 * @tty: tty being shut down
772 * @o_tty: pair tty for pty/tty pairs
774 * Called during the initial open of a tty/pty pair in order to set up the
775 * line disciplines and bind them to the tty. This has no locking issues
776 * as the device isn't yet active.
779 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
781 int retval = tty_ldisc_open(tty, tty->ldisc);
788 * Called without o_tty->ldisc_sem held, as o_tty has been
789 * just allocated and no one has a reference to it.
791 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
793 tty_ldisc_close(tty, tty->ldisc);
801 * tty_ldisc_release - release line discipline
802 * @tty: tty being shut down (or one end of pty pair)
804 * Called during the final close of a tty or a pty pair in order to shut
805 * down the line discpline layer. On exit, each tty's ldisc is NULL.
808 void tty_ldisc_release(struct tty_struct *tty)
810 struct tty_struct *o_tty = tty->link;
813 * Shutdown this line discipline. As this is the final close,
814 * it does not race with the set_ldisc code path.
817 tty_ldisc_lock_pair(tty, o_tty);
820 tty_ldisc_kill(o_tty);
821 tty_ldisc_unlock_pair(tty, o_tty);
824 * And the memory resources remaining (buffers, termios) will be
825 * disposed of when the kref hits zero
828 tty_ldisc_debug(tty, "released\n");
830 EXPORT_SYMBOL_GPL(tty_ldisc_release);
833 * tty_ldisc_init - ldisc setup for new tty
834 * @tty: tty being allocated
836 * Set up the line discipline objects for a newly allocated tty. Note that
837 * the tty structure is not completely set up when this call is made.
840 int tty_ldisc_init(struct tty_struct *tty)
842 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
851 * tty_ldisc_deinit - ldisc cleanup for new tty
852 * @tty: tty that was allocated recently
854 * The tty structure must not becompletely set up (tty_ldisc_setup) when
857 void tty_ldisc_deinit(struct tty_struct *tty)
859 /* no ldisc_sem, tty is being destroyed */
861 tty_ldisc_put(tty->ldisc);
865 static struct ctl_table tty_table[] = {
867 .procname = "ldisc_autoload",
868 .data = &tty_ldisc_autoload,
869 .maxlen = sizeof(tty_ldisc_autoload),
871 .proc_handler = proc_dointvec,
872 .extra1 = SYSCTL_ZERO,
873 .extra2 = SYSCTL_ONE,
878 static struct ctl_table tty_dir_table[] = {
887 static struct ctl_table tty_root_table[] = {
891 .child = tty_dir_table,
896 void tty_sysctl_init(void)
898 register_sysctl_table(tty_root_table);