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 * Note: Must not be called from an IRQ/timer context. The caller
261 * must also be careful not to hold other locks that will deadlock
262 * against a discipline change, such as an existing ldisc reference
263 * (which we check for)
265 * Note: a file_operations routine (read/poll/write) should use this
266 * function to wait for any ldisc lifetime events to finish.
269 struct tty_ldisc *tty_ldisc_ref_wait(struct tty_struct *tty)
271 ldsem_down_read(&tty->ldisc_sem, MAX_SCHEDULE_TIMEOUT);
273 ldsem_up_read(&tty->ldisc_sem);
276 EXPORT_SYMBOL_GPL(tty_ldisc_ref_wait);
279 * tty_ldisc_ref - get the tty ldisc
282 * Dereference the line discipline for the terminal and take a
283 * reference to it. If the line discipline is in flux then
284 * return NULL. Can be called from IRQ and timer functions.
287 struct tty_ldisc *tty_ldisc_ref(struct tty_struct *tty)
289 struct tty_ldisc *ld = NULL;
291 if (ldsem_down_read_trylock(&tty->ldisc_sem)) {
294 ldsem_up_read(&tty->ldisc_sem);
298 EXPORT_SYMBOL_GPL(tty_ldisc_ref);
301 * tty_ldisc_deref - free a tty ldisc reference
302 * @ld: reference to free up
304 * Undoes the effect of tty_ldisc_ref or tty_ldisc_ref_wait. May
305 * be called in IRQ context.
308 void tty_ldisc_deref(struct tty_ldisc *ld)
310 ldsem_up_read(&ld->tty->ldisc_sem);
312 EXPORT_SYMBOL_GPL(tty_ldisc_deref);
316 __tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
318 return ldsem_down_write(&tty->ldisc_sem, timeout);
322 __tty_ldisc_lock_nested(struct tty_struct *tty, unsigned long timeout)
324 return ldsem_down_write_nested(&tty->ldisc_sem,
325 LDISC_SEM_OTHER, timeout);
328 static inline void __tty_ldisc_unlock(struct tty_struct *tty)
330 ldsem_up_write(&tty->ldisc_sem);
333 static int tty_ldisc_lock(struct tty_struct *tty, unsigned long timeout)
337 ret = __tty_ldisc_lock(tty, timeout);
340 set_bit(TTY_LDISC_HALTED, &tty->flags);
344 static void tty_ldisc_unlock(struct tty_struct *tty)
346 clear_bit(TTY_LDISC_HALTED, &tty->flags);
347 __tty_ldisc_unlock(tty);
351 tty_ldisc_lock_pair_timeout(struct tty_struct *tty, struct tty_struct *tty2,
352 unsigned long timeout)
357 ret = __tty_ldisc_lock(tty, timeout);
359 ret = __tty_ldisc_lock_nested(tty2, timeout);
361 __tty_ldisc_unlock(tty);
364 /* if this is possible, it has lots of implications */
365 WARN_ON_ONCE(tty == tty2);
366 if (tty2 && tty != tty2) {
367 ret = __tty_ldisc_lock(tty2, timeout);
369 ret = __tty_ldisc_lock_nested(tty, timeout);
371 __tty_ldisc_unlock(tty2);
374 ret = __tty_ldisc_lock(tty, timeout);
380 set_bit(TTY_LDISC_HALTED, &tty->flags);
382 set_bit(TTY_LDISC_HALTED, &tty2->flags);
386 static void tty_ldisc_lock_pair(struct tty_struct *tty, struct tty_struct *tty2)
388 tty_ldisc_lock_pair_timeout(tty, tty2, MAX_SCHEDULE_TIMEOUT);
391 static void tty_ldisc_unlock_pair(struct tty_struct *tty,
392 struct tty_struct *tty2)
394 __tty_ldisc_unlock(tty);
396 __tty_ldisc_unlock(tty2);
400 * tty_ldisc_flush - flush line discipline queue
403 * Flush the line discipline queue (if any) and the tty flip buffers
407 void tty_ldisc_flush(struct tty_struct *tty)
409 struct tty_ldisc *ld = tty_ldisc_ref(tty);
411 tty_buffer_flush(tty, ld);
415 EXPORT_SYMBOL_GPL(tty_ldisc_flush);
418 * tty_set_termios_ldisc - set ldisc field
419 * @tty: tty structure
420 * @disc: line discipline number
422 * This is probably overkill for real world processors but
423 * they are not on hot paths so a little discipline won't do
426 * The line discipline-related tty_struct fields are reset to
427 * prevent the ldisc driver from re-using stale information for
428 * the new ldisc instance.
430 * Locking: takes termios_rwsem
433 static void tty_set_termios_ldisc(struct tty_struct *tty, int disc)
435 down_write(&tty->termios_rwsem);
436 tty->termios.c_line = disc;
437 up_write(&tty->termios_rwsem);
439 tty->disc_data = NULL;
440 tty->receive_room = 0;
444 * tty_ldisc_open - open a line discipline
445 * @tty: tty we are opening the ldisc on
446 * @ld: discipline to open
448 * A helper opening method. Also a convenient debugging and check
451 * Locking: always called with BTM already held.
454 static int tty_ldisc_open(struct tty_struct *tty, struct tty_ldisc *ld)
456 WARN_ON(test_and_set_bit(TTY_LDISC_OPEN, &tty->flags));
459 /* BTM here locks versus a hangup event */
460 ret = ld->ops->open(tty);
462 clear_bit(TTY_LDISC_OPEN, &tty->flags);
464 tty_ldisc_debug(tty, "%p: opened\n", ld);
471 * tty_ldisc_close - close a line discipline
472 * @tty: tty we are opening the ldisc on
473 * @ld: discipline to close
475 * A helper close method. Also a convenient debugging and check
479 static void tty_ldisc_close(struct tty_struct *tty, struct tty_ldisc *ld)
481 WARN_ON(!test_bit(TTY_LDISC_OPEN, &tty->flags));
482 clear_bit(TTY_LDISC_OPEN, &tty->flags);
485 tty_ldisc_debug(tty, "%p: closed\n", ld);
489 * tty_ldisc_restore - helper for tty ldisc change
490 * @tty: tty to recover
491 * @old: previous ldisc
493 * Restore the previous line discipline or N_TTY when a line discipline
494 * change fails due to an open error
497 static void tty_ldisc_restore(struct tty_struct *tty, struct tty_ldisc *old)
499 struct tty_ldisc *new_ldisc;
502 /* There is an outstanding reference here so this is safe */
503 old = tty_ldisc_get(tty, old->ops->num);
504 WARN_ON(IS_ERR(old));
506 tty_set_termios_ldisc(tty, old->ops->num);
507 if (tty_ldisc_open(tty, old) < 0) {
509 /* This driver is always present */
510 new_ldisc = tty_ldisc_get(tty, N_TTY);
511 if (IS_ERR(new_ldisc))
513 tty->ldisc = new_ldisc;
514 tty_set_termios_ldisc(tty, N_TTY);
515 r = tty_ldisc_open(tty, new_ldisc);
517 panic("Couldn't open N_TTY ldisc for "
524 * tty_set_ldisc - set line discipline
525 * @tty: the terminal to set
526 * @ldisc: the line discipline
528 * Set the discipline of a tty line. Must be called from a process
529 * context. The ldisc change logic has to protect itself against any
530 * overlapping ldisc change (including on the other end of pty pairs),
531 * the close of one side of a tty/pty pair, and eventually hangup.
534 int tty_set_ldisc(struct tty_struct *tty, int disc)
537 struct tty_ldisc *old_ldisc, *new_ldisc;
539 new_ldisc = tty_ldisc_get(tty, disc);
540 if (IS_ERR(new_ldisc))
541 return PTR_ERR(new_ldisc);
544 retval = tty_ldisc_lock(tty, 5 * HZ);
553 /* Check the no-op case */
554 if (tty->ldisc->ops->num == disc)
557 if (test_bit(TTY_HUPPED, &tty->flags)) {
558 /* We were raced by hangup */
563 old_ldisc = tty->ldisc;
565 /* Shutdown the old discipline. */
566 tty_ldisc_close(tty, old_ldisc);
568 /* Now set up the new line discipline. */
569 tty->ldisc = new_ldisc;
570 tty_set_termios_ldisc(tty, disc);
572 retval = tty_ldisc_open(tty, new_ldisc);
574 /* Back to the old one or N_TTY if we can't */
575 tty_ldisc_put(new_ldisc);
576 tty_ldisc_restore(tty, old_ldisc);
579 if (tty->ldisc->ops->num != old_ldisc->ops->num && tty->ops->set_ldisc) {
580 down_read(&tty->termios_rwsem);
581 tty->ops->set_ldisc(tty);
582 up_read(&tty->termios_rwsem);
585 /* At this point we hold a reference to the new ldisc and a
586 reference to the old ldisc, or we hold two references to
587 the old ldisc (if it was restored as part of error cleanup
588 above). In either case, releasing a single reference from
589 the old ldisc is correct. */
590 new_ldisc = old_ldisc;
592 tty_ldisc_unlock(tty);
594 /* Restart the work queue in case no characters kick it off. Safe if
596 tty_buffer_restart_work(tty->port);
598 tty_ldisc_put(new_ldisc); /* drop the extra reference */
604 * tty_ldisc_kill - teardown ldisc
605 * @tty: tty being released
607 * Perform final close of the ldisc and reset tty->ldisc
609 static void tty_ldisc_kill(struct tty_struct *tty)
614 * Now kill off the ldisc
616 tty_ldisc_close(tty, tty->ldisc);
617 tty_ldisc_put(tty->ldisc);
618 /* Force an oops if we mess this up */
623 * tty_reset_termios - reset terminal state
626 * Restore a terminal to the driver default state.
629 static void tty_reset_termios(struct tty_struct *tty)
631 down_write(&tty->termios_rwsem);
632 tty->termios = tty->driver->init_termios;
633 tty->termios.c_ispeed = tty_termios_input_baud_rate(&tty->termios);
634 tty->termios.c_ospeed = tty_termios_baud_rate(&tty->termios);
635 up_write(&tty->termios_rwsem);
640 * tty_ldisc_reinit - reinitialise the tty ldisc
641 * @tty: tty to reinit
642 * @disc: line discipline to reinitialize
644 * Completely reinitialize the line discipline state, by closing the
645 * current instance and opening a new instance. If an error occurs opening
646 * the new non-N_TTY instance, the instance is dropped and tty->ldisc reset
647 * to NULL. The caller can then retry with N_TTY instead.
649 * Returns 0 if successful, otherwise error code < 0
652 static int tty_ldisc_reinit(struct tty_struct *tty, int disc)
654 struct tty_ldisc *ld;
657 ld = tty_ldisc_get(tty, disc);
659 BUG_ON(disc == N_TTY);
664 tty_ldisc_close(tty, tty->ldisc);
665 tty_ldisc_put(tty->ldisc);
668 /* switch the line discipline */
670 tty_set_termios_ldisc(tty, disc);
671 retval = tty_ldisc_open(tty, tty->ldisc);
673 if (!WARN_ON(disc == N_TTY)) {
674 tty_ldisc_put(tty->ldisc);
682 * tty_ldisc_hangup - hangup ldisc reset
683 * @tty: tty being hung up
685 * Some tty devices reset their termios when they receive a hangup
686 * event. In that situation we must also switch back to N_TTY properly
687 * before we reset the termios data.
689 * Locking: We can take the ldisc mutex as the rest of the code is
690 * careful to allow for this.
692 * In the pty pair case this occurs in the close() path of the
693 * tty itself so we must be careful about locking rules.
696 void tty_ldisc_hangup(struct tty_struct *tty)
698 struct tty_ldisc *ld;
699 int reset = tty->driver->flags & TTY_DRIVER_RESET_TERMIOS;
702 tty_ldisc_debug(tty, "%p: hangup\n", tty->ldisc);
704 ld = tty_ldisc_ref(tty);
706 if (ld->ops->flush_buffer)
707 ld->ops->flush_buffer(tty);
708 tty_driver_flush_buffer(tty);
709 if ((test_bit(TTY_DO_WRITE_WAKEUP, &tty->flags)) &&
710 ld->ops->write_wakeup)
711 ld->ops->write_wakeup(tty);
713 ld->ops->hangup(tty);
717 wake_up_interruptible_poll(&tty->write_wait, POLLOUT);
718 wake_up_interruptible_poll(&tty->read_wait, POLLIN);
721 * Shutdown the current line discipline, and reset it to
724 * Avoid racing set_ldisc or tty_ldisc_release
726 tty_ldisc_lock(tty, MAX_SCHEDULE_TIMEOUT);
730 /* At this point we have a halted ldisc; we want to close it and
731 reopen a new ldisc. We could defer the reopen to the next
732 open but it means auditing a lot of other paths so this is
735 err = tty_ldisc_reinit(tty, tty->termios.c_line);
737 /* If the re-open fails or we reset then go to N_TTY. The
738 N_TTY open cannot fail */
739 if (reset || err < 0)
740 tty_ldisc_reinit(tty, N_TTY);
742 tty_ldisc_unlock(tty);
744 tty_reset_termios(tty);
746 tty_ldisc_debug(tty, "%p: re-opened\n", tty->ldisc);
750 * tty_ldisc_setup - open line discipline
751 * @tty: tty being shut down
752 * @o_tty: pair tty for pty/tty pairs
754 * Called during the initial open of a tty/pty pair in order to set up the
755 * line disciplines and bind them to the tty. This has no locking issues
756 * as the device isn't yet active.
759 int tty_ldisc_setup(struct tty_struct *tty, struct tty_struct *o_tty)
761 struct tty_ldisc *ld = tty->ldisc;
764 retval = tty_ldisc_open(tty, ld);
769 retval = tty_ldisc_open(o_tty, o_tty->ldisc);
771 tty_ldisc_close(tty, ld);
779 * tty_ldisc_release - release line discipline
780 * @tty: tty being shut down (or one end of pty pair)
782 * Called during the final close of a tty or a pty pair in order to shut
783 * down the line discpline layer. On exit, each tty's ldisc is NULL.
786 void tty_ldisc_release(struct tty_struct *tty)
788 struct tty_struct *o_tty = tty->link;
791 * Shutdown this line discipline. As this is the final close,
792 * it does not race with the set_ldisc code path.
795 tty_ldisc_lock_pair(tty, o_tty);
798 tty_ldisc_kill(o_tty);
799 tty_ldisc_unlock_pair(tty, o_tty);
801 /* And the memory resources remaining (buffers, termios) will be
802 disposed of when the kref hits zero */
804 tty_ldisc_debug(tty, "released\n");
808 * tty_ldisc_init - ldisc setup for new tty
809 * @tty: tty being allocated
811 * Set up the line discipline objects for a newly allocated tty. Note that
812 * the tty structure is not completely set up when this call is made.
815 void tty_ldisc_init(struct tty_struct *tty)
817 struct tty_ldisc *ld = tty_ldisc_get(tty, N_TTY);
819 panic("n_tty: init_tty");
824 * tty_ldisc_deinit - ldisc cleanup for new tty
825 * @tty: tty that was allocated recently
827 * The tty structure must not becompletely set up (tty_ldisc_setup) when
830 void tty_ldisc_deinit(struct tty_struct *tty)
833 tty_ldisc_put(tty->ldisc);
837 void tty_ldisc_begin(void)
839 /* Setup the default TTY line discipline. */
840 (void) tty_register_ldisc(N_TTY, &tty_ldisc_N_TTY);