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_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
330 unsigned long timeout)
335 ret = tty_ldisc_lock(tty, timeout);
337 ret = tty_ldisc_lock_nested(tty2, timeout);
339 tty_ldisc_unlock(tty);
342 /* if this is possible, it has lots of implications */
343 WARN_ON_ONCE(tty == tty2);
344 if (tty2 && tty != tty2) {
345 ret = tty_ldisc_lock(tty2, timeout);
347 ret = tty_ldisc_lock_nested(tty, timeout);
349 tty_ldisc_unlock(tty2);
352 ret = tty_ldisc_lock(tty, timeout);
358 set_bit(TTY_LDISC_HALTED, &tty->flags);
360 set_bit(TTY_LDISC_HALTED, &tty2->flags);
364 static void __lockfunc
365 tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
367 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
370 static void __lockfunc tty_ldisc_unlock_pair(struct tty_struct *tty,
371 struct tty_struct *tty2)
373 tty_ldisc_unlock(tty);
375 tty_ldisc_unlock(tty2);
378 static void __lockfunc tty_ldisc_enable_pair(struct tty_struct *tty,
379 struct tty_struct *tty2)
381 clear_bit(TTY_LDISC_HALTED, &tty->flags);
383 clear_bit(TTY_LDISC_HALTED, &tty2->flags);
385 tty_ldisc_unlock_pair(tty, tty2);
389 * tty_ldisc_flush - flush line discipline queue
392 * Flush the line discipline queue (if any) for this tty. If there
393 * is no line discipline active this is a no-op.
396 void tty_ldisc_flush(struct tty_struct *tty)
398 struct tty_ldisc *ld = tty_ldisc_ref(tty);
400 if (ld->ops->flush_buffer)
401 ld->ops->flush_buffer(tty);
404 tty_buffer_flush(tty);
406 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
409 * tty_set_termios_ldisc - set ldisc field
410 * @tty: tty structure
411 * @num: line discipline number
413 * This is probably overkill for real world processors but
414 * they are not on hot paths so a little discipline won't do
417 * Locking: takes termios_rwsem
420 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
422 down_write(&tty->termios_rwsem);
423 tty->termios.c_line = num;
424 up_write(&tty->termios_rwsem);
428 * tty_ldisc_open - open a line discipline
429 * @tty: tty we are opening the ldisc on
430 * @ld: discipline to open
432 * A helper opening method. Also a convenient debugging and check
435 * Locking: always called with BTM already held.
438 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
440 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
443 /* BTM here locks versus a hangup event */
444 ret = ld->ops->open(tty);
446 clear_bit(TTY_LDISC_OPEN, &tty->flags);
453 * tty_ldisc_close - close a line discipline
454 * @tty: tty we are opening the ldisc on
455 * @ld: discipline to close
457 * A helper close method. Also a convenient debugging and check
461 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
463 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
464 clear_bit(TTY_LDISC_OPEN, &tty->flags);
470 * tty_ldisc_restore - helper for tty ldisc change
471 * @tty: tty to recover
472 * @old: previous ldisc
474 * Restore the previous line discipline or N_TTY when a line discipline
475 * change fails due to an open error
478 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
481 struct tty_ldisc *new_ldisc;
484 /* There is an outstanding reference here so this is safe */
485 old = tty_ldisc_get(tty, old->ops->num);
486 WARN_ON(IS_ERR(old));
488 tty_set_termios_ldisc(tty, old->ops->num);
489 if (tty_ldisc_open(tty, old) < 0) {
491 /* This driver is always present */
492 new_ldisc = tty_ldisc_get(tty, N_TTY);
493 if (IS_ERR(new_ldisc))
495 tty->ldisc = new_ldisc;
496 tty_set_termios_ldisc(tty, N_TTY);
497 r = tty_ldisc_open(tty, new_ldisc);
499 panic("Couldn't open N_TTY ldisc for "
501 tty_name(tty, buf), r);
506 * tty_set_ldisc - set line discipline
507 * @tty: the terminal to set
508 * @ldisc: the line discipline
510 * Set the discipline of a tty line. Must be called from a process
511 * context. The ldisc change logic has to protect itself against any
512 * overlapping ldisc change (including on the other end of pty pairs),
513 * the close of one side of a tty/pty pair, and eventually hangup.
516 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
519 struct tty_ldisc *old_ldisc, *new_ldisc;
520 struct tty_struct *o_tty = tty->link;
522 new_ldisc = tty_ldisc_get(tty, ldisc);
523 if (IS_ERR(new_ldisc))
524 return PTR_ERR(new_ldisc);
526 retval = tty_ldisc_lock_pair_timeout(tty, o_tty, 5 * HZ);
528 tty_ldisc_put(new_ldisc);
533 * Check the no-op case
536 if (tty->ldisc->ops->num == ldisc) {
537 tty_ldisc_enable_pair(tty, o_tty);
538 tty_ldisc_put(new_ldisc);
542 old_ldisc = tty->ldisc;
545 if (test_bit(TTY_HUPPING, &tty->flags) ||
546 test_bit(TTY_HUPPED, &tty->flags)) {
547 /* We were raced by the hangup method. It will have stomped
548 the ldisc data and closed the ldisc down */
549 tty_ldisc_enable_pair(tty, o_tty);
550 tty_ldisc_put(new_ldisc);
555 /* Shutdown the old discipline. */
556 tty_ldisc_close(tty, old_ldisc);
558 /* Now set up the new line discipline. */
559 tty->ldisc = new_ldisc;
560 tty_set_termios_ldisc(tty, ldisc);
562 retval = tty_ldisc_open(tty, new_ldisc);
564 /* Back to the old one or N_TTY if we can't */
565 tty_ldisc_put(new_ldisc);
566 tty_ldisc_restore(tty, old_ldisc);
569 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc)
570 tty->ops->set_ldisc(tty);
572 /* At this point we hold a reference to the new ldisc and a
573 reference to the old ldisc, or we hold two references to
574 the old ldisc (if it was restored as part of error cleanup
575 above). In either case, releasing a single reference from
576 the old ldisc is correct. */
578 tty_ldisc_put(old_ldisc);
581 * Allow ldisc referencing to occur again
583 tty_ldisc_enable_pair(tty, o_tty);
585 /* Restart the work queue in case no characters kick it off. Safe if
587 schedule_work(&tty->port->buf.work);
589 schedule_work(&o_tty->port->buf.work);
596 * tty_reset_termios - reset terminal state
599 * Restore a terminal to the driver default state.
602 static void tty_reset_termios(struct tty_struct *tty)
604 down_write(&tty->termios_rwsem);
605 tty->termios = tty->driver->init_termios;
606 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
607 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
608 up_write(&tty->termios_rwsem);
613 * tty_ldisc_reinit - reinitialise the tty ldisc
614 * @tty: tty to reinit
615 * @ldisc: line discipline to reinitialize
617 * Switch the tty to a line discipline and leave the ldisc
621 static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
623 struct tty_ldisc *ld = tty_ldisc_get(tty, ldisc);
628 tty_ldisc_close(tty, tty->ldisc);
629 tty_ldisc_put(tty->ldisc);
631 * Switch the line discipline back
634 tty_set_termios_ldisc(tty, ldisc);
640 * tty_ldisc_hangup - hangup ldisc reset
641 * @tty: tty being hung up
643 * Some tty devices reset their termios when they receive a hangup
644 * event. In that situation we must also switch back to N_TTY properly
645 * before we reset the termios data.
647 * Locking: We can take the ldisc mutex as the rest of the code is
648 * careful to allow for this.
650 * In the pty pair case this occurs in the close() path of the
651 * tty itself so we must be careful about locking rules.
654 void tty_ldisc_hangup(struct tty_struct *tty)
656 struct tty_ldisc *ld;
657 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
660 pr_debug("[TTY_DEBUG tty_ldisc_hangup]pid %d\n",current->pid);
662 tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);
664 ld = tty_ldisc_ref(tty);
666 if (ld->ops->flush_buffer)
667 ld->ops->flush_buffer(tty);
668 tty_driver_flush_buffer(tty);
669 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
670 ld->ops->write_wakeup)
671 ld->ops->write_wakeup(tty);
673 ld->ops->hangup(tty);
677 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
678 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
683 * Shutdown the current line discipline, and reset it to
686 * Avoid racing set_ldisc or tty_ldisc_release
688 tty_ldisc_lock_pair(tty, tty->link);
693 /* At this point we have a halted ldisc; we want to close it and
694 reopen a new ldisc. We could defer the reopen to the next
695 open but it means auditing a lot of other paths so this is
699 if (!tty_ldisc_reinit(tty, tty->termios.c_line))
700 err = tty_ldisc_open(tty, tty->ldisc);
704 /* If the re-open fails or we reset then go to N_TTY. The
705 N_TTY open cannot fail */
707 BUG_ON(tty_ldisc_reinit(tty, N_TTY));
708 WARN_ON(tty_ldisc_open(tty, tty->ldisc));
711 tty_ldisc_enable_pair(tty, tty->link);
713 tty_reset_termios(tty);
715 tty_ldisc_debug(tty, "re-opened ldisc: %p\n", tty->ldisc);
719 * tty_ldisc_setup - open line discipline
720 * @tty: tty being shut down
721 * @o_tty: pair tty for pty/tty pairs
723 * Called during the initial open of a tty/pty pair in order to set up the
724 * line disciplines and bind them to the tty. This has no locking issues
725 * as the device isn't yet active.
728 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
730 struct tty_ldisc *ld = tty->ldisc;
733 retval = tty_ldisc_open(tty, ld);
738 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
740 tty_ldisc_close(tty, ld);
747 static void tty_ldisc_kill(struct tty_struct *tty)
750 * Now kill off the ldisc
752 tty_ldisc_close(tty, tty->ldisc);
753 tty_ldisc_put(tty->ldisc);
754 /* Force an oops if we mess this up */
757 /* Ensure the next open requests the N_TTY ldisc */
758 tty_set_termios_ldisc(tty, N_TTY);
762 * tty_ldisc_release - release line discipline
763 * @tty: tty being shut down
764 * @o_tty: pair tty for pty/tty pairs
766 * Called during the final close of a tty/pty pair in order to shut down
767 * the line discpline layer. On exit the ldisc assigned is N_TTY and the
768 * ldisc has not been opened.
771 void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
774 * Shutdown this line discipline. As this is the final close,
775 * it does not race with the set_ldisc code path.
778 tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);
780 tty_ldisc_lock_pair(tty, o_tty);
781 tty_lock_pair(tty, o_tty);
785 tty_ldisc_kill(o_tty);
787 tty_unlock_pair(tty, o_tty);
788 tty_ldisc_unlock_pair(tty, o_tty);
790 /* And the memory resources remaining (buffers, termios) will be
791 disposed of when the kref hits zero */
793 tty_ldisc_debug(tty, "ldisc closed\n");
797 * tty_ldisc_init - ldisc setup for new tty
798 * @tty: tty being allocated
800 * Set up the line discipline objects for a newly allocated tty. Note that
801 * the tty structure is not completely set up when this call is made.
804 void tty_ldisc_init(struct tty_struct *tty)
806 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
808 panic("n_tty: init_tty");
813 * tty_ldisc_init - ldisc cleanup for new tty
814 * @tty: tty that was allocated recently
816 * The tty structure must not becompletely set up (tty_ldisc_setup) when
819 void tty_ldisc_deinit(struct tty_struct *tty)
821 tty_ldisc_put(tty->ldisc);
825 void tty_ldisc_begin(void)
827 /* Setup the default TTY line discipline. */
828 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);