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 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
160 struct tty_ldisc *ld;
161 struct tty_ldisc_ops *ldops;
163 if (disc < N_TTY || disc >= NR_LDISCS)
164 return ERR_PTR(-EINVAL);
167 * Get the ldisc ops - we may need to request them to be loaded
168 * dynamically and try again.
170 ldops = get_ldops(disc);
172 request_module("tty-ldisc-%d", disc);
173 ldops = get_ldops(disc);
175 return ERR_CAST(ldops);
178 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
181 return ERR_PTR(-ENOMEM);
191 * tty_ldisc_put - release the ldisc
193 * Complement of tty_ldisc_get().
195 static void tty_ldisc_put(struct tty_ldisc *ld)
197 if (WARN_ON_ONCE(!ld))
204 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
206 return (*pos < NR_LDISCS) ? pos : NULL;
209 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
212 return (*pos < NR_LDISCS) ? pos : NULL;
215 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
219 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
221 int i = *(loff_t *)v;
222 struct tty_ldisc_ops *ldops;
224 ldops = get_ldops(i);
227 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
232 static 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,
239 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
241 return seq_open(file, &tty_ldiscs_seq_ops);
244 const struct file_operations tty_ldiscs_proc_fops = {
245 .owner = THIS_MODULE,
246 .open = proc_tty_ldiscs_open,
249 .release = seq_release,
253 * tty_ldisc_ref_wait - wait for the tty ldisc
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.
260 * Returns: NULL if the tty has been hungup and not re-opened with
261 * a new file descriptor, otherwise valid ldisc reference
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)
268 * Note: a file_operations routine (read/poll/write) should use this
269 * function to wait for any ldisc lifetime events to finish.
272 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
274 struct tty_ldisc *ld;
276 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
279 ldsem_up_read(&tty->ldisc_sem);
282 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
285 * tty_ldisc_ref - get the tty ldisc
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.
293 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
295 struct tty_ldisc *ld = NULL;
297 if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
300 ldsem_up_read(&tty->ldisc_sem);
304 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
307 * tty_ldisc_deref - free a tty ldisc reference
308 * @ld: reference to free up
310 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
311 * be called in IRQ context.
314 void tty_ldisc_deref(struct tty_ldisc *ld)
316 ldsem_up_read(&ld->tty->ldisc_sem);
318 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
322 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
324 return ldsem_down_write(&tty->ldisc_sem, timeout);
328 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
330 return ldsem_down_write_nested(&tty->ldisc_sem,
331 LDISC_SEM_OTHER, timeout);
334 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
336 ldsem_up_write(&tty->ldisc_sem);
339 int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
343 ret = __tty_ldisc_lock(tty, timeout);
346 set_bit(TTY_LDISC_HALTED, &tty->flags);
350 void tty_ldisc_unlock(struct tty_struct *tty)
352 clear_bit(TTY_LDISC_HALTED, &tty->flags);
353 __tty_ldisc_unlock(tty);
357 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
358 unsigned long timeout)
363 ret = __tty_ldisc_lock(tty, timeout);
365 ret = __tty_ldisc_lock_nested(tty2, timeout);
367 __tty_ldisc_unlock(tty);
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);
375 ret = __tty_ldisc_lock_nested(tty, timeout);
377 __tty_ldisc_unlock(tty2);
380 ret = __tty_ldisc_lock(tty, timeout);
386 set_bit(TTY_LDISC_HALTED, &tty->flags);
388 set_bit(TTY_LDISC_HALTED, &tty2->flags);
392 static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
394 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
397 static void tty_ldisc_unlock_pair(struct tty_struct *tty,
398 struct tty_struct *tty2)
400 __tty_ldisc_unlock(tty);
402 __tty_ldisc_unlock(tty2);
406 * tty_ldisc_flush - flush line discipline queue
409 * Flush the line discipline queue (if any) and the tty flip buffers
413 void tty_ldisc_flush(struct tty_struct *tty)
415 struct tty_ldisc *ld = tty_ldisc_ref(tty);
417 tty_buffer_flush(tty, ld);
421 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
424 * tty_set_termios_ldisc - set ldisc field
425 * @tty: tty structure
426 * @disc: line discipline number
428 * This is probably overkill for real world processors but
429 * they are not on hot paths so a little discipline won't do
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.
436 * Locking: takes termios_rwsem
439 static void tty_set_termios_ldisc(struct tty_struct *tty, int disc)
441 down_write(&tty->termios_rwsem);
442 tty->termios.c_line = disc;
443 up_write(&tty->termios_rwsem);
445 tty->disc_data = NULL;
446 tty->receive_room = 0;
450 * tty_ldisc_open - open a line discipline
451 * @tty: tty we are opening the ldisc on
452 * @ld: discipline to open
454 * A helper opening method. Also a convenient debugging and check
457 * Locking: always called with BTM already held.
460 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
462 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
465 /* BTM here locks versus a hangup event */
466 ret = ld->ops->open(tty);
468 clear_bit(TTY_LDISC_OPEN, &tty->flags);
470 tty_ldisc_debug(tty, "%p: opened\n", ld);
477 * tty_ldisc_close - close a line discipline
478 * @tty: tty we are opening the ldisc on
479 * @ld: discipline to close
481 * A helper close method. Also a convenient debugging and check
485 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
487 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
488 clear_bit(TTY_LDISC_OPEN, &tty->flags);
491 tty_ldisc_debug(tty, "%p: closed\n", ld);
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
499 * Helper to try and recover a tty when switching back to the old
500 * ldisc fails and we need something attached.
503 static int tty_ldisc_failto(struct tty_struct *tty, int ld)
505 struct tty_ldisc *disc = tty_ldisc_get(tty, ld);
509 return PTR_ERR(disc);
511 tty_set_termios_ldisc(tty, ld);
512 if ((r = tty_ldisc_open(tty, disc)) < 0)
518 * tty_ldisc_restore - helper for tty ldisc change
519 * @tty: tty to recover
520 * @old: previous ldisc
522 * Restore the previous line discipline or N_TTY when a line discipline
523 * change fails due to an open error
526 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
528 /* There is an outstanding reference here so this is safe */
529 old = tty_ldisc_get(tty, old->ops->num);
530 WARN_ON(IS_ERR(old));
532 tty_set_termios_ldisc(tty, old->ops->num);
533 if (tty_ldisc_open(tty, old) < 0) {
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 */
538 if (tty_ldisc_failto(tty, N_TTY) < 0 &&
539 tty_ldisc_failto(tty, N_NULL) < 0)
540 panic("Couldn't open N_NULL ldisc for %s.",
546 * tty_set_ldisc - set line discipline
547 * @tty: the terminal to set
548 * @ldisc: the line discipline
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);
607 /* At this point we hold a reference to the new ldisc and a
608 reference to the old ldisc, or we hold two references to
609 the old ldisc (if it was restored as part of error cleanup
610 above). In either case, releasing a single reference from
611 the old ldisc is correct. */
612 new_ldisc = old_ldisc;
614 tty_ldisc_unlock(tty);
616 /* Restart the work queue in case no characters kick it off. Safe if
618 tty_buffer_restart_work(tty->port);
620 tty_ldisc_put(new_ldisc); /* drop the extra reference */
624 EXPORT_SYMBOL_GPL(tty_set_ldisc);
627 * tty_ldisc_kill - teardown ldisc
628 * @tty: tty being released
630 * Perform final close of the ldisc and reset tty->ldisc
632 static void tty_ldisc_kill(struct tty_struct *tty)
637 * Now kill off the ldisc
639 tty_ldisc_close(tty, tty->ldisc);
640 tty_ldisc_put(tty->ldisc);
641 /* Force an oops if we mess this up */
646 * tty_reset_termios - reset terminal state
649 * Restore a terminal to the driver default state.
652 static void tty_reset_termios(struct tty_struct *tty)
654 down_write(&tty->termios_rwsem);
655 tty->termios = tty->driver->init_termios;
656 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
657 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
658 up_write(&tty->termios_rwsem);
663 * tty_ldisc_reinit - reinitialise the tty ldisc
664 * @tty: tty to reinit
665 * @disc: line discipline to reinitialize
667 * Completely reinitialize the line discipline state, by closing the
668 * current instance, if there is one, and opening a new instance. If
669 * an error occurs opening the new non-N_TTY instance, the instance
670 * is dropped and tty->ldisc reset to NULL. The caller can then retry
671 * with N_TTY instead.
673 * Returns 0 if successful, otherwise error code < 0
676 int tty_ldisc_reinit(struct tty_struct *tty, int disc)
678 struct tty_ldisc *ld;
681 ld = tty_ldisc_get(tty, disc);
683 BUG_ON(disc == N_TTY);
688 tty_ldisc_close(tty, tty->ldisc);
689 tty_ldisc_put(tty->ldisc);
692 /* switch the line discipline */
694 tty_set_termios_ldisc(tty, disc);
695 retval = tty_ldisc_open(tty, tty->ldisc);
697 tty_ldisc_put(tty->ldisc);
704 * tty_ldisc_hangup - hangup ldisc reset
705 * @tty: tty being hung up
707 * Some tty devices reset their termios when they receive a hangup
708 * event. In that situation we must also switch back to N_TTY properly
709 * before we reset the termios data.
711 * Locking: We can take the ldisc mutex as the rest of the code is
712 * careful to allow for this.
714 * In the pty pair case this occurs in the close() path of the
715 * tty itself so we must be careful about locking rules.
718 void tty_ldisc_hangup(struct tty_struct *tty, bool reinit)
720 struct tty_ldisc *ld;
722 tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
724 ld = tty_ldisc_ref(tty);
726 if (ld->ops->flush_buffer)
727 ld->ops->flush_buffer(tty);
728 tty_driver_flush_buffer(tty);
729 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
730 ld->ops->write_wakeup)
731 ld->ops->write_wakeup(tty);
733 ld->ops->hangup(tty);
737 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
738 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
741 * Shutdown the current line discipline, and reset it to
744 * Avoid racing set_ldisc or tty_ldisc_release
746 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
748 if (tty->driver->flags & TTY_DRIVER_RESET_TERMIOS)
749 tty_reset_termios(tty);
753 if (tty_ldisc_reinit(tty, tty->termios.c_line) < 0 &&
754 tty_ldisc_reinit(tty, N_TTY) < 0)
755 WARN_ON(tty_ldisc_reinit(tty, N_NULL) < 0);
759 tty_ldisc_unlock(tty);
763 * tty_ldisc_setup - open line discipline
764 * @tty: tty being shut down
765 * @o_tty: pair tty for pty/tty pairs
767 * Called during the initial open of a tty/pty pair in order to set up the
768 * line disciplines and bind them to the tty. This has no locking issues
769 * as the device isn't yet active.
772 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
774 int retval = tty_ldisc_open(tty, tty->ldisc);
779 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
781 tty_ldisc_close(tty, tty->ldisc);
789 * tty_ldisc_release - release line discipline
790 * @tty: tty being shut down (or one end of pty pair)
792 * Called during the final close of a tty or a pty pair in order to shut
793 * down the line discpline layer. On exit, each tty's ldisc is NULL.
796 void tty_ldisc_release(struct tty_struct *tty)
798 struct tty_struct *o_tty = tty->link;
801 * Shutdown this line discipline. As this is the final close,
802 * it does not race with the set_ldisc code path.
805 tty_ldisc_lock_pair(tty, o_tty);
808 tty_ldisc_kill(o_tty);
809 tty_ldisc_unlock_pair(tty, o_tty);
811 /* And the memory resources remaining (buffers, termios) will be
812 disposed of when the kref hits zero */
814 tty_ldisc_debug(tty, "released\n");
816 EXPORT_SYMBOL_GPL(tty_ldisc_release);
819 * tty_ldisc_init - ldisc setup for new tty
820 * @tty: tty being allocated
822 * Set up the line discipline objects for a newly allocated tty. Note that
823 * the tty structure is not completely set up when this call is made.
826 void tty_ldisc_init(struct tty_struct *tty)
828 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
830 panic("n_tty: init_tty");
835 * tty_ldisc_deinit - ldisc cleanup for new tty
836 * @tty: tty that was allocated recently
838 * The tty structure must not becompletely set up (tty_ldisc_setup) when
841 void tty_ldisc_deinit(struct tty_struct *tty)
844 tty_ldisc_put(tty->ldisc);