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...) ({ \
27 printk(KERN_DEBUG "%s: %s: " f, __func__, tty_name(tty, __b), ##args); \
30 #define tty_ldisc_debug(tty, f, args...)
33 /* lockdep nested classes for tty->ldisc_sem */
41 * This guards the refcounted line discipline lists. The lock
42 * must be taken with irqs off because there are hangup path
43 * callers who will do ldisc lookups and cannot sleep.
46 static DEFINE_RAW_SPINLOCK(tty_ldiscs_lock);
47 /* Line disc dispatch table */
48 static struct tty_ldisc_ops *tty_ldiscs[NR_LDISCS];
51 * tty_register_ldisc - install a line discipline
53 * @new_ldisc: pointer to the ldisc object
55 * Installs a new line discipline into the kernel. The discipline
56 * is set up as unreferenced and then made available to the kernel
57 * from this point onwards.
60 * takes tty_ldiscs_lock to guard against ldisc races
63 int tty_register_ldisc(int disc, struct tty_ldisc_ops *new_ldisc)
68 if (disc < N_TTY || disc >= NR_LDISCS)
71 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
72 tty_ldiscs[disc] = new_ldisc;
73 new_ldisc->num = disc;
74 new_ldisc->refcount = 0;
75 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
79 EXPORT_SYMBOL(tty_register_ldisc);
82 * tty_unregister_ldisc - unload a line discipline
84 * @new_ldisc: pointer to the ldisc object
86 * Remove a line discipline from the kernel providing it is not
90 * takes tty_ldiscs_lock to guard against ldisc races
93 int tty_unregister_ldisc(int disc)
98 if (disc < N_TTY || disc >= NR_LDISCS)
101 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
102 if (tty_ldiscs[disc]->refcount)
105 tty_ldiscs[disc] = NULL;
106 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
110 EXPORT_SYMBOL(tty_unregister_ldisc);
112 static struct tty_ldisc_ops *get_ldops(int disc)
115 struct tty_ldisc_ops *ldops, *ret;
117 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
118 ret = ERR_PTR(-EINVAL);
119 ldops = tty_ldiscs[disc];
121 ret = ERR_PTR(-EAGAIN);
122 if (try_module_get(ldops->owner)) {
127 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
131 static void put_ldops(struct tty_ldisc_ops *ldops)
135 raw_spin_lock_irqsave(&tty_ldiscs_lock, flags);
137 module_put(ldops->owner);
138 raw_spin_unlock_irqrestore(&tty_ldiscs_lock, flags);
142 * 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. Returns NULL if the discipline is not available.
147 * Returns a pointer to the discipline and bumps the ref count if it is
151 * takes tty_ldiscs_lock to guard against ldisc races
154 static struct tty_ldisc *tty_ldisc_get(struct tty_struct *tty, int disc)
156 struct tty_ldisc *ld;
157 struct tty_ldisc_ops *ldops;
159 if (disc < N_TTY || disc >= NR_LDISCS)
160 return ERR_PTR(-EINVAL);
163 * Get the ldisc ops - we may need to request them to be loaded
164 * dynamically and try again.
166 ldops = get_ldops(disc);
168 request_module("tty-ldisc-%d", disc);
169 ldops = get_ldops(disc);
171 return ERR_CAST(ldops);
174 ld = kmalloc(sizeof(struct tty_ldisc), GFP_KERNEL);
177 return ERR_PTR(-ENOMEM);
187 * tty_ldisc_put - release the ldisc
189 * Complement of tty_ldisc_get().
191 static inline void tty_ldisc_put(struct tty_ldisc *ld)
193 if (WARN_ON_ONCE(!ld))
200 static void *tty_ldiscs_seq_start(struct seq_file *m, loff_t *pos)
202 return (*pos < NR_LDISCS) ? pos : NULL;
205 static void *tty_ldiscs_seq_next(struct seq_file *m, void *v, loff_t *pos)
208 return (*pos < NR_LDISCS) ? pos : NULL;
211 static void tty_ldiscs_seq_stop(struct seq_file *m, void *v)
215 static int tty_ldiscs_seq_show(struct seq_file *m, void *v)
217 int i = *(loff_t *)v;
218 struct tty_ldisc_ops *ldops;
220 ldops = get_ldops(i);
223 seq_printf(m, "%-10s %2d\n", ldops->name ? ldops->name : "???", i);
228 static const struct seq_operations tty_ldiscs_seq_ops = {
229 .start = tty_ldiscs_seq_start,
230 .next = tty_ldiscs_seq_next,
231 .stop = tty_ldiscs_seq_stop,
232 .show = tty_ldiscs_seq_show,
235 static int proc_tty_ldiscs_open(struct inode *inode, struct file *file)
237 return seq_open(file, &tty_ldiscs_seq_ops);
240 const struct file_operations tty_ldiscs_proc_fops = {
241 .owner = THIS_MODULE,
242 .open = proc_tty_ldiscs_open,
245 .release = seq_release,
249 * tty_ldisc_ref_wait - wait for the tty ldisc
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.
256 * Note: Must not be called from an IRQ/timer context. The caller
257 * must also be careful not to hold other locks that will deadlock
258 * against a discipline change, such as an existing ldisc reference
259 * (which we check for)
261 * Note: only callable from a file_operations routine (which
262 * guarantees tty->ldisc != NULL when the lock is acquired).
265 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
267 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
268 WARN_ON(!tty->ldisc);
271 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
274 * tty_ldisc_ref - get the tty ldisc
277 * Dereference the line discipline for the terminal and take a
278 * reference to it. If the line discipline is in flux then
279 * return NULL. Can be called from IRQ and timer functions.
282 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
284 struct tty_ldisc *ld = NULL;
286 if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
289 ldsem_up_read(&tty->ldisc_sem);
293 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
296 * tty_ldisc_deref - free a tty ldisc reference
297 * @ld: reference to free up
299 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
300 * be called in IRQ context.
303 void tty_ldisc_deref(struct tty_ldisc *ld)
305 ldsem_up_read(&ld->tty->ldisc_sem);
307 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
310 static inline int __lockfunc
311 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
313 return ldsem_down_write(&tty->ldisc_sem, timeout);
316 static inline int __lockfunc
317 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
319 return ldsem_down_write_nested(&tty->ldisc_sem,
320 LDISC_SEM_OTHER, timeout);
323 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
325 return ldsem_up_write(&tty->ldisc_sem);
328 static int __lockfunc
329 tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
333 ret = __tty_ldisc_lock(tty, timeout);
336 set_bit(TTY_LDISC_HALTED, &tty->flags);
340 static void tty_ldisc_unlock(struct tty_struct *tty)
342 clear_bit(TTY_LDISC_HALTED, &tty->flags);
343 __tty_ldisc_unlock(tty);
346 static int __lockfunc
347 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
348 unsigned long timeout)
353 ret = __tty_ldisc_lock(tty, timeout);
355 ret = __tty_ldisc_lock_nested(tty2, timeout);
357 __tty_ldisc_unlock(tty);
360 /* if this is possible, it has lots of implications */
361 WARN_ON_ONCE(tty == tty2);
362 if (tty2 && tty != tty2) {
363 ret = __tty_ldisc_lock(tty2, timeout);
365 ret = __tty_ldisc_lock_nested(tty, timeout);
367 __tty_ldisc_unlock(tty2);
370 ret = __tty_ldisc_lock(tty, timeout);
376 set_bit(TTY_LDISC_HALTED, &tty->flags);
378 set_bit(TTY_LDISC_HALTED, &tty2->flags);
382 static void __lockfunc
383 tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
385 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
388 static void __lockfunc tty_ldisc_unlock_pair(struct tty_struct *tty,
389 struct tty_struct *tty2)
391 __tty_ldisc_unlock(tty);
393 __tty_ldisc_unlock(tty2);
397 * tty_ldisc_flush - flush line discipline queue
400 * Flush the line discipline queue (if any) for this tty. If there
401 * is no line discipline active this is a no-op.
404 void tty_ldisc_flush(struct tty_struct *tty)
406 struct tty_ldisc *ld = tty_ldisc_ref(tty);
408 if (ld->ops->flush_buffer)
409 ld->ops->flush_buffer(tty);
412 tty_buffer_flush(tty);
414 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
417 * tty_set_termios_ldisc - set ldisc field
418 * @tty: tty structure
419 * @num: line discipline number
421 * This is probably overkill for real world processors but
422 * they are not on hot paths so a little discipline won't do
425 * Locking: takes termios_rwsem
428 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
430 down_write(&tty->termios_rwsem);
431 tty->termios.c_line = num;
432 up_write(&tty->termios_rwsem);
436 * tty_ldisc_open - open a line discipline
437 * @tty: tty we are opening the ldisc on
438 * @ld: discipline to open
440 * A helper opening method. Also a convenient debugging and check
443 * Locking: always called with BTM already held.
446 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
448 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
451 /* BTM here locks versus a hangup event */
452 ret = ld->ops->open(tty);
454 clear_bit(TTY_LDISC_OPEN, &tty->flags);
461 * tty_ldisc_close - close a line discipline
462 * @tty: tty we are opening the ldisc on
463 * @ld: discipline to close
465 * A helper close method. Also a convenient debugging and check
469 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
471 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
472 clear_bit(TTY_LDISC_OPEN, &tty->flags);
478 * tty_ldisc_restore - helper for tty ldisc change
479 * @tty: tty to recover
480 * @old: previous ldisc
482 * Restore the previous line discipline or N_TTY when a line discipline
483 * change fails due to an open error
486 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
489 struct tty_ldisc *new_ldisc;
492 /* There is an outstanding reference here so this is safe */
493 old = tty_ldisc_get(tty, old->ops->num);
494 WARN_ON(IS_ERR(old));
496 tty_set_termios_ldisc(tty, old->ops->num);
497 if (tty_ldisc_open(tty, old) < 0) {
499 /* This driver is always present */
500 new_ldisc = tty_ldisc_get(tty, N_TTY);
501 if (IS_ERR(new_ldisc))
503 tty->ldisc = new_ldisc;
504 tty_set_termios_ldisc(tty, N_TTY);
505 r = tty_ldisc_open(tty, new_ldisc);
507 panic("Couldn't open N_TTY ldisc for "
509 tty_name(tty, buf), r);
514 * tty_set_ldisc - set line discipline
515 * @tty: the terminal to set
516 * @ldisc: the line discipline
518 * Set the discipline of a tty line. Must be called from a process
519 * context. The ldisc change logic has to protect itself against any
520 * overlapping ldisc change (including on the other end of pty pairs),
521 * the close of one side of a tty/pty pair, and eventually hangup.
524 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
527 struct tty_ldisc *old_ldisc, *new_ldisc;
529 new_ldisc = tty_ldisc_get(tty, ldisc);
530 if (IS_ERR(new_ldisc))
531 return PTR_ERR(new_ldisc);
534 retval = tty_ldisc_lock(tty, 5 * HZ);
536 tty_ldisc_put(new_ldisc);
542 * Check the no-op case
545 if (tty->ldisc->ops->num == ldisc) {
546 tty_ldisc_unlock(tty);
547 tty_ldisc_put(new_ldisc);
552 old_ldisc = tty->ldisc;
554 if (test_bit(TTY_HUPPED, &tty->flags)) {
555 /* We were raced by the hangup method. It will have stomped
556 the ldisc data and closed the ldisc down */
557 tty_ldisc_unlock(tty);
558 tty_ldisc_put(new_ldisc);
563 /* Shutdown the old discipline. */
564 tty_ldisc_close(tty, old_ldisc);
566 /* Now set up the new line discipline. */
567 tty->ldisc = new_ldisc;
568 tty_set_termios_ldisc(tty, ldisc);
570 retval = tty_ldisc_open(tty, new_ldisc);
572 /* Back to the old one or N_TTY if we can't */
573 tty_ldisc_put(new_ldisc);
574 tty_ldisc_restore(tty, old_ldisc);
577 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc)
578 tty->ops->set_ldisc(tty);
580 /* At this point we hold a reference to the new ldisc and a
581 reference to the old ldisc, or we hold two references to
582 the old ldisc (if it was restored as part of error cleanup
583 above). In either case, releasing a single reference from
584 the old ldisc is correct. */
586 tty_ldisc_put(old_ldisc);
589 * Allow ldisc referencing to occur again
591 tty_ldisc_unlock(tty);
593 /* Restart the work queue in case no characters kick it off. Safe if
595 schedule_work(&tty->port->buf.work);
602 * tty_reset_termios - reset terminal state
605 * Restore a terminal to the driver default state.
608 static void tty_reset_termios(struct tty_struct *tty)
610 down_write(&tty->termios_rwsem);
611 tty->termios = tty->driver->init_termios;
612 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
613 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
614 up_write(&tty->termios_rwsem);
619 * tty_ldisc_reinit - reinitialise the tty ldisc
620 * @tty: tty to reinit
621 * @ldisc: line discipline to reinitialize
623 * Switch the tty to a line discipline and leave the ldisc
627 static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
629 struct tty_ldisc *ld = tty_ldisc_get(tty, ldisc);
634 tty_ldisc_close(tty, tty->ldisc);
635 tty_ldisc_put(tty->ldisc);
637 * Switch the line discipline back
640 tty_set_termios_ldisc(tty, ldisc);
646 * tty_ldisc_hangup - hangup ldisc reset
647 * @tty: tty being hung up
649 * Some tty devices reset their termios when they receive a hangup
650 * event. In that situation we must also switch back to N_TTY properly
651 * before we reset the termios data.
653 * Locking: We can take the ldisc mutex as the rest of the code is
654 * careful to allow for this.
656 * In the pty pair case this occurs in the close() path of the
657 * tty itself so we must be careful about locking rules.
660 void tty_ldisc_hangup(struct tty_struct *tty)
662 struct tty_ldisc *ld;
663 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
666 tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);
668 ld = tty_ldisc_ref(tty);
670 if (ld->ops->flush_buffer)
671 ld->ops->flush_buffer(tty);
672 tty_driver_flush_buffer(tty);
673 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
674 ld->ops->write_wakeup)
675 ld->ops->write_wakeup(tty);
677 ld->ops->hangup(tty);
681 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
682 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
685 * Shutdown the current line discipline, and reset it to
688 * Avoid racing set_ldisc or tty_ldisc_release
690 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
694 /* At this point we have a halted ldisc; we want to close it and
695 reopen a new ldisc. We could defer the reopen to the next
696 open but it means auditing a lot of other paths so this is
700 if (!tty_ldisc_reinit(tty, tty->termios.c_line))
701 err = tty_ldisc_open(tty, tty->ldisc);
705 /* If the re-open fails or we reset then go to N_TTY. The
706 N_TTY open cannot fail */
708 BUG_ON(tty_ldisc_reinit(tty, N_TTY));
709 WARN_ON(tty_ldisc_open(tty, tty->ldisc));
712 tty_ldisc_unlock(tty);
714 tty_reset_termios(tty);
716 tty_ldisc_debug(tty, "re-opened ldisc: %p\n", tty->ldisc);
720 * tty_ldisc_setup - open line discipline
721 * @tty: tty being shut down
722 * @o_tty: pair tty for pty/tty pairs
724 * Called during the initial open of a tty/pty pair in order to set up the
725 * line disciplines and bind them to the tty. This has no locking issues
726 * as the device isn't yet active.
729 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
731 struct tty_ldisc *ld = tty->ldisc;
734 retval = tty_ldisc_open(tty, ld);
739 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
741 tty_ldisc_close(tty, ld);
748 static void tty_ldisc_kill(struct tty_struct *tty)
751 * Now kill off the ldisc
753 tty_ldisc_close(tty, tty->ldisc);
754 tty_ldisc_put(tty->ldisc);
755 /* Force an oops if we mess this up */
758 /* Ensure the next open requests the N_TTY ldisc */
759 tty_set_termios_ldisc(tty, N_TTY);
763 * tty_ldisc_release - release line discipline
764 * @tty: tty being shut down (or one end of pty pair)
766 * Called during the final close of a tty or a pty pair in order to shut
767 * down the line discpline layer. On exit, each ldisc assigned is N_TTY and
768 * each ldisc has not been opened.
771 void tty_ldisc_release(struct tty_struct *tty)
773 struct tty_struct *o_tty = tty->link;
776 * Shutdown this line discipline. As this is the final close,
777 * it does not race with the set_ldisc code path.
780 tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);
782 tty_ldisc_lock_pair(tty, o_tty);
785 tty_ldisc_kill(o_tty);
786 tty_ldisc_unlock_pair(tty, o_tty);
788 /* And the memory resources remaining (buffers, termios) will be
789 disposed of when the kref hits zero */
791 tty_ldisc_debug(tty, "ldisc closed\n");
795 * tty_ldisc_init - ldisc setup for new tty
796 * @tty: tty being allocated
798 * Set up the line discipline objects for a newly allocated tty. Note that
799 * the tty structure is not completely set up when this call is made.
802 void tty_ldisc_init(struct tty_struct *tty)
804 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
806 panic("n_tty: init_tty");
811 * tty_ldisc_init - ldisc cleanup for new tty
812 * @tty: tty that was allocated recently
814 * The tty structure must not becompletely set up (tty_ldisc_setup) when
817 void tty_ldisc_deinit(struct tty_struct *tty)
819 tty_ldisc_put(tty->ldisc);
823 void tty_ldisc_begin(void)
825 /* Setup the default TTY line discipline. */
826 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);