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 * The line discipline-related tty_struct fields are reset to
418 * prevent the ldisc driver from re-using stale information for
419 * the new ldisc instance.
421 * Locking: takes termios_rwsem
424 static void tty_set_termios_ldisc(struct tty_struct *tty, int num)
426 down_write(&tty->termios_rwsem);
427 tty->termios.c_line = num;
428 up_write(&tty->termios_rwsem);
430 tty->disc_data = NULL;
431 tty->receive_room = 0;
435 * tty_ldisc_open - open a line discipline
436 * @tty: tty we are opening the ldisc on
437 * @ld: discipline to open
439 * A helper opening method. Also a convenient debugging and check
442 * Locking: always called with BTM already held.
445 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
447 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
450 /* BTM here locks versus a hangup event */
451 ret = ld->ops->open(tty);
453 clear_bit(TTY_LDISC_OPEN, &tty->flags);
460 * tty_ldisc_close - close a line discipline
461 * @tty: tty we are opening the ldisc on
462 * @ld: discipline to close
464 * A helper close method. Also a convenient debugging and check
468 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
470 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
471 clear_bit(TTY_LDISC_OPEN, &tty->flags);
477 * tty_ldisc_restore - helper for tty ldisc change
478 * @tty: tty to recover
479 * @old: previous ldisc
481 * Restore the previous line discipline or N_TTY when a line discipline
482 * change fails due to an open error
485 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
488 struct tty_ldisc *new_ldisc;
491 /* There is an outstanding reference here so this is safe */
492 old = tty_ldisc_get(tty, old->ops->num);
493 WARN_ON(IS_ERR(old));
495 tty_set_termios_ldisc(tty, old->ops->num);
496 if (tty_ldisc_open(tty, old) < 0) {
498 /* This driver is always present */
499 new_ldisc = tty_ldisc_get(tty, N_TTY);
500 if (IS_ERR(new_ldisc))
502 tty->ldisc = new_ldisc;
503 tty_set_termios_ldisc(tty, N_TTY);
504 r = tty_ldisc_open(tty, new_ldisc);
506 panic("Couldn't open N_TTY ldisc for "
508 tty_name(tty, buf), r);
513 * tty_set_ldisc - set line discipline
514 * @tty: the terminal to set
515 * @ldisc: the line discipline
517 * Set the discipline of a tty line. Must be called from a process
518 * context. The ldisc change logic has to protect itself against any
519 * overlapping ldisc change (including on the other end of pty pairs),
520 * the close of one side of a tty/pty pair, and eventually hangup.
523 int tty_set_ldisc(struct tty_struct *tty, int ldisc)
526 struct tty_ldisc *old_ldisc, *new_ldisc;
527 struct tty_struct *o_tty = tty->link;
529 new_ldisc = tty_ldisc_get(tty, ldisc);
530 if (IS_ERR(new_ldisc))
531 return PTR_ERR(new_ldisc);
533 retval = tty_ldisc_lock_pair_timeout(tty, o_tty, 5 * HZ);
535 tty_ldisc_put(new_ldisc);
540 * Check the no-op case
543 if (tty->ldisc->ops->num == ldisc) {
544 tty_ldisc_enable_pair(tty, o_tty);
545 tty_ldisc_put(new_ldisc);
549 old_ldisc = tty->ldisc;
552 if (test_bit(TTY_HUPPING, &tty->flags) ||
553 test_bit(TTY_HUPPED, &tty->flags)) {
554 /* We were raced by the hangup method. It will have stomped
555 the ldisc data and closed the ldisc down */
556 tty_ldisc_enable_pair(tty, o_tty);
557 tty_ldisc_put(new_ldisc);
562 /* Shutdown the old discipline. */
563 tty_ldisc_close(tty, old_ldisc);
565 /* Now set up the new line discipline. */
566 tty->ldisc = new_ldisc;
567 tty_set_termios_ldisc(tty, ldisc);
569 retval = tty_ldisc_open(tty, new_ldisc);
571 /* Back to the old one or N_TTY if we can't */
572 tty_ldisc_put(new_ldisc);
573 tty_ldisc_restore(tty, old_ldisc);
576 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc)
577 tty->ops->set_ldisc(tty);
579 /* At this point we hold a reference to the new ldisc and a
580 reference to the old ldisc, or we hold two references to
581 the old ldisc (if it was restored as part of error cleanup
582 above). In either case, releasing a single reference from
583 the old ldisc is correct. */
585 tty_ldisc_put(old_ldisc);
588 * Allow ldisc referencing to occur again
590 tty_ldisc_enable_pair(tty, o_tty);
592 /* Restart the work queue in case no characters kick it off. Safe if
594 schedule_work(&tty->port->buf.work);
596 schedule_work(&o_tty->port->buf.work);
603 * tty_reset_termios - reset terminal state
606 * Restore a terminal to the driver default state.
609 static void tty_reset_termios(struct tty_struct *tty)
611 down_write(&tty->termios_rwsem);
612 tty->termios = tty->driver->init_termios;
613 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
614 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
615 up_write(&tty->termios_rwsem);
620 * tty_ldisc_reinit - reinitialise the tty ldisc
621 * @tty: tty to reinit
622 * @ldisc: line discipline to reinitialize
624 * Switch the tty to a line discipline and leave the ldisc
628 static int tty_ldisc_reinit(struct tty_struct *tty, int ldisc)
630 struct tty_ldisc *ld = tty_ldisc_get(tty, ldisc);
635 tty_ldisc_close(tty, tty->ldisc);
636 tty_ldisc_put(tty->ldisc);
638 * Switch the line discipline back
641 tty_set_termios_ldisc(tty, ldisc);
647 * tty_ldisc_hangup - hangup ldisc reset
648 * @tty: tty being hung up
650 * Some tty devices reset their termios when they receive a hangup
651 * event. In that situation we must also switch back to N_TTY properly
652 * before we reset the termios data.
654 * Locking: We can take the ldisc mutex as the rest of the code is
655 * careful to allow for this.
657 * In the pty pair case this occurs in the close() path of the
658 * tty itself so we must be careful about locking rules.
661 void tty_ldisc_hangup(struct tty_struct *tty)
663 struct tty_ldisc *ld;
664 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
667 tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);
669 ld = tty_ldisc_ref(tty);
671 if (ld->ops->flush_buffer)
672 ld->ops->flush_buffer(tty);
673 tty_driver_flush_buffer(tty);
674 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
675 ld->ops->write_wakeup)
676 ld->ops->write_wakeup(tty);
678 ld->ops->hangup(tty);
682 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
683 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
688 * Shutdown the current line discipline, and reset it to
691 * Avoid racing set_ldisc or tty_ldisc_release
693 tty_ldisc_lock_pair(tty, tty->link);
698 /* At this point we have a halted ldisc; we want to close it and
699 reopen a new ldisc. We could defer the reopen to the next
700 open but it means auditing a lot of other paths so this is
704 if (!tty_ldisc_reinit(tty, tty->termios.c_line))
705 err = tty_ldisc_open(tty, tty->ldisc);
709 /* If the re-open fails or we reset then go to N_TTY. The
710 N_TTY open cannot fail */
712 BUG_ON(tty_ldisc_reinit(tty, N_TTY));
713 WARN_ON(tty_ldisc_open(tty, tty->ldisc));
716 tty_ldisc_enable_pair(tty, tty->link);
718 tty_reset_termios(tty);
720 tty_ldisc_debug(tty, "re-opened ldisc: %p\n", tty->ldisc);
724 * tty_ldisc_setup - open line discipline
725 * @tty: tty being shut down
726 * @o_tty: pair tty for pty/tty pairs
728 * Called during the initial open of a tty/pty pair in order to set up the
729 * line disciplines and bind them to the tty. This has no locking issues
730 * as the device isn't yet active.
733 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
735 struct tty_ldisc *ld = tty->ldisc;
738 retval = tty_ldisc_open(tty, ld);
743 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
745 tty_ldisc_close(tty, ld);
752 static void tty_ldisc_kill(struct tty_struct *tty)
755 * Now kill off the ldisc
757 tty_ldisc_close(tty, tty->ldisc);
758 tty_ldisc_put(tty->ldisc);
759 /* Force an oops if we mess this up */
762 /* Ensure the next open requests the N_TTY ldisc */
763 tty_set_termios_ldisc(tty, N_TTY);
767 * tty_ldisc_release - release line discipline
768 * @tty: tty being shut down
769 * @o_tty: pair tty for pty/tty pairs
771 * Called during the final close of a tty/pty pair in order to shut down
772 * the line discpline layer. On exit the ldisc assigned is N_TTY and the
773 * ldisc has not been opened.
776 void tty_ldisc_release(struct tty_struct *tty, struct tty_struct *o_tty)
779 * Shutdown this line discipline. As this is the final close,
780 * it does not race with the set_ldisc code path.
783 tty_ldisc_debug(tty, "closing ldisc: %p\n", tty->ldisc);
785 tty_ldisc_lock_pair(tty, o_tty);
786 tty_lock_pair(tty, o_tty);
790 tty_ldisc_kill(o_tty);
792 tty_unlock_pair(tty, o_tty);
793 tty_ldisc_unlock_pair(tty, o_tty);
795 /* And the memory resources remaining (buffers, termios) will be
796 disposed of when the kref hits zero */
798 tty_ldisc_debug(tty, "ldisc closed\n");
802 * tty_ldisc_init - ldisc setup for new tty
803 * @tty: tty being allocated
805 * Set up the line discipline objects for a newly allocated tty. Note that
806 * the tty structure is not completely set up when this call is made.
809 void tty_ldisc_init(struct tty_struct *tty)
811 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
813 panic("n_tty: init_tty");
818 * tty_ldisc_init - ldisc cleanup for new tty
819 * @tty: tty that was allocated recently
821 * The tty structure must not becompletely set up (tty_ldisc_setup) when
824 void tty_ldisc_deinit(struct tty_struct *tty)
826 tty_ldisc_put(tty->ldisc);
830 void tty_ldisc_begin(void)
832 /* Setup the default TTY line discipline. */
833 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);