1 #include <linux/types.h>
2 #include <linux/errno.h>
3 #include <linux/kmod.h>
4 #include <linux/sched.h>
5 #include <linux/interrupt.h>
7 #include <linux/tty_driver.h>
8 #include <linux/file.h>
10 #include <linux/string.h>
11 #include <linux/slab.h>
12 #include <linux/poll.h>
13 #include <linux/proc_fs.h>
14 #include <linux/module.h>
15 #include <linux/device.h>
16 #include <linux/wait.h>
17 #include <linux/bitops.h>
18 #include <linux/seq_file.h>
19 #include <linux/uaccess.h>
20 #include <linux/ratelimit.h>
22 #undef LDISC_DEBUG_HANGUP
24 #ifdef LDISC_DEBUG_HANGUP
25 #define tty_ldisc_debug(tty, f, args...) tty_debug(tty, f, ##args)
27 #define tty_ldisc_debug(tty, f, args...)
30 /* lockdep nested classes for tty->ldisc_sem */
38 * This guards the refcounted line discipline lists. The lock
39 * must be taken with irqs off because there are hangup path
40 * callers who will do ldisc lookups and cannot sleep.
43 static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock);
44 /* Line disc dispatch table */
45 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
48 * tty_register_ldisc - install a line discipline
50 * @new_ldisc: pointer to the ldisc object
52 * Installs a new line discipline into the kernel. The discipline
53 * is set up as unreferenced and then made available to the kernel
54 * from this point onwards.
57 * takes tty_ldiscs_lock to guard against ldisc races
60 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
65 if (disc < N_TTY || disc >= NR_LDISCS)
68 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
69 tty_ldiscs[disc] = new_ldisc;
70 new_ldisc->num = disc;
71 new_ldisc->refcount = 0;
72 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
76 EXPORT_SYMBOL(tty_register_ldisc);
79 * tty_unregister_ldisc - unload a line discipline
81 * @new_ldisc: pointer to the ldisc object
83 * Remove a line discipline from the kernel providing it is not
87 * takes tty_ldiscs_lock to guard against ldisc races
90 int tty_unregister_ldisc(int disc)
95 if (disc < N_TTY || disc >= NR_LDISCS)
98 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
99 if (tty_ldiscs[disc]->refcount)
102 tty_ldiscs[disc] = NULL;
103 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
107 EXPORT_SYMBOL(tty_unregister_ldisc);
109 static struct tty_ldisc_ops *get_ldops(int disc)
112 struct tty_ldisc_ops *ldops, *ret;
114 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
115 ret = ERR_PTR(-EINVAL);
116 ldops = tty_ldiscs[disc];
118 ret = ERR_PTR(-EAGAIN);
119 if (try_module_get(ldops->owner)) {
124 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
128 static void put_ldops(struct tty_ldisc_ops *ldops)
132 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
134 module_put(ldops->owner);
135 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
139 * tty_ldisc_get - take a reference to an ldisc
140 * @disc: ldisc number
142 * Takes a reference to a line discipline. Deals with refcounts and
143 * module locking counts.
145 * Returns: -EINVAL if the discipline index is not [N_TTY..NR_LDISCS] or
146 * if the discipline is not registered
147 * -EAGAIN if request_module() failed to load or register the
149 * -ENOMEM if allocation failure
151 * Otherwise, returns a pointer to the discipline and bumps the
155 * takes tty_ldiscs_lock to guard against ldisc races
158 #if defined(CONFIG_LDISC_AUTOLOAD)
159 #define INITIAL_AUTOLOAD_STATE 1
161 #define INITIAL_AUTOLOAD_STATE 0
163 static int tty_ldisc_autoload = INITIAL_AUTOLOAD_STATE;
165 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
167 struct tty_ldisc *ld;
168 struct tty_ldisc_ops *ldops;
170 if (disc < N_TTY || disc >= NR_LDISCS)
171 return ERR_PTR(-EINVAL);
174 * Get the ldisc ops - we may need to request them to be loaded
175 * dynamically and try again.
177 ldops = get_ldops(disc);
179 if (!capable(CAP_SYS_MODULE) && !tty_ldisc_autoload)
180 return ERR_PTR(-EPERM);
181 request_module("tty-ldisc-%d", disc);
182 ldops = get_ldops(disc);
184 return ERR_CAST(ldops);
188 * There is no way to handle allocation failure of only 16 bytes.
189 * Let's simplify error handling and save more memory.
191 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL | __GFP_NOFAIL);
199 * tty_ldisc_put - release the ldisc
201 * Complement of tty_ldisc_get().
203 static void tty_ldisc_put(struct tty_ldisc *ld)
205 if (WARN_ON_ONCE(!ld))
212 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
214 return (*pos < NR_LDISCS) ? pos : NULL;
217 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
220 return (*pos < NR_LDISCS) ? pos : NULL;
223 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
227 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
229 int i = *(loff_t *)v;
230 struct tty_ldisc_ops *ldops;
232 ldops = get_ldops(i);
235 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
240 static const struct seq_operations tty_ldiscs_seq_ops = {
241 .start = tty_ldiscs_seq_start,
242 .next = tty_ldiscs_seq_next,
243 .stop = tty_ldiscs_seq_stop,
244 .show = tty_ldiscs_seq_show,
247 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
249 return seq_open(file, &tty_ldiscs_seq_ops);
252 const struct file_operations tty_ldiscs_proc_fops = {
253 .owner = THIS_MODULE,
254 .open = proc_tty_ldiscs_open,
257 .release = seq_release,
261 * tty_ldisc_ref_wait - wait for the tty ldisc
264 * Dereference the line discipline for the terminal and take a
265 * reference to it. If the line discipline is in flux then
266 * wait patiently until it changes.
268 * Returns: NULL if the tty has been hungup and not re-opened with
269 * a new file descriptor, otherwise valid ldisc reference
271 * Note: Must not be called from an IRQ/timer context. The caller
272 * must also be careful not to hold other locks that will deadlock
273 * against a discipline change, such as an existing ldisc reference
274 * (which we check for)
276 * Note: a file_operations routine (read/poll/write) should use this
277 * function to wait for any ldisc lifetime events to finish.
280 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
282 struct tty_ldisc *ld;
284 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
287 ldsem_up_read(&tty->ldisc_sem);
290 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
293 * tty_ldisc_ref - get the tty ldisc
296 * Dereference the line discipline for the terminal and take a
297 * reference to it. If the line discipline is in flux then
298 * return NULL. Can be called from IRQ and timer functions.
301 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
303 struct tty_ldisc *ld = NULL;
305 if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
308 ldsem_up_read(&tty->ldisc_sem);
312 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
315 * tty_ldisc_deref - free a tty ldisc reference
316 * @ld: reference to free up
318 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
319 * be called in IRQ context.
322 void tty_ldisc_deref(struct tty_ldisc *ld)
324 ldsem_up_read(&ld->tty->ldisc_sem);
326 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
330 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
332 return ldsem_down_write(&tty->ldisc_sem, timeout);
336 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
338 return ldsem_down_write_nested(&tty->ldisc_sem,
339 LDISC_SEM_OTHER, timeout);
342 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
344 ldsem_up_write(&tty->ldisc_sem);
347 int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
351 /* Kindly asking blocked readers to release the read side */
352 set_bit(TTY_LDISC_CHANGING, &tty->flags);
353 wake_up_interruptible_all(&tty->read_wait);
354 wake_up_interruptible_all(&tty->write_wait);
356 ret = __tty_ldisc_lock(tty, timeout);
359 set_bit(TTY_LDISC_HALTED, &tty->flags);
363 void tty_ldisc_unlock(struct tty_struct *tty)
365 clear_bit(TTY_LDISC_HALTED, &tty->flags);
366 /* Can be cleared here - ldisc_unlock will wake up writers firstly */
367 clear_bit(TTY_LDISC_CHANGING, &tty->flags);
368 __tty_ldisc_unlock(tty);
372 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
373 unsigned long timeout)
378 ret = __tty_ldisc_lock(tty, timeout);
380 ret = __tty_ldisc_lock_nested(tty2, timeout);
382 __tty_ldisc_unlock(tty);
385 /* if this is possible, it has lots of implications */
386 WARN_ON_ONCE(tty == tty2);
387 if (tty2 && tty != tty2) {
388 ret = __tty_ldisc_lock(tty2, timeout);
390 ret = __tty_ldisc_lock_nested(tty, timeout);
392 __tty_ldisc_unlock(tty2);
395 ret = __tty_ldisc_lock(tty, timeout);
401 set_bit(TTY_LDISC_HALTED, &tty->flags);
403 set_bit(TTY_LDISC_HALTED, &tty2->flags);
407 static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
409 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
412 static void tty_ldisc_unlock_pair(struct tty_struct *tty,
413 struct tty_struct *tty2)
415 __tty_ldisc_unlock(tty);
417 __tty_ldisc_unlock(tty2);
421 * tty_ldisc_flush - flush line discipline queue
424 * Flush the line discipline queue (if any) and the tty flip buffers
428 void tty_ldisc_flush(struct tty_struct *tty)
430 struct tty_ldisc *ld = tty_ldisc_ref(tty);
432 tty_buffer_flush(tty, ld);
436 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
439 * tty_set_termios_ldisc - set ldisc field
440 * @tty: tty structure
441 * @disc: line discipline number
443 * This is probably overkill for real world processors but
444 * they are not on hot paths so a little discipline won't do
447 * The line discipline-related tty_struct fields are reset to
448 * prevent the ldisc driver from re-using stale information for
449 * the new ldisc instance.
451 * Locking: takes termios_rwsem
454 static void tty_set_termios_ldisc(struct tty_struct *tty, int disc)
456 down_write(&tty->termios_rwsem);
457 tty->termios.c_line = disc;
458 up_write(&tty->termios_rwsem);
460 tty->disc_data = NULL;
461 tty->receive_room = 0;
465 * tty_ldisc_open - open a line discipline
466 * @tty: tty we are opening the ldisc on
467 * @ld: discipline to open
469 * A helper opening method. Also a convenient debugging and check
472 * Locking: always called with BTM already held.
475 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
477 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
480 /* BTM here locks versus a hangup event */
481 ret = ld->ops->open(tty);
483 clear_bit(TTY_LDISC_OPEN, &tty->flags);
485 tty_ldisc_debug(tty, "%p: opened\n", ld);
492 * tty_ldisc_close - close a line discipline
493 * @tty: tty we are opening the ldisc on
494 * @ld: discipline to close
496 * A helper close method. Also a convenient debugging and check
500 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
502 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
503 clear_bit(TTY_LDISC_OPEN, &tty->flags);
506 tty_ldisc_debug(tty, "%p: closed\n", ld);
510 * tty_ldisc_failto - helper for ldisc failback
511 * @tty: tty to open the ldisc on
512 * @ld: ldisc we are trying to fail back to
514 * Helper to try and recover a tty when switching back to the old
515 * ldisc fails and we need something attached.
518 static int tty_ldisc_failto(struct tty_struct *tty, int ld)
520 struct tty_ldisc *disc = tty_ldisc_get(tty, ld);
524 return PTR_ERR(disc);
526 tty_set_termios_ldisc(tty, ld);
527 if ((r = tty_ldisc_open(tty, disc)) < 0)
533 * tty_ldisc_restore - helper for tty ldisc change
534 * @tty: tty to recover
535 * @old: previous ldisc
537 * Restore the previous line discipline or N_TTY when a line discipline
538 * change fails due to an open error
541 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
543 /* There is an outstanding reference here so this is safe */
544 if (tty_ldisc_failto(tty, old->ops->num) < 0) {
545 const char *name = tty_name(tty);
547 pr_warn("Falling back ldisc for %s.\n", name);
548 /* The traditional behaviour is to fall back to N_TTY, we
549 want to avoid falling back to N_NULL unless we have no
550 choice to avoid the risk of breaking anything */
551 if (tty_ldisc_failto(tty, N_TTY) < 0 &&
552 tty_ldisc_failto(tty, N_NULL) < 0)
553 panic("Couldn't open N_NULL ldisc for %s.", name);
558 * tty_set_ldisc - set line discipline
559 * @tty: the terminal to set
560 * @ldisc: the line discipline
562 * Set the discipline of a tty line. Must be called from a process
563 * context. The ldisc change logic has to protect itself against any
564 * overlapping ldisc change (including on the other end of pty pairs),
565 * the close of one side of a tty/pty pair, and eventually hangup.
568 int tty_set_ldisc(struct tty_struct *tty, int disc)
571 struct tty_ldisc *old_ldisc, *new_ldisc;
573 new_ldisc = tty_ldisc_get(tty, disc);
574 if (IS_ERR(new_ldisc))
575 return PTR_ERR(new_ldisc);
578 retval = tty_ldisc_lock(tty, 5 * HZ);
587 /* Check the no-op case */
588 if (tty->ldisc->ops->num == disc)
591 if (test_bit(TTY_HUPPED, &tty->flags)) {
592 /* We were raced by hangup */
597 old_ldisc = tty->ldisc;
599 /* Shutdown the old discipline. */
600 tty_ldisc_close(tty, old_ldisc);
602 /* Now set up the new line discipline. */
603 tty->ldisc = new_ldisc;
604 tty_set_termios_ldisc(tty, disc);
606 retval = tty_ldisc_open(tty, new_ldisc);
608 /* Back to the old one or N_TTY if we can't */
609 tty_ldisc_put(new_ldisc);
610 tty_ldisc_restore(tty, old_ldisc);
613 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
614 down_read(&tty->termios_rwsem);
615 tty->ops->set_ldisc(tty);
616 up_read(&tty->termios_rwsem);
619 /* At this point we hold a reference to the new ldisc and a
620 reference to the old ldisc, or we hold two references to
621 the old ldisc (if it was restored as part of error cleanup
622 above). In either case, releasing a single reference from
623 the old ldisc is correct. */
624 new_ldisc = old_ldisc;
626 tty_ldisc_unlock(tty);
628 /* Restart the work queue in case no characters kick it off. Safe if
630 tty_buffer_restart_work(tty->port);
632 tty_ldisc_put(new_ldisc); /* drop the extra reference */
636 EXPORT_SYMBOL_GPL(tty_set_ldisc);
639 * tty_ldisc_kill - teardown ldisc
640 * @tty: tty being released
642 * Perform final close of the ldisc and reset tty->ldisc
644 static void tty_ldisc_kill(struct tty_struct *tty)
649 * Now kill off the ldisc
651 tty_ldisc_close(tty, tty->ldisc);
652 tty_ldisc_put(tty->ldisc);
653 /* Force an oops if we mess this up */
658 * tty_reset_termios - reset terminal state
661 * Restore a terminal to the driver default state.
664 static void tty_reset_termios(struct tty_struct *tty)
666 down_write(&tty->termios_rwsem);
667 tty->termios = tty->driver->init_termios;
668 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
669 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
670 up_write(&tty->termios_rwsem);
675 * tty_ldisc_reinit - reinitialise the tty ldisc
676 * @tty: tty to reinit
677 * @disc: line discipline to reinitialize
679 * Completely reinitialize the line discipline state, by closing the
680 * current instance, if there is one, and opening a new instance. If
681 * an error occurs opening the new non-N_TTY instance, the instance
682 * is dropped and tty->ldisc reset to NULL. The caller can then retry
683 * with N_TTY instead.
685 * Returns 0 if successful, otherwise error code < 0
688 int tty_ldisc_reinit(struct tty_struct *tty, int disc)
690 struct tty_ldisc *ld;
693 ld = tty_ldisc_get(tty, disc);
695 BUG_ON(disc == N_TTY);
700 tty_ldisc_close(tty, tty->ldisc);
701 tty_ldisc_put(tty->ldisc);
704 /* switch the line discipline */
706 tty_set_termios_ldisc(tty, disc);
707 retval = tty_ldisc_open(tty, tty->ldisc);
709 tty_ldisc_put(tty->ldisc);
716 * tty_ldisc_hangup - hangup ldisc reset
717 * @tty: tty being hung up
719 * Some tty devices reset their termios when they receive a hangup
720 * event. In that situation we must also switch back to N_TTY properly
721 * before we reset the termios data.
723 * Locking: We can take the ldisc mutex as the rest of the code is
724 * careful to allow for this.
726 * In the pty pair case this occurs in the close() path of the
727 * tty itself so we must be careful about locking rules.
730 void tty_ldisc_hangup(struct tty_struct *tty, bool reinit)
732 struct tty_ldisc *ld;
734 tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
736 ld = tty_ldisc_ref(tty);
738 if (ld->ops->flush_buffer)
739 ld->ops->flush_buffer(tty);
740 tty_driver_flush_buffer(tty);
741 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
742 ld->ops->write_wakeup)
743 ld->ops->write_wakeup(tty);
745 ld->ops->hangup(tty);
749 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
750 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
753 * Shutdown the current line discipline, and reset it to
756 * Avoid racing set_ldisc or tty_ldisc_release
758 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
760 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
761 tty_reset_termios(tty);
765 if (tty_ldisc_reinit(tty, tty->termios.c_line) < 0 &&
766 tty_ldisc_reinit(tty, N_TTY) < 0)
767 WARN_ON(tty_ldisc_reinit(tty, N_NULL) < 0);
771 tty_ldisc_unlock(tty);
775 * tty_ldisc_setup - open line discipline
776 * @tty: tty being shut down
777 * @o_tty: pair tty for pty/tty pairs
779 * Called during the initial open of a tty/pty pair in order to set up the
780 * line disciplines and bind them to the tty. This has no locking issues
781 * as the device isn't yet active.
784 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
786 int retval = tty_ldisc_open(tty, tty->ldisc);
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);
823 /* And the memory resources remaining (buffers, termios) will be
824 disposed of when the kref hits zero */
826 tty_ldisc_debug(tty, "released\n");
828 EXPORT_SYMBOL_GPL(tty_ldisc_release);
831 * tty_ldisc_init - ldisc setup for new tty
832 * @tty: tty being allocated
834 * Set up the line discipline objects for a newly allocated tty. Note that
835 * the tty structure is not completely set up when this call is made.
838 int tty_ldisc_init(struct tty_struct *tty)
840 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
848 * tty_ldisc_deinit - ldisc cleanup for new tty
849 * @tty: tty that was allocated recently
851 * The tty structure must not becompletely set up (tty_ldisc_setup) when
854 void tty_ldisc_deinit(struct tty_struct *tty)
857 tty_ldisc_put(tty->ldisc);
863 static struct ctl_table tty_table[] = {
865 .procname = "ldisc_autoload",
866 .data = &tty_ldisc_autoload,
867 .maxlen = sizeof(tty_ldisc_autoload),
869 .proc_handler = proc_dointvec,
876 static struct ctl_table tty_dir_table[] = {
885 static struct ctl_table tty_root_table[] = {
889 .child = tty_dir_table,
894 void tty_sysctl_init(void)
896 register_sysctl_table(tty_root_table);